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