EasyLocal++ Documentation |
|
ExpSpec.yy.cpp00001 #line 2 "ExpSpec.yy.cpp" 00002 /* A lexical scanner generated by flex */ 00003 00004 /* Scanner skeleton version: 00005 * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $ 00006 */ 00007 00008 #define FLEX_SCANNER 00009 #define YY_FLEX_MAJOR_VERSION 2 00010 #define YY_FLEX_MINOR_VERSION 5 00011 00012 #include <stdio.h> 00013 00014 00015 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ 00016 #ifdef c_plusplus 00017 #ifndef __cplusplus 00018 #define __cplusplus 00019 #endif 00020 #endif 00021 00022 00023 #ifdef __cplusplus 00024 00025 #include <stdlib.h> 00026 #include <unistd.h> 00027 00028 /* Use prototypes in function declarations. */ 00029 #define YY_USE_PROTOS 00030 00031 /* The "const" storage-class-modifier is valid. */ 00032 #define YY_USE_CONST 00033 00034 #else /* ! __cplusplus */ 00035 00036 #if __STDC__ 00037 00038 #define YY_USE_PROTOS 00039 #define YY_USE_CONST 00040 00041 #endif /* __STDC__ */ 00042 #endif /* ! __cplusplus */ 00043 00044 #ifdef __TURBOC__ 00045 #pragma warn -rch 00046 #pragma warn -use 00047 #include <io.h> 00048 #include <stdlib.h> 00049 #define YY_USE_CONST 00050 #define YY_USE_PROTOS 00051 #endif 00052 00053 #ifdef YY_USE_CONST 00054 #define yyconst const 00055 #else 00056 #define yyconst 00057 #endif 00058 00059 00060 #ifdef YY_USE_PROTOS 00061 #define YY_PROTO(proto) proto 00062 #else 00063 #define YY_PROTO(proto) () 00064 #endif 00065 00066 /* Returned upon end-of-file. */ 00067 #define YY_NULL 0 00068 00069 /* Promotes a possibly negative, possibly signed char to an unsigned 00070 * integer for use as an array index. If the signed char is negative, 00071 * we want to instead treat it as an 8-bit unsigned char, hence the 00072 * double cast. 00073 */ 00074 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 00075 00076 /* Enter a start condition. This macro really ought to take a parameter, 00077 * but we do it the disgusting crufty way forced on us by the ()-less 00078 * definition of BEGIN. 00079 */ 00080 #define BEGIN yy_start = 1 + 2 * 00081 00082 /* Translate the current start state into a value that can be later handed 00083 * to BEGIN to return to the state. The YYSTATE alias is for lex 00084 * compatibility. 00085 */ 00086 #define YY_START ((yy_start - 1) / 2) 00087 #define YYSTATE YY_START 00088 00089 /* Action number for EOF rule of a given start state. */ 00090 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 00091 00092 /* Special action meaning "start processing a new file". */ 00093 #define YY_NEW_FILE yyrestart( yyin ) 00094 00095 #define YY_END_OF_BUFFER_CHAR 0 00096 00097 /* Size of default input buffer. */ 00098 #define YY_BUF_SIZE 16384 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 /* The funky do-while in the following #define is used to turn the definition 00110 * int a single C statement (which needs a semi-colon terminator). This 00111 * avoids problems with code like: 00112 * 00113 * if ( condition_holds ) 00114 * yyless( 5 ); 00115 * else 00116 * do_something_else(); 00117 * 00118 * Prior to using the do-while the compiler would get upset at the 00119 * "else" because it interpreted the "if" statement as being all 00120 * done when it reached the ';' after the yyless() call. 00121 */ 00122 00123 /* Return all but the first 'n' matched characters back to the input stream. */ 00124 00125 #define yyless(n) \ 00126 do \ 00127 { \ 00128 /* Undo effects of setting up yytext. */ \ 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; /* set up yytext again */ \ 00133 } \ 00134 while ( 0 ) 00135 00136 #define unput(c) yyunput( c, yytext_ptr ) 00137 00138 /* The following is because we cannot portably get our hands on size_t 00139 * (without autoconf's help, which isn't available because we want 00140 * flex-generated scanners to compile on their own). 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; /* input buffer */ 00150 char *yy_buf_pos; /* current position in input buffer */ 00151 00152 /* Size of input buffer in bytes, not including room for EOB 00153 * characters. 00154 */ 00155 yy_size_t yy_buf_size; 00156 00157 /* Number of characters read into yy_ch_buf, not including EOB 00158 * characters. 00159 */ 00160 int yy_n_chars; 00161 00162 /* Whether we "own" the buffer - i.e., we know we created it, 00163 * and can realloc() it to grow it, and should free() it to 00164 * delete it. 00165 */ 00166 int yy_is_our_buffer; 00167 00168 /* Whether this is an "interactive" input source; if so, and 00169 * if we're using stdio for input, then we want to use getc() 00170 * instead of fread(), to make sure we stop fetching input after 00171 * each newline. 00172 */ 00173 int yy_is_interactive; 00174 00175 /* Whether we're considered to be at the beginning of a line. 00176 * If so, '^' rules will be active on the next match, otherwise 00177 * not. 00178 */ 00179 int yy_at_bol; 00180 00181 /* Whether to try to fill the input buffer when we reach the 00182 * end of it. 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 /* When an EOF's been seen but there's still some text to process 00190 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 00191 * shouldn't try reading from the input source any more. We might 00192 * still have a bunch of tokens to match, though, because of 00193 * possible backing-up. 00194 * 00195 * When we actually see the EOF, we change the status to "new" 00196 * (via yyrestart()), so that the user can continue scanning by 00197 * just pointing yyin at a new input file. 00198 */ 00199 #define YY_BUFFER_EOF_PENDING 2 00200 }; 00201 00202 static YY_BUFFER_STATE yy_current_buffer = 0; 00203 00204 /* We provide macros for accessing buffer states in case in the 00205 * future we want to put the buffer states in a more general 00206 * "scanner state". 00207 */ 00208 #define YY_CURRENT_BUFFER yy_current_buffer 00209 00210 00211 /* yy_hold_char holds the character lost when yytext is formed. */ 00212 static char yy_hold_char; 00213 00214 static int yy_n_chars; /* number of characters read into yy_ch_buf */ 00215 00216 00217 int yyleng; 00218 00219 /* Points to current character in buffer. */ 00220 static char *yy_c_buf_p = (char *) 0; 00221 static int yy_init = 1; /* whether we need to initialize */ 00222 static int yy_start = 0; /* start state number */ 00223 00224 /* Flag which is used to allow yywrap()'s to do buffer switches 00225 * instead of setting up a fresh yyin. A bit of a hack ... 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 #define YY_USES_REJECT 00267 00268 #define yywrap() 1 00269 #define YY_SKIP_YYWRAP 00270 typedef unsigned char YY_CHAR; 00271 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 00272 typedef int yy_state_type; 00273 extern int yylineno; 00274 int yylineno = 1; 00275 extern char *yytext; 00276 #define yytext_ptr yytext 00277 00278 static yy_state_type yy_get_previous_state YY_PROTO(( void )); 00279 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); 00280 static int yy_get_next_buffer YY_PROTO(( void )); 00281 static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); 00282 00283 /* Done after the current pattern has been matched and before the 00284 * corresponding action - sets up yytext. 00285 */ 00286 #define YY_DO_BEFORE_ACTION \ 00287 yytext_ptr = yy_bp; \ 00288 yyleng = (int) (yy_cp - yy_bp); \ 00289 yy_hold_char = *yy_cp; \ 00290 *yy_cp = '\0'; \ 00291 yy_c_buf_p = yy_cp; 00292 00293 #define YY_NUM_RULES 33 00294 #define YY_END_OF_BUFFER 34 00295 static yyconst short int yy_acclist[214] = 00296 { 0, 00297 2, 2, 34, 32, 33, 30, 32, 33, 31, 33, 00298 29, 32, 33, 32, 33, 32, 33, 32, 33, 26, 00299 32, 33, 24, 32, 33, 28, 32, 33, 28, 32, 00300 33, 23, 32, 33, 28, 32, 33, 28, 32, 33, 00301 28, 32, 33, 28, 32, 33, 28, 32, 33, 11, 00302 32, 33, 28, 32, 33, 28, 32, 33, 28, 32, 00303 33, 28, 32, 33, 28, 32, 33, 28, 32, 33, 00304 22, 32, 33, 2, 32, 33, 2, 30, 32, 33, 00305 2, 29, 32, 33, 2, 32, 33, 3, 32, 33, 00306 2, 32, 33, 2, 32, 33, 2, 26, 32, 33, 00307 00308 2, 24, 32, 33, 2, 28, 32, 33, 2, 23, 00309 32, 33, 27, 1, 26, 28, 28, 28, 28, 28, 00310 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 00311 28, 2, 2, 3, 3, 4, 2, 27, 2, 2, 00312 26, 2, 28, 2, 28, 25, 28, 28, 28, 28, 00313 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 00314 2, 25, 28, 28, 28, 28, 28, 28, 28, 28, 00315 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 00316 28, 28, 28, 10, 28, 28, 28, 28, 28, 28, 00317 9, 28, 28, 28, 5, 28, 28, 28, 6, 28, 00318 00319 28, 13, 8, 20, 12, 7, 15, 17, 18, 21, 00320 19, 16, 14 00321 } ; 00322 00323 static yyconst short int yy_accept[257] = 00324 { 0, 00325 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 00326 6, 9, 11, 14, 16, 18, 20, 23, 26, 29, 00327 32, 35, 38, 41, 44, 47, 50, 53, 56, 59, 00328 62, 65, 68, 71, 74, 77, 81, 85, 88, 91, 00329 94, 97, 101, 105, 109, 113, 113, 114, 115, 115, 00330 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 00331 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 00332 136, 137, 139, 140, 142, 144, 146, 147, 148, 149, 00333 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 00334 160, 161, 163, 164, 164, 165, 166, 167, 168, 169, 00335 00336 170, 170, 170, 171, 172, 173, 174, 175, 175, 176, 00337 176, 177, 178, 179, 179, 179, 179, 179, 180, 181, 00338 182, 182, 183, 183, 184, 184, 186, 187, 188, 188, 00339 188, 188, 188, 188, 189, 190, 190, 190, 191, 191, 00340 191, 191, 192, 193, 193, 193, 193, 193, 193, 194, 00341 195, 195, 195, 197, 197, 197, 197, 197, 197, 197, 00342 197, 197, 197, 198, 199, 199, 199, 200, 200, 200, 00343 200, 200, 200, 200, 200, 200, 201, 202, 202, 202, 00344 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 00345 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 00346 00347 202, 202, 202, 203, 203, 204, 204, 204, 204, 204, 00348 204, 204, 204, 204, 204, 204, 205, 206, 206, 206, 00349 206, 206, 206, 206, 206, 207, 207, 208, 208, 208, 00350 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 00351 209, 210, 210, 210, 210, 210, 210, 210, 210, 210, 00352 211, 211, 212, 213, 214, 214 00353 } ; 00354 00355 static yyconst int yy_ec[256] = 00356 { 0, 00357 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 00358 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 00359 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00360 1, 5, 1, 6, 1, 1, 1, 1, 1, 1, 00361 1, 7, 1, 1, 8, 9, 10, 11, 11, 11, 00362 11, 11, 11, 11, 11, 11, 11, 12, 13, 1, 00363 1, 1, 1, 1, 14, 14, 14, 14, 14, 14, 00364 14, 14, 15, 14, 14, 16, 14, 14, 17, 18, 00365 14, 19, 14, 20, 14, 14, 14, 14, 14, 14, 00366 1, 1, 1, 1, 21, 1, 22, 23, 24, 25, 00367 00368 26, 27, 28, 29, 30, 14, 14, 31, 32, 33, 00369 34, 35, 14, 36, 37, 38, 39, 14, 14, 40, 00370 14, 14, 41, 1, 42, 1, 1, 1, 1, 1, 00371 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00372 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00373 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00374 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00375 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00376 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00377 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00378 00379 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00380 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00381 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00382 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00383 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00384 1, 1, 1, 1, 1 00385 } ; 00386 00387 static yyconst int yy_meta[43] = 00388 { 0, 00389 1, 1, 2, 1, 1, 3, 4, 5, 1, 1, 00390 5, 1, 1, 5, 5, 5, 5, 5, 5, 5, 00391 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 00392 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 00393 1, 1 00394 } ; 00395 00396 static yyconst short int yy_base[263] = 00397 { 0, 00398 0, 0, 28, 56, 84, 112, 154, 196, 446, 447, 00399 447, 447, 447, 0, 434, 437, 40, 447, 435, 44, 00400 447, 45, 42, 47, 46, 48, 447, 49, 50, 60, 00401 61, 56, 80, 447, 0, 0, 0, 53, 55, 431, 00402 434, 52, 0, 238, 0, 434, 428, 447, 427, 80, 00403 429, 428, 58, 84, 59, 85, 92, 88, 95, 93, 00404 97, 98, 102, 96, 101, 107, 0, 127, 104, 128, 00405 447, 424, 423, 131, 280, 0, 447, 131, 138, 112, 00406 140, 143, 160, 162, 163, 169, 175, 144, 145, 177, 00407 171, 0, 165, 406, 173, 181, 203, 183, 211, 210, 00408 00409 186, 394, 220, 214, 182, 218, 219, 401, 217, 395, 00410 222, 184, 223, 405, 228, 406, 405, 246, 249, 227, 00411 389, 251, 394, 228, 388, 415, 252, 255, 391, 390, 00412 394, 396, 395, 253, 257, 379, 390, 265, 389, 379, 00413 387, 447, 262, 382, 385, 374, 370, 369, 226, 268, 00414 381, 384, 397, 392, 367, 375, 365, 368, 394, 376, 00415 392, 391, 260, 288, 363, 358, 447, 367, 362, 369, 00416 367, 359, 350, 349, 348, 269, 293, 350, 360, 356, 00417 342, 343, 350, 341, 348, 351, 350, 338, 352, 347, 00418 343, 341, 358, 343, 335, 341, 332, 332, 331, 341, 00419 00420 329, 325, 447, 320, 447, 347, 330, 321, 323, 316, 00421 315, 321, 318, 327, 333, 447, 447, 322, 327, 300, 00422 298, 295, 303, 282, 447, 281, 447, 292, 291, 285, 00423 293, 275, 282, 299, 298, 283, 277, 271, 272, 447, 00424 447, 280, 274, 277, 269, 288, 266, 266, 260, 447, 00425 160, 447, 447, 447, 447, 322, 327, 102, 332, 337, 00426 342, 347 00427 } ; 00428 00429 static yyconst short int yy_def[263] = 00430 { 0, 00431 255, 1, 1, 1, 1, 1, 256, 256, 255, 255, 00432 255, 255, 255, 257, 255, 255, 255, 255, 258, 258, 00433 255, 258, 258, 258, 258, 258, 255, 258, 258, 258, 00434 258, 258, 258, 255, 259, 259, 259, 260, 261, 259, 00435 259, 259, 259, 262, 259, 257, 255, 255, 255, 255, 00436 258, 258, 258, 258, 258, 258, 258, 258, 258, 258, 00437 258, 258, 258, 258, 258, 258, 259, 260, 261, 261, 00438 255, 259, 259, 259, 262, 75, 255, 258, 258, 258, 00439 258, 258, 258, 258, 258, 258, 258, 258, 258, 258, 00440 258, 259, 258, 255, 258, 258, 258, 258, 258, 258, 00441 00442 255, 255, 258, 258, 258, 258, 258, 255, 258, 255, 00443 258, 258, 258, 255, 255, 255, 255, 258, 258, 258, 00444 255, 258, 255, 258, 255, 258, 258, 258, 255, 255, 00445 255, 255, 255, 258, 258, 255, 255, 258, 255, 255, 00446 255, 255, 258, 255, 255, 255, 255, 255, 258, 258, 00447 255, 255, 258, 255, 255, 255, 255, 255, 255, 255, 00448 255, 255, 258, 258, 255, 255, 255, 255, 255, 255, 00449 255, 255, 255, 255, 255, 258, 258, 255, 255, 255, 00450 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 00451 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 00452 00453 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 00454 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 00455 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 00456 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 00457 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 00458 255, 255, 255, 255, 0, 255, 255, 255, 255, 255, 00459 255, 255 00460 } ; 00461 00462 static yyconst short int yy_nxt[490] = 00463 { 0, 00464 10, 11, 12, 13, 13, 14, 10, 10, 15, 16, 00465 17, 10, 18, 19, 20, 19, 19, 19, 19, 19, 00466 10, 19, 19, 19, 19, 19, 19, 19, 19, 19, 00467 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 00468 21, 10, 19, 22, 23, 24, 25, 26, 49, 51, 00469 50, 51, 51, 51, 51, 51, 51, 51, 67, 46, 00470 73, 70, 74, 51, 71, 51, 51, 51, 51, 27, 00471 19, 22, 23, 24, 25, 26, 53, 56, 54, 60, 00472 55, 61, 59, 58, 57, 64, 63, 51, 49, 62, 00473 50, 51, 51, 65, 78, 51, 80, 27, 19, 51, 00474 00475 51, 66, 51, 51, 51, 51, 52, 28, 51, 51, 00476 255, 79, 29, 255, 51, 30, 31, 83, 81, 51, 00477 32, 33, 90, 85, 82, 34, 19, 89, 84, 91, 00478 87, 88, 92, 46, 70, 28, 86, 71, 51, 73, 00479 29, 74, 94, 30, 31, 51, 95, 51, 32, 33, 00480 51, 51, 51, 34, 35, 36, 12, 37, 37, 38, 00481 39, 35, 40, 41, 42, 35, 43, 51, 93, 51, 00482 51, 103, 51, 101, 35, 97, 51, 96, 51, 102, 00483 51, 98, 51, 104, 51, 110, 107, 254, 51, 51, 00484 51, 51, 99, 100, 45, 35, 35, 36, 12, 37, 00485 00486 37, 38, 39, 35, 40, 41, 42, 35, 43, 106, 00487 51, 109, 105, 112, 114, 115, 35, 51, 51, 120, 00488 127, 51, 121, 116, 51, 51, 51, 51, 111, 51, 00489 51, 136, 140, 51, 51, 51, 45, 35, 67, 67, 00490 113, 67, 67, 67, 119, 75, 67, 67, 118, 67, 00491 67, 122, 130, 51, 124, 128, 51, 126, 51, 51, 00492 51, 163, 51, 142, 51, 131, 157, 51, 134, 51, 00493 135, 253, 51, 188, 138, 51, 51, 252, 67, 67, 00494 67, 67, 143, 67, 67, 67, 149, 75, 67, 67, 00495 153, 67, 67, 164, 150, 51, 176, 189, 251, 250, 00496 00497 51, 249, 248, 247, 246, 245, 244, 243, 242, 241, 00498 240, 239, 177, 238, 237, 236, 235, 234, 233, 232, 00499 67, 67, 44, 44, 44, 44, 44, 46, 231, 230, 00500 46, 46, 67, 229, 67, 228, 67, 68, 227, 68, 00501 68, 68, 69, 226, 225, 69, 69, 76, 224, 76, 00502 223, 76, 222, 221, 220, 219, 218, 217, 216, 215, 00503 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, 00504 204, 203, 202, 201, 200, 199, 198, 197, 196, 195, 00505 194, 193, 192, 191, 190, 187, 186, 185, 184, 183, 00506 182, 181, 180, 179, 178, 175, 174, 173, 172, 171, 00507 00508 170, 169, 168, 167, 51, 166, 165, 162, 161, 160, 00509 159, 158, 156, 155, 154, 152, 151, 148, 147, 146, 00510 145, 144, 51, 141, 139, 137, 133, 132, 129, 125, 00511 123, 117, 108, 72, 72, 51, 51, 47, 47, 77, 00512 48, 72, 51, 48, 47, 255, 9, 255, 255, 255, 00513 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 00514 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 00515 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 00516 255, 255, 255, 255, 255, 255, 255, 255, 255 00517 } ; 00518 00519 static yyconst short int yy_chk[490] = 00520 { 0, 00521 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00522 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00523 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00524 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00525 1, 1, 3, 3, 3, 3, 3, 3, 17, 23, 00526 17, 20, 22, 25, 24, 26, 28, 29, 38, 38, 00527 42, 39, 42, 32, 39, 53, 55, 30, 31, 3, 00528 4, 4, 4, 4, 4, 4, 20, 24, 22, 29, 00529 23, 30, 28, 26, 25, 32, 31, 33, 50, 30, 00530 50, 54, 56, 32, 53, 58, 55, 4, 5, 57, 00531 00532 60, 33, 59, 64, 61, 62, 258, 5, 65, 63, 00533 69, 54, 5, 69, 66, 5, 5, 58, 56, 80, 00534 5, 5, 65, 60, 57, 5, 6, 64, 59, 66, 00535 62, 63, 68, 68, 70, 6, 61, 70, 78, 74, 00536 6, 74, 79, 6, 6, 79, 80, 81, 6, 6, 00537 82, 88, 89, 6, 7, 7, 7, 7, 7, 7, 00538 7, 7, 7, 7, 7, 7, 7, 83, 78, 84, 00539 85, 88, 93, 86, 7, 82, 86, 81, 91, 87, 00540 95, 83, 87, 89, 90, 96, 93, 251, 96, 105, 00541 98, 112, 84, 85, 7, 7, 8, 8, 8, 8, 00542 00543 8, 8, 8, 8, 8, 8, 8, 8, 8, 91, 00544 97, 95, 90, 98, 100, 101, 8, 100, 99, 105, 00545 112, 104, 106, 101, 109, 106, 107, 103, 97, 111, 00546 113, 120, 124, 149, 120, 124, 8, 8, 44, 44, 00547 99, 44, 44, 44, 104, 44, 44, 44, 103, 44, 00548 44, 107, 115, 118, 109, 113, 119, 111, 122, 127, 00549 134, 149, 128, 127, 135, 115, 143, 163, 118, 143, 00550 119, 249, 138, 176, 122, 150, 176, 248, 44, 44, 00551 75, 75, 128, 75, 75, 75, 134, 75, 75, 75, 00552 138, 75, 75, 150, 135, 164, 163, 177, 247, 246, 00553 00554 177, 245, 244, 243, 242, 239, 238, 237, 236, 235, 00555 234, 233, 164, 232, 231, 230, 229, 228, 226, 224, 00556 75, 75, 256, 256, 256, 256, 256, 257, 223, 222, 00557 257, 257, 259, 221, 259, 220, 259, 260, 219, 260, 00558 260, 260, 261, 218, 215, 261, 261, 262, 214, 262, 00559 213, 262, 212, 211, 210, 209, 208, 207, 206, 204, 00560 202, 201, 200, 199, 198, 197, 196, 195, 194, 193, 00561 192, 191, 190, 189, 188, 187, 186, 185, 184, 183, 00562 182, 181, 180, 179, 178, 175, 174, 173, 172, 171, 00563 170, 169, 168, 166, 165, 162, 161, 160, 159, 158, 00564 00565 157, 156, 155, 154, 153, 152, 151, 148, 147, 146, 00566 145, 144, 141, 140, 139, 137, 136, 133, 132, 131, 00567 130, 129, 126, 125, 123, 121, 117, 116, 114, 110, 00568 108, 102, 94, 73, 72, 52, 51, 49, 47, 46, 00569 41, 40, 19, 16, 15, 9, 255, 255, 255, 255, 00570 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 00571 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 00572 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 00573 255, 255, 255, 255, 255, 255, 255, 255, 255 00574 } ; 00575 00576 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr; 00577 static char *yy_full_match; 00578 static int yy_lp; 00579 #define REJECT \ 00580 { \ 00581 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \ 00582 yy_cp = yy_full_match; /* restore poss. backed-over text */ \ 00583 ++yy_lp; \ 00584 goto find_rule; \ 00585 } 00586 #define yymore() yymore_used_but_not_detected 00587 #define YY_MORE_ADJ 0 00588 #define YY_RESTORE_YY_MORE_OFFSET 00589 char *yytext; 00590 #line 1 "ExpSpec.lex" 00591 #define INITIAL 0 00592 00603 /* this is a chunk of C code that is inserted before the lexical analyzer code, 00604 it consists of all header inclusion and the definition of global variables 00605 that are needed for exchanging information between the lexical analyzer and 00606 the actual bison parser */ 00607 #line 18 "ExpSpec.lex" 00608 #include <string> 00609 #include "EasyLocal.h" 00610 using namespace std; 00611 using std::string; 00612 using namespace easylocal; 00613 #include "ExpSpec.tab.h" 00614 00615 00616 /* the YY_USER_ACTION defines the default action that will be taken when a 00617 new lexical token has recognized */ 00618 00619 #define YY_USER_ACTION yycolno += yyleng; 00620 00621 /* the yyparse function is an extern function provided by the bison parser 00622 which simply start to parse a file */ 00623 extern "C++" int yyparse(void); 00624 /* yyerror is a bison function for error notifying */ 00625 extern "C++" int yyerror(const char* s); 00626 00627 char* trimdelims(const char*); 00628 char* copy(const char*); 00629 00630 unsigned int yycolno = 0; /* the column number */ 00631 int comment_caller; /* this variable contains the environment from which the comment is called */ 00632 int string_caller; /* this variable contains the environment from which the string is called */ 00633 char* foo; 00634 /* now we have to define some options; among these we may define some lexical 00635 environments for top-down parsing (problem, solver, runner, wm, comment). 00636 */ 00637 #define YY_NEVER_INTERACTIVE 1 00638 #define instance 1 00639 00640 #define runner 2 00641 00642 #define comment 3 00643 00644 /* here we define some shortcuts for lexical categories */ 00645 #line 646 "ExpSpec.yy.cpp" 00646 00647 /* Macros after this point can all be overridden by user definitions in 00648 * section 1. 00649 */ 00650 00651 #ifndef YY_SKIP_YYWRAP 00652 #ifdef __cplusplus 00653 extern "C" int yywrap YY_PROTO(( void )); 00654 #else 00655 extern int yywrap YY_PROTO(( void )); 00656 #endif 00657 #endif 00658 00659 #ifndef YY_NO_UNPUT 00660 static void yyunput YY_PROTO(( int c, char *buf_ptr )); 00661 #endif 00662 00663 #ifndef yytext_ptr 00664 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); 00665 #endif 00666 00667 #ifdef YY_NEED_STRLEN 00668 static int yy_flex_strlen YY_PROTO(( yyconst char * )); 00669 #endif 00670 00671 #ifndef YY_NO_INPUT 00672 #ifdef __cplusplus 00673 static int yyinput YY_PROTO(( void )); 00674 #else 00675 static int input YY_PROTO(( void )); 00676 #endif 00677 #endif 00678 00679 #if YY_STACK_USED 00680 static int yy_start_stack_ptr = 0; 00681 static int yy_start_stack_depth = 0; 00682 static int *yy_start_stack = 0; 00683 #ifndef YY_NO_PUSH_STATE 00684 static void yy_push_state YY_PROTO(( int new_state )); 00685 #endif 00686 #ifndef YY_NO_POP_STATE 00687 static void yy_pop_state YY_PROTO(( void )); 00688 #endif 00689 #ifndef YY_NO_TOP_STATE 00690 static int yy_top_state YY_PROTO(( void )); 00691 #endif 00692 00693 #else 00694 #define YY_NO_PUSH_STATE 1 00695 #define YY_NO_POP_STATE 1 00696 #define YY_NO_TOP_STATE 1 00697 #endif 00698 00699 #ifdef YY_MALLOC_DECL 00700 YY_MALLOC_DECL 00701 #else 00702 #if __STDC__ 00703 #ifndef __cplusplus 00704 #include <stdlib.h> 00705 #endif 00706 #else 00707 /* Just try to get by without declaring the routines. This will fail 00708 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) 00709 * or sizeof(void*) != sizeof(int). 00710 */ 00711 #endif 00712 #endif 00713 00714 /* Amount of stuff to slurp up with each read. */ 00715 #ifndef YY_READ_BUF_SIZE 00716 #define YY_READ_BUF_SIZE 8192 00717 #endif 00718 00719 /* Copy whatever the last rule matched to the standard output. */ 00720 00721 #ifndef ECHO 00722 /* This used to be an fputs(), but since the string might contain NUL's, 00723 * we now use fwrite(). 00724 */ 00725 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 00726 #endif 00727 00728 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 00729 * is returned in "result". 00730 */ 00731 #ifndef YY_INPUT 00732 #define YY_INPUT(buf,result,max_size) \ 00733 if ( yy_current_buffer->yy_is_interactive ) \ 00734 { \ 00735 int c = '*', n; \ 00736 for ( n = 0; n < max_size && \ 00737 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 00738 buf[n] = (char) c; \ 00739 if ( c == '\n' ) \ 00740 buf[n++] = (char) c; \ 00741 if ( c == EOF && ferror( yyin ) ) \ 00742 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 00743 result = n; \ 00744 } \ 00745 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ 00746 && ferror( yyin ) ) \ 00747 YY_FATAL_ERROR( "input in flex scanner failed" ); 00748 #endif 00749 00750 /* No semi-colon after return; correct usage is to write "yyterminate();" - 00751 * we don't want an extra ';' after the "return" because that will cause 00752 * some compilers to complain about unreachable statements. 00753 */ 00754 #ifndef yyterminate 00755 #define yyterminate() return YY_NULL 00756 #endif 00757 00758 /* Number of entries by which start-condition stack grows. */ 00759 #ifndef YY_START_STACK_INCR 00760 #define YY_START_STACK_INCR 25 00761 #endif 00762 00763 /* Report a fatal error. */ 00764 #ifndef YY_FATAL_ERROR 00765 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 00766 #endif 00767 00768 /* Default declaration of generated scanner - a define so the user can 00769 * easily add parameters. 00770 */ 00771 #ifndef YY_DECL 00772 #define YY_DECL int yylex YY_PROTO(( void )) 00773 #endif 00774 00775 /* Code executed at the beginning of each rule, after yytext and yyleng 00776 * have been set up. 00777 */ 00778 #ifndef YY_USER_ACTION 00779 #define YY_USER_ACTION 00780 #endif 00781 00782 /* Code executed at the end of each rule. */ 00783 #ifndef YY_BREAK 00784 #define YY_BREAK break; 00785 #endif 00786 00787 #define YY_RULE_SETUP \ 00788 YY_USER_ACTION 00789 00790 YY_DECL 00791 { 00792 register yy_state_type yy_current_state; 00793 register char *yy_cp, *yy_bp; 00794 register int yy_act; 00795 00796 #line 72 "ExpSpec.lex" 00797 00798 00799 #line 800 "ExpSpec.yy.cpp" 00800 00801 if ( yy_init ) 00802 { 00803 yy_init = 0; 00804 00805 #ifdef YY_USER_INIT 00806 YY_USER_INIT; 00807 #endif 00808 00809 if ( ! yy_start ) 00810 yy_start = 1; /* first start state */ 00811 00812 if ( ! yyin ) 00813 yyin = stdin; 00814 00815 if ( ! yyout ) 00816 yyout = stdout; 00817 00818 if ( ! yy_current_buffer ) 00819 yy_current_buffer = 00820 yy_create_buffer( yyin, YY_BUF_SIZE ); 00821 00822 yy_load_buffer_state(); 00823 } 00824 00825 while ( 1 ) /* loops until end-of-file is reached */ 00826 { 00827 yy_cp = yy_c_buf_p; 00828 00829 /* Support of yytext. */ 00830 *yy_cp = yy_hold_char; 00831 00832 /* yy_bp points to the position in yy_ch_buf of the start of 00833 * the current run. 00834 */ 00835 yy_bp = yy_cp; 00836 00837 yy_current_state = yy_start; 00838 yy_state_ptr = yy_state_buf; 00839 *yy_state_ptr++ = yy_current_state; 00840 yy_match: 00841 do 00842 { 00843 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 00844 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 00845 { 00846 yy_current_state = (int) yy_def[yy_current_state]; 00847 if ( yy_current_state >= 256 ) 00848 yy_c = yy_meta[(unsigned int) yy_c]; 00849 } 00850 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 00851 *yy_state_ptr++ = yy_current_state; 00852 ++yy_cp; 00853 } 00854 while ( yy_base[yy_current_state] != 447 ); 00855 00856 yy_find_action: 00857 yy_current_state = *--yy_state_ptr; 00858 yy_lp = yy_accept[yy_current_state]; 00859 find_rule: /* we branch to this label when backing up */ 00860 for ( ; ; ) /* until we find what rule we matched */ 00861 { 00862 if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] ) 00863 { 00864 yy_act = yy_acclist[yy_lp]; 00865 { 00866 yy_full_match = yy_cp; 00867 break; 00868 } 00869 } 00870 --yy_cp; 00871 yy_current_state = *--yy_state_ptr; 00872 yy_lp = yy_accept[yy_current_state]; 00873 } 00874 00875 YY_DO_BEFORE_ACTION; 00876 00877 if ( yy_act != YY_END_OF_BUFFER ) 00878 { 00879 int yyl; 00880 for ( yyl = 0; yyl < yyleng; ++yyl ) 00881 if ( yytext[yyl] == '\n' ) 00882 ++yylineno; 00883 } 00884 00885 do_action: /* This label is used only to access EOF actions. */ 00886 00887 00888 switch ( yy_act ) 00889 { /* beginning of action switch */ 00890 case 1: 00891 YY_RULE_SETUP 00892 #line 74 "ExpSpec.lex" 00893 comment_caller = YYSTATE; BEGIN(comment); 00894 YY_BREAK 00895 00896 case 2: 00897 YY_RULE_SETUP 00898 #line 76 "ExpSpec.lex" 00899 /* eat anything but a `*' */ 00900 YY_BREAK 00901 case 3: 00902 YY_RULE_SETUP 00903 #line 77 "ExpSpec.lex" 00904 /* eat the `*' not followed by a `/' */ 00905 YY_BREAK 00906 case 4: 00907 YY_RULE_SETUP 00908 #line 78 "ExpSpec.lex" 00909 BEGIN(comment_caller); /* restart from last environment */ 00910 YY_BREAK 00911 00912 case 5: 00913 YY_RULE_SETUP 00914 #line 81 "ExpSpec.lex" 00915 BEGIN(instance); return INSTANCE; 00916 YY_BREAK 00917 00918 case 6: 00919 YY_RULE_SETUP 00920 #line 84 "ExpSpec.lex" 00921 return LOG_FILE; 00922 YY_BREAK 00923 case 7: 00924 YY_RULE_SETUP 00925 #line 85 "ExpSpec.lex" 00926 return OUTPUT_PREFIX; 00927 YY_BREAK 00928 case 8: 00929 YY_RULE_SETUP 00930 #line 86 "ExpSpec.lex" 00931 return PLOT_PREFIX; 00932 YY_BREAK 00933 case 9: 00934 YY_RULE_SETUP 00935 #line 87 "ExpSpec.lex" 00936 return TRIALS; 00937 YY_BREAK 00938 case 10: 00939 YY_RULE_SETUP 00940 #line 88 "ExpSpec.lex" 00941 BEGIN(runner); return RUNNER; 00942 YY_BREAK 00943 case 11: 00944 YY_RULE_SETUP 00945 #line 89 "ExpSpec.lex" 00946 { 00947 /* end block, go back to the initial state */ 00948 BEGIN(INITIAL); return EBLOCK; 00949 } 00950 YY_BREAK 00951 00952 00953 case 12: 00954 YY_RULE_SETUP 00955 #line 96 "ExpSpec.lex" 00956 return HILL_CLIMBING; 00957 YY_BREAK 00958 case 13: 00959 YY_RULE_SETUP 00960 #line 97 "ExpSpec.lex" 00961 return TABU_SEARCH; 00962 YY_BREAK 00963 case 14: 00964 YY_RULE_SETUP 00965 #line 98 "ExpSpec.lex" 00966 return SIMULATED_ANNEALING; 00967 YY_BREAK 00968 case 15: 00969 YY_RULE_SETUP 00970 #line 99 "ExpSpec.lex" 00971 return MAX_ITERATION; 00972 YY_BREAK 00973 case 16: 00974 YY_RULE_SETUP 00975 #line 100 "ExpSpec.lex" 00976 return MAX_IDLE_ITERATION; 00977 YY_BREAK 00978 case 17: 00979 YY_RULE_SETUP 00980 #line 101 "ExpSpec.lex" 00981 return MAX_TABU_TENURE; 00982 YY_BREAK 00983 case 18: 00984 YY_RULE_SETUP 00985 #line 102 "ExpSpec.lex" 00986 return MIN_TABU_TENURE; 00987 YY_BREAK 00988 case 19: 00989 YY_RULE_SETUP 00990 #line 103 "ExpSpec.lex" 00991 return START_TEMPERATURE; 00992 YY_BREAK 00993 case 20: 00994 YY_RULE_SETUP 00995 #line 104 "ExpSpec.lex" 00996 return COOLING_RATE; 00997 YY_BREAK 00998 case 21: 00999 YY_RULE_SETUP 01000 #line 105 "ExpSpec.lex" 01001 return NEIGHBORS_SAMPLED; 01002 YY_BREAK 01003 case 22: 01004 YY_RULE_SETUP 01005 #line 106 "ExpSpec.lex" 01006 { 01007 /* end block, go back to the previous state */ 01008 BEGIN(instance); return EBLOCK; 01009 } 01010 YY_BREAK 01011 01012 case 23: 01013 YY_RULE_SETUP 01014 #line 112 "ExpSpec.lex" 01015 return BBLOCK; /* beginning block */ 01016 YY_BREAK 01017 case 24: 01018 YY_RULE_SETUP 01019 #line 113 "ExpSpec.lex" 01020 return ESTMT; /* end of statement `;' */ 01021 YY_BREAK 01022 case 25: 01023 YY_RULE_SETUP 01024 #line 115 "ExpSpec.lex" 01025 yylval.char_string = new string(trimdelims(yytext)); return STRING; 01026 YY_BREAK 01027 case 26: 01028 YY_RULE_SETUP 01029 #line 116 "ExpSpec.lex" 01030 yylval.natural = strtoul(yytext,&foo,0); return NATURAL; 01031 YY_BREAK 01032 case 27: 01033 YY_RULE_SETUP 01034 #line 117 "ExpSpec.lex" 01035 yylval.real = strtod(yytext,&foo); return REAL; 01036 YY_BREAK 01037 case 28: 01038 YY_RULE_SETUP 01039 #line 118 "ExpSpec.lex" 01040 yylval.char_string = new string(yytext); return IDENTIFIER; 01041 YY_BREAK 01042 case 29: 01043 YY_RULE_SETUP 01044 #line 120 "ExpSpec.lex" 01045 /* skips the blanks and the carriage returns */ 01046 YY_BREAK 01047 case 30: 01048 YY_RULE_SETUP 01049 #line 121 "ExpSpec.lex" 01050 { 01051 /* skips the tabs and update the column count */ 01052 yycolno += 7; 01053 } 01054 YY_BREAK 01055 case 31: 01056 YY_RULE_SETUP 01057 #line 125 "ExpSpec.lex" 01058 { 01059 /* skipping the newline involves the update 01060 of the column number */ 01061 yycolno = 0; 01062 } 01063 YY_BREAK 01064 case 32: 01065 YY_RULE_SETUP 01066 #line 132 "ExpSpec.lex" 01067 { /* overrules the default rule that echos all the 01068 unmatched input raising a syntax error message 01069 as output */ 01070 yyerror("syntax error"); 01071 yyterminate(); 01072 } 01073 YY_BREAK 01074 case 33: 01075 YY_RULE_SETUP 01076 #line 139 "ExpSpec.lex" 01077 ECHO; 01078 YY_BREAK 01079 #line 1080 "ExpSpec.yy.cpp" 01080 case YY_STATE_EOF(INITIAL): 01081 case YY_STATE_EOF(instance): 01082 case YY_STATE_EOF(runner): 01083 case YY_STATE_EOF(comment): 01084 yyterminate(); 01085 01086 case YY_END_OF_BUFFER: 01087 { 01088 /* Amount of text matched not including the EOB char. */ 01089 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; 01090 01091 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 01092 *yy_cp = yy_hold_char; 01093 YY_RESTORE_YY_MORE_OFFSET 01094 01095 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) 01096 { 01097 /* We're scanning a new file or input source. It's 01098 * possible that this happened because the user 01099 * just pointed yyin at a new source and called 01100 * yylex(). If so, then we have to assure 01101 * consistency between yy_current_buffer and our 01102 * globals. Here is the right place to do so, because 01103 * this is the first action (other than possibly a 01104 * back-up) that will match for the new input source. 01105 */ 01106 yy_n_chars = yy_current_buffer->yy_n_chars; 01107 yy_current_buffer->yy_input_file = yyin; 01108 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; 01109 } 01110 01111 /* Note that here we test for yy_c_buf_p "<=" to the position 01112 * of the first EOB in the buffer, since yy_c_buf_p will 01113 * already have been incremented past the NUL character 01114 * (since all states make transitions on EOB to the 01115 * end-of-buffer state). Contrast this with the test 01116 * in input(). 01117 */ 01118 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 01119 { /* This was really a NUL. */ 01120 yy_state_type yy_next_state; 01121 01122 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; 01123 01124 yy_current_state = yy_get_previous_state(); 01125 01126 /* Okay, we're now positioned to make the NUL 01127 * transition. We couldn't have 01128 * yy_get_previous_state() go ahead and do it 01129 * for us because it doesn't know how to deal 01130 * with the possibility of jamming (and we don't 01131 * want to build jamming into it because then it 01132 * will run more slowly). 01133 */ 01134 01135 yy_next_state = yy_try_NUL_trans( yy_current_state ); 01136 01137 yy_bp = yytext_ptr + YY_MORE_ADJ; 01138 01139 if ( yy_next_state ) 01140 { 01141 /* Consume the NUL. */ 01142 yy_cp = ++yy_c_buf_p; 01143 yy_current_state = yy_next_state; 01144 goto yy_match; 01145 } 01146 01147 else 01148 { 01149 yy_cp = yy_c_buf_p; 01150 goto yy_find_action; 01151 } 01152 } 01153 01154 else switch ( yy_get_next_buffer() ) 01155 { 01156 case EOB_ACT_END_OF_FILE: 01157 { 01158 yy_did_buffer_switch_on_eof = 0; 01159 01160 if ( yywrap() ) 01161 { 01162 /* Note: because we've taken care in 01163 * yy_get_next_buffer() to have set up 01164 * yytext, we can now set up 01165 * yy_c_buf_p so that if some total 01166 * hoser (like flex itself) wants to 01167 * call the scanner after we return the 01168 * YY_NULL, it'll still work - another 01169 * YY_NULL will get returned. 01170 */ 01171 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; 01172 01173 yy_act = YY_STATE_EOF(YY_START); 01174 goto do_action; 01175 } 01176 01177 else 01178 { 01179 if ( ! yy_did_buffer_switch_on_eof ) 01180 YY_NEW_FILE; 01181 } 01182 break; 01183 } 01184 01185 case EOB_ACT_CONTINUE_SCAN: 01186 yy_c_buf_p = 01187 yytext_ptr + yy_amount_of_matched_text; 01188 01189 yy_current_state = yy_get_previous_state(); 01190 01191 yy_cp = yy_c_buf_p; 01192 yy_bp = yytext_ptr + YY_MORE_ADJ; 01193 goto yy_match; 01194 01195 case EOB_ACT_LAST_MATCH: 01196 yy_c_buf_p = 01197 &yy_current_buffer->yy_ch_buf[yy_n_chars]; 01198 01199 yy_current_state = yy_get_previous_state(); 01200 01201 yy_cp = yy_c_buf_p; 01202 yy_bp = yytext_ptr + YY_MORE_ADJ; 01203 goto yy_find_action; 01204 } 01205 break; 01206 } 01207 01208 default: 01209 YY_FATAL_ERROR( 01210 "fatal flex scanner internal error--no action found" ); 01211 } /* end of action switch */ 01212 } /* end of scanning one token */ 01213 } /* end of yylex */ 01214 01215 01216 /* yy_get_next_buffer - try to read in a new buffer 01217 * 01218 * Returns a code representing an action: 01219 * EOB_ACT_LAST_MATCH - 01220 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 01221 * EOB_ACT_END_OF_FILE - end of file 01222 */ 01223 01224 static int yy_get_next_buffer() 01225 { 01226 register char *dest = yy_current_buffer->yy_ch_buf; 01227 register char *source = yytext_ptr; 01228 register int number_to_move, i; 01229 int ret_val; 01230 01231 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) 01232 YY_FATAL_ERROR( 01233 "fatal flex scanner internal error--end of buffer missed" ); 01234 01235 if ( yy_current_buffer->yy_fill_buffer == 0 ) 01236 { /* Don't try to fill the buffer, so this is an EOF. */ 01237 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) 01238 { 01239 /* We matched a single character, the EOB, so 01240 * treat this as a final EOF. 01241 */ 01242 return EOB_ACT_END_OF_FILE; 01243 } 01244 01245 else 01246 { 01247 /* We matched some text prior to the EOB, first 01248 * process it. 01249 */ 01250 return EOB_ACT_LAST_MATCH; 01251 } 01252 } 01253 01254 /* Try to read more data. */ 01255 01256 /* First move last chars to start of buffer. */ 01257 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; 01258 01259 for ( i = 0; i < number_to_move; ++i ) 01260 *(dest++) = *(source++); 01261 01262 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 01263 /* don't do the read, it's not guaranteed to return an EOF, 01264 * just force an EOF 01265 */ 01266 yy_current_buffer->yy_n_chars = yy_n_chars = 0; 01267 01268 else 01269 { 01270 int num_to_read = 01271 yy_current_buffer->yy_buf_size - number_to_move - 1; 01272 01273 while ( num_to_read <= 0 ) 01274 { /* Not enough room in the buffer - grow it. */ 01275 #ifdef YY_USES_REJECT 01276 YY_FATAL_ERROR( 01277 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 01278 #else 01279 01280 /* just a shorter name for the current buffer */ 01281 YY_BUFFER_STATE b = yy_current_buffer; 01282 01283 int yy_c_buf_p_offset = 01284 (int) (yy_c_buf_p - b->yy_ch_buf); 01285 01286 if ( b->yy_is_our_buffer ) 01287 { 01288 int new_size = b->yy_buf_size * 2; 01289 01290 if ( new_size <= 0 ) 01291 b->yy_buf_size += b->yy_buf_size / 8; 01292 else 01293 b->yy_buf_size *= 2; 01294 01295 b->yy_ch_buf = (char *) 01296 /* Include room in for 2 EOB chars. */ 01297 yy_flex_realloc( (void *) b->yy_ch_buf, 01298 b->yy_buf_size + 2 ); 01299 } 01300 else 01301 /* Can't grow it, we don't own it. */ 01302 b->yy_ch_buf = 0; 01303 01304 if ( ! b->yy_ch_buf ) 01305 YY_FATAL_ERROR( 01306 "fatal error - scanner input buffer overflow" ); 01307 01308 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 01309 01310 num_to_read = yy_current_buffer->yy_buf_size - 01311 number_to_move - 1; 01312 #endif 01313 } 01314 01315 if ( num_to_read > YY_READ_BUF_SIZE ) 01316 num_to_read = YY_READ_BUF_SIZE; 01317 01318 /* Read in more data. */ 01319 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), 01320 yy_n_chars, num_to_read ); 01321 01322 yy_current_buffer->yy_n_chars = yy_n_chars; 01323 } 01324 01325 if ( yy_n_chars == 0 ) 01326 { 01327 if ( number_to_move == YY_MORE_ADJ ) 01328 { 01329 ret_val = EOB_ACT_END_OF_FILE; 01330 yyrestart( yyin ); 01331 } 01332 01333 else 01334 { 01335 ret_val = EOB_ACT_LAST_MATCH; 01336 yy_current_buffer->yy_buffer_status = 01337 YY_BUFFER_EOF_PENDING; 01338 } 01339 } 01340 01341 else 01342 ret_val = EOB_ACT_CONTINUE_SCAN; 01343 01344 yy_n_chars += number_to_move; 01345 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; 01346 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 01347 01348 yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; 01349 01350 return ret_val; 01351 } 01352 01353 01354 /* yy_get_previous_state - get the state just before the EOB char was reached */ 01355 01356 static yy_state_type yy_get_previous_state() 01357 { 01358 register yy_state_type yy_current_state; 01359 register char *yy_cp; 01360 01361 yy_current_state = yy_start; 01362 yy_state_ptr = yy_state_buf; 01363 *yy_state_ptr++ = yy_current_state; 01364 01365 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) 01366 { 01367 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 01368 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 01369 { 01370 yy_current_state = (int) yy_def[yy_current_state]; 01371 if ( yy_current_state >= 256 ) 01372 yy_c = yy_meta[(unsigned int) yy_c]; 01373 } 01374 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 01375 *yy_state_ptr++ = yy_current_state; 01376 } 01377 01378 return yy_current_state; 01379 } 01380 01381 01382 /* yy_try_NUL_trans - try to make a transition on the NUL character 01383 * 01384 * synopsis 01385 * next_state = yy_try_NUL_trans( current_state ); 01386 */ 01387 01388 #ifdef YY_USE_PROTOS 01389 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 01390 #else 01391 static yy_state_type yy_try_NUL_trans( yy_current_state ) 01392 yy_state_type yy_current_state; 01393 #endif 01394 { 01395 register int yy_is_jam; 01396 01397 register YY_CHAR yy_c = 1; 01398 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 01399 { 01400 yy_current_state = (int) yy_def[yy_current_state]; 01401 if ( yy_current_state >= 256 ) 01402 yy_c = yy_meta[(unsigned int) yy_c]; 01403 } 01404 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 01405 yy_is_jam = (yy_current_state == 255); 01406 if ( ! yy_is_jam ) 01407 *yy_state_ptr++ = yy_current_state; 01408 01409 return yy_is_jam ? 0 : yy_current_state; 01410 } 01411 01412 01413 #ifndef YY_NO_UNPUT 01414 #ifdef YY_USE_PROTOS 01415 static void yyunput( int c, register char *yy_bp ) 01416 #else 01417 static void yyunput( c, yy_bp ) 01418 int c; 01419 register char *yy_bp; 01420 #endif 01421 { 01422 register char *yy_cp = yy_c_buf_p; 01423 01424 /* undo effects of setting up yytext */ 01425 *yy_cp = yy_hold_char; 01426 01427 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 01428 { /* need to shift things up to make room */ 01429 /* +2 for EOB chars. */ 01430 register int number_to_move = yy_n_chars + 2; 01431 register char *dest = &yy_current_buffer->yy_ch_buf[ 01432 yy_current_buffer->yy_buf_size + 2]; 01433 register char *source = 01434 &yy_current_buffer->yy_ch_buf[number_to_move]; 01435 01436 while ( source > yy_current_buffer->yy_ch_buf ) 01437 *--dest = *--source; 01438 01439 yy_cp += (int) (dest - source); 01440 yy_bp += (int) (dest - source); 01441 yy_current_buffer->yy_n_chars = 01442 yy_n_chars = yy_current_buffer->yy_buf_size; 01443 01444 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 01445 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 01446 } 01447 01448 *--yy_cp = (char) c; 01449 01450 if ( c == '\n' ) 01451 --yylineno; 01452 01453 yytext_ptr = yy_bp; 01454 yy_hold_char = *yy_cp; 01455 yy_c_buf_p = yy_cp; 01456 } 01457 #endif /* ifndef YY_NO_UNPUT */ 01458 01459 01460 #ifdef __cplusplus 01461 static int yyinput() 01462 #else 01463 static int input() 01464 #endif 01465 { 01466 int c; 01467 01468 *yy_c_buf_p = yy_hold_char; 01469 01470 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 01471 { 01472 /* yy_c_buf_p now points to the character we want to return. 01473 * If this occurs *before* the EOB characters, then it's a 01474 * valid NUL; if not, then we've hit the end of the buffer. 01475 */ 01476 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 01477 /* This was really a NUL. */ 01478 *yy_c_buf_p = '\0'; 01479 01480 else 01481 { /* need more input */ 01482 int offset = yy_c_buf_p - yytext_ptr; 01483 ++yy_c_buf_p; 01484 01485 switch ( yy_get_next_buffer() ) 01486 { 01487 case EOB_ACT_LAST_MATCH: 01488 /* This happens because yy_g_n_b() 01489 * sees that we've accumulated a 01490 * token and flags that we need to 01491 * try matching the token before 01492 * proceeding. But for input(), 01493 * there's no matching to consider. 01494 * So convert the EOB_ACT_LAST_MATCH 01495 * to EOB_ACT_END_OF_FILE. 01496 */ 01497 01498 /* Reset buffer status. */ 01499 yyrestart( yyin ); 01500 01501 /* fall through */ 01502 01503 case EOB_ACT_END_OF_FILE: 01504 { 01505 if ( yywrap() ) 01506 return EOF; 01507 01508 if ( ! yy_did_buffer_switch_on_eof ) 01509 YY_NEW_FILE; 01510 #ifdef __cplusplus 01511 return yyinput(); 01512 #else 01513 return input(); 01514 #endif 01515 } 01516 01517 case EOB_ACT_CONTINUE_SCAN: 01518 yy_c_buf_p = yytext_ptr + offset; 01519 break; 01520 } 01521 } 01522 } 01523 01524 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ 01525 *yy_c_buf_p = '\0'; /* preserve yytext */ 01526 yy_hold_char = *++yy_c_buf_p; 01527 01528 if ( c == '\n' ) 01529 ++yylineno; 01530 01531 return c; 01532 } 01533 01534 01535 #ifdef YY_USE_PROTOS 01536 void yyrestart( FILE *input_file ) 01537 #else 01538 void yyrestart( input_file ) 01539 FILE *input_file; 01540 #endif 01541 { 01542 if ( ! yy_current_buffer ) 01543 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 01544 01545 yy_init_buffer( yy_current_buffer, input_file ); 01546 yy_load_buffer_state(); 01547 } 01548 01549 01550 #ifdef YY_USE_PROTOS 01551 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 01552 #else 01553 void yy_switch_to_buffer( new_buffer ) 01554 YY_BUFFER_STATE new_buffer; 01555 #endif 01556 { 01557 if ( yy_current_buffer == new_buffer ) 01558 return; 01559 01560 if ( yy_current_buffer ) 01561 { 01562 /* Flush out information for old buffer. */ 01563 *yy_c_buf_p = yy_hold_char; 01564 yy_current_buffer->yy_buf_pos = yy_c_buf_p; 01565 yy_current_buffer->yy_n_chars = yy_n_chars; 01566 } 01567 01568 yy_current_buffer = new_buffer; 01569 yy_load_buffer_state(); 01570 01571 /* We don't actually know whether we did this switch during 01572 * EOF (yywrap()) processing, but the only time this flag 01573 * is looked at is after yywrap() is called, so it's safe 01574 * to go ahead and always set it. 01575 */ 01576 yy_did_buffer_switch_on_eof = 1; 01577 } 01578 01579 01580 #ifdef YY_USE_PROTOS 01581 void yy_load_buffer_state( void ) 01582 #else 01583 void yy_load_buffer_state() 01584 #endif 01585 { 01586 yy_n_chars = yy_current_buffer->yy_n_chars; 01587 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; 01588 yyin = yy_current_buffer->yy_input_file; 01589 yy_hold_char = *yy_c_buf_p; 01590 } 01591 01592 01593 #ifdef YY_USE_PROTOS 01594 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 01595 #else 01596 YY_BUFFER_STATE yy_create_buffer( file, size ) 01597 FILE *file; 01598 int size; 01599 #endif 01600 { 01601 YY_BUFFER_STATE b; 01602 01603 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 01604 if ( ! b ) 01605 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 01606 01607 b->yy_buf_size = size; 01608 01609 /* yy_ch_buf has to be 2 characters longer than the size given because 01610 * we need to put in 2 end-of-buffer characters. 01611 */ 01612 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); 01613 if ( ! b->yy_ch_buf ) 01614 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 01615 01616 b->yy_is_our_buffer = 1; 01617 01618 yy_init_buffer( b, file ); 01619 01620 return b; 01621 } 01622 01623 01624 #ifdef YY_USE_PROTOS 01625 void yy_delete_buffer( YY_BUFFER_STATE b ) 01626 #else 01627 void yy_delete_buffer( b ) 01628 YY_BUFFER_STATE b; 01629 #endif 01630 { 01631 if ( ! b ) 01632 return; 01633 01634 if ( b == yy_current_buffer ) 01635 yy_current_buffer = (YY_BUFFER_STATE) 0; 01636 01637 if ( b->yy_is_our_buffer ) 01638 yy_flex_free( (void *) b->yy_ch_buf ); 01639 01640 yy_flex_free( (void *) b ); 01641 } 01642 01643 01644 #ifndef YY_ALWAYS_INTERACTIVE 01645 #ifndef YY_NEVER_INTERACTIVE 01646 extern int isatty YY_PROTO(( int )); 01647 #endif 01648 #endif 01649 01650 #ifdef YY_USE_PROTOS 01651 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 01652 #else 01653 void yy_init_buffer( b, file ) 01654 YY_BUFFER_STATE b; 01655 FILE *file; 01656 #endif 01657 01658 01659 { 01660 yy_flush_buffer( b ); 01661 01662 b->yy_input_file = file; 01663 b->yy_fill_buffer = 1; 01664 01665 #if YY_ALWAYS_INTERACTIVE 01666 b->yy_is_interactive = 1; 01667 #else 01668 #if YY_NEVER_INTERACTIVE 01669 b->yy_is_interactive = 0; 01670 #else 01671 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 01672 #endif 01673 #endif 01674 } 01675 01676 01677 #ifdef YY_USE_PROTOS 01678 void yy_flush_buffer( YY_BUFFER_STATE b ) 01679 #else 01680 void yy_flush_buffer( b ) 01681 YY_BUFFER_STATE b; 01682 #endif 01683 01684 { 01685 if ( ! b ) 01686 return; 01687 01688 b->yy_n_chars = 0; 01689 01690 /* We always need two end-of-buffer characters. The first causes 01691 * a transition to the end-of-buffer state. The second causes 01692 * a jam in that state. 01693 */ 01694 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 01695 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 01696 01697 b->yy_buf_pos = &b->yy_ch_buf[0]; 01698 01699 b->yy_at_bol = 1; 01700 b->yy_buffer_status = YY_BUFFER_NEW; 01701 01702 if ( b == yy_current_buffer ) 01703 yy_load_buffer_state(); 01704 } 01705 01706 01707 #ifndef YY_NO_SCAN_BUFFER 01708 #ifdef YY_USE_PROTOS 01709 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 01710 #else 01711 YY_BUFFER_STATE yy_scan_buffer( base, size ) 01712 char *base; 01713 yy_size_t size; 01714 #endif 01715 { 01716 YY_BUFFER_STATE b; 01717 01718 if ( size < 2 || 01719 base[size-2] != YY_END_OF_BUFFER_CHAR || 01720 base[size-1] != YY_END_OF_BUFFER_CHAR ) 01721 /* They forgot to leave room for the EOB's. */ 01722 return 0; 01723 01724 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 01725 if ( ! b ) 01726 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 01727 01728 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 01729 b->yy_buf_pos = b->yy_ch_buf = base; 01730 b->yy_is_our_buffer = 0; 01731 b->yy_input_file = 0; 01732 b->yy_n_chars = b->yy_buf_size; 01733 b->yy_is_interactive = 0; 01734 b->yy_at_bol = 1; 01735 b->yy_fill_buffer = 0; 01736 b->yy_buffer_status = YY_BUFFER_NEW; 01737 01738 yy_switch_to_buffer( b ); 01739 01740 return b; 01741 } 01742 #endif 01743 01744 01745 #ifndef YY_NO_SCAN_STRING 01746 #ifdef YY_USE_PROTOS 01747 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 01748 #else 01749 YY_BUFFER_STATE yy_scan_string( yy_str ) 01750 yyconst char *yy_str; 01751 #endif 01752 { 01753 int len; 01754 for ( len = 0; yy_str[len]; ++len ) 01755 ; 01756 01757 return yy_scan_bytes( yy_str, len ); 01758 } 01759 #endif 01760 01761 01762 #ifndef YY_NO_SCAN_BYTES 01763 #ifdef YY_USE_PROTOS 01764 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 01765 #else 01766 YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 01767 yyconst char *bytes; 01768 int len; 01769 #endif 01770 { 01771 YY_BUFFER_STATE b; 01772 char *buf; 01773 yy_size_t n; 01774 int i; 01775 01776 /* Get memory for full buffer, including space for trailing EOB's. */ 01777 n = len + 2; 01778 buf = (char *) yy_flex_alloc( n ); 01779 if ( ! buf ) 01780 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 01781 01782 for ( i = 0; i < len; ++i ) 01783 buf[i] = bytes[i]; 01784 01785 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; 01786 01787 b = yy_scan_buffer( buf, n ); 01788 if ( ! b ) 01789 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 01790 01791 /* It's okay to grow etc. this buffer, and we should throw it 01792 * away when we're done. 01793 */ 01794 b->yy_is_our_buffer = 1; 01795 01796 return b; 01797 } 01798 #endif 01799 01800 01801 #ifndef YY_NO_PUSH_STATE 01802 #ifdef YY_USE_PROTOS 01803 static void yy_push_state( int new_state ) 01804 #else 01805 static void yy_push_state( new_state ) 01806 int new_state; 01807 #endif 01808 { 01809 if ( yy_start_stack_ptr >= yy_start_stack_depth ) 01810 { 01811 yy_size_t new_size; 01812 01813 yy_start_stack_depth += YY_START_STACK_INCR; 01814 new_size = yy_start_stack_depth * sizeof( int ); 01815 01816 if ( ! yy_start_stack ) 01817 yy_start_stack = (int *) yy_flex_alloc( new_size ); 01818 01819 else 01820 yy_start_stack = (int *) yy_flex_realloc( 01821 (void *) yy_start_stack, new_size ); 01822 01823 if ( ! yy_start_stack ) 01824 YY_FATAL_ERROR( 01825 "out of memory expanding start-condition stack" ); 01826 } 01827 01828 yy_start_stack[yy_start_stack_ptr++] = YY_START; 01829 01830 BEGIN(new_state); 01831 } 01832 #endif 01833 01834 01835 #ifndef YY_NO_POP_STATE 01836 static void yy_pop_state() 01837 { 01838 if ( --yy_start_stack_ptr < 0 ) 01839 YY_FATAL_ERROR( "start-condition stack underflow" ); 01840 01841 BEGIN(yy_start_stack[yy_start_stack_ptr]); 01842 } 01843 #endif 01844 01845 01846 #ifndef YY_NO_TOP_STATE 01847 static int yy_top_state() 01848 { 01849 return yy_start_stack[yy_start_stack_ptr - 1]; 01850 } 01851 #endif 01852 01853 #ifndef YY_EXIT_FAILURE 01854 #define YY_EXIT_FAILURE 2 01855 #endif 01856 01857 #ifdef YY_USE_PROTOS 01858 static void yy_fatal_error( yyconst char msg[] ) 01859 #else 01860 static void yy_fatal_error( msg ) 01861 char msg[]; 01862 #endif 01863 { 01864 (void) fprintf( stderr, "%s\n", msg ); 01865 exit( YY_EXIT_FAILURE ); 01866 } 01867 01868 01869 01870 /* Redefine yyless() so it works in section 3 code. */ 01871 01872 #undef yyless 01873 #define yyless(n) \ 01874 do \ 01875 { \ 01876 /* Undo effects of setting up yytext. */ \ 01877 yytext[yyleng] = yy_hold_char; \ 01878 yy_c_buf_p = yytext + n; \ 01879 yy_hold_char = *yy_c_buf_p; \ 01880 *yy_c_buf_p = '\0'; \ 01881 yyleng = n; \ 01882 } \ 01883 while ( 0 ) 01884 01885 01886 /* Internal utility routines. */ 01887 01888 #ifndef yytext_ptr 01889 #ifdef YY_USE_PROTOS 01890 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 01891 #else 01892 static void yy_flex_strncpy( s1, s2, n ) 01893 char *s1; 01894 yyconst char *s2; 01895 int n; 01896 #endif 01897 { 01898 register int i; 01899 for ( i = 0; i < n; ++i ) 01900 s1[i] = s2[i]; 01901 } 01902 #endif 01903 01904 #ifdef YY_NEED_STRLEN 01905 #ifdef YY_USE_PROTOS 01906 static int yy_flex_strlen( yyconst char *s ) 01907 #else 01908 static int yy_flex_strlen( s ) 01909 yyconst char *s; 01910 #endif 01911 { 01912 register int n; 01913 for ( n = 0; s[n]; ++n ) 01914 ; 01915 01916 return n; 01917 } 01918 #endif 01919 01920 01921 #ifdef YY_USE_PROTOS 01922 static void *yy_flex_alloc( yy_size_t size ) 01923 #else 01924 static void *yy_flex_alloc( size ) 01925 yy_size_t size; 01926 #endif 01927 { 01928 return (void *) malloc( size ); 01929 } 01930 01931 #ifdef YY_USE_PROTOS 01932 static void *yy_flex_realloc( void *ptr, yy_size_t size ) 01933 #else 01934 static void *yy_flex_realloc( ptr, size ) 01935 void *ptr; 01936 yy_size_t size; 01937 #endif 01938 { 01939 /* The cast to (char *) in the following accommodates both 01940 * implementations that use char* generic pointers, and those 01941 * that use void* generic pointers. It works with the latter 01942 * because both ANSI C and C++ allow castless assignment from 01943 * any pointer type to void*, and deal with argument conversions 01944 * as though doing an assignment. 01945 */ 01946 return (void *) realloc( (char *) ptr, size ); 01947 } 01948 01949 #ifdef YY_USE_PROTOS 01950 static void yy_flex_free( void *ptr ) 01951 #else 01952 static void yy_flex_free( ptr ) 01953 void *ptr; 01954 #endif 01955 { 01956 free( ptr ); 01957 } 01958 01959 #if YY_MAIN 01960 int main() 01961 { 01962 yylex(); 01963 return 0; 01964 } 01965 #endif 01966 #line 139 "ExpSpec.lex" 01967 01968 01969 char* trimdelims(const char* t) { 01970 int l = strlen(t); 01971 char* s = new char[l]; 01972 for (int i = 0; i < l-2; i++) 01973 s[i] = t[i+1]; 01974 s[l-2] = '\0'; 01975 return s; 01976 } 01977 01978 char* copy(const char* t) { 01979 int l = strlen(t); 01980 char* s = new char[l+1]; 01981 for (int i = 0; i < l; i++) 01982 s[i] = t[i]; 01983 s[l] = '\0'; 01984 return s; 01985 } |
|
Go to: the Main Page of the documentation. |