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

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [gdb/] [ada-lex.c] - Blame information for rev 501

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

Line No. Rev Author Line
1 330 jeremybenn
#line 2 "../../gdb-7.2/gdb/ada-lex.c"
2
 
3
#line 4 "../../gdb-7.2/gdb/ada-lex.c"
4
 
5
#define  YY_INT_ALIGNED short int
6
 
7
/* A lexical scanner generated by flex */
8
 
9
#define FLEX_SCANNER
10
#define YY_FLEX_MAJOR_VERSION 2
11
#define YY_FLEX_MINOR_VERSION 5
12
#define YY_FLEX_SUBMINOR_VERSION 35
13
#if YY_FLEX_SUBMINOR_VERSION > 0
14
#define FLEX_BETA
15
#endif
16
 
17
/* First, we deal with  platform-specific or compiler-specific issues. */
18
 
19
/* begin standard C headers. */
20
#include <stdio.h>
21
#include <string.h>
22
#include <errno.h>
23
#include <stdlib.h>
24
 
25
/* end standard C headers. */
26
 
27
/* flex integer type definitions */
28
 
29
#ifndef FLEXINT_H
30
#define FLEXINT_H
31
 
32
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
33
 
34
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
35
 
36
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
37
 * if you want the limit (max/min) macros for int types.
38
 */
39
#ifndef __STDC_LIMIT_MACROS
40
#define __STDC_LIMIT_MACROS 1
41
#endif
42
 
43
#include <inttypes.h>
44
typedef int8_t flex_int8_t;
45
typedef uint8_t flex_uint8_t;
46
typedef int16_t flex_int16_t;
47
typedef uint16_t flex_uint16_t;
48
typedef int32_t flex_int32_t;
49
typedef uint32_t flex_uint32_t;
50
#else
51
typedef signed char flex_int8_t;
52
typedef short int flex_int16_t;
53
typedef int flex_int32_t;
54
typedef unsigned char flex_uint8_t;
55
typedef unsigned short int flex_uint16_t;
56
typedef unsigned int flex_uint32_t;
57
#endif /* ! C99 */
58
 
59
/* Limits of integral types. */
60
#ifndef INT8_MIN
61
#define INT8_MIN               (-128)
62
#endif
63
#ifndef INT16_MIN
64
#define INT16_MIN              (-32767-1)
65
#endif
66
#ifndef INT32_MIN
67
#define INT32_MIN              (-2147483647-1)
68
#endif
69
#ifndef INT8_MAX
70
#define INT8_MAX               (127)
71
#endif
72
#ifndef INT16_MAX
73
#define INT16_MAX              (32767)
74
#endif
75
#ifndef INT32_MAX
76
#define INT32_MAX              (2147483647)
77
#endif
78
#ifndef UINT8_MAX
79
#define UINT8_MAX              (255U)
80
#endif
81
#ifndef UINT16_MAX
82
#define UINT16_MAX             (65535U)
83
#endif
84
#ifndef UINT32_MAX
85
#define UINT32_MAX             (4294967295U)
86
#endif
87
 
88
#endif /* ! FLEXINT_H */
89
 
90
#ifdef __cplusplus
91
 
92
/* The "const" storage-class-modifier is valid. */
93
#define YY_USE_CONST
94
 
95
#else   /* ! __cplusplus */
96
 
97
/* C99 requires __STDC__ to be defined as 1. */
98
#if defined (__STDC__)
99
 
100
#define YY_USE_CONST
101
 
102
#endif  /* defined (__STDC__) */
103
#endif  /* ! __cplusplus */
104
 
105
#ifdef YY_USE_CONST
106
#define yyconst const
107
#else
108
#define yyconst
109
#endif
110
 
111
/* Returned upon end-of-file. */
112
#define YY_NULL 0
113
 
114
/* Promotes a possibly negative, possibly signed char to an unsigned
115
 * integer for use as an array index.  If the signed char is negative,
116
 * we want to instead treat it as an 8-bit unsigned char, hence the
117
 * double cast.
118
 */
119
#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
120
 
121
/* Enter a start condition.  This macro really ought to take a parameter,
122
 * but we do it the disgusting crufty way forced on us by the ()-less
123
 * definition of BEGIN.
124
 */
125
#define BEGIN (yy_start) = 1 + 2 *
126
 
127
/* Translate the current start state into a value that can be later handed
128
 * to BEGIN to return to the state.  The YYSTATE alias is for lex
129
 * compatibility.
130
 */
131
#define YY_START (((yy_start) - 1) / 2)
132
#define YYSTATE YY_START
133
 
134
/* Action number for EOF rule of a given start state. */
135
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
136
 
137
/* Special action meaning "start processing a new file". */
138
#define YY_NEW_FILE yyrestart(yyin  )
139
 
140
#define YY_END_OF_BUFFER_CHAR 0
141
 
142
/* Size of default input buffer. */
143
#ifndef YY_BUF_SIZE
144
#define YY_BUF_SIZE 16384
145
#endif
146
 
147
/* The state buf must be large enough to hold one state per character in the main buffer.
148
 */
149
#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
150
 
151
#ifndef YY_TYPEDEF_YY_BUFFER_STATE
152
#define YY_TYPEDEF_YY_BUFFER_STATE
153
typedef struct yy_buffer_state *YY_BUFFER_STATE;
154
#endif
155
 
156
extern int yyleng;
157
 
158
extern FILE *yyin, *yyout;
159
 
160
#define EOB_ACT_CONTINUE_SCAN 0
161
#define EOB_ACT_END_OF_FILE 1
162
#define EOB_ACT_LAST_MATCH 2
163
 
164
    #define YY_LESS_LINENO(n)
165
 
166
/* Return all but the first "n" matched characters back to the input stream. */
167
#define yyless(n) \
168
        do \
169
                { \
170
                /* Undo effects of setting up yytext. */ \
171
        int yyless_macro_arg = (n); \
172
        YY_LESS_LINENO(yyless_macro_arg);\
173
                *yy_cp = (yy_hold_char); \
174
                YY_RESTORE_YY_MORE_OFFSET \
175
                (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
176
                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
177
                } \
178
        while ( 0 )
179
 
180
#define unput(c) yyunput( c, (yytext_ptr)  )
181
 
182
#ifndef YY_TYPEDEF_YY_SIZE_T
183
#define YY_TYPEDEF_YY_SIZE_T
184
typedef size_t yy_size_t;
185
#endif
186
 
187
#ifndef YY_STRUCT_YY_BUFFER_STATE
188
#define YY_STRUCT_YY_BUFFER_STATE
189
struct yy_buffer_state
190
        {
191
        FILE *yy_input_file;
192
 
193
        char *yy_ch_buf;                /* input buffer */
194
        char *yy_buf_pos;               /* current position in input buffer */
195
 
196
        /* Size of input buffer in bytes, not including room for EOB
197
         * characters.
198
         */
199
        yy_size_t yy_buf_size;
200
 
201
        /* Number of characters read into yy_ch_buf, not including EOB
202
         * characters.
203
         */
204
        int yy_n_chars;
205
 
206
        /* Whether we "own" the buffer - i.e., we know we created it,
207
         * and can xrealloc() it to grow it, and should xfree() it to
208
         * delete it.
209
         */
210
        int yy_is_our_buffer;
211
 
212
        /* Whether this is an "interactive" input source; if so, and
213
         * if we're using stdio for input, then we want to use getc()
214
         * instead of fread(), to make sure we stop fetching input after
215
         * each newline.
216
         */
217
        int yy_is_interactive;
218
 
219
        /* Whether we're considered to be at the beginning of a line.
220
         * If so, '^' rules will be active on the next match, otherwise
221
         * not.
222
         */
223
        int yy_at_bol;
224
 
225
    int yy_bs_lineno; /**< The line count. */
226
    int yy_bs_column; /**< The column count. */
227
 
228
        /* Whether to try to fill the input buffer when we reach the
229
         * end of it.
230
         */
231
        int yy_fill_buffer;
232
 
233
        int yy_buffer_status;
234
 
235
#define YY_BUFFER_NEW 0
236
#define YY_BUFFER_NORMAL 1
237
        /* When an EOF's been seen but there's still some text to process
238
         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
239
         * shouldn't try reading from the input source any more.  We might
240
         * still have a bunch of tokens to match, though, because of
241
         * possible backing-up.
242
         *
243
         * When we actually see the EOF, we change the status to "new"
244
         * (via yyrestart()), so that the user can continue scanning by
245
         * just pointing yyin at a new input file.
246
         */
247
#define YY_BUFFER_EOF_PENDING 2
248
 
249
        };
250
#endif /* !YY_STRUCT_YY_BUFFER_STATE */
251
 
252
/* Stack of input buffers. */
253
static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
254
static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
255
static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
256
 
257
/* We provide macros for accessing buffer states in case in the
258
 * future we want to put the buffer states in a more general
259
 * "scanner state".
260
 *
261
 * Returns the top of the stack, or NULL.
262
 */
263
#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
264
                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
265
                          : NULL)
266
 
267
/* Same as previous macro, but useful when we know that the buffer stack is not
268
 * NULL or when we need an lvalue. For internal use only.
269
 */
270
#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
271
 
272
/* yy_hold_char holds the character lost when yytext is formed. */
273
static char yy_hold_char;
274
static int yy_n_chars;          /* number of characters read into yy_ch_buf */
275
int yyleng;
276
 
277
/* Points to current character in buffer. */
278
static char *yy_c_buf_p = (char *) 0;
279
static int yy_init = 0;          /* whether we need to initialize */
280
static int yy_start = 0; /* start state number */
281
 
282
/* Flag which is used to allow yywrap()'s to do buffer switches
283
 * instead of setting up a fresh yyin.  A bit of a hack ...
284
 */
285
static int yy_did_buffer_switch_on_eof;
286
 
287
void yyrestart (FILE *input_file  );
288
void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
289
YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
290
void yy_delete_buffer (YY_BUFFER_STATE b  );
291
void yy_flush_buffer (YY_BUFFER_STATE b  );
292
void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
293
void yypop_buffer_state (void );
294
 
295
static void yyensure_buffer_stack (void );
296
static void yy_load_buffer_state (void );
297
static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
298
 
299
#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
300
 
301
YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
302
YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
303
YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
304
 
305
void *yyalloc (yy_size_t  );
306
void *yyxrealloc (void *,yy_size_t  );
307
void yyfree (void *  );
308
 
309
#define yy_new_buffer yy_create_buffer
310
 
311
#define yy_set_interactive(is_interactive) \
312
        { \
313
        if ( ! YY_CURRENT_BUFFER ){ \
314
        yyensure_buffer_stack (); \
315
                YY_CURRENT_BUFFER_LVALUE =    \
316
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
317
        } \
318
        YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
319
        }
320
 
321
#define yy_set_bol(at_bol) \
322
        { \
323
        if ( ! YY_CURRENT_BUFFER ){\
324
        yyensure_buffer_stack (); \
325
                YY_CURRENT_BUFFER_LVALUE =    \
326
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
327
        } \
328
        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
329
        }
330
 
331
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
332
 
333
/* Begin user sect3 */
334
 
335
typedef unsigned char YY_CHAR;
336
 
337
FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
338
 
339
typedef int yy_state_type;
340
 
341
extern int yylineno;
342
 
343
int yylineno = 1;
344
 
345
extern char *yytext;
346
#define yytext_ptr yytext
347
 
348
static yy_state_type yy_get_previous_state (void );
349
static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
350
static int yy_get_next_buffer (void );
351
static void yy_fatal_error (yyconst char msg[]  );
352
 
353
/* Done after the current pattern has been matched and before the
354
 * corresponding action - sets up yytext.
355
 */
356
#define YY_DO_BEFORE_ACTION \
357
        (yytext_ptr) = yy_bp; \
358
        yyleng = (size_t) (yy_cp - yy_bp); \
359
        (yy_hold_char) = *yy_cp; \
360
        *yy_cp = '\0'; \
361
        (yy_c_buf_p) = yy_cp;
362
 
363
#define YY_NUM_RULES 54
364
#define YY_END_OF_BUFFER 55
365
/* This struct is not used in this scanner,
366
   but its presence is necessary. */
367
struct yy_trans_info
368
        {
369
        flex_int32_t yy_verify;
370
        flex_int32_t yy_nxt;
371
        };
372
static yyconst flex_int16_t yy_accept[204] =
373
    {   0,
374
        0,    0,    0,    0,   55,   53,    1,    1,   15,   52,
375
       42,   53,   44,   45,   42,   43,   42,   42,   42,    4,
376
        4,   42,   42,   42,   42,   51,   48,   48,   48,   48,
377
       48,   48,   48,   48,   48,   48,   48,   41,    0,   14,
378
        0,   52,    0,    0,    0,    0,    0,    0,    0,   36,
379
        2,    0,   35,    0,   47,   47,   38,    0,    0,    4,
380
        0,    0,   50,   37,   39,    0,   34,   40,    0,    0,
381
       48,    0,   48,   48,   48,   48,   48,   16,   21,   48,
382
       48,   48,   48,   26,   48,   48,   48,   48,   48,   48,
383
        0,   14,    0,   12,   12,   33,    0,    2,    0,   47,
384
 
385
       47,    0,    9,    0,    3,    7,    0,   48,    0,    0,
386
        0,   48,   18,   19,   48,   48,   22,   23,   24,   48,
387
       48,   28,   48,   48,   48,   48,   30,    0,    0,    0,
388
        0,    0,    0,   47,   46,    6,    0,    0,    9,    0,
389
        3,    0,    0,    0,    0,    0,    0,    0,    0,    0,
390
        0,    0,    0,   48,   20,   48,   25,   48,   17,   29,
391
       48,   31,    0,   49,    0,    0,    0,    0,   48,    0,
392
        0,    0,    0,    0,    0,    0,    0,   32,   48,   48,
393
        0,    0,    5,   11,    0,    8,    0,    0,    0,    0,
394
        0,    0,   27,   17,    0,    5,    0,    8,   13,    0,
395
 
396
       10,   10,    0
397
    } ;
