1 2#line 2 "ldlex.c" 3 4#define YY_INT_ALIGNED short int 5 6/* A lexical scanner generated by flex */ 7 8#define FLEX_SCANNER 9#define YY_FLEX_MAJOR_VERSION 2 10#define YY_FLEX_MINOR_VERSION 6 11#define YY_FLEX_SUBMINOR_VERSION 4 12#if YY_FLEX_SUBMINOR_VERSION > 0 13#define FLEX_BETA 14#endif 15 16/* First, we deal with platform-specific or compiler-specific issues. */ 17 18/* begin standard C headers. */ 19#include <stdio.h> 20#include <string.h> 21#include <errno.h> 22#include <stdlib.h> 23 24/* end standard C headers. */ 25 26/* flex integer type definitions */ 27 28#ifndef FLEXINT_H 29#define FLEXINT_H 30 31/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ 32 33#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 34 35/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, 36 * if you want the limit (max/min) macros for int types. 37 */ 38#ifndef __STDC_LIMIT_MACROS 39#define __STDC_LIMIT_MACROS 1 40#endif 41 42#include <inttypes.h> 43typedef int8_t flex_int8_t; 44typedef uint8_t flex_uint8_t; 45typedef int16_t flex_int16_t; 46typedef uint16_t flex_uint16_t; 47typedef int32_t flex_int32_t; 48typedef uint32_t flex_uint32_t; 49#else 50typedef signed char flex_int8_t; 51typedef short int flex_int16_t; 52typedef int flex_int32_t; 53typedef unsigned char flex_uint8_t; 54typedef unsigned short int flex_uint16_t; 55typedef unsigned int flex_uint32_t; 56 57/* Limits of integral types. */ 58#ifndef INT8_MIN 59#define INT8_MIN (-128) 60#endif 61#ifndef INT16_MIN 62#define INT16_MIN (-32767-1) 63#endif 64#ifndef INT32_MIN 65#define INT32_MIN (-2147483647-1) 66#endif 67#ifndef INT8_MAX 68#define INT8_MAX (127) 69#endif 70#ifndef INT16_MAX 71#define INT16_MAX (32767) 72#endif 73#ifndef INT32_MAX 74#define INT32_MAX (2147483647) 75#endif 76#ifndef UINT8_MAX 77#define UINT8_MAX (255U) 78#endif 79#ifndef UINT16_MAX 80#define UINT16_MAX (65535U) 81#endif 82#ifndef UINT32_MAX 83#define UINT32_MAX (4294967295U) 84#endif 85 86#ifndef SIZE_MAX 87#define SIZE_MAX (~(size_t)0) 88#endif 89 90#endif /* ! C99 */ 91 92#endif /* ! FLEXINT_H */ 93 94/* begin standard C++ headers. */ 95 96/* TODO: this is always defined, so inline it */ 97#define yyconst const 98 99#if defined(__GNUC__) && __GNUC__ >= 3 100#define yynoreturn __attribute__((__noreturn__)) 101#else 102#define yynoreturn 103#endif 104 105/* Returned upon end-of-file. */ 106#define YY_NULL 0 107 108/* Promotes a possibly negative, possibly signed char to an 109 * integer in range [0..255] for use as an array index. 110 */ 111#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) 112 113/* Enter a start condition. This macro really ought to take a parameter, 114 * but we do it the disgusting crufty way forced on us by the ()-less 115 * definition of BEGIN. 116 */ 117#define BEGIN (yy_start) = 1 + 2 * 118/* Translate the current start state into a value that can be later handed 119 * to BEGIN to return to the state. The YYSTATE alias is for lex 120 * compatibility. 121 */ 122#define YY_START (((yy_start) - 1) / 2) 123#define YYSTATE YY_START 124/* Action number for EOF rule of a given start state. */ 125#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 126/* Special action meaning "start processing a new file". */ 127#define YY_NEW_FILE yyrestart( yyin ) 128#define YY_END_OF_BUFFER_CHAR 0 129 130/* Size of default input buffer. */ 131#ifndef YY_BUF_SIZE 132#ifdef __ia64__ 133/* On IA-64, the buffer size is 16k, not 8k. 134 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. 135 * Ditto for the __ia64__ case accordingly. 136 */ 137#define YY_BUF_SIZE 32768 138#else 139#define YY_BUF_SIZE 16384 140#endif /* __ia64__ */ 141#endif 142 143/* The state buf must be large enough to hold one state per character in the main buffer. 144 */ 145#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 146 147#ifndef YY_TYPEDEF_YY_BUFFER_STATE 148#define YY_TYPEDEF_YY_BUFFER_STATE 149typedef struct yy_buffer_state *YY_BUFFER_STATE; 150#endif 151 152#ifndef YY_TYPEDEF_YY_SIZE_T 153#define YY_TYPEDEF_YY_SIZE_T 154typedef size_t yy_size_t; 155#endif 156 157extern int yyleng; 158 159extern FILE *yyin, *yyout; 160 161#define EOB_ACT_CONTINUE_SCAN 0 162#define EOB_ACT_END_OF_FILE 1 163#define EOB_ACT_LAST_MATCH 2 164 165 #define YY_LESS_LINENO(n) 166 #define YY_LINENO_REWIND_TO(ptr) 167 168/* Return all but the first "n" matched characters back to the input stream. */ 169#define yyless(n) \ 170 do \ 171 { \ 172 /* Undo effects of setting up yytext. */ \ 173 int yyless_macro_arg = (n); \ 174 YY_LESS_LINENO(yyless_macro_arg);\ 175 *yy_cp = (yy_hold_char); \ 176 YY_RESTORE_YY_MORE_OFFSET \ 177 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 178 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 179 } \ 180 while ( 0 ) 181#define unput(c) yyunput( c, (yytext_ptr) ) 182 183#ifndef YY_STRUCT_YY_BUFFER_STATE 184#define YY_STRUCT_YY_BUFFER_STATE 185struct yy_buffer_state 186 { 187 FILE *yy_input_file; 188 189 char *yy_ch_buf; /* input buffer */ 190 char *yy_buf_pos; /* current position in input buffer */ 191 192 /* Size of input buffer in bytes, not including room for EOB 193 * characters. 194 */ 195 int yy_buf_size; 196 197 /* Number of characters read into yy_ch_buf, not including EOB 198 * characters. 199 */ 200 int yy_n_chars; 201 202 /* Whether we "own" the buffer - i.e., we know we created it, 203 * and can realloc() it to grow it, and should free() it to 204 * delete it. 205 */ 206 int yy_is_our_buffer; 207 208 /* Whether this is an "interactive" input source; if so, and 209 * if we're using stdio for input, then we want to use getc() 210 * instead of fread(), to make sure we stop fetching input after 211 * each newline. 212 */ 213 int yy_is_interactive; 214 215 /* Whether we're considered to be at the beginning of a line. 216 * If so, '^' rules will be active on the next match, otherwise 217 * not. 218 */ 219 int yy_at_bol; 220 221 int yy_bs_lineno; /**< The line count. */ 222 int yy_bs_column; /**< The column count. */ 223 224 /* Whether to try to fill the input buffer when we reach the 225 * end of it. 226 */ 227 int yy_fill_buffer; 228 229 int yy_buffer_status; 230 231#define YY_BUFFER_NEW 0 232#define YY_BUFFER_NORMAL 1 233 /* When an EOF's been seen but there's still some text to process 234 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 235 * shouldn't try reading from the input source any more. We might 236 * still have a bunch of tokens to match, though, because of 237 * possible backing-up. 238 * 239 * When we actually see the EOF, we change the status to "new" 240 * (via yyrestart()), so that the user can continue scanning by 241 * just pointing yyin at a new input file. 242 */ 243#define YY_BUFFER_EOF_PENDING 2 244 245 }; 246#endif /* !YY_STRUCT_YY_BUFFER_STATE */ 247 248/* Stack of input buffers. */ 249static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ 250static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ 251static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ 252 253/* We provide macros for accessing buffer states in case in the 254 * future we want to put the buffer states in a more general 255 * "scanner state". 256 * 257 * Returns the top of the stack, or NULL. 258 */ 259#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 260 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 261 : NULL) 262/* Same as previous macro, but useful when we know that the buffer stack is not 263 * NULL or when we need an lvalue. For internal use only. 264 */ 265#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 266 267/* yy_hold_char holds the character lost when yytext is formed. */ 268static char yy_hold_char; 269static int yy_n_chars; /* number of characters read into yy_ch_buf */ 270int yyleng; 271 272/* Points to current character in buffer. */ 273static char *yy_c_buf_p = NULL; 274static int yy_init = 0; /* whether we need to initialize */ 275static int yy_start = 0; /* start state number */ 276 277/* Flag which is used to allow yywrap()'s to do buffer switches 278 * instead of setting up a fresh yyin. A bit of a hack ... 279 */ 280static int yy_did_buffer_switch_on_eof; 281 282void yyrestart ( FILE *input_file ); 283void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); 284YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); 285void yy_delete_buffer ( YY_BUFFER_STATE b ); 286void yy_flush_buffer ( YY_BUFFER_STATE b ); 287void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); 288void yypop_buffer_state ( void ); 289 290static void yyensure_buffer_stack ( void ); 291static void yy_load_buffer_state ( void ); 292static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); 293#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) 294 295YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); 296YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); 297YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); 298 299void *yyalloc ( yy_size_t ); 300void *yyrealloc ( void *, yy_size_t ); 301void yyfree ( void * ); 302 303#define yy_new_buffer yy_create_buffer 304#define yy_set_interactive(is_interactive) \ 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_is_interactive = is_interactive; \ 312 } 313#define yy_set_bol(at_bol) \ 314 { \ 315 if ( ! YY_CURRENT_BUFFER ){\ 316 yyensure_buffer_stack (); \ 317 YY_CURRENT_BUFFER_LVALUE = \ 318 yy_create_buffer( yyin, YY_BUF_SIZE ); \ 319 } \ 320 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 321 } 322#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 323 324/* Begin user sect3 */ 325 326#define yywrap() (/*CONSTCOND*/1) 327#define YY_SKIP_YYWRAP 328typedef flex_uint8_t YY_CHAR; 329 330FILE *yyin = NULL, *yyout = NULL; 331 332typedef int yy_state_type; 333 334extern int yylineno; 335int yylineno = 1; 336 337extern char *yytext; 338#ifdef yytext_ptr 339#undef yytext_ptr 340#endif 341#define yytext_ptr yytext 342 343static yy_state_type yy_get_previous_state ( void ); 344static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); 345static int yy_get_next_buffer ( void ); 346static void yynoreturn yy_fatal_error ( const char* msg ); 347 348/* Done after the current pattern has been matched and before the 349 * corresponding action - sets up yytext. 350 */ 351#define YY_DO_BEFORE_ACTION \ 352 (yytext_ptr) = yy_bp; \ 353 yyleng = (int) (yy_cp - yy_bp); \ 354 (yy_hold_char) = *yy_cp; \ 355 *yy_cp = '\0'; \ 356 (yy_c_buf_p) = yy_cp; 357#define YY_NUM_RULES 195 358#define YY_END_OF_BUFFER 196 359/* This struct is not used in this scanner, 360 but its presence is necessary. */ 361struct yy_trans_info 362 { 363 flex_int32_t yy_verify; 364 flex_int32_t yy_nxt; 365 }; 366static const flex_int16_t yy_accept[1207] = 367 { 0, 368 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 369 177, 177, 0, 0, 0, 0, 0, 0, 196, 195, 370 193, 180, 179, 28, 193, 181, 172, 193, 40, 39, 371 193, 31, 24, 32, 172, 172, 4, 4, 41, 42, 372 193, 36, 23, 172, 172, 172, 172, 172, 172, 172, 373 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 374 172, 118, 116, 38, 193, 37, 27, 180, 195, 172, 375 40, 39, 24, 195, 172, 195, 172, 194, 180, 28, 376 194, 181, 175, 34, 25, 40, 39, 30, 31, 24, 377 32, 175, 33, 4, 4, 41, 42, 35, 36, 23, 378 379 29, 175, 175, 175, 175, 175, 175, 175, 175, 175, 380 175, 175, 175, 175, 175, 175, 38, 26, 37, 27, 381 133, 28, 132, 171, 34, 25, 30, 171, 33, 4, 382 4, 42, 35, 36, 23, 29, 171, 171, 171, 171, 383 171, 171, 171, 171, 171, 171, 171, 171, 171, 6, 384 5, 171, 171, 171, 171, 171, 171, 171, 171, 171, 385 171, 171, 26, 27, 177, 25, 177, 177, 177, 177, 386 36, 193, 177, 177, 177, 177, 177, 177, 177, 177, 387 177, 177, 177, 177, 6, 5, 193, 188, 187, 182, 388 189, 190, 186, 186, 186, 186, 191, 192, 180, 0, 389 390 178, 181, 172, 4, 20, 18, 16, 17, 1, 19, 391 4, 4, 0, 0, 0, 172, 172, 172, 172, 172, 392 123, 172, 172, 172, 172, 172, 172, 172, 172, 172, 393 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 394 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 395 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 396 21, 0, 173, 172, 11, 175, 2, 22, 19, 0, 397 4, 0, 3, 3, 3, 14, 13, 10, 12, 15, 398 175, 3, 3, 3, 175, 175, 123, 3, 175, 175, 399 3, 175, 175, 175, 175, 175, 175, 175, 175, 175, 400 401 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 402 175, 175, 9, 132, 132, 171, 2, 134, 18, 135, 403 171, 3, 3, 3, 171, 171, 171, 3, 171, 3, 404 3, 171, 171, 171, 171, 171, 171, 171, 171, 171, 405 3, 171, 171, 171, 3, 171, 3, 3, 171, 171, 406 171, 171, 171, 171, 171, 171, 177, 18, 16, 17, 407 19, 177, 123, 177, 177, 177, 177, 177, 177, 177, 408 177, 177, 177, 177, 177, 177, 177, 187, 186, 0, 409 186, 186, 186, 4, 4, 7, 8, 172, 172, 172, 410 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 411 412 172, 172, 172, 172, 90, 172, 172, 172, 172, 172, 413 172, 172, 172, 68, 59, 172, 60, 172, 172, 172, 414 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 415 172, 172, 172, 172, 172, 172, 172, 119, 117, 174, 416 173, 172, 4, 0, 175, 3, 175, 175, 175, 175, 417 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 418 175, 59, 60, 175, 175, 175, 175, 175, 175, 175, 419 175, 175, 175, 175, 175, 175, 4, 171, 171, 171, 420 171, 171, 136, 171, 171, 171, 171, 171, 171, 171, 421 171, 171, 171, 171, 171, 171, 171, 171, 171, 153, 422 423 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 424 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 425 177, 177, 177, 177, 177, 177, 186, 186, 186, 172, 426 55, 172, 172, 172, 172, 49, 172, 172, 172, 172, 427 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 428 172, 172, 172, 172, 172, 65, 172, 172, 172, 172, 429 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 430 172, 172, 172, 172, 172, 172, 0, 175, 55, 175, 431 175, 49, 175, 175, 110, 175, 175, 175, 175, 175, 432 111, 175, 175, 175, 65, 175, 175, 175, 175, 175, 433 434 175, 175, 175, 175, 175, 175, 112, 171, 171, 171, 435 141, 149, 140, 171, 171, 171, 151, 144, 147, 171, 436 171, 152, 171, 171, 171, 171, 171, 158, 166, 157, 437 171, 171, 169, 161, 164, 171, 171, 170, 171, 171, 438 177, 97, 177, 177, 177, 86, 177, 177, 177, 129, 439 95, 177, 93, 177, 104, 177, 186, 186, 186, 172, 440 84, 51, 172, 172, 48, 172, 172, 172, 63, 172, 441 92, 172, 74, 172, 172, 172, 73, 172, 172, 172, 442 172, 172, 172, 172, 172, 172, 172, 172, 172, 122, 443 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 444 445 172, 172, 172, 0, 175, 51, 175, 48, 175, 175, 446 175, 109, 175, 175, 175, 175, 175, 175, 175, 175, 447 175, 175, 175, 175, 175, 175, 175, 175, 171, 142, 448 139, 171, 171, 171, 151, 151, 146, 171, 150, 171, 449 171, 159, 156, 171, 171, 169, 169, 163, 171, 168, 450 171, 177, 177, 177, 177, 177, 177, 177, 177, 96, 451 177, 94, 186, 186, 184, 172, 172, 172, 62, 85, 452 172, 172, 172, 64, 172, 126, 172, 172, 83, 172, 453 50, 172, 172, 43, 172, 172, 172, 46, 72, 172, 454 172, 172, 172, 172, 172, 69, 172, 172, 172, 91, 455 456 70, 172, 172, 0, 175, 175, 175, 62, 175, 175, 457 175, 126, 175, 50, 175, 175, 175, 107, 175, 46, 458 175, 175, 175, 175, 69, 175, 175, 171, 171, 64, 459 148, 171, 145, 171, 171, 171, 167, 165, 162, 171, 460 62, 177, 177, 177, 126, 177, 177, 177, 177, 177, 461 185, 183, 172, 57, 172, 172, 172, 76, 172, 172, 462 121, 172, 172, 172, 172, 172, 98, 172, 172, 101, 463 127, 172, 172, 172, 172, 172, 115, 87, 172, 47, 464 172, 0, 175, 57, 175, 175, 175, 76, 121, 175, 465 175, 175, 175, 101, 127, 175, 175, 175, 115, 175, 466 467 171, 171, 121, 171, 171, 171, 171, 177, 177, 177, 468 121, 177, 127, 177, 177, 58, 172, 131, 172, 172, 469 172, 172, 172, 56, 61, 172, 172, 172, 172, 172, 470 172, 172, 82, 172, 172, 125, 172, 0, 58, 175, 471 131, 175, 56, 61, 175, 175, 175, 108, 175, 175, 472 125, 137, 138, 143, 154, 155, 160, 177, 177, 177, 473 177, 177, 177, 177, 172, 172, 172, 172, 172, 172, 474 172, 172, 172, 172, 172, 172, 172, 172, 172, 75, 475 176, 175, 175, 175, 175, 175, 175, 175, 177, 177, 476 177, 177, 177, 177, 177, 177, 106, 172, 172, 172, 477 478 172, 172, 45, 172, 113, 114, 172, 172, 172, 172, 479 71, 172, 172, 175, 175, 175, 113, 114, 175, 175, 480 175, 177, 177, 177, 177, 177, 177, 177, 177, 172, 481 172, 172, 172, 172, 99, 89, 172, 172, 172, 172, 482 172, 175, 175, 99, 175, 175, 175, 177, 177, 177, 483 177, 177, 177, 177, 177, 172, 172, 172, 172, 172, 484 172, 172, 172, 44, 172, 172, 175, 175, 175, 175, 485 175, 175, 78, 177, 130, 177, 177, 177, 177, 102, 486 172, 172, 172, 172, 172, 172, 88, 172, 67, 172, 487 175, 175, 175, 175, 67, 175, 177, 177, 177, 177, 488 489 177, 172, 172, 172, 172, 172, 172, 172, 100, 128, 490 66, 175, 175, 175, 175, 100, 128, 66, 177, 177, 491 128, 177, 177, 172, 172, 172, 172, 172, 172, 172, 492 175, 175, 175, 175, 177, 177, 177, 177, 124, 172, 493 54, 172, 172, 172, 172, 124, 175, 54, 175, 177, 494 177, 177, 177, 172, 172, 172, 172, 172, 175, 175, 495 177, 177, 103, 177, 52, 172, 172, 172, 172, 52, 496 175, 177, 177, 177, 172, 172, 172, 172, 175, 177, 497 120, 177, 172, 172, 172, 172, 175, 177, 177, 172, 498 172, 172, 172, 175, 77, 105, 53, 172, 80, 172, 499 500 53, 79, 172, 172, 81, 0 501 } ; 502 503static const YY_CHAR yy_ec[256] = 504 { 0, 505 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 506 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 507 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 508 1, 2, 4, 5, 6, 7, 8, 9, 1, 10, 509 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 510 19, 19, 19, 19, 19, 19, 19, 21, 22, 23, 511 24, 25, 26, 1, 27, 28, 29, 30, 31, 32, 512 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 513 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 514 53, 54, 55, 56, 57, 1, 58, 59, 60, 61, 515 516 62, 63, 64, 65, 66, 16, 67, 68, 69, 70, 517 71, 72, 16, 73, 74, 75, 76, 16, 16, 77, 518 16, 16, 78, 79, 80, 81, 1, 1, 1, 1, 519 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 520 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 521 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 522 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 523 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 524 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 525 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 526 527 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 528 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 529 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 530 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 531 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 532 1, 1, 1, 1, 1 533 } ; 534 535static const YY_CHAR yy_meta[82] = 536 { 0, 537 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 538 1, 3, 5, 6, 7, 8, 9, 10, 10, 10, 539 7, 1, 1, 6, 1, 3, 11, 11, 11, 11, 540 11, 11, 8, 8, 8, 8, 8, 8, 8, 8, 541 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 542 8, 8, 7, 4, 7, 3, 8, 11, 11, 11, 543 11, 11, 11, 8, 8, 8, 8, 8, 8, 8, 544 8, 8, 8, 8, 8, 8, 8, 1, 1, 1, 545 9 546 } ; 547 548static const flex_int16_t yy_base[1231] = 549 { 0, 550 0, 0, 0, 0, 81, 161, 241, 0, 322, 0, 551 403, 0, 111, 113, 484, 565, 646, 727, 2118, 2119, 552 2119, 2115, 2119, 2119, 2111, 0, 791, 2091, 2119, 2119, 553 2090, 2089, 2119, 2088, 0, 85, 654, 735, 2119, 2119, 554 2088, 2119, 2085, 93, 89, 2068, 91, 92, 88, 2064, 555 105, 2067, 114, 119, 110, 109, 114, 2075, 159, 2078, 556 2073, 2041, 2029, 2119, 2077, 2119, 0, 2098, 2094, 0, 557 2119, 2119, 2119, 2030, 2085, 0, 2051, 2119, 2093, 2070, 558 2088, 0, 837, 2119, 168, 2119, 2119, 2068, 2067, 2119, 559 2066, 0, 183, 883, 143, 2119, 2119, 87, 2065, 172, 560 561 2119, 943, 191, 483, 487, 506, 2053, 2047, 167, 176, 562 168, 183, 2042, 2054, 488, 2033, 2119, 123, 2119, 2119, 563 2119, 2059, 2079, 1003, 2119, 191, 2057, 0, 2056, 0, 564 450, 0, 201, 2055, 208, 2119, 1049, 515, 520, 184, 565 564, 518, 2038, 193, 2050, 2032, 2028, 485, 2030, 2119, 566 2119, 565, 567, 569, 612, 484, 164, 2015, 1999, 1995, 567 519, 1997, 517, 0, 0, 2045, 2044, 2043, 2042, 2041, 568 0, 2039, 504, 2012, 516, 2012, 2026, 2025, 2019, 2027, 569 2016, 2012, 2008, 565, 0, 0, 2042, 2119, 0, 2119, 570 2119, 2119, 2032, 91, 67, 540, 2119, 2119, 2050, 2046, 571 572 2119, 0, 0, 1109, 2119, 2119, 2119, 2119, 2119, 0, 573 745, 2119, 0, 2026, 2025, 2003, 2017, 2000, 2010, 1999, 574 0, 2011, 2002, 2000, 2000, 1993, 2006, 1991, 1990, 1994, 575 1990, 1992, 2002, 1993, 581, 1973, 1989, 493, 559, 1989, 576 1987, 1976, 584, 1987, 1989, 1977, 1991, 1991, 1979, 1986, 577 602, 1966, 1986, 1989, 1987, 1969, 1969, 1968, 1941, 1946, 578 2119, 0, 0, 1952, 2119, 0, 1161, 2119, 2119, 1973, 579 495, 748, 0, 2119, 0, 1983, 2119, 2119, 2119, 1982, 580 649, 660, 671, 0, 1970, 1959, 0, 731, 1963, 1961, 581 558, 796, 799, 1970, 1970, 607, 1959, 595, 1948, 1957, 582 583 1946, 603, 1957, 1959, 1962, 1951, 1964, 1957, 1937, 1957, 584 1959, 1944, 2119, 1982, 2119, 0, 1213, 0, 0, 0, 585 647, 658, 664, 0, 1949, 743, 745, 1948, 1952, 1935, 586 1936, 1950, 1933, 1950, 1937, 1945, 1946, 1944, 1945, 1924, 587 669, 1904, 684, 742, 1903, 1907, 1892, 1893, 1891, 1906, 588 1894, 1901, 1902, 1900, 1901, 1882, 0, 0, 0, 0, 589 0, 1912, 0, 1910, 1915, 1923, 1924, 1914, 1921, 588, 590 1919, 1909, 1907, 1920, 1905, 1901, 1897, 0, 1922, 1921, 591 640, 591, 616, 0, 644, 2119, 2119, 1900, 1896, 1908, 592 1905, 1906, 1895, 1905, 1905, 1888, 1905, 1896, 1886, 1898, 593 594 1901, 1898, 1879, 1895, 0, 1886, 1888, 1875, 1890, 1888, 595 1886, 1888, 1897, 0, 0, 1875, 0, 1869, 1870, 1875, 596 1861, 1878, 1868, 1865, 1864, 1859, 1871, 1861, 1858, 1864, 597 1871, 1872, 1856, 1872, 1860, 1864, 1851, 0, 0, 0, 598 0, 1855, 0, 1849, 1852, 802, 1859, 1860, 1860, 1860, 599 1843, 1836, 1859, 842, 1856, 1854, 1845, 1841, 1848, 1850, 600 1859, 0, 0, 1832, 1833, 1835, 1824, 1841, 1829, 1824, 601 1841, 1831, 1838, 1839, 1840, 1835, 0, 1824, 651, 1833, 602 1832, 1820, 0, 1830, 1821, 1821, 1812, 1827, 1825, 1824, 603 1816, 1807, 1808, 1811, 1779, 698, 1787, 1786, 1775, 0, 604 605 1784, 1776, 1769, 1782, 1780, 1779, 1772, 1764, 1765, 1767, 606 1805, 1804, 1789, 1806, 1794, 1793, 1800, 1791, 1772, 1766, 607 1764, 1738, 1734, 1717, 1714, 1728, 698, 621, 699, 1697, 608 0, 1680, 1677, 1655, 1654, 0, 1660, 1648, 1634, 1650, 609 1638, 1626, 1553, 1567, 1555, 1565, 1548, 1566, 1547, 1548, 610 1560, 1544, 1562, 1559, 1543, 0, 1545, 1544, 1527, 1548, 611 1535, 1543, 1535, 1544, 1536, 1547, 1540, 1543, 1532, 1537, 612 1525, 1532, 1534, 1537, 1532, 1535, 1536, 1526, 0, 1523, 613 1518, 0, 1524, 1514, 0, 1502, 1518, 1511, 1525, 1508, 614 0, 1508, 1526, 1523, 0, 1510, 1523, 1492, 1508, 1504, 615 616 1506, 1499, 1508, 1497, 1502, 1497, 0, 1491, 1480, 1479, 617 0, 0, 0, 1474, 1490, 1469, 1282, 0, 0, 1471, 618 1479, 0, 1467, 1483, 1443, 1436, 1439, 0, 0, 0, 619 1435, 1449, 1362, 0, 0, 1433, 1439, 0, 1429, 1443, 620 1458, 0, 1455, 1454, 1452, 0, 1466, 1449, 1449, 0, 621 0, 1459, 0, 1447, 1435, 1461, 131, 721, 632, 1443, 622 0, 677, 1443, 1457, 0, 1460, 1441, 1454, 0, 1444, 623 0, 1426, 0, 1442, 1451, 1445, 0, 1433, 1451, 1443, 624 1446, 1444, 1423, 1428, 1445, 1436, 1430, 1423, 1436, 0, 625 1432, 1421, 1426, 1418, 1418, 1425, 1428, 1402, 1410, 1411, 626 627 1392, 1396, 1405, 1408, 1387, 737, 1387, 0, 1405, 1386, 628 1399, 0, 1389, 1398, 1393, 1396, 1394, 1379, 1393, 1387, 629 1381, 1393, 1389, 1377, 1376, 1383, 1387, 1378, 1365, 0, 630 1372, 1370, 1363, 1378, 0, 1442, 0, 1378, 0, 1379, 631 1329, 0, 1335, 1333, 1327, 0, 1522, 0, 1341, 0, 632 1342, 1353, 1354, 1366, 1366, 1355, 1364, 1336, 1362, 0, 633 773, 0, 765, 771, 1370, 1344, 1357, 1334, 0, 0, 634 1342, 1350, 1350, 0, 764, 0, 1348, 1332, 0, 1331, 635 0, 1345, 1334, 0, 1320, 1313, 1326, 0, 1300, 1305, 636 1324, 1297, 1296, 1312, 1305, 1293, 95, 176, 205, 0, 637 638 0, 451, 608, 614, 693, 743, 747, 0, 759, 769, 639 773, 0, 797, 0, 803, 801, 793, 0, 811, 0, 640 807, 828, 822, 815, 805, 825, 838, 827, 833, 0, 641 0, 844, 0, 830, 803, 808, 0, 0, 0, 806, 642 0, 835, 826, 853, 0, 854, 841, 858, 839, 850, 643 871, 872, 863, 0, 869, 859, 873, 0, 866, 864, 644 0, 852, 869, 874, 881, 877, 0, 866, 898, 0, 645 869, 900, 898, 884, 874, 898, 0, 0, 894, 0, 646 904, 906, 906, 0, 903, 893, 907, 0, 0, 903, 647 911, 907, 896, 0, 898, 905, 900, 924, 0, 919, 648 649 933, 935, 0, 935, 905, 907, 907, 947, 937, 922, 650 0, 949, 925, 926, 945, 0, 940, 0, 948, 951, 651 950, 963, 950, 0, 0, 964, 952, 953, 957, 965, 652 962, 972, 0, 964, 979, 0, 981, 995, 0, 967, 653 0, 976, 0, 0, 985, 973, 984, 0, 974, 993, 654 0, 0, 0, 0, 0, 0, 0, 979, 998, 995, 655 999, 995, 1009, 1006, 1004, 1008, 1001, 994, 1001, 1012, 656 1013, 1005, 1018, 1004, 1015, 1016, 1008, 1007, 1028, 0, 657 2119, 1022, 1026, 1026, 1033, 1024, 1014, 1043, 1030, 1036, 658 1038, 1029, 1049, 1047, 1046, 1061, 0, 1032, 1051, 1051, 659 660 1051, 1055, 0, 1050, 0, 0, 1062, 1058, 1068, 1073, 661 0, 1074, 1072, 1046, 1064, 1060, 0, 0, 1076, 1086, 662 1085, 1072, 1086, 1080, 1084, 1091, 1087, 1088, 1085, 1090, 663 1084, 1091, 1075, 1094, 1077, 0, 1108, 1112, 1098, 1100, 664 1114, 1112, 1103, 1093, 1121, 1108, 1122, 1109, 1126, 1125, 665 1116, 1128, 1126, 1114, 1130, 1122, 1106, 1107, 1138, 1125, 666 1127, 1128, 1144, 0, 1131, 1138, 1143, 1127, 1139, 1155, 667 1141, 1150, 0, 1149, 0, 1156, 1166, 1159, 1144, 0, 668 1160, 1181, 1176, 1166, 1165, 1165, 0, 1167, 0, 1164, 669 1168, 1207, 1170, 1173, 0, 1169, 1158, 1159, 1177, 1179, 670 671 1184, 1180, 1191, 1195, 1205, 1199, 1201, 1189, 0, 0, 672 0, 1200, 1210, 1209, 1222, 0, 0, 0, 1209, 1223, 673 0, 1225, 1213, 1212, 1224, 1230, 1223, 1224, 1222, 1237, 674 1219, 1231, 1237, 1230, 1218, 1232, 1237, 1243, 0, 1246, 675 0, 1237, 1244, 1260, 1257, 0, 1264, 0, 1254, 1260, 676 1273, 1255, 1261, 1263, 1268, 1281, 1284, 1274, 1273, 1273, 677 1287, 1283, 0, 1273, 0, 1261, 1292, 1274, 1280, 0, 678 1265, 1282, 1279, 1290, 1295, 1281, 1293, 1300, 1299, 1293, 679 0, 1286, 1293, 1299, 1294, 1309, 1297, 1294, 1289, 1311, 680 1301, 1303, 1298, 1315, 0, 0, 0, 1306, 0, 1312, 681 682 0, 0, 1307, 1309, 0, 2119, 1602, 1613, 1624, 1635, 683 1646, 1657, 1668, 1676, 1684, 1692, 1703, 1711, 1722, 1733, 684 1742, 1746, 1755, 1757, 1765, 1773, 1784, 1795, 1806, 1817 685 } ; 686 687static const flex_int16_t yy_def[1231] = 688 { 0, 689 1207, 1207, 1206, 3, 1208, 1208, 1206, 7, 1206, 9, 690 1206, 11, 1209, 1209, 1210, 1210, 1211, 1211, 1206, 1206, 691 1206, 1206, 1206, 1206, 1212, 1213, 1214, 1206, 1206, 1206, 692 1206, 1206, 1206, 1206, 1214, 1214, 1206, 1206, 1206, 1206, 693 1206, 1206, 1206, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 694 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 695 1214, 1214, 1214, 1206, 1206, 1206, 1214, 1206, 1212, 1214, 696 1206, 1206, 1206, 1206, 1214, 1215, 1214, 1206, 1206, 1206, 697 1212, 1213, 1216, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 698 1206, 1216, 1206, 1206, 94, 1206, 1206, 1206, 1206, 1206, 699 700 1206, 1216, 102, 102, 102, 102, 1216, 1216, 1216, 1216, 701 1216, 1216, 1216, 1216, 1216, 1216, 1206, 1206, 1206, 1206, 702 1206, 1206, 1217, 1218, 1206, 1206, 1219, 1218, 1218, 94, 703 94, 1220, 1206, 1206, 1206, 1206, 1218, 137, 137, 137, 704 137, 137, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1206, 705 1206, 137, 137, 137, 137, 137, 1218, 1218, 1218, 1218, 706 1218, 1218, 1206, 1218, 1221, 1206, 1221, 1221, 1221, 1221, 707 1221, 1206, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 708 1221, 1221, 1221, 1221, 1221, 1221, 1206, 1206, 1222, 1206, 709 1206, 1206, 1223, 1223, 1223, 1223, 1206, 1206, 1206, 1212, 710 711 1206, 1213, 1214, 1214, 1206, 1206, 1206, 1206, 1206, 1214, 712 1206, 1206, 1224, 1206, 1206, 1214, 1214, 1214, 1214, 1214, 713 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 714 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 715 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 716 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 717 1206, 1225, 1226, 1214, 1206, 1216, 1216, 1206, 1206, 1206, 718 94, 94, 272, 1206, 1224, 1206, 1206, 1206, 1206, 1206, 719 102, 102, 102, 1216, 1216, 1216, 1216, 102, 1216, 1216, 720 1216, 102, 102, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 721 722 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 723 1216, 1216, 1206, 1217, 1206, 1218, 1218, 1219, 1219, 1220, 724 137, 137, 137, 1218, 1218, 137, 137, 1218, 1218, 1218, 725 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 726 137, 1218, 137, 137, 1218, 1218, 1218, 1218, 1218, 1218, 727 1218, 1218, 1218, 1218, 1218, 1218, 1221, 1221, 1221, 1221, 728 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 729 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1222, 1223, 1206, 730 1223, 1223, 1223, 1214, 1224, 1206, 1206, 1214, 1214, 1214, 731 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 732 733 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 734 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 735 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 736 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1225, 737 1226, 1214, 1216, 1206, 1216, 102, 1216, 1216, 1216, 1216, 738 1216, 1216, 1216, 102, 1216, 1216, 1216, 1216, 1216, 1216, 739 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 740 1216, 1216, 1216, 1216, 1216, 1216, 1218, 1218, 1218, 1218, 741 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 742 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 743 744 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 745 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 746 1221, 1221, 1221, 1221, 1221, 1221, 1223, 1223, 1223, 1214, 747 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 748 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 749 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 750 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 751 1214, 1214, 1214, 1214, 1214, 1214, 1206, 1216, 1216, 1216, 752 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 753 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 754 755 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1218, 1218, 1218, 756 1218, 1218, 1218, 1218, 1218, 1218, 1227, 1218, 1218, 1218, 757 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 758 1218, 1218, 1228, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 759 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 760 1221, 1221, 1221, 1221, 1221, 1221, 1223, 1223, 1223, 1214, 761 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 762 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 763 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 764 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 765 766 1214, 1214, 1214, 1206, 1216, 1216, 1216, 1216, 1216, 1216, 767 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 768 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1218, 1218, 769 1218, 1218, 1218, 1218, 1229, 1227, 1218, 1218, 1218, 1218, 770 1218, 1218, 1218, 1218, 1218, 1230, 1228, 1218, 1218, 1218, 771 1218, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 772 1221, 1221, 1223, 1223, 1223, 1214, 1214, 1214, 1214, 1214, 773 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 774 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 775 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 776 777 1214, 1214, 1214, 1206, 1216, 1216, 1216, 1216, 1216, 1216, 778 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 779 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1218, 1218, 1218, 780 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 781 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 782 1223, 1223, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 783 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 784 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 785 1214, 1206, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 786 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 787 788 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1221, 1221, 1221, 789 1221, 1221, 1221, 1221, 1221, 1214, 1214, 1214, 1214, 1214, 790 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 791 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1206, 1216, 1216, 792 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 793 1216, 1218, 1218, 1218, 1218, 1218, 1218, 1221, 1221, 1221, 794 1221, 1221, 1221, 1221, 1214, 1214, 1214, 1214, 1214, 1214, 795 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 796 1206, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1221, 1221, 797 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1214, 1214, 1214, 798 799 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 800 1214, 1214, 1214, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 801 1216, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1214, 802 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 803 1214, 1216, 1216, 1216, 1216, 1216, 1216, 1221, 1221, 1221, 804 1221, 1221, 1221, 1221, 1221, 1214, 1214, 1214, 1214, 1214, 805 1214, 1214, 1214, 1214, 1214, 1214, 1216, 1216, 1216, 1216, 806 1216, 1216, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 807 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 808 1216, 1216, 1216, 1216, 1216, 1216, 1221, 1221, 1221, 1221, 809 810 1221, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 811 1214, 1216, 1216, 1216, 1216, 1216, 1216, 1216, 1221, 1221, 812 1221, 1221, 1221, 1214, 1214, 1214, 1214, 1214, 1214, 1214, 813 1216, 1216, 1216, 1216, 1221, 1221, 1221, 1221, 1214, 1214, 814 1214, 1214, 1214, 1214, 1214, 1216, 1216, 1216, 1216, 1221, 815 1221, 1221, 1221, 1214, 1214, 1214, 1214, 1214, 1216, 1216, 816 1221, 1221, 1221, 1221, 1214, 1214, 1214, 1214, 1214, 1216, 817 1216, 1221, 1221, 1221, 1214, 1214, 1214, 1214, 1216, 1221, 818 1221, 1221, 1214, 1214, 1214, 1214, 1216, 1221, 1221, 1214, 819 1214, 1214, 1214, 1216, 1221, 1221, 1214, 1214, 1214, 1214, 820 821 1216, 1214, 1214, 1214, 1214, 0, 1206, 1206, 1206, 1206, 822 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 823 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206 824 } ; 825 826static const flex_int16_t yy_nxt[2201] = 827 { 0, 828 21, 22, 23, 24, 25, 26, 27, 21, 28, 29, 829 30, 31, 32, 33, 34, 35, 36, 37, 38, 38, 830 39, 40, 41, 42, 43, 21, 44, 45, 46, 47, 831 48, 49, 50, 51, 52, 35, 35, 53, 54, 55, 832 56, 57, 35, 58, 59, 60, 35, 61, 35, 35, 833 35, 35, 21, 35, 21, 21, 35, 35, 35, 35, 834 35, 35, 35, 35, 35, 35, 35, 62, 35, 35, 835 63, 35, 35, 35, 35, 35, 35, 64, 65, 66, 836 67, 20, 68, 23, 20, 69, 20, 380, 20, 20, 837 71, 72, 20, 20, 73, 74, 209, 75, 20, 20, 838 839 20, 20, 20, 20, 76, 20, 20, 77, 210, 276, 840 277, 380, 22, 23, 22, 23, 26, 226, 26, 222, 841 216, 227, 217, 223, 218, 230, 224, 187, 231, 187, 842 219, 228, 877, 20, 382, 20, 20, 220, 221, 233, 843 242, 229, 234, 236, 237, 239, 261, 248, 244, 240, 844 243, 380, 245, 241, 238, 246, 247, 249, 20, 20, 845 20, 20, 68, 23, 20, 69, 20, 381, 20, 20, 846 71, 72, 20, 20, 73, 74, 268, 75, 20, 20, 847 20, 20, 20, 20, 76, 20, 20, 77, 188, 251, 848 188, 205, 274, 252, 209, 279, 280, 297, 301, 268, 849 850 253, 313, 299, 763, 254, 255, 269, 298, 302, 256, 851 300, 323, 270, 20, 205, 20, 20, 878, 288, 274, 852 288, 316, 303, 276, 277, 289, 304, 333, 290, 349, 853 305, 279, 280, 334, 350, 266, 266, 879, 20, 20, 854 20, 78, 79, 23, 80, 81, 82, 83, 84, 85, 855 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 856 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 857 105, 106, 106, 92, 107, 108, 92, 92, 109, 110, 858 111, 112, 113, 92, 114, 115, 116, 92, 92, 92, 859 92, 92, 92, 78, 92, 78, 78, 92, 106, 106, 860 861 106, 106, 106, 106, 92, 92, 92, 92, 92, 92, 862 92, 92, 92, 92, 92, 92, 92, 92, 117, 118, 863 119, 120, 21, 22, 121, 122, 21, 123, 124, 125, 864 126, 29, 30, 127, 32, 33, 34, 128, 129, 130, 865 131, 131, 39, 132, 133, 134, 135, 136, 137, 138, 866 139, 140, 141, 142, 128, 128, 143, 128, 128, 144, 867 128, 145, 146, 147, 128, 128, 148, 149, 128, 128, 868 128, 128, 128, 128, 150, 128, 151, 21, 128, 152, 869 153, 154, 140, 155, 156, 128, 128, 128, 128, 157, 870 128, 158, 159, 160, 128, 161, 162, 128, 128, 64, 871 872 163, 66, 164, 21, 22, 23, 165, 25, 26, 165, 873 21, 166, 29, 30, 167, 168, 165, 169, 165, 170, 874 165, 165, 165, 165, 40, 41, 171, 172, 165, 173, 875 174, 175, 165, 176, 177, 165, 178, 179, 165, 180, 876 181, 165, 165, 165, 182, 183, 165, 184, 165, 165, 877 165, 165, 165, 165, 165, 185, 165, 186, 165, 165, 878 165, 165, 165, 165, 165, 165, 165, 165, 165, 165, 879 165, 165, 165, 165, 165, 165, 165, 165, 165, 165, 880 64, 65, 66, 165, 21, 22, 23, 21, 21, 26, 881 880, 21, 21, 21, 21, 21, 21, 190, 21, 274, 882 883 187, 21, 21, 21, 190, 190, 21, 21, 21, 21, 884 288, 323, 288, 292, 288, 338, 288, 293, 308, 412, 885 266, 316, 309, 291, 266, 413, 274, 266, 266, 310, 886 339, 294, 266, 288, 311, 288, 21, 21, 21, 21, 887 261, 326, 323, 266, 274, 323, 327, 323, 362, 363, 888 266, 266, 316, 328, 348, 316, 365, 316, 331, 366, 889 380, 191, 21, 192, 21, 21, 22, 23, 21, 21, 890 26, 274, 21, 21, 21, 21, 21, 21, 190, 21, 891 354, 187, 21, 21, 21, 190, 190, 21, 21, 21, 892 21, 323, 323, 355, 323, 313, 323, 451, 375, 452, 893 894 414, 316, 316, 329, 316, 376, 316, 377, 415, 406, 895 383, 380, 419, 330, 407, 420, 518, 21, 21, 21, 896 21, 460, 408, 341, 343, 409, 344, 461, 428, 519, 897 429, 465, 342, 345, 430, 457, 380, 881, 458, 323, 898 466, 380, 191, 21, 192, 21, 21, 22, 23, 316, 899 25, 26, 380, 21, 21, 21, 21, 882, 21, 190, 900 380, 528, 187, 21, 21, 21, 190, 190, 21, 21, 901 21, 211, 211, 211, 323, 529, 288, 609, 288, 658, 902 212, 346, 212, 610, 316, 323, 266, 288, 347, 288, 903 212, 323, 212, 266, 266, 316, 323, 266, 288, 765, 904 905 446, 316, 478, 213, 445, 266, 316, 194, 266, 195, 906 212, 323, 212, 196, 527, 266, 266, 767, 380, 380, 907 212, 316, 212, 197, 21, 198, 21, 21, 22, 23, 908 213, 25, 26, 768, 21, 21, 21, 21, 883, 21, 909 190, 380, 495, 187, 21, 21, 21, 190, 190, 21, 910 21, 21, 211, 211, 211, 626, 659, 497, 288, 657, 911 288, 627, 211, 211, 211, 272, 272, 272, 266, 323, 912 323, 212, 323, 212, 884, 266, 266, 806, 764, 316, 913 316, 212, 316, 212, 1206, 380, 1206, 480, 194, 481, 914 195, 380, 859, 807, 196, 885, 860, 274, 886, 887, 915 916 849, 212, 888, 212, 197, 21, 198, 21, 204, 204, 917 204, 212, 850, 212, 1206, 498, 1206, 204, 204, 204, 918 204, 204, 204, 288, 274, 288, 288, 889, 288, 288, 919 454, 288, 890, 266, 851, 891, 266, 892, 852, 266, 920 266, 453, 893, 266, 266, 579, 266, 266, 204, 204, 921 204, 204, 204, 204, 267, 267, 267, 894, 895, 896, 922 897, 898, 899, 267, 267, 267, 267, 267, 267, 288, 923 900, 288, 901, 902, 903, 904, 587, 905, 906, 266, 924 907, 908, 909, 910, 911, 912, 266, 266, 913, 914, 925 915, 380, 380, 916, 267, 267, 267, 267, 267, 267, 926 927 271, 271, 271, 917, 918, 919, 920, 921, 922, 272, 928 273, 272, 273, 272, 272, 923, 274, 924, 925, 212, 929 926, 212, 927, 274, 928, 930, 931, 932, 933, 929, 930 934, 935, 275, 936, 937, 938, 939, 940, 941, 942, 931 272, 273, 272, 273, 272, 272, 943, 274, 944, 212, 932 945, 212, 946, 274, 947, 948, 949, 950, 951, 275, 933 281, 281, 281, 952, 953, 954, 955, 956, 957, 281, 934 282, 281, 283, 281, 281, 958, 284, 959, 960, 961, 935 285, 962, 963, 284, 964, 965, 966, 286, 287, 967, 936 968, 969, 284, 970, 971, 972, 973, 974, 975, 976, 937 938 281, 288, 281, 288, 281, 281, 977, 284, 978, 979, 939 980, 981, 982, 284, 983, 984, 985, 986, 987, 284, 940 317, 317, 317, 988, 989, 990, 991, 992, 993, 317, 941 317, 317, 317, 317, 317, 994, 997, 998, 999, 1000, 942 1001, 1002, 1003, 995, 1004, 1005, 1007, 1008, 996, 1009, 943 1010, 1011, 1012, 1006, 1013, 1014, 1015, 1016, 1019, 1020, 944 317, 317, 317, 317, 317, 317, 321, 321, 321, 1021, 945 1022, 1023, 1024, 1017, 1025, 321, 322, 321, 323, 321, 946 321, 1018, 324, 1026, 1027, 1028, 325, 1029, 1030, 324, 947 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 324, 1039, 948 949 1040, 1041, 1042, 1043, 1044, 1045, 321, 323, 321, 323, 950 321, 321, 1046, 324, 1047, 1048, 1049, 1050, 1051, 324, 951 1052, 1053, 1054, 1055, 1056, 324, 204, 204, 204, 1057, 952 1058, 1059, 1060, 1061, 1062, 204, 204, 204, 204, 204, 953 204, 1063, 1064, 1065, 1066, 384, 1067, 384, 1068, 1069, 954 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 955 1080, 1081, 1082, 1083, 1084, 1085, 204, 204, 204, 204, 956 204, 204, 1086, 1087, 1088, 384, 1089, 384, 267, 267, 957 267, 1090, 1091, 1092, 1093, 1094, 1095, 267, 267, 267, 958 267, 267, 267, 1096, 1097, 1098, 1099, 443, 1100, 443, 959 960 1101, 1102, 1106, 1107, 1108, 1109, 1110, 1103, 1111, 1112, 961 1116, 1104, 1117, 1118, 1119, 1120, 1121, 1122, 267, 267, 962 267, 267, 267, 267, 1105, 1123, 1124, 443, 1125, 443, 963 317, 317, 317, 1113, 1126, 1127, 1128, 1114, 1129, 317, 964 317, 317, 317, 317, 317, 1130, 1131, 1132, 1133, 477, 965 1115, 477, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 966 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 967 317, 317, 317, 317, 317, 317, 1152, 1153, 1154, 477, 968 1155, 477, 735, 735, 1156, 735, 735, 735, 1157, 735, 969 735, 735, 735, 735, 1158, 735, 1159, 1160, 1161, 1162, 970 971 1163, 1164, 1165, 735, 735, 735, 735, 735, 1166, 1167, 972 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, 973 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 974 1188, 1189, 1190, 1191, 1192, 1193, 1194, 735, 1195, 1196, 975 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 876, 976 875, 874, 873, 872, 871, 870, 869, 868, 867, 735, 977 735, 735, 746, 746, 866, 746, 746, 746, 865, 746, 978 746, 746, 746, 746, 864, 746, 863, 862, 861, 858, 979 857, 856, 855, 746, 746, 746, 746, 746, 854, 853, 980 380, 848, 847, 846, 845, 844, 843, 842, 841, 840, 981 982 839, 838, 837, 836, 835, 834, 833, 832, 831, 830, 983 829, 828, 827, 826, 825, 824, 823, 746, 822, 821, 984 820, 819, 818, 817, 816, 815, 814, 813, 812, 811, 985 810, 809, 808, 805, 804, 803, 802, 801, 800, 746, 986 746, 746, 735, 735, 799, 735, 735, 735, 798, 735, 987 735, 735, 735, 735, 797, 735, 796, 795, 794, 793, 988 792, 791, 790, 735, 735, 735, 735, 735, 789, 788, 989 787, 786, 785, 784, 783, 782, 781, 780, 779, 778, 990 777, 776, 775, 774, 773, 772, 771, 770, 769, 766, 991 762, 761, 760, 759, 758, 757, 756, 735, 755, 754, 992 993 753, 752, 751, 750, 749, 748, 745, 744, 743, 742, 994 741, 740, 739, 738, 737, 734, 733, 732, 731, 735, 995 735, 735, 746, 746, 730, 746, 746, 746, 729, 746, 996 746, 746, 746, 746, 728, 746, 727, 726, 725, 724, 997 723, 722, 721, 746, 746, 746, 746, 746, 720, 719, 998 718, 717, 716, 715, 714, 713, 712, 711, 710, 709, 999 708, 707, 706, 705, 704, 703, 702, 701, 700, 699, 1000 698, 697, 696, 695, 694, 693, 692, 746, 691, 690, 1001 689, 688, 687, 686, 685, 684, 683, 682, 681, 680, 1002 679, 678, 677, 676, 675, 674, 673, 672, 671, 746, 1003 1004 746, 746, 20, 20, 20, 20, 20, 20, 20, 20, 1005 20, 20, 20, 70, 70, 70, 70, 70, 70, 70, 1006 70, 70, 70, 70, 21, 21, 21, 21, 21, 21, 1007 21, 21, 21, 21, 21, 189, 189, 189, 189, 189, 1008 189, 189, 189, 189, 189, 189, 193, 193, 193, 193, 1009 193, 193, 193, 193, 193, 193, 193, 200, 200, 200, 1010 200, 200, 200, 200, 200, 200, 200, 200, 202, 670, 1011 202, 202, 202, 202, 202, 202, 202, 202, 202, 203, 1012 203, 203, 203, 203, 203, 203, 203, 263, 669, 668, 1013 667, 263, 263, 666, 263, 266, 665, 664, 663, 266, 1014 1015 266, 266, 266, 314, 314, 314, 314, 314, 314, 314, 1016 314, 314, 314, 314, 316, 316, 662, 316, 316, 316, 1017 316, 316, 318, 661, 318, 318, 318, 318, 318, 318, 1018 318, 318, 318, 320, 660, 320, 320, 320, 320, 320, 1019 320, 320, 320, 320, 357, 357, 357, 357, 357, 357, 1020 357, 357, 357, 378, 656, 378, 378, 379, 379, 655, 1021 654, 379, 379, 653, 379, 379, 385, 385, 440, 440, 1022 440, 440, 440, 440, 440, 440, 441, 441, 441, 441, 1023 441, 441, 441, 441, 736, 652, 736, 736, 736, 736, 1024 736, 736, 736, 736, 736, 747, 651, 747, 747, 747, 1025 1026 747, 747, 747, 747, 747, 747, 735, 650, 735, 735, 1027 735, 735, 735, 735, 735, 735, 735, 746, 649, 746, 1028 746, 746, 746, 746, 746, 746, 746, 746, 648, 647, 1029 646, 645, 644, 643, 642, 641, 640, 639, 638, 637, 1030 636, 635, 634, 633, 632, 631, 630, 629, 628, 625, 1031 624, 623, 622, 621, 620, 619, 618, 617, 616, 615, 1032 614, 613, 612, 611, 608, 607, 606, 605, 604, 603, 1033 602, 601, 600, 599, 598, 597, 596, 595, 594, 593, 1034 592, 591, 590, 589, 588, 586, 585, 584, 583, 582, 1035 581, 580, 578, 577, 576, 575, 574, 573, 572, 571, 1036 1037 570, 569, 568, 567, 566, 565, 564, 563, 562, 561, 1038 560, 559, 558, 557, 556, 555, 554, 553, 552, 551, 1039 550, 549, 548, 547, 546, 545, 544, 543, 542, 541, 1040 540, 539, 538, 537, 536, 535, 534, 533, 532, 531, 1041 530, 379, 380, 526, 525, 524, 523, 522, 521, 520, 1042 517, 516, 515, 514, 513, 512, 511, 510, 509, 508, 1043 507, 506, 505, 504, 503, 502, 501, 500, 499, 496, 1044 494, 493, 492, 491, 490, 489, 488, 487, 486, 485, 1045 484, 483, 482, 479, 315, 476, 475, 474, 473, 472, 1046 471, 470, 469, 468, 467, 464, 463, 462, 459, 456, 1047 1048 455, 450, 449, 448, 447, 387, 386, 444, 442, 439, 1049 438, 437, 436, 435, 434, 433, 432, 431, 427, 426, 1050 425, 424, 423, 422, 421, 418, 417, 416, 411, 410, 1051 405, 404, 403, 402, 401, 400, 399, 398, 397, 396, 1052 395, 394, 393, 392, 391, 390, 389, 388, 387, 386, 1053 201, 199, 380, 209, 374, 373, 372, 371, 370, 369, 1054 368, 367, 364, 215, 361, 360, 359, 358, 205, 356, 1055 353, 352, 351, 340, 337, 336, 335, 332, 278, 269, 1056 319, 315, 265, 312, 307, 306, 296, 295, 278, 208, 1057 207, 206, 201, 265, 199, 264, 209, 262, 201, 199, 1058 1059 261, 260, 259, 258, 257, 250, 235, 232, 225, 215, 1060 214, 208, 207, 206, 205, 201, 199, 1206, 19, 1206, 1061 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1062 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1063 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1064 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1065 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1066 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1067 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1068 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206 1069 1070 } ; 1071 1072static const flex_int16_t yy_chk[2201] = 1073 { 0, 1074 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1075 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1076 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1077 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1078 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1079 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1080 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1081 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1082 3, 5, 5, 5, 5, 5, 5, 195, 5, 5, 1083 5, 5, 5, 5, 5, 5, 36, 5, 5, 5, 1084 1085 5, 5, 5, 5, 5, 5, 5, 5, 36, 98, 1086 98, 194, 13, 13, 14, 14, 13, 47, 14, 45, 1087 44, 47, 44, 45, 44, 49, 45, 13, 49, 14, 1088 44, 48, 797, 5, 195, 5, 5, 44, 44, 51, 1089 55, 48, 51, 53, 53, 54, 118, 57, 56, 54, 1090 55, 657, 56, 54, 53, 56, 56, 57, 5, 5, 1091 5, 6, 6, 6, 6, 6, 6, 194, 6, 6, 1092 6, 6, 6, 6, 6, 6, 85, 6, 6, 6, 1093 6, 6, 6, 6, 6, 6, 6, 6, 13, 59, 1094 14, 85, 95, 59, 93, 100, 100, 109, 111, 126, 1095 1096 59, 118, 110, 657, 59, 59, 93, 109, 111, 59, 1097 110, 140, 93, 6, 126, 6, 6, 798, 103, 95, 1098 103, 140, 112, 133, 133, 103, 112, 144, 103, 157, 1099 112, 135, 135, 144, 157, 103, 103, 799, 6, 6, 1100 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 1101 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 1102 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 1103 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 1104 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 1105 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 1106 1107 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 1108 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 1109 7, 7, 9, 9, 9, 9, 9, 9, 9, 9, 1110 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1111 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1112 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1113 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1114 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1115 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1116 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1117 1118 9, 9, 9, 11, 11, 11, 11, 11, 11, 11, 1119 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 1120 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 1121 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 1122 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 1123 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 1124 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 1125 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 1126 11, 11, 11, 11, 15, 15, 15, 15, 15, 15, 1127 802, 15, 15, 15, 15, 15, 15, 15, 15, 131, 1128 1129 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 1130 104, 156, 104, 105, 105, 148, 105, 105, 115, 238, 1131 104, 156, 115, 104, 105, 238, 131, 104, 104, 115, 1132 148, 105, 105, 106, 115, 106, 15, 15, 15, 15, 1133 163, 138, 138, 106, 271, 142, 139, 139, 173, 173, 1134 106, 106, 138, 139, 156, 142, 175, 139, 142, 175, 1135 196, 15, 15, 15, 15, 16, 16, 16, 16, 16, 1136 16, 271, 16, 16, 16, 16, 16, 16, 16, 16, 1137 161, 16, 16, 16, 16, 16, 16, 16, 16, 16, 1138 16, 141, 152, 161, 153, 163, 154, 291, 184, 291, 1139 1140 239, 141, 152, 141, 153, 184, 154, 184, 239, 235, 1141 196, 382, 243, 141, 235, 243, 370, 16, 16, 16, 1142 16, 298, 235, 152, 153, 235, 154, 298, 251, 370, 1143 251, 302, 152, 154, 251, 296, 383, 803, 296, 155, 1144 302, 528, 16, 16, 16, 16, 17, 17, 17, 155, 1145 17, 17, 659, 17, 17, 17, 17, 804, 17, 17, 1146 381, 382, 17, 17, 17, 17, 17, 17, 17, 17, 1147 17, 37, 37, 37, 321, 383, 281, 479, 281, 528, 1148 385, 155, 385, 479, 321, 322, 281, 282, 155, 282, 1149 37, 323, 37, 281, 281, 322, 341, 282, 283, 659, 1150 1151 283, 323, 322, 37, 282, 282, 341, 17, 283, 17, 1152 385, 343, 385, 17, 381, 283, 283, 662, 527, 529, 1153 37, 343, 37, 17, 17, 17, 17, 18, 18, 18, 1154 37, 18, 18, 662, 18, 18, 18, 18, 805, 18, 1155 18, 658, 341, 18, 18, 18, 18, 18, 18, 18, 1156 18, 18, 38, 38, 38, 496, 529, 343, 288, 527, 1157 288, 496, 211, 211, 211, 272, 272, 272, 288, 344, 1158 326, 38, 327, 38, 806, 288, 288, 706, 658, 344, 1159 326, 211, 327, 211, 272, 763, 272, 326, 18, 327, 1160 18, 764, 775, 706, 18, 807, 775, 272, 809, 810, 1161 1162 761, 38, 811, 38, 18, 18, 18, 18, 27, 27, 1163 27, 211, 761, 211, 272, 344, 272, 27, 27, 27, 1164 27, 27, 27, 292, 272, 292, 293, 813, 293, 446, 1165 293, 446, 815, 292, 763, 816, 293, 817, 764, 446, 1166 292, 292, 819, 293, 293, 446, 446, 446, 27, 27, 1167 27, 27, 27, 27, 83, 83, 83, 821, 822, 823, 1168 824, 825, 826, 83, 83, 83, 83, 83, 83, 454, 1169 827, 454, 828, 829, 832, 834, 454, 835, 836, 454, 1170 840, 842, 843, 844, 846, 847, 454, 454, 848, 849, 1171 850, 851, 852, 853, 83, 83, 83, 83, 83, 83, 1172 1173 94, 94, 94, 855, 856, 857, 859, 860, 862, 94, 1174 94, 94, 94, 94, 94, 863, 94, 864, 865, 94, 1175 866, 94, 868, 94, 869, 871, 872, 873, 874, 869, 1176 875, 876, 94, 879, 881, 882, 883, 885, 886, 887, 1177 94, 94, 94, 94, 94, 94, 890, 94, 891, 94, 1178 892, 94, 893, 94, 895, 896, 897, 898, 900, 94, 1179 102, 102, 102, 901, 902, 904, 905, 906, 907, 102, 1180 102, 102, 102, 102, 102, 908, 102, 909, 910, 912, 1181 102, 913, 914, 102, 915, 917, 919, 102, 102, 920, 1182 921, 922, 102, 923, 926, 927, 928, 929, 930, 931, 1183 1184 102, 102, 102, 102, 102, 102, 932, 102, 934, 935, 1185 937, 938, 940, 102, 942, 945, 946, 947, 949, 102, 1186 124, 124, 124, 950, 958, 959, 960, 961, 962, 124, 1187 124, 124, 124, 124, 124, 963, 964, 965, 966, 967, 1188 968, 969, 970, 963, 971, 972, 973, 974, 963, 975, 1189 976, 977, 978, 972, 979, 982, 983, 984, 986, 987, 1190 124, 124, 124, 124, 124, 124, 137, 137, 137, 988, 1191 989, 990, 991, 985, 992, 137, 137, 137, 137, 137, 1192 137, 985, 137, 993, 994, 995, 137, 996, 998, 137, 1193 999, 1000, 1001, 1002, 1004, 1007, 1008, 1009, 137, 1010, 1194 1195 1012, 1013, 1014, 1015, 1016, 1019, 137, 137, 137, 137, 1196 137, 137, 1020, 137, 1021, 1022, 1023, 1024, 1025, 137, 1197 1026, 1027, 1028, 1029, 1030, 137, 204, 204, 204, 1031, 1198 1032, 1033, 1034, 1035, 1037, 204, 204, 204, 204, 204, 1199 204, 1038, 1039, 1040, 1041, 204, 1042, 204, 1043, 1044, 1200 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1201 1055, 1056, 1057, 1058, 1059, 1060, 204, 204, 204, 204, 1202 204, 204, 1061, 1062, 1063, 204, 1065, 204, 267, 267, 1203 267, 1066, 1067, 1068, 1069, 1070, 1071, 267, 267, 267, 1204 267, 267, 267, 1072, 1074, 1076, 1077, 267, 1078, 267, 1205 1206 1079, 1081, 1083, 1084, 1085, 1086, 1088, 1082, 1090, 1091, 1207 1093, 1082, 1094, 1096, 1097, 1098, 1099, 1100, 267, 267, 1208 267, 267, 267, 267, 1082, 1101, 1102, 267, 1103, 267, 1209 317, 317, 317, 1092, 1104, 1105, 1106, 1092, 1107, 317, 1210 317, 317, 317, 317, 317, 1108, 1112, 1113, 1114, 317, 1211 1092, 317, 1115, 1119, 1120, 1122, 1123, 1124, 1125, 1126, 1212 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1213 317, 317, 317, 317, 317, 317, 1137, 1138, 1140, 317, 1214 1142, 317, 617, 617, 1143, 617, 617, 617, 1144, 617, 1215 617, 617, 617, 617, 1145, 617, 1147, 1149, 1150, 1151, 1216 1217 1152, 1153, 1154, 617, 617, 617, 617, 617, 1155, 1156, 1218 1157, 1158, 1159, 1160, 1161, 1162, 1164, 1166, 1167, 1168, 1219 1169, 1171, 1172, 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1220 1180, 1182, 1183, 1184, 1185, 1186, 1187, 617, 1188, 1189, 1221 1190, 1191, 1192, 1193, 1194, 1198, 1200, 1203, 1204, 796, 1222 795, 794, 793, 792, 791, 790, 789, 787, 786, 617, 1223 617, 617, 633, 633, 785, 633, 633, 633, 783, 633, 1224 633, 633, 633, 633, 782, 633, 780, 778, 777, 773, 1225 772, 771, 768, 633, 633, 633, 633, 633, 767, 766, 1226 765, 759, 758, 757, 756, 755, 754, 753, 752, 751, 1227 1228 749, 745, 744, 743, 741, 740, 738, 734, 733, 732, 1229 731, 729, 728, 727, 726, 725, 724, 633, 723, 722, 1230 721, 720, 719, 718, 717, 716, 715, 714, 713, 711, 1231 710, 709, 707, 705, 704, 703, 702, 701, 700, 633, 1232 633, 633, 736, 736, 699, 736, 736, 736, 698, 736, 1233 736, 736, 736, 736, 697, 736, 696, 695, 694, 693, 1234 692, 691, 689, 736, 736, 736, 736, 736, 688, 687, 1235 686, 685, 684, 683, 682, 681, 680, 679, 678, 676, 1236 675, 674, 672, 670, 668, 667, 666, 664, 663, 660, 1237 656, 655, 654, 652, 649, 648, 647, 736, 645, 644, 1238 1239 643, 641, 640, 639, 637, 636, 632, 631, 627, 626, 1240 625, 624, 623, 621, 620, 616, 615, 614, 610, 736, 1241 736, 736, 747, 747, 609, 747, 747, 747, 608, 747, 1242 747, 747, 747, 747, 606, 747, 605, 604, 603, 602, 1243 601, 600, 599, 747, 747, 747, 747, 747, 598, 597, 1244 596, 594, 593, 592, 590, 589, 588, 587, 586, 584, 1245 583, 581, 580, 578, 577, 576, 575, 574, 573, 572, 1246 571, 570, 569, 568, 567, 566, 565, 747, 564, 563, 1247 562, 561, 560, 559, 558, 557, 555, 554, 553, 552, 1248 551, 550, 549, 548, 547, 546, 545, 544, 543, 747, 1249 1250 747, 747, 1207, 1207, 1207, 1207, 1207, 1207, 1207, 1207, 1251 1207, 1207, 1207, 1208, 1208, 1208, 1208, 1208, 1208, 1208, 1252 1208, 1208, 1208, 1208, 1209, 1209, 1209, 1209, 1209, 1209, 1253 1209, 1209, 1209, 1209, 1209, 1210, 1210, 1210, 1210, 1210, 1254 1210, 1210, 1210, 1210, 1210, 1210, 1211, 1211, 1211, 1211, 1255 1211, 1211, 1211, 1211, 1211, 1211, 1211, 1212, 1212, 1212, 1256 1212, 1212, 1212, 1212, 1212, 1212, 1212, 1212, 1213, 542, 1257 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1214, 1258 1214, 1214, 1214, 1214, 1214, 1214, 1214, 1215, 541, 540, 1259 539, 1215, 1215, 538, 1215, 1216, 537, 535, 534, 1216, 1260 1261 1216, 1216, 1216, 1217, 1217, 1217, 1217, 1217, 1217, 1217, 1262 1217, 1217, 1217, 1217, 1218, 1218, 533, 1218, 1218, 1218, 1263 1218, 1218, 1219, 532, 1219, 1219, 1219, 1219, 1219, 1219, 1264 1219, 1219, 1219, 1220, 530, 1220, 1220, 1220, 1220, 1220, 1265 1220, 1220, 1220, 1220, 1221, 1221, 1221, 1221, 1221, 1221, 1266 1221, 1221, 1221, 1222, 526, 1222, 1222, 1223, 1223, 525, 1267 524, 1223, 1223, 523, 1223, 1223, 1224, 1224, 1225, 1225, 1268 1225, 1225, 1225, 1225, 1225, 1225, 1226, 1226, 1226, 1226, 1269 1226, 1226, 1226, 1226, 1227, 522, 1227, 1227, 1227, 1227, 1270 1227, 1227, 1227, 1227, 1227, 1228, 521, 1228, 1228, 1228, 1271 1272 1228, 1228, 1228, 1228, 1228, 1228, 1229, 520, 1229, 1229, 1273 1229, 1229, 1229, 1229, 1229, 1229, 1229, 1230, 519, 1230, 1274 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 518, 517, 1275 516, 515, 514, 513, 512, 511, 510, 509, 508, 507, 1276 506, 505, 504, 503, 502, 501, 499, 498, 497, 495, 1277 494, 493, 492, 491, 490, 489, 488, 487, 486, 485, 1278 484, 482, 481, 480, 478, 476, 475, 474, 473, 472, 1279 471, 470, 469, 468, 467, 466, 465, 464, 461, 460, 1280 459, 458, 457, 456, 455, 453, 452, 451, 450, 449, 1281 448, 447, 445, 444, 442, 437, 436, 435, 434, 433, 1282 1283 432, 431, 430, 429, 428, 427, 426, 425, 424, 423, 1284 422, 421, 420, 419, 418, 416, 413, 412, 411, 410, 1285 409, 408, 407, 406, 404, 403, 402, 401, 400, 399, 1286 398, 397, 396, 395, 394, 393, 392, 391, 390, 389, 1287 388, 380, 379, 377, 376, 375, 374, 373, 372, 371, 1288 369, 368, 367, 366, 365, 364, 362, 356, 355, 354, 1289 353, 352, 351, 350, 349, 348, 347, 346, 345, 342, 1290 340, 339, 338, 337, 336, 335, 334, 333, 332, 331, 1291 330, 329, 328, 325, 314, 312, 311, 310, 309, 308, 1292 307, 306, 305, 304, 303, 301, 300, 299, 297, 295, 1293 1294 294, 290, 289, 286, 285, 280, 276, 270, 264, 260, 1295 259, 258, 257, 256, 255, 254, 253, 252, 250, 249, 1296 248, 247, 246, 245, 244, 242, 241, 240, 237, 236, 1297 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, 1298 224, 223, 222, 220, 219, 218, 217, 216, 215, 214, 1299 200, 199, 193, 187, 183, 182, 181, 180, 179, 178, 1300 177, 176, 174, 172, 170, 169, 168, 167, 166, 162, 1301 160, 159, 158, 149, 147, 146, 145, 143, 134, 129, 1302 127, 123, 122, 116, 114, 113, 108, 107, 99, 91, 1303 89, 88, 81, 80, 79, 77, 75, 74, 69, 68, 1304 1305 65, 63, 62, 61, 60, 58, 52, 50, 46, 43, 1306 41, 34, 32, 31, 28, 25, 22, 19, 1206, 1206, 1307 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1308 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1309 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1310 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1311 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1312 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1313 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1314 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206, 1206 1315 1316 } ; 1317 1318static yy_state_type yy_last_accepting_state; 1319static char *yy_last_accepting_cpos; 1320 1321extern int yy_flex_debug; 1322int yy_flex_debug = 0; 1323 1324/* The intent behind this definition is that it'll catch 1325 * any uses of REJECT which flex missed. 1326 */ 1327#define REJECT reject_used_but_not_detected 1328#define yymore() yymore_used_but_not_detected 1329#define YY_MORE_ADJ 0 1330#define YY_RESTORE_YY_MORE_OFFSET 1331char *yytext; 1332#line 1 "ldlex.l" 1333#line 4 "ldlex.l" 1334 1335/* Copyright (C) 1991-2022 Free Software Foundation, Inc. 1336 Written by Steve Chamberlain of Cygnus Support. 1337 1338 This file is part of the GNU Binutils. 1339 1340 This program is free software; you can redistribute it and/or modify 1341 it under the terms of the GNU General Public License as published by 1342 the Free Software Foundation; either version 3 of the License, or 1343 (at your option) any later version. 1344 1345 This program is distributed in the hope that it will be useful, 1346 but WITHOUT ANY WARRANTY; without even the implied warranty of 1347 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1348 GNU General Public License for more details. 1349 1350 You should have received a copy of the GNU General Public License 1351 along with this program; if not, write to the Free Software 1352 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 1353 MA 02110-1301, USA. */ 1354 1355#include "bfd.h" 1356#include "safe-ctype.h" 1357#include "bfdlink.h" 1358#include "ctf-api.h" 1359#include "ld.h" 1360#include "ldmisc.h" 1361#include "ldexp.h" 1362#include "ldlang.h" 1363#include <ldgram.h> 1364#include "ldfile.h" 1365#include "ldlex.h" 1366#include "ldmain.h" 1367#include "libiberty.h" 1368 1369/* The type of top-level parser input. 1370 yylex and yyparse (indirectly) both check this. */ 1371input_type parser_input; 1372 1373/* Line number in the current input file. */ 1374unsigned int lineno; 1375 1376/* The string we are currently lexing, or NULL if we are reading a 1377 file. */ 1378const char *lex_string = NULL; 1379 1380/* Support for flex reading from more than one input file (stream). 1381 `include_stack' is flex's input state for each open file; 1382 `file_name_stack' is the file names. `lineno_stack' is the current 1383 line numbers. 1384 1385 If `include_stack_ptr' is 0, we haven't started reading anything yet. 1386 Otherwise, stack elements 0 through `include_stack_ptr - 1' are valid. */ 1387 1388#undef YY_INPUT 1389#define YY_INPUT(buf,result,max_size) result = yy_input (buf, max_size) 1390 1391#ifndef YY_NO_UNPUT 1392#define YY_NO_UNPUT 1393#endif 1394 1395#define MAX_INCLUDE_DEPTH 10 1396static YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH]; 1397static const char *file_name_stack[MAX_INCLUDE_DEPTH]; 1398static unsigned int lineno_stack[MAX_INCLUDE_DEPTH]; 1399static unsigned int sysrooted_stack[MAX_INCLUDE_DEPTH]; 1400static unsigned int include_stack_ptr = 0; 1401static int vers_node_nesting = 0; 1402 1403static int yy_input (char *, int); 1404static void comment (void); 1405static void lex_warn_invalid (char *where, char *what); 1406 1407/* STATES 1408 EXPRESSION in an expression 1409 SCRIPT in a script 1410 INPUTLIST in a script, a filename-list 1411 MRI in an MRI script 1412 WILD inside the braces of an output section or overlay, 1413 for input section wildcards 1414 VERS_START starting a Sun style mapfile 1415 VERS_SCRIPT a Sun style mapfile 1416 VERS_NODE a node within a Sun style mapfile 1417*/ 1418#define RTOKEN(x) { yylval.token = x; return x; } 1419 1420#line 1420 "ldlex.c" 1421 1422#line 1422 "ldlex.c" 1423 1424#define INITIAL 0 1425#define SCRIPT 1 1426#define INPUTLIST 2 1427#define EXPRESSION 3 1428#define MRI 4 1429#define WILD 5 1430#define VERS_START 6 1431#define VERS_SCRIPT 7 1432#define VERS_NODE 8 1433 1434#ifndef YY_NO_UNISTD_H 1435/* Special case for "unistd.h", since it is non-ANSI. We include it way 1436 * down here because we want the user's section 1 to have been scanned first. 1437 * The user has a chance to override it with an option. 1438 */ 1439#include <unistd.h> 1440#endif 1441 1442#ifndef YY_EXTRA_TYPE 1443#define YY_EXTRA_TYPE void * 1444#endif 1445 1446static int yy_init_globals ( void ); 1447 1448/* Accessor methods to globals. 1449 These are made visible to non-reentrant scanners for convenience. */ 1450 1451int yylex_destroy ( void ); 1452 1453int yyget_debug ( void ); 1454 1455void yyset_debug ( int debug_flag ); 1456 1457YY_EXTRA_TYPE yyget_extra ( void ); 1458 1459void yyset_extra ( YY_EXTRA_TYPE user_defined ); 1460 1461FILE *yyget_in ( void ); 1462 1463void yyset_in ( FILE * _in_str ); 1464 1465FILE *yyget_out ( void ); 1466 1467void yyset_out ( FILE * _out_str ); 1468 1469 int yyget_leng ( void ); 1470 1471char *yyget_text ( void ); 1472 1473int yyget_lineno ( void ); 1474 1475void yyset_lineno ( int _line_number ); 1476 1477/* Macros after this point can all be overridden by user definitions in 1478 * section 1. 1479 */ 1480 1481#ifndef YY_SKIP_YYWRAP 1482#ifdef __cplusplus 1483extern "C" int yywrap ( void ); 1484#else 1485extern int yywrap ( void ); 1486#endif 1487#endif 1488 1489#ifndef YY_NO_UNPUT 1490 1491#endif 1492 1493#ifndef yytext_ptr 1494static void yy_flex_strncpy ( char *, const char *, int ); 1495#endif 1496 1497#ifdef YY_NEED_STRLEN 1498static int yy_flex_strlen ( const char * ); 1499#endif 1500 1501#ifndef YY_NO_INPUT 1502#ifdef __cplusplus 1503static int yyinput ( void ); 1504#else 1505static int input ( void ); 1506#endif 1507 1508#endif 1509 1510/* Amount of stuff to slurp up with each read. */ 1511#ifndef YY_READ_BUF_SIZE 1512#ifdef __ia64__ 1513/* On IA-64, the buffer size is 16k, not 8k */ 1514#define YY_READ_BUF_SIZE 16384 1515#else 1516#define YY_READ_BUF_SIZE 8192 1517#endif /* __ia64__ */ 1518#endif 1519 1520/* Copy whatever the last rule matched to the standard output. */ 1521#ifndef ECHO 1522/* This used to be an fputs(), but since the string might contain NUL's, 1523 * we now use fwrite(). 1524 */ 1525#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) 1526#endif 1527 1528/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 1529 * is returned in "result". 1530 */ 1531#ifndef YY_INPUT 1532#define YY_INPUT(buf,result,max_size) \ 1533 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 1534 { \ 1535 int c = '*'; \ 1536 int n; \ 1537 for ( n = 0; n < max_size && \ 1538 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 1539 buf[n] = (char) c; \ 1540 if ( c == '\n' ) \ 1541 buf[n++] = (char) c; \ 1542 if ( c == EOF && ferror( yyin ) ) \ 1543 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 1544 result = n; \ 1545 } \ 1546 else \ 1547 { \ 1548 errno=0; \ 1549 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ 1550 { \ 1551 if( errno != EINTR) \ 1552 { \ 1553 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 1554 break; \ 1555 } \ 1556 errno=0; \ 1557 clearerr(yyin); \ 1558 } \ 1559 }\ 1560\ 1561 1562#endif 1563 1564/* No semi-colon after return; correct usage is to write "yyterminate();" - 1565 * we don't want an extra ';' after the "return" because that will cause 1566 * some compilers to complain about unreachable statements. 1567 */ 1568#ifndef yyterminate 1569#define yyterminate() return YY_NULL 1570#endif 1571 1572/* Number of entries by which start-condition stack grows. */ 1573#ifndef YY_START_STACK_INCR 1574#define YY_START_STACK_INCR 25 1575#endif 1576 1577/* Report a fatal error. */ 1578#ifndef YY_FATAL_ERROR 1579#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 1580#endif 1581 1582/* end tables serialization structures and prototypes */ 1583 1584/* Default declaration of generated scanner - a define so the user can 1585 * easily add parameters. 1586 */ 1587#ifndef YY_DECL 1588#define YY_DECL_IS_OURS 1 1589 1590extern int yylex (void); 1591 1592#define YY_DECL int yylex (void) 1593#endif /* !YY_DECL */ 1594 1595/* Code executed at the beginning of each rule, after yytext and yyleng 1596 * have been set up. 1597 */ 1598#ifndef YY_USER_ACTION 1599#define YY_USER_ACTION 1600#endif 1601 1602/* Code executed at the end of each rule. */ 1603#ifndef YY_BREAK 1604#define YY_BREAK /*LINTED*/break; 1605#endif 1606 1607#define YY_RULE_SETUP \ 1608 YY_USER_ACTION 1609 1610/** The main scanner function which does all the work. 1611 */ 1612YY_DECL 1613{ 1614 yy_state_type yy_current_state; 1615 char *yy_cp, *yy_bp; 1616 int yy_act; 1617 1618 if ( !(yy_init) ) 1619 { 1620 (yy_init) = 1; 1621 1622#ifdef YY_USER_INIT 1623 YY_USER_INIT; 1624#endif 1625 1626 if ( ! (yy_start) ) 1627 (yy_start) = 1; /* first start state */ 1628 1629 if ( ! yyin ) 1630 yyin = stdin; 1631 1632 if ( ! yyout ) 1633 yyout = stdout; 1634 1635 if ( ! YY_CURRENT_BUFFER ) { 1636 yyensure_buffer_stack (); 1637 YY_CURRENT_BUFFER_LVALUE = 1638 yy_create_buffer( yyin, YY_BUF_SIZE ); 1639 } 1640 1641 yy_load_buffer_state( ); 1642 } 1643 1644 { 1645#line 114 "ldlex.l" 1646 1647 1648#line 117 "ldlex.l" 1649 if (parser_input != input_selected) 1650 { 1651 /* The first token of the input determines the initial parser state. */ 1652 input_type t = parser_input; 1653 parser_input = input_selected; 1654 switch (t) 1655 { 1656 case input_script: return INPUT_SCRIPT; break; 1657 case input_mri_script: return INPUT_MRI_SCRIPT; break; 1658 case input_version_script: return INPUT_VERSION_SCRIPT; break; 1659 case input_dynamic_list: return INPUT_DYNAMIC_LIST; break; 1660 case input_defsym: return INPUT_DEFSYM; break; 1661 default: abort (); 1662 } 1663 } 1664 1665#line 1665 "ldlex.c" 1666 1667 while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ 1668 { 1669 yy_cp = (yy_c_buf_p); 1670 1671 /* Support of yytext. */ 1672 *yy_cp = (yy_hold_char); 1673 1674 /* yy_bp points to the position in yy_ch_buf of the start of 1675 * the current run. 1676 */ 1677 yy_bp = yy_cp; 1678 1679 yy_current_state = (yy_start); 1680yy_match: 1681 do 1682 { 1683 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; 1684 if ( yy_accept[yy_current_state] ) 1685 { 1686 (yy_last_accepting_state) = yy_current_state; 1687 (yy_last_accepting_cpos) = yy_cp; 1688 } 1689 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1690 { 1691 yy_current_state = (int) yy_def[yy_current_state]; 1692 if ( yy_current_state >= 1207 ) 1693 yy_c = yy_meta[yy_c]; 1694 } 1695 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1696 ++yy_cp; 1697 } 1698 while ( yy_base[yy_current_state] != 2119 ); 1699 1700yy_find_action: 1701 yy_act = yy_accept[yy_current_state]; 1702 if ( yy_act == 0 ) 1703 { /* have to back up */ 1704 yy_cp = (yy_last_accepting_cpos); 1705 yy_current_state = (yy_last_accepting_state); 1706 yy_act = yy_accept[yy_current_state]; 1707 } 1708 1709 YY_DO_BEFORE_ACTION; 1710 1711do_action: /* This label is used only to access EOF actions. */ 1712 1713 switch ( yy_act ) 1714 { /* beginning of action switch */ 1715 case 0: /* must back up */ 1716 /* undo the effects of YY_DO_BEFORE_ACTION */ 1717 *yy_cp = (yy_hold_char); 1718 yy_cp = (yy_last_accepting_cpos); 1719 yy_current_state = (yy_last_accepting_state); 1720 goto yy_find_action; 1721 1722case 1: 1723YY_RULE_SETUP 1724#line 133 "ldlex.l" 1725{ 1726 comment (); } 1727 YY_BREAK 1728case 2: 1729YY_RULE_SETUP 1730#line 136 "ldlex.l" 1731{ 1732 yylval.integer = bfd_scan_vma (yytext + 1, 0, 16); 1733 yylval.bigint.str = NULL; 1734 return INT; 1735 } 1736 YY_BREAK 1737case 3: 1738YY_RULE_SETUP 1739#line 142 "ldlex.l" 1740{ 1741 int ibase ; 1742 switch (yytext[yyleng - 1]) { 1743 case 'X': 1744 case 'x': 1745 case 'H': 1746 case 'h': 1747 ibase = 16; 1748 break; 1749 case 'O': 1750 case 'o': 1751 ibase = 8; 1752 break; 1753 case 'B': 1754 case 'b': 1755 ibase = 2; 1756 break; 1757 default: 1758 ibase = 10; 1759 } 1760 yylval.integer = bfd_scan_vma (yytext, 0, 1761 ibase); 1762 yylval.bigint.str = NULL; 1763 return INT; 1764 } 1765 YY_BREAK 1766case 4: 1767YY_RULE_SETUP 1768#line 167 "ldlex.l" 1769{ 1770 char *s = yytext; 1771 int ibase = 0; 1772 1773 if (*s == '$') 1774 { 1775 ++s; 1776 ibase = 16; 1777 } 1778 yylval.integer = bfd_scan_vma (s, 0, ibase); 1779 yylval.bigint.str = NULL; 1780 if (yytext[yyleng - 1] == 'M' 1781 || yytext[yyleng - 1] == 'm') 1782 { 1783 yylval.integer *= 1024 * 1024; 1784 } 1785 else if (yytext[yyleng - 1] == 'K' 1786 || yytext[yyleng - 1]=='k') 1787 { 1788 yylval.integer *= 1024; 1789 } 1790 else if (yytext[0] == '0' 1791 && (yytext[1] == 'x' 1792 || yytext[1] == 'X')) 1793 { 1794 yylval.bigint.str = xstrdup (yytext + 2); 1795 } 1796 return INT; 1797 } 1798 YY_BREAK 1799/* Some tokens that only appear in expressions must be enabled for 1800 states other than EXPRESSION, since parser lookahead means they 1801 must be recognised before the parser switches the lexer out of 1802 SCRIPT or WILD state into EXPRESSION state. 1803 1804 This sort of thing happens for example with NAME in ldgram.y 1805 "section" rule, which is immediately followed by ldlex_expression. 1806 However, if you follow the grammar from "sec_or_group_p1" you see 1807 "assignment" appearing in "statement_anywhere". Now, 1808 "assignment" also has NAME as its first token, just like 1809 "section". So the parser can't know whether it is in the 1810 "section" or the "assignment" rule until it has scanned the next 1811 token to find an assignment operator. Thus the next token after 1812 NAME in the "section" rule may be lexed before the lexer is 1813 switched to EXPRESSION state, and there are quite a number of 1814 optional components. The first token in all those components 1815 must be able to be lexed in SCRIPT state, as well as the 1816 assignment operators. In fact, due to "opt_exp_with_type", 1817 anything that can appear on the left hand side of "exp" might 1818 need to be lexed in SCRIPT state. 1819 1820 MRI mode tends to cover everything in MRI scripts. 1821 */ 1822case 5: 1823YY_RULE_SETUP 1824#line 220 "ldlex.l" 1825{ RTOKEN(']'); } 1826 YY_BREAK 1827case 6: 1828YY_RULE_SETUP 1829#line 221 "ldlex.l" 1830{ RTOKEN('['); } 1831 YY_BREAK 1832case 7: 1833YY_RULE_SETUP 1834#line 222 "ldlex.l" 1835{ RTOKEN(LSHIFTEQ); } 1836 YY_BREAK 1837case 8: 1838YY_RULE_SETUP 1839#line 223 "ldlex.l" 1840{ RTOKEN(RSHIFTEQ); } 1841 YY_BREAK 1842case 9: 1843YY_RULE_SETUP 1844#line 224 "ldlex.l" 1845{ RTOKEN(OROR); } 1846 YY_BREAK 1847case 10: 1848YY_RULE_SETUP 1849#line 225 "ldlex.l" 1850{ RTOKEN(EQ); } 1851 YY_BREAK 1852case 11: 1853YY_RULE_SETUP 1854#line 226 "ldlex.l" 1855{ RTOKEN(NE); } 1856 YY_BREAK 1857case 12: 1858YY_RULE_SETUP 1859#line 227 "ldlex.l" 1860{ RTOKEN(GE); } 1861 YY_BREAK 1862case 13: 1863YY_RULE_SETUP 1864#line 228 "ldlex.l" 1865{ RTOKEN(LE); } 1866 YY_BREAK 1867case 14: 1868YY_RULE_SETUP 1869#line 229 "ldlex.l" 1870{ RTOKEN(LSHIFT); } 1871 YY_BREAK 1872case 15: 1873YY_RULE_SETUP 1874#line 230 "ldlex.l" 1875{ RTOKEN(RSHIFT); } 1876 YY_BREAK 1877case 16: 1878YY_RULE_SETUP 1879#line 231 "ldlex.l" 1880{ RTOKEN(PLUSEQ); } 1881 YY_BREAK 1882case 17: 1883YY_RULE_SETUP 1884#line 232 "ldlex.l" 1885{ RTOKEN(MINUSEQ); } 1886 YY_BREAK 1887case 18: 1888YY_RULE_SETUP 1889#line 233 "ldlex.l" 1890{ RTOKEN(MULTEQ); } 1891 YY_BREAK 1892case 19: 1893YY_RULE_SETUP 1894#line 234 "ldlex.l" 1895{ RTOKEN(DIVEQ); } 1896 YY_BREAK 1897case 20: 1898YY_RULE_SETUP 1899#line 235 "ldlex.l" 1900{ RTOKEN(ANDEQ); } 1901 YY_BREAK 1902case 21: 1903YY_RULE_SETUP 1904#line 236 "ldlex.l" 1905{ RTOKEN(OREQ); } 1906 YY_BREAK 1907case 22: 1908YY_RULE_SETUP 1909#line 237 "ldlex.l" 1910{ RTOKEN(ANDAND); } 1911 YY_BREAK 1912case 23: 1913YY_RULE_SETUP 1914#line 238 "ldlex.l" 1915{ RTOKEN('>'); } 1916 YY_BREAK 1917case 24: 1918YY_RULE_SETUP 1919#line 239 "ldlex.l" 1920{ RTOKEN(','); } 1921 YY_BREAK 1922case 25: 1923YY_RULE_SETUP 1924#line 240 "ldlex.l" 1925{ RTOKEN('&'); } 1926 YY_BREAK 1927case 26: 1928YY_RULE_SETUP 1929#line 241 "ldlex.l" 1930{ RTOKEN('|'); } 1931 YY_BREAK 1932case 27: 1933YY_RULE_SETUP 1934#line 242 "ldlex.l" 1935{ RTOKEN('~'); } 1936 YY_BREAK 1937case 28: 1938YY_RULE_SETUP 1939#line 243 "ldlex.l" 1940{ RTOKEN('!'); } 1941 YY_BREAK 1942case 29: 1943YY_RULE_SETUP 1944#line 244 "ldlex.l" 1945{ RTOKEN('?'); } 1946 YY_BREAK 1947case 30: 1948YY_RULE_SETUP 1949#line 245 "ldlex.l" 1950{ RTOKEN('*'); } 1951 YY_BREAK 1952case 31: 1953YY_RULE_SETUP 1954#line 246 "ldlex.l" 1955{ RTOKEN('+'); } 1956 YY_BREAK 1957case 32: 1958YY_RULE_SETUP 1959#line 247 "ldlex.l" 1960{ RTOKEN('-'); } 1961 YY_BREAK 1962case 33: 1963YY_RULE_SETUP 1964#line 248 "ldlex.l" 1965{ RTOKEN('/'); } 1966 YY_BREAK 1967case 34: 1968YY_RULE_SETUP 1969#line 249 "ldlex.l" 1970{ RTOKEN('%'); } 1971 YY_BREAK 1972case 35: 1973YY_RULE_SETUP 1974#line 250 "ldlex.l" 1975{ RTOKEN('<'); } 1976 YY_BREAK 1977case 36: 1978YY_RULE_SETUP 1979#line 251 "ldlex.l" 1980{ RTOKEN('='); } 1981 YY_BREAK 1982case 37: 1983YY_RULE_SETUP 1984#line 252 "ldlex.l" 1985{ RTOKEN('}'); } 1986 YY_BREAK 1987case 38: 1988YY_RULE_SETUP 1989#line 253 "ldlex.l" 1990{ RTOKEN('{'); } 1991 YY_BREAK 1992case 39: 1993YY_RULE_SETUP 1994#line 254 "ldlex.l" 1995{ RTOKEN(')'); } 1996 YY_BREAK 1997case 40: 1998YY_RULE_SETUP 1999#line 255 "ldlex.l" 2000{ RTOKEN('('); } 2001 YY_BREAK 2002case 41: 2003YY_RULE_SETUP 2004#line 256 "ldlex.l" 2005{ RTOKEN(':'); } 2006 YY_BREAK 2007case 42: 2008YY_RULE_SETUP 2009#line 257 "ldlex.l" 2010{ RTOKEN(';'); } 2011 YY_BREAK 2012case 43: 2013YY_RULE_SETUP 2014#line 258 "ldlex.l" 2015{ RTOKEN(MEMORY); } 2016 YY_BREAK 2017case 44: 2018YY_RULE_SETUP 2019#line 259 "ldlex.l" 2020{ RTOKEN(REGION_ALIAS); } 2021 YY_BREAK 2022case 45: 2023YY_RULE_SETUP 2024#line 260 "ldlex.l" 2025{ RTOKEN(LD_FEATURE); } 2026 YY_BREAK 2027case 46: 2028YY_RULE_SETUP 2029#line 261 "ldlex.l" 2030{ RTOKEN(ORIGIN); } 2031 YY_BREAK 2032case 47: 2033YY_RULE_SETUP 2034#line 262 "ldlex.l" 2035{ RTOKEN(VERSIONK); } 2036 YY_BREAK 2037case 48: 2038YY_RULE_SETUP 2039#line 263 "ldlex.l" 2040{ RTOKEN(BLOCK); } 2041 YY_BREAK 2042case 49: 2043YY_RULE_SETUP 2044#line 264 "ldlex.l" 2045{ RTOKEN(BIND); } 2046 YY_BREAK 2047case 50: 2048YY_RULE_SETUP 2049#line 265 "ldlex.l" 2050{ RTOKEN(LENGTH); } 2051 YY_BREAK 2052case 51: 2053YY_RULE_SETUP 2054#line 266 "ldlex.l" 2055{ RTOKEN(ALIGN_K); } 2056 YY_BREAK 2057case 52: 2058YY_RULE_SETUP 2059#line 267 "ldlex.l" 2060{ RTOKEN(DATA_SEGMENT_ALIGN); } 2061 YY_BREAK 2062case 53: 2063YY_RULE_SETUP 2064#line 268 "ldlex.l" 2065{ RTOKEN(DATA_SEGMENT_RELRO_END); } 2066 YY_BREAK 2067case 54: 2068YY_RULE_SETUP 2069#line 269 "ldlex.l" 2070{ RTOKEN(DATA_SEGMENT_END); } 2071 YY_BREAK 2072case 55: 2073YY_RULE_SETUP 2074#line 270 "ldlex.l" 2075{ RTOKEN(ADDR); } 2076 YY_BREAK 2077case 56: 2078YY_RULE_SETUP 2079#line 271 "ldlex.l" 2080{ RTOKEN(LOADADDR); } 2081 YY_BREAK 2082case 57: 2083YY_RULE_SETUP 2084#line 272 "ldlex.l" 2085{ RTOKEN(ALIGNOF); } 2086 YY_BREAK 2087case 58: 2088YY_RULE_SETUP 2089#line 273 "ldlex.l" 2090{ RTOKEN(ABSOLUTE); } 2091 YY_BREAK 2092case 59: 2093YY_RULE_SETUP 2094#line 274 "ldlex.l" 2095{ RTOKEN(MAX_K); } 2096 YY_BREAK 2097case 60: 2098YY_RULE_SETUP 2099#line 275 "ldlex.l" 2100{ RTOKEN(MIN_K); } 2101 YY_BREAK 2102case 61: 2103YY_RULE_SETUP 2104#line 276 "ldlex.l" 2105{ RTOKEN(LOG2CEIL); } 2106 YY_BREAK 2107case 62: 2108YY_RULE_SETUP 2109#line 277 "ldlex.l" 2110{ RTOKEN(ASSERT_K); } 2111 YY_BREAK 2112case 63: 2113YY_RULE_SETUP 2114#line 278 "ldlex.l" 2115{ RTOKEN(ENTRY); } 2116 YY_BREAK 2117case 64: 2118YY_RULE_SETUP 2119#line 279 "ldlex.l" 2120{ RTOKEN(EXTERN); } 2121 YY_BREAK 2122case 65: 2123YY_RULE_SETUP 2124#line 280 "ldlex.l" 2125{ RTOKEN(NEXT); } 2126 YY_BREAK 2127case 66: 2128YY_RULE_SETUP 2129#line 281 "ldlex.l" 2130{ RTOKEN(SIZEOF_HEADERS); } 2131 YY_BREAK 2132case 67: 2133YY_RULE_SETUP 2134#line 282 "ldlex.l" 2135{ RTOKEN(SEGMENT_START); } 2136 YY_BREAK 2137case 68: 2138YY_RULE_SETUP 2139#line 283 "ldlex.l" 2140{ RTOKEN(MAP); } 2141 YY_BREAK 2142case 69: 2143YY_RULE_SETUP 2144#line 284 "ldlex.l" 2145{ RTOKEN(SIZEOF); } 2146 YY_BREAK 2147case 70: 2148YY_RULE_SETUP 2149#line 285 "ldlex.l" 2150{ RTOKEN(TARGET_K); } 2151 YY_BREAK 2152case 71: 2153YY_RULE_SETUP 2154#line 286 "ldlex.l" 2155{ RTOKEN(SEARCH_DIR); } 2156 YY_BREAK 2157case 72: 2158YY_RULE_SETUP 2159#line 287 "ldlex.l" 2160{ RTOKEN(OUTPUT); } 2161 YY_BREAK 2162case 73: 2163YY_RULE_SETUP 2164#line 288 "ldlex.l" 2165{ RTOKEN(INPUT); } 2166 YY_BREAK 2167case 74: 2168YY_RULE_SETUP 2169#line 289 "ldlex.l" 2170{ RTOKEN(GROUP); } 2171 YY_BREAK 2172case 75: 2173YY_RULE_SETUP 2174#line 290 "ldlex.l" 2175{ RTOKEN(AS_NEEDED); } 2176 YY_BREAK 2177case 76: 2178YY_RULE_SETUP 2179#line 291 "ldlex.l" 2180{ RTOKEN(DEFINED); } 2181 YY_BREAK 2182case 77: 2183YY_RULE_SETUP 2184#line 292 "ldlex.l" 2185{ RTOKEN(CREATE_OBJECT_SYMBOLS); } 2186 YY_BREAK 2187case 78: 2188YY_RULE_SETUP 2189#line 293 "ldlex.l" 2190{ RTOKEN(CONSTRUCTORS); } 2191 YY_BREAK 2192case 79: 2193YY_RULE_SETUP 2194#line 294 "ldlex.l" 2195{ RTOKEN(FORCE_COMMON_ALLOCATION); } 2196 YY_BREAK 2197case 80: 2198YY_RULE_SETUP 2199#line 295 "ldlex.l" 2200{ RTOKEN(FORCE_GROUP_ALLOCATION); } 2201 YY_BREAK 2202case 81: 2203YY_RULE_SETUP 2204#line 296 "ldlex.l" 2205{ RTOKEN(INHIBIT_COMMON_ALLOCATION); } 2206 YY_BREAK 2207case 82: 2208YY_RULE_SETUP 2209#line 297 "ldlex.l" 2210{ RTOKEN(SECTIONS); } 2211 YY_BREAK 2212case 83: 2213YY_RULE_SETUP 2214#line 298 "ldlex.l" 2215{ RTOKEN(INSERT_K); } 2216 YY_BREAK 2217case 84: 2218YY_RULE_SETUP 2219#line 299 "ldlex.l" 2220{ RTOKEN(AFTER); } 2221 YY_BREAK 2222case 85: 2223YY_RULE_SETUP 2224#line 300 "ldlex.l" 2225{ RTOKEN(BEFORE); } 2226 YY_BREAK 2227case 86: 2228YY_RULE_SETUP 2229#line 301 "ldlex.l" 2230{ RTOKEN(FILL); } 2231 YY_BREAK 2232case 87: 2233YY_RULE_SETUP 2234#line 302 "ldlex.l" 2235{ RTOKEN(STARTUP); } 2236 YY_BREAK 2237case 88: 2238YY_RULE_SETUP 2239#line 303 "ldlex.l" 2240{ RTOKEN(OUTPUT_FORMAT); } 2241 YY_BREAK 2242case 89: 2243YY_RULE_SETUP 2244#line 304 "ldlex.l" 2245{ RTOKEN(OUTPUT_ARCH); } 2246 YY_BREAK 2247case 90: 2248YY_RULE_SETUP 2249#line 305 "ldlex.l" 2250{ RTOKEN(HLL); } 2251 YY_BREAK 2252case 91: 2253YY_RULE_SETUP 2254#line 306 "ldlex.l" 2255{ RTOKEN(SYSLIB); } 2256 YY_BREAK 2257case 92: 2258YY_RULE_SETUP 2259#line 307 "ldlex.l" 2260{ RTOKEN(FLOAT); } 2261 YY_BREAK 2262case 93: 2263YY_RULE_SETUP 2264#line 308 "ldlex.l" 2265{ RTOKEN(QUAD); } 2266 YY_BREAK 2267case 94: 2268YY_RULE_SETUP 2269#line 309 "ldlex.l" 2270{ RTOKEN(SQUAD); } 2271 YY_BREAK 2272case 95: 2273YY_RULE_SETUP 2274#line 310 "ldlex.l" 2275{ RTOKEN(LONG); } 2276 YY_BREAK 2277case 96: 2278YY_RULE_SETUP 2279#line 311 "ldlex.l" 2280{ RTOKEN(SHORT); } 2281 YY_BREAK 2282case 97: 2283YY_RULE_SETUP 2284#line 312 "ldlex.l" 2285{ RTOKEN(BYTE); } 2286 YY_BREAK 2287case 98: 2288YY_RULE_SETUP 2289#line 313 "ldlex.l" 2290{ RTOKEN(NOFLOAT); } 2291 YY_BREAK 2292case 99: 2293YY_RULE_SETUP 2294#line 314 "ldlex.l" 2295{ RTOKEN(NOCROSSREFS); } 2296 YY_BREAK 2297case 100: 2298YY_RULE_SETUP 2299#line 315 "ldlex.l" 2300{ RTOKEN(NOCROSSREFS_TO); } 2301 YY_BREAK 2302case 101: 2303YY_RULE_SETUP 2304#line 316 "ldlex.l" 2305{ RTOKEN(OVERLAY); } 2306 YY_BREAK 2307case 102: 2308YY_RULE_SETUP 2309#line 317 "ldlex.l" 2310{ RTOKEN(SORT_BY_NAME); } 2311 YY_BREAK 2312case 103: 2313YY_RULE_SETUP 2314#line 318 "ldlex.l" 2315{ RTOKEN(SORT_BY_ALIGNMENT); } 2316 YY_BREAK 2317case 104: 2318YY_RULE_SETUP 2319#line 319 "ldlex.l" 2320{ RTOKEN(SORT_BY_NAME); } 2321 YY_BREAK 2322case 105: 2323YY_RULE_SETUP 2324#line 320 "ldlex.l" 2325{ RTOKEN(SORT_BY_INIT_PRIORITY); } 2326 YY_BREAK 2327case 106: 2328YY_RULE_SETUP 2329#line 321 "ldlex.l" 2330{ RTOKEN(SORT_NONE); } 2331 YY_BREAK 2332case 107: 2333YY_RULE_SETUP 2334#line 322 "ldlex.l" 2335{ RTOKEN(NOLOAD); } 2336 YY_BREAK 2337case 108: 2338YY_RULE_SETUP 2339#line 323 "ldlex.l" 2340{ RTOKEN(READONLY); } 2341 YY_BREAK 2342case 109: 2343YY_RULE_SETUP 2344#line 324 "ldlex.l" 2345{ RTOKEN(DSECT); } 2346 YY_BREAK 2347case 110: 2348YY_RULE_SETUP 2349#line 325 "ldlex.l" 2350{ RTOKEN(COPY); } 2351 YY_BREAK 2352case 111: 2353YY_RULE_SETUP 2354#line 326 "ldlex.l" 2355{ RTOKEN(INFO); } 2356 YY_BREAK 2357case 112: 2358YY_RULE_SETUP 2359#line 327 "ldlex.l" 2360{ RTOKEN(TYPE); } 2361 YY_BREAK 2362case 113: 2363YY_RULE_SETUP 2364#line 328 "ldlex.l" 2365{ RTOKEN(ONLY_IF_RO); } 2366 YY_BREAK 2367case 114: 2368YY_RULE_SETUP 2369#line 329 "ldlex.l" 2370{ RTOKEN(ONLY_IF_RW); } 2371 YY_BREAK 2372case 115: 2373YY_RULE_SETUP 2374#line 330 "ldlex.l" 2375{ RTOKEN(SPECIAL); } 2376 YY_BREAK 2377case 116: 2378YY_RULE_SETUP 2379#line 331 "ldlex.l" 2380{ RTOKEN(ORIGIN); } 2381 YY_BREAK 2382case 117: 2383YY_RULE_SETUP 2384#line 332 "ldlex.l" 2385{ RTOKEN(ORIGIN); } 2386 YY_BREAK 2387case 118: 2388YY_RULE_SETUP 2389#line 333 "ldlex.l" 2390{ RTOKEN(LENGTH); } 2391 YY_BREAK 2392case 119: 2393YY_RULE_SETUP 2394#line 334 "ldlex.l" 2395{ RTOKEN(LENGTH); } 2396 YY_BREAK 2397case 120: 2398YY_RULE_SETUP 2399#line 335 "ldlex.l" 2400{ RTOKEN(INPUT_SECTION_FLAGS); } 2401 YY_BREAK 2402case 121: 2403YY_RULE_SETUP 2404#line 336 "ldlex.l" 2405{ RTOKEN(INCLUDE);} 2406 YY_BREAK 2407case 122: 2408YY_RULE_SETUP 2409#line 337 "ldlex.l" 2410{ RTOKEN(PHDRS); } 2411 YY_BREAK 2412case 123: 2413YY_RULE_SETUP 2414#line 338 "ldlex.l" 2415{ RTOKEN(AT);} 2416 YY_BREAK 2417case 124: 2418YY_RULE_SETUP 2419#line 339 "ldlex.l" 2420{ RTOKEN(ALIGN_WITH_INPUT);} 2421 YY_BREAK 2422case 125: 2423YY_RULE_SETUP 2424#line 340 "ldlex.l" 2425{ RTOKEN(SUBALIGN);} 2426 YY_BREAK 2427case 126: 2428YY_RULE_SETUP 2429#line 341 "ldlex.l" 2430{ RTOKEN(HIDDEN); } 2431 YY_BREAK 2432case 127: 2433YY_RULE_SETUP 2434#line 342 "ldlex.l" 2435{ RTOKEN(PROVIDE); } 2436 YY_BREAK 2437case 128: 2438YY_RULE_SETUP 2439#line 343 "ldlex.l" 2440{ RTOKEN(PROVIDE_HIDDEN); } 2441 YY_BREAK 2442case 129: 2443YY_RULE_SETUP 2444#line 344 "ldlex.l" 2445{ RTOKEN(KEEP); } 2446 YY_BREAK 2447case 130: 2448YY_RULE_SETUP 2449#line 345 "ldlex.l" 2450{ RTOKEN(EXCLUDE_FILE); } 2451 YY_BREAK 2452case 131: 2453YY_RULE_SETUP 2454#line 346 "ldlex.l" 2455{ RTOKEN(CONSTANT);} 2456 YY_BREAK 2457case 132: 2458/* rule 132 can match eol */ 2459YY_RULE_SETUP 2460#line 348 "ldlex.l" 2461{ ++ lineno; } 2462 YY_BREAK 2463case 133: 2464/* rule 133 can match eol */ 2465YY_RULE_SETUP 2466#line 349 "ldlex.l" 2467{ ++ lineno; RTOKEN(NEWLINE); } 2468 YY_BREAK 2469case 134: 2470YY_RULE_SETUP 2471#line 350 "ldlex.l" 2472{ /* Mri comment line */ } 2473 YY_BREAK 2474case 135: 2475YY_RULE_SETUP 2476#line 351 "ldlex.l" 2477{ /* Mri comment line */ } 2478 YY_BREAK 2479case 136: 2480YY_RULE_SETUP 2481#line 352 "ldlex.l" 2482{ RTOKEN(ENDWORD); } 2483 YY_BREAK 2484case 137: 2485YY_RULE_SETUP 2486#line 353 "ldlex.l" 2487{ RTOKEN(ABSOLUTE); } 2488 YY_BREAK 2489case 138: 2490YY_RULE_SETUP 2491#line 354 "ldlex.l" 2492{ RTOKEN(ALIGNMOD);} 2493 YY_BREAK 2494case 139: 2495YY_RULE_SETUP 2496#line 355 "ldlex.l" 2497{ RTOKEN(ALIGN_K);} 2498 YY_BREAK 2499case 140: 2500YY_RULE_SETUP 2501#line 356 "ldlex.l" 2502{ RTOKEN(CHIP); } 2503 YY_BREAK 2504case 141: 2505YY_RULE_SETUP 2506#line 357 "ldlex.l" 2507{ RTOKEN(BASE); } 2508 YY_BREAK 2509case 142: 2510YY_RULE_SETUP 2511#line 358 "ldlex.l" 2512{ RTOKEN(ALIAS); } 2513 YY_BREAK 2514case 143: 2515YY_RULE_SETUP 2516#line 359 "ldlex.l" 2517{ RTOKEN(TRUNCATE); } 2518 YY_BREAK 2519case 144: 2520YY_RULE_SETUP 2521#line 360 "ldlex.l" 2522{ RTOKEN(LOAD); } 2523 YY_BREAK 2524case 145: 2525YY_RULE_SETUP 2526#line 361 "ldlex.l" 2527{ RTOKEN(PUBLIC); } 2528 YY_BREAK 2529case 146: 2530YY_RULE_SETUP 2531#line 362 "ldlex.l" 2532{ RTOKEN(ORDER); } 2533 YY_BREAK 2534case 147: 2535YY_RULE_SETUP 2536#line 363 "ldlex.l" 2537{ RTOKEN(NAMEWORD); } 2538 YY_BREAK 2539case 148: 2540YY_RULE_SETUP 2541#line 364 "ldlex.l" 2542{ RTOKEN(FORMAT); } 2543 YY_BREAK 2544case 149: 2545YY_RULE_SETUP 2546#line 365 "ldlex.l" 2547{ RTOKEN(CASE); } 2548 YY_BREAK 2549case 150: 2550YY_RULE_SETUP 2551#line 366 "ldlex.l" 2552{ RTOKEN(START); } 2553 YY_BREAK 2554case 151: 2555YY_RULE_SETUP 2556#line 367 "ldlex.l" 2557{ RTOKEN(LIST); /* LIST and ignore to end of line */ } 2558 YY_BREAK 2559case 152: 2560YY_RULE_SETUP 2561#line 368 "ldlex.l" 2562{ RTOKEN(SECT); } 2563 YY_BREAK 2564case 153: 2565YY_RULE_SETUP 2566#line 369 "ldlex.l" 2567{ RTOKEN(ENDWORD); } 2568 YY_BREAK 2569case 154: 2570YY_RULE_SETUP 2571#line 370 "ldlex.l" 2572{ RTOKEN(ABSOLUTE); } 2573 YY_BREAK 2574case 155: 2575YY_RULE_SETUP 2576#line 371 "ldlex.l" 2577{ RTOKEN(ALIGNMOD);} 2578 YY_BREAK 2579case 156: 2580YY_RULE_SETUP 2581#line 372 "ldlex.l" 2582{ RTOKEN(ALIGN_K);} 2583 YY_BREAK 2584case 157: 2585YY_RULE_SETUP 2586#line 373 "ldlex.l" 2587{ RTOKEN(CHIP); } 2588 YY_BREAK 2589case 158: 2590YY_RULE_SETUP 2591#line 374 "ldlex.l" 2592{ RTOKEN(BASE); } 2593 YY_BREAK 2594case 159: 2595YY_RULE_SETUP 2596#line 375 "ldlex.l" 2597{ RTOKEN(ALIAS); } 2598 YY_BREAK 2599case 160: 2600YY_RULE_SETUP 2601#line 376 "ldlex.l" 2602{ RTOKEN(TRUNCATE); } 2603 YY_BREAK 2604case 161: 2605YY_RULE_SETUP 2606#line 377 "ldlex.l" 2607{ RTOKEN(LOAD); } 2608 YY_BREAK 2609case 162: 2610YY_RULE_SETUP 2611#line 378 "ldlex.l" 2612{ RTOKEN(PUBLIC); } 2613 YY_BREAK 2614case 163: 2615YY_RULE_SETUP 2616#line 379 "ldlex.l" 2617{ RTOKEN(ORDER); } 2618 YY_BREAK 2619case 164: 2620YY_RULE_SETUP 2621#line 380 "ldlex.l" 2622{ RTOKEN(NAMEWORD); } 2623 YY_BREAK 2624case 165: 2625YY_RULE_SETUP 2626#line 381 "ldlex.l" 2627{ RTOKEN(FORMAT); } 2628 YY_BREAK 2629case 166: 2630YY_RULE_SETUP 2631#line 382 "ldlex.l" 2632{ RTOKEN(CASE); } 2633 YY_BREAK 2634case 167: 2635YY_RULE_SETUP 2636#line 383 "ldlex.l" 2637{ RTOKEN(EXTERN); } 2638 YY_BREAK 2639case 168: 2640YY_RULE_SETUP 2641#line 384 "ldlex.l" 2642{ RTOKEN(START); } 2643 YY_BREAK 2644case 169: 2645YY_RULE_SETUP 2646#line 385 "ldlex.l" 2647{ RTOKEN(LIST); /* LIST and ignore to end of line */ } 2648 YY_BREAK 2649case 170: 2650YY_RULE_SETUP 2651#line 386 "ldlex.l" 2652{ RTOKEN(SECT); } 2653 YY_BREAK 2654case 171: 2655YY_RULE_SETUP 2656#line 388 "ldlex.l" 2657{ 2658/* Filename without commas, needed to parse mri stuff */ 2659 yylval.name = xstrdup (yytext); 2660 return NAME; 2661 } 2662 YY_BREAK 2663case 172: 2664YY_RULE_SETUP 2665#line 395 "ldlex.l" 2666{ 2667 yylval.name = xstrdup (yytext); 2668 return NAME; 2669 } 2670 YY_BREAK 2671case 173: 2672YY_RULE_SETUP 2673#line 399 "ldlex.l" 2674{ 2675/* Filename to be prefixed by --sysroot or when non-sysrooted, nothing. */ 2676 yylval.name = xstrdup (yytext); 2677 return NAME; 2678 } 2679 YY_BREAK 2680case 174: 2681YY_RULE_SETUP 2682#line 404 "ldlex.l" 2683{ 2684 yylval.name = xstrdup (yytext + 2); 2685 return LNAME; 2686 } 2687 YY_BREAK 2688case 175: 2689YY_RULE_SETUP 2690#line 408 "ldlex.l" 2691{ 2692 yylval.name = xstrdup (yytext); 2693 return NAME; 2694 } 2695 YY_BREAK 2696/* The following rule is to prevent a fill expression on the output 2697 section before /DISCARD/ interpreting the '/' as a divide. */ 2698case 176: 2699YY_RULE_SETUP 2700#line 414 "ldlex.l" 2701{ 2702 yylval.name = xstrdup (yytext); 2703 return NAME; 2704 } 2705 YY_BREAK 2706case 177: 2707YY_RULE_SETUP 2708#line 418 "ldlex.l" 2709{ 2710 /* Annoyingly, this pattern can match comments, and we have 2711 longest match issues to consider. So if the first two 2712 characters are a comment opening, put the input back and 2713 try again. */ 2714 if (yytext[0] == '/' && yytext[1] == '*') 2715 { 2716 yyless (2); 2717 comment (); 2718 } 2719 else 2720 { 2721 yylval.name = xstrdup (yytext); 2722 return NAME; 2723 } 2724 } 2725 YY_BREAK 2726case 178: 2727/* rule 178 can match eol */ 2728YY_RULE_SETUP 2729#line 435 "ldlex.l" 2730{ 2731 /* No matter the state, quotes give what's inside. */ 2732 yylval.name = xmemdup (yytext + 1, yyleng - 2, yyleng - 1); 2733 return NAME; 2734 } 2735 YY_BREAK 2736case 179: 2737/* rule 179 can match eol */ 2738YY_RULE_SETUP 2739#line 441 "ldlex.l" 2740{ 2741 lineno++; } 2742 YY_BREAK 2743case 180: 2744YY_RULE_SETUP 2745#line 443 "ldlex.l" 2746{ 2747 /* Eat up whitespace */ } 2748 YY_BREAK 2749case 181: 2750YY_RULE_SETUP 2751#line 445 "ldlex.l" 2752{ 2753 /* Eat up comments */ } 2754 YY_BREAK 2755case 182: 2756YY_RULE_SETUP 2757#line 448 "ldlex.l" 2758{ return *yytext; } 2759 YY_BREAK 2760case 183: 2761YY_RULE_SETUP 2762#line 450 "ldlex.l" 2763{ RTOKEN(GLOBAL); } 2764 YY_BREAK 2765case 184: 2766YY_RULE_SETUP 2767#line 452 "ldlex.l" 2768{ RTOKEN(LOCAL); } 2769 YY_BREAK 2770case 185: 2771YY_RULE_SETUP 2772#line 454 "ldlex.l" 2773{ RTOKEN(EXTERN); } 2774 YY_BREAK 2775case 186: 2776YY_RULE_SETUP 2777#line 456 "ldlex.l" 2778{ yylval.name = xstrdup (yytext); 2779 return VERS_IDENTIFIER; } 2780 YY_BREAK 2781case 187: 2782YY_RULE_SETUP 2783#line 459 "ldlex.l" 2784{ yylval.name = xstrdup (yytext); 2785 return VERS_TAG; } 2786 YY_BREAK 2787case 188: 2788YY_RULE_SETUP 2789#line 462 "ldlex.l" 2790{ BEGIN(VERS_SCRIPT); return *yytext; } 2791 YY_BREAK 2792case 189: 2793YY_RULE_SETUP 2794#line 464 "ldlex.l" 2795{ BEGIN(VERS_NODE); 2796 vers_node_nesting = 0; 2797 return *yytext; 2798 } 2799 YY_BREAK 2800case 190: 2801YY_RULE_SETUP 2802#line 468 "ldlex.l" 2803{ return *yytext; } 2804 YY_BREAK 2805case 191: 2806YY_RULE_SETUP 2807#line 469 "ldlex.l" 2808{ vers_node_nesting++; return *yytext; } 2809 YY_BREAK 2810case 192: 2811YY_RULE_SETUP 2812#line 470 "ldlex.l" 2813{ if (--vers_node_nesting < 0) 2814 BEGIN(VERS_SCRIPT); 2815 return *yytext; 2816 } 2817 YY_BREAK 2818case YY_STATE_EOF(INITIAL): 2819case YY_STATE_EOF(SCRIPT): 2820case YY_STATE_EOF(INPUTLIST): 2821case YY_STATE_EOF(EXPRESSION): 2822case YY_STATE_EOF(MRI): 2823case YY_STATE_EOF(WILD): 2824case YY_STATE_EOF(VERS_START): 2825case YY_STATE_EOF(VERS_SCRIPT): 2826case YY_STATE_EOF(VERS_NODE): 2827#line 475 "ldlex.l" 2828{ 2829 include_stack_ptr--; 2830 if (include_stack_ptr == 0) 2831 { 2832 lineno = 0; 2833 yyterminate (); 2834 } 2835 else 2836 yy_switch_to_buffer (include_stack[include_stack_ptr]); 2837 2838 lineno = lineno_stack[include_stack_ptr]; 2839 input_flags.sysrooted = sysrooted_stack[include_stack_ptr]; 2840 2841 return END; 2842} 2843 YY_BREAK 2844case 193: 2845YY_RULE_SETUP 2846#line 491 "ldlex.l" 2847lex_warn_invalid (" in script", yytext); 2848 YY_BREAK 2849case 194: 2850YY_RULE_SETUP 2851#line 492 "ldlex.l" 2852lex_warn_invalid (" in expression", yytext); 2853 YY_BREAK 2854case 195: 2855YY_RULE_SETUP 2856#line 494 "ldlex.l" 2857ECHO; 2858 YY_BREAK 2859#line 2859 "ldlex.c" 2860 2861 case YY_END_OF_BUFFER: 2862 { 2863 /* Amount of text matched not including the EOB char. */ 2864 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; 2865 2866 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 2867 *yy_cp = (yy_hold_char); 2868 YY_RESTORE_YY_MORE_OFFSET 2869 2870 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 2871 { 2872 /* We're scanning a new file or input source. It's 2873 * possible that this happened because the user 2874 * just pointed yyin at a new source and called 2875 * yylex(). If so, then we have to assure 2876 * consistency between YY_CURRENT_BUFFER and our 2877 * globals. Here is the right place to do so, because 2878 * this is the first action (other than possibly a 2879 * back-up) that will match for the new input source. 2880 */ 2881 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 2882 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; 2883 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 2884 } 2885 2886 /* Note that here we test for yy_c_buf_p "<=" to the position 2887 * of the first EOB in the buffer, since yy_c_buf_p will 2888 * already have been incremented past the NUL character 2889 * (since all states make transitions on EOB to the 2890 * end-of-buffer state). Contrast this with the test 2891 * in input(). 2892 */ 2893 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 2894 { /* This was really a NUL. */ 2895 yy_state_type yy_next_state; 2896 2897 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; 2898 2899 yy_current_state = yy_get_previous_state( ); 2900 2901 /* Okay, we're now positioned to make the NUL 2902 * transition. We couldn't have 2903 * yy_get_previous_state() go ahead and do it 2904 * for us because it doesn't know how to deal 2905 * with the possibility of jamming (and we don't 2906 * want to build jamming into it because then it 2907 * will run more slowly). 2908 */ 2909 2910 yy_next_state = yy_try_NUL_trans( yy_current_state ); 2911 2912 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 2913 2914 if ( yy_next_state ) 2915 { 2916 /* Consume the NUL. */ 2917 yy_cp = ++(yy_c_buf_p); 2918 yy_current_state = yy_next_state; 2919 goto yy_match; 2920 } 2921 2922 else 2923 { 2924 yy_cp = (yy_c_buf_p); 2925 goto yy_find_action; 2926 } 2927 } 2928 2929 else switch ( yy_get_next_buffer( ) ) 2930 { 2931 case EOB_ACT_END_OF_FILE: 2932 { 2933 (yy_did_buffer_switch_on_eof) = 0; 2934 2935 if ( yywrap( ) ) 2936 { 2937 /* Note: because we've taken care in 2938 * yy_get_next_buffer() to have set up 2939 * yytext, we can now set up 2940 * yy_c_buf_p so that if some total 2941 * hoser (like flex itself) wants to 2942 * call the scanner after we return the 2943 * YY_NULL, it'll still work - another 2944 * YY_NULL will get returned. 2945 */ 2946 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; 2947 2948 yy_act = YY_STATE_EOF(YY_START); 2949 goto do_action; 2950 } 2951 2952 else 2953 { 2954 if ( ! (yy_did_buffer_switch_on_eof) ) 2955 YY_NEW_FILE; 2956 } 2957 break; 2958 } 2959 2960 case EOB_ACT_CONTINUE_SCAN: 2961 (yy_c_buf_p) = 2962 (yytext_ptr) + yy_amount_of_matched_text; 2963 2964 yy_current_state = yy_get_previous_state( ); 2965 2966 yy_cp = (yy_c_buf_p); 2967 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 2968 goto yy_match; 2969 2970 case EOB_ACT_LAST_MATCH: 2971 (yy_c_buf_p) = 2972 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; 2973 2974 yy_current_state = yy_get_previous_state( ); 2975 2976 yy_cp = (yy_c_buf_p); 2977 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 2978 goto yy_find_action; 2979 } 2980 break; 2981 } 2982 2983 default: 2984 YY_FATAL_ERROR( 2985 "fatal flex scanner internal error--no action found" ); 2986 } /* end of action switch */ 2987 } /* end of scanning one token */ 2988 } /* end of user's declarations */ 2989} /* end of yylex */ 2990 2991/* yy_get_next_buffer - try to read in a new buffer 2992 * 2993 * Returns a code representing an action: 2994 * EOB_ACT_LAST_MATCH - 2995 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 2996 * EOB_ACT_END_OF_FILE - end of file 2997 */ 2998static int yy_get_next_buffer (void) 2999{ 3000 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 3001 char *source = (yytext_ptr); 3002 int number_to_move, i; 3003 int ret_val; 3004 3005 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) 3006 YY_FATAL_ERROR( 3007 "fatal flex scanner internal error--end of buffer missed" ); 3008 3009 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 3010 { /* Don't try to fill the buffer, so this is an EOF. */ 3011 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) 3012 { 3013 /* We matched a single character, the EOB, so 3014 * treat this as a final EOF. 3015 */ 3016 return EOB_ACT_END_OF_FILE; 3017 } 3018 3019 else 3020 { 3021 /* We matched some text prior to the EOB, first 3022 * process it. 3023 */ 3024 return EOB_ACT_LAST_MATCH; 3025 } 3026 } 3027 3028 /* Try to read more data. */ 3029 3030 /* First move last chars to start of buffer. */ 3031 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); 3032 3033 for ( i = 0; i < number_to_move; ++i ) 3034 *(dest++) = *(source++); 3035 3036 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 3037 /* don't do the read, it's not guaranteed to return an EOF, 3038 * just force an EOF 3039 */ 3040 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; 3041 3042 else 3043 { 3044 int num_to_read = 3045 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 3046 3047 while ( num_to_read <= 0 ) 3048 { /* Not enough room in the buffer - grow it. */ 3049 3050 /* just a shorter name for the current buffer */ 3051 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; 3052 3053 int yy_c_buf_p_offset = 3054 (int) ((yy_c_buf_p) - b->yy_ch_buf); 3055 3056 if ( b->yy_is_our_buffer ) 3057 { 3058 int new_size = b->yy_buf_size * 2; 3059 3060 if ( new_size <= 0 ) 3061 b->yy_buf_size += b->yy_buf_size / 8; 3062 else 3063 b->yy_buf_size *= 2; 3064 3065 b->yy_ch_buf = (char *) 3066 /* Include room in for 2 EOB chars. */ 3067 yyrealloc( (void *) b->yy_ch_buf, 3068 (yy_size_t) (b->yy_buf_size + 2) ); 3069 } 3070 else 3071 /* Can't grow it, we don't own it. */ 3072 b->yy_ch_buf = NULL; 3073 3074 if ( ! b->yy_ch_buf ) 3075 YY_FATAL_ERROR( 3076 "fatal error - scanner input buffer overflow" ); 3077 3078 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 3079 3080 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - 3081 number_to_move - 1; 3082 3083 } 3084 3085 if ( num_to_read > YY_READ_BUF_SIZE ) 3086 num_to_read = YY_READ_BUF_SIZE; 3087 3088 /* Read in more data. */ 3089 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 3090 (yy_n_chars), num_to_read ); 3091 3092 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 3093 } 3094 3095 if ( (yy_n_chars) == 0 ) 3096 { 3097 if ( number_to_move == YY_MORE_ADJ ) 3098 { 3099 ret_val = EOB_ACT_END_OF_FILE; 3100 yyrestart( yyin ); 3101 } 3102 3103 else 3104 { 3105 ret_val = EOB_ACT_LAST_MATCH; 3106 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 3107 YY_BUFFER_EOF_PENDING; 3108 } 3109 } 3110 3111 else 3112 ret_val = EOB_ACT_CONTINUE_SCAN; 3113 3114 if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { 3115 /* Extend the array by 50%, plus the number we really need. */ 3116 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); 3117 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( 3118 (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); 3119 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 3120 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); 3121 /* "- 2" to take care of EOB's */ 3122 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); 3123 } 3124 3125 (yy_n_chars) += number_to_move; 3126 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; 3127 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; 3128 3129 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 3130 3131 return ret_val; 3132} 3133 3134/* yy_get_previous_state - get the state just before the EOB char was reached */ 3135 3136 static yy_state_type yy_get_previous_state (void) 3137{ 3138 yy_state_type yy_current_state; 3139 char *yy_cp; 3140 3141 yy_current_state = (yy_start); 3142 3143 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) 3144 { 3145 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 3146 if ( yy_accept[yy_current_state] ) 3147 { 3148 (yy_last_accepting_state) = yy_current_state; 3149 (yy_last_accepting_cpos) = yy_cp; 3150 } 3151 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 3152 { 3153 yy_current_state = (int) yy_def[yy_current_state]; 3154 if ( yy_current_state >= 1207 ) 3155 yy_c = yy_meta[yy_c]; 3156 } 3157 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 3158 } 3159 3160 return yy_current_state; 3161} 3162 3163/* yy_try_NUL_trans - try to make a transition on the NUL character 3164 * 3165 * synopsis 3166 * next_state = yy_try_NUL_trans( current_state ); 3167 */ 3168 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) 3169{ 3170 int yy_is_jam; 3171 char *yy_cp = (yy_c_buf_p); 3172 3173 YY_CHAR yy_c = 1; 3174 if ( yy_accept[yy_current_state] ) 3175 { 3176 (yy_last_accepting_state) = yy_current_state; 3177 (yy_last_accepting_cpos) = yy_cp; 3178 } 3179 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 3180 { 3181 yy_current_state = (int) yy_def[yy_current_state]; 3182 if ( yy_current_state >= 1207 ) 3183 yy_c = yy_meta[yy_c]; 3184 } 3185 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 3186 yy_is_jam = (yy_current_state == 1206); 3187 3188 return yy_is_jam ? 0 : yy_current_state; 3189} 3190 3191#ifndef YY_NO_UNPUT 3192 3193#endif 3194 3195#ifndef YY_NO_INPUT 3196#ifdef __cplusplus 3197 static int yyinput (void) 3198#else 3199 static int input (void) 3200#endif 3201 3202{ 3203 int c; 3204 3205 *(yy_c_buf_p) = (yy_hold_char); 3206 3207 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) 3208 { 3209 /* yy_c_buf_p now points to the character we want to return. 3210 * If this occurs *before* the EOB characters, then it's a 3211 * valid NUL; if not, then we've hit the end of the buffer. 3212 */ 3213 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 3214 /* This was really a NUL. */ 3215 *(yy_c_buf_p) = '\0'; 3216 3217 else 3218 { /* need more input */ 3219 int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); 3220 ++(yy_c_buf_p); 3221 3222 switch ( yy_get_next_buffer( ) ) 3223 { 3224 case EOB_ACT_LAST_MATCH: 3225 /* This happens because yy_g_n_b() 3226 * sees that we've accumulated a 3227 * token and flags that we need to 3228 * try matching the token before 3229 * proceeding. But for input(), 3230 * there's no matching to consider. 3231 * So convert the EOB_ACT_LAST_MATCH 3232 * to EOB_ACT_END_OF_FILE. 3233 */ 3234 3235 /* Reset buffer status. */ 3236 yyrestart( yyin ); 3237 3238 /*FALLTHROUGH*/ 3239 3240 case EOB_ACT_END_OF_FILE: 3241 { 3242 if ( yywrap( ) ) 3243 return 0; 3244 3245 if ( ! (yy_did_buffer_switch_on_eof) ) 3246 YY_NEW_FILE; 3247#ifdef __cplusplus 3248 return yyinput(); 3249#else 3250 return input(); 3251#endif 3252 } 3253 3254 case EOB_ACT_CONTINUE_SCAN: 3255 (yy_c_buf_p) = (yytext_ptr) + offset; 3256 break; 3257 } 3258 } 3259 } 3260 3261 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ 3262 *(yy_c_buf_p) = '\0'; /* preserve yytext */ 3263 (yy_hold_char) = *++(yy_c_buf_p); 3264 3265 return c; 3266} 3267#endif /* ifndef YY_NO_INPUT */ 3268 3269/** Immediately switch to a different input stream. 3270 * @param input_file A readable stream. 3271 * 3272 * @note This function does not reset the start condition to @c INITIAL . 3273 */ 3274 void yyrestart (FILE * input_file ) 3275{ 3276 3277 if ( ! YY_CURRENT_BUFFER ){ 3278 yyensure_buffer_stack (); 3279 YY_CURRENT_BUFFER_LVALUE = 3280 yy_create_buffer( yyin, YY_BUF_SIZE ); 3281 } 3282 3283 yy_init_buffer( YY_CURRENT_BUFFER, input_file ); 3284 yy_load_buffer_state( ); 3285} 3286 3287/** Switch to a different input buffer. 3288 * @param new_buffer The new input buffer. 3289 * 3290 */ 3291 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) 3292{ 3293 3294 /* TODO. We should be able to replace this entire function body 3295 * with 3296 * yypop_buffer_state(); 3297 * yypush_buffer_state(new_buffer); 3298 */ 3299 yyensure_buffer_stack (); 3300 if ( YY_CURRENT_BUFFER == new_buffer ) 3301 return; 3302 3303 if ( YY_CURRENT_BUFFER ) 3304 { 3305 /* Flush out information for old buffer. */ 3306 *(yy_c_buf_p) = (yy_hold_char); 3307 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 3308 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 3309 } 3310 3311 YY_CURRENT_BUFFER_LVALUE = new_buffer; 3312 yy_load_buffer_state( ); 3313 3314 /* We don't actually know whether we did this switch during 3315 * EOF (yywrap()) processing, but the only time this flag 3316 * is looked at is after yywrap() is called, so it's safe 3317 * to go ahead and always set it. 3318 */ 3319 (yy_did_buffer_switch_on_eof) = 1; 3320} 3321 3322static void yy_load_buffer_state (void) 3323{ 3324 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 3325 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 3326 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 3327 (yy_hold_char) = *(yy_c_buf_p); 3328} 3329 3330/** Allocate and initialize an input buffer state. 3331 * @param file A readable stream. 3332 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. 3333 * 3334 * @return the allocated buffer state. 3335 */ 3336 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) 3337{ 3338 YY_BUFFER_STATE b; 3339 3340 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); 3341 if ( ! b ) 3342 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 3343 3344 b->yy_buf_size = size; 3345 3346 /* yy_ch_buf has to be 2 characters longer than the size given because 3347 * we need to put in 2 end-of-buffer characters. 3348 */ 3349 b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); 3350 if ( ! b->yy_ch_buf ) 3351 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 3352 3353 b->yy_is_our_buffer = 1; 3354 3355 yy_init_buffer( b, file ); 3356 3357 return b; 3358} 3359 3360/** Destroy the buffer. 3361 * @param b a buffer created with yy_create_buffer() 3362 * 3363 */ 3364 void yy_delete_buffer (YY_BUFFER_STATE b ) 3365{ 3366 3367 if ( ! b ) 3368 return; 3369 3370 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 3371 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 3372 3373 if ( b->yy_is_our_buffer ) 3374 yyfree( (void *) b->yy_ch_buf ); 3375 3376 yyfree( (void *) b ); 3377} 3378 3379/* Initializes or reinitializes a buffer. 3380 * This function is sometimes called more than once on the same buffer, 3381 * such as during a yyrestart() or at EOF. 3382 */ 3383 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) 3384 3385{ 3386 int oerrno = errno; 3387 3388 yy_flush_buffer( b ); 3389 3390 b->yy_input_file = file; 3391 b->yy_fill_buffer = 1; 3392 3393 /* If b is the current buffer, then yy_init_buffer was _probably_ 3394 * called from yyrestart() or through yy_get_next_buffer. 3395 * In that case, we don't want to reset the lineno or column. 3396 */ 3397 if (b != YY_CURRENT_BUFFER){ 3398 b->yy_bs_lineno = 1; 3399 b->yy_bs_column = 0; 3400 } 3401 3402 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 3403 3404 errno = oerrno; 3405} 3406 3407/** Discard all buffered characters. On the next scan, YY_INPUT will be called. 3408 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. 3409 * 3410 */ 3411 void yy_flush_buffer (YY_BUFFER_STATE b ) 3412{ 3413 if ( ! b ) 3414 return; 3415 3416 b->yy_n_chars = 0; 3417 3418 /* We always need two end-of-buffer characters. The first causes 3419 * a transition to the end-of-buffer state. The second causes 3420 * a jam in that state. 3421 */ 3422 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 3423 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 3424 3425 b->yy_buf_pos = &b->yy_ch_buf[0]; 3426 3427 b->yy_at_bol = 1; 3428 b->yy_buffer_status = YY_BUFFER_NEW; 3429 3430 if ( b == YY_CURRENT_BUFFER ) 3431 yy_load_buffer_state( ); 3432} 3433 3434/** Pushes the new state onto the stack. The new state becomes 3435 * the current state. This function will allocate the stack 3436 * if necessary. 3437 * @param new_buffer The new state. 3438 * 3439 */ 3440void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) 3441{ 3442 if (new_buffer == NULL) 3443 return; 3444 3445 yyensure_buffer_stack(); 3446 3447 /* This block is copied from yy_switch_to_buffer. */ 3448 if ( YY_CURRENT_BUFFER ) 3449 { 3450 /* Flush out information for old buffer. */ 3451 *(yy_c_buf_p) = (yy_hold_char); 3452 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 3453 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 3454 } 3455 3456 /* Only push if top exists. Otherwise, replace top. */ 3457 if (YY_CURRENT_BUFFER) 3458 (yy_buffer_stack_top)++; 3459 YY_CURRENT_BUFFER_LVALUE = new_buffer; 3460 3461 /* copied from yy_switch_to_buffer. */ 3462 yy_load_buffer_state( ); 3463 (yy_did_buffer_switch_on_eof) = 1; 3464} 3465 3466/** Removes and deletes the top of the stack, if present. 3467 * The next element becomes the new top. 3468 * 3469 */ 3470void yypop_buffer_state (void) 3471{ 3472 if (!YY_CURRENT_BUFFER) 3473 return; 3474 3475 yy_delete_buffer(YY_CURRENT_BUFFER ); 3476 YY_CURRENT_BUFFER_LVALUE = NULL; 3477 if ((yy_buffer_stack_top) > 0) 3478 --(yy_buffer_stack_top); 3479 3480 if (YY_CURRENT_BUFFER) { 3481 yy_load_buffer_state( ); 3482 (yy_did_buffer_switch_on_eof) = 1; 3483 } 3484} 3485 3486/* Allocates the stack if it does not exist. 3487 * Guarantees space for at least one push. 3488 */ 3489static void yyensure_buffer_stack (void) 3490{ 3491 yy_size_t num_to_alloc; 3492 3493 if (!(yy_buffer_stack)) { 3494 3495 /* First allocation is just for 2 elements, since we don't know if this 3496 * scanner will even need a stack. We use 2 instead of 1 to avoid an 3497 * immediate realloc on the next call. 3498 */ 3499 num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 3500 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc 3501 (num_to_alloc * sizeof(struct yy_buffer_state*) 3502 ); 3503 if ( ! (yy_buffer_stack) ) 3504 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 3505 3506 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 3507 3508 (yy_buffer_stack_max) = num_to_alloc; 3509 (yy_buffer_stack_top) = 0; 3510 return; 3511 } 3512 3513 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ 3514 3515 /* Increase the buffer to prepare for a possible push. */ 3516 yy_size_t grow_size = 8 /* arbitrary grow size */; 3517 3518 num_to_alloc = (yy_buffer_stack_max) + grow_size; 3519 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc 3520 ((yy_buffer_stack), 3521 num_to_alloc * sizeof(struct yy_buffer_state*) 3522 ); 3523 if ( ! (yy_buffer_stack) ) 3524 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 3525 3526 /* zero only the new slots.*/ 3527 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 3528 (yy_buffer_stack_max) = num_to_alloc; 3529 } 3530} 3531 3532/** Setup the input buffer state to scan directly from a user-specified character buffer. 3533 * @param base the character buffer 3534 * @param size the size in bytes of the character buffer 3535 * 3536 * @return the newly allocated buffer state object. 3537 */ 3538YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) 3539{ 3540 YY_BUFFER_STATE b; 3541 3542 if ( size < 2 || 3543 base[size-2] != YY_END_OF_BUFFER_CHAR || 3544 base[size-1] != YY_END_OF_BUFFER_CHAR ) 3545 /* They forgot to leave room for the EOB's. */ 3546 return NULL; 3547 3548 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); 3549 if ( ! b ) 3550 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 3551 3552 b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 3553 b->yy_buf_pos = b->yy_ch_buf = base; 3554 b->yy_is_our_buffer = 0; 3555 b->yy_input_file = NULL; 3556 b->yy_n_chars = b->yy_buf_size; 3557 b->yy_is_interactive = 0; 3558 b->yy_at_bol = 1; 3559 b->yy_fill_buffer = 0; 3560 b->yy_buffer_status = YY_BUFFER_NEW; 3561 3562 yy_switch_to_buffer( b ); 3563 3564 return b; 3565} 3566 3567/** Setup the input buffer state to scan a string. The next call to yylex() will 3568 * scan from a @e copy of @a str. 3569 * @param yystr a NUL-terminated string to scan 3570 * 3571 * @return the newly allocated buffer state object. 3572 * @note If you want to scan bytes that may contain NUL values, then use 3573 * yy_scan_bytes() instead. 3574 */ 3575YY_BUFFER_STATE yy_scan_string (const char * yystr ) 3576{ 3577 3578 return yy_scan_bytes( yystr, (int) strlen(yystr) ); 3579} 3580 3581/** Setup the input buffer state to scan the given bytes. The next call to yylex() will 3582 * scan from a @e copy of @a bytes. 3583 * @param yybytes the byte buffer to scan 3584 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. 3585 * 3586 * @return the newly allocated buffer state object. 3587 */ 3588YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) 3589{ 3590 YY_BUFFER_STATE b; 3591 char *buf; 3592 yy_size_t n; 3593 int i; 3594 3595 /* Get memory for full buffer, including space for trailing EOB's. */ 3596 n = (yy_size_t) (_yybytes_len + 2); 3597 buf = (char *) yyalloc( n ); 3598 if ( ! buf ) 3599 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 3600 3601 for ( i = 0; i < _yybytes_len; ++i ) 3602 buf[i] = yybytes[i]; 3603 3604 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; 3605 3606 b = yy_scan_buffer( buf, n ); 3607 if ( ! b ) 3608 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 3609 3610 /* It's okay to grow etc. this buffer, and we should throw it 3611 * away when we're done. 3612 */ 3613 b->yy_is_our_buffer = 1; 3614 3615 return b; 3616} 3617 3618#ifndef YY_EXIT_FAILURE 3619#define YY_EXIT_FAILURE 2 3620#endif 3621 3622static void yynoreturn yy_fatal_error (const char* msg ) 3623{ 3624 fprintf( stderr, "%s\n", msg ); 3625 exit( YY_EXIT_FAILURE ); 3626} 3627 3628/* Redefine yyless() so it works in section 3 code. */ 3629 3630#undef yyless 3631#define yyless(n) \ 3632 do \ 3633 { \ 3634 /* Undo effects of setting up yytext. */ \ 3635 int yyless_macro_arg = (n); \ 3636 YY_LESS_LINENO(yyless_macro_arg);\ 3637 yytext[yyleng] = (yy_hold_char); \ 3638 (yy_c_buf_p) = yytext + yyless_macro_arg; \ 3639 (yy_hold_char) = *(yy_c_buf_p); \ 3640 *(yy_c_buf_p) = '\0'; \ 3641 yyleng = yyless_macro_arg; \ 3642 } \ 3643 while ( 0 ) 3644 3645/* Accessor methods (get/set functions) to struct members. */ 3646 3647/** Get the current line number. 3648 * 3649 */ 3650int yyget_lineno (void) 3651{ 3652 3653 return yylineno; 3654} 3655 3656/** Get the input stream. 3657 * 3658 */ 3659FILE *yyget_in (void) 3660{ 3661 return yyin; 3662} 3663 3664/** Get the output stream. 3665 * 3666 */ 3667FILE *yyget_out (void) 3668{ 3669 return yyout; 3670} 3671 3672/** Get the length of the current token. 3673 * 3674 */ 3675int yyget_leng (void) 3676{ 3677 return yyleng; 3678} 3679 3680/** Get the current token. 3681 * 3682 */ 3683 3684char *yyget_text (void) 3685{ 3686 return yytext; 3687} 3688 3689/** Set the current line number. 3690 * @param _line_number line number 3691 * 3692 */ 3693void yyset_lineno (int _line_number ) 3694{ 3695 3696 yylineno = _line_number; 3697} 3698 3699/** Set the input stream. This does not discard the current 3700 * input buffer. 3701 * @param _in_str A readable stream. 3702 * 3703 * @see yy_switch_to_buffer 3704 */ 3705void yyset_in (FILE * _in_str ) 3706{ 3707 yyin = _in_str ; 3708} 3709 3710void yyset_out (FILE * _out_str ) 3711{ 3712 yyout = _out_str ; 3713} 3714 3715int yyget_debug (void) 3716{ 3717 return yy_flex_debug; 3718} 3719 3720void yyset_debug (int _bdebug ) 3721{ 3722 yy_flex_debug = _bdebug ; 3723} 3724 3725static int yy_init_globals (void) 3726{ 3727 /* Initialization is the same as for the non-reentrant scanner. 3728 * This function is called from yylex_destroy(), so don't allocate here. 3729 */ 3730 3731 (yy_buffer_stack) = NULL; 3732 (yy_buffer_stack_top) = 0; 3733 (yy_buffer_stack_max) = 0; 3734 (yy_c_buf_p) = NULL; 3735 (yy_init) = 0; 3736 (yy_start) = 0; 3737 3738/* Defined in main.c */ 3739#ifdef YY_STDINIT 3740 yyin = stdin; 3741 yyout = stdout; 3742#else 3743 yyin = NULL; 3744 yyout = NULL; 3745#endif 3746 3747 /* For future reference: Set errno on error, since we are called by 3748 * yylex_init() 3749 */ 3750 return 0; 3751} 3752 3753/* yylex_destroy is for both reentrant and non-reentrant scanners. */ 3754int yylex_destroy (void) 3755{ 3756 3757 /* Pop the buffer stack, destroying each element. */ 3758 while(YY_CURRENT_BUFFER){ 3759 yy_delete_buffer( YY_CURRENT_BUFFER ); 3760 YY_CURRENT_BUFFER_LVALUE = NULL; 3761 yypop_buffer_state(); 3762 } 3763 3764 /* Destroy the stack itself. */ 3765 yyfree((yy_buffer_stack) ); 3766 (yy_buffer_stack) = NULL; 3767 3768 /* Reset the globals. This is important in a non-reentrant scanner so the next time 3769 * yylex() is called, initialization will occur. */ 3770 yy_init_globals( ); 3771 3772 return 0; 3773} 3774 3775/* 3776 * Internal utility routines. 3777 */ 3778 3779#ifndef yytext_ptr 3780static void yy_flex_strncpy (char* s1, const char * s2, int n ) 3781{ 3782 3783 int i; 3784 for ( i = 0; i < n; ++i ) 3785 s1[i] = s2[i]; 3786} 3787#endif 3788 3789#ifdef YY_NEED_STRLEN 3790static int yy_flex_strlen (const char * s ) 3791{ 3792 int n; 3793 for ( n = 0; s[n]; ++n ) 3794 ; 3795 3796 return n; 3797} 3798#endif 3799 3800void *yyalloc (yy_size_t size ) 3801{ 3802 return malloc(size); 3803} 3804 3805void *yyrealloc (void * ptr, yy_size_t size ) 3806{ 3807 3808 /* The cast to (char *) in the following accommodates both 3809 * implementations that use char* generic pointers, and those 3810 * that use void* generic pointers. It works with the latter 3811 * because both ANSI C and C++ allow castless assignment from 3812 * any pointer type to void*, and deal with argument conversions 3813 * as though doing an assignment. 3814 */ 3815 return realloc(ptr, size); 3816} 3817 3818void yyfree (void * ptr ) 3819{ 3820 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 3821} 3822 3823#define YYTABLES_NAME "yytables" 3824 3825#line 494 "ldlex.l" 3826 3827 3828 3829/* Switch flex to reading script file NAME, open on FILE, 3830 saving the current input info on the include stack. */ 3831 3832void 3833lex_push_file (FILE *file, const char *name, unsigned int sysrooted) 3834{ 3835 if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 3836 { 3837 einfo (_("%F:includes nested too deeply\n")); 3838 } 3839 file_name_stack[include_stack_ptr] = name; 3840 lineno_stack[include_stack_ptr] = lineno; 3841 sysrooted_stack[include_stack_ptr] = input_flags.sysrooted; 3842 include_stack[include_stack_ptr] = YY_CURRENT_BUFFER; 3843 3844 include_stack_ptr++; 3845 lineno = 1; 3846 input_flags.sysrooted = sysrooted; 3847 yyin = file; 3848 yy_switch_to_buffer (yy_create_buffer (yyin, YY_BUF_SIZE)); 3849} 3850 3851/* Return a newly created flex input buffer containing STRING, 3852 which is SIZE bytes long. */ 3853 3854static YY_BUFFER_STATE 3855yy_create_string_buffer (const char *string, size_t size) 3856{ 3857 YY_BUFFER_STATE b; 3858 3859 b = xmalloc (sizeof (struct yy_buffer_state)); 3860 b->yy_input_file = 0; 3861 b->yy_buf_size = size; 3862 3863 /* yy_ch_buf has to be 2 characters longer than the size given because 3864 we need to put in 2 end-of-buffer characters. */ 3865 b->yy_ch_buf = xmalloc ((size_t) b->yy_buf_size + 3); 3866 3867 b->yy_ch_buf[0] = '\n'; 3868 strcpy (b->yy_ch_buf+1, string); 3869 b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR; 3870 b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR; 3871 b->yy_n_chars = size+1; 3872 b->yy_buf_pos = &b->yy_ch_buf[1]; 3873 3874 b->yy_is_our_buffer = 1; 3875 b->yy_is_interactive = 0; 3876 b->yy_at_bol = 1; 3877 b->yy_fill_buffer = 0; 3878 3879 /* flex 2.4.7 changed the interface. FIXME: We should not be using 3880 a flex internal interface in the first place! */ 3881#ifdef YY_BUFFER_NEW 3882 b->yy_buffer_status = YY_BUFFER_NEW; 3883#else 3884 b->yy_eof_status = EOF_NOT_SEEN; 3885#endif 3886 3887 return b; 3888} 3889 3890/* Switch flex to reading from STRING, saving the current input info 3891 on the include stack. */ 3892 3893void 3894lex_redirect (const char *string, const char *fake_filename, unsigned int count) 3895{ 3896 YY_BUFFER_STATE tmp; 3897 3898 yy_init = 0; 3899 if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 3900 { 3901 einfo (_("%F: macros nested too deeply\n")); 3902 } 3903 file_name_stack[include_stack_ptr] = fake_filename; 3904 lineno_stack[include_stack_ptr] = lineno; 3905 include_stack[include_stack_ptr] = YY_CURRENT_BUFFER; 3906 include_stack_ptr++; 3907 lineno = count; 3908 tmp = yy_create_string_buffer (string, strlen (string)); 3909 yy_switch_to_buffer (tmp); 3910} 3911 3912/* Functions to switch to a different flex start condition, 3913 saving the current start condition on `state_stack'. */ 3914 3915static int state_stack[MAX_INCLUDE_DEPTH * 2]; 3916static int *state_stack_p = state_stack; 3917 3918void 3919ldlex_script (void) 3920{ 3921 *(state_stack_p)++ = yy_start; 3922 BEGIN (SCRIPT); 3923} 3924 3925void 3926ldlex_inputlist (void) 3927{ 3928 *(state_stack_p)++ = yy_start; 3929 BEGIN (INPUTLIST); 3930} 3931 3932void 3933ldlex_mri_script (void) 3934{ 3935 *(state_stack_p)++ = yy_start; 3936 BEGIN (MRI); 3937} 3938 3939void 3940ldlex_version_script (void) 3941{ 3942 *(state_stack_p)++ = yy_start; 3943 BEGIN (VERS_START); 3944} 3945 3946void 3947ldlex_version_file (void) 3948{ 3949 *(state_stack_p)++ = yy_start; 3950 BEGIN (VERS_SCRIPT); 3951} 3952 3953void 3954ldlex_expression (void) 3955{ 3956 *(state_stack_p)++ = yy_start; 3957 BEGIN (EXPRESSION); 3958} 3959 3960void 3961ldlex_wild (void) 3962{ 3963 *(state_stack_p)++ = yy_start; 3964 BEGIN (WILD); 3965} 3966 3967void 3968ldlex_popstate (void) 3969{ 3970 yy_start = *(--state_stack_p); 3971} 3972 3973/* In cases where the parser needs to look ahead and the context 3974 changes from expression to script or vice-versa, throw away a 3975 NAME. What constitutes a NAME depends on context. */ 3976 3977void 3978ldlex_backup (void) 3979{ 3980 yyless (0); 3981} 3982 3983/* Return the current file name, or the previous file if no file is 3984 current. */ 3985 3986const char* 3987ldlex_filename (void) 3988{ 3989 return file_name_stack[include_stack_ptr - (include_stack_ptr != 0)]; 3990} 3991 3992 3993/* Place up to MAX_SIZE characters in BUF and return 3994 either the number of characters read, or 0 to indicate EOF. */ 3995 3996static int 3997yy_input (char *buf, int max_size) 3998{ 3999 int result = 0; 4000 if (YY_CURRENT_BUFFER->yy_input_file) 4001 { 4002 if (yyin) 4003 { 4004 result = fread (buf, 1, max_size, yyin); 4005 if (result < max_size && ferror (yyin)) 4006 einfo (_("%F%P: read in flex scanner failed\n")); 4007 } 4008 } 4009 return result; 4010} 4011 4012/* Eat the rest of a C-style comment. */ 4013 4014static void 4015comment (void) 4016{ 4017 int c; 4018 4019 while (1) 4020 { 4021 c = input(); 4022 while (c != '*' && c != 0) 4023 { 4024 if (c == '\n') 4025 lineno++; 4026 c = input(); 4027 } 4028 4029 if (c == '*') 4030 { 4031 c = input(); 4032 while (c == '*') 4033 c = input(); 4034 if (c == '/') 4035 break; /* found the end */ 4036 } 4037 4038 if (c == '\n') 4039 lineno++; 4040 4041 if (c == 0) 4042 { 4043 einfo (_("%F%P: EOF in comment\n")); 4044 break; 4045 } 4046 } 4047} 4048 4049/* Warn the user about a garbage character WHAT in the input 4050 in context WHERE. */ 4051 4052static void 4053lex_warn_invalid (char *where, char *what) 4054{ 4055 char buf[5]; 4056 4057 /* If we have found an input file whose format we do not recognize, 4058 and we are therefore treating it as a linker script, and we find 4059 an invalid character, then most likely this is a real object file 4060 of some different format. Treat it as such. */ 4061 if (ldfile_assumed_script) 4062 { 4063 bfd_set_error (bfd_error_file_not_recognized); 4064 einfo (_("%F%s: file not recognized: %E\n"), ldlex_filename ()); 4065 } 4066 4067 if (! ISPRINT (*what)) 4068 { 4069 sprintf (buf, "\\%03o", *(unsigned char *) what); 4070 what = buf; 4071 } 4072 4073 einfo (_("%P:%pS: ignoring invalid character `%s'%s\n"), NULL, what, where); 4074} 4075 4076