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