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 %+ 28 class 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 104 typedef struct yy_buffer_state *YY_BUFFER_STATE; 105 106 extern int yyleng; 107 %- 108 extern 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 */ 148 typedef unsigned int yy_size_t; 149 150 151 struct 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 213 static 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. */ 225 static char yy_hold_char; 226 227 static int yy_n_chars; /* number of characters read into yy_ch_buf */ 228 229 230 int yyleng; 231 232 /* Points to current character in buffer. */ 233 static char *yy_c_buf_p = (char *) 0; 234 static int yy_init = 1; /* whether we need to initialize */ 235 static 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 */ 240 static int yy_did_buffer_switch_on_eof; 241 242 void yyrestart YY_PROTO(( FILE *input_file )); 243 244 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); 245 void yy_load_buffer_state YY_PROTO(( void )); 246 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); 247 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); 248 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); 249 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); 250 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) 251 252 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); 253 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); 254 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); 255 %* 256 257 static void *yy_flex_alloc YY_PROTO(( yy_size_t )); 258 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); 259 static 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 282 static yy_state_type yy_get_previous_state YY_PROTO(( void )); 283 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); 284 static int yy_get_next_buffer YY_PROTO(( void )); 285 static 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 307 extern "C" int yywrap YY_PROTO(( void )); 308 #else 309 extern int yywrap YY_PROTO(( void )); 310 #endif 311 #endif 312 313 %- 314 #ifndef YY_NO_UNPUT 315 static void yyunput YY_PROTO(( int c, char *buf_ptr )); 316 #endif 317 %* 318 319 #ifndef yytext_ptr 320 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); 321 #endif 322 323 #ifdef YY_NEED_STRLEN 324 static int yy_flex_strlen YY_PROTO(( yyconst char * )); 325 #endif 326 327 #ifndef YY_NO_INPUT 328 %- Standard (non-C++) definition 329 #ifdef __cplusplus 330 static int yyinput YY_PROTO(( void )); 331 #else 332 static int input YY_PROTO(( void )); 333 #endif 334 %* 335 #endif 336 337 #if YY_STACK_USED 338 static int yy_start_stack_ptr = 0; 339 static int yy_start_stack_depth = 0; 340 static int *yy_start_stack = 0; 341 #ifndef YY_NO_PUSH_STATE 342 static void yy_push_state YY_PROTO(( int new_state )); 343 #endif 344 #ifndef YY_NO_POP_STATE 345 static void yy_pop_state YY_PROTO(( void )); 346 #endif 347 #ifndef YY_NO_TOP_STATE 348 static 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 358 YY_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 449 YY_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 504 yy_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 511 do_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 %+ 649 yyFlexLexer::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 678 yyFlexLexer::~yyFlexLexer() 679 { 680 delete yy_state_buf; 681 yy_delete_buffer( yy_current_buffer ); 682 } 683 684 void 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 697 int yyFlexLexer::LexerInput( char* buf, int /* max_size */ ) 698 #else 699 int 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 726 void 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 %- 741 static int yy_get_next_buffer() 742 %+ 743 int 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 %- 877 static yy_state_type yy_get_previous_state() 878 %+ 879 yy_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 904 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 905 #else 906 static yy_state_type yy_try_NUL_trans( yy_current_state ) 907 yy_state_type yy_current_state; 908 #endif 909 %+ 910 yy_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 923 static void yyunput( int c, register char *yy_bp ) 924 #else 925 static void yyunput( c, yy_bp ) 926 int c; 927 register char *yy_bp; 928 #endif 929 %+ 930 void 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 974 static int yyinput() 975 #else 976 static int input() 977 #endif 978 %+ 979 int 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 1052 void yyrestart( FILE *input_file ) 1053 #else 1054 void yyrestart( input_file ) 1055 FILE *input_file; 1056 #endif 1057 %+ 1058 void 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 1071 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1072 #else 1073 void yy_switch_to_buffer( new_buffer ) 1074 YY_BUFFER_STATE new_buffer; 1075 #endif 1076 %+ 1077 void 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 1105 void yy_load_buffer_state( void ) 1106 #else 1107 void yy_load_buffer_state() 1108 #endif 1109 %+ 1110 void 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 1122 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 1123 #else 1124 YY_BUFFER_STATE yy_create_buffer( file, size ) 1125 FILE *file; 1126 int size; 1127 #endif 1128 %+ 1129 YY_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 1157 void yy_delete_buffer( YY_BUFFER_STATE b ) 1158 #else 1159 void yy_delete_buffer( b ) 1160 YY_BUFFER_STATE b; 1161 #endif 1162 %+ 1163 void 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 1182 extern int isatty YY_PROTO(( int )); 1183 #endif 1184 #endif 1185 1186 #ifdef YY_USE_PROTOS 1187 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 1188 #else 1189 void yy_init_buffer( b, file ) 1190 YY_BUFFER_STATE b; 1191 FILE *file; 1192 #endif 1193 1194 %+ 1195 extern "C" int isatty YY_PROTO(( int )); 1196 void 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 1223 void yy_flush_buffer( YY_BUFFER_STATE b ) 1224 #else 1225 void yy_flush_buffer( b ) 1226 YY_BUFFER_STATE b; 1227 #endif 1228 1229 %+ 1230 void 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 1259 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 1260 #else 1261 YY_BUFFER_STATE yy_scan_buffer( base, size ) 1262 char *base; 1263 yy_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 1299 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 1300 #else 1301 YY_BUFFER_STATE yy_scan_string( yy_str ) 1302 yyconst 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 1318 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 1319 #else 1320 YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 1321 yyconst char *bytes; 1322 int 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 1359 static void yy_push_state( int new_state ) 1360 #else 1361 static void yy_push_state( new_state ) 1362 int new_state; 1363 #endif 1364 %+ 1365 void 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 %- 1396 static void yy_pop_state() 1397 %+ 1398 void 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 %- 1411 static int yy_top_state() 1412 %+ 1413 int 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 1426 static void yy_fatal_error( yyconst char msg[] ) 1427 #else 1428 static void yy_fatal_error( msg ) 1429 char msg[]; 1430 #endif 1431 { 1432 (void) fprintf( stderr, "%s\n", msg ); 1433 exit( YY_EXIT_FAILURE ); 1434 } 1435 1436 %+ 1437 1438 void 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 1466 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 1467 #else 1468 static void yy_flex_strncpy( s1, s2, n ) 1469 char *s1; 1470 yyconst char *s2; 1471 int 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 1482 static int yy_flex_strlen( yyconst char *s ) 1483 #else 1484 static int yy_flex_strlen( s ) 1485 yyconst 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 1498 static void *yy_flex_alloc( yy_size_t size ) 1499 #else 1500 static void *yy_flex_alloc( size ) 1501 yy_size_t size; 1502 #endif 1503 { 1504 return (void *) malloc( size ); 1505 } 1506 1507 #ifdef YY_USE_PROTOS 1508 static void *yy_flex_realloc( void *ptr, yy_size_t size ) 1509 #else 1510 static void *yy_flex_realloc( ptr, size ) 1511 void *ptr; 1512 yy_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 1526 static void yy_flex_free( void *ptr ) 1527 #else 1528 static void yy_flex_free( ptr ) 1529 void *ptr; 1530 #endif 1531 { 1532 free( ptr ); 1533 } 1534 1535 #if YY_MAIN 1536 int main() 1537 { 1538 yylex(); 1539 return 0; 1540 } 1541 #endif 1542