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

Subversion Repositories openrisc_me

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

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

Line No. Rev Author Line
1 38 julius
/* A lexical scanner generated by flex */
2
 
3
/* Scanner skeleton version:
4
 * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
5
 */
6
 
7
#define FLEX_SCANNER
8
#define YY_FLEX_MAJOR_VERSION 2
9
#define YY_FLEX_MINOR_VERSION 5
10
 
11
#include <stdio.h>
12
#include <unistd.h>
13
 
14
 
15
/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
16
#ifdef c_plusplus
17
#ifndef __cplusplus
18
#define __cplusplus
19
#endif
20
#endif
21
 
22
 
23
#ifdef __cplusplus
24
 
25
#include <stdlib.h>
26
 
27
/* Use prototypes in function declarations. */
28
#define YY_USE_PROTOS
29
 
30
/* The "const" storage-class-modifier is valid. */
31
#define YY_USE_CONST
32
 
33
#else   /* ! __cplusplus */
34
 
35
#if __STDC__
36
 
37
#define YY_USE_PROTOS
38
#define YY_USE_CONST
39
 
40
#endif  /* __STDC__ */
41
#endif  /* ! __cplusplus */
42
 
43
#ifdef __TURBOC__
44
 #pragma warn -rch
45
 #pragma warn -use
46
#include <io.h>
47
#include <stdlib.h>
48
#define YY_USE_CONST
49
#define YY_USE_PROTOS
50
#endif
51
 
52
#ifdef YY_USE_CONST
53
#define yyconst const
54
#else
55
#define yyconst
56
#endif
57
 
58
 
59
#ifdef YY_USE_PROTOS
60
#define YY_PROTO(proto) proto
61
#else
62
#define YY_PROTO(proto) ()
63
#endif
64
 
65
/* Returned upon end-of-file. */
66
#define YY_NULL 0
67
 
68
/* Promotes a possibly negative, possibly signed char to an unsigned
69
 * integer for use as an array index.  If the signed char is negative,
70
 * we want to instead treat it as an 8-bit unsigned char, hence the
71
 * double cast.
72
 */
73
#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
74
 
75
/* Enter a start condition.  This macro really ought to take a parameter,
76
 * but we do it the disgusting crufty way forced on us by the ()-less
77
 * definition of BEGIN.
78
 */
79
#define BEGIN yy_start = 1 + 2 *
80
 
81
/* Translate the current start state into a value that can be later handed
82
 * to BEGIN to return to the state.  The YYSTATE alias is for lex
83
 * compatibility.
84
 */
85
#define YY_START ((yy_start - 1) / 2)
86
#define YYSTATE YY_START
87
 
88
/* Action number for EOF rule of a given start state. */
89
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
90
 
91
/* Special action meaning "start processing a new file". */
92
#define YY_NEW_FILE yyrestart( yyin )
93
 
94
#define YY_END_OF_BUFFER_CHAR 0
95
 
96
/* Size of default input buffer. */
97
#define YY_BUF_SIZE 16384
98
 
99
typedef struct yy_buffer_state *YY_BUFFER_STATE;
100
 
101
extern int yyleng;
102
extern FILE *yyin, *yyout;
103
 
104
#define EOB_ACT_CONTINUE_SCAN 0
105
#define EOB_ACT_END_OF_FILE 1
106
#define EOB_ACT_LAST_MATCH 2
107
 
108
/* The funky do-while in the following #define is used to turn the definition
109
 * int a single C statement (which needs a semi-colon terminator).  This
110
 * avoids problems with code like:
111
 *
112
 *      if ( condition_holds )
113
 *              yyless( 5 );
114
 *      else
115
 *              do_something_else();
116
 *
117
 * Prior to using the do-while the compiler would get upset at the
118
 * "else" because it interpreted the "if" statement as being all
119
 * done when it reached the ';' after the yyless() call.
120
 */
121
 
122
/* Return all but the first 'n' matched characters back to the input stream. */
123
 
124
#define yyless(n) \
125
        do \
126
                { \
127
                /* Undo effects of setting up yytext. */ \
128
                *yy_cp = yy_hold_char; \
129
                YY_RESTORE_YY_MORE_OFFSET \
130
                yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
131
                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
132
                } \
133
        while ( 0 )
134
 
135
#define unput(c) yyunput( c, yytext_ptr )
136
 
137
/* The following is because we cannot portably get our hands on size_t
138
 * (without autoconf's help, which isn't available because we want
139
 * flex-generated scanners to compile on their own).
140
 */
141
typedef unsigned int yy_size_t;
142
 
143
 
144
struct yy_buffer_state
145
        {
146
        FILE *yy_input_file;
147
 
148
        char *yy_ch_buf;                /* input buffer */
149
        char *yy_buf_pos;               /* current position in input buffer */
150
 
151
        /* Size of input buffer in bytes, not including room for EOB
152
         * characters.
153
         */
154
        yy_size_t yy_buf_size;
155
 
156
        /* Number of characters read into yy_ch_buf, not including EOB
157
         * characters.
158
         */
159
        int yy_n_chars;
160
 
161
        /* Whether we "own" the buffer - i.e., we know we created it,
162
         * and can realloc() it to grow it, and should free() it to
163
         * delete it.
164
         */
165
        int yy_is_our_buffer;
166
 
167
        /* Whether this is an "interactive" input source; if so, and
168
         * if we're using stdio for input, then we want to use getc()
169
         * instead of fread(), to make sure we stop fetching input after
170
         * each newline.
171
         */
172
        int yy_is_interactive;
173
 
174
        /* Whether we're considered to be at the beginning of a line.
175
         * If so, '^' rules will be active on the next match, otherwise
176
         * not.
177
         */
178
        int yy_at_bol;
179
 
180
        /* Whether to try to fill the input buffer when we reach the
181
         * end of it.
182
         */
183
        int yy_fill_buffer;
184
 
185
        int yy_buffer_status;
186
#define YY_BUFFER_NEW 0
187
#define YY_BUFFER_NORMAL 1
188
        /* When an EOF's been seen but there's still some text to process
189
         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
190
         * shouldn't try reading from the input source any more.  We might
191
         * still have a bunch of tokens to match, though, because of
192
         * possible backing-up.
193
         *
194
         * When we actually see the EOF, we change the status to "new"
195
         * (via yyrestart()), so that the user can continue scanning by
196
         * just pointing yyin at a new input file.
197
         */
198
#define YY_BUFFER_EOF_PENDING 2
199
        };
200
 
201
static YY_BUFFER_STATE yy_current_buffer = 0;
202
 
203
/* We provide macros for accessing buffer states in case in the
204
 * future we want to put the buffer states in a more general
205
 * "scanner state".
206
 */
207
#define YY_CURRENT_BUFFER yy_current_buffer
208
 
209
 
210
/* yy_hold_char holds the character lost when yytext is formed. */
211
static char yy_hold_char;
212
 
213
static int yy_n_chars;          /* number of characters read into yy_ch_buf */
214
 
