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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [binutils/] [syslex.c] - Blame information for rev 818

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius
 
2
#line 3 "syslex.c"
3
 
4
#define  YY_INT_ALIGNED short int
5
 
6
/* A lexical scanner generated by flex */
7
 
8
#define FLEX_SCANNER
9
#define YY_FLEX_MAJOR_VERSION 2
10
#define YY_FLEX_MINOR_VERSION 5
11
#define YY_FLEX_SUBMINOR_VERSION 35
12
#if YY_FLEX_SUBMINOR_VERSION > 0
13
#define FLEX_BETA
14
#endif
15
 
16
/* First, we deal with  platform-specific or compiler-specific issues. */
17
 
18
/* begin standard C headers. */
19
#include <stdio.h>
20
#include <string.h>
21
#include <errno.h>
22
#include <stdlib.h>
23
 
24
/* end standard C headers. */
25
 
26
/* flex integer type definitions */
27
 
28
#ifndef FLEXINT_H
29
#define FLEXINT_H
30
 
31
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
32
 
33
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
34
 
35
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
36
 * if you want the limit (max/min) macros for int types.
37
 */
38
#ifndef __STDC_LIMIT_MACROS
39
#define __STDC_LIMIT_MACROS 1
40
#endif
41
 
42
#include <inttypes.h>
43
typedef int8_t flex_int8_t;
44
typedef uint8_t flex_uint8_t;
45
typedef int16_t flex_int16_t;
46
typedef uint16_t flex_uint16_t;
47
typedef int32_t flex_int32_t;
48
typedef uint32_t flex_uint32_t;
49
#else
50
typedef signed char flex_int8_t;
51
typedef short int flex_int16_t;
52
typedef int flex_int32_t;
53
typedef unsigned char flex_uint8_t;
54
typedef unsigned short int flex_uint16_t;
55
typedef unsigned int flex_uint32_t;
56
#endif /* ! C99 */
57
 
58
/* Limits of integral types. */
59
#ifndef INT8_MIN
60
#define INT8_MIN               (-128)
61
#endif
62
#ifndef INT16_MIN
63
#define INT16_MIN              (-32767-1)
64
#endif
65
#ifndef INT32_MIN
66
#define INT32_MIN              (-2147483647-1)
67
#endif
68
#ifndef INT8_MAX
69
#define INT8_MAX               (127)
70
#endif
71
#ifndef INT16_MAX
72
#define INT16_MAX              (32767)
73
#endif
74
#ifndef INT32_MAX
75
#define INT32_MAX              (2147483647)
76
#endif
77
#ifndef UINT8_MAX
78
#define UINT8_MAX              (255U)
79
#endif
80
#ifndef UINT16_MAX
81
#define UINT16_MAX             (65535U)
82
#endif
83
#ifndef UINT32_MAX
84
#define UINT32_MAX             (4294967295U)
85
#endif
86
 
87
#endif /* ! FLEXINT_H */
88
 
89
#ifdef __cplusplus
90
 
91
/* The "const" storage-class-modifier is valid. */
92
#define YY_USE_CONST
93
 
94
#else   /* ! __cplusplus */
95
 
96
/* C99 requires __STDC__ to be defined as 1. */
97
#if defined (__STDC__)
98
 
99
#define YY_USE_CONST
100
 
101
#endif  /* defined (__STDC__) */
102
#endif  /* ! __cplusplus */
103
 
104
#ifdef YY_USE_CONST
105
#define yyconst const
106
#else
107
#define yyconst
108
#endif
109
 
110
/* Returned upon end-of-file. */
111
#define YY_NULL 0
112
 
113
/* Promotes a possibly negative, possibly signed char to an unsigned
114
 * integer for use as an array index.  If the signed char is negative,
115
 * we want to instead treat it as an 8-bit unsigned char, hence the
116
 * double cast.
117
 */
118
#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
119
 
120
/* Enter a start condition.  This macro really ought to take a parameter,
121
 * but we do it the disgusting crufty way forced on us by the ()-less
122
 * definition of BEGIN.
123
 */
124
#define BEGIN (yy_start) = 1 + 2 *
125
 
126
/* Translate the current start state into a value that can be later handed
127
 * to BEGIN to return to the state.  The YYSTATE alias is for lex
128
 * compatibility.
129
 */
130
#define YY_START (((yy_start) - 1) / 2)
131
#define YYSTATE YY_START
132
 
133
/* Action number for EOF rule of a given start state. */
134
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
135
 
136
/* Special action meaning "start processing a new file". */
137
#define YY_NEW_FILE yyrestart(yyin  )
138
 
139
#define YY_END_OF_BUFFER_CHAR 0
140
 
141
/* Size of default input buffer. */
142
#ifndef YY_BUF_SIZE
143
#define YY_BUF_SIZE 16384
144
#endif
145
 
146
/* The state buf must be large enough to hold one state per character in the main buffer.
147
 */
148
#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
149
 
150
#ifndef YY_TYPEDEF_YY_BUFFER_STATE
151
#define YY_TYPEDEF_YY_BUFFER_STATE
152
typedef struct yy_buffer_state *YY_BUFFER_STATE;
153
#endif
154
 
155
#ifndef YY_TYPEDEF_YY_SIZE_T
156
#define YY_TYPEDEF_YY_SIZE_T
157
typedef size_t yy_size_t;
158
#endif
159
 
160
extern yy_size_t yyleng;
161
 
162
extern FILE *yyin, *yyout;
163
 
164
#define EOB_ACT_CONTINUE_SCAN 0
165
#define EOB_ACT_END_OF_FILE 1
166
#define EOB_ACT_LAST_MATCH 2
167
 
168
    #define YY_LESS_LINENO(n)
169
 
170
/* Return all but the first "n" matched characters back to the input stream. */
171
#define yyless(n) \
172
        do \
173
                { \
174
                /* Undo effects of setting up yytext. */ \
175
        int yyless_macro_arg = (n); \
176
        YY_LESS_LINENO(yyless_macro_arg);\
177
                *yy_cp = (yy_hold_char); \
178
                YY_RESTORE_YY_MORE_OFFSET \
179
                (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
180
                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
181
                } \
182
        while ( 0 )
183
 
184
#define unput(c) yyunput( c, (yytext_ptr)  )
185
 
186
#ifndef YY_STRUCT_YY_BUFFER_STATE
187
#define YY_STRUCT_YY_BUFFER_STATE
188
struct yy_buffer_state
189
        {
190
        FILE *yy_input_file;
191
 
192
        char *yy_ch_buf;                /* input buffer */
193
        char *yy_buf_pos;               /* current position in input buffer */
194
 
195
        /* Size of input buffer in bytes, not including room for EOB
196
         * characters.
197
         */
198
        yy_size_t yy_buf_size;
199
 
200
        /* Number of characters read into yy_ch_buf, not including EOB
201
         * characters.
202
         */
203
        yy_size_t yy_n_chars;
204
 
205
        /* Whether we "own" the buffer - i.e., we know we created it,
206
         * and can realloc() it to grow it, and should free() it to
207
         * delete it.
208
         */
209
        int yy_is_our_buffer;
210
 
211
        /* Whether this is an "interactive" input source; if so, and
212
         * if we're using stdio for input, then we want to use getc()
213
         * instead of fread(), to make sure we stop fetching input after
214
         * each newline.
215
         */
216
        int yy_is_interactive;
217
 
218
        /* Whether we're considered to be at the beginning of a line.
219
         * If so, '^' rules will be active on the next match, otherwise
220
         * not.
221
         */
222
        int yy_at_bol;
223
 
224
    int yy_bs_lineno; /**< The line count. */
225
    int yy_bs_column; /**< The column count. */
226
 
227
        /* Whether to try to fill the input buffer when we reach the
228
         * end of it.
229
         */
230
        int yy_fill_buffer;
231
 
232
        int yy_buffer_status;
233
 
234
#define YY_BUFFER_NEW 0
235
#define YY_BUFFER_NORMAL 1
236
        /* When an EOF's been seen but there's still some text to process
237
         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
238
         * shouldn't try reading from the input source any more.  We might
239
         * still have a bunch of tokens to match, though, because of
240
         * possible backing-up.
241
         *
242
         * When we actually see the EOF, we change the status to "new"
243
         * (via yyrestart()), so that the user can continue scanning by
244
         * just pointing yyin at a new input file.
245
         */
246
#define YY_BUFFER_EOF_PENDING 2
247
 
248
        };
249
#endif /* !YY_STRUCT_YY_BUFFER_STATE */
250
 
251
/* Stack of input buffers. */
252
static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
253
static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
254
static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
255
 
256
/* We provide macros for accessing buffer states in case in the
257
 * future we want to put the buffer states in a more general
258
 * "scanner state".
259
 *
260
 * Returns the top of the stack, or NULL.
261
 */
262
#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
263
                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
264
                          : NULL)
