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