215
 
216
int yyleng;
217
 
218
/* Points to current character in buffer. */
219
static char *yy_c_buf_p = (char *) 0;
220
static int yy_init = 1;         /* whether we need to initialize */
221
static int yy_start = 0; /* start state number */
222
 
223
/* Flag which is used to allow yywrap()'s to do buffer switches
224
 * instead of setting up a fresh yyin.  A bit of a hack ...
225
 */
226
static int yy_did_buffer_switch_on_eof;
227
 
228
void yyrestart YY_PROTO(( FILE *input_file ));
229
 
230
void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
231
void yy_load_buffer_state YY_PROTO(( void ));
232
YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
233
void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
234
void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
235
void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
236
#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
237
 
238
YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
239
YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
240
YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
241
 
242
static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
243
static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
244
static void yy_flex_free YY_PROTO(( void * ));
245
 
246
#define yy_new_buffer yy_create_buffer
247
 
248
#define yy_set_interactive(is_interactive) \
249
        { \
250
        if ( ! yy_current_buffer ) \
251
                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
252
        yy_current_buffer->yy_is_interactive = is_interactive; \
253
        }
254
 
255
#define yy_set_bol(at_bol) \
256
        { \
257
        if ( ! yy_current_buffer ) \
258
                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
259
        yy_current_buffer->yy_at_bol = at_bol; \
260
        }
261
 
262
#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
263
 
264
typedef unsigned char YY_CHAR;
265
FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
266
typedef int yy_state_type;
267
extern char *yytext;
268
#define yytext_ptr yytext
269
 
270
static yy_state_type yy_get_previous_state YY_PROTO(( void ));
271
static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
272
static int yy_get_next_buffer YY_PROTO(( void ));
273
static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
274
 
275
/* Done after the current pattern has been matched and before the
276
 * corresponding action - sets up yytext.
277
 */
278
#define YY_DO_BEFORE_ACTION \
279
        yytext_ptr = yy_bp; \
280
        yyleng = (int) (yy_cp - yy_bp); \
281
        yy_hold_char = *yy_cp; \
282
        *yy_cp = '\0'; \
283
        yy_c_buf_p = yy_cp;
284
 
285
#define YY_NUM_RULES 15
286
#define YY_END_OF_BUFFER 16
287
static yyconst short int yy_accept[60] =
288
    {   0,
289
        0,    0,   16,   14,   13,   12,   11,    8,    8,   10,
290
       10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
291
       10,    8,    0,   10,   10,   10,   10,   10,   10,   10,
292
       10,   10,   10,   10,   10,   10,    7,    9,   10,   10,
293
       10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
294
        5,    1,    2,    3,   10,    6,   10,    4,    0
295
    } ;
296
 
297
static yyconst int yy_ec[256] =
298
    {   0,
299
        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
300
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
301
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
302
        1,    4,    1,    1,    5,    1,    1,    1,    1,    1,
303
        1,    1,    1,    1,    1,    1,    1,    6,    7,    7,
304
        7,    7,    7,    7,    7,    7,    7,    1,    8,    1,
305
        1,    1,    1,    1,    9,   10,   11,   12,   13,   10,
306
       14,   15,   16,   15,   15,   15,   17,   18,   15,   15,
307
       15,   19,   20,   15,   15,   15,   15,   15,   15,   15,
308
        1,    1,    1,    1,   15,    1,   21,   10,   22,   23,
309
 
310
       24,   10,   25,   15,   26,   15,   15,   15,   27,   28,
311
       15,   29,   15,   30,   31,   15,   15,   15,   15,   32,
312
       15,   15,    1,    1,    1,    1,    1,    1,    1,    1,
313
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
314
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
315
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
316
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
317
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
318
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
319
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
320
 
321
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
322
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
323
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
324
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
325
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
326
        1,    1,    1,    1,    1
327
    } ;
328
 
329
static yyconst int yy_meta[33] =
330
    {   0,
331
        1,    1,    1,    1,    1,    2,    2,    1,    2,    2,
332
        2,    2,    2,    3,    3,    3,    3,    3,    3,    3,
333
        2,    2,    2,    2,    3,    3,    3,    3,    3,    3,
334
        3,    3
335
    } ;
336
 
337
static yyconst short int yy_base[62] =
338
    {   0,
339
        0,    0,   83,   84,   84,   84,   84,   27,   29,   70,
340
        0,   62,   61,   60,   20,   55,   47,   46,   45,   12,
341
       35,   37,    0,    0,   62,   60,   59,   58,   53,   49,
342
       45,   43,   42,   41,   37,   32,    0,    0,   43,   44,
343
       43,   42,   42,   36,   23,   27,   26,   25,   25,   20,
344
        0,    0,    0,    0,   35,    0,   23,    0,   84,   58,
345
       43
346
    } ;
347
 
348
static yyconst short int yy_def[62] =
349
    {   0,
350
       59,    1,   59,   59,   59,   59,   59,   59,   59,   60,
351
       60,   60,   60,   60,   60,   60,   60,   60,   60,   60,
352
       60,   59,   61,   60,   60,   60,   60,   60,   60,   60,
353
       60,   60,   60,   60,   60,   60,   60,   61,   60,   60,
354
       60,   60,   60,   60,   60,   60,   60,   60,   60,   60,
355
       60,   60,   60,   60,   60,   60,   60,   60,    0,   59,
356
       59
357
    } ;
358
 
359
static yyconst short int yy_nxt[117] =
360
    {   0,
361
        4,    5,    6,    5,    7,    8,    9,    7,   10,   11,
362
       12,   13,   11,   14,   11,   15,   11,   11,   11,   11,
363
       16,   17,   18,   11,   19,   20,   11,   11,   21,   11,
364
       11,   11,   22,   22,   22,   22,   29,   30,   35,   36,
365
       37,   37,   22,   22,   38,   58,   58,   56,   57,   54,
366
       53,   52,   51,   56,   55,   54,   53,   52,   23,   24,
367
       24,   51,   50,   49,   48,   47,   46,   45,   44,   43,
368
       42,   41,   40,   39,   34,   33,   32,   31,   28,   27,
369
       26,   25,   59,    3,   59,   59,   59,   59,   59,   59,
370
       59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
371
 
372
       59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
373
       59,   59,   59,   59,   59,   59
374
    } ;
375
 
376
static yyconst short int yy_chk[117] =
377
    {   0,
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,    8,    8,    9,    9,   15,   15,   20,   20,
382
       21,   21,   22,   22,   61,   57,   55,   50,   49,   48,
383
       47,   46,   45,   44,   43,   42,   41,   40,    8,   60,
384
       60,   39,   36,   35,   34,   33,   32,   31,   30,   29,
385
       28,   27,   26,   25,   19,   18,   17,   16,   14,   13,
386
       12,   10,    3,   59,   59,   59,   59,   59,   59,   59,
387
       59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
388
 
389
       59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
390
       59,   59,   59,   59,   59,   59
391
    } ;
