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