Mercurial > hg > CbC > CbC_gcc

comparison gcc/gengtype-lex.c @ 0:a06113de4d67

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