Bug Summary

File:src/gnu/usr.bin/binutils/obj/gdb/./ada-lex.c
Warning:line 3047, column 3
Value stored to 'lim' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ada-exp.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -resource-dir /usr/local/lib/clang/13.0.0 -D PIE_DEFAULT=1 -I . -I /usr/src/gnu/usr.bin/binutils/gdb -I /usr/src/gnu/usr.bin/binutils/gdb/config -D LOCALEDIR="/usr/share/locale" -D HAVE_CONFIG_H -I /usr/src/gnu/usr.bin/binutils/gdb/../include/opcode -I ../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../include -I ../intl -I /usr/src/gnu/usr.bin/binutils/gdb/../intl -D MI_OUT=1 -D TUI=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -fcommon -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c ada-exp.c
1#line 2 "ada-lex.c"
2
3#line 4 "ada-lex.c"
4
5#define YY_INT_ALIGNEDshort int short int
6
7/* $OpenBSD: flex.skl,v 1.18 2021/11/30 15:50:06 millert Exp $ */
8
9/* A lexical scanner generated by flex */
10
11#define FLEX_SCANNER
12#define YY_FLEX_MAJOR_VERSION2 2
13#define YY_FLEX_MINOR_VERSION5 5
14#define YY_FLEX_SUBMINOR_VERSION39 39
15#if YY_FLEX_SUBMINOR_VERSION39 > 0
16#define FLEX_BETA
17#endif
18
19/* First, we deal with platform-specific or compiler-specific issues. */
20
21/* begin standard C headers. */
22#include <stdio.h>
23#include <string.h>
24#include <errno(*__errno()).h>
25#include <stdlib.h>
26
27/* end standard C headers. */
28
29/* $OpenBSD: flexint.h,v 1.1 2015/11/19 19:43:40 tedu Exp $ */
30
31/* flex integer type definitions */
32
33#ifndef FLEXINT_H
34#define FLEXINT_H
35
36/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
37
38#if defined (__STDC_VERSION__201710L) && __STDC_VERSION__201710L >= 199901L
39
40/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
41 * if you want the limit (max/min) macros for int types.
42 */
43#ifndef __STDC_LIMIT_MACROS1
44#define __STDC_LIMIT_MACROS1 1
45#endif
46
47#include <inttypes.h>
48typedef int8_t flex_int8_t;
49typedef uint8_t flex_uint8_t;
50typedef int16_t flex_int16_t;
51typedef uint16_t flex_uint16_t;
52typedef int32_t flex_int32_t;
53typedef uint32_t flex_uint32_t;
54#else
55typedef signed char flex_int8_t;
56typedef short int flex_int16_t;
57typedef int flex_int32_t;
58typedef unsigned char flex_uint8_t;
59typedef unsigned short int flex_uint16_t;
60typedef unsigned int flex_uint32_t;
61
62/* Limits of integral types. */
63#ifndef INT8_MIN(-0x7f - 1)
64#define INT8_MIN(-0x7f - 1) (-128)
65#endif
66#ifndef INT16_MIN(-0x7fff - 1)
67#define INT16_MIN(-0x7fff - 1) (-32767-1)
68#endif
69#ifndef INT32_MIN(-0x7fffffff - 1)
70#define INT32_MIN(-0x7fffffff - 1) (-2147483647-1)
71#endif
72#ifndef INT8_MAX0x7f
73#define INT8_MAX0x7f (127)
74#endif
75#ifndef INT16_MAX0x7fff
76#define INT16_MAX0x7fff (32767)
77#endif
78#ifndef INT32_MAX0x7fffffff
79#define INT32_MAX0x7fffffff (2147483647)
80#endif
81#ifndef UINT8_MAX0xff
82#define UINT8_MAX0xff (255U)
83#endif
84#ifndef UINT16_MAX0xffff
85#define UINT16_MAX0xffff (65535U)
86#endif
87#ifndef UINT32_MAX0xffffffffU
88#define UINT32_MAX0xffffffffU (4294967295U)
89#endif
90
91#endif /* ! C99 */
92
93#endif /* ! FLEXINT_H */
94
95#ifdef __cplusplus
96
97/* The "const" storage-class-modifier is valid. */
98#define YY_USE_CONST
99
100#else /* ! __cplusplus */
101
102/* C99 requires __STDC__ to be defined as 1. */
103#if defined (__STDC__1)
104
105#define YY_USE_CONST
106
107#endif /* defined (__STDC__) */
108#endif /* ! __cplusplus */
109
110#ifdef YY_USE_CONST
111#define yyconstconst const
112#else
113#define yyconstconst
114#endif
115
116/* Returned upon end-of-file. */
117#define YY_NULL0 0
118
119/* Promotes a possibly negative, possibly signed char to an unsigned
120 * integer for use as an array index. If the signed char is negative,
121 * we want to instead treat it as an 8-bit unsigned char, hence the
122 * double cast.
123 */
124#define YY_SC_TO_UI(c)((unsigned int) (unsigned char) c) ((unsigned int) (unsigned char) c)
125
126/* Enter a start condition. This macro really ought to take a parameter,
127 * but we do it the disgusting crufty way forced on us by the ()-less
128 * definition of BEGIN.
129 */
130#define BEGIN(yy_start) = 1 + 2 * (yy_start) = 1 + 2 *
131
132/* Translate the current start state into a value that can be later handed
133 * to BEGIN to return to the state. The YYSTATE alias is for lex
134 * compatibility.
135 */
136#define YY_START(((yy_start) - 1) / 2) (((yy_start) - 1) / 2)
137#define YYSTATE(((yy_start) - 1) / 2) YY_START(((yy_start) - 1) / 2)
138
139/* Action number for EOF rule of a given start state. */
140#define YY_STATE_EOF(state)(53 + state + 1) (YY_END_OF_BUFFER53 + state + 1)
141
142/* Special action meaning "start processing a new file". */
143#define YY_NEW_FILEada_yyrestart(yyin ) yyrestartada_yyrestart(yyin )
144
145#define YY_END_OF_BUFFER_CHAR0 0
146
147/* Size of default input buffer. */
148#ifndef YY_BUF_SIZE16384
149#define YY_BUF_SIZE16384 16384
150#endif
151
152/* The state buf must be large enough to hold one state per character in the main buffer.
153 */
154#define YY_STATE_BUF_SIZE((16384 + 2) * sizeof(yy_state_type)) ((YY_BUF_SIZE16384 + 2) * sizeof(yy_state_type))
155
156#ifndef YY_TYPEDEF_YY_BUFFER_STATE
157#define YY_TYPEDEF_YY_BUFFER_STATE
158typedef struct yy_buffer_state *YY_BUFFER_STATE;
159#endif
160
161#ifndef YY_TYPEDEF_YY_SIZE_T
162#define YY_TYPEDEF_YY_SIZE_T
163typedef size_t yy_size_t;
164#endif
165
166extern yy_size_t yyleng;
167
168extern FILE *yyin, *yyout;
169
170#define EOB_ACT_CONTINUE_SCAN0 0
171#define EOB_ACT_END_OF_FILE1 1
172#define EOB_ACT_LAST_MATCH2 2
173
174 #define YY_LESS_LINENO(n)
175 #define YY_LINENO_REWIND_TO(ptr)
176
177/* Return all but the first "n" matched characters back to the input stream. */
178#define yyless(n)do { int yyless_macro_arg = (n); ; ada_yytext[yyleng] = (yy_hold_char
); (yy_c_buf_p) = ada_yytext + yyless_macro_arg; (yy_hold_char
) = *(yy_c_buf_p); *(yy_c_buf_p) = '\0'; yyleng = yyless_macro_arg
; } while ( 0 ) \
179 do \
180 { \
181 /* Undo effects of setting up yytext. */ \
182 int yyless_macro_arg = (n); \
183 YY_LESS_LINENO(yyless_macro_arg);\
184 *yy_cp = (yy_hold_char); \
185 YY_RESTORE_YY_MORE_OFFSET \
186 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ0; \
187 YY_DO_BEFORE_ACTION(ada_yytext) = yy_bp; yyleng = (size_t) (yy_cp - yy_bp); (yy_hold_char
) = *yy_cp; *yy_cp = '\0'; (yy_c_buf_p) = yy_cp;; /* set up yytext again */ \
188 } \
189 while ( 0 )
190
191#define unput(c)yyunput( c, (ada_yytext) ) yyunput( c, (yytext_ptrada_yytext) )
192
193#ifndef YY_STRUCT_YY_BUFFER_STATE
194#define YY_STRUCT_YY_BUFFER_STATE
195struct yy_buffer_state
196 {
197 FILE *yy_input_file;
198
199 char *yy_ch_buf; /* input buffer */
200 char *yy_buf_pos; /* current position in input buffer */
201
202 /* Size of input buffer in bytes, not including room for EOB
203 * characters.
204 */
205 yy_size_t yy_buf_size;
206
207 /* Number of characters read into yy_ch_buf, not including EOB
208 * characters.
209 */
210 yy_size_t yy_n_chars;
211
212 /* Whether we "own" the buffer - i.e., we know we created it,
213 * and can xrealloc() it to grow it, and should free() it to
214 * delete it.
215 */
216 int yy_is_our_buffer;
217
218 /* Whether this is an "interactive" input source; if so, and
219 * if we're using stdio for input, then we want to use getc()
220 * instead of fread(), to make sure we stop fetching input after
221 * each newline.
222 */
223 int yy_is_interactive;
224
225 /* Whether we're considered to be at the beginning of a line.
226 * If so, '^' rules will be active on the next match, otherwise
227 * not.
228 */
229 int yy_at_bol;
230
231 int yy_bs_lineno; /**< The line count. */
232 int yy_bs_column; /**< The column count. */
233
234 /* Whether to try to fill the input buffer when we reach the
235 * end of it.
236 */
237 int yy_fill_buffer;
238
239 int yy_buffer_status;
240
241#define YY_BUFFER_NEW0 0
242#define YY_BUFFER_NORMAL1 1
243 /* When an EOF's been seen but there's still some text to process
244 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
245 * shouldn't try reading from the input source any more. We might
246 * still have a bunch of tokens to match, though, because of
247 * possible backing-up.
248 *
249 * When we actually see the EOF, we change the status to "new"
250 * (via yyrestart()), so that the user can continue scanning by
251 * just pointing yyin at a new input file.
252 */
253#define YY_BUFFER_EOF_PENDING2 2
254
255 };
256#endif /* !YY_STRUCT_YY_BUFFER_STATE */
257
258/* Stack of input buffers. */
259static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
260static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
261static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
262
263/* We provide macros for accessing buffer states in case in the
264 * future we want to put the buffer states in a more general
265 * "scanner state".
266 *
267 * Returns the top of the stack, or NULL.
268 */
269#define YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)) ( (yy_buffer_stack) \
270 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
271 : NULL((void*)0))
272
273/* Same as previous macro, but useful when we know that the buffer stack is not
274 * NULL or when we need an lvalue. For internal use only.
275 */
276#define YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)] (yy_buffer_stack)[(yy_buffer_stack_top)]
277
278/* yy_hold_char holds the character lost when yytext is formed. */
279static char yy_hold_char;
280static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
281yy_size_t yyleng;
282
283/* Points to current character in buffer. */
284static char *yy_c_buf_p = (char *) 0;
285static int yy_init = 0; /* whether we need to initialize */
286static int yy_start = 0; /* start state number */
287
288/* Flag which is used to allow yywrap()'s to do buffer switches
289 * instead of setting up a fresh yyin. A bit of a hack ...
290 */
291static int yy_did_buffer_switch_on_eof;
292
293void yyrestartada_yyrestart (FILE *input_file );
294void yy_switch_to_bufferada_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
295YY_BUFFER_STATE yy_create_bufferada_yy_create_buffer (FILE *file,int size );
296void yy_delete_bufferada_yy_delete_buffer (YY_BUFFER_STATE b );
297void yy_flush_buffer (YY_BUFFER_STATE b );
298void yypush_buffer_state (YY_BUFFER_STATE new_buffer );
299void yypop_buffer_state (void );
300
301static void yyensure_buffer_stack (void );
302static void yy_load_buffer_stateada_yy_load_buffer_state (void );
303static void yy_init_bufferada_yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
304
305#define YY_FLUSH_BUFFERyy_flush_buffer(( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top
)] : ((void*)0)) ) yy_flush_buffer(YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)) )
306
307YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size );
308YY_BUFFER_STATE yy_scan_string (yyconstconst char *yy_str );
309YY_BUFFER_STATE yy_scan_bytes (yyconstconst char *bytes,yy_size_t len );
310
311void *yyalloc (yy_size_t );
312void *yyxrealloc (void *,yy_size_t );
313void yyfree (void * );
314
315#define yy_new_bufferada_yy_create_buffer yy_create_bufferada_yy_create_buffer
316
317#define yy_set_interactive(is_interactive){ if ( ! ( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top
)] : ((void*)0)) ){ yyensure_buffer_stack (); (yy_buffer_stack
)[(yy_buffer_stack_top)] = ada_yy_create_buffer(yyin,16384 );
} (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_is_interactive
= is_interactive; } \
318 { \
319 if ( ! YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)) ){ \
320 yyensure_buffer_stack (); \
321 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)] = \
322 yy_create_bufferada_yy_create_buffer(yyin,YY_BUF_SIZE16384 ); \
323 } \
324 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_is_interactive = is_interactive; \
325 }
326
327#define yy_set_bol(at_bol){ if ( ! ( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top
)] : ((void*)0)) ){ yyensure_buffer_stack (); (yy_buffer_stack
)[(yy_buffer_stack_top)] = ada_yy_create_buffer(yyin,16384 );
} (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_at_bol = at_bol
; } \
328 { \
329 if ( ! YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)) ){\
330 yyensure_buffer_stack (); \
331 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)] = \
332 yy_create_bufferada_yy_create_buffer(yyin,YY_BUF_SIZE16384 ); \
333 } \
334 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_at_bol = at_bol; \
335 }
336
337#define YY_AT_BOL()((yy_buffer_stack)[(yy_buffer_stack_top)]->yy_at_bol) (YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_at_bol)
338
339/* Begin user sect3 */
340
341typedef unsigned char YY_CHAR;
342
343FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
344
345typedef int yy_state_type;
346
347extern int yylineno;
348
349int yylineno = 1;
350
351extern char *yytextada_yytext;
352#define yytext_ptrada_yytext yytextada_yytext
353
354static yy_state_type yy_get_previous_state (void );
355static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
356static int yy_get_next_buffer (void );
357static void yy_fatal_error (yyconstconst char msg[] );
358
359/* Done after the current pattern has been matched and before the
360 * corresponding action - sets up yytext.
361 */
362#define YY_DO_BEFORE_ACTION(ada_yytext) = yy_bp; yyleng = (size_t) (yy_cp - yy_bp); (yy_hold_char
) = *yy_cp; *yy_cp = '\0'; (yy_c_buf_p) = yy_cp; \
363 (yytext_ptrada_yytext) = yy_bp; \
364 yyleng = (size_t) (yy_cp - yy_bp); \
365 (yy_hold_char) = *yy_cp; \
366 *yy_cp = '\0'; \
367 (yy_c_buf_p) = yy_cp;
368
369#define YY_NUM_RULES52 52
370#define YY_END_OF_BUFFER53 53
371/* This struct is not used in this scanner,
372 but its presence is necessary. */
373struct yy_trans_info
374 {
375 flex_int32_t yy_verify;
376 flex_int32_t yy_nxt;
377 };
378static yyconstconst flex_int16_t yy_accept[343] =
379 { 0,
380 0, 0, 0, 0, 0, 0, 53, 51, 1, 1,
381 14, 50, 40, 51, 42, 43, 40, 41, 40, 40,
382 40, 4, 4, 40, 40, 40, 40, 49, 46, 46,
383 46, 46, 46, 46, 46, 46, 46, 46, 1, 51,
384 15, 50, 40, 51, 42, 43, 40, 41, 40, 40,
385 40, 4, 4, 40, 40, 40, 40, 49, 46, 46,
386 46, 46, 46, 46, 46, 46, 46, 46, 40, 39,
387 50, 0, 0, 0, 0, 0, 0, 0, 34, 2,
388 0, 33, 0, 45, 45, 36, 0, 0, 4, 0,
389 0, 35, 37, 0, 32, 38, 0, 0, 46, 0,
390
391 46, 0, 46, 46, 46, 18, 22, 46, 46, 46,
392 46, 27, 46, 46, 46, 0, 15, 0, 50, 0,
393 0, 15, 0, 0, 34, 2, 0, 33, 0, 45,
394 45, 36, 0, 0, 4, 0, 0, 35, 37, 0,
395 32, 38, 0, 46, 0, 46, 0, 46, 46, 46,
396 18, 22, 46, 46, 46, 46, 27, 46, 46, 46,
397 15, 0, 0, 12, 12, 31, 0, 2, 0, 45,
398 45, 0, 9, 0, 3, 7, 0, 46, 0, 0,
399 0, 46, 48, 19, 20, 46, 23, 24, 25, 46,
400 28, 46, 30, 0, 31, 15, 2, 2, 2, 0,
401
402 45, 45, 0, 9, 0, 3, 7, 0, 46, 0,
403 15, 0, 46, 48, 19, 20, 46, 23, 24, 25,
404 46, 28, 46, 30, 0, 0, 0, 0, 0, 0,
405 45, 44, 6, 0, 0, 9, 0, 3, 0, 0,
406 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
407 46, 21, 26, 29, 0, 0, 0, 0, 2, 0,
408 45, 44, 6, 0, 0, 9, 0, 3, 0, 46,
409 21, 26, 29, 0, 0, 47, 0, 0, 0, 0,
410 46, 0, 0, 0, 0, 0, 0, 0, 0, 47,
411 0, 0, 2, 2, 0, 0, 0, 0, 46, 17,
412
413 0, 0, 0, 5, 11, 0, 8, 0, 0, 0,
414 0, 0, 0, 17, 0, 2, 2, 0, 5, 11,
415 0, 8, 16, 0, 5, 0, 8, 16, 2, 2,
416 5, 0, 8, 13, 0, 2, 0, 10, 10, 10,
417 10, 0
418 } ;
419
420static yyconstconst flex_int32_t yy_ec[256] =
421 { 0,
422 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
423 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
424 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
425 1, 4, 5, 6, 7, 8, 5, 9, 10, 11,
426 12, 13, 14, 15, 16, 17, 18, 19, 20, 20,
427 20, 20, 20, 20, 20, 20, 20, 21, 22, 23,
428 24, 25, 5, 26, 27, 28, 29, 30, 31, 32,
429 33, 34, 35, 33, 33, 36, 37, 38, 39, 33,
430 33, 40, 41, 42, 43, 33, 44, 45, 33, 33,
431 46, 5, 47, 5, 48, 5, 49, 50, 29, 51,
432
433 52, 53, 33, 54, 55, 33, 33, 56, 57, 58,
434 59, 33, 33, 60, 61, 62, 63, 33, 64, 65,
435 33, 33, 26, 22, 26, 5, 1, 1, 1, 1,
436 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
437 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
438 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
439 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
440 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
441 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
442 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
443
444 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
445 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
446 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
447 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
448 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
449 1, 1, 1, 1, 1
450 } ;
451
452static yyconstconst flex_int32_t yy_meta[66] =
453 { 0,
454 1, 2, 3, 4, 5, 6, 7, 8, 5, 9,
455 5, 5, 5, 5, 5, 5, 10, 5, 11, 11,
456 9, 5, 12, 13, 14, 5, 15, 15, 15, 15,
457 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
458 16, 16, 16, 16, 16, 5, 5, 17, 15, 15,
459 15, 15, 15, 16, 16, 16, 16, 16, 16, 16,
460 16, 16, 16, 16, 16
461 } ;
462
463static yyconstconst flex_int16_t yy_base[371] =
464 { 0,
465 0, 0, 65, 0, 125, 126, 1410, 2846, 2846, 2846,
466 2846, 0, 2846, 136, 2846, 2846, 1394, 2846, 1377, 200,
467 1360, 199, 205, 1350, 1347, 1342, 1336, 2846, 263, 211,
468 238, 320, 224, 348, 247, 237, 274, 287, 199, 204,
469 2846, 408, 214, 455, 225, 232, 290, 240, 293, 519,
470 246, 579, 336, 252, 641, 304, 287, 298, 705, 310,
471 347, 319, 562, 743, 576, 580, 559, 749, 308, 808,
472 0, 1220, 1215, 1213, 1212, 1207, 873, 201, 2846, 0,
473 937, 2846, 0, 173, 0, 2846, 0, 114, 936, 345,
474 0, 2846, 2846, 1190, 2846, 2846, 314, 942, 2846, 231,
475
476 747, 1187, 934, 938, 941, 945, 968, 977, 976, 980,
477 1005, 978, 1007, 1015, 1016, 328, 2846, 343, 1073, 1195,
478 392, 1188, 1120, 1185, 364, 979, 1101, 370, 1228, 1290,
479 225, 390, 1350, 583, 1366, 1183, 1400, 393, 398, 1450,
480 402, 403, 1388, 582, 1496, 1043, 944, 1166, 1162, 1383,
481 1168, 1337, 1385, 1534, 1535, 1538, 1388, 1552, 1573, 1577,
482 1111, 1106, 1207, 1355, 2846, 1105, 1628, 0, 1089, 0,
483 325, 420, 1551, 343, 575, 0, 1087, 1665, 1610, 1678,
484 0, 1704, 2846, 1017, 1161, 1588, 1586, 1596, 1613, 1688,
485 1632, 1651, 1681, 1726, 0, 1767, 1360, 0, 1362, 1817,
486
487 579, 583, 1858, 1736, 772, 1743, 0, 1908, 1845, 0,
488 0, 1952, 2016, 951, 1537, 1615, 1752, 1720, 1743, 1818,
489 1843, 1822, 1845, 1846, 1105, 0, 1565, 1089, 2063, 1084,
490 2846, 0, 340, 0, 428, 2069, 426, 756, 1102, 437,
491 202, 291, 296, 2068, 583, 744, 902, 742, 910, 1082,
492 2120, 1721, 2067, 2095, 2136, 1011, 2177, 2212, 2260, 2310,
493 955, 915, 1439, 2339, 0, 2125, 1616, 2130, 2389, 0,
494 2130, 2131, 2134, 1058, 1060, 2846, 1044, 427, 998, 432,
495 2250, 917, 1021, 1062, 951, 968, 967, 1161, 923, 1013,
496 586, 941, 792, 2418, 1746, 2465, 2141, 2515, 2456, 2846,
497
498 750, 1005, 586, 1369, 1373, 789, 1588, 766, 634, 631,
499 601, 585, 447, 422, 1056, 343, 360, 2145, 2227, 1806,
500 0, 2230, 2846, 233, 1692, 627, 1757, 282, 0, 225,
501 2249, 2179, 2331, 2082, 770, 0, 2192, 1788, 2334, 1834,
502 2433, 2846, 2555, 2571, 2576, 2592, 2606, 2620, 2637, 2654,
503 2657, 2664, 769, 1012, 2671, 2687, 2704, 2721, 2735, 2747,
504 2752, 2763, 2766, 2782, 2796, 1089, 1091, 2803, 2817, 2828
505 } ;
506
507static yyconstconst flex_int16_t yy_def[371] =
508 { 0,
509 342, 1, 342, 3, 1, 1, 342, 342, 342, 342,
510 342, 343, 342, 342, 342, 342, 342, 342, 342, 344,
511 342, 342, 342, 342, 345, 342, 342, 342, 346, 346,
512 346, 346, 32, 32, 32, 32, 32, 32, 347, 347,
513 342, 348, 347, 342, 347, 347, 347, 347, 347, 342,
514 347, 347, 347, 347, 342, 347, 347, 347, 342, 59,
515 59, 59, 59, 59, 59, 59, 59, 59, 347, 342,
516 343, 349, 70, 70, 349, 342, 342, 349, 342, 350,
517 344, 342, 351, 352, 352, 342, 353, 342, 342, 342,
518 354, 342, 342, 355, 342, 342, 342, 342, 342, 356,
519
520 32, 342, 32, 32, 32, 32, 32, 32, 32, 32,
521 32, 32, 32, 32, 32, 347, 342, 347, 348, 44,
522 357, 349, 342, 357, 347, 358, 50, 347, 342, 342,
523 130, 347, 347, 347, 347, 347, 133, 347, 347, 359,
524 347, 347, 347, 347, 342, 59, 347, 59, 59, 59,
525 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
526 360, 77, 342, 342, 342, 77, 349, 350, 361, 352,
527 352, 362, 342, 342, 342, 354, 355, 342, 356, 342,
528 363, 364, 342, 32, 32, 32, 32, 32, 32, 32,
529 32, 32, 32, 347, 123, 167, 358, 350, 358, 365,
530
531 130, 130, 133, 347, 347, 347, 137, 359, 347, 145,
532 180, 342, 342, 347, 59, 59, 59, 59, 59, 59,
533 59, 59, 59, 59, 342, 366, 342, 342, 167, 361,
534 342, 352, 342, 367, 362, 342, 342, 342, 342, 342,
535 342, 342, 342, 342, 342, 342, 342, 342, 342, 368,
536 364, 32, 32, 32, 347, 347, 167, 167, 350, 365,
537 347, 130, 347, 137, 203, 347, 347, 347, 369, 213,
538 59, 59, 59, 342, 342, 342, 257, 342, 370, 342,
539 342, 342, 342, 342, 342, 342, 342, 342, 368, 347,
540 257, 257, 350, 350, 347, 137, 347, 369, 347, 342,
541
542 342, 257, 342, 342, 342, 370, 342, 342, 342, 342,
543 342, 342, 342, 257, 257, 350, 350, 347, 347, 347,
544 296, 347, 342, 257, 342, 342, 342, 257, 350, 350,
545 347, 347, 347, 342, 342, 350, 347, 342, 347, 342,
546 347, 0, 342, 342, 342, 342, 342, 342, 342, 342,
547 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
548 342, 342, 342, 342, 342, 342, 342, 342, 342, 342
549 } ;
550
551static yyconstconst flex_int16_t yy_nxt[2912] =
552 { 0,
553 8, 9, 10, 9, 8, 11, 8, 12, 13, 14,
554 15, 16, 17, 13, 18, 19, 20, 21, 22, 23,
555 24, 13, 25, 26, 27, 28, 29, 30, 30, 30,
556 31, 30, 30, 30, 32, 30, 33, 34, 35, 36,
557 30, 37, 30, 30, 38, 13, 13, 30, 29, 30,
558 30, 31, 30, 30, 32, 30, 33, 34, 35, 36,
559 30, 37, 30, 30, 38, 8, 9, 10, 39, 40,
560 41, 40, 42, 43, 44, 45, 46, 47, 43, 48,
561 49, 50, 51, 52, 53, 54, 43, 55, 56, 57,
562 58, 59, 60, 60, 60, 61, 60, 60, 60, 62,
563
564 60, 63, 64, 65, 66, 60, 67, 60, 60, 68,
565 69, 43, 60, 59, 60, 60, 61, 60, 60, 62,
566 60, 63, 64, 65, 66, 60, 67, 60, 60, 68,
567 8, 8, 173, 173, 70, 70, 72, 73, 73, 74,
568 75, 75, 75, 75, 75, 76, 75, 75, 75, 75,
569 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
570 75, 75, 77, 77, 77, 77, 77, 77, 77, 77,
571 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
572 77, 78, 75, 75, 77, 77, 77, 77, 77, 77,
573 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
574
575 77, 81, 81, 81, 117, 87, 167, 281, 171, 117,
576 164, 87, 97, 97, 98, 88, 82, 89, 89, 117,
577 99, 88, 83, 89, 89, 239, 84, 100, 171, 90,
578 117, 102, 179, 179, 179, 90, 180, 117, 72, 97,
579 97, 98, 334, 91, 118, 117, 89, 99, 84, 118,
580 90, 117, 89, 181, 100, 101, 90, 117, 102, 118,
581 201, 101, 108, 91, 97, 97, 98, 113, 101, 132,
582 118, 336, 99, 105, 101, 138, 101, 118, 101, 100,
583 201, 101, 108, 102, 101, 118, 112, 72, 113, 101,
584 103, 118, 117, 105, 101, 117, 281, 118, 117, 101,
585
586 104, 281, 125, 117, 101, 101, 112, 114, 126, 117,
587 142, 101, 103, 161, 239, 97, 97, 97, 101, 239,
588 104, 97, 97, 98, 101, 115, 101, 114, 141, 99,
589 100, 101, 118, 117, 102, 118, 100, 146, 118, 101,
590 102, 117, 133, 118, 101, 115, 146, 146, 161, 118,
591 151, 106, 134, 118, 135, 135, 152, 107, 174, 146,
592 232, 175, 175, 175, 175, 330, 136, 146, 146, 117,
593 278, 151, 106, 118, 146, 117, 152, 107, 109, 101,
594 232, 118, 150, 135, 146, 101, 110, 136, 118, 329,
595 111, 278, 72, 72, 72, 117, 146, 122, 117, 109,
596
597 101, 194, 150, 117, 146, 101, 110, 117, 117, 118,
598 111, 116, 116, 117, 116, 118, 116, 116, 116, 116,
599 116, 116, 116, 116, 116, 116, 233, 72, 116, 116,
600 116, 116, 116, 116, 233, 118, 234, 124, 118, 280,
601 303, 280, 281, 118, 234, 304, 304, 118, 118, 239,
602 307, 307, 281, 118, 116, 72, 73, 73, 120, 121,
603 122, 121, 121, 121, 116, 121, 121, 121, 121, 121,
604 121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
605 121, 123, 123, 123, 123, 123, 123, 123, 123, 123,
606 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
607
608 124, 121, 121, 123, 123, 123, 123, 123, 123, 123,
609 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
610 81, 81, 127, 116, 117, 116, 116, 116, 116, 116,
611 116, 116, 116, 116, 116, 128, 116, 116, 116, 116,
612 116, 129, 116, 116, 116, 130, 131, 131, 131, 131,
613 131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
614 131, 131, 131, 131, 118, 116, 131, 130, 131, 131,
615 131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
616 131, 131, 131, 131, 117, 133, 146, 117, 117, 146,
617 281, 72, 159, 238, 238, 134, 146, 135, 135, 146,
618
619 153, 204, 204, 146, 304, 304, 281, 146, 146, 136,
620 158, 146, 159, 146, 201, 157, 146, 146, 262, 146,
621 153, 284, 238, 137, 118, 146, 135, 118, 118, 146,
622 136, 158, 314, 146, 201, 157, 281, 146, 262, 281,
623 335, 284, 335, 137, 116, 116, 117, 116, 116, 116,
624 116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
625 116, 116, 116, 116, 139, 116, 116, 140, 140, 140,
626 140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
627 140, 140, 140, 140, 140, 140, 118, 116, 140, 140,
628 140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
629
630 140, 140, 140, 140, 140, 140, 97, 97, 143, 116,
631 117, 116, 116, 116, 144, 116, 116, 116, 116, 116,
632 116, 145, 116, 146, 146, 147, 116, 116, 116, 116,
633 116, 146, 148, 146, 146, 146, 146, 146, 146, 146,
634 146, 146, 149, 146, 146, 146, 146, 146, 146, 146,
635 118, 116, 146, 146, 148, 146, 146, 146, 146, 146,
636 146, 146, 149, 146, 146, 146, 146, 146, 146, 146,
637 146, 281, 287, 154, 238, 238, 146, 117, 101, 172,
638 146, 155, 285, 172, 101, 156, 146, 160, 338, 338,
639 206, 206, 146, 287, 154, 305, 323, 316, 146, 101,
640
641 146, 155, 285, 238, 101, 156, 146, 160, 72, 73,
642 73, 73, 72, 72, 72, 72, 72, 118, 72, 72,
643 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
644 72, 72, 72, 72, 162, 162, 162, 162, 162, 162,
645 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
646 162, 162, 162, 72, 72, 72, 162, 162, 162, 162,
647 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
648 162, 162, 162, 72, 72, 72, 72, 72, 72, 72,
649 72, 72, 164, 72, 72, 72, 72, 72, 72, 72,
650 72, 72, 72, 72, 72, 72, 72, 72, 72, 166,
651
652 166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
653 166, 166, 166, 166, 166, 166, 166, 166, 72, 72,
654 72, 166, 166, 166, 166, 166, 166, 166, 166, 166,
655 166, 166, 166, 166, 166, 166, 166, 166, 81, 81,
656 81, 286, 87, 97, 97, 98, 315, 281, 288, 117,
657 201, 99, 88, 342, 89, 89, 117, 308, 100, 83,
658 117, 286, 102, 84, 214, 101, 90, 185, 288, 101,
659 201, 101, 101, 281, 184, 101, 101, 308, 101, 168,
660 168, 186, 101, 89, 198, 84, 101, 90, 185, 118,
661 101, 101, 311, 101, 184, 101, 118, 101, 101, 101,
662
663 118, 186, 101, 312, 305, 101, 187, 101, 101, 101,
664 72, 101, 311, 101, 101, 101, 117, 101, 117, 188,
665 101, 189, 176, 312, 199, 101, 176, 187, 101, 101,
666 101, 290, 101, 101, 101, 101, 101, 101, 101, 188,
667 190, 189, 101, 191, 101, 192, 101, 101, 101, 302,
668 309, 324, 101, 101, 101, 193, 118, 101, 118, 101,
669 190, 72, 101, 191, 101, 301, 192, 101, 101, 101,
670 146, 309, 101, 101, 101, 193, 116, 116, 117, 116,
671 146, 116, 116, 116, 116, 116, 116, 116, 116, 116,
672 116, 310, 146, 116, 116, 116, 116, 116, 116, 275,
673
674 146, 279, 328, 275, 300, 279, 281, 281, 231, 276,
675 274, 178, 310, 231, 163, 163, 225, 116, 118, 116,
676 72, 72, 72, 121, 121, 122, 121, 121, 121, 194,
677 121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
678 121, 121, 121, 121, 121, 121, 195, 195, 195, 195,
679 195, 195, 195, 195, 195, 195, 195, 195, 195, 195,
680 195, 195, 195, 195, 195, 124, 121, 121, 195, 195,
681 195, 195, 195, 195, 195, 195, 195, 195, 195, 195,
682 195, 195, 195, 195, 195, 72, 72, 72, 117, 146,
683 196, 216, 101, 146, 194, 146, 205, 163, 101, 146,
684
685 313, 206, 206, 146, 194, 146, 215, 183, 227, 227,
686 227, 146, 216, 101, 178, 146, 165, 146, 101, 146,
687 313, 164, 164, 146, 163, 146, 215, 228, 118, 163,
688 124, 116, 116, 117, 116, 116, 116, 116, 116, 116,
689 116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
690 116, 116, 116, 116, 200, 200, 200, 200, 200, 200,
691 200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
692 200, 200, 200, 118, 116, 200, 200, 200, 200, 200,
693 200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
694 200, 200, 200, 116, 116, 117, 116, 116, 116, 116,
695
696 116, 116, 116, 116, 116, 116, 116, 116, 201, 201,
697 116, 116, 116, 116, 116, 116, 201, 201, 201, 201,
698 201, 201, 201, 201, 201, 202, 201, 201, 201, 201,
699 201, 201, 201, 201, 201, 118, 116, 201, 201, 201,
700 201, 201, 201, 201, 201, 202, 201, 201, 201, 201,
701 201, 201, 201, 201, 201, 117, 227, 227, 227, 96,
702 168, 168, 168, 168, 146, 198, 95, 259, 203, 203,
703 93, 117, 133, 92, 146, 228, 203, 203, 203, 203,
704 203, 203, 134, 86, 135, 135, 146, 325, 325, 97,
705 97, 143, 80, 117, 146, 118, 136, 144, 203, 203,
706
707 203, 203, 203, 326, 145, 199, 79, 199, 147, 342,
708 146, 118, 146, 135, 218, 146, 325, 136, 207, 207,
709 146, 342, 146, 217, 326, 146, 207, 207, 207, 207,
710 207, 207, 146, 118, 146, 218, 342, 146, 342, 342,
711 146, 342, 146, 217, 117, 146, 342, 342, 207, 207,
712 207, 207, 207, 116, 116, 117, 116, 116, 116, 116,
713 116, 116, 116, 116, 116, 116, 116, 116, 342, 295,
714 116, 116, 116, 116, 209, 116, 342, 342, 342, 342,
715 342, 342, 342, 342, 118, 342, 342, 342, 342, 342,
716 295, 342, 342, 342, 342, 118, 116, 179, 179, 210,
717
718 116, 211, 116, 116, 116, 116, 116, 116, 116, 116,
719 116, 116, 116, 116, 116, 116, 116, 116, 212, 116,
720 116, 116, 213, 213, 213, 213, 213, 213, 213, 213,
721 213, 213, 213, 213, 213, 213, 213, 213, 213, 213,
722 213, 118, 116, 213, 213, 213, 213, 213, 213, 213,
723 213, 213, 213, 213, 213, 213, 213, 213, 213, 213,
724 213, 146, 146, 342, 146, 146, 227, 227, 227, 236,
725 236, 146, 146, 221, 146, 146, 220, 219, 342, 146,
726 342, 237, 342, 146, 146, 228, 146, 146, 222, 146,
727 342, 146, 146, 221, 146, 146, 220, 219, 236, 342,
728
729 146, 146, 237, 223, 146, 342, 327, 327, 222, 146,
730 146, 179, 179, 179, 146, 180, 224, 101, 252, 101,
731 342, 117, 146, 101, 223, 101, 146, 101, 342, 297,
732 146, 297, 181, 101, 146, 327, 224, 163, 101, 252,
733 101, 342, 146, 101, 101, 101, 229, 229, 101, 342,
734 101, 342, 146, 101, 229, 229, 229, 229, 229, 229,
735 342, 118, 342, 101, 146, 101, 97, 97, 98, 101,
736 101, 342, 146, 342, 99, 342, 229, 229, 229, 229,
737 229, 100, 101, 342, 101, 102, 239, 342, 254, 101,
738 240, 239, 342, 239, 342, 241, 342, 342, 342, 342,
739
740 242, 239, 243, 101, 244, 97, 97, 98, 254, 342,
741 325, 325, 101, 99, 245, 246, 247, 248, 101, 101,
742 100, 342, 249, 253, 102, 101, 244, 227, 227, 255,
743 342, 117, 342, 101, 245, 246, 247, 248, 101, 325,
744 101, 117, 249, 253, 342, 101, 256, 146, 117, 342,
745 342, 117, 101, 342, 266, 266, 342, 146, 101, 318,
746 342, 268, 268, 342, 319, 319, 267, 342, 342, 146,
747 146, 118, 257, 101, 342, 327, 327, 146, 101, 146,
748 146, 118, 271, 266, 342, 258, 258, 267, 118, 146,
749 268, 118, 146, 258, 258, 258, 258, 258, 258, 342,
750
751 146, 146, 342, 271, 327, 342, 340, 340, 342, 146,
752 342, 117, 342, 342, 342, 258, 258, 258, 258, 258,
753 116, 116, 117, 116, 116, 116, 116, 116, 116, 116,
754 116, 116, 116, 116, 116, 340, 332, 116, 116, 116,
755 116, 261, 116, 342, 342, 146, 97, 97, 143, 146,
756 117, 118, 340, 340, 144, 146, 342, 332, 342, 146,
757 342, 145, 118, 116, 263, 147, 342, 146, 342, 342,
758 146, 146, 146, 146, 264, 146, 265, 265, 272, 146,
759 146, 340, 273, 146, 265, 265, 265, 265, 265, 265,
760 118, 342, 146, 342, 146, 146, 342, 342, 272, 342,
761
762 146, 342, 273, 146, 342, 265, 265, 265, 265, 265,
763 265, 116, 116, 117, 116, 116, 116, 116, 116, 116,
764 116, 116, 116, 116, 116, 116, 342, 342, 116, 116,
765 116, 116, 209, 116, 342, 342, 342, 342, 342, 342,
766 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
767 342, 342, 342, 118, 116, 116, 116, 117, 116, 116,
768 116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
769 116, 116, 116, 116, 116, 116, 116, 116, 269, 269,
770 269, 269, 269, 269, 269, 269, 269, 269, 269, 269,
771 269, 269, 269, 269, 269, 269, 269, 118, 116, 269,
772
773 269, 269, 269, 269, 269, 269, 269, 269, 269, 269,
774 269, 269, 269, 269, 269, 269, 269, 97, 97, 143,
775 116, 117, 116, 116, 116, 144, 116, 116, 116, 116,
776 116, 116, 145, 116, 270, 270, 147, 116, 116, 116,
777 116, 116, 270, 270, 270, 270, 270, 270, 270, 270,
778 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
779 270, 118, 116, 270, 270, 270, 270, 270, 270, 270,
780 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
781 270, 277, 277, 227, 227, 227, 342, 236, 236, 277,
782 277, 277, 277, 277, 277, 282, 342, 342, 101, 237,
783
784 342, 342, 228, 342, 101, 283, 342, 342, 342, 342,
785 342, 277, 277, 277, 277, 277, 236, 282, 342, 101,
786 237, 97, 97, 98, 101, 283, 101, 342, 342, 99,
787 117, 342, 101, 342, 342, 117, 100, 227, 227, 255,
788 102, 117, 342, 266, 266, 342, 117, 101, 268, 268,
789 117, 342, 101, 342, 342, 267, 256, 146, 146, 322,
790 322, 146, 342, 319, 319, 342, 342, 146, 146, 342,
791 118, 146, 266, 342, 342, 118, 267, 268, 342, 146,
792 146, 118, 291, 146, 117, 342, 118, 146, 146, 342,
793 118, 146, 337, 342, 337, 72, 72, 117, 342, 342,
794
795 342, 342, 342, 72, 72, 72, 72, 72, 72, 342,
796 339, 339, 342, 342, 342, 342, 342, 342, 342, 342,
797 342, 342, 342, 342, 118, 72, 72, 72, 72, 72,
798 292, 292, 117, 342, 342, 117, 342, 118, 292, 292,
799 292, 292, 292, 292, 342, 331, 331, 342, 333, 333,
800 342, 97, 97, 98, 117, 342, 342, 342, 342, 99,
801 292, 292, 292, 292, 292, 293, 100, 331, 331, 342,
802 102, 342, 118, 342, 331, 118, 342, 333, 294, 294,
803 342, 342, 342, 342, 342, 342, 294, 294, 294, 294,
804 294, 294, 342, 342, 118, 342, 331, 342, 342, 342,
805
806 342, 342, 342, 342, 342, 342, 342, 342, 294, 294,
807 294, 294, 294, 116, 116, 117, 116, 116, 116, 116,
808 116, 116, 116, 116, 116, 116, 116, 116, 342, 342,
809 116, 116, 116, 116, 261, 116, 117, 342, 342, 117,
810 342, 342, 342, 342, 342, 342, 342, 342, 342, 333,
811 333, 342, 341, 341, 342, 118, 116, 296, 296, 342,
812 342, 342, 342, 342, 342, 296, 296, 296, 296, 296,
813 296, 342, 342, 342, 342, 342, 118, 342, 333, 118,
814 342, 341, 342, 342, 342, 342, 342, 296, 296, 296,
815 296, 296, 116, 116, 117, 116, 116, 116, 116, 116,
816
817 116, 116, 116, 116, 116, 116, 116, 342, 342, 116,
818 116, 116, 116, 299, 116, 342, 342, 342, 342, 342,
819 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
820 342, 342, 342, 342, 118, 116, 317, 317, 117, 342,
821 342, 342, 342, 342, 317, 317, 317, 317, 317, 317,
822 342, 341, 341, 342, 342, 342, 342, 97, 97, 143,
823 342, 117, 342, 342, 342, 144, 317, 317, 317, 317,
824 317, 320, 145, 342, 342, 342, 147, 342, 118, 342,
825 341, 342, 342, 321, 321, 342, 342, 342, 342, 342,
826 342, 321, 321, 321, 321, 321, 321, 342, 342, 342,
827
828 342, 118, 342, 342, 342, 342, 342, 342, 342, 342,
829 342, 342, 321, 321, 321, 321, 321, 321, 116, 116,
830 117, 116, 116, 116, 116, 116, 116, 116, 116, 116,
831 116, 116, 116, 342, 342, 116, 116, 116, 116, 299,
832 116, 342, 342, 342, 342, 342, 342, 342, 342, 342,
833 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
834 118, 116, 71, 342, 342, 71, 342, 342, 342, 71,
835 71, 71, 85, 85, 85, 342, 342, 342, 342, 342,
836 85, 342, 85, 342, 342, 85, 85, 85, 94, 342,
837 94, 94, 94, 101, 101, 101, 342, 342, 342, 342,
838
839 101, 101, 101, 342, 342, 342, 101, 101, 101, 116,
840 116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
841 116, 116, 116, 119, 119, 119, 119, 119, 119, 119,
842 119, 119, 119, 119, 119, 119, 119, 72, 72, 72,
843 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
844 72, 72, 72, 72, 168, 168, 342, 168, 168, 168,
845 168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
846 168, 169, 169, 169, 170, 342, 342, 342, 170, 170,
847 170, 177, 342, 342, 177, 177, 177, 177, 182, 182,
848 182, 342, 182, 342, 342, 342, 342, 342, 182, 342,
849
850 342, 182, 182, 182, 121, 121, 121, 121, 121, 121,
851 121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
852 121, 197, 197, 342, 197, 197, 197, 197, 197, 197,
853 197, 197, 197, 197, 197, 197, 197, 197, 208, 208,
854 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
855 208, 208, 226, 342, 342, 342, 342, 226, 342, 342,
856 342, 226, 230, 342, 342, 230, 230, 230, 230, 235,
857 342, 342, 235, 235, 342, 342, 342, 235, 342, 235,
858 250, 250, 250, 251, 251, 251, 342, 342, 342, 342,
859 251, 251, 251, 342, 342, 342, 251, 251, 251, 260,
860
861 260, 260, 260, 260, 260, 260, 260, 260, 260, 260,
862 260, 260, 260, 289, 342, 342, 289, 289, 289, 289,
863 298, 298, 298, 298, 298, 298, 298, 298, 298, 298,
864 298, 298, 298, 298, 306, 342, 342, 342, 306, 342,
865 342, 342, 306, 342, 306, 7, 342, 342, 342, 342,
866 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
867 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
868 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
869 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
870 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
871
872 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
873 342
874 } ;
875
876static yyconstconst flex_int16_t yy_chk[2912] =
877 { 0,
878 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
879 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
880 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
881 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
882 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
883 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
884 1, 1, 1, 1, 1, 3, 3, 3, 3, 3,
885 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
886 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
887 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
888
889 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
890 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
891 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
892 5, 6, 88, 88, 5, 6, 14, 14, 14, 14,
893 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
894 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
895 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
896 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
897 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
898 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
899
900 14, 20, 20, 20, 39, 22, 78, 241, 84, 40,
901 78, 23, 30, 30, 30, 22, 20, 22, 22, 43,
902 30, 23, 20, 23, 23, 241, 20, 30, 84, 22,
903 45, 30, 100, 100, 100, 23, 100, 46, 324, 31,
904 31, 31, 324, 22, 39, 48, 22, 31, 20, 40,
905 22, 51, 23, 100, 31, 33, 23, 54, 31, 43,
906 131, 33, 33, 22, 29, 29, 29, 36, 36, 51,
907 45, 330, 29, 31, 36, 54, 33, 46, 35, 29,
908 131, 33, 33, 29, 35, 48, 35, 328, 36, 36,
909 29, 51, 57, 31, 36, 47, 242, 54, 49, 35,
910
911 29, 243, 47, 58, 35, 37, 35, 37, 49, 56,
912 57, 37, 29, 69, 242, 97, 97, 97, 38, 243,
913 29, 32, 32, 32, 38, 38, 37, 37, 56, 32,
914 97, 37, 57, 116, 97, 47, 32, 60, 49, 38,
915 32, 53, 53, 58, 38, 38, 62, 60, 118, 56,
916 62, 32, 53, 69, 53, 53, 62, 32, 90, 60,
917 171, 174, 174, 90, 90, 317, 53, 60, 62, 125,
918 233, 62, 32, 116, 61, 128, 62, 32, 34, 34,
919 171, 53, 61, 53, 61, 34, 34, 53, 118, 316,
920 34, 233, 121, 121, 121, 132, 61, 121, 138, 34,
921
922 34, 121, 61, 139, 61, 34, 34, 141, 142, 125,
923 34, 42, 42, 42, 42, 128, 42, 42, 42, 42,
924 42, 42, 42, 42, 42, 42, 172, 314, 42, 42,
925 42, 42, 42, 42, 235, 132, 172, 121, 138, 237,
926 278, 237, 240, 139, 235, 278, 278, 141, 142, 240,
927 280, 280, 313, 42, 42, 44, 44, 44, 44, 44,
928 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
929 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
930 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
931 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
932
933 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
934 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
935 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
936 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
937 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
938 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
939 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
940 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
941 50, 50, 50, 50, 52, 52, 67, 144, 134, 63,
942 312, 291, 67, 175, 175, 52, 67, 52, 52, 63,
943
944 63, 134, 134, 65, 303, 303, 311, 66, 67, 52,
945 66, 63, 67, 65, 201, 65, 67, 66, 202, 63,
946 63, 245, 175, 52, 52, 65, 52, 144, 134, 66,
947 52, 66, 291, 65, 201, 65, 310, 66, 202, 309,
948 326, 245, 326, 52, 55, 55, 55, 55, 55, 55,
949 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
950 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
951 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
952 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
953 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
954
955 55, 55, 55, 55, 55, 55, 59, 59, 59, 59,
956 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
957 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
958 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
959 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
960 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
961 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
962 64, 308, 248, 64, 238, 238, 68, 205, 101, 353,
963 64, 64, 246, 353, 101, 64, 68, 68, 335, 335,
964 205, 205, 64, 248, 64, 306, 301, 293, 68, 101,
965
966 64, 64, 246, 238, 101, 64, 68, 68, 70, 70,
967 70, 70, 70, 70, 70, 70, 70, 205, 70, 70,
968 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
969 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
970 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
971 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
972 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
973 70, 70, 70, 77, 77, 77, 77, 77, 77, 77,
974 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
975 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
976
977 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
978 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
979 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
980 77, 77, 77, 77, 77, 77, 77, 77, 81, 81,
981 81, 247, 89, 98, 98, 98, 292, 289, 249, 147,
982 262, 98, 89, 81, 89, 89, 214, 282, 98, 81,
983 261, 247, 98, 81, 147, 103, 89, 104, 249, 104,
984 262, 103, 105, 286, 103, 104, 106, 282, 105, 126,
985 126, 105, 106, 89, 126, 81, 103, 89, 104, 147,
986 104, 103, 285, 105, 103, 104, 214, 106, 105, 107,
987
988 261, 105, 106, 287, 279, 107, 108, 109, 108, 112,
989 302, 110, 285, 109, 108, 112, 256, 110, 290, 109,
990 107, 110, 354, 287, 126, 107, 354, 108, 109, 108,
991 112, 256, 110, 109, 108, 112, 111, 110, 113, 109,
992 111, 110, 111, 113, 113, 114, 114, 115, 184, 277,
993 283, 302, 114, 115, 184, 115, 256, 111, 290, 113,
994 111, 315, 111, 113, 113, 275, 114, 114, 115, 184,
995 146, 283, 114, 115, 184, 115, 119, 119, 119, 119,
996 146, 119, 119, 119, 119, 119, 119, 119, 119, 119,
997 119, 284, 146, 119, 119, 119, 119, 119, 119, 366,
998
999 146, 367, 315, 366, 274, 367, 250, 239, 230, 228,
1000 225, 177, 284, 169, 166, 162, 161, 127, 119, 119,
1001 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
1002 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
1003 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
1004 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
1005 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
1006 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
1007 123, 123, 123, 123, 123, 124, 124, 124, 136, 149,
1008 124, 149, 185, 148, 124, 151, 136, 122, 185, 149,
1009
1010 288, 136, 136, 148, 120, 151, 148, 102, 163, 163,
1011 163, 149, 149, 185, 94, 148, 76, 151, 185, 149,
1012 288, 75, 74, 148, 73, 151, 148, 163, 136, 72,
1013 124, 129, 129, 129, 129, 129, 129, 129, 129, 129,
1014 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
1015 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
1016 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
1017 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
1018 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
1019 129, 129, 129, 130, 130, 130, 130, 130, 130, 130,
1020
1021 130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
1022 130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
1023 130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
1024 130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
1025 130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
1026 130, 130, 130, 130, 130, 133, 164, 164, 164, 27,
1027 197, 197, 199, 199, 152, 197, 26, 199, 133, 133,
1028 25, 135, 135, 24, 152, 164, 133, 133, 133, 133,
1029 133, 133, 135, 21, 135, 135, 152, 304, 304, 143,
1030 143, 143, 19, 143, 152, 133, 135, 143, 133, 133,
1031
1032 133, 133, 133, 305, 143, 197, 17, 199, 143, 7,
1033 150, 135, 153, 135, 153, 157, 304, 135, 137, 137,
1034 150, 0, 153, 150, 305, 157, 137, 137, 137, 137,
1035 137, 137, 150, 143, 153, 153, 0, 157, 0, 0,
1036 150, 0, 153, 150, 263, 157, 0, 0, 137, 137,
1037 137, 137, 137, 140, 140, 140, 140, 140, 140, 140,
1038 140, 140, 140, 140, 140, 140, 140, 140, 0, 263,
1039 140, 140, 140, 140, 140, 140, 0, 0, 0, 0,
1040 0, 0, 0, 0, 263, 0, 0, 0, 0, 0,
1041 263, 0, 0, 0, 0, 140, 140, 145, 145, 145,
1042
1043 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
1044 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
1045 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
1046 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
1047 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
1048 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
1049 145, 154, 155, 0, 215, 156, 227, 227, 227, 173,
1050 173, 154, 155, 156, 215, 156, 155, 154, 0, 158,
1051 0, 173, 0, 154, 155, 227, 215, 156, 158, 158,
1052 0, 154, 155, 156, 215, 156, 155, 154, 173, 0,
1053
1054 159, 158, 173, 159, 160, 0, 307, 307, 158, 158,
1055 159, 179, 179, 179, 160, 179, 160, 187, 186, 186,
1056 0, 267, 159, 187, 159, 186, 160, 188, 0, 267,
1057 159, 267, 179, 188, 160, 307, 160, 167, 187, 186,
1058 186, 0, 216, 187, 189, 186, 167, 167, 188, 0,
1059 189, 0, 216, 188, 167, 167, 167, 167, 167, 167,
1060 0, 267, 0, 191, 216, 189, 178, 178, 178, 191,
1061 189, 0, 216, 0, 178, 0, 167, 167, 167, 167,
1062 167, 178, 192, 0, 191, 178, 180, 0, 192, 191,
1063 180, 180, 0, 180, 0, 180, 0, 0, 0, 0,
1064
1065 180, 180, 180, 192, 180, 182, 182, 182, 192, 0,
1066 325, 325, 193, 182, 180, 180, 180, 180, 193, 190,
1067 182, 0, 180, 190, 182, 190, 180, 194, 194, 194,
1068 0, 194, 0, 193, 180, 180, 180, 180, 193, 325,
1069 190, 204, 180, 190, 0, 190, 194, 218, 206, 0,
1070 0, 295, 252, 0, 204, 204, 0, 218, 252, 295,
1071 0, 206, 206, 0, 295, 295, 204, 0, 0, 218,
1072 219, 194, 196, 252, 0, 327, 327, 218, 252, 217,
1073 219, 204, 217, 204, 0, 196, 196, 204, 206, 217,
1074 206, 295, 219, 196, 196, 196, 196, 196, 196, 0,
1075
1076 219, 217, 0, 217, 327, 0, 338, 338, 0, 217,
1077 0, 320, 0, 0, 0, 196, 196, 196, 196, 196,
1078 200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
1079 200, 200, 200, 200, 200, 338, 320, 200, 200, 200,
1080 200, 200, 200, 0, 0, 220, 209, 209, 209, 222,
1081 209, 320, 340, 340, 209, 220, 0, 320, 0, 222,
1082 0, 209, 200, 200, 203, 209, 0, 220, 0, 0,
1083 221, 222, 223, 224, 203, 220, 203, 203, 221, 222,
1084 221, 340, 223, 224, 203, 203, 203, 203, 203, 203,
1085 209, 0, 221, 0, 223, 224, 0, 0, 221, 0,
1086
1087 221, 0, 223, 224, 0, 203, 203, 203, 203, 203,
1088 203, 208, 208, 208, 208, 208, 208, 208, 208, 208,
1089 208, 208, 208, 208, 208, 208, 0, 0, 208, 208,
1090 208, 208, 208, 208, 0, 0, 0, 0, 0, 0,
1091 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1092 0, 0, 0, 208, 208, 212, 212, 212, 212, 212,
1093 212, 212, 212, 212, 212, 212, 212, 212, 212, 212,
1094 212, 212, 212, 212, 212, 212, 212, 212, 212, 212,
1095 212, 212, 212, 212, 212, 212, 212, 212, 212, 212,
1096 212, 212, 212, 212, 212, 212, 212, 212, 212, 212,
1097
1098 212, 212, 212, 212, 212, 212, 212, 212, 212, 212,
1099 212, 212, 212, 212, 212, 212, 212, 213, 213, 213,
1100 213, 213, 213, 213, 213, 213, 213, 213, 213, 213,
1101 213, 213, 213, 213, 213, 213, 213, 213, 213, 213,
1102 213, 213, 213, 213, 213, 213, 213, 213, 213, 213,
1103 213, 213, 213, 213, 213, 213, 213, 213, 213, 213,
1104 213, 213, 213, 213, 213, 213, 213, 213, 213, 213,
1105 213, 213, 213, 213, 213, 213, 213, 213, 213, 213,
1106 213, 229, 229, 334, 334, 334, 0, 236, 236, 229,
1107 229, 229, 229, 229, 229, 244, 0, 0, 253, 236,
1108
1109 0, 0, 334, 0, 253, 244, 0, 0, 0, 0,
1110 0, 229, 229, 229, 229, 229, 236, 244, 0, 253,
1111 236, 251, 251, 251, 253, 244, 254, 0, 0, 251,
1112 266, 0, 254, 0, 0, 268, 251, 255, 255, 255,
1113 251, 255, 0, 266, 266, 0, 297, 254, 268, 268,
1114 318, 0, 254, 0, 0, 266, 255, 271, 272, 297,
1115 297, 273, 0, 318, 318, 0, 0, 271, 272, 0,
1116 266, 273, 266, 0, 0, 268, 266, 268, 0, 271,
1117 272, 255, 257, 273, 332, 0, 297, 271, 272, 0,
1118 318, 273, 332, 0, 332, 257, 257, 337, 0, 0,
1119
1120 0, 0, 0, 257, 257, 257, 257, 257, 257, 0,
1121 337, 337, 0, 0, 0, 0, 0, 0, 0, 0,
1122 0, 0, 0, 0, 332, 257, 257, 257, 257, 257,
1123 258, 258, 319, 0, 0, 322, 0, 337, 258, 258,
1124 258, 258, 258, 258, 0, 319, 319, 0, 322, 322,
1125 0, 281, 281, 281, 331, 0, 0, 0, 0, 281,
1126 258, 258, 258, 258, 258, 259, 281, 331, 331, 0,
1127 281, 0, 319, 0, 319, 322, 0, 322, 259, 259,
1128 0, 0, 0, 0, 0, 0, 259, 259, 259, 259,
1129 259, 259, 0, 0, 331, 0, 331, 0, 0, 0,
1130
1131 0, 0, 0, 0, 0, 0, 0, 0, 259, 259,
1132 259, 259, 259, 260, 260, 260, 260, 260, 260, 260,
1133 260, 260, 260, 260, 260, 260, 260, 260, 0, 0,
1134 260, 260, 260, 260, 260, 260, 333, 0, 0, 339,
1135 0, 0, 0, 0, 0, 0, 0, 0, 0, 333,
1136 333, 0, 339, 339, 0, 260, 260, 264, 264, 0,
1137 0, 0, 0, 0, 0, 264, 264, 264, 264, 264,
1138 264, 0, 0, 0, 0, 0, 333, 0, 333, 339,
1139 0, 339, 0, 0, 0, 0, 0, 264, 264, 264,
1140 264, 264, 269, 269, 269, 269, 269, 269, 269, 269,
1141
1142 269, 269, 269, 269, 269, 269, 269, 0, 0, 269,
1143 269, 269, 269, 269, 269, 0, 0, 0, 0, 0,
1144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1145 0, 0, 0, 0, 269, 269, 294, 294, 341, 0,
1146 0, 0, 0, 0, 294, 294, 294, 294, 294, 294,
1147 0, 341, 341, 0, 0, 0, 0, 299, 299, 299,
1148 0, 299, 0, 0, 0, 299, 294, 294, 294, 294,
1149 294, 296, 299, 0, 0, 0, 299, 0, 341, 0,
1150 341, 0, 0, 296, 296, 0, 0, 0, 0, 0,
1151 0, 296, 296, 296, 296, 296, 296, 0, 0, 0,
1152
1153 0, 299, 0, 0, 0, 0, 0, 0, 0, 0,
1154 0, 0, 296, 296, 296, 296, 296, 296, 298, 298,
1155 298, 298, 298, 298, 298, 298, 298, 298, 298, 298,
1156 298, 298, 298, 0, 0, 298, 298, 298, 298, 298,
1157 298, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1158 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1159 298, 298, 343, 0, 0, 343, 0, 0, 0, 343,
1160 343, 343, 344, 344, 344, 0, 0, 0, 0, 0,
1161 344, 0, 344, 0, 0, 344, 344, 344, 345, 0,
1162 345, 345, 345, 346, 346, 346, 0, 0, 0, 0,
1163
1164 346, 346, 346, 0, 0, 0, 346, 346, 346, 347,
1165 347, 347, 347, 347, 347, 347, 347, 347, 347, 347,
1166 347, 347, 347, 348, 348, 348, 348, 348, 348, 348,
1167 348, 348, 348, 348, 348, 348, 348, 349, 349, 349,
1168 349, 349, 349, 349, 349, 349, 349, 349, 349, 349,
1169 349, 349, 349, 349, 350, 350, 0, 350, 350, 350,
1170 350, 350, 350, 350, 350, 350, 350, 350, 350, 350,
1171 350, 351, 351, 351, 352, 0, 0, 0, 352, 352,
1172 352, 355, 0, 0, 355, 355, 355, 355, 356, 356,
1173 356, 0, 356, 0, 0, 0, 0, 0, 356, 0,
1174
1175 0, 356, 356, 356, 357, 357, 357, 357, 357, 357,
1176 357, 357, 357, 357, 357, 357, 357, 357, 357, 357,
1177 357, 358, 358, 0, 358, 358, 358, 358, 358, 358,
1178 358, 358, 358, 358, 358, 358, 358, 358, 359, 359,
1179 359, 359, 359, 359, 359, 359, 359, 359, 359, 359,
1180 359, 359, 360, 0, 0, 0, 0, 360, 0, 0,
1181 0, 360, 361, 0, 0, 361, 361, 361, 361, 362,
1182 0, 0, 362, 362, 0, 0, 0, 362, 0, 362,
1183 363, 363, 363, 364, 364, 364, 0, 0, 0, 0,
1184 364, 364, 364, 0, 0, 0, 364, 364, 364, 365,
1185
1186 365, 365, 365, 365, 365, 365, 365, 365, 365, 365,
1187 365, 365, 365, 368, 0, 0, 368, 368, 368, 368,
1188 369, 369, 369, 369, 369, 369, 369, 369, 369, 369,
1189 369, 369, 369, 369, 370, 0, 0, 0, 370, 0,
1190 0, 0, 370, 0, 370, 342, 342, 342, 342, 342,
1191 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
1192 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
1193 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
1194 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
1195 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
1196
1197 342, 342, 342, 342, 342, 342, 342, 342, 342, 342,
1198 342
1199 } ;
1200
1201static yy_state_type yy_last_accepting_state;
1202static char *yy_last_accepting_cpos;
1203
1204extern int yy_flex_debug;
1205int yy_flex_debug = 0;
1206
1207/* The intent behind this definition is that it'll catch
1208 * any uses of REJECT which flex missed.
1209 */
1210#define REJECTreject_used_but_not_detected reject_used_but_not_detected
1211#define yymore()yymore_used_but_not_detected yymore_used_but_not_detected
1212#define YY_MORE_ADJ0 0
1213#define YY_RESTORE_YY_MORE_OFFSET
1214char *yytextada_yytext;
1215#line 1 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1216/* FLEX lexer for Ada expressions, for GDB.
1217 Copyright (C) 1994, 1997, 1998, 2000, 2001, 2002, 2003
1218 Free Software Foundation, Inc.
1219
1220This file is part of GDB.
1221
1222This program is free software; you can redistribute it and/or modify
1223it under the terms of the GNU General Public License as published by
1224the Free Software Foundation; either version 2 of the License, or
1225(at your option) any later version.
1226
1227This program is distributed in the hope that it will be useful,
1228but WITHOUT ANY WARRANTY; without even the implied warranty of
1229MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1230GNU General Public License for more details.
1231
1232You should have received a copy of the GNU General Public License
1233along with this program; if not, write to the Free Software
1234Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
1235/*----------------------------------------------------------------------*/
1236/* The converted version of this file is to be included in ada-exp.y, */
1237/* the Ada parser for gdb. The function yylex obtains characters from */
1238/* the global pointer lexptr. It returns a syntactic category for */
1239/* each successive token and places a semantic value into yylval */
1240/* (ada-lval), defined by the parser. */
1241#line 45 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1242
1243#define NUMERAL_WIDTH256 256
1244#define LONGEST_SIGN((unsigned long) 1 << (sizeof(long) * 8 - 1)) ((ULONGESTunsigned long) 1 << (sizeof(LONGESTlong) * HOST_CHAR_BIT8 - 1))
1245
1246/* Temporary staging for numeric literals. */
1247static char numbuf[NUMERAL_WIDTH256];
1248 static void canonicalizeNumeral (char *s1, const char *);
1249static int processInt (const char *, const char *, const char *);
1250static int processReal (const char *);
1251static int processId (const char *, int);
1252static int processAttribute (const char *);
1253static int find_dot_all (const char *);
1254
1255#undef YY_DECLstatic int ada_lex ( void )
1256#define YY_DECLstatic int ada_lex ( void ) static int yylexada_lex ( void )
1257
1258#undef YY_INPUT
1259#define YY_INPUT(BUF, RESULT, MAX_SIZE)if ( *lexptr == '\000' ) (RESULT) = 0; else { *(BUF) = *lexptr
; (RESULT) = 1; lexptr += 1; } \
1260 if ( *lexptr == '\000' ) \
1261 (RESULT) = YY_NULL0; \
1262 else \
1263 { \
1264 *(BUF) = *lexptr; \
1265 (RESULT) = 1; \
1266 lexptr += 1; \
1267 }
1268
1269static char *tempbuf = NULL((void*)0);
1270static int tempbufsize = 0;
1271static int tempbuf_len;
1272static struct block *left_block_context;
1273
1274static void resize_tempbuf (unsigned int);
1275
1276static void block_lookup (char *, char *);
1277
1278static int name_lookup (char *, char *, int *, int);
1279
1280static int find_dot_all (const char *);
1281
1282
1283#line 1284 "ada-lex.c"
1284
1285#define INITIAL0 0
1286#define IN_STRING1 1
1287#define BEFORE_QUAL_QUOTE2 2
1288
1289#ifndef YY_NO_UNISTD_H
1290/* Special case for "unistd.h", since it is non-ANSI. We include it way
1291 * down here because we want the user's section 1 to have been scanned first.
1292 * The user has a chance to override it with an option.
1293 */
1294#include <unistd.h>
1295#endif
1296
1297#ifndef YY_EXTRA_TYPEvoid *
1298#define YY_EXTRA_TYPEvoid * void *
1299#endif
1300
1301static int yy_init_globals (void );
1302
1303/* Accessor methods to globals.
1304 These are made visible to non-reentrant scanners for convenience. */
1305
1306int yylex_destroy (void );
1307
1308int yyget_debug (void );
1309
1310void yyset_debug (int debug_flag );
1311
1312YY_EXTRA_TYPEvoid * yyget_extra (void );
1313
1314void yyset_extra (YY_EXTRA_TYPEvoid * user_defined );
1315
1316FILE *yyget_in (void );
1317
1318void yyset_in (FILE * in_str );
1319
1320FILE *yyget_out (void );
1321
1322void yyset_out (FILE * out_str );
1323
1324yy_size_t yyget_leng (void );
1325
1326char *yyget_text (void );
1327
1328int yyget_lineno (void );
1329
1330void yyset_lineno (int line_number );
1331
1332/* Macros after this point can all be overridden by user definitions in
1333 * section 1.
1334 */
1335
1336#ifndef YY_SKIP_YYWRAP
1337#ifdef __cplusplus
1338extern "C" int yywrapada_yywrap (void );
1339#else
1340extern int yywrapada_yywrap (void );
1341#endif
1342#endif
1343
1344 static void yyunput (int c,char *buf_ptr );
1345
1346#ifndef yytext_ptrada_yytext
1347static void yy_flex_strncpy (char *,yyconstconst char *,int );
1348#endif
1349
1350#ifdef YY_NEED_STRLEN
1351static int yy_flex_strlen (yyconstconst char * );
1352#endif
1353
1354#ifndef YY_NO_INPUT
1355
1356#ifdef __cplusplus
1357static int yyinput (void );
1358#else
1359static int input (void );
1360#endif
1361
1362#endif
1363
1364/* Amount of stuff to slurp up with each read. */
1365#ifndef YY_READ_BUF_SIZE8192
1366#define YY_READ_BUF_SIZE8192 8192
1367#endif
1368
1369/* Copy whatever the last rule matched to the standard output. */
1370#ifndef ECHOdo { if (fwrite( ada_yytext, yyleng, 1, yyout )) {} } while (
0)
1371/* This used to be an fputs(), but since the string might contain NUL's,
1372 * we now use fwrite().
1373 */
1374#define ECHOdo { if (fwrite( ada_yytext, yyleng, 1, yyout )) {} } while (
0) do { if (fwrite( yytextada_yytext, yyleng, 1, yyout )) {} } while (0)
1375#endif
1376
1377/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1378 * is returned in "result".
1379 */
1380#ifndef YY_INPUT
1381#define YY_INPUT(buf,result,max_size)if ( *lexptr == '\000' ) (result) = 0; else { *(buf) = *lexptr
; (result) = 1; lexptr += 1; } \
1382 if ( YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_is_interactive ) \
1383 { \
1384 int c = '*'; \
1385 size_t n; \
1386 for ( n = 0; n < max_size && \
1387 (c = getc( yyin )(!__isthreaded ? (--(yyin)->_r < 0 ? __srget(yyin) : (int
)(*(yyin)->_p++)) : (getc)(yyin))) != EOF(-1) && c != '\n'; ++n ) \
1388 buf[n] = (char) c; \
1389 if ( c == '\n' ) \
1390 buf[n++] = (char) c; \
1391 if ( c == EOF(-1) && ferror( yyin )(!__isthreaded ? (((yyin)->_flags & 0x0040) != 0) : (ferror
)(yyin)) ) \
1392 YY_FATAL_ERROR( "input in flex scanner failed" )yy_fatal_error( "input in flex scanner failed" ); \
1393 result = n; \
1394 } \
1395 else \
1396 { \
1397 errno(*__errno())=0; \
1398 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)(!__isthreaded ? (((yyin)->_flags & 0x0040) != 0) : (ferror
)(yyin))) \
1399 { \
1400 if( errno(*__errno()) != EINTR4) \
1401 { \
1402 YY_FATAL_ERROR( "input in flex scanner failed" )yy_fatal_error( "input in flex scanner failed" ); \
1403 break; \
1404 } \
1405 errno(*__errno())=0; \
1406 clearerr(yyin)(!__isthreaded ? ((void)((yyin)->_flags &= ~(0x0040|0x0020
))) : (clearerr)(yyin)); \
1407 } \
1408 }\
1409\
1410
1411#endif
1412
1413/* No semi-colon after return; correct usage is to write "yyterminate();" -
1414 * we don't want an extra ';' after the "return" because that will cause
1415 * some compilers to complain about unreachable statements.
1416 */
1417#ifndef yyterminate
1418#define yyterminate()return 0 return YY_NULL0
1419#endif
1420
1421/* Number of entries by which start-condition stack grows. */
1422#ifndef YY_START_STACK_INCR25
1423#define YY_START_STACK_INCR25 25
1424#endif
1425
1426/* Report a fatal error. */
1427#ifndef YY_FATAL_ERROR
1428#define YY_FATAL_ERROR(msg)yy_fatal_error( msg ) yy_fatal_error( msg )
1429#endif
1430
1431/* end tables serialization structures and prototypes */
1432
1433/* Default declaration of generated scanner - a define so the user can
1434 * easily add parameters.
1435 */
1436#ifndef YY_DECLstatic int ada_lex ( void )
1437#define YY_DECL_IS_OURS 1
1438
1439extern int yylexada_lex (void);
1440
1441#define YY_DECLstatic int ada_lex ( void ) int yylexada_lex (void)
1442#endif /* !YY_DECL */
1443
1444/* Code executed at the beginning of each rule, after yytext and yyleng
1445 * have been set up.
1446 */
1447#ifndef YY_USER_ACTION
1448#define YY_USER_ACTION
1449#endif
1450
1451/* Code executed at the end of each rule. */
1452#ifndef YY_BREAKbreak;
1453#define YY_BREAKbreak; break;
1454#endif
1455
1456#define YY_RULE_SETUP \
1457 YY_USER_ACTION
1458
1459/** The main scanner function which does all the work.
1460 */
1461YY_DECLstatic int ada_lex ( void )
1462{
1463 yy_state_type yy_current_state;
1464 char *yy_cp, *yy_bp;
1465 int yy_act;
1466
1467 if ( !(yy_init) )
1468 {
1469 (yy_init) = 1;
1470
1471#ifdef YY_USER_INIT
1472 YY_USER_INIT;
1473#endif
1474
1475 if ( ! (yy_start) )
1476 (yy_start) = 1; /* first start state */
1477
1478 if ( ! yyin ) {
1479 yyin = stdin(&__sF[0]);
1480 }
1481
1482 if ( ! yyout ) {
1483 yyout = stdout(&__sF[1]);
1484 }
1485
1486 if ( ! YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)) ) {
1487 yyensure_buffer_stack ();
1488 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)] =
1489 yy_create_bufferada_yy_create_buffer(yyin,YY_BUF_SIZE16384 );
1490 }
1491
1492 yy_load_buffer_stateada_yy_load_buffer_state( );
1493 }
1494
1495 {
1496#line 91 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1497
1498
1499#line 1500 "ada-lex.c"
1500
1501 while ( 1 ) /* loops until end-of-file is reached */
1502 {
1503 yy_cp = (yy_c_buf_p);
1504
1505 /* Support of yytext. */
1506 *yy_cp = (yy_hold_char);
1507
1508 /* yy_bp points to the position in yy_ch_buf of the start of
1509 * the current run.
1510 */
1511 yy_bp = yy_cp;
1512
1513 yy_current_state = (yy_start);
1514yy_match:
1515 do
1516 {
1517 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)((unsigned int) (unsigned char) *yy_cp)] ;
1518 if ( yy_accept[yy_current_state] )
1519 {
1520 (yy_last_accepting_state) = yy_current_state;
1521 (yy_last_accepting_cpos) = yy_cp;
1522 }
1523 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1524 {
1525 yy_current_state = (int) yy_def[yy_current_state];
1526 if ( yy_current_state >= 343 )
1527 yy_c = yy_meta[(unsigned int) yy_c];
1528 }
1529 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1530 ++yy_cp;
1531 }
1532 while ( yy_base[yy_current_state] != 2846 );
1533
1534yy_find_action:
1535 yy_act = yy_accept[yy_current_state];
1536 if ( yy_act == 0 )
1537 { /* have to back up */
1538 yy_cp = (yy_last_accepting_cpos);
1539 yy_current_state = (yy_last_accepting_state);
1540 yy_act = yy_accept[yy_current_state];
1541 }
1542
1543 YY_DO_BEFORE_ACTION(ada_yytext) = yy_bp; yyleng = (size_t) (yy_cp - yy_bp); (yy_hold_char
) = *yy_cp; *yy_cp = '\0'; (yy_c_buf_p) = yy_cp;;
1544
1545do_action: /* This label is used only to access EOF actions. */
1546
1547 switch ( yy_act )
1548 { /* beginning of action switch */
1549 case 0: /* must back up */
1550 /* undo the effects of YY_DO_BEFORE_ACTION */
1551 *yy_cp = (yy_hold_char);
1552 yy_cp = (yy_last_accepting_cpos);
1553 yy_current_state = (yy_last_accepting_state);
1554 goto yy_find_action;
1555
1556case 1:
1557/* rule 1 can match eol */
1558YY_RULE_SETUP
1559#line 93 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1560{ }
1561 YY_BREAKbreak;
1562case 2:
1563YY_RULE_SETUP
1564#line 95 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1565{ yyterminate()return 0; }
1566 YY_BREAKbreak;
1567case 3:
1568YY_RULE_SETUP
1569#line 97 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1570{
1571 canonicalizeNumeral (numbuf, yytextada_yytext);
1572 return processInt (NULL((void*)0), numbuf, strrchr(numbuf, 'e')+1);
1573 }
1574 YY_BREAKbreak;
1575case 4:
1576YY_RULE_SETUP
1577#line 102 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1578{
1579 canonicalizeNumeral (numbuf, yytextada_yytext);
1580 return processInt (NULL((void*)0), numbuf, NULL((void*)0));
1581 }
1582 YY_BREAKbreak;
1583case 5:
1584YY_RULE_SETUP
1585#line 107 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1586{
1587 canonicalizeNumeral (numbuf, yytextada_yytext);
1588 return processInt (numbuf,
1589 strchr (numbuf, '#') + 1,
1590 strrchr(numbuf, '#') + 1);
1591 }
1592 YY_BREAKbreak;
1593case 6:
1594YY_RULE_SETUP
1595#line 114 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1596{
1597 canonicalizeNumeral (numbuf, yytextada_yytext);
1598 return processInt (numbuf, strchr (numbuf, '#') + 1, NULL((void*)0));
1599 }
1600 YY_BREAKbreak;
1601case 7:
1602YY_RULE_SETUP
1603#line 119 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1604{
1605 canonicalizeNumeral (numbuf, yytextada_yytext+2);
1606 return processInt ("16#", numbuf, NULL((void*)0));
1607 }
1608 YY_BREAKbreak;
1609case 8:
1610YY_RULE_SETUP
1611#line 125 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1612{
1613 canonicalizeNumeral (numbuf, yytextada_yytext);
1614 return processReal (numbuf);
1615 }
1616 YY_BREAKbreak;
1617case 9:
1618YY_RULE_SETUP
1619#line 130 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1620{
1621 canonicalizeNumeral (numbuf, yytextada_yytext);
1622 return processReal (numbuf);
1623 }
1624 YY_BREAKbreak;
1625case 10:
1626YY_RULE_SETUP
1627#line 135 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1628{
1629 error ("Based real literals not implemented yet.");
1630 }
1631 YY_BREAKbreak;
1632case 11:
1633YY_RULE_SETUP
1634#line 139 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1635{
1636 error ("Based real literals not implemented yet.");
1637 }
1638 YY_BREAKbreak;
1639case 12:
1640YY_RULE_SETUP
1641#line 143 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1642{
1643 yylvalada_lval.typed_val.type = type_char ();
1644 yylvalada_lval.typed_val.val = yytextada_yytext[1];
1645 return CHARLIT259;
1646 }
1647 YY_BREAKbreak;
1648case 13:
1649YY_RULE_SETUP
1650#line 149 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1651{
1652 int v;
1653 yylvalada_lval.typed_val.type = type_char ();
1654 sscanf (yytextada_yytext+3, "%2x", &v);
1655 yylvalada_lval.typed_val.val = v;
1656 return CHARLIT259;
1657 }
1658 YY_BREAKbreak;
1659case 14:
1660YY_RULE_SETUP
1661#line 157 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1662{
1663 tempbuf_len = 0;
1664 BEGIN(yy_start) = 1 + 2 * IN_STRING1;
1665 }
1666 YY_BREAKbreak;
1667case 15:
1668YY_RULE_SETUP
1669#line 162 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1670{
1671 resize_tempbuf (yyleng+tempbuf_len);
1672 strncpy (tempbuf+tempbuf_len, yytextada_yytext, yyleng-1);
1673 tempbuf_len += yyleng-1;
1674 yylvalada_lval.sval.ptr = tempbuf;
1675 yylvalada_lval.sval.length = tempbuf_len;
1676 BEGIN(yy_start) = 1 + 2 * INITIAL0;
1677 return STRING263;
1678 }
1679 YY_BREAKbreak;
1680case 16:
1681YY_RULE_SETUP
1682#line 172 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1683{
1684 int n;
1685 resize_tempbuf (yyleng-5+tempbuf_len+1);
1686 strncpy (tempbuf+tempbuf_len, yytextada_yytext, yyleng-6);
1687 sscanf(yytextada_yytext+yyleng-4, "%2x", &n);
1688 tempbuf[yyleng-6+tempbuf_len] = (char) n;
1689 tempbuf_len += yyleng-5;
1690 }
1691 YY_BREAKbreak;
1692case 17:
1693YY_RULE_SETUP
1694#line 181 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1695{
1696 int n;
1697 resize_tempbuf (yyleng-4+tempbuf_len+1);
1698 strncpy (tempbuf+tempbuf_len, yytextada_yytext, yyleng-6);
1699 tempbuf[yyleng-5+tempbuf_len] = '"';
1700 tempbuf_len += yyleng-4;
1701 }
1702 YY_BREAKbreak;
1703case 18:
1704YY_RULE_SETUP
1705#line 189 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1706{
1707 while (*lexptr != 'i' && *lexptr != 'I')
1708 lexptr -= 1;
1709 yyrestartada_yyrestart(NULL((void*)0));
1710 return 0;
1711 }
1712 YY_BREAKbreak;
1713/* ADA KEYWORDS */
1714case 19:
1715YY_RULE_SETUP
1716#line 198 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1717{ return ABS284; }
1718 YY_BREAKbreak;
1719case 20:
1720YY_RULE_SETUP
1721#line 199 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1722{ return _AND_270; }
1723 YY_BREAKbreak;
1724case 21:
1725YY_RULE_SETUP
1726#line 200 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1727{ return ELSE274; }
1728 YY_BREAKbreak;
1729case 22:
1730YY_RULE_SETUP
1731#line 201 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1732{ return IN278; }
1733 YY_BREAKbreak;
1734case 23:
1735YY_RULE_SETUP
1736#line 202 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1737{ return MOD281; }
1738 YY_BREAKbreak;
1739case 24:
1740YY_RULE_SETUP
1741#line 203 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1742{ return NEW300; }
1743 YY_BREAKbreak;
1744case 25:
1745YY_RULE_SETUP
1746#line 204 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1747{ return NOT285; }
1748 YY_BREAKbreak;
1749case 26:
1750YY_RULE_SETUP
1751#line 205 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1752{ return NULL_PTR258; }
1753 YY_BREAKbreak;
1754case 27:
1755YY_RULE_SETUP
1756#line 206 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1757{ return OR271; }
1758 YY_BREAKbreak;
1759case 28:
1760YY_RULE_SETUP
1761#line 207 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1762{ return REM282; }
1763 YY_BREAKbreak;
1764case 29:
1765YY_RULE_SETUP
1766#line 208 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1767{ return THEN273; }
1768 YY_BREAKbreak;
1769case 30:
1770YY_RULE_SETUP
1771#line 209 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1772{ return XOR272; }
1773 YY_BREAKbreak;
1774/* ATTRIBUTES */
1775case 31:
1776/* rule 31 can match eol */
1777YY_RULE_SETUP
1778#line 213 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1779{ return processAttribute (yytextada_yytext+1); }
1780 YY_BREAKbreak;
1781/* PUNCTUATION */
1782case 32:
1783YY_RULE_SETUP
1784#line 217 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1785{ return ARROW299; }
1786 YY_BREAKbreak;
1787case 33:
1788YY_RULE_SETUP
1789#line 218 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1790{ return DOTDOT279; }
1791 YY_BREAKbreak;
1792case 34:
1793YY_RULE_SETUP
1794#line 219 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1795{ return STARSTAR283; }
1796 YY_BREAKbreak;
1797case 35:
1798YY_RULE_SETUP
1799#line 220 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1800{ return ASSIGN269; }
1801 YY_BREAKbreak;
1802case 36:
1803YY_RULE_SETUP
1804#line 221 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1805{ return NOTEQUAL275; }
1806 YY_BREAKbreak;
1807case 37:
1808YY_RULE_SETUP
1809#line 222 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1810{ return LEQ276; }
1811 YY_BREAKbreak;
1812case 38:
1813YY_RULE_SETUP
1814#line 223 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1815{ return GEQ277; }
1816 YY_BREAKbreak;
1817case 39:
1818YY_RULE_SETUP
1819#line 225 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1820{ BEGIN(yy_start) = 1 + 2 * INITIAL0; return '\''; }
1821 YY_BREAKbreak;
1822case 40:
1823YY_RULE_SETUP
1824#line 227 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1825{ return yytextada_yytext[0]; }
1826 YY_BREAKbreak;
1827case 41:
1828YY_RULE_SETUP
1829#line 229 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1830{ if (paren_depth == 0 && comma_terminates)
1831 {
1832 lexptr -= 1;
1833 yyrestartada_yyrestart(NULL((void*)0));
1834 return 0;
1835 }
1836 else
1837 return ',';
1838 }
1839 YY_BREAKbreak;
1840case 42:
1841YY_RULE_SETUP
1842#line 239 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1843{ paren_depth += 1; return '('; }
1844 YY_BREAKbreak;
1845case 43:
1846YY_RULE_SETUP
1847#line 240 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1848{ if (paren_depth == 0)
1849 {
1850 lexptr -= 1;
1851 yyrestartada_yyrestart(NULL((void*)0));
1852 return 0;
1853 }
1854 else
1855 {
1856 paren_depth -= 1;
1857 return ')';
1858 }
1859 }
1860 YY_BREAKbreak;
1861case 44:
1862/* rule 44 can match eol */
1863YY_RULE_SETUP
1864#line 253 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1865{ return DOT_ALL267; }
1866 YY_BREAKbreak;
1867case 45:
1868/* rule 45 can match eol */
1869YY_RULE_SETUP
1870#line 255 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1871{
1872 processId (yytextada_yytext+1, yyleng-1);
1873 return DOT_ID265;
1874 }
1875 YY_BREAKbreak;
1876case 46:
1877/* rule 46 can match eol */
1878YY_RULE_SETUP
1879#line 260 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1880{
1881 int all_posn = find_dot_all (yytextada_yytext);
1882 int token_type, segments, k;
1883 int quote_follows;
1884
1885 if (all_posn == -1 && yytextada_yytext[yyleng-1] == '\'')
1886 {
1887 quote_follows = 1;
1888 do {
1889 yyless (yyleng-1)do { int yyless_macro_arg = (yyleng-1); ; ada_yytext[yyleng] =
(yy_hold_char); (yy_c_buf_p) = ada_yytext + yyless_macro_arg
; (yy_hold_char) = *(yy_c_buf_p); *(yy_c_buf_p) = '\0'; yyleng
= yyless_macro_arg; } while ( 0 );
1890 } while (yytextada_yytext[yyleng-1] == ' ');
1891 }
1892 else
1893 quote_follows = 0;
1894
1895 if (all_posn >= 0)
1896 yyless (all_posn)do { int yyless_macro_arg = (all_posn); ; ada_yytext[yyleng] =
(yy_hold_char); (yy_c_buf_p) = ada_yytext + yyless_macro_arg
; (yy_hold_char) = *(yy_c_buf_p); *(yy_c_buf_p) = '\0'; yyleng
= yyless_macro_arg; } while ( 0 );
1897 processId(yytextada_yytext, yyleng);
1898 segments = name_lookup (ada_encode (yylvalada_lval.ssym.stoken.ptr),
1899 yylvalada_lval.ssym.stoken.ptr,
1900 &token_type,
1901 MAX_RENAMING_CHAIN_LENGTH10);
1902 left_block_context = NULL((void*)0);
1903 for (k = yyleng; segments > 0 && k > 0; k -= 1)
1904 {
1905 if (yytextada_yytext[k-1] == '.')
1906 segments -= 1;
1907 quote_follows = 0;
1908 }
1909 if (k <= 0)
1910 error ("confused by name %s", yytextada_yytext);
1911 yyless (k)do { int yyless_macro_arg = (k); ; ada_yytext[yyleng] = (yy_hold_char
); (yy_c_buf_p) = ada_yytext + yyless_macro_arg; (yy_hold_char
) = *(yy_c_buf_p); *(yy_c_buf_p) = '\0'; yyleng = yyless_macro_arg
; } while ( 0 );
1912 if (quote_follows)
1913 BEGIN(yy_start) = 1 + 2 * BEFORE_QUAL_QUOTE2;
1914 return token_type;
1915 }
1916 YY_BREAKbreak;
1917/* GDB EXPRESSION CONSTRUCTS */
1918case 47:
1919/* rule 47 can match eol */
1920YY_RULE_SETUP
1921#line 300 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1922{
1923 processId(yytextada_yytext, yyleng-2);
1924 block_lookup (yylvalada_lval.ssym.stoken.ptr, yylvalada_lval.ssym.stoken.ptr);
1925 return BLOCKNAME262;
1926 }
1927 YY_BREAKbreak;
1928case 48:
1929/* rule 48 can match eol */
1930YY_RULE_SETUP
1931#line 306 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1932{
1933 processId(yytextada_yytext, yyleng-2);
1934 block_lookup (ada_encode (yylvalada_lval.ssym.stoken.ptr),
1935 yylvalada_lval.ssym.stoken.ptr);
1936 return BLOCKNAME262;
1937 }
1938 YY_BREAKbreak;
1939case 49:
1940YY_RULE_SETUP
1941#line 313 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1942{ return yytextada_yytext[0]; }
1943 YY_BREAKbreak;
1944/* REGISTERS AND GDB CONVENIENCE VARIABLES */
1945case 50:
1946YY_RULE_SETUP
1947#line 317 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1948{
1949 yylvalada_lval.sval.ptr = yytextada_yytext;
1950 yylvalada_lval.sval.length = yyleng;
1951 return SPECIAL_VARIABLE268;
1952 }
1953 YY_BREAKbreak;
1954/* CATCH-ALL ERROR CASE */
1955case 51:
1956YY_RULE_SETUP
1957#line 325 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1958{ error ("Invalid character '%s' in expression.", yytextada_yytext); }
1959 YY_BREAKbreak;
1960case 52:
1961YY_RULE_SETUP
1962#line 326 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
1963YY_FATAL_ERROR( "flex scanner jammed" )yy_fatal_error( "flex scanner jammed" );
1964 YY_BREAKbreak;
1965#line 1966 "ada-lex.c"
1966case YY_STATE_EOF(INITIAL)(53 + 0 + 1):
1967case YY_STATE_EOF(IN_STRING)(53 + 1 + 1):
1968case YY_STATE_EOF(BEFORE_QUAL_QUOTE)(53 + 2 + 1):
1969 yyterminate()return 0;
1970
1971 case YY_END_OF_BUFFER53:
1972 {
1973 /* Amount of text matched not including the EOB char. */
1974 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptrada_yytext)) - 1;
1975
1976 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1977 *yy_cp = (yy_hold_char);
1978 YY_RESTORE_YY_MORE_OFFSET
1979
1980 if ( YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buffer_status == YY_BUFFER_NEW0 )
1981 {
1982 /* We're scanning a new file or input source. It's
1983 * possible that this happened because the user
1984 * just pointed yyin at a new source and called
1985 * yylex(). If so, then we have to assure
1986 * consistency between YY_CURRENT_BUFFER and our
1987 * globals. Here is the right place to do so, because
1988 * this is the first action (other than possibly a
1989 * back-up) that will match for the new input source.
1990 */
1991 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_n_chars;
1992 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_input_file = yyin;
1993 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buffer_status = YY_BUFFER_NORMAL1;
1994 }
1995
1996 /* Note that here we test for yy_c_buf_p "<=" to the position
1997 * of the first EOB in the buffer, since yy_c_buf_p will
1998 * already have been incremented past the NUL character
1999 * (since all states make transitions on EOB to the
2000 * end-of-buffer state). Contrast this with the test
2001 * in input().
2002 */
2003 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[(yy_n_chars)] )
2004 { /* This was really a NUL. */
2005 yy_state_type yy_next_state;
2006
2007 (yy_c_buf_p) = (yytext_ptrada_yytext) + yy_amount_of_matched_text;
2008
2009 yy_current_state = yy_get_previous_state( );
2010
2011 /* Okay, we're now positioned to make the NUL
2012 * transition. We couldn't have
2013 * yy_get_previous_state() go ahead and do it
2014 * for us because it doesn't know how to deal
2015 * with the possibility of jamming (and we don't
2016 * want to build jamming into it because then it
2017 * will run more slowly).
2018 */
2019
2020 yy_next_state = yy_try_NUL_trans( yy_current_state );
2021
2022 yy_bp = (yytext_ptrada_yytext) + YY_MORE_ADJ0;
2023
2024 if ( yy_next_state )
2025 {
2026 /* Consume the NUL. */
2027 yy_cp = ++(yy_c_buf_p);
2028 yy_current_state = yy_next_state;
2029 goto yy_match;
2030 }
2031
2032 else
2033 {
2034 yy_cp = (yy_c_buf_p);
2035 goto yy_find_action;
2036 }
2037 }
2038
2039 else switch ( yy_get_next_buffer( ) )
2040 {
2041 case EOB_ACT_END_OF_FILE1:
2042 {
2043 (yy_did_buffer_switch_on_eof) = 0;
2044
2045 if ( yywrapada_yywrap( ) )
2046 {
2047 /* Note: because we've taken care in
2048 * yy_get_next_buffer() to have set up
2049 * yytext, we can now set up
2050 * yy_c_buf_p so that if some total
2051 * hoser (like flex itself) wants to
2052 * call the scanner after we return the
2053 * YY_NULL, it'll still work - another
2054 * YY_NULL will get returned.
2055 */
2056 (yy_c_buf_p) = (yytext_ptrada_yytext) + YY_MORE_ADJ0;
2057
2058 yy_act = YY_STATE_EOF(YY_START)(53 + (((yy_start) - 1) / 2) + 1);
2059 goto do_action;
2060 }
2061
2062 else
2063 {
2064 if ( ! (yy_did_buffer_switch_on_eof) )
2065 YY_NEW_FILEada_yyrestart(yyin );
2066 }
2067 break;
2068 }
2069
2070 case EOB_ACT_CONTINUE_SCAN0:
2071 (yy_c_buf_p) =
2072 (yytext_ptrada_yytext) + yy_amount_of_matched_text;
2073
2074 yy_current_state = yy_get_previous_state( );
2075
2076 yy_cp = (yy_c_buf_p);
2077 yy_bp = (yytext_ptrada_yytext) + YY_MORE_ADJ0;
2078 goto yy_match;
2079
2080 case EOB_ACT_LAST_MATCH2:
2081 (yy_c_buf_p) =
2082 &YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[(yy_n_chars)];
2083
2084 yy_current_state = yy_get_previous_state( );
2085
2086 yy_cp = (yy_c_buf_p);
2087 yy_bp = (yytext_ptrada_yytext) + YY_MORE_ADJ0;
2088 goto yy_find_action;
2089 }
2090 break;
2091 }
2092
2093 default:
2094 YY_FATAL_ERROR(yy_fatal_error( "fatal flex scanner internal error--no action found"
)
2095 "fatal flex scanner internal error--no action found" )yy_fatal_error( "fatal flex scanner internal error--no action found"
);
2096 } /* end of action switch */
2097 } /* end of scanning one token */
2098 } /* end of user's declarations */
2099} /* end of yylex */
2100
2101/* yy_get_next_buffer - try to read in a new buffer
2102 *
2103 * Returns a code representing an action:
2104 * EOB_ACT_LAST_MATCH -
2105 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2106 * EOB_ACT_END_OF_FILE - end of file
2107 */
2108static int yy_get_next_buffer (void)
2109{
2110 char *dest = YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf;
2111 char *source = (yytext_ptrada_yytext);
2112 int number_to_move, i;
2113 int ret_val;
2114
2115 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[(yy_n_chars) + 1] )
2116 YY_FATAL_ERROR(yy_fatal_error( "fatal flex scanner internal error--end of buffer missed"
)
2117 "fatal flex scanner internal error--end of buffer missed" )yy_fatal_error( "fatal flex scanner internal error--end of buffer missed"
);
2118
2119 if ( YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_fill_buffer == 0 )
2120 { /* Don't try to fill the buffer, so this is an EOF. */
2121 if ( (yy_c_buf_p) - (yytext_ptrada_yytext) - YY_MORE_ADJ0 == 1 )
2122 {
2123 /* We matched a single character, the EOB, so
2124 * treat this as a final EOF.
2125 */
2126 return EOB_ACT_END_OF_FILE1;
2127 }
2128
2129 else
2130 {
2131 /* We matched some text prior to the EOB, first
2132 * process it.
2133 */
2134 return EOB_ACT_LAST_MATCH2;
2135 }
2136 }
2137
2138 /* Try to read more data. */
2139
2140 /* First move last chars to start of buffer. */
2141 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptrada_yytext)) - 1;
2142
2143 for ( i = 0; i < number_to_move; ++i )
2144 *(dest++) = *(source++);
2145
2146 if ( YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buffer_status == YY_BUFFER_EOF_PENDING2 )
2147 /* don't do the read, it's not guaranteed to return an EOF,
2148 * just force an EOF
2149 */
2150 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_n_chars = (yy_n_chars) = 0;
2151
2152 else
2153 {
2154 yy_size_t num_to_read =
2155 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buf_size - number_to_move - 1;
2156
2157 while ( num_to_read <= 0 )
2158 { /* Not enough room in the buffer - grow it. */
2159
2160 /* just a shorter name for the current buffer */
2161 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)];
2162
2163 int yy_c_buf_p_offset =
2164 (int) ((yy_c_buf_p) - b->yy_ch_buf);
2165
2166 if ( b->yy_is_our_buffer )
2167 {
2168 yy_size_t new_size = b->yy_buf_size * 2;
2169
2170 if ( new_size <= 0 )
2171 b->yy_buf_size += b->yy_buf_size / 8;
2172 else
2173 b->yy_buf_size *= 2;
2174
2175 b->yy_ch_buf = (char *)
2176 /* Include room in for 2 EOB chars. */
2177 yyxrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
2178 }
2179 else
2180 /* Can't grow it, we don't own it. */
2181 b->yy_ch_buf = 0;
2182
2183 if ( ! b->yy_ch_buf )
2184 YY_FATAL_ERROR(yy_fatal_error( "fatal error - scanner input buffer overflow"
)
2185 "fatal error - scanner input buffer overflow" )yy_fatal_error( "fatal error - scanner input buffer overflow"
);
2186
2187 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
2188
2189 num_to_read = YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buf_size -
2190 number_to_move - 1;
2191
2192 }
2193
2194 if ( num_to_read > YY_READ_BUF_SIZE8192 )
2195 num_to_read = YY_READ_BUF_SIZE8192;
2196
2197 /* Read in more data. */
2198 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),if ( *lexptr == '\000' ) ((yy_n_chars)) = 0; else { *((&(
yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[number_to_move
])) = *lexptr; ((yy_n_chars)) = 1; lexptr += 1; }
2199 (yy_n_chars), num_to_read )if ( *lexptr == '\000' ) ((yy_n_chars)) = 0; else { *((&(
yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[number_to_move
])) = *lexptr; ((yy_n_chars)) = 1; lexptr += 1; };
2200
2201 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_n_chars = (yy_n_chars);
2202 }
2203
2204 if ( (yy_n_chars) == 0 )
2205 {
2206 if ( number_to_move == YY_MORE_ADJ0 )
2207 {
2208 ret_val = EOB_ACT_END_OF_FILE1;
2209 yyrestartada_yyrestart(yyin );
2210 }
2211
2212 else
2213 {
2214 ret_val = EOB_ACT_LAST_MATCH2;
2215 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buffer_status =
2216 YY_BUFFER_EOF_PENDING2;
2217 }
2218 }
2219
2220 else
2221 ret_val = EOB_ACT_CONTINUE_SCAN0;
2222
2223 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buf_size) {
2224 /* Extend the array by 50%, plus the number we really need. */
2225 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
2226 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf = (char *) yyxrealloc((void *) YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf,new_size );
2227 if ( ! YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf )
2228 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" )yy_fatal_error( "out of dynamic memory in yy_get_next_buffer()"
);
2229 /* "- 2" to take care of EOB's */
2230 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buf_size = (int) (new_size - 2);
2231 }
2232
2233 (yy_n_chars) += number_to_move;
2234 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR0;
2235 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR0;
2236
2237 (yytext_ptrada_yytext) = &YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[0];
2238
2239 return ret_val;
2240}
2241
2242/* yy_get_previous_state - get the state just before the EOB char was reached */
2243
2244 static yy_state_type yy_get_previous_state (void)
2245{
2246 yy_state_type yy_current_state;
2247 char *yy_cp;
2248
2249 yy_current_state = (yy_start);
2250
2251 for ( yy_cp = (yytext_ptrada_yytext) + YY_MORE_ADJ0; yy_cp < (yy_c_buf_p); ++yy_cp )
2252 {
2253 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)((unsigned int) (unsigned char) *yy_cp)] : 1);
2254 if ( yy_accept[yy_current_state] )
2255 {
2256 (yy_last_accepting_state) = yy_current_state;
2257 (yy_last_accepting_cpos) = yy_cp;
2258 }
2259 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2260 {
2261 yy_current_state = (int) yy_def[yy_current_state];
2262 if ( yy_current_state >= 343 )
2263 yy_c = yy_meta[(unsigned int) yy_c];
2264 }
2265 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2266 }
2267
2268 return yy_current_state;
2269}
2270
2271/* yy_try_NUL_trans - try to make a transition on the NUL character
2272 *
2273 * synopsis
2274 * next_state = yy_try_NUL_trans( current_state );
2275 */
2276 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
2277{
2278 int yy_is_jam;
2279 char *yy_cp = (yy_c_buf_p);
2280
2281 YY_CHAR yy_c = 1;
2282 if ( yy_accept[yy_current_state] )
2283 {
2284 (yy_last_accepting_state) = yy_current_state;
2285 (yy_last_accepting_cpos) = yy_cp;
2286 }
2287 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2288 {
2289 yy_current_state = (int) yy_def[yy_current_state];
2290 if ( yy_current_state >= 343 )
2291 yy_c = yy_meta[(unsigned int) yy_c];
2292 }
2293 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2294 yy_is_jam = (yy_current_state == 342);
2295
2296 return yy_is_jam ? 0 : yy_current_state;
2297}
2298
2299 static void yyunput (int c, char * yy_bp )
2300{
2301 char *yy_cp;
2302
2303 yy_cp = (yy_c_buf_p);
2304
2305 /* undo effects of setting up yytext */
2306 *yy_cp = (yy_hold_char);
2307
2308 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf + 2 )
2309 { /* need to shift things up to make room */
2310 /* +2 for EOB chars. */
2311 yy_size_t number_to_move = (yy_n_chars) + 2;
2312 char *dest = &YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[
2313 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buf_size + 2];
2314 char *source =
2315 &YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[number_to_move];
2316
2317 while ( source > YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf )
2318 *--dest = *--source;
2319
2320 yy_cp += (int) (dest - source);
2321 yy_bp += (int) (dest - source);
2322 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_n_chars =
2323 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buf_size;
2324
2325 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf + 2 )
2326 YY_FATAL_ERROR( "flex scanner push-back overflow" )yy_fatal_error( "flex scanner push-back overflow" );
2327 }
2328
2329 *--yy_cp = (char) c;
2330
2331 (yytext_ptrada_yytext) = yy_bp;
2332 (yy_hold_char) = *yy_cp;
2333 (yy_c_buf_p) = yy_cp;
2334}
2335
2336#ifndef YY_NO_INPUT
2337#ifdef __cplusplus
2338 static int yyinput (void)
2339#else
2340 static int input (void)
2341#endif
2342
2343{
2344 int c;
2345
2346 *(yy_c_buf_p) = (yy_hold_char);
2347
2348 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR0 )
2349 {
2350 /* yy_c_buf_p now points to the character we want to return.
2351 * If this occurs *before* the EOB characters, then it's a
2352 * valid NUL; if not, then we've hit the end of the buffer.
2353 */
2354 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[(yy_n_chars)] )
2355 /* This was really a NUL. */
2356 *(yy_c_buf_p) = '\0';
2357
2358 else
2359 { /* need more input */
2360 yy_size_t offset = (yy_c_buf_p) - (yytext_ptrada_yytext);
2361 ++(yy_c_buf_p);
2362
2363 switch ( yy_get_next_buffer( ) )
2364 {
2365 case EOB_ACT_LAST_MATCH2:
2366 /* This happens because yy_g_n_b()
2367 * sees that we've accumulated a
2368 * token and flags that we need to
2369 * try matching the token before
2370 * proceeding. But for input(),
2371 * there's no matching to consider.
2372 * So convert the EOB_ACT_LAST_MATCH
2373 * to EOB_ACT_END_OF_FILE.
2374 */
2375
2376 /* Reset buffer status. */
2377 yyrestartada_yyrestart(yyin );
2378
2379 /*FALLTHROUGH*/
2380
2381 case EOB_ACT_END_OF_FILE1:
2382 {
2383 if ( yywrapada_yywrap( ) )
2384 return EOF(-1);
2385
2386 if ( ! (yy_did_buffer_switch_on_eof) )
2387 YY_NEW_FILEada_yyrestart(yyin );
2388#ifdef __cplusplus
2389 return yyinput();
2390#else
2391 return input();
2392#endif
2393 }
2394
2395 case EOB_ACT_CONTINUE_SCAN0:
2396 (yy_c_buf_p) = (yytext_ptrada_yytext) + offset;
2397 break;
2398 }
2399 }
2400 }
2401
2402 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
2403 *(yy_c_buf_p) = '\0'; /* preserve yytext */
2404 (yy_hold_char) = *++(yy_c_buf_p);
2405
2406 return c;
2407}
2408#endif /* ifndef YY_NO_INPUT */
2409
2410/** Immediately switch to a different input stream.
2411 * @param input_file A readable stream.
2412 *
2413 * @note This function does not reset the start condition to @c INITIAL .
2414 */
2415 void yyrestartada_yyrestart (FILE * input_file )
2416{
2417
2418 if ( ! YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)) ){
2419 yyensure_buffer_stack ();
2420 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)] =
2421 yy_create_bufferada_yy_create_buffer(yyin,YY_BUF_SIZE16384 );
2422 }
2423
2424 yy_init_bufferada_yy_init_buffer(YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)),input_file );
2425 yy_load_buffer_stateada_yy_load_buffer_state( );
2426}
2427
2428/** Switch to a different input buffer.
2429 * @param new_buffer The new input buffer.
2430 *
2431 */
2432 void yy_switch_to_bufferada_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
2433{
2434
2435 /* TODO. We should be able to replace this entire function body
2436 * with
2437 * yypop_buffer_state();
2438 * yypush_buffer_state(new_buffer);
2439 */
2440 yyensure_buffer_stack ();
2441 if ( YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)) == new_buffer )
2442 return;
2443
2444 if ( YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)) )
2445 {
2446 /* Flush out information for old buffer. */
2447 *(yy_c_buf_p) = (yy_hold_char);
2448 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buf_pos = (yy_c_buf_p);
2449 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_n_chars = (yy_n_chars);
2450 }
2451
2452 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)] = new_buffer;
2453 yy_load_buffer_stateada_yy_load_buffer_state( );
2454
2455 /* We don't actually know whether we did this switch during
2456 * EOF (yywrap()) processing, but the only time this flag
2457 * is looked at is after yywrap() is called, so it's safe
2458 * to go ahead and always set it.
2459 */
2460 (yy_did_buffer_switch_on_eof) = 1;
2461}
2462
2463static void yy_load_buffer_stateada_yy_load_buffer_state (void)
2464{
2465 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_n_chars;
2466 (yytext_ptrada_yytext) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buf_pos;
2467 yyin = YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_input_file;
2468 (yy_hold_char) = *(yy_c_buf_p);
2469}
2470
2471/** Allocate and initialize an input buffer state.
2472 * @param file A readable stream.
2473 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2474 *
2475 * @return the allocated buffer state.
2476 */
2477 YY_BUFFER_STATE yy_create_bufferada_yy_create_buffer (FILE * file, int size )
2478{
2479 YY_BUFFER_STATE b;
2480
2481 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
2482 if ( ! b )
2483 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" )yy_fatal_error( "out of dynamic memory in yy_create_buffer()"
);
2484
2485 b->yy_buf_size = size;
2486
2487 /* yy_ch_buf has to be 2 characters longer than the size given because
2488 * we need to put in 2 end-of-buffer characters.
2489 */
2490 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 );
2491 if ( ! b->yy_ch_buf )
2492 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" )yy_fatal_error( "out of dynamic memory in yy_create_buffer()"
);
2493
2494 b->yy_is_our_buffer = 1;
2495
2496 yy_init_bufferada_yy_init_buffer(b,file );
2497
2498 return b;
2499}
2500
2501/** Destroy the buffer.
2502 * @param b a buffer created with yy_create_buffer()
2503 *
2504 */
2505 void yy_delete_bufferada_yy_delete_buffer (YY_BUFFER_STATE b )
2506{
2507
2508 if ( ! b )
2509 return;
2510
2511 if ( b == YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)) ) /* Not sure if we should pop here. */
2512 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)] = (YY_BUFFER_STATE) 0;
2513
2514 if ( b->yy_is_our_buffer )
2515 yyfree((void *) b->yy_ch_buf );
2516
2517 yyfree((void *) b );
2518}
2519
2520/* Initializes or reinitializes a buffer.
2521 * This function is sometimes called more than once on the same buffer,
2522 * such as during a yyrestart() or at EOF.
2523 */
2524 static void yy_init_bufferada_yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
2525
2526{
2527 int oerrno = errno(*__errno());
2528
2529 yy_flush_buffer(b );
2530
2531 b->yy_input_file = file;
2532 b->yy_fill_buffer = 1;
2533
2534 /* If b is the current buffer, then yy_init_buffer was _probably_
2535 * called from yyrestart() or through yy_get_next_buffer.
2536 * In that case, we don't want to reset the lineno or column.
2537 */
2538 if (b != YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0))){
2539 b->yy_bs_lineno = 1;
2540 b->yy_bs_column = 0;
2541 }
2542
2543 b->yy_is_interactive = file ? (isatty( fileno(file)(!__isthreaded ? ((file)->_file) : (fileno)(file)) ) > 0) : 0;
2544
2545 errno(*__errno()) = oerrno;
2546}
2547
2548/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2549 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2550 *
2551 */
2552 void yy_flush_buffer (YY_BUFFER_STATE b )
2553{
2554 if ( ! b )
2555 return;
2556
2557 b->yy_n_chars = 0;
2558
2559 /* We always need two end-of-buffer characters. The first causes
2560 * a transition to the end-of-buffer state. The second causes
2561 * a jam in that state.
2562 */
2563 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR0;
2564 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR0;
2565
2566 b->yy_buf_pos = &b->yy_ch_buf[0];
2567
2568 b->yy_at_bol = 1;
2569 b->yy_buffer_status = YY_BUFFER_NEW0;
2570
2571 if ( b == YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)) )
2572 yy_load_buffer_stateada_yy_load_buffer_state( );
2573}
2574
2575/** Pushes the new state onto the stack. The new state becomes
2576 * the current state. This function will allocate the stack
2577 * if necessary.
2578 * @param new_buffer The new state.
2579 *
2580 */
2581void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2582{
2583 if (new_buffer == NULL((void*)0))
2584 return;
2585
2586 yyensure_buffer_stack();
2587
2588 /* This block is copied from yy_switch_to_buffer. */
2589 if ( YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)) )
2590 {
2591 /* Flush out information for old buffer. */
2592 *(yy_c_buf_p) = (yy_hold_char);
2593 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buf_pos = (yy_c_buf_p);
2594 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_n_chars = (yy_n_chars);
2595 }
2596
2597 /* Only push if top exists. Otherwise, replace top. */
2598 if (YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)))
2599 (yy_buffer_stack_top)++;
2600 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)] = new_buffer;
2601
2602 /* copied from yy_switch_to_buffer. */
2603 yy_load_buffer_stateada_yy_load_buffer_state( );
2604 (yy_did_buffer_switch_on_eof) = 1;
2605}
2606
2607/** Removes and deletes the top of the stack, if present.
2608 * The next element becomes the new top.
2609 *
2610 */
2611void yypop_buffer_state (void)
2612{
2613 if (!YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)))
2614 return;
2615
2616 yy_delete_bufferada_yy_delete_buffer(YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)) );
2617 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)] = NULL((void*)0);
2618 if ((yy_buffer_stack_top) > 0)
2619 --(yy_buffer_stack_top);
2620
2621 if (YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0))) {
2622 yy_load_buffer_stateada_yy_load_buffer_state( );
2623 (yy_did_buffer_switch_on_eof) = 1;
2624 }
2625}
2626
2627/* Allocates the stack if it does not exist.
2628 * Guarantees space for at least one push.
2629 */
2630static void yyensure_buffer_stack (void)
2631{
2632 yy_size_t num_to_alloc;
2633
2634 if (!(yy_buffer_stack)) {
2635
2636 /* First allocation is just for 2 elements, since we don't know if this
2637 * scanner will even need a stack. We use 2 instead of 1 to avoid an
2638 * immediate xrealloc on the next call.
2639 */
2640 num_to_alloc = 1;
2641 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2642 (num_to_alloc * sizeof(struct yy_buffer_state*)
2643 );
2644 if ( ! (yy_buffer_stack) )
2645 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" )yy_fatal_error( "out of dynamic memory in yyensure_buffer_stack()"
);
2646
2647 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2648
2649 (yy_buffer_stack_max) = num_to_alloc;
2650 (yy_buffer_stack_top) = 0;
2651 return;
2652 }
2653
2654 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2655
2656 /* Increase the buffer to prepare for a possible push. */
2657 int grow_size = 8 /* arbitrary grow size */;
2658
2659 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2660 (yy_buffer_stack) = (struct yy_buffer_state**)yyxrealloc
2661 ((yy_buffer_stack),
2662 num_to_alloc * sizeof(struct yy_buffer_state*)
2663 );
2664 if ( ! (yy_buffer_stack) )
2665 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" )yy_fatal_error( "out of dynamic memory in yyensure_buffer_stack()"
);
2666
2667 /* zero only the new slots.*/
2668 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2669 (yy_buffer_stack_max) = num_to_alloc;
2670 }
2671}
2672
2673/** Setup the input buffer state to scan directly from a user-specified character buffer.
2674 * @param base the character buffer
2675 * @param size the size in bytes of the character buffer
2676 *
2677 * @return the newly allocated buffer state object.
2678 */
2679YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
2680{
2681 YY_BUFFER_STATE b;
2682
2683 if ( size < 2 ||
2684 base[size-2] != YY_END_OF_BUFFER_CHAR0 ||
2685 base[size-1] != YY_END_OF_BUFFER_CHAR0 )
2686 /* They forgot to leave room for the EOB's. */
2687 return 0;
2688
2689 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
2690 if ( ! b )
2691 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" )yy_fatal_error( "out of dynamic memory in yy_scan_buffer()" );
2692
2693 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2694 b->yy_buf_pos = b->yy_ch_buf = base;
2695 b->yy_is_our_buffer = 0;
2696 b->yy_input_file = 0;
2697 b->yy_n_chars = b->yy_buf_size;
2698 b->yy_is_interactive = 0;
2699 b->yy_at_bol = 1;
2700 b->yy_fill_buffer = 0;
2701 b->yy_buffer_status = YY_BUFFER_NEW0;
2702
2703 yy_switch_to_bufferada_yy_switch_to_buffer(b );
2704
2705 return b;
2706}
2707
2708/** Setup the input buffer state to scan a string. The next call to yylex() will
2709 * scan from a @e copy of @a str.
2710 * @param yystr a NUL-terminated string to scan
2711 *
2712 * @return the newly allocated buffer state object.
2713 * @note If you want to scan bytes that may contain NUL values, then use
2714 * yy_scan_bytes() instead.
2715 */
2716YY_BUFFER_STATE yy_scan_string (yyconstconst char * yystr )
2717{
2718
2719 return yy_scan_bytes(yystr,strlen(yystr) );
2720}
2721
2722/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2723 * scan from a @e copy of @a bytes.
2724 * @param yybytes the byte buffer to scan
2725 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2726 *
2727 * @return the newly allocated buffer state object.
2728 */
2729YY_BUFFER_STATE yy_scan_bytes (yyconstconst char * yybytes, yy_size_t _yybytes_len )
2730{
2731 YY_BUFFER_STATE b;
2732 char *buf;
2733 yy_size_t n;
2734 yy_size_t i;
2735
2736 /* Get memory for full buffer, including space for trailing EOB's. */
2737 n = _yybytes_len + 2;
2738 buf = (char *) yyalloc(n );
2739 if ( ! buf )
2740 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" )yy_fatal_error( "out of dynamic memory in yy_scan_bytes()" );
2741
2742 for ( i = 0; i < _yybytes_len; ++i )
2743 buf[i] = yybytes[i];
2744
2745 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR0;
2746
2747 b = yy_scan_buffer(buf,n );
2748 if ( ! b )
2749 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" )yy_fatal_error( "bad buffer in yy_scan_bytes()" );
2750
2751 /* It's okay to grow etc. this buffer, and we should throw it
2752 * away when we're done.
2753 */
2754 b->yy_is_our_buffer = 1;
2755
2756 return b;
2757}
2758
2759#ifndef YY_EXIT_FAILURE2
2760#define YY_EXIT_FAILURE2 2
2761#endif
2762
2763static void yy_fatal_error (yyconstconst char* msg )
2764{
2765 (void) fprintf( stderr(&__sF[2]), "%s\n", msg );
2766 exit( YY_EXIT_FAILURE2 );
2767}
2768
2769/* Redefine yyless() so it works in section 3 code. */
2770
2771#undef yyless
2772#define yyless(n)do { int yyless_macro_arg = (n); ; ada_yytext[yyleng] = (yy_hold_char
); (yy_c_buf_p) = ada_yytext + yyless_macro_arg; (yy_hold_char
) = *(yy_c_buf_p); *(yy_c_buf_p) = '\0'; yyleng = yyless_macro_arg
; } while ( 0 ) \
2773 do \
2774 { \
2775 /* Undo effects of setting up yytext. */ \
2776 int yyless_macro_arg = (n); \
2777 YY_LESS_LINENO(yyless_macro_arg);\
2778 yytextada_yytext[yyleng] = (yy_hold_char); \
2779 (yy_c_buf_p) = yytextada_yytext + yyless_macro_arg; \
2780 (yy_hold_char) = *(yy_c_buf_p); \
2781 *(yy_c_buf_p) = '\0'; \
2782 yyleng = yyless_macro_arg; \
2783 } \
2784 while ( 0 )
2785
2786/* Accessor methods (get/set functions) to struct members. */
2787
2788/** Get the current line number.
2789 *
2790 */
2791int yyget_lineno (void)
2792{
2793
2794 return yylineno;
2795}
2796
2797/** Get the input stream.
2798 *
2799 */
2800FILE *yyget_in (void)
2801{
2802 return yyin;
2803}
2804
2805/** Get the output stream.
2806 *
2807 */
2808FILE *yyget_out (void)
2809{
2810 return yyout;
2811}
2812
2813/** Get the length of the current token.
2814 *
2815 */
2816yy_size_t yyget_leng (void)
2817{
2818 return yyleng;
2819}
2820
2821/** Get the current token.
2822 *
2823 */
2824
2825char *yyget_text (void)
2826{
2827 return yytextada_yytext;
2828}
2829
2830/** Set the current line number.
2831 * @param line_number
2832 *
2833 */
2834void yyset_lineno (int line_number )
2835{
2836
2837 yylineno = line_number;
2838}
2839
2840/** Set the input stream. This does not discard the current
2841 * input buffer.
2842 * @param in_str A readable stream.
2843 *
2844 * @see yy_switch_to_buffer
2845 */
2846void yyset_in (FILE * in_str )
2847{
2848 yyin = in_str ;
2849}
2850
2851void yyset_out (FILE * out_str )
2852{
2853 yyout = out_str ;
2854}
2855
2856int yyget_debug (void)
2857{
2858 return yy_flex_debug;
2859}
2860
2861void yyset_debug (int bdebug )
2862{
2863 yy_flex_debug = bdebug ;
2864}
2865
2866static int yy_init_globals (void)
2867{
2868 /* Initialization is the same as for the non-reentrant scanner.
2869 * This function is called from yylex_destroy(), so don't allocate here.
2870 */
2871
2872 (yy_buffer_stack) = 0;
2873 (yy_buffer_stack_top) = 0;
2874 (yy_buffer_stack_max) = 0;
2875 (yy_c_buf_p) = (char *) 0;
2876 (yy_init) = 0;
2877 (yy_start) = 0;
2878
2879/* Defined in main.c */
2880#ifdef YY_STDINIT
2881 yyin = stdin(&__sF[0]);
2882 yyout = stdout(&__sF[1]);
2883#else
2884 yyin = (FILE *) 0;
2885 yyout = (FILE *) 0;
2886#endif
2887
2888 /* For future reference: Set errno on error, since we are called by
2889 * yylex_init()
2890 */
2891 return 0;
2892}
2893
2894/* yylex_destroy is for both reentrant and non-reentrant scanners. */
2895int yylex_destroy (void)
2896{
2897
2898 /* Pop the buffer stack, destroying each element. */
2899 while(YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0))){
2900 yy_delete_bufferada_yy_delete_buffer(YY_CURRENT_BUFFER( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)
] : ((void*)0)) );
2901 YY_CURRENT_BUFFER_LVALUE(yy_buffer_stack)[(yy_buffer_stack_top)] = NULL((void*)0);
2902 yypop_buffer_state();
2903 }
2904
2905 /* Destroy the stack itself. */
2906 yyfree((yy_buffer_stack) );
2907 (yy_buffer_stack) = NULL((void*)0);
2908
2909 /* Reset the globals. This is important in a non-reentrant scanner so the next time
2910 * yylex() is called, initialization will occur. */
2911 yy_init_globals( );
2912
2913 return 0;
2914}
2915
2916/*
2917 * Internal utility routines.
2918 */
2919
2920#ifndef yytext_ptrada_yytext
2921static void yy_flex_strncpy (char* s1, yyconstconst char * s2, int n )
2922{
2923 int i;
2924 for ( i = 0; i < n; ++i )
2925 s1[i] = s2[i];
2926}
2927#endif
2928
2929#ifdef YY_NEED_STRLEN
2930static int yy_flex_strlen (yyconstconst char * s )
2931{
2932 int n;
2933 for ( n = 0; s[n]; ++n )
2934 ;
2935
2936 return n;
2937}
2938#endif
2939
2940void *yyalloc (yy_size_t size )
2941{
2942 return (void *) xmalloc( size );
2943}
2944
2945void *yyxrealloc (void * ptr, yy_size_t size )
2946{
2947 /* The cast to (char *) in the following accommodates both
2948 * implementations that use char* generic pointers, and those
2949 * that use void* generic pointers. It works with the latter
2950 * because both ANSI C and C++ allow castless assignment from
2951 * any pointer type to void*, and deal with argument conversions
2952 * as though doing an assignment.
2953 */
2954 return (void *) xrealloc( (char *) ptr, size );
2955}
2956
2957void yyfree (void * ptr )
2958{
2959 free( (char *) ptr ); /* see yyxrealloc() for (char *) cast */
2960}
2961
2962#define YYTABLES_NAME"yytables" "yytables"
2963
2964#line 326 "/usr/src/gnu/usr.bin/binutils/gdb/ada-lex.l"
2965
2966
2967
2968#include <ctype.h>
2969#include "gdb_string.h"
2970
2971/* Initialize the lexer for processing new expression */
2972void
2973lexer_init (FILE *inp)
2974{
2975 BEGIN(yy_start) = 1 + 2 * INITIAL0;
2976 yyrestartada_yyrestart (inp);
2977}
2978
2979
2980/* Make sure that tempbuf points at an array at least N characters long. */
2981
2982static void
2983resize_tempbuf (unsigned int n)
2984{
2985 if (tempbufsize < n)
2986 {
2987 tempbufsize = (n+63) & ~63;
2988 tempbuf = xrealloc (tempbuf, tempbufsize);
2989 }
2990}
2991
2992/* Copy S2 to S1, removing all underscores, and downcasing all letters. */
2993
2994static void
2995canonicalizeNumeral (char *s1, const char *s2)
2996{
2997 for (; *s2 != '\000'; s2 += 1)
2998 {
2999 if (*s2 != '_')
3000 {
3001 *s1 = tolower(*s2);
3002 s1 += 1;
3003 }
3004 }
3005 s1[0] = '\000';
3006}
3007
3008#define HIGH_BYTE_POSN((sizeof (unsigned long) - 1) * 8) ((sizeof (ULONGESTunsigned long) - 1) * HOST_CHAR_BIT8)
3009
3010/* True (non-zero) iff DIGIT is a valid digit in radix BASE,
3011 where 2 <= BASE <= 16. */
3012
3013static int
3014is_digit_in_base (unsigned char digit, int base)
3015{
3016 if (!isxdigit (digit))
3017 return 0;
3018 if (base <= 10)
3019 return (isdigit (digit) && digit < base + '0');
3020 else
3021 return (isdigit (digit) || tolower (digit) < base - 10 + 'a');
3022}
3023
3024static int
3025digit_to_int (unsigned char c)
3026{
3027 if (isdigit (c))
3028 return c - '0';
3029 else
3030 return tolower (c) - 'a' + 10;
3031}
3032
3033/* As for strtoul, but for ULONGEST results. */
3034ULONGESTunsigned long
3035strtoulst (const char *num, const char **trailer, int base)
3036{
3037 unsigned int high_part;
3038 ULONGESTunsigned long result;
3039 int i;
3040 unsigned char lim;
3041
3042 if (base < 2 || base > 16)
3043 {
3044 errno(*__errno()) = EINVAL22;
3045 return 0;
3046 }
3047 lim = base - 1 + '0';
Value stored to 'lim' is never read
3048
3049 result = high_part = 0;
3050 for (i = 0; is_digit_in_base (num[i], base); i += 1)
3051 {
3052 result = result*base + digit_to_int (num[i]);
3053 high_part = high_part*base + (unsigned int) (result >> HIGH_BYTE_POSN((sizeof (unsigned long) - 1) * 8));
3054 result &= ((ULONGESTunsigned long) 1 << HIGH_BYTE_POSN((sizeof (unsigned long) - 1) * 8)) - 1;
3055 if (high_part > 0xff)
3056 {
3057 errno(*__errno()) = ERANGE34;
3058 result = high_part = 0;
3059 break;
3060 }
3061 }
3062
3063 if (trailer != NULL((void*)0))
3064 *trailer = &num[i];
3065
3066 return result + ((ULONGESTunsigned long) high_part << HIGH_BYTE_POSN((sizeof (unsigned long) - 1) * 8));
3067}
3068
3069
3070
3071/* Interprets the prefix of NUM that consists of digits of the given BASE
3072 as an integer of that BASE, with the string EXP as an exponent.
3073 Puts value in yylval, and returns INT, if the string is valid. Causes
3074 an error if the number is improperly formated. BASE, if NULL, defaults
3075 to "10", and EXP to "1". The EXP does not contain a leading 'e' or 'E'. */
3076
3077static int
3078processInt (const char *base0, const char *num0, const char *exp0)
3079{
3080 ULONGESTunsigned long result;
3081 long exp;
3082 int base;
3083
3084 char *trailer;
3085
3086 if (base0 == NULL((void*)0))
3087 base = 10;
3088 else
3089 {
3090 base = strtol (base0, (char **) NULL((void*)0), 10);
3091 if (base < 2 || base > 16)
3092 error ("Invalid base: %d.", base);
3093 }
3094
3095 if (exp0 == NULL((void*)0))
3096 exp = 0;
3097 else
3098 exp = strtol(exp0, (char **) NULL((void*)0), 10);
3099
3100 errno(*__errno()) = 0;
3101 result = strtoulst (num0, (const char **) &trailer, base);
3102 if (errno(*__errno()) == ERANGE34)
3103 error ("Integer literal out of range");
3104 if (isxdigit(*trailer))
3105 error ("Invalid digit `%c' in based literal", *trailer);
3106
3107 while (exp > 0)
3108 {
3109 if (result > (ULONG_MAX(9223372036854775807L *2UL+1UL) / base))
3110 error ("Integer literal out of range");
3111 result *= base;
3112 exp -= 1;
3113 }
3114
3115 if ((result >> (TARGET_INT_BIT(gdbarch_int_bit (current_gdbarch))-1)) == 0)
3116 yylvalada_lval.typed_val.type = type_int ();
3117 else if ((result >> (TARGET_LONG_BIT(gdbarch_long_bit (current_gdbarch))-1)) == 0)
3118 yylvalada_lval.typed_val.type = type_long ();
3119 else if (((result >> (TARGET_LONG_BIT(gdbarch_long_bit (current_gdbarch))-1)) >> 1) == 0)
3120 {
3121 /* We have a number representable as an unsigned integer quantity.
3122 For consistency with the C treatment, we will treat it as an
3123 anonymous modular (unsigned) quantity. Alas, the types are such
3124 that we need to store .val as a signed quantity. Sorry
3125 for the mess, but C doesn't officially guarantee that a simple
3126 assignment does the trick (no, it doesn't; read the reference manual).
3127 */
3128 yylvalada_lval.typed_val.type = builtin_type_unsigned_long;
3129 if (result & LONGEST_SIGN((unsigned long) 1 << (sizeof(long) * 8 - 1)))
3130 yylvalada_lval.typed_val.val =
3131 (LONGESTlong) (result & ~LONGEST_SIGN((unsigned long) 1 << (sizeof(long) * 8 - 1)))
3132 - (LONGEST_SIGN((unsigned long) 1 << (sizeof(long) * 8 - 1))>>1) - (LONGEST_SIGN((unsigned long) 1 << (sizeof(long) * 8 - 1))>>1);
3133 else
3134 yylvalada_lval.typed_val.val = (LONGESTlong) result;
3135 return INT257;
3136 }
3137 else
3138 yylvalada_lval.typed_val.type = type_long_long ();
3139
3140 yylvalada_lval.typed_val.val = (LONGESTlong) result;
3141 return INT257;
3142}
3143
3144#if defined (PRINTF_HAS_LONG_DOUBLE1)
3145# undef PRINTF_HAS_LONG_DOUBLE1
3146# define PRINTF_HAS_LONG_DOUBLE1 1
3147#else
3148# define PRINTF_HAS_LONG_DOUBLE1 0
3149#endif
3150
3151static int
3152processReal (const char *num0)
3153{
3154#if defined (PRINTF_HAS_LONG_DOUBLE1)
3155 if (sizeof (DOUBLEST) > sizeof (double))
3156 sscanf (num0, "%Lg", &yylvalada_lval.typed_val_float.dval);
3157 else
3158#endif
3159 {
3160 double temp;
3161 sscanf (num0, "%lg", &temp);
3162 yylvalada_lval.typed_val_float.dval = temp;
3163 }
3164
3165 yylvalada_lval.typed_val_float.type = type_float ();
3166 if (sizeof(DOUBLEST) >= TARGET_DOUBLE_BIT(gdbarch_double_bit (current_gdbarch)) / TARGET_CHAR_BIT8)
3167 yylvalada_lval.typed_val_float.type = type_double ();
3168 if (sizeof(DOUBLEST) >= TARGET_LONG_DOUBLE_BIT(gdbarch_long_double_bit (current_gdbarch)) / TARGET_CHAR_BIT8)
3169 yylvalada_lval.typed_val_float.type = type_long_double ();
3170
3171 return FLOAT260;
3172}
3173
3174static int
3175processId (const char *name0, int len)
3176{
3177 char *name = obstack_alloc (&temp_parse_space, len + 11)__extension__ ({ struct obstack *__h = (&temp_parse_space
); __extension__ ({ struct obstack *__o = (__h); int __len = (
(len + 11)); if (__o->chunk_limit - __o->next_free <
__len) _obstack_newchunk (__o, __len); ((__o)->next_free +=
(__len)); (void) 0; }); __extension__ ({ struct obstack *__o1
= (__h); void *value; value = (void *) __o1->object_base;
if (__o1->next_free == value) __o1->maybe_empty_object
= 1; __o1->next_free = (((((__o1->next_free) - (char *
) 0)+__o1->alignment_mask) & ~ (__o1->alignment_mask
)) + (char *) 0); if (__o1->next_free - (char *)__o1->chunk
> __o1->chunk_limit - (char *)__o1->chunk) __o1->
next_free = __o1->chunk_limit; __o1->object_base = __o1
->next_free; value; }); });
3178 int i0, i;
3179
3180 while (len > 0 && isspace (name0[len-1]))
3181 len -= 1;
3182 i = i0 = 0;
3183 while (i0 < len)
3184 {
3185 if (isalnum (name0[i0]))
3186 {
3187 name[i] = tolower (name0[i0]);
3188 i += 1; i0 += 1;
3189 }
3190 else switch (name0[i0])
3191 {
3192 default:
3193 name[i] = name0[i0];
3194 i += 1; i0 += 1;
3195 break;
3196 case ' ': case '\t':
3197 i0 += 1;
3198 break;
3199 case '\'':
3200 i0 += 1;
3201 while (i0 < len && name0[i0] != '\'')
3202 {
3203 name[i] = name0[i0];
3204 i += 1; i0 += 1;
3205 }
3206 i0 += 1;
3207 break;
3208 case '<':
3209 i0 += 1;
3210 while (i0 < len && name0[i0] != '>')
3211 {
3212 name[i] = name0[i0];
3213 i += 1; i0 += 1;
3214 }
3215 i0 += 1;
3216 break;
3217 }
3218 }
3219 name[i] = '\000';
3220
3221 yylvalada_lval.ssym.sym = NULL((void*)0);
3222 yylvalada_lval.ssym.stoken.ptr = name;
3223 yylvalada_lval.ssym.stoken.length = i;
3224 return NAME264;
3225}
3226
3227static void
3228block_lookup (char *name, char *err_name)
3229{
3230 struct ada_symbol_info *syms;
3231 int nsyms;
3232 struct symtab *symtab;
3233 nsyms = ada_lookup_symbol_list (name, left_block_context,
3234 VAR_DOMAIN, &syms);
3235 if (left_block_context == NULL((void*)0) &&
3236 (nsyms == 0 || SYMBOL_CLASS (syms[0].sym)(syms[0].sym)->aclass != LOC_BLOCK))
3237 symtab = lookup_symtab (name);
3238 else
3239 symtab = NULL((void*)0);
3240
3241 if (symtab != NULL((void*)0))
3242 left_block_context = yylvalada_lval.bval =
3243 BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK)((symtab)->blockvector)->block[STATIC_BLOCK];
3244 else if (nsyms == 0 || SYMBOL_CLASS (syms[0].sym)(syms[0].sym)->aclass != LOC_BLOCK)
3245 {
3246 if (left_block_context == NULL((void*)0))
3247 error ("No file or function \"%s\".", err_name);
3248 else
3249 error ("No function \"%s\" in specified context.", err_name);
3250 }
3251 else
3252 {
3253 left_block_context = yylvalada_lval.bval = SYMBOL_BLOCK_VALUE (syms[0].sym)(syms[0].sym)->ginfo.value.block;
3254 if (nsyms > 1)
3255 warning ("Function name \"%s\" ambiguous here", err_name);
3256 }
3257}
3258
3259/* Look up NAME0 (assumed to be encoded) as a name in VAR_DOMAIN,
3260 setting *TOKEN_TYPE to NAME or TYPENAME, depending on what is
3261 found. Try first the entire name, then the name without the last
3262 segment (i.e., after the last .id), etc., and return the number of
3263 segments that had to be removed to get a match. Try only the full
3264 name if it starts with "standard__". Calls error if no
3265 matches are found, using ERR_NAME in any error message. When
3266 exactly one symbol match is found, it is placed in yylval. When
3267 the symbol is a renaming, follow at most DEPTH steps to find the
3268 ultimate definition; cause error if depth exceeded. */
3269
3270static int
3271name_lookup (char *name0, char *err_name, int *token_type, int depth)
3272{
3273 struct ada_symbol_info *syms;
3274 struct type *type;
3275 int len0 = strlen (name0);
3276 char *name = obsavestring (name0, len0, &temp_parse_space);
3277 int nsyms;
3278 int segments;
3279
3280 if (depth <= 0)
3281 error ("Could not find renamed symbol \"%s\"", err_name);
3282
3283 yylvalada_lval.ssym.stoken.ptr = name;
3284 yylvalada_lval.ssym.stoken.length = strlen (name);
3285 for (segments = 0; ; segments += 1)
3286 {
3287 struct type *preferred_type;
3288 int i, preferred_index;
3289
3290 if (left_block_context == NULL((void*)0))
3291 nsyms = ada_lookup_symbol_list (name, expression_context_block,
3292 VAR_DOMAIN, &syms);
3293 else
3294 nsyms = ada_lookup_symbol_list (name, left_block_context,
3295 VAR_DOMAIN, &syms);
3296
3297
3298 /* Check for a type renaming. */
3299
3300 if (nsyms == 1 && !ada_is_object_renaming (syms[0].sym))
3301 {
3302 struct symbol *renaming_sym =
3303 ada_find_renaming_symbol (SYMBOL_LINKAGE_NAME (syms[0].sym)(syms[0].sym)->ginfo.name,
3304 syms[0].block);
3305
3306 if (renaming_sym != NULL((void*)0))
3307 syms[0].sym = renaming_sym;
3308 }
3309
3310 /* Check for a type definition. */
3311
3312 /* Look for a symbol that doesn't denote void. This is (I think) a */
3313 /* temporary kludge to get around problems in GNAT output. */
3314 preferred_index = -1; preferred_type = NULL((void*)0);
3315 for (i = 0; i < nsyms; i += 1)
3316 switch (SYMBOL_CLASS (syms[i].sym)(syms[i].sym)->aclass)
3317 {
3318 case LOC_TYPEDEF:
3319 if (ada_prefer_type (SYMBOL_TYPE (syms[i].sym)(syms[i].sym)->type, preferred_type))
3320 {
3321 preferred_index = i;
3322 preferred_type = SYMBOL_TYPE (syms[i].sym)(syms[i].sym)->type;
3323 }
3324 break;
3325 case LOC_REGISTER:
3326 case LOC_ARG:
3327 case LOC_REF_ARG:
3328 case LOC_REGPARM:
3329 case LOC_REGPARM_ADDR:
3330 case LOC_LOCAL:
3331 case LOC_LOCAL_ARG:
3332 case LOC_BASEREG:
3333 case LOC_BASEREG_ARG:
3334 case LOC_COMPUTED:
3335 case LOC_COMPUTED_ARG:
3336 goto NotType;
3337 default:
3338 break;
3339 }
3340 if (preferred_type != NULL((void*)0))
3341 {
3342 if (TYPE_CODE (preferred_type)(preferred_type)->main_type->code == TYPE_CODE_VOID)
3343 error ("`%s' matches only void type name(s)",
3344 ada_decode (name));
3345 else if (ada_is_object_renaming (syms[preferred_index].sym))
3346 {
3347 yylvalada_lval.ssym.sym = syms[preferred_index].sym;
3348 *token_type = OBJECT_RENAMING266;
3349 return segments;
3350 }
3351 else if (ada_renaming_type (SYMBOL_TYPE (syms[preferred_index].sym)(syms[preferred_index].sym)->type)
3352 != NULL((void*)0))
3353 {
3354 int result;
3355 char *renaming
3356 = ada_simple_renamed_entity (syms[preferred_index].sym);
3357 char *new_name
3358 = (char *) obstack_alloc (&temp_parse_space,__extension__ ({ struct obstack *__h = (&temp_parse_space
); __extension__ ({ struct obstack *__o = (__h); int __len = (
(strlen (renaming) + len0 - ada_lval.ssym.stoken.length + 1))
; if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
(__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
value = (void *) __o1->object_base; if (__o1->next_free
== value) __o1->maybe_empty_object = 1; __o1->next_free
= (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
(char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); })
3359 strlen (renaming) + len0__extension__ ({ struct obstack *__h = (&temp_parse_space
); __extension__ ({ struct obstack *__o = (__h); int __len = (
(strlen (renaming) + len0 - ada_lval.ssym.stoken.length + 1))
; if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
(__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
value = (void *) __o1->object_base; if (__o1->next_free
== value) __o1->maybe_empty_object = 1; __o1->next_free
= (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
(char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); })
3360 - yylval.ssym.stoken.length + 1)__extension__ ({ struct obstack *__h = (&temp_parse_space
); __extension__ ({ struct obstack *__o = (__h); int __len = (
(strlen (renaming) + len0 - ada_lval.ssym.stoken.length + 1))
; if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
(__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
value = (void *) __o1->object_base; if (__o1->next_free
== value) __o1->maybe_empty_object = 1; __o1->next_free
= (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
(char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); });
3361 strcpy (new_name, renaming);
3362 xfree (renaming);
3363 strcat (new_name, name0 + yylvalada_lval.ssym.stoken.length);
3364 result = name_lookup (new_name, err_name, token_type, depth - 1);
3365 if (result > segments)
3366 error ("Confused by renamed symbol.");
3367 return result;
3368 }
3369 else if (segments == 0)
3370 {
3371 yylvalada_lval.tval = preferred_type;
3372 *token_type = TYPENAME261;
3373 return 0;
3374 }
3375 }
3376
3377 if (segments == 0)
3378 {
3379 type = language_lookup_primitive_type_by_name (current_language,
3380 current_gdbarch,
3381 name);
3382 if (type == NULL((void*)0) && strcmp ("system__address", name) == 0)
3383 type = type_system_address ();
3384 if (type != NULL((void*)0))
3385 {
3386 /* First check to see if we have a regular definition of this
3387 type that just didn't happen to have been read yet. */
3388 int ntypes;
3389 struct symbol *sym;
3390 char *expanded_name =
3391 (char *) alloca (strlen (name) + sizeof ("standard__"))__builtin_alloca(strlen (name) + sizeof ("standard__"));
3392 strcpy (expanded_name, "standard__");
3393 strcat (expanded_name, name);
3394 sym = ada_lookup_symbol (expanded_name, NULL((void*)0),
3395 VAR_DOMAIN, NULL((void*)0), NULL((void*)0));
3396 if (sym != NULL((void*)0) && SYMBOL_CLASS (sym)(sym)->aclass == LOC_TYPEDEF)
3397 type = SYMBOL_TYPE (sym)(sym)->type;
3398
3399 yylvalada_lval.tval = type;
3400 *token_type = TYPENAME261;
3401 return 0;
3402 }
3403 }
3404
3405 NotType:
3406 if (nsyms == 1)
3407 {
3408 *token_type = NAME264;
3409 yylvalada_lval.ssym.sym = syms[0].sym;
3410 yylvalada_lval.ssym.msym = NULL((void*)0);
3411 yylvalada_lval.ssym.block = syms[0].block;
3412 return segments;
3413 }
3414 else if (nsyms == 0) {
3415 int i;
3416 yylvalada_lval.ssym.msym = ada_lookup_simple_minsym (name);
3417 if (yylvalada_lval.ssym.msym != NULL((void*)0))
3418 {
3419 yylvalada_lval.ssym.sym = NULL((void*)0);
3420 yylvalada_lval.ssym.block = NULL((void*)0);
3421 *token_type = NAME264;
3422 return segments;
3423 }
3424
3425 if (segments == 0
3426 && strncmp (name, "standard__", sizeof ("standard__") - 1) == 0)
3427 error ("No definition of \"%s\" found.", err_name);
3428
3429 for (i = yylvalada_lval.ssym.stoken.length - 1; i > 0; i -= 1)
3430 {
3431 if (name[i] == '.')
3432 {
3433 name[i] = '\0';
3434 yylvalada_lval.ssym.stoken.length = i;
3435 break;
3436 }
3437 else if (name[i] == '_' && name[i-1] == '_')
3438 {
3439 i -= 1;
3440 name[i] = '\0';
3441 yylvalada_lval.ssym.stoken.length = i;
3442 break;
3443 }
3444 }
3445 if (i <= 0)
3446 {
3447 if (!have_full_symbols () && !have_partial_symbols ()
3448 && left_block_context == NULL((void*)0))
3449 error ("No symbol table is loaded. Use the \"file\" command.");
3450 if (left_block_context == NULL((void*)0))
3451 error ("No definition of \"%s\" in current context.",
3452 err_name);
3453 else
3454 error ("No definition of \"%s\" in specified context.",
3455 err_name);
3456 }
3457 }
3458 else
3459 {
3460 *token_type = NAME264;
3461 yylvalada_lval.ssym.sym = NULL((void*)0);
3462 yylvalada_lval.ssym.msym = NULL((void*)0);
3463 if (left_block_context == NULL((void*)0))
3464 yylvalada_lval.ssym.block = expression_context_block;
3465 else
3466 yylvalada_lval.ssym.block = left_block_context;
3467 return segments;
3468 }
3469 }
3470}
3471
3472/* Returns the position within STR of the '.' in a
3473 '.{WHITE}*all' component of a dotted name, or -1 if there is none. */
3474static int
3475find_dot_all (const char *str)
3476{
3477 int i;
3478 for (i = 0; str[i] != '\000'; i += 1)
3479 {
3480 if (str[i] == '.')
3481 {
3482 int i0 = i;
3483 do
3484 i += 1;
3485 while (isspace (str[i]));
3486 if (strcmp (str+i, "all") == 0
3487 && ! isalnum (str[i+3]) && str[i+3] != '_')
3488 return i0;
3489 }
3490 }
3491 return -1;
3492}
3493
3494/* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
3495 case. */
3496
3497static int
3498subseqMatch (const char *subseq, const char *str)
3499{
3500 if (subseq[0] == '\0')
3501 return 1;
3502 else if (str[0] == '\0')
3503 return 0;
3504 else if (tolower (subseq[0]) == tolower (str[0]))
3505 return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
3506 else
3507 return subseqMatch (subseq, str+1);
3508}
3509
3510
3511static struct { const char *name; int code; }
3512attributes[] = {
3513 { "address", TICK_ADDRESS287 },
3514 { "unchecked_access", TICK_ACCESS286 },
3515 { "unrestricted_access", TICK_ACCESS286 },
3516 { "access", TICK_ACCESS286 },
3517 { "first", TICK_FIRST288 },
3518 { "last", TICK_LAST289 },
3519 { "length", TICK_LENGTH290 },
3520 { "max", TICK_MAX291 },
3521 { "min", TICK_MIN292 },
3522 { "modulus", TICK_MODULUS293 },
3523 { "pos", TICK_POS294 },
3524 { "range", TICK_RANGE295 },
3525 { "size", TICK_SIZE296 },
3526 { "tag", TICK_TAG297 },
3527 { "val", TICK_VAL298 },
3528 { NULL((void*)0), -1 }
3529};
3530
3531/* Return the syntactic code corresponding to the attribute name or
3532 abbreviation STR. */
3533
3534static int
3535processAttribute (const char *str)
3536{
3537 int i, k;
3538
3539 for (i = 0; attributes[i].code != -1; i += 1)
3540 if (strcasecmp (str, attributes[i].name) == 0)
3541 return attributes[i].code;
3542
3543 for (i = 0, k = -1; attributes[i].code != -1; i += 1)
3544 if (subseqMatch (str, attributes[i].name))
3545 {
3546 if (k == -1)
3547 k = i;
3548 else
3549 error ("ambiguous attribute name: `%s'", str);
3550 }
3551 if (k == -1)
3552 error ("unrecognized attribute: `%s'", str);
3553
3554 return attributes[k].code;
3555}
3556
3557int
3558yywrapada_yywrap(void)
3559{
3560 return 1;
3561}
3562
3563/* Dummy definition to suppress warnings about unused static definitions. */
3564typedef void (*dummy_function) ();
3565dummy_function ada_flex_use[] =
3566{
3567 (dummy_function) yyunput
3568};
3569