392
 
393
static yy_state_type yy_last_accepting_state;
394
static char *yy_last_accepting_cpos;
395
 
396
/* The intent behind this definition is that it'll catch
397
 * any uses of REJECT which flex missed.
398
 */
399
#define REJECT reject_used_but_not_detected
400
#define yymore() yymore_used_but_not_detected
401
#define YY_MORE_ADJ 0
402
#define YY_RESTORE_YY_MORE_OFFSET
403
char *yytext;
404
#line 1 "itbl-lex.l"
405
#define INITIAL 0
406
/* itbl-lex.l
407
   Copyright 1997, 1998, 2001, 2002, 2005, 2006, 2007
408
   Free Software Foundation, Inc.
409
 
410
   This file is part of GAS, the GNU Assembler.
411
 
412
   GAS is free software; you can redistribute it and/or modify
413
   it under the terms of the GNU General Public License as published by
414
   the Free Software Foundation; either version 3, or (at your option)
415
   any later version.
416
 
417
   GAS is distributed in the hope that it will be useful,
418
   but WITHOUT ANY WARRANTY; without even the implied warranty of
419
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
420
   GNU General Public License for more details.
421
 
422
   You should have received a copy of the GNU General Public License
423
   along with GAS; see the file COPYING.  If not, write to the Free
424
   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
425
   02110-1301, USA.  */
426
#line 23 "itbl-lex.l"
427
#include "as.h"
428
#include "itbl-lex.h"
429
#include <itbl-parse.h>
430
 
431
#ifdef DEBUG
432
#define DBG(x) printf x
433
#define MDBG(x) printf x
434
#else
435
#define DBG(x)
436
#define MDBG(x)
437
#endif
438
 
439
int insntbl_line = 1;
440
#line 441 "itbl-lex.c"
441
 
442
/* Macros after this point can all be overridden by user definitions in
443
 * section 1.
444
 */
445
 
446
#ifndef YY_SKIP_YYWRAP
447
#ifdef __cplusplus
448
extern "C" int yywrap YY_PROTO(( void ));
449
#else
450
extern int yywrap YY_PROTO(( void ));
451
#endif
452
#endif
453
 
454
#ifndef YY_NO_UNPUT
455
static void yyunput YY_PROTO(( int c, char *buf_ptr ));
456
#endif
457
 
458
#ifndef yytext_ptr
459
static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
460
#endif
461
 
462
#ifdef YY_NEED_STRLEN
463
static int yy_flex_strlen YY_PROTO(( yyconst char * ));
464
#endif
465
 
466
#ifndef YY_NO_INPUT
467
#ifdef __cplusplus
468
static int yyinput YY_PROTO(( void ));
469
#else
470
static int input YY_PROTO(( void ));
471
#endif
472
#endif
473
 
474
#if YY_STACK_USED
475
static int yy_start_stack_ptr = 0;
476
static int yy_start_stack_depth = 0;
477
static int *yy_start_stack = 0;
478
#ifndef YY_NO_PUSH_STATE
479
static void yy_push_state YY_PROTO(( int new_state ));
480
#endif
481
#ifndef YY_NO_POP_STATE
482
static void yy_pop_state YY_PROTO(( void ));
483
#endif
484
#ifndef YY_NO_TOP_STATE
485
static int yy_top_state YY_PROTO(( void ));
486
#endif
487
 
488
#else
489
#define YY_NO_PUSH_STATE 1
490
#define YY_NO_POP_STATE 1
491
#define YY_NO_TOP_STATE 1
492
#endif
493
 
494
#ifdef YY_MALLOC_DECL
495
YY_MALLOC_DECL
496
#else
497
#if __STDC__
498
#ifndef __cplusplus
499
#include <stdlib.h>
500
#endif
501
#else
502
/* Just try to get by without declaring the routines.  This will fail
503
 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
504
 * or sizeof(void*) != sizeof(int).
505
 */
506
#endif
507
#endif
508
 
509
/* Amount of stuff to slurp up with each read. */
510
#ifndef YY_READ_BUF_SIZE
511
#define YY_READ_BUF_SIZE 8192
512
#endif
513
 
514
/* Copy whatever the last rule matched to the standard output. */
515
 
516
#ifndef ECHO
517
/* This used to be an fputs(), but since the string might contain NUL's,
518
 * we now use fwrite().
519
 */
520
#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
521
#endif
522
 
523
/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
524
 * is returned in "result".
525
 */
526
#ifndef YY_INPUT
527
#define YY_INPUT(buf,result,max_size) \
528
        if ( yy_current_buffer->yy_is_interactive ) \
529
                { \
530
                int c = '*', n; \
531
                for ( n = 0; n < max_size && \
532
                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
533
                        buf[n] = (char) c; \
534
                if ( c == '\n' ) \
535
                        buf[n++] = (char) c; \
536
                if ( c == EOF && ferror( yyin ) ) \
537
                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
538
                result = n; \
539
                } \
540
        else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
541
                  && ferror( yyin ) ) \
542
                YY_FATAL_ERROR( "input in flex scanner failed" );
543
#endif
544
 
545
/* No semi-colon after return; correct usage is to write "yyterminate();" -
546
 * we don't want an extra ';' after the "return" because that will cause
547
 * some compilers to complain about unreachable statements.
548
 */
549
#ifndef yyterminate
550
#define yyterminate() return YY_NULL
551
#endif
552
 
553
/* Number of entries by which start-condition stack grows. */
554
#ifndef YY_START_STACK_INCR
555
#define YY_START_STACK_INCR 25
556
#endif
557
 
558
/* Report a fatal error. */
559
#ifndef YY_FATAL_ERROR
560
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
561
#endif
562
 
563
/* Default declaration of generated scanner - a define so the user can
564
 * easily add parameters.
565
 */
566
#ifndef YY_DECL
567
#define YY_DECL int yylex YY_PROTO(( void ))
568
#endif
569
 
570
/* Code executed at the beginning of each rule, after yytext and yyleng
571
 * have been set up.
572
 */
573
#ifndef YY_USER_ACTION
574
#define YY_USER_ACTION
575
#endif
576
 
577
/* Code executed at the end of each rule. */
578
#ifndef YY_BREAK
579
#define YY_BREAK break;
580
#endif
581
 
582
#define YY_RULE_SETUP \
583
        YY_USER_ACTION
584
 