398
 
399
static yyconst flex_int32_t yy_ec[256] =
400
    {   0,
401
        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
402
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
403
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
404
        1,    4,    5,    6,    7,    8,    5,    9,   10,   11,
405
       12,   13,   14,   15,   16,   17,   18,   19,   20,   20,
406
       20,   20,   20,   20,   20,   20,   20,   21,   22,   23,
407
       24,   25,    5,   26,   27,   28,   29,   30,   31,   32,
408
       33,   34,   35,   33,   36,   37,   38,   39,   40,   33,
409
       33,   41,   42,   43,   44,   33,   45,   46,   33,   33,
410
       47,    5,   48,    5,   49,    5,   50,   51,   29,   52,
411
 
412
       53,   54,   33,   55,   56,   33,   57,   58,   59,   60,
413
       61,   33,   33,   62,   63,   64,   65,   33,   66,   67,
414
       33,   33,   26,   22,   26,    5,    1,    1,    1,    1,
415
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
416
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
417
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
418
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
419
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
420
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
421
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
422
 
423
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
424
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
425
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
426
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
427
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
428
        1,    1,    1,    1,    1
429
    } ;
430
 
431
static yyconst flex_int32_t yy_meta[68] =
432
    {   0,
433
        1,    2,    3,    4,    5,    6,    7,    8,    5,    9,
434
        5,    5,    5,    5,    5,    5,   10,    5,   11,   11,
435
        5,    5,   12,   13,   14,    5,   15,   15,   15,   15,
436
       15,   15,   16,   16,   16,   16,   16,   16,   16,   16,
437
       16,   16,   16,   16,   16,   16,    5,    5,   17,   15,
438
       15,   15,   15,   15,   16,   16,   16,   16,   16,   16,
439
       16,   16,   16,   16,   16,   16,   16
440
    } ;
441
 
442
static yyconst flex_int16_t yy_base[226] =
443
    {   0,
444
        0,    0,  649,  638,  646, 1252, 1252, 1252,   62,    0,
445
     1252,  109, 1252, 1252,  623, 1252,  619,  175,  606,  174,
446
      180,   48,  604,  592,  590, 1252,  204,   71,  214,  186,
447
      235,  244,  304,  256,   39,  368,   40,  430,  179, 1252,
448
      195,    0,  602,  595,  592,  585,  574,  497,   72, 1252,
449
        0,  273, 1252,    0,   39,    0, 1252,    0,   66,  262,
450
       75,    0, 1252, 1252, 1252,  557, 1252, 1252,  284,  300,
451
     1252,  322,  329,  349,  358,  377,  339,  396,  412,  563,
452
      566,  575,  584,  587,  569,  596,  623,  616,  576,  617,
453
      571,  568,  334,  380, 1252,  562,  677,    0,  403,    0,
454
 
455
       40,   89,  642,   71,  163,    0,  401,  672,  401,  723,
456
        0,  708,  741,  750,  637,  776,  785,  794,  797,  806,
457
      775,  827,  831,  843,  818,  819,  883,  415,    0,  712,
458
      399,  885,  352, 1252,    0,  191,    0,  202,  772,  170,
459
      243,  334,  222,  244,  247,  259,  766,   47,  209,  216,
460
      203,  251,  302,  892,  916,  890,  942,  715,  946,  958,
461
      930,  974,  274, 1252,   93,  344,  278,  310,  979,  256,
462
      264,  337,  270,  274,  352,  355,  215,  984,  995, 1000,
463
      299,  354,  589,  355,  223,  603,  209,  204,  198,  189,
464
      174,  101, 1004, 1016,   92,  634,  411,  644,  717,  373,
465
 
466
      793,  832, 1252, 1055, 1065, 1081, 1086, 1102, 1119, 1136,
467
     1139, 1146,  339,  560, 1153, 1169, 1181, 1186, 1197, 1200,
468
     1216,  634,  645, 1223, 1234
469
    } ;
470
 
471
static yyconst flex_int16_t yy_def[226] =
472
    {   0,
473
      203,    1,    1,    1,  203,  203,  203,  203,  204,  205,
474
      203,  203,  203,  203,  203,  203,  203,  206,  203,  203,
475
      203,  203,  207,  203,  203,  203,  208,  208,  208,  208,
476
      208,  208,  208,  208,   33,  208,   33,  203,  204,  203,
477
      204,  205,  209,   38,   38,  209,  203,  203,  209,  203,
478
      210,  206,  203,  211,  212,  212,  203,  213,  203,  203,
479
      203,  214,  203,  203,  203,  215,  203,  203,  203,  203,
480
      203,  216,  208,  208,  208,  208,  208,  208,  208,  208,
481
      208,  208,  208,  208,   36,  208,  208,   36,   33,   36,
482
       48,  217,  203,  203,  203,   48,  209,  210,  218,  212,
483
 
484
      212,  219,  203,  203,  203,  214,  215,  203,  216,  203,
485
      220,  221,  208,  208,   33,  208,  208,  208,  208,  208,
486
       33,  208,  208,  208,   33,   33,  208,  203,  222,  203,
487
      203,   97,  218,  203,  212,  203,  223,  219,  203,  203,
488
      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
489
      203,  203,  224,  221,  208,   33,  208,   36,  208,  208,
490
       36,  208,  203,  203,  209,  203,  225,  203,  203,  203,
491
      203,  203,  203,  203,  203,  203,  224,  208,  208,  208,
492
      209,  203,  203,  203,  225,  203,  203,  203,  203,  203,
493
      203,  203,  208,  208,  209,  203,  203,  203,  203,  203,
494
 
495
      203,  203,    0,  203,  203,  203,  203,  203,  203,  203,
496
      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
497
      203,  203,  203,  203,  203
498
    } ;
499
 
500
static yyconst flex_int16_t yy_nxt[1320] =
501
    {   0,
502
        6,    7,    8,    7,    6,    9,    6,   10,   11,   12,
503
       13,   14,   15,   11,   16,   17,   18,   19,   20,   21,
504
       22,   11,   23,   24,   25,   26,   27,   28,   28,   28,
505
       29,   30,   28,   28,   31,   28,   28,   32,   33,   34,
506
       35,   28,   36,   28,   28,   37,   11,   11,   28,   27,
507
       28,   28,   29,   30,   28,   31,   28,   28,   32,   33,
508
       34,   35,   28,   36,   28,   28,   37,   40,   63,   86,
509
       73,   64,   69,   69,   70,  101,  135,   97,   73,   90,
510
       71,   94,   73,   73,  103,  103,  172,   72,  104,  105,
511
      105,   86,   73,  105,  105,  136,  101,  135,  181,   73,
512
 
513
       90,  199,   93,   73,   73,  137,  169,  172,   41,   43,
514
       44,   44,   45,   46,   46,   46,   46,   46,   47,   46,
515
       46,   46,   46,   46,   46,   46,   46,   46,   46,   46,
516
       46,   46,   46,   46,   46,   48,   48,   48,   48,   48,
517
       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
518
       48,   48,   48,   48,   48,   49,   46,   46,   48,   48,
519
       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
520
       48,   48,   48,   48,   48,   48,   52,   52,   52,  169,
521
       58,  141,  141,  168,   40,  168,   58,   69,   69,   70,
522
       59,   53,   60,   60,  169,   71,   59,   54,   60,   60,
523
 
524
       92,   55,   72,  169,   61,   69,   69,   70,  136,  169,
525
       61,  141,   77,   71,  169,   69,   69,   70,  137,   62,
526
       72,  166,   60,   71,   55,   41,   61,  169,   60,  184,
527
       72,   74,   61,  175,  142,   77,   69,   69,   70,  169,
528
       62,   41,   75,  166,   71,   69,   69,   70,  173,  169,
529
       76,   72,  169,   71,   74,  175,  174,   69,   69,   70,
530
       72,  141,  141,   75,  169,   71,   78,  142,   58,  173,
531
      142,   76,   72,   79,   52,   52,   52,  174,   59,  169,
532
       60,   60,  142,   80,  184,   69,   69,   69,   78,  203,
533
      176,  141,   61,  188,   79,   54,   84,  187,   85,   55,
534
 
535
       72,   69,   69,   70,   80,   69,   69,   70,   93,   71,
536
       60,  176,  190,   71,   61,  188,   72,   84,  187,   85,
537
       72,   39,   55,  109,  109,  109,  169,  110,  186,  186,
538
       69,   69,   70,  190,   81,  130,  130,  130,   71,  169,
539
       69,   69,   70,   82,  111,   72,  195,   83,   71,  102,
540
       69,   69,   70,  102,  131,   72,   81,  182,   71,   69,
541
       69,   70,  183,  183,   82,   72,  189,   71,   83,   69,
542
       69,   70,  183,  183,   72,  116,  134,   71,   69,   69,
543
       70,  130,  130,  130,   72,  197,   71,  114,  189,  191,
544
      113,  201,  201,   72,   87,  192,  116,   69,   69,   70,
545
 
546
      131,   88,  109,  109,  109,   71,  110,  197,   89,  114,
547
      191,  113,   72,   69,   69,   70,  192,   87,  115,  164,
548
      163,   71,   88,  111,  200,  108,  200,  134,   72,   89,
549
       43,   44,   44,   44,   43,   43,   43,   43,   43,  115,
550
       43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
551
       43,   43,   43,   43,   43,   43,   91,   91,   91,   91,
552
       91,   91,   91,   91,   91,   91,   91,   91,   91,   91,
553
       91,   91,   91,   91,   91,   91,   43,   43,   43,   91,
554
       91,   91,   91,   91,   91,   91,   91,   91,   91,   91,
555
       91,   91,   91,   91,   91,   91,   91,   43,   43,   43,
556
 
557
       43,   43,   43,   43,   43,   43,   94,   43,   43,   43,
558
       43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
559
       43,   43,   43,   96,   96,   96,   96,   96,   96,   96,
560
       96,   96,   96,   96,   96,   96,   96,   96,   96,   96,
561
       96,   96,   96,   43,   43,   43,   96,   96,   96,   96,
562
       96,   96,   96,   96,   96,   96,   96,   96,   96,   96,
563
       96,   96,   96,   96,   69,   69,   70,   69,   69,   70,
564
      106,   93,   71,  128,  106,   71,   69,   69,   70,   72,
565
       93,  108,   72,   95,   71,   69,   69,   70,   69,   69,
566
       70,   72,  117,   71,   94,   73,   71,   69,   69,   70,
567
 
568
       72,   94,  121,   72,   93,   71,   73,  196,  196,   73,
569
      118,   93,   72,   68,  117,   73,   67,  119,   73,  126,
570
      120,  198,  198,  121,   69,   69,   70,   65,   73,   57,
571
       73,  118,   71,  122,   51,   50,   73,  196,  119,   72,
572
      126,  120,   73,   73,  128,  203,  124,   38,  128,   73,
573
       73,  198,  196,  196,  122,  167,  125,  127,   38,  167,
574
      139,  139,  198,  198,  123,   73,   73,  155,  124,  203,
575
       73,   73,  140,   69,   69,   70,   73,  125,  127,  203,
576
       73,   71,  196,  203,  203,  123,   93,  203,   72,  155,
577
      139,  203,  198,  203,  140,  132,  132,   73,  203,  203,
578
 
579
      203,   73,  203,  132,  132,  132,  132,  132,  132,   69,
580
       69,   70,  203,  130,  130,  130,  203,   71,  130,  130,
581
      130,  203,  203,  203,   72,  203,  132,  132,  132,  132,
582
      132,  142,  131,  203,  203,  143,  142,  131,  142,  203,
583
      144,   73,   69,   69,   70,  145,  142,  146,   73,  147,
584
       71,   69,   69,   70,  203,  179,  203,   72,  203,   71,
585
      148,  149,  150,  151,   73,  203,   72,  203,  152,   73,
586
      203,  203,  147,  203,  203,  203,  179,   69,   69,   70,
587
      203,  148,  149,  150,  151,   71,   69,   69,   70,  152,
588
      139,  139,   72,  170,   71,   69,   69,   70,   69,   69,
589
 
590
       70,   72,  140,   71,  171,  158,   71,   69,   69,   70,
591
       72,  202,  202,   72,   73,   71,  170,  156,   73,  203,
592
      139,  203,   72,  203,  140,  171,  203,  158,   69,   69,
593
       70,  203,   69,   69,   70,   73,   71,  203,  156,   73,
594
       71,  202,  157,   72,   69,   69,   70,   72,  161,  162,
595
      202,  202,   71,  203,  203,  203,  203,   73,   73,   72,
596
      203,   73,   73,  157,  203,  203,  159,  203,  203,  203,
597
      161,  162,  203,  203,  203,  203,  203,  203,   73,   73,
598
      202,  160,   73,   73,   69,   69,   70,  159,  203,  203,
599
      203,  203,   71,   69,   69,   70,  203,  203,  203,   72,
600
 
601
      203,   71,  160,  165,  165,  203,  203,  203,   72,  203,
602
      203,  165,  165,  165,  165,  165,  165,   69,   69,   70,
603
      178,  203,  203,  203,  203,   71,  203,  203,  203,   73,
604
      203,  203,   72,   73,  165,  165,  165,  165,  165,  203,
605
      203,  203,  178,   69,   69,   70,  203,   69,   69,   70,
606
       73,   71,  203,  203,   73,   71,  180,  203,   72,   69,
607
       69,   70,   72,   73,  203,  203,  203,   71,  203,  203,
608
       73,  203,  203,  203,   72,   69,   69,   70,  203,  180,
609
       69,   69,   70,   71,   73,   69,   69,   70,   71,  203,
610
       72,   73,  203,   71,  203,   72,   69,   69,   70,  203,
611
 
612
       72,   69,   69,   70,   71,   69,   69,   70,  203,   71,
613
      203,   72,  203,   71,  203,  203,   72,   69,   69,   70,
614
       72,  203,  203,  203,  203,   71,  203,  203,  203,  194,
615
      203,  203,   72,  203,  203,  203,  193,  203,  203,  203,
616
      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
617
      203,  194,  203,  203,  203,  203,  203,  193,   39,   39,
618
       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
619
       39,   39,   42,  203,  203,   42,  203,  203,  203,   42,
620
       42,   42,   56,   56,   56,  203,  203,  203,  203,  203,
621
       56,  203,   56,  203,  203,   56,   56,   56,   66,  203,
622
 
623
       66,   66,   66,   73,   73,   73,  203,  203,  203,  203,
624
       73,   73,   73,  203,  203,  203,   73,   73,   73,   43,
625
       43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
626
       43,   43,   43,   43,   43,   43,   98,   98,  203,   98,
627
       98,   98,   98,   98,   98,   98,   98,   98,   98,   98,
628
       98,   98,   98,   99,   99,   99,  100,  203,  203,  203,
629
      100,  100,  100,  107,  203,  203,  107,  107,  107,  107,
630
      112,  112,  112,  203,  112,  203,  203,  203,  203,  203,
631
      112,  203,  203,  112,  112,  112,  129,  203,  203,  203,
632
      203,  129,  203,  203,  203,  129,  133,  203,  203,  133,
633
 
634
      133,  133,  133,  138,  203,  203,  138,  138,  203,  203,
635
      203,  138,  203,  138,  153,  153,  153,  154,  154,  154,
636
      203,  203,  203,  203,  154,  154,  154,  203,  203,  203,
637
      154,  154,  154,  177,  203,  203,  177,  177,  177,  177,
638
      185,  203,  203,  203,  185,  203,  203,  203,  185,  203,
639
      185,    5,  203,  203,  203,  203,  203,  203,  203,  203,
640
      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
641
      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
642
      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
643
      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
644
 
645
      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
646
      203,  203,  203,  203,  203,  203,  203,  203,  203
647
    } ;
