The world's most popular open source database
mysql/src/5.1-dbg/storage/innobase/pars/lexyy.c
Go to the documentation of this file.00001 #include "univ.i" 00002 #line 2 "_flex_tmp.c" 00003 00004 #line 4 "_flex_tmp.c" 00005 00006 #define YY_INT_ALIGNED short int 00007 00008 /* A lexical scanner generated by flex */ 00009 00010 #define FLEX_SCANNER 00011 #define YY_FLEX_MAJOR_VERSION 2 00012 #define YY_FLEX_MINOR_VERSION 5 00013 #define YY_FLEX_SUBMINOR_VERSION 31 00014 #if YY_FLEX_SUBMINOR_VERSION > 0 00015 #define FLEX_BETA 00016 #endif 00017 00018 /* First, we deal with platform-specific or compiler-specific issues. */ 00019 00020 /* begin standard C headers. */ 00021 #include <stdio.h> 00022 #include <string.h> 00023 #include <errno.h> 00024 #include <stdlib.h> 00025 00026 /* end standard C headers. */ 00027 00028 /* flex integer type definitions */ 00029 00030 #ifndef FLEXINT_H 00031 #define FLEXINT_H 00032 00033 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ 00034 00035 #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L 00036 #include <inttypes.h> 00037 typedef int8_t flex_int8_t; 00038 typedef uint8_t flex_uint8_t; 00039 typedef int16_t flex_int16_t; 00040 typedef uint16_t flex_uint16_t; 00041 typedef int32_t flex_int32_t; 00042 typedef uint32_t flex_uint32_t; 00043 #else 00044 typedef signed char flex_int8_t; 00045 typedef short int flex_int16_t; 00046 typedef int flex_int32_t; 00047 typedef unsigned char flex_uint8_t; 00048 typedef unsigned short int flex_uint16_t; 00049 typedef unsigned int flex_uint32_t; 00050 #endif /* ! C99 */ 00051 00052 /* Limits of integral types. */ 00053 #ifndef INT8_MIN 00054 #define INT8_MIN (-128) 00055 #endif 00056 #ifndef INT16_MIN 00057 #define INT16_MIN (-32767-1) 00058 #endif 00059 #ifndef INT32_MIN 00060 #define INT32_MIN (-2147483647-1) 00061 #endif 00062 #ifndef INT8_MAX 00063 #define INT8_MAX (127) 00064 #endif 00065 #ifndef INT16_MAX 00066 #define INT16_MAX (32767) 00067 #endif 00068 #ifndef INT32_MAX 00069 #define INT32_MAX (2147483647) 00070 #endif 00071 #ifndef UINT8_MAX 00072 #define UINT8_MAX (255U) 00073 #endif 00074 #ifndef UINT16_MAX 00075 #define UINT16_MAX (65535U) 00076 #endif 00077 #ifndef UINT32_MAX 00078 #define UINT32_MAX (4294967295U) 00079 #endif 00080 00081 #endif /* ! FLEXINT_H */ 00082 00083 #ifdef __cplusplus 00084 00085 /* The "const" storage-class-modifier is valid. */ 00086 #define YY_USE_CONST 00087 00088 #else /* ! __cplusplus */ 00089 00090 #if __STDC__ 00091 00092 #define YY_USE_CONST 00093 00094 #endif /* __STDC__ */ 00095 #endif /* ! __cplusplus */ 00096 00097 #ifdef YY_USE_CONST 00098 #define yyconst const 00099 #else 00100 #define yyconst 00101 #endif 00102 00103 /* Returned upon end-of-file. */ 00104 #define YY_NULL 0 00105 00106 /* Promotes a possibly negative, possibly signed char to an unsigned 00107 * integer for use as an array index. If the signed char is negative, 00108 * we want to instead treat it as an 8-bit unsigned char, hence the 00109 * double cast. 00110 */ 00111 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 00112 00113 /* Enter a start condition. This macro really ought to take a parameter, 00114 * but we do it the disgusting crufty way forced on us by the ()-less 00115 * definition of BEGIN. 00116 */ 00117 #define BEGIN (yy_start) = 1 + 2 * 00118 00119 /* Translate the current start state into a value that can be later handed 00120 * to BEGIN to return to the state. The YYSTATE alias is for lex 00121 * compatibility. 00122 */ 00123 #define YY_START (((yy_start) - 1) / 2) 00124 #define YYSTATE YY_START 00125 00126 /* Action number for EOF rule of a given start state. */ 00127 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 00128 00129 /* Special action meaning "start processing a new file". */ 00130 #define YY_NEW_FILE yyrestart(yyin ) 00131 00132 #define YY_END_OF_BUFFER_CHAR 0 00133 00134 /* Size of default input buffer. */ 00135 #ifndef YY_BUF_SIZE 00136 #define YY_BUF_SIZE 16384 00137 #endif 00138 00139 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 00140 #define YY_TYPEDEF_YY_BUFFER_STATE 00141 typedef struct yy_buffer_state *YY_BUFFER_STATE; 00142 #endif 00143 00144 extern int yyleng; 00145 00146 extern FILE *yyin, *yyout; 00147 00148 #define EOB_ACT_CONTINUE_SCAN 0 00149 #define EOB_ACT_END_OF_FILE 1 00150 #define EOB_ACT_LAST_MATCH 2 00151 00152 #define YY_LESS_LINENO(n) 00153 00154 /* Return all but the first "n" matched characters back to the input stream. */ 00155 #define yyless(n) \ 00156 do \ 00157 { \ 00158 /* Undo effects of setting up yytext. */ \ 00159 int yyless_macro_arg = (n); \ 00160 YY_LESS_LINENO(yyless_macro_arg);\ 00161 *yy_cp = (yy_hold_char); \ 00162 YY_RESTORE_YY_MORE_OFFSET \ 00163 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 00164 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 00165 } \ 00166 while ( 0 ) 00167 00168 #define unput(c) yyunput( c, (yytext_ptr) ) 00169 00170 /* The following is because we cannot portably get our hands on size_t 00171 * (without autoconf's help, which isn't available because we want 00172 * flex-generated scanners to compile on their own). 00173 */ 00174 00175 #ifndef YY_TYPEDEF_YY_SIZE_T 00176 #define YY_TYPEDEF_YY_SIZE_T 00177 typedef unsigned int yy_size_t; 00178 #endif 00179 00180 #ifndef YY_STRUCT_YY_BUFFER_STATE 00181 #define YY_STRUCT_YY_BUFFER_STATE 00182 struct yy_buffer_state 00183 { 00184 FILE *yy_input_file; 00185 00186 char *yy_ch_buf; /* input buffer */ 00187 char *yy_buf_pos; /* current position in input buffer */ 00188 00189 /* Size of input buffer in bytes, not including room for EOB 00190 * characters. 00191 */ 00192 yy_size_t yy_buf_size; 00193 00194 /* Number of characters read into yy_ch_buf, not including EOB 00195 * characters. 00196 */ 00197 int yy_n_chars; 00198 00199 /* Whether we "own" the buffer - i.e., we know we created it, 00200 * and can realloc() it to grow it, and should free() it to 00201 * delete it. 00202 */ 00203 int yy_is_our_buffer; 00204 00205 /* Whether this is an "interactive" input source; if so, and 00206 * if we're using stdio for input, then we want to use getc() 00207 * instead of fread(), to make sure we stop fetching input after 00208 * each newline. 00209 */ 00210 int yy_is_interactive; 00211 00212 /* Whether we're considered to be at the beginning of a line. 00213 * If so, '^' rules will be active on the next match, otherwise 00214 * not. 00215 */ 00216 int yy_at_bol; 00217 00218 int yy_bs_lineno; 00219 int yy_bs_column; 00221 /* Whether to try to fill the input buffer when we reach the 00222 * end of it. 00223 */ 00224 int yy_fill_buffer; 00225 00226 int yy_buffer_status; 00227 00228 #define YY_BUFFER_NEW 0 00229 #define YY_BUFFER_NORMAL 1 00230 /* When an EOF's been seen but there's still some text to process 00231 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 00232 * shouldn't try reading from the input source any more. We might 00233 * still have a bunch of tokens to match, though, because of 00234 * possible backing-up. 00235 * 00236 * When we actually see the EOF, we change the status to "new" 00237 * (via yyrestart()), so that the user can continue scanning by 00238 * just pointing yyin at a new input file. 00239 */ 00240 #define YY_BUFFER_EOF_PENDING 2 00241 00242 }; 00243 #endif /* !YY_STRUCT_YY_BUFFER_STATE */ 00244 00245 /* Stack of input buffers. */ 00246 static size_t yy_buffer_stack_top = 0; 00247 static size_t yy_buffer_stack_max = 0; 00248 static YY_BUFFER_STATE * yy_buffer_stack = 0; 00250 /* We provide macros for accessing buffer states in case in the 00251 * future we want to put the buffer states in a more general 00252 * "scanner state". 00253 * 00254 * Returns the top of the stack, or NULL. 00255 */ 00256 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 00257 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 00258 : NULL) 00259 00260 /* Same as previous macro, but useful when we know that the buffer stack is not 00261 * NULL or when we need an lvalue. For internal use only. 00262 */ 00263 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 00264 00265 /* yy_hold_char holds the character lost when yytext is formed. */ 00266 static char yy_hold_char; 00267 static int yy_n_chars; /* number of characters read into yy_ch_buf */ 00268 int yyleng; 00269 00270 /* Points to current character in buffer. */ 00271 static char *yy_c_buf_p = (char *) 0; 00272 static int yy_init = 1; /* whether we need to initialize */ 00273 static int yy_start = 0; /* start state number */ 00274 00275 /* Flag which is used to allow yywrap()'s to do buffer switches 00276 * instead of setting up a fresh yyin. A bit of a hack ... 00277 */ 00278 static int yy_did_buffer_switch_on_eof; 00279 00280 void yyrestart (FILE *input_file ); 00281 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); 00282 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); 00283 void yy_delete_buffer (YY_BUFFER_STATE b ); 00284 void yy_flush_buffer (YY_BUFFER_STATE b ); 00285 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); 00286 void yypop_buffer_state (void ); 00287 00288 static void yyensure_buffer_stack (void ); 00289 static void yy_load_buffer_state (void ); 00290 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); 00291 00292 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) 00293 00294 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); 00295 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); 00296 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ); 00297 00298 void *yyalloc (yy_size_t ); 00299 void *yyrealloc (void *,yy_size_t ); 00300 void yyfree (void * ); 00301 00302 #define yy_new_buffer yy_create_buffer 00303 00304 #define yy_set_interactive(is_interactive) \ 00305 { \ 00306 if ( ! YY_CURRENT_BUFFER ){ \ 00307 yyensure_buffer_stack (); \ 00308 YY_CURRENT_BUFFER_LVALUE = \ 00309 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 00310 } \ 00311 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 00312 } 00313 00314 #define yy_set_bol(at_bol) \ 00315 { \ 00316 if ( ! YY_CURRENT_BUFFER ){\ 00317 yyensure_buffer_stack (); \ 00318 YY_CURRENT_BUFFER_LVALUE = \ 00319 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 00320 } \ 00321 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 00322 } 00323 00324 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 00325 00326 /* Begin user sect3 */ 00327 00328 #define yywrap(n) 1 00329 #define YY_SKIP_YYWRAP 00330 00331 typedef unsigned char YY_CHAR; 00332 00333 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 00334 00335 typedef int yy_state_type; 00336 00337 extern int yylineno; 00338 00339 int yylineno = 1; 00340 00341 extern char *yytext; 00342 #define yytext_ptr yytext 00343 00344 static yy_state_type yy_get_previous_state (void ); 00345 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); 00346 static int yy_get_next_buffer (void ); 00347 static void yy_fatal_error (yyconst char msg[] ); 00348 00349 /* Done after the current pattern has been matched and before the 00350 * corresponding action - sets up yytext. 00351 */ 00352 #define YY_DO_BEFORE_ACTION \ 00353 (yytext_ptr) = yy_bp; \ 00354 yyleng = (size_t) (yy_cp - yy_bp); \ 00355 (yy_hold_char) = *yy_cp; \ 00356 *yy_cp = '\0'; \ 00357 (yy_c_buf_p) = yy_cp; 00358 00359 #define YY_NUM_RULES 119 00360 #define YY_END_OF_BUFFER 120 00361 /* This struct is not used in this scanner, 00362 but its presence is necessary. */ 00363 struct yy_trans_info 00364 { 00365 flex_int32_t yy_verify; 00366 flex_int32_t yy_nxt; 00367 }; 00368 static yyconst flex_int16_t yy_accept[399] = 00369 { 0, 00370 0, 0, 114, 114, 0, 0, 0, 0, 120, 118, 00371 117, 117, 8, 118, 109, 5, 98, 104, 107, 105, 00372 102, 106, 118, 108, 1, 118, 103, 101, 99, 100, 00373 112, 92, 92, 92, 92, 92, 92, 92, 92, 92, 00374 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 00375 110, 111, 114, 115, 6, 7, 9, 10, 117, 4, 00376 93, 113, 2, 1, 3, 94, 95, 97, 96, 92, 00377 92, 92, 92, 92, 92, 44, 92, 92, 92, 92, 00378 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 00379 92, 92, 28, 17, 25, 92, 92, 92, 92, 92, 00380 00381 54, 61, 92, 14, 92, 92, 92, 92, 92, 92, 00382 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 00383 92, 92, 114, 115, 115, 116, 6, 7, 9, 10, 00384 2, 13, 45, 92, 92, 92, 92, 92, 92, 92, 00385 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 00386 92, 27, 92, 92, 92, 41, 92, 92, 92, 92, 00387 21, 92, 92, 92, 92, 15, 92, 92, 92, 18, 00388 92, 92, 92, 92, 92, 80, 92, 92, 92, 51, 00389 92, 12, 92, 36, 92, 92, 92, 92, 92, 92, 00390 92, 92, 92, 92, 92, 92, 92, 92, 20, 24, 00391 00392 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 00393 46, 92, 92, 30, 92, 87, 92, 92, 39, 92, 00394 92, 92, 92, 92, 48, 92, 89, 32, 91, 92, 00395 11, 64, 92, 92, 92, 42, 92, 92, 92, 92, 00396 92, 92, 92, 92, 92, 92, 29, 92, 92, 92, 00397 92, 92, 92, 92, 92, 92, 85, 92, 26, 92, 00398 66, 92, 92, 92, 37, 92, 92, 92, 92, 92, 00399 92, 92, 31, 65, 23, 92, 57, 92, 75, 92, 00400 92, 92, 43, 92, 92, 92, 92, 92, 92, 92, 00401 92, 90, 92, 92, 56, 92, 92, 92, 92, 92, 00402 00403 92, 92, 40, 33, 79, 19, 92, 83, 74, 55, 00404 92, 63, 92, 52, 92, 92, 92, 47, 92, 76, 00405 92, 78, 92, 92, 34, 92, 92, 92, 35, 72, 00406 92, 92, 92, 92, 58, 92, 50, 49, 92, 92, 00407 53, 62, 92, 92, 92, 22, 92, 92, 73, 81, 00408 92, 92, 77, 92, 68, 92, 92, 92, 92, 38, 00409 92, 88, 67, 92, 84, 92, 92, 92, 86, 92, 00410 59, 92, 16, 92, 70, 69, 92, 92, 82, 92, 00411 92, 92, 92, 92, 92, 92, 92, 92, 92, 71, 00412 92, 92, 92, 92, 92, 92, 60, 0 00413 00414 } ; 00415 00416 static yyconst flex_int32_t yy_ec[256] = 00417 { 0, 00418 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 00419 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00420 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00421 1, 2, 1, 4, 1, 5, 6, 1, 7, 8, 00422 9, 10, 11, 12, 13, 14, 15, 16, 16, 16, 00423 16, 16, 16, 16, 16, 16, 16, 17, 18, 19, 00424 20, 21, 22, 1, 23, 24, 25, 26, 27, 28, 00425 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 00426 39, 40, 41, 42, 43, 44, 45, 46, 47, 32, 00427 1, 1, 1, 1, 48, 1, 32, 32, 32, 32, 00428 00429 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 00430 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 00431 32, 32, 49, 1, 50, 1, 1, 1, 1, 1, 00432 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00433 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00434 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00435 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00436 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00437 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00438 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00439 00440 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00441 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00442 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00443 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00444 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00445 1, 1, 1, 1, 1 00446 } ; 00447 00448 static yyconst flex_int32_t yy_meta[51] = 00449 { 0, 00450 1, 1, 1, 2, 1, 1, 3, 1, 1, 4, 00451 1, 1, 1, 1, 1, 5, 1, 1, 1, 6, 00452 1, 1, 5, 5, 5, 5, 5, 5, 5, 5, 00453 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 00454 5, 5, 5, 5, 5, 5, 5, 5, 1, 1 00455 } ; 00456 00457 static yyconst flex_int16_t yy_base[409] = 00458 { 0, 00459 0, 0, 437, 436, 438, 437, 439, 438, 441, 448, 00460 49, 51, 448, 0, 448, 448, 448, 448, 448, 448, 00461 448, 448, 426, 429, 41, 418, 448, 38, 448, 417, 00462 448, 20, 33, 32, 46, 40, 44, 0, 54, 52, 00463 399, 48, 60, 395, 65, 67, 81, 27, 411, 75, 00464 448, 448, 0, 98, 0, 426, 0, 428, 113, 0, 00465 448, 448, 415, 54, 410, 448, 448, 448, 448, 0, 00466 403, 68, 399, 391, 389, 0, 402, 80, 84, 397, 00467 383, 96, 381, 394, 379, 393, 387, 375, 379, 375, 00468 377, 377, 0, 98, 0, 376, 97, 385, 368, 375, 00469 00470 0, 0, 381, 381, 364, 94, 103, 379, 98, 65, 00471 381, 369, 109, 361, 377, 373, 351, 97, 372, 363, 00472 115, 356, 0, 137, 138, 448, 0, 388, 0, 390, 00473 377, 0, 0, 365, 360, 367, 365, 348, 346, 345, 00474 350, 359, 347, 359, 95, 347, 353, 354, 336, 336, 00475 123, 0, 334, 350, 351, 0, 338, 347, 344, 122, 00476 124, 341, 336, 330, 340, 338, 331, 328, 336, 0, 00477 326, 336, 334, 325, 315, 309, 322, 307, 327, 0, 00478 313, 0, 311, 0, 325, 316, 313, 131, 309, 316, 00479 323, 302, 304, 309, 309, 301, 304, 299, 0, 0, 00480 00481 311, 295, 305, 312, 292, 291, 305, 294, 307, 287, 00482 0, 297, 279, 0, 298, 0, 295, 282, 0, 281, 00483 276, 281, 280, 290, 0, 276, 0, 0, 0, 280, 00484 0, 0, 276, 273, 287, 0, 272, 272, 270, 286, 00485 271, 283, 280, 264, 282, 277, 0, 272, 272, 258, 00486 257, 270, 256, 270, 269, 268, 0, 252, 0, 246, 00487 0, 265, 249, 248, 0, 262, 252, 247, 246, 258, 00488 248, 247, 0, 0, 0, 251, 0, 239, 0, 253, 00489 249, 235, 0, 249, 250, 233, 238, 231, 249, 231, 00490 228, 0, 229, 226, 0, 231, 243, 230, 237, 227, 00491 00492 235, 220, 0, 0, 0, 212, 219, 0, 0, 0, 00493 216, 0, 230, 0, 231, 218, 217, 0, 213, 0, 00494 216, 0, 208, 210, 0, 209, 223, 216, 0, 0, 00495 219, 222, 204, 219, 0, 215, 0, 0, 199, 213, 00496 0, 0, 197, 196, 201, 0, 210, 195, 0, 0, 00497 201, 197, 0, 192, 0, 204, 204, 192, 202, 0, 00498 179, 0, 0, 199, 0, 183, 177, 183, 0, 174, 00499 0, 193, 0, 192, 0, 0, 183, 187, 0, 174, 00500 174, 180, 166, 189, 181, 180, 166, 151, 118, 0, 00501 130, 136, 127, 123, 119, 111, 0, 448, 167, 173, 00502 00503 179, 152, 181, 124, 187, 193, 199, 205 00504 } ; 00505 00506 static yyconst flex_int16_t yy_def[409] = 00507 { 0, 00508 398, 1, 399, 399, 400, 400, 401, 401, 398, 398, 00509 398, 398, 398, 402, 398, 398, 398, 398, 398, 398, 00510 398, 398, 398, 398, 398, 403, 398, 398, 398, 398, 00511 398, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00512 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00513 398, 398, 405, 406, 407, 398, 408, 398, 398, 402, 00514 398, 398, 398, 398, 403, 398, 398, 398, 398, 404, 00515 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00516 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00517 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00518 00519 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00520 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00521 404, 404, 405, 406, 406, 398, 407, 398, 408, 398, 00522 398, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00523 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00524 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00525 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00526 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00527 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00528 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00529 00530 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00531 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00532 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00533 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00534 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00535 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00536 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00537 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00538 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00539 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00540 00541 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00542 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00543 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00544 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00545 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00546 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00547 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00548 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00549 404, 404, 404, 404, 404, 404, 404, 404, 404, 404, 00550 404, 404, 404, 404, 404, 404, 404, 0, 398, 398, 00551 00552 398, 398, 398, 398, 398, 398, 398, 398 00553 } ; 00554 00555 static yyconst flex_int16_t yy_nxt[499] = 00556 { 0, 00557 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 00558 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 00559 30, 31, 32, 33, 34, 35, 36, 37, 38, 38, 00560 39, 38, 38, 40, 41, 42, 43, 44, 38, 45, 00561 46, 47, 48, 49, 50, 38, 38, 38, 51, 52, 00562 59, 59, 59, 59, 63, 71, 64, 67, 68, 73, 00563 72, 77, 118, 74, 119, 78, 75, 63, 79, 64, 00564 88, 80, 82, 85, 81, 86, 83, 89, 96, 76, 00565 90, 93, 84, 91, 99, 87, 92, 101, 97, 94, 00566 100, 107, 133, 110, 95, 102, 111, 103, 179, 104, 00567 00568 108, 109, 105, 115, 121, 112, 180, 125, 134, 113, 00569 116, 122, 126, 114, 59, 59, 139, 117, 141, 142, 00570 146, 163, 140, 159, 171, 173, 143, 189, 70, 147, 00571 172, 177, 183, 164, 207, 208, 148, 190, 160, 161, 00572 174, 193, 178, 184, 175, 194, 398, 125, 222, 214, 00573 224, 398, 126, 215, 248, 249, 60, 397, 396, 395, 00574 225, 394, 393, 223, 392, 391, 250, 53, 53, 53, 00575 53, 53, 53, 55, 55, 55, 55, 55, 55, 57, 00576 57, 57, 57, 57, 57, 65, 65, 123, 123, 123, 00577 390, 123, 123, 124, 124, 124, 124, 124, 124, 127, 00578 00579 127, 389, 127, 127, 127, 129, 388, 129, 129, 129, 00580 129, 387, 386, 385, 384, 383, 382, 381, 380, 379, 00581 378, 377, 376, 375, 374, 373, 372, 371, 370, 369, 00582 368, 367, 366, 365, 364, 363, 362, 361, 360, 359, 00583 358, 357, 356, 355, 354, 353, 352, 351, 350, 349, 00584 348, 347, 346, 345, 344, 343, 342, 341, 340, 339, 00585 338, 337, 336, 335, 334, 333, 332, 331, 330, 329, 00586 328, 327, 326, 325, 324, 323, 322, 321, 320, 319, 00587 318, 317, 316, 315, 314, 313, 312, 311, 310, 309, 00588 308, 307, 306, 305, 304, 303, 302, 301, 300, 299, 00589 00590 298, 297, 296, 295, 294, 293, 292, 291, 290, 289, 00591 288, 287, 286, 285, 284, 283, 282, 281, 280, 279, 00592 278, 277, 276, 275, 274, 273, 272, 271, 270, 269, 00593 268, 267, 266, 265, 264, 263, 262, 261, 260, 259, 00594 258, 257, 256, 255, 254, 253, 252, 251, 247, 246, 00595 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, 00596 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 00597 221, 220, 219, 218, 217, 216, 213, 212, 211, 210, 00598 209, 206, 205, 204, 203, 202, 201, 200, 199, 198, 00599 197, 196, 131, 130, 128, 195, 192, 191, 188, 187, 00600 00601 186, 185, 182, 181, 176, 170, 169, 168, 167, 166, 00602 165, 162, 158, 157, 156, 155, 154, 153, 152, 151, 00603 150, 149, 145, 144, 138, 137, 136, 135, 132, 398, 00604 131, 130, 128, 120, 106, 98, 69, 66, 62, 61, 00605 398, 58, 58, 56, 56, 54, 54, 9, 398, 398, 00606 398, 398, 398, 398, 398, 398, 398, 398, 398, 398, 00607 398, 398, 398, 398, 398, 398, 398, 398, 398, 398, 00608 398, 398, 398, 398, 398, 398, 398, 398, 398, 398, 00609 398, 398, 398, 398, 398, 398, 398, 398, 398, 398, 00610 398, 398, 398, 398, 398, 398, 398, 398 00611 00612 } ; 00613 00614 static yyconst flex_int16_t yy_chk[499] = 00615 { 0, 00616 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00617 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00618 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00619 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00620 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00621 11, 11, 12, 12, 25, 32, 25, 28, 28, 33, 00622 32, 34, 48, 33, 48, 34, 33, 64, 34, 64, 00623 37, 34, 35, 36, 34, 36, 35, 37, 40, 33, 00624 37, 39, 35, 37, 42, 36, 37, 43, 40, 39, 00625 42, 45, 72, 46, 39, 43, 46, 43, 110, 43, 00626 00627 45, 45, 43, 47, 50, 46, 110, 54, 72, 46, 00628 47, 50, 54, 46, 59, 59, 78, 47, 79, 79, 00629 82, 97, 78, 94, 106, 107, 79, 118, 404, 82, 00630 106, 109, 113, 97, 145, 145, 82, 118, 94, 94, 00631 107, 121, 109, 113, 107, 121, 124, 125, 160, 151, 00632 161, 124, 125, 151, 188, 188, 402, 396, 395, 394, 00633 161, 393, 392, 160, 391, 389, 188, 399, 399, 399, 00634 399, 399, 399, 400, 400, 400, 400, 400, 400, 401, 00635 401, 401, 401, 401, 401, 403, 403, 405, 405, 405, 00636 388, 405, 405, 406, 406, 406, 406, 406, 406, 407, 00637 00638 407, 387, 407, 407, 407, 408, 386, 408, 408, 408, 00639 408, 385, 384, 383, 382, 381, 380, 378, 377, 374, 00640 372, 370, 368, 367, 366, 364, 361, 359, 358, 357, 00641 356, 354, 352, 351, 348, 347, 345, 344, 343, 340, 00642 339, 336, 334, 333, 332, 331, 328, 327, 326, 324, 00643 323, 321, 319, 317, 316, 315, 313, 311, 307, 306, 00644 302, 301, 300, 299, 298, 297, 296, 294, 293, 291, 00645 290, 289, 288, 287, 286, 285, 284, 282, 281, 280, 00646 278, 276, 272, 271, 270, 269, 268, 267, 266, 264, 00647 263, 262, 260, 258, 256, 255, 254, 253, 252, 251, 00648 00649 250, 249, 248, 246, 245, 244, 243, 242, 241, 240, 00650 239, 238, 237, 235, 234, 233, 230, 226, 224, 223, 00651 222, 221, 220, 218, 217, 215, 213, 212, 210, 209, 00652 208, 207, 206, 205, 204, 203, 202, 201, 198, 197, 00653 196, 195, 194, 193, 192, 191, 190, 189, 187, 186, 00654 185, 183, 181, 179, 178, 177, 176, 175, 174, 173, 00655 172, 171, 169, 168, 167, 166, 165, 164, 163, 162, 00656 159, 158, 157, 155, 154, 153, 150, 149, 148, 147, 00657 146, 144, 143, 142, 141, 140, 139, 138, 137, 136, 00658 135, 134, 131, 130, 128, 122, 120, 119, 117, 116, 00659 00660 115, 114, 112, 111, 108, 105, 104, 103, 100, 99, 00661 98, 96, 92, 91, 90, 89, 88, 87, 86, 85, 00662 84, 83, 81, 80, 77, 75, 74, 73, 71, 65, 00663 63, 58, 56, 49, 44, 41, 30, 26, 24, 23, 00664 9, 8, 7, 6, 5, 4, 3, 398, 398, 398, 00665 398, 398, 398, 398, 398, 398, 398, 398, 398, 398, 00666 398, 398, 398, 398, 398, 398, 398, 398, 398, 398, 00667 398, 398, 398, 398, 398, 398, 398, 398, 398, 398, 00668 398, 398, 398, 398, 398, 398, 398, 398, 398, 398, 00669 398, 398, 398, 398, 398, 398, 398, 398 00670 00671 } ; 00672 00673 static yy_state_type yy_last_accepting_state; 00674 static char *yy_last_accepting_cpos; 00675 00676 extern int yy_flex_debug; 00677 int yy_flex_debug = 0; 00678 00679 /* The intent behind this definition is that it'll catch 00680 * any uses of REJECT which flex missed. 00681 */ 00682 #define REJECT reject_used_but_not_detected 00683 #define yymore() yymore_used_but_not_detected 00684 #define YY_MORE_ADJ 0 00685 #define YY_RESTORE_YY_MORE_OFFSET 00686 char *yytext; 00687 #line 1 "pars0lex.l" 00688 /****************************************************** 00689 SQL parser lexical analyzer: input file for the GNU Flex lexer generator 00690 00691 (c) 1997 Innobase Oy 00692 00693 Created 12/14/1997 Heikki Tuuri 00694 Published under the GPL version 2 00695 00696 The InnoDB parser is frozen because MySQL takes care of SQL parsing. 00697 Therefore we normally keep the InnoDB parser C files as they are, and do 00698 not automatically generate them from pars0grm.y and pars0lex.l. 00699 00700 How to make the InnoDB parser and lexer C files: 00701 00702 1. Run ./make_flex.sh to generate lexer files. 00703 00704 2. Run ./make_bison.sh to generate parser files. 00705 00706 These instructions seem to work at least with bison-1.875d and flex-2.5.31 on 00707 Linux. 00708 *******************************************************/ 00709 #define YY_NO_INPUT 1 00710 #define YY_NO_UNISTD_H 1 00711 #line 38 "pars0lex.l" 00712 #define YYSTYPE que_node_t* 00713 00714 #include "univ.i" 00715 #include "pars0pars.h" 00716 #include "pars0grm.h" 00717 #include "pars0sym.h" 00718 #include "mem0mem.h" 00719 #include "os0proc.h" 00720 00721 #define malloc(A) ut_malloc(A) 00722 #define free(A) ut_free(A) 00723 #define realloc(P, A) ut_realloc(P, A) 00724 #define exit(A) ut_error 00725 00726 #define YY_INPUT(buf, result, max_size) pars_get_lex_chars(buf, &result, max_size) 00727 00728 /* String buffer for removing quotes */ 00729 static ulint stringbuf_len_alloc = 0; /* Allocated length */ 00730 static ulint stringbuf_len = 0; /* Current length */ 00731 static char* stringbuf; /* Start of buffer */ 00732 /* Appends a string to the buffer. */ 00733 static 00734 void 00735 string_append( 00736 /*==========*/ 00737 const char* str, /* in: string to be appended */ 00738 ulint len) /* in: length of the string */ 00739 { 00740 if (stringbuf == NULL) { 00741 stringbuf = malloc(1); 00742 stringbuf_len_alloc = 1; 00743 } 00744 00745 if (stringbuf_len + len > stringbuf_len_alloc) { 00746 while (stringbuf_len + len > stringbuf_len_alloc) { 00747 stringbuf_len_alloc <<= 1; 00748 } 00749 stringbuf = realloc(stringbuf, stringbuf_len_alloc); 00750 } 00751 00752 memcpy(stringbuf + stringbuf_len, str, len); 00753 stringbuf_len += len; 00754 } 00755 00756 00757 00758 00759 #line 759 "_flex_tmp.c" 00760 00761 #define INITIAL 0 00762 #define comment 1 00763 #define quoted 2 00764 #define id 3 00765 00766 #ifndef YY_NO_UNISTD_H 00767 /* Special case for "unistd.h", since it is non-ANSI. We include it way 00768 * down here because we want the user's section 1 to have been scanned first. 00769 * The user has a chance to override it with an option. 00770 */ 00771 #include <unistd.h> 00772 #endif 00773 00774 #ifndef YY_EXTRA_TYPE 00775 #define YY_EXTRA_TYPE void * 00776 #endif 00777 00778 /* Macros after this point can all be overridden by user definitions in 00779 * section 1. 00780 */ 00781 00782 #ifndef YY_SKIP_YYWRAP 00783 #ifdef __cplusplus 00784 extern "C" int yywrap (void ); 00785 #else 00786 extern int yywrap (void ); 00787 #endif 00788 #endif 00789 00790 #ifndef yytext_ptr 00791 static void yy_flex_strncpy (char *,yyconst char *,int ); 00792 #endif 00793 00794 #ifdef YY_NEED_STRLEN 00795 static int yy_flex_strlen (yyconst char * ); 00796 #endif 00797 00798 #ifndef YY_NO_INPUT 00799 00800 #ifdef __cplusplus 00801 static int yyinput (void ); 00802 #else 00803 static int input (void ); 00804 #endif 00805 00806 #endif 00807 00808 /* Amount of stuff to slurp up with each read. */ 00809 #ifndef YY_READ_BUF_SIZE 00810 #define YY_READ_BUF_SIZE 8192 00811 #endif 00812 00813 /* Copy whatever the last rule matched to the standard output. */ 00814 #ifndef ECHO 00815 /* This used to be an fputs(), but since the string might contain NUL's, 00816 * we now use fwrite(). 00817 */ 00818 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 00819 #endif 00820 00821 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 00822 * is returned in "result". 00823 */ 00824 #ifndef YY_INPUT 00825 #define YY_INPUT(buf,result,max_size) \ 00826 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 00827 { \ 00828 int c = '*'; \ 00829 size_t n; \ 00830 for ( n = 0; n < max_size && \ 00831 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 00832 buf[n] = (char) c; \ 00833 if ( c == '\n' ) \ 00834 buf[n++] = (char) c; \ 00835 if ( c == EOF && ferror( yyin ) ) \ 00836 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 00837 result = n; \ 00838 } \ 00839 else \ 00840 { \ 00841 errno=0; \ 00842 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 00843 { \ 00844 if( errno != EINTR) \ 00845 { \ 00846 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 00847 break; \ 00848 } \ 00849 errno=0; \ 00850 clearerr(yyin); \ 00851 } \ 00852 }\ 00853 \ 00854 00855 #endif 00856 00857 /* No semi-colon after return; correct usage is to write "yyterminate();" - 00858 * we don't want an extra ';' after the "return" because that will cause 00859 * some compilers to complain about unreachable statements. 00860 */ 00861 #ifndef yyterminate 00862 #define yyterminate() return YY_NULL 00863 #endif 00864 00865 /* Number of entries by which start-condition stack grows. */ 00866 #ifndef YY_START_STACK_INCR 00867 #define YY_START_STACK_INCR 25 00868 #endif 00869 00870 /* Report a fatal error. */ 00871 #ifndef YY_FATAL_ERROR 00872 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 00873 #endif 00874 00875 /* end tables serialization structures and prototypes */ 00876 00877 /* Default declaration of generated scanner - a define so the user can 00878 * easily add parameters. 00879 */ 00880 #ifndef YY_DECL 00881 #define YY_DECL_IS_OURS 1 00882 00883 extern int yylex (void); 00884 00885 #define YY_DECL int yylex (void) 00886 #endif /* !YY_DECL */ 00887 00888 /* Code executed at the beginning of each rule, after yytext and yyleng 00889 * have been set up. 00890 */ 00891 #ifndef YY_USER_ACTION 00892 #define YY_USER_ACTION 00893 #endif 00894 00895 /* Code executed at the end of each rule. */ 00896 #ifndef YY_BREAK 00897 #define YY_BREAK break; 00898 #endif 00899 00900 #define YY_RULE_SETUP \ 00901 YY_USER_ACTION 00902 00905 YY_DECL 00906 { 00907 register yy_state_type yy_current_state; 00908 register char *yy_cp, *yy_bp; 00909 register int yy_act; 00910 00911 #line 92 "pars0lex.l" 00912 00913 00914 #line 914 "_flex_tmp.c" 00915 00916 if ( (yy_init) ) 00917 { 00918 (yy_init) = 0; 00919 00920 #ifdef YY_USER_INIT 00921 YY_USER_INIT; 00922 #endif 00923 00924 if ( ! (yy_start) ) 00925 (yy_start) = 1; /* first start state */ 00926 00927 if ( ! yyin ) 00928 yyin = stdin; 00929 00930 if ( ! yyout ) 00931 yyout = stdout; 00932 00933 if ( ! YY_CURRENT_BUFFER ) { 00934 yyensure_buffer_stack (); 00935 YY_CURRENT_BUFFER_LVALUE = 00936 yy_create_buffer(yyin,YY_BUF_SIZE ); 00937 } 00938 00939 yy_load_buffer_state( ); 00940 } 00941 00942 while ( 1 ) /* loops until end-of-file is reached */ 00943 { 00944 yy_cp = (yy_c_buf_p); 00945 00946 /* Support of yytext. */ 00947 *yy_cp = (yy_hold_char); 00948 00949 /* yy_bp points to the position in yy_ch_buf of the start of 00950 * the current run. 00951 */ 00952 yy_bp = yy_cp; 00953 00954 yy_current_state = (yy_start); 00955 yy_match: 00956 do 00957 { 00958 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 00959 if ( yy_accept[yy_current_state] ) 00960 { 00961 (yy_last_accepting_state) = yy_current_state; 00962 (yy_last_accepting_cpos) = yy_cp; 00963 } 00964 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 00965 { 00966 yy_current_state = (int) yy_def[yy_current_state]; 00967 if ( yy_current_state >= 399 ) 00968 yy_c = yy_meta[(unsigned int) yy_c]; 00969 } 00970 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 00971 ++yy_cp; 00972 } 00973 while ( yy_current_state != 398 ); 00974 yy_cp = (yy_last_accepting_cpos); 00975 yy_current_state = (yy_last_accepting_state); 00976 00977 yy_find_action: 00978 yy_act = yy_accept[yy_current_state]; 00979 00980 YY_DO_BEFORE_ACTION; 00981 00982 do_action: /* This label is used only to access EOF actions. */ 00983 00984 switch ( yy_act ) 00985 { /* beginning of action switch */ 00986 case 0: /* must back up */ 00987 /* undo the effects of YY_DO_BEFORE_ACTION */ 00988 *yy_cp = (yy_hold_char); 00989 yy_cp = (yy_last_accepting_cpos); 00990 yy_current_state = (yy_last_accepting_state); 00991 goto yy_find_action; 00992 00993 case 1: 00994 YY_RULE_SETUP 00995 #line 94 "pars0lex.l" 00996 { 00997 yylval = sym_tab_add_int_lit(pars_sym_tab_global, 00998 atoi(yytext)); 00999 return(PARS_INT_LIT); 01000 } 01001 YY_BREAK 01002 case 2: 01003 YY_RULE_SETUP 01004 #line 100 "pars0lex.l" 01005 { 01006 ut_error; /* not implemented */ 01007 01008 return(PARS_FLOAT_LIT); 01009 } 01010 YY_BREAK 01011 case 3: 01012 YY_RULE_SETUP 01013 #line 106 "pars0lex.l" 01014 { 01015 ulint type; 01016 01017 yylval = sym_tab_add_bound_lit(pars_sym_tab_global, 01018 yytext + 1, &type); 01019 01020 return(type); 01021 } 01022 YY_BREAK 01023 case 4: 01024 YY_RULE_SETUP 01025 #line 115 "pars0lex.l" 01026 { 01027 yylval = sym_tab_add_bound_id(pars_sym_tab_global, 01028 yytext + 1); 01029 01030 return(PARS_ID_TOKEN); 01031 } 01032 YY_BREAK 01033 case 5: 01034 YY_RULE_SETUP 01035 #line 122 "pars0lex.l" 01036 { 01037 /* Quoted character string literals are handled in an explicit 01038 start state 'quoted'. This state is entered and the buffer for 01039 the scanned string is emptied upon encountering a starting quote. 01040 01041 In the state 'quoted', only two actions are possible (defined below). */ 01042 BEGIN(quoted); 01043 stringbuf_len = 0; 01044 } 01045 YY_BREAK 01046 case 6: 01047 /* rule 6 can match eol */ 01048 YY_RULE_SETUP 01049 #line 131 "pars0lex.l" 01050 { 01051 /* Got a sequence of characters other than "'": 01052 append to string buffer */ 01053 string_append(yytext, yyleng); 01054 } 01055 YY_BREAK 01056 case 7: 01057 YY_RULE_SETUP 01058 #line 136 "pars0lex.l" 01059 { 01060 /* Got a sequence of "'" characters: 01061 append half of them to string buffer, 01062 as "''" represents a single "'". 01063 We apply truncating division, 01064 so that "'''" will result in "'". */ 01065 01066 string_append(yytext, yyleng / 2); 01067 01068 /* If we got an odd number of quotes, then the 01069 last quote we got is the terminating quote. 01070 At the end of the string, we return to the 01071 initial start state and report the scanned 01072 string literal. */ 01073 01074 if (yyleng % 2) { 01075 BEGIN(INITIAL); 01076 yylval = sym_tab_add_str_lit( 01077 pars_sym_tab_global, 01078 (byte*) stringbuf, stringbuf_len); 01079 return(PARS_STR_LIT); 01080 } 01081 } 01082 YY_BREAK 01083 case 8: 01084 YY_RULE_SETUP 01085 #line 160 "pars0lex.l" 01086 { 01087 /* Quoted identifiers are handled in an explicit start state 'id'. 01088 This state is entered and the buffer for the scanned string is emptied 01089 upon encountering a starting quote. 01090 01091 In the state 'id', only two actions are possible (defined below). */ 01092 BEGIN(id); 01093 stringbuf_len = 0; 01094 } 01095 YY_BREAK 01096 case 9: 01097 /* rule 9 can match eol */ 01098 YY_RULE_SETUP 01099 #line 169 "pars0lex.l" 01100 { 01101 /* Got a sequence of characters other than '"': 01102 append to string buffer */ 01103 string_append(yytext, yyleng); 01104 } 01105 YY_BREAK 01106 case 10: 01107 YY_RULE_SETUP 01108 #line 174 "pars0lex.l" 01109 { 01110 /* Got a sequence of '"' characters: 01111 append half of them to string buffer, 01112 as '""' represents a single '"'. 01113 We apply truncating division, 01114 so that '"""' will result in '"'. */ 01115 01116 string_append(yytext, yyleng / 2); 01117 01118 /* If we got an odd number of quotes, then the 01119 last quote we got is the terminating quote. 01120 At the end of the string, we return to the 01121 initial start state and report the scanned 01122 identifier. */ 01123 01124 if (yyleng % 2) { 01125 BEGIN(INITIAL); 01126 yylval = sym_tab_add_id( 01127 pars_sym_tab_global, 01128 (byte*) stringbuf, stringbuf_len); 01129 01130 return(PARS_ID_TOKEN); 01131 } 01132 } 01133 YY_BREAK 01134 case 11: 01135 YY_RULE_SETUP 01136 #line 199 "pars0lex.l" 01137 { 01138 yylval = sym_tab_add_null_lit(pars_sym_tab_global); 01139 01140 return(PARS_NULL_LIT); 01141 } 01142 YY_BREAK 01143 case 12: 01144 YY_RULE_SETUP 01145 #line 205 "pars0lex.l" 01146 { 01147 /* Implicit cursor name */ 01148 yylval = sym_tab_add_str_lit(pars_sym_tab_global, 01149 (byte*) yytext, yyleng); 01150 return(PARS_SQL_TOKEN); 01151 } 01152 YY_BREAK 01153 case 13: 01154 YY_RULE_SETUP 01155 #line 212 "pars0lex.l" 01156 { 01157 return(PARS_AND_TOKEN); 01158 } 01159 YY_BREAK 01160 case 14: 01161 YY_RULE_SETUP 01162 #line 216 "pars0lex.l" 01163 { 01164 return(PARS_OR_TOKEN); 01165 } 01166 YY_BREAK 01167 case 15: 01168 YY_RULE_SETUP 01169 #line 220 "pars0lex.l" 01170 { 01171 return(PARS_NOT_TOKEN); 01172 } 01173 YY_BREAK 01174 case 16: 01175 YY_RULE_SETUP 01176 #line 224 "pars0lex.l" 01177 { 01178 return(PARS_PROCEDURE_TOKEN); 01179 } 01180 YY_BREAK 01181 case 17: 01182 YY_RULE_SETUP 01183 #line 228 "pars0lex.l" 01184 { 01185 return(PARS_IN_TOKEN); 01186 } 01187 YY_BREAK 01188 case 18: 01189 YY_RULE_SETUP 01190 #line 232 "pars0lex.l" 01191 { 01192 return(PARS_OUT_TOKEN); 01193 } 01194 YY_BREAK 01195 case 19: 01196 YY_RULE_SETUP 01197 #line 236 "pars0lex.l" 01198 { 01199 return(PARS_BINARY_TOKEN); 01200 } 01201 YY_BREAK 01202 case 20: 01203 YY_RULE_SETUP 01204 #line 240 "pars0lex.l" 01205 { 01206 return(PARS_BLOB_TOKEN); 01207 } 01208 YY_BREAK 01209 case 21: 01210 YY_RULE_SETUP 01211 #line 244 "pars0lex.l" 01212 { 01213 return(PARS_INT_TOKEN); 01214 } 01215 YY_BREAK 01216 case 22: 01217 YY_RULE_SETUP 01218 #line 248 "pars0lex.l" 01219 { 01220 return(PARS_INT_TOKEN); 01221 } 01222 YY_BREAK 01223 case 23: 01224 YY_RULE_SETUP 01225 #line 252 "pars0lex.l" 01226 { 01227 return(PARS_FLOAT_TOKEN); 01228 } 01229 YY_BREAK 01230 case 24: 01231 YY_RULE_SETUP 01232 #line 256 "pars0lex.l" 01233 { 01234 return(PARS_CHAR_TOKEN); 01235 } 01236 YY_BREAK 01237 case 25: 01238 YY_RULE_SETUP 01239 #line 260 "pars0lex.l" 01240 { 01241 return(PARS_IS_TOKEN); 01242 } 01243 YY_BREAK 01244 case 26: 01245 YY_RULE_SETUP 01246 #line 264 "pars0lex.l" 01247 { 01248 return(PARS_BEGIN_TOKEN); 01249 } 01250 YY_BREAK 01251 case 27: 01252 YY_RULE_SETUP 01253 #line 268 "pars0lex.l" 01254 { 01255 return(PARS_END_TOKEN); 01256 } 01257 YY_BREAK 01258 case 28: 01259 YY_RULE_SETUP 01260 #line 272 "pars0lex.l" 01261 { 01262 return(PARS_IF_TOKEN); 01263 } 01264 YY_BREAK 01265 case 29: 01266 YY_RULE_SETUP 01267 #line 276 "pars0lex.l" 01268 { 01269 return(PARS_THEN_TOKEN); 01270 } 01271 YY_BREAK 01272 case 30: 01273 YY_RULE_SETUP 01274 #line 280 "pars0lex.l" 01275 { 01276 return(PARS_ELSE_TOKEN); 01277 } 01278 YY_BREAK 01279 case 31: 01280 YY_RULE_SETUP 01281 #line 284 "pars0lex.l" 01282 { 01283 return(PARS_ELSIF_TOKEN); 01284 } 01285 YY_BREAK 01286 case 32: 01287 YY_RULE_SETUP 01288 #line 288 "pars0lex.l" 01289 { 01290 return(PARS_LOOP_TOKEN); 01291 } 01292 YY_BREAK 01293 case 33: 01294 YY_RULE_SETUP 01295 #line 292 "pars0lex.l" 01296 { 01297 return(PARS_WHILE_TOKEN); 01298 } 01299 YY_BREAK 01300 case 34: 01301 YY_RULE_SETUP 01302 #line 296 "pars0lex.l" 01303 { 01304 return(PARS_RETURN_TOKEN); 01305 } 01306 YY_BREAK 01307 case 35: 01308 YY_RULE_SETUP 01309 #line 300 "pars0lex.l" 01310 { 01311 return(PARS_SELECT_TOKEN); 01312 } 01313 YY_BREAK 01314 case 36: 01315 YY_RULE_SETUP 01316 #line 304 "pars0lex.l" 01317 { 01318 return(PARS_SUM_TOKEN); 01319 } 01320 YY_BREAK 01321 case 37: 01322 YY_RULE_SETUP 01323 #line 308 "pars0lex.l" 01324 { 01325 return(PARS_COUNT_TOKEN); 01326 } 01327 YY_BREAK 01328 case 38: 01329 YY_RULE_SETUP 01330 #line 312 "pars0lex.l" 01331 { 01332 return(PARS_DISTINCT_TOKEN); 01333 } 01334 YY_BREAK 01335 case 39: 01336 YY_RULE_SETUP 01337 #line 316 "pars0lex.l" 01338 { 01339 return(PARS_FROM_TOKEN); 01340 } 01341 YY_BREAK 01342 case 40: 01343 YY_RULE_SETUP 01344 #line 320 "pars0lex.l" 01345 { 01346 return(PARS_WHERE_TOKEN); 01347 } 01348 YY_BREAK 01349 case 41: 01350 YY_RULE_SETUP 01351 #line 324 "pars0lex.l" 01352 { 01353 return(PARS_FOR_TOKEN); 01354 } 01355 YY_BREAK 01356 case 42: 01357 YY_RULE_SETUP 01358 #line 328 "pars0lex.l" 01359 { 01360 return(PARS_READ_TOKEN); 01361 } 01362 YY_BREAK 01363 case 43: 01364 YY_RULE_SETUP 01365 #line 332 "pars0lex.l" 01366 { 01367 return(PARS_ORDER_TOKEN); 01368 } 01369 YY_BREAK 01370 case 44: 01371 YY_RULE_SETUP 01372 #line 336 "pars0lex.l" 01373 { 01374 return(PARS_BY_TOKEN); 01375 } 01376 YY_BREAK 01377 case 45: 01378 YY_RULE_SETUP 01379 #line 340 "pars0lex.l" 01380 { 01381 return(PARS_ASC_TOKEN); 01382 } 01383 YY_BREAK 01384 case 46: 01385 YY_RULE_SETUP 01386 #line 344 "pars0lex.l" 01387 { 01388 return(PARS_DESC_TOKEN); 01389 } 01390 YY_BREAK 01391 case 47: 01392 YY_RULE_SETUP 01393 #line 348 "pars0lex.l" 01394 { 01395 return(PARS_INSERT_TOKEN); 01396 } 01397 YY_BREAK 01398 case 48: 01399 YY_RULE_SETUP 01400 #line 352 "pars0lex.l" 01401 { 01402 return(PARS_INTO_TOKEN); 01403 } 01404 YY_BREAK 01405 case 49: 01406 YY_RULE_SETUP 01407 #line 356 "pars0lex.l" 01408 { 01409 return(PARS_VALUES_TOKEN); 01410 } 01411 YY_BREAK 01412 case 50: 01413 YY_RULE_SETUP 01414 #line 360 "pars0lex.l" 01415 { 01416 return(PARS_UPDATE_TOKEN); 01417 } 01418 YY_BREAK 01419 case 51: 01420 YY_RULE_SETUP 01421 #line 364 "pars0lex.l" 01422 { 01423 return(PARS_SET_TOKEN); 01424 } 01425 YY_BREAK 01426 case 52: 01427 YY_RULE_SETUP 01428 #line 368 "pars0lex.l" 01429 { 01430 return(PARS_DELETE_TOKEN); 01431 } 01432 YY_BREAK 01433 case 53: 01434 YY_RULE_SETUP 01435 #line 372 "pars0lex.l" 01436 { 01437 return(PARS_CURRENT_TOKEN); 01438 } 01439 YY_BREAK 01440 case 54: 01441 YY_RULE_SETUP 01442 #line 376 "pars0lex.l" 01443 { 01444 return(PARS_OF_TOKEN); 01445 } 01446 YY_BREAK 01447 case 55: 01448 YY_RULE_SETUP 01449 #line 380 "pars0lex.l" 01450 { 01451 return(PARS_CREATE_TOKEN); 01452 } 01453 YY_BREAK 01454 case 56: 01455 YY_RULE_SETUP 01456 #line 384 "pars0lex.l" 01457 { 01458 return(PARS_TABLE_TOKEN); 01459 } 01460 YY_BREAK 01461 case 57: 01462 YY_RULE_SETUP 01463 #line 388 "pars0lex.l" 01464 { 01465 return(PARS_INDEX_TOKEN); 01466 } 01467 YY_BREAK 01468 case 58: 01469 YY_RULE_SETUP 01470 #line 392 "pars0lex.l" 01471 { 01472 return(PARS_UNIQUE_TOKEN); 01473 } 01474 YY_BREAK 01475 case 59: 01476 YY_RULE_SETUP 01477 #line 396 "pars0lex.l" 01478 { 01479 return(PARS_CLUSTERED_TOKEN); 01480 } 01481 YY_BREAK 01482 case 60: 01483 YY_RULE_SETUP 01484 #line 400 "pars0lex.l" 01485 { 01486 return(PARS_DOES_NOT_FIT_IN_MEM_TOKEN); 01487 } 01488 YY_BREAK 01489 case 61: 01490 YY_RULE_SETUP 01491 #line 404 "pars0lex.l" 01492 { 01493 return(PARS_ON_TOKEN); 01494 } 01495 YY_BREAK 01496 case 62: 01497 YY_RULE_SETUP 01498 #line 408 "pars0lex.l" 01499 { 01500 return(PARS_DECLARE_TOKEN); 01501 } 01502 YY_BREAK 01503 case 63: 01504 YY_RULE_SETUP 01505 #line 412 "pars0lex.l" 01506 { 01507 return(PARS_CURSOR_TOKEN); 01508 } 01509 YY_BREAK 01510 case 64: 01511 YY_RULE_SETUP 01512 #line 416 "pars0lex.l" 01513 { 01514 return(PARS_OPEN_TOKEN); 01515 } 01516 YY_BREAK 01517 case 65: 01518 YY_RULE_SETUP 01519 #line 420 "pars0lex.l" 01520 { 01521 return(PARS_FETCH_TOKEN); 01522 } 01523 YY_BREAK 01524 case 66: 01525 YY_RULE_SETUP 01526 #line 424 "pars0lex.l" 01527 { 01528 return(PARS_CLOSE_TOKEN); 01529 } 01530 YY_BREAK 01531 case 67: 01532 YY_RULE_SETUP 01533 #line 428 "pars0lex.l" 01534 { 01535 return(PARS_NOTFOUND_TOKEN); 01536 } 01537 YY_BREAK 01538 case 68: 01539 YY_RULE_SETUP 01540 #line 432 "pars0lex.l" 01541 { 01542 return(PARS_TO_CHAR_TOKEN); 01543 } 01544 YY_BREAK 01545 case 69: 01546 YY_RULE_SETUP 01547 #line 436 "pars0lex.l" 01548 { 01549 return(PARS_TO_NUMBER_TOKEN); 01550 } 01551 YY_BREAK 01552 case 70: 01553 YY_RULE_SETUP 01554 #line 440 "pars0lex.l" 01555 { 01556 return(PARS_TO_BINARY_TOKEN); 01557 } 01558 YY_BREAK 01559 case 71: 01560 YY_RULE_SETUP 01561 #line 444 "pars0lex.l" 01562 { 01563 return(PARS_BINARY_TO_NUMBER_TOKEN); 01564 } 01565 YY_BREAK 01566 case 72: 01567 YY_RULE_SETUP 01568 #line 448 "pars0lex.l" 01569 { 01570 return(PARS_SUBSTR_TOKEN); 01571 } 01572 YY_BREAK 01573 case 73: 01574 YY_RULE_SETUP 01575 #line 452 "pars0lex.l" 01576 { 01577 return(PARS_REPLSTR_TOKEN); 01578 } 01579 YY_BREAK 01580 case 74: 01581 YY_RULE_SETUP 01582 #line 456 "pars0lex.l" 01583 { 01584 return(PARS_CONCAT_TOKEN); 01585 } 01586 YY_BREAK 01587 case 75: 01588 YY_RULE_SETUP 01589 #line 460 "pars0lex.l" 01590 { 01591 return(PARS_INSTR_TOKEN); 01592 } 01593 YY_BREAK 01594 case 76: 01595 YY_RULE_SETUP 01596 #line 464 "pars0lex.l" 01597 { 01598 return(PARS_LENGTH_TOKEN); 01599 } 01600 YY_BREAK 01601 case 77: 01602 YY_RULE_SETUP 01603 #line 468 "pars0lex.l" 01604 { 01605 return(PARS_SYSDATE_TOKEN); 01606 } 01607 YY_BREAK 01608 case 78: 01609 YY_RULE_SETUP 01610 #line 472 "pars0lex.l" 01611 { 01612 return(PARS_PRINTF_TOKEN); 01613 } 01614 YY_BREAK 01615 case 79: 01616 YY_RULE_SETUP 01617 #line 476 "pars0lex.l" 01618 { 01619 return(PARS_ASSERT_TOKEN); 01620 } 01621 YY_BREAK 01622 case 80: 01623 YY_RULE_SETUP 01624 #line 480 "pars0lex.l" 01625 { 01626 return(PARS_RND_TOKEN); 01627 } 01628 YY_BREAK 01629 case 81: 01630 YY_RULE_SETUP 01631 #line 484 "pars0lex.l" 01632 { 01633 return(PARS_RND_STR_TOKEN); 01634 } 01635 YY_BREAK 01636 case 82: 01637 YY_RULE_SETUP 01638 #line 488 "pars0lex.l" 01639 { 01640 return(PARS_ROW_PRINTF_TOKEN); 01641 } 01642 YY_BREAK 01643 case 83: 01644 YY_RULE_SETUP 01645 #line 492 "pars0lex.l" 01646 { 01647 return(PARS_COMMIT_TOKEN); 01648 } 01649 YY_BREAK 01650 case 84: 01651 YY_RULE_SETUP 01652 #line 496 "pars0lex.l" 01653 { 01654 return(PARS_ROLLBACK_TOKEN); 01655 } 01656 YY_BREAK 01657 case 85: 01658 YY_RULE_SETUP 01659 #line 500 "pars0lex.l" 01660 { 01661 return(PARS_WORK_TOKEN); 01662 } 01663 YY_BREAK 01664 case 86: 01665 YY_RULE_SETUP 01666 #line 504 "pars0lex.l" 01667 { 01668 return(PARS_UNSIGNED_TOKEN); 01669 } 01670 YY_BREAK 01671 case 87: 01672 YY_RULE_SETUP 01673 #line 508 "pars0lex.l" 01674 { 01675 return(PARS_EXIT_TOKEN); 01676 } 01677 YY_BREAK 01678 case 88: 01679 YY_RULE_SETUP 01680 #line 512 "pars0lex.l" 01681 { 01682 return(PARS_FUNCTION_TOKEN); 01683 } 01684 YY_BREAK 01685 case 89: 01686 YY_RULE_SETUP 01687 #line 516 "pars0lex.l" 01688 { 01689 return(PARS_LOCK_TOKEN); 01690 } 01691 YY_BREAK 01692 case 90: 01693 YY_RULE_SETUP 01694 #line 520 "pars0lex.l" 01695 { 01696 return(PARS_SHARE_TOKEN); 01697 } 01698 YY_BREAK 01699 case 91: 01700 YY_RULE_SETUP 01701 #line 524 "pars0lex.l" 01702 { 01703 return(PARS_MODE_TOKEN); 01704 } 01705 YY_BREAK 01706 case 92: 01707 YY_RULE_SETUP 01708 #line 528 "pars0lex.l" 01709 { 01710 yylval = sym_tab_add_id(pars_sym_tab_global, 01711 (byte*)yytext, 01712 ut_strlen(yytext)); 01713 return(PARS_ID_TOKEN); 01714 } 01715 YY_BREAK 01716 case 93: 01717 YY_RULE_SETUP 01718 #line 535 "pars0lex.l" 01719 { 01720 return(PARS_DDOT_TOKEN); 01721 } 01722 YY_BREAK 01723 case 94: 01724 YY_RULE_SETUP 01725 #line 539 "pars0lex.l" 01726 { 01727 return(PARS_ASSIGN_TOKEN); 01728 } 01729 YY_BREAK 01730 case 95: 01731 YY_RULE_SETUP 01732 #line 543 "pars0lex.l" 01733 { 01734 return(PARS_LE_TOKEN); 01735 } 01736 YY_BREAK 01737 case 96: 01738 YY_RULE_SETUP 01739 #line 547 "pars0lex.l" 01740 { 01741 return(PARS_GE_TOKEN); 01742 } 01743 YY_BREAK 01744 case 97: 01745 YY_RULE_SETUP 01746 #line 551 "pars0lex.l" 01747 { 01748 return(PARS_NE_TOKEN); 01749 } 01750 YY_BREAK 01751 case 98: 01752 YY_RULE_SETUP 01753 #line 555 "pars0lex.l" 01754 { 01755 01756 return((int)(*yytext)); 01757 } 01758 YY_BREAK 01759 case 99: 01760 YY_RULE_SETUP 01761 #line 560 "pars0lex.l" 01762 { 01763 01764 return((int)(*yytext)); 01765 } 01766 YY_BREAK 01767 case 100: 01768 YY_RULE_SETUP 01769 #line 565 "pars0lex.l" 01770 { 01771 01772 return((int)(*yytext)); 01773 } 01774 YY_BREAK 01775 case 101: 01776 YY_RULE_SETUP 01777 #line 570 "pars0lex.l" 01778 { 01779 01780 return((int)(*yytext)); 01781 } 01782 YY_BREAK 01783 case 102: 01784 YY_RULE_SETUP 01785 #line 575 "pars0lex.l" 01786 { 01787 01788 return((int)(*yytext)); 01789 } 01790 YY_BREAK 01791 case 103: 01792 YY_RULE_SETUP 01793 #line 580 "pars0lex.l" 01794 { 01795 01796 return((int)(*yytext)); 01797 } 01798 YY_BREAK 01799 case 104: 01800 YY_RULE_SETUP 01801 #line 585 "pars0lex.l" 01802 { 01803 01804 return((int)(*yytext)); 01805 } 01806 YY_BREAK 01807 case 105: 01808 YY_RULE_SETUP 01809 #line 590 "pars0lex.l" 01810 { 01811 01812 return((int)(*yytext)); 01813 } 01814 YY_BREAK 01815 case 106: 01816 YY_RULE_SETUP 01817 #line 595 "pars0lex.l" 01818 { 01819 01820 return((int)(*yytext)); 01821 } 01822 YY_BREAK 01823 case 107: 01824 YY_RULE_SETUP 01825 #line 600 "pars0lex.l" 01826 { 01827 01828 return((int)(*yytext)); 01829 } 01830 YY_BREAK 01831 case 108: 01832 YY_RULE_SETUP 01833 #line 605 "pars0lex.l" 01834 { 01835 01836 return((int)(*yytext)); 01837 } 01838 YY_BREAK 01839 case 109: 01840 YY_RULE_SETUP 01841 #line 610 "pars0lex.l" 01842 { 01843 01844 return((int)(*yytext)); 01845 } 01846 YY_BREAK 01847 case 110: 01848 YY_RULE_SETUP 01849 #line 615 "pars0lex.l" 01850 { 01851 01852 return((int)(*yytext)); 01853 } 01854 YY_BREAK 01855 case 111: 01856 YY_RULE_SETUP 01857 #line 620 "pars0lex.l" 01858 { 01859 01860 return((int)(*yytext)); 01861 } 01862 YY_BREAK 01863 case 112: 01864 YY_RULE_SETUP 01865 #line 625 "pars0lex.l" 01866 { 01867 01868 return((int)(*yytext)); 01869 } 01870 YY_BREAK 01871 case 113: 01872 YY_RULE_SETUP 01873 #line 630 "pars0lex.l" 01874 BEGIN(comment); /* eat up comment */ 01875 YY_BREAK 01876 case 114: 01877 /* rule 114 can match eol */ 01878 YY_RULE_SETUP 01879 #line 632 "pars0lex.l" 01880 01881 YY_BREAK 01882 case 115: 01883 /* rule 115 can match eol */ 01884 YY_RULE_SETUP 01885 #line 633 "pars0lex.l" 01886 01887 YY_BREAK 01888 case 116: 01889 YY_RULE_SETUP 01890 #line 634 "pars0lex.l" 01891 BEGIN(INITIAL); 01892 YY_BREAK 01893 case 117: 01894 /* rule 117 can match eol */ 01895 YY_RULE_SETUP 01896 #line 636 "pars0lex.l" 01897 /* eat up whitespace */ 01898 YY_BREAK 01899 case 118: 01900 YY_RULE_SETUP 01901 #line 639 "pars0lex.l" 01902 { 01903 fprintf(stderr,"Unrecognized character: %02x\n", 01904 *yytext); 01905 01906 ut_error; 01907 01908 return(0); 01909 } 01910 YY_BREAK 01911 case 119: 01912 YY_RULE_SETUP 01913 #line 648 "pars0lex.l" 01914 YY_FATAL_ERROR( "flex scanner jammed" ); 01915 YY_BREAK 01916 #line 1916 "_flex_tmp.c" 01917 case YY_STATE_EOF(INITIAL): 01918 case YY_STATE_EOF(comment): 01919 case YY_STATE_EOF(quoted): 01920 case YY_STATE_EOF(id): 01921 yyterminate(); 01922 01923 case YY_END_OF_BUFFER: 01924 { 01925 /* Amount of text matched not including the EOB char. */ 01926 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; 01927 01928 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 01929 *yy_cp = (yy_hold_char); 01930 YY_RESTORE_YY_MORE_OFFSET 01931 01932 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 01933 { 01934 /* We're scanning a new file or input source. It's 01935 * possible that this happened because the user 01936 * just pointed yyin at a new source and called 01937 * yylex(). If so, then we have to assure 01938 * consistency between YY_CURRENT_BUFFER and our 01939 * globals. Here is the right place to do so, because 01940 * this is the first action (other than possibly a 01941 * back-up) that will match for the new input source. 01942 */ 01943 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 01944 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; 01945 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 01946 } 01947 01948 /* Note that here we test for yy_c_buf_p "<=" to the position 01949 * of the first EOB in the buffer, since yy_c_buf_p will 01950 * already have been incremented past the NUL character 01951 * (since all states make transitions on EOB to the 01952 * end-of-buffer state). Contrast this with the test 01953 * in input(). 01954 */ 01955 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 01956 { /* This was really a NUL. */ 01957 yy_state_type yy_next_state; 01958 01959 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; 01960 01961 yy_current_state = yy_get_previous_state( ); 01962 01963 /* Okay, we're now positioned to make the NUL 01964 * transition. We couldn't have 01965 * yy_get_previous_state() go ahead and do it 01966 * for us because it doesn't know how to deal 01967 * with the possibility of jamming (and we don't 01968 * want to build jamming into it because then it 01969 * will run more slowly). 01970 */ 01971 01972 yy_next_state = yy_try_NUL_trans( yy_current_state ); 01973 01974 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 01975 01976 if ( yy_next_state ) 01977 { 01978 /* Consume the NUL. */ 01979 yy_cp = ++(yy_c_buf_p); 01980 yy_current_state = yy_next_state; 01981 goto yy_match; 01982 } 01983 01984 else 01985 { 01986 yy_cp = (yy_last_accepting_cpos); 01987 yy_current_state = (yy_last_accepting_state); 01988 goto yy_find_action; 01989 } 01990 } 01991 01992 else switch ( yy_get_next_buffer( ) ) 01993 { 01994 case EOB_ACT_END_OF_FILE: 01995 { 01996 (yy_did_buffer_switch_on_eof) = 0; 01997 01998 if ( yywrap( ) ) 01999 { 02000 /* Note: because we've taken care in 02001 * yy_get_next_buffer() to have set up 02002 * yytext, we can now set up 02003 * yy_c_buf_p so that if some total 02004 * hoser (like flex itself) wants to 02005 * call the scanner after we return the 02006 * YY_NULL, it'll still work - another 02007 * YY_NULL will get returned. 02008 */ 02009 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; 02010 02011 yy_act = YY_STATE_EOF(YY_START); 02012 goto do_action; 02013 } 02014 02015 else 02016 { 02017 if ( ! (yy_did_buffer_switch_on_eof) ) 02018 YY_NEW_FILE; 02019 } 02020 break; 02021 } 02022 02023 case EOB_ACT_CONTINUE_SCAN: 02024 (yy_c_buf_p) = 02025 (yytext_ptr) + yy_amount_of_matched_text; 02026 02027 yy_current_state = yy_get_previous_state( ); 02028 02029 yy_cp = (yy_c_buf_p); 02030 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 02031 goto yy_match; 02032 02033 case EOB_ACT_LAST_MATCH: 02034 (yy_c_buf_p) = 02035 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; 02036 02037 yy_current_state = yy_get_previous_state( ); 02038 02039 yy_cp = (yy_c_buf_p); 02040 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 02041 goto yy_find_action; 02042 } 02043 break; 02044 } 02045 02046 default: 02047 YY_FATAL_ERROR( 02048 "fatal flex scanner internal error--no action found" ); 02049 } /* end of action switch */ 02050 } /* end of scanning one token */ 02051 } /* end of yylex */ 02052 02053 /* yy_get_next_buffer - try to read in a new buffer 02054 * 02055 * Returns a code representing an action: 02056 * EOB_ACT_LAST_MATCH - 02057 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 02058 * EOB_ACT_END_OF_FILE - end of file 02059 */ 02060 static int yy_get_next_buffer (void) 02061 { 02062 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 02063 register char *source = (yytext_ptr); 02064 register int number_to_move, i; 02065 int ret_val; 02066 02067 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) 02068 YY_FATAL_ERROR( 02069 "fatal flex scanner internal error--end of buffer missed" ); 02070 02071 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 02072 { /* Don't try to fill the buffer, so this is an EOF. */ 02073 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) 02074 { 02075 /* We matched a single character, the EOB, so 02076 * treat this as a final EOF. 02077 */ 02078 return EOB_ACT_END_OF_FILE; 02079 } 02080 02081 else 02082 { 02083 /* We matched some text prior to the EOB, first 02084 * process it. 02085 */ 02086 return EOB_ACT_LAST_MATCH; 02087 } 02088 } 02089 02090 /* Try to read more data. */ 02091 02092 /* First move last chars to start of buffer. */ 02093 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; 02094 02095 for ( i = 0; i < number_to_move; ++i ) 02096 *(dest++) = *(source++); 02097 02098 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 02099 /* don't do the read, it's not guaranteed to return an EOF, 02100 * just force an EOF 02101 */ 02102 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; 02103 02104 else 02105 { 02106 size_t num_to_read = 02107 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 02108 02109 while ( num_to_read <= 0 ) 02110 { /* Not enough room in the buffer - grow it. */ 02111 02112 /* just a shorter name for the current buffer */ 02113 YY_BUFFER_STATE b = YY_CURRENT_BUFFER; 02114 02115 int yy_c_buf_p_offset = 02116 (int) ((yy_c_buf_p) - b->yy_ch_buf); 02117 02118 if ( b->yy_is_our_buffer ) 02119 { 02120 int new_size = b->yy_buf_size * 2; 02121 02122 if ( new_size <= 0 ) 02123 b->yy_buf_size += b->yy_buf_size / 8; 02124 else 02125 b->yy_buf_size *= 2; 02126 02127 b->yy_ch_buf = (char *) 02128 /* Include room in for 2 EOB chars. */ 02129 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); 02130 } 02131 else 02132 /* Can't grow it, we don't own it. */ 02133 b->yy_ch_buf = 0; 02134 02135 if ( ! b->yy_ch_buf ) 02136 YY_FATAL_ERROR( 02137 "fatal error - scanner input buffer overflow" ); 02138 02139 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 02140 02141 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - 02142 number_to_move - 1; 02143 02144 } 02145 02146 if ( num_to_read > YY_READ_BUF_SIZE ) 02147 num_to_read = YY_READ_BUF_SIZE; 02148 02149 /* Read in more data. */ 02150 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 02151 (yy_n_chars), num_to_read ); 02152 02153 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 02154 } 02155 02156 if ( (yy_n_chars) == 0 ) 02157 { 02158 if ( number_to_move == YY_MORE_ADJ ) 02159 { 02160 ret_val = EOB_ACT_END_OF_FILE; 02161 yyrestart(yyin ); 02162 } 02163 02164 else 02165 { 02166 ret_val = EOB_ACT_LAST_MATCH; 02167 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 02168 YY_BUFFER_EOF_PENDING; 02169 } 02170 } 02171 02172 else 02173 ret_val = EOB_ACT_CONTINUE_SCAN; 02174 02175 (yy_n_chars) += number_to_move; 02176 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; 02177 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; 02178 02179 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 02180 02181 return ret_val; 02182 } 02183 02184 /* yy_get_previous_state - get the state just before the EOB char was reached */ 02185 02186 static yy_state_type yy_get_previous_state (void) 02187 { 02188 register yy_state_type yy_current_state; 02189 register char *yy_cp; 02190 02191 yy_current_state = (yy_start); 02192 02193 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) 02194 { 02195 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 02196 if ( yy_accept[yy_current_state] ) 02197 { 02198 (yy_last_accepting_state) = yy_current_state; 02199 (yy_last_accepting_cpos) = yy_cp; 02200 } 02201 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 02202 { 02203 yy_current_state = (int) yy_def[yy_current_state]; 02204 if ( yy_current_state >= 399 ) 02205 yy_c = yy_meta[(unsigned int) yy_c]; 02206 } 02207 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 02208 } 02209 02210 return yy_current_state; 02211 } 02212 02213 /* yy_try_NUL_trans - try to make a transition on the NUL character 02214 * 02215 * synopsis 02216 * next_state = yy_try_NUL_trans( current_state ); 02217 */ 02218 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) 02219 { 02220 register int yy_is_jam; 02221 register char *yy_cp = (yy_c_buf_p); 02222 02223 register YY_CHAR yy_c = 1; 02224 if ( yy_accept[yy_current_state] ) 02225 { 02226 (yy_last_accepting_state) = yy_current_state; 02227 (yy_last_accepting_cpos) = yy_cp; 02228 } 02229 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 02230 { 02231 yy_current_state = (int) yy_def[yy_current_state]; 02232 if ( yy_current_state >= 399 ) 02233 yy_c = yy_meta[(unsigned int) yy_c]; 02234 } 02235 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 02236 yy_is_jam = (yy_current_state == 398); 02237 02238 return yy_is_jam ? 0 : yy_current_state; 02239 } 02240 02241 #ifndef YY_NO_INPUT 02242 #ifdef __cplusplus 02243 static int yyinput (void) 02244 #else 02245 static int input (void) 02246 #endif 02247 02248 { 02249 int c; 02250 02251 *(yy_c_buf_p) = (yy_hold_char); 02252 02253 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) 02254 { 02255 /* yy_c_buf_p now points to the character we want to return. 02256 * If this occurs *before* the EOB characters, then it's a 02257 * valid NUL; if not, then we've hit the end of the buffer. 02258 */ 02259 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 02260 /* This was really a NUL. */ 02261 *(yy_c_buf_p) = '\0'; 02262 02263 else 02264 { /* need more input */ 02265 int offset = (int)((yy_c_buf_p) - (yytext_ptr)); 02266 ++(yy_c_buf_p); 02267 02268 switch ( yy_get_next_buffer( ) ) 02269 { 02270 case EOB_ACT_LAST_MATCH: 02271 /* This happens because yy_g_n_b() 02272 * sees that we've accumulated a 02273 * token and flags that we need to 02274 * try matching the token before 02275 * proceeding. But for input(), 02276 * there's no matching to consider. 02277 * So convert the EOB_ACT_LAST_MATCH 02278 * to EOB_ACT_END_OF_FILE. 02279 */ 02280 02281 /* Reset buffer status. */ 02282 yyrestart(yyin ); 02283 02284 /*FALLTHROUGH*/ 02285 02286 case EOB_ACT_END_OF_FILE: 02287 { 02288 if ( yywrap( ) ) 02289 return EOF; 02290 02291 if ( ! (yy_did_buffer_switch_on_eof) ) 02292 YY_NEW_FILE; 02293 #ifdef __cplusplus 02294 return yyinput(); 02295 #else 02296 return input(); 02297 #endif 02298 } 02299 02300 case EOB_ACT_CONTINUE_SCAN: 02301 (yy_c_buf_p) = (yytext_ptr) + offset; 02302 break; 02303 } 02304 } 02305 } 02306 02307 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ 02308 *(yy_c_buf_p) = '\0'; /* preserve yytext */ 02309 (yy_hold_char) = *++(yy_c_buf_p); 02310 02311 return c; 02312 } 02313 #endif /* ifndef YY_NO_INPUT */ 02314 02320 void yyrestart (FILE * input_file ) 02321 { 02322 02323 if ( ! YY_CURRENT_BUFFER ){ 02324 yyensure_buffer_stack (); 02325 YY_CURRENT_BUFFER_LVALUE = 02326 yy_create_buffer(yyin,YY_BUF_SIZE ); 02327 } 02328 02329 yy_init_buffer(YY_CURRENT_BUFFER,input_file ); 02330 yy_load_buffer_state( ); 02331 } 02332 02337 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) 02338 { 02339 02340 /* TODO. We should be able to replace this entire function body 02341 * with 02342 * yypop_buffer_state(); 02343 * yypush_buffer_state(new_buffer); 02344 */ 02345 yyensure_buffer_stack (); 02346 if ( YY_CURRENT_BUFFER == new_buffer ) 02347 return; 02348 02349 if ( YY_CURRENT_BUFFER ) 02350 { 02351 /* Flush out information for old buffer. */ 02352 *(yy_c_buf_p) = (yy_hold_char); 02353 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 02354 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 02355 } 02356 02357 YY_CURRENT_BUFFER_LVALUE = new_buffer; 02358 yy_load_buffer_state( ); 02359 02360 /* We don't actually know whether we did this switch during 02361 * EOF (yywrap()) processing, but the only time this flag 02362 * is looked at is after yywrap() is called, so it's safe 02363 * to go ahead and always set it. 02364 */ 02365 (yy_did_buffer_switch_on_eof) = 1; 02366 } 02367 02368 static void yy_load_buffer_state (void) 02369 { 02370 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 02371 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 02372 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 02373 (yy_hold_char) = *(yy_c_buf_p); 02374 } 02375 02382 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) 02383 { 02384 YY_BUFFER_STATE b; 02385 02386 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); 02387 if ( ! b ) 02388 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 02389 02390 b->yy_buf_size = size; 02391 02392 /* yy_ch_buf has to be 2 characters longer than the size given because 02393 * we need to put in 2 end-of-buffer characters. 02394 */ 02395 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); 02396 if ( ! b->yy_ch_buf ) 02397 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 02398 02399 b->yy_is_our_buffer = 1; 02400 02401 yy_init_buffer(b,file ); 02402 02403 return b; 02404 } 02405 02410 void yy_delete_buffer (YY_BUFFER_STATE b ) 02411 { 02412 02413 if ( ! b ) 02414 return; 02415 02416 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 02417 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 02418 02419 if ( b->yy_is_our_buffer ) 02420 yyfree((void *) b->yy_ch_buf ); 02421 02422 yyfree((void *) b ); 02423 } 02424 02425 /* Initializes or reinitializes a buffer. 02426 * This function is sometimes called more than once on the same buffer, 02427 * such as during a yyrestart() or at EOF. 02428 */ 02429 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) 02430 02431 { 02432 int oerrno = errno; 02433 02434 yy_flush_buffer(b ); 02435 02436 b->yy_input_file = file; 02437 b->yy_fill_buffer = 1; 02438 02439 /* If b is the current buffer, then yy_init_buffer was _probably_ 02440 * called from yyrestart() or through yy_get_next_buffer. 02441 * In that case, we don't want to reset the lineno or column. 02442 */ 02443 if (b != YY_CURRENT_BUFFER){ 02444 b->yy_bs_lineno = 1; 02445 b->yy_bs_column = 0; 02446 } 02447 02448 b->yy_is_interactive = 0; 02449 02450 errno = oerrno; 02451 } 02452 02457 void yy_flush_buffer (YY_BUFFER_STATE b ) 02458 { 02459 if ( ! b ) 02460 return; 02461 02462 b->yy_n_chars = 0; 02463 02464 /* We always need two end-of-buffer characters. The first causes 02465 * a transition to the end-of-buffer state. The second causes 02466 * a jam in that state. 02467 */ 02468 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 02469 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 02470 02471 b->yy_buf_pos = &b->yy_ch_buf[0]; 02472 02473 b->yy_at_bol = 1; 02474 b->yy_buffer_status = YY_BUFFER_NEW; 02475 02476 if ( b == YY_CURRENT_BUFFER ) 02477 yy_load_buffer_state( ); 02478 } 02479 02486 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) 02487 { 02488 if (new_buffer == NULL) 02489 return; 02490 02491 yyensure_buffer_stack(); 02492 02493 /* This block is copied from yy_switch_to_buffer. */ 02494 if ( YY_CURRENT_BUFFER ) 02495 { 02496 /* Flush out information for old buffer. */ 02497 *(yy_c_buf_p) = (yy_hold_char); 02498 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 02499 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 02500 } 02501 02502 /* Only push if top exists. Otherwise, replace top. */ 02503 if (YY_CURRENT_BUFFER) 02504 (yy_buffer_stack_top)++; 02505 YY_CURRENT_BUFFER_LVALUE = new_buffer; 02506 02507 /* copied from yy_switch_to_buffer. */ 02508 yy_load_buffer_state( ); 02509 (yy_did_buffer_switch_on_eof) = 1; 02510 } 02511 02516 void yypop_buffer_state (void) 02517 { 02518 if (!YY_CURRENT_BUFFER) 02519 return; 02520 02521 yy_delete_buffer(YY_CURRENT_BUFFER ); 02522 YY_CURRENT_BUFFER_LVALUE = NULL; 02523 if ((yy_buffer_stack_top) > 0) 02524 --(yy_buffer_stack_top); 02525 02526 if (YY_CURRENT_BUFFER) { 02527 yy_load_buffer_state( ); 02528 (yy_did_buffer_switch_on_eof) = 1; 02529 } 02530 } 02531 02532 /* Allocates the stack if it does not exist. 02533 * Guarantees space for at least one push. 02534 */ 02535 static void yyensure_buffer_stack (void) 02536 { 02537 int num_to_alloc; 02538 02539 if (!(yy_buffer_stack)) { 02540 02541 /* First allocation is just for 2 elements, since we don't know if this 02542 * scanner will even need a stack. We use 2 instead of 1 to avoid an 02543 * immediate realloc on the next call. 02544 */ 02545 num_to_alloc = 1; 02546 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc 02547 (num_to_alloc * sizeof(struct yy_buffer_state*) 02548 ); 02549 02550 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 02551 02552 (yy_buffer_stack_max) = num_to_alloc; 02553 (yy_buffer_stack_top) = 0; 02554 return; 02555 } 02556 02557 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ 02558 02559 /* Increase the buffer to prepare for a possible push. */ 02560 int grow_size = 8 /* arbitrary grow size */; 02561 02562 num_to_alloc = (yy_buffer_stack_max) + grow_size; 02563 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc 02564 ((yy_buffer_stack), 02565 num_to_alloc * sizeof(struct yy_buffer_state*) 02566 ); 02567 02568 /* zero only the new slots.*/ 02569 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 02570 (yy_buffer_stack_max) = num_to_alloc; 02571 } 02572 } 02573 02574 #ifndef YY_EXIT_FAILURE 02575 #define YY_EXIT_FAILURE 2 02576 #endif 02577 02578 static void yy_fatal_error (yyconst char* msg ) 02579 { 02580 (void) fprintf( stderr, "%s\n", msg ); 02581 exit( YY_EXIT_FAILURE ); 02582 } 02583 02584 /* Redefine yyless() so it works in section 3 code. */ 02585 02586 #undef yyless 02587 #define yyless(n) \ 02588 do \ 02589 { \ 02590 /* Undo effects of setting up yytext. */ \ 02591 int yyless_macro_arg = (n); \ 02592 YY_LESS_LINENO(yyless_macro_arg);\ 02593 yytext[yyleng] = (yy_hold_char); \ 02594 (yy_c_buf_p) = yytext + yyless_macro_arg; \ 02595 (yy_hold_char) = *(yy_c_buf_p); \ 02596 *(yy_c_buf_p) = '\0'; \ 02597 yyleng = yyless_macro_arg; \ 02598 } \ 02599 while ( 0 ) 02600 02601 /* Accessor methods (get/set functions) to struct members. */ 02602 02606 int yyget_lineno (void) 02607 { 02608 02609 return yylineno; 02610 } 02611 02615 FILE *yyget_in (void) 02616 { 02617 return yyin; 02618 } 02619 02623 FILE *yyget_out (void) 02624 { 02625 return yyout; 02626 } 02627 02631 int yyget_leng (void) 02632 { 02633 return yyleng; 02634 } 02635 02640 char *yyget_text (void) 02641 { 02642 return yytext; 02643 } 02644 02649 void yyset_lineno (int line_number ) 02650 { 02651 02652 yylineno = line_number; 02653 } 02654 02661 void yyset_in (FILE * in_str ) 02662 { 02663 yyin = in_str ; 02664 } 02665 02666 void yyset_out (FILE * out_str ) 02667 { 02668 yyout = out_str ; 02669 } 02670 02671 int yyget_debug (void) 02672 { 02673 return yy_flex_debug; 02674 } 02675 02676 void yyset_debug (int bdebug ) 02677 { 02678 yy_flex_debug = bdebug ; 02679 } 02680 02681 /* yylex_destroy is for both reentrant and non-reentrant scanners. */ 02682 int yylex_destroy (void) 02683 { 02684 02685 /* Pop the buffer stack, destroying each element. */ 02686 while(YY_CURRENT_BUFFER){ 02687 yy_delete_buffer(YY_CURRENT_BUFFER ); 02688 YY_CURRENT_BUFFER_LVALUE = NULL; 02689 yypop_buffer_state(); 02690 } 02691 02692 /* Destroy the stack itself. */ 02693 yyfree((yy_buffer_stack) ); 02694 (yy_buffer_stack) = NULL; 02695 02696 return 0; 02697 } 02698 02699 /* 02700 * Internal utility routines. 02701 */ 02702 02703 #ifndef yytext_ptr 02704 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) 02705 { 02706 register int i; 02707 for ( i = 0; i < n; ++i ) 02708 s1[i] = s2[i]; 02709 } 02710 #endif 02711 02712 #ifdef YY_NEED_STRLEN 02713 static int yy_flex_strlen (yyconst char * s ) 02714 { 02715 register int n; 02716 for ( n = 0; s[n]; ++n ) 02717 ; 02718 02719 return n; 02720 } 02721 #endif 02722 02723 void *yyalloc (yy_size_t size ) 02724 { 02725 return (void *) malloc( size ); 02726 } 02727 02728 void *yyrealloc (void * ptr, yy_size_t size ) 02729 { 02730 /* The cast to (char *) in the following accommodates both 02731 * implementations that use char* generic pointers, and those 02732 * that use void* generic pointers. It works with the latter 02733 * because both ANSI C and C++ allow castless assignment from 02734 * any pointer type to void*, and deal with argument conversions 02735 * as though doing an assignment. 02736 */ 02737 return (void *) realloc( (char *) ptr, size ); 02738 } 02739 02740 void yyfree (void * ptr ) 02741 { 02742 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 02743 } 02744 02745 #define YYTABLES_NAME "yytables" 02746 02747 #undef YY_NEW_FILE 02748 #undef YY_FLUSH_BUFFER 02749 #undef yy_set_bol 02750 #undef yy_new_buffer 02751 #undef yy_set_interactive 02752 #undef yytext_ptr 02753 #undef YY_DO_BEFORE_ACTION 02754 02755 #ifdef YY_DECL_IS_OURS 02756 #undef YY_DECL_IS_OURS 02757 #undef YY_DECL 02758 #endif 02759 #line 648 "pars0lex.l" 02760 02761 02762
Generated on Sat Sep 9 00:50:28 2006 for MySQL 5.1 by
1.4.7
© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.