winprefslex.c revision 05b261ec
1 2#line 3 "winprefslex.c" 3 4#define YY_INT_ALIGNED short int 5 6/* A lexical scanner generated by flex */ 7 8#define FLEX_SCANNER 9#define YY_FLEX_MAJOR_VERSION 2 10#define YY_FLEX_MINOR_VERSION 5 11#define YY_FLEX_SUBMINOR_VERSION 35 12#if YY_FLEX_SUBMINOR_VERSION > 0 13#define FLEX_BETA 14#endif 15 16/* First, we deal with platform-specific or compiler-specific issues. */ 17 18/* begin standard C headers. */ 19#include <stdio.h> 20#include <string.h> 21#include <errno.h> 22#include <stdlib.h> 23 24/* end standard C headers. */ 25 26/* flex integer type definitions */ 27 28#ifndef FLEXINT_H 29#define FLEXINT_H 30 31/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ 32 33#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 34 35/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, 36 * if you want the limit (max/min) macros for int types. 37 */ 38#ifndef __STDC_LIMIT_MACROS 39#define __STDC_LIMIT_MACROS 1 40#endif 41 42#include <inttypes.h> 43typedef int8_t flex_int8_t; 44typedef uint8_t flex_uint8_t; 45typedef int16_t flex_int16_t; 46typedef uint16_t flex_uint16_t; 47typedef int32_t flex_int32_t; 48typedef uint32_t flex_uint32_t; 49#else 50typedef signed char flex_int8_t; 51typedef short int flex_int16_t; 52typedef int flex_int32_t; 53typedef unsigned char flex_uint8_t; 54typedef unsigned short int flex_uint16_t; 55typedef unsigned int flex_uint32_t; 56 57/* Limits of integral types. */ 58#ifndef INT8_MIN 59#define INT8_MIN (-128) 60#endif 61#ifndef INT16_MIN 62#define INT16_MIN (-32767-1) 63#endif 64#ifndef INT32_MIN 65#define INT32_MIN (-2147483647-1) 66#endif 67#ifndef INT8_MAX 68#define INT8_MAX (127) 69#endif 70#ifndef INT16_MAX 71#define INT16_MAX (32767) 72#endif 73#ifndef INT32_MAX 74#define INT32_MAX (2147483647) 75#endif 76#ifndef UINT8_MAX 77#define UINT8_MAX (255U) 78#endif 79#ifndef UINT16_MAX 80#define UINT16_MAX (65535U) 81#endif 82#ifndef UINT32_MAX 83#define UINT32_MAX (4294967295U) 84#endif 85 86#endif /* ! C99 */ 87 88#endif /* ! FLEXINT_H */ 89 90#ifdef __cplusplus 91 92/* The "const" storage-class-modifier is valid. */ 93#define YY_USE_CONST 94 95#else /* ! __cplusplus */ 96 97/* C99 requires __STDC__ to be defined as 1. */ 98#if defined (__STDC__) 99 100#define YY_USE_CONST 101 102#endif /* defined (__STDC__) */ 103#endif /* ! __cplusplus */ 104 105#ifdef YY_USE_CONST 106#define yyconst const 107#else 108#define yyconst 109#endif 110 111/* Returned upon end-of-file. */ 112#define YY_NULL 0 113 114/* Promotes a possibly negative, possibly signed char to an unsigned 115 * integer for use as an array index. If the signed char is negative, 116 * we want to instead treat it as an 8-bit unsigned char, hence the 117 * double cast. 118 */ 119#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 120 121/* Enter a start condition. This macro really ought to take a parameter, 122 * but we do it the disgusting crufty way forced on us by the ()-less 123 * definition of BEGIN. 124 */ 125#define BEGIN (yy_start) = 1 + 2 * 126 127/* Translate the current start state into a value that can be later handed 128 * to BEGIN to return to the state. The YYSTATE alias is for lex 129 * compatibility. 130 */ 131#define YY_START (((yy_start) - 1) / 2) 132#define YYSTATE YY_START 133 134/* Action number for EOF rule of a given start state. */ 135#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 136 137/* Special action meaning "start processing a new file". */ 138#define YY_NEW_FILE yyrestart(yyin ) 139 140#define YY_END_OF_BUFFER_CHAR 0 141 142/* Size of default input buffer. */ 143#ifndef YY_BUF_SIZE 144#define YY_BUF_SIZE 16384 145#endif 146 147/* The state buf must be large enough to hold one state per character in the main buffer. 148 */ 149#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 150 151#ifndef YY_TYPEDEF_YY_BUFFER_STATE 152#define YY_TYPEDEF_YY_BUFFER_STATE 153typedef struct yy_buffer_state *YY_BUFFER_STATE; 154#endif 155 156extern int yyleng; 157 158extern FILE *yyin, *yyout; 159 160#define EOB_ACT_CONTINUE_SCAN 0 161#define EOB_ACT_END_OF_FILE 1 162#define EOB_ACT_LAST_MATCH 2 163 164 /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires 165 * access to the local variable yy_act. Since yyless() is a macro, it would break 166 * existing scanners that call yyless() from OUTSIDE yylex. 167 * One obvious solution it to make yy_act a global. I tried that, and saw 168 * a 5% performance hit in a non-yylineno scanner, because yy_act is 169 * normally declared as a register variable-- so it is not worth it. 170 */ 171 #define YY_LESS_LINENO(n) \ 172 do { \ 173 int yyl;\ 174 for ( yyl = n; yyl < yyleng; ++yyl )\ 175 if ( yytext[yyl] == '\n' )\ 176 --yylineno;\ 177 }while(0) 178 179/* Return all but the first "n" matched characters back to the input stream. */ 180#define yyless(n) \ 181 do \ 182 { \ 183 /* Undo effects of setting up yytext. */ \ 184 int yyless_macro_arg = (n); \ 185 YY_LESS_LINENO(yyless_macro_arg);\ 186 *yy_cp = (yy_hold_char); \ 187 YY_RESTORE_YY_MORE_OFFSET \ 188 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 189 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 190 } \ 191 while ( 0 ) 192 193#define unput(c) yyunput( c, (yytext_ptr) ) 194 195#ifndef YY_TYPEDEF_YY_SIZE_T 196#define YY_TYPEDEF_YY_SIZE_T 197typedef size_t yy_size_t; 198#endif 199 200#ifndef YY_STRUCT_YY_BUFFER_STATE 201#define YY_STRUCT_YY_BUFFER_STATE 202struct yy_buffer_state 203 { 204 FILE *yy_input_file; 205 206 char *yy_ch_buf; /* input buffer */ 207 char *yy_buf_pos; /* current position in input buffer */ 208 209 /* Size of input buffer in bytes, not including room for EOB 210 * characters. 211 */ 212 yy_size_t yy_buf_size; 213 214 /* Number of characters read into yy_ch_buf, not including EOB 215 * characters. 216 */ 217 int yy_n_chars; 218 219 /* Whether we "own" the buffer - i.e., we know we created it, 220 * and can realloc() it to grow it, and should free() it to 221 * delete it. 222 */ 223 int yy_is_our_buffer; 224 225 /* Whether this is an "interactive" input source; if so, and 226 * if we're using stdio for input, then we want to use getc() 227 * instead of fread(), to make sure we stop fetching input after 228 * each newline. 229 */ 230 int yy_is_interactive; 231 232 /* Whether we're considered to be at the beginning of a line. 233 * If so, '^' rules will be active on the next match, otherwise 234 * not. 235 */ 236 int yy_at_bol; 237 238 int yy_bs_lineno; /**< The line count. */ 239 int yy_bs_column; /**< The column count. */ 240 241 /* Whether to try to fill the input buffer when we reach the 242 * end of it. 243 */ 244 int yy_fill_buffer; 245 246 int yy_buffer_status; 247 248#define YY_BUFFER_NEW 0 249#define YY_BUFFER_NORMAL 1 250 /* When an EOF's been seen but there's still some text to process 251 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 252 * shouldn't try reading from the input source any more. We might 253 * still have a bunch of tokens to match, though, because of 254 * possible backing-up. 255 * 256 * When we actually see the EOF, we change the status to "new" 257 * (via yyrestart()), so that the user can continue scanning by 258 * just pointing yyin at a new input file. 259 */ 260#define YY_BUFFER_EOF_PENDING 2 261 262 }; 263#endif /* !YY_STRUCT_YY_BUFFER_STATE */ 264 265/* Stack of input buffers. */ 266static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ 267static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ 268static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ 269 270/* We provide macros for accessing buffer states in case in the 271 * future we want to put the buffer states in a more general 272 * "scanner state". 273 * 274 * Returns the top of the stack, or NULL. 275 */ 276#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 277 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 278 : NULL) 279 280/* Same as previous macro, but useful when we know that the buffer stack is not 281 * NULL or when we need an lvalue. For internal use only. 282 */ 283#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 284 285/* yy_hold_char holds the character lost when yytext is formed. */ 286static char yy_hold_char; 287static int yy_n_chars; /* number of characters read into yy_ch_buf */ 288int yyleng; 289 290/* Points to current character in buffer. */ 291static char *yy_c_buf_p = (char *) 0; 292static int yy_init = 0; /* whether we need to initialize */ 293static int yy_start = 0; /* start state number */ 294 295/* Flag which is used to allow yywrap()'s to do buffer switches 296 * instead of setting up a fresh yyin. A bit of a hack ... 297 */ 298static int yy_did_buffer_switch_on_eof; 299 300void yyrestart (FILE *input_file ); 301void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); 302YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); 303void yy_delete_buffer (YY_BUFFER_STATE b ); 304void yy_flush_buffer (YY_BUFFER_STATE b ); 305void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); 306void yypop_buffer_state (void ); 307 308static void yyensure_buffer_stack (void ); 309static void yy_load_buffer_state (void ); 310static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); 311 312#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) 313 314YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); 315YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); 316YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ); 317 318void *yyalloc (yy_size_t ); 319void *yyrealloc (void *,yy_size_t ); 320void yyfree (void * ); 321 322#define yy_new_buffer yy_create_buffer 323 324#define yy_set_interactive(is_interactive) \ 325 { \ 326 if ( ! YY_CURRENT_BUFFER ){ \ 327 yyensure_buffer_stack (); \ 328 YY_CURRENT_BUFFER_LVALUE = \ 329 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 330 } \ 331 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 332 } 333 334#define yy_set_bol(at_bol) \ 335 { \ 336 if ( ! YY_CURRENT_BUFFER ){\ 337 yyensure_buffer_stack (); \ 338 YY_CURRENT_BUFFER_LVALUE = \ 339 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 340 } \ 341 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 342 } 343 344#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 345 346/* Begin user sect3 */ 347 348typedef unsigned char YY_CHAR; 349 350FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 351 352typedef int yy_state_type; 353 354extern int yylineno; 355 356int yylineno = 1; 357 358extern char *yytext; 359#define yytext_ptr yytext 360 361static yy_state_type yy_get_previous_state (void ); 362static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); 363static int yy_get_next_buffer (void ); 364static void yy_fatal_error (yyconst char msg[] ); 365 366/* Done after the current pattern has been matched and before the 367 * corresponding action - sets up yytext. 368 */ 369#define YY_DO_BEFORE_ACTION \ 370 (yytext_ptr) = yy_bp; \ 371 yyleng = (size_t) (yy_cp - yy_bp); \ 372 (yy_hold_char) = *yy_cp; \ 373 *yy_cp = '\0'; \ 374 (yy_c_buf_p) = yy_cp; 375 376#define YY_NUM_RULES 25 377#define YY_END_OF_BUFFER 26 378/* This struct is not used in this scanner, 379 but its presence is necessary. */ 380struct yy_trans_info 381 { 382 flex_int32_t yy_verify; 383 flex_int32_t yy_nxt; 384 }; 385static yyconst flex_int16_t yy_accept[136] = 386 { 0, 387 0, 0, 26, 24, 4, 3, 24, 24, 24, 24, 388 24, 24, 24, 24, 24, 24, 24, 21, 22, 24, 389 4, 24, 0, 24, 0, 1, 1, 24, 24, 24, 390 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 391 23, 23, 24, 0, 2, 2, 24, 24, 24, 24, 392 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 393 24, 24, 24, 24, 24, 15, 24, 5, 24, 24, 394 24, 24, 24, 24, 24, 14, 24, 17, 24, 24, 395 8, 24, 24, 24, 24, 24, 24, 24, 24, 24, 396 24, 18, 24, 24, 24, 24, 24, 24, 13, 24, 397 398 24, 24, 24, 24, 11, 24, 24, 24, 24, 24, 399 9, 24, 24, 19, 24, 24, 24, 24, 12, 24, 400 24, 24, 24, 24, 20, 16, 7, 24, 24, 24, 401 24, 24, 6, 10, 0 402 } ; 403 404static yyconst flex_int32_t yy_ec[256] = 405 { 0, 406 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 407 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 408 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 409 1, 2, 1, 5, 6, 1, 1, 1, 1, 1, 410 1, 1, 1, 1, 1, 1, 7, 1, 1, 1, 411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 412 1, 1, 1, 1, 8, 9, 10, 11, 12, 13, 413 14, 1, 15, 1, 1, 16, 17, 18, 19, 20, 414 1, 21, 22, 23, 24, 1, 25, 26, 27, 1, 415 1, 1, 1, 1, 1, 1, 28, 29, 30, 31, 416 417 32, 33, 34, 1, 35, 1, 1, 36, 37, 38, 418 39, 40, 1, 41, 42, 43, 44, 1, 45, 46, 419 47, 1, 48, 1, 49, 1, 1, 1, 1, 1, 420 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 421 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 422 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 423 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 424 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 425 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 426 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 427 428 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 429 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 430 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 431 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 432 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 433 1, 1, 1, 1, 1 434 } ; 435 436static yyconst flex_int32_t yy_meta[50] = 437 { 0, 438 1, 2, 3, 3, 1, 1, 1, 1, 1, 1, 439 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 440 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 441 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 442 1, 1, 1, 1, 1, 1, 1, 1, 1 443 } ; 444 445static yyconst flex_int16_t yy_base[143] = 446 { 0, 447 0, 0, 267, 0, 264, 301, 48, 52, 258, 35, 448 40, 31, 49, 48, 49, 55, 42, 0, 0, 0, 449 74, 60, 64, 71, 81, 301, 88, 91, 41, 77, 450 87, 85, 79, 83, 87, 85, 85, 90, 85, 100, 451 0, 301, 108, 110, 301, 126, 107, 104, 108, 108, 452 125, 124, 118, 113, 119, 116, 132, 129, 126, 117, 453 118, 135, 139, 134, 125, 0, 151, 0, 142, 138, 454 150, 154, 162, 161, 155, 0, 157, 0, 163, 165, 455 0, 170, 171, 176, 162, 168, 177, 169, 166, 167, 456 174, 0, 184, 188, 200, 189, 195, 198, 0, 202, 457 458 206, 195, 201, 195, 0, 205, 202, 216, 200, 218, 459 0, 208, 215, 0, 216, 223, 229, 229, 0, 230, 460 234, 238, 240, 239, 0, 0, 0, 247, 239, 243, 461 236, 240, 0, 0, 301, 63, 284, 286, 289, 291, 462 294, 297 463 } ; 464 465static yyconst flex_int16_t yy_def[143] = 466 { 0, 467 135, 1, 135, 136, 135, 135, 137, 138, 136, 136, 468 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 469 135, 137, 139, 138, 140, 135, 140, 141, 136, 136, 470 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 471 136, 135, 141, 142, 135, 142, 136, 136, 136, 136, 472 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 473 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 474 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 475 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 476 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 477 478 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 479 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 480 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 481 136, 136, 136, 136, 0, 135, 135, 135, 135, 135, 482 135, 135 483 } ; 484 485static yyconst flex_int16_t yy_nxt[351] = 486 { 0, 487 4, 5, 6, 6, 7, 8, 9, 10, 4, 4, 488 11, 12, 4, 4, 13, 4, 14, 4, 4, 4, 489 15, 16, 17, 4, 4, 4, 4, 10, 4, 4, 490 11, 12, 4, 4, 13, 4, 14, 4, 4, 4, 491 15, 16, 17, 4, 4, 4, 4, 18, 19, 23, 492 29, 31, 20, 25, 26, 27, 32, 30, 33, 34, 493 35, 23, 40, 20, 41, 47, 37, 36, 42, 38, 494 29, 31, 25, 26, 27, 21, 32, 30, 33, 34, 495 35, 39, 40, 26, 27, 47, 37, 36, 48, 38, 496 26, 27, 44, 45, 46, 50, 52, 53, 49, 51, 497 498 54, 39, 55, 56, 57, 58, 59, 60, 48, 44, 499 45, 46, 45, 46, 61, 50, 52, 53, 49, 51, 500 54, 62, 55, 56, 57, 58, 59, 60, 45, 46, 501 63, 64, 65, 66, 61, 67, 68, 69, 70, 71, 502 72, 62, 73, 74, 75, 76, 77, 78, 79, 82, 503 63, 64, 65, 66, 83, 67, 68, 69, 70, 71, 504 72, 80, 73, 74, 75, 76, 77, 78, 79, 82, 505 84, 85, 81, 86, 83, 87, 88, 89, 90, 91, 506 92, 80, 93, 94, 95, 96, 97, 98, 99, 100, 507 84, 85, 81, 86, 101, 87, 88, 89, 90, 91, 508 509 92, 102, 93, 94, 95, 96, 97, 98, 99, 100, 510 103, 104, 105, 106, 101, 107, 108, 110, 111, 112, 511 113, 102, 114, 109, 115, 116, 117, 118, 119, 120, 512 103, 104, 105, 106, 121, 107, 108, 110, 111, 112, 513 113, 122, 114, 109, 115, 116, 117, 118, 119, 120, 514 123, 124, 125, 126, 121, 127, 128, 129, 130, 131, 515 132, 122, 133, 134, 28, 21, 135, 135, 135, 135, 516 123, 124, 125, 126, 135, 127, 128, 129, 130, 131, 517 132, 135, 133, 134, 22, 22, 24, 24, 24, 23, 518 23, 25, 25, 25, 43, 43, 43, 44, 44, 44, 519 520 3, 135, 135, 135, 135, 135, 135, 135, 135, 135, 521 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 522 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 523 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 524 135, 135, 135, 135, 135, 135, 135, 135, 135, 135 525 } ; 526 527static yyconst flex_int16_t yy_chk[351] = 528 { 0, 529 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 530 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 531 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 532 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 533 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 534 10, 11, 7, 8, 8, 8, 12, 10, 13, 14, 535 15, 22, 17, 136, 22, 29, 16, 15, 23, 16, 536 10, 11, 24, 24, 24, 21, 12, 10, 13, 14, 537 15, 16, 17, 25, 25, 29, 16, 15, 30, 16, 538 27, 27, 28, 28, 28, 31, 32, 33, 30, 31, 539 540 34, 16, 35, 36, 37, 38, 39, 40, 30, 43, 541 43, 43, 44, 44, 47, 31, 32, 33, 30, 31, 542 34, 48, 35, 36, 37, 38, 39, 40, 46, 46, 543 49, 50, 51, 52, 47, 53, 54, 55, 56, 57, 544 58, 48, 59, 60, 61, 62, 63, 64, 65, 69, 545 49, 50, 51, 52, 70, 53, 54, 55, 56, 57, 546 58, 67, 59, 60, 61, 62, 63, 64, 65, 69, 547 71, 72, 67, 73, 70, 74, 75, 77, 79, 80, 548 82, 67, 83, 84, 85, 86, 87, 88, 89, 90, 549 71, 72, 67, 73, 91, 74, 75, 77, 79, 80, 550 551 82, 93, 83, 84, 85, 86, 87, 88, 89, 90, 552 94, 95, 96, 97, 91, 98, 100, 101, 102, 103, 553 104, 93, 106, 100, 107, 108, 109, 110, 112, 113, 554 94, 95, 96, 97, 115, 98, 100, 101, 102, 103, 555 104, 116, 106, 100, 107, 108, 109, 110, 112, 113, 556 117, 118, 120, 121, 115, 122, 123, 124, 128, 129, 557 130, 116, 131, 132, 9, 5, 3, 0, 0, 0, 558 117, 118, 120, 121, 0, 122, 123, 124, 128, 129, 559 130, 0, 131, 132, 137, 137, 138, 138, 138, 139, 560 139, 140, 140, 140, 141, 141, 141, 142, 142, 142, 561 562 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 563 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 564 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 565 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 566 135, 135, 135, 135, 135, 135, 135, 135, 135, 135 567 } ; 568 569/* Table of booleans, true if rule could match eol. */ 570static yyconst flex_int32_t yy_rule_can_match_eol[26] = 571 { 0, 5721, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 573 0, 0, 0, 0, 0, 0, }; 574 575static yy_state_type yy_last_accepting_state; 576static char *yy_last_accepting_cpos; 577 578extern int yy_flex_debug; 579int yy_flex_debug = 0; 580 581/* The intent behind this definition is that it'll catch 582 * any uses of REJECT which flex missed. 583 */ 584#define REJECT reject_used_but_not_detected 585#define yymore() yymore_used_but_not_detected 586#define YY_MORE_ADJ 0 587#define YY_RESTORE_YY_MORE_OFFSET 588char *yytext; 589#line 1 "winprefslex.l" 590#line 2 "winprefslex.l" 591/* 592 * Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved. 593 * 594 * Permission is hereby granted, free of charge, to any person obtaining 595 * a copy of this software and associated documentation files (the 596 * "Software"), to deal in the Software without restriction, including 597 * without limitation the rights to use, copy, modify, merge, publish, 598 * distribute, sublicense, and/or sell copies of the Software, and to 599 * permit persons to whom the Software is furnished to do so, subject to 600 * the following conditions: 601 * 602 * The above copyright notice and this permission notice shall be 603 * included in all copies or substantial portions of the Software. 604 * 605 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 606 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 607 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 608 * NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR 609 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF 610 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 611 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 612 * 613 * Except as contained in this notice, the name of the XFree86 Project 614 * shall not be used in advertising or otherwise to promote the sale, use 615 * or other dealings in this Software without prior written authorization 616 * from the XFree86 Project. 617 * 618 * Authors: Earle F. Philhower, III 619 */ 620/* $XFree86: $ */ 621 622#include <stdio.h> 623#include <stdlib.h> 624#include <string.h> 625#include "winprefsyacc.h" 626 627extern YYSTYPE yylval; 628extern char *yytext; 629extern int yyparse(void); 630 631extern void ErrorF (const char* /*f*/, ...); 632 633int yylineno; 634 635/* Copy the parsed string, must be free()d in yacc parser */ 636static char *makestr(char *str) 637{ 638 char *ptr; 639 ptr = (char*)malloc (strlen(str)+1); 640 if (!ptr) 641 { 642 ErrorF ("winMultiWindowLex:makestr() out of memory\n"); 643 exit (-1); 644 } 645 strcpy(ptr, str); 646 return ptr; 647} 648 649#line 650 "winprefslex.c" 650 651#define INITIAL 0 652 653#ifndef YY_NO_UNISTD_H 654/* Special case for "unistd.h", since it is non-ANSI. We include it way 655 * down here because we want the user's section 1 to have been scanned first. 656 * The user has a chance to override it with an option. 657 */ 658#include <unistd.h> 659#endif 660 661#ifndef YY_EXTRA_TYPE 662#define YY_EXTRA_TYPE void * 663#endif 664 665static int yy_init_globals (void ); 666 667/* Accessor methods to globals. 668 These are made visible to non-reentrant scanners for convenience. */ 669 670int yylex_destroy (void ); 671 672int yyget_debug (void ); 673 674void yyset_debug (int debug_flag ); 675 676YY_EXTRA_TYPE yyget_extra (void ); 677 678void yyset_extra (YY_EXTRA_TYPE user_defined ); 679 680FILE *yyget_in (void ); 681 682void yyset_in (FILE * in_str ); 683 684FILE *yyget_out (void ); 685 686void yyset_out (FILE * out_str ); 687 688int yyget_leng (void ); 689 690char *yyget_text (void ); 691 692int yyget_lineno (void ); 693 694void yyset_lineno (int line_number ); 695 696/* Macros after this point can all be overridden by user definitions in 697 * section 1. 698 */ 699 700#ifndef YY_SKIP_YYWRAP 701#ifdef __cplusplus 702extern "C" int yywrap (void ); 703#else 704extern int yywrap (void ); 705#endif 706#endif 707 708 static void yyunput (int c,char *buf_ptr ); 709 710#ifndef yytext_ptr 711static void yy_flex_strncpy (char *,yyconst char *,int ); 712#endif 713 714#ifdef YY_NEED_STRLEN 715static int yy_flex_strlen (yyconst char * ); 716#endif 717 718#ifndef YY_NO_INPUT 719 720#ifdef __cplusplus 721static int yyinput (void ); 722#else 723static int input (void ); 724#endif 725 726#endif 727 728/* Amount of stuff to slurp up with each read. */ 729#ifndef YY_READ_BUF_SIZE 730#define YY_READ_BUF_SIZE 8192 731#endif 732 733/* Copy whatever the last rule matched to the standard output. */ 734#ifndef ECHO 735/* This used to be an fputs(), but since the string might contain NUL's, 736 * we now use fwrite(). 737 */ 738#define ECHO fwrite( yytext, yyleng, 1, yyout ) 739#endif 740 741/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 742 * is returned in "result". 743 */ 744#ifndef YY_INPUT 745#define YY_INPUT(buf,result,max_size) \ 746 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 747 { \ 748 int c = '*'; \ 749 size_t n; \ 750 for ( n = 0; n < max_size && \ 751 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 752 buf[n] = (char) c; \ 753 if ( c == '\n' ) \ 754 buf[n++] = (char) c; \ 755 if ( c == EOF && ferror( yyin ) ) \ 756 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 757 result = n; \ 758 } \ 759 else \ 760 { \ 761 errno=0; \ 762 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 763 { \ 764 if( errno != EINTR) \ 765 { \ 766 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 767 break; \ 768 } \ 769 errno=0; \ 770 clearerr(yyin); \ 771 } \ 772 }\ 773\ 774 775#endif 776 777/* No semi-colon after return; correct usage is to write "yyterminate();" - 778 * we don't want an extra ';' after the "return" because that will cause 779 * some compilers to complain about unreachable statements. 780 */ 781#ifndef yyterminate 782#define yyterminate() return YY_NULL 783#endif 784 785/* Number of entries by which start-condition stack grows. */ 786#ifndef YY_START_STACK_INCR 787#define YY_START_STACK_INCR 25 788#endif 789 790/* Report a fatal error. */ 791#ifndef YY_FATAL_ERROR 792#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 793#endif 794 795/* end tables serialization structures and prototypes */ 796 797/* Default declaration of generated scanner - a define so the user can 798 * easily add parameters. 799 */ 800#ifndef YY_DECL 801#define YY_DECL_IS_OURS 1 802 803extern int yylex (void); 804 805#define YY_DECL int yylex (void) 806#endif /* !YY_DECL */ 807 808/* Code executed at the beginning of each rule, after yytext and yyleng 809 * have been set up. 810 */ 811#ifndef YY_USER_ACTION 812#define YY_USER_ACTION 813#endif 814 815/* Code executed at the end of each rule. */ 816#ifndef YY_BREAK 817#define YY_BREAK break; 818#endif 819 820#define YY_RULE_SETUP \ 821 YY_USER_ACTION 822 823/** The main scanner function which does all the work. 824 */ 825YY_DECL 826{ 827 register yy_state_type yy_current_state; 828 register char *yy_cp, *yy_bp; 829 register int yy_act; 830 831#line 64 "winprefslex.l" 832 833#line 834 "winprefslex.c" 834 835 if ( !(yy_init) ) 836 { 837 (yy_init) = 1; 838 839#ifdef YY_USER_INIT 840 YY_USER_INIT; 841#endif 842 843 if ( ! (yy_start) ) 844 (yy_start) = 1; /* first start state */ 845 846 if ( ! yyin ) 847 yyin = stdin; 848 849 if ( ! yyout ) 850 yyout = stdout; 851 852 if ( ! YY_CURRENT_BUFFER ) { 853 yyensure_buffer_stack (); 854 YY_CURRENT_BUFFER_LVALUE = 855 yy_create_buffer(yyin,YY_BUF_SIZE ); 856 } 857 858 yy_load_buffer_state( ); 859 } 860 861 while ( 1 ) /* loops until end-of-file is reached */ 862 { 863 yy_cp = (yy_c_buf_p); 864 865 /* Support of yytext. */ 866 *yy_cp = (yy_hold_char); 867 868 /* yy_bp points to the position in yy_ch_buf of the start of 869 * the current run. 870 */ 871 yy_bp = yy_cp; 872 873 yy_current_state = (yy_start); 874yy_match: 875 do 876 { 877 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 878 if ( yy_accept[yy_current_state] ) 879 { 880 (yy_last_accepting_state) = yy_current_state; 881 (yy_last_accepting_cpos) = yy_cp; 882 } 883 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 884 { 885 yy_current_state = (int) yy_def[yy_current_state]; 886 if ( yy_current_state >= 136 ) 887 yy_c = yy_meta[(unsigned int) yy_c]; 888 } 889 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 890 ++yy_cp; 891 } 892 while ( yy_base[yy_current_state] != 301 ); 893 894yy_find_action: 895 yy_act = yy_accept[yy_current_state]; 896 if ( yy_act == 0 ) 897 { /* have to back up */ 898 yy_cp = (yy_last_accepting_cpos); 899 yy_current_state = (yy_last_accepting_state); 900 yy_act = yy_accept[yy_current_state]; 901 } 902 903 YY_DO_BEFORE_ACTION; 904 905 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) 906 { 907 int yyl; 908 for ( yyl = 0; yyl < yyleng; ++yyl ) 909 if ( yytext[yyl] == '\n' ) 910 911 yylineno++; 912; 913 } 914 915do_action: /* This label is used only to access EOF actions. */ 916 917 switch ( yy_act ) 918 { /* beginning of action switch */ 919 case 0: /* must back up */ 920 /* undo the effects of YY_DO_BEFORE_ACTION */ 921 *yy_cp = (yy_hold_char); 922 yy_cp = (yy_last_accepting_cpos); 923 yy_current_state = (yy_last_accepting_state); 924 goto yy_find_action; 925 926case 1: 927/* rule 1 can match eol */ 928YY_RULE_SETUP 929#line 65 "winprefslex.l" 930{ /* comment */ return NEWLINE; } 931 YY_BREAK 932case 2: 933/* rule 2 can match eol */ 934YY_RULE_SETUP 935#line 66 "winprefslex.l" 936{ /* comment */ return NEWLINE; } 937 YY_BREAK 938case 3: 939/* rule 3 can match eol */ 940YY_RULE_SETUP 941#line 67 "winprefslex.l" 942{ return NEWLINE; } 943 YY_BREAK 944case 4: 945YY_RULE_SETUP 946#line 68 "winprefslex.l" 947{ /* ignore whitespace */ } 948 YY_BREAK 949case 5: 950YY_RULE_SETUP 951#line 69 "winprefslex.l" 952{ return MENU; } 953 YY_BREAK 954case 6: 955YY_RULE_SETUP 956#line 70 "winprefslex.l" 957{ return ICONDIRECTORY; } 958 YY_BREAK 959case 7: 960YY_RULE_SETUP 961#line 71 "winprefslex.l" 962{ return DEFAULTICON; } 963 YY_BREAK 964case 8: 965YY_RULE_SETUP 966#line 72 "winprefslex.l" 967{ return ICONS; } 968 YY_BREAK 969case 9: 970YY_RULE_SETUP 971#line 73 "winprefslex.l" 972{ return ROOTMENU; } 973 YY_BREAK 974case 10: 975YY_RULE_SETUP 976#line 74 "winprefslex.l" 977{ return DEFAULTSYSMENU; } 978 YY_BREAK 979case 11: 980YY_RULE_SETUP 981#line 75 "winprefslex.l" 982{ return SYSMENU; } 983 YY_BREAK 984case 12: 985YY_RULE_SETUP 986#line 76 "winprefslex.l" 987{ return SEPARATOR; } 988 YY_BREAK 989case 13: 990YY_RULE_SETUP 991#line 77 "winprefslex.l" 992{ return ATSTART; } 993 YY_BREAK 994case 14: 995YY_RULE_SETUP 996#line 78 "winprefslex.l" 997{ return ATEND; } 998 YY_BREAK 999case 15: 1000YY_RULE_SETUP 1001#line 79 "winprefslex.l" 1002{ return EXEC; } 1003 YY_BREAK 1004case 16: 1005YY_RULE_SETUP 1006#line 80 "winprefslex.l" 1007{ return ALWAYSONTOP; } 1008 YY_BREAK 1009case 17: 1010YY_RULE_SETUP 1011#line 81 "winprefslex.l" 1012{ return DEBUG; } 1013 YY_BREAK 1014case 18: 1015YY_RULE_SETUP 1016#line 82 "winprefslex.l" 1017{ return RELOAD; } 1018 YY_BREAK 1019case 19: 1020YY_RULE_SETUP 1021#line 83 "winprefslex.l" 1022{ return TRAYICON; } 1023 YY_BREAK 1024case 20: 1025YY_RULE_SETUP 1026#line 84 "winprefslex.l" 1027{ return SILENTEXIT; } 1028 YY_BREAK 1029case 21: 1030YY_RULE_SETUP 1031#line 85 "winprefslex.l" 1032{ return LB; } 1033 YY_BREAK 1034case 22: 1035YY_RULE_SETUP 1036#line 86 "winprefslex.l" 1037{ return RB; } 1038 YY_BREAK 1039case 23: 1040YY_RULE_SETUP 1041#line 87 "winprefslex.l" 1042{ yylval.sVal = makestr(yytext+1); \ 1043 yylval.sVal[strlen(yylval.sVal)-1] = 0; \ 1044 return STRING; } 1045 YY_BREAK 1046case 24: 1047YY_RULE_SETUP 1048#line 90 "winprefslex.l" 1049{ yylval.sVal = makestr(yytext); \ 1050 return STRING; } 1051 YY_BREAK 1052case 25: 1053YY_RULE_SETUP 1054#line 92 "winprefslex.l" 1055ECHO; 1056 YY_BREAK 1057#line 1058 "winprefslex.c" 1058case YY_STATE_EOF(INITIAL): 1059 yyterminate(); 1060 1061 case YY_END_OF_BUFFER: 1062 { 1063 /* Amount of text matched not including the EOB char. */ 1064 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; 1065 1066 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1067 *yy_cp = (yy_hold_char); 1068 YY_RESTORE_YY_MORE_OFFSET 1069 1070 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 1071 { 1072 /* We're scanning a new file or input source. It's 1073 * possible that this happened because the user 1074 * just pointed yyin at a new source and called 1075 * yylex(). If so, then we have to assure 1076 * consistency between YY_CURRENT_BUFFER and our 1077 * globals. Here is the right place to do so, because 1078 * this is the first action (other than possibly a 1079 * back-up) that will match for the new input source. 1080 */ 1081 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 1082 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; 1083 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 1084 } 1085 1086 /* Note that here we test for yy_c_buf_p "<=" to the position 1087 * of the first EOB in the buffer, since yy_c_buf_p will 1088 * already have been incremented past the NUL character 1089 * (since all states make transitions on EOB to the 1090 * end-of-buffer state). Contrast this with the test 1091 * in input(). 1092 */ 1093 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 1094 { /* This was really a NUL. */ 1095 yy_state_type yy_next_state; 1096 1097 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; 1098 1099 yy_current_state = yy_get_previous_state( ); 1100 1101 /* Okay, we're now positioned to make the NUL 1102 * transition. We couldn't have 1103 * yy_get_previous_state() go ahead and do it 1104 * for us because it doesn't know how to deal 1105 * with the possibility of jamming (and we don't 1106 * want to build jamming into it because then it 1107 * will run more slowly). 1108 */ 1109 1110 yy_next_state = yy_try_NUL_trans( yy_current_state ); 1111 1112 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1113 1114 if ( yy_next_state ) 1115 { 1116 /* Consume the NUL. */ 1117 yy_cp = ++(yy_c_buf_p); 1118 yy_current_state = yy_next_state; 1119 goto yy_match; 1120 } 1121 1122 else 1123 { 1124 yy_cp = (yy_c_buf_p); 1125 goto yy_find_action; 1126 } 1127 } 1128 1129 else switch ( yy_get_next_buffer( ) ) 1130 { 1131 case EOB_ACT_END_OF_FILE: 1132 { 1133 (yy_did_buffer_switch_on_eof) = 0; 1134 1135 if ( yywrap( ) ) 1136 { 1137 /* Note: because we've taken care in 1138 * yy_get_next_buffer() to have set up 1139 * yytext, we can now set up 1140 * yy_c_buf_p so that if some total 1141 * hoser (like flex itself) wants to 1142 * call the scanner after we return the 1143 * YY_NULL, it'll still work - another 1144 * YY_NULL will get returned. 1145 */ 1146 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; 1147 1148 yy_act = YY_STATE_EOF(YY_START); 1149 goto do_action; 1150 } 1151 1152 else 1153 { 1154 if ( ! (yy_did_buffer_switch_on_eof) ) 1155 YY_NEW_FILE; 1156 } 1157 break; 1158 } 1159 1160 case EOB_ACT_CONTINUE_SCAN: 1161 (yy_c_buf_p) = 1162 (yytext_ptr) + yy_amount_of_matched_text; 1163 1164 yy_current_state = yy_get_previous_state( ); 1165 1166 yy_cp = (yy_c_buf_p); 1167 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1168 goto yy_match; 1169 1170 case EOB_ACT_LAST_MATCH: 1171 (yy_c_buf_p) = 1172 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; 1173 1174 yy_current_state = yy_get_previous_state( ); 1175 1176 yy_cp = (yy_c_buf_p); 1177 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1178 goto yy_find_action; 1179 } 1180 break; 1181 } 1182 1183 default: 1184 YY_FATAL_ERROR( 1185 "fatal flex scanner internal error--no action found" ); 1186 } /* end of action switch */ 1187 } /* end of scanning one token */ 1188} /* end of yylex */ 1189 1190/* yy_get_next_buffer - try to read in a new buffer 1191 * 1192 * Returns a code representing an action: 1193 * EOB_ACT_LAST_MATCH - 1194 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1195 * EOB_ACT_END_OF_FILE - end of file 1196 */ 1197static int yy_get_next_buffer (void) 1198{ 1199 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 1200 register char *source = (yytext_ptr); 1201 register int number_to_move, i; 1202 int ret_val; 1203 1204 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) 1205 YY_FATAL_ERROR( 1206 "fatal flex scanner internal error--end of buffer missed" ); 1207 1208 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 1209 { /* Don't try to fill the buffer, so this is an EOF. */ 1210 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) 1211 { 1212 /* We matched a single character, the EOB, so 1213 * treat this as a final EOF. 1214 */ 1215 return EOB_ACT_END_OF_FILE; 1216 } 1217 1218 else 1219 { 1220 /* We matched some text prior to the EOB, first 1221 * process it. 1222 */ 1223 return EOB_ACT_LAST_MATCH; 1224 } 1225 } 1226 1227 /* Try to read more data. */ 1228 1229 /* First move last chars to start of buffer. */ 1230 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; 1231 1232 for ( i = 0; i < number_to_move; ++i ) 1233 *(dest++) = *(source++); 1234 1235 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1236 /* don't do the read, it's not guaranteed to return an EOF, 1237 * just force an EOF 1238 */ 1239 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; 1240 1241 else 1242 { 1243 int num_to_read = 1244 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 1245 1246 while ( num_to_read <= 0 ) 1247 { /* Not enough room in the buffer - grow it. */ 1248 1249 /* just a shorter name for the current buffer */ 1250 YY_BUFFER_STATE b = YY_CURRENT_BUFFER; 1251 1252 int yy_c_buf_p_offset = 1253 (int) ((yy_c_buf_p) - b->yy_ch_buf); 1254 1255 if ( b->yy_is_our_buffer ) 1256 { 1257 int new_size = b->yy_buf_size * 2; 1258 1259 if ( new_size <= 0 ) 1260 b->yy_buf_size += b->yy_buf_size / 8; 1261 else 1262 b->yy_buf_size *= 2; 1263 1264 b->yy_ch_buf = (char *) 1265 /* Include room in for 2 EOB chars. */ 1266 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); 1267 } 1268 else 1269 /* Can't grow it, we don't own it. */ 1270 b->yy_ch_buf = 0; 1271 1272 if ( ! b->yy_ch_buf ) 1273 YY_FATAL_ERROR( 1274 "fatal error - scanner input buffer overflow" ); 1275 1276 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 1277 1278 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - 1279 number_to_move - 1; 1280 1281 } 1282 1283 if ( num_to_read > YY_READ_BUF_SIZE ) 1284 num_to_read = YY_READ_BUF_SIZE; 1285 1286 /* Read in more data. */ 1287 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 1288 (yy_n_chars), (size_t) num_to_read ); 1289 1290 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1291 } 1292 1293 if ( (yy_n_chars) == 0 ) 1294 { 1295 if ( number_to_move == YY_MORE_ADJ ) 1296 { 1297 ret_val = EOB_ACT_END_OF_FILE; 1298 yyrestart(yyin ); 1299 } 1300 1301 else 1302 { 1303 ret_val = EOB_ACT_LAST_MATCH; 1304 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 1305 YY_BUFFER_EOF_PENDING; 1306 } 1307 } 1308 1309 else 1310 ret_val = EOB_ACT_CONTINUE_SCAN; 1311 1312 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { 1313 /* Extend the array by 50%, plus the number we really need. */ 1314 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); 1315 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); 1316 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1317 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); 1318 } 1319 1320 (yy_n_chars) += number_to_move; 1321 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; 1322 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; 1323 1324 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 1325 1326 return ret_val; 1327} 1328 1329/* yy_get_previous_state - get the state just before the EOB char was reached */ 1330 1331 static yy_state_type yy_get_previous_state (void) 1332{ 1333 register yy_state_type yy_current_state; 1334 register char *yy_cp; 1335 1336 yy_current_state = (yy_start); 1337 1338 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) 1339 { 1340 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1341 if ( yy_accept[yy_current_state] ) 1342 { 1343 (yy_last_accepting_state) = yy_current_state; 1344 (yy_last_accepting_cpos) = yy_cp; 1345 } 1346 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1347 { 1348 yy_current_state = (int) yy_def[yy_current_state]; 1349 if ( yy_current_state >= 136 ) 1350 yy_c = yy_meta[(unsigned int) yy_c]; 1351 } 1352 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1353 } 1354 1355 return yy_current_state; 1356} 1357 1358/* yy_try_NUL_trans - try to make a transition on the NUL character 1359 * 1360 * synopsis 1361 * next_state = yy_try_NUL_trans( current_state ); 1362 */ 1363 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) 1364{ 1365 register int yy_is_jam; 1366 register char *yy_cp = (yy_c_buf_p); 1367 1368 register YY_CHAR yy_c = 1; 1369 if ( yy_accept[yy_current_state] ) 1370 { 1371 (yy_last_accepting_state) = yy_current_state; 1372 (yy_last_accepting_cpos) = yy_cp; 1373 } 1374 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1375 { 1376 yy_current_state = (int) yy_def[yy_current_state]; 1377 if ( yy_current_state >= 136 ) 1378 yy_c = yy_meta[(unsigned int) yy_c]; 1379 } 1380 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1381 yy_is_jam = (yy_current_state == 135); 1382 1383 return yy_is_jam ? 0 : yy_current_state; 1384} 1385 1386 static void yyunput (int c, register char * yy_bp ) 1387{ 1388 register char *yy_cp; 1389 1390 yy_cp = (yy_c_buf_p); 1391 1392 /* undo effects of setting up yytext */ 1393 *yy_cp = (yy_hold_char); 1394 1395 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 1396 { /* need to shift things up to make room */ 1397 /* +2 for EOB chars. */ 1398 register int number_to_move = (yy_n_chars) + 2; 1399 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ 1400 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; 1401 register char *source = 1402 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; 1403 1404 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1405 *--dest = *--source; 1406 1407 yy_cp += (int) (dest - source); 1408 yy_bp += (int) (dest - source); 1409 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = 1410 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; 1411 1412 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 1413 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1414 } 1415 1416 *--yy_cp = (char) c; 1417 1418 if ( c == '\n' ){ 1419 --yylineno; 1420 } 1421 1422 (yytext_ptr) = yy_bp; 1423 (yy_hold_char) = *yy_cp; 1424 (yy_c_buf_p) = yy_cp; 1425} 1426 1427#ifndef YY_NO_INPUT 1428#ifdef __cplusplus 1429 static int yyinput (void) 1430#else 1431 static int input (void) 1432#endif 1433 1434{ 1435 int c; 1436 1437 *(yy_c_buf_p) = (yy_hold_char); 1438 1439 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) 1440 { 1441 /* yy_c_buf_p now points to the character we want to return. 1442 * If this occurs *before* the EOB characters, then it's a 1443 * valid NUL; if not, then we've hit the end of the buffer. 1444 */ 1445 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 1446 /* This was really a NUL. */ 1447 *(yy_c_buf_p) = '\0'; 1448 1449 else 1450 { /* need more input */ 1451 int offset = (yy_c_buf_p) - (yytext_ptr); 1452 ++(yy_c_buf_p); 1453 1454 switch ( yy_get_next_buffer( ) ) 1455 { 1456 case EOB_ACT_LAST_MATCH: 1457 /* This happens because yy_g_n_b() 1458 * sees that we've accumulated a 1459 * token and flags that we need to 1460 * try matching the token before 1461 * proceeding. But for input(), 1462 * there's no matching to consider. 1463 * So convert the EOB_ACT_LAST_MATCH 1464 * to EOB_ACT_END_OF_FILE. 1465 */ 1466 1467 /* Reset buffer status. */ 1468 yyrestart(yyin ); 1469 1470 /*FALLTHROUGH*/ 1471 1472 case EOB_ACT_END_OF_FILE: 1473 { 1474 if ( yywrap( ) ) 1475 return EOF; 1476 1477 if ( ! (yy_did_buffer_switch_on_eof) ) 1478 YY_NEW_FILE; 1479#ifdef __cplusplus 1480 return yyinput(); 1481#else 1482 return input(); 1483#endif 1484 } 1485 1486 case EOB_ACT_CONTINUE_SCAN: 1487 (yy_c_buf_p) = (yytext_ptr) + offset; 1488 break; 1489 } 1490 } 1491 } 1492 1493 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ 1494 *(yy_c_buf_p) = '\0'; /* preserve yytext */ 1495 (yy_hold_char) = *++(yy_c_buf_p); 1496 1497 if ( c == '\n' ) 1498 1499 yylineno++; 1500; 1501 1502 return c; 1503} 1504#endif /* ifndef YY_NO_INPUT */ 1505 1506/** Immediately switch to a different input stream. 1507 * @param input_file A readable stream. 1508 * 1509 * @note This function does not reset the start condition to @c INITIAL . 1510 */ 1511 void yyrestart (FILE * input_file ) 1512{ 1513 1514 if ( ! YY_CURRENT_BUFFER ){ 1515 yyensure_buffer_stack (); 1516 YY_CURRENT_BUFFER_LVALUE = 1517 yy_create_buffer(yyin,YY_BUF_SIZE ); 1518 } 1519 1520 yy_init_buffer(YY_CURRENT_BUFFER,input_file ); 1521 yy_load_buffer_state( ); 1522} 1523 1524/** Switch to a different input buffer. 1525 * @param new_buffer The new input buffer. 1526 * 1527 */ 1528 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) 1529{ 1530 1531 /* TODO. We should be able to replace this entire function body 1532 * with 1533 * yypop_buffer_state(); 1534 * yypush_buffer_state(new_buffer); 1535 */ 1536 yyensure_buffer_stack (); 1537 if ( YY_CURRENT_BUFFER == new_buffer ) 1538 return; 1539 1540 if ( YY_CURRENT_BUFFER ) 1541 { 1542 /* Flush out information for old buffer. */ 1543 *(yy_c_buf_p) = (yy_hold_char); 1544 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 1545 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1546 } 1547 1548 YY_CURRENT_BUFFER_LVALUE = new_buffer; 1549 yy_load_buffer_state( ); 1550 1551 /* We don't actually know whether we did this switch during 1552 * EOF (yywrap()) processing, but the only time this flag 1553 * is looked at is after yywrap() is called, so it's safe 1554 * to go ahead and always set it. 1555 */ 1556 (yy_did_buffer_switch_on_eof) = 1; 1557} 1558 1559static void yy_load_buffer_state (void) 1560{ 1561 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 1562 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 1563 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 1564 (yy_hold_char) = *(yy_c_buf_p); 1565} 1566 1567/** Allocate and initialize an input buffer state. 1568 * @param file A readable stream. 1569 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. 1570 * 1571 * @return the allocated buffer state. 1572 */ 1573 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) 1574{ 1575 YY_BUFFER_STATE b; 1576 1577 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); 1578 if ( ! b ) 1579 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1580 1581 b->yy_buf_size = size; 1582 1583 /* yy_ch_buf has to be 2 characters longer than the size given because 1584 * we need to put in 2 end-of-buffer characters. 1585 */ 1586 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); 1587 if ( ! b->yy_ch_buf ) 1588 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1589 1590 b->yy_is_our_buffer = 1; 1591 1592 yy_init_buffer(b,file ); 1593 1594 return b; 1595} 1596 1597/** Destroy the buffer. 1598 * @param b a buffer created with yy_create_buffer() 1599 * 1600 */ 1601 void yy_delete_buffer (YY_BUFFER_STATE b ) 1602{ 1603 1604 if ( ! b ) 1605 return; 1606 1607 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 1608 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 1609 1610 if ( b->yy_is_our_buffer ) 1611 yyfree((void *) b->yy_ch_buf ); 1612 1613 yyfree((void *) b ); 1614} 1615 1616#ifndef __cplusplus 1617extern int isatty (int ); 1618#endif /* __cplusplus */ 1619 1620/* Initializes or reinitializes a buffer. 1621 * This function is sometimes called more than once on the same buffer, 1622 * such as during a yyrestart() or at EOF. 1623 */ 1624 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) 1625 1626{ 1627 int oerrno = errno; 1628 1629 yy_flush_buffer(b ); 1630 1631 b->yy_input_file = file; 1632 b->yy_fill_buffer = 1; 1633 1634 /* If b is the current buffer, then yy_init_buffer was _probably_ 1635 * called from yyrestart() or through yy_get_next_buffer. 1636 * In that case, we don't want to reset the lineno or column. 1637 */ 1638 if (b != YY_CURRENT_BUFFER){ 1639 b->yy_bs_lineno = 1; 1640 b->yy_bs_column = 0; 1641 } 1642 1643 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 1644 1645 errno = oerrno; 1646} 1647 1648/** Discard all buffered characters. On the next scan, YY_INPUT will be called. 1649 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. 1650 * 1651 */ 1652 void yy_flush_buffer (YY_BUFFER_STATE b ) 1653{ 1654 if ( ! b ) 1655 return; 1656 1657 b->yy_n_chars = 0; 1658 1659 /* We always need two end-of-buffer characters. The first causes 1660 * a transition to the end-of-buffer state. The second causes 1661 * a jam in that state. 1662 */ 1663 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 1664 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 1665 1666 b->yy_buf_pos = &b->yy_ch_buf[0]; 1667 1668 b->yy_at_bol = 1; 1669 b->yy_buffer_status = YY_BUFFER_NEW; 1670 1671 if ( b == YY_CURRENT_BUFFER ) 1672 yy_load_buffer_state( ); 1673} 1674 1675/** Pushes the new state onto the stack. The new state becomes 1676 * the current state. This function will allocate the stack 1677 * if necessary. 1678 * @param new_buffer The new state. 1679 * 1680 */ 1681void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) 1682{ 1683 if (new_buffer == NULL) 1684 return; 1685 1686 yyensure_buffer_stack(); 1687 1688 /* This block is copied from yy_switch_to_buffer. */ 1689 if ( YY_CURRENT_BUFFER ) 1690 { 1691 /* Flush out information for old buffer. */ 1692 *(yy_c_buf_p) = (yy_hold_char); 1693 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 1694 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1695 } 1696 1697 /* Only push if top exists. Otherwise, replace top. */ 1698 if (YY_CURRENT_BUFFER) 1699 (yy_buffer_stack_top)++; 1700 YY_CURRENT_BUFFER_LVALUE = new_buffer; 1701 1702 /* copied from yy_switch_to_buffer. */ 1703 yy_load_buffer_state( ); 1704 (yy_did_buffer_switch_on_eof) = 1; 1705} 1706 1707/** Removes and deletes the top of the stack, if present. 1708 * The next element becomes the new top. 1709 * 1710 */ 1711void yypop_buffer_state (void) 1712{ 1713 if (!YY_CURRENT_BUFFER) 1714 return; 1715 1716 yy_delete_buffer(YY_CURRENT_BUFFER ); 1717 YY_CURRENT_BUFFER_LVALUE = NULL; 1718 if ((yy_buffer_stack_top) > 0) 1719 --(yy_buffer_stack_top); 1720 1721 if (YY_CURRENT_BUFFER) { 1722 yy_load_buffer_state( ); 1723 (yy_did_buffer_switch_on_eof) = 1; 1724 } 1725} 1726 1727/* Allocates the stack if it does not exist. 1728 * Guarantees space for at least one push. 1729 */ 1730static void yyensure_buffer_stack (void) 1731{ 1732 int num_to_alloc; 1733 1734 if (!(yy_buffer_stack)) { 1735 1736 /* First allocation is just for 2 elements, since we don't know if this 1737 * scanner will even need a stack. We use 2 instead of 1 to avoid an 1738 * immediate realloc on the next call. 1739 */ 1740 num_to_alloc = 1; 1741 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc 1742 (num_to_alloc * sizeof(struct yy_buffer_state*) 1743 ); 1744 if ( ! (yy_buffer_stack) ) 1745 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 1746 1747 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 1748 1749 (yy_buffer_stack_max) = num_to_alloc; 1750 (yy_buffer_stack_top) = 0; 1751 return; 1752 } 1753 1754 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ 1755 1756 /* Increase the buffer to prepare for a possible push. */ 1757 int grow_size = 8 /* arbitrary grow size */; 1758 1759 num_to_alloc = (yy_buffer_stack_max) + grow_size; 1760 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc 1761 ((yy_buffer_stack), 1762 num_to_alloc * sizeof(struct yy_buffer_state*) 1763 ); 1764 if ( ! (yy_buffer_stack) ) 1765 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 1766 1767 /* zero only the new slots.*/ 1768 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 1769 (yy_buffer_stack_max) = num_to_alloc; 1770 } 1771} 1772 1773/** Setup the input buffer state to scan directly from a user-specified character buffer. 1774 * @param base the character buffer 1775 * @param size the size in bytes of the character buffer 1776 * 1777 * @return the newly allocated buffer state object. 1778 */ 1779YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) 1780{ 1781 YY_BUFFER_STATE b; 1782 1783 if ( size < 2 || 1784 base[size-2] != YY_END_OF_BUFFER_CHAR || 1785 base[size-1] != YY_END_OF_BUFFER_CHAR ) 1786 /* They forgot to leave room for the EOB's. */ 1787 return 0; 1788 1789 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); 1790 if ( ! b ) 1791 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 1792 1793 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 1794 b->yy_buf_pos = b->yy_ch_buf = base; 1795 b->yy_is_our_buffer = 0; 1796 b->yy_input_file = 0; 1797 b->yy_n_chars = b->yy_buf_size; 1798 b->yy_is_interactive = 0; 1799 b->yy_at_bol = 1; 1800 b->yy_fill_buffer = 0; 1801 b->yy_buffer_status = YY_BUFFER_NEW; 1802 1803 yy_switch_to_buffer(b ); 1804 1805 return b; 1806} 1807 1808/** Setup the input buffer state to scan a string. The next call to yylex() will 1809 * scan from a @e copy of @a str. 1810 * @param yystr a NUL-terminated string to scan 1811 * 1812 * @return the newly allocated buffer state object. 1813 * @note If you want to scan bytes that may contain NUL values, then use 1814 * yy_scan_bytes() instead. 1815 */ 1816YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) 1817{ 1818 1819 return yy_scan_bytes(yystr,strlen(yystr) ); 1820} 1821 1822/** Setup the input buffer state to scan the given bytes. The next call to yylex() will 1823 * scan from a @e copy of @a bytes. 1824 * @param bytes the byte buffer to scan 1825 * @param len the number of bytes in the buffer pointed to by @a bytes. 1826 * 1827 * @return the newly allocated buffer state object. 1828 */ 1829YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len ) 1830{ 1831 YY_BUFFER_STATE b; 1832 char *buf; 1833 yy_size_t n; 1834 int i; 1835 1836 /* Get memory for full buffer, including space for trailing EOB's. */ 1837 n = _yybytes_len + 2; 1838 buf = (char *) yyalloc(n ); 1839 if ( ! buf ) 1840 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 1841 1842 for ( i = 0; i < _yybytes_len; ++i ) 1843 buf[i] = yybytes[i]; 1844 1845 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; 1846 1847 b = yy_scan_buffer(buf,n ); 1848 if ( ! b ) 1849 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 1850 1851 /* It's okay to grow etc. this buffer, and we should throw it 1852 * away when we're done. 1853 */ 1854 b->yy_is_our_buffer = 1; 1855 1856 return b; 1857} 1858 1859#ifndef YY_EXIT_FAILURE 1860#define YY_EXIT_FAILURE 2 1861#endif 1862 1863static void yy_fatal_error (yyconst char* msg ) 1864{ 1865 (void) fprintf( stderr, "%s\n", msg ); 1866 exit( YY_EXIT_FAILURE ); 1867} 1868 1869/* Redefine yyless() so it works in section 3 code. */ 1870 1871#undef yyless 1872#define yyless(n) \ 1873 do \ 1874 { \ 1875 /* Undo effects of setting up yytext. */ \ 1876 int yyless_macro_arg = (n); \ 1877 YY_LESS_LINENO(yyless_macro_arg);\ 1878 yytext[yyleng] = (yy_hold_char); \ 1879 (yy_c_buf_p) = yytext + yyless_macro_arg; \ 1880 (yy_hold_char) = *(yy_c_buf_p); \ 1881 *(yy_c_buf_p) = '\0'; \ 1882 yyleng = yyless_macro_arg; \ 1883 } \ 1884 while ( 0 ) 1885 1886/* Accessor methods (get/set functions) to struct members. */ 1887 1888/** Get the current line number. 1889 * 1890 */ 1891int yyget_lineno (void) 1892{ 1893 1894 return yylineno; 1895} 1896 1897/** Get the input stream. 1898 * 1899 */ 1900FILE *yyget_in (void) 1901{ 1902 return yyin; 1903} 1904 1905/** Get the output stream. 1906 * 1907 */ 1908FILE *yyget_out (void) 1909{ 1910 return yyout; 1911} 1912 1913/** Get the length of the current token. 1914 * 1915 */ 1916int yyget_leng (void) 1917{ 1918 return yyleng; 1919} 1920 1921/** Get the current token. 1922 * 1923 */ 1924 1925char *yyget_text (void) 1926{ 1927 return yytext; 1928} 1929 1930/** Set the current line number. 1931 * @param line_number 1932 * 1933 */ 1934void yyset_lineno (int line_number ) 1935{ 1936 1937 yylineno = line_number; 1938} 1939 1940/** Set the input stream. This does not discard the current 1941 * input buffer. 1942 * @param in_str A readable stream. 1943 * 1944 * @see yy_switch_to_buffer 1945 */ 1946void yyset_in (FILE * in_str ) 1947{ 1948 yyin = in_str ; 1949} 1950 1951void yyset_out (FILE * out_str ) 1952{ 1953 yyout = out_str ; 1954} 1955 1956int yyget_debug (void) 1957{ 1958 return yy_flex_debug; 1959} 1960 1961void yyset_debug (int bdebug ) 1962{ 1963 yy_flex_debug = bdebug ; 1964} 1965 1966static int yy_init_globals (void) 1967{ 1968 /* Initialization is the same as for the non-reentrant scanner. 1969 * This function is called from yylex_destroy(), so don't allocate here. 1970 */ 1971 1972 /* We do not touch yylineno unless the option is enabled. */ 1973 yylineno = 1; 1974 1975 (yy_buffer_stack) = 0; 1976 (yy_buffer_stack_top) = 0; 1977 (yy_buffer_stack_max) = 0; 1978 (yy_c_buf_p) = (char *) 0; 1979 (yy_init) = 0; 1980 (yy_start) = 0; 1981 1982/* Defined in main.c */ 1983#ifdef YY_STDINIT 1984 yyin = stdin; 1985 yyout = stdout; 1986#else 1987 yyin = (FILE *) 0; 1988 yyout = (FILE *) 0; 1989#endif 1990 1991 /* For future reference: Set errno on error, since we are called by 1992 * yylex_init() 1993 */ 1994 return 0; 1995} 1996 1997/* yylex_destroy is for both reentrant and non-reentrant scanners. */ 1998int yylex_destroy (void) 1999{ 2000 2001 /* Pop the buffer stack, destroying each element. */ 2002 while(YY_CURRENT_BUFFER){ 2003 yy_delete_buffer(YY_CURRENT_BUFFER ); 2004 YY_CURRENT_BUFFER_LVALUE = NULL; 2005 yypop_buffer_state(); 2006 } 2007 2008 /* Destroy the stack itself. */ 2009 yyfree((yy_buffer_stack) ); 2010 (yy_buffer_stack) = NULL; 2011 2012 /* Reset the globals. This is important in a non-reentrant scanner so the next time 2013 * yylex() is called, initialization will occur. */ 2014 yy_init_globals( ); 2015 2016 return 0; 2017} 2018 2019/* 2020 * Internal utility routines. 2021 */ 2022 2023#ifndef yytext_ptr 2024static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) 2025{ 2026 register int i; 2027 for ( i = 0; i < n; ++i ) 2028 s1[i] = s2[i]; 2029} 2030#endif 2031 2032#ifdef YY_NEED_STRLEN 2033static int yy_flex_strlen (yyconst char * s ) 2034{ 2035 register int n; 2036 for ( n = 0; s[n]; ++n ) 2037 ; 2038 2039 return n; 2040} 2041#endif 2042 2043void *yyalloc (yy_size_t size ) 2044{ 2045 return (void *) malloc( size ); 2046} 2047 2048void *yyrealloc (void * ptr, yy_size_t size ) 2049{ 2050 /* The cast to (char *) in the following accommodates both 2051 * implementations that use char* generic pointers, and those 2052 * that use void* generic pointers. It works with the latter 2053 * because both ANSI C and C++ allow castless assignment from 2054 * any pointer type to void*, and deal with argument conversions 2055 * as though doing an assignment. 2056 */ 2057 return (void *) realloc( (char *) ptr, size ); 2058} 2059 2060void yyfree (void * ptr ) 2061{ 2062 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 2063} 2064 2065#define YYTABLES_NAME "yytables" 2066 2067#line 92 "winprefslex.l" 2068 2069 2070 2071/* 2072 * Run-of-the mill requirement for yacc 2073 */ 2074int 2075yywrap () 2076{ 2077 return 1; 2078} 2079 2080/* 2081 * Run a file through the yacc parser 2082 */ 2083void 2084parse_file (FILE *file) 2085{ 2086 if (!file) 2087 return; 2088 2089 yylineno = 1; 2090 yyin = file; 2091 yyparse (); 2092} 2093 2094 2095