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