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