585
YY_DECL
586
        {
587
        register yy_state_type yy_current_state;
588
        register char *yy_cp = NULL, *yy_bp = NULL;
589
        register int yy_act;
590
 
591
#line 43 "itbl-lex.l"
592
 
593
 
594
#line 595 "itbl-lex.c"
595
 
596
        if ( yy_init )
597
                {
598
                yy_init = 0;
599
 
600
#ifdef YY_USER_INIT
601
                YY_USER_INIT;
602
#endif
603
 
604
                if ( ! yy_start )
605
                        yy_start = 1;   /* first start state */
606
 
607
                if ( ! yyin )
608
                        yyin = stdin;
609
 
610
                if ( ! yyout )
611
                        yyout = stdout;
612
 
613
                if ( ! yy_current_buffer )
614
                        yy_current_buffer =
615
                                yy_create_buffer( yyin, YY_BUF_SIZE );
616
 
617
                yy_load_buffer_state();
618
                }
619
 
620
        while ( 1 )             /* loops until end-of-file is reached */
621
                {
622
                yy_cp = yy_c_buf_p;
623
 
624
                /* Support of yytext. */
625
                *yy_cp = yy_hold_char;
626
 
627
                /* yy_bp points to the position in yy_ch_buf of the start of
628
                 * the current run.
629
                 */
630
                yy_bp = yy_cp;
631
 
632
                yy_current_state = yy_start;
633
yy_match:
634
                do
635
                        {
636
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
637
                        if ( yy_accept[yy_current_state] )
638
                                {
639
                                yy_last_accepting_state = yy_current_state;
640
                                yy_last_accepting_cpos = yy_cp;
641
                                }
642
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
643
                                {
644
                                yy_current_state = (int) yy_def[yy_current_state];
645
                                if ( yy_current_state >= 60 )
646
                                        yy_c = yy_meta[(unsigned int) yy_c];
647
                                }
648
                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
649
                        ++yy_cp;
650
                        }
651
                while ( yy_base[yy_current_state] != 84 );
652
 
653
yy_find_action:
654
                yy_act = yy_accept[yy_current_state];
655
                if ( yy_act == 0 )
656
                        { /* have to back up */
657
                        yy_cp = yy_last_accepting_cpos;
658
                        yy_current_state = yy_last_accepting_state;
659
                        yy_act = yy_accept[yy_current_state];
660
                        }
661
 
662
                YY_DO_BEFORE_ACTION;
663
 
664
 
665
do_action:      /* This label is used only to access EOF actions. */
666
 
667
 
668
                switch ( yy_act )
669
        { /* beginning of action switch */
670
                        case 0: /* must back up */
671
                        /* undo the effects of YY_DO_BEFORE_ACTION */
672
                        *yy_cp = yy_hold_char;
673
                        yy_cp = yy_last_accepting_cpos;
674
                        yy_current_state = yy_last_accepting_state;
675
                        goto yy_find_action;
676
 
677
case 1:
678
YY_RULE_SETUP
679
#line 45 "itbl-lex.l"
680
{
681
    return CREG;
682
  }
683
        YY_BREAK
684
case 2:
685
YY_RULE_SETUP
686
#line 48 "itbl-lex.l"
687
{
688
    return DREG;
689
  }
690
        YY_BREAK
691
case 3:
692
YY_RULE_SETUP
693
#line 51 "itbl-lex.l"
694
{
695
    return GREG;
696
  }
697
        YY_BREAK
698
case 4:
699
YY_RULE_SETUP
700
#line 54 "itbl-lex.l"
701
{
702
    return IMMED;
703
  }
704
        YY_BREAK
705
case 5:
706
YY_RULE_SETUP
707
#line 57 "itbl-lex.l"
708
{
709
    return ADDR;
710
  }
711
        YY_BREAK
712
case 6:
713
YY_RULE_SETUP
714
#line 60 "itbl-lex.l"
715
{
716
    return INSN;
717
  }
718
        YY_BREAK
719
case 7:
720
YY_RULE_SETUP
721
#line 63 "itbl-lex.l"
722
{
723
    yytext[yyleng] = 0;
724
    yylval.processor = strtoul (yytext+1, 0, 0);
725
    return PNUM;
726
  }
727
        YY_BREAK
728
case 8:
729
YY_RULE_SETUP
730
#line 68 "itbl-lex.l"
731
{
732
    yytext[yyleng] = 0;
733
    yylval.num = strtoul (yytext, 0, 0);
734
    return NUM;
735
  }
736
        YY_BREAK
737
case 9:
738
YY_RULE_SETUP
739
#line 73 "itbl-lex.l"
740
{
741
    yytext[yyleng] = 0;
742
    yylval.num = strtoul (yytext, 0, 0);
743
    return NUM;
744
  }
745
        YY_BREAK
746
case 10:
747
YY_RULE_SETUP
748
#line 78 "itbl-lex.l"
749
{
750
    yytext[yyleng] = 0;
751
    yylval.str = strdup (yytext);
752
    return ID;
753
  }
754
        YY_BREAK
755
case 11:
756
YY_RULE_SETUP
757
#line 83 "itbl-lex.l"
758
{
759
    int c;
760
    while ((c = input ()) !=  EOF)
761
      {
762
        if (c ==  '\n')
763
        {
764
                unput (c);
765
                break;
766
        }
767
      }
768
  }
769
        YY_BREAK
770
case 12:
771
YY_RULE_SETUP
772
#line 94 "itbl-lex.l"
773
{
774
    insntbl_line++;
775
    MDBG (("in lex, NL = %d (x%x)\n", NL, NL));
776
    return NL;
777
  }
778
        YY_BREAK
779
case 13:
780
YY_RULE_SETUP
781
#line 99 "itbl-lex.l"
782
{
783
  }
784
        YY_BREAK
785
case 14:
786
YY_RULE_SETUP
787
#line 101 "itbl-lex.l"
788
{
789
    MDBG (("char = %x, %d\n", yytext[0], yytext[0]));
790
    return yytext[0];
791
  }
792
        YY_BREAK
793
case 15:
794
YY_RULE_SETUP
795
#line 105 "itbl-lex.l"
796
ECHO;
797
        YY_BREAK
798
#line 799 "itbl-lex.c"
799
case YY_STATE_EOF(INITIAL):
800
        yyterminate();
801
 
802
        case YY_END_OF_BUFFER:
803
                {
804
                /* Amount of text matched not including the EOB char. */
805
                int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
806
 
807
                /* Undo the effects of YY_DO_BEFORE_ACTION. */
808
                *yy_cp = yy_hold_char;
809
                YY_RESTORE_YY_MORE_OFFSET
810
 
811
                if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
812
                        {
813
                        /* We're scanning a new file or input source.  It's
814
                         * possible that this happened because the user
815
                         * just pointed yyin at a new source and called
816
                         * yylex().  If so, then we have to assure
817
                         * consistency between yy_current_buffer and our
818
                         * globals.  Here is the right place to do so, because
819
                         * this is the first action (other than possibly a
820
                         * back-up) that will match for the new input source.
821
                         */
822
                        yy_n_chars = yy_current_buffer->yy_n_chars;
823
                        yy_current_buffer->yy_input_file = yyin;
824
                        yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
825
                        }
826
 
827
                /* Note that here we test for yy_c_buf_p "<=" to the position
828
                 * of the first EOB in the buffer, since yy_c_buf_p will
829
                 * already have been incremented past the NUL character
830
                 * (since all states make transitions on EOB to the
831
                 * end-of-buffer state).  Contrast this with the test
832
                 * in input().
833
                 */
834
                if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
835
                        { /* This was really a NUL. */
836
                        yy_state_type yy_next_state;
837
 
838
                        yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
839
 
840
                        yy_current_state = yy_get_previous_state();
841
 
842
                        /* Okay, we're now positioned to make the NUL
843
                         * transition.  We couldn't have
844
                         * yy_get_previous_state() go ahead and do it
845
                         * for us because it doesn't know how to deal
846
                         * with the possibility of jamming (and we don't
847
                         * want to build jamming into it because then it
848
                         * will run more slowly).
849
                         */
850
 
851
                        yy_next_state = yy_try_NUL_trans( yy_current_state );
852
 
853
                        yy_bp = yytext_ptr + YY_MORE_ADJ;
854
 
855
                        if ( yy_next_state )
856
                                {
857
                                /* Consume the NUL. */
858
                                yy_cp = ++yy_c_buf_p;
859
                                yy_current_state = yy_next_state;
860
                                goto yy_match;
861
                                }
862
 
863
                        else
864
                                {
865
                                yy_cp = yy_c_buf_p;
866
                                goto yy_find_action;
867
                                }
868
                        }
869
 
870
                else switch ( yy_get_next_buffer() )
871
                        {
872
                        case EOB_ACT_END_OF_FILE:
873
                                {
874
                                yy_did_buffer_switch_on_eof = 0;
875
 
876
                                if ( yywrap() )
877
                                        {
878
                                        /* Note: because we've taken care in
879
                                         * yy_get_next_buffer() to have set up
880
                                         * yytext, we can now set up
881
                                         * yy_c_buf_p so that if some total
882
                                         * hoser (like flex itself) wants to
883
                                         * call the scanner after we return the
884
                                         * YY_NULL, it'll still work - another
885
                                         * YY_NULL will get returned.
886
                                         */
887
                                        yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
888
 
889
                                        yy_act = YY_STATE_EOF(YY_START);
890
                                        goto do_action;
891
                                        }
892
 
893
                                else
894
                                        {
895
                                        if ( ! yy_did_buffer_switch_on_eof )
896
                                                YY_NEW_FILE;
897
                                        }
898
                                break;
899
                                }
900
 
901
                        case EOB_ACT_CONTINUE_SCAN:
902
                                yy_c_buf_p =
903
                                        yytext_ptr + yy_amount_of_matched_text;
904
 
905
                                yy_current_state = yy_get_previous_state();
906
 
907
                                yy_cp = yy_c_buf_p;
908
                                yy_bp = yytext_ptr + YY_MORE_ADJ;
909
                                goto yy_match;
910
 
911
                        case EOB_ACT_LAST_MATCH:
912
                                yy_c_buf_p =
913
                                &yy_current_buffer->yy_ch_buf[yy_n_chars];
914
 
915
                                yy_current_state = yy_get_previous_state();
916
 
917
                                yy_cp = yy_c_buf_p;
918
                                yy_bp = yytext_ptr + YY_MORE_ADJ;
919
                                goto yy_find_action;
920
                        }
921
                break;
922
                }
923
 
924
        default:
925
                YY_FATAL_ERROR(
926
                        "fatal flex scanner internal error--no action found" );
927
        } /* end of action switch */
928
                } /* end of scanning one token */
929
        } /* end of yylex */
