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