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