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