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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [ada-lex.c] - Blame information for rev 227

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

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

powered by: WebSVN 2.1.0

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