00001 #line 2 "scanner.cc"
00002
00003 #line 4 "scanner.cc"
00004
00005 #define YY_INT_ALIGNED short int
00006
00007
00008
00009 #define FLEX_SCANNER
00010 #define YY_FLEX_MAJOR_VERSION 2
00011 #define YY_FLEX_MINOR_VERSION 5
00012 #define YY_FLEX_SUBMINOR_VERSION 33
00013 #if YY_FLEX_SUBMINOR_VERSION > 0
00014 #define FLEX_BETA
00015 #endif
00016
00017
00018
00019
00020
00021
00022
00023
00024 #define yyFlexLexer ExampleFlexLexer
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046 #ifndef FLEXINT_H
00047 #define FLEXINT_H
00048
00049
00050
00051 #if __STDC_VERSION__ >= 199901L
00052
00053
00054
00055
00056 #ifndef __STDC_LIMIT_MACROS
00057 #define __STDC_LIMIT_MACROS 1
00058 #endif
00059
00060 #include <inttypes.h>
00061 typedef int8_t flex_int8_t;
00062 typedef uint8_t flex_uint8_t;
00063 typedef int16_t flex_int16_t;
00064 typedef uint16_t flex_uint16_t;
00065 typedef int32_t flex_int32_t;
00066 typedef uint32_t flex_uint32_t;
00067 #else
00068 typedef signed char flex_int8_t;
00069 typedef short int flex_int16_t;
00070 typedef int flex_int32_t;
00071 typedef unsigned char flex_uint8_t;
00072 typedef unsigned short int flex_uint16_t;
00073 typedef unsigned int flex_uint32_t;
00074 #endif
00075
00076
00077 #ifndef INT8_MIN
00078 #define INT8_MIN (-128)
00079 #endif
00080 #ifndef INT16_MIN
00081 #define INT16_MIN (-32767-1)
00082 #endif
00083 #ifndef INT32_MIN
00084 #define INT32_MIN (-2147483647-1)
00085 #endif
00086 #ifndef INT8_MAX
00087 #define INT8_MAX (127)
00088 #endif
00089 #ifndef INT16_MAX
00090 #define INT16_MAX (32767)
00091 #endif
00092 #ifndef INT32_MAX
00093 #define INT32_MAX (2147483647)
00094 #endif
00095 #ifndef UINT8_MAX
00096 #define UINT8_MAX (255U)
00097 #endif
00098 #ifndef UINT16_MAX
00099 #define UINT16_MAX (65535U)
00100 #endif
00101 #ifndef UINT32_MAX
00102 #define UINT32_MAX (4294967295U)
00103 #endif
00104
00105 #endif
00106
00107
00108
00109
00110
00111 #include <iostream>
00112 #include <errno.h>
00113 #include <cstdlib>
00114 #include <cstring>
00115
00116
00117
00118 #ifdef __cplusplus
00119
00120
00121 #define YY_USE_CONST
00122
00123 #else
00124
00125 #if __STDC__
00126
00127 #define YY_USE_CONST
00128
00129 #endif
00130 #endif
00131
00132 #ifdef YY_USE_CONST
00133 #define yyconst const
00134 #else
00135 #define yyconst
00136 #endif
00137
00138
00139
00140
00141 #define YY_NULL 0
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165 #define BEGIN (yy_start) = 1 + 2 *
00166
00167
00168
00169
00170
00171 #define YY_START (((yy_start) - 1) / 2)
00172 #define YYSTATE YY_START
00173
00174
00175 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
00176
00177
00178 #define YY_NEW_FILE yyrestart( yyin )
00179
00180 #define YY_END_OF_BUFFER_CHAR 0
00181
00182
00183 #ifndef YY_BUF_SIZE
00184 #define YY_BUF_SIZE 16384
00185 #endif
00186
00187
00188
00189 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
00190
00191 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
00192 #define YY_TYPEDEF_YY_BUFFER_STATE
00193 typedef struct yy_buffer_state *YY_BUFFER_STATE;
00194 #endif
00195
00196
00197 extern int yyleng;
00198
00199
00200
00201
00202
00203
00204
00205 #define EOB_ACT_CONTINUE_SCAN 0
00206 #define EOB_ACT_END_OF_FILE 1
00207 #define EOB_ACT_LAST_MATCH 2
00208
00209 #define YY_LESS_LINENO(n)
00210
00211
00212 #define yyless(n) \
00213 do \
00214 { \
00215 \
00216 int yyless_macro_arg = (n); \
00217 YY_LESS_LINENO(yyless_macro_arg);\
00218 *yy_cp = (yy_hold_char); \
00219 YY_RESTORE_YY_MORE_OFFSET \
00220 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
00221 YY_DO_BEFORE_ACTION; \
00222 } \
00223 while ( 0 )
00224
00225 #define unput(c) yyunput( c, (yytext_ptr) )
00226
00227
00228
00229
00230
00231
00232 #ifndef YY_TYPEDEF_YY_SIZE_T
00233 #define YY_TYPEDEF_YY_SIZE_T
00234 typedef unsigned int yy_size_t;
00235 #endif
00236
00237 #ifndef YY_STRUCT_YY_BUFFER_STATE
00238 #define YY_STRUCT_YY_BUFFER_STATE
00239 struct yy_buffer_state
00240 {
00241
00242
00243
00244
00245 std::istream* yy_input_file;
00246
00247
00248 char *yy_ch_buf;
00249 char *yy_buf_pos;
00250
00251
00252
00253
00254 yy_size_t yy_buf_size;
00255
00256
00257
00258
00259 int yy_n_chars;
00260
00261
00262
00263
00264
00265 int yy_is_our_buffer;
00266
00267
00268
00269
00270
00271
00272 int yy_is_interactive;
00273
00274
00275
00276
00277
00278 int yy_at_bol;
00279
00280 int yy_bs_lineno;
00281 int yy_bs_column;
00283
00284
00285
00286 int yy_fill_buffer;
00287
00288 int yy_buffer_status;
00289
00290 #define YY_BUFFER_NEW 0
00291 #define YY_BUFFER_NORMAL 1
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302 #define YY_BUFFER_EOF_PENDING 2
00303
00304 };
00305 #endif
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
00323 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
00324 : NULL)
00325
00326
00327
00328
00329 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340 void *Examplealloc (yy_size_t );
00341 void *Examplerealloc (void *,yy_size_t );
00342 void Examplefree (void * );
00343
00344 #define yy_new_buffer yy_create_buffer
00345
00346 #define yy_set_interactive(is_interactive) \
00347 { \
00348 if ( ! YY_CURRENT_BUFFER ){ \
00349 yyensure_buffer_stack (); \
00350 YY_CURRENT_BUFFER_LVALUE = \
00351 yy_create_buffer( yyin, YY_BUF_SIZE ); \
00352 } \
00353 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
00354 }
00355
00356 #define yy_set_bol(at_bol) \
00357 { \
00358 if ( ! YY_CURRENT_BUFFER ){\
00359 yyensure_buffer_stack (); \
00360 YY_CURRENT_BUFFER_LVALUE = \
00361 yy_create_buffer( yyin, YY_BUF_SIZE ); \
00362 } \
00363 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
00364 }
00365
00366 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
00367
00368
00369
00370
00371 #define yywrap(n) 1
00372 #define YY_SKIP_YYWRAP
00373
00374 #define FLEX_DEBUG
00375
00376 typedef unsigned char YY_CHAR;
00377
00378 #define yytext_ptr yytext
00379
00380 #include <FlexLexer.h>
00381
00382
00383
00384
00385
00386
00387
00388 #define YY_DO_BEFORE_ACTION \
00389 (yytext_ptr) = yy_bp; \
00390 \
00391 yyleng = (size_t) (yy_cp - yy_bp); \
00392 (yy_hold_char) = *yy_cp; \
00393 *yy_cp = '\0'; \
00394 \
00395 (yy_c_buf_p) = yy_cp;
00396
00397
00398 #define YY_NUM_RULES 7
00399 #define YY_END_OF_BUFFER 8
00400
00401
00402 struct yy_trans_info
00403 {
00404 flex_int32_t yy_verify;
00405 flex_int32_t yy_nxt;
00406 };
00407 static yyconst flex_int16_t yy_accept[15] =
00408 { 0,
00409 0, 0, 8, 6, 4, 5, 1, 3, 4, 2,
00410 1, 3, 2, 0
00411 } ;
00412
00413 static yyconst flex_int32_t yy_ec[256] =
00414 { 0,
00415 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
00416 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
00417 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00418 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
00419 1, 1, 1, 4, 4, 5, 1, 6, 6, 6,
00420 6, 6, 6, 6, 6, 6, 6, 1, 1, 1,
00421 1, 1, 1, 1, 7, 7, 7, 7, 7, 7,
00422 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
00423 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
00424 1, 1, 1, 1, 4, 1, 7, 7, 7, 7,
00425
00426 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
00427 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
00428 7, 7, 1, 1, 1, 1, 1, 1, 1, 1,
00429 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00430 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00431 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00432 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00433 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00434 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00435 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00436
00437 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00438 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00439 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00440 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00441 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00442 1, 1, 1, 1, 1
00443 } ;
00444
00445 static yyconst flex_int32_t yy_meta[8] =
00446 { 0,
00447 1, 1, 1, 2, 2, 2, 2
00448 } ;
00449
00450 static yyconst flex_int16_t yy_base[16] =
00451 { 0,
00452 0, 0, 15, 16, 12, 16, 3, 0, 11, 6,
00453 0, 0, 5, 16, 8
00454 } ;
00455
00456 static yyconst flex_int16_t yy_def[16] =
00457 { 0,
00458 14, 1, 14, 14, 14, 14, 14, 15, 14, 14,
00459 7, 15, 14, 0, 14
00460 } ;
00461
00462 static yyconst flex_int16_t yy_nxt[24] =
00463 { 0,
00464 4, 5, 6, 4, 4, 7, 8, 10, 11, 12,
00465 13, 13, 9, 9, 14, 3, 14, 14, 14, 14,
00466 14, 14, 14
00467 } ;
00468
00469 static yyconst flex_int16_t yy_chk[24] =
00470 { 0,
00471 1, 1, 1, 1, 1, 1, 1, 7, 7, 15,
00472 13, 10, 9, 5, 3, 14, 14, 14, 14, 14,
00473 14, 14, 14
00474 } ;
00475
00476 static yyconst flex_int16_t yy_rule_linenum[7] =
00477 { 0,
00478 67, 72, 77, 83, 88, 94
00479 } ;
00480
00481
00482
00483
00484 #define REJECT reject_used_but_not_detected
00485 #define yymore() yymore_used_but_not_detected
00486 #define YY_MORE_ADJ 0
00487 #define YY_RESTORE_YY_MORE_OFFSET
00488 #line 1 "scanner.ll"
00489
00491 #line 5 "scanner.ll"
00492
00493 #include <string>
00494
00495 #include "scanner.h"
00496
00497
00498 typedef example::Parser::token token;
00499 typedef example::Parser::token_type token_type;
00500
00501
00502
00503
00504 #undef yywrap
00505 #define yywrap() 1
00506
00507
00508
00509 #define yyterminate() return token::END
00510
00511
00512
00513 #define YY_NO_UNISTD_H
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525 #line 54 "scanner.ll"
00526 #define YY_USER_ACTION yylloc->columns(yyleng);
00527 #line 528 "scanner.cc"
00528
00529 #define INITIAL 0
00530
00531 #ifndef YY_NO_UNISTD_H
00532
00533
00534
00535
00536
00537
00538
00539 #include <unistd.h>
00540
00541 #endif
00542
00543 #ifndef YY_EXTRA_TYPE
00544 #define YY_EXTRA_TYPE void *
00545 #endif
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562 #ifndef yytext_ptr
00563 static void yy_flex_strncpy (char *,yyconst char *,int );
00564 #endif
00565
00566 #ifdef YY_NEED_STRLEN
00567 static int yy_flex_strlen (yyconst char * );
00568 #endif
00569
00570 #ifndef YY_NO_INPUT
00571
00572
00573
00574
00575
00576
00577 #endif
00578
00579
00580
00581
00582
00583 #ifndef YY_READ_BUF_SIZE
00584 #define YY_READ_BUF_SIZE 8192
00585 #endif
00586
00587
00588 #ifndef ECHO
00589
00590
00591
00592 #define ECHO LexerOutput( yytext, yyleng )
00593
00594 #endif
00595
00596
00597
00598
00599 #ifndef YY_INPUT
00600 #define YY_INPUT(buf,result,max_size) \
00601 \
00602 \
00603 \
00604 if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
00605 YY_FATAL_ERROR( "input in flex scanner failed" );
00606
00607
00608 #endif
00609
00610
00611
00612
00613
00614 #ifndef yyterminate
00615 #define yyterminate() return YY_NULL
00616 #endif
00617
00618
00619 #ifndef YY_START_STACK_INCR
00620 #define YY_START_STACK_INCR 25
00621 #endif
00622
00623
00624 #ifndef YY_FATAL_ERROR
00625
00626
00627
00628 #define YY_FATAL_ERROR(msg) LexerError( msg )
00629
00630 #endif
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646
00647
00648 #ifndef YY_DECL
00649 #define YY_DECL_IS_OURS 1
00650
00651
00652
00653 #define YY_DECL int yyFlexLexer::yylex()
00654
00655 #endif
00656
00657
00658
00659
00660 #ifndef YY_USER_ACTION
00661 #define YY_USER_ACTION
00662 #endif
00663
00664
00665 #ifndef YY_BREAK
00666 #define YY_BREAK break;
00667 #endif
00668
00669
00670 #define YY_RULE_SETUP \
00671 YY_USER_ACTION
00672
00673
00674
00677 YY_DECL
00678 {
00679 register yy_state_type yy_current_state;
00680 register char *yy_cp, *yy_bp;
00681 register int yy_act;
00682
00683
00684 #line 57 "scanner.ll"
00685
00686
00687
00688
00689
00690 yylloc->step();
00691
00692
00693
00694
00695 #line 696 "scanner.cc"
00696
00697 if ( !(yy_init) )
00698 {
00699 (yy_init) = 1;
00700
00701 #ifdef YY_USER_INIT
00702 YY_USER_INIT;
00703 #endif
00704
00705 if ( ! (yy_start) )
00706 (yy_start) = 1;
00707
00708 if ( ! yyin )
00709
00710
00711
00712 yyin = & std::cin;
00713
00714
00715 if ( ! yyout )
00716
00717
00718
00719 yyout = & std::cout;
00720
00721
00722 if ( ! YY_CURRENT_BUFFER ) {
00723 yyensure_buffer_stack ();
00724 YY_CURRENT_BUFFER_LVALUE =
00725 yy_create_buffer( yyin, YY_BUF_SIZE );
00726 }
00727
00728 yy_load_buffer_state( );
00729 }
00730
00731 while ( 1 )
00732 {
00733
00734 yy_cp = (yy_c_buf_p);
00735
00736
00737 *yy_cp = (yy_hold_char);
00738
00739
00740
00741
00742 yy_bp = yy_cp;
00743
00744
00745 yy_current_state = (yy_start);
00746 yy_match:
00747 do
00748 {
00749 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
00750 if ( yy_accept[yy_current_state] )
00751 {
00752 (yy_last_accepting_state) = yy_current_state;
00753 (yy_last_accepting_cpos) = yy_cp;
00754 }
00755 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00756 {
00757 yy_current_state = (int) yy_def[yy_current_state];
00758 if ( yy_current_state >= 15 )
00759 yy_c = yy_meta[(unsigned int) yy_c];
00760 }
00761 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
00762 ++yy_cp;
00763 }
00764 while ( yy_current_state != 14 );
00765 yy_cp = (yy_last_accepting_cpos);
00766 yy_current_state = (yy_last_accepting_state);
00767
00768 yy_find_action:
00769
00770 yy_act = yy_accept[yy_current_state];
00771
00772 YY_DO_BEFORE_ACTION;
00773
00774
00775
00776 do_action:
00777
00778
00779 if ( yy_flex_debug )
00780 {
00781 if ( yy_act == 0 )
00782 std::cerr << "--scanner backing up\n";
00783 else if ( yy_act < 7 )
00784 std::cerr << "--accepting rule at line " << yy_rule_linenum[yy_act] <<
00785 "(\"" << yytext << "\")\n";
00786 else if ( yy_act == 7 )
00787 std::cerr << "--accepting default rule (\"" << yytext << "\")\n";
00788 else if ( yy_act == 8 )
00789 std::cerr << "--(end of buffer or a NUL)\n";
00790 else
00791 std::cerr << "--EOF (start condition " << YY_START << ")\n";
00792 }
00793
00794 switch ( yy_act )
00795 {
00796
00797 case 0:
00798
00799 *yy_cp = (yy_hold_char);
00800 yy_cp = (yy_last_accepting_cpos);
00801 yy_current_state = (yy_last_accepting_state);
00802 goto yy_find_action;
00803
00804 case 1:
00805 YY_RULE_SETUP
00806 #line 67 "scanner.ll"
00807 {
00808 yylval->integerVal = atoi(yytext);
00809 return token::INTEGER;
00810 }
00811 YY_BREAK
00812 case 2:
00813 YY_RULE_SETUP
00814 #line 72 "scanner.ll"
00815 {
00816 yylval->doubleVal = atof(yytext);
00817 return token::DOUBLE;
00818 }
00819 YY_BREAK
00820 case 3:
00821 YY_RULE_SETUP
00822 #line 77 "scanner.ll"
00823 {
00824 yylval->stringVal = new std::string(yytext, yyleng);
00825 return token::STRING;
00826 }
00827 YY_BREAK
00828
00829 case 4:
00830 YY_RULE_SETUP
00831 #line 83 "scanner.ll"
00832 {
00833 yylloc->step();
00834 }
00835 YY_BREAK
00836
00837 case 5:
00838
00839 YY_RULE_SETUP
00840 #line 88 "scanner.ll"
00841 {
00842 yylloc->lines(yyleng); yylloc->step();
00843 return token::EOL;
00844 }
00845 YY_BREAK
00846
00847 case 6:
00848 YY_RULE_SETUP
00849 #line 94 "scanner.ll"
00850 {
00851 return static_cast<token_type>(*yytext);
00852 }
00853 YY_BREAK
00854
00855 case 7:
00856 YY_RULE_SETUP
00857 #line 100 "scanner.ll"
00858 ECHO;
00859 YY_BREAK
00860 #line 861 "scanner.cc"
00861 case YY_STATE_EOF(INITIAL):
00862 yyterminate();
00863
00864 case YY_END_OF_BUFFER:
00865 {
00866
00867 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
00868
00869
00870 *yy_cp = (yy_hold_char);
00871 YY_RESTORE_YY_MORE_OFFSET
00872
00873 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
00874 {
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
00885 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
00886 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
00887 }
00888
00889
00890
00891
00892
00893
00894
00895
00896 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
00897 {
00898 yy_state_type yy_next_state;
00899
00900 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
00901
00902 yy_current_state = yy_get_previous_state( );
00903
00904
00905
00906
00907
00908
00909
00910
00911
00912
00913 yy_next_state = yy_try_NUL_trans( yy_current_state );
00914
00915 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
00916
00917 if ( yy_next_state )
00918 {
00919
00920 yy_cp = ++(yy_c_buf_p);
00921 yy_current_state = yy_next_state;
00922 goto yy_match;
00923 }
00924
00925 else
00926 {
00927
00928 yy_cp = (yy_last_accepting_cpos);
00929 yy_current_state = (yy_last_accepting_state);
00930 goto yy_find_action;
00931 }
00932 }
00933
00934 else switch ( yy_get_next_buffer( ) )
00935 {
00936 case EOB_ACT_END_OF_FILE:
00937 {
00938 (yy_did_buffer_switch_on_eof) = 0;
00939
00940 if ( yywrap( ) )
00941 {
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
00952
00953 yy_act = YY_STATE_EOF(YY_START);
00954 goto do_action;
00955 }
00956
00957 else
00958 {
00959 if ( ! (yy_did_buffer_switch_on_eof) )
00960 YY_NEW_FILE;
00961 }
00962 break;
00963 }
00964
00965 case EOB_ACT_CONTINUE_SCAN:
00966 (yy_c_buf_p) =
00967 (yytext_ptr) + yy_amount_of_matched_text;
00968
00969 yy_current_state = yy_get_previous_state( );
00970
00971 yy_cp = (yy_c_buf_p);
00972 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
00973 goto yy_match;
00974
00975 case EOB_ACT_LAST_MATCH:
00976 (yy_c_buf_p) =
00977 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
00978
00979 yy_current_state = yy_get_previous_state( );
00980
00981 yy_cp = (yy_c_buf_p);
00982 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
00983 goto yy_find_action;
00984 }
00985 break;
00986 }
00987
00988 default:
00989 YY_FATAL_ERROR(
00990 "fatal flex scanner internal error--no action found" );
00991 }
00992 }
00993 }
00994
00995
00996
00997
00998
00999 yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )
01000 {
01001 yyin = arg_yyin;
01002 yyout = arg_yyout;
01003 yy_c_buf_p = 0;
01004 yy_init = 0;
01005 yy_start = 0;
01006 yy_flex_debug = 0;
01007 yylineno = 1;
01008
01009 yy_did_buffer_switch_on_eof = 0;
01010
01011 yy_looking_for_trail_begin = 0;
01012 yy_more_flag = 0;
01013 yy_more_len = 0;
01014 yy_more_offset = yy_prev_more_offset = 0;
01015
01016 yy_start_stack_ptr = yy_start_stack_depth = 0;
01017 yy_start_stack = NULL;
01018
01019 (yy_buffer_stack) = 0;
01020 (yy_buffer_stack_top) = 0;
01021 (yy_buffer_stack_max) = 0;
01022
01023 yy_state_buf = 0;
01024
01025 }
01026
01027 yyFlexLexer::~yyFlexLexer()
01028 {
01029 delete [] yy_state_buf;
01030 Examplefree(yy_start_stack );
01031 yy_delete_buffer( YY_CURRENT_BUFFER );
01032 }
01033
01034 void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
01035 {
01036 if ( new_in )
01037 {
01038 yy_delete_buffer( YY_CURRENT_BUFFER );
01039 yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
01040 }
01041
01042 if ( new_out )
01043 yyout = new_out;
01044 }
01045
01046 #ifdef YY_INTERACTIVE
01047 int yyFlexLexer::LexerInput( char* buf, int )
01048 #else
01049 int yyFlexLexer::LexerInput( char* buf, int max_size )
01050 #endif
01051 {
01052 if ( yyin->eof() || yyin->fail() )
01053 return 0;
01054
01055 #ifdef YY_INTERACTIVE
01056 yyin->get( buf[0] );
01057
01058 if ( yyin->eof() )
01059 return 0;
01060
01061 if ( yyin->bad() )
01062 return -1;
01063
01064 return 1;
01065
01066 #else
01067 (void) yyin->read( buf, max_size );
01068
01069 if ( yyin->bad() )
01070 return -1;
01071 else
01072 return yyin->gcount();
01073 #endif
01074 }
01075
01076 void yyFlexLexer::LexerOutput( const char* buf, int size )
01077 {
01078 (void) yyout->write( buf, size );
01079 }
01080
01081
01082
01083
01084
01085
01086
01087
01088
01089
01090
01091
01092
01093
01094 int yyFlexLexer::yy_get_next_buffer()
01095
01096 {
01097 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
01098 register char *source = (yytext_ptr);
01099 register int number_to_move, i;
01100 int ret_val;
01101
01102 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
01103 YY_FATAL_ERROR(
01104 "fatal flex scanner internal error--end of buffer missed" );
01105
01106 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
01107 {
01108 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
01109 {
01110
01111
01112
01113 return EOB_ACT_END_OF_FILE;
01114 }
01115
01116 else
01117 {
01118
01119
01120
01121 return EOB_ACT_LAST_MATCH;
01122 }
01123 }
01124
01125
01126
01127
01128 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
01129
01130 for ( i = 0; i < number_to_move; ++i )
01131 *(dest++) = *(source++);
01132
01133 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
01134
01135
01136
01137 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
01138
01139 else
01140 {
01141 int num_to_read =
01142 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
01143
01144 while ( num_to_read <= 0 )
01145 {
01146
01147
01148 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
01149
01150 int yy_c_buf_p_offset =
01151 (int) ((yy_c_buf_p) - b->yy_ch_buf);
01152
01153 if ( b->yy_is_our_buffer )
01154 {
01155 int new_size = b->yy_buf_size * 2;
01156
01157 if ( new_size <= 0 )
01158 b->yy_buf_size += b->yy_buf_size / 8;
01159 else
01160 b->yy_buf_size *= 2;
01161
01162 b->yy_ch_buf = (char *)
01163
01164 Examplerealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
01165 }
01166 else
01167
01168 b->yy_ch_buf = 0;
01169
01170 if ( ! b->yy_ch_buf )
01171 YY_FATAL_ERROR(
01172 "fatal error - scanner input buffer overflow" );
01173
01174 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
01175
01176 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
01177 number_to_move - 1;
01178
01179 }
01180
01181 if ( num_to_read > YY_READ_BUF_SIZE )
01182 num_to_read = YY_READ_BUF_SIZE;
01183
01184
01185 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
01186 (yy_n_chars), num_to_read );
01187
01188 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
01189 }
01190
01191 if ( (yy_n_chars) == 0 )
01192 {
01193 if ( number_to_move == YY_MORE_ADJ )
01194 {
01195 ret_val = EOB_ACT_END_OF_FILE;
01196 yyrestart( yyin );
01197 }
01198
01199 else
01200 {
01201 ret_val = EOB_ACT_LAST_MATCH;
01202 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
01203 YY_BUFFER_EOF_PENDING;
01204 }
01205 }
01206
01207 else
01208 ret_val = EOB_ACT_CONTINUE_SCAN;
01209
01210 (yy_n_chars) += number_to_move;
01211 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
01212 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
01213
01214 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
01215
01216 return ret_val;
01217 }
01218
01219
01220
01221
01222
01223
01224
01225
01226 yy_state_type yyFlexLexer::yy_get_previous_state()
01227
01228 {
01229 register yy_state_type yy_current_state;
01230 register char *yy_cp;
01231
01232
01233 yy_current_state = (yy_start);
01234
01235 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
01236 {
01237
01238 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
01239 if ( yy_accept[yy_current_state] )
01240 {
01241 (yy_last_accepting_state) = yy_current_state;
01242 (yy_last_accepting_cpos) = yy_cp;
01243 }
01244 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01245 {
01246 yy_current_state = (int) yy_def[yy_current_state];
01247 if ( yy_current_state >= 15 )
01248 yy_c = yy_meta[(unsigned int) yy_c];
01249 }
01250 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01251 }
01252
01253 return yy_current_state;
01254 }
01255
01256
01257
01258
01259
01260
01261
01262
01263
01264 yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
01265
01266 {
01267 register int yy_is_jam;
01268
01269 register char *yy_cp = (yy_c_buf_p);
01270
01271 register YY_CHAR yy_c = 1;
01272 if ( yy_accept[yy_current_state] )
01273 {
01274 (yy_last_accepting_state) = yy_current_state;
01275 (yy_last_accepting_cpos) = yy_cp;
01276 }
01277 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01278 {
01279 yy_current_state = (int) yy_def[yy_current_state];
01280 if ( yy_current_state >= 15 )
01281 yy_c = yy_meta[(unsigned int) yy_c];
01282 }
01283 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01284 yy_is_jam = (yy_current_state == 14);
01285
01286 return yy_is_jam ? 0 : yy_current_state;
01287 }
01288
01289
01290
01291
01292 void yyFlexLexer::yyunput( int c, register char* yy_bp)
01293
01294 {
01295 register char *yy_cp;
01296
01297 yy_cp = (yy_c_buf_p);
01298
01299
01300 *yy_cp = (yy_hold_char);
01301
01302 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
01303 {
01304
01305 register int number_to_move = (yy_n_chars) + 2;
01306 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
01307 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
01308 register char *source =
01309 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
01310
01311 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
01312 *--dest = *--source;
01313
01314 yy_cp += (int) (dest - source);
01315 yy_bp += (int) (dest - source);
01316 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
01317 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
01318
01319 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
01320 YY_FATAL_ERROR( "flex scanner push-back overflow" );
01321 }
01322
01323 *--yy_cp = (char) c;
01324
01325
01326
01327 (yytext_ptr) = yy_bp;
01328 (yy_hold_char) = *yy_cp;
01329 (yy_c_buf_p) = yy_cp;
01330 }
01331
01332
01333
01334
01335
01336
01337 int yyFlexLexer::yyinput()
01338
01339 {
01340 int c;
01341
01342 *(yy_c_buf_p) = (yy_hold_char);
01343
01344 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
01345 {
01346
01347
01348
01349
01350 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
01351
01352 *(yy_c_buf_p) = '\0';
01353
01354 else
01355 {
01356 int offset = (yy_c_buf_p) - (yytext_ptr);
01357 ++(yy_c_buf_p);
01358
01359 switch ( yy_get_next_buffer( ) )
01360 {
01361 case EOB_ACT_LAST_MATCH:
01362
01363
01364
01365
01366
01367
01368
01369
01370
01371
01372
01373 yyrestart( yyin );
01374
01375
01376
01377 case EOB_ACT_END_OF_FILE:
01378 {
01379 if ( yywrap( ) )
01380 return EOF;
01381
01382 if ( ! (yy_did_buffer_switch_on_eof) )
01383 YY_NEW_FILE;
01384 #ifdef __cplusplus
01385 return yyinput();
01386 #else
01387 return input();
01388 #endif
01389 }
01390
01391 case EOB_ACT_CONTINUE_SCAN:
01392 (yy_c_buf_p) = (yytext_ptr) + offset;
01393 break;
01394 }
01395 }
01396 }
01397
01398 c = *(unsigned char *) (yy_c_buf_p);
01399 *(yy_c_buf_p) = '\0';
01400 (yy_hold_char) = *++(yy_c_buf_p);
01401
01402
01403
01404 return c;
01405 }
01406
01407
01408
01414
01415
01416
01417 void yyFlexLexer::yyrestart( std::istream* input_file )
01418
01419 {
01420
01421 if ( ! YY_CURRENT_BUFFER ){
01422 yyensure_buffer_stack ();
01423 YY_CURRENT_BUFFER_LVALUE =
01424 yy_create_buffer( yyin, YY_BUF_SIZE );
01425 }
01426
01427 yy_init_buffer( YY_CURRENT_BUFFER, input_file );
01428 yy_load_buffer_state( );
01429 }
01430
01435
01436
01437
01438 void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
01439
01440 {
01441
01442
01443
01444
01445
01446
01447 yyensure_buffer_stack ();
01448 if ( YY_CURRENT_BUFFER == new_buffer )
01449 return;
01450
01451 if ( YY_CURRENT_BUFFER )
01452 {
01453
01454 *(yy_c_buf_p) = (yy_hold_char);
01455 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
01456 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
01457 }
01458
01459 YY_CURRENT_BUFFER_LVALUE = new_buffer;
01460 yy_load_buffer_state( );
01461
01462
01463
01464
01465
01466
01467 (yy_did_buffer_switch_on_eof) = 1;
01468 }
01469
01470
01471
01472
01473 void yyFlexLexer::yy_load_buffer_state()
01474
01475 {
01476 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
01477 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
01478 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
01479 (yy_hold_char) = *(yy_c_buf_p);
01480 }
01481
01488
01489
01490
01491 YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size )
01492
01493 {
01494 YY_BUFFER_STATE b;
01495
01496 b = (YY_BUFFER_STATE) Examplealloc(sizeof( struct yy_buffer_state ) );
01497 if ( ! b )
01498 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01499
01500 b->yy_buf_size = size;
01501
01502
01503
01504
01505 b->yy_ch_buf = (char *) Examplealloc(b->yy_buf_size + 2 );
01506 if ( ! b->yy_ch_buf )
01507 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01508
01509 b->yy_is_our_buffer = 1;
01510
01511 yy_init_buffer( b, file );
01512
01513 return b;
01514 }
01515
01520
01521
01522
01523 void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
01524
01525 {
01526
01527 if ( ! b )
01528 return;
01529
01530 if ( b == YY_CURRENT_BUFFER )
01531 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
01532
01533 if ( b->yy_is_our_buffer )
01534 Examplefree((void *) b->yy_ch_buf );
01535
01536 Examplefree((void *) b );
01537 }
01538
01539
01540
01541
01542
01543
01544 extern "C" int isatty (int );
01545
01546
01547
01548
01549
01550
01551
01552
01553
01554
01555 void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file )
01556
01557
01558 {
01559 int oerrno = errno;
01560
01561 yy_flush_buffer( b );
01562
01563 b->yy_input_file = file;
01564 b->yy_fill_buffer = 1;
01565
01566
01567
01568
01569
01570 if (b != YY_CURRENT_BUFFER){
01571 b->yy_bs_lineno = 1;
01572 b->yy_bs_column = 0;
01573 }
01574
01575
01576
01577
01578 b->yy_is_interactive = 0;
01579
01580 errno = oerrno;
01581 }
01582
01587
01588
01589
01590 void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
01591
01592 {
01593 if ( ! b )
01594 return;
01595
01596 b->yy_n_chars = 0;
01597
01598
01599
01600
01601
01602 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
01603 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
01604
01605 b->yy_buf_pos = &b->yy_ch_buf[0];
01606
01607 b->yy_at_bol = 1;
01608 b->yy_buffer_status = YY_BUFFER_NEW;
01609
01610 if ( b == YY_CURRENT_BUFFER )
01611 yy_load_buffer_state( );
01612 }
01613
01614
01621
01622
01623
01624 void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer)
01625
01626 {
01627 if (new_buffer == NULL)
01628 return;
01629
01630 yyensure_buffer_stack();
01631
01632
01633 if ( YY_CURRENT_BUFFER )
01634 {
01635
01636 *(yy_c_buf_p) = (yy_hold_char);
01637 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
01638 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
01639 }
01640
01641
01642 if (YY_CURRENT_BUFFER)
01643 (yy_buffer_stack_top)++;
01644 YY_CURRENT_BUFFER_LVALUE = new_buffer;
01645
01646
01647 yy_load_buffer_state( );
01648 (yy_did_buffer_switch_on_eof) = 1;
01649 }
01650
01651
01652
01657
01658
01659
01660 void yyFlexLexer::yypop_buffer_state (void)
01661
01662 {
01663 if (!YY_CURRENT_BUFFER)
01664 return;
01665
01666 yy_delete_buffer(YY_CURRENT_BUFFER );
01667 YY_CURRENT_BUFFER_LVALUE = NULL;
01668 if ((yy_buffer_stack_top) > 0)
01669 --(yy_buffer_stack_top);
01670
01671 if (YY_CURRENT_BUFFER) {
01672 yy_load_buffer_state( );
01673 (yy_did_buffer_switch_on_eof) = 1;
01674 }
01675 }
01676
01677
01678
01679
01680
01681
01682
01683
01684
01685 void yyFlexLexer::yyensure_buffer_stack(void)
01686
01687 {
01688 int num_to_alloc;
01689
01690 if (!(yy_buffer_stack)) {
01691
01692
01693
01694
01695
01696 num_to_alloc = 1;
01697 (yy_buffer_stack) = (struct yy_buffer_state**)Examplealloc
01698 (num_to_alloc * sizeof(struct yy_buffer_state*)
01699 );
01700
01701 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
01702
01703 (yy_buffer_stack_max) = num_to_alloc;
01704 (yy_buffer_stack_top) = 0;
01705 return;
01706 }
01707
01708 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
01709
01710
01711 int grow_size = 8 ;
01712
01713 num_to_alloc = (yy_buffer_stack_max) + grow_size;
01714 (yy_buffer_stack) = (struct yy_buffer_state**)Examplerealloc
01715 ((yy_buffer_stack),
01716 num_to_alloc * sizeof(struct yy_buffer_state*)
01717 );
01718
01719
01720 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
01721 (yy_buffer_stack_max) = num_to_alloc;
01722 }
01723 }
01724
01725
01726
01727
01728
01729
01730
01731
01732
01733
01734
01735
01736
01737
01738 void yyFlexLexer::yy_push_state( int new_state )
01739
01740 {
01741 if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
01742 {
01743 yy_size_t new_size;
01744
01745 (yy_start_stack_depth) += YY_START_STACK_INCR;
01746 new_size = (yy_start_stack_depth) * sizeof( int );
01747
01748 if ( ! (yy_start_stack) )
01749 (yy_start_stack) = (int *) Examplealloc(new_size );
01750
01751 else
01752 (yy_start_stack) = (int *) Examplerealloc((void *) (yy_start_stack),new_size );
01753
01754 if ( ! (yy_start_stack) )
01755 YY_FATAL_ERROR(
01756 "out of memory expanding start-condition stack" );
01757 }
01758
01759 (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
01760
01761 BEGIN(new_state);
01762 }
01763
01764
01765
01766
01767 void yyFlexLexer::yy_pop_state()
01768
01769 {
01770 if ( --(yy_start_stack_ptr) < 0 )
01771 YY_FATAL_ERROR( "start-condition stack underflow" );
01772
01773 BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
01774 }
01775
01776
01777
01778
01779 int yyFlexLexer::yy_top_state()
01780
01781 {
01782 return (yy_start_stack)[(yy_start_stack_ptr) - 1];
01783 }
01784
01785 #ifndef YY_EXIT_FAILURE
01786 #define YY_EXIT_FAILURE 2
01787 #endif
01788
01789
01790
01791
01792 void yyFlexLexer::LexerError( yyconst char msg[] )
01793 {
01794 std::cerr << msg << std::endl;
01795 exit( YY_EXIT_FAILURE );
01796 }
01797
01798
01799
01800
01801 #undef yyless
01802 #define yyless(n) \
01803 do \
01804 { \
01805 \
01806 int yyless_macro_arg = (n); \
01807 YY_LESS_LINENO(yyless_macro_arg);\
01808 yytext[yyleng] = (yy_hold_char); \
01809 (yy_c_buf_p) = yytext + yyless_macro_arg; \
01810 (yy_hold_char) = *(yy_c_buf_p); \
01811 *(yy_c_buf_p) = '\0'; \
01812 yyleng = yyless_macro_arg; \
01813 } \
01814 while ( 0 )
01815
01816
01817
01818
01819
01820
01821
01822
01823
01824
01825
01826
01827
01828
01829
01830
01831
01832
01833
01834
01835
01836
01837
01838
01839
01840
01841
01842 #ifndef yytext_ptr
01843 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
01844 {
01845 register int i;
01846 for ( i = 0; i < n; ++i )
01847 s1[i] = s2[i];
01848 }
01849 #endif
01850
01851 #ifdef YY_NEED_STRLEN
01852 static int yy_flex_strlen (yyconst char * s )
01853 {
01854 register int n;
01855 for ( n = 0; s[n]; ++n )
01856 ;
01857
01858 return n;
01859 }
01860 #endif
01861
01862 void *Examplealloc (yy_size_t size )
01863 {
01864 return (void *) malloc( size );
01865 }
01866
01867 void *Examplerealloc (void * ptr, yy_size_t size )
01868 {
01869
01870
01871
01872
01873
01874
01875
01876 return (void *) realloc( (char *) ptr, size );
01877 }
01878
01879 void Examplefree (void * ptr )
01880 {
01881 free( (char *) ptr );
01882 }
01883
01884
01885
01886 #define YYTABLES_NAME "yytables"
01887
01888
01889
01890
01891 #line 100 "scanner.ll"
01892
01893
01894
01895 namespace example {
01896
01897 Scanner::Scanner(std::istream* in,
01898 std::ostream* out)
01899 : ExampleFlexLexer(in, out)
01900 {
01901 }
01902
01903 Scanner::~Scanner()
01904 {
01905 }
01906
01907 void Scanner::set_debug(bool b)
01908 {
01909 yy_flex_debug = b;
01910 }
01911
01912 }
01913
01914
01915
01916
01917
01918 #ifdef yylex
01919 #undef yylex
01920 #endif
01921
01922 int ExampleFlexLexer::yylex()
01923 {
01924 std::cerr << "in ExampleFlexLexer::yylex() !" << std::endl;
01925 return 0;
01926 }
01927