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