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