1/* $OpenBSD: flex.skl,v 1.11 2010/08/04 18:24:50 millert Exp $ */ 2 3/* A lexical scanner generated by flex */ 4 5/* Scanner skeleton version: 6 * $Header: /home/cvs/src/usr.bin/lex/flex.skl,v 1.11 2010/08/04 18:24:50 millert Exp $ 7 */ 8 9#define FLEX_SCANNER 10#define YY_FLEX_MAJOR_VERSION 2 11#define YY_FLEX_MINOR_VERSION 5 12 13%- 14#include <stdio.h> 15#include <errno.h> 16%+ 17#include <cerrno> 18%* 19 20 21/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ 22#ifdef c_plusplus 23#ifndef __cplusplus 24#define __cplusplus 25#endif 26#endif 27 28 29#ifdef __cplusplus 30 31#include <stdlib.h> 32%+ 33#include <iosfwd> 34%* 35#include <unistd.h> 36 37/* Use prototypes in function declarations. */ 38#define YY_USE_PROTOS 39 40/* The "const" storage-class-modifier is valid. */ 41#define YY_USE_CONST 42 43#else /* ! __cplusplus */ 44 45#ifdef __STDC__ 46 47#define YY_USE_PROTOS 48#define YY_USE_CONST 49 50#endif /* __STDC__ */ 51#endif /* ! __cplusplus */ 52 53#ifdef __TURBOC__ 54 #pragma warn -rch 55 #pragma warn -use 56#include <io.h> 57#include <stdlib.h> 58#define YY_USE_CONST 59#define YY_USE_PROTOS 60#endif 61 62#ifdef YY_USE_CONST 63#define yyconst const 64#else 65#define yyconst 66#endif 67 68 69#ifdef YY_USE_PROTOS 70#define YY_PROTO(proto) proto 71#else 72#define YY_PROTO(proto) () 73#endif 74 75/* Returned upon end-of-file. */ 76#define YY_NULL 0 77 78/* Promotes a possibly negative, possibly signed char to an unsigned 79 * integer for use as an array index. If the signed char is negative, 80 * we want to instead treat it as an 8-bit unsigned char, hence the 81 * double cast. 82 */ 83#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 84 85/* Enter a start condition. This macro really ought to take a parameter, 86 * but we do it the disgusting crufty way forced on us by the ()-less 87 * definition of BEGIN. 88 */ 89#define BEGIN yy_start = 1 + 2 * 90 91/* Translate the current start state into a value that can be later handed 92 * to BEGIN to return to the state. The YYSTATE alias is for lex 93 * compatibility. 94 */ 95#define YY_START ((yy_start - 1) / 2) 96#define YYSTATE YY_START 97 98/* Action number for EOF rule of a given start state. */ 99#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 100 101/* Special action meaning "start processing a new file". */ 102#define YY_NEW_FILE yyrestart( yyin ) 103 104#define YY_END_OF_BUFFER_CHAR 0 105 106/* Size of default input buffer. */ 107#define YY_BUF_SIZE 16384 108 109typedef struct yy_buffer_state *YY_BUFFER_STATE; 110 111extern int yyleng; 112%- 113extern FILE *yyin, *yyout; 114%* 115 116#define EOB_ACT_CONTINUE_SCAN 0 117#define EOB_ACT_END_OF_FILE 1 118#define EOB_ACT_LAST_MATCH 2 119 120/* The funky do-while in the following #define is used to turn the definition 121 * int a single C statement (which needs a semi-colon terminator). This 122 * avoids problems with code like: 123 * 124 * if ( condition_holds ) 125 * yyless( 5 ); 126 * else 127 * do_something_else(); 128 * 129 * Prior to using the do-while the compiler would get upset at the 130 * "else" because it interpreted the "if" statement as being all 131 * done when it reached the ';' after the yyless() call. 132 */ 133 134/* Return all but the first 'n' matched characters back to the input stream. */ 135 136#define yyless(n) \ 137 do \ 138 { \ 139 /* Undo effects of setting up yytext. */ \ 140 *yy_cp = yy_hold_char; \ 141 YY_RESTORE_YY_MORE_OFFSET \ 142 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ 143 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 144 } \ 145 while ( 0 ) 146 147#define unput(c) yyunput( c, yytext_ptr ) 148 149/* The following is because we cannot portably get our hands on size_t 150 * (without autoconf's help, which isn't available because we want 151 * flex-generated scanners to compile on their own). 152 */ 153typedef unsigned int yy_size_t; 154 155 156struct yy_buffer_state 157 { 158%- 159 FILE *yy_input_file; 160%+ 161 std::istream* yy_input_file; 162%* 163 164 char *yy_ch_buf; /* input buffer */ 165 char *yy_buf_pos; /* current position in input buffer */ 166 167 /* Size of input buffer in bytes, not including room for EOB 168 * characters. 169 */ 170 yy_size_t yy_buf_size; 171 172 /* Number of characters read into yy_ch_buf, not including EOB 173 * characters. 174 */ 175 int yy_n_chars; 176 177 /* Whether we "own" the buffer - i.e., we know we created it, 178 * and can realloc() it to grow it, and should free() it to 179 * delete it. 180 */ 181 int yy_is_our_buffer; 182 183 /* Whether this is an "interactive" input source; if so, and 184 * if we're using stdio for input, then we want to use getc() 185 * instead of fread(), to make sure we stop fetching input after 186 * each newline. 187 */ 188 int yy_is_interactive; 189 190 /* Whether we're considered to be at the beginning of a line. 191 * If so, '^' rules will be active on the next match, otherwise 192 * not. 193 */ 194 int yy_at_bol; 195 196 /* Whether to try to fill the input buffer when we reach the 197 * end of it. 198 */ 199 int yy_fill_buffer; 200 201 int yy_buffer_status; 202#define YY_BUFFER_NEW 0 203#define YY_BUFFER_NORMAL 1 204 /* When an EOF's been seen but there's still some text to process 205 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 206 * shouldn't try reading from the input source any more. We might 207 * still have a bunch of tokens to match, though, because of 208 * possible backing-up. 209 * 210 * When we actually see the EOF, we change the status to "new" 211 * (via yyrestart()), so that the user can continue scanning by 212 * just pointing yyin at a new input file. 213 */ 214#define YY_BUFFER_EOF_PENDING 2 215 }; 216 217%- Standard (non-C++) definition 218static YY_BUFFER_STATE yy_current_buffer = 0; 219%* 220 221/* We provide macros for accessing buffer states in case in the 222 * future we want to put the buffer states in a more general 223 * "scanner state". 224 */ 225#define YY_CURRENT_BUFFER yy_current_buffer 226 227 228%- Standard (non-C++) definition 229/* yy_hold_char holds the character lost when yytext is formed. */ 230static char yy_hold_char; 231 232static int yy_n_chars; /* number of characters read into yy_ch_buf */ 233 234 235int yyleng; 236 237/* Points to current character in buffer. */ 238static char *yy_c_buf_p = (char *) 0; 239static int yy_init = 1; /* whether we need to initialize */ 240static int yy_start = 0; /* start state number */ 241 242/* Flag which is used to allow yywrap()'s to do buffer switches 243 * instead of setting up a fresh yyin. A bit of a hack ... 244 */ 245static int yy_did_buffer_switch_on_eof; 246 247void yyrestart YY_PROTO(( FILE *input_file )); 248 249void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); 250void yy_load_buffer_state YY_PROTO(( void )); 251YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); 252void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); 253void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); 254void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); 255#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) 256 257YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); 258YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); 259YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); 260%* 261 262static void *yy_flex_alloc YY_PROTO(( yy_size_t )); 263static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); 264static void yy_flex_free YY_PROTO(( void * )); 265 266#define yy_new_buffer yy_create_buffer 267 268#define yy_set_interactive(is_interactive) \ 269 { \ 270 if ( ! yy_current_buffer ) \ 271 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 272 yy_current_buffer->yy_is_interactive = is_interactive; \ 273 } 274 275#define yy_set_bol(at_bol) \ 276 { \ 277 if ( ! yy_current_buffer ) \ 278 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 279 yy_current_buffer->yy_at_bol = at_bol; \ 280 } 281 282#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) 283 284%% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here 285 286%- Standard (non-C++) definition 287static yy_state_type yy_get_previous_state YY_PROTO(( void )); 288static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); 289static int yy_get_next_buffer YY_PROTO(( void )); 290static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); 291%* 292 293/* Done after the current pattern has been matched and before the 294 * corresponding action - sets up yytext. 295 */ 296#define YY_DO_BEFORE_ACTION \ 297 yytext_ptr = yy_bp; \ 298%% code to fiddle yytext and yyleng for yymore() goes here 299 yy_hold_char = *yy_cp; \ 300 *yy_cp = '\0'; \ 301%% code to copy yytext_ptr to yytext[] goes here, if %array 302 yy_c_buf_p = yy_cp; 303 304%% data tables for the DFA and the user's section 1 definitions go here 305 306/* Macros after this point can all be overridden by user definitions in 307 * section 1. 308 */ 309 310#ifndef YY_SKIP_YYWRAP 311#ifdef __cplusplus 312extern "C" int yywrap YY_PROTO(( void )); 313#else 314extern int yywrap YY_PROTO(( void )); 315#endif 316#endif 317 318%- 319#ifndef YY_NO_UNPUT 320static void yyunput YY_PROTO(( int c, char *buf_ptr )); 321#endif 322%* 323 324#ifndef yytext_ptr 325static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); 326#endif 327 328#ifdef YY_NEED_STRLEN 329static int yy_flex_strlen YY_PROTO(( yyconst char * )); 330#endif 331 332#ifndef YY_NO_INPUT 333%- Standard (non-C++) definition 334#ifdef __cplusplus 335static int yyinput YY_PROTO(( void )); 336#else 337static int input YY_PROTO(( void )); 338#endif 339%* 340#endif 341 342#if defined(YY_STACK_USED) && YY_STACK_USED 343static int yy_start_stack_ptr = 0; 344static int yy_start_stack_depth = 0; 345static int *yy_start_stack = 0; 346#ifndef YY_NO_PUSH_STATE 347static void yy_push_state YY_PROTO(( int new_state )); 348#endif 349#ifndef YY_NO_POP_STATE 350static void yy_pop_state YY_PROTO(( void )); 351#endif 352#ifndef YY_NO_TOP_STATE 353static int yy_top_state YY_PROTO(( void )); 354#endif 355 356#else 357#define YY_NO_PUSH_STATE 1 358#define YY_NO_POP_STATE 1 359#define YY_NO_TOP_STATE 1 360#endif 361 362#ifdef YY_MALLOC_DECL 363YY_MALLOC_DECL 364#else 365#ifdef __STDC__ 366#ifndef __cplusplus 367#include <stdlib.h> 368#endif 369#else 370/* Just try to get by without declaring the routines. This will fail 371 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) 372 * or sizeof(void*) != sizeof(int). 373 */ 374#endif 375#endif 376 377/* Amount of stuff to slurp up with each read. */ 378#ifndef YY_READ_BUF_SIZE 379#define YY_READ_BUF_SIZE 8192 380#endif 381 382/* Copy whatever the last rule matched to the standard output. */ 383 384#ifndef ECHO 385%- Standard (non-C++) definition 386/* This used to be an fputs(), but since the string might contain NUL's, 387 * we now use fwrite(). 388 */ 389#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 390%+ C++ definition 391#define ECHO LexerOutput( yytext, yyleng ) 392%* 393#endif 394 395/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 396 * is returned in "result". 397 */ 398#ifndef YY_INPUT 399#define YY_INPUT(buf,result,max_size) \ 400%% fread()/read() definition of YY_INPUT goes here unless we're doing C++ 401%+ C++ definition 402 if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \ 403 YY_FATAL_ERROR( "input in flex scanner failed" ); 404%* 405#endif 406 407/* No semi-colon after return; correct usage is to write "yyterminate();" - 408 * we don't want an extra ';' after the "return" because that will cause 409 * some compilers to complain about unreachable statements. 410 */ 411#ifndef yyterminate 412#define yyterminate() return YY_NULL 413#endif 414 415/* Number of entries by which start-condition stack grows. */ 416#ifndef YY_START_STACK_INCR 417#define YY_START_STACK_INCR 25 418#endif 419 420/* Report a fatal error. */ 421#ifndef YY_FATAL_ERROR 422%- 423#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 424%+ 425#define YY_FATAL_ERROR(msg) LexerError( msg ) 426%* 427#endif 428 429/* Default declaration of generated scanner - a define so the user can 430 * easily add parameters. 431 */ 432#ifndef YY_DECL 433%- Standard (non-C++) definition 434#define YY_DECL int yylex YY_PROTO(( void )) 435%+ C++ definition 436#define YY_DECL int yyFlexLexer::yylex() 437%* 438#endif 439 440/* Code executed at the beginning of each rule, after yytext and yyleng 441 * have been set up. 442 */ 443#ifndef YY_USER_ACTION 444#define YY_USER_ACTION 445#endif 446 447/* Code executed at the end of each rule. */ 448#ifndef YY_BREAK 449#define YY_BREAK break; 450#endif 451 452%% YY_RULE_SETUP definition goes here 453 454YY_DECL 455 { 456 register yy_state_type yy_current_state; 457 register char *yy_cp, *yy_bp; 458 register int yy_act; 459 460%% user's declarations go here 461 462 if ( yy_init ) 463 { 464 yy_init = 0; 465 466#ifdef YY_USER_INIT 467 YY_USER_INIT; 468#endif 469 470 if ( ! yy_start ) 471 yy_start = 1; /* first start state */ 472 473 if ( ! yyin ) 474%- 475 yyin = stdin; 476%+ 477 yyin = &std::cin; 478%* 479 480 if ( ! yyout ) 481%- 482 yyout = stdout; 483%+ 484 yyout = &std::cout; 485%* 486 487 if ( ! yy_current_buffer ) 488 yy_current_buffer = 489 yy_create_buffer( yyin, YY_BUF_SIZE ); 490 491 yy_load_buffer_state(); 492 } 493 494 while ( 1 ) /* loops until end-of-file is reached */ 495 { 496%% yymore()-related code goes here 497 yy_cp = yy_c_buf_p; 498 499 /* Support of yytext. */ 500 *yy_cp = yy_hold_char; 501 502 /* yy_bp points to the position in yy_ch_buf of the start of 503 * the current run. 504 */ 505 yy_bp = yy_cp; 506 507%% code to set up and find next match goes here 508 509yy_find_action: 510%% code to find the action number goes here 511 512 YY_DO_BEFORE_ACTION; 513 514%% code for yylineno update goes here 515 516do_action: /* This label is used only to access EOF actions. */ 517 518%% debug code goes here 519 520 switch ( yy_act ) 521 { /* beginning of action switch */ 522%% actions go here 523 524 case YY_END_OF_BUFFER: 525 { 526 /* Amount of text matched not including the EOB char. */ 527 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; 528 529 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 530 *yy_cp = yy_hold_char; 531 YY_RESTORE_YY_MORE_OFFSET 532 533 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) 534 { 535 /* We're scanning a new file or input source. It's 536 * possible that this happened because the user 537 * just pointed yyin at a new source and called 538 * yylex(). If so, then we have to assure 539 * consistency between yy_current_buffer and our 540 * globals. Here is the right place to do so, because 541 * this is the first action (other than possibly a 542 * back-up) that will match for the new input source. 543 */ 544 yy_n_chars = yy_current_buffer->yy_n_chars; 545 yy_current_buffer->yy_input_file = yyin; 546 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; 547 } 548 549 /* Note that here we test for yy_c_buf_p "<=" to the position 550 * of the first EOB in the buffer, since yy_c_buf_p will 551 * already have been incremented past the NUL character 552 * (since all states make transitions on EOB to the 553 * end-of-buffer state). Contrast this with the test 554 * in input(). 555 */ 556 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 557 { /* This was really a NUL. */ 558 yy_state_type yy_next_state; 559 560 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; 561 562 yy_current_state = yy_get_previous_state(); 563 564 /* Okay, we're now positioned to make the NUL 565 * transition. We couldn't have 566 * yy_get_previous_state() go ahead and do it 567 * for us because it doesn't know how to deal 568 * with the possibility of jamming (and we don't 569 * want to build jamming into it because then it 570 * will run more slowly). 571 */ 572 573 yy_next_state = yy_try_NUL_trans( yy_current_state ); 574 575 yy_bp = yytext_ptr + YY_MORE_ADJ; 576 577 if ( yy_next_state ) 578 { 579 /* Consume the NUL. */ 580 yy_cp = ++yy_c_buf_p; 581 yy_current_state = yy_next_state; 582 goto yy_match; 583 } 584 585 else 586 { 587%% code to do back-up for compressed tables and set up yy_cp goes here 588 goto yy_find_action; 589 } 590 } 591 592 else switch ( yy_get_next_buffer() ) 593 { 594 case EOB_ACT_END_OF_FILE: 595 { 596 yy_did_buffer_switch_on_eof = 0; 597 598 if ( yywrap() ) 599 { 600 /* Note: because we've taken care in 601 * yy_get_next_buffer() to have set up 602 * yytext, we can now set up 603 * yy_c_buf_p so that if some total 604 * hoser (like flex itself) wants to 605 * call the scanner after we return the 606 * YY_NULL, it'll still work - another 607 * YY_NULL will get returned. 608 */ 609 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; 610 611 yy_act = YY_STATE_EOF(YY_START); 612 goto do_action; 613 } 614 615 else 616 { 617 if ( ! yy_did_buffer_switch_on_eof ) 618 YY_NEW_FILE; 619 } 620 break; 621 } 622 623 case EOB_ACT_CONTINUE_SCAN: 624 yy_c_buf_p = 625 yytext_ptr + yy_amount_of_matched_text; 626 627 yy_current_state = yy_get_previous_state(); 628 629 yy_cp = yy_c_buf_p; 630 yy_bp = yytext_ptr + YY_MORE_ADJ; 631 goto yy_match; 632 633 case EOB_ACT_LAST_MATCH: 634 yy_c_buf_p = 635 &yy_current_buffer->yy_ch_buf[yy_n_chars]; 636 637 yy_current_state = yy_get_previous_state(); 638 639 yy_cp = yy_c_buf_p; 640 yy_bp = yytext_ptr + YY_MORE_ADJ; 641 goto yy_find_action; 642 } 643 break; 644 } 645 646 default: 647 YY_FATAL_ERROR( 648 "fatal flex scanner internal error--no action found" ); 649 } /* end of action switch */ 650 } /* end of scanning one token */ 651 } /* end of yylex */ 652 653%+ 654yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout ) 655 { 656 yyin = arg_yyin; 657 yyout = arg_yyout; 658 yy_c_buf_p = 0; 659 yy_init = 1; 660 yy_start = 0; 661 yy_flex_debug = 0; 662 yylineno = 1; // this will only get updated if %option yylineno 663 664 yy_did_buffer_switch_on_eof = 0; 665 666 yy_looking_for_trail_begin = 0; 667 yy_more_flag = 0; 668 yy_more_len = 0; 669 yy_more_offset = yy_prev_more_offset = 0; 670 671 yy_start_stack_ptr = yy_start_stack_depth = 0; 672 yy_start_stack = 0; 673 674 yy_current_buffer = 0; 675 676#ifdef YY_USES_REJECT 677 yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2]; 678#else 679 yy_state_buf = 0; 680#endif 681 } 682 683yyFlexLexer::~yyFlexLexer() 684 { 685 delete yy_state_buf; 686 yy_delete_buffer( yy_current_buffer ); 687 } 688 689void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out ) 690 { 691 if ( new_in ) 692 { 693 yy_delete_buffer( yy_current_buffer ); 694 yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) ); 695 } 696 697 if ( new_out ) 698 yyout = new_out; 699 } 700 701#ifdef YY_INTERACTIVE 702int yyFlexLexer::LexerInput( char* buf, int /* max_size */ ) 703#else 704int yyFlexLexer::LexerInput( char* buf, int max_size ) 705#endif 706 { 707 if ( yyin->eof() || yyin->fail() ) 708 return 0; 709 710#ifdef YY_INTERACTIVE 711 yyin->get( buf[0] ); 712 713 if ( yyin->eof() ) 714 return 0; 715 716 if ( yyin->bad() ) 717 return -1; 718 719 return 1; 720 721#else 722 (void) yyin->read( buf, max_size ); 723 724 if ( yyin->bad() ) 725 return -1; 726 else 727 return yyin->gcount(); 728#endif 729 } 730 731void yyFlexLexer::LexerOutput( const char* buf, int size ) 732 { 733 (void) yyout->write( buf, size ); 734 } 735%* 736 737/* yy_get_next_buffer - try to read in a new buffer 738 * 739 * Returns a code representing an action: 740 * EOB_ACT_LAST_MATCH - 741 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 742 * EOB_ACT_END_OF_FILE - end of file 743 */ 744 745%- 746static int yy_get_next_buffer() 747%+ 748int yyFlexLexer::yy_get_next_buffer() 749%* 750 { 751 register char *dest = yy_current_buffer->yy_ch_buf; 752 register char *source = yytext_ptr; 753 register int number_to_move, i; 754 int ret_val; 755 756 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) 757 YY_FATAL_ERROR( 758 "fatal flex scanner internal error--end of buffer missed" ); 759 760 if ( yy_current_buffer->yy_fill_buffer == 0 ) 761 { /* Don't try to fill the buffer, so this is an EOF. */ 762 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) 763 { 764 /* We matched a single character, the EOB, so 765 * treat this as a final EOF. 766 */ 767 return EOB_ACT_END_OF_FILE; 768 } 769 770 else 771 { 772 /* We matched some text prior to the EOB, first 773 * process it. 774 */ 775 return EOB_ACT_LAST_MATCH; 776 } 777 } 778 779 /* Try to read more data. */ 780 781 /* First move last chars to start of buffer. */ 782 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; 783 784 for ( i = 0; i < number_to_move; ++i ) 785 *(dest++) = *(source++); 786 787 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 788 /* don't do the read, it's not guaranteed to return an EOF, 789 * just force an EOF 790 */ 791 yy_current_buffer->yy_n_chars = yy_n_chars = 0; 792 793 else 794 { 795 int num_to_read = 796 yy_current_buffer->yy_buf_size - number_to_move - 1; 797 798 while ( num_to_read <= 0 ) 799 { /* Not enough room in the buffer - grow it. */ 800#ifdef YY_USES_REJECT 801 YY_FATAL_ERROR( 802"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 803#else 804 805 /* just a shorter name for the current buffer */ 806 YY_BUFFER_STATE b = yy_current_buffer; 807 808 int yy_c_buf_p_offset = 809 (int) (yy_c_buf_p - b->yy_ch_buf); 810 811 if ( b->yy_is_our_buffer ) 812 { 813 int new_size = b->yy_buf_size * 2; 814 815 if ( new_size <= 0 ) 816 b->yy_buf_size += b->yy_buf_size / 8; 817 else 818 b->yy_buf_size *= 2; 819 820 b->yy_ch_buf = (char *) 821 /* Include room in for 2 EOB chars. */ 822 yy_flex_realloc( (void *) b->yy_ch_buf, 823 b->yy_buf_size + 2 ); 824 } 825 else 826 /* Can't grow it, we don't own it. */ 827 b->yy_ch_buf = 0; 828 829 if ( ! b->yy_ch_buf ) 830 YY_FATAL_ERROR( 831 "fatal error - scanner input buffer overflow" ); 832 833 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 834 835 num_to_read = yy_current_buffer->yy_buf_size - 836 number_to_move - 1; 837#endif 838 } 839 840 if ( num_to_read > YY_READ_BUF_SIZE ) 841 num_to_read = YY_READ_BUF_SIZE; 842 843 /* Read in more data. */ 844 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), 845 yy_n_chars, num_to_read ); 846 847 yy_current_buffer->yy_n_chars = yy_n_chars; 848 } 849 850 if ( yy_n_chars == 0 ) 851 { 852 if ( number_to_move == YY_MORE_ADJ ) 853 { 854 ret_val = EOB_ACT_END_OF_FILE; 855 yyrestart( yyin ); 856 } 857 858 else 859 { 860 ret_val = EOB_ACT_LAST_MATCH; 861 yy_current_buffer->yy_buffer_status = 862 YY_BUFFER_EOF_PENDING; 863 } 864 } 865 866 else 867 ret_val = EOB_ACT_CONTINUE_SCAN; 868 869 yy_n_chars += number_to_move; 870 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; 871 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 872 873 yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; 874 875 return ret_val; 876 } 877 878 879/* yy_get_previous_state - get the state just before the EOB char was reached */ 880 881%- 882static yy_state_type yy_get_previous_state() 883%+ 884yy_state_type yyFlexLexer::yy_get_previous_state() 885%* 886 { 887 register yy_state_type yy_current_state; 888 register char *yy_cp; 889 890%% code to get the start state into yy_current_state goes here 891 892 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) 893 { 894%% code to find the next state goes here 895 } 896 897 return yy_current_state; 898 } 899 900 901/* yy_try_NUL_trans - try to make a transition on the NUL character 902 * 903 * synopsis 904 * next_state = yy_try_NUL_trans( current_state ); 905 */ 906 907%- 908#ifdef YY_USE_PROTOS 909static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 910#else 911static yy_state_type yy_try_NUL_trans( yy_current_state ) 912yy_state_type yy_current_state; 913#endif 914%+ 915yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state ) 916%* 917 { 918 register int yy_is_jam; 919%% code to find the next state, and perhaps do backing up, goes here 920 921 return yy_is_jam ? 0 : yy_current_state; 922 } 923 924 925%- 926#ifndef YY_NO_UNPUT 927#ifdef YY_USE_PROTOS 928static void yyunput( int c, register char *yy_bp ) 929#else 930static void yyunput( c, yy_bp ) 931int c; 932register char *yy_bp; 933#endif 934%+ 935void yyFlexLexer::yyunput( int c, register char* yy_bp ) 936%* 937 { 938 register char *yy_cp = yy_c_buf_p; 939 940 /* undo effects of setting up yytext */ 941 *yy_cp = yy_hold_char; 942 943 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 944 { /* need to shift things up to make room */ 945 /* +2 for EOB chars. */ 946 register int number_to_move = yy_n_chars + 2; 947 register char *dest = &yy_current_buffer->yy_ch_buf[ 948 yy_current_buffer->yy_buf_size + 2]; 949 register char *source = 950 &yy_current_buffer->yy_ch_buf[number_to_move]; 951 952 while ( source > yy_current_buffer->yy_ch_buf ) 953 *--dest = *--source; 954 955 yy_cp += (int) (dest - source); 956 yy_bp += (int) (dest - source); 957 yy_current_buffer->yy_n_chars = 958 yy_n_chars = yy_current_buffer->yy_buf_size; 959 960 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 961 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 962 } 963 964 *--yy_cp = (char) c; 965 966%% update yylineno here 967 968 yytext_ptr = yy_bp; 969 yy_hold_char = *yy_cp; 970 yy_c_buf_p = yy_cp; 971 } 972%- 973#endif /* ifndef YY_NO_UNPUT */ 974%* 975 976 977%- 978#ifndef YY_NO_INPUT 979#ifdef __cplusplus 980static int yyinput() 981#else 982static int input() 983#endif 984%+ 985int yyFlexLexer::yyinput() 986%* 987 { 988 int c; 989 990 *yy_c_buf_p = yy_hold_char; 991 992 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 993 { 994 /* yy_c_buf_p now points to the character we want to return. 995 * If this occurs *before* the EOB characters, then it's a 996 * valid NUL; if not, then we've hit the end of the buffer. 997 */ 998 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 999 /* This was really a NUL. */ 1000 *yy_c_buf_p = '\0'; 1001 1002 else 1003 { /* need more input */ 1004 int offset = yy_c_buf_p - yytext_ptr; 1005 ++yy_c_buf_p; 1006 1007 switch ( yy_get_next_buffer() ) 1008 { 1009 case EOB_ACT_LAST_MATCH: 1010 /* This happens because yy_g_n_b() 1011 * sees that we've accumulated a 1012 * token and flags that we need to 1013 * try matching the token before 1014 * proceeding. But for input(), 1015 * there's no matching to consider. 1016 * So convert the EOB_ACT_LAST_MATCH 1017 * to EOB_ACT_END_OF_FILE. 1018 */ 1019 1020 /* Reset buffer status. */ 1021 yyrestart( yyin ); 1022 1023 /* fall through */ 1024 1025 case EOB_ACT_END_OF_FILE: 1026 { 1027 if ( yywrap() ) 1028 return EOF; 1029 1030 if ( ! yy_did_buffer_switch_on_eof ) 1031 YY_NEW_FILE; 1032#ifdef __cplusplus 1033 return yyinput(); 1034#else 1035 return input(); 1036#endif 1037 } 1038 1039 case EOB_ACT_CONTINUE_SCAN: 1040 yy_c_buf_p = yytext_ptr + offset; 1041 break; 1042 } 1043 } 1044 } 1045 1046 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ 1047 *yy_c_buf_p = '\0'; /* preserve yytext */ 1048 yy_hold_char = *++yy_c_buf_p; 1049 1050%% update BOL and yylineno 1051 1052 return c; 1053 } 1054%- 1055#endif /* ifndef YY_NO_INPUT */ 1056%* 1057 1058 1059%- 1060#ifdef YY_USE_PROTOS 1061void yyrestart( FILE *input_file ) 1062#else 1063void yyrestart( input_file ) 1064FILE *input_file; 1065#endif 1066%+ 1067void yyFlexLexer::yyrestart( std::istream* input_file ) 1068%* 1069 { 1070 if ( ! yy_current_buffer ) 1071 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 1072 1073 yy_init_buffer( yy_current_buffer, input_file ); 1074 yy_load_buffer_state(); 1075 } 1076 1077 1078%- 1079#ifdef YY_USE_PROTOS 1080void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1081#else 1082void yy_switch_to_buffer( new_buffer ) 1083YY_BUFFER_STATE new_buffer; 1084#endif 1085%+ 1086void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1087%* 1088 { 1089 if ( yy_current_buffer == new_buffer ) 1090 return; 1091 1092 if ( yy_current_buffer ) 1093 { 1094 /* Flush out information for old buffer. */ 1095 *yy_c_buf_p = yy_hold_char; 1096 yy_current_buffer->yy_buf_pos = yy_c_buf_p; 1097 yy_current_buffer->yy_n_chars = yy_n_chars; 1098 } 1099 1100 yy_current_buffer = new_buffer; 1101 yy_load_buffer_state(); 1102 1103 /* We don't actually know whether we did this switch during 1104 * EOF (yywrap()) processing, but the only time this flag 1105 * is looked at is after yywrap() is called, so it's safe 1106 * to go ahead and always set it. 1107 */ 1108 yy_did_buffer_switch_on_eof = 1; 1109 } 1110 1111 1112%- 1113#ifdef YY_USE_PROTOS 1114void yy_load_buffer_state( void ) 1115#else 1116void yy_load_buffer_state() 1117#endif 1118%+ 1119void yyFlexLexer::yy_load_buffer_state() 1120%* 1121 { 1122 yy_n_chars = yy_current_buffer->yy_n_chars; 1123 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; 1124 yyin = yy_current_buffer->yy_input_file; 1125 yy_hold_char = *yy_c_buf_p; 1126 } 1127 1128 1129%- 1130#ifdef YY_USE_PROTOS 1131YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 1132#else 1133YY_BUFFER_STATE yy_create_buffer( file, size ) 1134FILE *file; 1135int size; 1136#endif 1137%+ 1138YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size ) 1139%* 1140 { 1141 YY_BUFFER_STATE b; 1142 1143 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1144 if ( ! b ) 1145 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1146 1147 b->yy_buf_size = size; 1148 1149 /* yy_ch_buf has to be 2 characters longer than the size given because 1150 * we need to put in 2 end-of-buffer characters. 1151 */ 1152 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); 1153 if ( ! b->yy_ch_buf ) 1154 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1155 1156 b->yy_is_our_buffer = 1; 1157 1158 yy_init_buffer( b, file ); 1159 1160 return b; 1161 } 1162 1163 1164%- 1165#ifdef YY_USE_PROTOS 1166void yy_delete_buffer( YY_BUFFER_STATE b ) 1167#else 1168void yy_delete_buffer( b ) 1169YY_BUFFER_STATE b; 1170#endif 1171%+ 1172void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b ) 1173%* 1174 { 1175 if ( ! b ) 1176 return; 1177 1178 if ( b == yy_current_buffer ) 1179 yy_current_buffer = (YY_BUFFER_STATE) 0; 1180 1181 if ( b->yy_is_our_buffer ) 1182 yy_flex_free( (void *) b->yy_ch_buf ); 1183 1184 yy_flex_free( (void *) b ); 1185 } 1186 1187 1188%- 1189#ifndef YY_ALWAYS_INTERACTIVE 1190#ifndef YY_NEVER_INTERACTIVE 1191#include <unistd.h> 1192#endif 1193#endif 1194 1195#ifdef YY_USE_PROTOS 1196void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 1197#else 1198void yy_init_buffer( b, file ) 1199YY_BUFFER_STATE b; 1200FILE *file; 1201#endif 1202 1203%+ 1204extern "C" int isatty YY_PROTO(( int )); 1205void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file ) 1206%* 1207 1208 { 1209 int oerrno = errno; 1210 1211 yy_flush_buffer( b ); 1212 1213 b->yy_input_file = file; 1214 b->yy_fill_buffer = 1; 1215 1216%- 1217#if defined(YY_ALWAYS_INTERACTIVE) && YY_ALWAYS_INTERACTIVE 1218 b->yy_is_interactive = 1; 1219#else 1220#if defined(YY_NEVER_INTERACTIVE) && YY_NEVER_INTERACTIVE 1221 b->yy_is_interactive = 0; 1222#else 1223 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 1224#endif 1225#endif 1226%+ 1227 b->yy_is_interactive = 0; 1228%* 1229 errno = oerrno; 1230 } 1231 1232 1233%- 1234#ifdef YY_USE_PROTOS 1235void yy_flush_buffer( YY_BUFFER_STATE b ) 1236#else 1237void yy_flush_buffer( b ) 1238YY_BUFFER_STATE b; 1239#endif 1240 1241%+ 1242void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b ) 1243%* 1244 { 1245 if ( ! b ) 1246 return; 1247 1248 b->yy_n_chars = 0; 1249 1250 /* We always need two end-of-buffer characters. The first causes 1251 * a transition to the end-of-buffer state. The second causes 1252 * a jam in that state. 1253 */ 1254 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 1255 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 1256 1257 b->yy_buf_pos = &b->yy_ch_buf[0]; 1258 1259 b->yy_at_bol = 1; 1260 b->yy_buffer_status = YY_BUFFER_NEW; 1261 1262 if ( b == yy_current_buffer ) 1263 yy_load_buffer_state(); 1264 } 1265%* 1266 1267 1268#ifndef YY_NO_SCAN_BUFFER 1269%- 1270#ifdef YY_USE_PROTOS 1271YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 1272#else 1273YY_BUFFER_STATE yy_scan_buffer( base, size ) 1274char *base; 1275yy_size_t size; 1276#endif 1277 { 1278 YY_BUFFER_STATE b; 1279 1280 if ( size < 2 || 1281 base[size-2] != YY_END_OF_BUFFER_CHAR || 1282 base[size-1] != YY_END_OF_BUFFER_CHAR ) 1283 /* They forgot to leave room for the EOB's. */ 1284 return 0; 1285 1286 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1287 if ( ! b ) 1288 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 1289 1290 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 1291 b->yy_buf_pos = b->yy_ch_buf = base; 1292 b->yy_is_our_buffer = 0; 1293 b->yy_input_file = 0; 1294 b->yy_n_chars = b->yy_buf_size; 1295 b->yy_is_interactive = 0; 1296 b->yy_at_bol = 1; 1297 b->yy_fill_buffer = 0; 1298 b->yy_buffer_status = YY_BUFFER_NEW; 1299 1300 yy_switch_to_buffer( b ); 1301 1302 return b; 1303 } 1304%* 1305#endif 1306 1307 1308#ifndef YY_NO_SCAN_STRING 1309%- 1310#ifdef YY_USE_PROTOS 1311YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 1312#else 1313YY_BUFFER_STATE yy_scan_string( yy_str ) 1314yyconst char *yy_str; 1315#endif 1316 { 1317 int len; 1318 for ( len = 0; yy_str[len]; ++len ) 1319 ; 1320 1321 return yy_scan_bytes( yy_str, len ); 1322 } 1323%* 1324#endif 1325 1326 1327#ifndef YY_NO_SCAN_BYTES 1328%- 1329#ifdef YY_USE_PROTOS 1330YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 1331#else 1332YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 1333yyconst char *bytes; 1334int len; 1335#endif 1336 { 1337 YY_BUFFER_STATE b; 1338 char *buf; 1339 yy_size_t n; 1340 int i; 1341 1342 /* Get memory for full buffer, including space for trailing EOB's. */ 1343 n = len + 2; 1344 buf = (char *) yy_flex_alloc( n ); 1345 if ( ! buf ) 1346 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 1347 1348 for ( i = 0; i < len; ++i ) 1349 buf[i] = bytes[i]; 1350 1351 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; 1352 1353 b = yy_scan_buffer( buf, n ); 1354 if ( ! b ) 1355 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 1356 1357 /* It's okay to grow etc. this buffer, and we should throw it 1358 * away when we're done. 1359 */ 1360 b->yy_is_our_buffer = 1; 1361 1362 return b; 1363 } 1364%* 1365#endif 1366 1367 1368#ifndef YY_NO_PUSH_STATE 1369%- 1370#ifdef YY_USE_PROTOS 1371static void yy_push_state( int new_state ) 1372#else 1373static void yy_push_state( new_state ) 1374int new_state; 1375#endif 1376%+ 1377void yyFlexLexer::yy_push_state( int new_state ) 1378%* 1379 { 1380 if ( yy_start_stack_ptr >= yy_start_stack_depth ) 1381 { 1382 yy_size_t new_size; 1383 1384 yy_start_stack_depth += YY_START_STACK_INCR; 1385 new_size = yy_start_stack_depth * sizeof( int ); 1386 1387 if ( ! yy_start_stack ) 1388 yy_start_stack = (int *) yy_flex_alloc( new_size ); 1389 1390 else 1391 yy_start_stack = (int *) yy_flex_realloc( 1392 (void *) yy_start_stack, new_size ); 1393 1394 if ( ! yy_start_stack ) 1395 YY_FATAL_ERROR( 1396 "out of memory expanding start-condition stack" ); 1397 } 1398 1399 yy_start_stack[yy_start_stack_ptr++] = YY_START; 1400 1401 BEGIN(new_state); 1402 } 1403#endif 1404 1405 1406#ifndef YY_NO_POP_STATE 1407%- 1408static void yy_pop_state() 1409%+ 1410void yyFlexLexer::yy_pop_state() 1411%* 1412 { 1413 if ( --yy_start_stack_ptr < 0 ) 1414 YY_FATAL_ERROR( "start-condition stack underflow" ); 1415 1416 BEGIN(yy_start_stack[yy_start_stack_ptr]); 1417 } 1418#endif 1419 1420 1421#ifndef YY_NO_TOP_STATE 1422%- 1423static int yy_top_state() 1424%+ 1425int yyFlexLexer::yy_top_state() 1426%* 1427 { 1428 return yy_start_stack[yy_start_stack_ptr - 1]; 1429 } 1430#endif 1431 1432#ifndef YY_EXIT_FAILURE 1433#define YY_EXIT_FAILURE 2 1434#endif 1435 1436%- 1437#ifdef YY_USE_PROTOS 1438static void yy_fatal_error( yyconst char msg[] ) 1439#else 1440static void yy_fatal_error( msg ) 1441char msg[]; 1442#endif 1443 { 1444 (void) fprintf( stderr, "%s\n", msg ); 1445 exit( YY_EXIT_FAILURE ); 1446 } 1447 1448%+ 1449 1450void yyFlexLexer::LexerError( yyconst char msg[] ) 1451 { 1452 std::cerr << msg << '\n'; 1453 exit( YY_EXIT_FAILURE ); 1454 } 1455%* 1456 1457 1458/* Redefine yyless() so it works in section 3 code. */ 1459 1460#undef yyless 1461#define yyless(n) \ 1462 do \ 1463 { \ 1464 /* Undo effects of setting up yytext. */ \ 1465 yytext[yyleng] = yy_hold_char; \ 1466 yy_c_buf_p = yytext + n; \ 1467 yy_hold_char = *yy_c_buf_p; \ 1468 *yy_c_buf_p = '\0'; \ 1469 yyleng = n; \ 1470 } \ 1471 while ( 0 ) 1472 1473 1474/* Internal utility routines. */ 1475 1476#ifndef yytext_ptr 1477#ifdef YY_USE_PROTOS 1478static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 1479#else 1480static void yy_flex_strncpy( s1, s2, n ) 1481char *s1; 1482yyconst char *s2; 1483int n; 1484#endif 1485 { 1486 register int i; 1487 for ( i = 0; i < n; ++i ) 1488 s1[i] = s2[i]; 1489 } 1490#endif 1491 1492#ifdef YY_NEED_STRLEN 1493#ifdef YY_USE_PROTOS 1494static int yy_flex_strlen( yyconst char *s ) 1495#else 1496static int yy_flex_strlen( s ) 1497yyconst char *s; 1498#endif 1499 { 1500 register int n; 1501 for ( n = 0; s[n]; ++n ) 1502 ; 1503 1504 return n; 1505 } 1506#endif 1507 1508 1509#ifdef YY_USE_PROTOS 1510static void *yy_flex_alloc( yy_size_t size ) 1511#else 1512static void *yy_flex_alloc( size ) 1513yy_size_t size; 1514#endif 1515 { 1516 return (void *) malloc( size ); 1517 } 1518 1519#ifdef YY_USE_PROTOS 1520static void *yy_flex_realloc( void *ptr, yy_size_t size ) 1521#else 1522static void *yy_flex_realloc( ptr, size ) 1523void *ptr; 1524yy_size_t size; 1525#endif 1526 { 1527 /* The cast to (char *) in the following accommodates both 1528 * implementations that use char* generic pointers, and those 1529 * that use void* generic pointers. It works with the latter 1530 * because both ANSI C and C++ allow castless assignment from 1531 * any pointer type to void*, and deal with argument conversions 1532 * as though doing an assignment. 1533 */ 1534 return (void *) realloc( (char *) ptr, size ); 1535 } 1536 1537#ifdef YY_USE_PROTOS 1538static void yy_flex_free( void *ptr ) 1539#else 1540static void yy_flex_free( ptr ) 1541void *ptr; 1542#endif 1543 { 1544 free( ptr ); 1545 } 1546 1547#if defined(YY_MAIN) && YY_MAIN 1548int main() 1549 { 1550 yylex(); 1551 return 0; 1552 } 1553#endif 1554