1 #line 2 "scan-gram.c"
2
3 #line 4 "scan-gram.c"
4
5 #define YY_INT_ALIGNED short int
6
7 /* A lexical scanner generated by flex */
8
9 /* %not-for-header */
10
11 /* %if-c-only */
12 /* %if-not-reentrant */
13 #define yy_create_buffer gram__create_buffer
14 #define yy_delete_buffer gram__delete_buffer
15 #define yy_flex_debug gram__flex_debug
16 #define yy_init_buffer gram__init_buffer
17 #define yy_flush_buffer gram__flush_buffer
18 #define yy_load_buffer_state gram__load_buffer_state
19 #define yy_switch_to_buffer gram__switch_to_buffer
20 #define yyin gram_in
21 #define yyleng gram_leng
22 #define yylex gram_lex
23 #define yylineno gram_lineno
24 #define yyout gram_out
25 #define yyrestart gram_restart
26 #define yytext gram_text
27 #define yywrap gram_wrap
28 #define yyalloc gram_alloc
29 #define yyrealloc gram_realloc
30 #define yyfree gram_free
31
32 /* %endif */
33 /* %endif */
34 /* %ok-for-header */
35
36 #define FLEX_SCANNER
37 #define YY_FLEX_MAJOR_VERSION 2
38 #define YY_FLEX_MINOR_VERSION 5
39 #define YY_FLEX_SUBMINOR_VERSION 37
40 #if YY_FLEX_SUBMINOR_VERSION > 0
41 #define FLEX_BETA
42 #endif
43
44 /* %if-c++-only */
45 /* %endif */
46
47 /* %if-c-only */
48
49 /* %endif */
50
51 /* %if-c-only */
52
53 /* %endif */
54
55 /* First, we deal with platform-specific or compiler-specific issues. */
56
57 /* begin standard C headers. */
58 /* %if-c-only */
59 #include <stdio.h>
60 #include <string.h>
61 #include <errno.h>
62 #include <stdlib.h>
63 /* %endif */
64
65 /* %if-tables-serialization */
66 /* %endif */
67 /* end standard C headers. */
68
69 /* %if-c-or-c++ */
70 /* flex integer type definitions */
71
72 #ifndef FLEXINT_H
73 #define FLEXINT_H
74
75 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
76
77 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
78
79 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
80 * if you want the limit (max/min) macros for int types.
81 */
82 #ifndef __STDC_LIMIT_MACROS
83 #define __STDC_LIMIT_MACROS 1
84 #endif
85
86 #include <inttypes.h>
87 typedef int8_t flex_int8_t;
88 typedef uint8_t flex_uint8_t;
89 typedef int16_t flex_int16_t;
90 typedef uint16_t flex_uint16_t;
91 typedef int32_t flex_int32_t;
92 typedef uint32_t flex_uint32_t;
93 #else
94 typedef signed char flex_int8_t;
95 typedef short int flex_int16_t;
96 typedef int flex_int32_t;
97 typedef unsigned char flex_uint8_t;
98 typedef unsigned short int flex_uint16_t;
99 typedef unsigned int flex_uint32_t;
100
101 /* Limits of integral types. */
102 #ifndef INT8_MIN
103 #define INT8_MIN (-128)
104 #endif
105 #ifndef INT16_MIN
106 #define INT16_MIN (-32767-1)
107 #endif
108 #ifndef INT32_MIN
109 #define INT32_MIN (-2147483647-1)
110 #endif
111 #ifndef INT8_MAX
112 #define INT8_MAX (127)
113 #endif
114 #ifndef INT16_MAX
115 #define INT16_MAX (32767)
116 #endif
117 #ifndef INT32_MAX
118 #define INT32_MAX (2147483647)
119 #endif
120 #ifndef UINT8_MAX
121 #define UINT8_MAX (255U)
122 #endif
123 #ifndef UINT16_MAX
124 #define UINT16_MAX (65535U)
125 #endif
126 #ifndef UINT32_MAX
127 #define UINT32_MAX (4294967295U)
128 #endif
129
130 #endif /* ! C99 */
131
132 #endif /* ! FLEXINT_H */
133
134 /* %endif */
135
136 /* %if-c++-only */
137 /* %endif */
138
139 #ifdef __cplusplus
140
141 /* The "const" storage-class-modifier is valid. */
142 #define YY_USE_CONST
143
144 #else /* ! __cplusplus */
145
146 /* C99 requires __STDC__ to be defined as 1. */
147 #if defined (__STDC__)
148
149 #define YY_USE_CONST
150
151 #endif /* defined (__STDC__) */
152 #endif /* ! __cplusplus */
153
154 #ifdef YY_USE_CONST
155 #define yyconst const
156 #else
157 #define yyconst
158 #endif
159
160 /* %not-for-header */
161
162 /* Returned upon end-of-file. */
163 #define YY_NULL 0
164 /* %ok-for-header */
165
166 /* %not-for-header */
167
168 /* Promotes a possibly negative, possibly signed char to an unsigned
169 * integer for use as an array index. If the signed char is negative,
170 * we want to instead treat it as an 8-bit unsigned char, hence the
171 * double cast.
172 */
173 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
174 /* %ok-for-header */
175
176 /* %if-reentrant */
177 /* %endif */
178
179 /* %if-not-reentrant */
180
181 /* %endif */
182
183 /* Enter a start condition. This macro really ought to take a parameter,
184 * but we do it the disgusting crufty way forced on us by the ()-less
185 * definition of BEGIN.
186 */
187 #define BEGIN (yy_start) = 1 + 2 *
188
189 /* Translate the current start state into a value that can be later handed
190 * to BEGIN to return to the state. The YYSTATE alias is for lex
191 * compatibility.
192 */
193 #define YY_START (((yy_start) - 1) / 2)
194 #define YYSTATE YY_START
195
196 /* Action number for EOF rule of a given start state. */
197 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
198
199 /* Special action meaning "start processing a new file". */
200 #define YY_NEW_FILE gram_restart(gram_in )
201
202 #define YY_END_OF_BUFFER_CHAR 0
203
204 /* Size of default input buffer. */
205 #ifndef YY_BUF_SIZE
206 #define YY_BUF_SIZE 16384
207 #endif
208
209 /* The state buf must be large enough to hold one state per character in the main buffer.
210 */
211 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
212
213 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
214 #define YY_TYPEDEF_YY_BUFFER_STATE
215 typedef struct yy_buffer_state *YY_BUFFER_STATE;
216 #endif
217
218 #ifndef YY_TYPEDEF_YY_SIZE_T
219 #define YY_TYPEDEF_YY_SIZE_T
220 typedef size_t yy_size_t;
221 #endif
222
223 /* %if-not-reentrant */
224 extern yy_size_t gram_leng;
225 /* %endif */
226
227 /* %if-c-only */
228 /* %if-not-reentrant */
229 extern FILE *gram_in, *gram_out;
230 /* %endif */
231 /* %endif */
232
233 #define EOB_ACT_CONTINUE_SCAN 0
234 #define EOB_ACT_END_OF_FILE 1
235 #define EOB_ACT_LAST_MATCH 2
236
237 #define YY_LESS_LINENO(n)
238
239 /* Return all but the first "n" matched characters back to the input stream. */
240 #define yyless(n) \
241 do \
242 { \
243 /* Undo effects of setting up gram_text. */ \
244 int yyless_macro_arg = (n); \
245 YY_LESS_LINENO(yyless_macro_arg);\
246 *yy_cp = (yy_hold_char); \
247 YY_RESTORE_YY_MORE_OFFSET \
248 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
249 YY_DO_BEFORE_ACTION; /* set up gram_text again */ \
250 } \
251 while ( 0 )
252
253 #define unput(c) yyunput( c, (yytext_ptr) )
254
255 #ifndef YY_STRUCT_YY_BUFFER_STATE
256 #define YY_STRUCT_YY_BUFFER_STATE
257 struct yy_buffer_state
258 {
259 /* %if-c-only */
260 FILE *yy_input_file;
261 /* %endif */
262
263 /* %if-c++-only */
264 /* %endif */
265
266 char *yy_ch_buf; /* input buffer */
267 char *yy_buf_pos; /* current position in input buffer */
268
269 /* Size of input buffer in bytes, not including room for EOB
270 * characters.
271 */
272 yy_size_t yy_buf_size;
273
274 /* Number of characters read into yy_ch_buf, not including EOB
275 * characters.
276 */
277 yy_size_t yy_n_chars;
278
279 /* Whether we "own" the buffer - i.e., we know we created it,
280 * and can realloc() it to grow it, and should free() it to
281 * delete it.
282 */
283 int yy_is_our_buffer;
284
285 /* Whether this is an "interactive" input source; if so, and
286 * if we're using stdio for input, then we want to use getc()
287 * instead of fread(), to make sure we stop fetching input after
288 * each newline.
289 */
290 int yy_is_interactive;
291
292 /* Whether we're considered to be at the beginning of a line.
293 * If so, '^' rules will be active on the next match, otherwise
294 * not.
295 */
296 int yy_at_bol;
297
298 int yy_bs_lineno; /**< The line count. */
299 int yy_bs_column; /**< The column count. */
300
301 /* Whether to try to fill the input buffer when we reach the
302 * end of it.
303 */
304 int yy_fill_buffer;
305
306 int yy_buffer_status;
307
308 #define YY_BUFFER_NEW 0
309 #define YY_BUFFER_NORMAL 1
310 /* When an EOF's been seen but there's still some text to process
311 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
312 * shouldn't try reading from the input source any more. We might
313 * still have a bunch of tokens to match, though, because of
314 * possible backing-up.
315 *
316 * When we actually see the EOF, we change the status to "new"
317 * (via gram_restart()), so that the user can continue scanning by
318 * just pointing gram_in at a new input file.
319 */
320 #define YY_BUFFER_EOF_PENDING 2
321
322 };
323 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
324
325 /* %if-c-only Standard (non-C++) definition */
326 /* %not-for-header */
327
328 /* %if-not-reentrant */
329
330 /* Stack of input buffers. */
331 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
332 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
333 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
334 /* %endif */
335 /* %ok-for-header */
336
337 /* %endif */
338
339 /* We provide macros for accessing buffer states in case in the
340 * future we want to put the buffer states in a more general
341 * "scanner state".
342 *
343 * Returns the top of the stack, or NULL.
344 */
345 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
346 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
347 : NULL)
348
349 /* Same as previous macro, but useful when we know that the buffer stack is not
350 * NULL or when we need an lvalue. For internal use only.
351 */
352 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
353
354 /* %if-c-only Standard (non-C++) definition */
355
356 /* %if-not-reentrant */
357 /* %not-for-header */
358
359 /* yy_hold_char holds the character lost when gram_text is formed. */
360 static char yy_hold_char;
361 static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
362 yy_size_t gram_leng;
363
364 /* Points to current character in buffer. */
365 static char *yy_c_buf_p = (char *) 0;
366 static int yy_init = 0; /* whether we need to initialize */
367 static int yy_start = 0; /* start state number */
368
369 /* Flag which is used to allow gram_wrap()'s to do buffer switches
370 * instead of setting up a fresh gram_in. A bit of a hack ...
371 */
372 static int yy_did_buffer_switch_on_eof;
373 /* %ok-for-header */
374
375 /* %endif */
376
377 void gram_restart (FILE *input_file );
378 void gram__switch_to_buffer (YY_BUFFER_STATE new_buffer );
379 YY_BUFFER_STATE gram__create_buffer (FILE *file,int size );
380 void gram__delete_buffer (YY_BUFFER_STATE b );
381 void gram__flush_buffer (YY_BUFFER_STATE b );
382 void gram_push_buffer_state (YY_BUFFER_STATE new_buffer );
383 void gram_pop_buffer_state (void );
384
385 static void gram_ensure_buffer_stack (void );
386 static void gram__load_buffer_state (void );
387 static void gram__init_buffer (YY_BUFFER_STATE b,FILE *file );
388
389 #define YY_FLUSH_BUFFER gram__flush_buffer(YY_CURRENT_BUFFER )
390
391 YY_BUFFER_STATE gram__scan_buffer (char *base,yy_size_t size );
392 YY_BUFFER_STATE gram__scan_string (yyconst char *yy_str );
393 YY_BUFFER_STATE gram__scan_bytes (yyconst char *bytes,yy_size_t len );
394
395 /* %endif */
396
397 void *gram_alloc (yy_size_t );
398 void *gram_realloc (void *,yy_size_t );
399 void gram_free (void * );
400
401 #define yy_new_buffer gram__create_buffer
402
403 #define yy_set_interactive(is_interactive) \
404 { \
405 if ( ! YY_CURRENT_BUFFER ){ \
406 gram_ensure_buffer_stack (); \
407 YY_CURRENT_BUFFER_LVALUE = \
408 gram__create_buffer(gram_in,YY_BUF_SIZE ); \
409 } \
410 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
411 }
412
413 #define yy_set_bol(at_bol) \
414 { \
415 if ( ! YY_CURRENT_BUFFER ){\
416 gram_ensure_buffer_stack (); \
417 YY_CURRENT_BUFFER_LVALUE = \
418 gram__create_buffer(gram_in,YY_BUF_SIZE ); \
419 } \
420 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
421 }
422
423 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
424
425 /* %% [1.0] gram_text/gram_in/gram_out/yy_state_type/gram_lineno etc. def's & init go here */
426 /* Begin user sect3 */
427
428 #define gram_wrap() 1
429 #define YY_SKIP_YYWRAP
430
431 #define FLEX_DEBUG
432
433 typedef unsigned char YY_CHAR;
434
435 FILE *gram_in = (FILE *) 0, *gram_out = (FILE *) 0;
436
437 typedef int yy_state_type;
438
439 extern int gram_lineno;
440
441 int gram_lineno = 1;
442
443 extern char *gram_text;
444 #define yytext_ptr gram_text
445
446 /* %if-c-only Standard (non-C++) definition */
447
448 static yy_state_type yy_get_previous_state (void );
449 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
450 static int yy_get_next_buffer (void );
451 static void yy_fatal_error (yyconst char msg[] );
452
453 /* %endif */
454
455 /* Done after the current pattern has been matched and before the
456 * corresponding action - sets up gram_text.
457 */
458 #define YY_DO_BEFORE_ACTION \
459 (yytext_ptr) = yy_bp; \
460 /* %% [2.0] code to fiddle gram_text and gram_leng for yymore() goes here \ */\
461 gram_leng = (size_t) (yy_cp - yy_bp); \
462 (yy_hold_char) = *yy_cp; \
463 *yy_cp = '\0'; \
464 /* %% [3.0] code to copy yytext_ptr to gram_text[] goes here, if %array \ */\
465 (yy_c_buf_p) = yy_cp;
466
467 /* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */
468 #define YY_NUM_RULES 109
469 #define YY_END_OF_BUFFER 110
470 /* This struct is not used in this scanner,
471 but its presence is necessary. */
472 struct yy_trans_info
473 {
474 flex_int32_t yy_verify;
475 flex_int32_t yy_nxt;
476 };
477 static yyconst flex_int16_t yy_accept[482] =
478 { 0,
479 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
480 0, 0, 0, 0, 0, 0, 0, 0, 77, 77,
481 93, 93, 93, 93, 0, 0, 0, 0, 110, 65,
482 2, 2, 59, 65, 58, 65, 1, 54, 65, 55,
483 55, 51, 65, 49, 54, 64, 61, 50, 65, 74,
484 74, 107, 78, 78, 107, 80, 79, 79, 68, 2,
485 1, 68, 67, 66, 68, 108, 99, 107, 98, 107,
486 107, 107, 102, 104, 107, 76, 107, 97, 96, 107,
487 95, 94, 71, 2, 1, 69, 71, 71, 70, 71,
488 72, 2, 1, 72, 72, 65, 0, 63, 48, 48,
489
490 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
491 48, 48, 48, 48, 48, 48, 48, 60, 54, 54,
492 4, 3, 57, 55, 57, 0, 0, 53, 0, 73,
493 92, 90, 81, 92, 83, 84, 85, 86, 87, 88,
494 92, 89, 92, 106, 100, 101, 0, 103, 0, 102,
495 105, 0, 75, 0, 0, 77, 93, 93, 93, 93,
496 71, 69, 48, 48, 48, 48, 48, 48, 48, 48,
497 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
498 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
499 48, 48, 48, 48, 3, 57, 56, 62, 52, 0,
500
501 81, 0, 0, 82, 0, 0, 0, 0, 0, 0,
502 0, 0, 0, 0, 0, 0, 0, 48, 48, 48,
503 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
504 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
505 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
506 48, 48, 48, 0, 81, 0, 0, 48, 7, 48,
507 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
508 48, 22, 48, 48, 48, 48, 48, 48, 48, 48,
509 48, 48, 48, 34, 48, 48, 48, 48, 48, 48,
510 41, 48, 44, 48, 48, 47, 0, 0, 0, 48,
511
512 8, 48, 48, 48, 13, 48, 48, 48, 48, 48,
513 48, 48, 48, 48, 25, 48, 48, 48, 48, 48,
514 31, 48, 48, 48, 48, 48, 38, 48, 40, 42,
515 45, 48, 0, 0, 91, 6, 48, 10, 48, 48,
516 15, 48, 48, 48, 48, 48, 48, 48, 48, 48,
517 48, 48, 48, 32, 48, 48, 48, 48, 48, 48,
518 48, 0, 48, 11, 48, 48, 48, 48, 48, 48,
519 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
520 35, 48, 37, 48, 48, 46, 5, 0, 48, 48,
521 48, 48, 48, 48, 48, 48, 21, 48, 48, 48,
522
523 48, 28, 29, 48, 48, 48, 39, 48, 0, 48,
524 48, 48, 16, 48, 48, 48, 48, 23, 24, 48,
525 48, 48, 48, 48, 48, 0, 0, 48, 12, 48,
526 48, 48, 20, 48, 48, 48, 48, 48, 48, 48,
527 48, 48, 17, 48, 48, 26, 48, 48, 33, 36,
528 43, 9, 48, 48, 48, 48, 48, 14, 48, 48,
529 48, 48, 48, 19, 48, 48, 48, 27, 48, 48,
530 48, 48, 48, 18, 48, 48, 48, 48, 48, 30,
531 0
532 } ;
533
534 static yyconst flex_int32_t yy_ec[256] =
535 { 0,
536 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
537 2, 2, 1, 1, 1, 1, 1, 1, 1, 1,
538 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
539 1, 4, 5, 6, 7, 5, 8, 5, 9, 5,
540 5, 10, 5, 11, 12, 13, 14, 15, 16, 16,
541 16, 16, 16, 16, 16, 17, 17, 18, 19, 20,
542 21, 22, 23, 5, 24, 24, 24, 24, 24, 24,
543 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
544 25, 25, 25, 25, 26, 25, 25, 27, 25, 25,
545 28, 29, 30, 5, 31, 5, 32, 33, 34, 35,
546
547 36, 37, 38, 39, 40, 25, 41, 42, 43, 44,
548 45, 46, 47, 48, 49, 50, 51, 52, 25, 53,
549 54, 25, 55, 56, 57, 5, 1, 1, 1, 1,
550 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
551 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
552 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
553 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
554 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
555 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
556 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
557
558 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
559 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
560 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
561 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
562 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
563 1, 1, 1, 1, 1
564 } ;
565
566 static yyconst flex_int32_t yy_meta[59] =
567 { 0,
568 1, 2, 3, 2, 4, 5, 4, 5, 5, 5,
569 5, 6, 7, 8, 9, 9, 9, 4, 5, 5,
570 5, 5, 4, 9, 10, 10, 10, 11, 4, 12,
571 10, 9, 9, 9, 9, 9, 9, 10, 10, 10,
572 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
573 10, 10, 10, 10, 5, 5, 5, 13
574 } ;
575
576 static yyconst flex_int16_t yy_base[508] =
577 { 0,
578 0, 899, 895, 894, 56, 57, 58, 61, 70, 89,
579 96, 115, 119, 128, 62, 129, 72, 91, 66, 77,
580 138, 143, 80, 142, 185, 896, 150, 155, 902, 0,
581 907, 907, 907, 243, 907, 907, 907, 301, 98, 288,
582 62, 907, 146, 907, 315, 907, 907, 907, 859, 907,
583 886, 907, 907, 907, 368, 907, 907, 907, 907, 907,
584 907, 116, 907, 907, 857, 907, 907, 841, 907, 297,
585 91, 155, 907, 907, 126, 907, 175, 907, 907, 325,
586 907, 907, 0, 907, 0, 0, 307, 907, 907, 855,
587 907, 907, 907, 322, 854, 0, 0, 907, 0, 855,
588
589 849, 114, 117, 853, 850, 847, 303, 854, 302, 838,
590 305, 306, 132, 304, 844, 851, 854, 907, 421, 0,
591 907, 0, 0, 345, 465, 863, 862, 907, 843, 907,
592 907, 907, 165, 0, 907, 907, 907, 907, 907, 907,
593 0, 907, 0, 907, 907, 907, 361, 907, 364, 907,
594 907, 367, 907, 376, 383, 853, 907, 386, 852, 400,
595 0, 0, 0, 0, 836, 844, 359, 830, 829, 830,
596 270, 827, 834, 829, 272, 838, 823, 827, 383, 833,
597 818, 819, 315, 818, 818, 826, 827, 830, 813, 819,
598 813, 818, 809, 822, 0, 0, 0, 907, 907, 811,
599
600 360, 0, 0, 0, 407, 403, 421, 321, 427, 427,
601 434, 343, 438, 450, 455, 458, 378, 822, 817, 801,
602 278, 801, 814, 804, 812, 811, 810, 833, 794, 805,
603 792, 829, 808, 801, 802, 364, 411, 789, 790, 786,
604 800, 789, 796, 780, 791, 787, 780, 784, 790, 789,
605 779, 790, 788, 785, 907, 0, 0, 772, 0, 781,
606 767, 773, 768, 781, 766, 779, 800, 776, 764, 769,
607 757, 0, 761, 756, 769, 433, 768, 763, 753, 765,
608 757, 748, 762, 0, 747, 436, 756, 745, 758, 743,
609 0, 748, 0, 747, 745, 0, 785, 0, 0, 734,
610
611 0, 745, 750, 734, 0, 437, 734, 737, 443, 750,
612 749, 748, 747, 738, 0, 731, 739, 731, 725, 723,
613 0, 722, 759, 734, 723, 720, 0, 717, 0, 453,
614 0, 717, 454, 0, 907, 0, 715, 715, 729, 710,
615 454, 713, 715, 711, 716, 719, 708, 710, 706, 721,
616 716, 706, 714, 0, 703, 700, 715, 710, 700, 694,
617 707, 488, 463, 0, 692, 705, 692, 703, 687, 688,
618 724, 699, 702, 689, 696, 680, 681, 695, 680, 695,
619 0, 678, 0, 681, 692, 0, 907, 717, 676, 676,
620 672, 671, 681, 667, 680, 683, 0, 671, 664, 675,
621
622 669, 0, 0, 667, 661, 659, 0, 674, 700, 657,
623 656, 670, 0, 662, 655, 652, 665, 0, 0, 658,
624 647, 656, 663, 658, 651, 686, 470, 655, 0, 645,
625 626, 623, 0, 611, 603, 465, 598, 595, 588, 599,
626 600, 584, 0, 579, 588, 0, 579, 584, 0, 0,
627 0, 0, 555, 475, 541, 534, 530, 0, 539, 530,
628 537, 519, 528, 0, 533, 526, 521, 0, 527, 524,
629 483, 444, 444, 0, 456, 438, 434, 442, 424, 0,
630 907, 506, 519, 532, 545, 558, 571, 578, 588, 600,
631 613, 626, 634, 641, 648, 658, 666, 454, 406, 389,
632
633 384, 373, 138, 102, 88, 57, 676
634 } ;
635
636 static yyconst flex_int16_t yy_def[508] =
637 { 0,
638 481, 1, 482, 482, 483, 483, 483, 483, 484, 484,
639 483, 483, 483, 483, 483, 483, 483, 483, 483, 483,
640 483, 483, 483, 483, 481, 25, 485, 485, 481, 486,
641 481, 481, 481, 481, 481, 481, 481, 487, 481, 488,
642 488, 481, 489, 481, 487, 481, 481, 481, 486, 481,
643 481, 481, 481, 481, 490, 481, 481, 481, 481, 481,
644 481, 481, 481, 481, 481, 481, 481, 481, 481, 481,
645 481, 481, 481, 481, 481, 481, 481, 481, 481, 491,
646 481, 481, 492, 481, 492, 493, 481, 481, 481, 492,
647 481, 481, 481, 481, 481, 486, 494, 481, 495, 495,
648
649 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
650 495, 495, 495, 495, 495, 495, 495, 481, 487, 45,
651 481, 496, 497, 488, 497, 489, 489, 481, 481, 481,
652 481, 481, 481, 498, 481, 481, 481, 481, 481, 481,
653 499, 481, 500, 481, 481, 481, 481, 481, 481, 481,
654 481, 481, 481, 481, 481, 481, 481, 481, 481, 481,
655 492, 493, 494, 495, 495, 495, 495, 495, 495, 495,
656 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
657 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
658 495, 495, 495, 495, 496, 497, 125, 481, 481, 481,
659
660 481, 501, 502, 500, 481, 481, 481, 481, 481, 481,
661 481, 481, 481, 481, 481, 481, 491, 495, 495, 495,
662 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
663 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
664 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
665 495, 495, 495, 481, 481, 503, 504, 495, 495, 495,
666 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
667 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
668 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
669 495, 495, 495, 495, 495, 495, 481, 505, 506, 495,
670
671 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
672 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
673 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
674 495, 495, 481, 499, 481, 495, 495, 495, 495, 495,
675 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
676 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
677 495, 481, 495, 495, 495, 495, 495, 495, 495, 495,
678 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
679 495, 495, 495, 495, 495, 495, 481, 481, 495, 495,
680 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
681
682 495, 495, 495, 495, 495, 495, 495, 495, 507, 495,
683 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
684 495, 495, 495, 495, 495, 507, 507, 495, 495, 495,
685 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
686 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
687 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
688 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
689 495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
690 0, 481, 481, 481, 481, 481, 481, 481, 481, 481,
691 481, 481, 481, 481, 481, 481, 481, 481, 481, 481,
692
693 481, 481, 481, 481, 481, 481, 481
694 } ;
695
696 static yyconst flex_int16_t yy_nxt[966] =
697 { 0,
698 30, 31, 32, 31, 30, 33, 30, 34, 35, 36,
699 37, 30, 38, 39, 40, 41, 41, 30, 42, 43,
700 44, 36, 30, 45, 45, 45, 45, 46, 30, 30,
701 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
702 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
703 45, 45, 45, 45, 47, 48, 36, 30, 53, 53,
704 57, 54, 54, 57, 66, 335, 58, 67, 76, 58,
705 69, 60, 32, 60, 66, 70, 124, 124, 124, 76,
706 61, 75, 81, 62, 55, 55, 55, 63, 82, 55,
707 60, 32, 60, 66, 77, 65, 334, 64, 66, 61,
708
709 75, 67, 62, 68, 69, 77, 63, 121, 80, 70,
710 299, 122, 148, 56, 56, 56, 64, 66, 56, 149,
711 67, 66, 68, 69, 67, 121, 71, 69, 70, 122,
712 66, 66, 70, 67, 67, 71, 69, 69, 72, 153,
713 78, 70, 70, 79, 81, 78, 298, 72, 79, 167,
714 82, 92, 32, 92, 154, 127, 92, 32, 92, 168,
715 93, 95, 150, 94, 169, 93, 80, 128, 94, 170,
716 80, 80, 187, 73, 151, 74, 155, 156, 155, 201,
717 201, 188, 73, 152, 74, 83, 84, 32, 84, 83,
718 83, 83, 83, 83, 83, 85, 83, 86, 87, 88,
719
720 88, 88, 83, 83, 83, 83, 83, 83, 86, 86,
721 86, 86, 83, 83, 89, 86, 86, 86, 86, 86,
722 86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
723 86, 86, 86, 86, 86, 86, 86, 86, 86, 83,
724 83, 83, 83, 97, 97, 97, 97, 97, 97, 97,
725 98, 97, 97, 97, 97, 99, 97, 97, 97, 97,
726 97, 97, 97, 97, 97, 97, 99, 99, 99, 99,
727 97, 97, 97, 99, 99, 100, 101, 102, 103, 104,
728 105, 99, 106, 99, 107, 108, 109, 110, 111, 99,
729 112, 113, 114, 115, 116, 99, 117, 118, 97, 97,
730
731 97, 96, 124, 124, 124, 96, 145, 96, 231, 261,
732 146, 226, 119, 119, 125, 481, 121, 262, 96, 481,
733 122, 481, 227, 96, 232, 147, 158, 159, 158, 96,
734 96, 121, 481, 178, 174, 122, 182, 481, 175, 189,
735 125, 185, 148, 481, 481, 186, 179, 176, 190, 149,
736 241, 180, 183, 160, 242, 184, 153, 191, 96, 124,
737 124, 124, 205, 206, 205, 207, 208, 207, 209, 210,
738 209, 154, 481, 132, 255, 255, 132, 211, 212, 211,
739 481, 257, 133, 133, 155, 156, 155, 214, 159, 214,
740 132, 220, 256, 134, 236, 221, 132, 204, 277, 135,
741
742 136, 216, 217, 216, 137, 278, 160, 222, 205, 206,
743 205, 138, 145, 236, 203, 139, 146, 140, 141, 142,
744 143, 96, 207, 208, 207, 96, 237, 96, 209, 210,
745 209, 147, 119, 119, 150, 211, 212, 211, 96, 155,
746 156, 155, 279, 96, 316, 280, 151, 325, 340, 96,
747 96, 214, 159, 214, 343, 152, 214, 159, 214, 216,
748 217, 216, 202, 316, 360, 367, 325, 340, 362, 362,
749 362, 480, 387, 343, 389, 427, 447, 479, 96, 197,
750 197, 197, 478, 360, 367, 477, 459, 476, 197, 475,
751 387, 388, 474, 389, 473, 447, 197, 197, 197, 197,
752
753 197, 197, 362, 362, 362, 459, 50, 50, 50, 50,
754 50, 50, 50, 50, 50, 50, 50, 50, 50, 52,
755 52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
756 52, 52, 59, 59, 59, 59, 59, 59, 59, 59,
757 59, 59, 59, 59, 59, 91, 91, 91, 91, 91,
758 91, 91, 91, 91, 91, 91, 91, 91, 96, 472,
759 471, 96, 470, 96, 96, 469, 468, 467, 466, 96,
760 96, 120, 465, 464, 120, 463, 120, 120, 462, 120,
761 120, 461, 120, 120, 123, 460, 123, 123, 126, 126,
762 458, 126, 126, 126, 126, 126, 126, 126, 126, 126,
763
764 131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
765 131, 131, 131, 157, 157, 157, 157, 157, 157, 157,
766 157, 157, 157, 457, 456, 157, 161, 455, 454, 161,
767 161, 161, 453, 452, 451, 450, 161, 449, 161, 162,
768 162, 448, 162, 162, 163, 163, 163, 163, 163, 163,
769 163, 163, 163, 164, 164, 446, 164, 164, 195, 195,
770 445, 195, 195, 195, 195, 195, 195, 195, 195, 195,
771 195, 196, 196, 444, 196, 196, 426, 426, 443, 426,
772 426, 426, 426, 426, 426, 426, 426, 426, 426, 442,
773 441, 427, 440, 439, 438, 437, 436, 435, 434, 433,
774
775 432, 431, 430, 429, 428, 427, 425, 424, 423, 422,
776 421, 420, 419, 418, 417, 416, 415, 414, 413, 412,
777 411, 410, 409, 408, 407, 406, 405, 404, 403, 402,
778 401, 400, 399, 398, 397, 396, 395, 394, 393, 392,
779 391, 390, 386, 385, 384, 383, 382, 381, 380, 379,
780 378, 377, 376, 375, 374, 373, 372, 371, 370, 369,
781 368, 366, 365, 364, 363, 361, 359, 358, 357, 356,
782 355, 354, 353, 352, 351, 350, 349, 348, 347, 346,
783 345, 344, 342, 341, 339, 338, 337, 336, 333, 332,
784 331, 330, 329, 328, 327, 326, 324, 323, 322, 321,
785
786 320, 319, 318, 317, 315, 314, 313, 312, 311, 310,
787 309, 308, 307, 306, 305, 304, 303, 302, 301, 300,
788 297, 296, 295, 294, 293, 292, 291, 290, 289, 288,
789 287, 286, 285, 284, 283, 282, 281, 276, 275, 274,
790 273, 272, 271, 270, 269, 268, 267, 266, 265, 264,
791 263, 260, 259, 258, 254, 253, 252, 251, 250, 249,
792 248, 247, 246, 245, 244, 243, 240, 239, 238, 235,
793 234, 233, 230, 229, 228, 225, 224, 223, 219, 218,
794 215, 213, 200, 199, 198, 194, 193, 192, 181, 177,
795 173, 172, 171, 166, 165, 129, 129, 144, 129, 130,
796
797 129, 481, 90, 51, 51, 49, 29, 481, 481, 481,
798 481, 481, 481, 481, 481, 481, 481, 481, 481, 481,
799 481, 481, 481, 481, 481, 481, 481, 481, 481, 481,
800 481, 481, 481, 481, 481, 481, 481, 481, 481, 481,
801 481, 481, 481, 481, 481, 481, 481, 481, 481, 481,
802 481, 481, 481, 481, 481, 481, 481, 481, 481, 481,
803 481, 481, 481, 481, 481
804 } ;
805
806 static yyconst flex_int16_t yy_chk[966] =
807 { 0,
808 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
809 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
810 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
811 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
812 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
813 1, 1, 1, 1, 1, 1, 1, 1, 5, 6,
814 7, 5, 6, 8, 15, 506, 7, 15, 19, 8,
815 15, 9, 9, 9, 17, 15, 41, 41, 41, 20,
816 9, 17, 23, 9, 5, 6, 7, 9, 23, 8,
817 10, 10, 10, 18, 19, 10, 505, 9, 11, 10,
818
819 18, 11, 10, 11, 11, 20, 10, 39, 23, 11,
820 504, 39, 71, 5, 6, 7, 10, 12, 8, 71,
821 12, 13, 12, 12, 13, 62, 13, 13, 12, 62,
822 14, 16, 13, 14, 16, 14, 14, 16, 13, 75,
823 21, 14, 16, 21, 24, 22, 503, 14, 22, 102,
824 24, 27, 27, 27, 75, 43, 28, 28, 28, 102,
825 27, 28, 72, 27, 103, 28, 21, 43, 28, 103,
826 24, 22, 113, 13, 72, 13, 77, 77, 77, 133,
827 133, 113, 14, 72, 14, 25, 25, 25, 25, 25,
828 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
829
830 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
831 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
832 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
833 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
834 25, 25, 25, 34, 34, 34, 34, 34, 34, 34,
835 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
836 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
837 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
838 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
839 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
840
841 34, 38, 40, 40, 40, 38, 70, 38, 175, 221,
842 70, 171, 38, 38, 40, 45, 87, 221, 38, 45,
843 87, 45, 171, 38, 175, 70, 80, 80, 80, 38,
844 38, 94, 45, 109, 107, 94, 111, 45, 107, 114,
845 40, 112, 208, 45, 45, 112, 109, 107, 114, 208,
846 183, 109, 111, 80, 183, 111, 212, 114, 38, 124,
847 124, 124, 147, 147, 147, 149, 149, 149, 152, 152,
848 152, 212, 45, 55, 201, 201, 55, 154, 154, 154,
849 217, 502, 55, 55, 155, 155, 155, 158, 158, 158,
850 55, 167, 501, 55, 179, 167, 55, 500, 236, 55,
851
852 55, 160, 160, 160, 55, 236, 217, 167, 205, 205,
853 205, 55, 206, 179, 499, 55, 206, 55, 55, 55,
854 55, 119, 207, 207, 207, 119, 179, 119, 209, 209,
855 209, 206, 119, 119, 210, 211, 211, 211, 119, 213,
856 213, 213, 237, 119, 276, 237, 210, 286, 306, 119,
857 119, 214, 214, 214, 309, 210, 215, 215, 215, 216,
858 216, 216, 498, 276, 330, 341, 286, 306, 333, 333,
859 333, 479, 427, 309, 363, 427, 436, 478, 119, 125,
860 125, 125, 477, 330, 341, 476, 454, 475, 125, 473,
861 362, 362, 472, 363, 471, 436, 125, 125, 125, 125,
862
863 125, 125, 362, 362, 362, 454, 482, 482, 482, 482,
864 482, 482, 482, 482, 482, 482, 482, 482, 482, 483,
865 483, 483, 483, 483, 483, 483, 483, 483, 483, 483,
866 483, 483, 484, 484, 484, 484, 484, 484, 484, 484,
867 484, 484, 484, 484, 484, 485, 485, 485, 485, 485,
868 485, 485, 485, 485, 485, 485, 485, 485, 486, 470,
869 469, 486, 467, 486, 486, 466, 465, 463, 462, 486,
870 486, 487, 461, 460, 487, 459, 487, 487, 457, 487,
871 487, 456, 487, 487, 488, 455, 488, 488, 489, 489,
872 453, 489, 489, 489, 489, 489, 489, 489, 489, 489,
873
874 490, 490, 490, 490, 490, 490, 490, 490, 490, 490,
875 490, 490, 490, 491, 491, 491, 491, 491, 491, 491,
876 491, 491, 491, 448, 447, 491, 492, 445, 444, 492,
877 492, 492, 442, 441, 440, 439, 492, 438, 492, 493,
878 493, 437, 493, 493, 494, 494, 494, 494, 494, 494,
879 494, 494, 494, 495, 495, 435, 495, 495, 496, 496,
880 434, 496, 496, 496, 496, 496, 496, 496, 496, 496,
881 496, 497, 497, 432, 497, 497, 507, 507, 431, 507,
882 507, 507, 507, 507, 507, 507, 507, 507, 507, 430,
883 428, 426, 425, 424, 423, 422, 421, 420, 417, 416,
884
885 415, 414, 412, 411, 410, 409, 408, 406, 405, 404,
886 401, 400, 399, 398, 396, 395, 394, 393, 392, 391,
887 390, 389, 388, 385, 384, 382, 380, 379, 378, 377,
888 376, 375, 374, 373, 372, 371, 370, 369, 368, 367,
889 366, 365, 361, 360, 359, 358, 357, 356, 355, 353,
890 352, 351, 350, 349, 348, 347, 346, 345, 344, 343,
891 342, 340, 339, 338, 337, 332, 328, 326, 325, 324,
892 323, 322, 320, 319, 318, 317, 316, 314, 313, 312,
893 311, 310, 308, 307, 304, 303, 302, 300, 297, 295,
894 294, 292, 290, 289, 288, 287, 285, 283, 282, 281,
895
896 280, 279, 278, 277, 275, 274, 273, 271, 270, 269,
897 268, 267, 266, 265, 264, 263, 262, 261, 260, 258,
898 254, 253, 252, 251, 250, 249, 248, 247, 246, 245,
899 244, 243, 242, 241, 240, 239, 238, 235, 234, 233,
900 232, 231, 230, 229, 228, 227, 226, 225, 224, 223,
901 222, 220, 219, 218, 200, 194, 193, 192, 191, 190,
902 189, 188, 187, 186, 185, 184, 182, 181, 180, 178,
903 177, 176, 174, 173, 172, 170, 169, 168, 166, 165,
904 159, 156, 129, 127, 126, 117, 116, 115, 110, 108,
905 106, 105, 104, 101, 100, 95, 90, 68, 65, 51,
906
907 49, 29, 26, 4, 3, 2, 481, 481, 481, 481,
908 481, 481, 481, 481, 481, 481, 481, 481, 481, 481,
909 481, 481, 481, 481, 481, 481, 481, 481, 481, 481,
910 481, 481, 481, 481, 481, 481, 481, 481, 481, 481,
911 481, 481, 481, 481, 481, 481, 481, 481, 481, 481,
912 481, 481, 481, 481, 481, 481, 481, 481, 481, 481,
913 481, 481, 481, 481, 481
914 } ;
915
916 static yy_state_type yy_last_accepting_state;
917 static char *yy_last_accepting_cpos;
918
919 extern int gram__flex_debug;
920 int gram__flex_debug = 1;
921
922 static yyconst flex_int16_t yy_rule_linenum[109] =
923 { 0,
924 149, 150, 151, 152, 160, 178, 179, 180, 181, 182,
925 183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
926 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
927 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,
928 213, 214, 215, 216, 217, 218, 219, 221, 225, 226,
929 227, 228, 229, 231, 238, 242, 249, 254, 257, 260,
930 263, 271, 279, 286, 293, 312, 327, 332, 351, 363,
931 379, 394, 411, 412, 423, 434, 435, 447, 473, 518,
932 528, 537, 547, 548, 549, 550, 551, 552, 553, 556,
933 558, 566, 583, 588, 589, 595, 596, 607, 613, 619,
934
935 625, 641, 642, 643, 659, 678, 718, 719
936 } ;
937
938 /* The intent behind this definition is that it'll catch
939 * any uses of REJECT which flex missed.
940 */
941 #define REJECT reject_used_but_not_detected
942 #define yymore() yymore_used_but_not_detected
943 #define YY_MORE_ADJ 0
944 #define YY_RESTORE_YY_MORE_OFFSET
945 char *gram_text;
946 #line 1 "scan-gram.l"
947 /* Bison Grammar Scanner -*- C -*-
948
949 Copyright (C) 2002-2012 Free Software Foundation, Inc.
950
951 This file is part of Bison, the GNU Compiler Compiler.
952
953 This program is free software: you can redistribute it and/or modify
954 it under the terms of the GNU General Public License as published by
955 the Free Software Foundation, either version 3 of the License, or
956 (at your option) any later version.
957
958 This program is distributed in the hope that it will be useful,
959 but WITHOUT ANY WARRANTY; without even the implied warranty of
960 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
961 GNU General Public License for more details.
962
963 You should have received a copy of the GNU General Public License
964 along with this program. If not, see <http://www.gnu.org/licenses/>. */
965 #define YY_NO_INPUT 1
966 #line 24 "scan-gram.l"
967 /* Work around a bug in flex 2.5.31. See Debian bug 333231
968 <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=333231>. */
969 #undef gram_wrap
970 #define gram_wrap() 1
971
972 #define FLEX_PREFIX(Id) gram_ ## Id
973 #include "flex-scanner.h"
974
975 #include "complain.h"
976 #include "files.h"
977 #include "gram.h"
978 #include "quotearg.h"
979 #include "reader.h"
980 #include "uniqstr.h"
981
982 #include <c-ctype.h>
983 #include <mbswidth.h>
984 #include <quote.h>
985
986 #include "scan-gram.h"
987
988 #define YY_DECL GRAM_LEX_DECL
989
990 #define YY_USER_INIT \
991 code_start = scanner_cursor = loc->start; \
992
993 /* Location of scanner cursor. */
994 static boundary scanner_cursor;
995
996 #define YY_USER_ACTION location_compute (loc, &scanner_cursor, gram_text, gram_leng);
997
998 static size_t no_cr_read (FILE *, char *, size_t);
999 #define YY_INPUT(buf, result, size) ((result) = no_cr_read (gram_in, buf, size))
1000
1001 #define ROLLBACK_CURRENT_TOKEN \
1002 do { \
1003 scanner_cursor.column -= mbsnwidth (gram_text, gram_leng, 0); \
1004 yyless (0); \
1005 } while (0)
1006
1007 /* A string representing the most recently saved token. */
1008 static char *last_string;
1009
1010 /* Bracketed identifier. */
1011 static uniqstr bracketed_id_str = 0;
1012 static location bracketed_id_loc;
1013 static boundary bracketed_id_start;
1014 static int bracketed_id_context_state = 0;
1015
1016 void
gram_scanner_last_string_free(void)1017 gram_scanner_last_string_free (void)
1018 {
1019 STRING_FREE;
1020 }
1021
1022 static void handle_syncline (char *, location);
1023 static unsigned long int scan_integer (char const *p, int base, location loc);
1024 static int convert_ucn_to_byte (char const *hex_text);
1025 static void unexpected_eof (boundary, char const *);
1026 static void unexpected_newline (boundary, char const *);
1027
1028 /* A C-like comment in directives/rules. */
1029
1030 /* Strings and characters in directives/rules. */
1031
1032 /* A identifier was just read in directives/rules. Special state
1033 to capture the sequence 'identifier :'. */
1034
1035 /* Three types of user code:
1036 - prologue (code between '%{' '%}' in the first section, before %%);
1037 - actions, printers, union, etc, (between braced in the middle section);
1038 - epilogue (everything after the second %%). */
1039
1040 /* C and C++ comments in code. */
1041
1042 /* Strings and characters in code. */
1043
1044 /* Bracketed identifiers support. */
1045
1046 /* POSIX says that a tag must be both an id and a C union member, but
1047 historically almost any character is allowed in a tag. We disallow
1048 NUL and newline, as this simplifies our implementation. */
1049 /* Zero or more instances of backslash-newline. Following GCC, allow
1050 white space between the backslash and the newline. */
1051 #line 1052 "scan-gram.c"
1052
1053 #define INITIAL 0
1054 #define SC_YACC_COMMENT 1
1055 #define SC_ESCAPED_STRING 2
1056 #define SC_ESCAPED_CHARACTER 3
1057 #define SC_AFTER_IDENTIFIER 4
1058 #define SC_PROLOGUE 5
1059 #define SC_BRACED_CODE 6
1060 #define SC_EPILOGUE 7
1061 #define SC_COMMENT 8
1062 #define SC_LINE_COMMENT 9
1063 #define SC_STRING 10
1064 #define SC_CHARACTER 11
1065 #define SC_BRACKETED_ID 12
1066 #define SC_RETURN_BRACKETED_ID 13
1067
1068 #ifndef YY_NO_UNISTD_H
1069 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1070 * down here because we want the user's section 1 to have been scanned first.
1071 * The user has a chance to override it with an option.
1072 */
1073 /* %if-c-only */
1074 #include <unistd.h>
1075 /* %endif */
1076 /* %if-c++-only */
1077 /* %endif */
1078 #endif
1079
1080 #ifndef YY_EXTRA_TYPE
1081 #define YY_EXTRA_TYPE void *
1082 #endif
1083
1084 /* %if-c-only Reentrant structure and macros (non-C++). */
1085 /* %if-reentrant */
1086 /* %if-c-only */
1087
1088 static int yy_init_globals (void );
1089
1090 /* %endif */
1091 /* %if-reentrant */
1092 /* %endif */
1093 /* %endif End reentrant structures and macros. */
1094
1095 /* Accessor methods to globals.
1096 These are made visible to non-reentrant scanners for convenience. */
1097
1098 int gram_lex_destroy (void );
1099
1100 int gram_get_debug (void );
1101
1102 void gram_set_debug (int debug_flag );
1103
1104 YY_EXTRA_TYPE gram_get_extra (void );
1105
1106 void gram_set_extra (YY_EXTRA_TYPE user_defined );
1107
1108 FILE *gram_get_in (void );
1109
1110 void gram_set_in (FILE * in_str );
1111
1112 FILE *gram_get_out (void );
1113
1114 void gram_set_out (FILE * out_str );
1115
1116 yy_size_t gram_get_leng (void );
1117
1118 char *gram_get_text (void );
1119
1120 int gram_get_lineno (void );
1121
1122 void gram_set_lineno (int line_number );
1123
1124 /* %if-bison-bridge */
1125 /* %endif */
1126
1127 /* Macros after this point can all be overridden by user definitions in
1128 * section 1.
1129 */
1130
1131 #ifndef YY_SKIP_YYWRAP
1132 #ifdef __cplusplus
1133 extern "C" int gram_wrap (void );
1134 #else
1135 extern int gram_wrap (void );
1136 #endif
1137 #endif
1138
1139 /* %not-for-header */
1140
1141 /* %ok-for-header */
1142
1143 /* %endif */
1144
1145 #ifndef yytext_ptr
1146 static void yy_flex_strncpy (char *,yyconst char *,int );
1147 #endif
1148
1149 #ifdef YY_NEED_STRLEN
1150 static int yy_flex_strlen (yyconst char * );
1151 #endif
1152
1153 #ifndef YY_NO_INPUT
1154 /* %if-c-only Standard (non-C++) definition */
1155 /* %not-for-header */
1156
1157 #ifdef __cplusplus
1158 static int yyinput (void );
1159 #else
1160 static int input (void );
1161 #endif
1162 /* %ok-for-header */
1163
1164 /* %endif */
1165 #endif
1166
1167 /* %if-c-only */
1168
1169 /* %endif */
1170
1171 /* Amount of stuff to slurp up with each read. */
1172 #ifndef YY_READ_BUF_SIZE
1173 #define YY_READ_BUF_SIZE 8192
1174 #endif
1175
1176 /* Copy whatever the last rule matched to the standard output. */
1177 #ifndef ECHO
1178 /* %if-c-only Standard (non-C++) definition */
1179 /* This used to be an fputs(), but since the string might contain NUL's,
1180 * we now use fwrite().
1181 */
1182 #define ECHO do { if (fwrite( gram_text, gram_leng, 1, gram_out )) {} } while (0)
1183 /* %endif */
1184 /* %if-c++-only C++ definition */
1185 /* %endif */
1186 #endif
1187
1188 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1189 * is returned in "result".
1190 */
1191 #ifndef YY_INPUT
1192 #define YY_INPUT(buf,result,max_size) \
1193 /* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\
1194 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1195 { \
1196 int c = '*'; \
1197 size_t n; \
1198 for ( n = 0; n < max_size && \
1199 (c = getc( gram_in )) != EOF && c != '\n'; ++n ) \
1200 buf[n] = (char) c; \
1201 if ( c == '\n' ) \
1202 buf[n++] = (char) c; \
1203 if ( c == EOF && ferror( gram_in ) ) \
1204 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1205 result = n; \
1206 } \
1207 else \
1208 { \
1209 errno=0; \
1210 while ( (result = fread(buf, 1, max_size, gram_in))==0 && ferror(gram_in)) \
1211 { \
1212 if( errno != EINTR) \
1213 { \
1214 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1215 break; \
1216 } \
1217 errno=0; \
1218 clearerr(gram_in); \
1219 } \
1220 }\
1221 \
1222 /* %if-c++-only C++ definition \ */\
1223 /* %endif */
1224
1225 #endif
1226
1227 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1228 * we don't want an extra ';' after the "return" because that will cause
1229 * some compilers to complain about unreachable statements.
1230 */
1231 #ifndef yyterminate
1232 #define yyterminate() return YY_NULL
1233 #endif
1234
1235 /* Number of entries by which start-condition stack grows. */
1236 #ifndef YY_START_STACK_INCR
1237 #define YY_START_STACK_INCR 25
1238 #endif
1239
1240 /* Report a fatal error. */
1241 #ifndef YY_FATAL_ERROR
1242 /* %if-c-only */
1243 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1244 /* %endif */
1245 /* %if-c++-only */
1246 /* %endif */
1247 #endif
1248
1249 /* %if-tables-serialization structures and prototypes */
1250 /* %not-for-header */
1251
1252 /* %ok-for-header */
1253
1254 /* %not-for-header */
1255
1256 /* %tables-yydmap generated elements */
1257 /* %endif */
1258 /* end tables serialization structures and prototypes */
1259
1260 /* %ok-for-header */
1261
1262 /* Default declaration of generated scanner - a define so the user can
1263 * easily add parameters.
1264 */
1265 #ifndef YY_DECL
1266 #define YY_DECL_IS_OURS 1
1267 /* %if-c-only Standard (non-C++) definition */
1268
1269 extern int gram_lex (void);
1270
1271 #define YY_DECL int gram_lex (void)
1272 /* %endif */
1273 /* %if-c++-only C++ definition */
1274 /* %endif */
1275 #endif /* !YY_DECL */
1276
1277 /* Code executed at the beginning of each rule, after gram_text and gram_leng
1278 * have been set up.
1279 */
1280 #ifndef YY_USER_ACTION
1281 #define YY_USER_ACTION
1282 #endif
1283
1284 /* Code executed at the end of each rule. */
1285 #ifndef YY_BREAK
1286 #define YY_BREAK break;
1287 #endif
1288
1289 /* %% [6.0] YY_RULE_SETUP definition goes here */
1290 #define YY_RULE_SETUP \
1291 if ( gram_leng > 0 ) \
1292 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1293 (gram_text[gram_leng - 1] == '\n'); \
1294 YY_USER_ACTION
1295
1296 /* %not-for-header */
1297
1298 /** The main scanner function which does all the work.
1299 */
1300 YY_DECL
1301 {
1302 register yy_state_type yy_current_state;
1303 register char *yy_cp, *yy_bp;
1304 register int yy_act;
1305
1306 /* %% [7.0] user's declarations go here */
1307 #line 120 "scan-gram.l"
1308
1309
1310 /* Nesting level of the current code in braces. */
1311 int braces_level PACIFY_CC (= 0);
1312
1313 /* Parent context state, when applicable. */
1314 int context_state PACIFY_CC (= 0);
1315
1316 /* Location of most recent identifier, when applicable. */
1317 location id_loc PACIFY_CC (= empty_location);
1318
1319 /* Where containing code started, when applicable. Its initial
1320 value is relevant only when gram_lex is invoked in the SC_EPILOGUE
1321 start condition. */
1322 boundary code_start = scanner_cursor;
1323
1324 /* Where containing comment or string or character literal started,
1325 when applicable. */
1326 boundary token_start PACIFY_CC (= scanner_cursor);
1327
1328
1329
1330 /*-----------------------.
1331 | Scanning white space. |
1332 `-----------------------*/
1333
1334 #line 1335 "scan-gram.c"
1335
1336 if ( !(yy_init) )
1337 {
1338 (yy_init) = 1;
1339
1340 #ifdef YY_USER_INIT
1341 YY_USER_INIT;
1342 #endif
1343
1344 if ( ! (yy_start) )
1345 (yy_start) = 1; /* first start state */
1346
1347 if ( ! gram_in )
1348 /* %if-c-only */
1349 gram_in = stdin;
1350 /* %endif */
1351 /* %if-c++-only */
1352 /* %endif */
1353
1354 if ( ! gram_out )
1355 /* %if-c-only */
1356 gram_out = stdout;
1357 /* %endif */
1358 /* %if-c++-only */
1359 /* %endif */
1360
1361 if ( ! YY_CURRENT_BUFFER ) {
1362 gram_ensure_buffer_stack ();
1363 YY_CURRENT_BUFFER_LVALUE =
1364 gram__create_buffer(gram_in,YY_BUF_SIZE );
1365 }
1366
1367 gram__load_buffer_state( );
1368 }
1369
1370 while ( 1 ) /* loops until end-of-file is reached */
1371 {
1372 /* %% [8.0] yymore()-related code goes here */
1373 yy_cp = (yy_c_buf_p);
1374
1375 /* Support of gram_text. */
1376 *yy_cp = (yy_hold_char);
1377
1378 /* yy_bp points to the position in yy_ch_buf of the start of
1379 * the current run.
1380 */
1381 yy_bp = yy_cp;
1382
1383 /* %% [9.0] code to set up and find next match goes here */
1384 yy_current_state = (yy_start);
1385 yy_current_state += YY_AT_BOL();
1386 yy_match:
1387 do
1388 {
1389 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1390 if ( yy_accept[yy_current_state] )
1391 {
1392 (yy_last_accepting_state) = yy_current_state;
1393 (yy_last_accepting_cpos) = yy_cp;
1394 }
1395 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1396 {
1397 yy_current_state = (int) yy_def[yy_current_state];
1398 if ( yy_current_state >= 482 )
1399 yy_c = yy_meta[(unsigned int) yy_c];
1400 }
1401 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1402 ++yy_cp;
1403 }
1404 while ( yy_current_state != 481 );
1405 yy_cp = (yy_last_accepting_cpos);
1406 yy_current_state = (yy_last_accepting_state);
1407
1408 yy_find_action:
1409 /* %% [10.0] code to find the action number goes here */
1410 yy_act = yy_accept[yy_current_state];
1411
1412 YY_DO_BEFORE_ACTION;
1413
1414 /* %% [11.0] code for gram_lineno update goes here */
1415
1416 do_action: /* This label is used only to access EOF actions. */
1417
1418 /* %% [12.0] debug code goes here */
1419 if ( gram__flex_debug )
1420 {
1421 if ( yy_act == 0 )
1422 fprintf( stderr, "--scanner backing up\n" );
1423 else if ( yy_act < 109 )
1424 fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n",
1425 (long)yy_rule_linenum[yy_act], gram_text );
1426 else if ( yy_act == 109 )
1427 fprintf( stderr, "--accepting default rule (\"%s\")\n",
1428 gram_text );
1429 else if ( yy_act == 110 )
1430 fprintf( stderr, "--(end of buffer or a NUL)\n" );
1431 else
1432 fprintf( stderr, "--EOF (start condition %d)\n", YY_START );
1433 }
1434
1435 switch ( yy_act )
1436 { /* beginning of action switch */
1437 /* %% [13.0] actions go here */
1438 case 0: /* must back up */
1439 /* undo the effects of YY_DO_BEFORE_ACTION */
1440 *yy_cp = (yy_hold_char);
1441 yy_cp = (yy_last_accepting_cpos);
1442 yy_current_state = (yy_last_accepting_state);
1443 goto yy_find_action;
1444
1445 /* Comments and white space. */
1446 case 1:
1447 YY_RULE_SETUP
1448 #line 149 "scan-gram.l"
1449 warn_at (*loc, _("stray ',' treated as white space"));
1450 YY_BREAK
1451 case 2:
1452 /* rule 2 can match eol */
1453 #line 151 "scan-gram.l"
1454 case 3:
1455 /* rule 3 can match eol */
1456 YY_RULE_SETUP
1457 #line 151 "scan-gram.l"
1458 continue;
1459 YY_BREAK
1460 case 4:
1461 YY_RULE_SETUP
1462 #line 152 "scan-gram.l"
1463 {
1464 token_start = loc->start;
1465 context_state = YY_START;
1466 BEGIN SC_YACC_COMMENT;
1467 }
1468 YY_BREAK
1469 /* #line directives are not documented, and may be withdrawn or
1470 modified in future versions of Bison. */
1471 case 5:
1472 /* rule 5 can match eol */
1473 YY_RULE_SETUP
1474 #line 160 "scan-gram.l"
1475 {
1476 handle_syncline (gram_text + sizeof "#line " - 1, *loc);
1477 }
1478 YY_BREAK
1479
1480 /*----------------------------.
1481 | Scanning Bison directives. |
1482 `----------------------------*/
1483 /* For directives that are also command line options, the regex must be
1484 "%..."
1485 after "[-_]"s are removed, and the directive must match the --long
1486 option name, with a single string argument. Otherwise, add exceptions
1487 to ../build-aux/cross-options.pl. */
1488
1489
1490 case 6:
1491 YY_RULE_SETUP
1492 #line 178 "scan-gram.l"
1493 return PERCENT_NONASSOC;
1494 YY_BREAK
1495 case 7:
1496 YY_RULE_SETUP
1497 #line 179 "scan-gram.l"
1498 return PERCENT_CODE;
1499 YY_BREAK
1500 case 8:
1501 YY_RULE_SETUP
1502 #line 180 "scan-gram.l"
1503 return PERCENT_DEBUG;
1504 YY_BREAK
1505 case 9:
1506 YY_RULE_SETUP
1507 #line 181 "scan-gram.l"
1508 return PERCENT_DEFAULT_PREC;
1509 YY_BREAK
1510 case 10:
1511 YY_RULE_SETUP
1512 #line 182 "scan-gram.l"
1513 return PERCENT_DEFINE;
1514 YY_BREAK
1515 case 11:
1516 YY_RULE_SETUP
1517 #line 183 "scan-gram.l"
1518 return PERCENT_DEFINES;
1519 YY_BREAK
1520 case 12:
1521 YY_RULE_SETUP
1522 #line 184 "scan-gram.l"
1523 return PERCENT_DESTRUCTOR;
1524 YY_BREAK
1525 case 13:
1526 YY_RULE_SETUP
1527 #line 185 "scan-gram.l"
1528 return PERCENT_DPREC;
1529 YY_BREAK
1530 case 14:
1531 YY_RULE_SETUP
1532 #line 186 "scan-gram.l"
1533 return PERCENT_ERROR_VERBOSE;
1534 YY_BREAK
1535 case 15:
1536 YY_RULE_SETUP
1537 #line 187 "scan-gram.l"
1538 return PERCENT_EXPECT;
1539 YY_BREAK
1540 case 16:
1541 YY_RULE_SETUP
1542 #line 188 "scan-gram.l"
1543 return PERCENT_EXPECT_RR;
1544 YY_BREAK
1545 case 17:
1546 YY_RULE_SETUP
1547 #line 189 "scan-gram.l"
1548 return PERCENT_FILE_PREFIX;
1549 YY_BREAK
1550 case 18:
1551 YY_RULE_SETUP
1552 #line 190 "scan-gram.l"
1553 return PERCENT_YACC;
1554 YY_BREAK
1555 case 19:
1556 YY_RULE_SETUP
1557 #line 191 "scan-gram.l"
1558 return PERCENT_INITIAL_ACTION;
1559 YY_BREAK
1560 case 20:
1561 YY_RULE_SETUP
1562 #line 192 "scan-gram.l"
1563 return PERCENT_GLR_PARSER;
1564 YY_BREAK
1565 case 21:
1566 YY_RULE_SETUP
1567 #line 193 "scan-gram.l"
1568 return PERCENT_LANGUAGE;
1569 YY_BREAK
1570 case 22:
1571 YY_RULE_SETUP
1572 #line 194 "scan-gram.l"
1573 return PERCENT_LEFT;
1574 YY_BREAK
1575 case 23:
1576 YY_RULE_SETUP
1577 #line 195 "scan-gram.l"
1578 return PERCENT_LEX_PARAM;
1579 YY_BREAK
1580 case 24:
1581 YY_RULE_SETUP
1582 #line 196 "scan-gram.l"
1583 return PERCENT_LOCATIONS;
1584 YY_BREAK
1585 case 25:
1586 YY_RULE_SETUP
1587 #line 197 "scan-gram.l"
1588 return PERCENT_MERGE;
1589 YY_BREAK
1590 case 26:
1591 YY_RULE_SETUP
1592 #line 198 "scan-gram.l"
1593 return PERCENT_NAME_PREFIX;
1594 YY_BREAK
1595 case 27:
1596 YY_RULE_SETUP
1597 #line 199 "scan-gram.l"
1598 return PERCENT_NO_DEFAULT_PREC;
1599 YY_BREAK
1600 case 28:
1601 YY_RULE_SETUP
1602 #line 200 "scan-gram.l"
1603 return PERCENT_NO_LINES;
1604 YY_BREAK
1605 case 29:
1606 YY_RULE_SETUP
1607 #line 201 "scan-gram.l"
1608 return PERCENT_NONASSOC;
1609 YY_BREAK
1610 case 30:
1611 YY_RULE_SETUP
1612 #line 202 "scan-gram.l"
1613 return PERCENT_NONDETERMINISTIC_PARSER;
1614 YY_BREAK
1615 case 31:
1616 YY_RULE_SETUP
1617 #line 203 "scan-gram.l"
1618 return PERCENT_NTERM;
1619 YY_BREAK
1620 case 32:
1621 YY_RULE_SETUP
1622 #line 204 "scan-gram.l"
1623 return PERCENT_OUTPUT;
1624 YY_BREAK
1625 case 33:
1626 YY_RULE_SETUP
1627 #line 205 "scan-gram.l"
1628 return PERCENT_PARSE_PARAM;
1629 YY_BREAK
1630 case 34:
1631 YY_RULE_SETUP
1632 #line 206 "scan-gram.l"
1633 return PERCENT_PREC;
1634 YY_BREAK
1635 case 35:
1636 YY_RULE_SETUP
1637 #line 207 "scan-gram.l"
1638 return PERCENT_PRINTER;
1639 YY_BREAK
1640 case 36:
1641 YY_RULE_SETUP
1642 #line 208 "scan-gram.l"
1643 return PERCENT_PURE_PARSER;
1644 YY_BREAK
1645 case 37:
1646 YY_RULE_SETUP
1647 #line 209 "scan-gram.l"
1648 return PERCENT_REQUIRE;
1649 YY_BREAK
1650 case 38:
1651 YY_RULE_SETUP
1652 #line 210 "scan-gram.l"
1653 return PERCENT_RIGHT;
1654 YY_BREAK
1655 case 39:
1656 YY_RULE_SETUP
1657 #line 211 "scan-gram.l"
1658 return PERCENT_SKELETON;
1659 YY_BREAK
1660 case 40:
1661 YY_RULE_SETUP
1662 #line 212 "scan-gram.l"
1663 return PERCENT_START;
1664 YY_BREAK
1665 case 41:
1666 YY_RULE_SETUP
1667 #line 213 "scan-gram.l"
1668 return PERCENT_TOKEN;
1669 YY_BREAK
1670 case 42:
1671 YY_RULE_SETUP
1672 #line 214 "scan-gram.l"
1673 return PERCENT_TOKEN;
1674 YY_BREAK
1675 case 43:
1676 YY_RULE_SETUP
1677 #line 215 "scan-gram.l"
1678 return PERCENT_TOKEN_TABLE;
1679 YY_BREAK
1680 case 44:
1681 YY_RULE_SETUP
1682 #line 216 "scan-gram.l"
1683 return PERCENT_TYPE;
1684 YY_BREAK
1685 case 45:
1686 YY_RULE_SETUP
1687 #line 217 "scan-gram.l"
1688 return PERCENT_UNION;
1689 YY_BREAK
1690 case 46:
1691 YY_RULE_SETUP
1692 #line 218 "scan-gram.l"
1693 return PERCENT_VERBOSE;
1694 YY_BREAK
1695 case 47:
1696 YY_RULE_SETUP
1697 #line 219 "scan-gram.l"
1698 return PERCENT_YACC;
1699 YY_BREAK
1700 case 48:
1701 /* rule 48 can match eol */
1702 YY_RULE_SETUP
1703 #line 221 "scan-gram.l"
1704 {
1705 complain_at (*loc, _("invalid directive: %s"), quote (gram_text));
1706 }
1707 YY_BREAK
1708 case 49:
1709 YY_RULE_SETUP
1710 #line 225 "scan-gram.l"
1711 return EQUAL;
1712 YY_BREAK
1713 case 50:
1714 YY_RULE_SETUP
1715 #line 226 "scan-gram.l"
1716 return PIPE;
1717 YY_BREAK
1718 case 51:
1719 YY_RULE_SETUP
1720 #line 227 "scan-gram.l"
1721 return SEMICOLON;
1722 YY_BREAK
1723 case 52:
1724 YY_RULE_SETUP
1725 #line 228 "scan-gram.l"
1726 return TYPE_TAG_ANY;
1727 YY_BREAK
1728 case 53:
1729 YY_RULE_SETUP
1730 #line 229 "scan-gram.l"
1731 return TYPE_TAG_NONE;
1732 YY_BREAK
1733 case 54:
1734 YY_RULE_SETUP
1735 #line 231 "scan-gram.l"
1736 {
1737 val->uniqstr = uniqstr_new (gram_text);
1738 id_loc = *loc;
1739 bracketed_id_str = NULL;
1740 BEGIN SC_AFTER_IDENTIFIER;
1741 }
1742 YY_BREAK
1743 case 55:
1744 YY_RULE_SETUP
1745 #line 238 "scan-gram.l"
1746 {
1747 val->integer = scan_integer (gram_text, 10, *loc);
1748 return INT;
1749 }
1750 YY_BREAK
1751 case 56:
1752 YY_RULE_SETUP
1753 #line 242 "scan-gram.l"
1754 {
1755 val->integer = scan_integer (gram_text, 16, *loc);
1756 return INT;
1757 }
1758 YY_BREAK
1759 /* Identifiers may not start with a digit. Yet, don't silently
1760 accept "1FOO" as "1 FOO". */
1761 case 57:
1762 YY_RULE_SETUP
1763 #line 249 "scan-gram.l"
1764 {
1765 complain_at (*loc, _("invalid identifier: %s"), quote (gram_text));
1766 }
1767 YY_BREAK
1768 /* Characters. */
1769 case 58:
1770 YY_RULE_SETUP
1771 #line 254 "scan-gram.l"
1772 token_start = loc->start; BEGIN SC_ESCAPED_CHARACTER;
1773 YY_BREAK
1774 /* Strings. */
1775 case 59:
1776 YY_RULE_SETUP
1777 #line 257 "scan-gram.l"
1778 token_start = loc->start; BEGIN SC_ESCAPED_STRING;
1779 YY_BREAK
1780 /* Prologue. */
1781 case 60:
1782 YY_RULE_SETUP
1783 #line 260 "scan-gram.l"
1784 code_start = loc->start; BEGIN SC_PROLOGUE;
1785 YY_BREAK
1786 /* Code in between braces. */
1787 case 61:
1788 YY_RULE_SETUP
1789 #line 263 "scan-gram.l"
1790 {
1791 STRING_GROW;
1792 braces_level = 0;
1793 code_start = loc->start;
1794 BEGIN SC_BRACED_CODE;
1795 }
1796 YY_BREAK
1797 /* A type. */
1798 case 62:
1799 YY_RULE_SETUP
1800 #line 271 "scan-gram.l"
1801 {
1802 obstack_grow (&obstack_for_string, gram_text + 1, gram_leng - 2);
1803 STRING_FINISH;
1804 val->uniqstr = uniqstr_new (last_string);
1805 STRING_FREE;
1806 return TYPE;
1807 }
1808 YY_BREAK
1809 case 63:
1810 YY_RULE_SETUP
1811 #line 279 "scan-gram.l"
1812 {
1813 static int percent_percent_count;
1814 if (++percent_percent_count == 2)
1815 BEGIN SC_EPILOGUE;
1816 return PERCENT_PERCENT;
1817 }
1818 YY_BREAK
1819 case 64:
1820 YY_RULE_SETUP
1821 #line 286 "scan-gram.l"
1822 {
1823 bracketed_id_str = NULL;
1824 bracketed_id_start = loc->start;
1825 bracketed_id_context_state = YY_START;
1826 BEGIN SC_BRACKETED_ID;
1827 }
1828 YY_BREAK
1829 case 65:
1830 YY_RULE_SETUP
1831 #line 293 "scan-gram.l"
1832 {
1833 complain_at (*loc, "%s: %s",
1834 ngettext ("invalid character", "invalid characters", gram_leng),
1835 quote_mem (gram_text, gram_leng));
1836 }
1837 YY_BREAK
1838 case YY_STATE_EOF(INITIAL):
1839 #line 299 "scan-gram.l"
1840 {
1841 loc->start = loc->end = scanner_cursor;
1842 yyterminate ();
1843 }
1844 YY_BREAK
1845
1846 /*-----------------------------------------------------------------.
1847 | Scanning after an identifier, checking whether a colon is next. |
1848 `-----------------------------------------------------------------*/
1849
1850
1851 case 66:
1852 YY_RULE_SETUP
1853 #line 312 "scan-gram.l"
1854 {
1855 if (bracketed_id_str)
1856 {
1857 ROLLBACK_CURRENT_TOKEN;
1858 BEGIN SC_RETURN_BRACKETED_ID;
1859 *loc = id_loc;
1860 return ID;
1861 }
1862 else
1863 {
1864 bracketed_id_start = loc->start;
1865 bracketed_id_context_state = YY_START;
1866 BEGIN SC_BRACKETED_ID;
1867 }
1868 }
1869 YY_BREAK
1870 case 67:
1871 YY_RULE_SETUP
1872 #line 327 "scan-gram.l"
1873 {
1874 BEGIN (bracketed_id_str ? SC_RETURN_BRACKETED_ID : INITIAL);
1875 *loc = id_loc;
1876 return ID_COLON;
1877 }
1878 YY_BREAK
1879 case 68:
1880 YY_RULE_SETUP
1881 #line 332 "scan-gram.l"
1882 {
1883 ROLLBACK_CURRENT_TOKEN;
1884 BEGIN (bracketed_id_str ? SC_RETURN_BRACKETED_ID : INITIAL);
1885 *loc = id_loc;
1886 return ID;
1887 }
1888 YY_BREAK
1889 case YY_STATE_EOF(SC_AFTER_IDENTIFIER):
1890 #line 338 "scan-gram.l"
1891 {
1892 BEGIN (bracketed_id_str ? SC_RETURN_BRACKETED_ID : INITIAL);
1893 *loc = id_loc;
1894 return ID;
1895 }
1896 YY_BREAK
1897
1898 /*--------------------------------.
1899 | Scanning bracketed identifiers. |
1900 `--------------------------------*/
1901
1902
1903 case 69:
1904 YY_RULE_SETUP
1905 #line 351 "scan-gram.l"
1906 {
1907 if (bracketed_id_str)
1908 {
1909 complain_at (*loc, _("unexpected identifier in bracketed name: %s"),
1910 quote (gram_text));
1911 }
1912 else
1913 {
1914 bracketed_id_str = uniqstr_new (gram_text);
1915 bracketed_id_loc = *loc;
1916 }
1917 }
1918 YY_BREAK
1919 case 70:
1920 YY_RULE_SETUP
1921 #line 363 "scan-gram.l"
1922 {
1923 BEGIN bracketed_id_context_state;
1924 if (bracketed_id_str)
1925 {
1926 if (INITIAL == bracketed_id_context_state)
1927 {
1928 val->uniqstr = bracketed_id_str;
1929 bracketed_id_str = 0;
1930 *loc = bracketed_id_loc;
1931 return BRACKETED_ID;
1932 }
1933 }
1934 else
1935 complain_at (*loc, _("an identifier expected"));
1936 }
1937 YY_BREAK
1938 case 71:
1939 YY_RULE_SETUP
1940 #line 379 "scan-gram.l"
1941 {
1942 complain_at (*loc, "%s: %s",
1943 ngettext ("invalid character in bracketed name",
1944 "invalid characters in bracketed name", gram_leng),
1945 quote_mem (gram_text, gram_leng));
1946 }
1947 YY_BREAK
1948 case YY_STATE_EOF(SC_BRACKETED_ID):
1949 #line 386 "scan-gram.l"
1950 {
1951 BEGIN bracketed_id_context_state;
1952 unexpected_eof (bracketed_id_start, "]");
1953 }
1954 YY_BREAK
1955
1956
1957
1958 case 72:
1959 YY_RULE_SETUP
1960 #line 394 "scan-gram.l"
1961 {
1962 ROLLBACK_CURRENT_TOKEN;
1963 val->uniqstr = bracketed_id_str;
1964 bracketed_id_str = 0;
1965 *loc = bracketed_id_loc;
1966 BEGIN INITIAL;
1967 return BRACKETED_ID;
1968 }
1969 YY_BREAK
1970
1971 /*---------------------------------------------------------------.
1972 | Scanning a Yacc comment. The initial '/ *' is already eaten. |
1973 `---------------------------------------------------------------*/
1974
1975
1976 case 73:
1977 YY_RULE_SETUP
1978 #line 411 "scan-gram.l"
1979 BEGIN context_state;
1980 YY_BREAK
1981 case 74:
1982 /* rule 74 can match eol */
1983 YY_RULE_SETUP
1984 #line 412 "scan-gram.l"
1985 continue;
1986 YY_BREAK
1987 case YY_STATE_EOF(SC_YACC_COMMENT):
1988 #line 413 "scan-gram.l"
1989 unexpected_eof (token_start, "*/"); BEGIN context_state;
1990 YY_BREAK
1991
1992 /*------------------------------------------------------------.
1993 | Scanning a C comment. The initial '/ *' is already eaten. |
1994 `------------------------------------------------------------*/
1995
1996
1997 case 75:
1998 /* rule 75 can match eol */
1999 YY_RULE_SETUP
2000 #line 423 "scan-gram.l"
2001 STRING_GROW; BEGIN context_state;
2002 YY_BREAK
2003 case YY_STATE_EOF(SC_COMMENT):
2004 #line 424 "scan-gram.l"
2005 unexpected_eof (token_start, "*/"); BEGIN context_state;
2006 YY_BREAK
2007
2008 /*--------------------------------------------------------------.
2009 | Scanning a line comment. The initial '//' is already eaten. |
2010 `--------------------------------------------------------------*/
2011
2012
2013 case 76:
2014 /* rule 76 can match eol */
2015 YY_RULE_SETUP
2016 #line 434 "scan-gram.l"
2017 STRING_GROW; BEGIN context_state;
2018 YY_BREAK
2019 case 77:
2020 /* rule 77 can match eol */
2021 YY_RULE_SETUP
2022 #line 435 "scan-gram.l"
2023 STRING_GROW;
2024 YY_BREAK
2025 case YY_STATE_EOF(SC_LINE_COMMENT):
2026 #line 436 "scan-gram.l"
2027 BEGIN context_state;
2028 YY_BREAK
2029
2030 /*------------------------------------------------.
2031 | Scanning a Bison string, including its escapes. |
2032 | The initial quote is already eaten. |
2033 `------------------------------------------------*/
2034
2035
2036 case 78:
2037 /* rule 78 can match eol */
2038 YY_RULE_SETUP
2039 #line 447 "scan-gram.l"
2040 {
2041 if (gram_text[0] == '\n')
2042 unexpected_newline (token_start, "\"");
2043 STRING_FINISH;
2044 loc->start = token_start;
2045 val->chars = last_string;
2046 BEGIN INITIAL;
2047 return STRING;
2048 }
2049 YY_BREAK
2050 case YY_STATE_EOF(SC_ESCAPED_STRING):
2051 #line 456 "scan-gram.l"
2052 {
2053 unexpected_eof (token_start, "\"");
2054 STRING_FINISH;
2055 loc->start = token_start;
2056 val->chars = last_string;
2057 BEGIN INITIAL;
2058 return STRING;
2059 }
2060 YY_BREAK
2061
2062 /*----------------------------------------------------------.
2063 | Scanning a Bison character literal, decoding its escapes. |
2064 | The initial quote is already eaten. |
2065 `----------------------------------------------------------*/
2066
2067
2068 case 79:
2069 /* rule 79 can match eol */
2070 YY_RULE_SETUP
2071 #line 473 "scan-gram.l"
2072 {
2073 STRING_FINISH;
2074 loc->start = token_start;
2075 val->character = last_string[0];
2076 {
2077 /* FIXME: Eventually, make these errors. */
2078 if (last_string[0] == '\0')
2079 {
2080 warn_at (*loc, _("empty character literal"));
2081 /* '\0' seems dangerous even if we are about to complain. */
2082 val->character = '\'';
2083 }
2084 else if (last_string[1] != '\0')
2085 warn_at (*loc, _("extra characters in character literal"));
2086 }
2087 if (gram_text[0] == '\n')
2088 unexpected_newline (token_start, "'");
2089 STRING_FREE;
2090 BEGIN INITIAL;
2091 return CHAR;
2092 }
2093 YY_BREAK
2094 case YY_STATE_EOF(SC_ESCAPED_CHARACTER):
2095 #line 494 "scan-gram.l"
2096 {
2097 STRING_FINISH;
2098 loc->start = token_start;
2099 val->character = last_string[0];
2100 {
2101 /* FIXME: Eventually, make these errors. */
2102 if (last_string[0] == '\0')
2103 {
2104 warn_at (*loc, _("empty character literal"));
2105 /* '\0' seems dangerous even if we are about to complain. */
2106 val->character = '\'';
2107 }
2108 else if (last_string[1] != '\0')
2109 warn_at (*loc, _("extra characters in character literal"));
2110 }
2111 unexpected_eof (token_start, "'");
2112 STRING_FREE;
2113 BEGIN INITIAL;
2114 return CHAR;
2115 }
2116 YY_BREAK
2117
2118
2119
2120 case 80:
2121 YY_RULE_SETUP
2122 #line 518 "scan-gram.l"
2123 complain_at (*loc, _("invalid null character"));
2124 YY_BREAK
2125
2126 /*----------------------------.
2127 | Decode escaped characters. |
2128 `----------------------------*/
2129
2130
2131 case 81:
2132 YY_RULE_SETUP
2133 #line 528 "scan-gram.l"
2134 {
2135 unsigned long int c = strtoul (gram_text + 1, NULL, 8);
2136 if (!c || UCHAR_MAX < c)
2137 complain_at (*loc, _("invalid number after \\-escape: %s"),
2138 gram_text+1);
2139 else
2140 obstack_1grow (&obstack_for_string, c);
2141 }
2142 YY_BREAK
2143 case 82:
2144 YY_RULE_SETUP
2145 #line 537 "scan-gram.l"
2146 {
2147 verify (UCHAR_MAX < ULONG_MAX);
2148 unsigned long int c = strtoul (gram_text + 2, NULL, 16);
2149 if (!c || UCHAR_MAX < c)
2150 complain_at (*loc, _("invalid number after \\-escape: %s"),
2151 gram_text+1);
2152 else
2153 obstack_1grow (&obstack_for_string, c);
2154 }
2155 YY_BREAK
2156 case 83:
2157 YY_RULE_SETUP
2158 #line 547 "scan-gram.l"
2159 obstack_1grow (&obstack_for_string, '\a');
2160 YY_BREAK
2161 case 84:
2162 YY_RULE_SETUP
2163 #line 548 "scan-gram.l"
2164 obstack_1grow (&obstack_for_string, '\b');
2165 YY_BREAK
2166 case 85:
2167 YY_RULE_SETUP
2168 #line 549 "scan-gram.l"
2169 obstack_1grow (&obstack_for_string, '\f');
2170 YY_BREAK
2171 case 86:
2172 YY_RULE_SETUP
2173 #line 550 "scan-gram.l"
2174 obstack_1grow (&obstack_for_string, '\n');
2175 YY_BREAK
2176 case 87:
2177 YY_RULE_SETUP
2178 #line 551 "scan-gram.l"
2179 obstack_1grow (&obstack_for_string, '\r');
2180 YY_BREAK
2181 case 88:
2182 YY_RULE_SETUP
2183 #line 552 "scan-gram.l"
2184 obstack_1grow (&obstack_for_string, '\t');
2185 YY_BREAK
2186 case 89:
2187 YY_RULE_SETUP
2188 #line 553 "scan-gram.l"
2189 obstack_1grow (&obstack_for_string, '\v');
2190 YY_BREAK
2191 /* \\[\"\'?\\] would be shorter, but it confuses xgettext. */
2192 case 90:
2193 YY_RULE_SETUP
2194 #line 556 "scan-gram.l"
2195 obstack_1grow (&obstack_for_string, gram_text[1]);
2196 YY_BREAK
2197 case 91:
2198 YY_RULE_SETUP
2199 #line 558 "scan-gram.l"
2200 {
2201 int c = convert_ucn_to_byte (gram_text);
2202 if (c <= 0)
2203 complain_at (*loc, _("invalid number after \\-escape: %s"),
2204 gram_text+1);
2205 else
2206 obstack_1grow (&obstack_for_string, c);
2207 }
2208 YY_BREAK
2209 case 92:
2210 /* rule 92 can match eol */
2211 YY_RULE_SETUP
2212 #line 566 "scan-gram.l"
2213 {
2214 char const *p = gram_text + 1;
2215 /* Quote only if escaping won't make the character visible. */
2216 if (c_isspace ((unsigned char) *p) && c_isprint ((unsigned char) *p))
2217 p = quote (p);
2218 else
2219 p = quotearg_style_mem (escape_quoting_style, p, 1);
2220 complain_at (*loc, _("invalid character after \\-escape: %s"), p);
2221 }
2222 YY_BREAK
2223
2224 /*--------------------------------------------.
2225 | Scanning user-code characters and strings. |
2226 `--------------------------------------------*/
2227
2228
2229 case 93:
2230 /* rule 93 can match eol */
2231 YY_RULE_SETUP
2232 #line 583 "scan-gram.l"
2233 STRING_GROW;
2234 YY_BREAK
2235
2236
2237
2238 case 94:
2239 YY_RULE_SETUP
2240 #line 588 "scan-gram.l"
2241 STRING_GROW; BEGIN context_state;
2242 YY_BREAK
2243 case 95:
2244 /* rule 95 can match eol */
2245 YY_RULE_SETUP
2246 #line 589 "scan-gram.l"
2247 unexpected_newline (token_start, "'"); BEGIN context_state;
2248 YY_BREAK
2249 case YY_STATE_EOF(SC_CHARACTER):
2250 #line 590 "scan-gram.l"
2251 unexpected_eof (token_start, "'"); BEGIN context_state;
2252 YY_BREAK
2253
2254
2255
2256 case 96:
2257 YY_RULE_SETUP
2258 #line 595 "scan-gram.l"
2259 STRING_GROW; BEGIN context_state;
2260 YY_BREAK
2261 case 97:
2262 /* rule 97 can match eol */
2263 YY_RULE_SETUP
2264 #line 596 "scan-gram.l"
2265 unexpected_newline (token_start, "\""); BEGIN context_state;
2266 YY_BREAK
2267 case YY_STATE_EOF(SC_STRING):
2268 #line 597 "scan-gram.l"
2269 unexpected_eof (token_start, "\""); BEGIN context_state;
2270 YY_BREAK
2271
2272 /*---------------------------------------------------.
2273 | Strings, comments etc. can be found in user code. |
2274 `---------------------------------------------------*/
2275
2276
2277 case 98:
2278 YY_RULE_SETUP
2279 #line 607 "scan-gram.l"
2280 {
2281 STRING_GROW;
2282 context_state = YY_START;
2283 token_start = loc->start;
2284 BEGIN SC_CHARACTER;
2285 }
2286 YY_BREAK
2287 case 99:
2288 YY_RULE_SETUP
2289 #line 613 "scan-gram.l"
2290 {
2291 STRING_GROW;
2292 context_state = YY_START;
2293 token_start = loc->start;
2294 BEGIN SC_STRING;
2295 }
2296 YY_BREAK
2297 case 100:
2298 /* rule 100 can match eol */
2299 YY_RULE_SETUP
2300 #line 619 "scan-gram.l"
2301 {
2302 STRING_GROW;
2303 context_state = YY_START;
2304 token_start = loc->start;
2305 BEGIN SC_COMMENT;
2306 }
2307 YY_BREAK
2308 case 101:
2309 /* rule 101 can match eol */
2310 YY_RULE_SETUP
2311 #line 625 "scan-gram.l"
2312 {
2313 STRING_GROW;
2314 context_state = YY_START;
2315 BEGIN SC_LINE_COMMENT;
2316 }
2317 YY_BREAK
2318
2319 /*-----------------------------------------------------------.
2320 | Scanning some code in braces (actions). The initial "{" is |
2321 | already eaten. |
2322 `-----------------------------------------------------------*/
2323
2324
2325 case 102:
2326 /* rule 102 can match eol */
2327 YY_RULE_SETUP
2328 #line 641 "scan-gram.l"
2329 STRING_GROW; braces_level++;
2330 YY_BREAK
2331 case 103:
2332 /* rule 103 can match eol */
2333 YY_RULE_SETUP
2334 #line 642 "scan-gram.l"
2335 STRING_GROW; braces_level--;
2336 YY_BREAK
2337 case 104:
2338 YY_RULE_SETUP
2339 #line 643 "scan-gram.l"
2340 {
2341 obstack_1grow (&obstack_for_string, '}');
2342
2343 --braces_level;
2344 if (braces_level < 0)
2345 {
2346 STRING_FINISH;
2347 loc->start = code_start;
2348 val->code = last_string;
2349 BEGIN INITIAL;
2350 return BRACED_CODE;
2351 }
2352 }
2353 YY_BREAK
2354 /* Tokenize '<<%' correctly (as '<<' '%') rather than incorrrectly
2355 (as '<' '<%'). */
2356 case 105:
2357 /* rule 105 can match eol */
2358 YY_RULE_SETUP
2359 #line 659 "scan-gram.l"
2360 STRING_GROW;
2361 YY_BREAK
2362 case YY_STATE_EOF(SC_BRACED_CODE):
2363 #line 661 "scan-gram.l"
2364 {
2365 unexpected_eof (code_start, "}");
2366 STRING_FINISH;
2367 loc->start = code_start;
2368 val->code = last_string;
2369 BEGIN INITIAL;
2370 return BRACED_CODE;
2371 }
2372 YY_BREAK
2373
2374 /*--------------------------------------------------------------.
2375 | Scanning some prologue: from "%{" (already scanned) to "%}". |
2376 `--------------------------------------------------------------*/
2377
2378
2379 case 106:
2380 YY_RULE_SETUP
2381 #line 678 "scan-gram.l"
2382 {
2383 STRING_FINISH;
2384 loc->start = code_start;
2385 val->chars = last_string;
2386 BEGIN INITIAL;
2387 return PROLOGUE;
2388 }
2389 YY_BREAK
2390 case YY_STATE_EOF(SC_PROLOGUE):
2391 #line 686 "scan-gram.l"
2392 {
2393 unexpected_eof (code_start, "%}");
2394 STRING_FINISH;
2395 loc->start = code_start;
2396 val->chars = last_string;
2397 BEGIN INITIAL;
2398 return PROLOGUE;
2399 }
2400 YY_BREAK
2401
2402 /*---------------------------------------------------------------.
2403 | Scanning the epilogue (everything after the second "%%", which |
2404 | has already been eaten). |
2405 `---------------------------------------------------------------*/
2406
2407
2408 case YY_STATE_EOF(SC_EPILOGUE):
2409 #line 704 "scan-gram.l"
2410 {
2411 STRING_FINISH;
2412 loc->start = code_start;
2413 val->chars = last_string;
2414 BEGIN INITIAL;
2415 return EPILOGUE;
2416 }
2417 YY_BREAK
2418
2419 /*-----------------------------------------------------.
2420 | By default, grow the string obstack with the input. |
2421 `-----------------------------------------------------*/
2422 case 107:
2423 #line 719 "scan-gram.l"
2424 case 108:
2425 /* rule 108 can match eol */
2426 YY_RULE_SETUP
2427 #line 719 "scan-gram.l"
2428 STRING_GROW;
2429 YY_BREAK
2430 case 109:
2431 YY_RULE_SETUP
2432 #line 721 "scan-gram.l"
2433 YY_FATAL_ERROR( "flex scanner jammed" );
2434 YY_BREAK
2435 #line 2436 "scan-gram.c"
2436 case YY_STATE_EOF(SC_RETURN_BRACKETED_ID):
2437 yyterminate();
2438
2439 case YY_END_OF_BUFFER:
2440 {
2441 /* Amount of text matched not including the EOB char. */
2442 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
2443
2444 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2445 *yy_cp = (yy_hold_char);
2446 YY_RESTORE_YY_MORE_OFFSET
2447
2448 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2449 {
2450 /* We're scanning a new file or input source. It's
2451 * possible that this happened because the user
2452 * just pointed gram_in at a new source and called
2453 * gram_lex(). If so, then we have to assure
2454 * consistency between YY_CURRENT_BUFFER and our
2455 * globals. Here is the right place to do so, because
2456 * this is the first action (other than possibly a
2457 * back-up) that will match for the new input source.
2458 */
2459 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2460 YY_CURRENT_BUFFER_LVALUE->yy_input_file = gram_in;
2461 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
2462 }
2463
2464 /* Note that here we test for yy_c_buf_p "<=" to the position
2465 * of the first EOB in the buffer, since yy_c_buf_p will
2466 * already have been incremented past the NUL character
2467 * (since all states make transitions on EOB to the
2468 * end-of-buffer state). Contrast this with the test
2469 * in input().
2470 */
2471 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2472 { /* This was really a NUL. */
2473 yy_state_type yy_next_state;
2474
2475 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
2476
2477 yy_current_state = yy_get_previous_state( );
2478
2479 /* Okay, we're now positioned to make the NUL
2480 * transition. We couldn't have
2481 * yy_get_previous_state() go ahead and do it
2482 * for us because it doesn't know how to deal
2483 * with the possibility of jamming (and we don't
2484 * want to build jamming into it because then it
2485 * will run more slowly).
2486 */
2487
2488 yy_next_state = yy_try_NUL_trans( yy_current_state );
2489
2490 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2491
2492 if ( yy_next_state )
2493 {
2494 /* Consume the NUL. */
2495 yy_cp = ++(yy_c_buf_p);
2496 yy_current_state = yy_next_state;
2497 goto yy_match;
2498 }
2499
2500 else
2501 {
2502 /* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
2503 yy_cp = (yy_last_accepting_cpos);
2504 yy_current_state = (yy_last_accepting_state);
2505 goto yy_find_action;
2506 }
2507 }
2508
2509 else switch ( yy_get_next_buffer( ) )
2510 {
2511 case EOB_ACT_END_OF_FILE:
2512 {
2513 (yy_did_buffer_switch_on_eof) = 0;
2514
2515 if ( gram_wrap( ) )
2516 {
2517 /* Note: because we've taken care in
2518 * yy_get_next_buffer() to have set up
2519 * gram_text, we can now set up
2520 * yy_c_buf_p so that if some total
2521 * hoser (like flex itself) wants to
2522 * call the scanner after we return the
2523 * YY_NULL, it'll still work - another
2524 * YY_NULL will get returned.
2525 */
2526 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
2527
2528 yy_act = YY_STATE_EOF(YY_START);
2529 goto do_action;
2530 }
2531
2532 else
2533 {
2534 if ( ! (yy_did_buffer_switch_on_eof) )
2535 YY_NEW_FILE;
2536 }
2537 break;
2538 }
2539
2540 case EOB_ACT_CONTINUE_SCAN:
2541 (yy_c_buf_p) =
2542 (yytext_ptr) + yy_amount_of_matched_text;
2543
2544 yy_current_state = yy_get_previous_state( );
2545
2546 yy_cp = (yy_c_buf_p);
2547 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2548 goto yy_match;
2549
2550 case EOB_ACT_LAST_MATCH:
2551 (yy_c_buf_p) =
2552 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2553
2554 yy_current_state = yy_get_previous_state( );
2555
2556 yy_cp = (yy_c_buf_p);
2557 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2558 goto yy_find_action;
2559 }
2560 break;
2561 }
2562
2563 default:
2564 YY_FATAL_ERROR(
2565 "fatal flex scanner internal error--no action found" );
2566 } /* end of action switch */
2567 } /* end of scanning one token */
2568 } /* end of gram_lex */
2569 /* %ok-for-header */
2570
2571 /* %if-c++-only */
2572 /* %not-for-header */
2573
2574 /* %ok-for-header */
2575
2576 /* %endif */
2577
2578 /* yy_get_next_buffer - try to read in a new buffer
2579 *
2580 * Returns a code representing an action:
2581 * EOB_ACT_LAST_MATCH -
2582 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2583 * EOB_ACT_END_OF_FILE - end of file
2584 */
2585 /* %if-c-only */
yy_get_next_buffer(void)2586 static int yy_get_next_buffer (void)
2587 /* %endif */
2588 /* %if-c++-only */
2589 /* %endif */
2590 {
2591 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2592 register char *source = (yytext_ptr);
2593 register int number_to_move, i;
2594 int ret_val;
2595
2596 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
2597 YY_FATAL_ERROR(
2598 "fatal flex scanner internal error--end of buffer missed" );
2599
2600 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2601 { /* Don't try to fill the buffer, so this is an EOF. */
2602 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
2603 {
2604 /* We matched a single character, the EOB, so
2605 * treat this as a final EOF.
2606 */
2607 return EOB_ACT_END_OF_FILE;
2608 }
2609
2610 else
2611 {
2612 /* We matched some text prior to the EOB, first
2613 * process it.
2614 */
2615 return EOB_ACT_LAST_MATCH;
2616 }
2617 }
2618
2619 /* Try to read more data. */
2620
2621 /* First move last chars to start of buffer. */
2622 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
2623
2624 for ( i = 0; i < number_to_move; ++i )
2625 *(dest++) = *(source++);
2626
2627 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2628 /* don't do the read, it's not guaranteed to return an EOF,
2629 * just force an EOF
2630 */
2631 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2632
2633 else
2634 {
2635 yy_size_t num_to_read =
2636 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2637
2638 while ( num_to_read <= 0 )
2639 { /* Not enough room in the buffer - grow it. */
2640
2641 /* just a shorter name for the current buffer */
2642 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
2643
2644 int yy_c_buf_p_offset =
2645 (int) ((yy_c_buf_p) - b->yy_ch_buf);
2646
2647 if ( b->yy_is_our_buffer )
2648 {
2649 yy_size_t new_size = b->yy_buf_size * 2;
2650
2651 if ( new_size <= 0 )
2652 b->yy_buf_size += b->yy_buf_size / 8;
2653 else
2654 b->yy_buf_size *= 2;
2655
2656 b->yy_ch_buf = (char *)
2657 /* Include room in for 2 EOB chars. */
2658 gram_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
2659 }
2660 else
2661 /* Can't grow it, we don't own it. */
2662 b->yy_ch_buf = 0;
2663
2664 if ( ! b->yy_ch_buf )
2665 YY_FATAL_ERROR(
2666 "fatal error - scanner input buffer overflow" );
2667
2668 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
2669
2670 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2671 number_to_move - 1;
2672
2673 }
2674
2675 if ( num_to_read > YY_READ_BUF_SIZE )
2676 num_to_read = YY_READ_BUF_SIZE;
2677
2678 /* Read in more data. */
2679 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2680 (yy_n_chars), num_to_read );
2681
2682 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2683 }
2684
2685 if ( (yy_n_chars) == 0 )
2686 {
2687 if ( number_to_move == YY_MORE_ADJ )
2688 {
2689 ret_val = EOB_ACT_END_OF_FILE;
2690 gram_restart(gram_in );
2691 }
2692
2693 else
2694 {
2695 ret_val = EOB_ACT_LAST_MATCH;
2696 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2697 YY_BUFFER_EOF_PENDING;
2698 }
2699 }
2700
2701 else
2702 ret_val = EOB_ACT_CONTINUE_SCAN;
2703
2704 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
2705 /* Extend the array by 50%, plus the number we really need. */
2706 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
2707 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) gram_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
2708 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2709 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
2710 }
2711
2712 (yy_n_chars) += number_to_move;
2713 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2714 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2715
2716 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2717
2718 return ret_val;
2719 }
2720
2721 /* yy_get_previous_state - get the state just before the EOB char was reached */
2722
2723 /* %if-c-only */
2724 /* %not-for-header */
2725
yy_get_previous_state(void)2726 static yy_state_type yy_get_previous_state (void)
2727 /* %endif */
2728 /* %if-c++-only */
2729 /* %endif */
2730 {
2731 register yy_state_type yy_current_state;
2732 register char *yy_cp;
2733
2734 /* %% [15.0] code to get the start state into yy_current_state goes here */
2735 yy_current_state = (yy_start);
2736 yy_current_state += YY_AT_BOL();
2737
2738 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
2739 {
2740 /* %% [16.0] code to find the next state goes here */
2741 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 58);
2742 if ( yy_accept[yy_current_state] )
2743 {
2744 (yy_last_accepting_state) = yy_current_state;
2745 (yy_last_accepting_cpos) = yy_cp;
2746 }
2747 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2748 {
2749 yy_current_state = (int) yy_def[yy_current_state];
2750 if ( yy_current_state >= 482 )
2751 yy_c = yy_meta[(unsigned int) yy_c];
2752 }
2753 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2754 }
2755
2756 return yy_current_state;
2757 }
2758
2759 /* yy_try_NUL_trans - try to make a transition on the NUL character
2760 *
2761 * synopsis
2762 * next_state = yy_try_NUL_trans( current_state );
2763 */
2764 /* %if-c-only */
yy_try_NUL_trans(yy_state_type yy_current_state)2765 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
2766 /* %endif */
2767 /* %if-c++-only */
2768 /* %endif */
2769 {
2770 register int yy_is_jam;
2771 /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */
2772 register char *yy_cp = (yy_c_buf_p);
2773
2774 register YY_CHAR yy_c = 58;
2775 if ( yy_accept[yy_current_state] )
2776 {
2777 (yy_last_accepting_state) = yy_current_state;
2778 (yy_last_accepting_cpos) = yy_cp;
2779 }
2780 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2781 {
2782 yy_current_state = (int) yy_def[yy_current_state];
2783 if ( yy_current_state >= 482 )
2784 yy_c = yy_meta[(unsigned int) yy_c];
2785 }
2786 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2787 yy_is_jam = (yy_current_state == 481);
2788
2789 return yy_is_jam ? 0 : yy_current_state;
2790 }
2791
2792 /* %if-c-only */
2793
2794 /* %endif */
2795
2796 /* %if-c-only */
2797 #ifndef YY_NO_INPUT
2798 #ifdef __cplusplus
yyinput(void)2799 static int yyinput (void)
2800 #else
2801 static int input (void)
2802 #endif
2803
2804 /* %endif */
2805 /* %if-c++-only */
2806 /* %endif */
2807 {
2808 int c;
2809
2810 *(yy_c_buf_p) = (yy_hold_char);
2811
2812 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2813 {
2814 /* yy_c_buf_p now points to the character we want to return.
2815 * If this occurs *before* the EOB characters, then it's a
2816 * valid NUL; if not, then we've hit the end of the buffer.
2817 */
2818 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2819 /* This was really a NUL. */
2820 *(yy_c_buf_p) = '\0';
2821
2822 else
2823 { /* need more input */
2824 yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
2825 ++(yy_c_buf_p);
2826
2827 switch ( yy_get_next_buffer( ) )
2828 {
2829 case EOB_ACT_LAST_MATCH:
2830 /* This happens because yy_g_n_b()
2831 * sees that we've accumulated a
2832 * token and flags that we need to
2833 * try matching the token before
2834 * proceeding. But for input(),
2835 * there's no matching to consider.
2836 * So convert the EOB_ACT_LAST_MATCH
2837 * to EOB_ACT_END_OF_FILE.
2838 */
2839
2840 /* Reset buffer status. */
2841 gram_restart(gram_in );
2842
2843 /*FALLTHROUGH*/
2844
2845 case EOB_ACT_END_OF_FILE:
2846 {
2847 if ( gram_wrap( ) )
2848 return EOF;
2849
2850 if ( ! (yy_did_buffer_switch_on_eof) )
2851 YY_NEW_FILE;
2852 #ifdef __cplusplus
2853 return yyinput();
2854 #else
2855 return input();
2856 #endif
2857 }
2858
2859 case EOB_ACT_CONTINUE_SCAN:
2860 (yy_c_buf_p) = (yytext_ptr) + offset;
2861 break;
2862 }
2863 }
2864 }
2865
2866 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
2867 *(yy_c_buf_p) = '\0'; /* preserve gram_text */
2868 (yy_hold_char) = *++(yy_c_buf_p);
2869
2870 /* %% [19.0] update BOL and gram_lineno */
2871 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
2872
2873 return c;
2874 }
2875 /* %if-c-only */
2876 #endif /* ifndef YY_NO_INPUT */
2877 /* %endif */
2878
2879 /** Immediately switch to a different input stream.
2880 * @param input_file A readable stream.
2881 *
2882 * @note This function does not reset the start condition to @c INITIAL .
2883 */
2884 /* %if-c-only */
gram_restart(FILE * input_file)2885 void gram_restart (FILE * input_file )
2886 /* %endif */
2887 /* %if-c++-only */
2888 /* %endif */
2889 {
2890
2891 if ( ! YY_CURRENT_BUFFER ){
2892 gram_ensure_buffer_stack ();
2893 YY_CURRENT_BUFFER_LVALUE =
2894 gram__create_buffer(gram_in,YY_BUF_SIZE );
2895 }
2896
2897 gram__init_buffer(YY_CURRENT_BUFFER,input_file );
2898 gram__load_buffer_state( );
2899 }
2900
2901 /** Switch to a different input buffer.
2902 * @param new_buffer The new input buffer.
2903 *
2904 */
2905 /* %if-c-only */
gram__switch_to_buffer(YY_BUFFER_STATE new_buffer)2906 void gram__switch_to_buffer (YY_BUFFER_STATE new_buffer )
2907 /* %endif */
2908 /* %if-c++-only */
2909 /* %endif */
2910 {
2911
2912 /* TODO. We should be able to replace this entire function body
2913 * with
2914 * gram_pop_buffer_state();
2915 * gram_push_buffer_state(new_buffer);
2916 */
2917 gram_ensure_buffer_stack ();
2918 if ( YY_CURRENT_BUFFER == new_buffer )
2919 return;
2920
2921 if ( YY_CURRENT_BUFFER )
2922 {
2923 /* Flush out information for old buffer. */
2924 *(yy_c_buf_p) = (yy_hold_char);
2925 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2926 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2927 }
2928
2929 YY_CURRENT_BUFFER_LVALUE = new_buffer;
2930 gram__load_buffer_state( );
2931
2932 /* We don't actually know whether we did this switch during
2933 * EOF (gram_wrap()) processing, but the only time this flag
2934 * is looked at is after gram_wrap() is called, so it's safe
2935 * to go ahead and always set it.
2936 */
2937 (yy_did_buffer_switch_on_eof) = 1;
2938 }
2939
2940 /* %if-c-only */
gram__load_buffer_state(void)2941 static void gram__load_buffer_state (void)
2942 /* %endif */
2943 /* %if-c++-only */
2944 /* %endif */
2945 {
2946 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2947 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2948 gram_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2949 (yy_hold_char) = *(yy_c_buf_p);
2950 }
2951
2952 /** Allocate and initialize an input buffer state.
2953 * @param file A readable stream.
2954 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2955 *
2956 * @return the allocated buffer state.
2957 */
2958 /* %if-c-only */
gram__create_buffer(FILE * file,int size)2959 YY_BUFFER_STATE gram__create_buffer (FILE * file, int size )
2960 /* %endif */
2961 /* %if-c++-only */
2962 /* %endif */
2963 {
2964 YY_BUFFER_STATE b;
2965
2966 b = (YY_BUFFER_STATE) gram_alloc(sizeof( struct yy_buffer_state ) );
2967 if ( ! b )
2968 YY_FATAL_ERROR( "out of dynamic memory in gram__create_buffer()" );
2969
2970 b->yy_buf_size = size;
2971
2972 /* yy_ch_buf has to be 2 characters longer than the size given because
2973 * we need to put in 2 end-of-buffer characters.
2974 */
2975 b->yy_ch_buf = (char *) gram_alloc(b->yy_buf_size + 2 );
2976 if ( ! b->yy_ch_buf )
2977 YY_FATAL_ERROR( "out of dynamic memory in gram__create_buffer()" );
2978
2979 b->yy_is_our_buffer = 1;
2980
2981 gram__init_buffer(b,file );
2982
2983 return b;
2984 }
2985
2986 /** Destroy the buffer.
2987 * @param b a buffer created with gram__create_buffer()
2988 *
2989 */
2990 /* %if-c-only */
gram__delete_buffer(YY_BUFFER_STATE b)2991 void gram__delete_buffer (YY_BUFFER_STATE b )
2992 /* %endif */
2993 /* %if-c++-only */
2994 /* %endif */
2995 {
2996
2997 if ( ! b )
2998 return;
2999
3000 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
3001 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
3002
3003 if ( b->yy_is_our_buffer )
3004 gram_free((void *) b->yy_ch_buf );
3005
3006 gram_free((void *) b );
3007 }
3008
3009 /* Initializes or reinitializes a buffer.
3010 * This function is sometimes called more than once on the same buffer,
3011 * such as during a gram_restart() or at EOF.
3012 */
3013 /* %if-c-only */
gram__init_buffer(YY_BUFFER_STATE b,FILE * file)3014 static void gram__init_buffer (YY_BUFFER_STATE b, FILE * file )
3015 /* %endif */
3016 /* %if-c++-only */
3017 /* %endif */
3018
3019 {
3020 int oerrno = errno;
3021
3022 gram__flush_buffer(b );
3023
3024 b->yy_input_file = file;
3025 b->yy_fill_buffer = 1;
3026
3027 /* If b is the current buffer, then gram__init_buffer was _probably_
3028 * called from gram_restart() or through yy_get_next_buffer.
3029 * In that case, we don't want to reset the lineno or column.
3030 */
3031 if (b != YY_CURRENT_BUFFER){
3032 b->yy_bs_lineno = 1;
3033 b->yy_bs_column = 0;
3034 }
3035
3036 /* %if-c-only */
3037
3038 b->yy_is_interactive = 0;
3039
3040 /* %endif */
3041 /* %if-c++-only */
3042 /* %endif */
3043 errno = oerrno;
3044 }
3045
3046 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
3047 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
3048 *
3049 */
3050 /* %if-c-only */
gram__flush_buffer(YY_BUFFER_STATE b)3051 void gram__flush_buffer (YY_BUFFER_STATE b )
3052 /* %endif */
3053 /* %if-c++-only */
3054 /* %endif */
3055 {
3056 if ( ! b )
3057 return;
3058
3059 b->yy_n_chars = 0;
3060
3061 /* We always need two end-of-buffer characters. The first causes
3062 * a transition to the end-of-buffer state. The second causes
3063 * a jam in that state.
3064 */
3065 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
3066 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
3067
3068 b->yy_buf_pos = &b->yy_ch_buf[0];
3069
3070 b->yy_at_bol = 1;
3071 b->yy_buffer_status = YY_BUFFER_NEW;
3072
3073 if ( b == YY_CURRENT_BUFFER )
3074 gram__load_buffer_state( );
3075 }
3076
3077 /* %if-c-or-c++ */
3078 /** Pushes the new state onto the stack. The new state becomes
3079 * the current state. This function will allocate the stack
3080 * if necessary.
3081 * @param new_buffer The new state.
3082 *
3083 */
3084 /* %if-c-only */
gram_push_buffer_state(YY_BUFFER_STATE new_buffer)3085 void gram_push_buffer_state (YY_BUFFER_STATE new_buffer )
3086 /* %endif */
3087 /* %if-c++-only */
3088 /* %endif */
3089 {
3090 if (new_buffer == NULL)
3091 return;
3092
3093 gram_ensure_buffer_stack();
3094
3095 /* This block is copied from gram__switch_to_buffer. */
3096 if ( YY_CURRENT_BUFFER )
3097 {
3098 /* Flush out information for old buffer. */
3099 *(yy_c_buf_p) = (yy_hold_char);
3100 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3101 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3102 }
3103
3104 /* Only push if top exists. Otherwise, replace top. */
3105 if (YY_CURRENT_BUFFER)
3106 (yy_buffer_stack_top)++;
3107 YY_CURRENT_BUFFER_LVALUE = new_buffer;
3108
3109 /* copied from gram__switch_to_buffer. */
3110 gram__load_buffer_state( );
3111 (yy_did_buffer_switch_on_eof) = 1;
3112 }
3113 /* %endif */
3114
3115 /* %if-c-or-c++ */
3116 /** Removes and deletes the top of the stack, if present.
3117 * The next element becomes the new top.
3118 *
3119 */
3120 /* %if-c-only */
gram_pop_buffer_state(void)3121 void gram_pop_buffer_state (void)
3122 /* %endif */
3123 /* %if-c++-only */
3124 /* %endif */
3125 {
3126 if (!YY_CURRENT_BUFFER)
3127 return;
3128
3129 gram__delete_buffer(YY_CURRENT_BUFFER );
3130 YY_CURRENT_BUFFER_LVALUE = NULL;
3131 if ((yy_buffer_stack_top) > 0)
3132 --(yy_buffer_stack_top);
3133
3134 if (YY_CURRENT_BUFFER) {
3135 gram__load_buffer_state( );
3136 (yy_did_buffer_switch_on_eof) = 1;
3137 }
3138 }
3139 /* %endif */
3140
3141 /* %if-c-or-c++ */
3142 /* Allocates the stack if it does not exist.
3143 * Guarantees space for at least one push.
3144 */
3145 /* %if-c-only */
gram_ensure_buffer_stack(void)3146 static void gram_ensure_buffer_stack (void)
3147 /* %endif */
3148 /* %if-c++-only */
3149 /* %endif */
3150 {
3151 yy_size_t num_to_alloc;
3152
3153 if (!(yy_buffer_stack)) {
3154
3155 /* First allocation is just for 2 elements, since we don't know if this
3156 * scanner will even need a stack. We use 2 instead of 1 to avoid an
3157 * immediate realloc on the next call.
3158 */
3159 num_to_alloc = 1;
3160 (yy_buffer_stack) = (struct yy_buffer_state**)gram_alloc
3161 (num_to_alloc * sizeof(struct yy_buffer_state*)
3162 );
3163 if ( ! (yy_buffer_stack) )
3164 YY_FATAL_ERROR( "out of dynamic memory in gram_ensure_buffer_stack()" );
3165
3166 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
3167
3168 (yy_buffer_stack_max) = num_to_alloc;
3169 (yy_buffer_stack_top) = 0;
3170 return;
3171 }
3172
3173 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
3174
3175 /* Increase the buffer to prepare for a possible push. */
3176 int grow_size = 8 /* arbitrary grow size */;
3177
3178 num_to_alloc = (yy_buffer_stack_max) + grow_size;
3179 (yy_buffer_stack) = (struct yy_buffer_state**)gram_realloc
3180 ((yy_buffer_stack),
3181 num_to_alloc * sizeof(struct yy_buffer_state*)
3182 );
3183 if ( ! (yy_buffer_stack) )
3184 YY_FATAL_ERROR( "out of dynamic memory in gram_ensure_buffer_stack()" );
3185
3186 /* zero only the new slots.*/
3187 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
3188 (yy_buffer_stack_max) = num_to_alloc;
3189 }
3190 }
3191 /* %endif */
3192
3193 /* %if-c-only */
3194 /** Setup the input buffer state to scan directly from a user-specified character buffer.
3195 * @param base the character buffer
3196 * @param size the size in bytes of the character buffer
3197 *
3198 * @return the newly allocated buffer state object.
3199 */
gram__scan_buffer(char * base,yy_size_t size)3200 YY_BUFFER_STATE gram__scan_buffer (char * base, yy_size_t size )
3201 {
3202 YY_BUFFER_STATE b;
3203
3204 if ( size < 2 ||
3205 base[size-2] != YY_END_OF_BUFFER_CHAR ||
3206 base[size-1] != YY_END_OF_BUFFER_CHAR )
3207 /* They forgot to leave room for the EOB's. */
3208 return 0;
3209
3210 b = (YY_BUFFER_STATE) gram_alloc(sizeof( struct yy_buffer_state ) );
3211 if ( ! b )
3212 YY_FATAL_ERROR( "out of dynamic memory in gram__scan_buffer()" );
3213
3214 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
3215 b->yy_buf_pos = b->yy_ch_buf = base;
3216 b->yy_is_our_buffer = 0;
3217 b->yy_input_file = 0;
3218 b->yy_n_chars = b->yy_buf_size;
3219 b->yy_is_interactive = 0;
3220 b->yy_at_bol = 1;
3221 b->yy_fill_buffer = 0;
3222 b->yy_buffer_status = YY_BUFFER_NEW;
3223
3224 gram__switch_to_buffer(b );
3225
3226 return b;
3227 }
3228 /* %endif */
3229
3230 /* %if-c-only */
3231 /** Setup the input buffer state to scan a string. The next call to gram_lex() will
3232 * scan from a @e copy of @a str.
3233 * @param yystr a NUL-terminated string to scan
3234 *
3235 * @return the newly allocated buffer state object.
3236 * @note If you want to scan bytes that may contain NUL values, then use
3237 * gram__scan_bytes() instead.
3238 */
gram__scan_string(yyconst char * yystr)3239 YY_BUFFER_STATE gram__scan_string (yyconst char * yystr )
3240 {
3241
3242 return gram__scan_bytes(yystr,strlen(yystr) );
3243 }
3244 /* %endif */
3245
3246 /* %if-c-only */
3247 /** Setup the input buffer state to scan the given bytes. The next call to gram_lex() will
3248 * scan from a @e copy of @a bytes.
3249 * @param yybytes the byte buffer to scan
3250 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
3251 *
3252 * @return the newly allocated buffer state object.
3253 */
gram__scan_bytes(yyconst char * yybytes,yy_size_t _yybytes_len)3254 YY_BUFFER_STATE gram__scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
3255 {
3256 YY_BUFFER_STATE b;
3257 char *buf;
3258 yy_size_t n;
3259 int i;
3260
3261 /* Get memory for full buffer, including space for trailing EOB's. */
3262 n = _yybytes_len + 2;
3263 buf = (char *) gram_alloc(n );
3264 if ( ! buf )
3265 YY_FATAL_ERROR( "out of dynamic memory in gram__scan_bytes()" );
3266
3267 for ( i = 0; i < _yybytes_len; ++i )
3268 buf[i] = yybytes[i];
3269
3270 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
3271
3272 b = gram__scan_buffer(buf,n );
3273 if ( ! b )
3274 YY_FATAL_ERROR( "bad buffer in gram__scan_bytes()" );
3275
3276 /* It's okay to grow etc. this buffer, and we should throw it
3277 * away when we're done.
3278 */
3279 b->yy_is_our_buffer = 1;
3280
3281 return b;
3282 }
3283 /* %endif */
3284
3285 #ifndef YY_EXIT_FAILURE
3286 #define YY_EXIT_FAILURE 2
3287 #endif
3288
3289 /* %if-c-only */
yy_fatal_error(yyconst char * msg)3290 static void yy_fatal_error (yyconst char* msg )
3291 {
3292 (void) fprintf( stderr, "%s\n", msg );
3293 exit( YY_EXIT_FAILURE );
3294 }
3295 /* %endif */
3296 /* %if-c++-only */
3297 /* %endif */
3298
3299 /* Redefine yyless() so it works in section 3 code. */
3300
3301 #undef yyless
3302 #define yyless(n) \
3303 do \
3304 { \
3305 /* Undo effects of setting up gram_text. */ \
3306 int yyless_macro_arg = (n); \
3307 YY_LESS_LINENO(yyless_macro_arg);\
3308 gram_text[gram_leng] = (yy_hold_char); \
3309 (yy_c_buf_p) = gram_text + yyless_macro_arg; \
3310 (yy_hold_char) = *(yy_c_buf_p); \
3311 *(yy_c_buf_p) = '\0'; \
3312 gram_leng = yyless_macro_arg; \
3313 } \
3314 while ( 0 )
3315
3316 /* Accessor methods (get/set functions) to struct members. */
3317
3318 /* %if-c-only */
3319 /* %if-reentrant */
3320 /* %endif */
3321
3322 /** Get the current line number.
3323 *
3324 */
gram_get_lineno(void)3325 int gram_get_lineno (void)
3326 {
3327
3328 return gram_lineno;
3329 }
3330
3331 /** Get the input stream.
3332 *
3333 */
gram_get_in(void)3334 FILE *gram_get_in (void)
3335 {
3336 return gram_in;
3337 }
3338
3339 /** Get the output stream.
3340 *
3341 */
gram_get_out(void)3342 FILE *gram_get_out (void)
3343 {
3344 return gram_out;
3345 }
3346
3347 /** Get the length of the current token.
3348 *
3349 */
gram_get_leng(void)3350 yy_size_t gram_get_leng (void)
3351 {
3352 return gram_leng;
3353 }
3354
3355 /** Get the current token.
3356 *
3357 */
3358
gram_get_text(void)3359 char *gram_get_text (void)
3360 {
3361 return gram_text;
3362 }
3363
3364 /* %if-reentrant */
3365 /* %endif */
3366
3367 /** Set the current line number.
3368 * @param line_number
3369 *
3370 */
gram_set_lineno(int line_number)3371 void gram_set_lineno (int line_number )
3372 {
3373
3374 gram_lineno = line_number;
3375 }
3376
3377 /** Set the input stream. This does not discard the current
3378 * input buffer.
3379 * @param in_str A readable stream.
3380 *
3381 * @see gram__switch_to_buffer
3382 */
gram_set_in(FILE * in_str)3383 void gram_set_in (FILE * in_str )
3384 {
3385 gram_in = in_str ;
3386 }
3387
gram_set_out(FILE * out_str)3388 void gram_set_out (FILE * out_str )
3389 {
3390 gram_out = out_str ;
3391 }
3392
gram_get_debug(void)3393 int gram_get_debug (void)
3394 {
3395 return gram__flex_debug;
3396 }
3397
gram_set_debug(int bdebug)3398 void gram_set_debug (int bdebug )
3399 {
3400 gram__flex_debug = bdebug ;
3401 }
3402
3403 /* %endif */
3404
3405 /* %if-reentrant */
3406 /* %if-bison-bridge */
3407 /* %endif */
3408 /* %endif if-c-only */
3409
3410 /* %if-c-only */
yy_init_globals(void)3411 static int yy_init_globals (void)
3412 {
3413 /* Initialization is the same as for the non-reentrant scanner.
3414 * This function is called from gram_lex_destroy(), so don't allocate here.
3415 */
3416
3417 (yy_buffer_stack) = 0;
3418 (yy_buffer_stack_top) = 0;
3419 (yy_buffer_stack_max) = 0;
3420 (yy_c_buf_p) = (char *) 0;
3421 (yy_init) = 0;
3422 (yy_start) = 0;
3423
3424 /* Defined in main.c */
3425 #ifdef YY_STDINIT
3426 gram_in = stdin;
3427 gram_out = stdout;
3428 #else
3429 gram_in = (FILE *) 0;
3430 gram_out = (FILE *) 0;
3431 #endif
3432
3433 /* For future reference: Set errno on error, since we are called by
3434 * gram_lex_init()
3435 */
3436 return 0;
3437 }
3438 /* %endif */
3439
3440 /* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */
3441 /* gram_lex_destroy is for both reentrant and non-reentrant scanners. */
gram_lex_destroy(void)3442 int gram_lex_destroy (void)
3443 {
3444
3445 /* Pop the buffer stack, destroying each element. */
3446 while(YY_CURRENT_BUFFER){
3447 gram__delete_buffer(YY_CURRENT_BUFFER );
3448 YY_CURRENT_BUFFER_LVALUE = NULL;
3449 gram_pop_buffer_state();
3450 }
3451
3452 /* Destroy the stack itself. */
3453 gram_free((yy_buffer_stack) );
3454 (yy_buffer_stack) = NULL;
3455
3456 /* Reset the globals. This is important in a non-reentrant scanner so the next time
3457 * gram_lex() is called, initialization will occur. */
3458 yy_init_globals( );
3459
3460 /* %if-reentrant */
3461 /* %endif */
3462 return 0;
3463 }
3464 /* %endif */
3465
3466 /*
3467 * Internal utility routines.
3468 */
3469
3470 #ifndef yytext_ptr
yy_flex_strncpy(char * s1,yyconst char * s2,int n)3471 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
3472 {
3473 register int i;
3474 for ( i = 0; i < n; ++i )
3475 s1[i] = s2[i];
3476 }
3477 #endif
3478
3479 #ifdef YY_NEED_STRLEN
yy_flex_strlen(yyconst char * s)3480 static int yy_flex_strlen (yyconst char * s )
3481 {
3482 register int n;
3483 for ( n = 0; s[n]; ++n )
3484 ;
3485
3486 return n;
3487 }
3488 #endif
3489
gram_alloc(yy_size_t size)3490 void *gram_alloc (yy_size_t size )
3491 {
3492 return (void *) malloc( size );
3493 }
3494
gram_realloc(void * ptr,yy_size_t size)3495 void *gram_realloc (void * ptr, yy_size_t size )
3496 {
3497 /* The cast to (char *) in the following accommodates both
3498 * implementations that use char* generic pointers, and those
3499 * that use void* generic pointers. It works with the latter
3500 * because both ANSI C and C++ allow castless assignment from
3501 * any pointer type to void*, and deal with argument conversions
3502 * as though doing an assignment.
3503 */
3504 return (void *) realloc( (char *) ptr, size );
3505 }
3506
gram_free(void * ptr)3507 void gram_free (void * ptr )
3508 {
3509 free( (char *) ptr ); /* see gram_realloc() for (char *) cast */
3510 }
3511
3512 /* %if-tables-serialization definitions */
3513 /* %define-yytables The name for this specific scanner's tables. */
3514 #define YYTABLES_NAME "yytables"
3515 /* %endif */
3516
3517 /* %ok-for-header */
3518
3519 #line 721 "scan-gram.l"
3520
3521
3522
3523 /* Read bytes from FP into buffer BUF of size SIZE. Return the
3524 number of bytes read. Remove '\r' from input, treating \r\n
3525 and isolated \r as \n. */
3526
3527 static size_t
no_cr_read(FILE * fp,char * buf,size_t size)3528 no_cr_read (FILE *fp, char *buf, size_t size)
3529 {
3530 size_t bytes_read = fread (buf, 1, size, fp);
3531 if (bytes_read)
3532 {
3533 char *w = memchr (buf, '\r', bytes_read);
3534 if (w)
3535 {
3536 char const *r = ++w;
3537 char const *lim = buf + bytes_read;
3538
3539 for (;;)
3540 {
3541 /* Found an '\r'. Treat it like '\n', but ignore any
3542 '\n' that immediately follows. */
3543 w[-1] = '\n';
3544 if (r == lim)
3545 {
3546 int ch = getc (fp);
3547 if (ch != '\n' && ungetc (ch, fp) != ch)
3548 break;
3549 }
3550 else if (*r == '\n')
3551 r++;
3552
3553 /* Copy until the next '\r'. */
3554 do
3555 {
3556 if (r == lim)
3557 return w - buf;
3558 }
3559 while ((*w++ = *r++) != '\r');
3560 }
3561
3562 return w - buf;
3563 }
3564 }
3565
3566 return bytes_read;
3567 }
3568
3569
3570
3571 /*------------------------------------------------------.
3572 | Scan NUMBER for a base-BASE integer at location LOC. |
3573 `------------------------------------------------------*/
3574
3575 static unsigned long int
scan_integer(char const * number,int base,location loc)3576 scan_integer (char const *number, int base, location loc)
3577 {
3578 verify (INT_MAX < ULONG_MAX);
3579 unsigned long int num = strtoul (number, NULL, base);
3580
3581 if (INT_MAX < num)
3582 {
3583 complain_at (loc, _("integer out of range: %s"), quote (number));
3584 num = INT_MAX;
3585 }
3586
3587 return num;
3588 }
3589
3590
3591 /*------------------------------------------------------------------.
3592 | Convert universal character name UCN to a single-byte character, |
3593 | and return that character. Return -1 if UCN does not correspond |
3594 | to a single-byte character. |
3595 `------------------------------------------------------------------*/
3596
3597 static int
convert_ucn_to_byte(char const * ucn)3598 convert_ucn_to_byte (char const *ucn)
3599 {
3600 verify (UCHAR_MAX <= INT_MAX);
3601 unsigned long int code = strtoul (ucn + 2, NULL, 16);
3602
3603 /* FIXME: Currently we assume Unicode-compatible unibyte characters
3604 on ASCII hosts (i.e., Latin-1 on hosts with 8-bit bytes). On
3605 non-ASCII hosts we support only the portable C character set.
3606 These limitations should be removed once we add support for
3607 multibyte characters. */
3608
3609 if (UCHAR_MAX < code)
3610 return -1;
3611
3612 #if ! ('$' == 0x24 && '@' == 0x40 && '`' == 0x60 && '~' == 0x7e)
3613 {
3614 /* A non-ASCII host. Use CODE to index into a table of the C
3615 basic execution character set, which is guaranteed to exist on
3616 all Standard C platforms. This table also includes '$', '@',
3617 and '`', which are not in the basic execution character set but
3618 which are unibyte characters on all the platforms that we know
3619 about. */
3620 static signed char const table[] =
3621 {
3622 '\0', -1, -1, -1, -1, -1, -1, '\a',
3623 '\b', '\t', '\n', '\v', '\f', '\r', -1, -1,
3624 -1, -1, -1, -1, -1, -1, -1, -1,
3625 -1, -1, -1, -1, -1, -1, -1, -1,
3626 ' ', '!', '"', '#', '$', '%', '&', '\'',
3627 '(', ')', '*', '+', ',', '-', '.', '/',
3628 '0', '1', '2', '3', '4', '5', '6', '7',
3629 '8', '9', ':', ';', '<', '=', '>', '?',
3630 '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
3631 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
3632 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
3633 'X', 'Y', 'Z', '[', '\\', ']', '^', '_',
3634 '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
3635 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
3636 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
3637 'x', 'y', 'z', '{', '|', '}', '~'
3638 };
3639
3640 code = code < sizeof table ? table[code] : -1;
3641 }
3642 #endif
3643
3644 return code;
3645 }
3646
3647
3648 /*---------------------------------------------------------------------.
3649 | Handle '#line INT( "FILE")?\n'. ARGS has already skipped '#line '. |
3650 `---------------------------------------------------------------------*/
3651
3652 static void
handle_syncline(char * args,location loc)3653 handle_syncline (char *args, location loc)
3654 {
3655 char *file;
3656 unsigned long int lineno = strtoul (args, &file, 10);
3657 if (INT_MAX <= lineno)
3658 {
3659 warn_at (loc, _("line number overflow"));
3660 lineno = INT_MAX;
3661 }
3662
3663 file = mbschr (file, '"');
3664 if (file)
3665 {
3666 *mbschr (file + 1, '"') = '\0';
3667 current_file = uniqstr_new (file + 1);
3668 }
3669 boundary_set (&scanner_cursor, current_file, lineno, 1);
3670 }
3671
3672
3673 /*----------------------------------------------------------------.
3674 | For a token or comment starting at START, report message MSGID, |
3675 | which should say that an end marker was found before |
3676 | the expected TOKEN_END. |
3677 `----------------------------------------------------------------*/
3678
3679 static void
unexpected_end(boundary start,char const * msgid,char const * token_end)3680 unexpected_end (boundary start, char const *msgid, char const *token_end)
3681 {
3682 location loc;
3683 loc.start = start;
3684 loc.end = scanner_cursor;
3685 token_end = quote (token_end);
3686 /* Instead of '\'', display "'". */
3687 if (!strcmp (token_end, "'\\''"))
3688 token_end = "\"'\"";
3689 complain_at (loc, _(msgid), token_end);
3690 }
3691
3692
3693 /*------------------------------------------------------------------------.
3694 | Report an unexpected EOF in a token or comment starting at START. |
3695 | An end of file was encountered and the expected TOKEN_END was missing. |
3696 `------------------------------------------------------------------------*/
3697
3698 static void
unexpected_eof(boundary start,char const * token_end)3699 unexpected_eof (boundary start, char const *token_end)
3700 {
3701 unexpected_end (start, N_("missing %s at end of file"), token_end);
3702 }
3703
3704
3705 /*----------------------------------------.
3706 | Likewise, but for unexpected newlines. |
3707 `----------------------------------------*/
3708
3709 static void
unexpected_newline(boundary start,char const * token_end)3710 unexpected_newline (boundary start, char const *token_end)
3711 {
3712 unexpected_end (start, N_("missing %s at end of line"), token_end);
3713 }
3714
3715
3716 /*-------------------------.
3717 | Initialize the scanner. |
3718 `-------------------------*/
3719
3720 void
gram_scanner_initialize(void)3721 gram_scanner_initialize (void)
3722 {
3723 obstack_init (&obstack_for_string);
3724 }
3725
3726
3727 /*-----------------------------------------------.
3728 | Free all the memory allocated to the scanner. |
3729 `-----------------------------------------------*/
3730
3731 void
gram_scanner_free(void)3732 gram_scanner_free (void)
3733 {
3734 obstack_free (&obstack_for_string, 0);
3735 /* Reclaim Flex's buffers. */
3736 gram_lex_destroy ();
3737 }
3738
3739