930
 
931
 
932
/* yy_get_next_buffer - try to read in a new buffer
933
 *
934
 * Returns a code representing an action:
935
 *      EOB_ACT_LAST_MATCH -
936
 *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
937
 *      EOB_ACT_END_OF_FILE - end of file
938
 */
939
 
940
static int yy_get_next_buffer()
941
        {
942
        register char *dest = yy_current_buffer->yy_ch_buf;
943
        register char *source = yytext_ptr;
944
        register int number_to_move, i;
945
        int ret_val;
946
 
947
        if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
948
                YY_FATAL_ERROR(
949
                "fatal flex scanner internal error--end of buffer missed" );
950
 
951
        if ( yy_current_buffer->yy_fill_buffer == 0 )
952
                { /* Don't try to fill the buffer, so this is an EOF. */
953
                if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
954
                        {
955
                        /* We matched a single character, the EOB, so
956
                         * treat this as a final EOF.
957
                         */
958
                        return EOB_ACT_END_OF_FILE;
959
                        }
960
 
961
                else
962
                        {
963
                        /* We matched some text prior to the EOB, first
964
                         * process it.
965
                         */
966
                        return EOB_ACT_LAST_MATCH;
967
                        }
968
                }
969
 
970
        /* Try to read more data. */
971
 
972
        /* First move last chars to start of buffer. */
973
        number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
974
 
975
        for ( i = 0; i < number_to_move; ++i )
976
                *(dest++) = *(source++);
977
 
978
        if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
979
                /* don't do the read, it's not guaranteed to return an EOF,
980
                 * just force an EOF
981
                 */
982
                yy_current_buffer->yy_n_chars = yy_n_chars = 0;
983
 
984
        else
985
                {
986
                int num_to_read =
987
                        yy_current_buffer->yy_buf_size - number_to_move - 1;
988
 
989
                while ( num_to_read <= 0 )
990
                        { /* Not enough room in the buffer - grow it. */
991
#ifdef YY_USES_REJECT
992
                        YY_FATAL_ERROR(
993
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
994
#else
995
 
996
                        /* just a shorter name for the current buffer */
997
                        YY_BUFFER_STATE b = yy_current_buffer;
998
 
999
                        int yy_c_buf_p_offset =
1000
                                (int) (yy_c_buf_p - b->yy_ch_buf);
1001
 
1002
                        if ( b->yy_is_our_buffer )
1003
                                {
1004
                                int new_size = b->yy_buf_size * 2;
1005
 
1006
                                if ( new_size <= 0 )
1007
                                        b->yy_buf_size += b->yy_buf_size / 8;
1008
                                else
1009
                                        b->yy_buf_size *= 2;
1010
 
1011
                                b->yy_ch_buf = (char *)
1012
                                        /* Include room in for 2 EOB chars. */
1013
                                        yy_flex_realloc( (void *) b->yy_ch_buf,
1014
                                                         b->yy_buf_size + 2 );
1015
                                }
1016
                        else
1017
                                /* Can't grow it, we don't own it. */
1018
                                b->yy_ch_buf = 0;
1019
 
1020
                        if ( ! b->yy_ch_buf )
1021
                                YY_FATAL_ERROR(
1022
                                "fatal error - scanner input buffer overflow" );
1023
 
1024
                        yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1025
 
1026
                        num_to_read = yy_current_buffer->yy_buf_size -
1027
                                                number_to_move - 1;
1028
#endif
1029
                        }
1030
 
1031
                if ( num_to_read > YY_READ_BUF_SIZE )
1032
                        num_to_read = YY_READ_BUF_SIZE;
1033
 
1034
                /* Read in more data. */
1035
                YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1036
                        yy_n_chars, num_to_read );
1037
 
1038
                yy_current_buffer->yy_n_chars = yy_n_chars;
1039
                }
1040
 
1041
        if ( yy_n_chars == 0 )
1042
                {
1043
                if ( number_to_move == YY_MORE_ADJ )
1044
                        {
1045
                        ret_val = EOB_ACT_END_OF_FILE;
1046
                        yyrestart( yyin );
1047
                        }
1048
 
1049
                else
1050
                        {
1051
                        ret_val = EOB_ACT_LAST_MATCH;
1052
                        yy_current_buffer->yy_buffer_status =
1053
                                YY_BUFFER_EOF_PENDING;
1054
                        }
1055
                }
1056
 
1057
        else
1058
                ret_val = EOB_ACT_CONTINUE_SCAN;
1059
 
1060
        yy_n_chars += number_to_move;
1061
        yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1062
        yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1063
 
1064
        yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1065
 
1066
        return ret_val;
1067
        }
