00001
00002
00003
00004
00005
00006
00007 #define FLEX_SCANNER
00008 #define YY_FLEX_MAJOR_VERSION 2
00009 #define YY_FLEX_MINOR_VERSION 5
00010
00011
00012
00013
00014 #ifdef c_plusplus
00015 #ifndef __cplusplus
00016 #define __cplusplus
00017 #endif
00018 #endif
00019
00020
00021 #ifdef __cplusplus
00022
00023 #include <stdlib.h>
00024 class istream;
00025 #include <fstream>
00026 using std::istream;
00027 using std::ostream;
00028 #ifndef _WIN32
00029 #include <unistd.h>
00030 #endif
00031
00032
00033 #define YY_USE_PROTOS
00034
00035
00036 #define YY_USE_CONST
00037
00038 #else
00039
00040 #if __STDC__
00041
00042 #define YY_USE_PROTOS
00043 #define YY_USE_CONST
00044
00045 #endif
00046 #endif
00047
00048 #ifdef __TURBOC__
00049 #pragma warn -rch
00050 #pragma warn -use
00051 #include <io.h>
00052 #include <stdlib.h>
00053 #define YY_USE_CONST
00054 #define YY_USE_PROTOS
00055 #endif
00056
00057 #ifdef YY_USE_CONST
00058 #define yyconst const
00059 #else
00060 #define yyconst
00061 #endif
00062
00063
00064 #ifdef YY_USE_PROTOS
00065 #define YY_PROTO(proto) proto
00066 #else
00067 #define YY_PROTO(proto) ()
00068 #endif
00069
00070
00071 #define YY_NULL 0
00072
00073
00074
00075
00076
00077
00078 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00079
00080
00081
00082
00083
00084 #define BEGIN yy_start = 1 + 2 *
00085
00086
00087
00088
00089
00090 #define YY_START ((yy_start - 1) / 2)
00091 #define YYSTATE YY_START
00092
00093
00094 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
00095
00096
00097 #define YY_NEW_FILE yyrestart( yyin )
00098
00099 #define YY_END_OF_BUFFER_CHAR 0
00100
00101
00102 #define YY_BUF_SIZE 16384
00103
00104 typedef struct yy_buffer_state *YY_BUFFER_STATE;
00105
00106 extern int yyleng;
00107
00108 #define EOB_ACT_CONTINUE_SCAN 0
00109 #define EOB_ACT_END_OF_FILE 1
00110 #define EOB_ACT_LAST_MATCH 2
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128 #define yyless(n) \
00129 do \
00130 { \
00131 \
00132 *yy_cp = yy_hold_char; \
00133 YY_RESTORE_YY_MORE_OFFSET \
00134 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
00135 YY_DO_BEFORE_ACTION; \
00136 } \
00137 while ( 0 )
00138
00139 #define unput(c) yyunput( c, yytext_ptr )
00140
00141
00142
00143
00144
00145 typedef unsigned int yy_size_t;
00146
00147
00148 struct yy_buffer_state
00149 {
00150 istream* yy_input_file;
00151
00152 char *yy_ch_buf;
00153 char *yy_buf_pos;
00154
00155
00156
00157
00158 yy_size_t yy_buf_size;
00159
00160
00161
00162
00163 int yy_n_chars;
00164
00165
00166
00167
00168
00169 int yy_is_our_buffer;
00170
00171
00172
00173
00174
00175
00176 int yy_is_interactive;
00177
00178
00179
00180
00181
00182 int yy_at_bol;
00183
00184
00185
00186
00187 int yy_fill_buffer;
00188
00189 int yy_buffer_status;
00190 #define YY_BUFFER_NEW 0
00191 #define YY_BUFFER_NORMAL 1
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202 #define YY_BUFFER_EOF_PENDING 2
00203 };
00204
00205
00206
00207
00208
00209
00210 #define YY_CURRENT_BUFFER yy_current_buffer
00211
00212
00213
00214 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
00215 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
00216 static void yy_flex_free YY_PROTO(( void * ));
00217
00218 #define yy_new_buffer yy_create_buffer
00219
00220 #define yy_set_interactive(is_interactive) \
00221 { \
00222 if ( ! yy_current_buffer ) \
00223 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
00224 yy_current_buffer->yy_is_interactive = is_interactive; \
00225 }
00226
00227 #define yy_set_bol(at_bol) \
00228 { \
00229 if ( ! yy_current_buffer ) \
00230 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
00231 yy_current_buffer->yy_at_bol = at_bol; \
00232 }
00233
00234 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
00235
00236
00237 #define yywrap() 1
00238 #define YY_SKIP_YYWRAP
00239 typedef unsigned char YY_CHAR;
00240 #define yytext_ptr yytext
00241 #define YY_INTERACTIVE
00242
00243 #include <FlexLexer.h>
00244
00245
00246
00247
00248
00249 #define YY_DO_BEFORE_ACTION \
00250 yytext_ptr = yy_bp; \
00251 yyleng = (int) (yy_cp - yy_bp); \
00252 yy_hold_char = *yy_cp; \
00253 *yy_cp = '\0'; \
00254 yy_c_buf_p = yy_cp;
00255
00256 #define YY_NUM_RULES 32
00257 #define YY_END_OF_BUFFER 33
00258 static yyconst short int yy_accept[72] =
00259 { 0,
00260 0, 0, 33, 32, 2, 31, 30, 1, 20, 21,
00261 27, 28, 25, 26, 3, 18, 24, 16, 16, 16,
00262 29, 17, 17, 17, 17, 17, 17, 17, 17, 17,
00263 17, 22, 23, 2, 30, 1, 3, 19, 16, 0,
00264 13, 17, 17, 17, 17, 17, 17, 11, 17, 17,
00265 17, 17, 14, 12, 17, 17, 17, 17, 4, 5,
00266 17, 17, 10, 6, 8, 17, 7, 9, 17, 15,
00267 0
00268 } ;
00269
00270 static yyconst int yy_ec[256] =
00271 { 0,
00272 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
00273 1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
00274 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00275 1, 5, 6, 6, 7, 6, 6, 6, 6, 8,
00276 9, 10, 11, 12, 6, 13, 6, 14, 14, 14,
00277 14, 14, 14, 14, 14, 14, 14, 6, 6, 6,
00278 15, 6, 6, 16, 17, 18, 18, 19, 18, 18,
00279 18, 18, 18, 18, 18, 18, 18, 20, 21, 18,
00280 18, 22, 18, 18, 18, 18, 18, 18, 18, 18,
00281 6, 6, 6, 23, 24, 6, 25, 26, 27, 28,
00282
00283 29, 30, 27, 31, 32, 27, 27, 33, 34, 35,
00284 36, 37, 27, 38, 39, 40, 41, 27, 27, 27,
00285 27, 42, 43, 6, 44, 6, 1, 1, 1, 1,
00286 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00287 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00288 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00289 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00290 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00291 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00292 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00293
00294 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00295 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00296 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00297 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00298 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00299 1, 1, 1, 1, 1
00300 } ;
00301
00302 static yyconst int yy_meta[45] =
00303 { 0,
00304 1, 2, 1, 1, 2, 2, 2, 2, 2, 2,
00305 2, 2, 2, 3, 2, 2, 2, 2, 2, 4,
00306 2, 2, 2, 3, 3, 3, 3, 3, 3, 3,
00307 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00308 3, 3, 2, 2
00309 } ;
00310
00311 static yyconst short int yy_base[75] =
00312 { 0,
00313 0, 0, 100, 101, 43, 101, 47, 0, 101, 101,
00314 101, 101, 101, 101, 85, 83, 101, 77, 76, 33,
00315 101, 60, 65, 0, 64, 57, 50, 52, 48, 17,
00316 59, 101, 101, 54, 58, 0, 73, 101, 66, 66,
00317 101, 0, 56, 54, 49, 51, 46, 0, 44, 38,
00318 48, 38, 101, 0, 38, 37, 37, 46, 0, 0,
00319 34, 34, 0, 0, 0, 40, 0, 0, 23, 16,
00320 101, 62, 64, 47
00321 } ;
00322
00323 static yyconst short int yy_def[75] =
00324 { 0,
00325 71, 1, 71, 71, 71, 71, 71, 72, 71, 71,
00326 71, 71, 71, 71, 71, 71, 71, 73, 73, 73,
00327 71, 74, 74, 74, 74, 74, 74, 74, 74, 74,
00328 74, 71, 71, 71, 71, 72, 71, 71, 73, 71,
00329 71, 74, 74, 74, 74, 74, 74, 74, 74, 74,
00330 74, 74, 71, 74, 74, 74, 74, 74, 74, 74,
00331 74, 74, 74, 74, 74, 74, 74, 74, 74, 74,
00332 0, 71, 71, 71
00333 } ;
00334
00335 static yyconst short int yy_nxt[146] =
00336 { 0,
00337 4, 5, 6, 7, 5, 4, 8, 9, 10, 11,
00338 12, 13, 14, 15, 16, 17, 18, 19, 19, 19,
00339 20, 19, 21, 4, 22, 23, 24, 24, 24, 24,
00340 25, 26, 24, 24, 27, 28, 24, 29, 30, 24,
00341 24, 31, 32, 33, 34, 50, 35, 34, 35, 42,
00342 35, 35, 71, 70, 41, 34, 51, 35, 34, 35,
00343 70, 35, 35, 36, 36, 36, 39, 39, 69, 68,
00344 67, 66, 65, 64, 63, 62, 61, 60, 59, 58,
00345 57, 56, 55, 54, 53, 71, 37, 52, 49, 48,
00346 47, 46, 45, 44, 43, 71, 40, 38, 37, 71,
00347
00348 3, 71, 71, 71, 71, 71, 71, 71, 71, 71,
00349 71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
00350 71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
00351 71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
00352 71, 71, 71, 71, 71
00353 } ;
00354
00355 static yyconst short int yy_chk[146] =
00356 { 0,
00357 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00358 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00359 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00360 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00361 1, 1, 1, 1, 5, 30, 5, 5, 7, 74,
00362 7, 7, 20, 70, 20, 34, 30, 34, 34, 35,
00363 69, 35, 35, 72, 72, 72, 73, 73, 66, 62,
00364 61, 58, 57, 56, 55, 52, 51, 50, 49, 47,
00365 46, 45, 44, 43, 40, 39, 37, 31, 29, 28,
00366 27, 26, 25, 23, 22, 19, 18, 16, 15, 3,
00367
00368 71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
00369 71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
00370 71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
00371 71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
00372 71, 71, 71, 71, 71
00373 } ;
00374
00375
00376
00377
00378 #define REJECT reject_used_but_not_detected
00379 #define yymore() yymore_used_but_not_detected
00380 #define YY_MORE_ADJ 0
00381 #define YY_RESTORE_YY_MORE_OFFSET
00382 #line 1 "parser.ll"
00383 #define INITIAL 0
00384 #line 2 "parser.ll"
00385
00386 #include <string>
00387
00388 #include "parser.h"
00389 #include "parser.tab.hh"
00390
00391 #undef yywrap
00392 #define yywrap() 1
00393 extern int numLine;
00394
00395 #line 391 "lex.yy.cc"
00396
00397
00398
00399
00400
00401 #ifndef YY_SKIP_YYWRAP
00402 #ifdef __cplusplus
00403 extern "C" int yywrap YY_PROTO(( void ));
00404 #else
00405 extern int yywrap YY_PROTO(( void ));
00406 #endif
00407 #endif
00408
00409
00410 #ifndef yytext_ptr
00411 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
00412 #endif
00413
00414 #ifdef YY_NEED_STRLEN
00415 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
00416 #endif
00417
00418 #ifndef YY_NO_INPUT
00419 #endif
00420
00421 #if YY_STACK_USED
00422 static int yy_start_stack_ptr = 0;
00423 static int yy_start_stack_depth = 0;
00424 static int *yy_start_stack = 0;
00425 #ifndef YY_NO_PUSH_STATE
00426 static void yy_push_state YY_PROTO(( int new_state ));
00427 #endif
00428 #ifndef YY_NO_POP_STATE
00429 static void yy_pop_state YY_PROTO(( void ));
00430 #endif
00431 #ifndef YY_NO_TOP_STATE
00432 static int yy_top_state YY_PROTO(( void ));
00433 #endif
00434
00435 #else
00436 #define YY_NO_PUSH_STATE 1
00437 #define YY_NO_POP_STATE 1
00438 #define YY_NO_TOP_STATE 1
00439 #endif
00440
00441 #ifdef YY_MALLOC_DECL
00442 YY_MALLOC_DECL
00443 #else
00444 #if __STDC__
00445 #ifndef __cplusplus
00446 #include <stdlib.h>
00447 #endif
00448 #else
00449
00450
00451
00452
00453 #endif
00454 #endif
00455
00456
00457 #ifndef YY_READ_BUF_SIZE
00458 #define YY_READ_BUF_SIZE 8192
00459 #endif
00460
00461
00462
00463 #ifndef ECHO
00464 #define ECHO LexerOutput( yytext, yyleng )
00465 #endif
00466
00467
00468
00469
00470 #ifndef YY_INPUT
00471 #define YY_INPUT(buf,result,max_size) \
00472 if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
00473 YY_FATAL_ERROR( "input in flex scanner failed" );
00474 #endif
00475
00476
00477
00478
00479
00480 #ifndef yyterminate
00481 #define yyterminate() return YY_NULL
00482 #endif
00483
00484
00485 #ifndef YY_START_STACK_INCR
00486 #define YY_START_STACK_INCR 25
00487 #endif
00488
00489
00490 #ifndef YY_FATAL_ERROR
00491 #define YY_FATAL_ERROR(msg) LexerError( msg )
00492 #endif
00493
00494
00495
00496
00497 #ifndef YY_DECL
00498 #define YY_DECL int yyFlexLexer::yylex()
00499 #endif
00500
00501
00502
00503
00504 #ifndef YY_USER_ACTION
00505 #define YY_USER_ACTION
00506 #endif
00507
00508
00509 #ifndef YY_BREAK
00510 #define YY_BREAK break;
00511 #endif
00512
00513 #define YY_RULE_SETUP \
00514 YY_USER_ACTION
00515
00516 YY_DECL
00517 {
00518 register yy_state_type yy_current_state;
00519 register char *yy_cp, *yy_bp;
00520 register int yy_act;
00521
00522 #line 28 "parser.ll"
00523
00524
00525 #line 521 "lex.yy.cc"
00526
00527 if ( yy_init )
00528 {
00529 yy_init = 0;
00530
00531 #ifdef YY_USER_INIT
00532 YY_USER_INIT;
00533 #endif
00534
00535 if ( ! yy_start )
00536 yy_start = 1;
00537
00538 if ( ! yyin )
00539 yyin = &cin;
00540
00541 if ( ! yyout )
00542 yyout = &cout;
00543
00544 if ( ! yy_current_buffer )
00545 yy_current_buffer =
00546 yy_create_buffer( yyin, YY_BUF_SIZE );
00547
00548 yy_load_buffer_state();
00549 }
00550
00551 while ( 1 )
00552 {
00553 yy_cp = yy_c_buf_p;
00554
00555
00556 *yy_cp = yy_hold_char;
00557
00558
00559
00560
00561 yy_bp = yy_cp;
00562
00563 yy_current_state = yy_start;
00564 yy_match:
00565 do
00566 {
00567 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
00568 if ( yy_accept[yy_current_state] )
00569 {
00570 yy_last_accepting_state = yy_current_state;
00571 yy_last_accepting_cpos = yy_cp;
00572 }
00573 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00574 {
00575 yy_current_state = (int) yy_def[yy_current_state];
00576 if ( yy_current_state >= 72 )
00577 yy_c = yy_meta[(unsigned int) yy_c];
00578 }
00579 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
00580 ++yy_cp;
00581 }
00582 while ( yy_base[yy_current_state] != 101 );
00583
00584 yy_find_action:
00585 yy_act = yy_accept[yy_current_state];
00586 if ( yy_act == 0 )
00587 {
00588 yy_cp = yy_last_accepting_cpos;
00589 yy_current_state = yy_last_accepting_state;
00590 yy_act = yy_accept[yy_current_state];
00591 }
00592
00593 YY_DO_BEFORE_ACTION;
00594
00595
00596 do_action:
00597
00598
00599 switch ( yy_act )
00600 {
00601 case 0:
00602
00603 *yy_cp = yy_hold_char;
00604 yy_cp = yy_last_accepting_cpos;
00605 yy_current_state = yy_last_accepting_state;
00606 goto yy_find_action;
00607
00608 case 1:
00609 YY_RULE_SETUP
00610 #line 30 "parser.ll"
00611 { }
00612 YY_BREAK
00613 case 2:
00614 YY_RULE_SETUP
00615 #line 32 "parser.ll"
00616 { }
00617 YY_BREAK
00618 case 3:
00619 YY_RULE_SETUP
00620 #line 34 "parser.ll"
00621 {
00622 yylval.integerVal = atoi(yytext);
00623 return INT;
00624 }
00625 YY_BREAK
00626 case 4:
00627 YY_RULE_SETUP
00628 #line 39 "parser.ll"
00629 return(RUN);
00630 YY_BREAK
00631 case 5:
00632 YY_RULE_SETUP
00633 #line 41 "parser.ll"
00634 return(SET);
00635 YY_BREAK
00636 case 6:
00637 YY_RULE_SETUP
00638 #line 42 "parser.ll"
00639 return(HELP);
00640 YY_BREAK
00641 case 7:
00642 YY_RULE_SETUP
00643 #line 44 "parser.ll"
00644 return(STEP);
00645 YY_BREAK
00646 case 8:
00647 YY_RULE_SETUP
00648 #line 45 "parser.ll"
00649 return(INFO);
00650 YY_BREAK
00651 case 9:
00652 YY_RULE_SETUP
00653 #line 46 "parser.ll"
00654 return(ZERO);
00655 YY_BREAK
00656 case 10:
00657 YY_RULE_SETUP
00658 #line 47 "parser.ll"
00659 return(BEEP);
00660 YY_BREAK
00661 case 11:
00662 YY_RULE_SETUP
00663 #line 49 "parser.ll"
00664 return(OR);
00665 YY_BREAK
00666 case 12:
00667 YY_RULE_SETUP
00668 #line 51 "parser.ll"
00669 return(AND);
00670 YY_BREAK
00671 case 13:
00672 YY_RULE_SETUP
00673 #line 53 "parser.ll"
00674 return(OR);
00675 YY_BREAK
00676 case 14:
00677 YY_RULE_SETUP
00678 #line 55 "parser.ll"
00679 return(AND);
00680 YY_BREAK
00681 case 15:
00682 YY_RULE_SETUP
00683 #line 57 "parser.ll"
00684 {
00685 yylval.integerVal = atoi(yytext);
00686 return(INT);
00687 }
00688 YY_BREAK
00689 case 16:
00690 YY_RULE_SETUP
00691 #line 62 "parser.ll"
00692 {
00693 yylval.stringVal = new std::string(yytext);
00694 return(MAJ);
00695 }
00696 YY_BREAK
00697 case 17:
00698 YY_RULE_SETUP
00699 #line 67 "parser.ll"
00700 {
00701 yylval.stringVal = new std::string(yytext);
00702 return(MIN);
00703 }
00704 YY_BREAK
00705 case 18:
00706 YY_RULE_SETUP
00707 #line 72 "parser.ll"
00708 {
00709 return EQUAL;
00710 }
00711 YY_BREAK
00712 case 19:
00713 YY_RULE_SETUP
00714 #line 76 "parser.ll"
00715 {
00716 return EQUAL2;
00717 }
00718 YY_BREAK
00719 case 20:
00720 YY_RULE_SETUP
00721 #line 80 "parser.ll"
00722 {
00723 return LEFT_PAR;
00724 }
00725 YY_BREAK
00726 case 21:
00727 YY_RULE_SETUP
00728 #line 84 "parser.ll"
00729 {
00730 return RIGHT_PAR;
00731 }
00732 YY_BREAK
00733 case 22:
00734 YY_RULE_SETUP
00735 #line 88 "parser.ll"
00736 {
00737 return LEFT_BRA;
00738 }
00739 YY_BREAK
00740 case 23:
00741 YY_RULE_SETUP
00742 #line 92 "parser.ll"
00743 {
00744 return RIGHT_BRA;
00745 }
00746 YY_BREAK
00747 case 24:
00748 YY_RULE_SETUP
00749 #line 96 "parser.ll"
00750 {
00751 return HOLE;
00752 }
00753 YY_BREAK
00754 case 25:
00755 YY_RULE_SETUP
00756 #line 100 "parser.ll"
00757 {
00758 return COMMA;
00759 }
00760 YY_BREAK
00761 case 26:
00762 YY_RULE_SETUP
00763 #line 104 "parser.ll"
00764 {
00765 return DOT;
00766 }
00767 YY_BREAK
00768 case 27:
00769 YY_RULE_SETUP
00770 #line 108 "parser.ll"
00771 {
00772 return TIMES;
00773 }
00774 YY_BREAK
00775 case 28:
00776 YY_RULE_SETUP
00777 #line 112 "parser.ll"
00778 {
00779 return PLUS;
00780 }
00781 YY_BREAK
00782 case 29:
00783 YY_RULE_SETUP
00784 #line 116 "parser.ll"
00785 {
00786 return POWER;
00787 }
00788 YY_BREAK
00789 case 30:
00790 YY_RULE_SETUP
00791 #line 120 "parser.ll"
00792 {
00793
00794 }
00795 YY_BREAK
00796 case 31:
00797 YY_RULE_SETUP
00798 #line 124 "parser.ll"
00799 {
00800 numLine++;
00801 return EOL;
00802 }
00803 YY_BREAK
00804 case 32:
00805 YY_RULE_SETUP
00806 #line 128 "parser.ll"
00807 ECHO;
00808 YY_BREAK
00809 #line 805 "lex.yy.cc"
00810 case YY_STATE_EOF(INITIAL):
00811 yyterminate();
00812
00813 case YY_END_OF_BUFFER:
00814 {
00815
00816 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
00817
00818
00819 *yy_cp = yy_hold_char;
00820 YY_RESTORE_YY_MORE_OFFSET
00821
00822 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
00823 {
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833 yy_n_chars = yy_current_buffer->yy_n_chars;
00834 yy_current_buffer->yy_input_file = yyin;
00835 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
00836 }
00837
00838
00839
00840
00841
00842
00843
00844
00845 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
00846 {
00847 yy_state_type yy_next_state;
00848
00849 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
00850
00851 yy_current_state = yy_get_previous_state();
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861
00862 yy_next_state = yy_try_NUL_trans( yy_current_state );
00863
00864 yy_bp = yytext_ptr + YY_MORE_ADJ;
00865
00866 if ( yy_next_state )
00867 {
00868
00869 yy_cp = ++yy_c_buf_p;
00870 yy_current_state = yy_next_state;
00871 goto yy_match;
00872 }
00873
00874 else
00875 {
00876 yy_cp = yy_c_buf_p;
00877 goto yy_find_action;
00878 }
00879 }
00880
00881 else switch ( yy_get_next_buffer() )
00882 {
00883 case EOB_ACT_END_OF_FILE:
00884 {
00885 yy_did_buffer_switch_on_eof = 0;
00886
00887 if ( yywrap() )
00888 {
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
00899
00900 yy_act = YY_STATE_EOF(YY_START);
00901 goto do_action;
00902 }
00903
00904 else
00905 {
00906 if ( ! yy_did_buffer_switch_on_eof )
00907 YY_NEW_FILE;
00908 }
00909 break;
00910 }
00911
00912 case EOB_ACT_CONTINUE_SCAN:
00913 yy_c_buf_p =
00914 yytext_ptr + yy_amount_of_matched_text;
00915
00916 yy_current_state = yy_get_previous_state();
00917
00918 yy_cp = yy_c_buf_p;
00919 yy_bp = yytext_ptr + YY_MORE_ADJ;
00920 goto yy_match;
00921
00922 case EOB_ACT_LAST_MATCH:
00923 yy_c_buf_p =
00924 &yy_current_buffer->yy_ch_buf[yy_n_chars];
00925
00926 yy_current_state = yy_get_previous_state();
00927
00928 yy_cp = yy_c_buf_p;
00929 yy_bp = yytext_ptr + YY_MORE_ADJ;
00930 goto yy_find_action;
00931 }
00932 break;
00933 }
00934
00935 default:
00936 YY_FATAL_ERROR(
00937 "fatal flex scanner internal error--no action found" );
00938 }
00939 }
00940 }
00941
00942 yyFlexLexer::yyFlexLexer( istream* arg_yyin, ostream* arg_yyout )
00943 {
00944 yyin = arg_yyin;
00945 yyout = arg_yyout;
00946 yy_c_buf_p = 0;
00947 yy_init = 1;
00948 yy_start = 0;
00949 yy_flex_debug = 0;
00950 yylineno = 1;
00951
00952 yy_did_buffer_switch_on_eof = 0;
00953
00954 yy_looking_for_trail_begin = 0;
00955 yy_more_flag = 0;
00956 yy_more_len = 0;
00957 yy_more_offset = yy_prev_more_offset = 0;
00958
00959 yy_start_stack_ptr = yy_start_stack_depth = 0;
00960 yy_start_stack = 0;
00961
00962 yy_current_buffer = 0;
00963
00964 #ifdef YY_USES_REJECT
00965 yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2];
00966 #else
00967 yy_state_buf = 0;
00968 #endif
00969 }
00970
00971 yyFlexLexer::~yyFlexLexer()
00972 {
00973 delete yy_state_buf;
00974 yy_delete_buffer( yy_current_buffer );
00975 }
00976
00977 void yyFlexLexer::switch_streams( istream* new_in, ostream* new_out )
00978 {
00979 if ( new_in )
00980 {
00981 yy_delete_buffer( yy_current_buffer );
00982 yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
00983 }
00984
00985 if ( new_out )
00986 yyout = new_out;
00987 }
00988
00989 #ifdef YY_INTERACTIVE
00990 int yyFlexLexer::LexerInput( char* buf, int )
00991 #else
00992 int yyFlexLexer::LexerInput( char* buf, int max_size )
00993 #endif
00994 {
00995 if ( yyin->eof() || yyin->fail() )
00996 return 0;
00997
00998 #ifdef YY_INTERACTIVE
00999 yyin->get( buf[0] );
01000
01001 if ( yyin->eof() )
01002 return 0;
01003
01004 if ( yyin->bad() )
01005 return -1;
01006
01007 return 1;
01008
01009 #else
01010 (void) yyin->read( buf, max_size );
01011
01012 if ( yyin->bad() )
01013 return -1;
01014 else
01015 return yyin->gcount();
01016 #endif
01017 }
01018
01019 void yyFlexLexer::LexerOutput( const char* buf, int size )
01020 {
01021 (void) yyout->write( buf, size );
01022 }
01023
01024
01025
01026
01027
01028
01029
01030
01031
01032 int yyFlexLexer::yy_get_next_buffer()
01033 {
01034 register char *dest = yy_current_buffer->yy_ch_buf;
01035 register char *source = yytext_ptr;
01036 register int number_to_move, i;
01037 int ret_val;
01038
01039 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
01040 YY_FATAL_ERROR(
01041 "fatal flex scanner internal error--end of buffer missed" );
01042
01043 if ( yy_current_buffer->yy_fill_buffer == 0 )
01044 {
01045 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
01046 {
01047
01048
01049
01050 return EOB_ACT_END_OF_FILE;
01051 }
01052
01053 else
01054 {
01055
01056
01057
01058 return EOB_ACT_LAST_MATCH;
01059 }
01060 }
01061
01062
01063
01064
01065 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
01066
01067 for ( i = 0; i < number_to_move; ++i )
01068 *(dest++) = *(source++);
01069
01070 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
01071
01072
01073
01074 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
01075
01076 else
01077 {
01078 int num_to_read =
01079 yy_current_buffer->yy_buf_size - number_to_move - 1;
01080
01081 while ( num_to_read <= 0 )
01082 {
01083 #ifdef YY_USES_REJECT
01084 YY_FATAL_ERROR(
01085 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
01086 #else
01087
01088
01089 YY_BUFFER_STATE b = yy_current_buffer;
01090
01091 int yy_c_buf_p_offset =
01092 (int) (yy_c_buf_p - b->yy_ch_buf);
01093
01094 if ( b->yy_is_our_buffer )
01095 {
01096 int new_size = b->yy_buf_size * 2;
01097
01098 if ( new_size <= 0 )
01099 b->yy_buf_size += b->yy_buf_size / 8;
01100 else
01101 b->yy_buf_size *= 2;
01102
01103 b->yy_ch_buf = (char *)
01104
01105 yy_flex_realloc( (void *) b->yy_ch_buf,
01106 b->yy_buf_size + 2 );
01107 }
01108 else
01109
01110 b->yy_ch_buf = 0;
01111
01112 if ( ! b->yy_ch_buf )
01113 YY_FATAL_ERROR(
01114 "fatal error - scanner input buffer overflow" );
01115
01116 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
01117
01118 num_to_read = yy_current_buffer->yy_buf_size -
01119 number_to_move - 1;
01120 #endif
01121 }
01122
01123 if ( num_to_read > YY_READ_BUF_SIZE )
01124 num_to_read = YY_READ_BUF_SIZE;
01125
01126
01127 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
01128 yy_n_chars, num_to_read );
01129
01130 yy_current_buffer->yy_n_chars = yy_n_chars;
01131 }
01132
01133 if ( yy_n_chars == 0 )
01134 {
01135 if ( number_to_move == YY_MORE_ADJ )
01136 {
01137 ret_val = EOB_ACT_END_OF_FILE;
01138 yyrestart( yyin );
01139 }
01140
01141 else
01142 {
01143 ret_val = EOB_ACT_LAST_MATCH;
01144 yy_current_buffer->yy_buffer_status =
01145 YY_BUFFER_EOF_PENDING;
01146 }
01147 }
01148
01149 else
01150 ret_val = EOB_ACT_CONTINUE_SCAN;
01151
01152 yy_n_chars += number_to_move;
01153 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
01154 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
01155
01156 yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
01157
01158 return ret_val;
01159 }
01160
01161
01162
01163
01164 yy_state_type yyFlexLexer::yy_get_previous_state()
01165 {
01166 register yy_state_type yy_current_state;
01167 register char *yy_cp;
01168
01169 yy_current_state = yy_start;
01170
01171 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
01172 {
01173 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
01174 if ( yy_accept[yy_current_state] )
01175 {
01176 yy_last_accepting_state = yy_current_state;
01177 yy_last_accepting_cpos = yy_cp;
01178 }
01179 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01180 {
01181 yy_current_state = (int) yy_def[yy_current_state];
01182 if ( yy_current_state >= 72 )
01183 yy_c = yy_meta[(unsigned int) yy_c];
01184 }
01185 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01186 }
01187
01188 return yy_current_state;
01189 }
01190
01191
01192
01193
01194
01195
01196
01197
01198 yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
01199 {
01200 register int yy_is_jam;
01201 register char *yy_cp = yy_c_buf_p;
01202
01203 register YY_CHAR yy_c = 1;
01204 if ( yy_accept[yy_current_state] )
01205 {
01206 yy_last_accepting_state = yy_current_state;
01207 yy_last_accepting_cpos = yy_cp;
01208 }
01209 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01210 {
01211 yy_current_state = (int) yy_def[yy_current_state];
01212 if ( yy_current_state >= 72 )
01213 yy_c = yy_meta[(unsigned int) yy_c];
01214 }
01215 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01216 yy_is_jam = (yy_current_state == 71);
01217
01218 return yy_is_jam ? 0 : yy_current_state;
01219 }
01220
01221
01222 void yyFlexLexer::yyunput( int c, register char* yy_bp )
01223 {
01224 register char *yy_cp = yy_c_buf_p;
01225
01226
01227 *yy_cp = yy_hold_char;
01228
01229 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01230 {
01231
01232 register int number_to_move = yy_n_chars + 2;
01233 register char *dest = &yy_current_buffer->yy_ch_buf[
01234 yy_current_buffer->yy_buf_size + 2];
01235 register char *source =
01236 &yy_current_buffer->yy_ch_buf[number_to_move];
01237
01238 while ( source > yy_current_buffer->yy_ch_buf )
01239 *--dest = *--source;
01240
01241 yy_cp += (int) (dest - source);
01242 yy_bp += (int) (dest - source);
01243 yy_current_buffer->yy_n_chars =
01244 yy_n_chars = yy_current_buffer->yy_buf_size;
01245
01246 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01247 YY_FATAL_ERROR( "flex scanner push-back overflow" );
01248 }
01249
01250 *--yy_cp = (char) c;
01251
01252
01253 yytext_ptr = yy_bp;
01254 yy_hold_char = *yy_cp;
01255 yy_c_buf_p = yy_cp;
01256 }
01257
01258
01259 int yyFlexLexer::yyinput()
01260 {
01261 int c;
01262
01263 *yy_c_buf_p = yy_hold_char;
01264
01265 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
01266 {
01267
01268
01269
01270
01271 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01272
01273 *yy_c_buf_p = '\0';
01274
01275 else
01276 {
01277 int offset = yy_c_buf_p - yytext_ptr;
01278 ++yy_c_buf_p;
01279
01280 switch ( yy_get_next_buffer() )
01281 {
01282 case EOB_ACT_LAST_MATCH:
01283
01284
01285
01286
01287
01288
01289
01290
01291
01292
01293
01294 yyrestart( yyin );
01295
01296
01297
01298 case EOB_ACT_END_OF_FILE:
01299 {
01300 if ( yywrap() )
01301 return EOF;
01302
01303 if ( ! yy_did_buffer_switch_on_eof )
01304 YY_NEW_FILE;
01305 #ifdef __cplusplus
01306 return yyinput();
01307 #else
01308 return input();
01309 #endif
01310 }
01311
01312 case EOB_ACT_CONTINUE_SCAN:
01313 yy_c_buf_p = yytext_ptr + offset;
01314 break;
01315 }
01316 }
01317 }
01318
01319 c = *(unsigned char *) yy_c_buf_p;
01320 *yy_c_buf_p = '\0';
01321 yy_hold_char = *++yy_c_buf_p;
01322
01323
01324 return c;
01325 }
01326
01327
01328 void yyFlexLexer::yyrestart( istream* input_file )
01329 {
01330 if ( ! yy_current_buffer )
01331 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
01332
01333 yy_init_buffer( yy_current_buffer, input_file );
01334 yy_load_buffer_state();
01335 }
01336
01337
01338 void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
01339 {
01340 if ( yy_current_buffer == new_buffer )
01341 return;
01342
01343 if ( yy_current_buffer )
01344 {
01345
01346 *yy_c_buf_p = yy_hold_char;
01347 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
01348 yy_current_buffer->yy_n_chars = yy_n_chars;
01349 }
01350
01351 yy_current_buffer = new_buffer;
01352 yy_load_buffer_state();
01353
01354
01355
01356
01357
01358
01359 yy_did_buffer_switch_on_eof = 1;
01360 }
01361
01362
01363 void yyFlexLexer::yy_load_buffer_state()
01364 {
01365 yy_n_chars = yy_current_buffer->yy_n_chars;
01366 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
01367 yyin = yy_current_buffer->yy_input_file;
01368 yy_hold_char = *yy_c_buf_p;
01369 }
01370
01371
01372 YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )
01373 {
01374 YY_BUFFER_STATE b;
01375
01376 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
01377 if ( ! b )
01378 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01379
01380 b->yy_buf_size = size;
01381
01382
01383
01384
01385 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
01386 if ( ! b->yy_ch_buf )
01387 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01388
01389 b->yy_is_our_buffer = 1;
01390
01391 yy_init_buffer( b, file );
01392
01393 return b;
01394 }
01395
01396
01397 void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
01398 {
01399 if ( ! b )
01400 return;
01401
01402 if ( b == yy_current_buffer )
01403 yy_current_buffer = (YY_BUFFER_STATE) 0;
01404
01405 if ( b->yy_is_our_buffer )
01406 yy_flex_free( (void *) b->yy_ch_buf );
01407
01408 yy_flex_free( (void *) b );
01409 }
01410
01411
01412 extern "C" int isatty YY_PROTO(( int ));
01413 void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )
01414
01415 {
01416 yy_flush_buffer( b );
01417
01418 b->yy_input_file = file;
01419 b->yy_fill_buffer = 1;
01420
01421 b->yy_is_interactive = 0;
01422 }
01423
01424
01425 void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
01426 {
01427 if ( ! b )
01428 return;
01429
01430 b->yy_n_chars = 0;
01431
01432
01433
01434
01435
01436 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
01437 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
01438
01439 b->yy_buf_pos = &b->yy_ch_buf[0];
01440
01441 b->yy_at_bol = 1;
01442 b->yy_buffer_status = YY_BUFFER_NEW;
01443
01444 if ( b == yy_current_buffer )
01445 yy_load_buffer_state();
01446 }
01447
01448
01449 #ifndef YY_NO_SCAN_BUFFER
01450 #endif
01451
01452
01453 #ifndef YY_NO_SCAN_STRING
01454 #endif
01455
01456
01457 #ifndef YY_NO_SCAN_BYTES
01458 #endif
01459
01460
01461 #ifndef YY_NO_PUSH_STATE
01462 void yyFlexLexer::yy_push_state( int new_state )
01463 {
01464 if ( yy_start_stack_ptr >= yy_start_stack_depth )
01465 {
01466 yy_size_t new_size;
01467
01468 yy_start_stack_depth += YY_START_STACK_INCR;
01469 new_size = yy_start_stack_depth * sizeof( int );
01470
01471 if ( ! yy_start_stack )
01472 yy_start_stack = (int *) yy_flex_alloc( new_size );
01473
01474 else
01475 yy_start_stack = (int *) yy_flex_realloc(
01476 (void *) yy_start_stack, new_size );
01477
01478 if ( ! yy_start_stack )
01479 YY_FATAL_ERROR(
01480 "out of memory expanding start-condition stack" );
01481 }
01482
01483 yy_start_stack[yy_start_stack_ptr++] = YY_START;
01484
01485 BEGIN(new_state);
01486 }
01487 #endif
01488
01489
01490 #ifndef YY_NO_POP_STATE
01491 void yyFlexLexer::yy_pop_state()
01492 {
01493 if ( --yy_start_stack_ptr < 0 )
01494 YY_FATAL_ERROR( "start-condition stack underflow" );
01495
01496 BEGIN(yy_start_stack[yy_start_stack_ptr]);
01497 }
01498 #endif
01499
01500
01501 #ifndef YY_NO_TOP_STATE
01502 int yyFlexLexer::yy_top_state()
01503 {
01504 return yy_start_stack[yy_start_stack_ptr - 1];
01505 }
01506 #endif
01507
01508 #ifndef YY_EXIT_FAILURE
01509 #define YY_EXIT_FAILURE 2
01510 #endif
01511
01512
01513 void yyFlexLexer::LexerError( yyconst char msg[] )
01514 {
01515 cerr << msg << '\n';
01516 exit( YY_EXIT_FAILURE );
01517 }
01518
01519
01520
01521
01522 #undef yyless
01523 #define yyless(n) \
01524 do \
01525 { \
01526 \
01527 yytext[yyleng] = yy_hold_char; \
01528 yy_c_buf_p = yytext + n; \
01529 yy_hold_char = *yy_c_buf_p; \
01530 *yy_c_buf_p = '\0'; \
01531 yyleng = n; \
01532 } \
01533 while ( 0 )
01534
01535
01536
01537
01538 #ifndef yytext_ptr
01539 #ifdef YY_USE_PROTOS
01540 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
01541 #else
01542 static void yy_flex_strncpy( s1, s2, n )
01543 char *s1;
01544 yyconst char *s2;
01545 int n;
01546 #endif
01547 {
01548 register int i;
01549 for ( i = 0; i < n; ++i )
01550 s1[i] = s2[i];
01551 }
01552 #endif
01553
01554 #ifdef YY_NEED_STRLEN
01555 #ifdef YY_USE_PROTOS
01556 static int yy_flex_strlen( yyconst char *s )
01557 #else
01558 static int yy_flex_strlen( s )
01559 yyconst char *s;
01560 #endif
01561 {
01562 register int n;
01563 for ( n = 0; s[n]; ++n )
01564 ;
01565
01566 return n;
01567 }
01568 #endif
01569
01570
01571 #ifdef YY_USE_PROTOS
01572 static void *yy_flex_alloc( yy_size_t size )
01573 #else
01574 static void *yy_flex_alloc( size )
01575 yy_size_t size;
01576 #endif
01577 {
01578 return (void *) malloc( size );
01579 }
01580
01581 #ifdef YY_USE_PROTOS
01582 static void *yy_flex_realloc( void *ptr, yy_size_t size )
01583 #else
01584 static void *yy_flex_realloc( ptr, size )
01585 void *ptr;
01586 yy_size_t size;
01587 #endif
01588 {
01589
01590
01591
01592
01593
01594
01595
01596 return (void *) realloc( (char *) ptr, size );
01597 }
01598
01599 #ifdef YY_USE_PROTOS
01600 static void yy_flex_free( void *ptr )
01601 #else
01602 static void yy_flex_free( ptr )
01603 void *ptr;
01604 #endif
01605 {
01606 free( ptr );
01607 }
01608
01609 #if YY_MAIN
01610 int main()
01611 {
01612 yylex();
01613 return 0;
01614 }
01615 #endif
01616 #line 128 "parser.ll"