1#line 2 "scripts/genksyms/lex.c" 2 3#line 4 "scripts/genksyms/lex.c" 4 5#define YY_INT_ALIGNED short int 6 7/* A lexical scanner generated by flex */ 8 9/* %not-for-header */ 10 11/* %if-c-only */ 12/* %if-not-reentrant */ 13 14/* %endif */ 15/* %endif */ 16/* %ok-for-header */ 17 18#define FLEX_SCANNER 19#define YY_FLEX_MAJOR_VERSION 2 20#define YY_FLEX_MINOR_VERSION 5 21#define YY_FLEX_SUBMINOR_VERSION 35 22#if YY_FLEX_SUBMINOR_VERSION > 0 23#define FLEX_BETA 24#endif 25 26/* %if-c++-only */ 27/* %endif */ 28 29/* %if-c-only */ 30 31/* %endif */ 32 33/* %if-c-only */ 34 35/* %endif */ 36 37/* First, we deal with platform-specific or compiler-specific issues. */ 38 39/* begin standard C headers. */ 40/* %if-c-only */ 41#include <stdio.h> 42#include <string.h> 43#include <errno.h> 44#include <stdlib.h> 45/* %endif */ 46 47/* %if-tables-serialization */ 48/* %endif */ 49/* end standard C headers. */ 50 51/* %if-c-or-c++ */ 52/* flex integer type definitions */ 53 54#ifndef FLEXINT_H 55#define FLEXINT_H 56 57/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ 58 59#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 60 61/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, 62 * if you want the limit (max/min) macros for int types. 63 */ 64#ifndef __STDC_LIMIT_MACROS 65#define __STDC_LIMIT_MACROS 1 66#endif 67 68#include <inttypes.h> 69typedef int8_t flex_int8_t; 70typedef uint8_t flex_uint8_t; 71typedef int16_t flex_int16_t; 72typedef uint16_t flex_uint16_t; 73typedef int32_t flex_int32_t; 74typedef uint32_t flex_uint32_t; 75#else 76typedef signed char flex_int8_t; 77typedef short int flex_int16_t; 78typedef int flex_int32_t; 79typedef unsigned char flex_uint8_t; 80typedef unsigned short int flex_uint16_t; 81typedef unsigned int flex_uint32_t; 82 83/* Limits of integral types. */ 84#ifndef INT8_MIN 85#define INT8_MIN (-128) 86#endif 87#ifndef INT16_MIN 88#define INT16_MIN (-32767-1) 89#endif 90#ifndef INT32_MIN 91#define INT32_MIN (-2147483647-1) 92#endif 93#ifndef INT8_MAX 94#define INT8_MAX (127) 95#endif 96#ifndef INT16_MAX 97#define INT16_MAX (32767) 98#endif 99#ifndef INT32_MAX 100#define INT32_MAX (2147483647) 101#endif 102#ifndef UINT8_MAX 103#define UINT8_MAX (255U) 104#endif 105#ifndef UINT16_MAX 106#define UINT16_MAX (65535U) 107#endif 108#ifndef UINT32_MAX 109#define UINT32_MAX (4294967295U) 110#endif 111 112#endif /* ! C99 */ 113 114#endif /* ! FLEXINT_H */ 115 116/* %endif */ 117 118/* %if-c++-only */ 119/* %endif */ 120 121#ifdef __cplusplus 122 123/* The "const" storage-class-modifier is valid. */ 124#define YY_USE_CONST 125 126#else /* ! __cplusplus */ 127 128/* C99 requires __STDC__ to be defined as 1. */ 129#if defined (__STDC__) 130 131#define YY_USE_CONST 132 133#endif /* defined (__STDC__) */ 134#endif /* ! __cplusplus */ 135 136#ifdef YY_USE_CONST 137#define yyconst const 138#else 139#define yyconst 140#endif 141 142/* %not-for-header */ 143 144/* Returned upon end-of-file. */ 145#define YY_NULL 0 146/* %ok-for-header */ 147 148/* %not-for-header */ 149 150/* Promotes a possibly negative, possibly signed char to an unsigned 151 * integer for use as an array index. If the signed char is negative, 152 * we want to instead treat it as an 8-bit unsigned char, hence the 153 * double cast. 154 */ 155#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 156/* %ok-for-header */ 157 158/* %if-reentrant */ 159/* %endif */ 160 161/* %if-not-reentrant */ 162 163/* %endif */ 164 165/* Enter a start condition. This macro really ought to take a parameter, 166 * but we do it the disgusting crufty way forced on us by the ()-less 167 * definition of BEGIN. 168 */ 169#define BEGIN (yy_start) = 1 + 2 * 170 171/* Translate the current start state into a value that can be later handed 172 * to BEGIN to return to the state. The YYSTATE alias is for lex 173 * compatibility. 174 */ 175#define YY_START (((yy_start) - 1) / 2) 176#define YYSTATE YY_START 177 178/* Action number for EOF rule of a given start state. */ 179#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 180 181/* Special action meaning "start processing a new file". */ 182#define YY_NEW_FILE yyrestart(yyin ) 183 184#define YY_END_OF_BUFFER_CHAR 0 185 186/* Size of default input buffer. */ 187#ifndef YY_BUF_SIZE 188#define YY_BUF_SIZE 16384 189#endif 190 191/* The state buf must be large enough to hold one state per character in the main buffer. 192 */ 193#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 194 195#ifndef YY_TYPEDEF_YY_BUFFER_STATE 196#define YY_TYPEDEF_YY_BUFFER_STATE 197typedef struct yy_buffer_state *YY_BUFFER_STATE; 198#endif 199 200/* %if-not-reentrant */ 201extern int yyleng; 202/* %endif */ 203 204/* %if-c-only */ 205/* %if-not-reentrant */ 206extern FILE *yyin, *yyout; 207/* %endif */ 208/* %endif */ 209 210#define EOB_ACT_CONTINUE_SCAN 0 211#define EOB_ACT_END_OF_FILE 1 212#define EOB_ACT_LAST_MATCH 2 213 214 #define YY_LESS_LINENO(n) 215 216/* Return all but the first "n" matched characters back to the input stream. */ 217#define yyless(n) \ 218 do \ 219 { \ 220 /* Undo effects of setting up yytext. */ \ 221 int yyless_macro_arg = (n); \ 222 YY_LESS_LINENO(yyless_macro_arg);\ 223 *yy_cp = (yy_hold_char); \ 224 YY_RESTORE_YY_MORE_OFFSET \ 225 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 226 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 227 } \ 228 while ( 0 ) 229 230#define unput(c) yyunput( c, (yytext_ptr) ) 231 232#ifndef YY_TYPEDEF_YY_SIZE_T 233#define YY_TYPEDEF_YY_SIZE_T 234typedef size_t yy_size_t; 235#endif 236 237#ifndef YY_STRUCT_YY_BUFFER_STATE 238#define YY_STRUCT_YY_BUFFER_STATE 239struct yy_buffer_state 240 { 241/* %if-c-only */ 242 FILE *yy_input_file; 243/* %endif */ 244 245/* %if-c++-only */ 246/* %endif */ 247 248 char *yy_ch_buf; /* input buffer */ 249 char *yy_buf_pos; /* current position in input buffer */ 250 251 /* Size of input buffer in bytes, not including room for EOB 252 * characters. 253 */ 254 yy_size_t yy_buf_size; 255 256 /* Number of characters read into yy_ch_buf, not including EOB 257 * characters. 258 */ 259 int yy_n_chars; 260 261 /* Whether we "own" the buffer - i.e., we know we created it, 262 * and can realloc() it to grow it, and should free() it to 263 * delete it. 264 */ 265 int yy_is_our_buffer; 266 267 /* Whether this is an "interactive" input source; if so, and 268 * if we're using stdio for input, then we want to use getc() 269 * instead of fread(), to make sure we stop fetching input after 270 * each newline. 271 */ 272 int yy_is_interactive; 273 274 /* Whether we're considered to be at the beginning of a line. 275 * If so, '^' rules will be active on the next match, otherwise 276 * not. 277 */ 278 int yy_at_bol; 279 280 int yy_bs_lineno; /**< The line count. */ 281 int yy_bs_column; /**< The column count. */ 282 283 /* Whether to try to fill the input buffer when we reach the 284 * end of it. 285 */ 286 int yy_fill_buffer; 287 288 int yy_buffer_status; 289 290#define YY_BUFFER_NEW 0 291#define YY_BUFFER_NORMAL 1 292 /* When an EOF's been seen but there's still some text to process 293 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 294 * shouldn't try reading from the input source any more. We might 295 * still have a bunch of tokens to match, though, because of 296 * possible backing-up. 297 * 298 * When we actually see the EOF, we change the status to "new" 299 * (via yyrestart()), so that the user can continue scanning by 300 * just pointing yyin at a new input file. 301 */ 302#define YY_BUFFER_EOF_PENDING 2 303 304 }; 305#endif /* !YY_STRUCT_YY_BUFFER_STATE */ 306 307/* %if-c-only Standard (non-C++) definition */ 308/* %not-for-header */ 309 310/* %if-not-reentrant */ 311 312/* Stack of input buffers. */ 313static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ 314static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ 315static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ 316/* %endif */ 317/* %ok-for-header */ 318 319/* %endif */ 320 321/* We provide macros for accessing buffer states in case in the 322 * future we want to put the buffer states in a more general 323 * "scanner state". 324 * 325 * Returns the top of the stack, or NULL. 326 */ 327#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 328 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 329 : NULL) 330 331/* Same as previous macro, but useful when we know that the buffer stack is not 332 * NULL or when we need an lvalue. For internal use only. 333 */ 334#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 335 336/* %if-c-only Standard (non-C++) definition */ 337 338/* %if-not-reentrant */ 339/* %not-for-header */ 340 341/* yy_hold_char holds the character lost when yytext is formed. */ 342static char yy_hold_char; 343static int yy_n_chars; /* number of characters read into yy_ch_buf */ 344int yyleng; 345 346/* Points to current character in buffer. */ 347static char *yy_c_buf_p = (char *) 0; 348static int yy_init = 0; /* whether we need to initialize */ 349static int yy_start = 0; /* start state number */ 350 351/* Flag which is used to allow yywrap()'s to do buffer switches 352 * instead of setting up a fresh yyin. A bit of a hack ... 353 */ 354static int yy_did_buffer_switch_on_eof; 355/* %ok-for-header */ 356 357/* %endif */ 358 359void yyrestart (FILE *input_file ); 360void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); 361YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); 362void yy_delete_buffer (YY_BUFFER_STATE b ); 363void yy_flush_buffer (YY_BUFFER_STATE b ); 364void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); 365void yypop_buffer_state (void ); 366 367static void yyensure_buffer_stack (void ); 368static void yy_load_buffer_state (void ); 369static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); 370 371#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) 372 373YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); 374YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); 375YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ); 376 377/* %endif */ 378 379void *yyalloc (yy_size_t ); 380void *yyrealloc (void *,yy_size_t ); 381void yyfree (void * ); 382 383#define yy_new_buffer yy_create_buffer 384 385#define yy_set_interactive(is_interactive) \ 386 { \ 387 if ( ! YY_CURRENT_BUFFER ){ \ 388 yyensure_buffer_stack (); \ 389 YY_CURRENT_BUFFER_LVALUE = \ 390 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 391 } \ 392 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 393 } 394 395#define yy_set_bol(at_bol) \ 396 { \ 397 if ( ! YY_CURRENT_BUFFER ){\ 398 yyensure_buffer_stack (); \ 399 YY_CURRENT_BUFFER_LVALUE = \ 400 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 401 } \ 402 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 403 } 404 405#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 406 407/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */ 408/* Begin user sect3 */ 409 410#define yywrap(n) 1 411#define YY_SKIP_YYWRAP 412 413#define FLEX_DEBUG 414 415typedef unsigned char YY_CHAR; 416 417FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 418 419typedef int yy_state_type; 420 421extern int yylineno; 422 423int yylineno = 1; 424 425extern char *yytext; 426#define yytext_ptr yytext 427 428/* %if-c-only Standard (non-C++) definition */ 429 430static yy_state_type yy_get_previous_state (void ); 431static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); 432static int yy_get_next_buffer (void ); 433static void yy_fatal_error (yyconst char msg[] ); 434 435/* %endif */ 436 437/* Done after the current pattern has been matched and before the 438 * corresponding action - sets up yytext. 439 */ 440#define YY_DO_BEFORE_ACTION \ 441 (yytext_ptr) = yy_bp; \ 442/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\ 443 yyleng = (size_t) (yy_cp - yy_bp); \ 444 (yy_hold_char) = *yy_cp; \ 445 *yy_cp = '\0'; \ 446/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\ 447 (yy_c_buf_p) = yy_cp; 448 449/* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */ 450#define YY_NUM_RULES 13 451#define YY_END_OF_BUFFER 14 452/* This struct is not used in this scanner, 453 but its presence is necessary. */ 454struct yy_trans_info 455 { 456 flex_int32_t yy_verify; 457 flex_int32_t yy_nxt; 458 }; 459static yyconst flex_int16_t yy_accept[76] = 460 { 0, 461 0, 0, 0, 0, 14, 12, 4, 3, 12, 7, 462 12, 12, 7, 12, 12, 12, 12, 12, 9, 9, 463 12, 12, 12, 4, 0, 5, 0, 7, 0, 6, 464 0, 0, 0, 0, 0, 0, 2, 8, 10, 10, 465 9, 0, 0, 9, 9, 0, 9, 0, 0, 11, 466 0, 0, 0, 10, 0, 10, 9, 9, 0, 0, 467 0, 0, 0, 0, 0, 10, 10, 0, 0, 0, 468 0, 0, 0, 1, 0 469 } ; 470 471static yyconst flex_int32_t yy_ec[256] = 472 { 0, 473 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 474 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 475 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 476 1, 2, 1, 5, 6, 7, 8, 9, 10, 1, 477 1, 8, 11, 1, 12, 13, 8, 14, 15, 15, 478 15, 15, 15, 15, 15, 16, 16, 1, 1, 17, 479 18, 19, 1, 1, 20, 20, 20, 20, 21, 22, 480 7, 7, 7, 7, 7, 23, 7, 7, 7, 7, 481 7, 7, 7, 7, 24, 7, 7, 25, 7, 7, 482 1, 26, 1, 8, 7, 1, 20, 20, 20, 20, 483 484 21, 22, 7, 7, 7, 7, 7, 27, 7, 7, 485 7, 7, 7, 7, 7, 7, 24, 7, 7, 25, 486 7, 7, 1, 28, 1, 8, 1, 1, 1, 1, 487 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 488 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 489 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 490 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 491 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 492 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 493 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 494 495 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 496 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 497 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 498 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 499 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 500 1, 1, 1, 1, 1 501 } ; 502 503static yyconst flex_int32_t yy_meta[29] = 504 { 0, 505 1, 1, 2, 1, 1, 1, 3, 1, 1, 1, 506 4, 4, 5, 6, 6, 6, 1, 1, 1, 7, 507 8, 7, 3, 3, 3, 1, 3, 1 508 } ; 509 510static yyconst flex_int16_t yy_base[88] = 511 { 0, 512 0, 147, 21, 140, 145, 284, 39, 284, 26, 0, 513 32, 126, 40, 44, 115, 35, 36, 46, 50, 53, 514 39, 61, 54, 79, 65, 284, 0, 0, 66, 284, 515 0, 119, 79, 75, 123, 104, 284, 284, 107, 0, 516 79, 73, 76, 76, 66, 0, 0, 85, 86, 284, 517 133, 83, 91, 284, 99, 147, 284, 114, 122, 70, 518 107, 141, 172, 151, 135, 181, 284, 137, 114, 157, 519 149, 48, 45, 284, 284, 208, 214, 222, 230, 238, 520 246, 250, 255, 256, 261, 267, 275 521 } ; 522 523static yyconst flex_int16_t yy_def[88] = 524 { 0, 525 75, 1, 1, 3, 75, 75, 75, 75, 76, 77, 526 78, 75, 77, 79, 75, 75, 75, 75, 75, 19, 527 75, 75, 75, 75, 76, 75, 80, 77, 78, 75, 528 81, 75, 76, 78, 79, 79, 75, 75, 75, 39, 529 19, 82, 83, 75, 75, 84, 20, 76, 78, 75, 530 79, 51, 85, 75, 75, 75, 75, 84, 79, 51, 531 79, 79, 79, 51, 75, 75, 75, 86, 79, 63, 532 86, 87, 87, 75, 0, 75, 75, 75, 75, 75, 533 75, 75, 75, 75, 75, 75, 75 534 } ; 535 536static yyconst flex_int16_t yy_nxt[313] = 537 { 0, 538 6, 7, 8, 7, 9, 6, 10, 6, 6, 11, 539 6, 6, 12, 6, 6, 6, 6, 6, 6, 10, 540 10, 10, 13, 10, 10, 6, 10, 6, 15, 16, 541 26, 15, 17, 18, 19, 20, 20, 21, 15, 22, 542 24, 30, 24, 38, 33, 36, 37, 74, 23, 34, 543 74, 27, 38, 38, 38, 38, 38, 31, 32, 39, 544 39, 39, 40, 41, 41, 42, 47, 47, 47, 26, 545 43, 38, 44, 45, 46, 30, 44, 75, 38, 38, 546 24, 38, 24, 26, 30, 40, 55, 55, 57, 26, 547 27, 31, 57, 43, 35, 30, 64, 64, 64, 57, 548 549 31, 65, 65, 75, 27, 36, 37, 35, 59, 37, 550 27, 31, 56, 56, 56, 59, 37, 51, 52, 52, 551 39, 39, 39, 59, 37, 37, 68, 53, 54, 54, 552 69, 50, 38, 54, 59, 37, 44, 45, 32, 37, 553 44, 35, 59, 37, 75, 14, 60, 60, 66, 66, 554 66, 37, 14, 72, 75, 61, 62, 63, 59, 61, 555 56, 56, 56, 69, 64, 64, 64, 69, 67, 67, 556 75, 75, 75, 67, 37, 35, 75, 75, 75, 61, 557 62, 75, 75, 61, 75, 70, 70, 70, 75, 75, 558 75, 70, 70, 70, 66, 66, 66, 75, 75, 75, 559 560 75, 75, 54, 54, 75, 75, 75, 54, 25, 25, 561 25, 25, 25, 25, 25, 25, 28, 75, 75, 28, 562 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 563 35, 35, 35, 35, 35, 35, 35, 35, 48, 75, 564 48, 48, 48, 48, 48, 48, 49, 75, 49, 49, 565 49, 49, 49, 49, 42, 42, 75, 42, 56, 75, 566 56, 58, 58, 58, 66, 75, 66, 71, 71, 71, 567 71, 71, 71, 71, 71, 73, 73, 73, 73, 73, 568 73, 73, 73, 5, 75, 75, 75, 75, 75, 75, 569 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 570 571 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 572 75, 75 573 } ; 574 575static yyconst flex_int16_t yy_chk[313] = 576 { 0, 577 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 578 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 579 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 580 9, 3, 3, 3, 3, 3, 3, 3, 3, 3, 581 7, 11, 7, 16, 13, 14, 14, 73, 3, 13, 582 72, 9, 16, 17, 17, 21, 21, 11, 18, 18, 583 18, 18, 19, 19, 19, 19, 20, 20, 20, 25, 584 19, 23, 19, 19, 19, 29, 19, 20, 22, 22, 585 24, 23, 24, 33, 34, 42, 43, 43, 45, 48, 586 25, 29, 45, 42, 60, 49, 52, 52, 52, 44, 587 588 34, 53, 53, 41, 33, 36, 36, 52, 61, 61, 589 48, 49, 55, 55, 55, 69, 69, 36, 36, 36, 590 39, 39, 39, 59, 59, 35, 59, 39, 39, 39, 591 61, 32, 15, 39, 51, 51, 58, 58, 12, 68, 592 58, 68, 62, 62, 5, 4, 51, 51, 65, 65, 593 65, 71, 2, 71, 0, 51, 51, 51, 70, 51, 594 56, 56, 56, 62, 64, 64, 64, 62, 56, 56, 595 0, 0, 0, 56, 63, 64, 0, 0, 0, 70, 596 70, 0, 0, 70, 0, 63, 63, 63, 0, 0, 597 0, 63, 63, 63, 66, 66, 66, 0, 0, 0, 598 599 0, 0, 66, 66, 0, 0, 0, 66, 76, 76, 600 76, 76, 76, 76, 76, 76, 77, 0, 0, 77, 601 77, 77, 78, 78, 78, 78, 78, 78, 78, 78, 602 79, 79, 79, 79, 79, 79, 79, 79, 80, 0, 603 80, 80, 80, 80, 80, 80, 81, 0, 81, 81, 604 81, 81, 81, 81, 82, 82, 0, 82, 83, 0, 605 83, 84, 84, 84, 85, 0, 85, 86, 86, 86, 606 86, 86, 86, 86, 86, 87, 87, 87, 87, 87, 607 87, 87, 87, 75, 75, 75, 75, 75, 75, 75, 608 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 609 610 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 611 75, 75 612 } ; 613 614static yy_state_type yy_last_accepting_state; 615static char *yy_last_accepting_cpos; 616 617extern int yy_flex_debug; 618int yy_flex_debug = 1; 619 620static yyconst flex_int16_t yy_rule_linenum[13] = 621 { 0, 622 71, 72, 73, 76, 79, 80, 81, 87, 88, 89, 623 91, 94 624 } ; 625 626/* The intent behind this definition is that it'll catch 627 * any uses of REJECT which flex missed. 628 */ 629#define REJECT reject_used_but_not_detected 630#define yymore() yymore_used_but_not_detected 631#define YY_MORE_ADJ 0 632#define YY_RESTORE_YY_MORE_OFFSET 633char *yytext; 634#line 1 "scripts/genksyms/lex.l" 635/* Lexical analysis for genksyms. 636 Copyright 1996, 1997 Linux International. 637 638 New implementation contributed by Richard Henderson <rth@tamu.edu> 639 Based on original work by Bjorn Ekwall <bj0rn@blox.se> 640 641 Taken from Linux modutils 2.4.22. 642 643 This program is free software; you can redistribute it and/or modify it 644 under the terms of the GNU General Public License as published by the 645 Free Software Foundation; either version 2 of the License, or (at your 646 option) any later version. 647 648 This program is distributed in the hope that it will be useful, but 649 WITHOUT ANY WARRANTY; without even the implied warranty of 650 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 651 General Public License for more details. 652 653 You should have received a copy of the GNU General Public License 654 along with this program; if not, write to the Free Software Foundation, 655 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 656#line 25 "scripts/genksyms/lex.l" 657 658#include <limits.h> 659#include <stdlib.h> 660#include <string.h> 661#include <ctype.h> 662 663#include "genksyms.h" 664#include "parse.h" 665 666/* We've got a two-level lexer here. We let flex do basic tokenization 667 and then we categorize those basic tokens in the second stage. */ 668#define YY_DECL static int yylex1(void) 669 670/* Version 2 checksumming does proper tokenization; version 1 wasn't 671 quite so pedantic. */ 672 673/* We don't do multiple input files. */ 674#define YY_NO_INPUT 1 675#line 676 "scripts/genksyms/lex.c" 676 677#define INITIAL 0 678#define V2_TOKENS 1 679 680#ifndef YY_NO_UNISTD_H 681/* Special case for "unistd.h", since it is non-ANSI. We include it way 682 * down here because we want the user's section 1 to have been scanned first. 683 * The user has a chance to override it with an option. 684 */ 685/* %if-c-only */ 686#include <unistd.h> 687/* %endif */ 688/* %if-c++-only */ 689/* %endif */ 690#endif 691 692#ifndef YY_EXTRA_TYPE 693#define YY_EXTRA_TYPE void * 694#endif 695 696/* %if-c-only Reentrant structure and macros (non-C++). */ 697/* %if-reentrant */ 698/* %if-c-only */ 699 700static int yy_init_globals (void ); 701 702/* %endif */ 703/* %if-reentrant */ 704/* %endif */ 705/* %endif End reentrant structures and macros. */ 706 707/* Accessor methods to globals. 708 These are made visible to non-reentrant scanners for convenience. */ 709 710int yylex_destroy (void ); 711 712int yyget_debug (void ); 713 714void yyset_debug (int debug_flag ); 715 716YY_EXTRA_TYPE yyget_extra (void ); 717 718void yyset_extra (YY_EXTRA_TYPE user_defined ); 719 720FILE *yyget_in (void ); 721 722void yyset_in (FILE * in_str ); 723 724FILE *yyget_out (void ); 725 726void yyset_out (FILE * out_str ); 727 728int yyget_leng (void ); 729 730char *yyget_text (void ); 731 732int yyget_lineno (void ); 733 734void yyset_lineno (int line_number ); 735 736/* %if-bison-bridge */ 737/* %endif */ 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/* %not-for-header */ 752 753 static void yyunput (int c,char *buf_ptr ); 754 755/* %ok-for-header */ 756 757/* %endif */ 758 759#ifndef yytext_ptr 760static void yy_flex_strncpy (char *,yyconst char *,int ); 761#endif 762 763#ifdef YY_NEED_STRLEN 764static int yy_flex_strlen (yyconst char * ); 765#endif 766 767#ifndef YY_NO_INPUT 768/* %if-c-only Standard (non-C++) definition */ 769/* %not-for-header */ 770 771#ifdef __cplusplus 772static int yyinput (void ); 773#else 774static int input (void ); 775#endif 776/* %ok-for-header */ 777 778/* %endif */ 779#endif 780 781/* %if-c-only */ 782 783/* %endif */ 784 785/* Amount of stuff to slurp up with each read. */ 786#ifndef YY_READ_BUF_SIZE 787#define YY_READ_BUF_SIZE 8192 788#endif 789 790/* Copy whatever the last rule matched to the standard output. */ 791#ifndef ECHO 792/* %if-c-only Standard (non-C++) definition */ 793/* This used to be an fputs(), but since the string might contain NUL's, 794 * we now use fwrite(). 795 */ 796#define ECHO fwrite( yytext, yyleng, 1, yyout ) 797/* %endif */ 798/* %if-c++-only C++ definition */ 799/* %endif */ 800#endif 801 802/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 803 * is returned in "result". 804 */ 805#ifndef YY_INPUT 806#define YY_INPUT(buf,result,max_size) \ 807/* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\ 808 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 809 { \ 810 int c = '*'; \ 811 size_t n; \ 812 for ( n = 0; n < max_size && \ 813 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 814 buf[n] = (char) c; \ 815 if ( c == '\n' ) \ 816 buf[n++] = (char) c; \ 817 if ( c == EOF && ferror( yyin ) ) \ 818 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 819 result = n; \ 820 } \ 821 else \ 822 { \ 823 errno=0; \ 824 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 825 { \ 826 if( errno != EINTR) \ 827 { \ 828 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 829 break; \ 830 } \ 831 errno=0; \ 832 clearerr(yyin); \ 833 } \ 834 }\ 835\ 836/* %if-c++-only C++ definition \ */\ 837/* %endif */ 838 839#endif 840 841/* No semi-colon after return; correct usage is to write "yyterminate();" - 842 * we don't want an extra ';' after the "return" because that will cause 843 * some compilers to complain about unreachable statements. 844 */ 845#ifndef yyterminate 846#define yyterminate() return YY_NULL 847#endif 848 849/* Number of entries by which start-condition stack grows. */ 850#ifndef YY_START_STACK_INCR 851#define YY_START_STACK_INCR 25 852#endif 853 854/* Report a fatal error. */ 855#ifndef YY_FATAL_ERROR 856/* %if-c-only */ 857#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 858/* %endif */ 859/* %if-c++-only */ 860/* %endif */ 861#endif 862 863/* %if-tables-serialization structures and prototypes */ 864/* %not-for-header */ 865 866/* %ok-for-header */ 867 868/* %not-for-header */ 869 870/* %tables-yydmap generated elements */ 871/* %endif */ 872/* end tables serialization structures and prototypes */ 873 874/* %ok-for-header */ 875 876/* Default declaration of generated scanner - a define so the user can 877 * easily add parameters. 878 */ 879#ifndef YY_DECL 880#define YY_DECL_IS_OURS 1 881/* %if-c-only Standard (non-C++) definition */ 882 883extern int yylex (void); 884 885#define YY_DECL int yylex (void) 886/* %endif */ 887/* %if-c++-only C++ definition */ 888/* %endif */ 889#endif /* !YY_DECL */ 890 891/* Code executed at the beginning of each rule, after yytext and yyleng 892 * have been set up. 893 */ 894#ifndef YY_USER_ACTION 895#define YY_USER_ACTION 896#endif 897 898/* Code executed at the end of each rule. */ 899#ifndef YY_BREAK 900#define YY_BREAK break; 901#endif 902 903/* %% [6.0] YY_RULE_SETUP definition goes here */ 904#define YY_RULE_SETUP \ 905 if ( yyleng > 0 ) \ 906 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ 907 (yytext[yyleng - 1] == '\n'); \ 908 YY_USER_ACTION 909 910/* %not-for-header */ 911 912/** The main scanner function which does all the work. 913 */ 914YY_DECL 915{ 916 register yy_state_type yy_current_state; 917 register char *yy_cp, *yy_bp; 918 register int yy_act; 919 920/* %% [7.0] user's declarations go here */ 921#line 67 "scripts/genksyms/lex.l" 922 923 924 925 /* Keep track of our location in the original source files. */ 926#line 927 "scripts/genksyms/lex.c" 927 928 if ( !(yy_init) ) 929 { 930 (yy_init) = 1; 931 932#ifdef YY_USER_INIT 933 YY_USER_INIT; 934#endif 935 936 if ( ! (yy_start) ) 937 (yy_start) = 1; /* first start state */ 938 939 if ( ! yyin ) 940/* %if-c-only */ 941 yyin = stdin; 942/* %endif */ 943/* %if-c++-only */ 944/* %endif */ 945 946 if ( ! yyout ) 947/* %if-c-only */ 948 yyout = stdout; 949/* %endif */ 950/* %if-c++-only */ 951/* %endif */ 952 953 if ( ! YY_CURRENT_BUFFER ) { 954 yyensure_buffer_stack (); 955 YY_CURRENT_BUFFER_LVALUE = 956 yy_create_buffer(yyin,YY_BUF_SIZE ); 957 } 958 959 yy_load_buffer_state( ); 960 } 961 962 while ( 1 ) /* loops until end-of-file is reached */ 963 { 964/* %% [8.0] yymore()-related code goes here */ 965 yy_cp = (yy_c_buf_p); 966 967 /* Support of yytext. */ 968 *yy_cp = (yy_hold_char); 969 970 /* yy_bp points to the position in yy_ch_buf of the start of 971 * the current run. 972 */ 973 yy_bp = yy_cp; 974 975/* %% [9.0] code to set up and find next match goes here */ 976 yy_current_state = (yy_start); 977 yy_current_state += YY_AT_BOL(); 978yy_match: 979 do 980 { 981 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 982 if ( yy_accept[yy_current_state] ) 983 { 984 (yy_last_accepting_state) = yy_current_state; 985 (yy_last_accepting_cpos) = yy_cp; 986 } 987 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 988 { 989 yy_current_state = (int) yy_def[yy_current_state]; 990 if ( yy_current_state >= 76 ) 991 yy_c = yy_meta[(unsigned int) yy_c]; 992 } 993 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 994 ++yy_cp; 995 } 996 while ( yy_base[yy_current_state] != 284 ); 997 998yy_find_action: 999/* %% [10.0] code to find the action number goes here */ 1000 yy_act = yy_accept[yy_current_state];
1001 if ( yy_act == 0 ) 1002 { /* have to back up */ 1003 yy_cp = (yy_last_accepting_cpos); 1004 yy_current_state = (yy_last_accepting_state); 1005 yy_act = yy_accept[yy_current_state]; 1006 } 1007 1008 YY_DO_BEFORE_ACTION; 1009 1010/* %% [11.0] code for yylineno update goes here */ 1011 1012do_action: /* This label is used only to access EOF actions. */ 1013 1014/* %% [12.0] debug code goes here */ 1015 if ( yy_flex_debug ) 1016 { 1017 if ( yy_act == 0 ) 1018 fprintf( stderr, "--scanner backing up\n" ); 1019 else if ( yy_act < 13 ) 1020 fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n", 1021 (long)yy_rule_linenum[yy_act], yytext ); 1022 else if ( yy_act == 13 ) 1023 fprintf( stderr, "--accepting default rule (\"%s\")\n", 1024 yytext ); 1025 else if ( yy_act == 14 ) 1026 fprintf( stderr, "--(end of buffer or a NUL)\n" ); 1027 else 1028 fprintf( stderr, "--EOF (start condition %d)\n", YY_START ); 1029 } 1030 1031 switch ( yy_act ) 1032 { /* beginning of action switch */ 1033/* %% [13.0] actions go here */ 1034 case 0: /* must back up */ 1035 /* undo the effects of YY_DO_BEFORE_ACTION */ 1036 *yy_cp = (yy_hold_char); 1037 yy_cp = (yy_last_accepting_cpos); 1038 yy_current_state = (yy_last_accepting_state); 1039 goto yy_find_action; 1040 1041case 1: 1042/* rule 1 can match eol */ 1043YY_RULE_SETUP 1044#line 71 "scripts/genksyms/lex.l" 1045return FILENAME; 1046 YY_BREAK 1047case 2: 1048/* rule 2 can match eol */ 1049YY_RULE_SETUP 1050#line 72 "scripts/genksyms/lex.l" 1051cur_line++; 1052 YY_BREAK 1053case 3: 1054/* rule 3 can match eol */ 1055YY_RULE_SETUP 1056#line 73 "scripts/genksyms/lex.l" 1057cur_line++; 1058 YY_BREAK 1059/* Ignore all other whitespace. */ 1060case 4: 1061YY_RULE_SETUP 1062#line 76 "scripts/genksyms/lex.l" 1063; 1064 YY_BREAK 1065case 5: 1066/* rule 5 can match eol */ 1067YY_RULE_SETUP 1068#line 79 "scripts/genksyms/lex.l" 1069return STRING; 1070 YY_BREAK 1071case 6: 1072/* rule 6 can match eol */ 1073YY_RULE_SETUP 1074#line 80 "scripts/genksyms/lex.l" 1075return CHAR; 1076 YY_BREAK 1077case 7: 1078YY_RULE_SETUP 1079#line 81 "scripts/genksyms/lex.l" 1080return IDENT; 1081 YY_BREAK 1082/* The Pedant requires that the other C multi-character tokens be 1083 recognized as tokens. We don't actually use them since we don't 1084 parse expressions, but we do want whitespace to be arranged 1085 around them properly. */ 1086case 8: 1087YY_RULE_SETUP 1088#line 87 "scripts/genksyms/lex.l" 1089return OTHER; 1090 YY_BREAK 1091case 9: 1092YY_RULE_SETUP 1093#line 88 "scripts/genksyms/lex.l" 1094return INT; 1095 YY_BREAK 1096case 10: 1097YY_RULE_SETUP 1098#line 89 "scripts/genksyms/lex.l" 1099return REAL; 1100 YY_BREAK 1101case 11: 1102YY_RULE_SETUP 1103#line 91 "scripts/genksyms/lex.l" 1104return DOTS; 1105 YY_BREAK 1106/* All other tokens are single characters. */ 1107case 12: 1108YY_RULE_SETUP 1109#line 94 "scripts/genksyms/lex.l" 1110return yytext[0]; 1111 YY_BREAK 1112case 13: 1113YY_RULE_SETUP 1114#line 97 "scripts/genksyms/lex.l" 1115ECHO; 1116 YY_BREAK 1117#line 1118 "scripts/genksyms/lex.c" 1118case YY_STATE_EOF(INITIAL): 1119case YY_STATE_EOF(V2_TOKENS): 1120 yyterminate(); 1121 1122 case YY_END_OF_BUFFER: 1123 { 1124 /* Amount of text matched not including the EOB char. */ 1125 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; 1126 1127 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1128 *yy_cp = (yy_hold_char); 1129 YY_RESTORE_YY_MORE_OFFSET 1130 1131 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 1132 { 1133 /* We're scanning a new file or input source. It's 1134 * possible that this happened because the user 1135 * just pointed yyin at a new source and called 1136 * yylex(). If so, then we have to assure 1137 * consistency between YY_CURRENT_BUFFER and our 1138 * globals. Here is the right place to do so, because 1139 * this is the first action (other than possibly a 1140 * back-up) that will match for the new input source. 1141 */ 1142 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 1143 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; 1144 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 1145 } 1146 1147 /* Note that here we test for yy_c_buf_p "<=" to the position 1148 * of the first EOB in the buffer, since yy_c_buf_p will 1149 * already have been incremented past the NUL character 1150 * (since all states make transitions on EOB to the 1151 * end-of-buffer state). Contrast this with the test 1152 * in input(). 1153 */ 1154 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 1155 { /* This was really a NUL. */ 1156 yy_state_type yy_next_state; 1157 1158 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; 1159 1160 yy_current_state = yy_get_previous_state( ); 1161 1162 /* Okay, we're now positioned to make the NUL 1163 * transition. We couldn't have 1164 * yy_get_previous_state() go ahead and do it 1165 * for us because it doesn't know how to deal 1166 * with the possibility of jamming (and we don't 1167 * want to build jamming into it because then it 1168 * will run more slowly). 1169 */ 1170 1171 yy_next_state = yy_try_NUL_trans( yy_current_state ); 1172 1173 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1174 1175 if ( yy_next_state ) 1176 { 1177 /* Consume the NUL. */ 1178 yy_cp = ++(yy_c_buf_p); 1179 yy_current_state = yy_next_state; 1180 goto yy_match; 1181 } 1182 1183 else 1184 { 1185/* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */ 1186 yy_cp = (yy_c_buf_p); 1187 goto yy_find_action; 1188 } 1189 } 1190 1191 else switch ( yy_get_next_buffer( ) ) 1192 { 1193 case EOB_ACT_END_OF_FILE: 1194 { 1195 (yy_did_buffer_switch_on_eof) = 0; 1196 1197 if ( yywrap( ) ) 1198 { 1199 /* Note: because we've taken care in 1200 * yy_get_next_buffer() to have set up 1201 * yytext, we can now set up 1202 * yy_c_buf_p so that if some total 1203 * hoser (like flex itself) wants to 1204 * call the scanner after we return the 1205 * YY_NULL, it'll still work - another 1206 * YY_NULL will get returned. 1207 */ 1208 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; 1209 1210 yy_act = YY_STATE_EOF(YY_START); 1211 goto do_action; 1212 } 1213 1214 else 1215 { 1216 if ( ! (yy_did_buffer_switch_on_eof) ) 1217 YY_NEW_FILE; 1218 } 1219 break; 1220 } 1221 1222 case EOB_ACT_CONTINUE_SCAN: 1223 (yy_c_buf_p) = 1224 (yytext_ptr) + yy_amount_of_matched_text; 1225 1226 yy_current_state = yy_get_previous_state( ); 1227 1228 yy_cp = (yy_c_buf_p); 1229 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1230 goto yy_match; 1231 1232 case EOB_ACT_LAST_MATCH: 1233 (yy_c_buf_p) = 1234 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; 1235 1236 yy_current_state = yy_get_previous_state( ); 1237 1238 yy_cp = (yy_c_buf_p); 1239 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1240 goto yy_find_action; 1241 } 1242 break; 1243 } 1244 1245 default: 1246 YY_FATAL_ERROR( 1247 "fatal flex scanner internal error--no action found" ); 1248 } /* end of action switch */ 1249 } /* end of scanning one token */ 1250} /* end of yylex */ 1251/* %ok-for-header */ 1252 1253/* %if-c++-only */ 1254/* %not-for-header */ 1255 1256/* %ok-for-header */ 1257 1258/* %endif */ 1259 1260/* yy_get_next_buffer - try to read in a new buffer 1261 * 1262 * Returns a code representing an action: 1263 * EOB_ACT_LAST_MATCH - 1264 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1265 * EOB_ACT_END_OF_FILE - end of file 1266 */ 1267/* %if-c-only */ 1268static int yy_get_next_buffer (void) 1269/* %endif */ 1270/* %if-c++-only */ 1271/* %endif */ 1272{ 1273 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 1274 register char *source = (yytext_ptr); 1275 register int number_to_move, i; 1276 int ret_val; 1277 1278 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) 1279 YY_FATAL_ERROR( 1280 "fatal flex scanner internal error--end of buffer missed" ); 1281 1282 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 1283 { /* Don't try to fill the buffer, so this is an EOF. */ 1284 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) 1285 { 1286 /* We matched a single character, the EOB, so 1287 * treat this as a final EOF. 1288 */ 1289 return EOB_ACT_END_OF_FILE; 1290 } 1291 1292 else 1293 { 1294 /* We matched some text prior to the EOB, first 1295 * process it. 1296 */ 1297 return EOB_ACT_LAST_MATCH; 1298 } 1299 } 1300 1301 /* Try to read more data. */ 1302 1303 /* First move last chars to start of buffer. */ 1304 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; 1305 1306 for ( i = 0; i < number_to_move; ++i ) 1307 *(dest++) = *(source++); 1308 1309 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1310 /* don't do the read, it's not guaranteed to return an EOF, 1311 * just force an EOF 1312 */ 1313 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; 1314 1315 else 1316 { 1317 int num_to_read = 1318 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 1319 1320 while ( num_to_read <= 0 ) 1321 { /* Not enough room in the buffer - grow it. */ 1322 1323 /* just a shorter name for the current buffer */ 1324 YY_BUFFER_STATE b = YY_CURRENT_BUFFER; 1325 1326 int yy_c_buf_p_offset = 1327 (int) ((yy_c_buf_p) - b->yy_ch_buf); 1328 1329 if ( b->yy_is_our_buffer ) 1330 { 1331 int new_size = b->yy_buf_size * 2; 1332 1333 if ( new_size <= 0 ) 1334 b->yy_buf_size += b->yy_buf_size / 8; 1335 else 1336 b->yy_buf_size *= 2; 1337 1338 b->yy_ch_buf = (char *) 1339 /* Include room in for 2 EOB chars. */ 1340 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); 1341 } 1342 else 1343 /* Can't grow it, we don't own it. */ 1344 b->yy_ch_buf = 0; 1345 1346 if ( ! b->yy_ch_buf ) 1347 YY_FATAL_ERROR( 1348 "fatal error - scanner input buffer overflow" ); 1349 1350 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 1351 1352 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - 1353 number_to_move - 1; 1354 1355 } 1356 1357 if ( num_to_read > YY_READ_BUF_SIZE ) 1358 num_to_read = YY_READ_BUF_SIZE; 1359 1360 /* Read in more data. */ 1361 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 1362 (yy_n_chars), (size_t) num_to_read ); 1363 1364 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1365 } 1366 1367 if ( (yy_n_chars) == 0 ) 1368 { 1369 if ( number_to_move == YY_MORE_ADJ ) 1370 { 1371 ret_val = EOB_ACT_END_OF_FILE; 1372 yyrestart(yyin ); 1373 } 1374 1375 else 1376 { 1377 ret_val = EOB_ACT_LAST_MATCH; 1378 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 1379 YY_BUFFER_EOF_PENDING; 1380 } 1381 } 1382 1383 else 1384 ret_val = EOB_ACT_CONTINUE_SCAN; 1385 1386 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { 1387 /* Extend the array by 50%, plus the number we really need. */ 1388 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); 1389 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); 1390 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1391 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); 1392 } 1393 1394 (yy_n_chars) += number_to_move; 1395 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; 1396 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; 1397 1398 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 1399 1400 return ret_val; 1401} 1402 1403/* yy_get_previous_state - get the state just before the EOB char was reached */ 1404 1405/* %if-c-only */ 1406/* %not-for-header */ 1407 1408 static yy_state_type yy_get_previous_state (void) 1409/* %endif */ 1410/* %if-c++-only */ 1411/* %endif */ 1412{ 1413 register yy_state_type yy_current_state; 1414 register char *yy_cp; 1415 1416/* %% [15.0] code to get the start state into yy_current_state goes here */ 1417 yy_current_state = (yy_start); 1418 yy_current_state += YY_AT_BOL(); 1419 1420 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) 1421 { 1422/* %% [16.0] code to find the next state goes here */ 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 >= 76 ) 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/* %if-c-only */ 1447 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) 1448/* %endif */ 1449/* %if-c++-only */ 1450/* %endif */ 1451{ 1452 register int yy_is_jam; 1453 /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */ 1454 register char *yy_cp = (yy_c_buf_p); 1455 1456 register YY_CHAR yy_c = 1; 1457 if ( yy_accept[yy_current_state] ) 1458 { 1459 (yy_last_accepting_state) = yy_current_state; 1460 (yy_last_accepting_cpos) = yy_cp; 1461 } 1462 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1463 { 1464 yy_current_state = (int) yy_def[yy_current_state]; 1465 if ( yy_current_state >= 76 ) 1466 yy_c = yy_meta[(unsigned int) yy_c]; 1467 } 1468 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1469 yy_is_jam = (yy_current_state == 75); 1470 1471 return yy_is_jam ? 0 : yy_current_state; 1472} 1473 1474/* %if-c-only */ 1475 1476 static void yyunput (int c, register char * yy_bp ) 1477/* %endif */ 1478/* %if-c++-only */ 1479/* %endif */ 1480{ 1481 register char *yy_cp; 1482 1483 yy_cp = (yy_c_buf_p); 1484 1485 /* undo effects of setting up yytext */ 1486 *yy_cp = (yy_hold_char); 1487 1488 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 1489 { /* need to shift things up to make room */ 1490 /* +2 for EOB chars. */ 1491 register int number_to_move = (yy_n_chars) + 2; 1492 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ 1493 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; 1494 register char *source = 1495 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; 1496 1497 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1498 *--dest = *--source; 1499 1500 yy_cp += (int) (dest - source); 1501 yy_bp += (int) (dest - source); 1502 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = 1503 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; 1504 1505 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 1506 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1507 } 1508 1509 *--yy_cp = (char) c; 1510 1511/* %% [18.0] update yylineno here */ 1512 1513 (yytext_ptr) = yy_bp; 1514 (yy_hold_char) = *yy_cp; 1515 (yy_c_buf_p) = yy_cp; 1516} 1517/* %if-c-only */ 1518 1519/* %endif */ 1520 1521/* %if-c-only */ 1522#ifndef YY_NO_INPUT 1523#ifdef __cplusplus 1524 static int yyinput (void) 1525#else 1526 static int input (void) 1527#endif 1528 1529/* %endif */ 1530/* %if-c++-only */ 1531/* %endif */ 1532{ 1533 int c; 1534 1535 *(yy_c_buf_p) = (yy_hold_char); 1536 1537 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) 1538 { 1539 /* yy_c_buf_p now points to the character we want to return. 1540 * If this occurs *before* the EOB characters, then it's a 1541 * valid NUL; if not, then we've hit the end of the buffer. 1542 */ 1543 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 1544 /* This was really a NUL. */ 1545 *(yy_c_buf_p) = '\0'; 1546 1547 else 1548 { /* need more input */ 1549 int offset = (yy_c_buf_p) - (yytext_ptr); 1550 ++(yy_c_buf_p); 1551 1552 switch ( yy_get_next_buffer( ) ) 1553 { 1554 case EOB_ACT_LAST_MATCH: 1555 /* This happens because yy_g_n_b() 1556 * sees that we've accumulated a 1557 * token and flags that we need to 1558 * try matching the token before 1559 * proceeding. But for input(), 1560 * there's no matching to consider. 1561 * So convert the EOB_ACT_LAST_MATCH 1562 * to EOB_ACT_END_OF_FILE. 1563 */ 1564 1565 /* Reset buffer status. */ 1566 yyrestart(yyin ); 1567 1568 /*FALLTHROUGH*/ 1569 1570 case EOB_ACT_END_OF_FILE: 1571 { 1572 if ( yywrap( ) ) 1573 return EOF; 1574 1575 if ( ! (yy_did_buffer_switch_on_eof) ) 1576 YY_NEW_FILE; 1577#ifdef __cplusplus 1578 return yyinput(); 1579#else 1580 return input(); 1581#endif 1582 } 1583 1584 case EOB_ACT_CONTINUE_SCAN: 1585 (yy_c_buf_p) = (yytext_ptr) + offset; 1586 break; 1587 } 1588 } 1589 } 1590 1591 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ 1592 *(yy_c_buf_p) = '\0'; /* preserve yytext */ 1593 (yy_hold_char) = *++(yy_c_buf_p); 1594 1595/* %% [19.0] update BOL and yylineno */ 1596 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n'); 1597 1598 return c; 1599} 1600/* %if-c-only */ 1601#endif /* ifndef YY_NO_INPUT */ 1602/* %endif */ 1603 1604/** Immediately switch to a different input stream. 1605 * @param input_file A readable stream. 1606 * 1607 * @note This function does not reset the start condition to @c INITIAL . 1608 */ 1609/* %if-c-only */ 1610 void yyrestart (FILE * input_file ) 1611/* %endif */ 1612/* %if-c++-only */ 1613/* %endif */ 1614{ 1615 1616 if ( ! YY_CURRENT_BUFFER ){ 1617 yyensure_buffer_stack (); 1618 YY_CURRENT_BUFFER_LVALUE = 1619 yy_create_buffer(yyin,YY_BUF_SIZE ); 1620 } 1621 1622 yy_init_buffer(YY_CURRENT_BUFFER,input_file ); 1623 yy_load_buffer_state( ); 1624} 1625 1626/** Switch to a different input buffer. 1627 * @param new_buffer The new input buffer. 1628 * 1629 */ 1630/* %if-c-only */ 1631 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) 1632/* %endif */ 1633/* %if-c++-only */ 1634/* %endif */ 1635{ 1636 1637 /* TODO. We should be able to replace this entire function body 1638 * with 1639 * yypop_buffer_state(); 1640 * yypush_buffer_state(new_buffer); 1641 */ 1642 yyensure_buffer_stack (); 1643 if ( YY_CURRENT_BUFFER == new_buffer ) 1644 return; 1645 1646 if ( YY_CURRENT_BUFFER ) 1647 { 1648 /* Flush out information for old buffer. */ 1649 *(yy_c_buf_p) = (yy_hold_char); 1650 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 1651 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1652 } 1653 1654 YY_CURRENT_BUFFER_LVALUE = new_buffer; 1655 yy_load_buffer_state( ); 1656 1657 /* We don't actually know whether we did this switch during 1658 * EOF (yywrap()) processing, but the only time this flag 1659 * is looked at is after yywrap() is called, so it's safe 1660 * to go ahead and always set it. 1661 */ 1662 (yy_did_buffer_switch_on_eof) = 1; 1663} 1664 1665/* %if-c-only */ 1666static void yy_load_buffer_state (void) 1667/* %endif */ 1668/* %if-c++-only */ 1669/* %endif */ 1670{ 1671 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 1672 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 1673 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 1674 (yy_hold_char) = *(yy_c_buf_p); 1675} 1676 1677/** Allocate and initialize an input buffer state. 1678 * @param file A readable stream. 1679 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. 1680 * 1681 * @return the allocated buffer state. 1682 */ 1683/* %if-c-only */ 1684 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) 1685/* %endif */ 1686/* %if-c++-only */ 1687/* %endif */ 1688{ 1689 YY_BUFFER_STATE b; 1690 1691 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); 1692 if ( ! b ) 1693 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1694 1695 b->yy_buf_size = size; 1696 1697 /* yy_ch_buf has to be 2 characters longer than the size given because 1698 * we need to put in 2 end-of-buffer characters. 1699 */ 1700 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); 1701 if ( ! b->yy_ch_buf ) 1702 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1703 1704 b->yy_is_our_buffer = 1; 1705 1706 yy_init_buffer(b,file ); 1707 1708 return b; 1709} 1710 1711/** Destroy the buffer. 1712 * @param b a buffer created with yy_create_buffer() 1713 * 1714 */ 1715/* %if-c-only */ 1716 void yy_delete_buffer (YY_BUFFER_STATE b ) 1717/* %endif */ 1718/* %if-c++-only */ 1719/* %endif */ 1720{ 1721 1722 if ( ! b ) 1723 return; 1724 1725 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 1726 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 1727 1728 if ( b->yy_is_our_buffer ) 1729 yyfree((void *) b->yy_ch_buf ); 1730 1731 yyfree((void *) b ); 1732} 1733 1734/* %if-c-only */ 1735 1736#ifndef __cplusplus 1737extern int isatty (int ); 1738#endif /* __cplusplus */ 1739 1740/* %endif */ 1741 1742/* %if-c++-only */ 1743/* %endif */ 1744 1745/* Initializes or reinitializes a buffer. 1746 * This function is sometimes called more than once on the same buffer, 1747 * such as during a yyrestart() or at EOF. 1748 */ 1749/* %if-c-only */ 1750 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) 1751/* %endif */ 1752/* %if-c++-only */ 1753/* %endif */ 1754 1755{ 1756 int oerrno = errno; 1757 1758 yy_flush_buffer(b ); 1759 1760 b->yy_input_file = file; 1761 b->yy_fill_buffer = 1; 1762 1763 /* If b is the current buffer, then yy_init_buffer was _probably_ 1764 * called from yyrestart() or through yy_get_next_buffer. 1765 * In that case, we don't want to reset the lineno or column. 1766 */ 1767 if (b != YY_CURRENT_BUFFER){ 1768 b->yy_bs_lineno = 1; 1769 b->yy_bs_column = 0; 1770 } 1771 1772/* %if-c-only */ 1773 1774 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 1775 1776/* %endif */ 1777/* %if-c++-only */ 1778/* %endif */ 1779 errno = oerrno; 1780} 1781 1782/** Discard all buffered characters. On the next scan, YY_INPUT will be called. 1783 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. 1784 * 1785 */ 1786/* %if-c-only */ 1787 void yy_flush_buffer (YY_BUFFER_STATE b ) 1788/* %endif */ 1789/* %if-c++-only */ 1790/* %endif */ 1791{ 1792 if ( ! b ) 1793 return; 1794 1795 b->yy_n_chars = 0; 1796 1797 /* We always need two end-of-buffer characters. The first causes 1798 * a transition to the end-of-buffer state. The second causes 1799 * a jam in that state. 1800 */ 1801 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 1802 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 1803 1804 b->yy_buf_pos = &b->yy_ch_buf[0]; 1805 1806 b->yy_at_bol = 1; 1807 b->yy_buffer_status = YY_BUFFER_NEW; 1808 1809 if ( b == YY_CURRENT_BUFFER ) 1810 yy_load_buffer_state( ); 1811} 1812 1813/* %if-c-or-c++ */ 1814/** Pushes the new state onto the stack. The new state becomes 1815 * the current state. This function will allocate the stack 1816 * if necessary. 1817 * @param new_buffer The new state. 1818 * 1819 */ 1820/* %if-c-only */ 1821void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) 1822/* %endif */ 1823/* %if-c++-only */ 1824/* %endif */ 1825{ 1826 if (new_buffer == NULL) 1827 return; 1828 1829 yyensure_buffer_stack(); 1830 1831 /* This block is copied from yy_switch_to_buffer. */ 1832 if ( YY_CURRENT_BUFFER ) 1833 { 1834 /* Flush out information for old buffer. */ 1835 *(yy_c_buf_p) = (yy_hold_char); 1836 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 1837 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1838 } 1839 1840 /* Only push if top exists. Otherwise, replace top. */ 1841 if (YY_CURRENT_BUFFER) 1842 (yy_buffer_stack_top)++; 1843 YY_CURRENT_BUFFER_LVALUE = new_buffer; 1844 1845 /* copied from yy_switch_to_buffer. */ 1846 yy_load_buffer_state( ); 1847 (yy_did_buffer_switch_on_eof) = 1; 1848} 1849/* %endif */ 1850 1851/* %if-c-or-c++ */ 1852/** Removes and deletes the top of the stack, if present. 1853 * The next element becomes the new top. 1854 * 1855 */ 1856/* %if-c-only */ 1857void yypop_buffer_state (void) 1858/* %endif */ 1859/* %if-c++-only */ 1860/* %endif */ 1861{ 1862 if (!YY_CURRENT_BUFFER) 1863 return; 1864 1865 yy_delete_buffer(YY_CURRENT_BUFFER ); 1866 YY_CURRENT_BUFFER_LVALUE = NULL; 1867 if ((yy_buffer_stack_top) > 0) 1868 --(yy_buffer_stack_top); 1869 1870 if (YY_CURRENT_BUFFER) { 1871 yy_load_buffer_state( ); 1872 (yy_did_buffer_switch_on_eof) = 1; 1873 } 1874} 1875/* %endif */ 1876 1877/* %if-c-or-c++ */ 1878/* Allocates the stack if it does not exist. 1879 * Guarantees space for at least one push. 1880 */ 1881/* %if-c-only */ 1882static void yyensure_buffer_stack (void) 1883/* %endif */ 1884/* %if-c++-only */ 1885/* %endif */ 1886{ 1887 int num_to_alloc; 1888 1889 if (!(yy_buffer_stack)) { 1890 1891 /* First allocation is just for 2 elements, since we don't know if this 1892 * scanner will even need a stack. We use 2 instead of 1 to avoid an 1893 * immediate realloc on the next call. 1894 */ 1895 num_to_alloc = 1; 1896 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc 1897 (num_to_alloc * sizeof(struct yy_buffer_state*) 1898 ); 1899 if ( ! (yy_buffer_stack) ) 1900 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 1901 1902 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 1903 1904 (yy_buffer_stack_max) = num_to_alloc; 1905 (yy_buffer_stack_top) = 0; 1906 return; 1907 } 1908 1909 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ 1910 1911 /* Increase the buffer to prepare for a possible push. */ 1912 int grow_size = 8 /* arbitrary grow size */; 1913 1914 num_to_alloc = (yy_buffer_stack_max) + grow_size; 1915 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc 1916 ((yy_buffer_stack), 1917 num_to_alloc * sizeof(struct yy_buffer_state*) 1918 ); 1919 if ( ! (yy_buffer_stack) ) 1920 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 1921 1922 /* zero only the new slots.*/ 1923 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 1924 (yy_buffer_stack_max) = num_to_alloc; 1925 } 1926} 1927/* %endif */ 1928 1929/* %if-c-only */ 1930/** Setup the input buffer state to scan directly from a user-specified character buffer. 1931 * @param base the character buffer 1932 * @param size the size in bytes of the character buffer 1933 * 1934 * @return the newly allocated buffer state object. 1935 */ 1936YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) 1937{ 1938 YY_BUFFER_STATE b; 1939 1940 if ( size < 2 || 1941 base[size-2] != YY_END_OF_BUFFER_CHAR || 1942 base[size-1] != YY_END_OF_BUFFER_CHAR ) 1943 /* They forgot to leave room for the EOB's. */ 1944 return 0; 1945 1946 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); 1947 if ( ! b ) 1948 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 1949 1950 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 1951 b->yy_buf_pos = b->yy_ch_buf = base; 1952 b->yy_is_our_buffer = 0; 1953 b->yy_input_file = 0; 1954 b->yy_n_chars = b->yy_buf_size; 1955 b->yy_is_interactive = 0; 1956 b->yy_at_bol = 1; 1957 b->yy_fill_buffer = 0; 1958 b->yy_buffer_status = YY_BUFFER_NEW; 1959 1960 yy_switch_to_buffer(b ); 1961 1962 return b; 1963} 1964/* %endif */ 1965 1966/* %if-c-only */ 1967/** Setup the input buffer state to scan a string. The next call to yylex() will 1968 * scan from a @e copy of @a str. 1969 * @param yystr a NUL-terminated string to scan 1970 * 1971 * @return the newly allocated buffer state object. 1972 * @note If you want to scan bytes that may contain NUL values, then use 1973 * yy_scan_bytes() instead. 1974 */ 1975YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) 1976{ 1977 1978 return yy_scan_bytes(yystr,strlen(yystr) ); 1979} 1980/* %endif */ 1981 1982/* %if-c-only */ 1983/** Setup the input buffer state to scan the given bytes. The next call to yylex() will 1984 * scan from a @e copy of @a bytes. 1985 * @param bytes the byte buffer to scan 1986 * @param len the number of bytes in the buffer pointed to by @a bytes. 1987 * 1988 * @return the newly allocated buffer state object. 1989 */ 1990YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len ) 1991{ 1992 YY_BUFFER_STATE b; 1993 char *buf; 1994 yy_size_t n; 1995 int i; 1996 1997 /* Get memory for full buffer, including space for trailing EOB's. */ 1998 n = _yybytes_len + 2; 1999 buf = (char *) yyalloc(n ); 2000 if ( ! buf )
2001 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 2002 2003 for ( i = 0; i < _yybytes_len; ++i ) 2004 buf[i] = yybytes[i]; 2005 2006 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; 2007 2008 b = yy_scan_buffer(buf,n ); 2009 if ( ! b ) 2010 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 2011 2012 /* It's okay to grow etc. this buffer, and we should throw it 2013 * away when we're done. 2014 */ 2015 b->yy_is_our_buffer = 1; 2016 2017 return b; 2018} 2019/* %endif */ 2020 2021#ifndef YY_EXIT_FAILURE 2022#define YY_EXIT_FAILURE 2 2023#endif 2024 2025/* %if-c-only */ 2026static void yy_fatal_error (yyconst char* msg ) 2027{ 2028 (void) fprintf( stderr, "%s\n", msg ); 2029 exit( YY_EXIT_FAILURE ); 2030} 2031/* %endif */ 2032/* %if-c++-only */ 2033/* %endif */ 2034 2035/* Redefine yyless() so it works in section 3 code. */ 2036 2037#undef yyless 2038#define yyless(n) \ 2039 do \ 2040 { \ 2041 /* Undo effects of setting up yytext. */ \ 2042 int yyless_macro_arg = (n); \ 2043 YY_LESS_LINENO(yyless_macro_arg);\ 2044 yytext[yyleng] = (yy_hold_char); \ 2045 (yy_c_buf_p) = yytext + yyless_macro_arg; \ 2046 (yy_hold_char) = *(yy_c_buf_p); \ 2047 *(yy_c_buf_p) = '\0'; \ 2048 yyleng = yyless_macro_arg; \ 2049 } \ 2050 while ( 0 ) 2051 2052/* Accessor methods (get/set functions) to struct members. */ 2053 2054/* %if-c-only */ 2055/* %if-reentrant */ 2056/* %endif */ 2057 2058/** Get the current line number. 2059 * 2060 */ 2061int yyget_lineno (void) 2062{ 2063 2064 return yylineno; 2065} 2066 2067/** Get the input stream. 2068 * 2069 */ 2070FILE *yyget_in (void) 2071{ 2072 return yyin; 2073} 2074 2075/** Get the output stream. 2076 * 2077 */ 2078FILE *yyget_out (void) 2079{ 2080 return yyout; 2081} 2082 2083/** Get the length of the current token. 2084 * 2085 */ 2086int yyget_leng (void) 2087{ 2088 return yyleng; 2089} 2090 2091/** Get the current token. 2092 * 2093 */ 2094 2095char *yyget_text (void) 2096{ 2097 return yytext; 2098} 2099 2100/* %if-reentrant */ 2101/* %endif */ 2102 2103/** Set the current line number. 2104 * @param line_number 2105 * 2106 */ 2107void yyset_lineno (int line_number ) 2108{ 2109 2110 yylineno = line_number; 2111} 2112 2113/** Set the input stream. This does not discard the current 2114 * input buffer. 2115 * @param in_str A readable stream. 2116 * 2117 * @see yy_switch_to_buffer 2118 */ 2119void yyset_in (FILE * in_str ) 2120{ 2121 yyin = in_str ; 2122} 2123 2124void yyset_out (FILE * out_str ) 2125{ 2126 yyout = out_str ; 2127} 2128 2129int yyget_debug (void) 2130{ 2131 return yy_flex_debug; 2132} 2133 2134void yyset_debug (int bdebug ) 2135{ 2136 yy_flex_debug = bdebug ; 2137} 2138 2139/* %endif */ 2140 2141/* %if-reentrant */ 2142/* %if-bison-bridge */ 2143/* %endif */ 2144/* %endif if-c-only */ 2145 2146/* %if-c-only */ 2147static int yy_init_globals (void) 2148{ 2149 /* Initialization is the same as for the non-reentrant scanner. 2150 * This function is called from yylex_destroy(), so don't allocate here. 2151 */ 2152 2153 (yy_buffer_stack) = 0; 2154 (yy_buffer_stack_top) = 0; 2155 (yy_buffer_stack_max) = 0; 2156 (yy_c_buf_p) = (char *) 0; 2157 (yy_init) = 0; 2158 (yy_start) = 0; 2159 2160/* Defined in main.c */ 2161#ifdef YY_STDINIT 2162 yyin = stdin; 2163 yyout = stdout; 2164#else 2165 yyin = (FILE *) 0; 2166 yyout = (FILE *) 0; 2167#endif 2168 2169 /* For future reference: Set errno on error, since we are called by 2170 * yylex_init() 2171 */ 2172 return 0; 2173} 2174/* %endif */ 2175 2176/* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */ 2177/* yylex_destroy is for both reentrant and non-reentrant scanners. */ 2178int yylex_destroy (void) 2179{ 2180 2181 /* Pop the buffer stack, destroying each element. */ 2182 while(YY_CURRENT_BUFFER){ 2183 yy_delete_buffer(YY_CURRENT_BUFFER ); 2184 YY_CURRENT_BUFFER_LVALUE = NULL; 2185 yypop_buffer_state(); 2186 } 2187 2188 /* Destroy the stack itself. */ 2189 yyfree((yy_buffer_stack) ); 2190 (yy_buffer_stack) = NULL; 2191 2192 /* Reset the globals. This is important in a non-reentrant scanner so the next time 2193 * yylex() is called, initialization will occur. */ 2194 yy_init_globals( ); 2195 2196/* %if-reentrant */ 2197/* %endif */ 2198 return 0; 2199} 2200/* %endif */ 2201 2202/* 2203 * Internal utility routines. 2204 */ 2205 2206#ifndef yytext_ptr 2207static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) 2208{ 2209 register int i; 2210 for ( i = 0; i < n; ++i ) 2211 s1[i] = s2[i]; 2212} 2213#endif 2214 2215#ifdef YY_NEED_STRLEN 2216static int yy_flex_strlen (yyconst char * s ) 2217{ 2218 register int n; 2219 for ( n = 0; s[n]; ++n ) 2220 ; 2221 2222 return n; 2223} 2224#endif 2225 2226void *yyalloc (yy_size_t size ) 2227{ 2228 return (void *) malloc( size ); 2229} 2230 2231void *yyrealloc (void * ptr, yy_size_t size ) 2232{ 2233 /* The cast to (char *) in the following accommodates both 2234 * implementations that use char* generic pointers, and those 2235 * that use void* generic pointers. It works with the latter 2236 * because both ANSI C and C++ allow castless assignment from 2237 * any pointer type to void*, and deal with argument conversions 2238 * as though doing an assignment. 2239 */ 2240 return (void *) realloc( (char *) ptr, size ); 2241} 2242 2243void yyfree (void * ptr ) 2244{ 2245 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 2246} 2247 2248/* %if-tables-serialization definitions */ 2249/* %define-yytables The name for this specific scanner's tables. */ 2250#define YYTABLES_NAME "yytables" 2251/* %endif */ 2252 2253/* %ok-for-header */ 2254 2255#line 97 "scripts/genksyms/lex.l" 2256 2257 2258 2259/* Bring in the keyword recognizer. */ 2260 2261#include "keywords.c" 2262 2263 2264/* Macros to append to our phrase collection list. */ 2265 2266#define _APP(T,L) do { \ 2267 cur_node = next_node; \ 2268 next_node = xmalloc(sizeof(*next_node)); \ 2269 next_node->next = cur_node; \ 2270 cur_node->string = memcpy(xmalloc(L+1), T, L+1); \ 2271 cur_node->tag = SYM_NORMAL; \ 2272 } while (0) 2273 2274#define APP _APP(yytext, yyleng) 2275 2276 2277/* The second stage lexer. Here we incorporate knowledge of the state 2278 of the parser to tailor the tokens that are returned. */ 2279 2280int 2281yylex(void) 2282{ 2283 static enum { 2284 ST_NOTSTARTED, ST_NORMAL, ST_ATTRIBUTE, ST_ASM, ST_BRACKET, ST_BRACE, 2285 ST_EXPRESSION, ST_TABLE_1, ST_TABLE_2, ST_TABLE_3, ST_TABLE_4, 2286 ST_TABLE_5, ST_TABLE_6 2287 } lexstate = ST_NOTSTARTED; 2288 2289 static int suppress_type_lookup, dont_want_brace_phrase; 2290 static struct string_list *next_node; 2291 2292 int token, count = 0; 2293 struct string_list *cur_node; 2294 2295 if (lexstate == ST_NOTSTARTED) 2296 { 2297 BEGIN(V2_TOKENS); 2298 next_node = xmalloc(sizeof(*next_node)); 2299 next_node->next = NULL; 2300 lexstate = ST_NORMAL; 2301 } 2302 2303repeat: 2304 token = yylex1(); 2305 2306 if (token == 0) 2307 return 0; 2308 else if (token == FILENAME) 2309 { 2310 char *file, *e; 2311 2312 /* Save the filename and line number for later error messages. */ 2313 2314 if (cur_filename) 2315 free(cur_filename); 2316 2317 file = strchr(yytext, '\"')+1; 2318 e = strchr(file, '\"'); 2319 *e = '\0'; 2320 cur_filename = memcpy(xmalloc(e-file+1), file, e-file+1); 2321 cur_line = atoi(yytext+2); 2322 2323 goto repeat; 2324 } 2325 2326 switch (lexstate) 2327 { 2328 case ST_NORMAL: 2329 switch (token) 2330 { 2331 case IDENT: 2332 APP; 2333 { 2334 const struct resword *r = is_reserved_word(yytext, yyleng); 2335 if (r) 2336 { 2337 switch (token = r->token) 2338 { 2339 case ATTRIBUTE_KEYW: 2340 lexstate = ST_ATTRIBUTE; 2341 count = 0; 2342 goto repeat; 2343 case ASM_KEYW: 2344 lexstate = ST_ASM; 2345 count = 0; 2346 goto repeat; 2347 2348 case STRUCT_KEYW: 2349 case UNION_KEYW: 2350 dont_want_brace_phrase = 3; 2351 case ENUM_KEYW: 2352 suppress_type_lookup = 2; 2353 goto fini; 2354 2355 case EXPORT_SYMBOL_KEYW: 2356 goto fini; 2357 } 2358 } 2359 if (!suppress_type_lookup) 2360 { 2361 struct symbol *sym = find_symbol(yytext, SYM_TYPEDEF); 2362 if (sym && sym->type == SYM_TYPEDEF) 2363 token = TYPE; 2364 } 2365 } 2366 break; 2367 2368 case '[': 2369 APP; 2370 lexstate = ST_BRACKET; 2371 count = 1; 2372 goto repeat; 2373 2374 case '{': 2375 APP; 2376 if (dont_want_brace_phrase) 2377 break; 2378 lexstate = ST_BRACE; 2379 count = 1; 2380 goto repeat; 2381 2382 case '=': case ':': 2383 APP; 2384 lexstate = ST_EXPRESSION; 2385 break; 2386 2387 case DOTS: 2388 default: 2389 APP; 2390 break; 2391 } 2392 break; 2393 2394 case ST_ATTRIBUTE: 2395 APP; 2396 switch (token) 2397 { 2398 case '(': 2399 ++count; 2400 goto repeat; 2401 case ')': 2402 if (--count == 0) 2403 { 2404 lexstate = ST_NORMAL; 2405 token = ATTRIBUTE_PHRASE; 2406 break; 2407 } 2408 goto repeat; 2409 default: 2410 goto repeat; 2411 } 2412 break; 2413 2414 case ST_ASM: 2415 APP; 2416 switch (token) 2417 { 2418 case '(': 2419 ++count; 2420 goto repeat; 2421 case ')': 2422 if (--count == 0) 2423 { 2424 lexstate = ST_NORMAL; 2425 token = ASM_PHRASE; 2426 break; 2427 } 2428 goto repeat; 2429 default: 2430 goto repeat; 2431 } 2432 break; 2433 2434 case ST_BRACKET: 2435 APP; 2436 switch (token) 2437 { 2438 case '[': 2439 ++count; 2440 goto repeat; 2441 case ']': 2442 if (--count == 0) 2443 { 2444 lexstate = ST_NORMAL; 2445 token = BRACKET_PHRASE; 2446 break; 2447 } 2448 goto repeat; 2449 default: 2450 goto repeat; 2451 } 2452 break; 2453 2454 case ST_BRACE: 2455 APP; 2456 switch (token) 2457 { 2458 case '{': 2459 ++count; 2460 goto repeat; 2461 case '}': 2462 if (--count == 0) 2463 { 2464 lexstate = ST_NORMAL; 2465 token = BRACE_PHRASE; 2466 break; 2467 } 2468 goto repeat; 2469 default: 2470 goto repeat; 2471 } 2472 break; 2473 2474 case ST_EXPRESSION: 2475 switch (token) 2476 { 2477 case '(': case '[': case '{': 2478 ++count; 2479 APP; 2480 goto repeat; 2481 case ')': case ']': case '}': 2482 --count; 2483 APP; 2484 goto repeat; 2485 case ',': case ';': 2486 if (count == 0) 2487 { 2488 /* Put back the token we just read so's we can find it again 2489 after registering the expression. */ 2490 unput(token); 2491 2492 lexstate = ST_NORMAL; 2493 token = EXPRESSION_PHRASE; 2494 break; 2495 } 2496 APP; 2497 goto repeat; 2498 default: 2499 APP; 2500 goto repeat; 2501 } 2502 break; 2503 2504 case ST_TABLE_1: 2505 goto repeat; 2506 2507 case ST_TABLE_2: 2508 if (token == IDENT && yyleng == 1 && yytext[0] == 'X') 2509 { 2510 token = EXPORT_SYMBOL_KEYW; 2511 lexstate = ST_TABLE_5; 2512 APP; 2513 break; 2514 } 2515 lexstate = ST_TABLE_6; 2516 /* FALLTHRU */ 2517 2518 case ST_TABLE_6: 2519 switch (token) 2520 { 2521 case '{': case '[': case '(': 2522 ++count; 2523 break; 2524 case '}': case ']': case ')': 2525 --count; 2526 break; 2527 case ',': 2528 if (count == 0) 2529 lexstate = ST_TABLE_2; 2530 break; 2531 }; 2532 goto repeat; 2533 2534 case ST_TABLE_3: 2535 goto repeat; 2536 2537 case ST_TABLE_4: 2538 if (token == ';') 2539 lexstate = ST_NORMAL; 2540 goto repeat; 2541 2542 case ST_TABLE_5: 2543 switch (token) 2544 { 2545 case ',': 2546 token = ';'; 2547 lexstate = ST_TABLE_2; 2548 APP; 2549 break; 2550 default: 2551 APP; 2552 break; 2553 } 2554 break; 2555 2556 default: 2557 exit(1); 2558 } 2559fini: 2560 2561 if (suppress_type_lookup > 0) 2562 --suppress_type_lookup; 2563 if (dont_want_brace_phrase > 0) 2564 --dont_want_brace_phrase; 2565 2566 yylval = &next_node->next; 2567 2568 return token; 2569} 2570/* A Bison parser, made by GNU Bison 2.3. */ 2571 2572/* Skeleton interface for Bison's Yacc-like parsers in C 2573 2574 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 2575 Free Software Foundation, Inc. 2576 2577 This program is free software; you can redistribute it and/or modify 2578 it under the terms of the GNU General Public License as published by 2579 the Free Software Foundation; either version 2, or (at your option) 2580 any later version. 2581 2582 This program is distributed in the hope that it will be useful, 2583 but WITHOUT ANY WARRANTY; without even the implied warranty of 2584 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 2585 GNU General Public License for more details. 2586 2587 You should have received a copy of the GNU General Public License 2588 along with this program; if not, write to the Free Software 2589 Foundation, Inc., 51 Franklin Street, Fifth Floor, 2590 Boston, MA 02110-1301, USA. */ 2591 2592/* As a special exception, you may create a larger work that contains 2593 part or all of the Bison parser skeleton and distribute that work 2594 under terms of your choice, so long as that work isn't itself a 2595 parser generator using the skeleton or a modified version thereof 2596 as a parser skeleton. Alternatively, if you modify or redistribute 2597 the parser skeleton itself, you may (at your option) remove this 2598 special exception, which will cause the skeleton and the resulting 2599 Bison output files to be licensed under the GNU General Public 2600 License without this special exception. 2601 2602 This special exception was added by the Free Software Foundation in 2603 version 2.2 of Bison. */ 2604 2605/* Tokens. */ 2606#ifndef YYTOKENTYPE 2607# define YYTOKENTYPE 2608 /* Put the tokens into the symbol table, so that GDB and other debuggers 2609 know about them. */ 2610 enum yytokentype { 2611 ASM_KEYW = 258, 2612 ATTRIBUTE_KEYW = 259, 2613 AUTO_KEYW = 260, 2614 BOOL_KEYW = 261, 2615 CHAR_KEYW = 262, 2616 CONST_KEYW = 263, 2617 DOUBLE_KEYW = 264, 2618 ENUM_KEYW = 265, 2619 EXTERN_KEYW = 266, 2620 EXTENSION_KEYW = 267, 2621 FLOAT_KEYW = 268, 2622 INLINE_KEYW = 269, 2623 INT_KEYW = 270, 2624 LONG_KEYW = 271, 2625 REGISTER_KEYW = 272, 2626 RESTRICT_KEYW = 273, 2627 SHORT_KEYW = 274, 2628 SIGNED_KEYW = 275, 2629 STATIC_KEYW = 276, 2630 STRUCT_KEYW = 277, 2631 TYPEDEF_KEYW = 278, 2632 UNION_KEYW = 279, 2633 UNSIGNED_KEYW = 280, 2634 VOID_KEYW = 281, 2635 VOLATILE_KEYW = 282, 2636 TYPEOF_KEYW = 283, 2637 EXPORT_SYMBOL_KEYW = 284, 2638 ASM_PHRASE = 285, 2639 ATTRIBUTE_PHRASE = 286, 2640 BRACE_PHRASE = 287, 2641 BRACKET_PHRASE = 288, 2642 EXPRESSION_PHRASE = 289, 2643 CHAR = 290, 2644 DOTS = 291, 2645 IDENT = 292, 2646 INT = 293, 2647 REAL = 294, 2648 STRING = 295, 2649 TYPE = 296, 2650 OTHER = 297, 2651 FILENAME = 298 2652 }; 2653#endif 2654/* Tokens. */ 2655#define ASM_KEYW 258 2656#define ATTRIBUTE_KEYW 259 2657#define AUTO_KEYW 260 2658#define BOOL_KEYW 261 2659#define CHAR_KEYW 262 2660#define CONST_KEYW 263 2661#define DOUBLE_KEYW 264 2662#define ENUM_KEYW 265 2663#define EXTERN_KEYW 266 2664#define EXTENSION_KEYW 267 2665#define FLOAT_KEYW 268 2666#define INLINE_KEYW 269 2667#define INT_KEYW 270 2668#define LONG_KEYW 271 2669#define REGISTER_KEYW 272 2670#define RESTRICT_KEYW 273 2671#define SHORT_KEYW 274 2672#define SIGNED_KEYW 275 2673#define STATIC_KEYW 276 2674#define STRUCT_KEYW 277 2675#define TYPEDEF_KEYW 278 2676#define UNION_KEYW 279 2677#define UNSIGNED_KEYW 280 2678#define VOID_KEYW 281 2679#define VOLATILE_KEYW 282 2680#define TYPEOF_KEYW 283 2681#define EXPORT_SYMBOL_KEYW 284 2682#define ASM_PHRASE 285 2683#define ATTRIBUTE_PHRASE 286 2684#define BRACE_PHRASE 287 2685#define BRACKET_PHRASE 288 2686#define EXPRESSION_PHRASE 289 2687#define CHAR 290 2688#define DOTS 291 2689#define IDENT 292 2690#define INT 293 2691#define REAL 294 2692#define STRING 295 2693#define TYPE 296 2694#define OTHER 297 2695#define FILENAME 298 2696 2697 2698 2699 2700#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 2701typedef int YYSTYPE; 2702# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 2703# define YYSTYPE_IS_DECLARED 1 2704# define YYSTYPE_IS_TRIVIAL 1 2705#endif 2706 2707extern YYSTYPE yylval; 2708 2709 2710