648
 
649
static yyconst flex_int16_t yy_chk[1320] =
650
    {   0,
651
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
652
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
653
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
654
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
655
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
656
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
657
        1,    1,    1,    1,    1,    1,    1,    9,   22,   35,
658
       37,   22,   28,   28,   28,   55,  101,   49,   35,   37,
659
       28,   49,   35,   37,   59,   59,  148,   28,   61,  104,
660
      104,   35,   37,   61,   61,  102,   55,  101,  165,   35,
661
 
662
       37,  195,  165,   35,   37,  102,  192,  148,    9,   12,
663
       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
664
       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
665
       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
666
       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
667
       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
668
       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
669
       12,   12,   12,   12,   12,   12,   18,   18,   18,  191,
670
       20,  105,  105,  140,   39,  140,   21,   30,   30,   30,
671
       20,   18,   20,   20,  190,   30,   21,   18,   21,   21,
672
 
673
       41,   18,   30,  189,   20,   27,   27,   27,  138,  188,
674
       21,  105,   30,   27,  187,   29,   29,   29,  138,   20,
675
       27,  136,   20,   29,   18,   39,   20,  143,   21,  185,
676
       29,   27,   21,  151,  143,   30,   31,   31,   31,  177,
677
       20,   41,   27,  136,   31,   32,   32,   32,  149,  144,
678
       29,   31,  145,   32,   27,  151,  150,   34,   34,   34,
679
       32,  141,  141,   27,  146,   34,   31,  144,   60,  149,
680
      145,   29,   34,   31,   52,   52,   52,  150,   60,  174,
681
       60,   60,  146,   32,  167,   69,   69,   69,   31,   52,
682
      152,  141,   60,  171,   31,   52,   34,  170,   34,   52,
683
 
684
       69,   70,   70,   70,   32,   33,   33,   33,  181,   70,
685
       60,  152,  173,   33,   60,  171,   70,   34,  170,   34,
686
       33,  163,   52,   72,   72,   72,  153,   72,  168,  168,
687
       73,   73,   73,  173,   33,   93,   93,   93,   73,  142,
688
       77,   77,   77,   33,   72,   73,  181,   33,   77,  213,
689
       74,   74,   74,  213,   93,   77,   33,  166,   74,   75,
690
       75,   75,  166,  166,   33,   74,  172,   75,   33,   36,
691
       36,   36,  182,  182,   75,   77,  133,   36,   76,   76,
692
       76,   94,   94,   94,   36,  184,   76,   75,  172,  175,
693
       74,  200,  200,   76,   36,  176,   77,   78,   78,   78,
694
 
695
       94,   36,  109,  109,  109,   78,  109,  184,   36,   75,
696
      175,   74,   78,   79,   79,   79,  176,   36,   76,  131,
697
      128,   79,   36,  109,  197,  107,  197,   99,   79,   36,
698
       38,   38,   38,   38,   38,   38,   38,   38,   38,   76,
699
       38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
700
       38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
701
       38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
702
       38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
703
       38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
704
       38,   38,   38,   38,   38,   38,   38,   48,   48,   48,
705
 
706
       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
707
       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
708
       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
709
       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
710
       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
711
       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
712
       48,   48,   48,   48,   80,   80,   80,   81,   81,   81,
713
      214,   96,   80,   92,  214,   81,   82,   82,   82,   80,
714
       91,   66,   81,   47,   82,   83,   83,   83,   84,   84,
715
       84,   82,   80,   83,   46,   85,   84,   86,   86,   86,
716
 
717
       83,   45,   85,   84,   44,   86,   89,  183,  183,   85,
718
       81,   43,   86,   25,   80,   89,   24,   82,   85,   89,
719
       83,  186,  186,   85,   87,   87,   87,   23,   89,   19,
720
       85,   81,   87,   86,   17,   15,   89,  183,   82,   87,
721
       89,   83,   88,   90,  222,    5,   88,    4,  222,   88,
722
       90,  186,  196,  196,   86,  223,   88,   90,    3,  223,
723
      103,  103,  198,  198,   87,   88,   90,  115,   88,    0,
724
       88,   90,  103,  108,  108,  108,  115,   88,   90,    0,
725
      115,  108,  196,    0,    0,   87,   97,    0,  108,  115,
726
      103,    0,  198,    0,  103,   97,   97,  115,    0,    0,
727
 
728
        0,  115,    0,   97,   97,   97,   97,   97,   97,  112,
729
      112,  112,    0,  130,  130,  130,    0,  112,  199,  199,
730
      199,    0,    0,    0,  112,    0,   97,   97,   97,   97,
731
       97,  110,  130,    0,    0,  110,  110,  199,  110,    0,
732
      110,  158,  113,  113,  113,  110,  110,  110,  158,  110,
733
      113,  114,  114,  114,    0,  158,    0,  113,    0,  114,
734
      110,  110,  110,  110,  158,    0,  114,    0,  110,  158,
735
        0,    0,  110,    0,    0,    0,  158,  116,  116,  116,
736
        0,  110,  110,  110,  110,  116,  117,  117,  117,  110,
737
      139,  139,  116,  147,  117,  118,  118,  118,  119,  119,
738
 
739
      119,  117,  139,  118,  147,  121,  119,  120,  120,  120,
740
      118,  201,  201,  119,  121,  120,  147,  116,  121,    0,
741
      139,    0,  120,    0,  139,  147,    0,  121,  122,  122,
742
      122,    0,  123,  123,  123,  121,  122,    0,  116,  121,
743
      123,  201,  120,  122,  124,  124,  124,  123,  125,  126,
744
      202,  202,  124,    0,    0,    0,    0,  125,  126,  124,
745
        0,  125,  126,  120,    0,    0,  123,    0,    0,    0,
746
      125,  126,    0,    0,    0,    0,    0,    0,  125,  126,
747
      202,  124,  125,  126,  127,  127,  127,  123,    0,    0,
748
        0,    0,  127,  154,  154,  154,    0,    0,    0,  127,
749
 
750
        0,  154,  124,  132,  132,    0,    0,    0,  154,    0,
751
        0,  132,  132,  132,  132,  132,  132,  155,  155,  155,
752
      156,    0,    0,    0,    0,  155,    0,    0,    0,  156,
753
        0,    0,  155,  156,  132,  132,  132,  132,  132,    0,
754
        0,    0,  156,  157,  157,  157,    0,  159,  159,  159,
755
      156,  157,    0,    0,  156,  159,  161,    0,  157,  160,
756
      160,  160,  159,  161,    0,    0,    0,  160,    0,    0,
757
      161,    0,    0,    0,  160,  162,  162,  162,    0,  161,
758
      169,  169,  169,  162,  161,  178,  178,  178,  169,    0,
759
      162,  161,    0,  178,    0,  169,  179,  179,  179,    0,
760
 
761
      178,  180,  180,  180,  179,  193,  193,  193,    0,  180,
762
        0,  179,    0,  193,    0,    0,  180,  194,  194,  194,
763
      193,    0,    0,    0,    0,  194,    0,    0,    0,  180,
764
        0,    0,  194,    0,    0,    0,  179,    0,    0,    0,
765
        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
766
        0,  180,    0,    0,    0,    0,    0,  179,  204,  204,
767
      204,  204,  204,  204,  204,  204,  204,  204,  204,  204,
768
      204,  204,  205,    0,    0,  205,    0,    0,    0,  205,
769
      205,  205,  206,  206,  206,    0,    0,    0,    0,    0,
770
      206,    0,  206,    0,    0,  206,  206,  206,  207,    0,
771
 
772
      207,  207,  207,  208,  208,  208,    0,    0,    0,    0,
773
      208,  208,  208,    0,    0,    0,  208,  208,  208,  209,
774
      209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
775
      209,  209,  209,  209,  209,  209,  210,  210,    0,  210,
776
      210,  210,  210,  210,  210,  210,  210,  210,  210,  210,
777
      210,  210,  210,  211,  211,  211,  212,    0,    0,    0,
778
      212,  212,  212,  215,    0,    0,  215,  215,  215,  215,
779
      216,  216,  216,    0,  216,    0,    0,    0,    0,    0,
780
      216,    0,    0,  216,  216,  216,  217,    0,    0,    0,
781
        0,  217,    0,    0,    0,  217,  218,    0,    0,  218,
782
 
783
      218,  218,  218,  219,    0,    0,  219,  219,    0,    0,
784
        0,  219,    0,  219,  220,  220,  220,  221,  221,  221,
785
        0,    0,    0,    0,  221,  221,  221,    0,    0,    0,
786
      221,  221,  221,  224,    0,    0,  224,  224,  224,  224,
787
      225,    0,    0,    0,  225,    0,    0,    0,  225,    0,
788
      225,  203,  203,  203,  203,  203,  203,  203,  203,  203,
789
      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
790
      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
791
      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
792
      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
793
 
794
      203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
795
      203,  203,  203,  203,  203,  203,  203,  203,  203
796
    } ;
797
 
798
static yy_state_type yy_last_accepting_state;
799
static char *yy_last_accepting_cpos;
800
 
801
extern int yy_flex_debug;
802
int yy_flex_debug = 0;
803
 
804
/* The intent behind this definition is that it'll catch
805
 * any uses of REJECT which flex missed.
806
 */
807
#define REJECT reject_used_but_not_detected
808
#define yymore() yymore_used_but_not_detected
809
#define YY_MORE_ADJ 0
810
#define YY_RESTORE_YY_MORE_OFFSET
811
char *yytext;
812
#line 1 "../../gdb-7.2/gdb/ada-lex.l"
813
/* FLEX lexer for Ada expressions, for GDB.
814
   Copyright (C) 1994, 1997, 1998, 2000, 2001, 2002, 2003, 2007, 2008, 2009,
815
   2010 Free Software Foundation, Inc.
816
 
817
   This file is part of GDB.
818
 
819
   This program is free software; you can redistribute it and/or modify
820
   it under the terms of the GNU General Public License as published by
821
   the Free Software Foundation; either version 3 of the License, or
822
   (at your option) any later version.
823
 
824
   This program is distributed in the hope that it will be useful,
825
   but WITHOUT ANY WARRANTY; without even the implied warranty of
826
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
827
   GNU General Public License for more details.
828
 
829
   You should have received a copy of the GNU General Public License
830
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
831
/*----------------------------------------------------------------------*/
832
/* The converted version of this file is to be included in ada-exp.y, */
833
/* the Ada parser for gdb.  The function yylex obtains characters from */
834
/* the global pointer lexptr.  It returns a syntactic category for */
835
/* each successive token and places a semantic value into yylval */
836
/* (ada-lval), defined by the parser.   */
837
#line 44 "../../gdb-7.2/gdb/ada-lex.l"
838
 
839
#define NUMERAL_WIDTH 256
840
#define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
841
 
