File indexing completed on 2024-12-22 04:17:55
0001 #include "kstmath_export.h" 0002 #ifdef Q_CC_MSVC 0003 #define strdup _strdup 0004 #endif 0005 #line 4 "escan.cpp" 0006 #define YY_INT_ALIGNED short int 0007 0008 /* A lexical scanner generated by flex */ 0009 0010 #define FLEX_SCANNER 0011 #define YY_FLEX_MAJOR_VERSION 2 0012 #define YY_FLEX_MINOR_VERSION 5 0013 #define YY_FLEX_SUBMINOR_VERSION 35 0014 #if YY_FLEX_SUBMINOR_VERSION > 0 0015 #define FLEX_BETA 0016 #endif 0017 0018 /* First, we deal with platform-specific or compiler-specific issues. */ 0019 0020 /* begin standard C headers. */ 0021 #include <stdio.h> 0022 #include <string.h> 0023 #include <errno.h> 0024 #include <stdlib.h> 0025 0026 /* end standard C headers. */ 0027 0028 /* flex integer type definitions */ 0029 0030 #ifndef FLEXINT_H 0031 #define FLEXINT_H 0032 0033 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ 0034 0035 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 0036 0037 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, 0038 * if you want the limit (max/min) macros for int types. 0039 */ 0040 #ifndef __STDC_LIMIT_MACROS 0041 #define __STDC_LIMIT_MACROS 1 0042 #endif 0043 0044 #include <inttypes.h> 0045 typedef int8_t flex_int8_t; 0046 typedef uint8_t flex_uint8_t; 0047 typedef int16_t flex_int16_t; 0048 typedef uint16_t flex_uint16_t; 0049 typedef int32_t flex_int32_t; 0050 typedef uint32_t flex_uint32_t; 0051 #else 0052 typedef signed char flex_int8_t; 0053 typedef short int flex_int16_t; 0054 typedef int flex_int32_t; 0055 typedef unsigned char flex_uint8_t; 0056 typedef unsigned short int flex_uint16_t; 0057 typedef unsigned int flex_uint32_t; 0058 0059 /* Limits of integral types. */ 0060 #ifndef INT8_MIN 0061 #define INT8_MIN (-128) 0062 #endif 0063 #ifndef INT16_MIN 0064 #define INT16_MIN (-32767-1) 0065 #endif 0066 #ifndef INT32_MIN 0067 #define INT32_MIN (-2147483647-1) 0068 #endif 0069 #ifndef INT8_MAX 0070 #define INT8_MAX (127) 0071 #endif 0072 #ifndef INT16_MAX 0073 #define INT16_MAX (32767) 0074 #endif 0075 #ifndef INT32_MAX 0076 #define INT32_MAX (2147483647) 0077 #endif 0078 #ifndef UINT8_MAX 0079 #define UINT8_MAX (255U) 0080 #endif 0081 #ifndef UINT16_MAX 0082 #define UINT16_MAX (65535U) 0083 #endif 0084 #ifndef UINT32_MAX 0085 #define UINT32_MAX (4294967295U) 0086 #endif 0087 0088 #endif /* ! C99 */ 0089 0090 #endif /* ! FLEXINT_H */ 0091 0092 #ifdef __cplusplus 0093 0094 /* The "const" storage-class-modifier is valid. */ 0095 #define YY_USE_CONST 0096 0097 #else /* ! __cplusplus */ 0098 0099 /* C99 requires __STDC__ to be defined as 1. */ 0100 #if defined (__STDC__) 0101 0102 #define YY_USE_CONST 0103 0104 #endif /* defined (__STDC__) */ 0105 #endif /* ! __cplusplus */ 0106 0107 #ifdef YY_USE_CONST 0108 #define yyconst const 0109 #else 0110 #define yyconst 0111 #endif 0112 0113 /* Returned upon end-of-file. */ 0114 #define YY_NULL 0 0115 0116 /* Promotes a possibly negative, possibly signed char to an unsigned 0117 * integer for use as an array index. If the signed char is negative, 0118 * we want to instead treat it as an 8-bit unsigned char, hence the 0119 * double cast. 0120 */ 0121 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 0122 0123 /* Enter a start condition. This macro really ought to take a parameter, 0124 * but we do it the disgusting crufty way forced on us by the ()-less 0125 * definition of BEGIN. 0126 */ 0127 #define BEGIN (yy_start) = 1 + 2 * 0128 0129 /* Translate the current start state into a value that can be later handed 0130 * to BEGIN to return to the state. The YYSTATE alias is for lex 0131 * compatibility. 0132 */ 0133 #define YY_START (((yy_start) - 1) / 2) 0134 #define YYSTATE YY_START 0135 0136 /* Action number for EOF rule of a given start state. */ 0137 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 0138 0139 /* Special action meaning "start processing a new file". */ 0140 #define YY_NEW_FILE yyrestart(yyin ) 0141 0142 #define YY_END_OF_BUFFER_CHAR 0 0143 0144 /* Size of default input buffer. */ 0145 #ifndef YY_BUF_SIZE 0146 #ifdef __ia64__ 0147 /* On IA-64, the buffer size is 16k, not 8k. 0148 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. 0149 * Ditto for the __ia64__ case accordingly. 0150 */ 0151 #define YY_BUF_SIZE 32768 0152 #else 0153 #define YY_BUF_SIZE 16384 0154 #endif /* __ia64__ */ 0155 #endif 0156 0157 /* The state buf must be large enough to hold one state per character in the main buffer. 0158 */ 0159 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 0160 0161 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 0162 #define YY_TYPEDEF_YY_BUFFER_STATE 0163 typedef struct yy_buffer_state *YY_BUFFER_STATE; 0164 #endif 0165 0166 extern int yyleng; 0167 0168 extern FILE *yyin, *yyout; 0169 0170 #define EOB_ACT_CONTINUE_SCAN 0 0171 #define EOB_ACT_END_OF_FILE 1 0172 #define EOB_ACT_LAST_MATCH 2 0173 0174 #define YY_LESS_LINENO(n) 0175 0176 /* Return all but the first "n" matched characters back to the input stream. */ 0177 #define yyless(n) \ 0178 do \ 0179 { \ 0180 /* Undo effects of setting up yytext. */ \ 0181 int yyless_macro_arg = (n); \ 0182 YY_LESS_LINENO(yyless_macro_arg);\ 0183 *yy_cp = (yy_hold_char); \ 0184 YY_RESTORE_YY_MORE_OFFSET \ 0185 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 0186 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 0187 } \ 0188 while ( 0 ) 0189 0190 //#define unput(c) yyunput( c, (yytext_ptr) ) 0191 0192 #ifndef YY_TYPEDEF_YY_SIZE_T 0193 #define YY_TYPEDEF_YY_SIZE_T 0194 typedef size_t yy_size_t; 0195 #endif 0196 0197 #ifndef YY_STRUCT_YY_BUFFER_STATE 0198 #define YY_STRUCT_YY_BUFFER_STATE 0199 struct yy_buffer_state 0200 { 0201 FILE *yy_input_file; 0202 0203 char *yy_ch_buf; /* input buffer */ 0204 char *yy_buf_pos; /* current position in input buffer */ 0205 0206 /* Size of input buffer in bytes, not including room for EOB 0207 * characters. 0208 */ 0209 yy_size_t yy_buf_size; 0210 0211 /* Number of characters read into yy_ch_buf, not including EOB 0212 * characters. 0213 */ 0214 int yy_n_chars; 0215 0216 /* Whether we "own" the buffer - i.e., we know we created it, 0217 * and can realloc() it to grow it, and should free() it to 0218 * delete it. 0219 */ 0220 int yy_is_our_buffer; 0221 0222 /* Whether this is an "interactive" input source; if so, and 0223 * if we're using stdio for input, then we want to use getc() 0224 * instead of fread(), to make sure we stop fetching input after 0225 * each newline. 0226 */ 0227 int yy_is_interactive; 0228 0229 /* Whether we're considered to be at the beginning of a line. 0230 * If so, '^' rules will be active on the next match, otherwise 0231 * not. 0232 */ 0233 int yy_at_bol; 0234 0235 int yy_bs_lineno; /**< The line count. */ 0236 int yy_bs_column; /**< The column count. */ 0237 0238 /* Whether to try to fill the input buffer when we reach the 0239 * end of it. 0240 */ 0241 int yy_fill_buffer; 0242 0243 int yy_buffer_status; 0244 0245 #define YY_BUFFER_NEW 0 0246 #define YY_BUFFER_NORMAL 1 0247 /* When an EOF's been seen but there's still some text to process 0248 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 0249 * shouldn't try reading from the input source any more. We might 0250 * still have a bunch of tokens to match, though, because of 0251 * possible backing-up. 0252 * 0253 * When we actually see the EOF, we change the status to "new" 0254 * (via yyrestart()), so that the user can continue scanning by 0255 * just pointing yyin at a new input file. 0256 */ 0257 #define YY_BUFFER_EOF_PENDING 2 0258 0259 }; 0260 #endif /* !YY_STRUCT_YY_BUFFER_STATE */ 0261 0262 /* Stack of input buffers. */ 0263 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ 0264 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ 0265 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ 0266 0267 /* We provide macros for accessing buffer states in case in the 0268 * future we want to put the buffer states in a more general 0269 * "scanner state". 0270 * 0271 * Returns the top of the stack, or NULL. 0272 */ 0273 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 0274 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 0275 : NULL) 0276 0277 /* Same as previous macro, but useful when we know that the buffer stack is not 0278 * NULL or when we need an lvalue. For internal use only. 0279 */ 0280 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 0281 0282 /* yy_hold_char holds the character lost when yytext is formed. */ 0283 static char yy_hold_char; 0284 static int yy_n_chars; /* number of characters read into yy_ch_buf */ 0285 int yyleng; 0286 0287 /* Points to current character in buffer. */ 0288 static char *yy_c_buf_p = (char *) 0; 0289 static int yy_init = 0; /* whether we need to initialize */ 0290 static int yy_start = 0; /* start state number */ 0291 0292 /* Flag which is used to allow yywrap()'s to do buffer switches 0293 * instead of setting up a fresh yyin. A bit of a hack ... 0294 */ 0295 static int yy_did_buffer_switch_on_eof; 0296 0297 void yyrestart (FILE *input_file ); 0298 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); 0299 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); 0300 void yy_delete_buffer (YY_BUFFER_STATE b ); 0301 void yy_flush_buffer (YY_BUFFER_STATE b ); 0302 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); 0303 void yypop_buffer_state (void ); 0304 0305 static void yyensure_buffer_stack (void ); 0306 static void yy_load_buffer_state (void ); 0307 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); 0308 0309 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) 0310 0311 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); 0312 KSTMATH_EXPORT YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); 0313 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ); 0314 0315 void *yyalloc (yy_size_t ); 0316 void *yyrealloc (void *,yy_size_t ); 0317 void yyfree (void * ); 0318 0319 #define yy_new_buffer yy_create_buffer 0320 0321 #define yy_set_interactive(is_interactive) \ 0322 { \ 0323 if ( ! YY_CURRENT_BUFFER ){ \ 0324 yyensure_buffer_stack (); \ 0325 YY_CURRENT_BUFFER_LVALUE = \ 0326 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 0327 } \ 0328 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 0329 } 0330 0331 #define yy_set_bol(at_bol) \ 0332 { \ 0333 if ( ! YY_CURRENT_BUFFER ){\ 0334 yyensure_buffer_stack (); \ 0335 YY_CURRENT_BUFFER_LVALUE = \ 0336 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 0337 } \ 0338 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 0339 } 0340 0341 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 0342 0343 /* Begin user sect3 */ 0344 0345 #define yywrap() 1 0346 #define YY_SKIP_YYWRAP 0347 0348 typedef unsigned char YY_CHAR; 0349 0350 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 0351 0352 typedef int yy_state_type; 0353 0354 extern int yylineno; 0355 0356 int yylineno = 1; 0357 0358 extern char *yytext; 0359 #define yytext_ptr yytext 0360 0361 static yy_state_type yy_get_previous_state (void ); 0362 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); 0363 static int yy_get_next_buffer (void ); 0364 static void yy_fatal_error (yyconst char msg[] ); 0365 0366 /* Done after the current pattern has been matched and before the 0367 * corresponding action - sets up yytext. 0368 */ 0369 #define YY_DO_BEFORE_ACTION \ 0370 (yytext_ptr) = yy_bp; \ 0371 yyleng = (size_t) (yy_cp - yy_bp); \ 0372 (yy_hold_char) = *yy_cp; \ 0373 *yy_cp = '\0'; \ 0374 (yy_c_buf_p) = yy_cp; 0375 0376 #define YY_NUM_RULES 29 0377 #define YY_END_OF_BUFFER 30 0378 /* This struct is not used in this scanner, 0379 but its presence is necessary. */ 0380 struct yy_trans_info 0381 { 0382 flex_int32_t yy_verify; 0383 flex_int32_t yy_nxt; 0384 }; 0385 static yyconst flex_int16_t yy_accept[44] = 0386 { 0, 0387 0, 0, 0, 0, 30, 28, 27, 29, 6, 22, 0388 7, 24, 25, 20, 18, 26, 19, 21, 1, 1, 0389 11, 15, 13, 2, 4, 5, 23, 8, 3, 17, 0390 9, 0, 0, 1, 12, 16, 14, 2, 10, 1, 0391 0, 1, 0 0392 } ; 0393 0394 static yyconst flex_int32_t yy_ec[256] = 0395 { 0, 0396 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 0397 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0398 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0399 1, 2, 4, 1, 1, 1, 5, 6, 1, 7, 0400 8, 9, 10, 11, 12, 13, 14, 15, 16, 16, 0401 16, 16, 16, 16, 16, 16, 16, 1, 1, 17, 0402 18, 19, 1, 1, 20, 20, 20, 20, 21, 20, 0403 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0404 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0405 22, 1, 23, 24, 1, 1, 20, 20, 20, 20, 0406 0407 21, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0408 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0409 20, 20, 1, 25, 1, 1, 1, 1, 1, 1, 0410 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0412 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0413 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0414 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0415 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0416 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0417 0418 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0419 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0420 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0421 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0422 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0423 1, 1, 1, 1, 1 0424 } ; 0425 0426 static yyconst flex_int32_t yy_meta[26] = 0427 { 0, 0428 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0429 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0430 1, 1, 1, 1, 1 0431 } ; 0432 0433 static yyconst flex_int16_t yy_base[45] = 0434 { 0, 0435 0, 0, 55, 54, 56, 59, 59, 59, 37, 59, 0436 48, 59, 59, 59, 59, 59, 59, 59, 13, 22, 0437 35, 34, 33, 7, 59, 59, 59, 11, 59, 59, 0438 59, 14, 34, 0, 59, 59, 59, 11, 59, 24, 0439 26, 32, 59, 32 0440 } ; 0441 0442 static yyconst flex_int16_t yy_def[45] = 0443 { 0, 0444 43, 1, 44, 44, 43, 43, 43, 43, 43, 43, 0445 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 0446 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 0447 43, 43, 43, 20, 43, 43, 43, 43, 43, 43, 0448 43, 43, 0, 43 0449 } ; 0450 0451 static yyconst flex_int16_t yy_nxt[85] = 0452 { 0, 0453 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0454 16, 17, 6, 18, 19, 20, 21, 22, 23, 24, 0455 24, 25, 26, 27, 28, 32, 38, 38, 40, 40, 0456 38, 38, 29, 33, 32, 39, 34, 34, 40, 40, 0457 42, 42, 33, 41, 33, 41, 42, 42, 42, 42, 0458 37, 36, 35, 31, 30, 43, 8, 8, 5, 43, 0459 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 0460 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 0461 43, 43, 43, 43 0462 } ; 0463 0464 static yyconst flex_int16_t yy_chk[85] = 0465 { 0, 0466 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0467 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0468 1, 1, 1, 1, 1, 19, 24, 24, 32, 32, 0469 38, 38, 44, 19, 20, 28, 20, 20, 40, 40, 0470 41, 41, 20, 33, 40, 33, 42, 42, 33, 33, 0471 23, 22, 21, 11, 9, 5, 4, 3, 43, 43, 0472 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 0473 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 0474 43, 43, 43, 43 0475 } ; 0476 0477 static yy_state_type yy_last_accepting_state; 0478 static char *yy_last_accepting_cpos; 0479 0480 extern int yy_flex_debug; 0481 int yy_flex_debug = 0; 0482 0483 /* The intent behind this definition is that it'll catch 0484 * any uses of REJECT which flex missed. 0485 */ 0486 #define REJECT reject_used_but_not_detected 0487 #define yymore() yymore_used_but_not_detected 0488 #define YY_MORE_ADJ 0 0489 #define YY_RESTORE_YY_MORE_OFFSET 0490 char *yytext; 0491 #line 1 "escan.l" 0492 0493 #line 4 "escan.l" 0494 #include <stdlib.h> 0495 #include <stdio.h> 0496 #include <string.h> 0497 #include "eparse.h" 0498 #include "eparse-eh.h" 0499 0500 int bracketCount = 0; 0501 char dataSpec[1024]; 0502 char *dataSpecPtr; 0503 //void yyerror(Kst::ObjectStore *store, const char *s); 0504 #define YY_DECL int yylex(Kst::ObjectStore *store) 0505 0506 #line 506 "escan.cpp" 0507 0508 #define INITIAL 0 0509 #define DATA 1 0510 0511 #ifndef YY_NO_UNISTD_H 0512 /* Special case for "unistd.h", since it is non-ANSI. We include it way 0513 * down here because we want the user's section 1 to have been scanned first. 0514 * The user has a chance to override it with an option. 0515 */ 0516 #ifndef Q_OS_WIN32 0517 #include <unistd.h> 0518 #endif 0519 #endif 0520 0521 #ifndef YY_EXTRA_TYPE 0522 #define YY_EXTRA_TYPE void * 0523 #endif 0524 0525 static int yy_init_globals (void ); 0526 0527 /* Accessor methods to globals. 0528 These are made visible to non-reentrant scanners for convenience. */ 0529 0530 int yylex_destroy (void ); 0531 0532 int yyget_debug (void ); 0533 0534 void yyset_debug (int debug_flag ); 0535 0536 YY_EXTRA_TYPE yyget_extra (void ); 0537 0538 void yyset_extra (YY_EXTRA_TYPE user_defined ); 0539 0540 FILE *yyget_in (void ); 0541 0542 void yyset_in (FILE * in_str ); 0543 0544 FILE *yyget_out (void ); 0545 0546 void yyset_out (FILE * out_str ); 0547 0548 int yyget_leng (void ); 0549 0550 char *yyget_text (void ); 0551 0552 int yyget_lineno (void ); 0553 0554 void yyset_lineno (int line_number ); 0555 0556 /* Macros after this point can all be overridden by user definitions in 0557 * section 1. 0558 */ 0559 0560 #ifndef YY_SKIP_YYWRAP 0561 #ifdef __cplusplus 0562 extern "C" int yywrap (void ); 0563 #else 0564 extern int yywrap (void ); 0565 #endif 0566 #endif 0567 0568 // static void yyunput (int c,char *buf_ptr ); 0569 0570 #ifndef yytext_ptr 0571 static void yy_flex_strncpy (char *,yyconst char *,int ); 0572 #endif 0573 0574 #ifdef YY_NEED_STRLEN 0575 static int yy_flex_strlen (yyconst char * ); 0576 #endif 0577 0578 #ifndef YY_NO_INPUT 0579 0580 #if 0 0581 #ifdef __cplusplus 0582 static int yyinput (void ); 0583 #else 0584 static int input (void ); 0585 #endif 0586 #endif // if 0 0587 0588 #endif 0589 0590 /* Amount of stuff to slurp up with each read. */ 0591 #ifndef YY_READ_BUF_SIZE 0592 #ifdef __ia64__ 0593 /* On IA-64, the buffer size is 16k, not 8k */ 0594 #define YY_READ_BUF_SIZE 16384 0595 #else 0596 #define YY_READ_BUF_SIZE 8192 0597 #endif /* __ia64__ */ 0598 #endif 0599 0600 /* Copy whatever the last rule matched to the standard output. */ 0601 #ifndef ECHO 0602 /* This used to be an fputs(), but since the string might contain NUL's, 0603 * we now use fwrite(). 0604 */ 0605 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) 0606 #endif 0607 0608 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 0609 * is returned in "result". 0610 */ 0611 #ifndef YY_INPUT 0612 #define YY_INPUT(buf,result,max_size) \ 0613 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 0614 { \ 0615 int c = '*'; \ 0616 size_t n; \ 0617 for ( n = 0; n < max_size && \ 0618 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 0619 buf[n] = (char) c; \ 0620 if ( c == '\n' ) \ 0621 buf[n++] = (char) c; \ 0622 if ( c == EOF && ferror( yyin ) ) \ 0623 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 0624 result = n; \ 0625 } \ 0626 else \ 0627 { \ 0628 errno=0; \ 0629 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 0630 { \ 0631 if( errno != EINTR) \ 0632 { \ 0633 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 0634 break; \ 0635 } \ 0636 errno=0; \ 0637 clearerr(yyin); \ 0638 } \ 0639 }\ 0640 \ 0641 0642 #endif 0643 0644 /* No semi-colon after return; correct usage is to write "yyterminate();" - 0645 * we don't want an extra ';' after the "return" because that will cause 0646 * some compilers to complain about unreachable statements. 0647 */ 0648 #ifndef yyterminate 0649 #define yyterminate() return YY_NULL 0650 #endif 0651 0652 /* Number of entries by which start-condition stack grows. */ 0653 #ifndef YY_START_STACK_INCR 0654 #define YY_START_STACK_INCR 25 0655 #endif 0656 0657 /* Report a fatal error. */ 0658 #ifndef YY_FATAL_ERROR 0659 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 0660 #endif 0661 0662 /* end tables serialization structures and prototypes */ 0663 0664 /* Default declaration of generated scanner - a define so the user can 0665 * easily add parameters. 0666 */ 0667 #ifndef YY_DECL 0668 #define YY_DECL_IS_OURS 1 0669 0670 extern int yylex (void); 0671 0672 #define YY_DECL int yylex (void) 0673 #endif /* !YY_DECL */ 0674 0675 /* Code executed at the beginning of each rule, after yytext and yyleng 0676 * have been set up. 0677 */ 0678 #ifndef YY_USER_ACTION 0679 #define YY_USER_ACTION 0680 #endif 0681 0682 /* Code executed at the end of each rule. */ 0683 #ifndef YY_BREAK 0684 #define YY_BREAK break; 0685 #endif 0686 0687 #define YY_RULE_SETUP \ 0688 YY_USER_ACTION 0689 0690 /** The main scanner function which does all the work. 0691 */ 0692 YY_DECL 0693 { 0694 register yy_state_type yy_current_state; 0695 register char *yy_cp, *yy_bp; 0696 register int yy_act; 0697 0698 #line 21 "escan.l" 0699 0700 0701 #line 697 "escan.cpp" 0702 0703 if ( !(yy_init) ) 0704 { 0705 (yy_init) = 1; 0706 0707 #ifdef YY_USER_INIT 0708 YY_USER_INIT; 0709 #endif 0710 0711 if ( ! (yy_start) ) 0712 (yy_start) = 1; /* first start state */ 0713 0714 if ( ! yyin ) 0715 yyin = stdin; 0716 0717 if ( ! yyout ) 0718 yyout = stdout; 0719 0720 if ( ! YY_CURRENT_BUFFER ) { 0721 yyensure_buffer_stack (); 0722 YY_CURRENT_BUFFER_LVALUE = 0723 yy_create_buffer(yyin,YY_BUF_SIZE ); 0724 } 0725 0726 yy_load_buffer_state( ); 0727 } 0728 0729 while ( 1 ) /* loops until end-of-file is reached */ 0730 { 0731 yy_cp = (yy_c_buf_p); 0732 0733 /* Support of yytext. */ 0734 *yy_cp = (yy_hold_char); 0735 0736 /* yy_bp points to the position in yy_ch_buf of the start of 0737 * the current run. 0738 */ 0739 yy_bp = yy_cp; 0740 0741 yy_current_state = (yy_start); 0742 yy_match: 0743 do 0744 { 0745 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 0746 if ( yy_accept[yy_current_state] ) 0747 { 0748 (yy_last_accepting_state) = yy_current_state; 0749 (yy_last_accepting_cpos) = yy_cp; 0750 } 0751 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 0752 { 0753 yy_current_state = (int) yy_def[yy_current_state]; 0754 if ( yy_current_state >= 44 ) 0755 yy_c = yy_meta[(unsigned int) yy_c]; 0756 } 0757 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 0758 ++yy_cp; 0759 } 0760 while ( yy_base[yy_current_state] != 59 ); 0761 0762 yy_find_action: 0763 yy_act = yy_accept[yy_current_state]; 0764 if ( yy_act == 0 ) 0765 { /* have to back up */ 0766 yy_cp = (yy_last_accepting_cpos); 0767 yy_current_state = (yy_last_accepting_state); 0768 yy_act = yy_accept[yy_current_state]; 0769 } 0770 0771 YY_DO_BEFORE_ACTION; 0772 0773 do_action: /* This label is used only to access EOF actions. */ 0774 0775 switch ( yy_act ) 0776 { /* beginning of action switch */ 0777 case 0: /* must back up */ 0778 /* undo the effects of YY_DO_BEFORE_ACTION */ 0779 *yy_cp = (yy_hold_char); 0780 yy_cp = (yy_last_accepting_cpos); 0781 yy_current_state = (yy_last_accepting_state); 0782 goto yy_find_action; 0783 0784 case 1: 0785 YY_RULE_SETUP 0786 #line 23 "escan.l" 0787 { 0788 yylval.number = atof(yytext); 0789 return T_NUMBER; 0790 } 0791 YY_BREAK 0792 case 2: 0793 YY_RULE_SETUP 0794 #line 30 "escan.l" 0795 { 0796 yylval.data = strdup(yytext); 0797 /*printf("Found an ID [%s]\n", yylval.data);*/ 0798 return T_IDENTIFIER; 0799 } 0800 YY_BREAK 0801 case 3: 0802 YY_RULE_SETUP 0803 #line 36 "escan.l" 0804 { 0805 switch (*yytext) { 0806 case '[': 0807 ++bracketCount; 0808 *dataSpecPtr = *yytext; 0809 ++dataSpecPtr; 0810 break; 0811 case ']': 0812 if (--bracketCount == 0) { 0813 *dataSpecPtr = 0; 0814 yylval.data = strdup(dataSpec); 0815 if (dataSpecPtr == dataSpec) { 0816 yyerror(store, "Empty data reference."); 0817 yy_flush_buffer(YY_CURRENT_BUFFER); 0818 BEGIN(INITIAL); 0819 return T_INVALID; 0820 } 0821 BEGIN(INITIAL); 0822 return T_DATA; 0823 } 0824 *dataSpecPtr = *yytext; 0825 ++dataSpecPtr; 0826 break; 0827 default: 0828 *dataSpecPtr = *yytext; 0829 ++dataSpecPtr; 0830 break; 0831 } 0832 } 0833 YY_BREAK 0834 case YY_STATE_EOF(DATA): 0835 #line 66 "escan.l" 0836 { 0837 yyerror(store, "Invalid data reference."); 0838 yy_flush_buffer(YY_CURRENT_BUFFER); 0839 BEGIN(INITIAL); 0840 return T_INVALID; 0841 } 0842 YY_BREAK 0843 case 4: 0844 YY_RULE_SETUP 0845 #line 73 "escan.l" 0846 { 0847 bracketCount = 1; 0848 dataSpecPtr = dataSpec; 0849 *dataSpecPtr = 0; 0850 BEGIN(DATA); 0851 } 0852 YY_BREAK 0853 case 5: 0854 YY_RULE_SETUP 0855 #line 80 "escan.l" 0856 { 0857 yyerror(store, "Unmatched ']'."); 0858 yy_flush_buffer(YY_CURRENT_BUFFER); 0859 return T_INVALID; 0860 } 0861 YY_BREAK 0862 case 6: 0863 YY_RULE_SETUP 0864 #line 86 "escan.l" 0865 return T_NOT; 0866 YY_BREAK 0867 case 7: 0868 YY_RULE_SETUP 0869 #line 88 "escan.l" 0870 return T_AND; 0871 YY_BREAK 0872 case 8: 0873 YY_RULE_SETUP 0874 #line 90 "escan.l" 0875 return T_OR; 0876 YY_BREAK 0877 case 9: 0878 YY_RULE_SETUP 0879 #line 92 "escan.l" 0880 return T_LAND; 0881 YY_BREAK 0882 case 10: 0883 YY_RULE_SETUP 0884 #line 94 "escan.l" 0885 return T_LOR; 0886 YY_BREAK 0887 case 11: 0888 YY_RULE_SETUP 0889 #line 96 "escan.l" 0890 return T_LT; 0891 YY_BREAK 0892 case 12: 0893 YY_RULE_SETUP 0894 #line 98 "escan.l" 0895 return T_LE; 0896 YY_BREAK 0897 case 13: 0898 YY_RULE_SETUP 0899 #line 100 "escan.l" 0900 return T_GT; 0901 YY_BREAK 0902 case 14: 0903 YY_RULE_SETUP 0904 #line 102 "escan.l" 0905 return T_GE; 0906 YY_BREAK 0907 case 15: 0908 YY_RULE_SETUP 0909 #line 104 "escan.l" 0910 return T_EQ; 0911 YY_BREAK 0912 case 16: 0913 YY_RULE_SETUP 0914 #line 106 "escan.l" 0915 return T_EQ; 0916 YY_BREAK 0917 case 17: 0918 YY_RULE_SETUP 0919 #line 108 "escan.l" 0920 return T_NE; 0921 YY_BREAK 0922 case 18: 0923 YY_RULE_SETUP 0924 #line 110 "escan.l" 0925 return T_ADD; 0926 YY_BREAK 0927 case 19: 0928 YY_RULE_SETUP 0929 #line 112 "escan.l" 0930 return T_SUBTRACT; 0931 YY_BREAK 0932 case 20: 0933 YY_RULE_SETUP 0934 #line 114 "escan.l" 0935 return T_MULTIPLY; 0936 YY_BREAK 0937 case 21: 0938 YY_RULE_SETUP 0939 #line 116 "escan.l" 0940 return T_DIVIDE; 0941 YY_BREAK 0942 case 22: 0943 YY_RULE_SETUP 0944 #line 118 "escan.l" 0945 return T_MOD; 0946 YY_BREAK 0947 case 23: 0948 YY_RULE_SETUP 0949 #line 120 "escan.l" 0950 return T_EXP; 0951 YY_BREAK 0952 case 24: 0953 YY_RULE_SETUP 0954 #line 122 "escan.l" 0955 return T_OPENPAR; 0956 YY_BREAK 0957 case 25: 0958 YY_RULE_SETUP 0959 #line 124 "escan.l" 0960 return T_CLOSEPAR; 0961 YY_BREAK 0962 case 26: 0963 YY_RULE_SETUP 0964 #line 126 "escan.l" 0965 return T_COMMA; 0966 YY_BREAK 0967 case 27: 0968 YY_RULE_SETUP 0969 #line 128 "escan.l" 0970 {} 0971 YY_BREAK 0972 case 28: 0973 YY_RULE_SETUP 0974 #line 130 "escan.l" 0975 { 0976 /*printf("Found char '%c'\n", yytext[0]);*/ 0977 yylval.character = yytext[0]; 0978 return T_INVALID; 0979 } 0980 YY_BREAK 0981 case YY_STATE_EOF(INITIAL): 0982 #line 137 "escan.l" 0983 { 0984 /*printf("yyterminate\n");*/ 0985 yyterminate(); 0986 } 0987 YY_BREAK 0988 case 29: 0989 YY_RULE_SETUP 0990 #line 142 "escan.l" 0991 ECHO; 0992 YY_BREAK 0993 #line 990 "escan.cpp" 0994 0995 case YY_END_OF_BUFFER: 0996 { 0997 /* Amount of text matched not including the EOB char. */ 0998 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; 0999 1000 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1001 *yy_cp = (yy_hold_char); 1002 YY_RESTORE_YY_MORE_OFFSET 1003 1004 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 1005 { 1006 /* We're scanning a new file or input source. It's 1007 * possible that this happened because the user 1008 * just pointed yyin at a new source and called 1009 * yylex(). If so, then we have to assure 1010 * consistency between YY_CURRENT_BUFFER and our 1011 * globals. Here is the right place to do so, because 1012 * this is the first action (other than possibly a 1013 * back-up) that will match for the new input source. 1014 */ 1015 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 1016 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; 1017 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 1018 } 1019 1020 /* Note that here we test for yy_c_buf_p "<=" to the position 1021 * of the first EOB in the buffer, since yy_c_buf_p will 1022 * already have been incremented past the NUL character 1023 * (since all states make transitions on EOB to the 1024 * end-of-buffer state). Contrast this with the test 1025 * in input(). 1026 */ 1027 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 1028 { /* This was really a NUL. */ 1029 yy_state_type yy_next_state; 1030 1031 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; 1032 1033 yy_current_state = yy_get_previous_state( ); 1034 1035 /* Okay, we're now positioned to make the NUL 1036 * transition. We couldn't have 1037 * yy_get_previous_state() go ahead and do it 1038 * for us because it doesn't know how to deal 1039 * with the possibility of jamming (and we don't 1040 * want to build jamming into it because then it 1041 * will run more slowly). 1042 */ 1043 1044 yy_next_state = yy_try_NUL_trans( yy_current_state ); 1045 1046 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1047 1048 if ( yy_next_state ) 1049 { 1050 /* Consume the NUL. */ 1051 yy_cp = ++(yy_c_buf_p); 1052 yy_current_state = yy_next_state; 1053 goto yy_match; 1054 } 1055 1056 else 1057 { 1058 yy_cp = (yy_c_buf_p); 1059 goto yy_find_action; 1060 } 1061 } 1062 1063 else switch ( yy_get_next_buffer( ) ) 1064 { 1065 case EOB_ACT_END_OF_FILE: 1066 { 1067 (yy_did_buffer_switch_on_eof) = 0; 1068 1069 if ( yywrap( ) ) 1070 { 1071 /* Note: because we've taken care in 1072 * yy_get_next_buffer() to have set up 1073 * yytext, we can now set up 1074 * yy_c_buf_p so that if some total 1075 * hoser (like flex itself) wants to 1076 * call the scanner after we return the 1077 * YY_NULL, it'll still work - another 1078 * YY_NULL will get returned. 1079 */ 1080 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; 1081 1082 yy_act = YY_STATE_EOF(YY_START); 1083 goto do_action; 1084 } 1085 1086 else 1087 { 1088 if ( ! (yy_did_buffer_switch_on_eof) ) 1089 YY_NEW_FILE; 1090 } 1091 break; 1092 } 1093 1094 case EOB_ACT_CONTINUE_SCAN: 1095 (yy_c_buf_p) = 1096 (yytext_ptr) + yy_amount_of_matched_text; 1097 1098 yy_current_state = yy_get_previous_state( ); 1099 1100 yy_cp = (yy_c_buf_p); 1101 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1102 goto yy_match; 1103 1104 case EOB_ACT_LAST_MATCH: 1105 (yy_c_buf_p) = 1106 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; 1107 1108 yy_current_state = yy_get_previous_state( ); 1109 1110 yy_cp = (yy_c_buf_p); 1111 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1112 goto yy_find_action; 1113 } 1114 break; 1115 } 1116 1117 default: 1118 YY_FATAL_ERROR( 1119 "fatal flex scanner internal error--no action found" ); 1120 } /* end of action switch */ 1121 } /* end of scanning one token */ 1122 } /* end of yylex */ 1123 1124 /* yy_get_next_buffer - try to read in a new buffer 1125 * 1126 * Returns a code representing an action: 1127 * EOB_ACT_LAST_MATCH - 1128 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1129 * EOB_ACT_END_OF_FILE - end of file 1130 */ 1131 static int yy_get_next_buffer (void) 1132 { 1133 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 1134 register char *source = (yytext_ptr); 1135 register int number_to_move, i; 1136 int ret_val; 1137 1138 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) 1139 YY_FATAL_ERROR( 1140 "fatal flex scanner internal error--end of buffer missed" ); 1141 1142 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 1143 { /* Don't try to fill the buffer, so this is an EOF. */ 1144 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) 1145 { 1146 /* We matched a single character, the EOB, so 1147 * treat this as a final EOF. 1148 */ 1149 return EOB_ACT_END_OF_FILE; 1150 } 1151 1152 else 1153 { 1154 /* We matched some text prior to the EOB, first 1155 * process it. 1156 */ 1157 return EOB_ACT_LAST_MATCH; 1158 } 1159 } 1160 1161 /* Try to read more data. */ 1162 1163 /* First move last chars to start of buffer. */ 1164 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; 1165 1166 for ( i = 0; i < number_to_move; ++i ) 1167 *(dest++) = *(source++); 1168 1169 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1170 /* don't do the read, it's not guaranteed to return an EOF, 1171 * just force an EOF 1172 */ 1173 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; 1174 1175 else 1176 { 1177 int num_to_read = 1178 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 1179 1180 while ( num_to_read <= 0 ) 1181 { /* Not enough room in the buffer - grow it. */ 1182 1183 /* just a shorter name for the current buffer */ 1184 YY_BUFFER_STATE b = YY_CURRENT_BUFFER; 1185 1186 int yy_c_buf_p_offset = 1187 (int) ((yy_c_buf_p) - b->yy_ch_buf); 1188 1189 if ( b->yy_is_our_buffer ) 1190 { 1191 int new_size = b->yy_buf_size * 2; 1192 1193 if ( new_size <= 0 ) 1194 b->yy_buf_size += b->yy_buf_size / 8; 1195 else 1196 b->yy_buf_size *= 2; 1197 1198 b->yy_ch_buf = (char *) 1199 /* Include room in for 2 EOB chars. */ 1200 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); 1201 } 1202 else 1203 /* Can't grow it, we don't own it. */ 1204 b->yy_ch_buf = 0; 1205 1206 if ( ! b->yy_ch_buf ) 1207 YY_FATAL_ERROR( 1208 "fatal error - scanner input buffer overflow" ); 1209 1210 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 1211 1212 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - 1213 number_to_move - 1; 1214 1215 } 1216 1217 if ( num_to_read > YY_READ_BUF_SIZE ) 1218 num_to_read = YY_READ_BUF_SIZE; 1219 1220 /* Read in more data. */ 1221 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 1222 (yy_n_chars), (size_t) num_to_read ); 1223 1224 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1225 } 1226 1227 if ( (yy_n_chars) == 0 ) 1228 { 1229 if ( number_to_move == YY_MORE_ADJ ) 1230 { 1231 ret_val = EOB_ACT_END_OF_FILE; 1232 yyrestart(yyin ); 1233 } 1234 1235 else 1236 { 1237 ret_val = EOB_ACT_LAST_MATCH; 1238 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 1239 YY_BUFFER_EOF_PENDING; 1240 } 1241 } 1242 1243 else 1244 ret_val = EOB_ACT_CONTINUE_SCAN; 1245 1246 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { 1247 /* Extend the array by 50%, plus the number we really need. */ 1248 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); 1249 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); 1250 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1251 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); 1252 } 1253 1254 (yy_n_chars) += number_to_move; 1255 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; 1256 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; 1257 1258 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 1259 1260 return ret_val; 1261 } 1262 1263 /* yy_get_previous_state - get the state just before the EOB char was reached */ 1264 1265 static yy_state_type yy_get_previous_state (void) 1266 { 1267 register yy_state_type yy_current_state; 1268 register char *yy_cp; 1269 1270 yy_current_state = (yy_start); 1271 1272 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) 1273 { 1274 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1275 if ( yy_accept[yy_current_state] ) 1276 { 1277 (yy_last_accepting_state) = yy_current_state; 1278 (yy_last_accepting_cpos) = yy_cp; 1279 } 1280 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1281 { 1282 yy_current_state = (int) yy_def[yy_current_state]; 1283 if ( yy_current_state >= 44 ) 1284 yy_c = yy_meta[(unsigned int) yy_c]; 1285 } 1286 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1287 } 1288 1289 return yy_current_state; 1290 } 1291 1292 /* yy_try_NUL_trans - try to make a transition on the NUL character 1293 * 1294 * synopsis 1295 * next_state = yy_try_NUL_trans( current_state ); 1296 */ 1297 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) 1298 { 1299 register int yy_is_jam; 1300 register char *yy_cp = (yy_c_buf_p); 1301 1302 register YY_CHAR yy_c = 1; 1303 if ( yy_accept[yy_current_state] ) 1304 { 1305 (yy_last_accepting_state) = yy_current_state; 1306 (yy_last_accepting_cpos) = yy_cp; 1307 } 1308 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1309 { 1310 yy_current_state = (int) yy_def[yy_current_state]; 1311 if ( yy_current_state >= 44 ) 1312 yy_c = yy_meta[(unsigned int) yy_c]; 1313 } 1314 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1315 yy_is_jam = (yy_current_state == 43); 1316 1317 return yy_is_jam ? 0 : yy_current_state; 1318 } 1319 #if 0 1320 static void yyunput (int c, register char * yy_bp ) 1321 { 1322 register char *yy_cp; 1323 1324 yy_cp = (yy_c_buf_p); 1325 1326 /* undo effects of setting up yytext */ 1327 *yy_cp = (yy_hold_char); 1328 1329 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 1330 { /* need to shift things up to make room */ 1331 /* +2 for EOB chars. */ 1332 register int number_to_move = (yy_n_chars) + 2; 1333 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ 1334 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; 1335 register char *source = 1336 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; 1337 1338 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1339 *--dest = *--source; 1340 1341 yy_cp += (int) (dest - source); 1342 yy_bp += (int) (dest - source); 1343 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = 1344 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; 1345 1346 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 1347 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1348 } 1349 1350 *--yy_cp = (char) c; 1351 1352 (yytext_ptr) = yy_bp; 1353 (yy_hold_char) = *yy_cp; 1354 (yy_c_buf_p) = yy_cp; 1355 } 1356 #endif 1357 1358 // get rid of clang compiler warning: the following function is never used. 1359 #if 0 1360 #ifndef YY_NO_INPUT 1361 #ifdef __cplusplus 1362 static int yyinput (void) 1363 #else 1364 static int input (void) 1365 #endif 1366 1367 { 1368 int c; 1369 1370 *(yy_c_buf_p) = (yy_hold_char); 1371 1372 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) 1373 { 1374 /* yy_c_buf_p now points to the character we want to return. 1375 * If this occurs *before* the EOB characters, then it's a 1376 * valid NUL; if not, then we've hit the end of the buffer. 1377 */ 1378 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 1379 /* This was really a NUL. */ 1380 *(yy_c_buf_p) = '\0'; 1381 1382 else 1383 { /* need more input */ 1384 int offset = (yy_c_buf_p) - (yytext_ptr); 1385 ++(yy_c_buf_p); 1386 1387 switch ( yy_get_next_buffer( ) ) 1388 { 1389 case EOB_ACT_LAST_MATCH: 1390 /* This happens because yy_g_n_b() 1391 * sees that we've accumulated a 1392 * token and flags that we need to 1393 * try matching the token before 1394 * proceeding. But for input(), 1395 * there's no matching to consider. 1396 * So convert the EOB_ACT_LAST_MATCH 1397 * to EOB_ACT_END_OF_FILE. 1398 */ 1399 1400 /* Reset buffer status. */ 1401 yyrestart(yyin ); 1402 1403 /*FALLTHROUGH*/ 1404 1405 case EOB_ACT_END_OF_FILE: 1406 { 1407 if ( yywrap( ) ) 1408 return EOF; 1409 1410 if ( ! (yy_did_buffer_switch_on_eof) ) 1411 YY_NEW_FILE; 1412 #ifdef __cplusplus 1413 return yyinput(); 1414 #else 1415 return input(); 1416 #endif 1417 } 1418 1419 case EOB_ACT_CONTINUE_SCAN: 1420 (yy_c_buf_p) = (yytext_ptr) + offset; 1421 break; 1422 } 1423 } 1424 } 1425 1426 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ 1427 *(yy_c_buf_p) = '\0'; /* preserve yytext */ 1428 (yy_hold_char) = *++(yy_c_buf_p); 1429 1430 return c; 1431 } 1432 #endif /* ifndef YY_NO_INPUT */ 1433 #endif /* ifdef 0 */ 1434 1435 /** Immediately switch to a different input stream. 1436 * @param input_file A readable stream. 1437 * 1438 * @note This function does not reset the start condition to @c INITIAL . 1439 */ 1440 void yyrestart (FILE * input_file ) 1441 { 1442 1443 if ( ! YY_CURRENT_BUFFER ){ 1444 yyensure_buffer_stack (); 1445 YY_CURRENT_BUFFER_LVALUE = 1446 yy_create_buffer(yyin,YY_BUF_SIZE ); 1447 } 1448 1449 yy_init_buffer(YY_CURRENT_BUFFER,input_file ); 1450 yy_load_buffer_state( ); 1451 } 1452 1453 /** Switch to a different input buffer. 1454 * @param new_buffer The new input buffer. 1455 * 1456 */ 1457 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) 1458 { 1459 1460 /* TODO. We should be able to replace this entire function body 1461 * with 1462 * yypop_buffer_state(); 1463 * yypush_buffer_state(new_buffer); 1464 */ 1465 yyensure_buffer_stack (); 1466 if ( YY_CURRENT_BUFFER == new_buffer ) 1467 return; 1468 1469 if ( YY_CURRENT_BUFFER ) 1470 { 1471 /* Flush out information for old buffer. */ 1472 *(yy_c_buf_p) = (yy_hold_char); 1473 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 1474 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1475 } 1476 1477 YY_CURRENT_BUFFER_LVALUE = new_buffer; 1478 yy_load_buffer_state( ); 1479 1480 /* We don't actually know whether we did this switch during 1481 * EOF (yywrap()) processing, but the only time this flag 1482 * is looked at is after yywrap() is called, so it's safe 1483 * to go ahead and always set it. 1484 */ 1485 (yy_did_buffer_switch_on_eof) = 1; 1486 } 1487 1488 static void yy_load_buffer_state (void) 1489 { 1490 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 1491 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 1492 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 1493 (yy_hold_char) = *(yy_c_buf_p); 1494 } 1495 1496 /** Allocate and initialize an input buffer state. 1497 * @param file A readable stream. 1498 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. 1499 * 1500 * @return the allocated buffer state. 1501 */ 1502 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) 1503 { 1504 YY_BUFFER_STATE b; 1505 1506 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); 1507 if ( ! b ) 1508 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1509 1510 b->yy_buf_size = size; 1511 1512 /* yy_ch_buf has to be 2 characters longer than the size given because 1513 * we need to put in 2 end-of-buffer characters. 1514 */ 1515 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); 1516 if ( ! b->yy_ch_buf ) 1517 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1518 1519 b->yy_is_our_buffer = 1; 1520 1521 yy_init_buffer(b,file ); 1522 1523 return b; 1524 } 1525 1526 /** Destroy the buffer. 1527 * @param b a buffer created with yy_create_buffer() 1528 * 1529 */ 1530 void yy_delete_buffer (YY_BUFFER_STATE b ) 1531 { 1532 1533 if ( ! b ) 1534 return; 1535 1536 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 1537 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 1538 1539 if ( b->yy_is_our_buffer ) 1540 yyfree((void *) b->yy_ch_buf ); 1541 1542 yyfree((void *) b ); 1543 } 1544 1545 #ifndef __cplusplus 1546 #ifndef Q_OS_WIN32 1547 extern int isatty (int ); 1548 #endif 1549 #endif /* __cplusplus */ 1550 1551 /* Initializes or reinitializes a buffer. 1552 * This function is sometimes called more than once on the same buffer, 1553 * such as during a yyrestart() or at EOF. 1554 */ 1555 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) 1556 1557 { 1558 int oerrno = errno; 1559 1560 yy_flush_buffer(b ); 1561 1562 b->yy_input_file = file; 1563 b->yy_fill_buffer = 1; 1564 1565 /* If b is the current buffer, then yy_init_buffer was _probably_ 1566 * called from yyrestart() or through yy_get_next_buffer. 1567 * In that case, we don't want to reset the lineno or column. 1568 */ 1569 if (b != YY_CURRENT_BUFFER){ 1570 b->yy_bs_lineno = 1; 1571 b->yy_bs_column = 0; 1572 } 1573 #ifdef Q_OS_WIN32 1574 b->yy_is_interactive = false; 1575 #else 1576 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 1577 #endif 1578 errno = oerrno; 1579 } 1580 1581 /** Discard all buffered characters. On the next scan, YY_INPUT will be called. 1582 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. 1583 * 1584 */ 1585 void yy_flush_buffer (YY_BUFFER_STATE b ) 1586 { 1587 if ( ! b ) 1588 return; 1589 1590 b->yy_n_chars = 0; 1591 1592 /* We always need two end-of-buffer characters. The first causes 1593 * a transition to the end-of-buffer state. The second causes 1594 * a jam in that state. 1595 */ 1596 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 1597 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 1598 1599 b->yy_buf_pos = &b->yy_ch_buf[0]; 1600 1601 b->yy_at_bol = 1; 1602 b->yy_buffer_status = YY_BUFFER_NEW; 1603 1604 if ( b == YY_CURRENT_BUFFER ) 1605 yy_load_buffer_state( ); 1606 } 1607 1608 /** Pushes the new state onto the stack. The new state becomes 1609 * the current state. This function will allocate the stack 1610 * if necessary. 1611 * @param new_buffer The new state. 1612 * 1613 */ 1614 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) 1615 { 1616 if (new_buffer == NULL) 1617 return; 1618 1619 yyensure_buffer_stack(); 1620 1621 /* This block is copied from yy_switch_to_buffer. */ 1622 if ( YY_CURRENT_BUFFER ) 1623 { 1624 /* Flush out information for old buffer. */ 1625 *(yy_c_buf_p) = (yy_hold_char); 1626 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 1627 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1628 } 1629 1630 /* Only push if top exists. Otherwise, replace top. */ 1631 if (YY_CURRENT_BUFFER) 1632 (yy_buffer_stack_top)++; 1633 YY_CURRENT_BUFFER_LVALUE = new_buffer; 1634 1635 /* copied from yy_switch_to_buffer. */ 1636 yy_load_buffer_state( ); 1637 (yy_did_buffer_switch_on_eof) = 1; 1638 } 1639 1640 /** Removes and deletes the top of the stack, if present. 1641 * The next element becomes the new top. 1642 * 1643 */ 1644 void yypop_buffer_state (void) 1645 { 1646 if (!YY_CURRENT_BUFFER) 1647 return; 1648 1649 yy_delete_buffer(YY_CURRENT_BUFFER ); 1650 YY_CURRENT_BUFFER_LVALUE = NULL; 1651 if ((yy_buffer_stack_top) > 0) 1652 --(yy_buffer_stack_top); 1653 1654 if (YY_CURRENT_BUFFER) { 1655 yy_load_buffer_state( ); 1656 (yy_did_buffer_switch_on_eof) = 1; 1657 } 1658 } 1659 1660 /* Allocates the stack if it does not exist. 1661 * Guarantees space for at least one push. 1662 */ 1663 static void yyensure_buffer_stack (void) 1664 { 1665 int num_to_alloc; 1666 1667 if (!(yy_buffer_stack)) { 1668 1669 /* First allocation is just for 2 elements, since we don't know if this 1670 * scanner will even need a stack. We use 2 instead of 1 to avoid an 1671 * immediate realloc on the next call. 1672 */ 1673 num_to_alloc = 1; 1674 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc 1675 (num_to_alloc * sizeof(struct yy_buffer_state*) 1676 ); 1677 if ( ! (yy_buffer_stack) ) 1678 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 1679 1680 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 1681 1682 (yy_buffer_stack_max) = num_to_alloc; 1683 (yy_buffer_stack_top) = 0; 1684 return; 1685 } 1686 1687 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ 1688 1689 /* Increase the buffer to prepare for a possible push. */ 1690 int grow_size = 8 /* arbitrary grow size */; 1691 1692 num_to_alloc = (yy_buffer_stack_max) + grow_size; 1693 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc 1694 ((yy_buffer_stack), 1695 num_to_alloc * sizeof(struct yy_buffer_state*) 1696 ); 1697 if ( ! (yy_buffer_stack) ) 1698 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 1699 1700 /* zero only the new slots.*/ 1701 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 1702 (yy_buffer_stack_max) = num_to_alloc; 1703 } 1704 } 1705 1706 /** Setup the input buffer state to scan directly from a user-specified character buffer. 1707 * @param base the character buffer 1708 * @param size the size in bytes of the character buffer 1709 * 1710 * @return the newly allocated buffer state object. 1711 */ 1712 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) 1713 { 1714 YY_BUFFER_STATE b; 1715 1716 if ( size < 2 || 1717 base[size-2] != YY_END_OF_BUFFER_CHAR || 1718 base[size-1] != YY_END_OF_BUFFER_CHAR ) 1719 /* They forgot to leave room for the EOB's. */ 1720 return 0; 1721 1722 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); 1723 if ( ! b ) 1724 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 1725 1726 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 1727 b->yy_buf_pos = b->yy_ch_buf = base; 1728 b->yy_is_our_buffer = 0; 1729 b->yy_input_file = 0; 1730 b->yy_n_chars = b->yy_buf_size; 1731 b->yy_is_interactive = 0; 1732 b->yy_at_bol = 1; 1733 b->yy_fill_buffer = 0; 1734 b->yy_buffer_status = YY_BUFFER_NEW; 1735 1736 yy_switch_to_buffer(b ); 1737 1738 return b; 1739 } 1740 1741 /** Setup the input buffer state to scan a string. The next call to yylex() will 1742 * scan from a @e copy of @a str. 1743 * @param yystr a NUL-terminated string to scan 1744 * 1745 * @return the newly allocated buffer state object. 1746 * @note If you want to scan bytes that may contain NUL values, then use 1747 * yy_scan_bytes() instead. 1748 */ 1749 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) 1750 { 1751 1752 return yy_scan_bytes(yystr,strlen(yystr) ); 1753 } 1754 1755 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will 1756 * scan from a @e copy of @a bytes. 1757 * @param yybytes the byte buffer to scan 1758 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. 1759 * 1760 * @return the newly allocated buffer state object. 1761 */ 1762 YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len ) 1763 { 1764 YY_BUFFER_STATE b; 1765 char *buf; 1766 yy_size_t n; 1767 int i; 1768 1769 /* Get memory for full buffer, including space for trailing EOB's. */ 1770 n = _yybytes_len + 2; 1771 buf = (char *) yyalloc(n ); 1772 if ( ! buf ) 1773 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 1774 1775 for ( i = 0; i < _yybytes_len; ++i ) 1776 buf[i] = yybytes[i]; 1777 1778 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; 1779 1780 b = yy_scan_buffer(buf,n ); 1781 if ( ! b ) 1782 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 1783 1784 /* It's okay to grow etc. this buffer, and we should throw it 1785 * away when we're done. 1786 */ 1787 b->yy_is_our_buffer = 1; 1788 1789 return b; 1790 } 1791 1792 #ifndef YY_EXIT_FAILURE 1793 #define YY_EXIT_FAILURE 2 1794 #endif 1795 1796 static void yy_fatal_error (yyconst char* msg ) 1797 { 1798 (void) fprintf( stderr, "%s\n", msg ); 1799 exit( YY_EXIT_FAILURE ); 1800 } 1801 1802 /* Redefine yyless() so it works in section 3 code. */ 1803 1804 #undef yyless 1805 #define yyless(n) \ 1806 do \ 1807 { \ 1808 /* Undo effects of setting up yytext. */ \ 1809 int yyless_macro_arg = (n); \ 1810 YY_LESS_LINENO(yyless_macro_arg);\ 1811 yytext[yyleng] = (yy_hold_char); \ 1812 (yy_c_buf_p) = yytext + yyless_macro_arg; \ 1813 (yy_hold_char) = *(yy_c_buf_p); \ 1814 *(yy_c_buf_p) = '\0'; \ 1815 yyleng = yyless_macro_arg; \ 1816 } \ 1817 while ( 0 ) 1818 1819 /* Accessor methods (get/set functions) to struct members. */ 1820 1821 /** Get the current line number. 1822 * 1823 */ 1824 int yyget_lineno (void) 1825 { 1826 1827 return yylineno; 1828 } 1829 1830 /** Get the input stream. 1831 * 1832 */ 1833 FILE *yyget_in (void) 1834 { 1835 return yyin; 1836 } 1837 1838 /** Get the output stream. 1839 * 1840 */ 1841 FILE *yyget_out (void) 1842 { 1843 return yyout; 1844 } 1845 1846 /** Get the length of the current token. 1847 * 1848 */ 1849 int yyget_leng (void) 1850 { 1851 return yyleng; 1852 } 1853 1854 /** Get the current token. 1855 * 1856 */ 1857 1858 char *yyget_text (void) 1859 { 1860 return yytext; 1861 } 1862 1863 /** Set the current line number. 1864 * @param line_number 1865 * 1866 */ 1867 void yyset_lineno (int line_number ) 1868 { 1869 1870 yylineno = line_number; 1871 } 1872 1873 /** Set the input stream. This does not discard the current 1874 * input buffer. 1875 * @param in_str A readable stream. 1876 * 1877 * @see yy_switch_to_buffer 1878 */ 1879 void yyset_in (FILE * in_str ) 1880 { 1881 yyin = in_str ; 1882 } 1883 1884 void yyset_out (FILE * out_str ) 1885 { 1886 yyout = out_str ; 1887 } 1888 1889 int yyget_debug (void) 1890 { 1891 return yy_flex_debug; 1892 } 1893 1894 void yyset_debug (int bdebug ) 1895 { 1896 yy_flex_debug = bdebug ; 1897 } 1898 1899 static int yy_init_globals (void) 1900 { 1901 /* Initialization is the same as for the non-reentrant scanner. 1902 * This function is called from yylex_destroy(), so don't allocate here. 1903 */ 1904 1905 (yy_buffer_stack) = 0; 1906 (yy_buffer_stack_top) = 0; 1907 (yy_buffer_stack_max) = 0; 1908 (yy_c_buf_p) = (char *) 0; 1909 (yy_init) = 0; 1910 (yy_start) = 0; 1911 1912 /* Defined in main.c */ 1913 #ifdef YY_STDINIT 1914 yyin = stdin; 1915 yyout = stdout; 1916 #else 1917 yyin = (FILE *) 0; 1918 yyout = (FILE *) 0; 1919 #endif 1920 1921 /* For future reference: Set errno on error, since we are called by 1922 * yylex_init() 1923 */ 1924 return 0; 1925 } 1926 1927 /* yylex_destroy is for both reentrant and non-reentrant scanners. */ 1928 int yylex_destroy (void) 1929 { 1930 1931 /* Pop the buffer stack, destroying each element. */ 1932 while(YY_CURRENT_BUFFER){ 1933 yy_delete_buffer(YY_CURRENT_BUFFER ); 1934 YY_CURRENT_BUFFER_LVALUE = NULL; 1935 yypop_buffer_state(); 1936 } 1937 1938 /* Destroy the stack itself. */ 1939 yyfree((yy_buffer_stack) ); 1940 (yy_buffer_stack) = NULL; 1941 1942 /* Reset the globals. This is important in a non-reentrant scanner so the next time 1943 * yylex() is called, initialization will occur. */ 1944 yy_init_globals( ); 1945 1946 return 0; 1947 } 1948 1949 /* 1950 * Internal utility routines. 1951 */ 1952 1953 #ifndef yytext_ptr 1954 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) 1955 { 1956 register int i; 1957 for ( i = 0; i < n; ++i ) 1958 s1[i] = s2[i]; 1959 } 1960 #endif 1961 1962 #ifdef YY_NEED_STRLEN 1963 static int yy_flex_strlen (yyconst char * s ) 1964 { 1965 register int n; 1966 for ( n = 0; s[n]; ++n ) 1967 ; 1968 1969 return n; 1970 } 1971 #endif 1972 1973 void *yyalloc (yy_size_t size ) 1974 { 1975 return (void *) malloc( size ); 1976 } 1977 1978 void *yyrealloc (void * ptr, yy_size_t size ) 1979 { 1980 /* The cast to (char *) in the following accommodates both 1981 * implementations that use char* generic pointers, and those 1982 * that use void* generic pointers. It works with the latter 1983 * because both ANSI C and C++ allow castless assignment from 1984 * any pointer type to void*, and deal with argument conversions 1985 * as though doing an assignment. 1986 */ 1987 return (void *) realloc( (char *) ptr, size ); 1988 } 1989 1990 void yyfree (void * ptr ) 1991 { 1992 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 1993 } 1994 1995 #define YYTABLES_NAME "yytables" 1996 1997 #line 142 "escan.l" 1998 1999 2000 2001