| blob | 2ac23bcca5b537fad4c8b06401404b20adb03e9e |
1 #line 2 "scripts/genksyms/lex.c"
3 #line 4 "scripts/genksyms/lex.c"
5 #define YY_INT_ALIGNED short int
7 /* A lexical scanner generated by flex */
9 /* %not-for-header */
11 /* %if-c-only */
12 /* %if-not-reentrant */
14 /* %endif */
15 /* %endif */
16 /* %ok-for-header */
18 #define FLEX_SCANNER
19 #define YY_FLEX_MAJOR_VERSION 2
20 #define YY_FLEX_MINOR_VERSION 5
21 #define YY_FLEX_SUBMINOR_VERSION 35
22 #if YY_FLEX_SUBMINOR_VERSION > 0
23 #define FLEX_BETA
24 #endif
26 /* %if-c++-only */
27 /* %endif */
29 /* %if-c-only */
31 /* %endif */
33 /* %if-c-only */
35 /* %endif */
37 /* First, we deal with platform-specific or compiler-specific issues. */
39 /* begin standard C headers. */
40 /* %if-c-only */
41 #include <stdio.h>
42 #include <string.h>
43 #include <errno.h>
44 #include <stdlib.h>
45 /* %endif */
47 /* %if-tables-serialization */
48 /* %endif */
49 /* end standard C headers. */
51 /* %if-c-or-c++ */
52 /* flex integer type definitions */
54 #ifndef FLEXINT_H
55 #define FLEXINT_H
57 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
59 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
61 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
62 * if you want the limit (max/min) macros for int types.
63 */
64 #ifndef __STDC_LIMIT_MACROS
65 #define __STDC_LIMIT_MACROS 1
66 #endif
68 #include <inttypes.h>
69 typedef int8_t flex_int8_t;
70 typedef uint8_t flex_uint8_t;
71 typedef int16_t flex_int16_t;
72 typedef uint16_t flex_uint16_t;
73 typedef int32_t flex_int32_t;
74 typedef uint32_t flex_uint32_t;
75 #else
76 typedef signed char flex_int8_t;
77 typedef short int flex_int16_t;
78 typedef int flex_int32_t;
79 typedef unsigned char flex_uint8_t;
80 typedef unsigned short int flex_uint16_t;
81 typedef unsigned int flex_uint32_t;
83 /* Limits of integral types. */
84 #ifndef INT8_MIN
85 #define INT8_MIN (-128)
86 #endif
87 #ifndef INT16_MIN
88 #define INT16_MIN (-32767-1)
89 #endif
90 #ifndef INT32_MIN
91 #define INT32_MIN (-2147483647-1)
92 #endif
93 #ifndef INT8_MAX
94 #define INT8_MAX (127)
95 #endif
96 #ifndef INT16_MAX
97 #define INT16_MAX (32767)
98 #endif
99 #ifndef INT32_MAX
100 #define INT32_MAX (2147483647)
101 #endif
102 #ifndef UINT8_MAX
103 #define UINT8_MAX (255U)
104 #endif
105 #ifndef UINT16_MAX
106 #define UINT16_MAX (65535U)
107 #endif
108 #ifndef UINT32_MAX
109 #define UINT32_MAX (4294967295U)
110 #endif
112 #endif /* ! C99 */
114 #endif /* ! FLEXINT_H */
116 /* %endif */
118 /* %if-c++-only */
119 /* %endif */
121 #ifdef __cplusplus
123 /* The "const" storage-class-modifier is valid. */
124 #define YY_USE_CONST
126 #else /* ! __cplusplus */
128 /* C99 requires __STDC__ to be defined as 1. */
129 #if defined (__STDC__)
131 #define YY_USE_CONST
133 #endif /* defined (__STDC__) */
134 #endif /* ! __cplusplus */
136 #ifdef YY_USE_CONST
137 #define yyconst const
138 #else
139 #define yyconst
140 #endif
142 /* %not-for-header */
144 /* Returned upon end-of-file. */
145 #define YY_NULL 0
146 /* %ok-for-header */
148 /* %not-for-header */
150 /* Promotes a possibly negative, possibly signed char to an unsigned
151 * integer for use as an array index. If the signed char is negative,
152 * we want to instead treat it as an 8-bit unsigned char, hence the
153 * double cast.
154 */
155 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
156 /* %ok-for-header */
158 /* %if-reentrant */
159 /* %endif */
161 /* %if-not-reentrant */
163 /* %endif */
165 /* Enter a start condition. This macro really ought to take a parameter,
166 * but we do it the disgusting crufty way forced on us by the ()-less
167 * definition of BEGIN.
168 */
169 #define BEGIN (yy_start) = 1 + 2 *
171 /* Translate the current start state into a value that can be later handed
172 * to BEGIN to return to the state. The YYSTATE alias is for lex
173 * compatibility.
174 */
175 #define YY_START (((yy_start) - 1) / 2)
176 #define YYSTATE YY_START
178 /* Action number for EOF rule of a given start state. */
179 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
181 /* Special action meaning "start processing a new file". */
182 #define YY_NEW_FILE yyrestart(yyin )
184 #define YY_END_OF_BUFFER_CHAR 0
186 /* Size of default input buffer. */
187 #ifndef YY_BUF_SIZE
188 #define YY_BUF_SIZE 16384
189 #endif
191 /* The state buf must be large enough to hold one state per character in the main buffer.
192 */
193 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
195 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
196 #define YY_TYPEDEF_YY_BUFFER_STATE
197 typedef struct yy_buffer_state *YY_BUFFER_STATE;
198 #endif
200 /* %if-not-reentrant */
201 extern int yyleng;
202 /* %endif */
204 /* %if-c-only */
205 /* %if-not-reentrant */
206 extern FILE *yyin, *yyout;
207 /* %endif */
208 /* %endif */
210 #define EOB_ACT_CONTINUE_SCAN 0
211 #define EOB_ACT_END_OF_FILE 1
212 #define EOB_ACT_LAST_MATCH 2
214 #define YY_LESS_LINENO(n)
216 /* Return all but the first "n" matched characters back to the input stream. */
217 #define yyless(n) \
218 do \
219 { \
220 /* Undo effects of setting up yytext. */ \
221 int yyless_macro_arg = (n); \
222 YY_LESS_LINENO(yyless_macro_arg);\
223 *yy_cp = (yy_hold_char); \
224 YY_RESTORE_YY_MORE_OFFSET \
225 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
226 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
227 } \
228 while ( 0 )
230 #define unput(c) yyunput( c, (yytext_ptr) )
232 #ifndef YY_TYPEDEF_YY_SIZE_T
233 #define YY_TYPEDEF_YY_SIZE_T
234 typedef size_t yy_size_t;
235 #endif
237 #ifndef YY_STRUCT_YY_BUFFER_STATE
238 #define YY_STRUCT_YY_BUFFER_STATE
239 struct yy_buffer_state
240 {
241 /* %if-c-only */
242 FILE *yy_input_file;
243 /* %endif */
245 /* %if-c++-only */
246 /* %endif */
248 char *yy_ch_buf; /* input buffer */
249 char *yy_buf_pos; /* current position in input buffer */
251 /* Size of input buffer in bytes, not including room for EOB
252 * characters.
253 */
254 yy_size_t yy_buf_size;
256 /* Number of characters read into yy_ch_buf, not including EOB
257 * characters.
258 */
259 int yy_n_chars;
261 /* Whether we "own" the buffer - i.e., we know we created it,
262 * and can realloc() it to grow it, and should free() it to
263 * delete it.
264 */
265 int yy_is_our_buffer;
267 /* Whether this is an "interactive" input source; if so, and
268 * if we're using stdio for input, then we want to use getc()
269 * instead of fread(), to make sure we stop fetching input after
270 * each newline.
271 */
272 int yy_is_interactive;
274 /* Whether we're considered to be at the beginning of a line.
275 * If so, '^' rules will be active on the next match, otherwise
276 * not.
277 */
278 int yy_at_bol;
280 int yy_bs_lineno; /**< The line count. */
281 int yy_bs_column; /**< The column count. */
283 /* Whether to try to fill the input buffer when we reach the
284 * end of it.
285 */
286 int yy_fill_buffer;
288 int yy_buffer_status;
290 #define YY_BUFFER_NEW 0
291 #define YY_BUFFER_NORMAL 1
292 /* When an EOF's been seen but there's still some text to process
293 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
294 * shouldn't try reading from the input source any more. We might
295 * still have a bunch of tokens to match, though, because of
296 * possible backing-up.
297 *
298 * When we actually see the EOF, we change the status to "new"
299 * (via yyrestart()), so that the user can continue scanning by
300 * just pointing yyin at a new input file.
301 */
302 #define YY_BUFFER_EOF_PENDING 2
304 };
305 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
307 /* %if-c-only Standard (non-C++) definition */
308 /* %not-for-header */
310 /* %if-not-reentrant */
312 /* Stack of input buffers. */
313 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
314 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
315 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
316 /* %endif */
317 /* %ok-for-header */
319 /* %endif */
321 /* We provide macros for accessing buffer states in case in the
322 * future we want to put the buffer states in a more general
323 * "scanner state".
324 *
325 * Returns the top of the stack, or NULL.
326 */
327 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
328 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
329 : NULL)
331 /* Same as previous macro, but useful when we know that the buffer stack is not
332 * NULL or when we need an lvalue. For internal use only.
333 */
334 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
336 /* %if-c-only Standard (non-C++) definition */
338 /* %if-not-reentrant */
339 /* %not-for-header */
341 /* yy_hold_char holds the character lost when yytext is formed. */
342 static char yy_hold_char;
343 static int yy_n_chars; /* number of characters read into yy_ch_buf */
344 int yyleng;
346 /* Points to current character in buffer. */
347 static char *yy_c_buf_p = (char *) 0;
348 static int yy_init = 0; /* whether we need to initialize */
349 static int yy_start = 0; /* start state number */
351 /* Flag which is used to allow yywrap()'s to do buffer switches
352 * instead of setting up a fresh yyin. A bit of a hack ...
353 */
354 static int yy_did_buffer_switch_on_eof;
355 /* %ok-for-header */
357 /* %endif */
359 void yyrestart (FILE *input_file );
360 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
361 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size );
362 void yy_delete_buffer (YY_BUFFER_STATE b );
363 void yy_flush_buffer (YY_BUFFER_STATE b );
364 void yypush_buffer_state (YY_BUFFER_STATE new_buffer );
365 void yypop_buffer_state (void );
367 static void yyensure_buffer_stack (void );
368 static void yy_load_buffer_state (void );
369 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
371 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
373 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size );
374 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str );
375 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len );
377 /* %endif */
379 void *yyalloc (yy_size_t );
380 void *yyrealloc (void *,yy_size_t );
381 void yyfree (void * );
383 #define yy_new_buffer yy_create_buffer
385 #define yy_set_interactive(is_interactive) \
386 { \
387 if ( ! YY_CURRENT_BUFFER ){ \
388 yyensure_buffer_stack (); \
389 YY_CURRENT_BUFFER_LVALUE = \
390 yy_create_buffer(yyin,YY_BUF_SIZE ); \
391 } \
392 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
393 }
395 #define yy_set_bol(at_bol) \
396 { \
397 if ( ! YY_CURRENT_BUFFER ){\
398 yyensure_buffer_stack (); \
399 YY_CURRENT_BUFFER_LVALUE = \
400 yy_create_buffer(yyin,YY_BUF_SIZE ); \
401 } \
402 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
403 }
405 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
407 /* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */
408 /* Begin user sect3 */
410 #define yywrap(n) 1
411 #define YY_SKIP_YYWRAP
413 #define FLEX_DEBUG
415 typedef unsigned char YY_CHAR;
417 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
419 typedef int yy_state_type;
421 extern int yylineno;
423 int yylineno = 1;
425 extern char *yytext;
426 #define yytext_ptr yytext
428 /* %if-c-only Standard (non-C++) definition */
430 static yy_state_type yy_get_previous_state (void );
431 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
432 static int yy_get_next_buffer (void );
433 static void yy_fatal_error (yyconst char msg[] );
435 /* %endif */
437 /* Done after the current pattern has been matched and before the
438 * corresponding action - sets up yytext.
439 */
440 #define YY_DO_BEFORE_ACTION \
441 (yytext_ptr) = yy_bp; \
442 /* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\
443 yyleng = (size_t) (yy_cp - yy_bp); \
444 (yy_hold_char) = *yy_cp; \
445 *yy_cp = '\0'; \
446 /* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\
447 (yy_c_buf_p) = yy_cp;
449 /* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */
450 #define YY_NUM_RULES 13
451 #define YY_END_OF_BUFFER 14
452 /* This struct is not used in this scanner,
453 but its presence is necessary. */
454 struct yy_trans_info
455 {
456 flex_int32_t yy_verify;
457 flex_int32_t yy_nxt;
458 };
459 static yyconst flex_int16_t yy_accept[76] =
460 { 0,
461 0, 0, 0, 0, 14, 12, 4, 3, 12, 7,
462 12, 12, 7, 12, 12, 12, 12, 12, 9, 9,
463 12, 12, 12, 4, 0, 5, 0, 7, 0, 6,
464 0, 0, 0, 0, 0, 0, 2, 8, 10, 10,
465 9, 0, 0, 9, 9, 0, 9, 0, 0, 11,
466 0, 0, 0, 10, 0, 10, 9, 9, 0, 0,
467 0, 0, 0, 0, 0, 10, 10, 0, 0, 0,
468 0, 0, 0, 1, 0
469 } ;
471 static yyconst flex_int32_t yy_ec[256] =
472 { 0,
473 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
474 4, 4, 4, 1, 1, 1, 1, 1, 1, 1,
475 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
476 1, 2, 1, 5, 6, 7, 8, 9, 10, 1,
477 1, 8, 11, 1, 12, 13, 8, 14, 15, 15,
478 15, 15, 15, 15, 15, 16, 16, 1, 1, 17,
479 18, 19, 1, 1, 20, 20, 20, 20, 21, 22,
480 7, 7, 7, 7, 7, 23, 7, 7, 7, 7,
481 7, 7, 7, 7, 24, 7, 7, 25, 7, 7,
482 1, 26, 1, 8, 7, 1, 20, 20, 20, 20,
484 21, 22, 7, 7, 7, 7, 7, 27, 7, 7,
485 7, 7, 7, 7, 7, 7, 24, 7, 7, 25,
486 7, 7, 1, 28, 1, 8, 1, 1, 1, 1,
487 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
488 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
489 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
490 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
491 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
492 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
493 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
495 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
496 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
497 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
498 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
499 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
500 1, 1, 1, 1, 1
501 } ;
503 static yyconst flex_int32_t yy_meta[29] =
504 { 0,
505 1, 1, 2, 1, 1, 1, 3, 1, 1, 1,
506 4, 4, 5, 6, 6, 6, 1, 1, 1, 7,
507 8, 7, 3, 3, 3, 1, 3, 1
508 } ;
510 static yyconst flex_int16_t yy_base[88] =
511 { 0,
512 0, 147, 21, 140, 145, 284, 39, 284, 26, 0,
513 32, 126, 40, 44, 115, 35, 36, 46, 50, 53,
514 39, 61, 54, 79, 65, 284, 0, 0, 66, 284,
515 0, 119, 79, 75, 123, 104, 284, 284, 107, 0,
516 79, 73, 76, 76, 66, 0, 0, 85, 86, 284,
517 133, 83, 91, 284, 99, 147, 284, 114, 122, 70,
518 107, 141, 172, 151, 135, 181, 284, 137, 114, 157,
519 149, 48, 45, 284, 284, 208, 214, 222, 230, 238,
520 246, 250, 255, 256, 261, 267, 275
521 } ;
523 static yyconst flex_int16_t yy_def[88] =
524 { 0,
525 75, 1, 1, 3, 75, 75, 75, 75, 76, 77,
526 78, 75, 77, 79, 75, 75, 75, 75, 75, 19,
527 75, 75, 75, 75, 76, 75, 80, 77, 78, 75,
528 81, 75, 76, 78, 79, 79, 75, 75, 75, 39,
529 19, 82, 83, 75, 75, 84, 20, 76, 78, 75,
530 79, 51, 85, 75, 75, 75, 75, 84, 79, 51,
531 79, 79, 79, 51, 75, 75, 75, 86, 79, 63,
532 86, 87, 87, 75, 0, 75, 75, 75, 75, 75,
533 75, 75, 75, 75, 75, 75, 75
534 } ;
536 static yyconst flex_int16_t yy_nxt[313] =
537 { 0,
538 6, 7, 8, 7, 9, 6, 10, 6, 6, 11,
539 6, 6, 12, 6, 6, 6, 6, 6, 6, 10,
540 10, 10, 13, 10, 10, 6, 10, 6, 15, 16,
541 26, 15, 17, 18, 19, 20, 20, 21, 15, 22,
542 24, 30, 24, 38, 33, 36, 37, 74, 23, 34,
543 74, 27, 38, 38, 38, 38, 38, 31, 32, 39,
544 39, 39, 40, 41, 41, 42, 47, 47, 47, 26,
545 43, 38, 44, 45, 46, 30, 44, 75, 38, 38,
546 24, 38, 24, 26, 30, 40, 55, 55, 57, 26,
547 27, 31, 57, 43, 35, 30, 64, 64, 64, 57,
549 31, 65, 65, 75, 27, 36, 37, 35, 59, 37,
550 27, 31, 56, 56, 56, 59, 37, 51, 52, 52,
551 39, 39, 39, 59, 37, 37, 68, 53, 54, 54,
552 69, 50, 38, 54, 59, 37, 44, 45, 32, 37,
553 44, 35, 59, 37, 75, 14, 60, 60, 66, 66,
554 66, 37, 14, 72, 75, 61, 62, 63, 59, 61,
555 56, 56, 56, 69, 64, 64, 64, 69, 67, 67,
556 75, 75, 75, 67, 37, 35, 75, 75, 75, 61,
557 62, 75, 75, 61, 75, 70, 70, 70, 75, 75,
558 75, 70, 70, 70, 66, 66, 66, 75, 75, 75,
560 75, 75, 54, 54, 75, 75, 75, 54, 25, 25,
561 25, 25, 25, 25, 25, 25, 28, 75, 75, 28,
562 28, 28, 29, 29, 29, 29, 29, 29, 29, 29,
563 35, 35, 35, 35, 35, 35, 35, 35, 48, 75,
564 48, 48, 48, 48, 48, 48, 49, 75, 49, 49,
565 49, 49, 49, 49, 42, 42, 75, 42, 56, 75,
566 56, 58, 58, 58, 66, 75, 66, 71, 71, 71,
567 71, 71, 71, 71, 71, 73, 73, 73, 73, 73,
568 73, 73, 73, 5, 75, 75, 75, 75, 75, 75,
569 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
571 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
572 75, 75
573 } ;
575 static yyconst flex_int16_t yy_chk[313] =
576 { 0,
577 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
578 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
579 1, 1, 1, 1, 1, 1, 1, 1, 3, 3,
580 9, 3, 3, 3, 3, 3, 3, 3, 3, 3,
581 7, 11, 7, 16, 13, 14, 14, 73, 3, 13,
582 72, 9, 16, 17, 17, 21, 21, 11, 18, 18,
583 18, 18, 19, 19, 19, 19, 20, 20, 20, 25,
584 19, 23, 19, 19, 19, 29, 19, 20, 22, 22,
585 24, 23, 24, 33, 34, 42, 43, 43, 45, 48,
586 25, 29, 45, 42, 60, 49, 52, 52, 52, 44,
588 34, 53, 53, 41, 33, 36, 36, 52, 61, 61,
589 48, 49, 55, 55, 55, 69, 69, 36, 36, 36,
590 39, 39, 39, 59, 59, 35, 59, 39, 39, 39,
591 61, 32, 15, 39, 51, 51, 58, 58, 12, 68,
592 58, 68, 62, 62, 5, 4, 51, 51, 65, 65,
593 65, 71, 2, 71, 0, 51, 51, 51, 70, 51,
594 56, 56, 56, 62, 64, 64, 64, 62, 56, 56,
595 0, 0, 0, 56, 63, 64, 0, 0, 0, 70,
596 70, 0, 0, 70, 0, 63, 63, 63, 0, 0,
597 0, 63, 63, 63, 66, 66, 66, 0, 0, 0,
599 0, 0, 66, 66, 0, 0, 0, 66, 76, 76,
600 76, 76, 76, 76, 76, 76, 77, 0, 0, 77,
601 77, 77, 78, 78, 78, 78, 78, 78, 78, 78,
602 79, 79, 79, 79, 79, 79, 79, 79, 80, 0,
603 80, 80, 80, 80, 80, 80, 81, 0, 81, 81,
604 81, 81, 81, 81, 82, 82, 0, 82, 83, 0,
605 83, 84, 84, 84, 85, 0, 85, 86, 86, 86,
606 86, 86, 86, 86, 86, 87, 87, 87, 87, 87,
607 87, 87, 87, 75, 75, 75, 75, 75, 75, 75,
608 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
610 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
611 75, 75
612 } ;
614 static yy_state_type yy_last_accepting_state;
615 static char *yy_last_accepting_cpos;
617 extern int yy_flex_debug;
618 int yy_flex_debug = 1;
620 static yyconst flex_int16_t yy_rule_linenum[13] =
621 { 0,
622 71, 72, 73, 76, 79, 80, 81, 87, 88, 89,
623 91, 94
624 } ;
626 /* The intent behind this definition is that it'll catch
627 * any uses of REJECT which flex missed.
628 */
629 #define REJECT reject_used_but_not_detected
630 #define yymore() yymore_used_but_not_detected
631 #define YY_MORE_ADJ 0
632 #define YY_RESTORE_YY_MORE_OFFSET
633 char *yytext;
634 #line 1 "scripts/genksyms/lex.l"
635 /* Lexical analysis for genksyms.
636 Copyright 1996, 1997 Linux International.
638 New implementation contributed by Richard Henderson <rth@tamu.edu>
639 Based on original work by Bjorn Ekwall <bj0rn@blox.se>
641 Taken from Linux modutils 2.4.22.
643 This program is free software; you can redistribute it and/or modify it
644 under the terms of the GNU General Public License as published by the
645 Free Software Foundation; either version 2 of the License, or (at your
646 option) any later version.
648 This program is distributed in the hope that it will be useful, but
649 WITHOUT ANY WARRANTY; without even the implied warranty of
650 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
651 General Public License for more details.
653 You should have received a copy of the GNU General Public License
654 along with this program; if not, write to the Free Software Foundation,
655 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
656 #line 25 "scripts/genksyms/lex.l"
658 #include <limits.h>
659 #include <stdlib.h>
660 #include <string.h>
661 #include <ctype.h>
663 #include "genksyms.h"
664 #include "parse.h"
666 /* We've got a two-level lexer here. We let flex do basic tokenization
667 and then we categorize those basic tokens in the second stage. */
668 #define YY_DECL static int yylex1(void)
670 /* Version 2 checksumming does proper tokenization; version 1 wasn't
671 quite so pedantic. */
673 /* We don't do multiple input files. */
674 #define YY_NO_INPUT 1
675 #line 676 "scripts/genksyms/lex.c"
677 #define INITIAL 0
678 #define V2_TOKENS 1
680 #ifndef YY_NO_UNISTD_H
681 /* Special case for "unistd.h", since it is non-ANSI. We include it way
682 * down here because we want the user's section 1 to have been scanned first.
683 * The user has a chance to override it with an option.
684 */
685 /* %if-c-only */
686 #include <unistd.h>
687 /* %endif */
688 /* %if-c++-only */
689 /* %endif */
690 #endif
692 #ifndef YY_EXTRA_TYPE
693 #define YY_EXTRA_TYPE void *
694 #endif
696 /* %if-c-only Reentrant structure and macros (non-C++). */
697 /* %if-reentrant */
698 /* %if-c-only */
700 static int yy_init_globals (void );
702 /* %endif */
703 /* %if-reentrant */
704 /* %endif */
705 /* %endif End reentrant structures and macros. */
707 /* Accessor methods to globals.
708 These are made visible to non-reentrant scanners for convenience. */
710 int yylex_destroy (void );
712 int yyget_debug (void );
714 void yyset_debug (int debug_flag );
716 YY_EXTRA_TYPE yyget_extra (void );
718 void yyset_extra (YY_EXTRA_TYPE user_defined );
720 FILE *yyget_in (void );
722 void yyset_in (FILE * in_str );
724 FILE *yyget_out (void );
726 void yyset_out (FILE * out_str );
728 int yyget_leng (void );
730 char *yyget_text (void );
732 int yyget_lineno (void );
734 void yyset_lineno (int line_number );
736 /* %if-bison-bridge */
737 /* %endif */
739 /* Macros after this point can all be overridden by user definitions in
740 * section 1.
741 */
743 #ifndef YY_SKIP_YYWRAP
744 #ifdef __cplusplus
745 extern "C" int yywrap (void );
746 #else
747 extern int yywrap (void );
748 #endif
749 #endif
751 /* %not-for-header */
753 static void yyunput (int c,char *buf_ptr );
755 /* %ok-for-header */
757 /* %endif */
759 #ifndef yytext_ptr
760 static void yy_flex_strncpy (char *,yyconst char *,int );
761 #endif
763 #ifdef YY_NEED_STRLEN
764 static int yy_flex_strlen (yyconst char * );
765 #endif
767 #ifndef YY_NO_INPUT
768 /* %if-c-only Standard (non-C++) definition */
769 /* %not-for-header */
771 #ifdef __cplusplus
772 static int yyinput (void );
773 #else
774 static int input (void );
775 #endif
776 /* %ok-for-header */
778 /* %endif */
779 #endif
781 /* %if-c-only */
783 /* %endif */
785 /* Amount of stuff to slurp up with each read. */
786 #ifndef YY_READ_BUF_SIZE
787 #define YY_READ_BUF_SIZE 8192
788 #endif
790 /* Copy whatever the last rule matched to the standard output. */
791 #ifndef ECHO
792 /* %if-c-only Standard (non-C++) definition */
793 /* This used to be an fputs(), but since the string might contain NUL's,
794 * we now use fwrite().
795 */
796 #define ECHO fwrite( yytext, yyleng, 1, yyout )
797 /* %endif */
798 /* %if-c++-only C++ definition */
799 /* %endif */
800 #endif
802 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
803 * is returned in "result".
804 */
805 #ifndef YY_INPUT
806 #define YY_INPUT(buf,result,max_size) \
807 /* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\
808 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
809 { \
810 int c = '*'; \
811 size_t n; \
812 for ( n = 0; n < max_size && \
813 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
814 buf[n] = (char) c; \
815 if ( c == '\n' ) \
816 buf[n++] = (char) c; \
817 if ( c == EOF && ferror( yyin ) ) \
818 YY_FATAL_ERROR( "input in flex scanner failed" ); \
819 result = n; \
820 } \
821 else \
822 { \
823 errno=0; \
824 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
825 { \
826 if( errno != EINTR) \
827 { \
828 YY_FATAL_ERROR( "input in flex scanner failed" ); \
829 break; \
830 } \
831 errno=0; \
832 clearerr(yyin); \
833 } \
834 }\
835 \
836 /* %if-c++-only C++ definition \ */\
837 /* %endif */
839 #endif
841 /* No semi-colon after return; correct usage is to write "yyterminate();" -
842 * we don't want an extra ';' after the "return" because that will cause
843 * some compilers to complain about unreachable statements.
844 */
845 #ifndef yyterminate
846 #define yyterminate() return YY_NULL
847 #endif
849 /* Number of entries by which start-condition stack grows. */
850 #ifndef YY_START_STACK_INCR
851 #define YY_START_STACK_INCR 25
852 #endif
854 /* Report a fatal error. */
855 #ifndef YY_FATAL_ERROR
856 /* %if-c-only */
857 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
858 /* %endif */
859 /* %if-c++-only */
860 /* %endif */
861 #endif
863 /* %if-tables-serialization structures and prototypes */
864 /* %not-for-header */
866 /* %ok-for-header */
868 /* %not-for-header */
870 /* %tables-yydmap generated elements */
871 /* %endif */
872 /* end tables serialization structures and prototypes */
874 /* %ok-for-header */
876 /* Default declaration of generated scanner - a define so the user can
877 * easily add parameters.
878 */
879 #ifndef YY_DECL
880 #define YY_DECL_IS_OURS 1
881 /* %if-c-only Standard (non-C++) definition */
883 extern int yylex (void);
885 #define YY_DECL int yylex (void)
886 /* %endif */
887 /* %if-c++-only C++ definition */
888 /* %endif */
889 #endif /* !YY_DECL */
891 /* Code executed at the beginning of each rule, after yytext and yyleng
892 * have been set up.
893 */
894 #ifndef YY_USER_ACTION
895 #define YY_USER_ACTION
896 #endif
898 /* Code executed at the end of each rule. */
899 #ifndef YY_BREAK
900 #define YY_BREAK break;
901 #endif
903 /* %% [6.0] YY_RULE_SETUP definition goes here */
904 #define YY_RULE_SETUP \
905 if ( yyleng > 0 ) \
906 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
907 (yytext[yyleng - 1] == '\n'); \
908 YY_USER_ACTION
910 /* %not-for-header */
912 /** The main scanner function which does all the work.
913 */
914 YY_DECL
915 {
916 register yy_state_type yy_current_state;
917 register char *yy_cp, *yy_bp;
918 register int yy_act;
920 /* %% [7.0] user's declarations go here */
921 #line 67 "scripts/genksyms/lex.l"
925 /* Keep track of our location in the original source files. */
926 #line 927 "scripts/genksyms/lex.c"
928 if ( !(yy_init) )
929 {
930 (yy_init) = 1;
932 #ifdef YY_USER_INIT
933 YY_USER_INIT;
934 #endif
936 if ( ! (yy_start) )
937 (yy_start) = 1; /* first start state */
939 if ( ! yyin )
940 /* %if-c-only */
941 yyin = stdin;
942 /* %endif */
943 /* %if-c++-only */
944 /* %endif */
946 if ( ! yyout )
947 /* %if-c-only */
948 yyout = stdout;
949 /* %endif */
950 /* %if-c++-only */
951 /* %endif */
953 if ( ! YY_CURRENT_BUFFER ) {
954 yyensure_buffer_stack ();
955 YY_CURRENT_BUFFER_LVALUE =
956 yy_create_buffer(yyin,YY_BUF_SIZE );
957 }
959 yy_load_buffer_state( );
960 }
962 while ( 1 ) /* loops until end-of-file is reached */
963 {
964 /* %% [8.0] yymore()-related code goes here */
965 yy_cp = (yy_c_buf_p);
967 /* Support of yytext. */
968 *yy_cp = (yy_hold_char);
970 /* yy_bp points to the position in yy_ch_buf of the start of
971 * the current run.
972 */
973 yy_bp = yy_cp;
975 /* %% [9.0] code to set up and find next match goes here */
976 yy_current_state = (yy_start);
977 yy_current_state += YY_AT_BOL();
978 yy_match:
979 do
980 {
981 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
982 if ( yy_accept[yy_current_state] )
983 {
984 (yy_last_accepting_state) = yy_current_state;
985 (yy_last_accepting_cpos) = yy_cp;
986 }
987 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
988 {
989 yy_current_state = (int) yy_def[yy_current_state];
990 if ( yy_current_state >= 76 )
991 yy_c = yy_meta[(unsigned int) yy_c];
992 }
993 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
994 ++yy_cp;
995 }
996 while ( yy_base[yy_current_state] != 284 );
998 yy_find_action:
999 /* %% [10.0] code to find the action number goes here */
1000 yy_act = yy_accept[yy_current_state];
1001 if ( yy_act == 0 )
1002 { /* have to back up */
1003 yy_cp = (yy_last_accepting_cpos);
1004 yy_current_state = (yy_last_accepting_state);
1005 yy_act = yy_accept[yy_current_state];
1006 }
1008 YY_DO_BEFORE_ACTION;
1010 /* %% [11.0] code for yylineno update goes here */
1012 do_action: /* This label is used only to access EOF actions. */
1014 /* %% [12.0] debug code goes here */
1015 if ( yy_flex_debug )
1016 {
1017 if ( yy_act == 0 )
1018 fprintf( stderr, "--scanner backing up\n" );
1019 else if ( yy_act < 13 )
1020 fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n",
1021 (long)yy_rule_linenum[yy_act], yytext );
1022 else if ( yy_act == 13 )
1023 fprintf( stderr, "--accepting default rule (\"%s\")\n",
1024 yytext );
1025 else if ( yy_act == 14 )
1026 fprintf( stderr, "--(end of buffer or a NUL)\n" );
1027 else
1028 fprintf( stderr, "--EOF (start condition %d)\n", YY_START );
1029 }
1031 switch ( yy_act )
1032 { /* beginning of action switch */
1033 /* %% [13.0] actions go here */
1034 case 0: /* must back up */
1035 /* undo the effects of YY_DO_BEFORE_ACTION */
1036 *yy_cp = (yy_hold_char);
1037 yy_cp = (yy_last_accepting_cpos);
1038 yy_current_state = (yy_last_accepting_state);
1039 goto yy_find_action;
1041 case 1:
1042 /* rule 1 can match eol */
1043 YY_RULE_SETUP
1044 #line 71 "scripts/genksyms/lex.l"
1045 return FILENAME;
1046 YY_BREAK
1047 case 2:
1048 /* rule 2 can match eol */
1049 YY_RULE_SETUP
1050 #line 72 "scripts/genksyms/lex.l"
1051 cur_line++;
1052 YY_BREAK
1053 case 3:
1054 /* rule 3 can match eol */
1055 YY_RULE_SETUP
1056 #line 73 "scripts/genksyms/lex.l"
1057 cur_line++;
1058 YY_BREAK
1059 /* Ignore all other whitespace. */
1060 case 4:
1061 YY_RULE_SETUP
1062 #line 76 "scripts/genksyms/lex.l"
1063 ;
1064 YY_BREAK
1065 case 5:
1066 /* rule 5 can match eol */
1067 YY_RULE_SETUP
1068 #line 79 "scripts/genksyms/lex.l"
1069 return STRING;
1070 YY_BREAK
1071 case 6:
1072 /* rule 6 can match eol */
1073 YY_RULE_SETUP
1074 #line 80 "scripts/genksyms/lex.l"
1075 return CHAR;
1076 YY_BREAK
1077 case 7:
1078 YY_RULE_SETUP
1079 #line 81 "scripts/genksyms/lex.l"
1080 return IDENT;
1081 YY_BREAK
1082 /* The Pedant requires that the other C multi-character tokens be
1083 recognized as tokens. We don't actually use them since we don't
1084 parse expressions, but we do want whitespace to be arranged
1085 around them properly. */
1086 case 8:
1087 YY_RULE_SETUP
1088 #line 87 "scripts/genksyms/lex.l"
1089 return OTHER;
1090 YY_BREAK
1091 case 9:
1092 YY_RULE_SETUP
1093 #line 88 "scripts/genksyms/lex.l"
1094 return INT;
1095 YY_BREAK
1096 case 10:
1097 YY_RULE_SETUP
1098 #line 89 "scripts/genksyms/lex.l"
1099 return REAL;
1100 YY_BREAK
1101 case 11:
1102 YY_RULE_SETUP
1103 #line 91 "scripts/genksyms/lex.l"
1104 return DOTS;
1105 YY_BREAK
1106 /* All other tokens are single characters. */
1107 case 12:
1108 YY_RULE_SETUP
1109 #line 94 "scripts/genksyms/lex.l"
1110 return yytext[0];
1111 YY_BREAK
1112 case 13:
1113 YY_RULE_SETUP
1114 #line 97 "scripts/genksyms/lex.l"
1115 ECHO;
1116 YY_BREAK
1117 #line 1118 "scripts/genksyms/lex.c"
1118 case YY_STATE_EOF(INITIAL):
1119 case YY_STATE_EOF(V2_TOKENS):
1120 yyterminate();
1122 case YY_END_OF_BUFFER:
1123 {
1124 /* Amount of text matched not including the EOB char. */
1125 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1127 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1128 *yy_cp = (yy_hold_char);
1129 YY_RESTORE_YY_MORE_OFFSET
1131 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1132 {
1133 /* We're scanning a new file or input source. It's
1134 * possible that this happened because the user
1135 * just pointed yyin at a new source and called
1136 * yylex(). If so, then we have to assure
1137 * consistency between YY_CURRENT_BUFFER and our
1138 * globals. Here is the right place to do so, because
1139 * this is the first action (other than possibly a
1140 * back-up) that will match for the new input source.
1141 */
1142 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1143 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1144 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1145 }
1147 /* Note that here we test for yy_c_buf_p "<=" to the position
1148 * of the first EOB in the buffer, since yy_c_buf_p will
1149 * already have been incremented past the NUL character
1150 * (since all states make transitions on EOB to the
1151 * end-of-buffer state). Contrast this with the test
1152 * in input().
1153 */
1154 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1155 { /* This was really a NUL. */
1156 yy_state_type yy_next_state;
1158 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1160 yy_current_state = yy_get_previous_state( );
1162 /* Okay, we're now positioned to make the NUL
1163 * transition. We couldn't have
1164 * yy_get_previous_state() go ahead and do it
1165 * for us because it doesn't know how to deal
1166 * with the possibility of jamming (and we don't
1167 * want to build jamming into it because then it
1168 * will run more slowly).
1169 */
1171 yy_next_state = yy_try_NUL_trans( yy_current_state );
1173 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1175 if ( yy_next_state )
1176 {
1177 /* Consume the NUL. */
1178 yy_cp = ++(yy_c_buf_p);
1179 yy_current_state = yy_next_state;
1180 goto yy_match;
1181 }
1183 else
1184 {
1185 /* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
1186 yy_cp = (yy_c_buf_p);
1187 goto yy_find_action;
1188 }
1189 }
1191 else switch ( yy_get_next_buffer( ) )
1192 {
1193 case EOB_ACT_END_OF_FILE:
1194 {
1195 (yy_did_buffer_switch_on_eof) = 0;
1197 if ( yywrap( ) )
1198 {
1199 /* Note: because we've taken care in
1200 * yy_get_next_buffer() to have set up
1201 * yytext, we can now set up
1202 * yy_c_buf_p so that if some total
1203 * hoser (like flex itself) wants to
1204 * call the scanner after we return the
1205 * YY_NULL, it'll still work - another
1206 * YY_NULL will get returned.
1207 */
1208 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1210 yy_act = YY_STATE_EOF(YY_START);
1211 goto do_action;
1212 }
1214 else
1215 {
1216 if ( ! (yy_did_buffer_switch_on_eof) )
1217 YY_NEW_FILE;
1218 }
1219 break;
1220 }
1222 case EOB_ACT_CONTINUE_SCAN:
1223 (yy_c_buf_p) =
1224 (yytext_ptr) + yy_amount_of_matched_text;
1226 yy_current_state = yy_get_previous_state( );
1228 yy_cp = (yy_c_buf_p);
1229 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1230 goto yy_match;
1232 case EOB_ACT_LAST_MATCH:
1233 (yy_c_buf_p) =
1234 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1236 yy_current_state = yy_get_previous_state( );
1238 yy_cp = (yy_c_buf_p);
1239 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1240 goto yy_find_action;
1241 }
1242 break;
1243 }
1245 default:
1246 YY_FATAL_ERROR(
1247 "fatal flex scanner internal error--no action found" );
1248 } /* end of action switch */
1249 } /* end of scanning one token */
1250 } /* end of yylex */
1251 /* %ok-for-header */
1253 /* %if-c++-only */
1254 /* %not-for-header */
1256 /* %ok-for-header */
1258 /* %endif */
1260 /* yy_get_next_buffer - try to read in a new buffer
1261 *
1262 * Returns a code representing an action:
1263 * EOB_ACT_LAST_MATCH -
1264 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1265 * EOB_ACT_END_OF_FILE - end of file
1266 */
1267 /* %if-c-only */
1268 static int yy_get_next_buffer (void)
1269 /* %endif */
1270 /* %if-c++-only */
1271 /* %endif */
1272 {
1273 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1274 register char *source = (yytext_ptr);
1275 register int number_to_move, i;
1276 int ret_val;
1278 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1279 YY_FATAL_ERROR(
1280 "fatal flex scanner internal error--end of buffer missed" );
1282 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1283 { /* Don't try to fill the buffer, so this is an EOF. */
1284 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1285 {
1286 /* We matched a single character, the EOB, so
1287 * treat this as a final EOF.
1288 */
1289 return EOB_ACT_END_OF_FILE;
1290 }
1292 else
1293 {
1294 /* We matched some text prior to the EOB, first
1295 * process it.
1296 */
1297 return EOB_ACT_LAST_MATCH;
1298 }
1299 }
1301 /* Try to read more data. */
1303 /* First move last chars to start of buffer. */
1304 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1306 for ( i = 0; i < number_to_move; ++i )
1307 *(dest++) = *(source++);
1309 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1310 /* don't do the read, it's not guaranteed to return an EOF,
1311 * just force an EOF
1312 */
1313 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1315 else
1316 {
1317 int num_to_read =
1318 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1320 while ( num_to_read <= 0 )
1321 { /* Not enough room in the buffer - grow it. */
1323 /* just a shorter name for the current buffer */
1324 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1326 int yy_c_buf_p_offset =
1327 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1329 if ( b->yy_is_our_buffer )
1330 {
1331 int new_size = b->yy_buf_size * 2;
1333 if ( new_size <= 0 )
1334 b->yy_buf_size += b->yy_buf_size / 8;
1335 else
1336 b->yy_buf_size *= 2;
1338 b->yy_ch_buf = (char *)
1339 /* Include room in for 2 EOB chars. */
1340 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1341 }
1342 else
1343 /* Can't grow it, we don't own it. */
1344 b->yy_ch_buf = 0;
1346 if ( ! b->yy_ch_buf )
1347 YY_FATAL_ERROR(
1348 "fatal error - scanner input buffer overflow" );
1350 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1352 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1353 number_to_move - 1;
1355 }
1357 if ( num_to_read > YY_READ_BUF_SIZE )
1358 num_to_read = YY_READ_BUF_SIZE;
1360 /* Read in more data. */
1361 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1362 (yy_n_chars), (size_t) num_to_read );
1364 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1365 }
1367 if ( (yy_n_chars) == 0 )
1368 {
1369 if ( number_to_move == YY_MORE_ADJ )
1370 {
1371 ret_val = EOB_ACT_END_OF_FILE;
1372 yyrestart(yyin );
1373 }
1375 else
1376 {
1377 ret_val = EOB_ACT_LAST_MATCH;
1378 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1379 YY_BUFFER_EOF_PENDING;
1380 }
1381 }
1383 else
1384 ret_val = EOB_ACT_CONTINUE_SCAN;
1386 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1387 /* Extend the array by 50%, plus the number we really need. */
1388 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1389 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1390 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1391 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1392 }
1394 (yy_n_chars) += number_to_move;
1395 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1396 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1398 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1400 return ret_val;
1401 }
1403 /* yy_get_previous_state - get the state just before the EOB char was reached */
1405 /* %if-c-only */
1406 /* %not-for-header */
1408 static yy_state_type yy_get_previous_state (void)
1409 /* %endif */
1410 /* %if-c++-only */
1411 /* %endif */
1412 {
1413 register yy_state_type yy_current_state;
1414 register char *yy_cp;
1416 /* %% [15.0] code to get the start state into yy_current_state goes here */
1417 yy_current_state = (yy_start);
1418 yy_current_state += YY_AT_BOL();
1420 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1421 {
1422 /* %% [16.0] code to find the next state goes here */
1423 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1424 if ( yy_accept[yy_current_state] )
1425 {
1426 (yy_last_accepting_state) = yy_current_state;
1427 (yy_last_accepting_cpos) = yy_cp;
1428 }
1429 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1430 {
1431 yy_current_state = (int) yy_def[yy_current_state];
1432 if ( yy_current_state >= 76 )
1433 yy_c = yy_meta[(unsigned int) yy_c];
1434 }
1435 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1436 }
1438 return yy_current_state;
1439 }
1441 /* yy_try_NUL_trans - try to make a transition on the NUL character
1442 *
1443 * synopsis
1444 * next_state = yy_try_NUL_trans( current_state );
1445 */
1446 /* %if-c-only */
1447 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1448 /* %endif */
1449 /* %if-c++-only */
1450 /* %endif */
1451 {
1452 register int yy_is_jam;
1453 /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */
1454 register char *yy_cp = (yy_c_buf_p);
1456 register YY_CHAR yy_c = 1;
1457 if ( yy_accept[yy_current_state] )
1458 {
1459 (yy_last_accepting_state) = yy_current_state;
1460 (yy_last_accepting_cpos) = yy_cp;
1461 }
1462 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1463 {
1464 yy_current_state = (int) yy_def[yy_current_state];
1465 if ( yy_current_state >= 76 )
1466 yy_c = yy_meta[(unsigned int) yy_c];
1467 }
1468 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1469 yy_is_jam = (yy_current_state == 75);
1471 return yy_is_jam ? 0 : yy_current_state;
1472 }
1474 /* %if-c-only */
1476 static void yyunput (int c, register char * yy_bp )
1477 /* %endif */
1478 /* %if-c++-only */
1479 /* %endif */
1480 {
1481 register char *yy_cp;
1483 yy_cp = (yy_c_buf_p);
1485 /* undo effects of setting up yytext */
1486 *yy_cp = (yy_hold_char);
1488 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1489 { /* need to shift things up to make room */
1490 /* +2 for EOB chars. */
1491 register int number_to_move = (yy_n_chars) + 2;
1492 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1493 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1494 register char *source =
1495 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1497 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1498 *--dest = *--source;
1500 yy_cp += (int) (dest - source);
1501 yy_bp += (int) (dest - source);
1502 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1503 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1505 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1506 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1507 }
1509 *--yy_cp = (char) c;
1511 /* %% [18.0] update yylineno here */
1513 (yytext_ptr) = yy_bp;
1514 (yy_hold_char) = *yy_cp;
1515 (yy_c_buf_p) = yy_cp;
1516 }
1517 /* %if-c-only */
1519 /* %endif */
1521 /* %if-c-only */
1522 #ifndef YY_NO_INPUT
1523 #ifdef __cplusplus
1524 static int yyinput (void)
1525 #else
1526 static int input (void)
1527 #endif
1529 /* %endif */
1530 /* %if-c++-only */
1531 /* %endif */
1532 {
1533 int c;
1535 *(yy_c_buf_p) = (yy_hold_char);
1537 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1538 {
1539 /* yy_c_buf_p now points to the character we want to return.
1540 * If this occurs *before* the EOB characters, then it's a
1541 * valid NUL; if not, then we've hit the end of the buffer.
1542 */
1543 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1544 /* This was really a NUL. */
1545 *(yy_c_buf_p) = '\0';
1547 else
1548 { /* need more input */
1549 int offset = (yy_c_buf_p) - (yytext_ptr);
1550 ++(yy_c_buf_p);
1552 switch ( yy_get_next_buffer( ) )
1553 {
1554 case EOB_ACT_LAST_MATCH:
1555 /* This happens because yy_g_n_b()
1556 * sees that we've accumulated a
1557 * token and flags that we need to
1558 * try matching the token before
1559 * proceeding. But for input(),
1560 * there's no matching to consider.
1561 * So convert the EOB_ACT_LAST_MATCH
1562 * to EOB_ACT_END_OF_FILE.
1563 */
1565 /* Reset buffer status. */
1566 yyrestart(yyin );
1568 /*FALLTHROUGH*/
1570 case EOB_ACT_END_OF_FILE:
1571 {
1572 if ( yywrap( ) )
1573 return EOF;
1575 if ( ! (yy_did_buffer_switch_on_eof) )
1576 YY_NEW_FILE;
1577 #ifdef __cplusplus
1578 return yyinput();
1579 #else
1580 return input();
1581 #endif
1582 }
1584 case EOB_ACT_CONTINUE_SCAN:
1585 (yy_c_buf_p) = (yytext_ptr) + offset;
1586 break;
1587 }
1588 }
1589 }
1591 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1592 *(yy_c_buf_p) = '\0'; /* preserve yytext */
1593 (yy_hold_char) = *++(yy_c_buf_p);
1595 /* %% [19.0] update BOL and yylineno */
1596 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
1598 return c;
1599 }
1600 /* %if-c-only */
1601 #endif /* ifndef YY_NO_INPUT */
1602 /* %endif */
1604 /** Immediately switch to a different input stream.
1605 * @param input_file A readable stream.
1606 *
1607 * @note This function does not reset the start condition to @c INITIAL .
1608 */
1609 /* %if-c-only */
1610 void yyrestart (FILE * input_file )
1611 /* %endif */
1612 /* %if-c++-only */
1613 /* %endif */
1614 {
1616 if ( ! YY_CURRENT_BUFFER ){
1617 yyensure_buffer_stack ();
1618 YY_CURRENT_BUFFER_LVALUE =
1619 yy_create_buffer(yyin,YY_BUF_SIZE );
1620 }
1622 yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1623 yy_load_buffer_state( );
1624 }
1626 /** Switch to a different input buffer.
1627 * @param new_buffer The new input buffer.
1628 *
1629 */
1630 /* %if-c-only */
1631 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1632 /* %endif */
1633 /* %if-c++-only */
1634 /* %endif */
1635 {
1637 /* TODO. We should be able to replace this entire function body
1638 * with
1639 * yypop_buffer_state();
1640 * yypush_buffer_state(new_buffer);
1641 */
1642 yyensure_buffer_stack ();
1643 if ( YY_CURRENT_BUFFER == new_buffer )
1644 return;
1646 if ( YY_CURRENT_BUFFER )
1647 {
1648 /* Flush out information for old buffer. */
1649 *(yy_c_buf_p) = (yy_hold_char);
1650 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1651 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1652 }
1654 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1655 yy_load_buffer_state( );
1657 /* We don't actually know whether we did this switch during
1658 * EOF (yywrap()) processing, but the only time this flag
1659 * is looked at is after yywrap() is called, so it's safe
1660 * to go ahead and always set it.
1661 */
1662 (yy_did_buffer_switch_on_eof) = 1;
1663 }
1665 /* %if-c-only */
1666 static void yy_load_buffer_state (void)
1667 /* %endif */
1668 /* %if-c++-only */
1669 /* %endif */
1670 {
1671 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1672 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1673 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1674 (yy_hold_char) = *(yy_c_buf_p);
1675 }
1677 /** Allocate and initialize an input buffer state.
1678 * @param file A readable stream.
1679 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1680 *
1681 * @return the allocated buffer state.
1682 */
1683 /* %if-c-only */
1684 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1685 /* %endif */
1686 /* %if-c++-only */
1687 /* %endif */
1688 {
1689 YY_BUFFER_STATE b;
1691 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1692 if ( ! b )
1693 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1695 b->yy_buf_size = size;
1697 /* yy_ch_buf has to be 2 characters longer than the size given because
1698 * we need to put in 2 end-of-buffer characters.
1699 */
1700 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 );
1701 if ( ! b->yy_ch_buf )
1702 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1704 b->yy_is_our_buffer = 1;
1706 yy_init_buffer(b,file );
1708 return b;
1709 }
1711 /** Destroy the buffer.
1712 * @param b a buffer created with yy_create_buffer()
1713 *
1714 */
1715 /* %if-c-only */
1716 void yy_delete_buffer (YY_BUFFER_STATE b )
1717 /* %endif */
1718 /* %if-c++-only */
1719 /* %endif */
1720 {
1722 if ( ! b )
1723 return;
1725 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1726 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1728 if ( b->yy_is_our_buffer )
1729 yyfree((void *) b->yy_ch_buf );
1731 yyfree((void *) b );
1732 }
1734 /* %if-c-only */
1736 #ifndef __cplusplus
1737 extern int isatty (int );
1738 #endif /* __cplusplus */
1740 /* %endif */
1742 /* %if-c++-only */
1743 /* %endif */
1745 /* Initializes or reinitializes a buffer.
1746 * This function is sometimes called more than once on the same buffer,
1747 * such as during a yyrestart() or at EOF.
1748 */
1749 /* %if-c-only */
1750 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1751 /* %endif */
1752 /* %if-c++-only */
1753 /* %endif */
1755 {
1756 int oerrno = errno;
1758 yy_flush_buffer(b );
1760 b->yy_input_file = file;
1761 b->yy_fill_buffer = 1;
1763 /* If b is the current buffer, then yy_init_buffer was _probably_
1764 * called from yyrestart() or through yy_get_next_buffer.
1765 * In that case, we don't want to reset the lineno or column.
1766 */
1767 if (b != YY_CURRENT_BUFFER){
1768 b->yy_bs_lineno = 1;
1769 b->yy_bs_column = 0;
1770 }
1772 /* %if-c-only */
1774 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1776 /* %endif */
1777 /* %if-c++-only */
1778 /* %endif */
1779 errno = oerrno;
1780 }
1782 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1783 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1784 *
1785 */
1786 /* %if-c-only */
1787 void yy_flush_buffer (YY_BUFFER_STATE b )
1788 /* %endif */
1789 /* %if-c++-only */
1790 /* %endif */
1791 {
1792 if ( ! b )
1793 return;
1795 b->yy_n_chars = 0;
1797 /* We always need two end-of-buffer characters. The first causes
1798 * a transition to the end-of-buffer state. The second causes
1799 * a jam in that state.
1800 */
1801 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1802 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1804 b->yy_buf_pos = &b->yy_ch_buf[0];
1806 b->yy_at_bol = 1;
1807 b->yy_buffer_status = YY_BUFFER_NEW;
1809 if ( b == YY_CURRENT_BUFFER )
1810 yy_load_buffer_state( );
1811 }
1813 /* %if-c-or-c++ */
1814 /** Pushes the new state onto the stack. The new state becomes
1815 * the current state. This function will allocate the stack
1816 * if necessary.
1817 * @param new_buffer The new state.
1818 *
1819 */
1820 /* %if-c-only */
1821 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1822 /* %endif */
1823 /* %if-c++-only */
1824 /* %endif */
1825 {
1826 if (new_buffer == NULL)
1827 return;
1829 yyensure_buffer_stack();
1831 /* This block is copied from yy_switch_to_buffer. */
1832 if ( YY_CURRENT_BUFFER )
1833 {
1834 /* Flush out information for old buffer. */
1835 *(yy_c_buf_p) = (yy_hold_char);
1836 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1837 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1838 }
1840 /* Only push if top exists. Otherwise, replace top. */
1841 if (YY_CURRENT_BUFFER)
1842 (yy_buffer_stack_top)++;
1843 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1845 /* copied from yy_switch_to_buffer. */
1846 yy_load_buffer_state( );
1847 (yy_did_buffer_switch_on_eof) = 1;
1848 }
1849 /* %endif */
1851 /* %if-c-or-c++ */
1852 /** Removes and deletes the top of the stack, if present.
1853 * The next element becomes the new top.
1854 *
1855 */
1856 /* %if-c-only */
1857 void yypop_buffer_state (void)
1858 /* %endif */
1859 /* %if-c++-only */
1860 /* %endif */
1861 {
1862 if (!YY_CURRENT_BUFFER)
1863 return;
1865 yy_delete_buffer(YY_CURRENT_BUFFER );
1866 YY_CURRENT_BUFFER_LVALUE = NULL;
1867 if ((yy_buffer_stack_top) > 0)
1868 --(yy_buffer_stack_top);
1870 if (YY_CURRENT_BUFFER) {
1871 yy_load_buffer_state( );
1872 (yy_did_buffer_switch_on_eof) = 1;
1873 }
1874 }
1875 /* %endif */
1877 /* %if-c-or-c++ */
1878 /* Allocates the stack if it does not exist.
1879 * Guarantees space for at least one push.
1880 */
1881 /* %if-c-only */
1882 static void yyensure_buffer_stack (void)
1883 /* %endif */
1884 /* %if-c++-only */
1885 /* %endif */
1886 {
1887 int num_to_alloc;
1889 if (!(yy_buffer_stack)) {
1891 /* First allocation is just for 2 elements, since we don't know if this
1892 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1893 * immediate realloc on the next call.
1894 */
1895 num_to_alloc = 1;
1896 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1897 (num_to_alloc * sizeof(struct yy_buffer_state*)
1898 );
1899 if ( ! (yy_buffer_stack) )
1900 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1902 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1904 (yy_buffer_stack_max) = num_to_alloc;
1905 (yy_buffer_stack_top) = 0;
1906 return;
1907 }
1909 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1911 /* Increase the buffer to prepare for a possible push. */
1912 int grow_size = 8 /* arbitrary grow size */;
1914 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1915 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1916 ((yy_buffer_stack),
1917 num_to_alloc * sizeof(struct yy_buffer_state*)
1918 );
1919 if ( ! (yy_buffer_stack) )
1920 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1922 /* zero only the new slots.*/
1923 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1924 (yy_buffer_stack_max) = num_to_alloc;
1925 }
1926 }
1927 /* %endif */
1929 /* %if-c-only */
1930 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1931 * @param base the character buffer
1932 * @param size the size in bytes of the character buffer
1933 *
1934 * @return the newly allocated buffer state object.
1935 */
1936 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
1937 {
1938 YY_BUFFER_STATE b;
1940 if ( size < 2 ||
1941 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1942 base[size-1] != YY_END_OF_BUFFER_CHAR )
1943 /* They forgot to leave room for the EOB's. */
1944 return 0;
1946 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1947 if ( ! b )
1948 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1950 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1951 b->yy_buf_pos = b->yy_ch_buf = base;
1952 b->yy_is_our_buffer = 0;
1953 b->yy_input_file = 0;
1954 b->yy_n_chars = b->yy_buf_size;
1955 b->yy_is_interactive = 0;
1956 b->yy_at_bol = 1;
1957 b->yy_fill_buffer = 0;
1958 b->yy_buffer_status = YY_BUFFER_NEW;
1960 yy_switch_to_buffer(b );
1962 return b;
1963 }
1964 /* %endif */
1966 /* %if-c-only */
1967 /** Setup the input buffer state to scan a string. The next call to yylex() will
1968 * scan from a @e copy of @a str.
1969 * @param yystr a NUL-terminated string to scan
1970 *
1971 * @return the newly allocated buffer state object.
1972 * @note If you want to scan bytes that may contain NUL values, then use
1973 * yy_scan_bytes() instead.
1974 */
1975 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
1976 {
1978 return yy_scan_bytes(yystr,strlen(yystr) );
1979 }
1980 /* %endif */
1982 /* %if-c-only */
1983 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1984 * scan from a @e copy of @a bytes.
1985 * @param bytes the byte buffer to scan
1986 * @param len the number of bytes in the buffer pointed to by @a bytes.
1987 *
1988 * @return the newly allocated buffer state object.
1989 */
1990 YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len )
1991 {
1992 YY_BUFFER_STATE b;
1993 char *buf;
1994 yy_size_t n;
1995 int i;
1997 /* Get memory for full buffer, including space for trailing EOB's. */
1998 n = _yybytes_len + 2;
1999 buf = (char *) yyalloc(n );
2000 if ( ! buf )
2001 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2003 for ( i = 0; i < _yybytes_len; ++i )
2004 buf[i] = yybytes[i];
2006 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2008 b = yy_scan_buffer(buf,n );
2009 if ( ! b )
2010 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2012 /* It's okay to grow etc. this buffer, and we should throw it
2013 * away when we're done.
2014 */
2015 b->yy_is_our_buffer = 1;
2017 return b;
2018 }
2019 /* %endif */
2021 #ifndef YY_EXIT_FAILURE
2022 #define YY_EXIT_FAILURE 2
2023 #endif
2025 /* %if-c-only */
2026 static void yy_fatal_error (yyconst char* msg )
2027 {
2028 (void) fprintf( stderr, "%s\n", msg );
2029 exit( YY_EXIT_FAILURE );
2030 }
2031 /* %endif */
2032 /* %if-c++-only */
2033 /* %endif */
2035 /* Redefine yyless() so it works in section 3 code. */
2037 #undef yyless
2038 #define yyless(n) \
2039 do \
2040 { \
2041 /* Undo effects of setting up yytext. */ \
2042 int yyless_macro_arg = (n); \
2043 YY_LESS_LINENO(yyless_macro_arg);\
2044 yytext[yyleng] = (yy_hold_char); \
2045 (yy_c_buf_p) = yytext + yyless_macro_arg; \
2046 (yy_hold_char) = *(yy_c_buf_p); \
2047 *(yy_c_buf_p) = '\0'; \
2048 yyleng = yyless_macro_arg; \
2049 } \
2050 while ( 0 )
2052 /* Accessor methods (get/set functions) to struct members. */
2054 /* %if-c-only */
2055 /* %if-reentrant */
2056 /* %endif */
2058 /** Get the current line number.
2059 *
2060 */
2061 int yyget_lineno (void)
2062 {
2064 return yylineno;
2065 }
2067 /** Get the input stream.
2068 *
2069 */
2070 FILE *yyget_in (void)
2071 {
2072 return yyin;
2073 }
2075 /** Get the output stream.
2076 *
2077 */
2078 FILE *yyget_out (void)
2079 {
2080 return yyout;
2081 }
2083 /** Get the length of the current token.
2084 *
2085 */
2086 int yyget_leng (void)
2087 {
2088 return yyleng;
2089 }
2091 /** Get the current token.
2092 *
2093 */
2095 char *yyget_text (void)
2096 {
2097 return yytext;
2098 }
2100 /* %if-reentrant */
2101 /* %endif */
2103 /** Set the current line number.
2104 * @param line_number
2105 *
2106 */
2107 void yyset_lineno (int line_number )
2108 {
2110 yylineno = line_number;
2111 }
2113 /** Set the input stream. This does not discard the current
2114 * input buffer.
2115 * @param in_str A readable stream.
2116 *
2117 * @see yy_switch_to_buffer
2118 */
2119 void yyset_in (FILE * in_str )
2120 {
2121 yyin = in_str ;
2122 }
2124 void yyset_out (FILE * out_str )
2125 {
2126 yyout = out_str ;
2127 }
2129 int yyget_debug (void)
2130 {
2131 return yy_flex_debug;
2132 }
2134 void yyset_debug (int bdebug )
2135 {
2136 yy_flex_debug = bdebug ;
2137 }
2139 /* %endif */
2141 /* %if-reentrant */
2142 /* %if-bison-bridge */
2143 /* %endif */
2144 /* %endif if-c-only */
2146 /* %if-c-only */
2147 static int yy_init_globals (void)
2148 {
2149 /* Initialization is the same as for the non-reentrant scanner.
2150 * This function is called from yylex_destroy(), so don't allocate here.
2151 */
2153 (yy_buffer_stack) = 0;
2154 (yy_buffer_stack_top) = 0;
2155 (yy_buffer_stack_max) = 0;
2156 (yy_c_buf_p) = (char *) 0;
2157 (yy_init) = 0;
2158 (yy_start) = 0;
2160 /* Defined in main.c */
2161 #ifdef YY_STDINIT
2162 yyin = stdin;
2163 yyout = stdout;
2164 #else
2165 yyin = (FILE *) 0;
2166 yyout = (FILE *) 0;
2167 #endif
2169 /* For future reference: Set errno on error, since we are called by
2170 * yylex_init()
2171 */
2172 return 0;
2173 }
2174 /* %endif */
2176 /* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */
2177 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2178 int yylex_destroy (void)
2179 {
2181 /* Pop the buffer stack, destroying each element. */
2182 while(YY_CURRENT_BUFFER){
2183 yy_delete_buffer(YY_CURRENT_BUFFER );
2184 YY_CURRENT_BUFFER_LVALUE = NULL;
2185 yypop_buffer_state();
2186 }
2188 /* Destroy the stack itself. */
2189 yyfree((yy_buffer_stack) );
2190 (yy_buffer_stack) = NULL;
2192 /* Reset the globals. This is important in a non-reentrant scanner so the next time
2193 * yylex() is called, initialization will occur. */
2194 yy_init_globals( );
2196 /* %if-reentrant */
2197 /* %endif */
2198 return 0;
2199 }
2200 /* %endif */
2202 /*
2203 * Internal utility routines.
2204 */
2206 #ifndef yytext_ptr
2207 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2208 {
2209 register int i;
2210 for ( i = 0; i < n; ++i )
2211 s1[i] = s2[i];
2212 }
2213 #endif
2215 #ifdef YY_NEED_STRLEN
2216 static int yy_flex_strlen (yyconst char * s )
2217 {
2218 register int n;
2219 for ( n = 0; s[n]; ++n )
2220 ;
2222 return n;
2223 }
2224 #endif
2226 void *yyalloc (yy_size_t size )
2227 {
2228 return (void *) malloc( size );
2229 }
2231 void *yyrealloc (void * ptr, yy_size_t size )
2232 {
2233 /* The cast to (char *) in the following accommodates both
2234 * implementations that use char* generic pointers, and those
2235 * that use void* generic pointers. It works with the latter
2236 * because both ANSI C and C++ allow castless assignment from
2237 * any pointer type to void*, and deal with argument conversions
2238 * as though doing an assignment.
2239 */
2240 return (void *) realloc( (char *) ptr, size );
2241 }
2243 void yyfree (void * ptr )
2244 {
2245 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2246 }
2248 /* %if-tables-serialization definitions */
2249 /* %define-yytables The name for this specific scanner's tables. */
2250 #define YYTABLES_NAME "yytables"
2251 /* %endif */
2253 /* %ok-for-header */
2255 #line 97 "scripts/genksyms/lex.l"
2259 /* Bring in the keyword recognizer. */
2261 #include "keywords.c"
2264 /* Macros to append to our phrase collection list. */
2266 #define _APP(T,L) do { \
2267 cur_node = next_node; \
2268 next_node = xmalloc(sizeof(*next_node)); \
2269 next_node->next = cur_node; \
2270 cur_node->string = memcpy(xmalloc(L+1), T, L+1); \
2271 cur_node->tag = SYM_NORMAL; \
2272 } while (0)
2274 #define APP _APP(yytext, yyleng)
2277 /* The second stage lexer. Here we incorporate knowledge of the state
2278 of the parser to tailor the tokens that are returned. */
2280 int
2281 yylex(void)
2282 {
2283 static enum {
2284 ST_NOTSTARTED, ST_NORMAL, ST_ATTRIBUTE, ST_ASM, ST_BRACKET, ST_BRACE,
2285 ST_EXPRESSION, ST_TABLE_1, ST_TABLE_2, ST_TABLE_3, ST_TABLE_4,
2286 ST_TABLE_5, ST_TABLE_6
2287 } lexstate = ST_NOTSTARTED;
2289 static int suppress_type_lookup, dont_want_brace_phrase;
2290 static struct string_list *next_node;
2292 int token, count = 0;
2293 struct string_list *cur_node;
2295 if (lexstate == ST_NOTSTARTED)
2296 {
2297 BEGIN(V2_TOKENS);
2298 next_node = xmalloc(sizeof(*next_node));
2299 next_node->next = NULL;
2300 lexstate = ST_NORMAL;
2301 }
2303 repeat:
2304 token = yylex1();
2306 if (token == 0)
2307 return 0;
2308 else if (token == FILENAME)
2309 {
2310 char *file, *e;
2312 /* Save the filename and line number for later error messages. */
2314 if (cur_filename)
2315 free(cur_filename);
2317 file = strchr(yytext, '\"')+1;
2318 e = strchr(file, '\"');
2319 *e = '\0';
2320 cur_filename = memcpy(xmalloc(e-file+1), file, e-file+1);
2321 cur_line = atoi(yytext+2);
2323 goto repeat;
2324 }
2326 switch (lexstate)
2327 {
2328 case ST_NORMAL:
2329 switch (token)
2330 {
2331 case IDENT:
2332 APP;
2333 {
2334 const struct resword *r = is_reserved_word(yytext, yyleng);
2335 if (r)
2336 {
2337 switch (token = r->token)
2338 {
2339 case ATTRIBUTE_KEYW:
2340 lexstate = ST_ATTRIBUTE;
2341 count = 0;
2342 goto repeat;
2343 case ASM_KEYW:
2344 lexstate = ST_ASM;
2345 count = 0;
2346 goto repeat;
2348 case STRUCT_KEYW:
2349 case UNION_KEYW:
2350 dont_want_brace_phrase = 3;
2351 case ENUM_KEYW:
2352 suppress_type_lookup = 2;
2353 goto fini;
2355 case EXPORT_SYMBOL_KEYW:
2356 goto fini;
2357 }
2358 }
2359 if (!suppress_type_lookup)
2360 {
2361 struct symbol *sym = find_symbol(yytext, SYM_TYPEDEF);
2362 if (sym && sym->type == SYM_TYPEDEF)
2363 token = TYPE;
2364 }
2365 }
2366 break;
2368 case '[':
2369 APP;
2370 lexstate = ST_BRACKET;
2371 count = 1;
2372 goto repeat;
2374 case '{':
2375 APP;
2376 if (dont_want_brace_phrase)
2377 break;
2378 lexstate = ST_BRACE;
2379 count = 1;
2380 goto repeat;
2382 case '=': case ':':
2383 APP;
2384 lexstate = ST_EXPRESSION;
2385 break;
2387 case DOTS:
2388 default:
2389 APP;
2390 break;
2391 }
2392 break;
2394 case ST_ATTRIBUTE:
2395 APP;
2396 switch (token)
2397 {
2398 case '(':
2399 ++count;
2400 goto repeat;
2401 case ')':
2402 if (--count == 0)
2403 {
2404 lexstate = ST_NORMAL;
2405 token = ATTRIBUTE_PHRASE;
2406 break;
2407 }
2408 goto repeat;
2409 default:
2410 goto repeat;
2411 }
2412 break;
2414 case ST_ASM:
2415 APP;
2416 switch (token)
2417 {
2418 case '(':
2419 ++count;
2420 goto repeat;
2421 case ')':
2422 if (--count == 0)
2423 {
2424 lexstate = ST_NORMAL;
2425 token = ASM_PHRASE;
2426 break;
2427 }
2428 goto repeat;
2429 default:
2430 goto repeat;
2431 }
2432 break;
2434 case ST_BRACKET:
2435 APP;
2436 switch (token)
2437 {
2438 case '[':
2439 ++count;
2440 goto repeat;
2441 case ']':
2442 if (--count == 0)
2443 {
2444 lexstate = ST_NORMAL;
2445 token = BRACKET_PHRASE;
2446 break;
2447 }
2448 goto repeat;
2449 default:
2450 goto repeat;
2451 }
2452 break;
2454 case ST_BRACE:
2455 APP;
2456 switch (token)
2457 {
2458 case '{':
2459 ++count;
2460 goto repeat;
2461 case '}':
2462 if (--count == 0)
2463 {
2464 lexstate = ST_NORMAL;
2465 token = BRACE_PHRASE;
2466 break;
2467 }
2468 goto repeat;
2469 default:
2470 goto repeat;
2471 }
2472 break;
2474 case ST_EXPRESSION:
2475 switch (token)
2476 {
2477 case '(': case '[': case '{':
2478 ++count;
2479 APP;
2480 goto repeat;
2481 case ')': case ']': case '}':
2482 --count;
2483 APP;
2484 goto repeat;
2485 case ',': case ';':
2486 if (count == 0)
2487 {
2488 /* Put back the token we just read so's we can find it again
2489 after registering the expression. */
2490 unput(token);
2492 lexstate = ST_NORMAL;
2493 token = EXPRESSION_PHRASE;
2494 break;
2495 }
2496 APP;
2497 goto repeat;
2498 default:
2499 APP;
2500 goto repeat;
2501 }
2502 break;
2504 case ST_TABLE_1:
2505 goto repeat;
2507 case ST_TABLE_2:
2508 if (token == IDENT && yyleng == 1 && yytext[0] == 'X')
2509 {
2510 token = EXPORT_SYMBOL_KEYW;
2511 lexstate = ST_TABLE_5;
2512 APP;
2513 break;
2514 }
2515 lexstate = ST_TABLE_6;
2516 /* FALLTHRU */
2518 case ST_TABLE_6:
2519 switch (token)
2520 {
2521 case '{': case '[': case '(':
2522 ++count;
2523 break;
2524 case '}': case ']': case ')':
2525 --count;
2526 break;
2527 case ',':
2528 if (count == 0)
2529 lexstate = ST_TABLE_2;
2530 break;
2531 };
2532 goto repeat;
2534 case ST_TABLE_3:
2535 goto repeat;
2537 case ST_TABLE_4:
2538 if (token == ';')
2539 lexstate = ST_NORMAL;
2540 goto repeat;
2542 case ST_TABLE_5:
2543 switch (token)
2544 {
2545 case ',':
2546 token = ';';
2547 lexstate = ST_TABLE_2;
2548 APP;
2549 break;
2550 default:
2551 APP;
2552 break;
2553 }
2554 break;
2556 default:
2557 exit(1);
2558 }
2559 fini:
2561 if (suppress_type_lookup > 0)
2562 --suppress_type_lookup;
2563 if (dont_want_brace_phrase > 0)
2564 --dont_want_brace_phrase;
2566 yylval = &next_node->next;
2568 return token;
2569 }
2570 /* A Bison parser, made by GNU Bison 2.3. */
2572 /* Skeleton interface for Bison's Yacc-like parsers in C
2574 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
2575 Free Software Foundation, Inc.
2577 This program is free software; you can redistribute it and/or modify
2578 it under the terms of the GNU General Public License as published by
2579 the Free Software Foundation; either version 2, or (at your option)
2580 any later version.
2582 This program is distributed in the hope that it will be useful,
2583 but WITHOUT ANY WARRANTY; without even the implied warranty of
2584 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2585 GNU General Public License for more details.
2587 You should have received a copy of the GNU General Public License
2588 along with this program; if not, write to the Free Software
2589 Foundation, Inc., 51 Franklin Street, Fifth Floor,
2590 Boston, MA 02110-1301, USA. */
2592 /* As a special exception, you may create a larger work that contains
2593 part or all of the Bison parser skeleton and distribute that work
2594 under terms of your choice, so long as that work isn't itself a
2595 parser generator using the skeleton or a modified version thereof
2596 as a parser skeleton. Alternatively, if you modify or redistribute
2597 the parser skeleton itself, you may (at your option) remove this
2598 special exception, which will cause the skeleton and the resulting
2599 Bison output files to be licensed under the GNU General Public
2600 License without this special exception.
2602 This special exception was added by the Free Software Foundation in
2603 version 2.2 of Bison. */
2605 /* Tokens. */
2606 #ifndef YYTOKENTYPE
2607 # define YYTOKENTYPE
2608 /* Put the tokens into the symbol table, so that GDB and other debuggers
2609 know about them. */
2610 enum yytokentype {
2611 ASM_KEYW = 258,
2612 ATTRIBUTE_KEYW = 259,
2613 AUTO_KEYW = 260,
2614 BOOL_KEYW = 261,
2615 CHAR_KEYW = 262,
2616 CONST_KEYW = 263,
2617 DOUBLE_KEYW = 264,
2618 ENUM_KEYW = 265,
2619 EXTERN_KEYW = 266,
2620 EXTENSION_KEYW = 267,
2621 FLOAT_KEYW = 268,
2622 INLINE_KEYW = 269,
2623 INT_KEYW = 270,
2624 LONG_KEYW = 271,
2625 REGISTER_KEYW = 272,
2626 RESTRICT_KEYW = 273,
2627 SHORT_KEYW = 274,
2628 SIGNED_KEYW = 275,
2629 STATIC_KEYW = 276,
2630 STRUCT_KEYW = 277,
2631 TYPEDEF_KEYW = 278,
2632 UNION_KEYW = 279,
2633 UNSIGNED_KEYW = 280,
2634 VOID_KEYW = 281,
2635 VOLATILE_KEYW = 282,
2636 TYPEOF_KEYW = 283,
2637 EXPORT_SYMBOL_KEYW = 284,
2638 ASM_PHRASE = 285,
2639 ATTRIBUTE_PHRASE = 286,
2640 BRACE_PHRASE = 287,
2641 BRACKET_PHRASE = 288,
2642 EXPRESSION_PHRASE = 289,
2643 CHAR = 290,
2644 DOTS = 291,
2645 IDENT = 292,
2646 INT = 293,
2647 REAL = 294,
2648 STRING = 295,
2649 TYPE = 296,
2650 OTHER = 297,
2651 FILENAME = 298
2652 };
2653 #endif
2654 /* Tokens. */
2655 #define ASM_KEYW 258
2656 #define ATTRIBUTE_KEYW 259
2657 #define AUTO_KEYW 260
2658 #define BOOL_KEYW 261
2659 #define CHAR_KEYW 262
2660 #define CONST_KEYW 263
2661 #define DOUBLE_KEYW 264
2662 #define ENUM_KEYW 265
2663 #define EXTERN_KEYW 266
2664 #define EXTENSION_KEYW 267
2665 #define FLOAT_KEYW 268
2666 #define INLINE_KEYW 269
2667 #define INT_KEYW 270
2668 #define LONG_KEYW 271
2669 #define REGISTER_KEYW 272
2670 #define RESTRICT_KEYW 273
2671 #define SHORT_KEYW 274
2672 #define SIGNED_KEYW 275
2673 #define STATIC_KEYW 276
2674 #define STRUCT_KEYW 277
2675 #define TYPEDEF_KEYW 278
2676 #define UNION_KEYW 279
2677 #define UNSIGNED_KEYW 280
2678 #define VOID_KEYW 281
2679 #define VOLATILE_KEYW 282
2680 #define TYPEOF_KEYW 283
2681 #define EXPORT_SYMBOL_KEYW 284
2682 #define ASM_PHRASE 285
2683 #define ATTRIBUTE_PHRASE 286
2684 #define BRACE_PHRASE 287
2685 #define BRACKET_PHRASE 288
2686 #define EXPRESSION_PHRASE 289
2687 #define CHAR 290
2688 #define DOTS 291
2689 #define IDENT 292
2690 #define INT 293
2691 #define REAL 294
2692 #define STRING 295
2693 #define TYPE 296
2694 #define OTHER 297
2695 #define FILENAME 298
2700 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
2701 typedef int YYSTYPE;
2702 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
2703 # define YYSTYPE_IS_DECLARED 1
2704 # define YYSTYPE_IS_TRIVIAL 1
2705 #endif
2707 extern YYSTYPE yylval;