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