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