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


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