842
/* Temporary staging for numeric literals.  */
843
static char numbuf[NUMERAL_WIDTH];
844
 static void canonicalizeNumeral (char *s1, const char *);
845
static struct stoken processString (const char*, int);
846
static int processInt (const char *, const char *, const char *);
847
static int processReal (const char *);
848
static struct stoken processId (const char *, int);
849
static int processAttribute (const char *);
850
static int find_dot_all (const char *);
851
 
852
#undef YY_DECL
853
#define YY_DECL static int yylex ( void )
854
 
855
/* Flex generates a static function "input" which is not used.
856
   Defining YY_NO_INPUT comments it out.  */
857
#define YY_NO_INPUT
858
 
859
#undef YY_INPUT
860
#define YY_INPUT(BUF, RESULT, MAX_SIZE) \
861
    if ( *lexptr == '\000' ) \
862
      (RESULT) = YY_NULL; \
863
    else \
864
      { \
865
        *(BUF) = *lexptr; \
866
        (RESULT) = 1; \
867
        lexptr += 1; \
868
      }
869
 
870
static int find_dot_all (const char *);
871
 
872
 
873
#line 874 "../../gdb-7.2/gdb/ada-lex.c"
874
 
875
#define INITIAL 0
876
#define BEFORE_QUAL_QUOTE 1
877
 
878
#ifndef YY_NO_UNISTD_H
879
/* Special case for "unistd.h", since it is non-ANSI. We include it way
880
 * down here because we want the user's section 1 to have been scanned first.
881
 * The user has a chance to override it with an option.
882
 */
883
#include <unistd.h>
884
#endif
885
 
886
#ifndef YY_EXTRA_TYPE
887
#define YY_EXTRA_TYPE void *
888
#endif
889
 
890
static int yy_init_globals (void );
891
 
892
/* Accessor methods to globals.
893
   These are made visible to non-reentrant scanners for convenience. */
894
 
895
int yylex_destroy (void );
896
 
897
int yyget_debug (void );
898
 
899
void yyset_debug (int debug_flag  );
900
 
901
YY_EXTRA_TYPE yyget_extra (void );
902
 
903
void yyset_extra (YY_EXTRA_TYPE user_defined  );
904
 
905
FILE *yyget_in (void );
906
 
907
void yyset_in  (FILE * in_str  );
908
 
909
FILE *yyget_out (void );
910
 
911
void yyset_out  (FILE * out_str  );
912
 
913
int yyget_leng (void );
914
 
915
char *yyget_text (void );
916
 
917
int yyget_lineno (void );
918
 
919
void yyset_lineno (int line_number  );
920
 
921
/* Macros after this point can all be overridden by user definitions in
922
 * section 1.
923
 */
924
 
925
#ifndef YY_SKIP_YYWRAP
926
#ifdef __cplusplus
927
extern "C" int yywrap (void );
928
#else
929
extern int yywrap (void );
930
#endif
931
#endif
932
 
933
    static void yyunput (int c,char *buf_ptr  );
934
 
935
#ifndef yytext_ptr
936
static void yy_flex_strncpy (char *,yyconst char *,int );
937
#endif
938
 
939
#ifdef YY_NEED_STRLEN
940
static int yy_flex_strlen (yyconst char * );
941
#endif
942
 
943
#ifndef YY_NO_INPUT
944
 
945
#ifdef __cplusplus
946
static int yyinput (void );
947
#else
948
static int input (void );
949
#endif
950
 
951
#endif
952
 
953
/* Amount of stuff to slurp up with each read. */
954
#ifndef YY_READ_BUF_SIZE
955
#define YY_READ_BUF_SIZE 8192
956
#endif
957
 
958
/* Copy whatever the last rule matched to the standard output. */
959
#ifndef ECHO
960
/* This used to be an fputs(), but since the string might contain NUL's,
961
 * we now use fwrite().
962
 */
963
#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
964
#endif
965
 
966
/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
967
 * is returned in "result".
968
 */
969
#ifndef YY_INPUT
970
#define YY_INPUT(buf,result,max_size) \
971
        if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
