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