1 /* A lexical scanner generated by flex */ 2 3 /* Scanner skeleton version: 4 * $Header: /home/cvs/src/gnu/usr.bin/binutils-2.17/gas/bfin-lex.c,v 1.2 2021/05/05 04:52:39 drahn Exp $ 5 */ 6 7 #define FLEX_SCANNER 8 #define YY_FLEX_MAJOR_VERSION 2 9 #define YY_FLEX_MINOR_VERSION 5 10 11 #include <stdio.h> 12 #include <errno.h> 13 14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ 15 #ifdef c_plusplus 16 #ifndef __cplusplus 17 #define __cplusplus 18 #endif 19 #endif 20 21 22 #ifdef __cplusplus 23 24 #include <stdlib.h> 25 #ifndef _WIN32 26 #include <unistd.h> 27 #endif 28 29 /* Use prototypes in function declarations. */ 30 #define YY_USE_PROTOS 31 32 /* The "const" storage-class-modifier is valid. */ 33 #define YY_USE_CONST 34 35 #else /* ! __cplusplus */ 36 37 #if __STDC__ 38 39 #define YY_USE_PROTOS 40 #define YY_USE_CONST 41 42 #endif /* __STDC__ */ 43 #endif /* ! __cplusplus */ 44 45 #ifdef __TURBOC__ 46 #pragma warn -rch 47 #pragma warn -use 48 #include <io.h> 49 #include <stdlib.h> 50 #define YY_USE_CONST 51 #define YY_USE_PROTOS 52 #endif 53 54 #ifdef YY_USE_CONST 55 #define yyconst const 56 #else 57 #define yyconst 58 #endif 59 60 61 #ifdef YY_USE_PROTOS 62 #define YY_PROTO(proto) proto 63 #else 64 #define YY_PROTO(proto) () 65 #endif 66 67 68 /* Returned upon end-of-file. */ 69 #define YY_NULL 0 70 71 /* Promotes a possibly negative, possibly signed char to an unsigned 72 * integer for use as an array index. If the signed char is negative, 73 * we want to instead treat it as an 8-bit unsigned char, hence the 74 * double cast. 75 */ 76 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 77 78 /* Enter a start condition. This macro really ought to take a parameter, 79 * but we do it the disgusting crufty way forced on us by the ()-less 80 * definition of BEGIN. 81 */ 82 #define BEGIN yy_start = 1 + 2 * 83 84 /* Translate the current start state into a value that can be later handed 85 * to BEGIN to return to the state. The YYSTATE alias is for lex 86 * compatibility. 87 */ 88 #define YY_START ((yy_start - 1) / 2) 89 #define YYSTATE YY_START 90 91 /* Action number for EOF rule of a given start state. */ 92 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 93 94 /* Special action meaning "start processing a new file". */ 95 #define YY_NEW_FILE yyrestart( yyin ) 96 97 #define YY_END_OF_BUFFER_CHAR 0 98 99 /* Size of default input buffer. */ 100 #define YY_BUF_SIZE 16384 101 102 typedef struct yy_buffer_state *YY_BUFFER_STATE; 103 104 extern int yyleng; 105 extern FILE *yyin, *yyout; 106 107 #define EOB_ACT_CONTINUE_SCAN 0 108 #define EOB_ACT_END_OF_FILE 1 109 #define EOB_ACT_LAST_MATCH 2 110 111 /* The funky do-while in the following #define is used to turn the definition 112 * int a single C statement (which needs a semi-colon terminator). This 113 * avoids problems with code like: 114 * 115 * if ( condition_holds ) 116 * yyless( 5 ); 117 * else 118 * do_something_else(); 119 * 120 * Prior to using the do-while the compiler would get upset at the 121 * "else" because it interpreted the "if" statement as being all 122 * done when it reached the ';' after the yyless() call. 123 */ 124 125 /* Return all but the first 'n' matched characters back to the input stream. */ 126 127 #define yyless(n) \ 128 do \ 129 { \ 130 /* Undo effects of setting up yytext. */ \ 131 *yy_cp = yy_hold_char; \ 132 YY_RESTORE_YY_MORE_OFFSET \ 133 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ 134 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 135 } \ 136 while ( 0 ) 137 138 #define unput(c) yyunput( c, yytext_ptr ) 139 140 /* The following is because we cannot portably get our hands on size_t 141 * (without autoconf's help, which isn't available because we want 142 * flex-generated scanners to compile on their own). 143 */ 144 typedef unsigned int yy_size_t; 145 146 147 struct yy_buffer_state 148 { 149 FILE *yy_input_file; 150 151 char *yy_ch_buf; /* input buffer */ 152 char *yy_buf_pos; /* current position in input buffer */ 153 154 /* Size of input buffer in bytes, not including room for EOB 155 * characters. 156 */ 157 yy_size_t yy_buf_size; 158 159 /* Number of characters read into yy_ch_buf, not including EOB 160 * characters. 161 */ 162 int yy_n_chars; 163 164 /* Whether we "own" the buffer - i.e., we know we created it, 165 * and can realloc() it to grow it, and should free() it to 166 * delete it. 167 */ 168 int yy_is_our_buffer; 169 170 /* Whether this is an "interactive" input source; if so, and 171 * if we're using stdio for input, then we want to use getc() 172 * instead of fread(), to make sure we stop fetching input after 173 * each newline. 174 */ 175 int yy_is_interactive; 176 177 /* Whether we're considered to be at the beginning of a line. 178 * If so, '^' rules will be active on the next match, otherwise 179 * not. 180 */ 181 int yy_at_bol; 182 183 /* Whether to try to fill the input buffer when we reach the 184 * end of it. 185 */ 186 int yy_fill_buffer; 187 188 int yy_buffer_status; 189 #define YY_BUFFER_NEW 0 190 #define YY_BUFFER_NORMAL 1 191 /* When an EOF's been seen but there's still some text to process 192 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 193 * shouldn't try reading from the input source any more. We might 194 * still have a bunch of tokens to match, though, because of 195 * possible backing-up. 196 * 197 * When we actually see the EOF, we change the status to "new" 198 * (via yyrestart()), so that the user can continue scanning by 199 * just pointing yyin at a new input file. 200 */ 201 #define YY_BUFFER_EOF_PENDING 2 202 }; 203 204 static YY_BUFFER_STATE yy_current_buffer = 0; 205 206 /* We provide macros for accessing buffer states in case in the 207 * future we want to put the buffer states in a more general 208 * "scanner state". 209 */ 210 #define YY_CURRENT_BUFFER yy_current_buffer 211 212 213 /* yy_hold_char holds the character lost when yytext is formed. */ 214 static char yy_hold_char; 215 216 static int yy_n_chars; /* number of characters read into yy_ch_buf */ 217 218 219 int yyleng; 220 221 /* Points to current character in buffer. */ 222 static char *yy_c_buf_p = (char *) 0; 223 static int yy_init = 1; /* whether we need to initialize */ 224 static int yy_start = 0; /* start state number */ 225 226 /* Flag which is used to allow yywrap()'s to do buffer switches 227 * instead of setting up a fresh yyin. A bit of a hack ... 228 */ 229 static int yy_did_buffer_switch_on_eof; 230 231 void yyrestart YY_PROTO(( FILE *input_file )); 232 233 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); 234 void yy_load_buffer_state YY_PROTO(( void )); 235 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); 236 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); 237 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); 238 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); 239 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) 240 241 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); 242 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); 243 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); 244 245 static void *yy_flex_alloc YY_PROTO(( yy_size_t )); 246 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); 247 static void yy_flex_free YY_PROTO(( void * )); 248 249 #define yy_new_buffer yy_create_buffer 250 251 #define yy_set_interactive(is_interactive) \ 252 { \ 253 if ( ! yy_current_buffer ) \ 254 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 255 yy_current_buffer->yy_is_interactive = is_interactive; \ 256 } 257 258 #define yy_set_bol(at_bol) \ 259 { \ 260 if ( ! yy_current_buffer ) \ 261 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 262 yy_current_buffer->yy_at_bol = at_bol; \ 263 } 264 265 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol) 266 267 typedef unsigned char YY_CHAR; 268 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 269 typedef int yy_state_type; 270 extern char *yytext; 271 #define yytext_ptr yytext 272 273 static yy_state_type yy_get_previous_state YY_PROTO(( void )); 274 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); 275 static int yy_get_next_buffer YY_PROTO(( void )); 276 static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); 277 278 /* Done after the current pattern has been matched and before the 279 * corresponding action - sets up yytext. 280 */ 281 #define YY_DO_BEFORE_ACTION \ 282 yytext_ptr = yy_bp; \ 283 yyleng = (int) (yy_cp - yy_bp); \ 284 yy_hold_char = *yy_cp; \ 285 *yy_cp = '\0'; \ 286 yy_c_buf_p = yy_cp; 287 288 #define YY_NUM_RULES 238 289 #define YY_END_OF_BUFFER 239 290 static yyconst short int yy_accept[559] = 291 { 0, 292 0, 0, 0, 0, 239, 237, 235, 235, 220, 233, 293 219, 218, 200, 201, 216, 214, 211, 210, 203, 232, 294 232, 202, 221, 199, 195, 237, 224, 233, 148, 233, 295 233, 233, 233, 233, 233, 233, 233, 233, 70, 233, 296 233, 233, 54, 19, 18, 233, 12, 10, 8, 7, 297 189, 188, 187, 233, 185, 183, 233, 233, 233, 233, 298 233, 233, 217, 215, 213, 212, 0, 209, 204, 0, 299 0, 0, 232, 234, 0, 232, 234, 198, 196, 222, 300 194, 193, 178, 175, 233, 233, 233, 150, 151, 233, 301 233, 149, 0, 147, 233, 140, 233, 233, 136, 233, 302 303 125, 233, 123, 233, 233, 233, 233, 233, 233, 233, 304 103, 102, 101, 233, 100, 99, 233, 233, 97, 233, 305 95, 94, 93, 91, 233, 85, 233, 233, 77, 86, 306 233, 71, 69, 233, 233, 233, 233, 65, 233, 233, 307 233, 59, 233, 56, 233, 233, 53, 233, 233, 233, 308 233, 233, 233, 233, 233, 233, 233, 233, 233, 25, 309 233, 233, 233, 233, 233, 15, 14, 233, 233, 159, 310 233, 186, 233, 184, 223, 233, 233, 95, 233, 233, 311 233, 205, 207, 206, 208, 0, 0, 232, 232, 232, 312 232, 197, 191, 192, 233, 233, 171, 152, 153, 233, 313 314 233, 162, 163, 233, 154, 156, 232, 233, 233, 233, 315 233, 233, 233, 124, 233, 233, 119, 233, 233, 233, 316 233, 233, 233, 233, 233, 233, 179, 98, 233, 233, 317 233, 233, 233, 233, 80, 83, 78, 81, 233, 233, 318 233, 79, 82, 233, 67, 66, 233, 63, 62, 233, 319 233, 233, 233, 233, 233, 233, 233, 233, 233, 44, 320 39, 38, 37, 36, 35, 34, 233, 32, 31, 233, 321 233, 233, 233, 233, 233, 233, 21, 233, 233, 16, 322 13, 233, 9, 233, 233, 233, 233, 233, 233, 233, 323 236, 190, 170, 168, 177, 176, 169, 167, 174, 173, 324 325 233, 233, 233, 155, 157, 146, 233, 233, 233, 233, 326 139, 138, 233, 127, 233, 233, 118, 233, 233, 233, 327 233, 111, 110, 233, 233, 233, 233, 233, 233, 233, 328 105, 104, 233, 233, 233, 96, 233, 92, 89, 84, 329 74, 233, 233, 68, 64, 233, 61, 60, 58, 57, 330 233, 55, 45, 233, 50, 47, 49, 46, 48, 233, 331 233, 43, 42, 233, 233, 233, 233, 233, 27, 24, 332 23, 233, 233, 233, 233, 233, 233, 228, 233, 227, 333 233, 233, 233, 233, 160, 233, 233, 233, 233, 233, 334 233, 233, 233, 233, 233, 122, 233, 117, 116, 233, 335 336 233, 233, 233, 233, 233, 233, 233, 108, 233, 233, 337 233, 233, 233, 233, 233, 233, 233, 233, 2, 182, 338 52, 41, 40, 33, 233, 233, 233, 30, 233, 22, 339 233, 233, 233, 172, 231, 233, 233, 233, 233, 233, 340 164, 161, 145, 144, 143, 142, 141, 233, 233, 233, 341 233, 126, 121, 233, 233, 233, 233, 233, 51, 233, 342 233, 107, 233, 233, 233, 233, 233, 88, 87, 90, 343 233, 233, 73, 72, 29, 233, 233, 233, 20, 233, 344 233, 233, 229, 233, 226, 165, 166, 233, 233, 233, 345 233, 233, 233, 120, 233, 114, 113, 233, 233, 233, 346 347 5, 106, 233, 180, 233, 233, 233, 233, 28, 233, 348 233, 17, 11, 233, 233, 233, 233, 135, 133, 134, 349 132, 129, 233, 115, 233, 6, 109, 233, 233, 3, 350 233, 76, 1, 26, 230, 225, 137, 130, 131, 233, 351 233, 233, 233, 233, 128, 233, 233, 4, 75, 233, 352 233, 112, 233, 233, 233, 233, 181, 0 353 } ; 354 355 static yyconst int yy_ec[256] = 356 { 0, 357 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 358 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 359 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 360 1, 2, 4, 1, 5, 6, 7, 8, 1, 9, 361 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 362 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 363 30, 31, 1, 32, 33, 34, 35, 36, 37, 38, 364 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 365 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 366 59, 1, 60, 61, 62, 1, 63, 64, 35, 36, 367 368 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 369 65, 48, 49, 66, 51, 67, 53, 54, 55, 56, 370 57, 58, 1, 68, 1, 69, 1, 1, 1, 1, 371 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 372 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 373 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 374 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 375 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 376 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 377 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 378 379 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 380 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 381 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 382 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 383 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 384 1, 1, 1, 1, 1 385 } ; 386 387 static yyconst int yy_meta[70] = 388 { 0, 389 1, 1, 2, 1, 1, 3, 1, 1, 1, 1, 390 1, 1, 1, 1, 3, 1, 4, 4, 4, 4, 391 4, 4, 4, 4, 4, 4, 1, 1, 1, 1, 392 1, 1, 5, 4, 5, 5, 5, 4, 3, 3, 393 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 394 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 395 1, 3, 5, 4, 3, 3, 3, 1, 1 396 } ; 397 398 static yyconst short int yy_base[565] = 399 { 0, 400 0, 0, 32, 33, 814, 815, 815, 815, 815, 0, 401 815, 783, 815, 815, 782, 60, 815, 61, 800, 113, 402 44, 815, 815, 54, 75, 779, 815, 161, 221, 59, 403 84, 42, 92, 105, 109, 148, 756, 271, 141, 48, 404 110, 322, 372, 421, 153, 757, 60, 787, 0, 0, 405 815, 815, 776, 741, 58, 815, 141, 64, 763, 43, 406 61, 0, 815, 815, 815, 815, 105, 815, 815, 129, 407 792, 210, 225, 235, 472, 275, 815, 772, 815, 815, 408 815, 145, 786, 785, 748, 163, 757, 0, 0, 263, 409 185, 0, 0, 782, 131, 0, 759, 97, 154, 751, 410 411 0, 753, 0, 736, 757, 752, 742, 69, 736, 279, 412 773, 741, 0, 156, 0, 0, 157, 749, 770, 740, 413 0, 0, 732, 0, 737, 766, 196, 199, 0, 153, 414 226, 247, 765, 723, 732, 220, 280, 0, 221, 740, 415 170, 761, 740, 0, 250, 728, 758, 731, 252, 735, 416 257, 308, 260, 248, 269, 288, 281, 729, 730, 753, 417 710, 725, 714, 713, 710, 0, 0, 714, 298, 0, 418 742, 815, 219, 815, 815, 707, 715, 714, 711, 174, 419 712, 815, 815, 815, 815, 744, 138, 356, 408, 0, 420 0, 815, 815, 724, 312, 343, 0, 0, 0, 714, 421 422 711, 0, 0, 249, 700, 699, 0, 232, 369, 695, 423 303, 711, 703, 0, 700, 701, 375, 337, 337, 122, 424 238, 338, 378, 347, 239, 709, 725, 0, 356, 318, 425 705, 722, 692, 363, 0, 0, 0, 0, 691, 390, 426 697, 0, 0, 372, 0, 0, 689, 0, 0, 700, 427 684, 699, 403, 690, 684, 393, 436, 680, 474, 431, 428 0, 0, 0, 0, 0, 0, 684, 0, 0, 398, 429 678, 401, 690, 681, 437, 680, 0, 690, 401, 0, 430 0, 662, 0, 657, 671, 684, 667, 676, 680, 676, 431 705, 815, 0, 0, 0, 0, 0, 0, 0, 0, 432 433 669, 676, 434, 0, 0, 0, 669, 659, 674, 448, 434 0, 659, 466, 694, 673, 670, 439, 661, 411, 654, 435 660, 0, 0, 419, 422, 647, 649, 450, 665, 470, 436 0, 0, 664, 675, 462, 0, 636, 0, 682, 0, 437 634, 642, 656, 0, 0, 656, 0, 0, 0, 0, 438 657, 0, 0, 654, 0, 0, 0, 0, 0, 671, 439 672, 0, 0, 652, 652, 470, 649, 471, 470, 0, 440 0, 650, 646, 632, 637, 614, 640, 617, 627, 0, 441 640, 630, 521, 474, 0, 466, 619, 475, 630, 477, 442 633, 624, 485, 625, 614, 0, 618, 0, 0, 620, 443 444 623, 625, 626, 611, 491, 628, 611, 0, 619, 625, 445 622, 613, 622, 495, 503, 487, 608, 497, 0, 0, 446 0, 0, 0, 0, 615, 517, 603, 0, 612, 0, 447 613, 614, 519, 0, 609, 609, 501, 605, 624, 625, 448 0, 0, 0, 0, 0, 0, 0, 604, 537, 609, 449 595, 0, 623, 597, 508, 510, 594, 588, 0, 590, 450 600, 0, 511, 585, 614, 532, 597, 0, 0, 0, 451 596, 586, 0, 0, 0, 514, 594, 517, 0, 518, 452 574, 583, 0, 593, 0, 0, 0, 589, 544, 315, 453 578, 582, 538, 0, 568, 0, 0, 586, 578, 520, 454 455 0, 0, 575, 0, 551, 554, 563, 564, 0, 521, 456 548, 0, 0, 543, 556, 522, 418, 0, 0, 0, 457 0, 0, 558, 0, 535, 0, 0, 524, 528, 0, 458 424, 0, 0, 0, 0, 0, 0, 0, 0, 403, 459 388, 378, 324, 279, 0, 272, 529, 0, 0, 531, 460 538, 0, 262, 168, 82, 83, 0, 815, 603, 608, 461 92, 613, 615, 617 462 } ; 463 464 static yyconst short int yy_def[565] = 465 { 0, 466 558, 1, 1, 1, 558, 558, 558, 558, 558, 559, 467 558, 558, 558, 558, 558, 558, 558, 558, 558, 560, 468 561, 558, 558, 558, 558, 558, 558, 559, 559, 559, 469 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 470 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 471 558, 558, 558, 28, 558, 558, 559, 36, 38, 42, 472 559, 559, 558, 558, 558, 558, 558, 558, 558, 558, 473 562, 558, 558, 558, 558, 558, 558, 558, 558, 558, 474 558, 558, 559, 559, 559, 559, 559, 559, 559, 559, 475 559, 559, 563, 559, 559, 559, 559, 559, 559, 559, 476 477 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 478 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 479 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 480 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 481 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 482 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 483 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 484 559, 558, 559, 558, 558, 559, 559, 559, 559, 559, 485 559, 558, 558, 558, 558, 562, 562, 558, 558, 75, 486 564, 558, 558, 558, 559, 559, 559, 559, 559, 559, 487 488 559, 559, 559, 559, 559, 559, 563, 559, 559, 559, 489 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 490 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 491 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 492 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 493 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 494 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 495 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 496 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 497 562, 558, 559, 559, 559, 559, 559, 559, 559, 559, 498 499 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 500 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 501 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 502 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 503 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 504 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 505 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 506 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 507 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 508 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 509 510 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 511 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 512 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 513 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 514 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 515 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 516 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 517 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 518 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 519 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 520 521 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 522 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 523 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 524 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 525 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 526 559, 559, 559, 559, 559, 559, 559, 0, 558, 558, 527 558, 558, 558, 558 528 } ; 529 530 static yyconst short int yy_nxt[885] = 531 { 0, 532 6, 7, 8, 9, 6, 10, 11, 12, 13, 14, 533 15, 16, 17, 18, 10, 19, 20, 21, 21, 21, 534 21, 21, 21, 21, 21, 21, 22, 23, 24, 25, 535 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 536 36, 37, 10, 38, 39, 40, 41, 42, 10, 43, 537 44, 45, 46, 47, 48, 49, 10, 50, 51, 52, 538 53, 10, 54, 29, 41, 43, 45, 55, 56, 57, 539 57, 65, 58, 58, 68, 59, 59, 77, 80, 60, 540 60, 77, 78, 79, 61, 61, 109, 174, 93, 66, 541 69, 100, 180, 101, 137, 76, 93, 110, 138, 177, 542 543 169, 178, 102, 557, 81, 103, 181, 77, 180, 104, 544 170, 168, 137, 93, 93, 105, 182, 106, 183, 219, 545 107, 100, 220, 103, 108, 175, 556, 67, 70, 73, 546 73, 73, 73, 73, 73, 73, 73, 73, 73, 111, 547 184, 113, 185, 211, 112, 93, 74, 106, 187, 116, 548 74, 114, 117, 291, 139, 140, 115, 133, 133, 133, 549 133, 211, 141, 118, 119, 119, 119, 119, 75, 114, 550 322, 115, 323, 134, 193, 194, 74, 83, 84, 198, 551 199, 135, 209, 120, 176, 121, 136, 122, 111, 164, 552 165, 555, 166, 112, 85, 86, 167, 209, 123, 239, 553 554 124, 205, 206, 134, 87, 212, 88, 227, 228, 89, 555 289, 90, 235, 236, 91, 237, 238, 239, 92, 256, 556 212, 252, 227, 228, 85, 93, 188, 188, 188, 188, 557 188, 188, 188, 188, 188, 188, 252, 94, 94, 94, 558 94, 189, 189, 189, 189, 189, 189, 189, 189, 189, 559 189, 188, 188, 188, 188, 188, 188, 188, 188, 188, 560 188, 95, 240, 242, 243, 241, 247, 250, 96, 197, 561 97, 306, 324, 325, 326, 306, 98, 99, 331, 554, 562 268, 303, 332, 284, 247, 250, 97, 126, 126, 126, 563 126, 76, 76, 76, 76, 76, 76, 76, 76, 76, 564 565 76, 255, 201, 259, 127, 128, 202, 129, 261, 267, 566 268, 303, 203, 222, 204, 269, 255, 130, 259, 550, 567 270, 131, 132, 261, 549, 267, 223, 248, 203, 204, 568 224, 249, 272, 269, 127, 130, 271, 132, 142, 142, 569 142, 142, 142, 142, 262, 224, 249, 272, 263, 282, 570 270, 293, 312, 264, 143, 294, 144, 336, 265, 519, 571 548, 336, 520, 266, 282, 145, 295, 296, 312, 321, 572 327, 146, 188, 188, 188, 188, 188, 188, 188, 188, 573 188, 188, 297, 320, 143, 328, 298, 146, 147, 147, 574 147, 147, 147, 147, 147, 147, 330, 299, 300, 321, 575 576 327, 320, 340, 307, 148, 335, 340, 317, 149, 318, 577 329, 344, 330, 308, 319, 344, 547, 150, 151, 309, 578 310, 335, 546, 152, 189, 189, 189, 189, 189, 189, 579 189, 189, 189, 189, 148, 310, 151, 317, 152, 153, 580 329, 342, 349, 401, 352, 545, 349, 365, 360, 361, 581 367, 404, 374, 154, 405, 155, 342, 156, 157, 352, 582 158, 159, 538, 365, 544, 539, 367, 374, 160, 353, 583 362, 161, 162, 401, 363, 353, 370, 163, 398, 353, 584 371, 404, 399, 154, 405, 385, 389, 162, 190, 190, 585 190, 190, 190, 190, 190, 190, 190, 190, 390, 353, 586 587 385, 408, 410, 429, 191, 191, 191, 191, 191, 191, 588 355, 413, 392, 393, 356, 443, 408, 450, 394, 357, 589 471, 426, 428, 472, 358, 442, 445, 413, 447, 359, 590 392, 443, 410, 429, 191, 191, 426, 428, 439, 440, 591 442, 445, 459, 447, 467, 441, 468, 450, 474, 476, 592 471, 481, 484, 469, 489, 490, 491, 459, 470, 496, 593 467, 497, 502, 474, 505, 509, 517, 484, 511, 512, 594 523, 527, 533, 537, 496, 551, 497, 502, 543, 476, 595 509, 481, 552, 511, 512, 542, 527, 533, 537, 553, 596 541, 518, 540, 551, 505, 536, 535, 552, 534, 532, 597 598 523, 531, 530, 529, 553, 62, 62, 62, 72, 528, 599 72, 72, 72, 186, 526, 186, 186, 186, 207, 207, 600 191, 191, 525, 524, 522, 521, 516, 515, 514, 513, 601 510, 508, 507, 506, 504, 503, 501, 500, 499, 498, 602 495, 494, 493, 492, 488, 487, 486, 485, 483, 482, 603 480, 479, 478, 477, 475, 473, 466, 465, 464, 463, 604 462, 461, 460, 458, 457, 456, 455, 454, 453, 452, 605 451, 449, 448, 446, 444, 438, 437, 436, 414, 435, 606 434, 433, 432, 431, 430, 427, 425, 424, 423, 422, 607 421, 420, 419, 418, 417, 416, 415, 414, 412, 411, 608 609 409, 407, 406, 403, 402, 400, 397, 396, 395, 391, 610 388, 387, 386, 384, 383, 187, 382, 381, 380, 379, 611 378, 377, 376, 375, 373, 372, 369, 368, 366, 364, 612 354, 351, 350, 348, 347, 346, 345, 343, 341, 339, 613 338, 337, 334, 333, 316, 315, 314, 313, 311, 305, 614 304, 302, 301, 292, 187, 290, 288, 287, 286, 285, 615 283, 281, 280, 279, 278, 277, 276, 275, 274, 273, 616 260, 258, 257, 256, 254, 253, 251, 246, 245, 244, 617 234, 233, 232, 231, 230, 229, 226, 225, 221, 218, 618 217, 216, 215, 214, 213, 210, 208, 200, 197, 196, 619 620 195, 192, 187, 179, 173, 172, 171, 168, 125, 82, 621 71, 64, 63, 558, 5, 558, 558, 558, 558, 558, 622 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 623 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 624 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 625 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 626 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 627 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 628 558, 558, 558, 558 629 } ; 630 631 static yyconst short int yy_chk[885] = 632 { 0, 633 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 634 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 635 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 636 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 637 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 638 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 639 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 640 4, 16, 3, 4, 18, 3, 4, 21, 25, 3, 641 4, 21, 24, 24, 3, 4, 32, 55, 31, 16, 642 18, 30, 60, 30, 40, 561, 33, 32, 40, 58, 643 644 47, 58, 30, 556, 25, 30, 61, 21, 60, 30, 645 47, 61, 40, 35, 41, 30, 67, 31, 67, 108, 646 31, 30, 108, 30, 31, 55, 555, 16, 18, 20, 647 20, 20, 20, 20, 20, 20, 20, 20, 20, 33, 648 70, 34, 70, 98, 33, 57, 20, 31, 187, 35, 649 20, 34, 35, 187, 41, 41, 34, 39, 39, 39, 650 39, 98, 41, 35, 36, 36, 36, 36, 20, 34, 651 220, 34, 220, 39, 82, 82, 20, 28, 28, 86, 652 86, 39, 95, 36, 57, 36, 39, 36, 57, 45, 653 45, 554, 45, 57, 28, 28, 45, 95, 36, 130, 654 655 36, 91, 91, 39, 28, 99, 28, 114, 117, 28, 656 180, 28, 127, 127, 28, 128, 128, 130, 28, 180, 657 99, 141, 114, 117, 28, 29, 72, 72, 72, 72, 658 72, 72, 72, 72, 72, 72, 141, 29, 29, 29, 659 29, 73, 73, 73, 73, 73, 73, 73, 73, 73, 660 73, 74, 74, 74, 74, 74, 74, 74, 74, 74, 661 74, 29, 131, 132, 132, 131, 136, 139, 29, 173, 662 29, 208, 221, 221, 221, 208, 29, 29, 225, 553, 663 154, 204, 225, 173, 136, 139, 29, 38, 38, 38, 664 38, 76, 76, 76, 76, 76, 76, 76, 76, 76, 665 666 76, 145, 90, 149, 38, 38, 90, 38, 151, 153, 667 154, 204, 90, 110, 90, 155, 145, 38, 149, 546, 668 156, 38, 38, 151, 544, 153, 110, 137, 90, 90, 669 110, 137, 157, 155, 38, 38, 156, 38, 42, 42, 670 42, 42, 42, 42, 152, 110, 137, 157, 152, 169, 671 156, 195, 211, 152, 42, 195, 42, 230, 152, 490, 672 543, 230, 490, 152, 169, 42, 195, 195, 211, 219, 673 222, 42, 188, 188, 188, 188, 188, 188, 188, 188, 674 188, 188, 196, 218, 42, 222, 196, 42, 43, 43, 675 43, 43, 43, 43, 43, 43, 224, 196, 196, 219, 676 677 222, 218, 234, 209, 43, 229, 234, 217, 43, 217, 678 223, 244, 224, 209, 217, 244, 542, 43, 43, 209, 679 209, 229, 541, 43, 189, 189, 189, 189, 189, 189, 680 189, 189, 189, 189, 43, 209, 43, 217, 43, 44, 681 223, 240, 253, 319, 256, 540, 253, 270, 260, 260, 682 272, 324, 279, 44, 325, 44, 240, 44, 44, 256, 683 44, 44, 517, 270, 531, 517, 272, 279, 44, 257, 684 260, 44, 44, 319, 260, 257, 275, 44, 317, 257, 685 275, 324, 317, 44, 325, 303, 310, 44, 75, 75, 686 75, 75, 75, 75, 75, 75, 75, 75, 310, 257, 687 688 303, 328, 330, 369, 75, 75, 75, 75, 75, 75, 689 259, 335, 313, 313, 259, 386, 328, 393, 313, 259, 690 416, 366, 368, 416, 259, 384, 388, 335, 390, 259, 691 313, 386, 330, 369, 75, 75, 366, 368, 383, 383, 692 384, 388, 405, 390, 414, 383, 415, 393, 418, 426, 693 416, 433, 437, 415, 449, 449, 449, 405, 415, 455, 694 414, 456, 463, 418, 466, 476, 489, 437, 478, 480, 695 493, 500, 510, 516, 455, 547, 456, 463, 529, 426, 696 476, 433, 550, 478, 480, 528, 500, 510, 516, 551, 697 525, 489, 523, 547, 466, 515, 514, 550, 511, 508, 698 699 493, 507, 506, 505, 551, 559, 559, 559, 560, 503, 700 560, 560, 560, 562, 499, 562, 562, 562, 563, 563, 701 564, 564, 498, 495, 492, 491, 488, 484, 482, 481, 702 477, 472, 471, 467, 465, 464, 461, 460, 458, 457, 703 454, 453, 451, 450, 448, 440, 439, 438, 436, 435, 704 432, 431, 429, 427, 425, 417, 413, 412, 411, 410, 705 409, 407, 406, 404, 403, 402, 401, 400, 397, 395, 706 394, 392, 391, 389, 387, 382, 381, 379, 378, 377, 707 376, 375, 374, 373, 372, 367, 365, 364, 361, 360, 708 354, 351, 346, 343, 342, 341, 339, 337, 334, 333, 709 710 329, 327, 326, 321, 320, 318, 316, 315, 314, 312, 711 309, 308, 307, 302, 301, 291, 290, 289, 288, 287, 712 286, 285, 284, 282, 278, 276, 274, 273, 271, 267, 713 258, 255, 254, 252, 251, 250, 247, 241, 239, 233, 714 232, 231, 227, 226, 216, 215, 213, 212, 210, 206, 715 205, 201, 200, 194, 186, 181, 179, 178, 177, 176, 716 171, 168, 165, 164, 163, 162, 161, 160, 159, 158, 717 150, 148, 147, 146, 143, 142, 140, 135, 134, 133, 718 126, 125, 123, 120, 119, 118, 112, 111, 109, 107, 719 106, 105, 104, 102, 100, 97, 94, 87, 85, 84, 720 721 83, 78, 71, 59, 54, 53, 48, 46, 37, 26, 722 19, 15, 12, 5, 558, 558, 558, 558, 558, 558, 723 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 724 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 725 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 726 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 727 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 728 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 729 558, 558, 558, 558 730 } ; 731 732 static yy_state_type yy_last_accepting_state; 733 static char *yy_last_accepting_cpos; 734 735 /* The intent behind this definition is that it'll catch 736 * any uses of REJECT which flex missed. 737 */ 738 #define REJECT reject_used_but_not_detected 739 #define yymore() yymore_used_but_not_detected 740 #define YY_MORE_ADJ 0 741 #define YY_RESTORE_YY_MORE_OFFSET 742 char *yytext; 743 #line 1 "bfin-lex.l" 744 #define INITIAL 0 745 /* bfin-lex.l ADI Blackfin lexer 746 Copyright 2005 747 Free Software Foundation, Inc. 748 749 This file is part of GAS, the GNU Assembler. 750 751 GAS is free software; you can redistribute it and/or modify 752 it under the terms of the GNU General Public License as published by 753 the Free Software Foundation; either version 2, or (at your option) 754 any later version. 755 756 GAS is distributed in the hope that it will be useful, 757 but WITHOUT ANY WARRANTY; without even the implied warranty of 758 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 759 GNU General Public License for more details. 760 761 You should have received a copy of the GNU General Public License 762 along with GAS; see the file COPYING. If not, write to the Free 763 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 764 02110-1301, USA. */ 765 #line 22 "bfin-lex.l" 766 767 #include <stdlib.h> 768 #include <string.h> 769 #include "bfin-defs.h" 770 #include "bfin-parse.h" 771 #include "as.h" 772 773 static long parse_int (char **end); 774 static int parse_halfreg (Register *r, int cl, char *hr); 775 static int parse_reg (Register *r, int type, char *rt); 776 int yylex (void); 777 778 #define _REG yylval.reg 779 780 781 /* Define Start States ... Actually we will use exclusion. 782 If no start state is specified it should match any state 783 and <INITIAL> would match some keyword rules only with 784 initial. */ 785 #define KEYWORD 1 786 787 #line 788 "bfin-lex.c" 788 789 /* Macros after this point can all be overridden by user definitions in 790 * section 1. 791 */ 792 793 #ifndef YY_SKIP_YYWRAP 794 #ifdef __cplusplus 795 extern "C" int yywrap YY_PROTO(( void )); 796 #else 797 extern int yywrap YY_PROTO(( void )); 798 #endif 799 #endif 800 801 #ifndef YY_NO_UNPUT 802 static void yyunput YY_PROTO(( int c, char *buf_ptr )); 803 #endif 804 805 #ifndef yytext_ptr 806 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); 807 #endif 808 809 #ifdef YY_NEED_STRLEN 810 static int yy_flex_strlen YY_PROTO(( yyconst char * )); 811 #endif 812 813 #ifndef YY_NO_INPUT 814 #ifdef __cplusplus 815 static int yyinput YY_PROTO(( void )); 816 #else 817 static int input YY_PROTO(( void )); 818 #endif 819 #endif 820 821 #if YY_STACK_USED 822 static int yy_start_stack_ptr = 0; 823 static int yy_start_stack_depth = 0; 824 static int *yy_start_stack = 0; 825 #ifndef YY_NO_PUSH_STATE 826 static void yy_push_state YY_PROTO(( int new_state )); 827 #endif 828 #ifndef YY_NO_POP_STATE 829 static void yy_pop_state YY_PROTO(( void )); 830 #endif 831 #ifndef YY_NO_TOP_STATE 832 static int yy_top_state YY_PROTO(( void )); 833 #endif 834 835 #else 836 #define YY_NO_PUSH_STATE 1 837 #define YY_NO_POP_STATE 1 838 #define YY_NO_TOP_STATE 1 839 #endif 840 841 #ifdef YY_MALLOC_DECL 842 YY_MALLOC_DECL 843 #else 844 #if __STDC__ 845 #ifndef __cplusplus 846 #include <stdlib.h> 847 #endif 848 #else 849 /* Just try to get by without declaring the routines. This will fail 850 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) 851 * or sizeof(void*) != sizeof(int). 852 */ 853 #endif 854 #endif 855 856 /* Amount of stuff to slurp up with each read. */ 857 #ifndef YY_READ_BUF_SIZE 858 #define YY_READ_BUF_SIZE 8192 859 #endif 860 861 /* Copy whatever the last rule matched to the standard output. */ 862 863 #ifndef ECHO 864 /* This used to be an fputs(), but since the string might contain NUL's, 865 * we now use fwrite(). 866 */ 867 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 868 #endif 869 870 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 871 * is returned in "result". 872 */ 873 #ifndef YY_INPUT 874 #define YY_INPUT(buf,result,max_size) \ 875 if ( yy_current_buffer->yy_is_interactive ) \ 876 { \ 877 int c = '*', n; \ 878 for ( n = 0; n < max_size && \ 879 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 880 buf[n] = (char) c; \ 881 if ( c == '\n' ) \ 882 buf[n++] = (char) c; \ 883 if ( c == EOF && ferror( yyin ) ) \ 884 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 885 result = n; \ 886 } \ 887 else \ 888 { \ 889 errno=0; \ 890 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 891 { \ 892 if( errno != EINTR) \ 893 { \ 894 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 895 break; \ 896 } \ 897 errno=0; \ 898 clearerr(yyin); \ 899 } \ 900 } 901 #endif 902 903 /* No semi-colon after return; correct usage is to write "yyterminate();" - 904 * we don't want an extra ';' after the "return" because that will cause 905 * some compilers to complain about unreachable statements. 906 */ 907 #ifndef yyterminate 908 #define yyterminate() return YY_NULL 909 #endif 910 911 /* Number of entries by which start-condition stack grows. */ 912 #ifndef YY_START_STACK_INCR 913 #define YY_START_STACK_INCR 25 914 #endif 915 916 /* Report a fatal error. */ 917 #ifndef YY_FATAL_ERROR 918 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 919 #endif 920 921 /* Default declaration of generated scanner - a define so the user can 922 * easily add parameters. 923 */ 924 #ifndef YY_DECL 925 #define YY_DECL int yylex YY_PROTO(( void )) 926 #endif 927 928 /* Code executed at the beginning of each rule, after yytext and yyleng 929 * have been set up. 930 */ 931 #ifndef YY_USER_ACTION 932 #define YY_USER_ACTION 933 #endif 934 935 /* Code executed at the end of each rule. */ 936 #ifndef YY_BREAK 937 #define YY_BREAK break; 938 #endif 939 940 #define YY_RULE_SETUP \ 941 YY_USER_ACTION 942 943 YY_DECL 944 { 945 register yy_state_type yy_current_state; 946 register char *yy_cp, *yy_bp; 947 register int yy_act; 948 949 #line 45 "bfin-lex.l" 950 951 #line 952 "bfin-lex.c" 952 953 if ( yy_init ) 954 { 955 yy_init = 0; 956 957 #ifdef YY_USER_INIT 958 YY_USER_INIT; 959 #endif 960 961 if ( ! yy_start ) 962 yy_start = 1; /* first start state */ 963 964 if ( ! yyin ) 965 yyin = stdin; 966 967 if ( ! yyout ) 968 yyout = stdout; 969 970 if ( ! yy_current_buffer ) 971 yy_current_buffer = 972 yy_create_buffer( yyin, YY_BUF_SIZE ); 973 974 yy_load_buffer_state(); 975 } 976 977 while ( 1 ) /* loops until end-of-file is reached */ 978 { 979 yy_cp = yy_c_buf_p; 980 981 /* Support of yytext. */ 982 *yy_cp = yy_hold_char; 983 984 /* yy_bp points to the position in yy_ch_buf of the start of 985 * the current run. 986 */ 987 yy_bp = yy_cp; 988 989 yy_current_state = yy_start; 990 yy_match: 991 do 992 { 993 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 994 if ( yy_accept[yy_current_state] ) 995 { 996 yy_last_accepting_state = yy_current_state; 997 yy_last_accepting_cpos = yy_cp; 998 } 999 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1000 { 1001 yy_current_state = (int) yy_def[yy_current_state]; 1002 if ( yy_current_state >= 559 ) 1003 yy_c = yy_meta[(unsigned int) yy_c]; 1004 } 1005 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1006 ++yy_cp; 1007 } 1008 while ( yy_base[yy_current_state] != 815 ); 1009 1010 yy_find_action: 1011 yy_act = yy_accept[yy_current_state]; 1012 if ( yy_act == 0 ) 1013 { /* have to back up */ 1014 yy_cp = yy_last_accepting_cpos; 1015 yy_current_state = yy_last_accepting_state; 1016 yy_act = yy_accept[yy_current_state]; 1017 } 1018 1019 YY_DO_BEFORE_ACTION; 1020 1021 1022 do_action: /* This label is used only to access EOF actions. */ 1023 1024 1025 switch ( yy_act ) 1026 { /* beginning of action switch */ 1027 case 0: /* must back up */ 1028 /* undo the effects of YY_DO_BEFORE_ACTION */ 1029 *yy_cp = yy_hold_char; 1030 yy_cp = yy_last_accepting_cpos; 1031 yy_current_state = yy_last_accepting_state; 1032 goto yy_find_action; 1033 1034 case 1: 1035 YY_RULE_SETUP 1036 #line 46 "bfin-lex.l" 1037 _REG.regno = REG_sftreset; return REG; 1038 YY_BREAK 1039 case 2: 1040 YY_RULE_SETUP 1041 #line 47 "bfin-lex.l" 1042 _REG.regno = REG_omode; return REG; 1043 YY_BREAK 1044 case 3: 1045 YY_RULE_SETUP 1046 #line 48 "bfin-lex.l" 1047 _REG.regno = REG_idle_req; return REG; 1048 YY_BREAK 1049 case 4: 1050 YY_RULE_SETUP 1051 #line 49 "bfin-lex.l" 1052 _REG.regno = REG_hwerrcause; return REG; 1053 YY_BREAK 1054 case 5: 1055 YY_RULE_SETUP 1056 #line 50 "bfin-lex.l" 1057 _REG.regno = REG_excause; return REG; 1058 YY_BREAK 1059 case 6: 1060 YY_RULE_SETUP 1061 #line 51 "bfin-lex.l" 1062 _REG.regno = REG_emucause; return REG; 1063 YY_BREAK 1064 case 7: 1065 YY_RULE_SETUP 1066 #line 52 "bfin-lex.l" 1067 return Z; 1068 YY_BREAK 1069 case 8: 1070 YY_RULE_SETUP 1071 #line 53 "bfin-lex.l" 1072 return X; 1073 YY_BREAK 1074 case 9: 1075 YY_RULE_SETUP 1076 #line 54 "bfin-lex.l" 1077 yylval.value = M_W32; return MMOD; 1078 YY_BREAK 1079 case 10: 1080 YY_RULE_SETUP 1081 #line 55 "bfin-lex.l" 1082 return W; 1083 YY_BREAK 1084 case 11: 1085 YY_RULE_SETUP 1086 #line 56 "bfin-lex.l" 1087 return VIT_MAX; 1088 YY_BREAK 1089 case 12: 1090 YY_RULE_SETUP 1091 #line 57 "bfin-lex.l" 1092 return V; /* Special: V is a statflag and a modifier. */ 1093 YY_BREAK 1094 case 13: 1095 YY_RULE_SETUP 1096 #line 58 "bfin-lex.l" 1097 _REG.regno = REG_USP; return REG; 1098 YY_BREAK 1099 case 14: 1100 YY_RULE_SETUP 1101 #line 59 "bfin-lex.l" 1102 return TL; 1103 YY_BREAK 1104 case 15: 1105 YY_RULE_SETUP 1106 #line 60 "bfin-lex.l" 1107 return TH; 1108 YY_BREAK 1109 case 16: 1110 YY_RULE_SETUP 1111 #line 61 "bfin-lex.l" 1112 yylval.value = M_TFU; return MMOD; 1113 YY_BREAK 1114 case 17: 1115 YY_RULE_SETUP 1116 #line 62 "bfin-lex.l" 1117 return TESTSET; 1118 YY_BREAK 1119 case 18: 1120 YY_RULE_SETUP 1121 #line 63 "bfin-lex.l" 1122 yylval.value = M_T; return MMOD; 1123 YY_BREAK 1124 case 19: 1125 YY_RULE_SETUP 1126 #line 64 "bfin-lex.l" 1127 return S; 1128 YY_BREAK 1129 case 20: 1130 YY_RULE_SETUP 1131 #line 65 "bfin-lex.l" 1132 _REG.regno = REG_SYSCFG; return REG; 1133 YY_BREAK 1134 case 21: 1135 YY_RULE_SETUP 1136 #line 66 "bfin-lex.l" 1137 return STI; 1138 YY_BREAK 1139 case 22: 1140 YY_RULE_SETUP 1141 #line 67 "bfin-lex.l" 1142 return SSYNC; 1143 YY_BREAK 1144 case 23: 1145 YY_RULE_SETUP 1146 #line 68 "bfin-lex.l" 1147 _REG.regno = REG_SP; return HALF_REG; 1148 YY_BREAK 1149 case 24: 1150 YY_RULE_SETUP 1151 #line 69 "bfin-lex.l" 1152 _REG.regno = REG_SP | F_REG_HIGH; return HALF_REG; 1153 YY_BREAK 1154 case 25: 1155 YY_RULE_SETUP 1156 #line 70 "bfin-lex.l" 1157 _REG.regno = REG_SP; return REG; 1158 YY_BREAK 1159 case 26: 1160 YY_RULE_SETUP 1161 #line 71 "bfin-lex.l" 1162 return SIGNBITS; 1163 YY_BREAK 1164 case 27: 1165 YY_RULE_SETUP 1166 #line 72 "bfin-lex.l" 1167 return SIGN; 1168 YY_BREAK 1169 case 28: 1170 YY_RULE_SETUP 1171 #line 73 "bfin-lex.l" 1172 _REG.regno = REG_SEQSTAT; return REG; 1173 YY_BREAK 1174 case 29: 1175 YY_RULE_SETUP 1176 #line 74 "bfin-lex.l" 1177 return SEARCH; 1178 YY_BREAK 1179 case 30: 1180 YY_RULE_SETUP 1181 #line 75 "bfin-lex.l" 1182 return SHIFT; 1183 YY_BREAK 1184 case 31: 1185 YY_RULE_SETUP 1186 #line 76 "bfin-lex.l" 1187 return SCO; 1188 YY_BREAK 1189 case 32: 1190 YY_RULE_SETUP 1191 #line 78 "bfin-lex.l" 1192 return SAA; 1193 YY_BREAK 1194 case 33: 1195 YY_RULE_SETUP 1196 #line 79 "bfin-lex.l" 1197 yylval.value = M_S2RND; return MMOD; 1198 YY_BREAK 1199 case 34: 1200 YY_RULE_SETUP 1201 #line 80 "bfin-lex.l" 1202 return RTX; 1203 YY_BREAK 1204 case 35: 1205 YY_RULE_SETUP 1206 #line 81 "bfin-lex.l" 1207 return RTS; 1208 YY_BREAK 1209 case 36: 1210 YY_RULE_SETUP 1211 #line 82 "bfin-lex.l" 1212 return RTN; 1213 YY_BREAK 1214 case 37: 1215 YY_RULE_SETUP 1216 #line 83 "bfin-lex.l" 1217 return RTI; 1218 YY_BREAK 1219 case 38: 1220 YY_RULE_SETUP 1221 #line 84 "bfin-lex.l" 1222 return RTE; 1223 YY_BREAK 1224 case 39: 1225 YY_RULE_SETUP 1226 #line 85 "bfin-lex.l" 1227 return ROT; 1228 YY_BREAK 1229 case 40: 1230 YY_RULE_SETUP 1231 #line 86 "bfin-lex.l" 1232 return RND20; 1233 YY_BREAK 1234 case 41: 1235 YY_RULE_SETUP 1236 #line 87 "bfin-lex.l" 1237 return RND12; 1238 YY_BREAK 1239 case 42: 1240 YY_RULE_SETUP 1241 #line 88 "bfin-lex.l" 1242 return RNDL; 1243 YY_BREAK 1244 case 43: 1245 YY_RULE_SETUP 1246 #line 89 "bfin-lex.l" 1247 return RNDH; 1248 YY_BREAK 1249 case 44: 1250 YY_RULE_SETUP 1251 #line 90 "bfin-lex.l" 1252 return RND; 1253 YY_BREAK 1254 case 45: 1255 YY_RULE_SETUP 1256 #line 92 "bfin-lex.l" 1257 return parse_halfreg(&yylval.reg, T_REG_R, yytext); 1258 YY_BREAK 1259 case 46: 1260 YY_RULE_SETUP 1261 #line 94 "bfin-lex.l" 1262 _REG.regno = REG_RETS; return REG; 1263 YY_BREAK 1264 case 47: 1265 YY_RULE_SETUP 1266 #line 95 "bfin-lex.l" 1267 _REG.regno = REG_RETI; return REG; 1268 YY_BREAK 1269 case 48: 1270 YY_RULE_SETUP 1271 #line 96 "bfin-lex.l" 1272 _REG.regno = REG_RETX; return REG; 1273 YY_BREAK 1274 case 49: 1275 YY_RULE_SETUP 1276 #line 97 "bfin-lex.l" 1277 _REG.regno = REG_RETN; return REG; 1278 YY_BREAK 1279 case 50: 1280 YY_RULE_SETUP 1281 #line 98 "bfin-lex.l" 1282 _REG.regno = REG_RETE; return REG; 1283 YY_BREAK 1284 case 51: 1285 YY_RULE_SETUP 1286 #line 99 "bfin-lex.l" 1287 _REG.regno = REG_EMUDAT; return REG; 1288 YY_BREAK 1289 case 52: 1290 YY_RULE_SETUP 1291 #line 100 "bfin-lex.l" 1292 return RAISE; 1293 YY_BREAK 1294 case 53: 1295 YY_RULE_SETUP 1296 #line 102 "bfin-lex.l" 1297 return parse_reg (&yylval.reg, T_REG_R, yytext); 1298 YY_BREAK 1299 case 54: 1300 YY_RULE_SETUP 1301 #line 104 "bfin-lex.l" 1302 return R; 1303 YY_BREAK 1304 case 55: 1305 YY_RULE_SETUP 1306 #line 105 "bfin-lex.l" 1307 return PRNT; 1308 YY_BREAK 1309 case 56: 1310 YY_RULE_SETUP 1311 #line 106 "bfin-lex.l" 1312 return PC; 1313 YY_BREAK 1314 case 57: 1315 YY_RULE_SETUP 1316 #line 107 "bfin-lex.l" 1317 return PACK; 1318 YY_BREAK 1319 case 58: 1320 YY_RULE_SETUP 1321 #line 109 "bfin-lex.l" 1322 return parse_halfreg (&yylval.reg, T_REG_P, yytext); 1323 YY_BREAK 1324 case 59: 1325 YY_RULE_SETUP 1326 #line 110 "bfin-lex.l" 1327 return parse_reg (&yylval.reg, T_REG_P, yytext); 1328 YY_BREAK 1329 case 60: 1330 YY_RULE_SETUP 1331 #line 112 "bfin-lex.l" 1332 return OUTC; 1333 YY_BREAK 1334 case 61: 1335 YY_RULE_SETUP 1336 #line 113 "bfin-lex.l" 1337 return ONES; 1338 YY_BREAK 1339 case 62: 1340 YY_RULE_SETUP 1341 #line 115 "bfin-lex.l" 1342 return NOT; 1343 YY_BREAK 1344 case 63: 1345 YY_RULE_SETUP 1346 #line 116 "bfin-lex.l" 1347 return NOP; 1348 YY_BREAK 1349 case 64: 1350 YY_RULE_SETUP 1351 #line 117 "bfin-lex.l" 1352 return MNOP; 1353 YY_BREAK 1354 case 65: 1355 YY_RULE_SETUP 1356 #line 118 "bfin-lex.l" 1357 return NS; 1358 YY_BREAK 1359 case 66: 1360 YY_RULE_SETUP 1361 #line 121 "bfin-lex.l" 1362 return MIN; 1363 YY_BREAK 1364 case 67: 1365 YY_RULE_SETUP 1366 #line 122 "bfin-lex.l" 1367 return MAX; 1368 YY_BREAK 1369 case 68: 1370 YY_RULE_SETUP 1371 #line 124 "bfin-lex.l" 1372 return parse_halfreg (&yylval.reg, T_REG_M, yytext); 1373 YY_BREAK 1374 case 69: 1375 YY_RULE_SETUP 1376 #line 125 "bfin-lex.l" 1377 return parse_reg (&yylval.reg, T_REG_M, yytext); 1378 YY_BREAK 1379 case 70: 1380 YY_RULE_SETUP 1381 #line 127 "bfin-lex.l" 1382 return M; 1383 YY_BREAK 1384 case 71: 1385 YY_RULE_SETUP 1386 #line 128 "bfin-lex.l" 1387 return LT; 1388 YY_BREAK 1389 case 72: 1390 YY_RULE_SETUP 1391 #line 129 "bfin-lex.l" 1392 return LSHIFT; 1393 YY_BREAK 1394 case 73: 1395 YY_RULE_SETUP 1396 #line 130 "bfin-lex.l" 1397 return LSETUP; 1398 YY_BREAK 1399 case 74: 1400 YY_RULE_SETUP 1401 #line 131 "bfin-lex.l" 1402 return LOOP; 1403 YY_BREAK 1404 case 75: 1405 YY_RULE_SETUP 1406 #line 132 "bfin-lex.l" 1407 return LOOP_BEGIN; 1408 YY_BREAK 1409 case 76: 1410 YY_RULE_SETUP 1411 #line 133 "bfin-lex.l" 1412 return LOOP_END; 1413 YY_BREAK 1414 case 77: 1415 YY_RULE_SETUP 1416 #line 135 "bfin-lex.l" 1417 return LE; 1418 YY_BREAK 1419 case 78: 1420 YY_RULE_SETUP 1421 #line 136 "bfin-lex.l" 1422 _REG.regno = REG_LC0; return REG; 1423 YY_BREAK 1424 case 79: 1425 YY_RULE_SETUP 1426 #line 137 "bfin-lex.l" 1427 _REG.regno = REG_LT0; return REG; 1428 YY_BREAK 1429 case 80: 1430 YY_RULE_SETUP 1431 #line 138 "bfin-lex.l" 1432 _REG.regno = REG_LB0; return REG; 1433 YY_BREAK 1434 case 81: 1435 YY_RULE_SETUP 1436 #line 139 "bfin-lex.l" 1437 _REG.regno = REG_LC1; return REG; 1438 YY_BREAK 1439 case 82: 1440 YY_RULE_SETUP 1441 #line 140 "bfin-lex.l" 1442 _REG.regno = REG_LT1; return REG; 1443 YY_BREAK 1444 case 83: 1445 YY_RULE_SETUP 1446 #line 141 "bfin-lex.l" 1447 _REG.regno = REG_LB1; return REG; 1448 YY_BREAK 1449 case 84: 1450 YY_RULE_SETUP 1451 #line 143 "bfin-lex.l" 1452 return parse_halfreg (&yylval.reg, T_REG_L, yytext); 1453 YY_BREAK 1454 case 85: 1455 YY_RULE_SETUP 1456 #line 144 "bfin-lex.l" 1457 return parse_reg (&yylval.reg, T_REG_L, yytext); 1458 YY_BREAK 1459 case 86: 1460 YY_RULE_SETUP 1461 #line 145 "bfin-lex.l" 1462 return LO; 1463 YY_BREAK 1464 case 87: 1465 YY_RULE_SETUP 1466 #line 146 "bfin-lex.l" 1467 { BEGIN 0; return JUMP_DOT_S;} 1468 YY_BREAK 1469 case 88: 1470 YY_RULE_SETUP 1471 #line 147 "bfin-lex.l" 1472 { BEGIN 0; return JUMP_DOT_L;} 1473 YY_BREAK 1474 case 89: 1475 YY_RULE_SETUP 1476 #line 148 "bfin-lex.l" 1477 { BEGIN 0; return JUMP;} 1478 YY_BREAK 1479 case 90: 1480 YY_RULE_SETUP 1481 #line 149 "bfin-lex.l" 1482 { BEGIN 0; return JUMP_DOT_L; } 1483 YY_BREAK 1484 case 91: 1485 YY_RULE_SETUP 1486 #line 150 "bfin-lex.l" 1487 yylval.value = M_IU; return MMOD; 1488 YY_BREAK 1489 case 92: 1490 YY_RULE_SETUP 1491 #line 151 "bfin-lex.l" 1492 yylval.value = M_ISS2; return MMOD; 1493 YY_BREAK 1494 case 93: 1495 YY_RULE_SETUP 1496 #line 152 "bfin-lex.l" 1497 yylval.value = M_IS; return MMOD; 1498 YY_BREAK 1499 case 94: 1500 YY_RULE_SETUP 1501 #line 153 "bfin-lex.l" 1502 yylval.value = M_IH; return MMOD; 1503 YY_BREAK 1504 case 95: 1505 YY_RULE_SETUP 1506 #line 154 "bfin-lex.l" 1507 return IF; 1508 YY_BREAK 1509 case 96: 1510 YY_RULE_SETUP 1511 #line 155 "bfin-lex.l" 1512 return parse_halfreg (&yylval.reg, T_REG_I, yytext); 1513 YY_BREAK 1514 case 97: 1515 YY_RULE_SETUP 1516 #line 156 "bfin-lex.l" 1517 return parse_reg (&yylval.reg, T_REG_I, yytext); 1518 YY_BREAK 1519 case 98: 1520 YY_RULE_SETUP 1521 #line 157 "bfin-lex.l" 1522 return HLT; 1523 YY_BREAK 1524 case 99: 1525 YY_RULE_SETUP 1526 #line 158 "bfin-lex.l" 1527 return HI; 1528 YY_BREAK 1529 case 100: 1530 YY_RULE_SETUP 1531 #line 159 "bfin-lex.l" 1532 return GT; 1533 YY_BREAK 1534 case 101: 1535 YY_RULE_SETUP 1536 #line 160 "bfin-lex.l" 1537 return GE; 1538 YY_BREAK 1539 case 102: 1540 YY_RULE_SETUP 1541 #line 161 "bfin-lex.l" 1542 yylval.value = M_FU; return MMOD; 1543 YY_BREAK 1544 case 103: 1545 YY_RULE_SETUP 1546 #line 162 "bfin-lex.l" 1547 _REG.regno = REG_FP; return REG; 1548 YY_BREAK 1549 case 104: 1550 YY_RULE_SETUP 1551 #line 163 "bfin-lex.l" 1552 _REG.regno = REG_FP; return HALF_REG; 1553 YY_BREAK 1554 case 105: 1555 YY_RULE_SETUP 1556 #line 164 "bfin-lex.l" 1557 _REG.regno = REG_FP | F_REG_HIGH; return HALF_REG; 1558 YY_BREAK 1559 case 106: 1560 YY_RULE_SETUP 1561 #line 166 "bfin-lex.l" 1562 return EXTRACT; 1563 YY_BREAK 1564 case 107: 1565 YY_RULE_SETUP 1566 #line 167 "bfin-lex.l" 1567 return EXPADJ; 1568 YY_BREAK 1569 case 108: 1570 YY_RULE_SETUP 1571 #line 168 "bfin-lex.l" 1572 return EXCPT; 1573 YY_BREAK 1574 case 109: 1575 YY_RULE_SETUP 1576 #line 169 "bfin-lex.l" 1577 return EMUEXCPT; 1578 YY_BREAK 1579 case 110: 1580 YY_RULE_SETUP 1581 #line 170 "bfin-lex.l" 1582 return DIVS; 1583 YY_BREAK 1584 case 111: 1585 YY_RULE_SETUP 1586 #line 171 "bfin-lex.l" 1587 return DIVQ; 1588 YY_BREAK 1589 case 112: 1590 YY_RULE_SETUP 1591 #line 172 "bfin-lex.l" 1592 return DISALGNEXCPT; 1593 YY_BREAK 1594 case 113: 1595 YY_RULE_SETUP 1596 #line 173 "bfin-lex.l" 1597 return DEPOSIT; 1598 YY_BREAK 1599 case 114: 1600 YY_RULE_SETUP 1601 #line 174 "bfin-lex.l" 1602 return DBGHALT; 1603 YY_BREAK 1604 case 115: 1605 YY_RULE_SETUP 1606 #line 175 "bfin-lex.l" 1607 return DBGCMPLX; 1608 YY_BREAK 1609 case 116: 1610 YY_RULE_SETUP 1611 #line 176 "bfin-lex.l" 1612 return DBGAL; 1613 YY_BREAK 1614 case 117: 1615 YY_RULE_SETUP 1616 #line 177 "bfin-lex.l" 1617 return DBGAH; 1618 YY_BREAK 1619 case 118: 1620 YY_RULE_SETUP 1621 #line 178 "bfin-lex.l" 1622 return DBGA; 1623 YY_BREAK 1624 case 119: 1625 YY_RULE_SETUP 1626 #line 179 "bfin-lex.l" 1627 return DBG; 1628 YY_BREAK 1629 case 120: 1630 YY_RULE_SETUP 1631 #line 180 "bfin-lex.l" 1632 { _REG.regno = REG_CYCLES2; return REG; } 1633 YY_BREAK 1634 case 121: 1635 YY_RULE_SETUP 1636 #line 181 "bfin-lex.l" 1637 { _REG.regno = REG_CYCLES; return REG; } 1638 YY_BREAK 1639 case 122: 1640 YY_RULE_SETUP 1641 #line 182 "bfin-lex.l" 1642 return CSYNC; 1643 YY_BREAK 1644 case 123: 1645 YY_RULE_SETUP 1646 #line 183 "bfin-lex.l" 1647 return CO; 1648 YY_BREAK 1649 case 124: 1650 YY_RULE_SETUP 1651 #line 184 "bfin-lex.l" 1652 return CLI; 1653 YY_BREAK 1654 case 125: 1655 YY_RULE_SETUP 1656 #line 186 "bfin-lex.l" 1657 _REG.regno = REG_CC; return CCREG; 1658 YY_BREAK 1659 case 126: 1660 YY_RULE_SETUP 1661 #line 187 "bfin-lex.l" 1662 { BEGIN 0; return CALL;} 1663 YY_BREAK 1664 case 127: 1665 YY_RULE_SETUP 1666 #line 188 "bfin-lex.l" 1667 { BEGIN 0; return CALL;} 1668 YY_BREAK 1669 case 128: 1670 YY_RULE_SETUP 1671 #line 189 "bfin-lex.l" 1672 return BYTEUNPACK; 1673 YY_BREAK 1674 case 129: 1675 YY_RULE_SETUP 1676 #line 190 "bfin-lex.l" 1677 return BYTEPACK; 1678 YY_BREAK 1679 case 130: 1680 YY_RULE_SETUP 1681 #line 191 "bfin-lex.l" 1682 return BYTEOP16M; 1683 YY_BREAK 1684 case 131: 1685 YY_RULE_SETUP 1686 #line 192 "bfin-lex.l" 1687 return BYTEOP16P; 1688 YY_BREAK 1689 case 132: 1690 YY_RULE_SETUP 1691 #line 193 "bfin-lex.l" 1692 return BYTEOP3P; 1693 YY_BREAK 1694 case 133: 1695 YY_RULE_SETUP 1696 #line 194 "bfin-lex.l" 1697 return BYTEOP2M; 1698 YY_BREAK 1699 case 134: 1700 YY_RULE_SETUP 1701 #line 195 "bfin-lex.l" 1702 return BYTEOP2P; 1703 YY_BREAK 1704 case 135: 1705 YY_RULE_SETUP 1706 #line 196 "bfin-lex.l" 1707 return BYTEOP1P; 1708 YY_BREAK 1709 case 136: 1710 YY_RULE_SETUP 1711 #line 197 "bfin-lex.l" 1712 return BY; 1713 YY_BREAK 1714 case 137: 1715 YY_RULE_SETUP 1716 #line 198 "bfin-lex.l" 1717 return BXORSHIFT; 1718 YY_BREAK 1719 case 138: 1720 YY_RULE_SETUP 1721 #line 199 "bfin-lex.l" 1722 return BXOR; 1723 YY_BREAK 1724 case 139: 1725 YY_RULE_SETUP 1726 #line 201 "bfin-lex.l" 1727 return BREV; 1728 YY_BREAK 1729 case 140: 1730 YY_RULE_SETUP 1731 #line 202 "bfin-lex.l" 1732 return BP; 1733 YY_BREAK 1734 case 141: 1735 YY_RULE_SETUP 1736 #line 203 "bfin-lex.l" 1737 return BITTST; 1738 YY_BREAK 1739 case 142: 1740 YY_RULE_SETUP 1741 #line 204 "bfin-lex.l" 1742 return BITTGL; 1743 YY_BREAK 1744 case 143: 1745 YY_RULE_SETUP 1746 #line 205 "bfin-lex.l" 1747 return BITSET; 1748 YY_BREAK 1749 case 144: 1750 YY_RULE_SETUP 1751 #line 206 "bfin-lex.l" 1752 return BITMUX; 1753 YY_BREAK 1754 case 145: 1755 YY_RULE_SETUP 1756 #line 207 "bfin-lex.l" 1757 return BITCLR; 1758 YY_BREAK 1759 case 146: 1760 YY_RULE_SETUP 1761 #line 208 "bfin-lex.l" 1762 return parse_halfreg (&yylval.reg, T_REG_B, yytext); 1763 YY_BREAK 1764 case 147: 1765 YY_RULE_SETUP 1766 #line 209 "bfin-lex.l" 1767 return parse_reg (&yylval.reg, T_REG_B, yytext); 1768 YY_BREAK 1769 case 148: 1770 YY_RULE_SETUP 1771 #line 210 "bfin-lex.l" 1772 return B; 1773 YY_BREAK 1774 case 149: 1775 YY_RULE_SETUP 1776 #line 211 "bfin-lex.l" 1777 _REG.regno = S_AZ; return STATUS_REG; 1778 YY_BREAK 1779 case 150: 1780 YY_RULE_SETUP 1781 #line 212 "bfin-lex.l" 1782 _REG.regno = S_AN; return STATUS_REG; 1783 YY_BREAK 1784 case 151: 1785 YY_RULE_SETUP 1786 #line 213 "bfin-lex.l" 1787 _REG.regno = S_AQ; return STATUS_REG; 1788 YY_BREAK 1789 case 152: 1790 YY_RULE_SETUP 1791 #line 214 "bfin-lex.l" 1792 _REG.regno = S_AC0; return STATUS_REG; 1793 YY_BREAK 1794 case 153: 1795 YY_RULE_SETUP 1796 #line 215 "bfin-lex.l" 1797 _REG.regno = S_AC1; return STATUS_REG; 1798 YY_BREAK 1799 case 154: 1800 YY_RULE_SETUP 1801 #line 216 "bfin-lex.l" 1802 _REG.regno = S_AV0; return STATUS_REG; 1803 YY_BREAK 1804 case 155: 1805 YY_RULE_SETUP 1806 #line 217 "bfin-lex.l" 1807 _REG.regno = S_AV0S; return STATUS_REG; 1808 YY_BREAK 1809 case 156: 1810 YY_RULE_SETUP 1811 #line 218 "bfin-lex.l" 1812 _REG.regno = S_AV1; return STATUS_REG; 1813 YY_BREAK 1814 case 157: 1815 YY_RULE_SETUP 1816 #line 219 "bfin-lex.l" 1817 _REG.regno = S_AV1S; return STATUS_REG; 1818 YY_BREAK 1819 case 158: 1820 YY_RULE_SETUP 1821 #line 220 "bfin-lex.l" 1822 _REG.regno = S_V; return STATUS_REG; 1823 YY_BREAK 1824 case 159: 1825 YY_RULE_SETUP 1826 #line 221 "bfin-lex.l" 1827 _REG.regno = S_VS; return STATUS_REG; 1828 YY_BREAK 1829 case 160: 1830 YY_RULE_SETUP 1831 #line 224 "bfin-lex.l" 1832 _REG.regno = REG_ASTAT; return REG; 1833 YY_BREAK 1834 case 161: 1835 YY_RULE_SETUP 1836 #line 225 "bfin-lex.l" 1837 return ASHIFT; 1838 YY_BREAK 1839 case 162: 1840 YY_RULE_SETUP 1841 #line 226 "bfin-lex.l" 1842 return ASL; 1843 YY_BREAK 1844 case 163: 1845 YY_RULE_SETUP 1846 #line 227 "bfin-lex.l" 1847 return ASR; 1848 YY_BREAK 1849 case 164: 1850 YY_RULE_SETUP 1851 #line 228 "bfin-lex.l" 1852 return ALIGN8; 1853 YY_BREAK 1854 case 165: 1855 YY_RULE_SETUP 1856 #line 229 "bfin-lex.l" 1857 return ALIGN16; 1858 YY_BREAK 1859 case 166: 1860 YY_RULE_SETUP 1861 #line 230 "bfin-lex.l" 1862 return ALIGN24; 1863 YY_BREAK 1864 case 167: 1865 YY_RULE_SETUP 1866 #line 231 "bfin-lex.l" 1867 return A_ONE_DOT_L; 1868 YY_BREAK 1869 case 168: 1870 YY_RULE_SETUP 1871 #line 232 "bfin-lex.l" 1872 return A_ZERO_DOT_L; 1873 YY_BREAK 1874 case 169: 1875 YY_RULE_SETUP 1876 #line 233 "bfin-lex.l" 1877 return A_ONE_DOT_H; 1878 YY_BREAK 1879 case 170: 1880 YY_RULE_SETUP 1881 #line 234 "bfin-lex.l" 1882 return A_ZERO_DOT_H; 1883 YY_BREAK 1884 case 171: 1885 YY_RULE_SETUP 1886 #line 235 "bfin-lex.l" 1887 return ABS; 1888 YY_BREAK 1889 case 172: 1890 YY_RULE_SETUP 1891 #line 236 "bfin-lex.l" 1892 return ABORT; 1893 YY_BREAK 1894 case 173: 1895 YY_RULE_SETUP 1896 #line 237 "bfin-lex.l" 1897 _REG.regno = REG_A1x; return REG; 1898 YY_BREAK 1899 case 174: 1900 YY_RULE_SETUP 1901 #line 238 "bfin-lex.l" 1902 _REG.regno = REG_A1w; return REG; 1903 YY_BREAK 1904 case 175: 1905 YY_RULE_SETUP 1906 #line 239 "bfin-lex.l" 1907 _REG.regno = REG_A1; return REG_A_DOUBLE_ONE; 1908 YY_BREAK 1909 case 176: 1910 YY_RULE_SETUP 1911 #line 240 "bfin-lex.l" 1912 _REG.regno = REG_A0x; return REG; 1913 YY_BREAK 1914 case 177: 1915 YY_RULE_SETUP 1916 #line 241 "bfin-lex.l" 1917 _REG.regno = REG_A0w; return REG; 1918 YY_BREAK 1919 case 178: 1920 YY_RULE_SETUP 1921 #line 242 "bfin-lex.l" 1922 _REG.regno = REG_A0; return REG_A_DOUBLE_ZERO; 1923 YY_BREAK 1924 case 179: 1925 YY_RULE_SETUP 1926 #line 243 "bfin-lex.l" 1927 return GOT; 1928 YY_BREAK 1929 case 180: 1930 YY_RULE_SETUP 1931 #line 244 "bfin-lex.l" 1932 return GOT17M4; 1933 YY_BREAK 1934 case 181: 1935 YY_RULE_SETUP 1936 #line 245 "bfin-lex.l" 1937 return FUNCDESC_GOT17M4; 1938 YY_BREAK 1939 case 182: 1940 YY_RULE_SETUP 1941 #line 246 "bfin-lex.l" 1942 return PLTPC; 1943 YY_BREAK 1944 case 183: 1945 YY_RULE_SETUP 1946 #line 249 "bfin-lex.l" 1947 return TILDA; 1948 YY_BREAK 1949 case 184: 1950 YY_RULE_SETUP 1951 #line 250 "bfin-lex.l" 1952 return _BAR_ASSIGN; 1953 YY_BREAK 1954 case 185: 1955 YY_RULE_SETUP 1956 #line 251 "bfin-lex.l" 1957 return BAR; 1958 YY_BREAK 1959 case 186: 1960 YY_RULE_SETUP 1961 #line 252 "bfin-lex.l" 1962 return _CARET_ASSIGN; 1963 YY_BREAK 1964 case 187: 1965 YY_RULE_SETUP 1966 #line 253 "bfin-lex.l" 1967 return CARET; 1968 YY_BREAK 1969 case 188: 1970 YY_RULE_SETUP 1971 #line 254 "bfin-lex.l" 1972 return RBRACK; 1973 YY_BREAK 1974 case 189: 1975 YY_RULE_SETUP 1976 #line 255 "bfin-lex.l" 1977 return LBRACK; 1978 YY_BREAK 1979 case 190: 1980 YY_RULE_SETUP 1981 #line 256 "bfin-lex.l" 1982 return _GREATER_GREATER_GREATER_THAN_ASSIGN; 1983 YY_BREAK 1984 case 191: 1985 YY_RULE_SETUP 1986 #line 257 "bfin-lex.l" 1987 return _GREATER_GREATER_ASSIGN; 1988 YY_BREAK 1989 case 192: 1990 YY_RULE_SETUP 1991 #line 258 "bfin-lex.l" 1992 return _GREATER_GREATER_GREATER; 1993 YY_BREAK 1994 case 193: 1995 YY_RULE_SETUP 1996 #line 259 "bfin-lex.l" 1997 return GREATER_GREATER; 1998 YY_BREAK 1999 case 194: 2000 YY_RULE_SETUP 2001 #line 260 "bfin-lex.l" 2002 return _ASSIGN_ASSIGN; 2003 YY_BREAK 2004 case 195: 2005 YY_RULE_SETUP 2006 #line 261 "bfin-lex.l" 2007 return ASSIGN; 2008 YY_BREAK 2009 case 196: 2010 YY_RULE_SETUP 2011 #line 262 "bfin-lex.l" 2012 return _LESS_THAN_ASSIGN; 2013 YY_BREAK 2014 case 197: 2015 YY_RULE_SETUP 2016 #line 263 "bfin-lex.l" 2017 return _LESS_LESS_ASSIGN; 2018 YY_BREAK 2019 case 198: 2020 YY_RULE_SETUP 2021 #line 264 "bfin-lex.l" 2022 return LESS_LESS; 2023 YY_BREAK 2024 case 199: 2025 YY_RULE_SETUP 2026 #line 265 "bfin-lex.l" 2027 return LESS_THAN; 2028 YY_BREAK 2029 case 200: 2030 YY_RULE_SETUP 2031 #line 266 "bfin-lex.l" 2032 return LPAREN; 2033 YY_BREAK 2034 case 201: 2035 YY_RULE_SETUP 2036 #line 267 "bfin-lex.l" 2037 return RPAREN; 2038 YY_BREAK 2039 case 202: 2040 YY_RULE_SETUP 2041 #line 268 "bfin-lex.l" 2042 return COLON; 2043 YY_BREAK 2044 case 203: 2045 YY_RULE_SETUP 2046 #line 269 "bfin-lex.l" 2047 return SLASH; 2048 YY_BREAK 2049 case 204: 2050 YY_RULE_SETUP 2051 #line 270 "bfin-lex.l" 2052 return _MINUS_ASSIGN; 2053 YY_BREAK 2054 case 205: 2055 YY_RULE_SETUP 2056 #line 271 "bfin-lex.l" 2057 return _PLUS_BAR_PLUS; 2058 YY_BREAK 2059 case 206: 2060 YY_RULE_SETUP 2061 #line 272 "bfin-lex.l" 2062 return _MINUS_BAR_PLUS; 2063 YY_BREAK 2064 case 207: 2065 YY_RULE_SETUP 2066 #line 273 "bfin-lex.l" 2067 return _PLUS_BAR_MINUS; 2068 YY_BREAK 2069 case 208: 2070 YY_RULE_SETUP 2071 #line 274 "bfin-lex.l" 2072 return _MINUS_BAR_MINUS; 2073 YY_BREAK 2074 case 209: 2075 YY_RULE_SETUP 2076 #line 275 "bfin-lex.l" 2077 return _MINUS_MINUS; 2078 YY_BREAK 2079 case 210: 2080 YY_RULE_SETUP 2081 #line 276 "bfin-lex.l" 2082 return MINUS; 2083 YY_BREAK 2084 case 211: 2085 YY_RULE_SETUP 2086 #line 277 "bfin-lex.l" 2087 return COMMA; 2088 YY_BREAK 2089 case 212: 2090 YY_RULE_SETUP 2091 #line 278 "bfin-lex.l" 2092 return _PLUS_ASSIGN; 2093 YY_BREAK 2094 case 213: 2095 YY_RULE_SETUP 2096 #line 279 "bfin-lex.l" 2097 return _PLUS_PLUS; 2098 YY_BREAK 2099 case 214: 2100 YY_RULE_SETUP 2101 #line 280 "bfin-lex.l" 2102 return PLUS; 2103 YY_BREAK 2104 case 215: 2105 YY_RULE_SETUP 2106 #line 281 "bfin-lex.l" 2107 return _STAR_ASSIGN; 2108 YY_BREAK 2109 case 216: 2110 YY_RULE_SETUP 2111 #line 282 "bfin-lex.l" 2112 return STAR; 2113 YY_BREAK 2114 case 217: 2115 YY_RULE_SETUP 2116 #line 283 "bfin-lex.l" 2117 return _AMPERSAND_ASSIGN; 2118 YY_BREAK 2119 case 218: 2120 YY_RULE_SETUP 2121 #line 284 "bfin-lex.l" 2122 return AMPERSAND; 2123 YY_BREAK 2124 case 219: 2125 YY_RULE_SETUP 2126 #line 285 "bfin-lex.l" 2127 return PERCENT; 2128 YY_BREAK 2129 case 220: 2130 YY_RULE_SETUP 2131 #line 286 "bfin-lex.l" 2132 return BANG; 2133 YY_BREAK 2134 case 221: 2135 YY_RULE_SETUP 2136 #line 287 "bfin-lex.l" 2137 return SEMICOLON; 2138 YY_BREAK 2139 case 222: 2140 YY_RULE_SETUP 2141 #line 288 "bfin-lex.l" 2142 return _ASSIGN_BANG; 2143 YY_BREAK 2144 case 223: 2145 YY_RULE_SETUP 2146 #line 289 "bfin-lex.l" 2147 return DOUBLE_BAR; 2148 YY_BREAK 2149 case 224: 2150 YY_RULE_SETUP 2151 #line 290 "bfin-lex.l" 2152 return AT; 2153 YY_BREAK 2154 case 225: 2155 YY_RULE_SETUP 2156 #line 291 "bfin-lex.l" 2157 return PREFETCH; 2158 YY_BREAK 2159 case 226: 2160 YY_RULE_SETUP 2161 #line 292 "bfin-lex.l" 2162 return UNLINK; 2163 YY_BREAK 2164 case 227: 2165 YY_RULE_SETUP 2166 #line 293 "bfin-lex.l" 2167 return LINK; 2168 YY_BREAK 2169 case 228: 2170 YY_RULE_SETUP 2171 #line 294 "bfin-lex.l" 2172 return IDLE; 2173 YY_BREAK 2174 case 229: 2175 YY_RULE_SETUP 2176 #line 295 "bfin-lex.l" 2177 return IFLUSH; 2178 YY_BREAK 2179 case 230: 2180 YY_RULE_SETUP 2181 #line 296 "bfin-lex.l" 2182 return FLUSHINV; 2183 YY_BREAK 2184 case 231: 2185 YY_RULE_SETUP 2186 #line 297 "bfin-lex.l" 2187 return FLUSH; 2188 YY_BREAK 2189 case 232: 2190 YY_RULE_SETUP 2191 #line 298 "bfin-lex.l" 2192 { 2193 yylval.value = parse_int (&yytext); 2194 return NUMBER; 2195 } 2196 YY_BREAK 2197 case 233: 2198 YY_RULE_SETUP 2199 #line 302 "bfin-lex.l" 2200 { 2201 yylval.symbol = symbol_find_or_make (yytext); 2202 symbol_mark_used (yylval.symbol); 2203 return SYMBOL; 2204 } 2205 YY_BREAK 2206 case 234: 2207 YY_RULE_SETUP 2208 #line 307 "bfin-lex.l" 2209 { 2210 char *name; 2211 char *ref = strdup (yytext); 2212 if (ref[1] == 'b' || ref[1] == 'B') 2213 { 2214 name = fb_label_name ((int) (ref[0] - '0'), 0); 2215 yylval.symbol = symbol_find (name); 2216 2217 if ((yylval.symbol != NULL) 2218 && (S_IS_DEFINED (yylval.symbol))) 2219 return SYMBOL; 2220 as_bad ("backward reference to unknown label %d:", 2221 (int) (ref[0] - '0')); 2222 } 2223 else if (ref[1] == 'f' || ref[1] == 'F') 2224 { 2225 /* Forward reference. Expect symbol to be undefined or 2226 unknown. undefined: seen it before. unknown: never seen 2227 it before. 2228 2229 Construct a local label name, then an undefined symbol. 2230 Just return it as never seen before. */ 2231 2232 name = fb_label_name ((int) (ref[0] - '0'), 1); 2233 yylval.symbol = symbol_find_or_make (name); 2234 /* We have no need to check symbol properties. */ 2235 return SYMBOL; 2236 } 2237 } 2238 YY_BREAK 2239 case 235: 2240 YY_RULE_SETUP 2241 #line 336 "bfin-lex.l" 2242 ; 2243 YY_BREAK 2244 case 236: 2245 YY_RULE_SETUP 2246 #line 337 "bfin-lex.l" 2247 ; 2248 YY_BREAK 2249 case 237: 2250 YY_RULE_SETUP 2251 #line 338 "bfin-lex.l" 2252 return yytext[0]; 2253 YY_BREAK 2254 case 238: 2255 YY_RULE_SETUP 2256 #line 339 "bfin-lex.l" 2257 ECHO; 2258 YY_BREAK 2259 #line 2260 "bfin-lex.c" 2260 case YY_STATE_EOF(INITIAL): 2261 case YY_STATE_EOF(KEYWORD): 2262 yyterminate(); 2263 2264 case YY_END_OF_BUFFER: 2265 { 2266 /* Amount of text matched not including the EOB char. */ 2267 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; 2268 2269 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 2270 *yy_cp = yy_hold_char; 2271 YY_RESTORE_YY_MORE_OFFSET 2272 2273 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) 2274 { 2275 /* We're scanning a new file or input source. It's 2276 * possible that this happened because the user 2277 * just pointed yyin at a new source and called 2278 * yylex(). If so, then we have to assure 2279 * consistency between yy_current_buffer and our 2280 * globals. Here is the right place to do so, because 2281 * this is the first action (other than possibly a 2282 * back-up) that will match for the new input source. 2283 */ 2284 yy_n_chars = yy_current_buffer->yy_n_chars; 2285 yy_current_buffer->yy_input_file = yyin; 2286 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; 2287 } 2288 2289 /* Note that here we test for yy_c_buf_p "<=" to the position 2290 * of the first EOB in the buffer, since yy_c_buf_p will 2291 * already have been incremented past the NUL character 2292 * (since all states make transitions on EOB to the 2293 * end-of-buffer state). Contrast this with the test 2294 * in input(). 2295 */ 2296 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 2297 { /* This was really a NUL. */ 2298 yy_state_type yy_next_state; 2299 2300 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; 2301 2302 yy_current_state = yy_get_previous_state(); 2303 2304 /* Okay, we're now positioned to make the NUL 2305 * transition. We couldn't have 2306 * yy_get_previous_state() go ahead and do it 2307 * for us because it doesn't know how to deal 2308 * with the possibility of jamming (and we don't 2309 * want to build jamming into it because then it 2310 * will run more slowly). 2311 */ 2312 2313 yy_next_state = yy_try_NUL_trans( yy_current_state ); 2314 2315 yy_bp = yytext_ptr + YY_MORE_ADJ; 2316 2317 if ( yy_next_state ) 2318 { 2319 /* Consume the NUL. */ 2320 yy_cp = ++yy_c_buf_p; 2321 yy_current_state = yy_next_state; 2322 goto yy_match; 2323 } 2324 2325 else 2326 { 2327 yy_cp = yy_c_buf_p; 2328 goto yy_find_action; 2329 } 2330 } 2331 2332 else switch ( yy_get_next_buffer() ) 2333 { 2334 case EOB_ACT_END_OF_FILE: 2335 { 2336 yy_did_buffer_switch_on_eof = 0; 2337 2338 if ( yywrap() ) 2339 { 2340 /* Note: because we've taken care in 2341 * yy_get_next_buffer() to have set up 2342 * yytext, we can now set up 2343 * yy_c_buf_p so that if some total 2344 * hoser (like flex itself) wants to 2345 * call the scanner after we return the 2346 * YY_NULL, it'll still work - another 2347 * YY_NULL will get returned. 2348 */ 2349 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; 2350 2351 yy_act = YY_STATE_EOF(YY_START); 2352 goto do_action; 2353 } 2354 2355 else 2356 { 2357 if ( ! yy_did_buffer_switch_on_eof ) 2358 YY_NEW_FILE; 2359 } 2360 break; 2361 } 2362 2363 case EOB_ACT_CONTINUE_SCAN: 2364 yy_c_buf_p = 2365 yytext_ptr + yy_amount_of_matched_text; 2366 2367 yy_current_state = yy_get_previous_state(); 2368 2369 yy_cp = yy_c_buf_p; 2370 yy_bp = yytext_ptr + YY_MORE_ADJ; 2371 goto yy_match; 2372 2373 case EOB_ACT_LAST_MATCH: 2374 yy_c_buf_p = 2375 &yy_current_buffer->yy_ch_buf[yy_n_chars]; 2376 2377 yy_current_state = yy_get_previous_state(); 2378 2379 yy_cp = yy_c_buf_p; 2380 yy_bp = yytext_ptr + YY_MORE_ADJ; 2381 goto yy_find_action; 2382 } 2383 break; 2384 } 2385 2386 default: 2387 YY_FATAL_ERROR( 2388 "fatal flex scanner internal error--no action found" ); 2389 } /* end of action switch */ 2390 } /* end of scanning one token */ 2391 } /* end of yylex */ 2392 2393 2394 /* yy_get_next_buffer - try to read in a new buffer 2395 * 2396 * Returns a code representing an action: 2397 * EOB_ACT_LAST_MATCH - 2398 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 2399 * EOB_ACT_END_OF_FILE - end of file 2400 */ 2401 2402 static int yy_get_next_buffer() 2403 { 2404 register char *dest = yy_current_buffer->yy_ch_buf; 2405 register char *source = yytext_ptr; 2406 register int number_to_move, i; 2407 int ret_val; 2408 2409 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) 2410 YY_FATAL_ERROR( 2411 "fatal flex scanner internal error--end of buffer missed" ); 2412 2413 if ( yy_current_buffer->yy_fill_buffer == 0 ) 2414 { /* Don't try to fill the buffer, so this is an EOF. */ 2415 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) 2416 { 2417 /* We matched a single character, the EOB, so 2418 * treat this as a final EOF. 2419 */ 2420 return EOB_ACT_END_OF_FILE; 2421 } 2422 2423 else 2424 { 2425 /* We matched some text prior to the EOB, first 2426 * process it. 2427 */ 2428 return EOB_ACT_LAST_MATCH; 2429 } 2430 } 2431 2432 /* Try to read more data. */ 2433 2434 /* First move last chars to start of buffer. */ 2435 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; 2436 2437 for ( i = 0; i < number_to_move; ++i ) 2438 *(dest++) = *(source++); 2439 2440 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 2441 /* don't do the read, it's not guaranteed to return an EOF, 2442 * just force an EOF 2443 */ 2444 yy_current_buffer->yy_n_chars = yy_n_chars = 0; 2445 2446 else 2447 { 2448 int num_to_read = 2449 yy_current_buffer->yy_buf_size - number_to_move - 1; 2450 2451 while ( num_to_read <= 0 ) 2452 { /* Not enough room in the buffer - grow it. */ 2453 #ifdef YY_USES_REJECT 2454 YY_FATAL_ERROR( 2455 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 2456 #else 2457 2458 /* just a shorter name for the current buffer */ 2459 YY_BUFFER_STATE b = yy_current_buffer; 2460 2461 int yy_c_buf_p_offset = 2462 (int) (yy_c_buf_p - b->yy_ch_buf); 2463 2464 if ( b->yy_is_our_buffer ) 2465 { 2466 int new_size = b->yy_buf_size * 2; 2467 2468 if ( new_size <= 0 ) 2469 b->yy_buf_size += b->yy_buf_size / 8; 2470 else 2471 b->yy_buf_size *= 2; 2472 2473 b->yy_ch_buf = (char *) 2474 /* Include room in for 2 EOB chars. */ 2475 yy_flex_realloc( (void *) b->yy_ch_buf, 2476 b->yy_buf_size + 2 ); 2477 } 2478 else 2479 /* Can't grow it, we don't own it. */ 2480 b->yy_ch_buf = 0; 2481 2482 if ( ! b->yy_ch_buf ) 2483 YY_FATAL_ERROR( 2484 "fatal error - scanner input buffer overflow" ); 2485 2486 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 2487 2488 num_to_read = yy_current_buffer->yy_buf_size - 2489 number_to_move - 1; 2490 #endif 2491 } 2492 2493 if ( num_to_read > YY_READ_BUF_SIZE ) 2494 num_to_read = YY_READ_BUF_SIZE; 2495 2496 /* Read in more data. */ 2497 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), 2498 yy_n_chars, num_to_read ); 2499 2500 yy_current_buffer->yy_n_chars = yy_n_chars; 2501 } 2502 2503 if ( yy_n_chars == 0 ) 2504 { 2505 if ( number_to_move == YY_MORE_ADJ ) 2506 { 2507 ret_val = EOB_ACT_END_OF_FILE; 2508 yyrestart( yyin ); 2509 } 2510 2511 else 2512 { 2513 ret_val = EOB_ACT_LAST_MATCH; 2514 yy_current_buffer->yy_buffer_status = 2515 YY_BUFFER_EOF_PENDING; 2516 } 2517 } 2518 2519 else 2520 ret_val = EOB_ACT_CONTINUE_SCAN; 2521 2522 yy_n_chars += number_to_move; 2523 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; 2524 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 2525 2526 yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; 2527 2528 return ret_val; 2529 } 2530 2531 2532 /* yy_get_previous_state - get the state just before the EOB char was reached */ 2533 2534 static yy_state_type yy_get_previous_state() 2535 { 2536 register yy_state_type yy_current_state; 2537 register char *yy_cp; 2538 2539 yy_current_state = yy_start; 2540 2541 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) 2542 { 2543 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 2544 if ( yy_accept[yy_current_state] ) 2545 { 2546 yy_last_accepting_state = yy_current_state; 2547 yy_last_accepting_cpos = yy_cp; 2548 } 2549 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 2550 { 2551 yy_current_state = (int) yy_def[yy_current_state]; 2552 if ( yy_current_state >= 559 ) 2553 yy_c = yy_meta[(unsigned int) yy_c]; 2554 } 2555 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 2556 } 2557 2558 return yy_current_state; 2559 } 2560 2561 2562 /* yy_try_NUL_trans - try to make a transition on the NUL character 2563 * 2564 * synopsis 2565 * next_state = yy_try_NUL_trans( current_state ); 2566 */ 2567 2568 #ifdef YY_USE_PROTOS 2569 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 2570 #else 2571 static yy_state_type yy_try_NUL_trans( yy_current_state ) 2572 yy_state_type yy_current_state; 2573 #endif 2574 { 2575 register int yy_is_jam; 2576 register char *yy_cp = yy_c_buf_p; 2577 2578 register YY_CHAR yy_c = 1; 2579 if ( yy_accept[yy_current_state] ) 2580 { 2581 yy_last_accepting_state = yy_current_state; 2582 yy_last_accepting_cpos = yy_cp; 2583 } 2584 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 2585 { 2586 yy_current_state = (int) yy_def[yy_current_state]; 2587 if ( yy_current_state >= 559 ) 2588 yy_c = yy_meta[(unsigned int) yy_c]; 2589 } 2590 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 2591 yy_is_jam = (yy_current_state == 558); 2592 2593 return yy_is_jam ? 0 : yy_current_state; 2594 } 2595 2596 2597 #ifndef YY_NO_UNPUT 2598 #ifdef YY_USE_PROTOS 2599 static void yyunput( int c, register char *yy_bp ) 2600 #else 2601 static void yyunput( c, yy_bp ) 2602 int c; 2603 register char *yy_bp; 2604 #endif 2605 { 2606 register char *yy_cp = yy_c_buf_p; 2607 2608 /* undo effects of setting up yytext */ 2609 *yy_cp = yy_hold_char; 2610 2611 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 2612 { /* need to shift things up to make room */ 2613 /* +2 for EOB chars. */ 2614 register int number_to_move = yy_n_chars + 2; 2615 register char *dest = &yy_current_buffer->yy_ch_buf[ 2616 yy_current_buffer->yy_buf_size + 2]; 2617 register char *source = 2618 &yy_current_buffer->yy_ch_buf[number_to_move]; 2619 2620 while ( source > yy_current_buffer->yy_ch_buf ) 2621 *--dest = *--source; 2622 2623 yy_cp += (int) (dest - source); 2624 yy_bp += (int) (dest - source); 2625 yy_current_buffer->yy_n_chars = 2626 yy_n_chars = yy_current_buffer->yy_buf_size; 2627 2628 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 2629 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 2630 } 2631 2632 *--yy_cp = (char) c; 2633 2634 2635 yytext_ptr = yy_bp; 2636 yy_hold_char = *yy_cp; 2637 yy_c_buf_p = yy_cp; 2638 } 2639 #endif /* ifndef YY_NO_UNPUT */ 2640 2641 2642 #ifdef __cplusplus 2643 static int yyinput() 2644 #else 2645 static int input() 2646 #endif 2647 { 2648 int c; 2649 2650 *yy_c_buf_p = yy_hold_char; 2651 2652 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 2653 { 2654 /* yy_c_buf_p now points to the character we want to return. 2655 * If this occurs *before* the EOB characters, then it's a 2656 * valid NUL; if not, then we've hit the end of the buffer. 2657 */ 2658 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 2659 /* This was really a NUL. */ 2660 *yy_c_buf_p = '\0'; 2661 2662 else 2663 { /* need more input */ 2664 int offset = yy_c_buf_p - yytext_ptr; 2665 ++yy_c_buf_p; 2666 2667 switch ( yy_get_next_buffer() ) 2668 { 2669 case EOB_ACT_LAST_MATCH: 2670 /* This happens because yy_g_n_b() 2671 * sees that we've accumulated a 2672 * token and flags that we need to 2673 * try matching the token before 2674 * proceeding. But for input(), 2675 * there's no matching to consider. 2676 * So convert the EOB_ACT_LAST_MATCH 2677 * to EOB_ACT_END_OF_FILE. 2678 */ 2679 2680 /* Reset buffer status. */ 2681 yyrestart( yyin ); 2682 2683 /* fall through */ 2684 2685 case EOB_ACT_END_OF_FILE: 2686 { 2687 if ( yywrap() ) 2688 return EOF; 2689 2690 if ( ! yy_did_buffer_switch_on_eof ) 2691 YY_NEW_FILE; 2692 #ifdef __cplusplus 2693 return yyinput(); 2694 #else 2695 return input(); 2696 #endif 2697 } 2698 2699 case EOB_ACT_CONTINUE_SCAN: 2700 yy_c_buf_p = yytext_ptr + offset; 2701 break; 2702 } 2703 } 2704 } 2705 2706 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ 2707 *yy_c_buf_p = '\0'; /* preserve yytext */ 2708 yy_hold_char = *++yy_c_buf_p; 2709 2710 2711 return c; 2712 } 2713 2714 2715 #ifdef YY_USE_PROTOS 2716 void yyrestart( FILE *input_file ) 2717 #else 2718 void yyrestart( input_file ) 2719 FILE *input_file; 2720 #endif 2721 { 2722 if ( ! yy_current_buffer ) 2723 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 2724 2725 yy_init_buffer( yy_current_buffer, input_file ); 2726 yy_load_buffer_state(); 2727 } 2728 2729 2730 #ifdef YY_USE_PROTOS 2731 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 2732 #else 2733 void yy_switch_to_buffer( new_buffer ) 2734 YY_BUFFER_STATE new_buffer; 2735 #endif 2736 { 2737 if ( yy_current_buffer == new_buffer ) 2738 return; 2739 2740 if ( yy_current_buffer ) 2741 { 2742 /* Flush out information for old buffer. */ 2743 *yy_c_buf_p = yy_hold_char; 2744 yy_current_buffer->yy_buf_pos = yy_c_buf_p; 2745 yy_current_buffer->yy_n_chars = yy_n_chars; 2746 } 2747 2748 yy_current_buffer = new_buffer; 2749 yy_load_buffer_state(); 2750 2751 /* We don't actually know whether we did this switch during 2752 * EOF (yywrap()) processing, but the only time this flag 2753 * is looked at is after yywrap() is called, so it's safe 2754 * to go ahead and always set it. 2755 */ 2756 yy_did_buffer_switch_on_eof = 1; 2757 } 2758 2759 2760 #ifdef YY_USE_PROTOS 2761 void yy_load_buffer_state( void ) 2762 #else 2763 void yy_load_buffer_state() 2764 #endif 2765 { 2766 yy_n_chars = yy_current_buffer->yy_n_chars; 2767 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; 2768 yyin = yy_current_buffer->yy_input_file; 2769 yy_hold_char = *yy_c_buf_p; 2770 } 2771 2772 2773 #ifdef YY_USE_PROTOS 2774 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 2775 #else 2776 YY_BUFFER_STATE yy_create_buffer( file, size ) 2777 FILE *file; 2778 int size; 2779 #endif 2780 { 2781 YY_BUFFER_STATE b; 2782 2783 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 2784 if ( ! b ) 2785 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 2786 2787 b->yy_buf_size = size; 2788 2789 /* yy_ch_buf has to be 2 characters longer than the size given because 2790 * we need to put in 2 end-of-buffer characters. 2791 */ 2792 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); 2793 if ( ! b->yy_ch_buf ) 2794 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 2795 2796 b->yy_is_our_buffer = 1; 2797 2798 yy_init_buffer( b, file ); 2799 2800 return b; 2801 } 2802 2803 2804 #ifdef YY_USE_PROTOS 2805 void yy_delete_buffer( YY_BUFFER_STATE b ) 2806 #else 2807 void yy_delete_buffer( b ) 2808 YY_BUFFER_STATE b; 2809 #endif 2810 { 2811 if ( ! b ) 2812 return; 2813 2814 if ( b == yy_current_buffer ) 2815 yy_current_buffer = (YY_BUFFER_STATE) 0; 2816 2817 if ( b->yy_is_our_buffer ) 2818 yy_flex_free( (void *) b->yy_ch_buf ); 2819 2820 yy_flex_free( (void *) b ); 2821 } 2822 2823 2824 #ifndef _WIN32 2825 #include <unistd.h> 2826 #else 2827 #ifndef YY_ALWAYS_INTERACTIVE 2828 #ifndef YY_NEVER_INTERACTIVE 2829 extern int isatty YY_PROTO(( int )); 2830 #endif 2831 #endif 2832 #endif 2833 2834 #ifdef YY_USE_PROTOS 2835 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 2836 #else 2837 void yy_init_buffer( b, file ) 2838 YY_BUFFER_STATE b; 2839 FILE *file; 2840 #endif 2841 2842 2843 { 2844 yy_flush_buffer( b ); 2845 2846 b->yy_input_file = file; 2847 b->yy_fill_buffer = 1; 2848 2849 #if YY_ALWAYS_INTERACTIVE 2850 b->yy_is_interactive = 1; 2851 #else 2852 #if YY_NEVER_INTERACTIVE 2853 b->yy_is_interactive = 0; 2854 #else 2855 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 2856 #endif 2857 #endif 2858 } 2859 2860 2861 #ifdef YY_USE_PROTOS 2862 void yy_flush_buffer( YY_BUFFER_STATE b ) 2863 #else 2864 void yy_flush_buffer( b ) 2865 YY_BUFFER_STATE b; 2866 #endif 2867 2868 { 2869 if ( ! b ) 2870 return; 2871 2872 b->yy_n_chars = 0; 2873 2874 /* We always need two end-of-buffer characters. The first causes 2875 * a transition to the end-of-buffer state. The second causes 2876 * a jam in that state. 2877 */ 2878 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 2879 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 2880 2881 b->yy_buf_pos = &b->yy_ch_buf[0]; 2882 2883 b->yy_at_bol = 1; 2884 b->yy_buffer_status = YY_BUFFER_NEW; 2885 2886 if ( b == yy_current_buffer ) 2887 yy_load_buffer_state(); 2888 } 2889 2890 2891 #ifndef YY_NO_SCAN_BUFFER 2892 #ifdef YY_USE_PROTOS 2893 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 2894 #else 2895 YY_BUFFER_STATE yy_scan_buffer( base, size ) 2896 char *base; 2897 yy_size_t size; 2898 #endif 2899 { 2900 YY_BUFFER_STATE b; 2901 2902 if ( size < 2 || 2903 base[size-2] != YY_END_OF_BUFFER_CHAR || 2904 base[size-1] != YY_END_OF_BUFFER_CHAR ) 2905 /* They forgot to leave room for the EOB's. */ 2906 return 0; 2907 2908 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 2909 if ( ! b ) 2910 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 2911 2912 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 2913 b->yy_buf_pos = b->yy_ch_buf = base; 2914 b->yy_is_our_buffer = 0; 2915 b->yy_input_file = 0; 2916 b->yy_n_chars = b->yy_buf_size; 2917 b->yy_is_interactive = 0; 2918 b->yy_at_bol = 1; 2919 b->yy_fill_buffer = 0; 2920 b->yy_buffer_status = YY_BUFFER_NEW; 2921 2922 yy_switch_to_buffer( b ); 2923 2924 return b; 2925 } 2926 #endif 2927 2928 2929 #ifndef YY_NO_SCAN_STRING 2930 #ifdef YY_USE_PROTOS 2931 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 2932 #else 2933 YY_BUFFER_STATE yy_scan_string( yy_str ) 2934 yyconst char *yy_str; 2935 #endif 2936 { 2937 int len; 2938 for ( len = 0; yy_str[len]; ++len ) 2939 ; 2940 2941 return yy_scan_bytes( yy_str, len ); 2942 } 2943 #endif 2944 2945 2946 #ifndef YY_NO_SCAN_BYTES 2947 #ifdef YY_USE_PROTOS 2948 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 2949 #else 2950 YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 2951 yyconst char *bytes; 2952 int len; 2953 #endif 2954 { 2955 YY_BUFFER_STATE b; 2956 char *buf; 2957 yy_size_t n; 2958 int i; 2959 2960 /* Get memory for full buffer, including space for trailing EOB's. */ 2961 n = len + 2; 2962 buf = (char *) yy_flex_alloc( n ); 2963 if ( ! buf ) 2964 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 2965 2966 for ( i = 0; i < len; ++i ) 2967 buf[i] = bytes[i]; 2968 2969 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; 2970 2971 b = yy_scan_buffer( buf, n ); 2972 if ( ! b ) 2973 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 2974 2975 /* It's okay to grow etc. this buffer, and we should throw it 2976 * away when we're done. 2977 */ 2978 b->yy_is_our_buffer = 1; 2979 2980 return b; 2981 } 2982 #endif 2983 2984 2985 #ifndef YY_NO_PUSH_STATE 2986 #ifdef YY_USE_PROTOS 2987 static void yy_push_state( int new_state ) 2988 #else 2989 static void yy_push_state( new_state ) 2990 int new_state; 2991 #endif 2992 { 2993 if ( yy_start_stack_ptr >= yy_start_stack_depth ) 2994 { 2995 yy_size_t new_size; 2996 2997 yy_start_stack_depth += YY_START_STACK_INCR; 2998 new_size = yy_start_stack_depth * sizeof( int ); 2999 3000 if ( ! yy_start_stack ) 3001 yy_start_stack = (int *) yy_flex_alloc( new_size ); 3002 3003 else 3004 yy_start_stack = (int *) yy_flex_realloc( 3005 (void *) yy_start_stack, new_size ); 3006 3007 if ( ! yy_start_stack ) 3008 YY_FATAL_ERROR( 3009 "out of memory expanding start-condition stack" ); 3010 } 3011 3012 yy_start_stack[yy_start_stack_ptr++] = YY_START; 3013 3014 BEGIN(new_state); 3015 } 3016 #endif 3017 3018 3019 #ifndef YY_NO_POP_STATE 3020 static void yy_pop_state() 3021 { 3022 if ( --yy_start_stack_ptr < 0 ) 3023 YY_FATAL_ERROR( "start-condition stack underflow" ); 3024 3025 BEGIN(yy_start_stack[yy_start_stack_ptr]); 3026 } 3027 #endif 3028 3029 3030 #ifndef YY_NO_TOP_STATE 3031 static int yy_top_state() 3032 { 3033 return yy_start_stack[yy_start_stack_ptr - 1]; 3034 } 3035 #endif 3036 3037 #ifndef YY_EXIT_FAILURE 3038 #define YY_EXIT_FAILURE 2 3039 #endif 3040 3041 #ifdef YY_USE_PROTOS 3042 static void yy_fatal_error( yyconst char msg[] ) 3043 #else 3044 static void yy_fatal_error( msg ) 3045 char msg[]; 3046 #endif 3047 { 3048 (void) fprintf( stderr, "%s\n", msg ); 3049 exit( YY_EXIT_FAILURE ); 3050 } 3051 3052 3053 3054 /* Redefine yyless() so it works in section 3 code. */ 3055 3056 #undef yyless 3057 #define yyless(n) \ 3058 do \ 3059 { \ 3060 /* Undo effects of setting up yytext. */ \ 3061 yytext[yyleng] = yy_hold_char; \ 3062 yy_c_buf_p = yytext + n; \ 3063 yy_hold_char = *yy_c_buf_p; \ 3064 *yy_c_buf_p = '\0'; \ 3065 yyleng = n; \ 3066 } \ 3067 while ( 0 ) 3068 3069 3070 /* Internal utility routines. */ 3071 3072 #ifndef yytext_ptr 3073 #ifdef YY_USE_PROTOS 3074 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 3075 #else 3076 static void yy_flex_strncpy( s1, s2, n ) 3077 char *s1; 3078 yyconst char *s2; 3079 int n; 3080 #endif 3081 { 3082 register int i; 3083 for ( i = 0; i < n; ++i ) 3084 s1[i] = s2[i]; 3085 } 3086 #endif 3087 3088 #ifdef YY_NEED_STRLEN 3089 #ifdef YY_USE_PROTOS 3090 static int yy_flex_strlen( yyconst char *s ) 3091 #else 3092 static int yy_flex_strlen( s ) 3093 yyconst char *s; 3094 #endif 3095 { 3096 register int n; 3097 for ( n = 0; s[n]; ++n ) 3098 ; 3099 3100 return n; 3101 } 3102 #endif 3103 3104 3105 #ifdef YY_USE_PROTOS 3106 static void *yy_flex_alloc( yy_size_t size ) 3107 #else 3108 static void *yy_flex_alloc( size ) 3109 yy_size_t size; 3110 #endif 3111 { 3112 return (void *) malloc( size ); 3113 } 3114 3115 #ifdef YY_USE_PROTOS 3116 static void *yy_flex_realloc( void *ptr, yy_size_t size ) 3117 #else 3118 static void *yy_flex_realloc( ptr, size ) 3119 void *ptr; 3120 yy_size_t size; 3121 #endif 3122 { 3123 /* The cast to (char *) in the following accommodates both 3124 * implementations that use char* generic pointers, and those 3125 * that use void* generic pointers. It works with the latter 3126 * because both ANSI C and C++ allow castless assignment from 3127 * any pointer type to void*, and deal with argument conversions 3128 * as though doing an assignment. 3129 */ 3130 return (void *) realloc( (char *) ptr, size ); 3131 } 3132 3133 #ifdef YY_USE_PROTOS 3134 static void yy_flex_free( void *ptr ) 3135 #else 3136 static void yy_flex_free( ptr ) 3137 void *ptr; 3138 #endif 3139 { 3140 free( ptr ); 3141 } 3142 3143 #if YY_MAIN 3144 int main() 3145 { 3146 yylex(); 3147 return 0; 3148 } 3149 #endif 3150 #line 339 "bfin-lex.l" 3151 3152 static long parse_int (char **end) 3153 { 3154 char fmt = '\0'; 3155 int not_done = 1; 3156 int shiftvalue = 0; 3157 char * char_bag; 3158 long value = 0; 3159 char c; 3160 char *arg = *end; 3161 3162 while (*arg && *arg == ' ') 3163 arg++; 3164 3165 switch (*arg) 3166 { 3167 case '1': 3168 case '2': 3169 case '3': 3170 case '4': 3171 case '5': 3172 case '6': 3173 case '7': 3174 case '8': 3175 case '9': 3176 fmt = 'd'; 3177 break; 3178 3179 case '0': /* Accept different formated integers hex octal and binary. */ 3180 { 3181 c = *++arg; 3182 arg++; 3183 if (c == 'x' || c == 'X') /* Hex input. */ 3184 fmt = 'h'; 3185 else if (c == 'b' || c == 'B') 3186 fmt = 'b'; 3187 else if (c == '.') 3188 fmt = 'f'; 3189 else 3190 { /* Octal. */ 3191 arg--; 3192 fmt = 'o'; 3193 } 3194 break; 3195 } 3196 3197 case 'd': 3198 case 'D': 3199 case 'h': 3200 case 'H': 3201 case 'o': 3202 case 'O': 3203 case 'b': 3204 case 'B': 3205 case 'f': 3206 case 'F': 3207 { 3208 fmt = *arg++; 3209 if (*arg == '#') 3210 arg++; 3211 } 3212 } 3213 3214 switch (fmt) 3215 { 3216 case 'h': 3217 case 'H': 3218 shiftvalue = 4; 3219 char_bag = "0123456789ABCDEFabcdef"; 3220 break; 3221 3222 case 'o': 3223 case 'O': 3224 shiftvalue = 3; 3225 char_bag = "01234567"; 3226 break; 3227 3228 case 'b': 3229 case 'B': 3230 shiftvalue = 1; 3231 char_bag = "01"; 3232 break; 3233 3234 /* The assembler allows for fractional constants to be created 3235 by either the 0.xxxx or the f#xxxx format 3236 3237 i.e. 0.5 would result in 0x4000 3238 3239 note .5 would result in the identifier .5. 3240 3241 The assembler converts to fractional format 1.15 by the simple rule: 3242 3243 value = (short) (finput * (1 << 15)). */ 3244 3245 case 'f': 3246 case 'F': 3247 { 3248 float fval = 0.0; 3249 float pos = 10.0; 3250 while (1) 3251 { 3252 int c; 3253 c = *arg++; 3254 3255 if (c >= '0' && c <= '9') 3256 { 3257 float digit = (c - '0') / pos; 3258 fval = fval + digit; 3259 pos = pos * 10.0; 3260 } 3261 else 3262 { 3263 *--arg = c; 3264 value = (short) (fval * (1 << 15)); 3265 break; 3266 } 3267 } 3268 *end = arg+1; 3269 return value; 3270 } 3271 3272 case 'd': 3273 case 'D': 3274 default: 3275 { 3276 while (1) 3277 { 3278 int c; 3279 c = *arg++; 3280 if (c >= '0' && c <= '9') 3281 value = (value * 10) + (c - '0'); 3282 else 3283 { 3284 /* Constants that are suffixed with k|K are multiplied by 1024 3285 This suffix is only allowed on decimal constants. */ 3286 if (c == 'k' || c == 'K') 3287 value *= 1024; 3288 else 3289 *--arg = c; 3290 break; 3291 } 3292 } 3293 *end = arg+1; 3294 return value; 3295 } 3296 } 3297 3298 while (not_done) 3299 { 3300 char c; 3301 c = *arg++; 3302 if (c == 0 || !index (char_bag, c)) 3303 { 3304 not_done = 0; 3305 *--arg = c; 3306 } 3307 else 3308 { 3309 if (c >= 'a' && c <= 'z') 3310 c = c - ('a' - '9') + 1; 3311 else if (c >= 'A' && c <= 'Z') 3312 c = c - ('A' - '9') + 1; 3313 3314 c -= '0'; 3315 value = (value << shiftvalue) + c; 3316 } 3317 } 3318 *end = arg+1; 3319 return value; 3320 } 3321 3322 3323 static int parse_reg (Register *r, int cl, char *rt) 3324 { 3325 r->regno = cl | (rt[1] - '0'); 3326 return REG; 3327 } 3328 3329 static int parse_halfreg (Register *r, int cl, char *rt) 3330 { 3331 r->regno = cl | (rt[1] - '0'); 3332 3333 switch (rt[3]) 3334 { 3335 case 'b': 3336 case 'B': 3337 return BYTE_DREG; 3338 3339 case 'l': 3340 case 'L': 3341 break; 3342 3343 case 'h': 3344 case 'H': 3345 r->regno |= F_REG_HIGH; 3346 break; 3347 } 3348 3349 return HALF_REG; 3350 } 3351 3352 /* Our start state is KEYWORD as we have 3353 command keywords such as PREFETCH. */ 3354 3355 void 3356 set_start_state (void) 3357 { 3358 BEGIN KEYWORD; 3359 } 3360 3361 3362 #ifndef yywrap 3363 int 3364 yywrap () 3365 { 3366 return 1; 3367 } 3368 #endif 3369