972
                { \
973
                int c = '*'; \
974
                unsigned n; \
975
                for ( n = 0; n < max_size && \
976
                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
977
                        buf[n] = (char) c; \
978
                if ( c == '\n' ) \
979
                        buf[n++] = (char) c; \
980
                if ( c == EOF && ferror( yyin ) ) \
981
                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
982
                result = n; \
983
                } \
984
        else \
985
                { \
986
                errno=0; \
987
                while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
988
                        { \
989
                        if( errno != EINTR) \
990
                                { \
991
                                YY_FATAL_ERROR( "input in flex scanner failed" ); \
992
                                break; \
993
                                } \
994
                        errno=0; \
995
                        clearerr(yyin); \
996
                        } \
997
                }\
998
\
999
 
1000
#endif
1001
 
1002
/* No semi-colon after return; correct usage is to write "yyterminate();" -
1003
 * we don't want an extra ';' after the "return" because that will cause
1004
 * some compilers to complain about unreachable statements.
1005
 */
1006
#ifndef yyterminate
1007
#define yyterminate() return YY_NULL
1008
#endif
1009
 
1010
/* Number of entries by which start-condition stack grows. */
1011
#ifndef YY_START_STACK_INCR
1012
#define YY_START_STACK_INCR 25
1013
#endif
1014
 
1015
/* Report a fatal error. */
1016
#ifndef YY_FATAL_ERROR
1017
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1018
#endif
1019
 
1020
/* end tables serialization structures and prototypes */
1021
 
1022
/* Default declaration of generated scanner - a define so the user can
1023
 * easily add parameters.
1024
 */
1025
#ifndef YY_DECL
1026
#define YY_DECL_IS_OURS 1
1027
 
1028
extern int yylex (void);
1029
 
1030
#define YY_DECL int yylex (void)
1031
#endif /* !YY_DECL */
1032
 
1033
/* Code executed at the beginning of each rule, after yytext and yyleng
1034
 * have been set up.
1035
 */
1036
#ifndef YY_USER_ACTION
1037
#define YY_USER_ACTION
1038
#endif
1039
 
1040
/* Code executed at the end of each rule. */
1041
#ifndef YY_BREAK
1042
#define YY_BREAK break;
1043
#endif
1044
 
1045
#define YY_RULE_SETUP \
1046
        YY_USER_ACTION
1047
 
1048
/** The main scanner function which does all the work.
1049
 */
1050
YY_DECL
1051
{
1052
        register yy_state_type yy_current_state;
1053
        register char *yy_cp, *yy_bp;
1054
        register int yy_act;
1055
 
1056
#line 84 "../../gdb-7.2/gdb/ada-lex.l"
1057
 
1058
 
1059
#line 1060 "../../gdb-7.2/gdb/ada-lex.c"
1060
 
1061
        if ( !(yy_init) )
1062
                {
1063
                (yy_init) = 1;
1064
 
1065
#ifdef YY_USER_INIT
1066
                YY_USER_INIT;
1067
#endif
1068
 
1069
                if ( ! (yy_start) )
1070
                        (yy_start) = 1; /* first start state */
1071
 
1072
                if ( ! yyin )
1073
                        yyin = stdin;
1074
 
1075
                if ( ! yyout )
1076
                        yyout = stdout;
1077
 
1078
                if ( ! YY_CURRENT_BUFFER ) {
1079
                        yyensure_buffer_stack ();
1080
                        YY_CURRENT_BUFFER_LVALUE =
1081
                                yy_create_buffer(yyin,YY_BUF_SIZE );
1082
                }
1083
 
1084
                yy_load_buffer_state( );
1085
                }
1086
 
1087
        while ( 1 )             /* loops until end-of-file is reached */
1088
                {
1089
                yy_cp = (yy_c_buf_p);
1090
 
1091
                /* Support of yytext. */
1092
                *yy_cp = (yy_hold_char);
1093
 
1094
                /* yy_bp points to the position in yy_ch_buf of the start of
1095
                 * the current run.
1096
                 */
1097
                yy_bp = yy_cp;
1098
 
1099
                yy_current_state = (yy_start);
1100
yy_match:
1101
                do
1102
                        {
1103
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1104
                        if ( yy_accept[yy_current_state] )
1105
                                {
1106
                                (yy_last_accepting_state) = yy_current_state;
1107
                                (yy_last_accepting_cpos) = yy_cp;
1108
                                }
1109
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1110
                                {
1111
                                yy_current_state = (int) yy_def[yy_current_state];
1112
                                if ( yy_current_state >= 204 )
1113
                                        yy_c = yy_meta[(unsigned int) yy_c];
1114
                                }
1115
                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1116
                        ++yy_cp;
1117
                        }
1118
                while ( yy_base[yy_current_state] != 1252 );
1119
 
1120
yy_find_action:
1121
                yy_act = yy_accept[yy_current_state];
1122
                if ( yy_act == 0 )
1123
                        { /* have to back up */
1124
                        yy_cp = (yy_last_accepting_cpos);
1125
                        yy_current_state = (yy_last_accepting_state);
1126
                        yy_act = yy_accept[yy_current_state];
1127
                        }
1128
 
1129
                YY_DO_BEFORE_ACTION;
1130
 
1131
do_action:      /* This label is used only to access EOF actions. */
1132
 
1133
                switch ( yy_act )
1134
        { /* beginning of action switch */
1135
                        case 0: /* must back up */
1136
                        /* undo the effects of YY_DO_BEFORE_ACTION */
1137
                        *yy_cp = (yy_hold_char);
1138
                        yy_cp = (yy_last_accepting_cpos);
1139
                        yy_current_state = (yy_last_accepting_state);
1140
                        goto yy_find_action;
1141
 
1142
case 1:
1143
/* rule 1 can match eol */
1144
YY_RULE_SETUP
1145
#line 86 "../../gdb-7.2/gdb/ada-lex.l"
1146
{ }
1147
        YY_BREAK
1148
case 2:
1149
YY_RULE_SETUP
1150
#line 88 "../../gdb-7.2/gdb/ada-lex.l"
1151
{ yyterminate(); }
1152
        YY_BREAK
1153
case 3:
1154
YY_RULE_SETUP
1155
#line 90 "../../gdb-7.2/gdb/ada-lex.l"
1156
{
1157
                   canonicalizeNumeral (numbuf, yytext);
1158
                   return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1);
1159
                 }
1160
        YY_BREAK
1161
case 4:
1162
YY_RULE_SETUP
1163
#line 95 "../../gdb-7.2/gdb/ada-lex.l"
1164
{
1165
                   canonicalizeNumeral (numbuf, yytext);
1166
                   return processInt (NULL, numbuf, NULL);
1167
                 }
1168
        YY_BREAK
1169
case 5:
1170
YY_RULE_SETUP
1171
#line 100 "../../gdb-7.2/gdb/ada-lex.l"
1172
{
1173
                   canonicalizeNumeral (numbuf, yytext);
1174
                   return processInt (numbuf,
1175
                                      strchr (numbuf, '#') + 1,
1176
                                      strrchr(numbuf, '#') + 1);
1177
                 }
1178
        YY_BREAK
1179
case 6:
1180
YY_RULE_SETUP
1181
#line 107 "../../gdb-7.2/gdb/ada-lex.l"
1182
{
1183
                   canonicalizeNumeral (numbuf, yytext);
1184
                   return processInt (numbuf, strchr (numbuf, '#') + 1, NULL);
1185
                 }
1186
        YY_BREAK
1187
case 7:
1188
YY_RULE_SETUP
1189
#line 112 "../../gdb-7.2/gdb/ada-lex.l"
1190
{
1191
                  canonicalizeNumeral (numbuf, yytext+2);
1192
                  return processInt ("16#", numbuf, NULL);
1193
                }
1194
        YY_BREAK
1195
case 8:
1196
YY_RULE_SETUP
1197
#line 118 "../../gdb-7.2/gdb/ada-lex.l"
1198
{
1199
                   canonicalizeNumeral (numbuf, yytext);
1200
                   return processReal (numbuf);
1201
                }
1202
        YY_BREAK
1203
case 9:
1204
YY_RULE_SETUP
1205
#line 123 "../../gdb-7.2/gdb/ada-lex.l"
1206
{
1207
                   canonicalizeNumeral (numbuf, yytext);
1208
                   return processReal (numbuf);
1209
                }
1210
        YY_BREAK
1211
case 10:
1212
YY_RULE_SETUP
1213
#line 128 "../../gdb-7.2/gdb/ada-lex.l"
1214
{
1215
                   error (_("Based real literals not implemented yet."));
1216
                }
1217
        YY_BREAK
1218
case 11:
1219
YY_RULE_SETUP
1220
#line 132 "../../gdb-7.2/gdb/ada-lex.l"
1221
{
1222
                   error (_("Based real literals not implemented yet."));
1223
                }
1224
        YY_BREAK
1225
case 12:
1226
YY_RULE_SETUP
1227
#line 136 "../../gdb-7.2/gdb/ada-lex.l"
1228
{
1229
                   yylval.typed_val.type = type_char ();
1230
                   yylval.typed_val.val = yytext[1];
1231
                   return CHARLIT;
1232
                }
1233
        YY_BREAK
1234
case 13:
1235
YY_RULE_SETUP
1236
#line 142 "../../gdb-7.2/gdb/ada-lex.l"
1237
{
1238
                   int v;
1239
                   yylval.typed_val.type = type_char ();
1240
                   sscanf (yytext+3, "%2x", &v);
1241
                   yylval.typed_val.val = v;
1242
                   return CHARLIT;
1243
                }
1244
        YY_BREAK
1245
case 14:
1246
YY_RULE_SETUP
1247
#line 150 "../../gdb-7.2/gdb/ada-lex.l"
1248
{
1249
                   yylval.sval = processString (yytext+1, yyleng-2);
1250
                   return STRING;
1251
                }
1252
        YY_BREAK
1253
case 15:
1254
YY_RULE_SETUP
1255
#line 155 "../../gdb-7.2/gdb/ada-lex.l"
1256
{
1257
                   error (_("ill-formed or non-terminated string literal"));
1258
                }
1259
        YY_BREAK
1260
case 16:
1261
YY_RULE_SETUP
1262
#line 160 "../../gdb-7.2/gdb/ada-lex.l"
1263
{
1264
                  while (*lexptr != 'i' && *lexptr != 'I')
1265
                    lexptr -= 1;
1266
                  yyrestart(NULL);
1267
                  return 0;
1268
                }
1269
        YY_BREAK
1270
case 17:
1271
YY_RULE_SETUP
1272
#line 167 "../../gdb-7.2/gdb/ada-lex.l"
1273
{
1274
                  /* This keyword signals the end of the expression and
1275
                     will be processed separately.  */
1276
                  while (*lexptr != 't' && *lexptr != 'T')
1277
                    lexptr--;
1278
                  yyrestart(NULL);
1279
                  return 0;
1280
                }
1281
        YY_BREAK
1282
/* ADA KEYWORDS */
1283
case 18:
1284
YY_RULE_SETUP
1285
#line 178 "../../gdb-7.2/gdb/ada-lex.l"
1286
{ return ABS; }
1287
        YY_BREAK
1288
case 19:
1289
YY_RULE_SETUP
1290
#line 179 "../../gdb-7.2/gdb/ada-lex.l"
1291
{ return _AND_; }
1292
        YY_BREAK
1293
case 20:
1294
YY_RULE_SETUP
1295
#line 180 "../../gdb-7.2/gdb/ada-lex.l"
1296
{ return ELSE; }
1297
        YY_BREAK
1298
case 21:
1299
YY_RULE_SETUP
1300
#line 181 "../../gdb-7.2/gdb/ada-lex.l"
1301
{ return IN; }
1302
        YY_BREAK
1303
case 22:
1304
YY_RULE_SETUP
1305
#line 182 "../../gdb-7.2/gdb/ada-lex.l"
1306
{ return MOD; }
1307
        YY_BREAK
1308
case 23:
1309
YY_RULE_SETUP
1310
#line 183 "../../gdb-7.2/gdb/ada-lex.l"
1311
{ return NEW; }
1312
        YY_BREAK
1313
case 24:
1314
YY_RULE_SETUP
1315
#line 184 "../../gdb-7.2/gdb/ada-lex.l"
1316
{ return NOT; }
1317
        YY_BREAK
1318
case 25:
1319
YY_RULE_SETUP
1320
#line 185 "../../gdb-7.2/gdb/ada-lex.l"
1321
{ return NULL_PTR; }
1322
        YY_BREAK
1323
case 26:
1324
YY_RULE_SETUP
1325
#line 186 "../../gdb-7.2/gdb/ada-lex.l"
1326
{ return OR; }
1327
        YY_BREAK
1328
case 27:
1329
YY_RULE_SETUP
1330
#line 187 "../../gdb-7.2/gdb/ada-lex.l"
1331
{ return OTHERS; }
1332
        YY_BREAK
1333
case 28:
1334
YY_RULE_SETUP
1335
#line 188 "../../gdb-7.2/gdb/ada-lex.l"
1336
{ return REM; }
1337
        YY_BREAK
1338
case 29:
1339
YY_RULE_SETUP
1340
#line 189 "../../gdb-7.2/gdb/ada-lex.l"
1341
{ return THEN; }
1342
        YY_BREAK
1343
case 30:
1344
YY_RULE_SETUP
1345
#line 190 "../../gdb-7.2/gdb/ada-lex.l"
1346
{ return XOR; }
1347
        YY_BREAK
1348
/* BOOLEAN "KEYWORDS" */
1349
/* True and False are not keywords in Ada, but rather enumeration constants.
1350
    However, the boolean type is no longer represented as an enum, so True
1351
    and False are no longer defined in symbol tables.  We compromise by
1352
    making them keywords (when bare). */
1353
case 31:
1354
YY_RULE_SETUP
1355
#line 199 "../../gdb-7.2/gdb/ada-lex.l"
1356
{ return TRUEKEYWORD; }
1357
        YY_BREAK
1358
case 32:
1359
YY_RULE_SETUP
1360
#line 200 "../../gdb-7.2/gdb/ada-lex.l"
1361
{ return FALSEKEYWORD; }
1362
        YY_BREAK
1363
/* ATTRIBUTES */
1364
case 33:
1365
/* rule 33 can match eol */
1366
YY_RULE_SETUP
1367
#line 204 "../../gdb-7.2/gdb/ada-lex.l"
1368
{ return processAttribute (yytext+1); }
1369
        YY_BREAK
1370
/* PUNCTUATION */
1371
case 34:
1372
YY_RULE_SETUP
1373
#line 208 "../../gdb-7.2/gdb/ada-lex.l"
1374
{ return ARROW; }
1375
        YY_BREAK
1376
case 35:
1377
YY_RULE_SETUP
1378
#line 209 "../../gdb-7.2/gdb/ada-lex.l"
1379
{ return DOTDOT; }
1380
        YY_BREAK
1381
case 36:
1382
YY_RULE_SETUP
1383
#line 210 "../../gdb-7.2/gdb/ada-lex.l"
1384
{ return STARSTAR; }
1385
        YY_BREAK
1386
case 37:
1387
YY_RULE_SETUP
1388
#line 211 "../../gdb-7.2/gdb/ada-lex.l"
1389
{ return ASSIGN; }
1390
        YY_BREAK
1391
case 38:
1392
YY_RULE_SETUP
1393
#line 212 "../../gdb-7.2/gdb/ada-lex.l"
1394
{ return NOTEQUAL; }
1395
        YY_BREAK
1396
case 39:
1397
YY_RULE_SETUP
1398
#line 213 "../../gdb-7.2/gdb/ada-lex.l"
1399
{ return LEQ; }
1400
        YY_BREAK
1401
case 40:
1402
YY_RULE_SETUP
1403
#line 214 "../../gdb-7.2/gdb/ada-lex.l"
1404
{ return GEQ; }
1405
        YY_BREAK
1406
case 41:
1407
YY_RULE_SETUP
1408
#line 216 "../../gdb-7.2/gdb/ada-lex.l"
1409
{ BEGIN INITIAL; return '\''; }
1410
        YY_BREAK
1411
case 42:
1412
YY_RULE_SETUP
1413
#line 218 "../../gdb-7.2/gdb/ada-lex.l"
1414
{ return yytext[0]; }
1415
        YY_BREAK
1416
case 43:
1417
YY_RULE_SETUP
1418
#line 220 "../../gdb-7.2/gdb/ada-lex.l"
1419
{ if (paren_depth == 0 && comma_terminates)
1420
                    {
1421
                      lexptr -= 1;
1422
                      yyrestart(NULL);
1423
                      return 0;
1424
                    }
1425
                  else
1426
                    return ',';
1427
                }
1428
        YY_BREAK
1429
case 44:
1430
YY_RULE_SETUP
1431
#line 230 "../../gdb-7.2/gdb/ada-lex.l"
1432
{ paren_depth += 1; return '('; }
1433
        YY_BREAK
1434
case 45:
1435
YY_RULE_SETUP
1436
#line 231 "../../gdb-7.2/gdb/ada-lex.l"
1437
{ if (paren_depth == 0)
1438
                    {
1439
                      lexptr -= 1;
1440
                      yyrestart(NULL);
1441
                      return 0;
1442
                    }
1443
                  else
1444
                    {
1445
                      paren_depth -= 1;
1446
                      return ')';
1447
                    }
1448
                }
1449
        YY_BREAK
1450
case 46:
1451
/* rule 46 can match eol */
1452
YY_RULE_SETUP
1453
#line 244 "../../gdb-7.2/gdb/ada-lex.l"
1454
{ return DOT_ALL; }
1455
        YY_BREAK
1456
case 47:
1457
/* rule 47 can match eol */
1458
YY_RULE_SETUP
1459
#line 246 "../../gdb-7.2/gdb/ada-lex.l"
1460
{
1461
                  yylval.sval = processId (yytext+1, yyleng-1);
1462
                  return DOT_ID;
1463
                }
1464
        YY_BREAK
1465
case 48:
1466
/* rule 48 can match eol */
1467
YY_RULE_SETUP
1468
#line 251 "../../gdb-7.2/gdb/ada-lex.l"
1469
{
1470
                  int all_posn = find_dot_all (yytext);
1471
 
1472
                  if (all_posn == -1 && yytext[yyleng-1] == '\'')
1473
                    {
1474
                      BEGIN BEFORE_QUAL_QUOTE;
1475
                      yyless (yyleng-1);
1476
                    }
1477
                  else if (all_posn >= 0)
1478
                    yyless (all_posn);
1479
                  yylval.sval = processId (yytext, yyleng);
1480
                  return NAME;
1481
               }
1482
        YY_BREAK
1483
/* GDB EXPRESSION CONSTRUCTS  */
1484
case 49:
1485
/* rule 49 can match eol */
1486
YY_RULE_SETUP
1487
#line 268 "../../gdb-7.2/gdb/ada-lex.l"
1488
{
1489
                  yyless (yyleng - 2);
1490
                  yylval.sval = processId (yytext, yyleng);
1491
                  return NAME;
1492
                }
1493
        YY_BREAK
1494
case 50:
1495
YY_RULE_SETUP
1496
#line 274 "../../gdb-7.2/gdb/ada-lex.l"
1497
{ return COLONCOLON; }
1498
        YY_BREAK
1499
case 51:
1500
YY_RULE_SETUP
1501
#line 276 "../../gdb-7.2/gdb/ada-lex.l"
1502
{ return yytext[0]; }
1503
        YY_BREAK
1504
/* REGISTERS AND GDB CONVENIENCE VARIABLES */
1505
case 52:
1506
YY_RULE_SETUP
1507
#line 280 "../../gdb-7.2/gdb/ada-lex.l"
1508
{
1509
                  yylval.sval.ptr = yytext;
1510
                  yylval.sval.length = yyleng;
1511
                  return SPECIAL_VARIABLE;
1512
                }
1513
        YY_BREAK
1514
/* CATCH-ALL ERROR CASE */
1515
case 53:
1516
YY_RULE_SETUP
1517
#line 288 "../../gdb-7.2/gdb/ada-lex.l"
1518
{ error (_("Invalid character '%s' in expression."), yytext); }
1519
        YY_BREAK
1520
case 54:
1521
YY_RULE_SETUP
1522
#line 289 "../../gdb-7.2/gdb/ada-lex.l"
1523
YY_FATAL_ERROR( "flex scanner jammed" );
1524
        YY_BREAK
1525
#line 1526 "../../gdb-7.2/gdb/ada-lex.c"
1526
case YY_STATE_EOF(INITIAL):
1527
case YY_STATE_EOF(BEFORE_QUAL_QUOTE):
1528
        yyterminate();
1529
 
1530
        case YY_END_OF_BUFFER:
1531
                {
1532
                /* Amount of text matched not including the EOB char. */
1533
                int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1534
 
1535
                /* Undo the effects of YY_DO_BEFORE_ACTION. */
1536
                *yy_cp = (yy_hold_char);
1537
                YY_RESTORE_YY_MORE_OFFSET
1538
 
1539
                if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1540
                        {
1541
                        /* We're scanning a new file or input source.  It's
1542
                         * possible that this happened because the user
1543
                         * just pointed yyin at a new source and called
1544
                         * yylex().  If so, then we have to assure
1545
                         * consistency between YY_CURRENT_BUFFER and our
1546
                         * globals.  Here is the right place to do so, because
1547
                         * this is the first action (other than possibly a
1548
                         * back-up) that will match for the new input source.
1549
                         */
1550
                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1551
                        YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1552
                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1553
                        }
1554
 
1555
                /* Note that here we test for yy_c_buf_p "<=" to the position
1556
                 * of the first EOB in the buffer, since yy_c_buf_p will
1557
                 * already have been incremented past the NUL character
1558
                 * (since all states make transitions on EOB to the
1559
                 * end-of-buffer state).  Contrast this with the test
1560
                 * in input().
1561
                 */
1562
                if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1563
                        { /* This was really a NUL. */
1564
                        yy_state_type yy_next_state;
1565
 
1566
                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1567
 
1568
                        yy_current_state = yy_get_previous_state(  );
1569
 
1570
                        /* Okay, we're now positioned to make the NUL
1571
                         * transition.  We couldn't have
1572
                         * yy_get_previous_state() go ahead and do it
1573
                         * for us because it doesn't know how to deal
1574
                         * with the possibility of jamming (and we don't
1575
                         * want to build jamming into it because then it
1576
                         * will run more slowly).
1577
                         */
1578
 
1579
                        yy_next_state = yy_try_NUL_trans( yy_current_state );
1580
 
1581
                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1582
 
1583
                        if ( yy_next_state )
1584
                                {
1585
                                /* Consume the NUL. */
1586
                                yy_cp = ++(yy_c_buf_p);
1587
                                yy_current_state = yy_next_state;
1588
                                goto yy_match;
1589
                                }
1590
 
1591
                        else
1592
                                {
1593
                                yy_cp = (yy_c_buf_p);
1594
                                goto yy_find_action;
1595
                                }
1596
                        }
1597
 
1598
                else switch ( yy_get_next_buffer(  ) )
1599
                        {
1600
                        case EOB_ACT_END_OF_FILE:
1601
                                {
1602
                                (yy_did_buffer_switch_on_eof) = 0;
1603
 
1604
                                if ( yywrap( ) )
1605
                                        {
1606
                                        /* Note: because we've taken care in
1607
                                         * yy_get_next_buffer() to have set up
1608
                                         * yytext, we can now set up
1609
                                         * yy_c_buf_p so that if some total
1610
                                         * hoser (like flex itself) wants to
1611
                                         * call the scanner after we return the
1612
                                         * YY_NULL, it'll still work - another
1613
                                         * YY_NULL will get returned.
1614
                                         */
1615
                                        (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1616
 
1617
                                        yy_act = YY_STATE_EOF(YY_START);
1618
                                        goto do_action;
1619
                                        }
1620
 
1621
                                else
1622
                                        {
1623
                                        if ( ! (yy_did_buffer_switch_on_eof) )
1624
                                                YY_NEW_FILE;
1625
                                        }
1626
                                break;
1627
                                }
1628
 
1629
                        case EOB_ACT_CONTINUE_SCAN:
1630
                                (yy_c_buf_p) =
1631
                                        (yytext_ptr) + yy_amount_of_matched_text;
1632
 
1633
                                yy_current_state = yy_get_previous_state(  );
1634
 
1635
                                yy_cp = (yy_c_buf_p);
1636
                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1637
                                goto yy_match;
1638
 
1639
                        case EOB_ACT_LAST_MATCH:
1640
                                (yy_c_buf_p) =
1641
                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1642
 
1643
                                yy_current_state = yy_get_previous_state(  );
1644
 
1645
                                yy_cp = (yy_c_buf_p);
1646
                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1647
                                goto yy_find_action;
1648
                        }
1649
                break;
1650
                }
1651
 
1652
        default:
1653
                YY_FATAL_ERROR(
1654
                        "fatal flex scanner internal error--no action found" );
1655
        } /* end of action switch */
1656
                } /* end of scanning one token */
1657
} /* end of yylex */
1658
 
1659
/* yy_get_next_buffer - try to read in a new buffer
1660
 *
1661
 * Returns a code representing an action:
1662
 *      EOB_ACT_LAST_MATCH -
1663
 *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1664
 *      EOB_ACT_END_OF_FILE - end of file
1665
 */
1666
static int yy_get_next_buffer (void)
1667
{
1668
        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1669
        register char *source = (yytext_ptr);
1670
        register int number_to_move, i;
1671
        int ret_val;
1672
 
1673
        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1674
                YY_FATAL_ERROR(
1675
                "fatal flex scanner internal error--end of buffer missed" );
1676
 
1677
        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1678
                { /* Don't try to fill the buffer, so this is an EOF. */
1679
                if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1680
                        {
1681
                        /* We matched a single character, the EOB, so
1682
                         * treat this as a final EOF.
1683
                         */
1684
                        return EOB_ACT_END_OF_FILE;
1685
                        }
1686
 
1687
                else
1688
                        {
1689
                        /* We matched some text prior to the EOB, first
1690
                         * process it.
1691
                         */
1692
                        return EOB_ACT_LAST_MATCH;
1693
                        }
1694
                }
1695
 
1696
        /* Try to read more data. */
1697
 
1698
        /* First move last chars to start of buffer. */
1699
        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1700
 
1701
        for ( i = 0; i < number_to_move; ++i )
1702
                *(dest++) = *(source++);
1703
 
1704
        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1705
                /* don't do the read, it's not guaranteed to return an EOF,
1706
                 * just force an EOF
1707
                 */
1708
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1709
 
1710
        else
1711
                {
1712
                        int num_to_read =
1713
                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1714
 
1715
                while ( num_to_read <= 0 )
1716
                        { /* Not enough room in the buffer - grow it. */
1717
 
1718
                        /* just a shorter name for the current buffer */
1719
                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1720
 
1721
                        int yy_c_buf_p_offset =
1722
                                (int) ((yy_c_buf_p) - b->yy_ch_buf);
1723
 
1724
                        if ( b->yy_is_our_buffer )
1725
                                {
1726
                                int new_size = b->yy_buf_size * 2;
1727
 
1728
                                if ( new_size <= 0 )
1729
                                        b->yy_buf_size += b->yy_buf_size / 8;
1730
                                else
1731
                                        b->yy_buf_size *= 2;
1732
 
1733
                                b->yy_ch_buf = (char *)
1734
                                        /* Include room in for 2 EOB chars. */
1735
                                        yyxrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1736
                                }
1737
                        else
1738
                                /* Can't grow it, we don't own it. */
1739
                                b->yy_ch_buf = 0;
1740
 
1741
                        if ( ! b->yy_ch_buf )
1742
                                YY_FATAL_ERROR(
1743
                                "fatal error - scanner input buffer overflow" );
1744
 
1745
                        (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1746
 
1747
                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1748
                                                number_to_move - 1;
1749
 
1750
                        }
1751
 
1752
                if ( num_to_read > YY_READ_BUF_SIZE )
1753
                        num_to_read = YY_READ_BUF_SIZE;
1754
 
1755
                /* Read in more data. */
1756
                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1757
                        (yy_n_chars), (size_t) num_to_read );
1758
 
1759
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1760
                }
1761
 
1762
        if ( (yy_n_chars) == 0 )
1763
                {
1764
                if ( number_to_move == YY_MORE_ADJ )
1765
                        {
1766
                        ret_val = EOB_ACT_END_OF_FILE;
1767
                        yyrestart(yyin  );
1768
                        }
1769
 
1770
                else
1771
                        {
1772
                        ret_val = EOB_ACT_LAST_MATCH;
1773
                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1774
                                YY_BUFFER_EOF_PENDING;
1775
                        }
1776
                }
1777
 
1778
        else
1779
                ret_val = EOB_ACT_CONTINUE_SCAN;
1780
 
1781
        if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1782
                /* Extend the array by 50%, plus the number we really need. */
1783
                yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1784
                YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyxrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1785
                if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1786
                        YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1787
        }
1788
 
1789
        (yy_n_chars) += number_to_move;
1790
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1791
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1792
 
1793
        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1794
 
1795
        return ret_val;
1796
}
1797
 
