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