1/* A lexical scanner generated by flex */ 2 3/* Scanner skeleton version: 4 * $Header: /usr/local/opengrok/home/cvs-mirror/mirrors/openbsd/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 102typedef struct yy_buffer_state *YY_BUFFER_STATE; 103 104extern int yyleng; 105extern 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 */ 144typedef unsigned int yy_size_t; 145 146 147struct 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 204static 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. */ 214static char yy_hold_char; 215 216static int yy_n_chars; /* number of characters read into yy_ch_buf */ 217 218 219int yyleng; 220 221/* Points to current character in buffer. */ 222static char *yy_c_buf_p = (char *) 0; 223static int yy_init = 1; /* whether we need to initialize */ 224static 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 */ 229static int yy_did_buffer_switch_on_eof; 230 231void yyrestart YY_PROTO(( FILE *input_file )); 232 233void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); 234void yy_load_buffer_state YY_PROTO(( void )); 235YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); 236void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); 237void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); 238void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); 239#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) 240 241YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); 242YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); 243YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); 244 245static void *yy_flex_alloc YY_PROTO(( yy_size_t )); 246static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); 247static 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 267typedef unsigned char YY_CHAR; 268FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 269typedef int yy_state_type; 270extern char *yytext; 271#define yytext_ptr yytext 272 273static yy_state_type yy_get_previous_state YY_PROTO(( void )); 274static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); 275static int yy_get_next_buffer YY_PROTO(( void )); 276static 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 290static 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 355static 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 387static 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 398static 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 464static 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 530static 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 631static 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 732static yy_state_type yy_last_accepting_state; 733static 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 742char *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 773static long parse_int (char **end); 774static int parse_halfreg (Register *r, int cl, char *hr); 775static int parse_reg (Register *r, int type, char *rt); 776int 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 795extern "C" int yywrap YY_PROTO(( void )); 796#else 797extern int yywrap YY_PROTO(( void )); 798#endif 799#endif 800 801#ifndef YY_NO_UNPUT 802static void yyunput YY_PROTO(( int c, char *buf_ptr )); 803#endif 804 805#ifndef yytext_ptr 806static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); 807#endif 808 809#ifdef YY_NEED_STRLEN 810static int yy_flex_strlen YY_PROTO(( yyconst char * )); 811#endif 812 813#ifndef YY_NO_INPUT 814#ifdef __cplusplus 815static int yyinput YY_PROTO(( void )); 816#else 817static int input YY_PROTO(( void )); 818#endif 819#endif 820 821#if YY_STACK_USED 822static int yy_start_stack_ptr = 0; 823static int yy_start_stack_depth = 0; 824static int *yy_start_stack = 0; 825#ifndef YY_NO_PUSH_STATE 826static void yy_push_state YY_PROTO(( int new_state )); 827#endif 828#ifndef YY_NO_POP_STATE 829static void yy_pop_state YY_PROTO(( void )); 830#endif 831#ifndef YY_NO_TOP_STATE 832static 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 842YY_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 943YY_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; 990yy_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 1010yy_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 1022do_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 1034case 1: 1035YY_RULE_SETUP 1036#line 46 "bfin-lex.l" 1037_REG.regno = REG_sftreset; return REG; 1038 YY_BREAK 1039case 2: 1040YY_RULE_SETUP 1041#line 47 "bfin-lex.l" 1042_REG.regno = REG_omode; return REG; 1043 YY_BREAK 1044case 3: 1045YY_RULE_SETUP 1046#line 48 "bfin-lex.l" 1047_REG.regno = REG_idle_req; return REG; 1048 YY_BREAK 1049case 4: 1050YY_RULE_SETUP 1051#line 49 "bfin-lex.l" 1052_REG.regno = REG_hwerrcause; return REG; 1053 YY_BREAK 1054case 5: 1055YY_RULE_SETUP 1056#line 50 "bfin-lex.l" 1057_REG.regno = REG_excause; return REG; 1058 YY_BREAK 1059case 6: 1060YY_RULE_SETUP 1061#line 51 "bfin-lex.l" 1062_REG.regno = REG_emucause; return REG; 1063 YY_BREAK 1064case 7: 1065YY_RULE_SETUP 1066#line 52 "bfin-lex.l" 1067return Z; 1068 YY_BREAK 1069case 8: 1070YY_RULE_SETUP 1071#line 53 "bfin-lex.l" 1072return X; 1073 YY_BREAK 1074case 9: 1075YY_RULE_SETUP 1076#line 54 "bfin-lex.l" 1077yylval.value = M_W32; return MMOD; 1078 YY_BREAK 1079case 10: 1080YY_RULE_SETUP 1081#line 55 "bfin-lex.l" 1082return W; 1083 YY_BREAK 1084case 11: 1085YY_RULE_SETUP 1086#line 56 "bfin-lex.l" 1087return VIT_MAX; 1088 YY_BREAK 1089case 12: 1090YY_RULE_SETUP 1091#line 57 "bfin-lex.l" 1092return V; /* Special: V is a statflag and a modifier. */ 1093 YY_BREAK 1094case 13: 1095YY_RULE_SETUP 1096#line 58 "bfin-lex.l" 1097_REG.regno = REG_USP; return REG; 1098 YY_BREAK 1099case 14: 1100YY_RULE_SETUP 1101#line 59 "bfin-lex.l" 1102return TL; 1103 YY_BREAK 1104case 15: 1105YY_RULE_SETUP 1106#line 60 "bfin-lex.l" 1107return TH; 1108 YY_BREAK 1109case 16: 1110YY_RULE_SETUP 1111#line 61 "bfin-lex.l" 1112yylval.value = M_TFU; return MMOD; 1113 YY_BREAK 1114case 17: 1115YY_RULE_SETUP 1116#line 62 "bfin-lex.l" 1117return TESTSET; 1118 YY_BREAK 1119case 18: 1120YY_RULE_SETUP 1121#line 63 "bfin-lex.l" 1122yylval.value = M_T; return MMOD; 1123 YY_BREAK 1124case 19: 1125YY_RULE_SETUP 1126#line 64 "bfin-lex.l" 1127return S; 1128 YY_BREAK 1129case 20: 1130YY_RULE_SETUP 1131#line 65 "bfin-lex.l" 1132_REG.regno = REG_SYSCFG; return REG; 1133 YY_BREAK 1134case 21: 1135YY_RULE_SETUP 1136#line 66 "bfin-lex.l" 1137return STI; 1138 YY_BREAK 1139case 22: 1140YY_RULE_SETUP 1141#line 67 "bfin-lex.l" 1142return SSYNC; 1143 YY_BREAK 1144case 23: 1145YY_RULE_SETUP 1146#line 68 "bfin-lex.l" 1147_REG.regno = REG_SP; return HALF_REG; 1148 YY_BREAK 1149case 24: 1150YY_RULE_SETUP 1151#line 69 "bfin-lex.l" 1152_REG.regno = REG_SP | F_REG_HIGH; return HALF_REG; 1153 YY_BREAK 1154case 25: 1155YY_RULE_SETUP 1156#line 70 "bfin-lex.l" 1157_REG.regno = REG_SP; return REG; 1158 YY_BREAK 1159case 26: 1160YY_RULE_SETUP 1161#line 71 "bfin-lex.l" 1162return SIGNBITS; 1163 YY_BREAK 1164case 27: 1165YY_RULE_SETUP 1166#line 72 "bfin-lex.l" 1167return SIGN; 1168 YY_BREAK 1169case 28: 1170YY_RULE_SETUP 1171#line 73 "bfin-lex.l" 1172_REG.regno = REG_SEQSTAT; return REG; 1173 YY_BREAK 1174case 29: 1175YY_RULE_SETUP 1176#line 74 "bfin-lex.l" 1177return SEARCH; 1178 YY_BREAK 1179case 30: 1180YY_RULE_SETUP 1181#line 75 "bfin-lex.l" 1182return SHIFT; 1183 YY_BREAK 1184case 31: 1185YY_RULE_SETUP 1186#line 76 "bfin-lex.l" 1187return SCO; 1188 YY_BREAK 1189case 32: 1190YY_RULE_SETUP 1191#line 78 "bfin-lex.l" 1192return SAA; 1193 YY_BREAK 1194case 33: 1195YY_RULE_SETUP 1196#line 79 "bfin-lex.l" 1197yylval.value = M_S2RND; return MMOD; 1198 YY_BREAK 1199case 34: 1200YY_RULE_SETUP 1201#line 80 "bfin-lex.l" 1202return RTX; 1203 YY_BREAK 1204case 35: 1205YY_RULE_SETUP 1206#line 81 "bfin-lex.l" 1207return RTS; 1208 YY_BREAK 1209case 36: 1210YY_RULE_SETUP 1211#line 82 "bfin-lex.l" 1212return RTN; 1213 YY_BREAK 1214case 37: 1215YY_RULE_SETUP 1216#line 83 "bfin-lex.l" 1217return RTI; 1218 YY_BREAK 1219case 38: 1220YY_RULE_SETUP 1221#line 84 "bfin-lex.l" 1222return RTE; 1223 YY_BREAK 1224case 39: 1225YY_RULE_SETUP 1226#line 85 "bfin-lex.l" 1227return ROT; 1228 YY_BREAK 1229case 40: 1230YY_RULE_SETUP 1231#line 86 "bfin-lex.l" 1232return RND20; 1233 YY_BREAK 1234case 41: 1235YY_RULE_SETUP 1236#line 87 "bfin-lex.l" 1237return RND12; 1238 YY_BREAK 1239case 42: 1240YY_RULE_SETUP 1241#line 88 "bfin-lex.l" 1242return RNDL; 1243 YY_BREAK 1244case 43: 1245YY_RULE_SETUP 1246#line 89 "bfin-lex.l" 1247return RNDH; 1248 YY_BREAK 1249case 44: 1250YY_RULE_SETUP 1251#line 90 "bfin-lex.l" 1252return RND; 1253 YY_BREAK 1254case 45: 1255YY_RULE_SETUP 1256#line 92 "bfin-lex.l" 1257return parse_halfreg(&yylval.reg, T_REG_R, yytext); 1258 YY_BREAK 1259case 46: 1260YY_RULE_SETUP 1261#line 94 "bfin-lex.l" 1262_REG.regno = REG_RETS; return REG; 1263 YY_BREAK 1264case 47: 1265YY_RULE_SETUP 1266#line 95 "bfin-lex.l" 1267_REG.regno = REG_RETI; return REG; 1268 YY_BREAK 1269case 48: 1270YY_RULE_SETUP 1271#line 96 "bfin-lex.l" 1272_REG.regno = REG_RETX; return REG; 1273 YY_BREAK 1274case 49: 1275YY_RULE_SETUP 1276#line 97 "bfin-lex.l" 1277_REG.regno = REG_RETN; return REG; 1278 YY_BREAK 1279case 50: 1280YY_RULE_SETUP 1281#line 98 "bfin-lex.l" 1282_REG.regno = REG_RETE; return REG; 1283 YY_BREAK 1284case 51: 1285YY_RULE_SETUP 1286#line 99 "bfin-lex.l" 1287_REG.regno = REG_EMUDAT; return REG; 1288 YY_BREAK 1289case 52: 1290YY_RULE_SETUP 1291#line 100 "bfin-lex.l" 1292return RAISE; 1293 YY_BREAK 1294case 53: 1295YY_RULE_SETUP 1296#line 102 "bfin-lex.l" 1297return parse_reg (&yylval.reg, T_REG_R, yytext); 1298 YY_BREAK 1299case 54: 1300YY_RULE_SETUP 1301#line 104 "bfin-lex.l" 1302return R; 1303 YY_BREAK 1304case 55: 1305YY_RULE_SETUP 1306#line 105 "bfin-lex.l" 1307return PRNT; 1308 YY_BREAK 1309case 56: 1310YY_RULE_SETUP 1311#line 106 "bfin-lex.l" 1312return PC; 1313 YY_BREAK 1314case 57: 1315YY_RULE_SETUP 1316#line 107 "bfin-lex.l" 1317return PACK; 1318 YY_BREAK 1319case 58: 1320YY_RULE_SETUP 1321#line 109 "bfin-lex.l" 1322return parse_halfreg (&yylval.reg, T_REG_P, yytext); 1323 YY_BREAK 1324case 59: 1325YY_RULE_SETUP 1326#line 110 "bfin-lex.l" 1327return parse_reg (&yylval.reg, T_REG_P, yytext); 1328 YY_BREAK 1329case 60: 1330YY_RULE_SETUP 1331#line 112 "bfin-lex.l" 1332return OUTC; 1333 YY_BREAK 1334case 61: 1335YY_RULE_SETUP 1336#line 113 "bfin-lex.l" 1337return ONES; 1338 YY_BREAK 1339case 62: 1340YY_RULE_SETUP 1341#line 115 "bfin-lex.l" 1342return NOT; 1343 YY_BREAK 1344case 63: 1345YY_RULE_SETUP 1346#line 116 "bfin-lex.l" 1347return NOP; 1348 YY_BREAK 1349case 64: 1350YY_RULE_SETUP 1351#line 117 "bfin-lex.l" 1352return MNOP; 1353 YY_BREAK 1354case 65: 1355YY_RULE_SETUP 1356#line 118 "bfin-lex.l" 1357return NS; 1358 YY_BREAK 1359case 66: 1360YY_RULE_SETUP 1361#line 121 "bfin-lex.l" 1362return MIN; 1363 YY_BREAK 1364case 67: 1365YY_RULE_SETUP 1366#line 122 "bfin-lex.l" 1367return MAX; 1368 YY_BREAK 1369case 68: 1370YY_RULE_SETUP 1371#line 124 "bfin-lex.l" 1372return parse_halfreg (&yylval.reg, T_REG_M, yytext); 1373 YY_BREAK 1374case 69: 1375YY_RULE_SETUP 1376#line 125 "bfin-lex.l" 1377return parse_reg (&yylval.reg, T_REG_M, yytext); 1378 YY_BREAK 1379case 70: 1380YY_RULE_SETUP 1381#line 127 "bfin-lex.l" 1382return M; 1383 YY_BREAK 1384case 71: 1385YY_RULE_SETUP 1386#line 128 "bfin-lex.l" 1387return LT; 1388 YY_BREAK 1389case 72: 1390YY_RULE_SETUP 1391#line 129 "bfin-lex.l" 1392return LSHIFT; 1393 YY_BREAK 1394case 73: 1395YY_RULE_SETUP 1396#line 130 "bfin-lex.l" 1397return LSETUP; 1398 YY_BREAK 1399case 74: 1400YY_RULE_SETUP 1401#line 131 "bfin-lex.l" 1402return LOOP; 1403 YY_BREAK 1404case 75: 1405YY_RULE_SETUP 1406#line 132 "bfin-lex.l" 1407return LOOP_BEGIN; 1408 YY_BREAK 1409case 76: 1410YY_RULE_SETUP 1411#line 133 "bfin-lex.l" 1412return LOOP_END; 1413 YY_BREAK 1414case 77: 1415YY_RULE_SETUP 1416#line 135 "bfin-lex.l" 1417return LE; 1418 YY_BREAK 1419case 78: 1420YY_RULE_SETUP 1421#line 136 "bfin-lex.l" 1422_REG.regno = REG_LC0; return REG; 1423 YY_BREAK 1424case 79: 1425YY_RULE_SETUP 1426#line 137 "bfin-lex.l" 1427_REG.regno = REG_LT0; return REG; 1428 YY_BREAK 1429case 80: 1430YY_RULE_SETUP 1431#line 138 "bfin-lex.l" 1432_REG.regno = REG_LB0; return REG; 1433 YY_BREAK 1434case 81: 1435YY_RULE_SETUP 1436#line 139 "bfin-lex.l" 1437_REG.regno = REG_LC1; return REG; 1438 YY_BREAK 1439case 82: 1440YY_RULE_SETUP 1441#line 140 "bfin-lex.l" 1442_REG.regno = REG_LT1; return REG; 1443 YY_BREAK 1444case 83: 1445YY_RULE_SETUP 1446#line 141 "bfin-lex.l" 1447_REG.regno = REG_LB1; return REG; 1448 YY_BREAK 1449case 84: 1450YY_RULE_SETUP 1451#line 143 "bfin-lex.l" 1452return parse_halfreg (&yylval.reg, T_REG_L, yytext); 1453 YY_BREAK 1454case 85: 1455YY_RULE_SETUP 1456#line 144 "bfin-lex.l" 1457return parse_reg (&yylval.reg, T_REG_L, yytext); 1458 YY_BREAK 1459case 86: 1460YY_RULE_SETUP 1461#line 145 "bfin-lex.l" 1462return LO; 1463 YY_BREAK 1464case 87: 1465YY_RULE_SETUP 1466#line 146 "bfin-lex.l" 1467{ BEGIN 0; return JUMP_DOT_S;} 1468 YY_BREAK 1469case 88: 1470YY_RULE_SETUP 1471#line 147 "bfin-lex.l" 1472{ BEGIN 0; return JUMP_DOT_L;} 1473 YY_BREAK 1474case 89: 1475YY_RULE_SETUP 1476#line 148 "bfin-lex.l" 1477{ BEGIN 0; return JUMP;} 1478 YY_BREAK 1479case 90: 1480YY_RULE_SETUP 1481#line 149 "bfin-lex.l" 1482{ BEGIN 0; return JUMP_DOT_L; } 1483 YY_BREAK 1484case 91: 1485YY_RULE_SETUP 1486#line 150 "bfin-lex.l" 1487yylval.value = M_IU; return MMOD; 1488 YY_BREAK 1489case 92: 1490YY_RULE_SETUP 1491#line 151 "bfin-lex.l" 1492yylval.value = M_ISS2; return MMOD; 1493 YY_BREAK 1494case 93: 1495YY_RULE_SETUP 1496#line 152 "bfin-lex.l" 1497yylval.value = M_IS; return MMOD; 1498 YY_BREAK 1499case 94: 1500YY_RULE_SETUP 1501#line 153 "bfin-lex.l" 1502yylval.value = M_IH; return MMOD; 1503 YY_BREAK 1504case 95: 1505YY_RULE_SETUP 1506#line 154 "bfin-lex.l" 1507return IF; 1508 YY_BREAK 1509case 96: 1510YY_RULE_SETUP 1511#line 155 "bfin-lex.l" 1512return parse_halfreg (&yylval.reg, T_REG_I, yytext); 1513 YY_BREAK 1514case 97: 1515YY_RULE_SETUP 1516#line 156 "bfin-lex.l" 1517return parse_reg (&yylval.reg, T_REG_I, yytext); 1518 YY_BREAK 1519case 98: 1520YY_RULE_SETUP 1521#line 157 "bfin-lex.l" 1522return HLT; 1523 YY_BREAK 1524case 99: 1525YY_RULE_SETUP 1526#line 158 "bfin-lex.l" 1527return HI; 1528 YY_BREAK 1529case 100: 1530YY_RULE_SETUP 1531#line 159 "bfin-lex.l" 1532return GT; 1533 YY_BREAK 1534case 101: 1535YY_RULE_SETUP 1536#line 160 "bfin-lex.l" 1537return GE; 1538 YY_BREAK 1539case 102: 1540YY_RULE_SETUP 1541#line 161 "bfin-lex.l" 1542yylval.value = M_FU; return MMOD; 1543 YY_BREAK 1544case 103: 1545YY_RULE_SETUP 1546#line 162 "bfin-lex.l" 1547_REG.regno = REG_FP; return REG; 1548 YY_BREAK 1549case 104: 1550YY_RULE_SETUP 1551#line 163 "bfin-lex.l" 1552_REG.regno = REG_FP; return HALF_REG; 1553 YY_BREAK 1554case 105: 1555YY_RULE_SETUP 1556#line 164 "bfin-lex.l" 1557_REG.regno = REG_FP | F_REG_HIGH; return HALF_REG; 1558 YY_BREAK 1559case 106: 1560YY_RULE_SETUP 1561#line 166 "bfin-lex.l" 1562return EXTRACT; 1563 YY_BREAK 1564case 107: 1565YY_RULE_SETUP 1566#line 167 "bfin-lex.l" 1567return EXPADJ; 1568 YY_BREAK 1569case 108: 1570YY_RULE_SETUP 1571#line 168 "bfin-lex.l" 1572return EXCPT; 1573 YY_BREAK 1574case 109: 1575YY_RULE_SETUP 1576#line 169 "bfin-lex.l" 1577return EMUEXCPT; 1578 YY_BREAK 1579case 110: 1580YY_RULE_SETUP 1581#line 170 "bfin-lex.l" 1582return DIVS; 1583 YY_BREAK 1584case 111: 1585YY_RULE_SETUP 1586#line 171 "bfin-lex.l" 1587return DIVQ; 1588 YY_BREAK 1589case 112: 1590YY_RULE_SETUP 1591#line 172 "bfin-lex.l" 1592return DISALGNEXCPT; 1593 YY_BREAK 1594case 113: 1595YY_RULE_SETUP 1596#line 173 "bfin-lex.l" 1597return DEPOSIT; 1598 YY_BREAK 1599case 114: 1600YY_RULE_SETUP 1601#line 174 "bfin-lex.l" 1602return DBGHALT; 1603 YY_BREAK 1604case 115: 1605YY_RULE_SETUP 1606#line 175 "bfin-lex.l" 1607return DBGCMPLX; 1608 YY_BREAK 1609case 116: 1610YY_RULE_SETUP 1611#line 176 "bfin-lex.l" 1612return DBGAL; 1613 YY_BREAK 1614case 117: 1615YY_RULE_SETUP 1616#line 177 "bfin-lex.l" 1617return DBGAH; 1618 YY_BREAK 1619case 118: 1620YY_RULE_SETUP 1621#line 178 "bfin-lex.l" 1622return DBGA; 1623 YY_BREAK 1624case 119: 1625YY_RULE_SETUP 1626#line 179 "bfin-lex.l" 1627return DBG; 1628 YY_BREAK 1629case 120: 1630YY_RULE_SETUP 1631#line 180 "bfin-lex.l" 1632{ _REG.regno = REG_CYCLES2; return REG; } 1633 YY_BREAK 1634case 121: 1635YY_RULE_SETUP 1636#line 181 "bfin-lex.l" 1637{ _REG.regno = REG_CYCLES; return REG; } 1638 YY_BREAK 1639case 122: 1640YY_RULE_SETUP 1641#line 182 "bfin-lex.l" 1642return CSYNC; 1643 YY_BREAK 1644case 123: 1645YY_RULE_SETUP 1646#line 183 "bfin-lex.l" 1647return CO; 1648 YY_BREAK 1649case 124: 1650YY_RULE_SETUP 1651#line 184 "bfin-lex.l" 1652return CLI; 1653 YY_BREAK 1654case 125: 1655YY_RULE_SETUP 1656#line 186 "bfin-lex.l" 1657_REG.regno = REG_CC; return CCREG; 1658 YY_BREAK 1659case 126: 1660YY_RULE_SETUP 1661#line 187 "bfin-lex.l" 1662{ BEGIN 0; return CALL;} 1663 YY_BREAK 1664case 127: 1665YY_RULE_SETUP 1666#line 188 "bfin-lex.l" 1667{ BEGIN 0; return CALL;} 1668 YY_BREAK 1669case 128: 1670YY_RULE_SETUP 1671#line 189 "bfin-lex.l" 1672return BYTEUNPACK; 1673 YY_BREAK 1674case 129: 1675YY_RULE_SETUP 1676#line 190 "bfin-lex.l" 1677return BYTEPACK; 1678 YY_BREAK 1679case 130: 1680YY_RULE_SETUP 1681#line 191 "bfin-lex.l" 1682return BYTEOP16M; 1683 YY_BREAK 1684case 131: 1685YY_RULE_SETUP 1686#line 192 "bfin-lex.l" 1687return BYTEOP16P; 1688 YY_BREAK 1689case 132: 1690YY_RULE_SETUP 1691#line 193 "bfin-lex.l" 1692return BYTEOP3P; 1693 YY_BREAK 1694case 133: 1695YY_RULE_SETUP 1696#line 194 "bfin-lex.l" 1697return BYTEOP2M; 1698 YY_BREAK 1699case 134: 1700YY_RULE_SETUP 1701#line 195 "bfin-lex.l" 1702return BYTEOP2P; 1703 YY_BREAK 1704case 135: 1705YY_RULE_SETUP 1706#line 196 "bfin-lex.l" 1707return BYTEOP1P; 1708 YY_BREAK 1709case 136: 1710YY_RULE_SETUP 1711#line 197 "bfin-lex.l" 1712return BY; 1713 YY_BREAK 1714case 137: 1715YY_RULE_SETUP 1716#line 198 "bfin-lex.l" 1717return BXORSHIFT; 1718 YY_BREAK 1719case 138: 1720YY_RULE_SETUP 1721#line 199 "bfin-lex.l" 1722return BXOR; 1723 YY_BREAK 1724case 139: 1725YY_RULE_SETUP 1726#line 201 "bfin-lex.l" 1727return BREV; 1728 YY_BREAK 1729case 140: 1730YY_RULE_SETUP 1731#line 202 "bfin-lex.l" 1732return BP; 1733 YY_BREAK 1734case 141: 1735YY_RULE_SETUP 1736#line 203 "bfin-lex.l" 1737return BITTST; 1738 YY_BREAK 1739case 142: 1740YY_RULE_SETUP 1741#line 204 "bfin-lex.l" 1742return BITTGL; 1743 YY_BREAK 1744case 143: 1745YY_RULE_SETUP 1746#line 205 "bfin-lex.l" 1747return BITSET; 1748 YY_BREAK 1749case 144: 1750YY_RULE_SETUP 1751#line 206 "bfin-lex.l" 1752return BITMUX; 1753 YY_BREAK 1754case 145: 1755YY_RULE_SETUP 1756#line 207 "bfin-lex.l" 1757return BITCLR; 1758 YY_BREAK 1759case 146: 1760YY_RULE_SETUP 1761#line 208 "bfin-lex.l" 1762return parse_halfreg (&yylval.reg, T_REG_B, yytext); 1763 YY_BREAK 1764case 147: 1765YY_RULE_SETUP 1766#line 209 "bfin-lex.l" 1767return parse_reg (&yylval.reg, T_REG_B, yytext); 1768 YY_BREAK 1769case 148: 1770YY_RULE_SETUP 1771#line 210 "bfin-lex.l" 1772return B; 1773 YY_BREAK 1774case 149: 1775YY_RULE_SETUP 1776#line 211 "bfin-lex.l" 1777_REG.regno = S_AZ; return STATUS_REG; 1778 YY_BREAK 1779case 150: 1780YY_RULE_SETUP 1781#line 212 "bfin-lex.l" 1782_REG.regno = S_AN; return STATUS_REG; 1783 YY_BREAK 1784case 151: 1785YY_RULE_SETUP 1786#line 213 "bfin-lex.l" 1787_REG.regno = S_AQ; return STATUS_REG; 1788 YY_BREAK 1789case 152: 1790YY_RULE_SETUP 1791#line 214 "bfin-lex.l" 1792_REG.regno = S_AC0; return STATUS_REG; 1793 YY_BREAK 1794case 153: 1795YY_RULE_SETUP 1796#line 215 "bfin-lex.l" 1797_REG.regno = S_AC1; return STATUS_REG; 1798 YY_BREAK 1799case 154: 1800YY_RULE_SETUP 1801#line 216 "bfin-lex.l" 1802_REG.regno = S_AV0; return STATUS_REG; 1803 YY_BREAK 1804case 155: 1805YY_RULE_SETUP 1806#line 217 "bfin-lex.l" 1807_REG.regno = S_AV0S; return STATUS_REG; 1808 YY_BREAK 1809case 156: 1810YY_RULE_SETUP 1811#line 218 "bfin-lex.l" 1812_REG.regno = S_AV1; return STATUS_REG; 1813 YY_BREAK 1814case 157: 1815YY_RULE_SETUP 1816#line 219 "bfin-lex.l" 1817_REG.regno = S_AV1S; return STATUS_REG; 1818 YY_BREAK 1819case 158: 1820YY_RULE_SETUP 1821#line 220 "bfin-lex.l" 1822_REG.regno = S_V; return STATUS_REG; 1823 YY_BREAK 1824case 159: 1825YY_RULE_SETUP 1826#line 221 "bfin-lex.l" 1827_REG.regno = S_VS; return STATUS_REG; 1828 YY_BREAK 1829case 160: 1830YY_RULE_SETUP 1831#line 224 "bfin-lex.l" 1832_REG.regno = REG_ASTAT; return REG; 1833 YY_BREAK 1834case 161: 1835YY_RULE_SETUP 1836#line 225 "bfin-lex.l" 1837return ASHIFT; 1838 YY_BREAK 1839case 162: 1840YY_RULE_SETUP 1841#line 226 "bfin-lex.l" 1842return ASL; 1843 YY_BREAK 1844case 163: 1845YY_RULE_SETUP 1846#line 227 "bfin-lex.l" 1847return ASR; 1848 YY_BREAK 1849case 164: 1850YY_RULE_SETUP 1851#line 228 "bfin-lex.l" 1852return ALIGN8; 1853 YY_BREAK 1854case 165: 1855YY_RULE_SETUP 1856#line 229 "bfin-lex.l" 1857return ALIGN16; 1858 YY_BREAK 1859case 166: 1860YY_RULE_SETUP 1861#line 230 "bfin-lex.l" 1862return ALIGN24; 1863 YY_BREAK 1864case 167: 1865YY_RULE_SETUP 1866#line 231 "bfin-lex.l" 1867return A_ONE_DOT_L; 1868 YY_BREAK 1869case 168: 1870YY_RULE_SETUP 1871#line 232 "bfin-lex.l" 1872return A_ZERO_DOT_L; 1873 YY_BREAK 1874case 169: 1875YY_RULE_SETUP 1876#line 233 "bfin-lex.l" 1877return A_ONE_DOT_H; 1878 YY_BREAK 1879case 170: 1880YY_RULE_SETUP 1881#line 234 "bfin-lex.l" 1882return A_ZERO_DOT_H; 1883 YY_BREAK 1884case 171: 1885YY_RULE_SETUP 1886#line 235 "bfin-lex.l" 1887return ABS; 1888 YY_BREAK 1889case 172: 1890YY_RULE_SETUP 1891#line 236 "bfin-lex.l" 1892return ABORT; 1893 YY_BREAK 1894case 173: 1895YY_RULE_SETUP 1896#line 237 "bfin-lex.l" 1897_REG.regno = REG_A1x; return REG; 1898 YY_BREAK 1899case 174: 1900YY_RULE_SETUP 1901#line 238 "bfin-lex.l" 1902_REG.regno = REG_A1w; return REG; 1903 YY_BREAK 1904case 175: 1905YY_RULE_SETUP 1906#line 239 "bfin-lex.l" 1907_REG.regno = REG_A1; return REG_A_DOUBLE_ONE; 1908 YY_BREAK 1909case 176: 1910YY_RULE_SETUP 1911#line 240 "bfin-lex.l" 1912_REG.regno = REG_A0x; return REG; 1913 YY_BREAK 1914case 177: 1915YY_RULE_SETUP 1916#line 241 "bfin-lex.l" 1917_REG.regno = REG_A0w; return REG; 1918 YY_BREAK 1919case 178: 1920YY_RULE_SETUP 1921#line 242 "bfin-lex.l" 1922_REG.regno = REG_A0; return REG_A_DOUBLE_ZERO; 1923 YY_BREAK 1924case 179: 1925YY_RULE_SETUP 1926#line 243 "bfin-lex.l" 1927return GOT; 1928 YY_BREAK 1929case 180: 1930YY_RULE_SETUP 1931#line 244 "bfin-lex.l" 1932return GOT17M4; 1933 YY_BREAK 1934case 181: 1935YY_RULE_SETUP 1936#line 245 "bfin-lex.l" 1937return FUNCDESC_GOT17M4; 1938 YY_BREAK 1939case 182: 1940YY_RULE_SETUP 1941#line 246 "bfin-lex.l" 1942return PLTPC; 1943 YY_BREAK 1944case 183: 1945YY_RULE_SETUP 1946#line 249 "bfin-lex.l" 1947return TILDA; 1948 YY_BREAK 1949case 184: 1950YY_RULE_SETUP 1951#line 250 "bfin-lex.l" 1952return _BAR_ASSIGN; 1953 YY_BREAK 1954case 185: 1955YY_RULE_SETUP 1956#line 251 "bfin-lex.l" 1957return BAR; 1958 YY_BREAK 1959case 186: 1960YY_RULE_SETUP 1961#line 252 "bfin-lex.l" 1962return _CARET_ASSIGN; 1963 YY_BREAK 1964case 187: 1965YY_RULE_SETUP 1966#line 253 "bfin-lex.l" 1967return CARET; 1968 YY_BREAK 1969case 188: 1970YY_RULE_SETUP 1971#line 254 "bfin-lex.l" 1972return RBRACK; 1973 YY_BREAK 1974case 189: 1975YY_RULE_SETUP 1976#line 255 "bfin-lex.l" 1977return LBRACK; 1978 YY_BREAK 1979case 190: 1980YY_RULE_SETUP 1981#line 256 "bfin-lex.l" 1982return _GREATER_GREATER_GREATER_THAN_ASSIGN; 1983 YY_BREAK 1984case 191: 1985YY_RULE_SETUP 1986#line 257 "bfin-lex.l" 1987return _GREATER_GREATER_ASSIGN; 1988 YY_BREAK 1989case 192: 1990YY_RULE_SETUP 1991#line 258 "bfin-lex.l" 1992return _GREATER_GREATER_GREATER; 1993 YY_BREAK 1994case 193: 1995YY_RULE_SETUP 1996#line 259 "bfin-lex.l" 1997return GREATER_GREATER; 1998 YY_BREAK 1999case 194: 2000YY_RULE_SETUP 2001#line 260 "bfin-lex.l" 2002return _ASSIGN_ASSIGN; 2003 YY_BREAK 2004case 195: 2005YY_RULE_SETUP 2006#line 261 "bfin-lex.l" 2007return ASSIGN; 2008 YY_BREAK 2009case 196: 2010YY_RULE_SETUP 2011#line 262 "bfin-lex.l" 2012return _LESS_THAN_ASSIGN; 2013 YY_BREAK 2014case 197: 2015YY_RULE_SETUP 2016#line 263 "bfin-lex.l" 2017return _LESS_LESS_ASSIGN; 2018 YY_BREAK 2019case 198: 2020YY_RULE_SETUP 2021#line 264 "bfin-lex.l" 2022return LESS_LESS; 2023 YY_BREAK 2024case 199: 2025YY_RULE_SETUP 2026#line 265 "bfin-lex.l" 2027return LESS_THAN; 2028 YY_BREAK 2029case 200: 2030YY_RULE_SETUP 2031#line 266 "bfin-lex.l" 2032return LPAREN; 2033 YY_BREAK 2034case 201: 2035YY_RULE_SETUP 2036#line 267 "bfin-lex.l" 2037return RPAREN; 2038 YY_BREAK 2039case 202: 2040YY_RULE_SETUP 2041#line 268 "bfin-lex.l" 2042return COLON; 2043 YY_BREAK 2044case 203: 2045YY_RULE_SETUP 2046#line 269 "bfin-lex.l" 2047return SLASH; 2048 YY_BREAK 2049case 204: 2050YY_RULE_SETUP 2051#line 270 "bfin-lex.l" 2052return _MINUS_ASSIGN; 2053 YY_BREAK 2054case 205: 2055YY_RULE_SETUP 2056#line 271 "bfin-lex.l" 2057return _PLUS_BAR_PLUS; 2058 YY_BREAK 2059case 206: 2060YY_RULE_SETUP 2061#line 272 "bfin-lex.l" 2062return _MINUS_BAR_PLUS; 2063 YY_BREAK 2064case 207: 2065YY_RULE_SETUP 2066#line 273 "bfin-lex.l" 2067return _PLUS_BAR_MINUS; 2068 YY_BREAK 2069case 208: 2070YY_RULE_SETUP 2071#line 274 "bfin-lex.l" 2072return _MINUS_BAR_MINUS; 2073 YY_BREAK 2074case 209: 2075YY_RULE_SETUP 2076#line 275 "bfin-lex.l" 2077return _MINUS_MINUS; 2078 YY_BREAK 2079case 210: 2080YY_RULE_SETUP 2081#line 276 "bfin-lex.l" 2082return MINUS; 2083 YY_BREAK 2084case 211: 2085YY_RULE_SETUP 2086#line 277 "bfin-lex.l" 2087return COMMA; 2088 YY_BREAK 2089case 212: 2090YY_RULE_SETUP 2091#line 278 "bfin-lex.l" 2092return _PLUS_ASSIGN; 2093 YY_BREAK 2094case 213: 2095YY_RULE_SETUP 2096#line 279 "bfin-lex.l" 2097return _PLUS_PLUS; 2098 YY_BREAK 2099case 214: 2100YY_RULE_SETUP 2101#line 280 "bfin-lex.l" 2102return PLUS; 2103 YY_BREAK 2104case 215: 2105YY_RULE_SETUP 2106#line 281 "bfin-lex.l" 2107return _STAR_ASSIGN; 2108 YY_BREAK 2109case 216: 2110YY_RULE_SETUP 2111#line 282 "bfin-lex.l" 2112return STAR; 2113 YY_BREAK 2114case 217: 2115YY_RULE_SETUP 2116#line 283 "bfin-lex.l" 2117return _AMPERSAND_ASSIGN; 2118 YY_BREAK 2119case 218: 2120YY_RULE_SETUP 2121#line 284 "bfin-lex.l" 2122return AMPERSAND; 2123 YY_BREAK 2124case 219: 2125YY_RULE_SETUP 2126#line 285 "bfin-lex.l" 2127return PERCENT; 2128 YY_BREAK 2129case 220: 2130YY_RULE_SETUP 2131#line 286 "bfin-lex.l" 2132return BANG; 2133 YY_BREAK 2134case 221: 2135YY_RULE_SETUP 2136#line 287 "bfin-lex.l" 2137return SEMICOLON; 2138 YY_BREAK 2139case 222: 2140YY_RULE_SETUP 2141#line 288 "bfin-lex.l" 2142return _ASSIGN_BANG; 2143 YY_BREAK 2144case 223: 2145YY_RULE_SETUP 2146#line 289 "bfin-lex.l" 2147return DOUBLE_BAR; 2148 YY_BREAK 2149case 224: 2150YY_RULE_SETUP 2151#line 290 "bfin-lex.l" 2152return AT; 2153 YY_BREAK 2154case 225: 2155YY_RULE_SETUP 2156#line 291 "bfin-lex.l" 2157return PREFETCH; 2158 YY_BREAK 2159case 226: 2160YY_RULE_SETUP 2161#line 292 "bfin-lex.l" 2162return UNLINK; 2163 YY_BREAK 2164case 227: 2165YY_RULE_SETUP 2166#line 293 "bfin-lex.l" 2167return LINK; 2168 YY_BREAK 2169case 228: 2170YY_RULE_SETUP 2171#line 294 "bfin-lex.l" 2172return IDLE; 2173 YY_BREAK 2174case 229: 2175YY_RULE_SETUP 2176#line 295 "bfin-lex.l" 2177return IFLUSH; 2178 YY_BREAK 2179case 230: 2180YY_RULE_SETUP 2181#line 296 "bfin-lex.l" 2182return FLUSHINV; 2183 YY_BREAK 2184case 231: 2185YY_RULE_SETUP 2186#line 297 "bfin-lex.l" 2187return FLUSH; 2188 YY_BREAK 2189case 232: 2190YY_RULE_SETUP 2191#line 298 "bfin-lex.l" 2192{ 2193 yylval.value = parse_int (&yytext); 2194 return NUMBER; 2195 } 2196 YY_BREAK 2197case 233: 2198YY_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 2206case 234: 2207YY_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 2239case 235: 2240YY_RULE_SETUP 2241#line 336 "bfin-lex.l" 2242; 2243 YY_BREAK 2244case 236: 2245YY_RULE_SETUP 2246#line 337 "bfin-lex.l" 2247; 2248 YY_BREAK 2249case 237: 2250YY_RULE_SETUP 2251#line 338 "bfin-lex.l" 2252return yytext[0]; 2253 YY_BREAK 2254case 238: 2255YY_RULE_SETUP 2256#line 339 "bfin-lex.l" 2257ECHO; 2258 YY_BREAK 2259#line 2260 "bfin-lex.c" 2260case YY_STATE_EOF(INITIAL): 2261case 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 2402static 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 2534static 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 2569static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 2570#else 2571static yy_state_type yy_try_NUL_trans( yy_current_state ) 2572yy_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 2599static void yyunput( int c, register char *yy_bp ) 2600#else 2601static void yyunput( c, yy_bp ) 2602int c; 2603register 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 2643static int yyinput() 2644#else 2645static 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 2716void yyrestart( FILE *input_file ) 2717#else 2718void yyrestart( input_file ) 2719FILE *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 2731void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 2732#else 2733void yy_switch_to_buffer( new_buffer ) 2734YY_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 2761void yy_load_buffer_state( void ) 2762#else 2763void 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 2774YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 2775#else 2776YY_BUFFER_STATE yy_create_buffer( file, size ) 2777FILE *file; 2778int 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 2805void yy_delete_buffer( YY_BUFFER_STATE b ) 2806#else 2807void yy_delete_buffer( b ) 2808YY_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 2829extern int isatty YY_PROTO(( int )); 2830#endif 2831#endif 2832#endif 2833 2834#ifdef YY_USE_PROTOS 2835void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 2836#else 2837void yy_init_buffer( b, file ) 2838YY_BUFFER_STATE b; 2839FILE *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 2862void yy_flush_buffer( YY_BUFFER_STATE b ) 2863#else 2864void yy_flush_buffer( b ) 2865YY_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 2893YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 2894#else 2895YY_BUFFER_STATE yy_scan_buffer( base, size ) 2896char *base; 2897yy_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 2931YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 2932#else 2933YY_BUFFER_STATE yy_scan_string( yy_str ) 2934yyconst 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 2948YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 2949#else 2950YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 2951yyconst char *bytes; 2952int 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 2987static void yy_push_state( int new_state ) 2988#else 2989static void yy_push_state( new_state ) 2990int 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 3020static 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 3031static 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 3042static void yy_fatal_error( yyconst char msg[] ) 3043#else 3044static void yy_fatal_error( msg ) 3045char 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 3074static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 3075#else 3076static void yy_flex_strncpy( s1, s2, n ) 3077char *s1; 3078yyconst char *s2; 3079int 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 3090static int yy_flex_strlen( yyconst char *s ) 3091#else 3092static int yy_flex_strlen( s ) 3093yyconst 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 3106static void *yy_flex_alloc( yy_size_t size ) 3107#else 3108static void *yy_flex_alloc( size ) 3109yy_size_t size; 3110#endif 3111 { 3112 return (void *) malloc( size ); 3113 } 3114 3115#ifdef YY_USE_PROTOS 3116static void *yy_flex_realloc( void *ptr, yy_size_t size ) 3117#else 3118static void *yy_flex_realloc( ptr, size ) 3119void *ptr; 3120yy_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 3134static void yy_flex_free( void *ptr ) 3135#else 3136static void yy_flex_free( ptr ) 3137void *ptr; 3138#endif 3139 { 3140 free( ptr ); 3141 } 3142 3143#if YY_MAIN 3144int main() 3145 { 3146 yylex(); 3147 return 0; 3148 } 3149#endif 3150#line 339 "bfin-lex.l" 3151 3152static 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 3323static int parse_reg (Register *r, int cl, char *rt) 3324{ 3325 r->regno = cl | (rt[1] - '0'); 3326 return REG; 3327} 3328 3329static 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 3355void 3356set_start_state (void) 3357{ 3358 BEGIN KEYWORD; 3359} 3360 3361 3362#ifndef yywrap 3363int 3364yywrap () 3365{ 3366 return 1; 3367} 3368#endif 3369