1798
/* yy_get_previous_state - get the state just before the EOB char was reached */
1799
 
1800
    static yy_state_type yy_get_previous_state (void)
1801
{
1802
        register yy_state_type yy_current_state;
1803
        register char *yy_cp;
1804
 
1805
        yy_current_state = (yy_start);
1806
 
1807
        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1808
                {
1809
                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1810
                if ( yy_accept[yy_current_state] )
1811
                        {
1812
                        (yy_last_accepting_state) = yy_current_state;
1813
                        (yy_last_accepting_cpos) = yy_cp;
1814
                        }
1815
                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1816
                        {
1817
                        yy_current_state = (int) yy_def[yy_current_state];
1818
                        if ( yy_current_state >= 204 )
1819
                                yy_c = yy_meta[(unsigned int) yy_c];
1820
                        }
1821
                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1822
                }
1823
 
1824
        return yy_current_state;
1825
}
1826
 
1827
/* yy_try_NUL_trans - try to make a transition on the NUL character
1828
 *
1829
 * synopsis
1830
 *      next_state = yy_try_NUL_trans( current_state );
1831
 */
1832
    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1833
{
1834
        register int yy_is_jam;
1835
        register char *yy_cp = (yy_c_buf_p);
1836
 
1837
        register YY_CHAR yy_c = 1;
1838
        if ( yy_accept[yy_current_state] )
1839
                {
1840
                (yy_last_accepting_state) = yy_current_state;
1841
                (yy_last_accepting_cpos) = yy_cp;
1842
                }
1843
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1844
                {
1845
                yy_current_state = (int) yy_def[yy_current_state];
1846
                if ( yy_current_state >= 204 )
1847
                        yy_c = yy_meta[(unsigned int) yy_c];
1848
                }
1849
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1850
        yy_is_jam = (yy_current_state == 203);
1851
 
1852
        return yy_is_jam ? 0 : yy_current_state;
1853
}
1854
 
1855
    static void yyunput (int c, register char * yy_bp )
1856
{
1857
        register char *yy_cp;
1858
 
1859
    yy_cp = (yy_c_buf_p);
1860
 
1861
        /* undo effects of setting up yytext */
1862
        *yy_cp = (yy_hold_char);
1863
 
1864
        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1865
                { /* need to shift things up to make room */
1866
                /* +2 for EOB chars. */
1867
                register int number_to_move = (yy_n_chars) + 2;
1868
                register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1869
                                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1870
                register char *source =
1871
                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1872
 
1873
                while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1874
                        *--dest = *--source;
1875
 
1876
                yy_cp += (int) (dest - source);
1877
                yy_bp += (int) (dest - source);
1878
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1879
                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1880
 
1881
                if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1882
                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
1883
                }
1884
 
1885
        *--yy_cp = (char) c;
1886
 
1887
        (yytext_ptr) = yy_bp;
1888
        (yy_hold_char) = *yy_cp;
1889
        (yy_c_buf_p) = yy_cp;
1890
}
1891
 
1892
#ifndef YY_NO_INPUT
1893
#ifdef __cplusplus
1894
    static int yyinput (void)
1895
#else
1896
    static int input  (void)
1897
#endif
1898
 
1899
{
1900
        int c;
1901
 
1902
        *(yy_c_buf_p) = (yy_hold_char);
1903
 
1904
        if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1905
                {
1906
                /* yy_c_buf_p now points to the character we want to return.
1907
                 * If this occurs *before* the EOB characters, then it's a
1908
                 * valid NUL; if not, then we've hit the end of the buffer.
1909
                 */
1910
                if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1911
                        /* This was really a NUL. */
1912
                        *(yy_c_buf_p) = '\0';
1913
 
1914
                else
1915
                        { /* need more input */
1916
                        int offset = (yy_c_buf_p) - (yytext_ptr);
1917
                        ++(yy_c_buf_p);
1918
 
1919
                        switch ( yy_get_next_buffer(  ) )
1920
                                {
1921
                                case EOB_ACT_LAST_MATCH:
1922
                                        /* This happens because yy_g_n_b()
1923
                                         * sees that we've accumulated a
1924
                                         * token and flags that we need to
1925
                                         * try matching the token before
1926
                                         * proceeding.  But for input(),
1927
                                         * there's no matching to consider.
1928
                                         * So convert the EOB_ACT_LAST_MATCH
1929
                                         * to EOB_ACT_END_OF_FILE.
1930
                                         */
1931
 
1932
                                        /* Reset buffer status. */
1933
                                        yyrestart(yyin );
1934
 
1935
                                        /*FALLTHROUGH*/
1936
 
1937
                                case EOB_ACT_END_OF_FILE:
1938
                                        {
1939
                                        if ( yywrap( ) )
1940
                                                return EOF;
1941
 
1942
                                        if ( ! (yy_did_buffer_switch_on_eof) )
1943
                                                YY_NEW_FILE;
1944
#ifdef __cplusplus
1945
                                        return yyinput();
1946
#else
1947
                                        return input();
1948
#endif
1949
                                        }
1950
 
1951
                                case EOB_ACT_CONTINUE_SCAN:
1952
                                        (yy_c_buf_p) = (yytext_ptr) + offset;
1953
                                        break;
1954
                                }
1955
                        }
1956
                }
1957
 
1958
        c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1959
        *(yy_c_buf_p) = '\0';   /* preserve yytext */
1960
        (yy_hold_char) = *++(yy_c_buf_p);
1961
 
1962
        return c;
1963
}
1964
#endif  /* ifndef YY_NO_INPUT */
1965
 
1966
/** Immediately switch to a different input stream.
1967
 * @param input_file A readable stream.
1968
 *
1969
 * @note This function does not reset the start condition to @c INITIAL .
1970
 */
1971
    void yyrestart  (FILE * input_file )
1972
{
1973
 
1974
        if ( ! YY_CURRENT_BUFFER ){
1975
        yyensure_buffer_stack ();
1976
                YY_CURRENT_BUFFER_LVALUE =
1977
            yy_create_buffer(yyin,YY_BUF_SIZE );
1978
        }
1979
 
1980
        yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1981
        yy_load_buffer_state( );
1982
}
1983
 
1984
/** Switch to a different input buffer.
1985
 * @param new_buffer The new input buffer.
1986
 *
1987
 */
1988
    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1989
{
1990
 
1991
        /* TODO. We should be able to replace this entire function body
1992
         * with
1993
         *              yypop_buffer_state();
1994
         *              yypush_buffer_state(new_buffer);
1995
     */
1996
        yyensure_buffer_stack ();
1997
        if ( YY_CURRENT_BUFFER == new_buffer )
1998
                return;
1999
 
2000
        if ( YY_CURRENT_BUFFER )
2001
                {
2002
                /* Flush out information for old buffer. */
2003
                *(yy_c_buf_p) = (yy_hold_char);
2004
                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2005
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2006
                }
2007
 
2008
        YY_CURRENT_BUFFER_LVALUE = new_buffer;
2009
        yy_load_buffer_state( );
2010
 
2011
        /* We don't actually know whether we did this switch during
2012
         * EOF (yywrap()) processing, but the only time this flag
2013
         * is looked at is after yywrap() is called, so it's safe
2014
         * to go ahead and always set it.
2015
         */
2016
        (yy_did_buffer_switch_on_eof) = 1;
2017
}
2018
 
