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