OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

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

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.