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