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