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