1068
 
1069
 
1070
/* yy_get_previous_state - get the state just before the EOB char was reached */
1071
 
1072
static yy_state_type yy_get_previous_state()
1073
        {
1074
        register yy_state_type yy_current_state;
1075
        register char *yy_cp;
1076
 
1077
        yy_current_state = yy_start;
1078
 
1079
        for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1080
                {
1081
                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1082
                if ( yy_accept[yy_current_state] )
1083
                        {
1084
                        yy_last_accepting_state = yy_current_state;
1085
                        yy_last_accepting_cpos = yy_cp;
1086
                        }
1087
                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1088
                        {
1089
                        yy_current_state = (int) yy_def[yy_current_state];
1090
                        if ( yy_current_state >= 60 )
1091
                                yy_c = yy_meta[(unsigned int) yy_c];
1092
                        }
1093
                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1094
                }
1095
 
1096
        return yy_current_state;
1097
        }
1098
 
1099
 
1100
/* yy_try_NUL_trans - try to make a transition on the NUL character
1101
 *
1102
 * synopsis
1103
 *      next_state = yy_try_NUL_trans( current_state );
1104
 */
1105
 
1106
#ifdef YY_USE_PROTOS
1107
static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1108
#else
1109
static yy_state_type yy_try_NUL_trans( yy_current_state )
1110
yy_state_type yy_current_state;
1111
#endif
1112
        {
1113
        register int yy_is_jam;
1114
        register char *yy_cp = yy_c_buf_p;
1115
 
1116
        register YY_CHAR yy_c = 1;
1117
        if ( yy_accept[yy_current_state] )
1118
                {
1119
                yy_last_accepting_state = yy_current_state;
1120
                yy_last_accepting_cpos = yy_cp;
1121
                }
1122
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1123
                {
1124
                yy_current_state = (int) yy_def[yy_current_state];
1125
                if ( yy_current_state >= 60 )
1126
                        yy_c = yy_meta[(unsigned int) yy_c];
1127
                }
1128
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1129
        yy_is_jam = (yy_current_state == 59);
1130
 
1131
        return yy_is_jam ? 0 : yy_current_state;
1132
        }
1133
 
1134
 
1135
#ifndef YY_NO_UNPUT
1136
#ifdef YY_USE_PROTOS
1137
static void yyunput( int c, register char *yy_bp )
1138
#else
1139
static void yyunput( c, yy_bp )
1140
int c;
1141
register char *yy_bp;
1142
#endif
1143
        {
1144
        register char *yy_cp = yy_c_buf_p;
1145
 
1146
        /* undo effects of setting up yytext */
1147
        *yy_cp = yy_hold_char;
1148
 
1149
        if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1150
                { /* need to shift things up to make room */
1151
                /* +2 for EOB chars. */
1152
                register int number_to_move = yy_n_chars + 2;
1153
                register char *dest = &yy_current_buffer->yy_ch_buf[
1154
                                        yy_current_buffer->yy_buf_size + 2];
1155
                register char *source =
1156
                                &yy_current_buffer->yy_ch_buf[number_to_move];
1157
 
1158
                while ( source > yy_current_buffer->yy_ch_buf )
1159
                        *--dest = *--source;
1160
 
1161
                yy_cp += (int) (dest - source);
1162
                yy_bp += (int) (dest - source);
1163
                yy_current_buffer->yy_n_chars =
1164
                        yy_n_chars = yy_current_buffer->yy_buf_size;
1165
 
1166
                if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1167
                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
1168
                }
1169
 
1170
        *--yy_cp = (char) c;
1171
 
1172
 
1173
        yytext_ptr = yy_bp;
1174
        yy_hold_char = *yy_cp;
1175
        yy_c_buf_p = yy_cp;
1176
        }
1177
#endif  /* ifndef YY_NO_UNPUT */
1178
 
1179
 
1180
#ifndef YY_NO_INPUT
1181
#ifdef __cplusplus
1182
static int yyinput()
1183
#else
1184
static int input()
1185
#endif
1186
        {
1187
        int c;
1188
 
1189
        *yy_c_buf_p = yy_hold_char;
1190
 
1191
        if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1192
                {
1193
                /* yy_c_buf_p now points to the character we want to return.
1194
                 * If this occurs *before* the EOB characters, then it's a
1195
                 * valid NUL; if not, then we've hit the end of the buffer.
1196
                 */
1197
                if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1198
                        /* This was really a NUL. */
1199
                        *yy_c_buf_p = '\0';
1200
 
1201
                else
1202
                        { /* need more input */
1203
                        int offset = yy_c_buf_p - yytext_ptr;
1204
                        ++yy_c_buf_p;
1205
 
1206
                        switch ( yy_get_next_buffer() )
1207
                                {
1208
                                case EOB_ACT_LAST_MATCH:
1209
                                        /* This happens because yy_g_n_b()
1210
                                         * sees that we've accumulated a
1211
                                         * token and flags that we need to
1212
                                         * try matching the token before
1213
                                         * proceeding.  But for input(),
1214
                                         * there's no matching to consider.
1215
                                         * So convert the EOB_ACT_LAST_MATCH
1216
                                         * to EOB_ACT_END_OF_FILE.
1217
                                         */
1218
 
1219
                                        /* Reset buffer status. */
1220
                                        yyrestart( yyin );
1221
 
1222
                                        /* fall through */
1223
 
1224
                                case EOB_ACT_END_OF_FILE:
1225
                                        {
1226
                                        if ( yywrap() )
1227
                                                return EOF;
1228
 
1229
                                        if ( ! yy_did_buffer_switch_on_eof )
1230
                                                YY_NEW_FILE;
1231
#ifdef __cplusplus
1232
                                        return yyinput();
1233
#else
1234
                                        return input();
1235
#endif
1236
                                        }
1237
 
1238
                                case EOB_ACT_CONTINUE_SCAN:
1239
                                        yy_c_buf_p = yytext_ptr + offset;
1240
                                        break;
1241
                                }
1242
                        }
1243
                }
1244
 
1245
        c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1246
        *yy_c_buf_p = '\0';     /* preserve yytext */
1247
        yy_hold_char = *++yy_c_buf_p;
1248
 
1249
 
1250
        return c;
1251
        }