2019
static void yy_load_buffer_state  (void)
2020
{
2021
        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2022
        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2023
        yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2024
        (yy_hold_char) = *(yy_c_buf_p);
2025
}
2026
 
2027
/** Allocate and initialize an input buffer state.
2028
 * @param file A readable stream.
2029
 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2030
 *
2031
 * @return the allocated buffer state.
2032
 */
2033
    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
2034
{
2035
        YY_BUFFER_STATE b;
2036
 
2037
        b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2038
        if ( ! b )
2039
                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2040
 
2041
        b->yy_buf_size = size;
2042
 
2043
        /* yy_ch_buf has to be 2 characters longer than the size given because
2044
         * we need to put in 2 end-of-buffer characters.
2045
         */
2046
        b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
2047
        if ( ! b->yy_ch_buf )
2048
                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2049
 
2050
        b->yy_is_our_buffer = 1;
2051
 
2052
        yy_init_buffer(b,file );
2053
 
2054
        return b;
2055
}
2056
 
2057
/** Destroy the buffer.
2058
 * @param b a buffer created with yy_create_buffer()
2059
 *
2060
 */
2061
    void yy_delete_buffer (YY_BUFFER_STATE  b )
2062
{
2063
 
2064
        if ( ! b )
2065
                return;
2066
 
2067
        if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2068
                YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2069
 
2070
        if ( b->yy_is_our_buffer )
2071
                yyfree((void *) b->yy_ch_buf  );
2072
 
2073
        yyfree((void *) b  );
2074
}
2075
 
2076
#ifndef __cplusplus
2077
extern int isatty (int );
2078
#endif /* __cplusplus */
2079
 
2080
/* Initializes or reinitializes a buffer.
2081
 * This function is sometimes called more than once on the same buffer,
2082
 * such as during a yyrestart() or at EOF.
2083
 */
2084
    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
2085
 
2086
{
2087
        int oerrno = errno;
2088
 
2089
        yy_flush_buffer(b );
2090
 
2091
        b->yy_input_file = file;
2092
        b->yy_fill_buffer = 1;
2093
 
2094
    /* If b is the current buffer, then yy_init_buffer was _probably_
2095
     * called from yyrestart() or through yy_get_next_buffer.
2096
     * In that case, we don't want to reset the lineno or column.
2097
     */
2098
    if (b != YY_CURRENT_BUFFER){
2099
        b->yy_bs_lineno = 1;
2100
        b->yy_bs_column = 0;
2101
    }
2102
 
2103
        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2104
 
2105
        errno = oerrno;
2106
}
2107
 
2108
/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2109
 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2110
 *
2111
 */
2112
    void yy_flush_buffer (YY_BUFFER_STATE  b )
2113
{
2114
        if ( ! b )
2115
                return;
2116
 
2117
        b->yy_n_chars = 0;
2118
 
2119
        /* We always need two end-of-buffer characters.  The first causes
2120
         * a transition to the end-of-buffer state.  The second causes
2121
         * a jam in that state.
2122
         */
2123
        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2124
        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2125
 
2126
        b->yy_buf_pos = &b->yy_ch_buf[0];
2127
 
2128
        b->yy_at_bol = 1;
2129
        b->yy_buffer_status = YY_BUFFER_NEW;
2130
 
2131
        if ( b == YY_CURRENT_BUFFER )
2132
                yy_load_buffer_state( );
2133
}
2134
 
2135
/** Pushes the new state onto the stack. The new state becomes
2136
 *  the current state. This function will allocate the stack
2137
 *  if necessary.
2138
 *  @param new_buffer The new state.
2139
 *
2140
 */
2141
void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2142
{
2143
        if (new_buffer == NULL)
2144
                return;
2145
 
2146
        yyensure_buffer_stack();
2147
 
2148
        /* This block is copied from yy_switch_to_buffer. */
2149
        if ( YY_CURRENT_BUFFER )
2150
                {
2151
                /* Flush out information for old buffer. */
2152
                *(yy_c_buf_p) = (yy_hold_char);
2153
                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2154
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2155
                }
2156
 
2157
        /* Only push if top exists. Otherwise, replace top. */
2158
        if (YY_CURRENT_BUFFER)
2159
                (yy_buffer_stack_top)++;
2160
        YY_CURRENT_BUFFER_LVALUE = new_buffer;
2161
 
2162
        /* copied from yy_switch_to_buffer. */
2163
        yy_load_buffer_state( );
2164
        (yy_did_buffer_switch_on_eof) = 1;
2165
}
2166
 
2167
/** Removes and deletes the top of the stack, if present.
2168
 *  The next element becomes the new top.
2169
 *
2170
 */
2171
void yypop_buffer_state (void)
2172
{
2173
        if (!YY_CURRENT_BUFFER)
2174
                return;
2175
 
2176
        yy_delete_buffer(YY_CURRENT_BUFFER );
2177
        YY_CURRENT_BUFFER_LVALUE = NULL;
2178
        if ((yy_buffer_stack_top) > 0)
2179
                --(yy_buffer_stack_top);
2180
 
2181
        if (YY_CURRENT_BUFFER) {
2182
                yy_load_buffer_state( );
2183
                (yy_did_buffer_switch_on_eof) = 1;
2184
        }
2185
}
2186
 
2187
/* Allocates the stack if it does not exist.
2188
 *  Guarantees space for at least one push.
2189
 */
2190
static void yyensure_buffer_stack (void)
2191
{
2192
        int num_to_alloc;
2193
 
2194
        if (!(yy_buffer_stack)) {
2195
 
2196
                /* First allocation is just for 2 elements, since we don't know if this
2197
                 * scanner will even need a stack. We use 2 instead of 1 to avoid an
2198
                 * immediate xrealloc on the next call.
2199
         */
2200
                num_to_alloc = 1;
2201
                (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2202
                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
2203
                                                                );
2204
                if ( ! (yy_buffer_stack) )
2205
                        YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2206
 
2207
                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2208
 
2209
                (yy_buffer_stack_max) = num_to_alloc;
2210
                (yy_buffer_stack_top) = 0;
2211
                return;
2212
        }
2213
 
2214
        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2215
 
2216
                /* Increase the buffer to prepare for a possible push. */
2217
                int grow_size = 8 /* arbitrary grow size */;
2218
 
2219
                num_to_alloc = (yy_buffer_stack_max) + grow_size;
2220
                (yy_buffer_stack) = (struct yy_buffer_state**)yyxrealloc
2221
                                                                ((yy_buffer_stack),
2222
                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
2223
                                                                );
2224
                if ( ! (yy_buffer_stack) )
2225
                        YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2226
 
2227
                /* zero only the new slots.*/
2228
                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2229
                (yy_buffer_stack_max) = num_to_alloc;
2230
        }
2231
}
2232
 
2233
/** Setup the input buffer state to scan directly from a user-specified character buffer.
2234
 * @param base the character buffer
2235
 * @param size the size in bytes of the character buffer
2236
 *
2237
 * @return the newly allocated buffer state object.
2238
 */
2239
YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
2240
{
2241
        YY_BUFFER_STATE b;
2242
 
2243
        if ( size < 2 ||
2244
             base[size-2] != YY_END_OF_BUFFER_CHAR ||
2245
             base[size-1] != YY_END_OF_BUFFER_CHAR )
2246
                /* They forgot to leave room for the EOB's. */
2247
                return 0;
2248
 
2249
        b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2250
        if ( ! b )
2251
                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2252
 
2253
        b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2254
        b->yy_buf_pos = b->yy_ch_buf = base;
2255
        b->yy_is_our_buffer = 0;
2256
        b->yy_input_file = 0;
2257
        b->yy_n_chars = b->yy_buf_size;
2258
        b->yy_is_interactive = 0;
2259
        b->yy_at_bol = 1;
2260
        b->yy_fill_buffer = 0;
2261
        b->yy_buffer_status = YY_BUFFER_NEW;
2262
 
2263
        yy_switch_to_buffer(b  );
2264
 
2265
        return b;
2266
}
2267
 
2268
/** Setup the input buffer state to scan a string. The next call to yylex() will
2269
 * scan from a @e copy of @a str.
2270
 * @param yystr a NUL-terminated string to scan
2271
 *
2272
 * @return the newly allocated buffer state object.
2273
 * @note If you want to scan bytes that may contain NUL values, then use
2274
 *       yy_scan_bytes() instead.
2275
 */
2276
YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
2277
{
2278
 
2279
        return yy_scan_bytes(yystr,strlen(yystr) );
2280
}
2281
 
2282
/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2283
 * scan from a @e copy of @a bytes.
2284
 * @param bytes the byte buffer to scan
2285
 * @param len the number of bytes in the buffer pointed to by @a bytes.
2286
 *
2287
 * @return the newly allocated buffer state object.
2288
 */
2289
YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
2290
{
2291
        YY_BUFFER_STATE b;
2292
        char *buf;
2293
        yy_size_t n;
2294
        int i;
2295
 
2296
        /* Get memory for full buffer, including space for trailing EOB's. */
2297
        n = _yybytes_len + 2;
2298
        buf = (char *) yyalloc(n  );
2299
        if ( ! buf )
2300
                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2301
 
2302
        for ( i = 0; i < _yybytes_len; ++i )
2303
                buf[i] = yybytes[i];
2304
 
2305
        buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2306
 
2307
        b = yy_scan_buffer(buf,n );
2308
        if ( ! b )
2309
                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2310
 
2311
        /* It's okay to grow etc. this buffer, and we should throw it
2312
         * away when we're done.
2313
         */
2314
        b->yy_is_our_buffer = 1;
2315
 
2316
        return b;
2317
}
2318
 
2319
#ifndef YY_EXIT_FAILURE
2320
#define YY_EXIT_FAILURE 2
2321
#endif
2322
 
2323
static void yy_fatal_error (yyconst char* msg )
2324
{
2325
        (void) fprintf( stderr, "%s\n", msg );
2326
        exit( YY_EXIT_FAILURE );
2327
}
2328
 
2329
/* Redefine yyless() so it works in section 3 code. */
2330
 
2331
#undef yyless
2332
#define yyless(n) \
2333
        do \
2334
                { \
2335
                /* Undo effects of setting up yytext. */ \
2336
        int yyless_macro_arg = (n); \
2337
        YY_LESS_LINENO(yyless_macro_arg);\
2338
                yytext[yyleng] = (yy_hold_char); \
2339
                (yy_c_buf_p) = yytext + yyless_macro_arg; \
2340
                (yy_hold_char) = *(yy_c_buf_p); \
2341
                *(yy_c_buf_p) = '\0'; \
2342
                yyleng = yyless_macro_arg; \
2343
                } \
2344
        while ( 0 )
2345
 
2346
/* Accessor  methods (get/set functions) to struct members. */
2347
 
2348
/** Get the current line number.
2349
 *
2350
 */
2351
int yyget_lineno  (void)
2352
{
2353
 
2354
    return yylineno;
2355
}
2356
 
2357
/** Get the input stream.
2358
 *
2359
 */
2360
FILE *yyget_in  (void)
2361
{
2362
        return yyin;
2363
}
2364
 
2365
/** Get the output stream.
2366
 *
2367
 */
2368
FILE *yyget_out  (void)
2369
{
2370
        return yyout;
2371
}
2372
 
2373
/** Get the length of the current token.
2374
 *
2375
 */
2376
int yyget_leng  (void)
2377
{
2378
        return yyleng;
2379
}
2380
 
2381
/** Get the current token.
2382
 *
2383
 */
2384
 
2385
char *yyget_text  (void)
2386
{
2387
        return yytext;
2388
}
2389
 
2390
/** Set the current line number.
2391
 * @param line_number
2392
 *
2393
 */
2394
void yyset_lineno (int  line_number )
2395
{
2396
 
2397
    yylineno = line_number;
2398
}
2399
 
2400
/** Set the input stream. This does not discard the current
2401
 * input buffer.
2402
 * @param in_str A readable stream.
2403
 *
2404
 * @see yy_switch_to_buffer
2405
 */
2406
void yyset_in (FILE *  in_str )
2407
{
2408
        yyin = in_str ;
2409
}
2410
 
2411
void yyset_out (FILE *  out_str )
2412
{
2413
        yyout = out_str ;
2414
}
2415
 
2416
int yyget_debug  (void)
2417
{
2418
        return yy_flex_debug;
2419
}
2420
 
2421
void yyset_debug (int  bdebug )
2422
{
2423
        yy_flex_debug = bdebug ;
2424
}
2425
 
2426
static int yy_init_globals (void)
2427
{
2428
        /* Initialization is the same as for the non-reentrant scanner.
2429
     * This function is called from yylex_destroy(), so don't allocate here.
2430
     */
2431
 
2432
    (yy_buffer_stack) = 0;
2433
    (yy_buffer_stack_top) = 0;
2434
    (yy_buffer_stack_max) = 0;
2435
    (yy_c_buf_p) = (char *) 0;
2436
    (yy_init) = 0;
2437
    (yy_start) = 0;
2438
 
2439
/* Defined in main.c */
2440
#ifdef YY_STDINIT
2441
    yyin = stdin;
2442
    yyout = stdout;
2443
#else
2444
    yyin = (FILE *) 0;
2445
    yyout = (FILE *) 0;
2446
#endif
2447
 
2448
    /* For future reference: Set errno on error, since we are called by
2449
     * yylex_init()
2450
     */
2451
    return 0;
2452
}
2453
 
