1 /* A lexical scanner generated by flex */
2
3 /* Scanner skeleton version:
4 * $Header: /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
yy_get_next_buffer()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
yy_get_previous_state()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
yy_try_NUL_trans(yy_state_type yy_current_state)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
yyunput(int c,register char * yy_bp)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
yyinput()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
yyrestart(FILE * input_file)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
yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)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
yy_load_buffer_state(void)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
yy_create_buffer(FILE * file,int size)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
yy_delete_buffer(YY_BUFFER_STATE b)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
yy_init_buffer(YY_BUFFER_STATE b,FILE * file)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
yy_flush_buffer(YY_BUFFER_STATE b)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
yy_scan_buffer(char * base,yy_size_t size)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
yy_scan_string(yyconst char * yy_str)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
yy_scan_bytes(yyconst char * bytes,int len)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
yy_push_state(int new_state)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
yy_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
yy_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
yy_fatal_error(yyconst char msg[])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
yy_flex_strncpy(char * s1,yyconst char * s2,int n)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
yy_flex_strlen(yyconst char * s)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
yy_flex_alloc(yy_size_t size)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
yy_flex_realloc(void * ptr,yy_size_t size)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
yy_flex_free(void * ptr)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
main()3144 int main()
3145 {
3146 yylex();
3147 return 0;
3148 }
3149 #endif
3150 #line 339 "bfin-lex.l"
3151
parse_int(char ** end)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
parse_reg(Register * r,int cl,char * rt)3323 static int parse_reg (Register *r, int cl, char *rt)
3324 {
3325 r->regno = cl | (rt[1] - '0');
3326 return REG;
3327 }
3328
parse_halfreg(Register * r,int cl,char * rt)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
set_start_state(void)3356 set_start_state (void)
3357 {
3358 BEGIN KEYWORD;
3359 }
3360
3361
3362 #ifndef yywrap
3363 int
yywrap()3364 yywrap ()
3365 {
3366 return 1;
3367 }
3368 #endif
3369