265
 
266
/* Same as previous macro, but useful when we know that the buffer stack is not
267
 * NULL or when we need an lvalue. For internal use only.
268
 */
269
#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
270
 
271
/* yy_hold_char holds the character lost when yytext is formed. */
272
static char yy_hold_char;
273
static yy_size_t yy_n_chars;            /* number of characters read into yy_ch_buf */
274
yy_size_t yyleng;
275
 
276
/* Points to current character in buffer. */
277
static char *yy_c_buf_p = (char *) 0;
278
static int yy_init = 0;          /* whether we need to initialize */
279
static int yy_start = 0; /* start state number */
280
 
281
/* Flag which is used to allow yywrap()'s to do buffer switches
282
 * instead of setting up a fresh yyin.  A bit of a hack ...
283
 */
284
static int yy_did_buffer_switch_on_eof;
285
 
286
void yyrestart (FILE *input_file  );
287
void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
288
YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
289
void yy_delete_buffer (YY_BUFFER_STATE b  );
290
void yy_flush_buffer (YY_BUFFER_STATE b  );
291
void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
292
void yypop_buffer_state (void );
293
 
294
static void yyensure_buffer_stack (void );
295
static void yy_load_buffer_state (void );
296
static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
297
 
298
#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
299
 
300
YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
301
YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
302
YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len  );
303
 
304
void *yyalloc (yy_size_t  );
305
void *yyrealloc (void *,yy_size_t  );
306
void yyfree (void *  );
307
 
308
#define yy_new_buffer yy_create_buffer
309
 
310
#define yy_set_interactive(is_interactive) \
311
        { \
312
        if ( ! YY_CURRENT_BUFFER ){ \
313
        yyensure_buffer_stack (); \
314
                YY_CURRENT_BUFFER_LVALUE =    \
315
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
316
        } \
317
        YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
318
        }
319
 
320
#define yy_set_bol(at_bol) \
321
        { \
322
        if ( ! YY_CURRENT_BUFFER ){\
323
        yyensure_buffer_stack (); \
324
                YY_CURRENT_BUFFER_LVALUE =    \
325
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
326
        } \
327
        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
328
        }
329
 
330
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
331
 
332
typedef unsigned char YY_CHAR;
333
 
334
FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
335
 
336
typedef int yy_state_type;
337
 
338
extern int yylineno;
339
 
340
int yylineno = 1;
341
 
342
extern char *yytext;
343
#define yytext_ptr yytext
344
 
345
static yy_state_type yy_get_previous_state (void );
346
static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
347
static int yy_get_next_buffer (void );
348
static void yy_fatal_error (yyconst char msg[]  );
349
 
350
/* Done after the current pattern has been matched and before the
351
 * corresponding action - sets up yytext.
352
 */
353
#define YY_DO_BEFORE_ACTION \
354
        (yytext_ptr) = yy_bp; \
355
        yyleng = (size_t) (yy_cp - yy_bp); \
356
        (yy_hold_char) = *yy_cp; \
357
        *yy_cp = '\0'; \
358
        (yy_c_buf_p) = yy_cp;
359
 
360
#define YY_NUM_RULES 25
361
#define YY_END_OF_BUFFER 26
362
/* This struct is not used in this scanner,
363
   but its presence is necessary. */
364
struct yy_trans_info
365
        {
366
        flex_int32_t yy_verify;
367
        flex_int32_t yy_nxt;
368
        };
369
static yyconst flex_int16_t yy_accept[81] =
370
    {   0,
371
        0,    0,   26,   25,    7,    8,    5,   25,    1,    2,
372
       11,   11,    6,    3,    4,   25,   25,   25,   25,   25,
373
       25,   25,    0,    9,   11,    0,    6,    0,    0,    0,
374
        0,    0,    0,    0,    0,    0,    0,   10,    0,    0,
375
       13,    0,    0,    0,    0,   16,    0,    0,    0,    0,
376
        0,   12,   15,    0,   23,    0,    0,    0,    0,    0,
377
        0,   14,   18,    0,    0,    0,    0,    0,   17,    0,
378
       24,    0,    0,    0,   20,   22,    0,   21,   19,    0
379
    } ;
380
 
381
static yyconst flex_int32_t yy_ec[256] =
382
    {   0,
383
        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
384
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
385
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
386
        1,    4,    1,    5,    1,    1,    1,    1,    1,    6,
387
        7,    1,    1,    1,    1,    1,    1,    8,    9,    9,
388
        9,    9,    9,    9,    9,    9,    9,    1,   10,    1,
389
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
390
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
391
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
392
       11,    1,   12,    1,    1,    1,   13,   14,   15,   16,
393
 
394
       17,   18,   19,   20,   21,    1,    1,   22,    1,   23,
395
       24,   25,    1,   26,   27,   28,   29,   30,    1,   31,
396
       32,   33,    1,    1,    1,    1,    1,    1,    1,    1,
397
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
398
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
399
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
400
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
401
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
402
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
403
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
404
 
405
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
406
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
407
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
408
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
409
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
410
        1,    1,    1,    1,    1
411
    } ;
412
 
413
static yyconst flex_int32_t yy_meta[34] =
414
    {   0,
415
        1,    1,    2,    1,    1,    1,    1,    3,    3,    1,
416
        1,    1,    3,    3,    3,    3,    3,    3,    1,    1,
417
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
418
        1,    1,    1
419
    } ;
420
 
421
static yyconst flex_int16_t yy_base[84] =
422
    {   0,
423
        0,    0,  100,  101,  101,  101,  101,   94,  101,  101,
424
       26,   28,    0,  101,  101,   82,   26,   18,   74,   79,
425
       78,   81,   88,  101,   32,    0,    0,   76,   65,   62,
426
       61,   75,   20,   59,   61,   66,   58,    0,   57,   56,
427
       54,   63,   53,   62,   54,  101,   59,   48,   53,   46,
428
       59,  101,   44,   43,  101,   41,   55,   46,   53,   44,
429
       31,  101,  101,   39,   27,   21,   39,   19,  101,   35,
430
      101,   33,   26,   29,  101,  101,   28,  101,  101,  101,
431
       58,   61,   41
432
    } ;
433
 
434
static yyconst flex_int16_t yy_def[84] =
435
    {   0,
436
       80,    1,   80,   80,   80,   80,   80,   81,   80,   80,
437
       80,   80,   82,   80,   80,   80,   80,   80,   80,   80,
438
       80,   80,   81,   80,   80,   83,   82,   80,   80,   80,
439
       80,   80,   80,   80,   80,   80,   80,   83,   80,   80,
440
       80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
441
       80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
442
       80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
443
       80,   80,   80,   80,   80,   80,   80,   80,   80,    0,
444
       80,   80,   80
445
    } ;
446
 
