OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [gas/] [bfin-lex.c] - Blame information for rev 404

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.