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