447
static yyconst flex_int16_t yy_nxt[135] =
448
    {   0,
449
        4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
450
       14,   15,   16,   17,   18,    4,    4,    4,    4,    4,
451
       19,    4,    4,    4,    4,   20,   21,    4,    4,   22,
452
        4,    4,    4,   25,   25,   25,   25,   32,   29,   25,
453
       25,   33,   44,   38,   79,   78,   30,   77,   45,   76,
454
       75,   74,   73,   72,   71,   70,   26,   31,   23,   23,
455
       23,   27,   69,   27,   68,   67,   66,   65,   64,   63,
456
       62,   61,   60,   59,   58,   57,   56,   55,   54,   53,
457
       52,   51,   50,   49,   48,   47,   46,   43,   42,   41,
458
       40,   39,   24,   37,   36,   35,   34,   28,   24,   80,
459
 
460
        3,   80,   80,   80,   80,   80,   80,   80,   80,   80,
461
       80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
462
       80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
463
       80,   80,   80,   80
464
    } ;
465
 
466
static yyconst flex_int16_t yy_chk[135] =
467
    {   0,
468
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
469
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
470
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
471
        1,    1,    1,   11,   11,   12,   12,   18,   17,   25,
472
       25,   18,   33,   83,   77,   74,   17,   73,   33,   72,
473
       70,   68,   67,   66,   65,   64,   11,   17,   81,   81,
474
       81,   82,   61,   82,   60,   59,   58,   57,   56,   54,
475
       53,   51,   50,   49,   48,   47,   45,   44,   43,   42,
476
       41,   40,   39,   37,   36,   35,   34,   32,   31,   30,
477
       29,   28,   23,   22,   21,   20,   19,   16,    8,    3,
478
 
479
       80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
480
       80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
481
       80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
482
       80,   80,   80,   80
483
    } ;
484
 
485
static yy_state_type yy_last_accepting_state;
486
static char *yy_last_accepting_cpos;
487
 
488
extern int yy_flex_debug;
489
int yy_flex_debug = 0;
490
 
491
/* The intent behind this definition is that it'll catch
492
 * any uses of REJECT which flex missed.
493
 */
494
#define REJECT reject_used_but_not_detected
495
#define yymore() yymore_used_but_not_detected
496
#define YY_MORE_ADJ 0
497
#define YY_RESTORE_YY_MORE_OFFSET
498
char *yytext;
499
#line 1 "syslex.l"
500
#line 2 "syslex.l"
501
/* Copyright 2001, 2003, 2005, 2007 Free Software Foundation, Inc.
502
 
503
   This file is part of GNU Binutils.
504
 
505
   This program is free software; you can redistribute it and/or modify
506
   it under the terms of the GNU General Public License as published by
507
   the Free Software Foundation; either version 3, or (at your option)
508
   any later version.
509
 
510
   This program is distributed in the hope that it will be useful,
511
   but WITHOUT ANY WARRANTY; without even the implied warranty of
512
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
513
   GNU General Public License for more details.
514
 
515
   You should have received a copy of the GNU General Public License
516
   along with GLD; see the file COPYING.  If not, write to the Free
517
   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
518
   02110-1301, USA.  */
519
 
520
#include "config.h"
521
#ifdef HAVE_STRING_H
522
#include <string.h>
523
#else
524
#ifdef HAVE_STRINGS_H
525
#include <strings.h>
526
#endif
527
#endif
528
#include "sysinfo.h"
529
 
530
#define YY_NO_UNPUT
531
 
532
#ifndef yywrap
533
static int yywrap (void) { return 1; }
534
#endif
535
 
536
extern int yylex (void);
537
#line 538 "syslex.c"
538
 
539
#define INITIAL 0
540
 
541
#ifndef YY_NO_UNISTD_H
542
/* Special case for "unistd.h", since it is non-ANSI. We include it way
543
 * down here because we want the user's section 1 to have been scanned first.
544
 * The user has a chance to override it with an option.
545
 */
546
#include <unistd.h>
547
#endif
548
 
549
#ifndef YY_EXTRA_TYPE
550
#define YY_EXTRA_TYPE void *
551
#endif
552
 
553
static int yy_init_globals (void );
554
 
555
/* Accessor methods to globals.
556
   These are made visible to non-reentrant scanners for convenience. */
557
 
558
int yylex_destroy (void );
559
 
560
int yyget_debug (void );
561
 
562
void yyset_debug (int debug_flag  );
563
 
564
YY_EXTRA_TYPE yyget_extra (void );
565
 
566
void yyset_extra (YY_EXTRA_TYPE user_defined  );
567
 
568
FILE *yyget_in (void );
569
 
570
void yyset_in  (FILE * in_str  );
571
 
572
FILE *yyget_out (void );
573
 
574
void yyset_out  (FILE * out_str  );
575
 
576
yy_size_t yyget_leng (void );
577
 
578
char *yyget_text (void );
579
 
580
int yyget_lineno (void );
581
 
582
void yyset_lineno (int line_number  );
583
 
584
/* Macros after this point can all be overridden by user definitions in
585
 * section 1.
586
 */
587
 
588
#ifndef YY_SKIP_YYWRAP
589
#ifdef __cplusplus
590
extern "C" int yywrap (void );
591
#else
592
extern int yywrap (void );
593
#endif
594
#endif
595
 
596
    static void yyunput (int c,char *buf_ptr  );
597
 
598
#ifndef yytext_ptr
599
static void yy_flex_strncpy (char *,yyconst char *,int );
600
#endif
601
 
602
#ifdef YY_NEED_STRLEN
603
static int yy_flex_strlen (yyconst char * );
604
#endif
605
 
606
#ifndef YY_NO_INPUT
607
 
608
#ifdef __cplusplus
609
static int yyinput (void );
610
#else
611
static int input (void );
612
#endif
613
 
614
#endif
615
 
616
/* Amount of stuff to slurp up with each read. */
617
#ifndef YY_READ_BUF_SIZE
618
#define YY_READ_BUF_SIZE 8192
619
#endif
620
 
621
/* Copy whatever the last rule matched to the standard output. */
622
#ifndef ECHO
623
/* This used to be an fputs(), but since the string might contain NUL's,
624
 * we now use fwrite().
625
 */
626
#define ECHO fwrite( yytext, yyleng, 1, yyout )
627
#endif
628
 
629
/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
630
 * is returned in "result".
631
 */
632
#ifndef YY_INPUT
633
#define YY_INPUT(buf,result,max_size) \
634
        if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
