]> git.saurik.com Git - bison.git/blob - src/scan-gram.c
projects / bison.git / blob
? search:


94e0d9d01ce7a32285fe8af7e5029df7a120abe7
[bison.git] / src / scan-gram.c
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>
30 #include <errno.h>
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>
43 #ifndef _WIN32
44 #include <unistd.h>
45 #endif
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
119 typedef struct yy_buffer_state *YY_BUFFER_STATE;
120
121 extern int yyleng;
122 extern 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 */
161 typedef unsigned int yy_size_t;
162
163
164 struct 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
221 static 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. */
231 static char yy_hold_char;
232
233 static int yy_n_chars; /* number of characters read into yy_ch_buf */
234
235
236 int yyleng;
237
238 /* Points to current character in buffer. */
239 static char *yy_c_buf_p = (char *) 0;
240 static int yy_init = 1; /* whether we need to initialize */
241 static 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 */
246 static int yy_did_buffer_switch_on_eof;
247
248 void yyrestart YY_PROTO(( FILE *input_file ));
249
250 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
251 void yy_load_buffer_state YY_PROTO(( void ));
252 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
253 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
254 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
255 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
256 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
257
258 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
259 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
260 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
261
262 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
263 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
264 static 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
289 typedef unsigned char YY_CHAR;
290 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
291 typedef int yy_state_type;
292
293 #define FLEX_DEBUG
294 extern char *yytext;
295 #define yytext_ptr yytext
296
297 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
298 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
299 static int yy_get_next_buffer YY_PROTO(( void ));
300 static 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
314 static 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
357 static 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
389 static 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
398 static 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
444 static 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
490 static 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
587 static 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
684 static yy_state_type yy_last_accepting_state;
685 static char *yy_last_accepting_cpos;
686
687 extern int yy_flex_debug;
688 int yy_flex_debug = 1;
689
690 static yyconst short int yy_rule_linenum[92] =
691 { 0,
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
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
712 char *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
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
762 static struct obstack string_obstack;
763 char *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)
782
783 /* This is only to avoid GCC warnings. */
784 #define YY_USER_INIT if (yycontrol) {;};
785
786
787 static int braces_level = 0;
788 static int percent_percent_count = 0;
789
790 static void handle_dollar PARAMS ((char *cp));
791 static 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
805 #line 806 "scan-gram.c"
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
813 extern "C" int yywrap YY_PROTO(( void ));
814 #else
815 extern int yywrap YY_PROTO(( void ));
816 #endif
817 #endif
818
819 #ifndef YY_NO_UNPUT
820 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
821 #endif
822
823 #ifndef yytext_ptr
824 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
825 #endif
826
827 #ifdef YY_NEED_STRLEN
828 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
829 #endif
830
831 #ifndef YY_NO_INPUT
832 #ifdef __cplusplus
833 static int yyinput YY_PROTO(( void ));
834 #else
835 static int input YY_PROTO(( void ));
836 #endif
837 #endif
838
839 #if YY_STACK_USED
840 static int yy_start_stack_ptr = 0;
841 static int yy_start_stack_depth = 0;
842 static int *yy_start_stack = 0;
843 #ifndef YY_NO_PUSH_STATE
844 static void yy_push_state YY_PROTO(( int new_state ));
845 #endif
846 #ifndef YY_NO_POP_STATE
847 static void yy_pop_state YY_PROTO(( void ));
848 #endif
849 #ifndef YY_NO_TOP_STATE
850 static 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
860 YY_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 } \
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 }
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
961 YY_DECL
962 {
963 register yy_state_type yy_current_state;
964 register char *yy_cp, *yy_bp;
965 register int yy_act;
966
967 #line 91 "scan-gram.l"
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 `----------------------------*/
990 #line 991 "scan-gram.c"
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;
1029 yy_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
1049 yy_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
1061 do_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
1090 case 1:
1091 YY_RULE_SETUP
1092 #line 115 "scan-gram.l"
1093 return PERCENT_NONASSOC;
1094 YY_BREAK
1095 case 2:
1096 YY_RULE_SETUP
1097 #line 116 "scan-gram.l"
1098 return PERCENT_DEBUG;
1099 YY_BREAK
1100 case 3:
1101 YY_RULE_SETUP
1102 #line 117 "scan-gram.l"
1103 return PERCENT_DEFINE;
1104 YY_BREAK
1105 case 4:
1106 YY_RULE_SETUP
1107 #line 118 "scan-gram.l"
1108 return PERCENT_DEFINES;
1109 YY_BREAK
1110 case 5:
1111 YY_RULE_SETUP
1112 #line 119 "scan-gram.l"
1113 return PERCENT_ERROR_VERBOSE;
1114 YY_BREAK
1115 case 6:
1116 YY_RULE_SETUP
1117 #line 120 "scan-gram.l"
1118 return PERCENT_EXPECT;
1119 YY_BREAK
1120 case 7:
1121 YY_RULE_SETUP
1122 #line 121 "scan-gram.l"
1123 return PERCENT_FILE_PREFIX;
1124 YY_BREAK
1125 case 8:
1126 YY_RULE_SETUP
1127 #line 122 "scan-gram.l"
1128 return PERCENT_YACC;
1129 YY_BREAK
1130 case 9:
1131 YY_RULE_SETUP
1132 #line 123 "scan-gram.l"
1133 return PERCENT_LEFT;
1134 YY_BREAK
1135 case 10:
1136 YY_RULE_SETUP
1137 #line 124 "scan-gram.l"
1138 return PERCENT_LOCATIONS;
1139 YY_BREAK
1140 case 11:
1141 YY_RULE_SETUP
1142 #line 125 "scan-gram.l"
1143 return PERCENT_NAME_PREFIX;
1144 YY_BREAK
1145 case 12:
1146 YY_RULE_SETUP
1147 #line 126 "scan-gram.l"
1148 return PERCENT_NO_LINES;
1149 YY_BREAK
1150 case 13:
1151 YY_RULE_SETUP
1152 #line 127 "scan-gram.l"
1153 return PERCENT_NONASSOC;
1154 YY_BREAK
1155 case 14:
1156 YY_RULE_SETUP
1157 #line 128 "scan-gram.l"
1158 return PERCENT_NTERM;
1159 YY_BREAK
1160 case 15:
1161 YY_RULE_SETUP
1162 #line 129 "scan-gram.l"
1163 return PERCENT_OUTPUT;
1164 YY_BREAK
1165 case 16:
1166 YY_RULE_SETUP
1167 #line 130 "scan-gram.l"
1168 return PERCENT_PREC;
1169 YY_BREAK
1170 case 17:
1171 YY_RULE_SETUP
1172 #line 131 "scan-gram.l"
1173 return PERCENT_PURE_PARSER;
1174 YY_BREAK
1175 case 18:
1176 YY_RULE_SETUP
1177 #line 132 "scan-gram.l"
1178 return PERCENT_RIGHT;
1179 YY_BREAK
1180 case 19:
1181 YY_RULE_SETUP
1182 #line 133 "scan-gram.l"
1183 return PERCENT_SKELETON;
1184 YY_BREAK
1185 case 20:
1186 YY_RULE_SETUP
1187 #line 134 "scan-gram.l"
1188 return PERCENT_START;
1189 YY_BREAK
1190 case 21:
1191 YY_RULE_SETUP
1192 #line 135 "scan-gram.l"
1193 return PERCENT_TOKEN;
1194 YY_BREAK
1195 case 22:
1196 YY_RULE_SETUP
1197 #line 136 "scan-gram.l"
1198 return PERCENT_TOKEN;
1199 YY_BREAK
1200 case 23:
1201 YY_RULE_SETUP
1202 #line 137 "scan-gram.l"
1203 return PERCENT_TOKEN_TABLE;
1204 YY_BREAK
1205 case 24:
1206 YY_RULE_SETUP
1207 #line 138 "scan-gram.l"
1208 return PERCENT_TYPE;
1209 YY_BREAK
1210 case 25:
1211 YY_RULE_SETUP
1212 #line 139 "scan-gram.l"
1213 return PERCENT_UNION;
1214 YY_BREAK
1215 case 26:
1216 YY_RULE_SETUP
1217 #line 140 "scan-gram.l"
1218 return PERCENT_VERBOSE;
1219 YY_BREAK
1220 case 27:
1221 YY_RULE_SETUP
1222 #line 141 "scan-gram.l"
1223 return PERCENT_YACC;
1224 YY_BREAK
1225 case 28:
1226 YY_RULE_SETUP
1227 #line 143 "scan-gram.l"
1228 return EQUAL;
1229 YY_BREAK
1230 case 29:
1231 YY_RULE_SETUP
1232 #line 144 "scan-gram.l"
1233 return COLON;
1234 YY_BREAK
1235 case 30:
1236 YY_RULE_SETUP
1237 #line 145 "scan-gram.l"
1238 return PIPE;
1239 YY_BREAK
1240 case 31:
1241 YY_RULE_SETUP
1242 #line 146 "scan-gram.l"
1243 return SEMICOLON;
1244 YY_BREAK
1245 case 32:
1246 YY_RULE_SETUP
1247 #line 148 "scan-gram.l"
1248 YY_LINES; YY_STEP;
1249 YY_BREAK
1250 case 33:
1251 YY_RULE_SETUP
1252 #line 149 "scan-gram.l"
1253 YY_STEP;
1254 YY_BREAK
1255 case 34:
1256 YY_RULE_SETUP
1257 #line 150 "scan-gram.l"
1258 {
1259 YY_OBS_INIT; YY_OBS_GROW; YY_OBS_FINISH;
1260 yylval->symbol = getsym (last_string);
1261 YY_OBS_FREE;
1262 return ID;
1263 }
1264 YY_BREAK
1265 case 35:
1266 YY_RULE_SETUP
1267 #line 157 "scan-gram.l"
1268 yylval->integer = strtol (yytext, 0, 10); return INT;
1269 YY_BREAK
1270 /* Characters. We don't check there is only one. */
1271 case 36:
1272 YY_RULE_SETUP
1273 #line 160 "scan-gram.l"
1274 YY_OBS_INIT; YY_OBS_GROW; yy_push_state (SC_ESCAPED_CHARACTER);
1275 YY_BREAK
1276 /* Strings. */
1277 case 37:
1278 YY_RULE_SETUP
1279 #line 163 "scan-gram.l"
1280 YY_OBS_INIT; YY_OBS_GROW; yy_push_state (SC_ESCAPED_STRING);
1281 YY_BREAK
1282 /* Comments. */
1283 case 38:
1284 YY_RULE_SETUP
1285 #line 166 "scan-gram.l"
1286 yy_push_state (SC_COMMENT);
1287 YY_BREAK
1288 case 39:
1289 YY_RULE_SETUP
1290 #line 167 "scan-gram.l"
1291 YY_STEP;
1292 YY_BREAK
1293 /* Prologue. */
1294 case 40:
1295 YY_RULE_SETUP
1296 #line 170 "scan-gram.l"
1297 YY_OBS_INIT; yy_push_state (SC_PROLOGUE);
1298 YY_BREAK
1299 /* Code in between braces. */
1300 case 41:
1301 YY_RULE_SETUP
1302 #line 173 "scan-gram.l"
1303 YY_OBS_INIT; YY_OBS_GROW; ++braces_level; yy_push_state (SC_BRACED_CODE);
1304 YY_BREAK
1305 /* A type. */
1306 case 42:
1307 YY_RULE_SETUP
1308 #line 176 "scan-gram.l"
1309 YY_OBS_INIT; obstack_grow (&string_obstack, yytext + 1, yyleng - 2); YY_OBS_FINISH; return TYPE;
1310 YY_BREAK
1311 case 43:
1312 YY_RULE_SETUP
1313 #line 178 "scan-gram.l"
1314 {
1315 if (++percent_percent_count == 2)
1316 yy_push_state (SC_EPILOGUE);
1317 return PERCENT_PERCENT;
1318 }
1319 YY_BREAK
1320 case 44:
1321 YY_RULE_SETUP
1322 #line 184 "scan-gram.l"
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
1337 case 45:
1338 YY_RULE_SETUP
1339 #line 200 "scan-gram.l"
1340 obstack_sgrow (&string_obstack, "@<:@");
1341 YY_BREAK
1342 case 46:
1343 YY_RULE_SETUP
1344 #line 201 "scan-gram.l"
1345 obstack_sgrow (&string_obstack, "@:>@");
1346 YY_BREAK
1347
1348 /*-----------------------------------------------------------.
1349 | Scanning a C comment. The initial `/ *' is already eaten. |
1350 `-----------------------------------------------------------*/
1351
1352
1353 case 47:
1354 YY_RULE_SETUP
1355 #line 212 "scan-gram.l"
1356 { /* End of the comment. */
1357 if (yy_top_state () == INITIAL)
1358 {
1359 YY_STEP;
1360 }
1361 else
1362 {
1363 YY_OBS_GROW;
1364 }
1365 yy_pop_state ();
1366 }
1367 YY_BREAK
1368 case 48:
1369 YY_RULE_SETUP
1370 #line 224 "scan-gram.l"
1371 if (yy_top_state () != INITIAL) YY_OBS_GROW;
1372 YY_BREAK
1373 case 49:
1374 YY_RULE_SETUP
1375 #line 225 "scan-gram.l"
1376 if (yy_top_state () != INITIAL) YY_OBS_GROW; YY_LINES;
1377 YY_BREAK
1378 case 50:
1379 YY_RULE_SETUP
1380 #line 226 "scan-gram.l"
1381 /* Stray `*'. */if (yy_top_state () != INITIAL) YY_OBS_GROW;
1382 YY_BREAK
1383 case YY_STATE_EOF(SC_COMMENT):
1384 #line 228 "scan-gram.l"
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
1398 case 51:
1399 YY_RULE_SETUP
1400 #line 243 "scan-gram.l"
1401 {
1402 assert (yy_top_state () == INITIAL);
1403 YY_OBS_GROW;
1404 YY_OBS_FINISH;
1405 yy_pop_state ();
1406 return STRING;
1407 }
1408 YY_BREAK
1409 case 52:
1410 YY_RULE_SETUP
1411 #line 251 "scan-gram.l"
1412 YY_OBS_GROW;
1413 YY_BREAK
1414 case 53:
1415 YY_RULE_SETUP
1416 #line 253 "scan-gram.l"
1417 obstack_1grow (&string_obstack, '\n'); YY_LINES;
1418 YY_BREAK
1419 case YY_STATE_EOF(SC_ESCAPED_STRING):
1420 #line 255 "scan-gram.l"
1421 {
1422 LOCATION_PRINT (stderr, *yylloc);
1423 fprintf (stderr, ": unexpected end of file in a string\n");
1424 assert (yy_top_state () == INITIAL);
1425 YY_OBS_FINISH;
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
1437 case 54:
1438 YY_RULE_SETUP
1439 #line 272 "scan-gram.l"
1440 {
1441 YY_OBS_GROW;
1442 assert (yy_top_state () == INITIAL);
1443 {
1444 YY_OBS_FINISH;
1445 yylval->symbol = getsym (last_string);
1446 symbol_class_set (yylval->symbol, token_sym);
1447 symbol_user_token_number_set (yylval->symbol, last_string[1]);
1448 YY_OBS_FREE;
1449 yy_pop_state ();
1450 return ID;
1451 }
1452 }
1453 YY_BREAK
1454 case 55:
1455 YY_RULE_SETUP
1456 #line 286 "scan-gram.l"
1457 YY_OBS_GROW;
1458 YY_BREAK
1459 case 56:
1460 YY_RULE_SETUP
1461 #line 288 "scan-gram.l"
1462 obstack_1grow (&string_obstack, '\n'); YY_LINES;
1463 YY_BREAK
1464 case YY_STATE_EOF(SC_ESCAPED_CHARACTER):
1465 #line 290 "scan-gram.l"
1466 {
1467 LOCATION_PRINT (stderr, *yylloc);
1468 fprintf (stderr, ": unexpected end of file in a character\n");
1469 assert (yy_top_state () == INITIAL);
1470 YY_OBS_FINISH;
1471 yy_pop_state ();
1472 return CHARACTER;
1473 }
1474 YY_BREAK
1475
1476 /*----------------------------.
1477 | Decode escaped characters. |
1478 `----------------------------*/
1479
1480
1481 case 57:
1482 YY_RULE_SETUP
1483 #line 307 "scan-gram.l"
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
1496 case 58:
1497 YY_RULE_SETUP
1498 #line 319 "scan-gram.l"
1499 {
1500 obstack_1grow (&string_obstack, strtol (yytext + 2, 0, 16));
1501 }
1502 YY_BREAK
1503 case 59:
1504 YY_RULE_SETUP
1505 #line 323 "scan-gram.l"
1506 obstack_1grow (&string_obstack, '\a');
1507 YY_BREAK
1508 case 60:
1509 YY_RULE_SETUP
1510 #line 324 "scan-gram.l"
1511 obstack_1grow (&string_obstack, '\b');
1512 YY_BREAK
1513 case 61:
1514 YY_RULE_SETUP
1515 #line 325 "scan-gram.l"
1516 obstack_1grow (&string_obstack, '\f');
1517 YY_BREAK
1518 case 62:
1519 YY_RULE_SETUP
1520 #line 326 "scan-gram.l"
1521 obstack_1grow (&string_obstack, '\n');
1522 YY_BREAK
1523 case 63:
1524 YY_RULE_SETUP
1525 #line 327 "scan-gram.l"
1526 obstack_1grow (&string_obstack, '\r');
1527 YY_BREAK
1528 case 64:
1529 YY_RULE_SETUP
1530 #line 328 "scan-gram.l"
1531 obstack_1grow (&string_obstack, '\t');
1532 YY_BREAK
1533 case 65:
1534 YY_RULE_SETUP
1535 #line 329 "scan-gram.l"
1536 obstack_1grow (&string_obstack, '\v');
1537 YY_BREAK
1538 case 66:
1539 YY_RULE_SETUP
1540 #line 330 "scan-gram.l"
1541 obstack_1grow (&string_obstack, yytext[1]);
1542 YY_BREAK
1543 case 67:
1544 YY_RULE_SETUP
1545 #line 331 "scan-gram.l"
1546 {
1547 LOCATION_PRINT (stderr, *yylloc);
1548 fprintf (stderr, ": unrecognized escape: %s\n", yytext);
1549 YY_OBS_GROW;
1550 }
1551 YY_BREAK
1552
1553 /*----------------------------------------------------------.
1554 | Scanning a C character without decoding its escapes. The |
1555 | initial "'" is already eaten. |
1556 `----------------------------------------------------------*/
1557
1558
1559 case 68:
1560 YY_RULE_SETUP
1561 #line 346 "scan-gram.l"
1562 {
1563 YY_OBS_GROW;
1564 assert (yy_top_state () != INITIAL);
1565 yy_pop_state ();
1566 }
1567 YY_BREAK
1568 case 69:
1569 YY_RULE_SETUP
1570 #line 352 "scan-gram.l"
1571 YY_OBS_GROW;
1572 YY_BREAK
1573 case 70:
1574 YY_RULE_SETUP
1575 #line 353 "scan-gram.l"
1576 YY_OBS_GROW;
1577 YY_BREAK
1578 case 71:
1579 YY_RULE_SETUP
1580 #line 355 "scan-gram.l"
1581 YY_OBS_GROW; YY_LINES;
1582 YY_BREAK
1583 case YY_STATE_EOF(SC_CHARACTER):
1584 #line 357 "scan-gram.l"
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
1599 case 72:
1600 YY_RULE_SETUP
1601 #line 373 "scan-gram.l"
1602 {
1603 assert (yy_top_state () != INITIAL);
1604 YY_OBS_GROW;
1605 yy_pop_state ();
1606 }
1607 YY_BREAK
1608 case 73:
1609 YY_RULE_SETUP
1610 #line 379 "scan-gram.l"
1611 YY_OBS_GROW;
1612 YY_BREAK
1613 case 74:
1614 YY_RULE_SETUP
1615 #line 380 "scan-gram.l"
1616 YY_OBS_GROW;
1617 YY_BREAK
1618 case 75:
1619 YY_RULE_SETUP
1620 #line 382 "scan-gram.l"
1621 YY_OBS_GROW; YY_LINES;
1622 YY_BREAK
1623 case YY_STATE_EOF(SC_STRING):
1624 #line 384 "scan-gram.l"
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. */
1639 case 76:
1640 YY_RULE_SETUP
1641 #line 400 "scan-gram.l"
1642 YY_OBS_GROW; yy_push_state (SC_CHARACTER);
1643 YY_BREAK
1644 /* Strings. */
1645 case 77:
1646 YY_RULE_SETUP
1647 #line 403 "scan-gram.l"
1648 YY_OBS_GROW; yy_push_state (SC_STRING);
1649 YY_BREAK
1650 /* Comments. */
1651 case 78:
1652 YY_RULE_SETUP
1653 #line 406 "scan-gram.l"
1654 YY_OBS_GROW; yy_push_state (SC_COMMENT);
1655 YY_BREAK
1656 case 79:
1657 YY_RULE_SETUP
1658 #line 407 "scan-gram.l"
1659 YY_OBS_GROW;
1660 YY_BREAK
1661
1662 /*---------------------------------------------------------------.
1663 | Scanning some code in braces (%union and actions). The initial |
1664 | "{" is already eaten. |
1665 `---------------------------------------------------------------*/
1666
1667
1668 case 80:
1669 YY_RULE_SETUP
1670 #line 418 "scan-gram.l"
1671 {
1672 YY_OBS_GROW;
1673 if (--braces_level == 0)
1674 {
1675 yy_pop_state ();
1676 YY_OBS_FINISH;
1677 return BRACED_CODE;
1678 }
1679 }
1680 YY_BREAK
1681 case 81:
1682 YY_RULE_SETUP
1683 #line 428 "scan-gram.l"
1684 YY_OBS_GROW; braces_level++;
1685 YY_BREAK
1686 case 82:
1687 YY_RULE_SETUP
1688 #line 430 "scan-gram.l"
1689 { handle_dollar (yytext); }
1690 YY_BREAK
1691 case 83:
1692 YY_RULE_SETUP
1693 #line 431 "scan-gram.l"
1694 { handle_at (yytext); }
1695 YY_BREAK
1696 case 84:
1697 YY_RULE_SETUP
1698 #line 433 "scan-gram.l"
1699 YY_OBS_GROW;
1700 YY_BREAK
1701 case 85:
1702 YY_RULE_SETUP
1703 #line 434 "scan-gram.l"
1704 YY_OBS_GROW; YY_LINES;
1705 YY_BREAK
1706 /* A lose $, or /, or etc. */
1707 case 86:
1708 YY_RULE_SETUP
1709 #line 437 "scan-gram.l"
1710 YY_OBS_GROW;
1711 YY_BREAK
1712 case YY_STATE_EOF(SC_BRACED_CODE):
1713 #line 439 "scan-gram.l"
1714 {
1715 LOCATION_PRINT (stderr, *yylloc);
1716 fprintf (stderr, ": unexpected end of file in a braced code\n");
1717 yy_pop_state ();
1718 YY_OBS_FINISH;
1719 return PROLOGUE;
1720 }
1721 YY_BREAK
1722
1723 /*--------------------------------------------------------------.
1724 | Scanning some prologue: from "%{" (already scanned) to "%}". |
1725 `--------------------------------------------------------------*/
1726
1727
1728 case 87:
1729 YY_RULE_SETUP
1730 #line 456 "scan-gram.l"
1731 {
1732 yy_pop_state ();
1733 YY_OBS_FINISH;
1734 return PROLOGUE;
1735 }
1736 YY_BREAK
1737 case 88:
1738 YY_RULE_SETUP
1739 #line 462 "scan-gram.l"
1740 YY_OBS_GROW;
1741 YY_BREAK
1742 case 89:
1743 YY_RULE_SETUP
1744 #line 463 "scan-gram.l"
1745 YY_OBS_GROW;
1746 YY_BREAK
1747 case 90:
1748 YY_RULE_SETUP
1749 #line 464 "scan-gram.l"
1750 YY_OBS_GROW; YY_LINES;
1751 YY_BREAK
1752 case YY_STATE_EOF(SC_PROLOGUE):
1753 #line 466 "scan-gram.l"
1754 {
1755 LOCATION_PRINT (stderr, *yylloc);
1756 fprintf (stderr, ": unexpected end of file in a prologue\n");
1757 yy_pop_state ();
1758 YY_OBS_FINISH;
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
1769 case 91:
1770 YY_RULE_SETUP
1771 #line 484 "scan-gram.l"
1772 YY_OBS_GROW;
1773 YY_BREAK
1774 case YY_STATE_EOF(SC_EPILOGUE):
1775 #line 486 "scan-gram.l"
1776 {
1777 yy_pop_state ();
1778 YY_OBS_FINISH;
1779 return EPILOGUE;
1780 }
1781 YY_BREAK
1782
1783 case 92:
1784 YY_RULE_SETUP
1785 #line 494 "scan-gram.l"
1786 YY_FATAL_ERROR( "flex scanner jammed" );
1787 YY_BREAK
1788 #line 1789 "scan-gram.c"
1789 case 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
1930 static 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
2062 static 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
2097 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2098 #else
2099 static yy_state_type yy_try_NUL_trans( yy_current_state )
2100 yy_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
2127 static void yyunput( int c, register char *yy_bp )
2128 #else
2129 static void yyunput( c, yy_bp )
2130 int c;
2131 register 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
2171 static int yyinput()
2172 #else
2173 static 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
2244 void yyrestart( FILE *input_file )
2245 #else
2246 void yyrestart( input_file )
2247 FILE *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
2259 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2260 #else
2261 void yy_switch_to_buffer( new_buffer )
2262 YY_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
2289 void yy_load_buffer_state( void )
2290 #else
2291 void 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
2302 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2303 #else
2304 YY_BUFFER_STATE yy_create_buffer( file, size )
2305 FILE *file;
2306 int 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
2333 void yy_delete_buffer( YY_BUFFER_STATE b )
2334 #else
2335 void yy_delete_buffer( b )
2336 YY_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
2352 #ifndef _WIN32
2353 #include <unistd.h>
2354 #else
2355 #ifndef YY_ALWAYS_INTERACTIVE
2356 #ifndef YY_NEVER_INTERACTIVE
2357 extern int isatty YY_PROTO(( int ));
2358 #endif
2359 #endif
2360 #endif
2361
2362 #ifdef YY_USE_PROTOS
2363 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2364 #else
2365 void yy_init_buffer( b, file )
2366 YY_BUFFER_STATE b;
2367 FILE *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
2390 void yy_flush_buffer( YY_BUFFER_STATE b )
2391 #else
2392 void yy_flush_buffer( b )
2393 YY_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
2421 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2422 #else
2423 YY_BUFFER_STATE yy_scan_buffer( base, size )
2424 char *base;
2425 yy_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
2459 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2460 #else
2461 YY_BUFFER_STATE yy_scan_string( yy_str )
2462 yyconst 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
2476 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2477 #else
2478 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2479 yyconst char *bytes;
2480 int 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
2515 static void yy_push_state( int new_state )
2516 #else
2517 static void yy_push_state( new_state )
2518 int 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
2548 static 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
2559 static 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
2570 static void yy_fatal_error( yyconst char msg[] )
2571 #else
2572 static void yy_fatal_error( msg )
2573 char 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
2602 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2603 #else
2604 static void yy_flex_strncpy( s1, s2, n )
2605 char *s1;
2606 yyconst char *s2;
2607 int 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
2618 static int yy_flex_strlen( yyconst char *s )
2619 #else
2620 static int yy_flex_strlen( s )
2621 yyconst 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
2634 static void *yy_flex_alloc( yy_size_t size )
2635 #else
2636 static void *yy_flex_alloc( size )
2637 yy_size_t size;
2638 #endif
2639 {
2640 return (void *) malloc( size );
2641 }
2642
2643 #ifdef YY_USE_PROTOS
2644 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2645 #else
2646 static void *yy_flex_realloc( ptr, size )
2647 void *ptr;
2648 yy_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
2662 static void yy_flex_free( void *ptr )
2663 #else
2664 static void yy_flex_free( ptr )
2665 void *ptr;
2666 #endif
2667 {
2668 free( ptr );
2669 }
2670
2671 #if YY_MAIN
2672 int main()
2673 {
2674 yylex();
2675 return 0;
2676 }
2677 #endif
2678 #line 494 "scan-gram.l"
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
2689 static void
2690 handle_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
2760 static void
2761 handle_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