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