1252
#endif /* YY_NO_INPUT */
1253
 
1254
#ifdef YY_USE_PROTOS
1255
void yyrestart( FILE *input_file )
1256
#else
1257
void yyrestart( input_file )
1258
FILE *input_file;
1259
#endif
1260
        {
1261
        if ( ! yy_current_buffer )
1262
                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1263
 
1264
        yy_init_buffer( yy_current_buffer, input_file );
1265
        yy_load_buffer_state();
1266
        }
1267
 
1268
 
1269
#ifdef YY_USE_PROTOS
1270
void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1271
#else
1272
void yy_switch_to_buffer( new_buffer )
1273
YY_BUFFER_STATE new_buffer;
1274
#endif
1275
        {
1276
        if ( yy_current_buffer == new_buffer )
1277
                return;
1278
 
1279
        if ( yy_current_buffer )
1280
                {
1281
                /* Flush out information for old buffer. */
1282
                *yy_c_buf_p = yy_hold_char;
1283
                yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1284
                yy_current_buffer->yy_n_chars = yy_n_chars;
1285
                }
1286
 
1287
        yy_current_buffer = new_buffer;
1288
        yy_load_buffer_state();
1289
 
1290
        /* We don't actually know whether we did this switch during
1291
         * EOF (yywrap()) processing, but the only time this flag
1292
         * is looked at is after yywrap() is called, so it's safe
1293
         * to go ahead and always set it.
1294
         */
1295
        yy_did_buffer_switch_on_eof = 1;
1296
        }
1297
 
1298
 
1299
#ifdef YY_USE_PROTOS
1300
void yy_load_buffer_state( void )
1301
#else
1302
void yy_load_buffer_state()
1303
#endif
1304
        {
1305
        yy_n_chars = yy_current_buffer->yy_n_chars;
1306
        yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1307
        yyin = yy_current_buffer->yy_input_file;
1308
        yy_hold_char = *yy_c_buf_p;
1309
        }
1310
 
1311
 
1312
#ifdef YY_USE_PROTOS
1313
YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1314
#else
1315
YY_BUFFER_STATE yy_create_buffer( file, size )
1316
FILE *file;
1317
int size;
1318
#endif
1319
        {
1320
        YY_BUFFER_STATE b;
1321
 
1322
        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1323
        if ( ! b )
1324
                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1325
 
1326
        b->yy_buf_size = size;
1327
 
1328
        /* yy_ch_buf has to be 2 characters longer than the size given because
1329
         * we need to put in 2 end-of-buffer characters.
1330
         */
1331
        b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1332
        if ( ! b->yy_ch_buf )
1333
                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1334
 
1335
        b->yy_is_our_buffer = 1;
1336
 
1337
        yy_init_buffer( b, file );
1338
 
1339
        return b;
1340
        }
1341
 
1342
 
1343
#ifdef YY_USE_PROTOS
1344
void yy_delete_buffer( YY_BUFFER_STATE b )
1345
#else
1346
void yy_delete_buffer( b )
1347
YY_BUFFER_STATE b;
1348
#endif
1349
        {
1350
        if ( ! b )
1351
                return;
1352
 
1353
        if ( b == yy_current_buffer )
1354
                yy_current_buffer = (YY_BUFFER_STATE) 0;
1355
 
1356
        if ( b->yy_is_our_buffer )
1357
                yy_flex_free( (void *) b->yy_ch_buf );
1358
 
1359
        yy_flex_free( (void *) b );
1360
        }
1361
 
1362
 
1363
 
1364
#ifdef YY_USE_PROTOS
1365
void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1366
#else
1367
void yy_init_buffer( b, file )
1368
YY_BUFFER_STATE b;
1369
FILE *file;
1370
#endif
1371
 
1372
 
1373
        {
1374
        yy_flush_buffer( b );
1375
 
1376
        b->yy_input_file = file;
1377
        b->yy_fill_buffer = 1;
1378
 
1379
#if YY_ALWAYS_INTERACTIVE
1380
        b->yy_is_interactive = 1;
1381
#else
1382
#if YY_NEVER_INTERACTIVE
1383
        b->yy_is_interactive = 0;
1384
#else
1385
        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1386
#endif
1387
#endif
1388
        }
1389
 
1390
 
1391
#ifdef YY_USE_PROTOS
1392
void yy_flush_buffer( YY_BUFFER_STATE b )
1393
#else
1394
void yy_flush_buffer( b )
1395
YY_BUFFER_STATE b;
1396
#endif
1397
 
1398
        {
1399
        if ( ! b )
1400
                return;
1401
 
1402
        b->yy_n_chars = 0;
1403
 
1404
        /* We always need two end-of-buffer characters.  The first causes
1405
         * a transition to the end-of-buffer state.  The second causes
1406
         * a jam in that state.
1407
         */
1408
        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1409
        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1410
 
1411
        b->yy_buf_pos = &b->yy_ch_buf[0];
1412
 
1413
        b->yy_at_bol = 1;
1414
        b->yy_buffer_status = YY_BUFFER_NEW;
1415
 
1416
        if ( b == yy_current_buffer )
1417
                yy_load_buffer_state();
1418
        }
1419
 
1420
 
1421
#ifndef YY_NO_SCAN_BUFFER
1422
#ifdef YY_USE_PROTOS
1423
YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1424
#else
1425
YY_BUFFER_STATE yy_scan_buffer( base, size )
1426
char *base;
1427
yy_size_t size;
1428
#endif
1429
        {
1430
        YY_BUFFER_STATE b;
1431
 
1432
        if ( size < 2 ||
1433
             base[size-2] != YY_END_OF_BUFFER_CHAR ||
1434
             base[size-1] != YY_END_OF_BUFFER_CHAR )
1435
                /* They forgot to leave room for the EOB's. */
1436
                return 0;
1437
 
1438
        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1439
        if ( ! b )
1440
                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1441
 
1442
        b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1443
        b->yy_buf_pos = b->yy_ch_buf = base;
1444
        b->yy_is_our_buffer = 0;
1445
        b->yy_input_file = 0;
1446
        b->yy_n_chars = b->yy_buf_size;
1447
        b->yy_is_interactive = 0;
1448
        b->yy_at_bol = 1;
1449
        b->yy_fill_buffer = 0;
1450
        b->yy_buffer_status = YY_BUFFER_NEW;
1451
 
1452
        yy_switch_to_buffer( b );
1453
 
1454
        return b;
1455
        }
1456
#endif
1457
 
1458
 
