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