2454
/* yylex_destroy is for both reentrant and non-reentrant scanners. */
2455
int yylex_destroy  (void)
2456
{
2457
 
2458
    /* Pop the buffer stack, destroying each element. */
2459
        while(YY_CURRENT_BUFFER){
2460
                yy_delete_buffer(YY_CURRENT_BUFFER  );
2461
                YY_CURRENT_BUFFER_LVALUE = NULL;
2462
                yypop_buffer_state();
2463
        }
2464
 
2465
        /* Destroy the stack itself. */
2466
        yyfree((yy_buffer_stack) );
2467
        (yy_buffer_stack) = NULL;
2468
 
2469
    /* Reset the globals. This is important in a non-reentrant scanner so the next time
2470
     * yylex() is called, initialization will occur. */
2471
    yy_init_globals( );
2472
 
2473
    return 0;
2474
}
2475
 
2476
/*
2477
 * Internal utility routines.
2478
 */
2479
 
2480
#ifndef yytext_ptr
2481
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2482
{
2483
        register int i;
2484
        for ( i = 0; i < n; ++i )
2485
                s1[i] = s2[i];
2486
}
2487
#endif
2488
 
2489
#ifdef YY_NEED_STRLEN
2490
static int yy_flex_strlen (yyconst char * s )
2491
{
2492
        register int n;
2493
        for ( n = 0; s[n]; ++n )
2494
                ;
2495
 
2496
        return n;
2497
}
2498
#endif
2499
 
2500
void *yyalloc (yy_size_t  size )
2501
{
2502
        return (void *) xmalloc( size );
2503
}
2504
 
2505
void *yyxrealloc  (void * ptr, yy_size_t  size )
2506
{
2507
        /* The cast to (char *) in the following accommodates both
2508
         * implementations that use char* generic pointers, and those
2509
         * that use void* generic pointers.  It works with the latter
2510
         * because both ANSI C and C++ allow castless assignment from
2511
         * any pointer type to void*, and deal with argument conversions
2512
         * as though doing an assignment.
2513
         */
2514
        return (void *) xrealloc( (char *) ptr, size );
2515
}
2516
 
2517
void yyfree (void * ptr )
2518
{
2519
        xfree( (char *) ptr );  /* see yyxrealloc() for (char *) cast */
2520
}
2521
 
2522
#define YYTABLES_NAME "yytables"
2523
 
2524
#line 289 "../../gdb-7.2/gdb/ada-lex.l"
2525
 
2526
 
2527
 
2528
#include <ctype.h>
2529
#include "gdb_string.h"
2530
 
2531
/* Initialize the lexer for processing new expression. */
2532
 
2533
void
2534
lexer_init (FILE *inp)
2535
{
2536
  BEGIN INITIAL;
2537
  yyrestart (inp);
2538
}
2539
 
2540
 
2541
/* Copy S2 to S1, removing all underscores, and downcasing all letters.  */
2542
 
2543
static void
2544
canonicalizeNumeral (char *s1, const char *s2)
2545
{
2546
  for (; *s2 != '\000'; s2 += 1)
2547
    {
2548
      if (*s2 != '_')
2549
        {
2550
          *s1 = tolower(*s2);
2551
          s1 += 1;
2552
        }
2553
    }
2554
  s1[0] = '\000';
2555
}
2556
 
2557
/* Interprets the prefix of NUM that consists of digits of the given BASE
2558
   as an integer of that BASE, with the string EXP as an exponent.
2559
   Puts value in yylval, and returns INT, if the string is valid.  Causes
2560
   an error if the number is improperly formated.   BASE, if NULL, defaults
2561
   to "10", and EXP to "1".  The EXP does not contain a leading 'e' or 'E'.
2562
 */
2563
 
2564
static int
2565
processInt (const char *base0, const char *num0, const char *exp0)
2566
{
2567
  ULONGEST result;
2568
  long exp;
2569
  int base;
2570
 
2571
  char *trailer;
2572
 
2573
  if (base0 == NULL)
2574
    base = 10;
2575
  else
2576
    {
2577
      base = strtol (base0, (char **) NULL, 10);
2578
      if (base < 2 || base > 16)
2579
        error (_("Invalid base: %d."), base);
2580
    }
2581
 
2582
  if (exp0 == NULL)
2583
    exp = 0;
2584
  else
2585
    exp = strtol(exp0, (char **) NULL, 10);
2586
 
2587
  errno = 0;
2588
  result = strtoulst (num0, (const char **) &trailer, base);
2589
  if (errno == ERANGE)
2590
    error (_("Integer literal out of range"));
2591
  if (isxdigit(*trailer))
2592
    error (_("Invalid digit `%c' in based literal"), *trailer);
2593
 
2594
  while (exp > 0)
2595
    {
2596
      if (result > (ULONG_MAX / base))
2597
        error (_("Integer literal out of range"));
2598
      result *= base;
2599
      exp -= 1;
2600
    }
2601
 
2602
  if ((result >> (gdbarch_int_bit (parse_gdbarch)-1)) == 0)
2603
    yylval.typed_val.type = type_int ();
2604
  else if ((result >> (gdbarch_long_bit (parse_gdbarch)-1)) == 0)
2605
    yylval.typed_val.type = type_long ();
2606
  else if (((result >> (gdbarch_long_bit (parse_gdbarch)-1)) >> 1) == 0)
2607
    {
2608
      /* We have a number representable as an unsigned integer quantity.
2609
         For consistency with the C treatment, we will treat it as an
2610
         anonymous modular (unsigned) quantity.  Alas, the types are such
2611
         that we need to store .val as a signed quantity.  Sorry
2612
         for the mess, but C doesn't officially guarantee that a simple
2613
         assignment does the trick (no, it doesn't; read the reference manual).
2614
       */
2615
      yylval.typed_val.type
2616
        = builtin_type (parse_gdbarch)->builtin_unsigned_long;
2617
      if (result & LONGEST_SIGN)
2618
        yylval.typed_val.val =
2619
          (LONGEST) (result & ~LONGEST_SIGN)
2620
          - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
2621
      else
2622
        yylval.typed_val.val = (LONGEST) result;
2623
      return INT;
2624
    }
2625
  else
2626
    yylval.typed_val.type = type_long_long ();
2627
 
2628
  yylval.typed_val.val = (LONGEST) result;
2629
  return INT;
2630
}
2631
 
2632
static int
2633
processReal (const char *num0)
2634
{
2635
  sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval);
2636
 
2637
  yylval.typed_val_float.type = type_float ();
2638
  if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch)
2639
                            / TARGET_CHAR_BIT)
2640
    yylval.typed_val_float.type = type_double ();
2641
  if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch)
2642
                            / TARGET_CHAR_BIT)
2643
    yylval.typed_val_float.type = type_long_double ();
2644
 
2645
  return FLOAT;
2646
}
2647
 
2648
 
2649
/* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym.  The
2650
   resulting string is valid until the next call to ada_parse.  It differs
2651
   from NAME0 in that:
2652
    + Characters between '...' or <...> are transfered verbatim to
2653
      yylval.ssym.
2654
    + <, >, and trailing "'" characters in quoted sequences are removed
2655
      (a leading quote is preserved to indicate that the name is not to be
2656
      GNAT-encoded).
2657
    + Unquoted whitespace is removed.
2658
    + Unquoted alphabetic characters are mapped to lower case.
2659
   Result is returned as a struct stoken, but for convenience, the string
2660
   is also null-terminated.  Result string valid until the next call of
2661
   ada_parse.
2662
 */
2663
static struct stoken
2664
processId (const char *name0, int len)
2665
{
2666
  char *name = obstack_alloc (&temp_parse_space, len + 11);
2667
  int i0, i;
2668
  struct stoken result;
2669
 
2670
  while (len > 0 && isspace (name0[len-1]))
2671
    len -= 1;
2672
  i = i0 = 0;
2673
  while (i0 < len)
2674
    {
2675
      if (isalnum (name0[i0]))
2676
        {
2677
          name[i] = tolower (name0[i0]);
2678
          i += 1; i0 += 1;
2679
        }
2680
      else switch (name0[i0])
2681
        {
2682
        default:
2683
          name[i] = name0[i0];
2684
          i += 1; i0 += 1;
2685
          break;
2686
        case ' ': case '\t':
2687
          i0 += 1;
2688
          break;
2689
        case '\'':
2690
          do
2691
            {
2692
              name[i] = name0[i0];
2693
              i += 1; i0 += 1;
2694
            }
2695
          while (i0 < len && name0[i0] != '\'');
2696
          i0 += 1;
2697
          break;
2698
        case '<':
2699
          i0 += 1;
2700
          while (i0 < len && name0[i0] != '>')
2701
            {
2702
              name[i] = name0[i0];
2703
              i += 1; i0 += 1;
2704
            }
2705
          i0 += 1;
2706
          break;
2707
        }
2708
    }
2709
  name[i] = '\000';
2710
 
2711
  result.ptr = name;
2712
  result.length = i;
2713
  return result;
2714
}
2715
 
2716
/* Return TEXT[0..LEN-1], a string literal without surrounding quotes,
2717
   with special hex character notations replaced with characters.
2718
   Result valid until the next call to ada_parse.  */
2719
 
2720
static struct stoken
2721
processString (const char *text, int len)
2722
{
2723
  const char *p;
2724
  char *q;
2725
  const char *lim = text + len;
2726
  struct stoken result;
2727
 
2728
  q = result.ptr = obstack_alloc (&temp_parse_space, len);
2729
  p = text;
2730
  while (p < lim)
2731
    {
2732
      if (p[0] == '[' && p[1] == '"' && p+2 < lim)
2733
         {
2734
           if (p[2] == '"')  /* "...["""]... */
2735
             {
2736
               *q = '"';
2737
               p += 4;
2738
             }
2739
           else
2740
             {
2741
               int chr;
2742
               sscanf (p+2, "%2x", &chr);
2743
               *q = (char) chr;
2744
               p += 5;
2745
             }
2746
         }
2747
       else
2748
         *q = *p;
2749
       q += 1;
2750
       p += 1;
2751
     }
2752
  result.length = q - result.ptr;
2753
  return result;
2754
}
2755
 
2756
/* Returns the position within STR of the '.' in a
2757
   '.{WHITE}*all' component of a dotted name, or -1 if there is none.
2758
   Note: we actually don't need this routine, since 'all' can never be an
2759
   Ada identifier.  Thus, looking up foo.all or foo.all.x as a name
2760
   must fail, and will eventually be interpreted as (foo).all or
2761
   (foo).all.x.  However, this does avoid an extraneous lookup. */
2762
 
2763
static int
2764
find_dot_all (const char *str)
2765
{
2766
  int i;
2767
  for (i = 0; str[i] != '\000'; i += 1)
2768
    {
2769
      if (str[i] == '.')
2770
        {
2771
          int i0 = i;
2772
          do
2773
            i += 1;
2774
          while (isspace (str[i]));
2775
          if (strncmp (str+i, "all", 3) == 0
2776
              && ! isalnum (str[i+3]) && str[i+3] != '_')
2777
            return i0;
2778
        }
2779
    }
2780
  return -1;
2781
}
2782
 
2783
/* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
2784
   case.  */
2785
 
2786
static int
2787
subseqMatch (const char *subseq, const char *str)
2788
{
2789
  if (subseq[0] == '\0')
2790
    return 1;
2791
  else if (str[0] == '\0')
2792
    return 0;
2793
  else if (tolower (subseq[0]) == tolower (str[0]))
2794
    return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
2795
  else
2796
    return subseqMatch (subseq, str+1);
2797
}
2798
 
2799
 
2800
static struct { const char *name; int code; }
2801
attributes[] = {
2802
  { "address", TICK_ADDRESS },
2803
  { "unchecked_access", TICK_ACCESS },
2804
  { "unrestricted_access", TICK_ACCESS },
2805
  { "access", TICK_ACCESS },
2806
  { "first", TICK_FIRST },
2807
  { "last", TICK_LAST },
2808
  { "length", TICK_LENGTH },
2809
  { "max", TICK_MAX },
2810
  { "min", TICK_MIN },
2811
  { "modulus", TICK_MODULUS },
2812
  { "pos", TICK_POS },
2813
  { "range", TICK_RANGE },
2814
  { "size", TICK_SIZE },
2815
  { "tag", TICK_TAG },
2816
  { "val", TICK_VAL },
2817
  { NULL, -1 }
2818
};
2819
 
2820
/* Return the syntactic code corresponding to the attribute name or
2821
   abbreviation STR.  */
2822
 
2823
static int
2824
processAttribute (const char *str)
2825
{
2826
  int i, k;
2827
 
2828
  for (i = 0; attributes[i].code != -1; i += 1)
2829
    if (strcasecmp (str, attributes[i].name) == 0)
2830
      return attributes[i].code;
2831
 
2832
  for (i = 0, k = -1; attributes[i].code != -1; i += 1)
2833
    if (subseqMatch (str, attributes[i].name))
2834
      {
2835
        if (k == -1)
2836
          k = i;
2837
        else
2838
          error (_("ambiguous attribute name: `%s'"), str);
2839
      }
2840
  if (k == -1)
2841
    error (_("unrecognized attribute: `%s'"), str);
2842
 
2843
  return attributes[k].code;
2844
}
2845
 
2846
int
2847
yywrap(void)
2848
{
2849
  return 1;
2850
}
2851
 
2852
/* Dummy definition to suppress warnings about unused static definitions. */
2853
typedef void (*dummy_function) ();
2854
dummy_function ada_flex_use[] =
2855
{
2856
  (dummy_function) yyunput
2857
};
2858
 

powered by: WebSVN 2.1.0

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