635
                { \
636
                int c = '*'; \
637
                yy_size_t n; \
638
                for ( n = 0; n < max_size && \
639
                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
640
                        buf[n] = (char) c; \
641
                if ( c == '\n' ) \
642
                        buf[n++] = (char) c; \
643
                if ( c == EOF && ferror( yyin ) ) \
644
                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
645
                result = n; \
646
                } \
647
        else \
648
                { \
649
                errno=0; \
650
                while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
651
                        { \
652
                        if( errno != EINTR) \
653
                                { \
654
                                YY_FATAL_ERROR( "input in flex scanner failed" ); \
655
                                break; \
656
                                } \
657
                        errno=0; \
658
                        clearerr(yyin); \
659
                        } \
660
                }\
661
\
662
 
663
#endif
664
 
665
/* No semi-colon after return; correct usage is to write "yyterminate();" -
666
 * we don't want an extra ';' after the "return" because that will cause
667
 * some compilers to complain about unreachable statements.
668
 */
669
#ifndef yyterminate
670
#define yyterminate() return YY_NULL
671
#endif
672
 
673
/* Number of entries by which start-condition stack grows. */
674
#ifndef YY_START_STACK_INCR
675
#define YY_START_STACK_INCR 25
676
#endif
677
 
678
/* Report a fatal error. */
679
#ifndef YY_FATAL_ERROR
680
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
681
#endif
682
 
683
/* end tables serialization structures and prototypes */
684
 
685
/* Default declaration of generated scanner - a define so the user can
686
 * easily add parameters.
687
 */
688
#ifndef YY_DECL
689
#define YY_DECL_IS_OURS 1
690
 
691
extern int yylex (void);
692
 
693
#define YY_DECL int yylex (void)
694
#endif /* !YY_DECL */
695
 
696
/* Code executed at the beginning of each rule, after yytext and yyleng
697
 * have been set up.
698
 */
699
#ifndef YY_USER_ACTION
700
#define YY_USER_ACTION
701
#endif
702
 
703
/* Code executed at the end of each rule. */
704
#ifndef YY_BREAK
705
#define YY_BREAK break;
706
#endif
707
 
708
#define YY_RULE_SETUP \
709
        YY_USER_ACTION
710
 
711
/** The main scanner function which does all the work.
712
 */
713
YY_DECL
714
{
715
        register yy_state_type yy_current_state;
716
        register char *yy_cp, *yy_bp;
717
        register int yy_act;
718
 
719
#line 39 "syslex.l"
720
 
721
#line 722 "syslex.c"
722
 
723
        if ( !(yy_init) )
724
                {
725
                (yy_init) = 1;
726
 
727
#ifdef YY_USER_INIT
728
                YY_USER_INIT;
729
#endif
730
 
731
                if ( ! (yy_start) )
732
                        (yy_start) = 1; /* first start state */
733
 
734
                if ( ! yyin )
735
                        yyin = stdin;
736
 
737
                if ( ! yyout )
738
                        yyout = stdout;
739
 
740
                if ( ! YY_CURRENT_BUFFER ) {
741
                        yyensure_buffer_stack ();
742
                        YY_CURRENT_BUFFER_LVALUE =
743
                                yy_create_buffer(yyin,YY_BUF_SIZE );
744
                }
745
 
746
                yy_load_buffer_state( );
747
                }
748
 
749
        while ( 1 )             /* loops until end-of-file is reached */
750
                {
751
                yy_cp = (yy_c_buf_p);
752
 
753
                /* Support of yytext. */
754
                *yy_cp = (yy_hold_char);
755
 
756
                /* yy_bp points to the position in yy_ch_buf of the start of
757
                 * the current run.
758
                 */
759
                yy_bp = yy_cp;
760
 
761
                yy_current_state = (yy_start);
762
yy_match:
763
                do
764
                        {
765
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
766
                        if ( yy_accept[yy_current_state] )
767
                                {
768
                                (yy_last_accepting_state) = yy_current_state;
769
                                (yy_last_accepting_cpos) = yy_cp;
770
                                }
771
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
772
                                {
773
                                yy_current_state = (int) yy_def[yy_current_state];
774
                                if ( yy_current_state >= 81 )
775
                                        yy_c = yy_meta[(unsigned int) yy_c];
776
                                }
777
                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
778
                        ++yy_cp;
779
                        }
780
                while ( yy_base[yy_current_state] != 101 );
781
 
782
yy_find_action:
783
                yy_act = yy_accept[yy_current_state];
784
                if ( yy_act == 0 )
785
                        { /* have to back up */
786
                        yy_cp = (yy_last_accepting_cpos);
787
                        yy_current_state = (yy_last_accepting_state);
788
                        yy_act = yy_accept[yy_current_state];
789
                        }
790
 
791
                YY_DO_BEFORE_ACTION;
792
 
793
do_action:      /* This label is used only to access EOF actions. */
794
 
795
                switch ( yy_act )
796
        { /* beginning of action switch */
797
                        case 0: /* must back up */
798
                        /* undo the effects of YY_DO_BEFORE_ACTION */
799
                        *yy_cp = (yy_hold_char);
800
                        yy_cp = (yy_last_accepting_cpos);
801
                        yy_current_state = (yy_last_accepting_state);
802
                        goto yy_find_action;
803
 
804
case 1:
805
YY_RULE_SETUP
806
#line 40 "syslex.l"
807
{ return '(';}
808
        YY_BREAK
809
case 2:
810
YY_RULE_SETUP
811
#line 41 "syslex.l"
812
{ return ')';}
813
        YY_BREAK
814
case 3:
815
YY_RULE_SETUP
816
#line 42 "syslex.l"
817
{ return '[';}
818
        YY_BREAK
819
case 4:
820
YY_RULE_SETUP
821
#line 43 "syslex.l"
822
{ return ']';}
823
        YY_BREAK
824
case 5:
825
YY_RULE_SETUP
826
#line 44 "syslex.l"
827
{ ; }
828
        YY_BREAK
829
case 6:
830
YY_RULE_SETUP
831
#line 45 "syslex.l"
832
{ ; }
833
        YY_BREAK
834
case 7:
835
YY_RULE_SETUP
836
#line 46 "syslex.l"
837
{ ; }
838
        YY_BREAK
839
case 8:
840
/* rule 8 can match eol */
841
YY_RULE_SETUP
842
#line 47 "syslex.l"
843
{ ; }
844
        YY_BREAK
845
case 9:
846
/* rule 9 can match eol */
847
YY_RULE_SETUP
848
#line 48 "syslex.l"
849
{
850
        yylval.s = malloc (yyleng - 1);
851
        memcpy (yylval.s, yytext + 1, yyleng - 2);
852
        yylval.s[yyleng - 2] = '\0';
853
        return NAME;
854
        }
855
        YY_BREAK
856
case 10:
857
YY_RULE_SETUP
858
#line 55 "syslex.l"
859
{
860
        yylval.i = strtol(yytext,0,16);
861
        return  NUMBER;
862
        }
863
        YY_BREAK
864
case 11:
865
YY_RULE_SETUP
866
#line 60 "syslex.l"
867
{
868
        yylval.i = atoi(yytext);
869
        return  NUMBER;
870
        }
871
        YY_BREAK
872
case 12:
873
YY_RULE_SETUP
874
#line 66 "syslex.l"
875
{ yylval.i =1 ;return UNIT;}
876
        YY_BREAK
877
case 13:
878
YY_RULE_SETUP
879
#line 67 "syslex.l"
880
{ yylval.i = 1; return UNIT;}
881
        YY_BREAK
882
case 14:
883
YY_RULE_SETUP
884
#line 68 "syslex.l"
885
{ yylval.i= 8; return UNIT;}
886
        YY_BREAK
887
case 15:
888
YY_RULE_SETUP
889
#line 69 "syslex.l"
890
{ yylval.i = 8; return UNIT;}
891
        YY_BREAK
892
case 16:
893
YY_RULE_SETUP
894
#line 71 "syslex.l"
895
{ yylval.s = "INT"; return TYPE;}
896
        YY_BREAK
897
case 17:
898
YY_RULE_SETUP
899
#line 72 "syslex.l"
900
{ yylval.s = "BARRAY"; return TYPE;}
901
        YY_BREAK
902
case 18:
903
YY_RULE_SETUP
904
#line 73 "syslex.l"
905
{ yylval.s = "CHARS"; return TYPE;}
906
        YY_BREAK
907
case 19:
908
YY_RULE_SETUP
909
#line 74 "syslex.l"
910
{ yylval.i = 0; return NUMBER;}
911
        YY_BREAK
912
case 20:
913
YY_RULE_SETUP
914
#line 75 "syslex.l"
915
{ yylval.i = -4; return NUMBER;}
916
        YY_BREAK
917
case 21:
918
YY_RULE_SETUP
919
#line 76 "syslex.l"
920
{ yylval.i = -2; return NUMBER; }
921
        YY_BREAK
922
case 22:
923
YY_RULE_SETUP
924
#line 77 "syslex.l"
925
{ yylval.i = -1; return NUMBER; }
926
        YY_BREAK
927
case 23:
928
YY_RULE_SETUP
929
#line 78 "syslex.l"
930
{ return COND;}
931
        YY_BREAK
932
case 24:
933
YY_RULE_SETUP
934
#line 79 "syslex.l"
935
{ return REPEAT;}
936
        YY_BREAK
937
case 25:
938
YY_RULE_SETUP
939
#line 80 "syslex.l"
940
ECHO;
941
        YY_BREAK
942
#line 943 "syslex.c"
943
case YY_STATE_EOF(INITIAL):
944
        yyterminate();
945
 
946
        case YY_END_OF_BUFFER:
947
                {
948
                /* Amount of text matched not including the EOB char. */
949
                int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
950
 
951
                /* Undo the effects of YY_DO_BEFORE_ACTION. */
952
                *yy_cp = (yy_hold_char);
953
                YY_RESTORE_YY_MORE_OFFSET
954
 
955
                if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
956
                        {
957
                        /* We're scanning a new file or input source.  It's
958
                         * possible that this happened because the user
959
                         * just pointed yyin at a new source and called
960
                         * yylex().  If so, then we have to assure
961
                         * consistency between YY_CURRENT_BUFFER and our
962
                         * globals.  Here is the right place to do so, because
963
                         * this is the first action (other than possibly a
964
                         * back-up) that will match for the new input source.
965
                         */
966
                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
967
                        YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
968
                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
969
                        }
970
 
971
                /* Note that here we test for yy_c_buf_p "<=" to the position
972
                 * of the first EOB in the buffer, since yy_c_buf_p will
973
                 * already have been incremented past the NUL character
974
                 * (since all states make transitions on EOB to the
975
                 * end-of-buffer state).  Contrast this with the test
976
                 * in input().
977
                 */
978
                if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
979
                        { /* This was really a NUL. */
980
                        yy_state_type yy_next_state;
981
 
982
                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
983
 
984
                        yy_current_state = yy_get_previous_state(  );
985
 
986
                        /* Okay, we're now positioned to make the NUL
987
                         * transition.  We couldn't have
988
                         * yy_get_previous_state() go ahead and do it
989
                         * for us because it doesn't know how to deal
990
                         * with the possibility of jamming (and we don't
991
                         * want to build jamming into it because then it
992
                         * will run more slowly).
993
                         */
994
 
995
                        yy_next_state = yy_try_NUL_trans( yy_current_state );
996
 
997
                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
998
 
999
                        if ( yy_next_state )
1000
                                {
1001
                                /* Consume the NUL. */
1002
                                yy_cp = ++(yy_c_buf_p);
1003
                                yy_current_state = yy_next_state;
1004
                                goto yy_match;
1005
                                }
1006
 
1007
                        else
1008
                                {
1009
                                yy_cp = (yy_c_buf_p);
1010
                                goto yy_find_action;
1011
                                }
1012
                        }
1013
 
1014
                else switch ( yy_get_next_buffer(  ) )
1015
                        {
1016
                        case EOB_ACT_END_OF_FILE:
1017
                                {
1018
                                (yy_did_buffer_switch_on_eof) = 0;
1019
 
1020
                                if ( yywrap( ) )
1021
                                        {
1022
                                        /* Note: because we've taken care in
1023
                                         * yy_get_next_buffer() to have set up
1024
                                         * yytext, we can now set up
1025
                                         * yy_c_buf_p so that if some total
1026
                                         * hoser (like flex itself) wants to
1027
                                         * call the scanner after we return the
1028
                                         * YY_NULL, it'll still work - another
1029
                                         * YY_NULL will get returned.
1030
                                         */
1031
                                        (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1032
 
1033
                                        yy_act = YY_STATE_EOF(YY_START);
1034
                                        goto do_action;
1035
                                        }
1036
 
1037
                                else
1038
                                        {
1039
                                        if ( ! (yy_did_buffer_switch_on_eof) )
1040
                                                YY_NEW_FILE;
1041
                                        }
1042
                                break;
1043
                                }
1044
 
1045
                        case EOB_ACT_CONTINUE_SCAN:
1046
                                (yy_c_buf_p) =
1047
                                        (yytext_ptr) + yy_amount_of_matched_text;
1048
 
1049
                                yy_current_state = yy_get_previous_state(  );
1050
 
1051
                                yy_cp = (yy_c_buf_p);
1052
                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1053
                                goto yy_match;
1054
 
1055
                        case EOB_ACT_LAST_MATCH:
1056
                                (yy_c_buf_p) =
1057
                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1058
 
1059
                                yy_current_state = yy_get_previous_state(  );
1060
 
1061
                                yy_cp = (yy_c_buf_p);
1062
                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1063
                                goto yy_find_action;
1064
                        }
1065
                break;
1066
                }
1067
 
1068
        default:
1069
                YY_FATAL_ERROR(
1070
                        "fatal flex scanner internal error--no action found" );
1071
        } /* end of action switch */
1072
                } /* end of scanning one token */
1073
} /* end of yylex */
1074
 
1075
/* yy_get_next_buffer - try to read in a new buffer
1076
 *
1077
 * Returns a code representing an action:
1078
 *      EOB_ACT_LAST_MATCH -
1079
 *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1080
 *      EOB_ACT_END_OF_FILE - end of file
1081
 */
1082
static int yy_get_next_buffer (void)
1083
{
1084
        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1085
        register char *source = (yytext_ptr);
1086
        register int number_to_move, i;
1087
        int ret_val;
1088
 
1089
        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1090
                YY_FATAL_ERROR(
1091
                "fatal flex scanner internal error--end of buffer missed" );
1092
 
1093
        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1094
                { /* Don't try to fill the buffer, so this is an EOF. */
1095
                if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1096
                        {
1097
                        /* We matched a single character, the EOB, so
1098
                         * treat this as a final EOF.
1099
                         */
1100
                        return EOB_ACT_END_OF_FILE;
1101
                        }
1102
 
1103
                else
1104
                        {
1105
                        /* We matched some text prior to the EOB, first
1106
                         * process it.
1107
                         */
1108
                        return EOB_ACT_LAST_MATCH;
1109
                        }
1110
                }
1111
 
1112
        /* Try to read more data. */
1113
 
1114
        /* First move last chars to start of buffer. */
1115
        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1116
 
1117
        for ( i = 0; i < number_to_move; ++i )
1118
                *(dest++) = *(source++);
1119
 
1120
        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1121
                /* don't do the read, it's not guaranteed to return an EOF,
1122
                 * just force an EOF
1123
                 */
1124
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1125
 
1126
        else
1127
                {
1128
                        yy_size_t num_to_read =
1129
                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1130
 
1131
                while ( num_to_read <= 0 )
1132
                        { /* Not enough room in the buffer - grow it. */
1133
 
1134
                        /* just a shorter name for the current buffer */
1135
                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1136
 
1137
                        int yy_c_buf_p_offset =
1138
                                (int) ((yy_c_buf_p) - b->yy_ch_buf);
1139
 
1140
                        if ( b->yy_is_our_buffer )
1141
                                {
1142
                                yy_size_t new_size = b->yy_buf_size * 2;
1143
 
1144
                                if ( new_size <= 0 )
1145
                                        b->yy_buf_size += b->yy_buf_size / 8;
1146
                                else
1147
                                        b->yy_buf_size *= 2;
1148
 
1149
                                b->yy_ch_buf = (char *)
1150
                                        /* Include room in for 2 EOB chars. */
1151
                                        yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1152
                                }
1153
                        else
1154
                                /* Can't grow it, we don't own it. */
1155
                                b->yy_ch_buf = 0;
1156
 
1157
                        if ( ! b->yy_ch_buf )
1158
                                YY_FATAL_ERROR(
1159
                                "fatal error - scanner input buffer overflow" );
1160
 
1161
                        (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1162
 
1163
                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1164
                                                number_to_move - 1;
1165
 
1166
                        }
1167
 
1168
                if ( num_to_read > YY_READ_BUF_SIZE )
1169
                        num_to_read = YY_READ_BUF_SIZE;
1170
 
1171
                /* Read in more data. */
1172
                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1173
                        (yy_n_chars), num_to_read );
1174
 
1175
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1176
                }
1177
 
1178
        if ( (yy_n_chars) == 0 )
1179
                {
1180
                if ( number_to_move == YY_MORE_ADJ )
1181
                        {
1182
                        ret_val = EOB_ACT_END_OF_FILE;
1183
                        yyrestart(yyin  );
1184
                        }
1185
 
1186
                else
1187
                        {
1188
                        ret_val = EOB_ACT_LAST_MATCH;
1189
                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1190
                                YY_BUFFER_EOF_PENDING;
1191
                        }
1192
                }
1193
 
1194
        else
1195
                ret_val = EOB_ACT_CONTINUE_SCAN;
1196
 
1197
        if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1198
                /* Extend the array by 50%, plus the number we really need. */
1199
                yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1200
                YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1201
                if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1202
                        YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1203
        }
1204
 
1205
        (yy_n_chars) += number_to_move;
1206
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1207
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1208
 
1209
        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1210
 
1211
        return ret_val;
1212
}
1213
 
1214
/* yy_get_previous_state - get the state just before the EOB char was reached */
1215
 
1216
    static yy_state_type yy_get_previous_state (void)
1217
{
1218
        register yy_state_type yy_current_state;
1219
        register char *yy_cp;
1220
 
1221
        yy_current_state = (yy_start);
1222
 
1223
        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1224
                {
1225
                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1226
                if ( yy_accept[yy_current_state] )
1227
                        {
1228
                        (yy_last_accepting_state) = yy_current_state;
1229
                        (yy_last_accepting_cpos) = yy_cp;
1230
                        }
1231
                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1232
                        {
1233
                        yy_current_state = (int) yy_def[yy_current_state];
1234
                        if ( yy_current_state >= 81 )
1235
                                yy_c = yy_meta[(unsigned int) yy_c];
1236
                        }
1237
                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1238
                }
1239
 
1240
        return yy_current_state;
1241
}
1242
 
1243
/* yy_try_NUL_trans - try to make a transition on the NUL character
1244
 *
1245
 * synopsis
1246
 *      next_state = yy_try_NUL_trans( current_state );
1247
 */
1248
    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1249
{
1250
        register int yy_is_jam;
1251
        register char *yy_cp = (yy_c_buf_p);
1252
 
1253
        register YY_CHAR yy_c = 1;
1254
        if ( yy_accept[yy_current_state] )
1255
                {
1256
                (yy_last_accepting_state) = yy_current_state;
1257
                (yy_last_accepting_cpos) = yy_cp;
1258
                }
1259
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1260
                {
1261
                yy_current_state = (int) yy_def[yy_current_state];
1262
                if ( yy_current_state >= 81 )
1263
                        yy_c = yy_meta[(unsigned int) yy_c];
1264
                }
1265
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1266
        yy_is_jam = (yy_current_state == 80);
1267
 
1268
        return yy_is_jam ? 0 : yy_current_state;
1269
}
1270
 
1271
    static void yyunput (int c, register char * yy_bp )
1272
{
1273
        register char *yy_cp;
1274
 
1275
    yy_cp = (yy_c_buf_p);
1276
 
1277
        /* undo effects of setting up yytext */
1278
        *yy_cp = (yy_hold_char);
1279
 
1280
        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1281
                { /* need to shift things up to make room */
1282
                /* +2 for EOB chars. */
1283
                register yy_size_t number_to_move = (yy_n_chars) + 2;
1284
                register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1285
                                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1286
                register char *source =
1287
                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1288
 
1289
                while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1290
                        *--dest = *--source;
1291
 
1292
                yy_cp += (int) (dest - source);
1293
                yy_bp += (int) (dest - source);
1294
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1295
                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1296
 
1297
                if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1298
                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
1299
                }
1300
 
1301
        *--yy_cp = (char) c;
1302
 
1303
        (yytext_ptr) = yy_bp;
1304
        (yy_hold_char) = *yy_cp;
1305
        (yy_c_buf_p) = yy_cp;
1306
}
1307
 
1308
#ifndef YY_NO_INPUT
1309
#ifdef __cplusplus
1310
    static int yyinput (void)
1311
#else
1312
    static int input  (void)
1313
#endif
1314
 
1315
{
1316
        int c;
1317
 
1318
        *(yy_c_buf_p) = (yy_hold_char);
1319
 
1320
        if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1321
                {
1322
                /* yy_c_buf_p now points to the character we want to return.
1323
                 * If this occurs *before* the EOB characters, then it's a
1324
                 * valid NUL; if not, then we've hit the end of the buffer.
1325
                 */
1326
                if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1327
                        /* This was really a NUL. */
1328
                        *(yy_c_buf_p) = '\0';
1329
 
1330
                else
1331
                        { /* need more input */
1332
                        yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1333
                        ++(yy_c_buf_p);
1334
 
1335
                        switch ( yy_get_next_buffer(  ) )
1336
                                {
1337
                                case EOB_ACT_LAST_MATCH:
1338
                                        /* This happens because yy_g_n_b()
1339
                                         * sees that we've accumulated a
1340
                                         * token and flags that we need to
1341
                                         * try matching the token before
1342
                                         * proceeding.  But for input(),
1343
                                         * there's no matching to consider.
1344
                                         * So convert the EOB_ACT_LAST_MATCH
1345
                                         * to EOB_ACT_END_OF_FILE.
1346
                                         */
1347
 
1348
                                        /* Reset buffer status. */
1349
                                        yyrestart(yyin );
1350
 
1351
                                        /*FALLTHROUGH*/
1352
 
1353
                                case EOB_ACT_END_OF_FILE:
1354
                                        {
1355
                                        if ( yywrap( ) )
1356
                                                return 0;
1357
 
1358
                                        if ( ! (yy_did_buffer_switch_on_eof) )
1359
                                                YY_NEW_FILE;
1360
#ifdef __cplusplus
1361
                                        return yyinput();
1362
#else
1363
                                        return input();
1364
#endif
1365
                                        }
1366
 
1367
                                case EOB_ACT_CONTINUE_SCAN:
1368
                                        (yy_c_buf_p) = (yytext_ptr) + offset;
1369
                                        break;
1370
                                }
1371
                        }
1372
                }
1373
 
1374
        c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1375
        *(yy_c_buf_p) = '\0';   /* preserve yytext */
1376
        (yy_hold_char) = *++(yy_c_buf_p);
1377
 
1378
        return c;
1379
}
1380
#endif  /* ifndef YY_NO_INPUT */
1381
 
1382
/** Immediately switch to a different input stream.
1383
 * @param input_file A readable stream.
1384
 *
1385
 * @note This function does not reset the start condition to @c INITIAL .
1386
 */
1387
    void yyrestart  (FILE * input_file )
1388
{
1389
 
1390
        if ( ! YY_CURRENT_BUFFER ){
1391
        yyensure_buffer_stack ();
1392
                YY_CURRENT_BUFFER_LVALUE =
1393
            yy_create_buffer(yyin,YY_BUF_SIZE );
1394
        }
1395
 
1396
        yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1397
        yy_load_buffer_state( );
1398
}
1399
 
1400
/** Switch to a different input buffer.
1401
 * @param new_buffer The new input buffer.
1402
 *
1403
 */
1404
    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1405
{
1406
 
1407
        /* TODO. We should be able to replace this entire function body
1408
         * with
1409
         *              yypop_buffer_state();
1410
         *              yypush_buffer_state(new_buffer);
1411
     */
1412
        yyensure_buffer_stack ();
1413
        if ( YY_CURRENT_BUFFER == new_buffer )
1414
                return;
1415
 
1416
        if ( YY_CURRENT_BUFFER )
1417
                {
1418
                /* Flush out information for old buffer. */
1419
                *(yy_c_buf_p) = (yy_hold_char);
1420
                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1421
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1422
                }
1423
 
1424
        YY_CURRENT_BUFFER_LVALUE = new_buffer;
1425
        yy_load_buffer_state( );
1426
 
1427
        /* We don't actually know whether we did this switch during
1428
         * EOF (yywrap()) processing, but the only time this flag
1429
         * is looked at is after yywrap() is called, so it's safe
1430
         * to go ahead and always set it.
1431
         */
1432
        (yy_did_buffer_switch_on_eof) = 1;
1433
}
1434
 
1435
static void yy_load_buffer_state  (void)
1436
{
1437
        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1438
        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1439
        yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1440
        (yy_hold_char) = *(yy_c_buf_p);
1441
}
1442
 
1443
/** Allocate and initialize an input buffer state.
1444
 * @param file A readable stream.
1445
 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1446
 *
1447
 * @return the allocated buffer state.
1448
 */
1449
    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
1450
{
1451
        YY_BUFFER_STATE b;
1452
 
1453
        b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
1454
        if ( ! b )
1455
                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1456
 
1457
        b->yy_buf_size = size;
1458
 
1459
        /* yy_ch_buf has to be 2 characters longer than the size given because
1460
         * we need to put in 2 end-of-buffer characters.
1461
         */
1462
        b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
1463
        if ( ! b->yy_ch_buf )
1464
                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1465
 
1466
        b->yy_is_our_buffer = 1;
1467
 
1468
        yy_init_buffer(b,file );
1469
 
1470
        return b;
1471
}
1472
 
1473
/** Destroy the buffer.
1474
 * @param b a buffer created with yy_create_buffer()
1475
 *
1476
 */
1477
    void yy_delete_buffer (YY_BUFFER_STATE  b )
1478
{
1479
 
1480
        if ( ! b )
1481
                return;
1482
 
1483
        if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1484
                YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1485
 
1486
        if ( b->yy_is_our_buffer )
1487
                yyfree((void *) b->yy_ch_buf  );
1488
 
1489
        yyfree((void *) b  );
1490
}
1491
 
1492
#ifndef __cplusplus
1493
extern int isatty (int );
1494
#endif /* __cplusplus */
1495
 
1496
/* Initializes or reinitializes a buffer.
1497
 * This function is sometimes called more than once on the same buffer,
1498
 * such as during a yyrestart() or at EOF.
1499
 */
1500
    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1501
 
1502
{
1503
        int oerrno = errno;
1504
 
1505
        yy_flush_buffer(b );
1506
 
1507
        b->yy_input_file = file;
1508
        b->yy_fill_buffer = 1;
1509
 
1510
    /* If b is the current buffer, then yy_init_buffer was _probably_
1511
     * called from yyrestart() or through yy_get_next_buffer.
1512
     * In that case, we don't want to reset the lineno or column.
1513
     */
1514
    if (b != YY_CURRENT_BUFFER){
1515
        b->yy_bs_lineno = 1;
1516
        b->yy_bs_column = 0;
1517
    }
1518
 
1519
        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1520
 
1521
        errno = oerrno;
1522
}
1523
 
1524
/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1525
 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1526
 *
1527
 */
1528
    void yy_flush_buffer (YY_BUFFER_STATE  b )
1529
{
1530
        if ( ! b )
1531
                return;
1532
 
1533
        b->yy_n_chars = 0;
1534
 
1535
        /* We always need two end-of-buffer characters.  The first causes
1536
         * a transition to the end-of-buffer state.  The second causes
1537
         * a jam in that state.
1538
         */
1539
        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1540
        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1541
 
1542
        b->yy_buf_pos = &b->yy_ch_buf[0];
1543
 
1544
        b->yy_at_bol = 1;
1545
        b->yy_buffer_status = YY_BUFFER_NEW;
1546
 
1547
        if ( b == YY_CURRENT_BUFFER )
1548
                yy_load_buffer_state( );
1549
}
1550
 
1551
/** Pushes the new state onto the stack. The new state becomes
1552
 *  the current state. This function will allocate the stack
1553
 *  if necessary.
1554
 *  @param new_buffer The new state.
1555
 *
1556
 */
1557
void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1558
{
1559
        if (new_buffer == NULL)
1560
                return;
1561
 
1562
        yyensure_buffer_stack();
1563
 
1564
        /* This block is copied from yy_switch_to_buffer. */
1565
        if ( YY_CURRENT_BUFFER )
1566
                {
1567
                /* Flush out information for old buffer. */
1568
                *(yy_c_buf_p) = (yy_hold_char);
1569
                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1570
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1571
                }
1572
 
1573
        /* Only push if top exists. Otherwise, replace top. */
1574
        if (YY_CURRENT_BUFFER)
1575
                (yy_buffer_stack_top)++;
1576
        YY_CURRENT_BUFFER_LVALUE = new_buffer;
1577
 
1578
        /* copied from yy_switch_to_buffer. */
1579
        yy_load_buffer_state( );
1580
        (yy_did_buffer_switch_on_eof) = 1;
1581
}
1582
 
1583
/** Removes and deletes the top of the stack, if present.
1584
 *  The next element becomes the new top.
1585
 *
1586
 */
1587
void yypop_buffer_state (void)
1588
{
1589
        if (!YY_CURRENT_BUFFER)
1590
                return;
1591
 
1592
        yy_delete_buffer(YY_CURRENT_BUFFER );
1593
        YY_CURRENT_BUFFER_LVALUE = NULL;
1594
        if ((yy_buffer_stack_top) > 0)
1595
                --(yy_buffer_stack_top);
1596
 
1597
        if (YY_CURRENT_BUFFER) {
1598
                yy_load_buffer_state( );
1599
                (yy_did_buffer_switch_on_eof) = 1;
1600
        }
1601
}
1602
 
1603
/* Allocates the stack if it does not exist.
1604
 *  Guarantees space for at least one push.
1605
 */
1606
static void yyensure_buffer_stack (void)
1607
{
1608
        yy_size_t num_to_alloc;
1609
 
1610
        if (!(yy_buffer_stack)) {
1611
 
1612
                /* First allocation is just for 2 elements, since we don't know if this
1613
                 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1614
                 * immediate realloc on the next call.
1615
         */
1616
                num_to_alloc = 1;
1617
                (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1618
                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
1619
                                                                );
1620
                if ( ! (yy_buffer_stack) )
1621
                        YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1622
 
1623
                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1624
 
1625
                (yy_buffer_stack_max) = num_to_alloc;
1626
                (yy_buffer_stack_top) = 0;
1627
                return;
1628
        }
1629
 
1630
        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1631
 
1632
                /* Increase the buffer to prepare for a possible push. */
1633
                int grow_size = 8 /* arbitrary grow size */;
1634
 
1635
                num_to_alloc = (yy_buffer_stack_max) + grow_size;
1636
                (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1637
                                                                ((yy_buffer_stack),
1638
                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
1639
                                                                );
1640
                if ( ! (yy_buffer_stack) )
1641
                        YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1642
 
1643
                /* zero only the new slots.*/
1644
                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1645
                (yy_buffer_stack_max) = num_to_alloc;
1646
        }
1647
}
1648
 
1649
/** Setup the input buffer state to scan directly from a user-specified character buffer.
1650
 * @param base the character buffer
1651
 * @param size the size in bytes of the character buffer
1652
 *
1653
 * @return the newly allocated buffer state object.
1654
 */
1655
YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
1656
{
1657
        YY_BUFFER_STATE b;
1658
 
1659
        if ( size < 2 ||
1660
             base[size-2] != YY_END_OF_BUFFER_CHAR ||
1661
             base[size-1] != YY_END_OF_BUFFER_CHAR )
1662
                /* They forgot to leave room for the EOB's. */
1663
                return 0;
1664
 
1665
        b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
1666
        if ( ! b )
1667
                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1668
 
1669
        b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1670
        b->yy_buf_pos = b->yy_ch_buf = base;
1671
        b->yy_is_our_buffer = 0;
1672
        b->yy_input_file = 0;
1673
        b->yy_n_chars = b->yy_buf_size;
1674
        b->yy_is_interactive = 0;
1675
        b->yy_at_bol = 1;
1676
        b->yy_fill_buffer = 0;
1677
        b->yy_buffer_status = YY_BUFFER_NEW;
1678
 
1679
        yy_switch_to_buffer(b  );
1680
 
1681
        return b;
1682
}
1683
 
1684
/** Setup the input buffer state to scan a string. The next call to yylex() will
1685
 * scan from a @e copy of @a str.
1686
 * @param yystr a NUL-terminated string to scan
1687
 *
1688
 * @return the newly allocated buffer state object.
1689
 * @note If you want to scan bytes that may contain NUL values, then use
1690
 *       yy_scan_bytes() instead.
1691
 */
1692
YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
1693
{
1694
 
1695
        return yy_scan_bytes(yystr,strlen(yystr) );
1696
}
1697
 
1698
/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1699
 * scan from a @e copy of @a bytes.
1700
 * @param bytes the byte buffer to scan
1701
 * @param len the number of bytes in the buffer pointed to by @a bytes.
1702
 *
1703
 * @return the newly allocated buffer state object.
1704
 */
1705
YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
1706
{
1707
        YY_BUFFER_STATE b;
1708
        char *buf;
1709
        yy_size_t n, i;
1710
 
1711
        /* Get memory for full buffer, including space for trailing EOB's. */
1712
        n = _yybytes_len + 2;
1713
        buf = (char *) yyalloc(n  );
1714
        if ( ! buf )
1715
                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1716
 
1717
        for ( i = 0; i < _yybytes_len; ++i )
1718
                buf[i] = yybytes[i];
1719
 
1720
        buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1721
 
1722
        b = yy_scan_buffer(buf,n );
1723
        if ( ! b )
1724
                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1725
 
1726
        /* It's okay to grow etc. this buffer, and we should throw it
1727
         * away when we're done.
1728
         */
1729
        b->yy_is_our_buffer = 1;
1730
 
1731
        return b;
1732
}
1733
 
1734
#ifndef YY_EXIT_FAILURE
1735
#define YY_EXIT_FAILURE 2
1736
#endif
1737
 
1738
static void yy_fatal_error (yyconst char* msg )
1739
{
1740
        (void) fprintf( stderr, "%s\n", msg );
1741
        exit( YY_EXIT_FAILURE );
1742
}
1743
 
1744
/* Redefine yyless() so it works in section 3 code. */
1745
 
1746
#undef yyless
1747
#define yyless(n) \
1748
        do \
1749
                { \
1750
                /* Undo effects of setting up yytext. */ \
1751
        int yyless_macro_arg = (n); \
1752
        YY_LESS_LINENO(yyless_macro_arg);\
1753
                yytext[yyleng] = (yy_hold_char); \
1754
                (yy_c_buf_p) = yytext + yyless_macro_arg; \
1755
                (yy_hold_char) = *(yy_c_buf_p); \
1756
                *(yy_c_buf_p) = '\0'; \
1757
                yyleng = yyless_macro_arg; \
1758
                } \
1759
        while ( 0 )
1760
 
1761
/* Accessor  methods (get/set functions) to struct members. */
1762
 
1763
/** Get the current line number.
1764
 *
1765
 */
1766
int yyget_lineno  (void)
1767
{
1768
 
1769
    return yylineno;
1770
}
1771
 
1772
/** Get the input stream.
1773
 *
1774
 */
1775
FILE *yyget_in  (void)
1776
{
1777
        return yyin;
1778
}
1779
 
1780
/** Get the output stream.
1781
 *
1782
 */
1783
FILE *yyget_out  (void)
1784
{
1785
        return yyout;
1786
}
1787
 
1788
/** Get the length of the current token.
1789
 *
1790
 */
1791
yy_size_t yyget_leng  (void)
1792
{
1793
        return yyleng;
1794
}
1795
 
1796
/** Get the current token.
1797
 *
1798
 */
1799
 
1800
char *yyget_text  (void)
1801
{
1802
        return yytext;
1803
}
1804
 
1805
/** Set the current line number.
1806
 * @param line_number
1807
 *
1808
 */
1809
void yyset_lineno (int  line_number )
1810
{
1811
 
1812
    yylineno = line_number;
1813
}
1814
 
1815
/** Set the input stream. This does not discard the current
1816
 * input buffer.
1817
 * @param in_str A readable stream.
1818
 *
1819
 * @see yy_switch_to_buffer
1820
 */
1821
void yyset_in (FILE *  in_str )
1822
{
1823
        yyin = in_str ;
1824
}
1825
 
1826
void yyset_out (FILE *  out_str )
1827
{
1828
        yyout = out_str ;
1829
}
1830
 
1831
int yyget_debug  (void)
1832
{
1833
        return yy_flex_debug;
1834
}
1835
 
1836
void yyset_debug (int  bdebug )
1837
{
1838
        yy_flex_debug = bdebug ;
1839
}
1840
 
1841
static int yy_init_globals (void)
1842
{
1843
        /* Initialization is the same as for the non-reentrant scanner.
1844
     * This function is called from yylex_destroy(), so don't allocate here.
1845
     */
1846
 
1847
    (yy_buffer_stack) = 0;
1848
    (yy_buffer_stack_top) = 0;
1849
    (yy_buffer_stack_max) = 0;
1850
    (yy_c_buf_p) = (char *) 0;
1851
    (yy_init) = 0;
1852
    (yy_start) = 0;
1853
 
1854
/* Defined in main.c */
1855
#ifdef YY_STDINIT
1856
    yyin = stdin;
1857
    yyout = stdout;
1858
#else
1859
    yyin = (FILE *) 0;
1860
    yyout = (FILE *) 0;
1861
#endif
1862
 
1863
    /* For future reference: Set errno on error, since we are called by
1864
     * yylex_init()
1865
     */
1866
    return 0;
1867
}
1868
 
1869
/* yylex_destroy is for both reentrant and non-reentrant scanners. */
1870
int yylex_destroy  (void)
1871
{
1872
 
1873
    /* Pop the buffer stack, destroying each element. */
1874
        while(YY_CURRENT_BUFFER){
1875
                yy_delete_buffer(YY_CURRENT_BUFFER  );
1876
                YY_CURRENT_BUFFER_LVALUE = NULL;
1877
                yypop_buffer_state();
1878
        }
1879
 
1880
        /* Destroy the stack itself. */
1881
        yyfree((yy_buffer_stack) );
1882
        (yy_buffer_stack) = NULL;
1883
 
1884
    /* Reset the globals. This is important in a non-reentrant scanner so the next time
1885
     * yylex() is called, initialization will occur. */
1886
    yy_init_globals( );
1887
 
1888
    return 0;
1889
}
1890
 
1891
/*
1892
 * Internal utility routines.
1893
 */
1894
 
1895
#ifndef yytext_ptr
1896
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1897
{
1898
        register int i;
1899
        for ( i = 0; i < n; ++i )
1900
                s1[i] = s2[i];
1901
}
1902
#endif
1903
 
1904
#ifdef YY_NEED_STRLEN
1905
static int yy_flex_strlen (yyconst char * s )
1906
{
1907
        register int n;
1908
        for ( n = 0; s[n]; ++n )
1909
                ;
1910
 
1911
        return n;
1912
}
1913
#endif
1914
 
1915
void *yyalloc (yy_size_t  size )
1916
{
1917
        return (void *) malloc( size );
1918
}
1919
 
1920
void *yyrealloc  (void * ptr, yy_size_t  size )
1921
{
1922
        /* The cast to (char *) in the following accommodates both
1923
         * implementations that use char* generic pointers, and those
1924
         * that use void* generic pointers.  It works with the latter
1925
         * because both ANSI C and C++ allow castless assignment from
1926
         * any pointer type to void*, and deal with argument conversions
1927
         * as though doing an assignment.
1928
         */
1929
        return (void *) realloc( (char *) ptr, size );
1930
}
1931
 
1932
void yyfree (void * ptr )
1933
{
1934
        free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
1935
}
1936
 
1937
#define YYTABLES_NAME "yytables"
1938
 
1939
#line 80 "syslex.l"

powered by: WebSVN 2.1.0

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