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