1459
#ifndef YY_NO_SCAN_STRING
1460
#ifdef YY_USE_PROTOS
1461
YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1462
#else
1463
YY_BUFFER_STATE yy_scan_string( yy_str )
1464
yyconst char *yy_str;
1465
#endif
1466
        {
1467
        int len;
1468
        for ( len = 0; yy_str[len]; ++len )
1469
                ;
1470
 
1471
        return yy_scan_bytes( yy_str, len );
1472
        }
1473
#endif
1474
 
1475
 
1476
#ifndef YY_NO_SCAN_BYTES
1477
#ifdef YY_USE_PROTOS
1478
YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1479
#else
1480
YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1481
yyconst char *bytes;
1482
int len;
1483
#endif
1484
        {
1485
        YY_BUFFER_STATE b;
1486
        char *buf;
1487
        yy_size_t n;
1488
        int i;
1489
 
1490
        /* Get memory for full buffer, including space for trailing EOB's. */
1491
        n = len + 2;
1492
        buf = (char *) yy_flex_alloc( n );
1493
        if ( ! buf )
1494
                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1495
 
1496
        for ( i = 0; i < len; ++i )
1497
                buf[i] = bytes[i];
1498
 
1499
        buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1500
 
1501
        b = yy_scan_buffer( buf, n );
1502
        if ( ! b )
1503
                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1504
 
1505
        /* It's okay to grow etc. this buffer, and we should throw it
1506
         * away when we're done.
1507
         */
1508
        b->yy_is_our_buffer = 1;
1509
 
1510
        return b;
1511
        }
1512
#endif
1513
 
1514
 
1515
#ifndef YY_NO_PUSH_STATE
1516
#ifdef YY_USE_PROTOS
1517
static void yy_push_state( int new_state )
1518
#else
1519
static void yy_push_state( new_state )
1520
int new_state;
1521
#endif
1522
        {
1523
        if ( yy_start_stack_ptr >= yy_start_stack_depth )
1524
                {
1525
                yy_size_t new_size;
1526
 
1527
                yy_start_stack_depth += YY_START_STACK_INCR;
1528
                new_size = yy_start_stack_depth * sizeof( int );
1529
 
1530
                if ( ! yy_start_stack )
1531
                        yy_start_stack = (int *) yy_flex_alloc( new_size );
1532
 
1533
                else
1534
                        yy_start_stack = (int *) yy_flex_realloc(
1535
                                        (void *) yy_start_stack, new_size );
1536
 
1537
                if ( ! yy_start_stack )
1538
                        YY_FATAL_ERROR(
1539
                        "out of memory expanding start-condition stack" );
1540
                }
1541
 
1542
        yy_start_stack[yy_start_stack_ptr++] = YY_START;
1543
 
1544
        BEGIN(new_state);
1545
        }
1546
#endif
1547
 
1548
 
1549
#ifndef YY_NO_POP_STATE
1550
static void yy_pop_state()
1551
        {
1552
        if ( --yy_start_stack_ptr < 0 )
1553
                YY_FATAL_ERROR( "start-condition stack underflow" );
1554
 
1555
        BEGIN(yy_start_stack[yy_start_stack_ptr]);
1556
        }
1557
#endif
1558
 
1559
 
1560
#ifndef YY_NO_TOP_STATE
1561
static int yy_top_state()
1562
        {
1563
        return yy_start_stack[yy_start_stack_ptr - 1];
1564
        }
1565
#endif
1566
 
1567
#ifndef YY_EXIT_FAILURE
1568
#define YY_EXIT_FAILURE 2
1569
#endif
1570
 
1571
#ifdef YY_USE_PROTOS
1572
static void yy_fatal_error( yyconst char msg[] )
1573
#else
1574
static void yy_fatal_error( msg )
1575
char msg[];
1576
#endif
1577
        {
1578
        (void) fprintf( stderr, "%s\n", msg );
1579
        exit( YY_EXIT_FAILURE );
1580
        }
1581
 
1582
 
1583
 
1584
/* Redefine yyless() so it works in section 3 code. */
1585
 
1586
#undef yyless
1587
#define yyless(n) \
1588
        do \
1589
                { \
1590
                /* Undo effects of setting up yytext. */ \
1591
                yytext[yyleng] = yy_hold_char; \
1592
                yy_c_buf_p = yytext + n; \
1593
                yy_hold_char = *yy_c_buf_p; \
1594
                *yy_c_buf_p = '\0'; \
1595
                yyleng = n; \
1596
                } \
1597
        while ( 0 )
1598
 
1599
 
1600
/* Internal utility routines. */
1601
 
1602
#ifndef yytext_ptr
1603
#ifdef YY_USE_PROTOS
1604
static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1605
#else
1606
static void yy_flex_strncpy( s1, s2, n )
1607
char *s1;
1608
yyconst char *s2;
1609
int n;
1610
#endif
1611
        {
1612
        register int i;
1613
        for ( i = 0; i < n; ++i )
1614
                s1[i] = s2[i];
1615
        }
1616
#endif
1617
 
1618
#ifdef YY_NEED_STRLEN
1619
#ifdef YY_USE_PROTOS
1620
static int yy_flex_strlen( yyconst char *s )
1621
#else
1622
static int yy_flex_strlen( s )
1623
yyconst char *s;
1624
#endif
1625
        {
1626
        register int n;
1627
        for ( n = 0; s[n]; ++n )
1628
                ;
1629
 
1630
        return n;
1631
        }
1632
#endif
1633
 
1634
 
1635
#ifdef YY_USE_PROTOS
1636
static void *yy_flex_alloc( yy_size_t size )
1637
#else
1638
static void *yy_flex_alloc( size )
1639
yy_size_t size;
1640
#endif
1641
        {
1642
        return (void *) malloc( size );
1643
        }
1644
 
1645
#ifdef YY_USE_PROTOS
1646
static void *yy_flex_realloc( void *ptr, yy_size_t size )
1647
#else
1648
static void *yy_flex_realloc( ptr, size )
1649
void *ptr;
1650
yy_size_t size;
1651
#endif
1652
        {
1653
        /* The cast to (char *) in the following accommodates both
1654
         * implementations that use char* generic pointers, and those
1655
         * that use void* generic pointers.  It works with the latter
1656
         * because both ANSI C and C++ allow castless assignment from
1657
         * any pointer type to void*, and deal with argument conversions
1658
         * as though doing an assignment.
1659
         */
1660
        return (void *) realloc( (char *) ptr, size );
1661
        }
1662
 
1663
#ifdef YY_USE_PROTOS
1664
static void yy_flex_free( void *ptr )
1665
#else
1666
static void yy_flex_free( ptr )
1667
void *ptr;
1668
#endif
1669
        {
1670
        free( ptr );
1671
        }
1672
 
1673
#if YY_MAIN
1674
int main()
1675
        {
1676
        yylex();
1677
        return 0;
1678
        }
1679
#endif
1680
#line 105 "itbl-lex.l"
1681
 
1682
 
1683
#ifndef yywrap
1684
int
1685
yywrap ()
1686
  {
1687
    return 1;
1688
  }
1689
#endif

powered by: WebSVN 2.1.0

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