1 #line 2 "ada-lex.c" 2 /* A lexical scanner generated by flex */ 3 4 /* Scanner skeleton version: 5 * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $ 6 */ 7 8 #define FLEX_SCANNER 9 #define YY_FLEX_MAJOR_VERSION 2 10 #define YY_FLEX_MINOR_VERSION 5 11 12 #include <stdio.h> 13 #include <unistd.h> 14 15 16 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ 17 #ifdef c_plusplus 18 #ifndef __cplusplus 19 #define __cplusplus 20 #endif 21 #endif 22 23 24 #ifdef __cplusplus 25 26 #include <stdlib.h> 27 28 /* Use prototypes in function declarations. */ 29 #define YY_USE_PROTOS 30 31 /* The "const" storage-class-modifier is valid. */ 32 #define YY_USE_CONST 33 34 #else /* ! __cplusplus */ 35 36 #if __STDC__ 37 38 #define YY_USE_PROTOS 39 #define YY_USE_CONST 40 41 #endif /* __STDC__ */ 42 #endif /* ! __cplusplus */ 43 44 #ifdef __TURBOC__ 45 #pragma warn -rch 46 #pragma warn -use 47 #include <io.h> 48 #include <stdlib.h> 49 #define YY_USE_CONST 50 #define YY_USE_PROTOS 51 #endif 52 53 #ifdef YY_USE_CONST 54 #define yyconst const 55 #else 56 #define yyconst 57 #endif 58 59 60 #ifdef YY_USE_PROTOS 61 #define YY_PROTO(proto) proto 62 #else 63 #define YY_PROTO(proto) () 64 #endif 65 66 /* Returned upon end-of-file. */ 67 #define YY_NULL 0 68 69 /* Promotes a possibly negative, possibly signed char to an unsigned 70 * integer for use as an array index. If the signed char is negative, 71 * we want to instead treat it as an 8-bit unsigned char, hence the 72 * double cast. 73 */ 74 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 75 76 /* Enter a start condition. This macro really ought to take a parameter, 77 * but we do it the disgusting crufty way forced on us by the ()-less 78 * definition of BEGIN. 79 */ 80 #define BEGIN yy_start = 1 + 2 * 81 82 /* Translate the current start state into a value that can be later handed 83 * to BEGIN to return to the state. The YYSTATE alias is for lex 84 * compatibility. 85 */ 86 #define YY_START ((yy_start - 1) / 2) 87 #define YYSTATE YY_START 88 89 /* Action number for EOF rule of a given start state. */ 90 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 91 92 /* Special action meaning "start processing a new file". */ 93 #define YY_NEW_FILE yyrestart( yyin ) 94 95 #define YY_END_OF_BUFFER_CHAR 0 96 97 /* Size of default input buffer. */ 98 #define YY_BUF_SIZE 16384 99 100 typedef struct yy_buffer_state *YY_BUFFER_STATE; 101 102 extern int yyleng; 103 extern FILE *yyin, *yyout; 104 105 #define EOB_ACT_CONTINUE_SCAN 0 106 #define EOB_ACT_END_OF_FILE 1 107 #define EOB_ACT_LAST_MATCH 2 108 109 /* The funky do-while in the following #define is used to turn the definition 110 * int a single C statement (which needs a semi-colon terminator). This 111 * avoids problems with code like: 112 * 113 * if ( condition_holds ) 114 * yyless( 5 ); 115 * else 116 * do_something_else(); 117 * 118 * Prior to using the do-while the compiler would get upset at the 119 * "else" because it interpreted the "if" statement as being all 120 * done when it reached the ';' after the yyless() call. 121 */ 122 123 /* Return all but the first 'n' matched characters back to the input stream. */ 124 125 #define yyless(n) \ 126 do \ 127 { \ 128 /* Undo effects of setting up yytext. */ \ 129 *yy_cp = yy_hold_char; \ 130 YY_RESTORE_YY_MORE_OFFSET \ 131 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ 132 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 133 } \ 134 while ( 0 ) 135 136 #define unput(c) yyunput( c, yytext_ptr ) 137 138 /* The following is because we cannot portably get our hands on size_t 139 * (without autoconf's help, which isn't available because we want 140 * flex-generated scanners to compile on their own). 141 */ 142 typedef unsigned int yy_size_t; 143 144 145 struct yy_buffer_state 146 { 147 FILE *yy_input_file; 148 149 char *yy_ch_buf; /* input buffer */ 150 char *yy_buf_pos; /* current position in input buffer */ 151 152 /* Size of input buffer in bytes, not including room for EOB 153 * characters. 154 */ 155 yy_size_t yy_buf_size; 156 157 /* Number of characters read into yy_ch_buf, not including EOB 158 * characters. 159 */ 160 int yy_n_chars; 161 162 /* Whether we "own" the buffer - i.e., we know we created it, 163 * and can xrealloc() it to grow it, and should xfree() it to 164 * delete it. 165 */ 166 int yy_is_our_buffer; 167 168 /* Whether this is an "interactive" input source; if so, and 169 * if we're using stdio for input, then we want to use getc() 170 * instead of fread(), to make sure we stop fetching input after 171 * each newline. 172 */ 173 int yy_is_interactive; 174 175 /* Whether we're considered to be at the beginning of a line. 176 * If so, '^' rules will be active on the next match, otherwise 177 * not. 178 */ 179 int yy_at_bol; 180 181 /* Whether to try to fill the input buffer when we reach the 182 * end of it. 183 */ 184 int yy_fill_buffer; 185 186 int yy_buffer_status; 187 #define YY_BUFFER_NEW 0 188 #define YY_BUFFER_NORMAL 1 189 /* When an EOF's been seen but there's still some text to process 190 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 191 * shouldn't try reading from the input source any more. We might 192 * still have a bunch of tokens to match, though, because of 193 * possible backing-up. 194 * 195 * When we actually see the EOF, we change the status to "new" 196 * (via yyrestart()), so that the user can continue scanning by 197 * just pointing yyin at a new input file. 198 */ 199 #define YY_BUFFER_EOF_PENDING 2 200 }; 201 202 static YY_BUFFER_STATE yy_current_buffer = 0; 203 204 /* We provide macros for accessing buffer states in case in the 205 * future we want to put the buffer states in a more general 206 * "scanner state". 207 */ 208 #define YY_CURRENT_BUFFER yy_current_buffer 209 210 211 /* yy_hold_char holds the character lost when yytext is formed. */ 212 static char yy_hold_char; 213 214 static int yy_n_chars; /* number of characters read into yy_ch_buf */ 215 216 217 int yyleng; 218 219 /* Points to current character in buffer. */ 220 static char *yy_c_buf_p = (char *) 0; 221 static int yy_init = 1; /* whether we need to initialize */ 222 static int yy_start = 0; /* start state number */ 223 224 /* Flag which is used to allow yywrap()'s to do buffer switches 225 * instead of setting up a fresh yyin. A bit of a hack ... 226 */ 227 static int yy_did_buffer_switch_on_eof; 228 229 void yyrestart YY_PROTO(( FILE *input_file )); 230 231 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); 232 void yy_load_buffer_state YY_PROTO(( void )); 233 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); 234 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); 235 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); 236 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); 237 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) 238 239 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); 240 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); 241 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); 242 243 static void *yy_flex_alloc YY_PROTO(( yy_size_t )); 244 static void *yyxrealloc YY_PROTO(( void *, yy_size_t )); 245 static void yy_flex_free YY_PROTO(( void * )); 246 247 #define yy_new_buffer yy_create_buffer 248 249 #define yy_set_interactive(is_interactive) \ 250 { \ 251 if ( ! yy_current_buffer ) \ 252 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 253 yy_current_buffer->yy_is_interactive = is_interactive; \ 254 } 255 256 #define yy_set_bol(at_bol) \ 257 { \ 258 if ( ! yy_current_buffer ) \ 259 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 260 yy_current_buffer->yy_at_bol = at_bol; \ 261 } 262 263 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol) 264 265 typedef unsigned char YY_CHAR; 266 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 267 typedef int yy_state_type; 268 extern char *yytext; 269 #define yytext_ptr yytext 270 271 static yy_state_type yy_get_previous_state YY_PROTO(( void )); 272 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); 273 static int yy_get_next_buffer YY_PROTO(( void )); 274 static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); 275 276 /* Done after the current pattern has been matched and before the 277 * corresponding action - sets up yytext. 278 */ 279 #define YY_DO_BEFORE_ACTION \ 280 yytext_ptr = yy_bp; \ 281 yyleng = (int) (yy_cp - yy_bp); \ 282 yy_hold_char = *yy_cp; \ 283 *yy_cp = '\0'; \ 284 yy_c_buf_p = yy_cp; 285 286 #define YY_NUM_RULES 53 287 #define YY_END_OF_BUFFER 54 288 static yyconst short int yy_accept[190] = 289 { 0, 290 0, 0, 0, 0, 54, 52, 1, 1, 15, 51, 291 41, 52, 43, 44, 41, 42, 41, 41, 41, 4, 292 4, 41, 41, 41, 41, 50, 47, 47, 47, 47, 293 47, 47, 47, 47, 47, 47, 47, 40, 0, 14, 294 0, 51, 0, 0, 0, 0, 0, 0, 0, 35, 295 2, 0, 34, 0, 46, 46, 37, 0, 0, 4, 296 0, 0, 49, 36, 38, 0, 33, 39, 0, 0, 297 47, 0, 47, 47, 47, 47, 47, 16, 20, 47, 298 47, 47, 47, 25, 47, 47, 47, 47, 47, 0, 299 14, 0, 12, 12, 0, 32, 2, 0, 46, 46, 300 301 0, 9, 0, 3, 7, 0, 47, 0, 0, 0, 302 47, 17, 18, 47, 47, 21, 22, 23, 47, 47, 303 27, 47, 47, 29, 0, 0, 0, 0, 0, 0, 304 46, 45, 6, 0, 0, 9, 0, 3, 0, 0, 305 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 306 47, 19, 47, 24, 47, 28, 30, 0, 48, 0, 307 0, 0, 0, 47, 0, 0, 0, 0, 0, 0, 308 0, 31, 47, 0, 0, 5, 11, 0, 8, 26, 309 0, 5, 0, 8, 13, 0, 10, 10, 0 310 } ; 311 312 static yyconst int yy_ec[256] = 313 { 0, 314 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 315 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 316 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 317 1, 4, 5, 6, 7, 8, 5, 9, 10, 11, 318 12, 13, 14, 15, 16, 17, 18, 19, 20, 20, 319 20, 20, 20, 20, 20, 20, 20, 21, 22, 23, 320 24, 25, 5, 26, 30, 31, 32, 33, 34, 35, 321 36, 37, 38, 36, 36, 39, 40, 41, 42, 36, 322 36, 43, 44, 45, 46, 36, 47, 48, 36, 36, 323 27, 5, 28, 5, 29, 5, 30, 31, 32, 33, 324 325 34, 35, 36, 37, 38, 36, 36, 39, 40, 41, 326 42, 36, 36, 43, 44, 45, 46, 36, 47, 48, 327 36, 36, 26, 22, 26, 5, 1, 1, 1, 1, 328 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 329 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 330 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 331 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 332 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 333 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 334 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 335 336 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 337 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 338 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 339 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 340 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 341 1, 1, 1, 1, 1 342 } ; 343 344 static yyconst int yy_meta[49] = 345 { 0, 346 1, 2, 3, 4, 5, 6, 7, 8, 5, 9, 347 5, 5, 5, 5, 5, 5, 10, 5, 11, 11, 348 5, 5, 12, 13, 14, 5, 5, 5, 15, 16, 349 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 350 17, 17, 17, 17, 17, 17, 17, 17 351 } ; 352 353 static yyconst short int yy_base[211] = 354 { 0, 355 0, 0, 592, 587, 596, 736, 736, 736, 43, 0, 356 736, 70, 736, 736, 581, 736, 576, 117, 567, 116, 357 122, 29, 566, 564, 564, 736, 52, 150, 20, 27, 358 91, 96, 124, 118, 137, 142, 145, 191, 119, 736, 359 142, 0, 238, 571, 570, 569, 567, 54, 277, 736, 360 0, 324, 736, 0, 0, 537, 736, 0, 46, 155, 361 230, 0, 736, 736, 736, 534, 736, 736, 243, 249, 362 736, 327, 149, 223, 224, 257, 258, 259, 261, 262, 363 301, 304, 265, 303, 315, 320, 324, 322, 326, 541, 364 543, 368, 371, 736, 374, 526, 0, 509, 0, 453, 365 366 359, 361, 111, 358, 0, 458, 381, 397, 412, 0, 367 412, 355, 371, 393, 400, 382, 402, 407, 408, 425, 368 409, 420, 431, 426, 471, 0, 466, 450, 469, 433, 369 736, 0, 412, 0, 456, 456, 242, 462, 439, 330, 370 237, 358, 373, 433, 390, 377, 375, 383, 346, 337, 371 476, 453, 464, 465, 466, 477, 479, 331, 736, 334, 372 497, 331, 124, 511, 261, 261, 258, 156, 148, 114, 373 103, 481, 488, 96, 243, 504, 33, 56, 506, 496, 374 42, 511, 323, 519, 539, 391, 525, 527, 736, 557, 375 567, 583, 588, 604, 621, 624, 631, 166, 539, 638, 376 377 654, 666, 672, 683, 685, 701, 541, 542, 708, 719 378 } ; 379 380 static yyconst short int yy_def[211] = 381 { 0, 382 189, 1, 1, 1, 189, 189, 189, 189, 190, 191, 383 189, 189, 189, 189, 189, 189, 189, 192, 189, 189, 384 189, 189, 193, 189, 189, 189, 194, 194, 28, 28, 385 28, 28, 28, 28, 28, 28, 28, 189, 190, 189, 386 190, 191, 38, 38, 38, 43, 189, 43, 43, 189, 387 195, 192, 189, 196, 197, 197, 189, 198, 189, 189, 388 189, 199, 189, 189, 189, 200, 189, 189, 189, 189, 389 189, 201, 28, 28, 28, 28, 28, 28, 28, 28, 390 28, 28, 28, 28, 28, 28, 28, 28, 28, 49, 391 202, 189, 189, 189, 43, 49, 195, 203, 197, 197, 392 393 204, 189, 189, 189, 199, 200, 189, 201, 189, 205, 394 206, 28, 28, 28, 28, 28, 28, 28, 28, 28, 395 28, 28, 28, 28, 189, 207, 189, 189, 43, 203, 396 189, 197, 189, 208, 204, 189, 189, 189, 189, 189, 397 189, 189, 189, 189, 189, 189, 189, 189, 189, 209, 398 206, 28, 28, 28, 28, 28, 28, 189, 189, 43, 399 189, 210, 189, 189, 189, 189, 189, 189, 189, 189, 400 209, 28, 28, 43, 189, 189, 189, 210, 189, 28, 401 43, 189, 189, 189, 189, 189, 189, 189, 0, 189, 402 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 403 404 189, 189, 189, 189, 189, 189, 189, 189, 189, 189 405 } ; 406 407 static yyconst short int yy_nxt[785] = 408 { 0, 409 6, 7, 8, 7, 6, 9, 6, 10, 11, 12, 410 13, 14, 15, 11, 16, 17, 18, 19, 20, 21, 411 22, 11, 23, 24, 25, 26, 11, 11, 27, 28, 412 27, 27, 27, 29, 30, 27, 27, 31, 27, 32, 413 33, 34, 35, 27, 36, 27, 27, 37, 40, 63, 414 73, 185, 64, 69, 69, 70, 77, 73, 76, 95, 415 73, 71, 177, 93, 102, 102, 183, 73, 72, 41, 416 43, 44, 44, 45, 46, 46, 46, 46, 46, 47, 417 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 418 46, 46, 46, 46, 46, 46, 48, 46, 46, 49, 419 420 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 421 49, 49, 49, 49, 49, 49, 49, 49, 52, 52, 422 52, 73, 58, 181, 40, 78, 73, 164, 58, 104, 423 104, 79, 59, 53, 60, 60, 73, 80, 59, 54, 424 60, 60, 179, 179, 60, 41, 56, 91, 73, 61, 425 60, 69, 69, 70, 73, 61, 139, 81, 73, 71, 426 84, 58, 85, 62, 73, 82, 72, 73, 41, 83, 427 86, 59, 73, 60, 60, 73, 101, 73, 87, 73, 428 74, 101, 73, 60, 88, 73, 89, 139, 61, 73, 429 75, 43, 44, 44, 44, 43, 43, 43, 43, 43, 430 431 139, 43, 43, 43, 43, 43, 43, 43, 43, 43, 432 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 433 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 434 90, 90, 90, 90, 90, 90, 90, 90, 90, 43, 435 43, 43, 164, 103, 69, 69, 69, 92, 104, 104, 436 69, 69, 70, 73, 73, 163, 113, 163, 71, 72, 437 139, 176, 176, 73, 73, 72, 112, 43, 43, 43, 438 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 439 43, 43, 43, 43, 43, 43, 93, 73, 73, 73, 440 139, 73, 73, 139, 116, 73, 115, 73, 73, 73, 441 442 114, 73, 73, 119, 139, 73, 96, 96, 96, 96, 443 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 444 96, 96, 96, 96, 96, 52, 52, 52, 108, 108, 445 108, 73, 109, 73, 73, 164, 186, 177, 186, 174, 446 189, 73, 139, 73, 73, 73, 54, 117, 118, 110, 447 73, 120, 73, 56, 73, 73, 73, 122, 39, 121, 448 73, 164, 73, 164, 73, 133, 73, 123, 124, 127, 449 127, 127, 127, 127, 127, 134, 138, 138, 164, 136, 450 136, 139, 69, 69, 70, 73, 138, 170, 128, 136, 451 71, 128, 129, 129, 137, 73, 139, 72, 108, 108, 452 453 108, 73, 109, 129, 129, 129, 129, 129, 129, 187, 454 187, 73, 73, 69, 69, 70, 169, 139, 168, 110, 455 139, 71, 73, 73, 140, 139, 152, 139, 72, 141, 456 73, 167, 73, 73, 142, 139, 143, 73, 73, 73, 457 73, 144, 73, 153, 164, 161, 154, 73, 73, 73, 458 73, 145, 146, 147, 148, 73, 73, 131, 155, 149, 459 156, 73, 133, 165, 157, 73, 73, 127, 127, 127, 460 159, 73, 134, 166, 136, 136, 158, 69, 69, 70, 461 138, 138, 107, 73, 136, 71, 128, 160, 160, 137, 462 138, 132, 72, 73, 73, 73, 73, 172, 160, 160, 463 464 160, 160, 160, 160, 73, 73, 73, 73, 173, 73, 465 175, 73, 69, 69, 70, 176, 176, 73, 73, 73, 466 71, 73, 182, 182, 184, 184, 73, 72, 73, 182, 467 182, 180, 182, 131, 184, 92, 73, 184, 184, 182, 468 127, 127, 127, 188, 188, 188, 188, 184, 125, 105, 469 92, 125, 162, 188, 105, 188, 125, 162, 107, 128, 470 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 471 39, 39, 39, 39, 42, 100, 94, 42, 93, 93, 472 92, 42, 42, 42, 55, 55, 55, 68, 67, 65, 473 57, 51, 55, 50, 55, 189, 38, 55, 55, 55, 474 475 66, 38, 66, 66, 66, 73, 73, 73, 189, 189, 476 189, 189, 73, 73, 73, 189, 189, 189, 73, 73, 477 73, 97, 97, 189, 97, 97, 97, 97, 97, 97, 478 97, 97, 97, 97, 97, 97, 97, 97, 98, 98, 479 98, 99, 189, 189, 189, 99, 99, 99, 106, 189, 480 189, 106, 106, 106, 106, 111, 111, 111, 189, 111, 481 189, 189, 189, 189, 189, 111, 189, 189, 111, 111, 482 111, 126, 189, 189, 189, 189, 126, 189, 189, 189, 483 189, 126, 130, 189, 189, 130, 130, 130, 130, 135, 484 189, 189, 135, 135, 189, 189, 189, 135, 135, 150, 485 486 150, 150, 151, 151, 151, 189, 189, 189, 189, 151, 487 151, 151, 189, 189, 189, 151, 151, 151, 171, 189, 488 189, 171, 171, 171, 171, 178, 189, 189, 189, 178, 489 189, 189, 189, 178, 178, 5, 189, 189, 189, 189, 490 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 491 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 492 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 493 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 494 189, 189, 189, 189 495 } ; 496 497 static yyconst short int yy_chk[785] = 498 { 0, 499 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 500 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 501 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 502 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 503 1, 1, 1, 1, 1, 1, 1, 1, 9, 22, 504 29, 181, 22, 27, 27, 27, 30, 30, 29, 48, 505 29, 27, 178, 48, 59, 59, 177, 30, 27, 9, 506 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 507 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 508 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 509 510 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 511 12, 12, 12, 12, 12, 12, 12, 12, 18, 18, 512 18, 31, 20, 174, 39, 31, 32, 171, 21, 103, 513 103, 31, 20, 18, 20, 20, 32, 32, 21, 18, 514 21, 21, 163, 163, 20, 39, 18, 41, 34, 20, 515 21, 28, 28, 28, 33, 21, 170, 33, 34, 28, 516 34, 60, 34, 20, 33, 33, 28, 35, 41, 33, 517 35, 60, 36, 60, 60, 37, 198, 35, 36, 73, 518 28, 198, 36, 60, 36, 37, 37, 169, 60, 73, 519 28, 38, 38, 38, 38, 38, 38, 38, 38, 38, 520 521 168, 38, 38, 38, 38, 38, 38, 38, 38, 38, 522 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 523 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 524 38, 38, 38, 38, 38, 38, 38, 38, 38, 43, 525 43, 43, 141, 61, 69, 69, 69, 43, 61, 61, 526 70, 70, 70, 74, 75, 137, 75, 137, 70, 69, 527 141, 175, 175, 74, 75, 70, 74, 43, 43, 43, 528 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 529 43, 43, 43, 43, 43, 43, 49, 76, 77, 78, 530 167, 79, 80, 166, 80, 83, 77, 76, 77, 78, 531 532 76, 79, 80, 83, 165, 83, 49, 49, 49, 49, 533 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 534 49, 49, 49, 49, 49, 52, 52, 52, 72, 72, 535 72, 81, 72, 84, 82, 140, 183, 162, 183, 160, 536 52, 81, 140, 84, 82, 85, 52, 81, 82, 72, 537 86, 85, 88, 52, 87, 85, 89, 87, 158, 86, 538 86, 150, 88, 142, 87, 101, 89, 88, 89, 92, 539 92, 92, 93, 93, 93, 101, 104, 104, 143, 102, 540 102, 142, 107, 107, 107, 112, 104, 149, 92, 102, 541 107, 93, 95, 95, 102, 112, 143, 107, 108, 108, 542 543 108, 113, 108, 95, 95, 95, 95, 95, 95, 186, 544 186, 113, 116, 111, 111, 111, 148, 147, 146, 108, 545 109, 111, 116, 114, 109, 109, 114, 109, 111, 109, 546 115, 145, 117, 114, 109, 109, 109, 118, 119, 121, 547 115, 109, 117, 115, 139, 133, 119, 118, 119, 121, 548 122, 109, 109, 109, 109, 120, 124, 130, 120, 109, 549 122, 123, 135, 144, 123, 120, 124, 127, 127, 127, 550 128, 123, 135, 144, 136, 136, 125, 151, 151, 151, 551 138, 138, 106, 152, 136, 151, 127, 129, 129, 136, 552 138, 100, 151, 152, 153, 154, 155, 153, 129, 129, 553 554 129, 129, 129, 129, 153, 154, 155, 156, 155, 157, 555 161, 172, 164, 164, 164, 161, 161, 156, 173, 157, 556 164, 172, 176, 176, 179, 179, 180, 164, 173, 182, 557 182, 173, 176, 98, 179, 96, 180, 184, 184, 182, 558 185, 185, 185, 187, 187, 188, 188, 184, 91, 199, 559 90, 207, 208, 187, 199, 188, 207, 208, 66, 185, 560 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, 561 190, 190, 190, 190, 191, 56, 47, 191, 46, 45, 562 44, 191, 191, 191, 192, 192, 192, 25, 24, 23, 563 19, 17, 192, 15, 192, 5, 4, 192, 192, 192, 564 565 193, 3, 193, 193, 193, 194, 194, 194, 0, 0, 566 0, 0, 194, 194, 194, 0, 0, 0, 194, 194, 567 194, 195, 195, 0, 195, 195, 195, 195, 195, 195, 568 195, 195, 195, 195, 195, 195, 195, 195, 196, 196, 569 196, 197, 0, 0, 0, 197, 197, 197, 200, 0, 570 0, 200, 200, 200, 200, 201, 201, 201, 0, 201, 571 0, 0, 0, 0, 0, 201, 0, 0, 201, 201, 572 201, 202, 0, 0, 0, 0, 202, 0, 0, 0, 573 0, 202, 203, 0, 0, 203, 203, 203, 203, 204, 574 0, 0, 204, 204, 0, 0, 0, 204, 204, 205, 575 576 205, 205, 206, 206, 206, 0, 0, 0, 0, 206, 577 206, 206, 0, 0, 0, 206, 206, 206, 209, 0, 578 0, 209, 209, 209, 209, 210, 0, 0, 0, 210, 579 0, 0, 0, 210, 210, 189, 189, 189, 189, 189, 580 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 581 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 582 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 583 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 584 189, 189, 189, 189 585 } ; 586 587 static yy_state_type yy_last_accepting_state; 588 static char *yy_last_accepting_cpos; 589 590 /* The intent behind this definition is that it'll catch 591 * any uses of REJECT which flex missed. 592 */ 593 #define REJECT reject_used_but_not_detected 594 #define yymore() yymore_used_but_not_detected 595 #define YY_MORE_ADJ 0 596 #define YY_RESTORE_YY_MORE_OFFSET 597 char *yytext; 598 #line 1 "ada-lex.l" 599 #define INITIAL 0 600 /* FLEX lexer for Ada expressions, for GDB. 601 Copyright (C) 1994, 1997, 1998, 2000, 2001, 2002, 2003, 2007, 2008, 2009 602 Free Software Foundation, Inc. 603 604 This file is part of GDB. 605 606 This program is free software; you can redistribute it and/or modify 607 it under the terms of the GNU General Public License as published by 608 the Free Software Foundation; either version 3 of the License, or 609 (at your option) any later version. 610 611 This program is distributed in the hope that it will be useful, 612 but WITHOUT ANY WARRANTY; without even the implied warranty of 613 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 614 GNU General Public License for more details. 615 616 You should have received a copy of the GNU General Public License 617 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 618 /*----------------------------------------------------------------------*/ 619 /* The converted version of this file is to be included in ada-exp.y, */ 620 /* the Ada parser for gdb. The function yylex obtains characters from */ 621 /* the global pointer lexptr. It returns a syntactic category for */ 622 /* each successive token and places a semantic value into yylval */ 623 /* (ada-lval), defined by the parser. */ 624 #line 44 "ada-lex.l" 625 626 #define NUMERAL_WIDTH 256 627 #define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1)) 628 629 /* Temporary staging for numeric literals. */ 630 static char numbuf[NUMERAL_WIDTH]; 631 static void canonicalizeNumeral (char *s1, const char *); 632 static struct stoken processString (const char*, int); 633 static int processInt (const char *, const char *, const char *); 634 static int processReal (const char *); 635 static struct stoken processId (const char *, int); 636 static int processAttribute (const char *); 637 static int find_dot_all (const char *); 638 639 #undef YY_DECL 640 #define YY_DECL static int yylex ( void ) 641 642 #undef YY_INPUT 643 #define YY_INPUT(BUF, RESULT, MAX_SIZE) \ 644 if ( *lexptr == '\000' ) \ 645 (RESULT) = YY_NULL; \ 646 else \ 647 { \ 648 *(BUF) = *lexptr; \ 649 (RESULT) = 1; \ 650 lexptr += 1; \ 651 } 652 653 static int find_dot_all (const char *); 654 655 #define BEFORE_QUAL_QUOTE 1 656 657 #line 658 "ada-lex.c" 658 659 /* Macros after this point can all be overridden by user definitions in 660 * section 1. 661 */ 662 663 #ifndef YY_SKIP_YYWRAP 664 #ifdef __cplusplus 665 extern "C" int yywrap YY_PROTO(( void )); 666 #else 667 extern int yywrap YY_PROTO(( void )); 668 #endif 669 #endif 670 671 #ifndef YY_NO_UNPUT 672 static void yyunput YY_PROTO(( int c, char *buf_ptr )); 673 #endif 674 675 #ifndef yytext_ptr 676 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); 677 #endif 678 679 #ifdef YY_NEED_STRLEN 680 static int yy_flex_strlen YY_PROTO(( yyconst char * )); 681 #endif 682 683 #ifndef YY_NO_INPUT 684 #ifdef __cplusplus 685 static int yyinput YY_PROTO(( void )); 686 #else 687 static int input YY_PROTO(( void )); 688 #endif 689 #endif 690 691 #if YY_STACK_USED 692 static int yy_start_stack_ptr = 0; 693 static int yy_start_stack_depth = 0; 694 static int *yy_start_stack = 0; 695 #ifndef YY_NO_PUSH_STATE 696 static void yy_push_state YY_PROTO(( int new_state )); 697 #endif 698 #ifndef YY_NO_POP_STATE 699 static void yy_pop_state YY_PROTO(( void )); 700 #endif 701 #ifndef YY_NO_TOP_STATE 702 static int yy_top_state YY_PROTO(( void )); 703 #endif 704 705 #else 706 #define YY_NO_PUSH_STATE 1 707 #define YY_NO_POP_STATE 1 708 #define YY_NO_TOP_STATE 1 709 #endif 710 711 #ifdef YY_MALLOC_DECL 712 YY_MALLOC_DECL 713 #else 714 #if __STDC__ 715 #ifndef __cplusplus 716 #include <stdlib.h> 717 #endif 718 #else 719 /* Just try to get by without declaring the routines. This will fail 720 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) 721 * or sizeof(void*) != sizeof(int). 722 */ 723 #endif 724 #endif 725 726 /* Amount of stuff to slurp up with each read. */ 727 #ifndef YY_READ_BUF_SIZE 728 #define YY_READ_BUF_SIZE 8192 729 #endif 730 731 /* Copy whatever the last rule matched to the standard output. */ 732 733 #ifndef ECHO 734 /* This used to be an fputs(), but since the string might contain NUL's, 735 * we now use fwrite(). 736 */ 737 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 738 #endif 739 740 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 741 * is returned in "result". 742 */ 743 #ifndef YY_INPUT 744 #define YY_INPUT(buf,result,max_size) \ 745 if ( yy_current_buffer->yy_is_interactive ) \ 746 { \ 747 int c = '*', n; \ 748 for ( n = 0; n < max_size && \ 749 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 750 buf[n] = (char) c; \ 751 if ( c == '\n' ) \ 752 buf[n++] = (char) c; \ 753 if ( c == EOF && ferror( yyin ) ) \ 754 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 755 result = n; \ 756 } \ 757 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ 758 && ferror( yyin ) ) \ 759 YY_FATAL_ERROR( "input in flex scanner failed" ); 760 #endif 761 762 /* No semi-colon after return; correct usage is to write "yyterminate();" - 763 * we don't want an extra ';' after the "return" because that will cause 764 * some compilers to complain about unreachable statements. 765 */ 766 #ifndef yyterminate 767 #define yyterminate() return YY_NULL 768 #endif 769 770 /* Number of entries by which start-condition stack grows. */ 771 #ifndef YY_START_STACK_INCR 772 #define YY_START_STACK_INCR 25 773 #endif 774 775 /* Report a fatal error. */ 776 #ifndef YY_FATAL_ERROR 777 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 778 #endif 779 780 /* Default declaration of generated scanner - a define so the user can 781 * easily add parameters. 782 */ 783 #ifndef YY_DECL 784 #define YY_DECL int yylex YY_PROTO(( void )) 785 #endif 786 787 /* Code executed at the beginning of each rule, after yytext and yyleng 788 * have been set up. 789 */ 790 #ifndef YY_USER_ACTION 791 #define YY_USER_ACTION 792 #endif 793 794 /* Code executed at the end of each rule. */ 795 #ifndef YY_BREAK 796 #define YY_BREAK break; 797 #endif 798 799 #define YY_RULE_SETUP \ 800 YY_USER_ACTION 801 802 YY_DECL 803 { 804 register yy_state_type yy_current_state; 805 register char *yy_cp = NULL, *yy_bp = NULL; 806 register int yy_act; 807 808 #line 80 "ada-lex.l" 809 810 811 #line 812 "ada-lex.c" 812 813 if ( yy_init ) 814 { 815 yy_init = 0; 816 817 #ifdef YY_USER_INIT 818 YY_USER_INIT; 819 #endif 820 821 if ( ! yy_start ) 822 yy_start = 1; /* first start state */ 823 824 if ( ! yyin ) 825 yyin = stdin; 826 827 if ( ! yyout ) 828 yyout = stdout; 829 830 if ( ! yy_current_buffer ) 831 yy_current_buffer = 832 yy_create_buffer( yyin, YY_BUF_SIZE ); 833 834 yy_load_buffer_state(); 835 } 836 837 while ( 1 ) /* loops until end-of-file is reached */ 838 { 839 yy_cp = yy_c_buf_p; 840 841 /* Support of yytext. */ 842 *yy_cp = yy_hold_char; 843 844 /* yy_bp points to the position in yy_ch_buf of the start of 845 * the current run. 846 */ 847 yy_bp = yy_cp; 848 849 yy_current_state = yy_start; 850 yy_match: 851 do 852 { 853 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 854 if ( yy_accept[yy_current_state] ) 855 { 856 yy_last_accepting_state = yy_current_state; 857 yy_last_accepting_cpos = yy_cp; 858 } 859 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 860 { 861 yy_current_state = (int) yy_def[yy_current_state]; 862 if ( yy_current_state >= 190 ) 863 yy_c = yy_meta[(unsigned int) yy_c]; 864 } 865 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 866 ++yy_cp; 867 } 868 while ( yy_base[yy_current_state] != 736 ); 869 870 yy_find_action: 871 yy_act = yy_accept[yy_current_state]; 872 if ( yy_act == 0 ) 873 { /* have to back up */ 874 yy_cp = yy_last_accepting_cpos; 875 yy_current_state = yy_last_accepting_state; 876 yy_act = yy_accept[yy_current_state]; 877 } 878 879 YY_DO_BEFORE_ACTION; 880 881 882 do_action: /* This label is used only to access EOF actions. */ 883 884 885 switch ( yy_act ) 886 { /* beginning of action switch */ 887 case 0: /* must back up */ 888 /* undo the effects of YY_DO_BEFORE_ACTION */ 889 *yy_cp = yy_hold_char; 890 yy_cp = yy_last_accepting_cpos; 891 yy_current_state = yy_last_accepting_state; 892 goto yy_find_action; 893 894 case 1: 895 YY_RULE_SETUP 896 #line 82 "ada-lex.l" 897 { } 898 YY_BREAK 899 case 2: 900 YY_RULE_SETUP 901 #line 84 "ada-lex.l" 902 { yyterminate(); } 903 YY_BREAK 904 case 3: 905 YY_RULE_SETUP 906 #line 86 "ada-lex.l" 907 { 908 canonicalizeNumeral (numbuf, yytext); 909 return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1); 910 } 911 YY_BREAK 912 case 4: 913 YY_RULE_SETUP 914 #line 91 "ada-lex.l" 915 { 916 canonicalizeNumeral (numbuf, yytext); 917 return processInt (NULL, numbuf, NULL); 918 } 919 YY_BREAK 920 case 5: 921 YY_RULE_SETUP 922 #line 96 "ada-lex.l" 923 { 924 canonicalizeNumeral (numbuf, yytext); 925 return processInt (numbuf, 926 strchr (numbuf, '#') + 1, 927 strrchr(numbuf, '#') + 1); 928 } 929 YY_BREAK 930 case 6: 931 YY_RULE_SETUP 932 #line 103 "ada-lex.l" 933 { 934 canonicalizeNumeral (numbuf, yytext); 935 return processInt (numbuf, strchr (numbuf, '#') + 1, NULL); 936 } 937 YY_BREAK 938 case 7: 939 YY_RULE_SETUP 940 #line 108 "ada-lex.l" 941 { 942 canonicalizeNumeral (numbuf, yytext+2); 943 return processInt ("16#", numbuf, NULL); 944 } 945 YY_BREAK 946 case 8: 947 YY_RULE_SETUP 948 #line 114 "ada-lex.l" 949 { 950 canonicalizeNumeral (numbuf, yytext); 951 return processReal (numbuf); 952 } 953 YY_BREAK 954 case 9: 955 YY_RULE_SETUP 956 #line 119 "ada-lex.l" 957 { 958 canonicalizeNumeral (numbuf, yytext); 959 return processReal (numbuf); 960 } 961 YY_BREAK 962 case 10: 963 YY_RULE_SETUP 964 #line 124 "ada-lex.l" 965 { 966 error (_("Based real literals not implemented yet.")); 967 } 968 YY_BREAK 969 case 11: 970 YY_RULE_SETUP 971 #line 128 "ada-lex.l" 972 { 973 error (_("Based real literals not implemented yet.")); 974 } 975 YY_BREAK 976 case 12: 977 YY_RULE_SETUP 978 #line 132 "ada-lex.l" 979 { 980 yylval.typed_val.type = type_char (); 981 yylval.typed_val.val = yytext[1]; 982 return CHARLIT; 983 } 984 YY_BREAK 985 case 13: 986 YY_RULE_SETUP 987 #line 138 "ada-lex.l" 988 { 989 int v; 990 yylval.typed_val.type = type_char (); 991 sscanf (yytext+3, "%2x", &v); 992 yylval.typed_val.val = v; 993 return CHARLIT; 994 } 995 YY_BREAK 996 case 14: 997 YY_RULE_SETUP 998 #line 146 "ada-lex.l" 999 { 1000 yylval.sval = processString (yytext+1, yyleng-2); 1001 return STRING; 1002 } 1003 YY_BREAK 1004 case 15: 1005 YY_RULE_SETUP 1006 #line 151 "ada-lex.l" 1007 { 1008 error (_("ill-formed or non-terminated string literal")); 1009 } 1010 YY_BREAK 1011 case 16: 1012 YY_RULE_SETUP 1013 #line 156 "ada-lex.l" 1014 { 1015 while (*lexptr != 'i' && *lexptr != 'I') 1016 lexptr -= 1; 1017 yyrestart(NULL); 1018 return 0; 1019 } 1020 YY_BREAK 1021 /* ADA KEYWORDS */ 1022 case 17: 1023 YY_RULE_SETUP 1024 #line 165 "ada-lex.l" 1025 { return ABS; } 1026 YY_BREAK 1027 case 18: 1028 YY_RULE_SETUP 1029 #line 166 "ada-lex.l" 1030 { return _AND_; } 1031 YY_BREAK 1032 case 19: 1033 YY_RULE_SETUP 1034 #line 167 "ada-lex.l" 1035 { return ELSE; } 1036 YY_BREAK 1037 case 20: 1038 YY_RULE_SETUP 1039 #line 168 "ada-lex.l" 1040 { return IN; } 1041 YY_BREAK 1042 case 21: 1043 YY_RULE_SETUP 1044 #line 169 "ada-lex.l" 1045 { return MOD; } 1046 YY_BREAK 1047 case 22: 1048 YY_RULE_SETUP 1049 #line 170 "ada-lex.l" 1050 { return NEW; } 1051 YY_BREAK 1052 case 23: 1053 YY_RULE_SETUP 1054 #line 171 "ada-lex.l" 1055 { return NOT; } 1056 YY_BREAK 1057 case 24: 1058 YY_RULE_SETUP 1059 #line 172 "ada-lex.l" 1060 { return NULL_PTR; } 1061 YY_BREAK 1062 case 25: 1063 YY_RULE_SETUP 1064 #line 173 "ada-lex.l" 1065 { return OR; } 1066 YY_BREAK 1067 case 26: 1068 YY_RULE_SETUP 1069 #line 174 "ada-lex.l" 1070 { return OTHERS; } 1071 YY_BREAK 1072 case 27: 1073 YY_RULE_SETUP 1074 #line 175 "ada-lex.l" 1075 { return REM; } 1076 YY_BREAK 1077 case 28: 1078 YY_RULE_SETUP 1079 #line 176 "ada-lex.l" 1080 { return THEN; } 1081 YY_BREAK 1082 case 29: 1083 YY_RULE_SETUP 1084 #line 177 "ada-lex.l" 1085 { return XOR; } 1086 YY_BREAK 1087 /* BOOLEAN "KEYWORDS" */ 1088 /* True and False are not keywords in Ada, but rather enumeration constants. 1089 However, the boolean type is no longer represented as an enum, so True 1090 and False are no longer defined in symbol tables. We compromise by 1091 making them keywords (when bare). */ 1092 case 30: 1093 YY_RULE_SETUP 1094 #line 186 "ada-lex.l" 1095 { return TRUEKEYWORD; } 1096 YY_BREAK 1097 case 31: 1098 YY_RULE_SETUP 1099 #line 187 "ada-lex.l" 1100 { return FALSEKEYWORD; } 1101 YY_BREAK 1102 /* ATTRIBUTES */ 1103 case 32: 1104 YY_RULE_SETUP 1105 #line 191 "ada-lex.l" 1106 { return processAttribute (yytext+1); } 1107 YY_BREAK 1108 /* PUNCTUATION */ 1109 case 33: 1110 YY_RULE_SETUP 1111 #line 195 "ada-lex.l" 1112 { return ARROW; } 1113 YY_BREAK 1114 case 34: 1115 YY_RULE_SETUP 1116 #line 196 "ada-lex.l" 1117 { return DOTDOT; } 1118 YY_BREAK 1119 case 35: 1120 YY_RULE_SETUP 1121 #line 197 "ada-lex.l" 1122 { return STARSTAR; } 1123 YY_BREAK 1124 case 36: 1125 YY_RULE_SETUP 1126 #line 198 "ada-lex.l" 1127 { return ASSIGN; } 1128 YY_BREAK 1129 case 37: 1130 YY_RULE_SETUP 1131 #line 199 "ada-lex.l" 1132 { return NOTEQUAL; } 1133 YY_BREAK 1134 case 38: 1135 YY_RULE_SETUP 1136 #line 200 "ada-lex.l" 1137 { return LEQ; } 1138 YY_BREAK 1139 case 39: 1140 YY_RULE_SETUP 1141 #line 201 "ada-lex.l" 1142 { return GEQ; } 1143 YY_BREAK 1144 case 40: 1145 YY_RULE_SETUP 1146 #line 203 "ada-lex.l" 1147 { BEGIN INITIAL; return '\''; } 1148 YY_BREAK 1149 case 41: 1150 YY_RULE_SETUP 1151 #line 205 "ada-lex.l" 1152 { return yytext[0]; } 1153 YY_BREAK 1154 case 42: 1155 YY_RULE_SETUP 1156 #line 207 "ada-lex.l" 1157 { if (paren_depth == 0 && comma_terminates) 1158 { 1159 lexptr -= 1; 1160 yyrestart(NULL); 1161 return 0; 1162 } 1163 else 1164 return ','; 1165 } 1166 YY_BREAK 1167 case 43: 1168 YY_RULE_SETUP 1169 #line 217 "ada-lex.l" 1170 { paren_depth += 1; return '('; } 1171 YY_BREAK 1172 case 44: 1173 YY_RULE_SETUP 1174 #line 218 "ada-lex.l" 1175 { if (paren_depth == 0) 1176 { 1177 lexptr -= 1; 1178 yyrestart(NULL); 1179 return 0; 1180 } 1181 else 1182 { 1183 paren_depth -= 1; 1184 return ')'; 1185 } 1186 } 1187 YY_BREAK 1188 case 45: 1189 YY_RULE_SETUP 1190 #line 231 "ada-lex.l" 1191 { return DOT_ALL; } 1192 YY_BREAK 1193 case 46: 1194 YY_RULE_SETUP 1195 #line 233 "ada-lex.l" 1196 { 1197 yylval.sval = processId (yytext+1, yyleng-1); 1198 return DOT_ID; 1199 } 1200 YY_BREAK 1201 case 47: 1202 YY_RULE_SETUP 1203 #line 238 "ada-lex.l" 1204 { 1205 int all_posn = find_dot_all (yytext); 1206 1207 if (all_posn == -1 && yytext[yyleng-1] == '\'') 1208 { 1209 BEGIN BEFORE_QUAL_QUOTE; 1210 yyless (yyleng-1); 1211 } 1212 else if (all_posn >= 0) 1213 yyless (all_posn); 1214 yylval.sval = processId (yytext, yyleng); 1215 return NAME; 1216 } 1217 YY_BREAK 1218 /* GDB EXPRESSION CONSTRUCTS */ 1219 case 48: 1220 YY_RULE_SETUP 1221 #line 255 "ada-lex.l" 1222 { 1223 yyless (yyleng - 2); 1224 yylval.sval = processId (yytext, yyleng); 1225 return NAME; 1226 } 1227 YY_BREAK 1228 case 49: 1229 YY_RULE_SETUP 1230 #line 261 "ada-lex.l" 1231 { return COLONCOLON; } 1232 YY_BREAK 1233 case 50: 1234 YY_RULE_SETUP 1235 #line 263 "ada-lex.l" 1236 { return yytext[0]; } 1237 YY_BREAK 1238 /* REGISTERS AND GDB CONVENIENCE VARIABLES */ 1239 case 51: 1240 YY_RULE_SETUP 1241 #line 267 "ada-lex.l" 1242 { 1243 yylval.sval.ptr = yytext; 1244 yylval.sval.length = yyleng; 1245 return SPECIAL_VARIABLE; 1246 } 1247 YY_BREAK 1248 /* CATCH-ALL ERROR CASE */ 1249 case 52: 1250 YY_RULE_SETUP 1251 #line 275 "ada-lex.l" 1252 { error (_("Invalid character '%s' in expression."), yytext); } 1253 YY_BREAK 1254 case 53: 1255 YY_RULE_SETUP 1256 #line 276 "ada-lex.l" 1257 YY_FATAL_ERROR( "flex scanner jammed" ); 1258 YY_BREAK 1259 #line 1260 "ada-lex.c" 1260 case YY_STATE_EOF(INITIAL): 1261 case YY_STATE_EOF(BEFORE_QUAL_QUOTE): 1262 yyterminate(); 1263 1264 case YY_END_OF_BUFFER: 1265 { 1266 /* Amount of text matched not including the EOB char. */ 1267 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; 1268 1269 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1270 *yy_cp = yy_hold_char; 1271 YY_RESTORE_YY_MORE_OFFSET 1272 1273 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) 1274 { 1275 /* We're scanning a new file or input source. It's 1276 * possible that this happened because the user 1277 * just pointed yyin at a new source and called 1278 * yylex(). If so, then we have to assure 1279 * consistency between yy_current_buffer and our 1280 * globals. Here is the right place to do so, because 1281 * this is the first action (other than possibly a 1282 * back-up) that will match for the new input source. 1283 */ 1284 yy_n_chars = yy_current_buffer->yy_n_chars; 1285 yy_current_buffer->yy_input_file = yyin; 1286 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; 1287 } 1288 1289 /* Note that here we test for yy_c_buf_p "<=" to the position 1290 * of the first EOB in the buffer, since yy_c_buf_p will 1291 * already have been incremented past the NUL character 1292 * (since all states make transitions on EOB to the 1293 * end-of-buffer state). Contrast this with the test 1294 * in input(). 1295 */ 1296 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1297 { /* This was really a NUL. */ 1298 yy_state_type yy_next_state; 1299 1300 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; 1301 1302 yy_current_state = yy_get_previous_state(); 1303 1304 /* Okay, we're now positioned to make the NUL 1305 * transition. We couldn't have 1306 * yy_get_previous_state() go ahead and do it 1307 * for us because it doesn't know how to deal 1308 * with the possibility of jamming (and we don't 1309 * want to build jamming into it because then it 1310 * will run more slowly). 1311 */ 1312 1313 yy_next_state = yy_try_NUL_trans( yy_current_state ); 1314 1315 yy_bp = yytext_ptr + YY_MORE_ADJ; 1316 1317 if ( yy_next_state ) 1318 { 1319 /* Consume the NUL. */ 1320 yy_cp = ++yy_c_buf_p; 1321 yy_current_state = yy_next_state; 1322 goto yy_match; 1323 } 1324 1325 else 1326 { 1327 yy_cp = yy_c_buf_p; 1328 goto yy_find_action; 1329 } 1330 } 1331 1332 else switch ( yy_get_next_buffer() ) 1333 { 1334 case EOB_ACT_END_OF_FILE: 1335 { 1336 yy_did_buffer_switch_on_eof = 0; 1337 1338 if ( yywrap() ) 1339 { 1340 /* Note: because we've taken care in 1341 * yy_get_next_buffer() to have set up 1342 * yytext, we can now set up 1343 * yy_c_buf_p so that if some total 1344 * hoser (like flex itself) wants to 1345 * call the scanner after we return the 1346 * YY_NULL, it'll still work - another 1347 * YY_NULL will get returned. 1348 */ 1349 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; 1350 1351 yy_act = YY_STATE_EOF(YY_START); 1352 goto do_action; 1353 } 1354 1355 else 1356 { 1357 if ( ! yy_did_buffer_switch_on_eof ) 1358 YY_NEW_FILE; 1359 } 1360 break; 1361 } 1362 1363 case EOB_ACT_CONTINUE_SCAN: 1364 yy_c_buf_p = 1365 yytext_ptr + yy_amount_of_matched_text; 1366 1367 yy_current_state = yy_get_previous_state(); 1368 1369 yy_cp = yy_c_buf_p; 1370 yy_bp = yytext_ptr + YY_MORE_ADJ; 1371 goto yy_match; 1372 1373 case EOB_ACT_LAST_MATCH: 1374 yy_c_buf_p = 1375 &yy_current_buffer->yy_ch_buf[yy_n_chars]; 1376 1377 yy_current_state = yy_get_previous_state(); 1378 1379 yy_cp = yy_c_buf_p; 1380 yy_bp = yytext_ptr + YY_MORE_ADJ; 1381 goto yy_find_action; 1382 } 1383 break; 1384 } 1385 1386 default: 1387 YY_FATAL_ERROR( 1388 "fatal flex scanner internal error--no action found" ); 1389 } /* end of action switch */ 1390 } /* end of scanning one token */ 1391 } /* end of yylex */ 1392 1393 1394 /* yy_get_next_buffer - try to read in a new buffer 1395 * 1396 * Returns a code representing an action: 1397 * EOB_ACT_LAST_MATCH - 1398 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1399 * EOB_ACT_END_OF_FILE - end of file 1400 */ 1401 1402 static int yy_get_next_buffer() 1403 { 1404 register char *dest = yy_current_buffer->yy_ch_buf; 1405 register char *source = yytext_ptr; 1406 register int number_to_move, i; 1407 int ret_val; 1408 1409 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) 1410 YY_FATAL_ERROR( 1411 "fatal flex scanner internal error--end of buffer missed" ); 1412 1413 if ( yy_current_buffer->yy_fill_buffer == 0 ) 1414 { /* Don't try to fill the buffer, so this is an EOF. */ 1415 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) 1416 { 1417 /* We matched a single character, the EOB, so 1418 * treat this as a final EOF. 1419 */ 1420 return EOB_ACT_END_OF_FILE; 1421 } 1422 1423 else 1424 { 1425 /* We matched some text prior to the EOB, first 1426 * process it. 1427 */ 1428 return EOB_ACT_LAST_MATCH; 1429 } 1430 } 1431 1432 /* Try to read more data. */ 1433 1434 /* First move last chars to start of buffer. */ 1435 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; 1436 1437 for ( i = 0; i < number_to_move; ++i ) 1438 *(dest++) = *(source++); 1439 1440 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1441 /* don't do the read, it's not guaranteed to return an EOF, 1442 * just force an EOF 1443 */ 1444 yy_current_buffer->yy_n_chars = yy_n_chars = 0; 1445 1446 else 1447 { 1448 int num_to_read = 1449 yy_current_buffer->yy_buf_size - number_to_move - 1; 1450 1451 while ( num_to_read <= 0 ) 1452 { /* Not enough room in the buffer - grow it. */ 1453 #ifdef YY_USES_REJECT 1454 YY_FATAL_ERROR( 1455 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 1456 #else 1457 1458 /* just a shorter name for the current buffer */ 1459 YY_BUFFER_STATE b = yy_current_buffer; 1460 1461 int yy_c_buf_p_offset = 1462 (int) (yy_c_buf_p - b->yy_ch_buf); 1463 1464 if ( b->yy_is_our_buffer ) 1465 { 1466 int new_size = b->yy_buf_size * 2; 1467 1468 if ( new_size <= 0 ) 1469 b->yy_buf_size += b->yy_buf_size / 8; 1470 else 1471 b->yy_buf_size *= 2; 1472 1473 b->yy_ch_buf = (char *) 1474 /* Include room in for 2 EOB chars. */ 1475 yyxrealloc( (void *) b->yy_ch_buf, 1476 b->yy_buf_size + 2 ); 1477 } 1478 else 1479 /* Can't grow it, we don't own it. */ 1480 b->yy_ch_buf = 0; 1481 1482 if ( ! b->yy_ch_buf ) 1483 YY_FATAL_ERROR( 1484 "fatal error - scanner input buffer overflow" ); 1485 1486 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1487 1488 num_to_read = yy_current_buffer->yy_buf_size - 1489 number_to_move - 1; 1490 #endif 1491 } 1492 1493 if ( num_to_read > YY_READ_BUF_SIZE ) 1494 num_to_read = YY_READ_BUF_SIZE; 1495 1496 /* Read in more data. */ 1497 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), 1498 yy_n_chars, num_to_read ); 1499 1500 yy_current_buffer->yy_n_chars = yy_n_chars; 1501 } 1502 1503 if ( yy_n_chars == 0 ) 1504 { 1505 if ( number_to_move == YY_MORE_ADJ ) 1506 { 1507 ret_val = EOB_ACT_END_OF_FILE; 1508 yyrestart( yyin ); 1509 } 1510 1511 else 1512 { 1513 ret_val = EOB_ACT_LAST_MATCH; 1514 yy_current_buffer->yy_buffer_status = 1515 YY_BUFFER_EOF_PENDING; 1516 } 1517 } 1518 1519 else 1520 ret_val = EOB_ACT_CONTINUE_SCAN; 1521 1522 yy_n_chars += number_to_move; 1523 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; 1524 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 1525 1526 yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; 1527 1528 return ret_val; 1529 } 1530 1531 1532 /* yy_get_previous_state - get the state just before the EOB char was reached */ 1533 1534 static yy_state_type yy_get_previous_state() 1535 { 1536 register yy_state_type yy_current_state; 1537 register char *yy_cp; 1538 1539 yy_current_state = yy_start; 1540 1541 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) 1542 { 1543 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1544 if ( yy_accept[yy_current_state] ) 1545 { 1546 yy_last_accepting_state = yy_current_state; 1547 yy_last_accepting_cpos = yy_cp; 1548 } 1549 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1550 { 1551 yy_current_state = (int) yy_def[yy_current_state]; 1552 if ( yy_current_state >= 190 ) 1553 yy_c = yy_meta[(unsigned int) yy_c]; 1554 } 1555 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1556 } 1557 1558 return yy_current_state; 1559 } 1560 1561 1562 /* yy_try_NUL_trans - try to make a transition on the NUL character 1563 * 1564 * synopsis 1565 * next_state = yy_try_NUL_trans( current_state ); 1566 */ 1567 1568 #ifdef YY_USE_PROTOS 1569 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 1570 #else 1571 static yy_state_type yy_try_NUL_trans( yy_current_state ) 1572 yy_state_type yy_current_state; 1573 #endif 1574 { 1575 register int yy_is_jam; 1576 register char *yy_cp = yy_c_buf_p; 1577 1578 register YY_CHAR yy_c = 1; 1579 if ( yy_accept[yy_current_state] ) 1580 { 1581 yy_last_accepting_state = yy_current_state; 1582 yy_last_accepting_cpos = yy_cp; 1583 } 1584 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1585 { 1586 yy_current_state = (int) yy_def[yy_current_state]; 1587 if ( yy_current_state >= 190 ) 1588 yy_c = yy_meta[(unsigned int) yy_c]; 1589 } 1590 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1591 yy_is_jam = (yy_current_state == 189); 1592 1593 return yy_is_jam ? 0 : yy_current_state; 1594 } 1595 1596 1597 #ifndef YY_NO_UNPUT 1598 #ifdef YY_USE_PROTOS 1599 static void yyunput( int c, register char *yy_bp ) 1600 #else 1601 static void yyunput( c, yy_bp ) 1602 int c; 1603 register char *yy_bp; 1604 #endif 1605 { 1606 register char *yy_cp = yy_c_buf_p; 1607 1608 /* undo effects of setting up yytext */ 1609 *yy_cp = yy_hold_char; 1610 1611 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1612 { /* need to shift things up to make room */ 1613 /* +2 for EOB chars. */ 1614 register int number_to_move = yy_n_chars + 2; 1615 register char *dest = &yy_current_buffer->yy_ch_buf[ 1616 yy_current_buffer->yy_buf_size + 2]; 1617 register char *source = 1618 &yy_current_buffer->yy_ch_buf[number_to_move]; 1619 1620 while ( source > yy_current_buffer->yy_ch_buf ) 1621 *--dest = *--source; 1622 1623 yy_cp += (int) (dest - source); 1624 yy_bp += (int) (dest - source); 1625 yy_current_buffer->yy_n_chars = 1626 yy_n_chars = yy_current_buffer->yy_buf_size; 1627 1628 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1629 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1630 } 1631 1632 *--yy_cp = (char) c; 1633 1634 1635 yytext_ptr = yy_bp; 1636 yy_hold_char = *yy_cp; 1637 yy_c_buf_p = yy_cp; 1638 } 1639 #endif /* ifndef YY_NO_UNPUT */ 1640 1641 1642 #ifndef YY_NO_INPUT 1643 #ifdef __cplusplus 1644 static int yyinput() 1645 #else 1646 static int input() 1647 #endif 1648 { 1649 int c; 1650 1651 *yy_c_buf_p = yy_hold_char; 1652 1653 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 1654 { 1655 /* yy_c_buf_p now points to the character we want to return. 1656 * If this occurs *before* the EOB characters, then it's a 1657 * valid NUL; if not, then we've hit the end of the buffer. 1658 */ 1659 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1660 /* This was really a NUL. */ 1661 *yy_c_buf_p = '\0'; 1662 1663 else 1664 { /* need more input */ 1665 int offset = yy_c_buf_p - yytext_ptr; 1666 ++yy_c_buf_p; 1667 1668 switch ( yy_get_next_buffer() ) 1669 { 1670 case EOB_ACT_LAST_MATCH: 1671 /* This happens because yy_g_n_b() 1672 * sees that we've accumulated a 1673 * token and flags that we need to 1674 * try matching the token before 1675 * proceeding. But for input(), 1676 * there's no matching to consider. 1677 * So convert the EOB_ACT_LAST_MATCH 1678 * to EOB_ACT_END_OF_FILE. 1679 */ 1680 1681 /* Reset buffer status. */ 1682 yyrestart( yyin ); 1683 1684 /* fall through */ 1685 1686 case EOB_ACT_END_OF_FILE: 1687 { 1688 if ( yywrap() ) 1689 return EOF; 1690 1691 if ( ! yy_did_buffer_switch_on_eof ) 1692 YY_NEW_FILE; 1693 #ifdef __cplusplus 1694 return yyinput(); 1695 #else 1696 return input(); 1697 #endif 1698 } 1699 1700 case EOB_ACT_CONTINUE_SCAN: 1701 yy_c_buf_p = yytext_ptr + offset; 1702 break; 1703 } 1704 } 1705 } 1706 1707 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ 1708 *yy_c_buf_p = '\0'; /* preserve yytext */ 1709 yy_hold_char = *++yy_c_buf_p; 1710 1711 1712 return c; 1713 } 1714 #endif /* YY_NO_INPUT */ 1715 1716 #ifdef YY_USE_PROTOS 1717 void yyrestart( FILE *input_file ) 1718 #else 1719 void yyrestart( input_file ) 1720 FILE *input_file; 1721 #endif 1722 { 1723 if ( ! yy_current_buffer ) 1724 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 1725 1726 yy_init_buffer( yy_current_buffer, input_file ); 1727 yy_load_buffer_state(); 1728 } 1729 1730 1731 #ifdef YY_USE_PROTOS 1732 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1733 #else 1734 void yy_switch_to_buffer( new_buffer ) 1735 YY_BUFFER_STATE new_buffer; 1736 #endif 1737 { 1738 if ( yy_current_buffer == new_buffer ) 1739 return; 1740 1741 if ( yy_current_buffer ) 1742 { 1743 /* Flush out information for old buffer. */ 1744 *yy_c_buf_p = yy_hold_char; 1745 yy_current_buffer->yy_buf_pos = yy_c_buf_p; 1746 yy_current_buffer->yy_n_chars = yy_n_chars; 1747 } 1748 1749 yy_current_buffer = new_buffer; 1750 yy_load_buffer_state(); 1751 1752 /* We don't actually know whether we did this switch during 1753 * EOF (yywrap()) processing, but the only time this flag 1754 * is looked at is after yywrap() is called, so it's safe 1755 * to go ahead and always set it. 1756 */ 1757 yy_did_buffer_switch_on_eof = 1; 1758 } 1759 1760 1761 #ifdef YY_USE_PROTOS 1762 void yy_load_buffer_state( void ) 1763 #else 1764 void yy_load_buffer_state() 1765 #endif 1766 { 1767 yy_n_chars = yy_current_buffer->yy_n_chars; 1768 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; 1769 yyin = yy_current_buffer->yy_input_file; 1770 yy_hold_char = *yy_c_buf_p; 1771 } 1772 1773 1774 #ifdef YY_USE_PROTOS 1775 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 1776 #else 1777 YY_BUFFER_STATE yy_create_buffer( file, size ) 1778 FILE *file; 1779 int size; 1780 #endif 1781 { 1782 YY_BUFFER_STATE b; 1783 1784 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1785 if ( ! b ) 1786 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1787 1788 b->yy_buf_size = size; 1789 1790 /* yy_ch_buf has to be 2 characters longer than the size given because 1791 * we need to put in 2 end-of-buffer characters. 1792 */ 1793 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); 1794 if ( ! b->yy_ch_buf ) 1795 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1796 1797 b->yy_is_our_buffer = 1; 1798 1799 yy_init_buffer( b, file ); 1800 1801 return b; 1802 } 1803 1804 1805 #ifdef YY_USE_PROTOS 1806 void yy_delete_buffer( YY_BUFFER_STATE b ) 1807 #else 1808 void yy_delete_buffer( b ) 1809 YY_BUFFER_STATE b; 1810 #endif 1811 { 1812 if ( ! b ) 1813 return; 1814 1815 if ( b == yy_current_buffer ) 1816 yy_current_buffer = (YY_BUFFER_STATE) 0; 1817 1818 if ( b->yy_is_our_buffer ) 1819 yy_flex_free( (void *) b->yy_ch_buf ); 1820 1821 yy_flex_free( (void *) b ); 1822 } 1823 1824 1825 1826 #ifdef YY_USE_PROTOS 1827 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 1828 #else 1829 void yy_init_buffer( b, file ) 1830 YY_BUFFER_STATE b; 1831 FILE *file; 1832 #endif 1833 1834 1835 { 1836 yy_flush_buffer( b ); 1837 1838 b->yy_input_file = file; 1839 b->yy_fill_buffer = 1; 1840 1841 #if YY_ALWAYS_INTERACTIVE 1842 b->yy_is_interactive = 1; 1843 #else 1844 #if YY_NEVER_INTERACTIVE 1845 b->yy_is_interactive = 0; 1846 #else 1847 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 1848 #endif 1849 #endif 1850 } 1851 1852 1853 #ifdef YY_USE_PROTOS 1854 void yy_flush_buffer( YY_BUFFER_STATE b ) 1855 #else 1856 void yy_flush_buffer( b ) 1857 YY_BUFFER_STATE b; 1858 #endif 1859 1860 { 1861 if ( ! b ) 1862 return; 1863 1864 b->yy_n_chars = 0; 1865 1866 /* We always need two end-of-buffer characters. The first causes 1867 * a transition to the end-of-buffer state. The second causes 1868 * a jam in that state. 1869 */ 1870 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 1871 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 1872 1873 b->yy_buf_pos = &b->yy_ch_buf[0]; 1874 1875 b->yy_at_bol = 1; 1876 b->yy_buffer_status = YY_BUFFER_NEW; 1877 1878 if ( b == yy_current_buffer ) 1879 yy_load_buffer_state(); 1880 } 1881 1882 1883 #ifndef YY_NO_SCAN_BUFFER 1884 #ifdef YY_USE_PROTOS 1885 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 1886 #else 1887 YY_BUFFER_STATE yy_scan_buffer( base, size ) 1888 char *base; 1889 yy_size_t size; 1890 #endif 1891 { 1892 YY_BUFFER_STATE b; 1893 1894 if ( size < 2 || 1895 base[size-2] != YY_END_OF_BUFFER_CHAR || 1896 base[size-1] != YY_END_OF_BUFFER_CHAR ) 1897 /* They forgot to leave room for the EOB's. */ 1898 return 0; 1899 1900 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1901 if ( ! b ) 1902 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 1903 1904 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 1905 b->yy_buf_pos = b->yy_ch_buf = base; 1906 b->yy_is_our_buffer = 0; 1907 b->yy_input_file = 0; 1908 b->yy_n_chars = b->yy_buf_size; 1909 b->yy_is_interactive = 0; 1910 b->yy_at_bol = 1; 1911 b->yy_fill_buffer = 0; 1912 b->yy_buffer_status = YY_BUFFER_NEW; 1913 1914 yy_switch_to_buffer( b ); 1915 1916 return b; 1917 } 1918 #endif 1919 1920 1921 #ifndef YY_NO_SCAN_STRING 1922 #ifdef YY_USE_PROTOS 1923 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 1924 #else 1925 YY_BUFFER_STATE yy_scan_string( yy_str ) 1926 yyconst char *yy_str; 1927 #endif 1928 { 1929 int len; 1930 for ( len = 0; yy_str[len]; ++len ) 1931 ; 1932 1933 return yy_scan_bytes( yy_str, len ); 1934 } 1935 #endif 1936 1937 1938 #ifndef YY_NO_SCAN_BYTES 1939 #ifdef YY_USE_PROTOS 1940 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 1941 #else 1942 YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 1943 yyconst char *bytes; 1944 int len; 1945 #endif 1946 { 1947 YY_BUFFER_STATE b; 1948 char *buf; 1949 yy_size_t n; 1950 int i; 1951 1952 /* Get memory for full buffer, including space for trailing EOB's. */ 1953 n = len + 2; 1954 buf = (char *) yy_flex_alloc( n ); 1955 if ( ! buf ) 1956 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 1957 1958 for ( i = 0; i < len; ++i ) 1959 buf[i] = bytes[i]; 1960 1961 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; 1962 1963 b = yy_scan_buffer( buf, n ); 1964 if ( ! b ) 1965 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 1966 1967 /* It's okay to grow etc. this buffer, and we should throw it 1968 * away when we're done. 1969 */ 1970 b->yy_is_our_buffer = 1; 1971 1972 return b; 1973 } 1974 #endif 1975 1976 1977 #ifndef YY_NO_PUSH_STATE 1978 #ifdef YY_USE_PROTOS 1979 static void yy_push_state( int new_state ) 1980 #else 1981 static void yy_push_state( new_state ) 1982 int new_state; 1983 #endif 1984 { 1985 if ( yy_start_stack_ptr >= yy_start_stack_depth ) 1986 { 1987 yy_size_t new_size; 1988 1989 yy_start_stack_depth += YY_START_STACK_INCR; 1990 new_size = yy_start_stack_depth * sizeof( int ); 1991 1992 if ( ! yy_start_stack ) 1993 yy_start_stack = (int *) yy_flex_alloc( new_size ); 1994 1995 else 1996 yy_start_stack = (int *) yyxrealloc( 1997 (void *) yy_start_stack, new_size ); 1998 1999 if ( ! yy_start_stack ) 2000 YY_FATAL_ERROR( 2001 "out of memory expanding start-condition stack" ); 2002 } 2003 2004 yy_start_stack[yy_start_stack_ptr++] = YY_START; 2005 2006 BEGIN(new_state); 2007 } 2008 #endif 2009 2010 2011 #ifndef YY_NO_POP_STATE 2012 static void yy_pop_state() 2013 { 2014 if ( --yy_start_stack_ptr < 0 ) 2015 YY_FATAL_ERROR( "start-condition stack underflow" ); 2016 2017 BEGIN(yy_start_stack[yy_start_stack_ptr]); 2018 } 2019 #endif 2020 2021 2022 #ifndef YY_NO_TOP_STATE 2023 static int yy_top_state() 2024 { 2025 return yy_start_stack[yy_start_stack_ptr - 1]; 2026 } 2027 #endif 2028 2029 #ifndef YY_EXIT_FAILURE 2030 #define YY_EXIT_FAILURE 2 2031 #endif 2032 2033 #ifdef YY_USE_PROTOS 2034 static void yy_fatal_error( yyconst char msg[] ) 2035 #else 2036 static void yy_fatal_error( msg ) 2037 char msg[]; 2038 #endif 2039 { 2040 (void) fprintf( stderr, "%s\n", msg ); 2041 exit( YY_EXIT_FAILURE ); 2042 } 2043 2044 2045 2046 /* Redefine yyless() so it works in section 3 code. */ 2047 2048 #undef yyless 2049 #define yyless(n) \ 2050 do \ 2051 { \ 2052 /* Undo effects of setting up yytext. */ \ 2053 yytext[yyleng] = yy_hold_char; \ 2054 yy_c_buf_p = yytext + n; \ 2055 yy_hold_char = *yy_c_buf_p; \ 2056 *yy_c_buf_p = '\0'; \ 2057 yyleng = n; \ 2058 } \ 2059 while ( 0 ) 2060 2061 2062 /* Internal utility routines. */ 2063 2064 #ifndef yytext_ptr 2065 #ifdef YY_USE_PROTOS 2066 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 2067 #else 2068 static void yy_flex_strncpy( s1, s2, n ) 2069 char *s1; 2070 yyconst char *s2; 2071 int n; 2072 #endif 2073 { 2074 register int i; 2075 for ( i = 0; i < n; ++i ) 2076 s1[i] = s2[i]; 2077 } 2078 #endif 2079 2080 #ifdef YY_NEED_STRLEN 2081 #ifdef YY_USE_PROTOS 2082 static int yy_flex_strlen( yyconst char *s ) 2083 #else 2084 static int yy_flex_strlen( s ) 2085 yyconst char *s; 2086 #endif 2087 { 2088 register int n; 2089 for ( n = 0; s[n]; ++n ) 2090 ; 2091 2092 return n; 2093 } 2094 #endif 2095 2096 2097 #ifdef YY_USE_PROTOS 2098 static void *yy_flex_alloc( yy_size_t size ) 2099 #else 2100 static void *yy_flex_alloc( size ) 2101 yy_size_t size; 2102 #endif 2103 { 2104 return (void *) xmalloc( size ); 2105 } 2106 2107 #ifdef YY_USE_PROTOS 2108 static void *yyxrealloc( void *ptr, yy_size_t size ) 2109 #else 2110 static void *yyxrealloc( ptr, size ) 2111 void *ptr; 2112 yy_size_t size; 2113 #endif 2114 { 2115 /* The cast to (char *) in the following accommodates both 2116 * implementations that use char* generic pointers, and those 2117 * that use void* generic pointers. It works with the latter 2118 * because both ANSI C and C++ allow castless assignment from 2119 * any pointer type to void*, and deal with argument conversions 2120 * as though doing an assignment. 2121 */ 2122 return (void *) xrealloc( (char *) ptr, size ); 2123 } 2124 2125 #ifdef YY_USE_PROTOS 2126 static void yy_flex_free( void *ptr ) 2127 #else 2128 static void yy_flex_free( ptr ) 2129 void *ptr; 2130 #endif 2131 { 2132 xfree( ptr ); 2133 } 2134 2135 #if YY_MAIN 2136 int main() 2137 { 2138 yylex(); 2139 return 0; 2140 } 2141 #endif 2142 #line 276 "ada-lex.l" 2143 2144 2145 #include <ctype.h> 2146 #include "gdb_string.h" 2147 2148 /* Initialize the lexer for processing new expression. */ 2149 2150 void 2151 lexer_init (FILE *inp) 2152 { 2153 BEGIN INITIAL; 2154 yyrestart (inp); 2155 } 2156 2157 2158 /* Copy S2 to S1, removing all underscores, and downcasing all letters. */ 2159 2160 static void 2161 canonicalizeNumeral (char *s1, const char *s2) 2162 { 2163 for (; *s2 != '\000'; s2 += 1) 2164 { 2165 if (*s2 != '_') 2166 { 2167 *s1 = tolower(*s2); 2168 s1 += 1; 2169 } 2170 } 2171 s1[0] = '\000'; 2172 } 2173 2174 /* Interprets the prefix of NUM that consists of digits of the given BASE 2175 as an integer of that BASE, with the string EXP as an exponent. 2176 Puts value in yylval, and returns INT, if the string is valid. Causes 2177 an error if the number is improperly formated. BASE, if NULL, defaults 2178 to "10", and EXP to "1". The EXP does not contain a leading 'e' or 'E'. 2179 */ 2180 2181 static int 2182 processInt (const char *base0, const char *num0, const char *exp0) 2183 { 2184 ULONGEST result; 2185 long exp; 2186 int base; 2187 2188 char *trailer; 2189 2190 if (base0 == NULL) 2191 base = 10; 2192 else 2193 { 2194 base = strtol (base0, (char **) NULL, 10); 2195 if (base < 2 || base > 16) 2196 error (_("Invalid base: %d."), base); 2197 } 2198 2199 if (exp0 == NULL) 2200 exp = 0; 2201 else 2202 exp = strtol(exp0, (char **) NULL, 10); 2203 2204 errno = 0; 2205 result = strtoulst (num0, (const char **) &trailer, base); 2206 if (errno == ERANGE) 2207 error (_("Integer literal out of range")); 2208 if (isxdigit(*trailer)) 2209 error (_("Invalid digit `%c' in based literal"), *trailer); 2210 2211 while (exp > 0) 2212 { 2213 if (result > (ULONG_MAX / base)) 2214 error (_("Integer literal out of range")); 2215 result *= base; 2216 exp -= 1; 2217 } 2218 2219 if ((result >> (gdbarch_int_bit (parse_gdbarch)-1)) == 0) 2220 yylval.typed_val.type = type_int (); 2221 else if ((result >> (gdbarch_long_bit (parse_gdbarch)-1)) == 0) 2222 yylval.typed_val.type = type_long (); 2223 else if (((result >> (gdbarch_long_bit (parse_gdbarch)-1)) >> 1) == 0) 2224 { 2225 /* We have a number representable as an unsigned integer quantity. 2226 For consistency with the C treatment, we will treat it as an 2227 anonymous modular (unsigned) quantity. Alas, the types are such 2228 that we need to store .val as a signed quantity. Sorry 2229 for the mess, but C doesn't officially guarantee that a simple 2230 assignment does the trick (no, it doesn't; read the reference manual). 2231 */ 2232 yylval.typed_val.type 2233 = builtin_type (parse_gdbarch)->builtin_unsigned_long; 2234 if (result & LONGEST_SIGN) 2235 yylval.typed_val.val = 2236 (LONGEST) (result & ~LONGEST_SIGN) 2237 - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1); 2238 else 2239 yylval.typed_val.val = (LONGEST) result; 2240 return INT; 2241 } 2242 else 2243 yylval.typed_val.type = type_long_long (); 2244 2245 yylval.typed_val.val = (LONGEST) result; 2246 return INT; 2247 } 2248 2249 static int 2250 processReal (const char *num0) 2251 { 2252 sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval); 2253 2254 yylval.typed_val_float.type = type_float (); 2255 if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch) 2256 / TARGET_CHAR_BIT) 2257 yylval.typed_val_float.type = type_double (); 2258 if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch) 2259 / TARGET_CHAR_BIT) 2260 yylval.typed_val_float.type = type_long_double (); 2261 2262 return FLOAT; 2263 } 2264 2265 2266 /* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym. The 2267 resulting string is valid until the next call to ada_parse. It differs 2268 from NAME0 in that: 2269 + Characters between '...' or <...> are transfered verbatim to 2270 yylval.ssym. 2271 + <, >, and trailing "'" characters in quoted sequences are removed 2272 (a leading quote is preserved to indicate that the name is not to be 2273 GNAT-encoded). 2274 + Unquoted whitespace is removed. 2275 + Unquoted alphabetic characters are mapped to lower case. 2276 Result is returned as a struct stoken, but for convenience, the string 2277 is also null-terminated. Result string valid until the next call of 2278 ada_parse. 2279 */ 2280 static struct stoken 2281 processId (const char *name0, int len) 2282 { 2283 char *name = obstack_alloc (&temp_parse_space, len + 11); 2284 int i0, i; 2285 struct stoken result; 2286 2287 while (len > 0 && isspace (name0[len-1])) 2288 len -= 1; 2289 i = i0 = 0; 2290 while (i0 < len) 2291 { 2292 if (isalnum (name0[i0])) 2293 { 2294 name[i] = tolower (name0[i0]); 2295 i += 1; i0 += 1; 2296 } 2297 else switch (name0[i0]) 2298 { 2299 default: 2300 name[i] = name0[i0]; 2301 i += 1; i0 += 1; 2302 break; 2303 case ' ': case '\t': 2304 i0 += 1; 2305 break; 2306 case '\'': 2307 do 2308 { 2309 name[i] = name0[i0]; 2310 i += 1; i0 += 1; 2311 } 2312 while (i0 < len && name0[i0] != '\''); 2313 i0 += 1; 2314 break; 2315 case '<': 2316 i0 += 1; 2317 while (i0 < len && name0[i0] != '>') 2318 { 2319 name[i] = name0[i0]; 2320 i += 1; i0 += 1; 2321 } 2322 i0 += 1; 2323 break; 2324 } 2325 } 2326 name[i] = '\000'; 2327 2328 result.ptr = name; 2329 result.length = i; 2330 return result; 2331 } 2332 2333 /* Return TEXT[0..LEN-1], a string literal without surrounding quotes, 2334 with special hex character notations replaced with characters. 2335 Result valid until the next call to ada_parse. */ 2336 2337 static struct stoken 2338 processString (const char *text, int len) 2339 { 2340 const char *p; 2341 char *q; 2342 const char *lim = text + len; 2343 struct stoken result; 2344 2345 q = result.ptr = obstack_alloc (&temp_parse_space, len); 2346 p = text; 2347 while (p < lim) 2348 { 2349 if (p[0] == '[' && p[1] == '"' && p+2 < lim) 2350 { 2351 if (p[2] == '"') /* "...["""]... */ 2352 { 2353 *q = '"'; 2354 p += 4; 2355 } 2356 else 2357 { 2358 int chr; 2359 sscanf (p+2, "%2x", &chr); 2360 *q = (char) chr; 2361 p += 5; 2362 } 2363 } 2364 else 2365 *q = *p; 2366 q += 1; 2367 p += 1; 2368 } 2369 result.length = q - result.ptr; 2370 return result; 2371 } 2372 2373 /* Returns the position within STR of the '.' in a 2374 '.{WHITE}*all' component of a dotted name, or -1 if there is none. 2375 Note: we actually don't need this routine, since 'all' can never be an 2376 Ada identifier. Thus, looking up foo.all or foo.all.x as a name 2377 must fail, and will eventually be interpreted as (foo).all or 2378 (foo).all.x. However, this does avoid an extraneous lookup. */ 2379 2380 static int 2381 find_dot_all (const char *str) 2382 { 2383 int i; 2384 for (i = 0; str[i] != '\000'; i += 1) 2385 { 2386 if (str[i] == '.') 2387 { 2388 int i0 = i; 2389 do 2390 i += 1; 2391 while (isspace (str[i])); 2392 if (strncmp (str+i, "all", 3) == 0 2393 && ! isalnum (str[i+3]) && str[i+3] != '_') 2394 return i0; 2395 } 2396 } 2397 return -1; 2398 } 2399 2400 /* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring 2401 case. */ 2402 2403 static int 2404 subseqMatch (const char *subseq, const char *str) 2405 { 2406 if (subseq[0] == '\0') 2407 return 1; 2408 else if (str[0] == '\0') 2409 return 0; 2410 else if (tolower (subseq[0]) == tolower (str[0])) 2411 return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1); 2412 else 2413 return subseqMatch (subseq, str+1); 2414 } 2415 2416 2417 static struct { const char *name; int code; } 2418 attributes[] = { 2419 { "address", TICK_ADDRESS }, 2420 { "unchecked_access", TICK_ACCESS }, 2421 { "unrestricted_access", TICK_ACCESS }, 2422 { "access", TICK_ACCESS }, 2423 { "first", TICK_FIRST }, 2424 { "last", TICK_LAST }, 2425 { "length", TICK_LENGTH }, 2426 { "max", TICK_MAX }, 2427 { "min", TICK_MIN }, 2428 { "modulus", TICK_MODULUS }, 2429 { "pos", TICK_POS }, 2430 { "range", TICK_RANGE }, 2431 { "size", TICK_SIZE }, 2432 { "tag", TICK_TAG }, 2433 { "val", TICK_VAL }, 2434 { NULL, -1 } 2435 }; 2436 2437 /* Return the syntactic code corresponding to the attribute name or 2438 abbreviation STR. */ 2439 2440 static int 2441 processAttribute (const char *str) 2442 { 2443 int i, k; 2444 2445 for (i = 0; attributes[i].code != -1; i += 1) 2446 if (strcasecmp (str, attributes[i].name) == 0) 2447 return attributes[i].code; 2448 2449 for (i = 0, k = -1; attributes[i].code != -1; i += 1) 2450 if (subseqMatch (str, attributes[i].name)) 2451 { 2452 if (k == -1) 2453 k = i; 2454 else 2455 error (_("ambiguous attribute name: `%s'"), str); 2456 } 2457 if (k == -1) 2458 error (_("unrecognized attribute: `%s'"), str); 2459 2460 return attributes[k].code; 2461 } 2462 2463 int 2464 yywrap(void) 2465 { 2466 return 1; 2467 } 2468 2469 /* Dummy definition to suppress warnings about unused static definitions. */ 2470 typedef void (*dummy_function) (); 2471 dummy_function ada_flex_use[] = 2472 { 2473 (dummy_function) yyunput 2474 }; 2475