|
GDB (API)
|
|
GDB (API)
|
00001 #line 2 "ada-lex.c" 00002 00003 #line 4 "ada-lex.c" 00004 00005 #define YY_INT_ALIGNED short int 00006 00007 /* A lexical scanner generated by flex */ 00008 00009 #define FLEX_SCANNER 00010 #define YY_FLEX_MAJOR_VERSION 2 00011 #define YY_FLEX_MINOR_VERSION 5 00012 #define YY_FLEX_SUBMINOR_VERSION 35 00013 #if YY_FLEX_SUBMINOR_VERSION > 0 00014 #define FLEX_BETA 00015 #endif 00016 00017 /* First, we deal with platform-specific or compiler-specific issues. */ 00018 00019 /* begin standard C headers. */ 00020 #include <stdio.h> 00021 #include <string.h> 00022 #include <errno.h> 00023 #include <stdlib.h> 00024 00025 /* end standard C headers. */ 00026 00027 /* flex integer type definitions */ 00028 00029 #ifndef FLEXINT_H 00030 #define FLEXINT_H 00031 00032 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ 00033 00034 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 00035 00036 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, 00037 * if you want the limit (max/min) macros for int types. 00038 */ 00039 #ifndef __STDC_LIMIT_MACROS 00040 #define __STDC_LIMIT_MACROS 1 00041 #endif 00042 00043 #include <inttypes.h> 00044 typedef int8_t flex_int8_t; 00045 typedef uint8_t flex_uint8_t; 00046 typedef int16_t flex_int16_t; 00047 typedef uint16_t flex_uint16_t; 00048 typedef int32_t flex_int32_t; 00049 typedef uint32_t flex_uint32_t; 00050 #else 00051 typedef signed char flex_int8_t; 00052 typedef short int flex_int16_t; 00053 typedef int flex_int32_t; 00054 typedef unsigned char flex_uint8_t; 00055 typedef unsigned short int flex_uint16_t; 00056 typedef unsigned int flex_uint32_t; 00057 00058 /* Limits of integral types. */ 00059 #ifndef INT8_MIN 00060 #define INT8_MIN (-128) 00061 #endif 00062 #ifndef INT16_MIN 00063 #define INT16_MIN (-32767-1) 00064 #endif 00065 #ifndef INT32_MIN 00066 #define INT32_MIN (-2147483647-1) 00067 #endif 00068 #ifndef INT8_MAX 00069 #define INT8_MAX (127) 00070 #endif 00071 #ifndef INT16_MAX 00072 #define INT16_MAX (32767) 00073 #endif 00074 #ifndef INT32_MAX 00075 #define INT32_MAX (2147483647) 00076 #endif 00077 #ifndef UINT8_MAX 00078 #define UINT8_MAX (255U) 00079 #endif 00080 #ifndef UINT16_MAX 00081 #define UINT16_MAX (65535U) 00082 #endif 00083 #ifndef UINT32_MAX 00084 #define UINT32_MAX (4294967295U) 00085 #endif 00086 00087 #endif /* ! C99 */ 00088 00089 #endif /* ! FLEXINT_H */ 00090 00091 #ifdef __cplusplus 00092 00093 /* The "const" storage-class-modifier is valid. */ 00094 #define YY_USE_CONST 00095 00096 #else /* ! __cplusplus */ 00097 00098 /* C99 requires __STDC__ to be defined as 1. */ 00099 #if defined (__STDC__) 00100 00101 #define YY_USE_CONST 00102 00103 #endif /* defined (__STDC__) */ 00104 #endif /* ! __cplusplus */ 00105 00106 #ifdef YY_USE_CONST 00107 #define yyconst const 00108 #else 00109 #define yyconst 00110 #endif 00111 00112 /* Returned upon end-of-file. */ 00113 #define YY_NULL 0 00114 00115 /* Promotes a possibly negative, possibly signed char to an unsigned 00116 * integer for use as an array index. If the signed char is negative, 00117 * we want to instead treat it as an 8-bit unsigned char, hence the 00118 * double cast. 00119 */ 00120 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 00121 00122 /* Enter a start condition. This macro really ought to take a parameter, 00123 * but we do it the disgusting crufty way forced on us by the ()-less 00124 * definition of BEGIN. 00125 */ 00126 #define BEGIN (yy_start) = 1 + 2 * 00127 00128 /* Translate the current start state into a value that can be later handed 00129 * to BEGIN to return to the state. The YYSTATE alias is for lex 00130 * compatibility. 00131 */ 00132 #define YY_START (((yy_start) - 1) / 2) 00133 #define YYSTATE YY_START 00134 00135 /* Action number for EOF rule of a given start state. */ 00136 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 00137 00138 /* Special action meaning "start processing a new file". */ 00139 #define YY_NEW_FILE yyrestart(yyin ) 00140 00141 #define YY_END_OF_BUFFER_CHAR 0 00142 00143 /* Size of default input buffer. */ 00144 #ifndef YY_BUF_SIZE 00145 #ifdef __ia64__ 00146 /* On IA-64, the buffer size is 16k, not 8k. 00147 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. 00148 * Ditto for the __ia64__ case accordingly. 00149 */ 00150 #define YY_BUF_SIZE 32768 00151 #else 00152 #define YY_BUF_SIZE 16384 00153 #endif /* __ia64__ */ 00154 #endif 00155 00156 /* The state buf must be large enough to hold one state per character in the main buffer. 00157 */ 00158 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 00159 00160 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 00161 #define YY_TYPEDEF_YY_BUFFER_STATE 00162 typedef struct yy_buffer_state *YY_BUFFER_STATE; 00163 #endif 00164 00165 extern int yyleng; 00166 00167 extern FILE *yyin, *yyout; 00168 00169 #define EOB_ACT_CONTINUE_SCAN 0 00170 #define EOB_ACT_END_OF_FILE 1 00171 #define EOB_ACT_LAST_MATCH 2 00172 00173 #define YY_LESS_LINENO(n) 00174 00175 /* Return all but the first "n" matched characters back to the input stream. */ 00176 #define yyless(n) \ 00177 do \ 00178 { \ 00179 /* Undo effects of setting up yytext. */ \ 00180 int yyless_macro_arg = (n); \ 00181 YY_LESS_LINENO(yyless_macro_arg);\ 00182 *yy_cp = (yy_hold_char); \ 00183 YY_RESTORE_YY_MORE_OFFSET \ 00184 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 00185 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 00186 } \ 00187 while ( 0 ) 00188 00189 #define unput(c) yyunput( c, (yytext_ptr) ) 00190 00191 #ifndef YY_TYPEDEF_YY_SIZE_T 00192 #define YY_TYPEDEF_YY_SIZE_T 00193 typedef size_t yy_size_t; 00194 #endif 00195 00196 #ifndef YY_STRUCT_YY_BUFFER_STATE 00197 #define YY_STRUCT_YY_BUFFER_STATE 00198 struct yy_buffer_state 00199 { 00200 FILE *yy_input_file; 00201 00202 char *yy_ch_buf; /* input buffer */ 00203 char *yy_buf_pos; /* current position in input buffer */ 00204 00205 /* Size of input buffer in bytes, not including room for EOB 00206 * characters. 00207 */ 00208 yy_size_t yy_buf_size; 00209 00210 /* Number of characters read into yy_ch_buf, not including EOB 00211 * characters. 00212 */ 00213 int yy_n_chars; 00214 00215 /* Whether we "own" the buffer - i.e., we know we created it, 00216 * and can xrealloc() it to grow it, and should xfree() it to 00217 * delete it. 00218 */ 00219 int yy_is_our_buffer; 00220 00221 /* Whether this is an "interactive" input source; if so, and 00222 * if we're using stdio for input, then we want to use getc() 00223 * instead of fread(), to make sure we stop fetching input after 00224 * each newline. 00225 */ 00226 int yy_is_interactive; 00227 00228 /* Whether we're considered to be at the beginning of a line. 00229 * If so, '^' rules will be active on the next match, otherwise 00230 * not. 00231 */ 00232 int yy_at_bol; 00233 00234 int yy_bs_lineno; 00235 int yy_bs_column; 00237 /* Whether to try to fill the input buffer when we reach the 00238 * end of it. 00239 */ 00240 int yy_fill_buffer; 00241 00242 int yy_buffer_status; 00243 00244 #define YY_BUFFER_NEW 0 00245 #define YY_BUFFER_NORMAL 1 00246 /* When an EOF's been seen but there's still some text to process 00247 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 00248 * shouldn't try reading from the input source any more. We might 00249 * still have a bunch of tokens to match, though, because of 00250 * possible backing-up. 00251 * 00252 * When we actually see the EOF, we change the status to "new" 00253 * (via yyrestart()), so that the user can continue scanning by 00254 * just pointing yyin at a new input file. 00255 */ 00256 #define YY_BUFFER_EOF_PENDING 2 00257 00258 }; 00259 #endif /* !YY_STRUCT_YY_BUFFER_STATE */ 00260 00261 /* Stack of input buffers. */ 00262 static size_t yy_buffer_stack_top = 0; 00263 static size_t yy_buffer_stack_max = 0; 00264 static YY_BUFFER_STATE * yy_buffer_stack = 0; 00266 /* We provide macros for accessing buffer states in case in the 00267 * future we want to put the buffer states in a more general 00268 * "scanner state". 00269 * 00270 * Returns the top of the stack, or NULL. 00271 */ 00272 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 00273 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 00274 : NULL) 00275 00276 /* Same as previous macro, but useful when we know that the buffer stack is not 00277 * NULL or when we need an lvalue. For internal use only. 00278 */ 00279 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 00280 00281 /* yy_hold_char holds the character lost when yytext is formed. */ 00282 static char yy_hold_char; 00283 static int yy_n_chars; /* number of characters read into yy_ch_buf */ 00284 int yyleng; 00285 00286 /* Points to current character in buffer. */ 00287 static char *yy_c_buf_p = (char *) 0; 00288 static int yy_init = 0; /* whether we need to initialize */ 00289 static int yy_start = 0; /* start state number */ 00290 00291 /* Flag which is used to allow yywrap()'s to do buffer switches 00292 * instead of setting up a fresh yyin. A bit of a hack ... 00293 */ 00294 static int yy_did_buffer_switch_on_eof; 00295 00296 void yyrestart (FILE *input_file ); 00297 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); 00298 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); 00299 void yy_delete_buffer (YY_BUFFER_STATE b ); 00300 void yy_flush_buffer (YY_BUFFER_STATE b ); 00301 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); 00302 void yypop_buffer_state (void ); 00303 00304 static void yyensure_buffer_stack (void ); 00305 static void yy_load_buffer_state (void ); 00306 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); 00307 00308 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) 00309 00310 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); 00311 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); 00312 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ); 00313 00314 void *yyalloc (yy_size_t ); 00315 void *yyxrealloc (void *,yy_size_t ); 00316 void yyfree (void * ); 00317 00318 #define yy_new_buffer yy_create_buffer 00319 00320 #define yy_set_interactive(is_interactive) \ 00321 { \ 00322 if ( ! YY_CURRENT_BUFFER ){ \ 00323 yyensure_buffer_stack (); \ 00324 YY_CURRENT_BUFFER_LVALUE = \ 00325 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 00326 } \ 00327 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 00328 } 00329 00330 #define yy_set_bol(at_bol) \ 00331 { \ 00332 if ( ! YY_CURRENT_BUFFER ){\ 00333 yyensure_buffer_stack (); \ 00334 YY_CURRENT_BUFFER_LVALUE = \ 00335 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 00336 } \ 00337 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 00338 } 00339 00340 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 00341 00342 /* Begin user sect3 */ 00343 00344 typedef unsigned char YY_CHAR; 00345 00346 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 00347 00348 typedef int yy_state_type; 00349 00350 extern int yylineno; 00351 00352 int yylineno = 1; 00353 00354 extern char *yytext; 00355 #define yytext_ptr yytext 00356 00357 static yy_state_type yy_get_previous_state (void ); 00358 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); 00359 static int yy_get_next_buffer (void ); 00360 static void yy_fatal_error (yyconst char msg[] ); 00361 00362 /* Done after the current pattern has been matched and before the 00363 * corresponding action - sets up yytext. 00364 */ 00365 #define YY_DO_BEFORE_ACTION \ 00366 (yytext_ptr) = yy_bp; \ 00367 yyleng = (size_t) (yy_cp - yy_bp); \ 00368 (yy_hold_char) = *yy_cp; \ 00369 *yy_cp = '\0'; \ 00370 (yy_c_buf_p) = yy_cp; 00371 00372 #define YY_NUM_RULES 55 00373 #define YY_END_OF_BUFFER 56 00374 /* This struct is not used in this scanner, 00375 but its presence is necessary. */ 00376 struct yy_trans_info 00377 { 00378 flex_int32_t yy_verify; 00379 flex_int32_t yy_nxt; 00380 }; 00381 static yyconst flex_int16_t yy_accept[207] = 00382 { 0, 00383 0, 0, 0, 0, 56, 54, 1, 1, 15, 53, 00384 43, 54, 45, 46, 43, 44, 43, 43, 43, 4, 00385 4, 43, 43, 43, 43, 52, 49, 49, 49, 49, 00386 49, 49, 49, 49, 49, 49, 49, 42, 0, 14, 00387 0, 53, 0, 0, 0, 0, 0, 0, 0, 37, 00388 2, 0, 36, 0, 48, 48, 39, 0, 0, 4, 00389 0, 0, 51, 38, 40, 0, 35, 41, 0, 0, 00390 49, 0, 49, 49, 49, 49, 49, 16, 22, 49, 00391 49, 49, 49, 27, 49, 49, 49, 49, 49, 49, 00392 0, 14, 0, 12, 12, 34, 0, 2, 0, 48, 00393 00394 48, 0, 9, 0, 3, 7, 0, 49, 0, 0, 00395 0, 49, 19, 20, 49, 49, 23, 24, 25, 49, 00396 49, 29, 49, 49, 49, 49, 31, 0, 0, 0, 00397 0, 0, 0, 48, 47, 6, 0, 0, 9, 0, 00398 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00399 0, 0, 0, 49, 21, 49, 26, 49, 17, 30, 00400 49, 32, 0, 50, 0, 0, 0, 0, 49, 0, 00401 0, 0, 0, 0, 0, 0, 0, 33, 49, 49, 00402 0, 0, 5, 11, 0, 8, 0, 0, 0, 0, 00403 0, 0, 28, 49, 0, 5, 0, 8, 0, 0, 00404 00405 13, 0, 18, 10, 10, 0 00406 } ; 00407 00408 static yyconst flex_int32_t yy_ec[256] = 00409 { 0, 00410 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 00411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00412 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00413 1, 4, 5, 6, 7, 8, 5, 9, 10, 11, 00414 12, 13, 14, 15, 16, 17, 18, 19, 20, 20, 00415 20, 20, 20, 20, 20, 20, 20, 21, 22, 23, 00416 24, 25, 5, 26, 27, 28, 29, 30, 31, 32, 00417 33, 34, 35, 33, 36, 37, 38, 39, 40, 33, 00418 33, 41, 42, 43, 44, 33, 45, 46, 33, 33, 00419 47, 5, 48, 5, 49, 5, 50, 51, 29, 52, 00420 00421 53, 54, 33, 55, 56, 33, 57, 58, 59, 60, 00422 61, 33, 33, 62, 63, 64, 65, 33, 66, 67, 00423 33, 33, 26, 22, 26, 5, 1, 1, 1, 1, 00424 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00425 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00426 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00427 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00428 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00429 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00430 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00431 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 00438 } ; 00439 00440 static yyconst flex_int32_t yy_meta[68] = 00441 { 0, 00442 1, 2, 3, 4, 5, 6, 7, 8, 5, 9, 00443 5, 5, 5, 5, 5, 5, 10, 5, 11, 11, 00444 5, 5, 12, 13, 14, 5, 15, 15, 15, 15, 00445 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 00446 16, 16, 16, 16, 16, 16, 5, 5, 17, 15, 00447 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 00448 16, 16, 16, 16, 16, 16, 16 00449 } ; 00450 00451 static yyconst flex_int16_t yy_base[229] = 00452 { 0, 00453 0, 0, 649, 638, 646, 1252, 1252, 1252, 62, 0, 00454 1252, 109, 1252, 1252, 623, 1252, 619, 175, 606, 174, 00455 180, 48, 604, 592, 590, 1252, 204, 71, 214, 186, 00456 235, 244, 304, 256, 39, 368, 40, 430, 179, 1252, 00457 195, 0, 602, 595, 592, 585, 574, 497, 72, 1252, 00458 0, 273, 1252, 0, 39, 0, 1252, 0, 66, 262, 00459 75, 0, 1252, 1252, 1252, 557, 1252, 1252, 284, 300, 00460 1252, 322, 329, 349, 358, 377, 339, 396, 412, 563, 00461 566, 575, 584, 587, 569, 596, 623, 616, 576, 617, 00462 571, 568, 334, 380, 1252, 562, 677, 0, 403, 0, 00463 00464 40, 89, 642, 71, 163, 0, 401, 672, 401, 723, 00465 0, 708, 741, 750, 637, 776, 785, 794, 797, 806, 00466 775, 827, 831, 843, 818, 819, 883, 415, 0, 712, 00467 399, 885, 352, 1252, 0, 191, 0, 202, 772, 170, 00468 243, 334, 222, 244, 247, 259, 766, 47, 209, 216, 00469 203, 251, 302, 892, 916, 890, 942, 715, 946, 958, 00470 930, 974, 274, 1252, 93, 344, 278, 310, 979, 256, 00471 264, 337, 270, 274, 352, 355, 215, 984, 995, 1000, 00472 299, 354, 589, 355, 223, 603, 209, 204, 198, 189, 00473 174, 101, 1004, 1016, 92, 634, 411, 644, 872, 1021, 00474 00475 717, 373, 1252, 793, 832, 1252, 1055, 1065, 1081, 1086, 00476 1102, 1119, 1136, 1139, 1146, 339, 560, 1153, 1169, 1181, 00477 1186, 1197, 1200, 1216, 634, 645, 1223, 1234 00478 } ; 00479 00480 static yyconst flex_int16_t yy_def[229] = 00481 { 0, 00482 206, 1, 1, 1, 206, 206, 206, 206, 207, 208, 00483 206, 206, 206, 206, 206, 206, 206, 209, 206, 206, 00484 206, 206, 210, 206, 206, 206, 211, 211, 211, 211, 00485 211, 211, 211, 211, 33, 211, 33, 206, 207, 206, 00486 207, 208, 212, 38, 38, 212, 206, 206, 212, 206, 00487 213, 209, 206, 214, 215, 215, 206, 216, 206, 206, 00488 206, 217, 206, 206, 206, 218, 206, 206, 206, 206, 00489 206, 219, 211, 211, 211, 211, 211, 211, 211, 211, 00490 211, 211, 211, 211, 36, 211, 211, 36, 33, 36, 00491 48, 220, 206, 206, 206, 48, 212, 213, 221, 215, 00492 00493 215, 222, 206, 206, 206, 217, 218, 206, 219, 206, 00494 223, 224, 211, 211, 33, 211, 211, 211, 211, 211, 00495 33, 211, 211, 211, 33, 33, 211, 206, 225, 206, 00496 206, 97, 221, 206, 215, 206, 226, 222, 206, 206, 00497 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00498 206, 206, 227, 224, 211, 33, 211, 36, 211, 211, 00499 36, 211, 206, 206, 212, 206, 228, 206, 206, 206, 00500 206, 206, 206, 206, 206, 206, 227, 211, 211, 211, 00501 212, 206, 206, 206, 228, 206, 206, 206, 206, 206, 00502 206, 206, 211, 211, 212, 206, 206, 206, 206, 206, 00503 00504 206, 206, 206, 206, 206, 0, 206, 206, 206, 206, 00505 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00506 206, 206, 206, 206, 206, 206, 206, 206 00507 } ; 00508 00509 static yyconst flex_int16_t yy_nxt[1320] = 00510 { 0, 00511 6, 7, 8, 7, 6, 9, 6, 10, 11, 12, 00512 13, 14, 15, 11, 16, 17, 18, 19, 20, 21, 00513 22, 11, 23, 24, 25, 26, 27, 28, 28, 28, 00514 29, 30, 28, 28, 31, 28, 28, 32, 33, 34, 00515 35, 28, 36, 28, 28, 37, 11, 11, 28, 27, 00516 28, 28, 29, 30, 28, 31, 28, 28, 32, 33, 00517 34, 35, 28, 36, 28, 28, 37, 40, 63, 86, 00518 73, 64, 69, 69, 70, 101, 135, 97, 73, 90, 00519 71, 94, 73, 73, 103, 103, 172, 72, 104, 105, 00520 105, 86, 73, 105, 105, 136, 101, 135, 181, 73, 00521 00522 90, 201, 93, 73, 73, 137, 169, 172, 41, 43, 00523 44, 44, 45, 46, 46, 46, 46, 46, 47, 46, 00524 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 00525 46, 46, 46, 46, 46, 48, 48, 48, 48, 48, 00526 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 00527 48, 48, 48, 48, 48, 49, 46, 46, 48, 48, 00528 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 00529 48, 48, 48, 48, 48, 48, 52, 52, 52, 169, 00530 58, 141, 141, 168, 40, 168, 58, 69, 69, 70, 00531 59, 53, 60, 60, 169, 71, 59, 54, 60, 60, 00532 00533 92, 55, 72, 169, 61, 69, 69, 70, 136, 169, 00534 61, 141, 77, 71, 169, 69, 69, 70, 137, 62, 00535 72, 166, 60, 71, 55, 41, 61, 169, 60, 184, 00536 72, 74, 61, 175, 142, 77, 69, 69, 70, 169, 00537 62, 41, 75, 166, 71, 69, 69, 70, 173, 169, 00538 76, 72, 169, 71, 74, 175, 174, 69, 69, 70, 00539 72, 141, 141, 75, 169, 71, 78, 142, 58, 173, 00540 142, 76, 72, 79, 52, 52, 52, 174, 59, 169, 00541 60, 60, 142, 80, 184, 69, 69, 69, 78, 206, 00542 176, 141, 61, 188, 79, 54, 84, 187, 85, 55, 00543 00544 72, 69, 69, 70, 80, 69, 69, 70, 93, 71, 00545 60, 176, 190, 71, 61, 188, 72, 84, 187, 85, 00546 72, 39, 55, 109, 109, 109, 169, 110, 186, 186, 00547 69, 69, 70, 190, 81, 130, 130, 130, 71, 169, 00548 69, 69, 70, 82, 111, 72, 195, 83, 71, 102, 00549 69, 69, 70, 102, 131, 72, 81, 182, 71, 69, 00550 69, 70, 183, 183, 82, 72, 189, 71, 83, 69, 00551 69, 70, 183, 183, 72, 116, 134, 71, 69, 69, 00552 70, 130, 130, 130, 72, 197, 71, 114, 189, 191, 00553 113, 204, 204, 72, 87, 192, 116, 69, 69, 70, 00554 00555 131, 88, 109, 109, 109, 71, 110, 197, 89, 114, 00556 191, 113, 72, 69, 69, 70, 192, 87, 115, 164, 00557 163, 71, 88, 111, 202, 108, 202, 134, 72, 89, 00558 43, 44, 44, 44, 43, 43, 43, 43, 43, 115, 00559 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 00560 43, 43, 43, 43, 43, 43, 91, 91, 91, 91, 00561 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 00562 91, 91, 91, 91, 91, 91, 43, 43, 43, 91, 00563 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 00564 91, 91, 91, 91, 91, 91, 91, 43, 43, 43, 00565 00566 43, 43, 43, 43, 43, 43, 94, 43, 43, 43, 00567 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 00568 43, 43, 43, 96, 96, 96, 96, 96, 96, 96, 00569 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 00570 96, 96, 96, 43, 43, 43, 96, 96, 96, 96, 00571 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 00572 96, 96, 96, 96, 69, 69, 70, 69, 69, 70, 00573 106, 93, 71, 128, 106, 71, 69, 69, 70, 72, 00574 93, 108, 72, 95, 71, 69, 69, 70, 69, 69, 00575 70, 72, 117, 71, 94, 73, 71, 69, 69, 70, 00576 00577 72, 94, 121, 72, 93, 71, 73, 196, 196, 73, 00578 118, 93, 72, 68, 117, 73, 67, 119, 73, 126, 00579 120, 198, 198, 121, 69, 69, 70, 65, 73, 57, 00580 73, 118, 71, 122, 51, 50, 73, 196, 119, 72, 00581 126, 120, 73, 73, 128, 206, 124, 38, 128, 73, 00582 73, 198, 196, 196, 122, 167, 125, 127, 38, 167, 00583 139, 139, 198, 198, 123, 73, 73, 155, 124, 206, 00584 73, 73, 140, 69, 69, 70, 73, 125, 127, 206, 00585 73, 71, 196, 206, 206, 123, 93, 206, 72, 155, 00586 139, 206, 198, 206, 140, 132, 132, 73, 206, 206, 00587 00588 206, 73, 206, 132, 132, 132, 132, 132, 132, 69, 00589 69, 70, 206, 130, 130, 130, 206, 71, 130, 130, 00590 130, 206, 206, 206, 72, 206, 132, 132, 132, 132, 00591 132, 142, 131, 206, 206, 143, 142, 131, 142, 206, 00592 144, 73, 69, 69, 70, 145, 142, 146, 73, 147, 00593 71, 69, 69, 70, 206, 179, 206, 72, 206, 71, 00594 148, 149, 150, 151, 73, 206, 72, 206, 152, 73, 00595 206, 206, 147, 206, 206, 206, 179, 69, 69, 70, 00596 206, 148, 149, 150, 151, 71, 69, 69, 70, 152, 00597 139, 139, 72, 170, 71, 69, 69, 70, 69, 69, 00598 00599 70, 72, 140, 71, 171, 158, 71, 69, 69, 70, 00600 72, 205, 205, 72, 73, 71, 170, 156, 73, 206, 00601 139, 206, 72, 206, 140, 171, 206, 158, 69, 69, 00602 70, 206, 69, 69, 70, 73, 71, 206, 156, 73, 00603 71, 205, 157, 72, 69, 69, 70, 72, 161, 162, 00604 205, 205, 71, 206, 206, 206, 206, 73, 73, 72, 00605 206, 73, 73, 157, 206, 206, 159, 206, 206, 206, 00606 161, 162, 206, 199, 199, 199, 206, 206, 73, 73, 00607 205, 160, 73, 73, 69, 69, 70, 159, 72, 206, 00608 203, 203, 71, 69, 69, 70, 206, 206, 206, 72, 00609 00610 206, 71, 160, 165, 165, 206, 206, 206, 72, 206, 00611 206, 165, 165, 165, 165, 165, 165, 69, 69, 70, 00612 178, 206, 206, 206, 206, 71, 206, 206, 206, 73, 00613 206, 206, 72, 73, 165, 165, 165, 165, 165, 206, 00614 206, 206, 178, 69, 69, 70, 206, 69, 69, 70, 00615 73, 71, 206, 206, 73, 71, 180, 206, 72, 69, 00616 69, 70, 72, 73, 206, 206, 206, 71, 206, 206, 00617 73, 206, 206, 206, 72, 69, 69, 70, 206, 180, 00618 69, 69, 70, 71, 73, 69, 69, 70, 71, 206, 00619 72, 73, 206, 71, 206, 72, 69, 69, 70, 206, 00620 00621 72, 69, 69, 70, 71, 69, 69, 70, 206, 71, 00622 206, 72, 206, 71, 206, 206, 72, 199, 199, 200, 00623 72, 206, 199, 199, 200, 71, 206, 206, 206, 194, 00624 71, 206, 72, 206, 206, 206, 193, 72, 206, 203, 00625 203, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00626 206, 194, 206, 206, 206, 206, 206, 193, 39, 39, 00627 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 00628 39, 39, 42, 206, 206, 42, 206, 206, 206, 42, 00629 42, 42, 56, 56, 56, 206, 206, 206, 206, 206, 00630 56, 206, 56, 206, 206, 56, 56, 56, 66, 206, 00631 00632 66, 66, 66, 73, 73, 73, 206, 206, 206, 206, 00633 73, 73, 73, 206, 206, 206, 73, 73, 73, 43, 00634 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 00635 43, 43, 43, 43, 43, 43, 98, 98, 206, 98, 00636 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 00637 98, 98, 98, 99, 99, 99, 100, 206, 206, 206, 00638 100, 100, 100, 107, 206, 206, 107, 107, 107, 107, 00639 112, 112, 112, 206, 112, 206, 206, 206, 206, 206, 00640 112, 206, 206, 112, 112, 112, 129, 206, 206, 206, 00641 206, 129, 206, 206, 206, 129, 133, 206, 206, 133, 00642 00643 133, 133, 133, 138, 206, 206, 138, 138, 206, 206, 00644 206, 138, 206, 138, 153, 153, 153, 154, 154, 154, 00645 206, 206, 206, 206, 154, 154, 154, 206, 206, 206, 00646 154, 154, 154, 177, 206, 206, 177, 177, 177, 177, 00647 185, 206, 206, 206, 185, 206, 206, 206, 185, 206, 00648 185, 5, 206, 206, 206, 206, 206, 206, 206, 206, 00649 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00650 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00651 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00652 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00653 00654 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00655 206, 206, 206, 206, 206, 206, 206, 206, 206 00656 } ; 00657 00658 static yyconst flex_int16_t yy_chk[1320] = 00659 { 0, 00660 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00661 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00662 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00663 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00664 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00665 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00666 1, 1, 1, 1, 1, 1, 1, 9, 22, 35, 00667 37, 22, 28, 28, 28, 55, 101, 49, 35, 37, 00668 28, 49, 35, 37, 59, 59, 148, 28, 61, 104, 00669 104, 35, 37, 61, 61, 102, 55, 101, 165, 35, 00670 00671 37, 195, 165, 35, 37, 102, 192, 148, 9, 12, 00672 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 00673 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 00674 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 00675 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 00676 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 00677 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 00678 12, 12, 12, 12, 12, 12, 18, 18, 18, 191, 00679 20, 105, 105, 140, 39, 140, 21, 30, 30, 30, 00680 20, 18, 20, 20, 190, 30, 21, 18, 21, 21, 00681 00682 41, 18, 30, 189, 20, 27, 27, 27, 138, 188, 00683 21, 105, 30, 27, 187, 29, 29, 29, 138, 20, 00684 27, 136, 20, 29, 18, 39, 20, 143, 21, 185, 00685 29, 27, 21, 151, 143, 30, 31, 31, 31, 177, 00686 20, 41, 27, 136, 31, 32, 32, 32, 149, 144, 00687 29, 31, 145, 32, 27, 151, 150, 34, 34, 34, 00688 32, 141, 141, 27, 146, 34, 31, 144, 60, 149, 00689 145, 29, 34, 31, 52, 52, 52, 150, 60, 174, 00690 60, 60, 146, 32, 167, 69, 69, 69, 31, 52, 00691 152, 141, 60, 171, 31, 52, 34, 170, 34, 52, 00692 00693 69, 70, 70, 70, 32, 33, 33, 33, 181, 70, 00694 60, 152, 173, 33, 60, 171, 70, 34, 170, 34, 00695 33, 163, 52, 72, 72, 72, 153, 72, 168, 168, 00696 73, 73, 73, 173, 33, 93, 93, 93, 73, 142, 00697 77, 77, 77, 33, 72, 73, 181, 33, 77, 216, 00698 74, 74, 74, 216, 93, 77, 33, 166, 74, 75, 00699 75, 75, 166, 166, 33, 74, 172, 75, 33, 36, 00700 36, 36, 182, 182, 75, 77, 133, 36, 76, 76, 00701 76, 94, 94, 94, 36, 184, 76, 75, 172, 175, 00702 74, 202, 202, 76, 36, 176, 77, 78, 78, 78, 00703 00704 94, 36, 109, 109, 109, 78, 109, 184, 36, 75, 00705 175, 74, 78, 79, 79, 79, 176, 36, 76, 131, 00706 128, 79, 36, 109, 197, 107, 197, 99, 79, 36, 00707 38, 38, 38, 38, 38, 38, 38, 38, 38, 76, 00708 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 00709 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 00710 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 00711 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 00712 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 00713 38, 38, 38, 38, 38, 38, 38, 48, 48, 48, 00714 00715 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 00716 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 00717 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 00718 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 00719 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 00720 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 00721 48, 48, 48, 48, 80, 80, 80, 81, 81, 81, 00722 217, 96, 80, 92, 217, 81, 82, 82, 82, 80, 00723 91, 66, 81, 47, 82, 83, 83, 83, 84, 84, 00724 84, 82, 80, 83, 46, 85, 84, 86, 86, 86, 00725 00726 83, 45, 85, 84, 44, 86, 89, 183, 183, 85, 00727 81, 43, 86, 25, 80, 89, 24, 82, 85, 89, 00728 83, 186, 186, 85, 87, 87, 87, 23, 89, 19, 00729 85, 81, 87, 86, 17, 15, 89, 183, 82, 87, 00730 89, 83, 88, 90, 225, 5, 88, 4, 225, 88, 00731 90, 186, 196, 196, 86, 226, 88, 90, 3, 226, 00732 103, 103, 198, 198, 87, 88, 90, 115, 88, 0, 00733 88, 90, 103, 108, 108, 108, 115, 88, 90, 0, 00734 115, 108, 196, 0, 0, 87, 97, 0, 108, 115, 00735 103, 0, 198, 0, 103, 97, 97, 115, 0, 0, 00736 00737 0, 115, 0, 97, 97, 97, 97, 97, 97, 112, 00738 112, 112, 0, 130, 130, 130, 0, 112, 201, 201, 00739 201, 0, 0, 0, 112, 0, 97, 97, 97, 97, 00740 97, 110, 130, 0, 0, 110, 110, 201, 110, 0, 00741 110, 158, 113, 113, 113, 110, 110, 110, 158, 110, 00742 113, 114, 114, 114, 0, 158, 0, 113, 0, 114, 00743 110, 110, 110, 110, 158, 0, 114, 0, 110, 158, 00744 0, 0, 110, 0, 0, 0, 158, 116, 116, 116, 00745 0, 110, 110, 110, 110, 116, 117, 117, 117, 110, 00746 139, 139, 116, 147, 117, 118, 118, 118, 119, 119, 00747 00748 119, 117, 139, 118, 147, 121, 119, 120, 120, 120, 00749 118, 204, 204, 119, 121, 120, 147, 116, 121, 0, 00750 139, 0, 120, 0, 139, 147, 0, 121, 122, 122, 00751 122, 0, 123, 123, 123, 121, 122, 0, 116, 121, 00752 123, 204, 120, 122, 124, 124, 124, 123, 125, 126, 00753 205, 205, 124, 0, 0, 0, 0, 125, 126, 124, 00754 0, 125, 126, 120, 0, 0, 123, 0, 0, 0, 00755 125, 126, 0, 199, 199, 199, 0, 0, 125, 126, 00756 205, 124, 125, 126, 127, 127, 127, 123, 199, 0, 00757 199, 199, 127, 154, 154, 154, 0, 0, 0, 127, 00758 00759 0, 154, 124, 132, 132, 0, 0, 0, 154, 0, 00760 0, 132, 132, 132, 132, 132, 132, 155, 155, 155, 00761 156, 0, 0, 0, 0, 155, 0, 0, 0, 156, 00762 0, 0, 155, 156, 132, 132, 132, 132, 132, 0, 00763 0, 0, 156, 157, 157, 157, 0, 159, 159, 159, 00764 156, 157, 0, 0, 156, 159, 161, 0, 157, 160, 00765 160, 160, 159, 161, 0, 0, 0, 160, 0, 0, 00766 161, 0, 0, 0, 160, 162, 162, 162, 0, 161, 00767 169, 169, 169, 162, 161, 178, 178, 178, 169, 0, 00768 162, 161, 0, 178, 0, 169, 179, 179, 179, 0, 00769 00770 178, 180, 180, 180, 179, 193, 193, 193, 0, 180, 00771 0, 179, 0, 193, 0, 0, 180, 194, 194, 194, 00772 193, 0, 200, 200, 200, 194, 0, 0, 0, 180, 00773 200, 0, 194, 0, 0, 0, 179, 200, 0, 200, 00774 200, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00775 0, 180, 0, 0, 0, 0, 0, 179, 207, 207, 00776 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 00777 207, 207, 208, 0, 0, 208, 0, 0, 0, 208, 00778 208, 208, 209, 209, 209, 0, 0, 0, 0, 0, 00779 209, 0, 209, 0, 0, 209, 209, 209, 210, 0, 00780 00781 210, 210, 210, 211, 211, 211, 0, 0, 0, 0, 00782 211, 211, 211, 0, 0, 0, 211, 211, 211, 212, 00783 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 00784 212, 212, 212, 212, 212, 212, 213, 213, 0, 213, 00785 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 00786 213, 213, 213, 214, 214, 214, 215, 0, 0, 0, 00787 215, 215, 215, 218, 0, 0, 218, 218, 218, 218, 00788 219, 219, 219, 0, 219, 0, 0, 0, 0, 0, 00789 219, 0, 0, 219, 219, 219, 220, 0, 0, 0, 00790 0, 220, 0, 0, 0, 220, 221, 0, 0, 221, 00791 00792 221, 221, 221, 222, 0, 0, 222, 222, 0, 0, 00793 0, 222, 0, 222, 223, 223, 223, 224, 224, 224, 00794 0, 0, 0, 0, 224, 224, 224, 0, 0, 0, 00795 224, 224, 224, 227, 0, 0, 227, 227, 227, 227, 00796 228, 0, 0, 0, 228, 0, 0, 0, 228, 0, 00797 228, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00798 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00799 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00800 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00801 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00802 00803 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 00804 206, 206, 206, 206, 206, 206, 206, 206, 206 00805 } ; 00806 00807 static yy_state_type yy_last_accepting_state; 00808 static char *yy_last_accepting_cpos; 00809 00810 extern int yy_flex_debug; 00811 int yy_flex_debug = 0; 00812 00813 /* The intent behind this definition is that it'll catch 00814 * any uses of REJECT which flex missed. 00815 */ 00816 #define REJECT reject_used_but_not_detected 00817 #define yymore() yymore_used_but_not_detected 00818 #define YY_MORE_ADJ 0 00819 #define YY_RESTORE_YY_MORE_OFFSET 00820 char *yytext; 00821 #line 1 "../../src/gdb/ada-lex.l" 00822 /* FLEX lexer for Ada expressions, for GDB. 00823 Copyright (C) 1994-2013 Free Software Foundation, Inc. 00824 00825 This file is part of GDB. 00826 00827 This program is free software; you can redistribute it and/or modify 00828 it under the terms of the GNU General Public License as published by 00829 the Free Software Foundation; either version 3 of the License, or 00830 (at your option) any later version. 00831 00832 This program is distributed in the hope that it will be useful, 00833 but WITHOUT ANY WARRANTY; without even the implied warranty of 00834 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00835 GNU General Public License for more details. 00836 00837 You should have received a copy of the GNU General Public License 00838 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 00839 /*----------------------------------------------------------------------*/ 00840 /* The converted version of this file is to be included in ada-exp.y, */ 00841 /* the Ada parser for gdb. The function yylex obtains characters from */ 00842 /* the global pointer lexptr. It returns a syntactic category for */ 00843 /* each successive token and places a semantic value into yylval */ 00844 /* (ada-lval), defined by the parser. */ 00845 #line 43 "../../src/gdb/ada-lex.l" 00846 00847 #define NUMERAL_WIDTH 256 00848 #define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1)) 00849 00850 /* Temporary staging for numeric literals. */ 00851 static char numbuf[NUMERAL_WIDTH]; 00852 static void canonicalizeNumeral (char *s1, const char *); 00853 static struct stoken processString (const char*, int); 00854 static int processInt (const char *, const char *, const char *); 00855 static int processReal (const char *); 00856 static struct stoken processId (const char *, int); 00857 static int processAttribute (const char *); 00858 static int find_dot_all (const char *); 00859 static void rewind_to_char (int); 00860 00861 #undef YY_DECL 00862 #define YY_DECL static int yylex ( void ) 00863 00864 /* Flex generates a static function "input" which is not used. 00865 Defining YY_NO_INPUT comments it out. */ 00866 #define YY_NO_INPUT 00867 00868 #undef YY_INPUT 00869 #define YY_INPUT(BUF, RESULT, MAX_SIZE) \ 00870 if ( *lexptr == '\000' ) \ 00871 (RESULT) = YY_NULL; \ 00872 else \ 00873 { \ 00874 *(BUF) = *lexptr; \ 00875 (RESULT) = 1; \ 00876 lexptr += 1; \ 00877 } 00878 00879 static int find_dot_all (const char *); 00880 00881 00882 #line 883 "ada-lex.c" 00883 00884 #define INITIAL 0 00885 #define BEFORE_QUAL_QUOTE 1 00886 00887 #ifndef YY_NO_UNISTD_H 00888 /* Special case for "unistd.h", since it is non-ANSI. We include it way 00889 * down here because we want the user's section 1 to have been scanned first. 00890 * The user has a chance to override it with an option. 00891 */ 00892 #include <unistd.h> 00893 #endif 00894 00895 #ifndef YY_EXTRA_TYPE 00896 #define YY_EXTRA_TYPE void * 00897 #endif 00898 00899 static int yy_init_globals (void ); 00900 00901 /* Accessor methods to globals. 00902 These are made visible to non-reentrant scanners for convenience. */ 00903 00904 int yylex_destroy (void ); 00905 00906 int yyget_debug (void ); 00907 00908 void yyset_debug (int debug_flag ); 00909 00910 YY_EXTRA_TYPE yyget_extra (void ); 00911 00912 void yyset_extra (YY_EXTRA_TYPE user_defined ); 00913 00914 FILE *yyget_in (void ); 00915 00916 void yyset_in (FILE * in_str ); 00917 00918 FILE *yyget_out (void ); 00919 00920 void yyset_out (FILE * out_str ); 00921 00922 int yyget_leng (void ); 00923 00924 char *yyget_text (void ); 00925 00926 int yyget_lineno (void ); 00927 00928 void yyset_lineno (int line_number ); 00929 00930 /* Macros after this point can all be overridden by user definitions in 00931 * section 1. 00932 */ 00933 00934 #ifndef YY_SKIP_YYWRAP 00935 #ifdef __cplusplus 00936 extern "C" int yywrap (void ); 00937 #else 00938 extern int yywrap (void ); 00939 #endif 00940 #endif 00941 00942 static void yyunput (int c,char *buf_ptr ); 00943 00944 #ifndef yytext_ptr 00945 static void yy_flex_strncpy (char *,yyconst char *,int ); 00946 #endif 00947 00948 #ifdef YY_NEED_STRLEN 00949 static int yy_flex_strlen (yyconst char * ); 00950 #endif 00951 00952 #ifndef YY_NO_INPUT 00953 00954 #ifdef __cplusplus 00955 static int yyinput (void ); 00956 #else 00957 static int input (void ); 00958 #endif 00959 00960 #endif 00961 00962 /* Amount of stuff to slurp up with each read. */ 00963 #ifndef YY_READ_BUF_SIZE 00964 #ifdef __ia64__ 00965 /* On IA-64, the buffer size is 16k, not 8k */ 00966 #define YY_READ_BUF_SIZE 16384 00967 #else 00968 #define YY_READ_BUF_SIZE 8192 00969 #endif /* __ia64__ */ 00970 #endif 00971 00972 /* Copy whatever the last rule matched to the standard output. */ 00973 #ifndef ECHO 00974 /* This used to be an fputs(), but since the string might contain NUL's, 00975 * we now use fwrite(). 00976 */ 00977 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) 00978 #endif 00979 00980 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 00981 * is returned in "result". 00982 */ 00983 #ifndef YY_INPUT 00984 #define YY_INPUT(buf,result,max_size) \ 00985 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 00986 { \ 00987 int c = '*'; \ 00988 size_t n; \ 00989 for ( n = 0; n < max_size && \ 00990 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 00991 buf[n] = (char) c; \ 00992 if ( c == '\n' ) \ 00993 buf[n++] = (char) c; \ 00994 if ( c == EOF && ferror( yyin ) ) \ 00995 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 00996 result = n; \ 00997 } \ 00998 else \ 00999 { \ 01000 errno=0; \ 01001 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 01002 { \ 01003 if( errno != EINTR) \ 01004 { \ 01005 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 01006 break; \ 01007 } \ 01008 errno=0; \ 01009 clearerr(yyin); \ 01010 } \ 01011 }\ 01012 \ 01013 01014 #endif 01015 01016 /* No semi-colon after return; correct usage is to write "yyterminate();" - 01017 * we don't want an extra ';' after the "return" because that will cause 01018 * some compilers to complain about unreachable statements. 01019 */ 01020 #ifndef yyterminate 01021 #define yyterminate() return YY_NULL 01022 #endif 01023 01024 /* Number of entries by which start-condition stack grows. */ 01025 #ifndef YY_START_STACK_INCR 01026 #define YY_START_STACK_INCR 25 01027 #endif 01028 01029 /* Report a fatal error. */ 01030 #ifndef YY_FATAL_ERROR 01031 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 01032 #endif 01033 01034 /* end tables serialization structures and prototypes */ 01035 01036 /* Default declaration of generated scanner - a define so the user can 01037 * easily add parameters. 01038 */ 01039 #ifndef YY_DECL 01040 #define YY_DECL_IS_OURS 1 01041 01042 extern int yylex (void); 01043 01044 #define YY_DECL int yylex (void) 01045 #endif /* !YY_DECL */ 01046 01047 /* Code executed at the beginning of each rule, after yytext and yyleng 01048 * have been set up. 01049 */ 01050 #ifndef YY_USER_ACTION 01051 #define YY_USER_ACTION 01052 #endif 01053 01054 /* Code executed at the end of each rule. */ 01055 #ifndef YY_BREAK 01056 #define YY_BREAK break; 01057 #endif 01058 01059 #define YY_RULE_SETUP \ 01060 YY_USER_ACTION 01061 01064 YY_DECL 01065 { 01066 register yy_state_type yy_current_state; 01067 register char *yy_cp, *yy_bp; 01068 register int yy_act; 01069 01070 #line 84 "../../src/gdb/ada-lex.l" 01071 01072 01073 #line 1074 "ada-lex.c" 01074 01075 if ( !(yy_init) ) 01076 { 01077 (yy_init) = 1; 01078 01079 #ifdef YY_USER_INIT 01080 YY_USER_INIT; 01081 #endif 01082 01083 if ( ! (yy_start) ) 01084 (yy_start) = 1; /* first start state */ 01085 01086 if ( ! yyin ) 01087 yyin = stdin; 01088 01089 if ( ! yyout ) 01090 yyout = stdout; 01091 01092 if ( ! YY_CURRENT_BUFFER ) { 01093 yyensure_buffer_stack (); 01094 YY_CURRENT_BUFFER_LVALUE = 01095 yy_create_buffer(yyin,YY_BUF_SIZE ); 01096 } 01097 01098 yy_load_buffer_state( ); 01099 } 01100 01101 while ( 1 ) /* loops until end-of-file is reached */ 01102 { 01103 yy_cp = (yy_c_buf_p); 01104 01105 /* Support of yytext. */ 01106 *yy_cp = (yy_hold_char); 01107 01108 /* yy_bp points to the position in yy_ch_buf of the start of 01109 * the current run. 01110 */ 01111 yy_bp = yy_cp; 01112 01113 yy_current_state = (yy_start); 01114 yy_match: 01115 do 01116 { 01117 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 01118 if ( yy_accept[yy_current_state] ) 01119 { 01120 (yy_last_accepting_state) = yy_current_state; 01121 (yy_last_accepting_cpos) = yy_cp; 01122 } 01123 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 01124 { 01125 yy_current_state = (int) yy_def[yy_current_state]; 01126 if ( yy_current_state >= 207 ) 01127 yy_c = yy_meta[(unsigned int) yy_c]; 01128 } 01129 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 01130 ++yy_cp; 01131 } 01132 while ( yy_base[yy_current_state] != 1252 ); 01133 01134 yy_find_action: 01135 yy_act = yy_accept[yy_current_state]; 01136 if ( yy_act == 0 ) 01137 { /* have to back up */ 01138 yy_cp = (yy_last_accepting_cpos); 01139 yy_current_state = (yy_last_accepting_state); 01140 yy_act = yy_accept[yy_current_state]; 01141 } 01142 01143 YY_DO_BEFORE_ACTION; 01144 01145 do_action: /* This label is used only to access EOF actions. */ 01146 01147 switch ( yy_act ) 01148 { /* beginning of action switch */ 01149 case 0: /* must back up */ 01150 /* undo the effects of YY_DO_BEFORE_ACTION */ 01151 *yy_cp = (yy_hold_char); 01152 yy_cp = (yy_last_accepting_cpos); 01153 yy_current_state = (yy_last_accepting_state); 01154 goto yy_find_action; 01155 01156 case 1: 01157 /* rule 1 can match eol */ 01158 YY_RULE_SETUP 01159 #line 86 "../../src/gdb/ada-lex.l" 01160 { } 01161 YY_BREAK 01162 case 2: 01163 YY_RULE_SETUP 01164 #line 88 "../../src/gdb/ada-lex.l" 01165 { yyterminate(); } 01166 YY_BREAK 01167 case 3: 01168 YY_RULE_SETUP 01169 #line 90 "../../src/gdb/ada-lex.l" 01170 { 01171 canonicalizeNumeral (numbuf, yytext); 01172 return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1); 01173 } 01174 YY_BREAK 01175 case 4: 01176 YY_RULE_SETUP 01177 #line 95 "../../src/gdb/ada-lex.l" 01178 { 01179 canonicalizeNumeral (numbuf, yytext); 01180 return processInt (NULL, numbuf, NULL); 01181 } 01182 YY_BREAK 01183 case 5: 01184 YY_RULE_SETUP 01185 #line 100 "../../src/gdb/ada-lex.l" 01186 { 01187 canonicalizeNumeral (numbuf, yytext); 01188 return processInt (numbuf, 01189 strchr (numbuf, '#') + 1, 01190 strrchr(numbuf, '#') + 1); 01191 } 01192 YY_BREAK 01193 case 6: 01194 YY_RULE_SETUP 01195 #line 107 "../../src/gdb/ada-lex.l" 01196 { 01197 canonicalizeNumeral (numbuf, yytext); 01198 return processInt (numbuf, strchr (numbuf, '#') + 1, NULL); 01199 } 01200 YY_BREAK 01201 case 7: 01202 YY_RULE_SETUP 01203 #line 112 "../../src/gdb/ada-lex.l" 01204 { 01205 canonicalizeNumeral (numbuf, yytext+2); 01206 return processInt ("16#", numbuf, NULL); 01207 } 01208 YY_BREAK 01209 case 8: 01210 YY_RULE_SETUP 01211 #line 118 "../../src/gdb/ada-lex.l" 01212 { 01213 canonicalizeNumeral (numbuf, yytext); 01214 return processReal (numbuf); 01215 } 01216 YY_BREAK 01217 case 9: 01218 YY_RULE_SETUP 01219 #line 123 "../../src/gdb/ada-lex.l" 01220 { 01221 canonicalizeNumeral (numbuf, yytext); 01222 return processReal (numbuf); 01223 } 01224 YY_BREAK 01225 case 10: 01226 YY_RULE_SETUP 01227 #line 128 "../../src/gdb/ada-lex.l" 01228 { 01229 error (_("Based real literals not implemented yet.")); 01230 } 01231 YY_BREAK 01232 case 11: 01233 YY_RULE_SETUP 01234 #line 132 "../../src/gdb/ada-lex.l" 01235 { 01236 error (_("Based real literals not implemented yet.")); 01237 } 01238 YY_BREAK 01239 case 12: 01240 YY_RULE_SETUP 01241 #line 136 "../../src/gdb/ada-lex.l" 01242 { 01243 yylval.typed_val.type = type_char (); 01244 yylval.typed_val.val = yytext[1]; 01245 return CHARLIT; 01246 } 01247 YY_BREAK 01248 case 13: 01249 YY_RULE_SETUP 01250 #line 142 "../../src/gdb/ada-lex.l" 01251 { 01252 int v; 01253 yylval.typed_val.type = type_char (); 01254 sscanf (yytext+3, "%2x", &v); 01255 yylval.typed_val.val = v; 01256 return CHARLIT; 01257 } 01258 YY_BREAK 01259 case 14: 01260 YY_RULE_SETUP 01261 #line 150 "../../src/gdb/ada-lex.l" 01262 { 01263 yylval.sval = processString (yytext+1, yyleng-2); 01264 return STRING; 01265 } 01266 YY_BREAK 01267 case 15: 01268 YY_RULE_SETUP 01269 #line 155 "../../src/gdb/ada-lex.l" 01270 { 01271 error (_("ill-formed or non-terminated string literal")); 01272 } 01273 YY_BREAK 01274 case 16: 01275 YY_RULE_SETUP 01276 #line 160 "../../src/gdb/ada-lex.l" 01277 { 01278 rewind_to_char ('i'); 01279 return 0; 01280 } 01281 YY_BREAK 01282 case 17: 01283 YY_RULE_SETUP 01284 #line 165 "../../src/gdb/ada-lex.l" 01285 { 01286 rewind_to_char ('t'); 01287 return 0; 01288 } 01289 YY_BREAK 01290 case 18: 01291 /* rule 18 can match eol */ 01292 YY_RULE_SETUP 01293 #line 170 "../../src/gdb/ada-lex.l" 01294 { 01295 /* This keyword signals the end of the expression and 01296 will be processed separately. */ 01297 rewind_to_char ('t'); 01298 return 0; 01299 } 01300 YY_BREAK 01301 /* ADA KEYWORDS */ 01302 case 19: 01303 YY_RULE_SETUP 01304 #line 179 "../../src/gdb/ada-lex.l" 01305 { return ABS; } 01306 YY_BREAK 01307 case 20: 01308 YY_RULE_SETUP 01309 #line 180 "../../src/gdb/ada-lex.l" 01310 { return _AND_; } 01311 YY_BREAK 01312 case 21: 01313 YY_RULE_SETUP 01314 #line 181 "../../src/gdb/ada-lex.l" 01315 { return ELSE; } 01316 YY_BREAK 01317 case 22: 01318 YY_RULE_SETUP 01319 #line 182 "../../src/gdb/ada-lex.l" 01320 { return IN; } 01321 YY_BREAK 01322 case 23: 01323 YY_RULE_SETUP 01324 #line 183 "../../src/gdb/ada-lex.l" 01325 { return MOD; } 01326 YY_BREAK 01327 case 24: 01328 YY_RULE_SETUP 01329 #line 184 "../../src/gdb/ada-lex.l" 01330 { return NEW; } 01331 YY_BREAK 01332 case 25: 01333 YY_RULE_SETUP 01334 #line 185 "../../src/gdb/ada-lex.l" 01335 { return NOT; } 01336 YY_BREAK 01337 case 26: 01338 YY_RULE_SETUP 01339 #line 186 "../../src/gdb/ada-lex.l" 01340 { return NULL_PTR; } 01341 YY_BREAK 01342 case 27: 01343 YY_RULE_SETUP 01344 #line 187 "../../src/gdb/ada-lex.l" 01345 { return OR; } 01346 YY_BREAK 01347 case 28: 01348 YY_RULE_SETUP 01349 #line 188 "../../src/gdb/ada-lex.l" 01350 { return OTHERS; } 01351 YY_BREAK 01352 case 29: 01353 YY_RULE_SETUP 01354 #line 189 "../../src/gdb/ada-lex.l" 01355 { return REM; } 01356 YY_BREAK 01357 case 30: 01358 YY_RULE_SETUP 01359 #line 190 "../../src/gdb/ada-lex.l" 01360 { return THEN; } 01361 YY_BREAK 01362 case 31: 01363 YY_RULE_SETUP 01364 #line 191 "../../src/gdb/ada-lex.l" 01365 { return XOR; } 01366 YY_BREAK 01367 /* BOOLEAN "KEYWORDS" */ 01368 /* True and False are not keywords in Ada, but rather enumeration constants. 01369 However, the boolean type is no longer represented as an enum, so True 01370 and False are no longer defined in symbol tables. We compromise by 01371 making them keywords (when bare). */ 01372 case 32: 01373 YY_RULE_SETUP 01374 #line 200 "../../src/gdb/ada-lex.l" 01375 { return TRUEKEYWORD; } 01376 YY_BREAK 01377 case 33: 01378 YY_RULE_SETUP 01379 #line 201 "../../src/gdb/ada-lex.l" 01380 { return FALSEKEYWORD; } 01381 YY_BREAK 01382 /* ATTRIBUTES */ 01383 case 34: 01384 /* rule 34 can match eol */ 01385 YY_RULE_SETUP 01386 #line 205 "../../src/gdb/ada-lex.l" 01387 { return processAttribute (yytext+1); } 01388 YY_BREAK 01389 /* PUNCTUATION */ 01390 case 35: 01391 YY_RULE_SETUP 01392 #line 209 "../../src/gdb/ada-lex.l" 01393 { return ARROW; } 01394 YY_BREAK 01395 case 36: 01396 YY_RULE_SETUP 01397 #line 210 "../../src/gdb/ada-lex.l" 01398 { return DOTDOT; } 01399 YY_BREAK 01400 case 37: 01401 YY_RULE_SETUP 01402 #line 211 "../../src/gdb/ada-lex.l" 01403 { return STARSTAR; } 01404 YY_BREAK 01405 case 38: 01406 YY_RULE_SETUP 01407 #line 212 "../../src/gdb/ada-lex.l" 01408 { return ASSIGN; } 01409 YY_BREAK 01410 case 39: 01411 YY_RULE_SETUP 01412 #line 213 "../../src/gdb/ada-lex.l" 01413 { return NOTEQUAL; } 01414 YY_BREAK 01415 case 40: 01416 YY_RULE_SETUP 01417 #line 214 "../../src/gdb/ada-lex.l" 01418 { return LEQ; } 01419 YY_BREAK 01420 case 41: 01421 YY_RULE_SETUP 01422 #line 215 "../../src/gdb/ada-lex.l" 01423 { return GEQ; } 01424 YY_BREAK 01425 case 42: 01426 YY_RULE_SETUP 01427 #line 217 "../../src/gdb/ada-lex.l" 01428 { BEGIN INITIAL; return '\''; } 01429 YY_BREAK 01430 case 43: 01431 YY_RULE_SETUP 01432 #line 219 "../../src/gdb/ada-lex.l" 01433 { return yytext[0]; } 01434 YY_BREAK 01435 case 44: 01436 YY_RULE_SETUP 01437 #line 221 "../../src/gdb/ada-lex.l" 01438 { if (paren_depth == 0 && comma_terminates) 01439 { 01440 rewind_to_char (','); 01441 return 0; 01442 } 01443 else 01444 return ','; 01445 } 01446 YY_BREAK 01447 case 45: 01448 YY_RULE_SETUP 01449 #line 230 "../../src/gdb/ada-lex.l" 01450 { paren_depth += 1; return '('; } 01451 YY_BREAK 01452 case 46: 01453 YY_RULE_SETUP 01454 #line 231 "../../src/gdb/ada-lex.l" 01455 { if (paren_depth == 0) 01456 { 01457 rewind_to_char (')'); 01458 return 0; 01459 } 01460 else 01461 { 01462 paren_depth -= 1; 01463 return ')'; 01464 } 01465 } 01466 YY_BREAK 01467 case 47: 01468 /* rule 47 can match eol */ 01469 YY_RULE_SETUP 01470 #line 243 "../../src/gdb/ada-lex.l" 01471 { return DOT_ALL; } 01472 YY_BREAK 01473 case 48: 01474 /* rule 48 can match eol */ 01475 YY_RULE_SETUP 01476 #line 245 "../../src/gdb/ada-lex.l" 01477 { 01478 yylval.sval = processId (yytext+1, yyleng-1); 01479 return DOT_ID; 01480 } 01481 YY_BREAK 01482 case 49: 01483 /* rule 49 can match eol */ 01484 YY_RULE_SETUP 01485 #line 250 "../../src/gdb/ada-lex.l" 01486 { 01487 int all_posn = find_dot_all (yytext); 01488 01489 if (all_posn == -1 && yytext[yyleng-1] == '\'') 01490 { 01491 BEGIN BEFORE_QUAL_QUOTE; 01492 yyless (yyleng-1); 01493 } 01494 else if (all_posn >= 0) 01495 yyless (all_posn); 01496 yylval.sval = processId (yytext, yyleng); 01497 return NAME; 01498 } 01499 YY_BREAK 01500 /* GDB EXPRESSION CONSTRUCTS */ 01501 case 50: 01502 /* rule 50 can match eol */ 01503 YY_RULE_SETUP 01504 #line 267 "../../src/gdb/ada-lex.l" 01505 { 01506 yyless (yyleng - 2); 01507 yylval.sval = processId (yytext, yyleng); 01508 return NAME; 01509 } 01510 YY_BREAK 01511 case 51: 01512 YY_RULE_SETUP 01513 #line 273 "../../src/gdb/ada-lex.l" 01514 { return COLONCOLON; } 01515 YY_BREAK 01516 case 52: 01517 YY_RULE_SETUP 01518 #line 275 "../../src/gdb/ada-lex.l" 01519 { return yytext[0]; } 01520 YY_BREAK 01521 /* REGISTERS AND GDB CONVENIENCE VARIABLES */ 01522 case 53: 01523 YY_RULE_SETUP 01524 #line 279 "../../src/gdb/ada-lex.l" 01525 { 01526 yylval.sval.ptr = yytext; 01527 yylval.sval.length = yyleng; 01528 return SPECIAL_VARIABLE; 01529 } 01530 YY_BREAK 01531 /* CATCH-ALL ERROR CASE */ 01532 case 54: 01533 YY_RULE_SETUP 01534 #line 287 "../../src/gdb/ada-lex.l" 01535 { error (_("Invalid character '%s' in expression."), yytext); } 01536 YY_BREAK 01537 case 55: 01538 YY_RULE_SETUP 01539 #line 288 "../../src/gdb/ada-lex.l" 01540 YY_FATAL_ERROR( "flex scanner jammed" ); 01541 YY_BREAK 01542 #line 1543 "ada-lex.c" 01543 case YY_STATE_EOF(INITIAL): 01544 case YY_STATE_EOF(BEFORE_QUAL_QUOTE): 01545 yyterminate(); 01546 01547 case YY_END_OF_BUFFER: 01548 { 01549 /* Amount of text matched not including the EOB char. */ 01550 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; 01551 01552 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 01553 *yy_cp = (yy_hold_char); 01554 YY_RESTORE_YY_MORE_OFFSET 01555 01556 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 01557 { 01558 /* We're scanning a new file or input source. It's 01559 * possible that this happened because the user 01560 * just pointed yyin at a new source and called 01561 * yylex(). If so, then we have to assure 01562 * consistency between YY_CURRENT_BUFFER and our 01563 * globals. Here is the right place to do so, because 01564 * this is the first action (other than possibly a 01565 * back-up) that will match for the new input source. 01566 */ 01567 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 01568 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; 01569 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 01570 } 01571 01572 /* Note that here we test for yy_c_buf_p "<=" to the position 01573 * of the first EOB in the buffer, since yy_c_buf_p will 01574 * already have been incremented past the NUL character 01575 * (since all states make transitions on EOB to the 01576 * end-of-buffer state). Contrast this with the test 01577 * in input(). 01578 */ 01579 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 01580 { /* This was really a NUL. */ 01581 yy_state_type yy_next_state; 01582 01583 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; 01584 01585 yy_current_state = yy_get_previous_state( ); 01586 01587 /* Okay, we're now positioned to make the NUL 01588 * transition. We couldn't have 01589 * yy_get_previous_state() go ahead and do it 01590 * for us because it doesn't know how to deal 01591 * with the possibility of jamming (and we don't 01592 * want to build jamming into it because then it 01593 * will run more slowly). 01594 */ 01595 01596 yy_next_state = yy_try_NUL_trans( yy_current_state ); 01597 01598 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 01599 01600 if ( yy_next_state ) 01601 { 01602 /* Consume the NUL. */ 01603 yy_cp = ++(yy_c_buf_p); 01604 yy_current_state = yy_next_state; 01605 goto yy_match; 01606 } 01607 01608 else 01609 { 01610 yy_cp = (yy_c_buf_p); 01611 goto yy_find_action; 01612 } 01613 } 01614 01615 else switch ( yy_get_next_buffer( ) ) 01616 { 01617 case EOB_ACT_END_OF_FILE: 01618 { 01619 (yy_did_buffer_switch_on_eof) = 0; 01620 01621 if ( yywrap( ) ) 01622 { 01623 /* Note: because we've taken care in 01624 * yy_get_next_buffer() to have set up 01625 * yytext, we can now set up 01626 * yy_c_buf_p so that if some total 01627 * hoser (like flex itself) wants to 01628 * call the scanner after we return the 01629 * YY_NULL, it'll still work - another 01630 * YY_NULL will get returned. 01631 */ 01632 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; 01633 01634 yy_act = YY_STATE_EOF(YY_START); 01635 goto do_action; 01636 } 01637 01638 else 01639 { 01640 if ( ! (yy_did_buffer_switch_on_eof) ) 01641 YY_NEW_FILE; 01642 } 01643 break; 01644 } 01645 01646 case EOB_ACT_CONTINUE_SCAN: 01647 (yy_c_buf_p) = 01648 (yytext_ptr) + yy_amount_of_matched_text; 01649 01650 yy_current_state = yy_get_previous_state( ); 01651 01652 yy_cp = (yy_c_buf_p); 01653 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 01654 goto yy_match; 01655 01656 case EOB_ACT_LAST_MATCH: 01657 (yy_c_buf_p) = 01658 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; 01659 01660 yy_current_state = yy_get_previous_state( ); 01661 01662 yy_cp = (yy_c_buf_p); 01663 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 01664 goto yy_find_action; 01665 } 01666 break; 01667 } 01668 01669 default: 01670 YY_FATAL_ERROR( 01671 "fatal flex scanner internal error--no action found" ); 01672 } /* end of action switch */ 01673 } /* end of scanning one token */ 01674 } /* end of yylex */ 01675 01676 /* yy_get_next_buffer - try to read in a new buffer 01677 * 01678 * Returns a code representing an action: 01679 * EOB_ACT_LAST_MATCH - 01680 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 01681 * EOB_ACT_END_OF_FILE - end of file 01682 */ 01683 static int yy_get_next_buffer (void) 01684 { 01685 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 01686 register char *source = (yytext_ptr); 01687 register int number_to_move, i; 01688 int ret_val; 01689 01690 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) 01691 YY_FATAL_ERROR( 01692 "fatal flex scanner internal error--end of buffer missed" ); 01693 01694 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 01695 { /* Don't try to fill the buffer, so this is an EOF. */ 01696 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) 01697 { 01698 /* We matched a single character, the EOB, so 01699 * treat this as a final EOF. 01700 */ 01701 return EOB_ACT_END_OF_FILE; 01702 } 01703 01704 else 01705 { 01706 /* We matched some text prior to the EOB, first 01707 * process it. 01708 */ 01709 return EOB_ACT_LAST_MATCH; 01710 } 01711 } 01712 01713 /* Try to read more data. */ 01714 01715 /* First move last chars to start of buffer. */ 01716 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; 01717 01718 for ( i = 0; i < number_to_move; ++i ) 01719 *(dest++) = *(source++); 01720 01721 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 01722 /* don't do the read, it's not guaranteed to return an EOF, 01723 * just force an EOF 01724 */ 01725 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; 01726 01727 else 01728 { 01729 int num_to_read = 01730 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 01731 01732 while ( num_to_read <= 0 ) 01733 { /* Not enough room in the buffer - grow it. */ 01734 01735 /* just a shorter name for the current buffer */ 01736 YY_BUFFER_STATE b = YY_CURRENT_BUFFER; 01737 01738 int yy_c_buf_p_offset = 01739 (int) ((yy_c_buf_p) - b->yy_ch_buf); 01740 01741 if ( b->yy_is_our_buffer ) 01742 { 01743 int new_size = b->yy_buf_size * 2; 01744 01745 if ( new_size <= 0 ) 01746 b->yy_buf_size += b->yy_buf_size / 8; 01747 else 01748 b->yy_buf_size *= 2; 01749 01750 b->yy_ch_buf = (char *) 01751 /* Include room in for 2 EOB chars. */ 01752 yyxrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); 01753 } 01754 else 01755 /* Can't grow it, we don't own it. */ 01756 b->yy_ch_buf = 0; 01757 01758 if ( ! b->yy_ch_buf ) 01759 YY_FATAL_ERROR( 01760 "fatal error - scanner input buffer overflow" ); 01761 01762 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 01763 01764 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - 01765 number_to_move - 1; 01766 01767 } 01768 01769 if ( num_to_read > YY_READ_BUF_SIZE ) 01770 num_to_read = YY_READ_BUF_SIZE; 01771 01772 /* Read in more data. */ 01773 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 01774 (yy_n_chars), (size_t) num_to_read ); 01775 01776 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 01777 } 01778 01779 if ( (yy_n_chars) == 0 ) 01780 { 01781 if ( number_to_move == YY_MORE_ADJ ) 01782 { 01783 ret_val = EOB_ACT_END_OF_FILE; 01784 yyrestart(yyin ); 01785 } 01786 01787 else 01788 { 01789 ret_val = EOB_ACT_LAST_MATCH; 01790 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 01791 YY_BUFFER_EOF_PENDING; 01792 } 01793 } 01794 01795 else 01796 ret_val = EOB_ACT_CONTINUE_SCAN; 01797 01798 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { 01799 /* Extend the array by 50%, plus the number we really need. */ 01800 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); 01801 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyxrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); 01802 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 01803 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); 01804 } 01805 01806 (yy_n_chars) += number_to_move; 01807 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; 01808 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; 01809 01810 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 01811 01812 return ret_val; 01813 } 01814 01815 /* yy_get_previous_state - get the state just before the EOB char was reached */ 01816 01817 static yy_state_type yy_get_previous_state (void) 01818 { 01819 register yy_state_type yy_current_state; 01820 register char *yy_cp; 01821 01822 yy_current_state = (yy_start); 01823 01824 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) 01825 { 01826 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 01827 if ( yy_accept[yy_current_state] ) 01828 { 01829 (yy_last_accepting_state) = yy_current_state; 01830 (yy_last_accepting_cpos) = yy_cp; 01831 } 01832 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 01833 { 01834 yy_current_state = (int) yy_def[yy_current_state]; 01835 if ( yy_current_state >= 207 ) 01836 yy_c = yy_meta[(unsigned int) yy_c]; 01837 } 01838 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 01839 } 01840 01841 return yy_current_state; 01842 } 01843 01844 /* yy_try_NUL_trans - try to make a transition on the NUL character 01845 * 01846 * synopsis 01847 * next_state = yy_try_NUL_trans( current_state ); 01848 */ 01849 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) 01850 { 01851 register int yy_is_jam; 01852 register char *yy_cp = (yy_c_buf_p); 01853 01854 register YY_CHAR yy_c = 1; 01855 if ( yy_accept[yy_current_state] ) 01856 { 01857 (yy_last_accepting_state) = yy_current_state; 01858 (yy_last_accepting_cpos) = yy_cp; 01859 } 01860 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 01861 { 01862 yy_current_state = (int) yy_def[yy_current_state]; 01863 if ( yy_current_state >= 207 ) 01864 yy_c = yy_meta[(unsigned int) yy_c]; 01865 } 01866 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 01867 yy_is_jam = (yy_current_state == 206); 01868 01869 return yy_is_jam ? 0 : yy_current_state; 01870 } 01871 01872 static void yyunput (int c, register char * yy_bp ) 01873 { 01874 register char *yy_cp; 01875 01876 yy_cp = (yy_c_buf_p); 01877 01878 /* undo effects of setting up yytext */ 01879 *yy_cp = (yy_hold_char); 01880 01881 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 01882 { /* need to shift things up to make room */ 01883 /* +2 for EOB chars. */ 01884 register int number_to_move = (yy_n_chars) + 2; 01885 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ 01886 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; 01887 register char *source = 01888 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; 01889 01890 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 01891 *--dest = *--source; 01892 01893 yy_cp += (int) (dest - source); 01894 yy_bp += (int) (dest - source); 01895 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = 01896 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; 01897 01898 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 01899 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 01900 } 01901 01902 *--yy_cp = (char) c; 01903 01904 (yytext_ptr) = yy_bp; 01905 (yy_hold_char) = *yy_cp; 01906 (yy_c_buf_p) = yy_cp; 01907 } 01908 01909 #ifndef YY_NO_INPUT 01910 #ifdef __cplusplus 01911 static int yyinput (void) 01912 #else 01913 static int input (void) 01914 #endif 01915 01916 { 01917 int c; 01918 01919 *(yy_c_buf_p) = (yy_hold_char); 01920 01921 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) 01922 { 01923 /* yy_c_buf_p now points to the character we want to return. 01924 * If this occurs *before* the EOB characters, then it's a 01925 * valid NUL; if not, then we've hit the end of the buffer. 01926 */ 01927 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 01928 /* This was really a NUL. */ 01929 *(yy_c_buf_p) = '\0'; 01930 01931 else 01932 { /* need more input */ 01933 int offset = (yy_c_buf_p) - (yytext_ptr); 01934 ++(yy_c_buf_p); 01935 01936 switch ( yy_get_next_buffer( ) ) 01937 { 01938 case EOB_ACT_LAST_MATCH: 01939 /* This happens because yy_g_n_b() 01940 * sees that we've accumulated a 01941 * token and flags that we need to 01942 * try matching the token before 01943 * proceeding. But for input(), 01944 * there's no matching to consider. 01945 * So convert the EOB_ACT_LAST_MATCH 01946 * to EOB_ACT_END_OF_FILE. 01947 */ 01948 01949 /* Reset buffer status. */ 01950 yyrestart(yyin ); 01951 01952 /*FALLTHROUGH*/ 01953 01954 case EOB_ACT_END_OF_FILE: 01955 { 01956 if ( yywrap( ) ) 01957 return EOF; 01958 01959 if ( ! (yy_did_buffer_switch_on_eof) ) 01960 YY_NEW_FILE; 01961 #ifdef __cplusplus 01962 return yyinput(); 01963 #else 01964 return input(); 01965 #endif 01966 } 01967 01968 case EOB_ACT_CONTINUE_SCAN: 01969 (yy_c_buf_p) = (yytext_ptr) + offset; 01970 break; 01971 } 01972 } 01973 } 01974 01975 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ 01976 *(yy_c_buf_p) = '\0'; /* preserve yytext */ 01977 (yy_hold_char) = *++(yy_c_buf_p); 01978 01979 return c; 01980 } 01981 #endif /* ifndef YY_NO_INPUT */ 01982 01988 void yyrestart (FILE * input_file ) 01989 { 01990 01991 if ( ! YY_CURRENT_BUFFER ){ 01992 yyensure_buffer_stack (); 01993 YY_CURRENT_BUFFER_LVALUE = 01994 yy_create_buffer(yyin,YY_BUF_SIZE ); 01995 } 01996 01997 yy_init_buffer(YY_CURRENT_BUFFER,input_file ); 01998 yy_load_buffer_state( ); 01999 } 02000 02005 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) 02006 { 02007 02008 /* TODO. We should be able to replace this entire function body 02009 * with 02010 * yypop_buffer_state(); 02011 * yypush_buffer_state(new_buffer); 02012 */ 02013 yyensure_buffer_stack (); 02014 if ( YY_CURRENT_BUFFER == new_buffer ) 02015 return; 02016 02017 if ( YY_CURRENT_BUFFER ) 02018 { 02019 /* Flush out information for old buffer. */ 02020 *(yy_c_buf_p) = (yy_hold_char); 02021 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 02022 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 02023 } 02024 02025 YY_CURRENT_BUFFER_LVALUE = new_buffer; 02026 yy_load_buffer_state( ); 02027 02028 /* We don't actually know whether we did this switch during 02029 * EOF (yywrap()) processing, but the only time this flag 02030 * is looked at is after yywrap() is called, so it's safe 02031 * to go ahead and always set it. 02032 */ 02033 (yy_did_buffer_switch_on_eof) = 1; 02034 } 02035 02036 static void yy_load_buffer_state (void) 02037 { 02038 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 02039 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 02040 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 02041 (yy_hold_char) = *(yy_c_buf_p); 02042 } 02043 02050 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) 02051 { 02052 YY_BUFFER_STATE b; 02053 02054 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); 02055 if ( ! b ) 02056 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 02057 02058 b->yy_buf_size = size; 02059 02060 /* yy_ch_buf has to be 2 characters longer than the size given because 02061 * we need to put in 2 end-of-buffer characters. 02062 */ 02063 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); 02064 if ( ! b->yy_ch_buf ) 02065 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 02066 02067 b->yy_is_our_buffer = 1; 02068 02069 yy_init_buffer(b,file ); 02070 02071 return b; 02072 } 02073 02078 void yy_delete_buffer (YY_BUFFER_STATE b ) 02079 { 02080 02081 if ( ! b ) 02082 return; 02083 02084 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 02085 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 02086 02087 if ( b->yy_is_our_buffer ) 02088 yyfree((void *) b->yy_ch_buf ); 02089 02090 yyfree((void *) b ); 02091 } 02092 02093 #ifndef __cplusplus 02094 extern int isatty (int ); 02095 #endif /* __cplusplus */ 02096 02097 /* Initializes or reinitializes a buffer. 02098 * This function is sometimes called more than once on the same buffer, 02099 * such as during a yyrestart() or at EOF. 02100 */ 02101 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) 02102 02103 { 02104 int oerrno = errno; 02105 02106 yy_flush_buffer(b ); 02107 02108 b->yy_input_file = file; 02109 b->yy_fill_buffer = 1; 02110 02111 /* If b is the current buffer, then yy_init_buffer was _probably_ 02112 * called from yyrestart() or through yy_get_next_buffer. 02113 * In that case, we don't want to reset the lineno or column. 02114 */ 02115 if (b != YY_CURRENT_BUFFER){ 02116 b->yy_bs_lineno = 1; 02117 b->yy_bs_column = 0; 02118 } 02119 02120 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 02121 02122 errno = oerrno; 02123 } 02124 02129 void yy_flush_buffer (YY_BUFFER_STATE b ) 02130 { 02131 if ( ! b ) 02132 return; 02133 02134 b->yy_n_chars = 0; 02135 02136 /* We always need two end-of-buffer characters. The first causes 02137 * a transition to the end-of-buffer state. The second causes 02138 * a jam in that state. 02139 */ 02140 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 02141 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 02142 02143 b->yy_buf_pos = &b->yy_ch_buf[0]; 02144 02145 b->yy_at_bol = 1; 02146 b->yy_buffer_status = YY_BUFFER_NEW; 02147 02148 if ( b == YY_CURRENT_BUFFER ) 02149 yy_load_buffer_state( ); 02150 } 02151 02158 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) 02159 { 02160 if (new_buffer == NULL) 02161 return; 02162 02163 yyensure_buffer_stack(); 02164 02165 /* This block is copied from yy_switch_to_buffer. */ 02166 if ( YY_CURRENT_BUFFER ) 02167 { 02168 /* Flush out information for old buffer. */ 02169 *(yy_c_buf_p) = (yy_hold_char); 02170 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 02171 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 02172 } 02173 02174 /* Only push if top exists. Otherwise, replace top. */ 02175 if (YY_CURRENT_BUFFER) 02176 (yy_buffer_stack_top)++; 02177 YY_CURRENT_BUFFER_LVALUE = new_buffer; 02178 02179 /* copied from yy_switch_to_buffer. */ 02180 yy_load_buffer_state( ); 02181 (yy_did_buffer_switch_on_eof) = 1; 02182 } 02183 02188 void yypop_buffer_state (void) 02189 { 02190 if (!YY_CURRENT_BUFFER) 02191 return; 02192 02193 yy_delete_buffer(YY_CURRENT_BUFFER ); 02194 YY_CURRENT_BUFFER_LVALUE = NULL; 02195 if ((yy_buffer_stack_top) > 0) 02196 --(yy_buffer_stack_top); 02197 02198 if (YY_CURRENT_BUFFER) { 02199 yy_load_buffer_state( ); 02200 (yy_did_buffer_switch_on_eof) = 1; 02201 } 02202 } 02203 02204 /* Allocates the stack if it does not exist. 02205 * Guarantees space for at least one push. 02206 */ 02207 static void yyensure_buffer_stack (void) 02208 { 02209 int num_to_alloc; 02210 02211 if (!(yy_buffer_stack)) { 02212 02213 /* First allocation is just for 2 elements, since we don't know if this 02214 * scanner will even need a stack. We use 2 instead of 1 to avoid an 02215 * immediate xrealloc on the next call. 02216 */ 02217 num_to_alloc = 1; 02218 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc 02219 (num_to_alloc * sizeof(struct yy_buffer_state*) 02220 ); 02221 if ( ! (yy_buffer_stack) ) 02222 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 02223 02224 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 02225 02226 (yy_buffer_stack_max) = num_to_alloc; 02227 (yy_buffer_stack_top) = 0; 02228 return; 02229 } 02230 02231 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ 02232 02233 /* Increase the buffer to prepare for a possible push. */ 02234 int grow_size = 8 /* arbitrary grow size */; 02235 02236 num_to_alloc = (yy_buffer_stack_max) + grow_size; 02237 (yy_buffer_stack) = (struct yy_buffer_state**)yyxrealloc 02238 ((yy_buffer_stack), 02239 num_to_alloc * sizeof(struct yy_buffer_state*) 02240 ); 02241 if ( ! (yy_buffer_stack) ) 02242 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 02243 02244 /* zero only the new slots.*/ 02245 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 02246 (yy_buffer_stack_max) = num_to_alloc; 02247 } 02248 } 02249 02256 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) 02257 { 02258 YY_BUFFER_STATE b; 02259 02260 if ( size < 2 || 02261 base[size-2] != YY_END_OF_BUFFER_CHAR || 02262 base[size-1] != YY_END_OF_BUFFER_CHAR ) 02263 /* They forgot to leave room for the EOB's. */ 02264 return 0; 02265 02266 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); 02267 if ( ! b ) 02268 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 02269 02270 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 02271 b->yy_buf_pos = b->yy_ch_buf = base; 02272 b->yy_is_our_buffer = 0; 02273 b->yy_input_file = 0; 02274 b->yy_n_chars = b->yy_buf_size; 02275 b->yy_is_interactive = 0; 02276 b->yy_at_bol = 1; 02277 b->yy_fill_buffer = 0; 02278 b->yy_buffer_status = YY_BUFFER_NEW; 02279 02280 yy_switch_to_buffer(b ); 02281 02282 return b; 02283 } 02284 02293 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) 02294 { 02295 02296 return yy_scan_bytes(yystr,strlen(yystr) ); 02297 } 02298 02306 YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len ) 02307 { 02308 YY_BUFFER_STATE b; 02309 char *buf; 02310 yy_size_t n; 02311 int i; 02312 02313 /* Get memory for full buffer, including space for trailing EOB's. */ 02314 n = _yybytes_len + 2; 02315 buf = (char *) yyalloc(n ); 02316 if ( ! buf ) 02317 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 02318 02319 for ( i = 0; i < _yybytes_len; ++i ) 02320 buf[i] = yybytes[i]; 02321 02322 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; 02323 02324 b = yy_scan_buffer(buf,n ); 02325 if ( ! b ) 02326 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 02327 02328 /* It's okay to grow etc. this buffer, and we should throw it 02329 * away when we're done. 02330 */ 02331 b->yy_is_our_buffer = 1; 02332 02333 return b; 02334 } 02335 02336 #ifndef YY_EXIT_FAILURE 02337 #define YY_EXIT_FAILURE 2 02338 #endif 02339 02340 static void yy_fatal_error (yyconst char* msg ) 02341 { 02342 (void) fprintf( stderr, "%s\n", msg ); 02343 exit( YY_EXIT_FAILURE ); 02344 } 02345 02346 /* Redefine yyless() so it works in section 3 code. */ 02347 02348 #undef yyless 02349 #define yyless(n) \ 02350 do \ 02351 { \ 02352 /* Undo effects of setting up yytext. */ \ 02353 int yyless_macro_arg = (n); \ 02354 YY_LESS_LINENO(yyless_macro_arg);\ 02355 yytext[yyleng] = (yy_hold_char); \ 02356 (yy_c_buf_p) = yytext + yyless_macro_arg; \ 02357 (yy_hold_char) = *(yy_c_buf_p); \ 02358 *(yy_c_buf_p) = '\0'; \ 02359 yyleng = yyless_macro_arg; \ 02360 } \ 02361 while ( 0 ) 02362 02363 /* Accessor methods (get/set functions) to struct members. */ 02364 02368 int yyget_lineno (void) 02369 { 02370 02371 return yylineno; 02372 } 02373 02377 FILE *yyget_in (void) 02378 { 02379 return yyin; 02380 } 02381 02385 FILE *yyget_out (void) 02386 { 02387 return yyout; 02388 } 02389 02393 int yyget_leng (void) 02394 { 02395 return yyleng; 02396 } 02397 02402 char *yyget_text (void) 02403 { 02404 return yytext; 02405 } 02406 02411 void yyset_lineno (int line_number ) 02412 { 02413 02414 yylineno = line_number; 02415 } 02416 02423 void yyset_in (FILE * in_str ) 02424 { 02425 yyin = in_str ; 02426 } 02427 02428 void yyset_out (FILE * out_str ) 02429 { 02430 yyout = out_str ; 02431 } 02432 02433 int yyget_debug (void) 02434 { 02435 return yy_flex_debug; 02436 } 02437 02438 void yyset_debug (int bdebug ) 02439 { 02440 yy_flex_debug = bdebug ; 02441 } 02442 02443 static int yy_init_globals (void) 02444 { 02445 /* Initialization is the same as for the non-reentrant scanner. 02446 * This function is called from yylex_destroy(), so don't allocate here. 02447 */ 02448 02449 (yy_buffer_stack) = 0; 02450 (yy_buffer_stack_top) = 0; 02451 (yy_buffer_stack_max) = 0; 02452 (yy_c_buf_p) = (char *) 0; 02453 (yy_init) = 0; 02454 (yy_start) = 0; 02455 02456 /* Defined in main.c */ 02457 #ifdef YY_STDINIT 02458 yyin = stdin; 02459 yyout = stdout; 02460 #else 02461 yyin = (FILE *) 0; 02462 yyout = (FILE *) 0; 02463 #endif 02464 02465 /* For future reference: Set errno on error, since we are called by 02466 * yylex_init() 02467 */ 02468 return 0; 02469 } 02470 02471 /* yylex_destroy is for both reentrant and non-reentrant scanners. */ 02472 int yylex_destroy (void) 02473 { 02474 02475 /* Pop the buffer stack, destroying each element. */ 02476 while(YY_CURRENT_BUFFER){ 02477 yy_delete_buffer(YY_CURRENT_BUFFER ); 02478 YY_CURRENT_BUFFER_LVALUE = NULL; 02479 yypop_buffer_state(); 02480 } 02481 02482 /* Destroy the stack itself. */ 02483 yyfree((yy_buffer_stack) ); 02484 (yy_buffer_stack) = NULL; 02485 02486 /* Reset the globals. This is important in a non-reentrant scanner so the next time 02487 * yylex() is called, initialization will occur. */ 02488 yy_init_globals( ); 02489 02490 return 0; 02491 } 02492 02493 /* 02494 * Internal utility routines. 02495 */ 02496 02497 #ifndef yytext_ptr 02498 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) 02499 { 02500 register int i; 02501 for ( i = 0; i < n; ++i ) 02502 s1[i] = s2[i]; 02503 } 02504 #endif 02505 02506 #ifdef YY_NEED_STRLEN 02507 static int yy_flex_strlen (yyconst char * s ) 02508 { 02509 register int n; 02510 for ( n = 0; s[n]; ++n ) 02511 ; 02512 02513 return n; 02514 } 02515 #endif 02516 02517 void *yyalloc (yy_size_t size ) 02518 { 02519 return (void *) xmalloc( size ); 02520 } 02521 02522 void *yyxrealloc (void * ptr, yy_size_t size ) 02523 { 02524 /* The cast to (char *) in the following accommodates both 02525 * implementations that use char* generic pointers, and those 02526 * that use void* generic pointers. It works with the latter 02527 * because both ANSI C and C++ allow castless assignment from 02528 * any pointer type to void*, and deal with argument conversions 02529 * as though doing an assignment. 02530 */ 02531 return (void *) xrealloc( (char *) ptr, size ); 02532 } 02533 02534 void yyfree (void * ptr ) 02535 { 02536 xfree( (char *) ptr ); /* see yyxrealloc() for (char *) cast */ 02537 } 02538 02539 #define YYTABLES_NAME "yytables" 02540 02541 #line 288 "../../src/gdb/ada-lex.l" 02542 02543 02544 02545 #include <ctype.h> 02546 #include "gdb_string.h" 02547 02548 /* Initialize the lexer for processing new expression. */ 02549 02550 static void 02551 lexer_init (FILE *inp) 02552 { 02553 BEGIN INITIAL; 02554 yyrestart (inp); 02555 } 02556 02557 02558 /* Copy S2 to S1, removing all underscores, and downcasing all letters. */ 02559 02560 static void 02561 canonicalizeNumeral (char *s1, const char *s2) 02562 { 02563 for (; *s2 != '\000'; s2 += 1) 02564 { 02565 if (*s2 != '_') 02566 { 02567 *s1 = tolower(*s2); 02568 s1 += 1; 02569 } 02570 } 02571 s1[0] = '\000'; 02572 } 02573 02574 /* Interprets the prefix of NUM that consists of digits of the given BASE 02575 as an integer of that BASE, with the string EXP as an exponent. 02576 Puts value in yylval, and returns INT, if the string is valid. Causes 02577 an error if the number is improperly formated. BASE, if NULL, defaults 02578 to "10", and EXP to "1". The EXP does not contain a leading 'e' or 'E'. 02579 */ 02580 02581 static int 02582 processInt (const char *base0, const char *num0, const char *exp0) 02583 { 02584 ULONGEST result; 02585 long exp; 02586 int base; 02587 const char *trailer; 02588 02589 if (base0 == NULL) 02590 base = 10; 02591 else 02592 { 02593 base = strtol (base0, (char **) NULL, 10); 02594 if (base < 2 || base > 16) 02595 error (_("Invalid base: %d."), base); 02596 } 02597 02598 if (exp0 == NULL) 02599 exp = 0; 02600 else 02601 exp = strtol(exp0, (char **) NULL, 10); 02602 02603 errno = 0; 02604 result = strtoulst (num0, &trailer, base); 02605 if (errno == ERANGE) 02606 error (_("Integer literal out of range")); 02607 if (isxdigit(*trailer)) 02608 error (_("Invalid digit `%c' in based literal"), *trailer); 02609 02610 while (exp > 0) 02611 { 02612 if (result > (ULONG_MAX / base)) 02613 error (_("Integer literal out of range")); 02614 result *= base; 02615 exp -= 1; 02616 } 02617 02618 if ((result >> (gdbarch_int_bit (parse_gdbarch)-1)) == 0) 02619 yylval.typed_val.type = type_int (); 02620 else if ((result >> (gdbarch_long_bit (parse_gdbarch)-1)) == 0) 02621 yylval.typed_val.type = type_long (); 02622 else if (((result >> (gdbarch_long_bit (parse_gdbarch)-1)) >> 1) == 0) 02623 { 02624 /* We have a number representable as an unsigned integer quantity. 02625 For consistency with the C treatment, we will treat it as an 02626 anonymous modular (unsigned) quantity. Alas, the types are such 02627 that we need to store .val as a signed quantity. Sorry 02628 for the mess, but C doesn't officially guarantee that a simple 02629 assignment does the trick (no, it doesn't; read the reference manual). 02630 */ 02631 yylval.typed_val.type 02632 = builtin_type (parse_gdbarch)->builtin_unsigned_long; 02633 if (result & LONGEST_SIGN) 02634 yylval.typed_val.val = 02635 (LONGEST) (result & ~LONGEST_SIGN) 02636 - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1); 02637 else 02638 yylval.typed_val.val = (LONGEST) result; 02639 return INT; 02640 } 02641 else 02642 yylval.typed_val.type = type_long_long (); 02643 02644 yylval.typed_val.val = (LONGEST) result; 02645 return INT; 02646 } 02647 02648 static int 02649 processReal (const char *num0) 02650 { 02651 sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval); 02652 02653 yylval.typed_val_float.type = type_float (); 02654 if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch) 02655 / TARGET_CHAR_BIT) 02656 yylval.typed_val_float.type = type_double (); 02657 if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch) 02658 / TARGET_CHAR_BIT) 02659 yylval.typed_val_float.type = type_long_double (); 02660 02661 return FLOAT; 02662 } 02663 02664 02665 /* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym. The 02666 resulting string is valid until the next call to ada_parse. If 02667 NAME0 contains the substring "___", it is assumed to be already 02668 encoded and the resulting name is equal to it. Otherwise, it differs 02669 from NAME0 in that: 02670 + Characters between '...' or <...> are transfered verbatim to 02671 yylval.ssym. 02672 + <, >, and trailing "'" characters in quoted sequences are removed 02673 (a leading quote is preserved to indicate that the name is not to be 02674 GNAT-encoded). 02675 + Unquoted whitespace is removed. 02676 + Unquoted alphabetic characters are mapped to lower case. 02677 Result is returned as a struct stoken, but for convenience, the string 02678 is also null-terminated. Result string valid until the next call of 02679 ada_parse. 02680 */ 02681 static struct stoken 02682 processId (const char *name0, int len) 02683 { 02684 char *name = obstack_alloc (&temp_parse_space, len + 11); 02685 int i0, i; 02686 struct stoken result; 02687 02688 result.ptr = name; 02689 while (len > 0 && isspace (name0[len-1])) 02690 len -= 1; 02691 02692 if (strstr (name0, "___") != NULL) 02693 { 02694 strncpy (name, name0, len); 02695 name[len] = '\000'; 02696 result.length = len; 02697 return result; 02698 } 02699 02700 i = i0 = 0; 02701 while (i0 < len) 02702 { 02703 if (isalnum (name0[i0])) 02704 { 02705 name[i] = tolower (name0[i0]); 02706 i += 1; i0 += 1; 02707 } 02708 else switch (name0[i0]) 02709 { 02710 default: 02711 name[i] = name0[i0]; 02712 i += 1; i0 += 1; 02713 break; 02714 case ' ': case '\t': 02715 i0 += 1; 02716 break; 02717 case '\'': 02718 do 02719 { 02720 name[i] = name0[i0]; 02721 i += 1; i0 += 1; 02722 } 02723 while (i0 < len && name0[i0] != '\''); 02724 i0 += 1; 02725 break; 02726 case '<': 02727 i0 += 1; 02728 while (i0 < len && name0[i0] != '>') 02729 { 02730 name[i] = name0[i0]; 02731 i += 1; i0 += 1; 02732 } 02733 i0 += 1; 02734 break; 02735 } 02736 } 02737 name[i] = '\000'; 02738 02739 result.length = i; 02740 return result; 02741 } 02742 02743 /* Return TEXT[0..LEN-1], a string literal without surrounding quotes, 02744 with special hex character notations replaced with characters. 02745 Result valid until the next call to ada_parse. */ 02746 02747 static struct stoken 02748 processString (const char *text, int len) 02749 { 02750 const char *p; 02751 char *q; 02752 const char *lim = text + len; 02753 struct stoken result; 02754 02755 q = obstack_alloc (&temp_parse_space, len); 02756 result.ptr = q; 02757 p = text; 02758 while (p < lim) 02759 { 02760 if (p[0] == '[' && p[1] == '"' && p+2 < lim) 02761 { 02762 if (p[2] == '"') /* "...["""]... */ 02763 { 02764 *q = '"'; 02765 p += 4; 02766 } 02767 else 02768 { 02769 int chr; 02770 sscanf (p+2, "%2x", &chr); 02771 *q = (char) chr; 02772 p += 5; 02773 } 02774 } 02775 else 02776 *q = *p; 02777 q += 1; 02778 p += 1; 02779 } 02780 result.length = q - result.ptr; 02781 return result; 02782 } 02783 02784 /* Returns the position within STR of the '.' in a 02785 '.{WHITE}*all' component of a dotted name, or -1 if there is none. 02786 Note: we actually don't need this routine, since 'all' can never be an 02787 Ada identifier. Thus, looking up foo.all or foo.all.x as a name 02788 must fail, and will eventually be interpreted as (foo).all or 02789 (foo).all.x. However, this does avoid an extraneous lookup. */ 02790 02791 static int 02792 find_dot_all (const char *str) 02793 { 02794 int i; 02795 for (i = 0; str[i] != '\000'; i += 1) 02796 { 02797 if (str[i] == '.') 02798 { 02799 int i0 = i; 02800 do 02801 i += 1; 02802 while (isspace (str[i])); 02803 if (strncmp (str+i, "all", 3) == 0 02804 && ! isalnum (str[i+3]) && str[i+3] != '_') 02805 return i0; 02806 } 02807 } 02808 return -1; 02809 } 02810 02811 /* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring 02812 case. */ 02813 02814 static int 02815 subseqMatch (const char *subseq, const char *str) 02816 { 02817 if (subseq[0] == '\0') 02818 return 1; 02819 else if (str[0] == '\0') 02820 return 0; 02821 else if (tolower (subseq[0]) == tolower (str[0])) 02822 return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1); 02823 else 02824 return subseqMatch (subseq, str+1); 02825 } 02826 02827 02828 static struct { const char *name; int code; } 02829 attributes[] = { 02830 { "address", TICK_ADDRESS }, 02831 { "unchecked_access", TICK_ACCESS }, 02832 { "unrestricted_access", TICK_ACCESS }, 02833 { "access", TICK_ACCESS }, 02834 { "first", TICK_FIRST }, 02835 { "last", TICK_LAST }, 02836 { "length", TICK_LENGTH }, 02837 { "max", TICK_MAX }, 02838 { "min", TICK_MIN }, 02839 { "modulus", TICK_MODULUS }, 02840 { "pos", TICK_POS }, 02841 { "range", TICK_RANGE }, 02842 { "size", TICK_SIZE }, 02843 { "tag", TICK_TAG }, 02844 { "val", TICK_VAL }, 02845 { NULL, -1 } 02846 }; 02847 02848 /* Return the syntactic code corresponding to the attribute name or 02849 abbreviation STR. */ 02850 02851 static int 02852 processAttribute (const char *str) 02853 { 02854 int i, k; 02855 02856 for (i = 0; attributes[i].code != -1; i += 1) 02857 if (strcasecmp (str, attributes[i].name) == 0) 02858 return attributes[i].code; 02859 02860 for (i = 0, k = -1; attributes[i].code != -1; i += 1) 02861 if (subseqMatch (str, attributes[i].name)) 02862 { 02863 if (k == -1) 02864 k = i; 02865 else 02866 error (_("ambiguous attribute name: `%s'"), str); 02867 } 02868 if (k == -1) 02869 error (_("unrecognized attribute: `%s'"), str); 02870 02871 return attributes[k].code; 02872 } 02873 02874 /* Back up lexptr by yyleng and then to the rightmost occurrence of 02875 character CH, case-folded (there must be one). WARNING: since 02876 lexptr points to the next input character that Flex has not yet 02877 transferred to its internal buffer, the use of this function 02878 depends on the assumption that Flex calls YY_INPUT only when it is 02879 logically necessary to do so (thus, there is no reading ahead 02880 farther than needed to identify the next token.) */ 02881 02882 static void 02883 rewind_to_char (int ch) 02884 { 02885 lexptr -= yyleng; 02886 while (toupper (*lexptr) != toupper (ch)) 02887 lexptr -= 1; 02888 yyrestart (NULL); 02889 } 02890 02891 int 02892 yywrap(void) 02893 { 02894 return 1; 02895 } 02896 02897 /* Dummy definition to suppress warnings about unused static definitions. */ 02898 typedef void (*dummy_function) (); 02899 dummy_function ada_flex_use[] = 02900 { 02901 (dummy_function) yyunput 02902 }; 02903
1.7.6.1
