made temporary file generation more robust
[swftools.git] / lib / action / lex.swf5.c
1 #define yy_create_buffer swf5_create_buffer
2 #define yy_delete_buffer swf5_delete_buffer
3 #define yy_scan_buffer swf5_scan_buffer
4 #define yy_scan_string swf5_scan_string
5 #define yy_scan_bytes swf5_scan_bytes
6 #define yy_flex_debug swf5_flex_debug
7 #define yy_init_buffer swf5_init_buffer
8 #define yy_flush_buffer swf5_flush_buffer
9 #define yy_load_buffer_state swf5_load_buffer_state
10 #define yy_switch_to_buffer swf5_switch_to_buffer
11 #define yyin swf5in
12 #define yyleng swf5leng
13 #define yylex swf5lex
14 #define yyout swf5out
15 #define yyrestart swf5restart
16 #define yytext swf5text
17 #define yywrap swf5wrap
18
19 /* A lexical scanner generated by flex */
20
21 /* Scanner skeleton version:
22  * $Header: /cvsroot/swftools/swftools/lib/action/lex.swf5.c,v 1.1 2008/05/24 17:09:56 kramm Exp $
23  */
24
25 #define FLEX_SCANNER
26 #define YY_FLEX_MAJOR_VERSION 2
27 #define YY_FLEX_MINOR_VERSION 5
28
29 #include <stdio.h>
30 #include <unistd.h>
31
32
33 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
34 #ifdef c_plusplus
35 #ifndef __cplusplus
36 #define __cplusplus
37 #endif
38 #endif
39
40
41 #ifdef __cplusplus
42
43 #include <stdlib.h>
44
45 /* Use prototypes in function declarations. */
46 #define YY_USE_PROTOS
47
48 /* The "const" storage-class-modifier is valid. */
49 #define YY_USE_CONST
50
51 #else   /* ! __cplusplus */
52
53 #if __STDC__
54
55 #define YY_USE_PROTOS
56 #define YY_USE_CONST
57
58 #endif  /* __STDC__ */
59 #endif  /* ! __cplusplus */
60
61 #ifdef __TURBOC__
62  #pragma warn -rch
63  #pragma warn -use
64 #include <io.h>
65 #include <stdlib.h>
66 #define YY_USE_CONST
67 #define YY_USE_PROTOS
68 #endif
69
70 #ifdef YY_USE_CONST
71 #define yyconst const
72 #else
73 #define yyconst
74 #endif
75
76
77 #ifdef YY_USE_PROTOS
78 #define YY_PROTO(proto) proto
79 #else
80 #define YY_PROTO(proto) ()
81 #endif
82
83 /* Returned upon end-of-file. */
84 #define YY_NULL 0
85
86 /* Promotes a possibly negative, possibly signed char to an unsigned
87  * integer for use as an array index.  If the signed char is negative,
88  * we want to instead treat it as an 8-bit unsigned char, hence the
89  * double cast.
90  */
91 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
92
93 /* Enter a start condition.  This macro really ought to take a parameter,
94  * but we do it the disgusting crufty way forced on us by the ()-less
95  * definition of BEGIN.
96  */
97 #define BEGIN yy_start = 1 + 2 *
98
99 /* Translate the current start state into a value that can be later handed
100  * to BEGIN to return to the state.  The YYSTATE alias is for lex
101  * compatibility.
102  */
103 #define YY_START ((yy_start - 1) / 2)
104 #define YYSTATE YY_START
105
106 /* Action number for EOF rule of a given start state. */
107 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
108
109 /* Special action meaning "start processing a new file". */
110 #define YY_NEW_FILE yyrestart( yyin )
111
112 #define YY_END_OF_BUFFER_CHAR 0
113
114 /* Size of default input buffer. */
115 #define YY_BUF_SIZE 16384
116
117 typedef struct yy_buffer_state *YY_BUFFER_STATE;
118
119 extern int yyleng;
120 extern FILE *yyin, *yyout;
121
122 #define EOB_ACT_CONTINUE_SCAN 0
123 #define EOB_ACT_END_OF_FILE 1
124 #define EOB_ACT_LAST_MATCH 2
125
126 /* The funky do-while in the following #define is used to turn the definition
127  * int a single C statement (which needs a semi-colon terminator).  This
128  * avoids problems with code like:
129  *
130  *      if ( condition_holds )
131  *              yyless( 5 );
132  *      else
133  *              do_something_else();
134  *
135  * Prior to using the do-while the compiler would get upset at the
136  * "else" because it interpreted the "if" statement as being all
137  * done when it reached the ';' after the yyless() call.
138  */
139
140 /* Return all but the first 'n' matched characters back to the input stream. */
141
142 #define yyless(n) \
143         do \
144                 { \
145                 /* Undo effects of setting up yytext. */ \
146                 *yy_cp = yy_hold_char; \
147                 YY_RESTORE_YY_MORE_OFFSET \
148                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
149                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
150                 } \
151         while ( 0 )
152
153 #define unput(c) yyunput( c, yytext_ptr )
154
155 /* The following is because we cannot portably get our hands on size_t
156  * (without autoconf's help, which isn't available because we want
157  * flex-generated scanners to compile on their own).
158  */
159 typedef unsigned int yy_size_t;
160
161
162 struct yy_buffer_state
163         {
164         FILE *yy_input_file;
165
166         char *yy_ch_buf;                /* input buffer */
167         char *yy_buf_pos;               /* current position in input buffer */
168
169         /* Size of input buffer in bytes, not including room for EOB
170          * characters.
171          */
172         yy_size_t yy_buf_size;
173
174         /* Number of characters read into yy_ch_buf, not including EOB
175          * characters.
176          */
177         int yy_n_chars;
178
179         /* Whether we "own" the buffer - i.e., we know we created it,
180          * and can realloc() it to grow it, and should free() it to
181          * delete it.
182          */
183         int yy_is_our_buffer;
184
185         /* Whether this is an "interactive" input source; if so, and
186          * if we're using stdio for input, then we want to use getc()
187          * instead of fread(), to make sure we stop fetching input after
188          * each newline.
189          */
190         int yy_is_interactive;
191
192         /* Whether we're considered to be at the beginning of a line.
193          * If so, '^' rules will be active on the next match, otherwise
194          * not.
195          */
196         int yy_at_bol;
197
198         /* Whether to try to fill the input buffer when we reach the
199          * end of it.
200          */
201         int yy_fill_buffer;
202
203         int yy_buffer_status;
204 #define YY_BUFFER_NEW 0
205 #define YY_BUFFER_NORMAL 1
206         /* When an EOF's been seen but there's still some text to process
207          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
208          * shouldn't try reading from the input source any more.  We might
209          * still have a bunch of tokens to match, though, because of
210          * possible backing-up.
211          *
212          * When we actually see the EOF, we change the status to "new"
213          * (via yyrestart()), so that the user can continue scanning by
214          * just pointing yyin at a new input file.
215          */
216 #define YY_BUFFER_EOF_PENDING 2
217         };
218
219 static YY_BUFFER_STATE yy_current_buffer = 0;
220
221 /* We provide macros for accessing buffer states in case in the
222  * future we want to put the buffer states in a more general
223  * "scanner state".
224  */
225 #define YY_CURRENT_BUFFER yy_current_buffer
226
227
228 /* yy_hold_char holds the character lost when yytext is formed. */
229 static char yy_hold_char;
230
231 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
232
233
234 int yyleng;
235
236 /* Points to current character in buffer. */
237 static char *yy_c_buf_p = (char *) 0;
238 static int yy_init = 1;         /* whether we need to initialize */
239 static int yy_start = 0;        /* start state number */
240
241 /* Flag which is used to allow yywrap()'s to do buffer switches
242  * instead of setting up a fresh yyin.  A bit of a hack ...
243  */
244 static int yy_did_buffer_switch_on_eof;
245
246 void yyrestart YY_PROTO(( FILE *input_file ));
247
248 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
249 void yy_load_buffer_state YY_PROTO(( void ));
250 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
251 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
252 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
253 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
254 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
255
256 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
257 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
258 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
259
260 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
261 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
262 static void yy_flex_free YY_PROTO(( void * ));
263
264 #define yy_new_buffer yy_create_buffer
265
266 #define yy_set_interactive(is_interactive) \
267         { \
268         if ( ! yy_current_buffer ) \
269                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
270         yy_current_buffer->yy_is_interactive = is_interactive; \
271         }
272
273 #define yy_set_bol(at_bol) \
274         { \
275         if ( ! yy_current_buffer ) \
276                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
277         yy_current_buffer->yy_at_bol = at_bol; \
278         }
279
280 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
281
282 typedef unsigned char YY_CHAR;
283 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
284 typedef int yy_state_type;
285 extern char *yytext;
286 #define yytext_ptr yytext
287
288 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
289 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
290 static int yy_get_next_buffer YY_PROTO(( void ));
291 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
292
293 /* Done after the current pattern has been matched and before the
294  * corresponding action - sets up yytext.
295  */
296 #define YY_DO_BEFORE_ACTION \
297         yytext_ptr = yy_bp; \
298         yyleng = (int) (yy_cp - yy_bp); \
299         yy_hold_char = *yy_cp; \
300         *yy_cp = '\0'; \
301         yy_c_buf_p = yy_cp;
302
303 #define YY_NUM_RULES 166
304 #define YY_END_OF_BUFFER 167
305 static yyconst short int yy_accept[650] =
306     {   0,
307         0,    0,    0,    0,  167,  165,  119,  164,  165,  152,
308       165,  151,  146,  165,  153,  154,  149,  144,  159,  145,
309       160,  150,    3,    3,  162,  142,  140,  143,  141,  161,
310       155,  156,  148,  112,  112,  112,  112,  112,  112,  112,
311       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
312       112,  157,  147,  158,  163,  112,  112,  112,  112,  112,
313       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
314       164,  125,    0,  115,  113,    0,  126,  132,    0,  116,
315       114,    0,  128,  120,  130,  121,  131,  117,  118,  129,
316         4,    2,    3,    0,  134,  122,  124,  123,  135,  112,
317
318       112,  112,  112,  112,  112,  112,   19,  112,  112,  112,
319       112,  112,  112,  112,  112,   17,   16,  112,  112,  112,
320       112,  112,  112,  112,    0,  112,  112,  112,  112,  112,
321       112,  112,  112,  112,  112,  112,  112,  133,  127,  112,
322       112,  112,  112,  112,  112,  112,  112,  112,  112,   16,
323       112,  112,  112,  112,  112,  112,  112,  112,   63,  112,
324       112,  112,  112,  112,  112,  112,  112,  112,    4,    1,
325       137,  138,  136,   25,  112,  112,  112,   37,  112,  112,
326       112,  112,  112,  112,  112,   15,  112,  112,  112,  112,
327        35,  112,  112,   21,  112,  112,   36,  112,  112,  111,
328
329       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
330       112,   20,  112,  112,   66,   62,  112,  112,   73,  112,
331        55,  110,  112,  112,  109,   72,  112,  112,  112,  112,
332       112,  112,  112,  112,  112,   21,   91,  112,   57,  112,
333       112,  112,  112,  112,  112,  112,  112,  112,   20,   64,
334       139,  112,  112,   13,  112,  112,  112,  112,  112,   11,
335        26,  112,  112,  112,  112,  112,  112,  112,  112,  112,
336         7,   42,  112,  112,  112,  112,  112,   43,  112,  112,
337       112,  112,    5,  112,  112,   24,  112,  112,  112,  112,
338       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
339
340       112,  112,  112,  112,  112,  112,  112,  112,  108,   58,
341       112,  112,  112,  112,  112,  112,   43,  112,  112,  112,
342        56,  112,    8,  112,  112,  112,  112,  112,  112,    6,
343       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
344       112,  112,  112,  112,  112,  112,  112,  112,   34,  112,
345        18,  112,  112,  112,  112,  112,  112,  112,  112,  112,
346       112,  112,  112,  104,  112,  103,  112,  112,  112,  112,
347       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
348       112,  112,  112,  112,  112,  112,  112,   32,  112,  112,
349        22,  112,  112,  112,   38,  112,  112,   31,  112,  112,
350
351       112,  112,   29,  112,   23,  112,  112,   33,   12,  112,
352        27,  105,  112,  112,   86,  112,   70,  112,  112,  112,
353       112,  112,  112,  112,  112,   65,  112,   67,  112,  112,
354        83,  112,  112,  112,  112,  112,  112,  112,  112,  112,
355       112,  112,   33,  112,  112,  112,  112,   14,  112,  112,
356       112,   39,  112,  112,  112,  112,  112,  112,  112,  112,
357       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
358       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
359       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
360       112,  112,  112,  112,    9,  112,   10,   30,  112,  112,
361
362       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
363       112,  112,  112,  112,  112,  112,  112,   68,  112,  112,
364       101,  112,   85,  112,  112,  112,  112,  112,  112,  112,
365       112,  112,  112,  112,   99,   92,  112,  112,   84,  112,
366        46,  112,   47,  112,   50,  112,   40,   41,  112,   48,
367       112,  112,  112,  112,  112,  112,   74,   77,  112,   76,
368       112,  112,   90,  112,   71,  112,   87,  112,   78,  112,
369        48,  112,   79,  112,   98,  112,  112,   94,   82,  112,
370        28,  112,  112,  112,   45,  112,  112,  112,  112,   61,
371       112,   75,   89,  112,  112,  112,  112,  112,  112,   80,
372
373       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
374        95,  102,   69,   88,   59,  112,   96,   81,  112,  112,
375       112,   52,  112,  112,  112,  106,  107,   60,  112,   93,
376       112,  112,   49,  112,   44,   97,  112,  112,  112,  112,
377       100,  112,  112,   54,  112,   51,  112,   53,    0
378     } ;
379
380 static yyconst int yy_ec[256] =
381     {   0,
382         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
383         2,    2,    4,    1,    1,    1,    1,    1,    1,    1,
384         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
385         1,    2,    5,    6,    1,    1,    7,    8,    9,   10,
386        11,   12,   13,   14,   15,   16,   17,   18,   19,   20,
387        21,   21,   21,   21,   21,   22,   22,   23,   24,   25,
388        26,   27,   28,    1,   34,   35,   36,   37,   38,   39,
389        40,   41,   42,   43,   44,   45,   46,   47,   48,   49,
390        50,   51,   52,   53,   54,   55,   56,   57,   58,   33,
391        29,   30,   31,   32,   33,    1,   34,   35,   36,   37,
392
393        38,   39,   40,   41,   42,   43,   44,   45,   46,   47,
394        48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
395        58,   33,   59,   60,   61,   62,    1,    1,    1,    1,
396         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
397         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
398         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
399         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
400         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
401         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
402         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
403
404         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
405         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
406         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
407         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
408         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
409         1,    1,    1,    1,    1
410     } ;
411
412 static yyconst int yy_meta[63] =
413     {   0,
414         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
415         1,    1,    1,    1,    1,    1,    1,    2,    2,    2,
416         2,    2,    1,    1,    1,    1,    1,    1,    1,    1,
417         1,    1,    3,    2,    2,    2,    2,    2,    2,    3,
418         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
419         3,    3,    3,    3,    3,    3,    3,    3,    1,    1,
420         1,    1
421     } ;
422
423 static yyconst short int yy_base[654] =
424     {   0,
425         0,    0,   29,    0,  741,  742,  742,  742,  737,  713,
426        67,  742,   64,   76,  742,  742,  712,   67,  742,   68,
427       742,   70,   82,   89,  742,  742,   63,  711,   65,  742,
428       742,  742,  742,    0,  684,  684,   78,   75,   69,   82,
429        77,   81,   79,   80,  683,   86,  109,   95,   87,  699,
430        80,  742,  114,  742,  742,  105,  681,  112,  116,  116,
431       117,  120,  124,  121,  130,   99,  128,  139,  697,  682,
432       742,  742,  180,  182,  742,  726,  742,  742,  178,  187,
433       742,  725,  742,  742,  742,  742,  742,  742,  742,  742,
434       179,  200,  207,    0,  701,  742,  742,  742,  176,    0,
435
436       680,  687,  159,  673,  676,  168,    0,  673,  669,  686,
437       674,  667,  670,  663,  662,    0,  153,  667,  679,  158,
438       667,  674,  676,  671,  212,  661,  189,  654,  658,  670,
439       662,  663,  155,  653,  650,  658,  646,  742,  742,  661,
440       660,   61,  191,  201,  641,  646,  187,  640,  640,  202,
441       198,  213,  212,  655,  646,  195,  637,  652,  651,  142,
442       635,  633,  643,  215,  649,  225,  632,  631,  250,    0,
443       742,  742,  655,    0,  646,  634,  640,    0,  203,  643,
444       638,  630,  636,  628,  620,    0,  635,  208,  622,  616,
445         0,  628,  630,    0,  613,  620,    0,  606,  608,  255,
446
447       625,  613,  606,  606,  609,  605,  603,  615,  618,  615,
448       614,    0,  606,  609,    0,    0,  602,  603,    0,  605,
449       601,    0,  599,  610,  232,    0,  590,  590,  599,  599,
450       601,  587,  583,  582,  582,  245,    0,  246,    0,  581,
451       592,  242,  593,  580,  581,  587,  229,  579,  589,    0,
452       742,  582,  586,    0,  590,  581,  568,  568,  578,    0,
453         0,  581,  565,  575,  565,  576,  580,  560,  243,  573,
454         0,    0,  572,  562,  554,  557,  573,  554,  552,  568,
455       558,  564,    0,  553,  562,    0,  563,  219,  561,  559,
456       551,  557,  560,  258,  540,  556,  540,  543,  552,  553,
457
458       542,  544,  548,  534,  545,  545,  531,  542,    0,    0,
459       541,  540,  543,  542,  522,  521,  257,  526,  519,  520,
460         0,  520,    0,  518,  515,  520,  521,  527,  528,    0,
461       521,  516,  516,  509,  512,  517,  509,  522,  504,  503,
462       507,  514,  504,  499,  501,  497,  506,  508,    0,  506,
463         0,  503,  245,  505,  504,  490,  488,  493,  487,  486,
464       501,  494,  500,    0,  493,    0,  480,  483,  481,  492,
465       474,  475,  489,  471,  472,  477,  482,  470,  469,  256,
466       482,  467,  477,  465,  481,  460,  479,    0,  458,  458,
467         0,  476,  461,  470,  488,  472,  469,    0,  449,  452,
468
469       468,  467,    0,  454,    0,  459,  444,    0,    0,  447,
470         0,  266,  449,  442,    0,  460,    0,  458,  450,  440,
471       447,  455,  443,  434,  433,    0,  440,    0,  450,  431,
472         0,  448,  429,  445,  437,  438,  435,  438,  433,  423,
473       439,  265,  430,  435,  436,  423,  430,    0,  414,  419,
474       414,    0,  418,  425,  420,  419,  414,  413,  410,  419,
475       409,  401,  409,  414,  416,  410,  397,  411,  414,  413,
476       408,  398,  268,  403,  392,  384,  396,  387,  394,  385,
477       399,  384,  397,  400,  394,  392,  397,  390,  379,  390,
478       380,  373,  380,  386,    0,  385,    0,    0,  384,  373,
479
480       382,  385,  380,  379,  361,  362,  377,  379,  356,  358,
481       357,  361,  370,  356,  371,  347,  368,    0,  356,  351,
482         0,  359,    0,  348,  358,  346,  356,  345,  342,  341,
483       358,  339,  350,  350,    0,    0,  265,  349,    0,  336,
484         0,  341,    0,  347,  338,  349,    0,    0,  341,    0,
485       330,  336,  346,  328,  336,  340,    0,    0,  331,    0,
486       322,  337,    0,  326,    0,  338,    0,  337,    0,  332,
487       331,  323,    0,  314,    0,  326,  313,    0,    0,  316,
488         0,  309,  317,  323,    0,  318,  301,  304,  309,    0,
489       318,    0,    0,  315,  307,  306,  301,  294,  312,  329,
490
491       295,  294,  291,  299,  306,  307,  289,  289,  302,  292,
492         0,    0,    0,    0,    0,  289,    0,    0,  296,  295,
493       293,    0,  282,  288,  274,    0,    0,    0,  280,    0,
494       296,  291,  281,  285,    0,    0,  279,  279,  260,  264,
495         0,  266,  259,    0,  262,    0,   92,    0,  742,  317,
496       320,  322,   66
497     } ;
498
499 static yyconst short int yy_def[654] =
500     {   0,
501       649,    1,    1,    3,  649,  649,  649,  649,  649,  649,
502       650,  649,  649,  651,  649,  649,  649,  649,  649,  649,
503       649,  649,  649,  649,  649,  649,  649,  649,  649,  649,
504       649,  649,  649,  652,  652,  652,  652,  652,  652,  652,
505       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
506       652,  649,  649,  649,  649,  652,  652,  652,  652,  652,
507       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
508       649,  649,  650,  650,  649,  650,  649,  649,  651,  651,
509       649,  651,  649,  649,  649,  649,  649,  649,  649,  649,
510       649,  649,  649,  653,  649,  649,  649,  649,  649,  652,
511
512       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
513       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
514       652,  652,  652,  652,  649,  652,  652,  652,  652,  652,
515       652,  652,  652,  652,  652,  652,  652,  649,  649,  652,
516       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
517       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
518       652,  652,  652,  652,  652,  652,  652,  652,  649,  653,
519       649,  649,  649,  652,  652,  652,  652,  652,  652,  652,
520       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
521       652,  652,  652,  652,  652,  652,  652,  652,  652,  649,
522
523       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
524       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
525       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
526       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
527       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
528       649,  652,  652,  652,  652,  652,  652,  652,  652,  652,
529       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
530       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
531       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
532       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
533
534       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
535       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
536       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
537       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
538       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
539       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
540       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
541       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
542       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
543       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
544
545       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
546       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
547       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
548       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
549       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
550       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
551       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
552       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
553       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
554       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
555
556       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
557       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
558       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
559       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
560       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
561       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
562       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
563       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
564       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
565       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
566
567       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
568       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
569       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
570       652,  652,  652,  652,  652,  652,  652,  652,  652,  652,
571       652,  652,  652,  652,  652,  652,  652,  652,    0,  649,
572       649,  649,  649
573     } ;
574
575 static yyconst short int yy_nxt[805] =
576     {   0,
577         6,    7,    8,    9,   10,   11,   12,   13,   14,   15,
578        16,   17,   18,   19,   20,   21,   22,   23,   24,   24,
579        24,   24,   25,   26,   27,   28,   29,   30,   31,    6,
580        32,   33,   34,   35,   36,   37,   38,   39,   40,   41,
581        34,   42,   34,   34,   43,   34,   44,   45,   46,   34,
582        47,   48,   49,   34,   50,   51,   34,   34,   52,   53,
583        54,   55,   56,   57,   58,   59,   60,  170,   61,   74,
584        62,   77,   75,   63,   64,   65,   66,   67,   80,   84,
585        68,   88,   86,   69,   81,   70,   89,   95,   96,   78,
586        98,   99,   85,   87,  217,   90,   76,   91,  175,   92,
587
588        92,   92,   92,   93,   91,   82,   93,   93,   93,   93,
589        93,  103,  106,  109,  114,  111,  118,  120,  104,  116,
590       136,  137,  107,  110,  115,  105,  119,  117,  108,  112,
591       123,  125,  128,  121,  132,  113,  124,  133,   94,  138,
592       648,  140,  126,  158,  134,  143,  127,  129,  130,  159,
593       131,  141,  104,  144,  149,  153,  101,  145,  116,  105,
594       109,  151,  147,  107,  115,  148,  150,  156,  154,  146,
595       110,  152,  123,  139,  155,  160,  162,  157,  124,  163,
596        80,  161,   74,  121,   74,   75,   81,   75,  209,   80,
597       239,  164,  165,  240,  166,   81,  169,  169,  169,  169,
598
599       169,  172,  173,  176,  190,  191,  180,   82,  210,   76,
600       177,   76,  181,  194,  195,   91,   82,   92,   92,   92,
601        92,   93,   91,  222,   93,   93,   93,   93,   93,  200,
602       200,  200,  200,  200,  202,  218,  219,  226,  255,  180,
603       223,  203,  177,  227,  192,  181,  193,  230,  244,  228,
604       236,  195,  229,  190,  191,  256,  231,  353,  248,  232,
605       264,  265,  245,  233,  354,  246,  207,  169,  169,  169,
606       169,  169,  200,  200,  200,  200,  200,  292,  303,  306,
607       319,  320,  304,  307,  264,  265,  293,  311,  337,  305,
608       308,  360,  312,  382,  313,  387,  314,  338,  413,  463,
609
610       438,  519,  489,  647,  646,  361,  439,  464,  345,  490,
611       645,  576,  644,  643,  642,  520,  577,   73,   73,   73,
612        79,   79,   79,  100,  100,  641,  640,  639,  638,  637,
613       636,  635,  634,  633,  632,  631,  630,  629,  628,  627,
614       626,  625,  624,  623,  622,  621,  620,  619,  618,  617,
615       616,  615,  614,  613,  612,  611,  610,  609,  608,  607,
616       606,  605,  604,  603,  602,  601,  600,  599,  598,  597,
617       596,  595,  594,  593,  592,  591,  590,  589,  588,  587,
618       586,  585,  584,  583,  582,  581,  580,  579,  578,  575,
619       574,  573,  572,  571,  570,  569,  568,  567,  566,  565,
620
621       564,  563,  562,  561,  560,  559,  558,  557,  556,  555,
622       554,  553,  552,  551,  550,  549,  548,  547,  546,  545,
623       544,  543,  542,  541,  540,  539,  538,  537,  536,  535,
624       534,  533,  532,  531,  530,  529,  528,  527,  526,  525,
625       524,  523,  522,  521,  518,  517,  516,  515,  514,  513,
626       512,  511,  510,  509,  508,  507,  506,  505,  504,  503,
627       502,  501,  500,  499,  498,  497,  496,  495,  494,  493,
628       492,  491,  488,  487,  486,  485,  484,  483,  482,  481,
629       480,  479,  478,  477,  476,  475,  474,  473,  472,  471,
630       470,  469,  468,  467,  466,  465,  462,  461,  460,  459,
631
632       458,  457,  456,  455,  454,  453,  452,  451,  450,  449,
633       448,  447,  446,  445,  444,  443,  442,  441,  440,  437,
634       436,  435,  434,  433,  432,  431,  430,  429,  428,  427,
635       426,  425,  424,  423,  422,  421,  420,  419,  418,  417,
636       416,  415,  414,  412,  411,  410,  409,  408,  407,  406,
637       405,  404,  403,  402,  401,  400,  399,  398,  397,  396,
638       395,  394,  393,  392,  391,  390,  389,  388,  387,  386,
639       385,  384,  383,  381,  380,  379,  378,  377,  376,  375,
640       374,  373,  372,  371,  370,  369,  368,  367,  366,  365,
641       364,  363,  362,  359,  358,  357,  356,  355,  352,  351,
642
643       350,  349,  348,  347,  346,  345,  344,  343,  342,  341,
644       340,  339,  336,  335,  334,  333,  332,  331,  330,  329,
645       328,  327,  326,  325,  324,  323,  322,  321,  318,  317,
646       316,  315,  310,  309,  302,  301,  300,  299,  298,  297,
647       296,  295,  294,  291,  290,  259,  289,  288,  287,  286,
648       285,  284,  283,  282,  281,  280,  279,  278,  277,  276,
649       275,  274,  273,  272,  271,  270,  269,  268,  267,  266,
650       263,  262,  261,  260,  259,  258,  257,  254,  253,  252,
651       251,  250,  249,  247,  243,  242,  241,  197,  238,  237,
652       235,  234,  225,  224,  221,  220,  216,  215,  214,  213,
653
654       212,  211,  208,  207,  206,  205,  204,  201,  199,  198,
655       197,  196,  193,  192,  189,  188,  187,  186,  185,  184,
656       183,  182,  179,  178,  175,  174,  171,  649,  649,  168,
657       167,  142,  135,  122,  102,  101,   97,   83,   72,   71,
658       649,    5,  649,  649,  649,  649,  649,  649,  649,  649,
659       649,  649,  649,  649,  649,  649,  649,  649,  649,  649,
660       649,  649,  649,  649,  649,  649,  649,  649,  649,  649,
661       649,  649,  649,  649,  649,  649,  649,  649,  649,  649,
662       649,  649,  649,  649,  649,  649,  649,  649,  649,  649,
663       649,  649,  649,  649,  649,  649,  649,  649,  649,  649,
664
665       649,  649,  649,  649
666     } ;
667
668 static yyconst short int yy_chk[805] =
669     {   0,
670         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
671         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
672         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
673         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
674         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
675         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
676         1,    1,    3,    3,    3,    3,    3,  653,    3,   11,
677         3,   13,   11,    3,    3,    3,    3,    3,   14,   18,
678         3,   22,   20,    3,   14,    3,   22,   27,   27,   13,
679        29,   29,   18,   20,  142,   22,   11,   23,  142,   23,
680
681        23,   23,   23,   23,   24,   14,   24,   24,   24,   24,
682        24,   37,   38,   39,   41,   40,   43,   44,   37,   42,
683        51,   51,   38,   39,   41,   37,   43,   42,   38,   40,
684        46,   47,   48,   44,   49,   40,   46,   49,   23,   53,
685       647,   56,   47,   66,   49,   58,   47,   48,   48,   66,
686        48,   56,   58,   59,   61,   64,   56,   59,   62,   58,
687        60,   63,   60,   59,   61,   60,   62,   65,   64,   59,
688        60,   63,   67,   53,   64,   67,   68,   65,   67,   68,
689        79,   67,   73,   65,   74,   73,   79,   74,  133,   80,
690       160,   68,   68,  160,   68,   80,   91,   91,   91,   91,
691
692        91,   99,   99,  103,  117,  117,  106,   79,  133,   73,
693       103,   74,  106,  120,  120,   92,   80,   92,   92,   92,
694        92,   92,   93,  147,   93,   93,   93,   93,   93,  125,
695       125,  125,  125,  125,  127,  143,  144,  150,  179,  144,
696       147,  127,  143,  150,  151,  144,  152,  153,  164,  151,
697       156,  156,  152,  150,  150,  179,  153,  288,  166,  153,
698       188,  188,  164,  153,  288,  164,  166,  169,  169,  169,
699       169,  169,  200,  200,  200,  200,  200,  225,  236,  238,
700       247,  247,  236,  238,  225,  225,  225,  242,  269,  236,
701       238,  294,  242,  317,  242,  353,  242,  269,  353,  412,
702
703       380,  473,  442,  645,  643,  294,  380,  412,  317,  442,
704       642,  537,  640,  639,  638,  473,  537,  650,  650,  650,
705       651,  651,  651,  652,  652,  637,  634,  633,  632,  631,
706       629,  625,  624,  623,  621,  620,  619,  616,  610,  609,
707       608,  607,  606,  605,  604,  603,  602,  601,  600,  599,
708       598,  597,  596,  595,  594,  591,  589,  588,  587,  586,
709       584,  583,  582,  580,  577,  576,  574,  572,  571,  570,
710       568,  566,  564,  562,  561,  559,  556,  555,  554,  553,
711       552,  551,  549,  546,  545,  544,  542,  540,  538,  534,
712       533,  532,  531,  530,  529,  528,  527,  526,  525,  524,
713
714       522,  520,  519,  517,  516,  515,  514,  513,  512,  511,
715       510,  509,  508,  507,  506,  505,  504,  503,  502,  501,
716       500,  499,  496,  494,  493,  492,  491,  490,  489,  488,
717       487,  486,  485,  484,  483,  482,  481,  480,  479,  478,
718       477,  476,  475,  474,  472,  471,  470,  469,  468,  467,
719       466,  465,  464,  463,  462,  461,  460,  459,  458,  457,
720       456,  455,  454,  453,  451,  450,  449,  447,  446,  445,
721       444,  443,  441,  440,  439,  438,  437,  436,  435,  434,
722       433,  432,  430,  429,  427,  425,  424,  423,  422,  421,
723       420,  419,  418,  416,  414,  413,  410,  407,  406,  404,
724
725       402,  401,  400,  399,  397,  396,  395,  394,  393,  392,
726       390,  389,  387,  386,  385,  384,  383,  382,  381,  379,
727       378,  377,  376,  375,  374,  373,  372,  371,  370,  369,
728       368,  367,  365,  363,  362,  361,  360,  359,  358,  357,
729       356,  355,  354,  352,  350,  348,  347,  346,  345,  344,
730       343,  342,  341,  340,  339,  338,  337,  336,  335,  334,
731       333,  332,  331,  329,  328,  327,  326,  325,  324,  322,
732       320,  319,  318,  316,  315,  314,  313,  312,  311,  308,
733       307,  306,  305,  304,  303,  302,  301,  300,  299,  298,
734       297,  296,  295,  293,  292,  291,  290,  289,  287,  285,
735
736       284,  282,  281,  280,  279,  278,  277,  276,  275,  274,
737       273,  270,  268,  267,  266,  265,  264,  263,  262,  259,
738       258,  257,  256,  255,  253,  252,  249,  248,  246,  245,
739       244,  243,  241,  240,  235,  234,  233,  232,  231,  230,
740       229,  228,  227,  224,  223,  221,  220,  218,  217,  214,
741       213,  211,  210,  209,  208,  207,  206,  205,  204,  203,
742       202,  201,  199,  198,  196,  195,  193,  192,  190,  189,
743       187,  185,  184,  183,  182,  181,  180,  177,  176,  175,
744       173,  168,  167,  165,  163,  162,  161,  159,  158,  157,
745       155,  154,  149,  148,  146,  145,  141,  140,  137,  136,
746
747       135,  134,  132,  131,  130,  129,  128,  126,  124,  123,
748       122,  121,  119,  118,  115,  114,  113,  112,  111,  110,
749       109,  108,  105,  104,  102,  101,   95,   82,   76,   70,
750        69,   57,   50,   45,   36,   35,   28,   17,   10,    9,
751         5,  649,  649,  649,  649,  649,  649,  649,  649,  649,
752       649,  649,  649,  649,  649,  649,  649,  649,  649,  649,
753       649,  649,  649,  649,  649,  649,  649,  649,  649,  649,
754       649,  649,  649,  649,  649,  649,  649,  649,  649,  649,
755       649,  649,  649,  649,  649,  649,  649,  649,  649,  649,
756       649,  649,  649,  649,  649,  649,  649,  649,  649,  649,
757
758       649,  649,  649,  649
759     } ;
760
761 static yy_state_type yy_last_accepting_state;
762 static char *yy_last_accepting_cpos;
763
764 /* The intent behind this definition is that it'll catch
765  * any uses of REJECT which flex missed.
766  */
767 #define REJECT reject_used_but_not_detected
768 #define yymore() yymore_used_but_not_detected
769 #define YY_MORE_ADJ 0
770 #define YY_RESTORE_YY_MORE_OFFSET
771 char *yytext;
772 #line 1 "swf5compiler.flex"
773 #define INITIAL 0
774 #line 2 "swf5compiler.flex"
775
776 #include <math.h>
777 #include <string.h>
778
779 #include "compile.h"
780 #include "action.h"
781 #include "blocks/error.h"
782 #include "swf5compiler.tab.h" /* defines token types */
783
784 static int swf5debug;
785
786 static const char *lexBuffer = NULL;
787 static int lexBufferLen = 0;
788
789 static int  sLineNumber = 0;
790 static char szLine[1024];
791 static char msgbufs[2][1024] = { {0}, {0} }, *msgline = {0};
792 static int  column = 0;
793
794 static void comment();
795 static void comment1();
796 static void count();
797 static void countline();
798 static void warning(char *msg);
799
800 #define YY_INPUT(buf,result,max_size) result=lexBufferInput(buf, max_size)
801
802 /* thanks to the prolific and brilliant Raff: */
803 static int lexBufferInput(char *buf, int max_size)
804 {
805   int l = lexBufferLen > max_size ? max_size : lexBufferLen;
806
807   if (lexBufferLen <= 0)
808     return YY_NULL;
809
810   memcpy(buf, lexBuffer, l);
811   lexBuffer += l;
812   lexBufferLen -= l;
813   return l;
814 }
815
816         /* very inefficient method of unescaping strings */
817 static void unescape(char *buf)
818 {
819   char *p, *p1;
820
821   for (p1=buf; (p=strchr(p1, '\\')) != 0; p1 = p+1) {
822     switch(p[1])
823     {
824     case 'b' : p[1] = '\b'; break;
825     case 'f' : p[1] = '\f'; break;
826     case 'n' : p[1] = '\n'; break;
827     case 'r' : p[1] = '\r'; break;
828     case 't' : p[1] = '\t'; break;
829     case 'x' :
830     case 'u' : warning("unsupported escape sequence");
831     }
832     strcpy(p, p+1);
833   }
834 }
835
836 void swf5ParseInit(const char *script, int debug)
837 {
838   checkByteOrder();
839   yyrestart(NULL);
840
841   swf5debug = debug;
842
843   lexBuffer = script;
844   lexBufferLen = strlen(script);
845   sLineNumber = 0;
846   column = 0;
847   msgline = msgbufs[0];
848 }
849
850 #define asm 1
851
852 #line 82 "swf5compiler.flex"
853  // forward declaration needed by the following function
854 #ifndef YY_PROTO
855 #ifdef YY_USE_PROTOS
856 #define YY_PROTO(proto) proto
857 #else
858 #define YY_PROTO(proto) ()
859 #endif
860 #endif
861  static void yyunput YY_PROTO(( int c, char *buf_ptr ));
862
863  void do_unput5(const char c) { unput(c); }
864 #line 865 "lex.swf5.c"
865
866 /* Macros after this point can all be overridden by user definitions in
867  * section 1.
868  */
869
870 #ifndef YY_SKIP_YYWRAP
871 #ifdef __cplusplus
872 extern "C" int yywrap YY_PROTO(( void ));
873 #else
874 extern int yywrap YY_PROTO(( void ));
875 #endif
876 #endif
877
878 #ifndef YY_NO_UNPUT
879 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
880 #endif
881
882 #ifndef yytext_ptr
883 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
884 #endif
885
886 #ifdef YY_NEED_STRLEN
887 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
888 #endif
889
890 #ifndef YY_NO_INPUT
891 #ifdef __cplusplus
892 static int yyinput YY_PROTO(( void ));
893 #else
894 static int input YY_PROTO(( void ));
895 #endif
896 #endif
897
898 #if YY_STACK_USED
899 static int yy_start_stack_ptr = 0;
900 static int yy_start_stack_depth = 0;
901 static int *yy_start_stack = 0;
902 #ifndef YY_NO_PUSH_STATE
903 static void yy_push_state YY_PROTO(( int new_state ));
904 #endif
905 #ifndef YY_NO_POP_STATE
906 static void yy_pop_state YY_PROTO(( void ));
907 #endif
908 #ifndef YY_NO_TOP_STATE
909 static int yy_top_state YY_PROTO(( void ));
910 #endif
911
912 #else
913 #define YY_NO_PUSH_STATE 1
914 #define YY_NO_POP_STATE 1
915 #define YY_NO_TOP_STATE 1
916 #endif
917
918 #ifdef YY_MALLOC_DECL
919 YY_MALLOC_DECL
920 #else
921 #if __STDC__
922 #ifndef __cplusplus
923 #include <stdlib.h>
924 #endif
925 #else
926 /* Just try to get by without declaring the routines.  This will fail
927  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
928  * or sizeof(void*) != sizeof(int).
929  */
930 #endif
931 #endif
932
933 /* Amount of stuff to slurp up with each read. */
934 #ifndef YY_READ_BUF_SIZE
935 #define YY_READ_BUF_SIZE 8192
936 #endif
937
938 /* Copy whatever the last rule matched to the standard output. */
939
940 #ifndef ECHO
941 /* This used to be an fputs(), but since the string might contain NUL's,
942  * we now use fwrite().
943  */
944 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
945 #endif
946
947 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
948  * is returned in "result".
949  */
950 #ifndef YY_INPUT
951 #define YY_INPUT(buf,result,max_size) \
952         if ( yy_current_buffer->yy_is_interactive ) \
953                 { \
954                 int c = '*', n; \
955                 for ( n = 0; n < max_size && \
956                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
957                         buf[n] = (char) c; \
958                 if ( c == '\n' ) \
959                         buf[n++] = (char) c; \
960                 if ( c == EOF && ferror( yyin ) ) \
961                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
962                 result = n; \
963                 } \
964         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
965                   && ferror( yyin ) ) \
966                 YY_FATAL_ERROR( "input in flex scanner failed" );
967 #endif
968
969 /* No semi-colon after return; correct usage is to write "yyterminate();" -
970  * we don't want an extra ';' after the "return" because that will cause
971  * some compilers to complain about unreachable statements.
972  */
973 #ifndef yyterminate
974 #define yyterminate() return YY_NULL
975 #endif
976
977 /* Number of entries by which start-condition stack grows. */
978 #ifndef YY_START_STACK_INCR
979 #define YY_START_STACK_INCR 25
980 #endif
981
982 /* Report a fatal error. */
983 #ifndef YY_FATAL_ERROR
984 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
985 #endif
986
987 /* Default declaration of generated scanner - a define so the user can
988  * easily add parameters.
989  */
990 #ifndef YY_DECL
991 #define YY_DECL int yylex YY_PROTO(( void ))
992 #endif
993
994 /* Code executed at the beginning of each rule, after yytext and yyleng
995  * have been set up.
996  */
997 #ifndef YY_USER_ACTION
998 #define YY_USER_ACTION
999 #endif
1000
1001 /* Code executed at the end of each rule. */
1002 #ifndef YY_BREAK
1003 #define YY_BREAK break;
1004 #endif
1005
1006 #define YY_RULE_SETUP \
1007         YY_USER_ACTION
1008
1009 YY_DECL
1010         {
1011         register yy_state_type yy_current_state;
1012         register char *yy_cp = NULL, *yy_bp = NULL;
1013         register int yy_act;
1014
1015 #line 98 "swf5compiler.flex"
1016
1017
1018 #line 1019 "lex.swf5.c"
1019
1020         if ( yy_init )
1021                 {
1022                 yy_init = 0;
1023
1024 #ifdef YY_USER_INIT
1025                 YY_USER_INIT;
1026 #endif
1027
1028                 if ( ! yy_start )
1029                         yy_start = 1;   /* first start state */
1030
1031                 if ( ! yyin )
1032                         yyin = stdin;
1033
1034                 if ( ! yyout )
1035                         yyout = stdout;
1036
1037                 if ( ! yy_current_buffer )
1038                         yy_current_buffer =
1039                                 yy_create_buffer( yyin, YY_BUF_SIZE );
1040
1041                 yy_load_buffer_state();
1042                 }
1043
1044         while ( 1 )             /* loops until end-of-file is reached */
1045                 {
1046                 yy_cp = yy_c_buf_p;
1047
1048                 /* Support of yytext. */
1049                 *yy_cp = yy_hold_char;
1050
1051                 /* yy_bp points to the position in yy_ch_buf of the start of
1052                  * the current run.
1053                  */
1054                 yy_bp = yy_cp;
1055
1056                 yy_current_state = yy_start;
1057 yy_match:
1058                 do
1059                         {
1060                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1061                         if ( yy_accept[yy_current_state] )
1062                                 {
1063                                 yy_last_accepting_state = yy_current_state;
1064                                 yy_last_accepting_cpos = yy_cp;
1065                                 }
1066                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1067                                 {
1068                                 yy_current_state = (int) yy_def[yy_current_state];
1069                                 if ( yy_current_state >= 650 )
1070                                         yy_c = yy_meta[(unsigned int) yy_c];
1071                                 }
1072                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1073                         ++yy_cp;
1074                         }
1075                 while ( yy_base[yy_current_state] != 742 );
1076
1077 yy_find_action:
1078                 yy_act = yy_accept[yy_current_state];
1079                 if ( yy_act == 0 )
1080                         { /* have to back up */
1081                         yy_cp = yy_last_accepting_cpos;
1082                         yy_current_state = yy_last_accepting_state;
1083                         yy_act = yy_accept[yy_current_state];
1084                         }
1085
1086                 YY_DO_BEFORE_ACTION;
1087
1088
1089 do_action:      /* This label is used only to access EOF actions. */
1090
1091
1092                 switch ( yy_act )
1093         { /* beginning of action switch */
1094                         case 0: /* must back up */
1095                         /* undo the effects of YY_DO_BEFORE_ACTION */
1096                         *yy_cp = yy_hold_char;
1097                         yy_cp = yy_last_accepting_cpos;
1098                         yy_current_state = yy_last_accepting_state;
1099                         goto yy_find_action;
1100
1101 case 1:
1102 YY_RULE_SETUP
1103 #line 100 "swf5compiler.flex"
1104 { count();      swf5lval.intVal = strtoul(yytext, NULL, 0);
1105                                         return INTEGER;         }
1106         YY_BREAK
1107 case 2:
1108 YY_RULE_SETUP
1109 #line 102 "swf5compiler.flex"
1110 { count();      swf5lval.intVal = strtoul(yytext, NULL, 0);
1111                                         return INTEGER;         }
1112         YY_BREAK
1113 case 3:
1114 YY_RULE_SETUP
1115 #line 104 "swf5compiler.flex"
1116 { count();      swf5lval.intVal = atoi(yytext);
1117                                         return INTEGER;         }
1118         YY_BREAK
1119 case 4:
1120 YY_RULE_SETUP
1121 #line 106 "swf5compiler.flex"
1122 { count();      swf5lval.doubleVal = atof(yytext);
1123                                         return DOUBLE;          }
1124         YY_BREAK
1125 case 5:
1126 YY_RULE_SETUP
1127 #line 108 "swf5compiler.flex"
1128 { count();      swf5lval.intVal = 1;
1129                                         return BOOLEAN;         }
1130         YY_BREAK
1131 case 6:
1132 YY_RULE_SETUP
1133 #line 110 "swf5compiler.flex"
1134 { count();      swf5lval.intVal = 0;
1135                                         return BOOLEAN;         }
1136         YY_BREAK
1137 case 7:
1138 YY_RULE_SETUP
1139 #line 112 "swf5compiler.flex"
1140 { count();      return NULLVAL;         }
1141         YY_BREAK
1142 case 8:
1143 YY_RULE_SETUP
1144 #line 113 "swf5compiler.flex"
1145 { count();      return BREAK;           }
1146         YY_BREAK
1147 case 9:
1148 YY_RULE_SETUP
1149 #line 114 "swf5compiler.flex"
1150 { count();      return CONTINUE;        }
1151         YY_BREAK
1152 case 10:
1153 YY_RULE_SETUP
1154 #line 115 "swf5compiler.flex"
1155 { count();      return FUNCTION;        }
1156         YY_BREAK
1157 case 11:
1158 YY_RULE_SETUP
1159 #line 116 "swf5compiler.flex"
1160 { count();      return ELSE;            }
1161         YY_BREAK
1162 case 12:
1163 YY_RULE_SETUP
1164 #line 117 "swf5compiler.flex"
1165 { count();      return SWITCH;          }
1166         YY_BREAK
1167 case 13:
1168 YY_RULE_SETUP
1169 #line 118 "swf5compiler.flex"
1170 { count();      return CASE;            }
1171         YY_BREAK
1172 case 14:
1173 YY_RULE_SETUP
1174 #line 119 "swf5compiler.flex"
1175 { count();      return DEFAULT;         }
1176         YY_BREAK
1177 case 15:
1178 YY_RULE_SETUP
1179 #line 120 "swf5compiler.flex"
1180 { count();      return FOR;             }
1181         YY_BREAK
1182 case 16:
1183 YY_RULE_SETUP
1184 #line 121 "swf5compiler.flex"
1185 { count();      return IN;              }
1186         YY_BREAK
1187 case 17:
1188 YY_RULE_SETUP
1189 #line 122 "swf5compiler.flex"
1190 { count();      return IF;              }
1191         YY_BREAK
1192 case 18:
1193 YY_RULE_SETUP
1194 #line 123 "swf5compiler.flex"
1195 { count();      return WHILE;           }
1196         YY_BREAK
1197 case 19:
1198 YY_RULE_SETUP
1199 #line 124 "swf5compiler.flex"
1200 { count();      return DO;              }
1201         YY_BREAK
1202 case 20:
1203 YY_RULE_SETUP
1204 #line 125 "swf5compiler.flex"
1205 { count();      return VAR;             }
1206         YY_BREAK
1207 case 21:
1208 YY_RULE_SETUP
1209 #line 126 "swf5compiler.flex"
1210 { count();      return NEW;             }
1211         YY_BREAK
1212 case 22:
1213 YY_RULE_SETUP
1214 #line 127 "swf5compiler.flex"
1215 { count();      return DELETE;          }
1216         YY_BREAK
1217 case 23:
1218 YY_RULE_SETUP
1219 #line 128 "swf5compiler.flex"
1220 { count();      return RETURN;          }
1221         YY_BREAK
1222 case 24:
1223 YY_RULE_SETUP
1224 #line 129 "swf5compiler.flex"
1225 { count();      return WITH;            }
1226         YY_BREAK
1227 case 25:
1228 YY_RULE_SETUP
1229 #line 130 "swf5compiler.flex"
1230 { count();      BEGIN(asm); return ASM;         }
1231         YY_BREAK
1232 case 26:
1233 YY_RULE_SETUP
1234 #line 131 "swf5compiler.flex"
1235 { count();      return EVAL;            }
1236         YY_BREAK
1237 case 27:
1238 YY_RULE_SETUP
1239 #line 132 "swf5compiler.flex"
1240 { count();      return TYPEOF; }
1241         YY_BREAK
1242 case 28:
1243 YY_RULE_SETUP
1244 #line 133 "swf5compiler.flex"
1245 { count();      return INSTANCEOF; }
1246         YY_BREAK
1247 /* legacy functions */
1248 case 29:
1249 YY_RULE_SETUP
1250 #line 136 "swf5compiler.flex"
1251 { count();      return RANDOM;  }
1252         YY_BREAK
1253 case 30:
1254 YY_RULE_SETUP
1255 #line 137 "swf5compiler.flex"
1256 { count();      return GETTIMER;        }
1257         YY_BREAK
1258 case 31:
1259 YY_RULE_SETUP
1260 #line 138 "swf5compiler.flex"
1261 { count();      return LENGTH;  }
1262         YY_BREAK
1263 case 32:
1264 YY_RULE_SETUP
1265 #line 139 "swf5compiler.flex"
1266 { count();      return CONCAT;  }
1267         YY_BREAK
1268 case 33:
1269 YY_RULE_SETUP
1270 #line 140 "swf5compiler.flex"
1271 { count();      return SUBSTR;  }
1272         YY_BREAK
1273 case 34:
1274 YY_RULE_SETUP
1275 #line 141 "swf5compiler.flex"
1276 { count();      return TRACE;   }
1277         YY_BREAK
1278 case 35:
1279 YY_RULE_SETUP
1280 #line 142 "swf5compiler.flex"
1281 { count();      return INT;     }
1282         YY_BREAK
1283 case 36:
1284 YY_RULE_SETUP
1285 #line 143 "swf5compiler.flex"
1286 { count();      return ORD;     }
1287         YY_BREAK
1288 case 37:
1289 YY_RULE_SETUP
1290 #line 144 "swf5compiler.flex"
1291 { count();      return CHR;     }
1292         YY_BREAK
1293 case 38:
1294 YY_RULE_SETUP
1295 #line 145 "swf5compiler.flex"
1296 { count();      return GETURL;  }
1297         YY_BREAK
1298 case 39:
1299 YY_RULE_SETUP
1300 #line 146 "swf5compiler.flex"
1301 { count();      return GETURL1; }
1302         YY_BREAK
1303 case 40:
1304 YY_RULE_SETUP
1305 #line 147 "swf5compiler.flex"
1306 { count();      return NEXTFRAME;       }
1307         YY_BREAK
1308 case 41:
1309 YY_RULE_SETUP
1310 #line 148 "swf5compiler.flex"
1311 { count();      return PREVFRAME;       }
1312         YY_BREAK
1313 case 42:
1314 YY_RULE_SETUP
1315 #line 149 "swf5compiler.flex"
1316 { count();      return PLAY;            }
1317         YY_BREAK
1318 case 43:
1319 YY_RULE_SETUP
1320 #line 150 "swf5compiler.flex"
1321 { count();      return STOP;            }
1322         YY_BREAK
1323 case 44:
1324 YY_RULE_SETUP
1325 #line 151 "swf5compiler.flex"
1326 { count();      return TOGGLEQUALITY;   }
1327         YY_BREAK
1328 case 45:
1329 YY_RULE_SETUP
1330 #line 152 "swf5compiler.flex"
1331 { count();      return STOPSOUNDS;      }
1332         YY_BREAK
1333 case 46:
1334 YY_RULE_SETUP
1335 #line 153 "swf5compiler.flex"
1336 { count();      return CALLFRAME;       }
1337         YY_BREAK
1338 case 47:
1339 YY_RULE_SETUP
1340 #line 154 "swf5compiler.flex"
1341 { count();      return GOTOFRAME;       }
1342         YY_BREAK
1343 case 48:
1344 YY_RULE_SETUP
1345 #line 155 "swf5compiler.flex"
1346 { count();      return SETTARGET;       }
1347         YY_BREAK
1348 case 49:
1349 YY_RULE_SETUP
1350 #line 156 "swf5compiler.flex"
1351 { count();      return LOADVARIABLES;   }
1352         YY_BREAK
1353 case 50:
1354 YY_RULE_SETUP
1355 #line 157 "swf5compiler.flex"
1356 { count();      return LOADMOVIE;       }
1357         YY_BREAK
1358 case 51:
1359 YY_RULE_SETUP
1360 #line 158 "swf5compiler.flex"
1361 { count();      return LOADVARIABLESNUM;        }
1362         YY_BREAK
1363 case 52:
1364 YY_RULE_SETUP
1365 #line 159 "swf5compiler.flex"
1366 { count();      return LOADMOVIENUM;    }
1367         YY_BREAK
1368 case 53:
1369 YY_RULE_SETUP
1370 #line 160 "swf5compiler.flex"
1371 { count();      return DUPLICATEMOVIECLIP; }
1372         YY_BREAK
1373 case 54:
1374 YY_RULE_SETUP
1375 #line 161 "swf5compiler.flex"
1376 { count();      return REMOVEMOVIECLIP; }
1377         YY_BREAK
1378 /* assembler ops */
1379
1380 case 55:
1381 YY_RULE_SETUP
1382 #line 165 "swf5compiler.flex"
1383 { count();      return DUP; }
1384         YY_BREAK
1385 case 56:
1386 YY_RULE_SETUP
1387 #line 166 "swf5compiler.flex"
1388 { count();      return SWAP; }
1389         YY_BREAK
1390 case 57:
1391 YY_RULE_SETUP
1392 #line 167 "swf5compiler.flex"
1393 { count();      return POP; }
1394         YY_BREAK
1395 case 58:
1396 YY_RULE_SETUP
1397 #line 168 "swf5compiler.flex"
1398 { count();      return PUSH; }
1399         YY_BREAK
1400 case 59:
1401 YY_RULE_SETUP
1402 #line 169 "swf5compiler.flex"
1403 { count();      return SETREGISTER; }
1404         YY_BREAK
1405 case 60:
1406 YY_RULE_SETUP
1407 #line 170 "swf5compiler.flex"
1408 { count();      return CALLFUNCTION; }
1409         YY_BREAK
1410 case 61:
1411 YY_RULE_SETUP
1412 #line 171 "swf5compiler.flex"
1413 { count();      return CALLMETHOD; }
1414         YY_BREAK
1415 case 62:
1416 YY_RULE_SETUP
1417 #line 172 "swf5compiler.flex"
1418 { count();      return AND; }
1419         YY_BREAK
1420 case 63:
1421 YY_RULE_SETUP
1422 #line 173 "swf5compiler.flex"
1423 { count();      return OR; }
1424         YY_BREAK
1425 case 64:
1426 YY_RULE_SETUP
1427 #line 174 "swf5compiler.flex"
1428 { count();      return XOR; }
1429         YY_BREAK
1430 case 65:
1431 YY_RULE_SETUP
1432 #line 175 "swf5compiler.flex"
1433 { count();      return MODULO; }
1434         YY_BREAK
1435 case 66:
1436 YY_RULE_SETUP
1437 #line 176 "swf5compiler.flex"
1438 { count();      return ADD; }
1439         YY_BREAK
1440 case 67:
1441 YY_RULE_SETUP
1442 #line 177 "swf5compiler.flex"
1443 { count();      return ADD; }
1444         YY_BREAK
1445 case 68:
1446 YY_RULE_SETUP
1447 #line 178 "swf5compiler.flex"
1448 { count();      return LESSTHAN; }
1449         YY_BREAK
1450 case 69:
1451 YY_RULE_SETUP
1452 #line 179 "swf5compiler.flex"
1453 { count();      return LESSTHAN; }
1454         YY_BREAK
1455 case 70:
1456 YY_RULE_SETUP
1457 #line 180 "swf5compiler.flex"
1458 { count();      return EQUALS; }
1459         YY_BREAK
1460 case 71:
1461 YY_RULE_SETUP
1462 #line 181 "swf5compiler.flex"
1463 { count();      return EQUALS; }
1464         YY_BREAK
1465 case 72:
1466 YY_RULE_SETUP
1467 #line 182 "swf5compiler.flex"
1468 { count();      return INC; }
1469         YY_BREAK
1470 case 73:
1471 YY_RULE_SETUP
1472 #line 183 "swf5compiler.flex"
1473 { count();      return DEC; }
1474         YY_BREAK
1475 case 74:
1476 YY_RULE_SETUP
1477 #line 184 "swf5compiler.flex"
1478 { count();      return ENUMERATE; }
1479         YY_BREAK
1480 case 75:
1481 YY_RULE_SETUP
1482 #line 185 "swf5compiler.flex"
1483 { count();      return INITOBJECT; }
1484         YY_BREAK
1485 case 76:
1486 YY_RULE_SETUP
1487 #line 186 "swf5compiler.flex"
1488 { count();      return INITARRAY; }
1489         YY_BREAK
1490 case 77:
1491 YY_RULE_SETUP
1492 #line 187 "swf5compiler.flex"
1493 { count();      return GETMEMBER; }
1494         YY_BREAK
1495 case 78:
1496 YY_RULE_SETUP
1497 #line 188 "swf5compiler.flex"
1498 { count();      return SETMEMBER; }
1499         YY_BREAK
1500 case 79:
1501 YY_RULE_SETUP
1502 #line 189 "swf5compiler.flex"
1503 { count();      return SHIFTLEFT; }
1504         YY_BREAK
1505 case 80:
1506 YY_RULE_SETUP
1507 #line 190 "swf5compiler.flex"
1508 { count();      return SHIFTRIGHT; }
1509         YY_BREAK
1510 case 81:
1511 YY_RULE_SETUP
1512 #line 191 "swf5compiler.flex"
1513 { count();      return SHIFTRIGHT2; }
1514         YY_BREAK
1515 case 82:
1516 YY_RULE_SETUP
1517 #line 192 "swf5compiler.flex"
1518 { count();      return VAREQUALS; }
1519         YY_BREAK
1520 case 83:
1521 YY_RULE_SETUP
1522 #line 193 "swf5compiler.flex"
1523 { count();      return OLDADD; }
1524         YY_BREAK
1525 case 84:
1526 YY_RULE_SETUP
1527 #line 194 "swf5compiler.flex"
1528 { count();      return SUBTRACT; }
1529         YY_BREAK
1530 case 85:
1531 YY_RULE_SETUP
1532 #line 195 "swf5compiler.flex"
1533 { count();      return MULTIPLY; }
1534         YY_BREAK
1535 case 86:
1536 YY_RULE_SETUP
1537 #line 196 "swf5compiler.flex"
1538 { count();      return DIVIDE; }
1539         YY_BREAK
1540 case 87:
1541 YY_RULE_SETUP
1542 #line 197 "swf5compiler.flex"
1543 { count();      return OLDEQUALS; }
1544         YY_BREAK
1545 case 88:
1546 YY_RULE_SETUP
1547 #line 198 "swf5compiler.flex"
1548 { count();      return OLDLESSTHAN; }
1549         YY_BREAK
1550 case 89:
1551 YY_RULE_SETUP
1552 #line 199 "swf5compiler.flex"
1553 { count();      return LOGICALAND; }
1554         YY_BREAK
1555 case 90:
1556 YY_RULE_SETUP
1557 #line 200 "swf5compiler.flex"
1558 { count();      return LOGICALOR; }
1559         YY_BREAK
1560 case 91:
1561 YY_RULE_SETUP
1562 #line 201 "swf5compiler.flex"
1563 { count();      return NOT; }
1564         YY_BREAK
1565 case 92:
1566 YY_RULE_SETUP
1567 #line 202 "swf5compiler.flex"
1568 { count();      return STRINGEQ; }
1569         YY_BREAK
1570 case 93:
1571 YY_RULE_SETUP
1572 #line 203 "swf5compiler.flex"
1573 { count();      return STRINGLENGTH; }
1574         YY_BREAK
1575 case 94:
1576 YY_RULE_SETUP
1577 #line 204 "swf5compiler.flex"
1578 { count();      return SUBSTRING; }
1579         YY_BREAK
1580 case 95:
1581 YY_RULE_SETUP
1582 #line 205 "swf5compiler.flex"
1583 { count();      return GETVARIABLE; }
1584         YY_BREAK
1585 case 96:
1586 YY_RULE_SETUP
1587 #line 206 "swf5compiler.flex"
1588 { count();      return SETVARIABLE; }
1589         YY_BREAK
1590 case 97:
1591 YY_RULE_SETUP
1592 #line 207 "swf5compiler.flex"
1593 { count();      return SETTARGETEXPRESSION; }
1594         YY_BREAK
1595 case 98:
1596 YY_RULE_SETUP
1597 #line 208 "swf5compiler.flex"
1598 { count();      return STARTDRAG; }
1599         YY_BREAK
1600 case 99:
1601 YY_RULE_SETUP
1602 #line 209 "swf5compiler.flex"
1603 { count();      return STOPDRAG; }
1604         YY_BREAK
1605 case 100:
1606 YY_RULE_SETUP
1607 #line 210 "swf5compiler.flex"
1608 { count();      return STRINGLESSTHAN; }
1609         YY_BREAK
1610 case 101:
1611 YY_RULE_SETUP
1612 #line 211 "swf5compiler.flex"
1613 { count();      return MBLENGTH; }
1614         YY_BREAK
1615 case 102:
1616 YY_RULE_SETUP
1617 #line 212 "swf5compiler.flex"
1618 { count();      return MBSUBSTRING; }
1619         YY_BREAK
1620 case 103:
1621 YY_RULE_SETUP
1622 #line 213 "swf5compiler.flex"
1623 { count();      return MBORD; }
1624         YY_BREAK
1625 case 104:
1626 YY_RULE_SETUP
1627 #line 214 "swf5compiler.flex"
1628 { count();      return MBCHR; }
1629         YY_BREAK
1630 case 105:
1631 YY_RULE_SETUP
1632 #line 215 "swf5compiler.flex"
1633 { count();      return BRANCHALWAYS; }
1634         YY_BREAK
1635 case 106:
1636 YY_RULE_SETUP
1637 #line 216 "swf5compiler.flex"
1638 { count();      return BRANCHALWAYS; }
1639         YY_BREAK
1640 case 107:
1641 YY_RULE_SETUP
1642 #line 217 "swf5compiler.flex"
1643 { count();      return BRANCHIFTRUE; }
1644         YY_BREAK
1645 case 108:
1646 YY_RULE_SETUP
1647 #line 218 "swf5compiler.flex"
1648 { count();      return POST; }
1649         YY_BREAK
1650 case 109:
1651 YY_RULE_SETUP
1652 #line 219 "swf5compiler.flex"
1653 { count();      return GET; }
1654         YY_BREAK
1655 case 110:
1656 YY_RULE_SETUP
1657 #line 220 "swf5compiler.flex"
1658 { count();      return END;             }
1659         YY_BREAK
1660
1661 case 111:
1662 YY_RULE_SETUP
1663 #line 223 "swf5compiler.flex"
1664 { count();      swf5lval.str = strdup(yytext+2);
1665                                         return REGISTER;        }
1666         YY_BREAK
1667 case 112:
1668 YY_RULE_SETUP
1669 #line 227 "swf5compiler.flex"
1670 { count();      swf5lval.str = strdup(yytext);
1671                                         return IDENTIFIER;      }
1672         YY_BREAK
1673 case 113:
1674 YY_RULE_SETUP
1675 #line 230 "swf5compiler.flex"
1676 { count();      swf5lval.str = strdup(yytext+1);
1677                                         swf5lval.str[strlen(swf5lval.str)-1]=0;
1678                                         unescape(swf5lval.str);
1679                                         return STRING;          }
1680         YY_BREAK
1681 case 114:
1682 YY_RULE_SETUP
1683 #line 235 "swf5compiler.flex"
1684 { count();      swf5lval.str = strdup(yytext+1);
1685                                         swf5lval.str[strlen(swf5lval.str)-1]=0;
1686                                         unescape(swf5lval.str);
1687                                         return STRING;          }
1688         YY_BREAK
1689 case 115:
1690 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1691 yy_c_buf_p = yy_cp -= 1;
1692 YY_DO_BEFORE_ACTION; /* set up yytext again */
1693 YY_RULE_SETUP
1694 #line 240 "swf5compiler.flex"
1695 { count();      swf5lval.str = strdup("");
1696                                         warning("Unterminated string!");
1697                                         return STRING;          }
1698         YY_BREAK
1699 case 116:
1700 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1701 yy_c_buf_p = yy_cp -= 1;
1702 YY_DO_BEFORE_ACTION; /* set up yytext again */
1703 YY_RULE_SETUP
1704 #line 244 "swf5compiler.flex"
1705 { count();      swf5lval.str = strdup("");
1706                                         warning("Unterminated string!");
1707                                         return STRING;          }
1708         YY_BREAK
1709 case 117:
1710 YY_RULE_SETUP
1711 #line 248 "swf5compiler.flex"
1712 { count();      comment();              }
1713         YY_BREAK
1714 case 118:
1715 YY_RULE_SETUP
1716 #line 249 "swf5compiler.flex"
1717 { count();      comment1();             }
1718         YY_BREAK
1719 case 119:
1720 YY_RULE_SETUP
1721 #line 250 "swf5compiler.flex"
1722 { count(); }
1723         YY_BREAK
1724 case 120:
1725 YY_RULE_SETUP
1726 #line 252 "swf5compiler.flex"
1727 { count();      return INCR; }
1728         YY_BREAK
1729 case 121:
1730 YY_RULE_SETUP
1731 #line 253 "swf5compiler.flex"
1732 { count();      return DECR; }
1733         YY_BREAK
1734 case 122:
1735 YY_RULE_SETUP
1736 #line 254 "swf5compiler.flex"
1737 { count();      return LE; }
1738         YY_BREAK
1739 case 123:
1740 YY_RULE_SETUP
1741 #line 255 "swf5compiler.flex"
1742 { count();      return GE; }
1743         YY_BREAK
1744 case 124:
1745 YY_RULE_SETUP
1746 #line 256 "swf5compiler.flex"
1747 { count();      return EQ; }
1748         YY_BREAK
1749 case 125:
1750 YY_RULE_SETUP
1751 #line 257 "swf5compiler.flex"
1752 { count();      return NE; }
1753         YY_BREAK
1754 case 126:
1755 YY_RULE_SETUP
1756 #line 258 "swf5compiler.flex"
1757 { count();      return LAN; }
1758         YY_BREAK
1759 case 127:
1760 YY_RULE_SETUP
1761 #line 259 "swf5compiler.flex"
1762 { count();      return LOR; }
1763         YY_BREAK
1764 case 128:
1765 YY_RULE_SETUP
1766 #line 260 "swf5compiler.flex"
1767 { count();      return MEQ; }
1768         YY_BREAK
1769 case 129:
1770 YY_RULE_SETUP
1771 #line 261 "swf5compiler.flex"
1772 { count();      return DEQ; }
1773         YY_BREAK
1774 case 130:
1775 YY_RULE_SETUP
1776 #line 262 "swf5compiler.flex"
1777 { count();      return IEQ; }
1778         YY_BREAK
1779 case 131:
1780 YY_RULE_SETUP
1781 #line 263 "swf5compiler.flex"
1782 { count();      return SEQ; }
1783         YY_BREAK
1784 case 132:
1785 YY_RULE_SETUP
1786 #line 264 "swf5compiler.flex"
1787 { count();      return AEQ; }
1788         YY_BREAK
1789 case 133:
1790 YY_RULE_SETUP
1791 #line 265 "swf5compiler.flex"
1792 { count();      return OEQ; }
1793         YY_BREAK
1794 case 134:
1795 YY_RULE_SETUP
1796 #line 266 "swf5compiler.flex"
1797 { count();      return SHL; }
1798         YY_BREAK
1799 case 135:
1800 YY_RULE_SETUP
1801 #line 267 "swf5compiler.flex"
1802 { count();      return SHR; }
1803         YY_BREAK
1804 case 136:
1805 YY_RULE_SETUP
1806 #line 268 "swf5compiler.flex"
1807 { count();      return SHR2; }
1808         YY_BREAK
1809 case 137:
1810 YY_RULE_SETUP
1811 #line 269 "swf5compiler.flex"
1812 { count();      return SHLEQ; }
1813         YY_BREAK
1814 case 138:
1815 YY_RULE_SETUP
1816 #line 270 "swf5compiler.flex"
1817 { count();      return SHREQ; }
1818         YY_BREAK
1819 case 139:
1820 YY_RULE_SETUP
1821 #line 271 "swf5compiler.flex"
1822 { count();      return SHR2EQ; }
1823         YY_BREAK
1824 case 140:
1825 YY_RULE_SETUP
1826 #line 273 "swf5compiler.flex"
1827 { count();      return '<'; }
1828         YY_BREAK
1829 case 141:
1830 YY_RULE_SETUP
1831 #line 274 "swf5compiler.flex"
1832 { count();      return '>'; }
1833         YY_BREAK
1834 case 142:
1835 YY_RULE_SETUP
1836 #line 275 "swf5compiler.flex"
1837 { count();      return ';'; }
1838         YY_BREAK
1839 case 143:
1840 YY_RULE_SETUP
1841 #line 276 "swf5compiler.flex"
1842 { count();      return '='; }
1843         YY_BREAK
1844 case 144:
1845 YY_RULE_SETUP
1846 #line 277 "swf5compiler.flex"
1847 { count();      return '+'; }
1848         YY_BREAK
1849 case 145:
1850 YY_RULE_SETUP
1851 #line 278 "swf5compiler.flex"
1852 { count();      return '-'; }
1853         YY_BREAK
1854 case 146:
1855 YY_RULE_SETUP
1856 #line 279 "swf5compiler.flex"
1857 { count();      return '&'; }
1858         YY_BREAK
1859 case 147:
1860 YY_RULE_SETUP
1861 #line 280 "swf5compiler.flex"
1862 { count();      return '|'; }
1863         YY_BREAK
1864 case 148:
1865 YY_RULE_SETUP
1866 #line 281 "swf5compiler.flex"
1867 { count();      return '^'; }
1868         YY_BREAK
1869 case 149:
1870 YY_RULE_SETUP
1871 #line 282 "swf5compiler.flex"
1872 { count();      return '*'; }
1873         YY_BREAK
1874 case 150:
1875 YY_RULE_SETUP
1876 #line 283 "swf5compiler.flex"
1877 { count();      return '/'; }
1878         YY_BREAK
1879 case 151:
1880 YY_RULE_SETUP
1881 #line 284 "swf5compiler.flex"
1882 { count();      return '%'; }
1883         YY_BREAK
1884 case 152:
1885 YY_RULE_SETUP
1886 #line 285 "swf5compiler.flex"
1887 { count();      return '!'; }
1888         YY_BREAK
1889 case 153:
1890 YY_RULE_SETUP
1891 #line 286 "swf5compiler.flex"
1892 { count();      return '('; }
1893         YY_BREAK
1894 case 154:
1895 YY_RULE_SETUP
1896 #line 287 "swf5compiler.flex"
1897 { count();      return ')'; }
1898         YY_BREAK
1899 case 155:
1900 YY_RULE_SETUP
1901 #line 288 "swf5compiler.flex"
1902 { count();      return '['; }
1903         YY_BREAK
1904 case 156:
1905 YY_RULE_SETUP
1906 #line 289 "swf5compiler.flex"
1907 { count();      return ']'; }
1908         YY_BREAK
1909 case 157:
1910 YY_RULE_SETUP
1911 #line 290 "swf5compiler.flex"
1912 { count();      return '{'; }
1913         YY_BREAK
1914 case 158:
1915 YY_RULE_SETUP
1916 #line 291 "swf5compiler.flex"
1917 { count();      BEGIN(0); return '}'; }
1918         YY_BREAK
1919 case 159:
1920 YY_RULE_SETUP
1921 #line 292 "swf5compiler.flex"
1922 { count();      return ','; }
1923         YY_BREAK
1924 case 160:
1925 YY_RULE_SETUP
1926 #line 293 "swf5compiler.flex"
1927 { count();      return '.'; }
1928         YY_BREAK
1929 case 161:
1930 YY_RULE_SETUP
1931 #line 294 "swf5compiler.flex"
1932 { count();      return '?'; }
1933         YY_BREAK
1934 case 162:
1935 YY_RULE_SETUP
1936 #line 295 "swf5compiler.flex"
1937 { count();      return ':'; }
1938         YY_BREAK
1939 case 163:
1940 YY_RULE_SETUP
1941 #line 296 "swf5compiler.flex"
1942 { count();      return '~'; }
1943         YY_BREAK
1944 case 164:
1945 YY_RULE_SETUP
1946 #line 298 "swf5compiler.flex"
1947 { count();      strcpy(szLine, yytext + 1);
1948                                         countline();    yyless(1);      }
1949         YY_BREAK
1950 case 165:
1951 YY_RULE_SETUP
1952 #line 301 "swf5compiler.flex"
1953 SWF_error("Unrecognized character: %s\n", yytext);
1954         YY_BREAK
1955 case 166:
1956 YY_RULE_SETUP
1957 #line 303 "swf5compiler.flex"
1958 ECHO;
1959         YY_BREAK
1960 #line 1961 "lex.swf5.c"
1961 case YY_STATE_EOF(INITIAL):
1962 case YY_STATE_EOF(asm):
1963         yyterminate();
1964
1965         case YY_END_OF_BUFFER:
1966                 {
1967                 /* Amount of text matched not including the EOB char. */
1968                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1969
1970                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1971                 *yy_cp = yy_hold_char;
1972                 YY_RESTORE_YY_MORE_OFFSET
1973
1974                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1975                         {
1976                         /* We're scanning a new file or input source.  It's
1977                          * possible that this happened because the user
1978                          * just pointed yyin at a new source and called
1979                          * yylex().  If so, then we have to assure
1980                          * consistency between yy_current_buffer and our
1981                          * globals.  Here is the right place to do so, because
1982                          * this is the first action (other than possibly a
1983                          * back-up) that will match for the new input source.
1984                          */
1985                         yy_n_chars = yy_current_buffer->yy_n_chars;
1986                         yy_current_buffer->yy_input_file = yyin;
1987                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1988                         }
1989
1990                 /* Note that here we test for yy_c_buf_p "<=" to the position
1991                  * of the first EOB in the buffer, since yy_c_buf_p will
1992                  * already have been incremented past the NUL character
1993                  * (since all states make transitions on EOB to the
1994                  * end-of-buffer state).  Contrast this with the test
1995                  * in input().
1996                  */
1997                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1998                         { /* This was really a NUL. */
1999                         yy_state_type yy_next_state;
2000
2001                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
2002
2003                         yy_current_state = yy_get_previous_state();
2004
2005                         /* Okay, we're now positioned to make the NUL
2006                          * transition.  We couldn't have
2007                          * yy_get_previous_state() go ahead and do it
2008                          * for us because it doesn't know how to deal
2009                          * with the possibility of jamming (and we don't
2010                          * want to build jamming into it because then it
2011                          * will run more slowly).
2012                          */
2013
2014                         yy_next_state = yy_try_NUL_trans( yy_current_state );
2015
2016                         yy_bp = yytext_ptr + YY_MORE_ADJ;
2017
2018                         if ( yy_next_state )
2019                                 {
2020                                 /* Consume the NUL. */
2021                                 yy_cp = ++yy_c_buf_p;
2022                                 yy_current_state = yy_next_state;
2023                                 goto yy_match;
2024                                 }
2025
2026                         else
2027                                 {
2028                                 yy_cp = yy_c_buf_p;
2029                                 goto yy_find_action;
2030                                 }
2031                         }
2032
2033                 else switch ( yy_get_next_buffer() )
2034                         {
2035                         case EOB_ACT_END_OF_FILE:
2036                                 {
2037                                 yy_did_buffer_switch_on_eof = 0;
2038
2039                                 if ( yywrap() )
2040                                         {
2041                                         /* Note: because we've taken care in
2042                                          * yy_get_next_buffer() to have set up
2043                                          * yytext, we can now set up
2044                                          * yy_c_buf_p so that if some total
2045                                          * hoser (like flex itself) wants to
2046                                          * call the scanner after we return the
2047                                          * YY_NULL, it'll still work - another
2048                                          * YY_NULL will get returned.
2049                                          */
2050                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
2051
2052                                         yy_act = YY_STATE_EOF(YY_START);
2053                                         goto do_action;
2054                                         }
2055
2056                                 else
2057                                         {
2058                                         if ( ! yy_did_buffer_switch_on_eof )
2059                                                 YY_NEW_FILE;
2060                                         }
2061                                 break;
2062                                 }
2063
2064                         case EOB_ACT_CONTINUE_SCAN:
2065                                 yy_c_buf_p =
2066                                         yytext_ptr + yy_amount_of_matched_text;
2067
2068                                 yy_current_state = yy_get_previous_state();
2069
2070                                 yy_cp = yy_c_buf_p;
2071                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
2072                                 goto yy_match;
2073
2074                         case EOB_ACT_LAST_MATCH:
2075                                 yy_c_buf_p =
2076                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
2077
2078                                 yy_current_state = yy_get_previous_state();
2079
2080                                 yy_cp = yy_c_buf_p;
2081                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
2082                                 goto yy_find_action;
2083                         }
2084                 break;
2085                 }
2086
2087         default:
2088                 YY_FATAL_ERROR(
2089                         "fatal flex scanner internal error--no action found" );
2090         } /* end of action switch */
2091                 } /* end of scanning one token */
2092         } /* end of yylex */
2093
2094
2095 /* yy_get_next_buffer - try to read in a new buffer
2096  *
2097  * Returns a code representing an action:
2098  *      EOB_ACT_LAST_MATCH -
2099  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2100  *      EOB_ACT_END_OF_FILE - end of file
2101  */
2102
2103 static int yy_get_next_buffer()
2104         {
2105         register char *dest = yy_current_buffer->yy_ch_buf;
2106         register char *source = yytext_ptr;
2107         register int number_to_move, i;
2108         int ret_val;
2109
2110         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
2111                 YY_FATAL_ERROR(
2112                 "fatal flex scanner internal error--end of buffer missed" );
2113
2114         if ( yy_current_buffer->yy_fill_buffer == 0 )
2115                 { /* Don't try to fill the buffer, so this is an EOF. */
2116                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
2117                         {
2118                         /* We matched a single character, the EOB, so
2119                          * treat this as a final EOF.
2120                          */
2121                         return EOB_ACT_END_OF_FILE;
2122                         }
2123
2124                 else
2125                         {
2126                         /* We matched some text prior to the EOB, first
2127                          * process it.
2128                          */
2129                         return EOB_ACT_LAST_MATCH;
2130                         }
2131                 }
2132
2133         /* Try to read more data. */
2134
2135         /* First move last chars to start of buffer. */
2136         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
2137
2138         for ( i = 0; i < number_to_move; ++i )
2139                 *(dest++) = *(source++);
2140
2141         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2142                 /* don't do the read, it's not guaranteed to return an EOF,
2143                  * just force an EOF
2144                  */
2145                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
2146
2147         else
2148                 {
2149                 int num_to_read =
2150                         yy_current_buffer->yy_buf_size - number_to_move - 1;
2151
2152                 while ( num_to_read <= 0 )
2153                         { /* Not enough room in the buffer - grow it. */
2154 #ifdef YY_USES_REJECT
2155                         YY_FATAL_ERROR(
2156 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2157 #else
2158
2159                         /* just a shorter name for the current buffer */
2160                         YY_BUFFER_STATE b = yy_current_buffer;
2161
2162                         int yy_c_buf_p_offset =
2163                                 (int) (yy_c_buf_p - b->yy_ch_buf);
2164
2165                         if ( b->yy_is_our_buffer )
2166                                 {
2167                                 int new_size = b->yy_buf_size * 2;
2168
2169                                 if ( new_size <= 0 )
2170                                         b->yy_buf_size += b->yy_buf_size / 8;
2171                                 else
2172                                         b->yy_buf_size *= 2;
2173
2174                                 b->yy_ch_buf = (char *)
2175                                         /* Include room in for 2 EOB chars. */
2176                                         yy_flex_realloc( (void *) b->yy_ch_buf,
2177                                                          b->yy_buf_size + 2 );
2178                                 }
2179                         else
2180                                 /* Can't grow it, we don't own it. */
2181                                 b->yy_ch_buf = 0;
2182
2183                         if ( ! b->yy_ch_buf )
2184                                 YY_FATAL_ERROR(
2185                                 "fatal error - scanner input buffer overflow" );
2186
2187                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2188
2189                         num_to_read = yy_current_buffer->yy_buf_size -
2190                                                 number_to_move - 1;
2191 #endif
2192                         }
2193
2194                 if ( num_to_read > YY_READ_BUF_SIZE )
2195                         num_to_read = YY_READ_BUF_SIZE;
2196
2197                 /* Read in more data. */
2198                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
2199                         yy_n_chars, num_to_read );
2200
2201                 yy_current_buffer->yy_n_chars = yy_n_chars;
2202                 }
2203
2204         if ( yy_n_chars == 0 )
2205                 {
2206                 if ( number_to_move == YY_MORE_ADJ )
2207                         {
2208                         ret_val = EOB_ACT_END_OF_FILE;
2209                         yyrestart( yyin );
2210                         }
2211
2212                 else
2213                         {
2214                         ret_val = EOB_ACT_LAST_MATCH;
2215                         yy_current_buffer->yy_buffer_status =
2216                                 YY_BUFFER_EOF_PENDING;
2217                         }
2218                 }
2219
2220         else
2221                 ret_val = EOB_ACT_CONTINUE_SCAN;
2222
2223         yy_n_chars += number_to_move;
2224         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2225         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2226
2227         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
2228
2229         return ret_val;
2230         }
2231
2232
2233 /* yy_get_previous_state - get the state just before the EOB char was reached */
2234
2235 static yy_state_type yy_get_previous_state()
2236         {
2237         register yy_state_type yy_current_state;
2238         register char *yy_cp;
2239
2240         yy_current_state = yy_start;
2241
2242         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
2243                 {
2244                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2245                 if ( yy_accept[yy_current_state] )
2246                         {
2247                         yy_last_accepting_state = yy_current_state;
2248                         yy_last_accepting_cpos = yy_cp;
2249                         }
2250                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2251                         {
2252                         yy_current_state = (int) yy_def[yy_current_state];
2253                         if ( yy_current_state >= 650 )
2254                                 yy_c = yy_meta[(unsigned int) yy_c];
2255                         }
2256                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2257                 }
2258
2259         return yy_current_state;
2260         }
2261
2262
2263 /* yy_try_NUL_trans - try to make a transition on the NUL character
2264  *
2265  * synopsis
2266  *      next_state = yy_try_NUL_trans( current_state );
2267  */
2268
2269 #ifdef YY_USE_PROTOS
2270 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2271 #else
2272 static yy_state_type yy_try_NUL_trans( yy_current_state )
2273 yy_state_type yy_current_state;
2274 #endif
2275         {
2276         register int yy_is_jam;
2277         register char *yy_cp = yy_c_buf_p;
2278
2279         register YY_CHAR yy_c = 1;
2280         if ( yy_accept[yy_current_state] )
2281                 {
2282                 yy_last_accepting_state = yy_current_state;
2283                 yy_last_accepting_cpos = yy_cp;
2284                 }
2285         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2286                 {
2287                 yy_current_state = (int) yy_def[yy_current_state];
2288                 if ( yy_current_state >= 650 )
2289                         yy_c = yy_meta[(unsigned int) yy_c];
2290                 }
2291         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2292         yy_is_jam = (yy_current_state == 649);
2293
2294         return yy_is_jam ? 0 : yy_current_state;
2295         }
2296
2297
2298 #ifndef YY_NO_UNPUT
2299 #ifdef YY_USE_PROTOS
2300 static void yyunput( int c, register char *yy_bp )
2301 #else
2302 static void yyunput( c, yy_bp )
2303 int c;
2304 register char *yy_bp;
2305 #endif
2306         {
2307         register char *yy_cp = yy_c_buf_p;
2308
2309         /* undo effects of setting up yytext */
2310         *yy_cp = yy_hold_char;
2311
2312         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2313                 { /* need to shift things up to make room */
2314                 /* +2 for EOB chars. */
2315                 register int number_to_move = yy_n_chars + 2;
2316                 register char *dest = &yy_current_buffer->yy_ch_buf[
2317                                         yy_current_buffer->yy_buf_size + 2];
2318                 register char *source =
2319                                 &yy_current_buffer->yy_ch_buf[number_to_move];
2320
2321                 while ( source > yy_current_buffer->yy_ch_buf )
2322                         *--dest = *--source;
2323
2324                 yy_cp += (int) (dest - source);
2325                 yy_bp += (int) (dest - source);
2326                 yy_current_buffer->yy_n_chars =
2327                         yy_n_chars = yy_current_buffer->yy_buf_size;
2328
2329                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2330                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2331                 }
2332
2333         *--yy_cp = (char) c;
2334
2335
2336         yytext_ptr = yy_bp;
2337         yy_hold_char = *yy_cp;
2338         yy_c_buf_p = yy_cp;
2339         }
2340 #endif  /* ifndef YY_NO_UNPUT */
2341
2342
2343 #ifdef __cplusplus
2344 static int yyinput()
2345 #else
2346 static int input()
2347 #endif
2348         {
2349         int c;
2350
2351         *yy_c_buf_p = yy_hold_char;
2352
2353         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2354                 {
2355                 /* yy_c_buf_p now points to the character we want to return.
2356                  * If this occurs *before* the EOB characters, then it's a
2357                  * valid NUL; if not, then we've hit the end of the buffer.
2358                  */
2359                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2360                         /* This was really a NUL. */
2361                         *yy_c_buf_p = '\0';
2362
2363                 else
2364                         { /* need more input */
2365                         int offset = yy_c_buf_p - yytext_ptr;
2366                         ++yy_c_buf_p;
2367
2368                         switch ( yy_get_next_buffer() )
2369                                 {
2370                                 case EOB_ACT_LAST_MATCH:
2371                                         /* This happens because yy_g_n_b()
2372                                          * sees that we've accumulated a
2373                                          * token and flags that we need to
2374                                          * try matching the token before
2375                                          * proceeding.  But for input(),
2376                                          * there's no matching to consider.
2377                                          * So convert the EOB_ACT_LAST_MATCH
2378                                          * to EOB_ACT_END_OF_FILE.
2379                                          */
2380
2381                                         /* Reset buffer status. */
2382                                         yyrestart( yyin );
2383
2384                                         /* fall through */
2385
2386                                 case EOB_ACT_END_OF_FILE:
2387                                         {
2388                                         if ( yywrap() )
2389                                                 return EOF;
2390
2391                                         if ( ! yy_did_buffer_switch_on_eof )
2392                                                 YY_NEW_FILE;
2393 #ifdef __cplusplus
2394                                         return yyinput();
2395 #else
2396                                         return input();
2397 #endif
2398                                         }
2399
2400                                 case EOB_ACT_CONTINUE_SCAN:
2401                                         yy_c_buf_p = yytext_ptr + offset;
2402                                         break;
2403                                 }
2404                         }
2405                 }
2406
2407         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
2408         *yy_c_buf_p = '\0';     /* preserve yytext */
2409         yy_hold_char = *++yy_c_buf_p;
2410
2411
2412         return c;
2413         }
2414
2415
2416 #ifdef YY_USE_PROTOS
2417 void yyrestart( FILE *input_file )
2418 #else
2419 void yyrestart( input_file )
2420 FILE *input_file;
2421 #endif
2422         {
2423         if ( ! yy_current_buffer )
2424                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2425
2426         yy_init_buffer( yy_current_buffer, input_file );
2427         yy_load_buffer_state();
2428         }
2429
2430
2431 #ifdef YY_USE_PROTOS
2432 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2433 #else
2434 void yy_switch_to_buffer( new_buffer )
2435 YY_BUFFER_STATE new_buffer;
2436 #endif
2437         {
2438         if ( yy_current_buffer == new_buffer )
2439                 return;
2440
2441         if ( yy_current_buffer )
2442                 {
2443                 /* Flush out information for old buffer. */
2444                 *yy_c_buf_p = yy_hold_char;
2445                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2446                 yy_current_buffer->yy_n_chars = yy_n_chars;
2447                 }
2448
2449         yy_current_buffer = new_buffer;
2450         yy_load_buffer_state();
2451
2452         /* We don't actually know whether we did this switch during
2453          * EOF (yywrap()) processing, but the only time this flag
2454          * is looked at is after yywrap() is called, so it's safe
2455          * to go ahead and always set it.
2456          */
2457         yy_did_buffer_switch_on_eof = 1;
2458         }
2459
2460
2461 #ifdef YY_USE_PROTOS
2462 void yy_load_buffer_state( void )
2463 #else
2464 void yy_load_buffer_state()
2465 #endif
2466         {
2467         yy_n_chars = yy_current_buffer->yy_n_chars;
2468         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2469         yyin = yy_current_buffer->yy_input_file;
2470         yy_hold_char = *yy_c_buf_p;
2471         }
2472
2473
2474 #ifdef YY_USE_PROTOS
2475 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2476 #else
2477 YY_BUFFER_STATE yy_create_buffer( file, size )
2478 FILE *file;
2479 int size;
2480 #endif
2481         {
2482         YY_BUFFER_STATE b;
2483
2484         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2485         if ( ! b )
2486                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2487
2488         b->yy_buf_size = size;
2489
2490         /* yy_ch_buf has to be 2 characters longer than the size given because
2491          * we need to put in 2 end-of-buffer characters.
2492          */
2493         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2494         if ( ! b->yy_ch_buf )
2495                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2496
2497         b->yy_is_our_buffer = 1;
2498
2499         yy_init_buffer( b, file );
2500
2501         return b;
2502         }
2503
2504
2505 #ifdef YY_USE_PROTOS
2506 void yy_delete_buffer( YY_BUFFER_STATE b )
2507 #else
2508 void yy_delete_buffer( b )
2509 YY_BUFFER_STATE b;
2510 #endif
2511         {
2512         if ( ! b )
2513                 return;
2514
2515         if ( b == yy_current_buffer )
2516                 yy_current_buffer = (YY_BUFFER_STATE) 0;
2517
2518         if ( b->yy_is_our_buffer )
2519                 yy_flex_free( (void *) b->yy_ch_buf );
2520
2521         yy_flex_free( (void *) b );
2522         }
2523
2524
2525
2526 #ifdef YY_USE_PROTOS
2527 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2528 #else
2529 void yy_init_buffer( b, file )
2530 YY_BUFFER_STATE b;
2531 FILE *file;
2532 #endif
2533
2534
2535         {
2536         yy_flush_buffer( b );
2537
2538         b->yy_input_file = file;
2539         b->yy_fill_buffer = 1;
2540
2541 #if YY_ALWAYS_INTERACTIVE
2542         b->yy_is_interactive = 1;
2543 #else
2544 #if YY_NEVER_INTERACTIVE
2545         b->yy_is_interactive = 0;
2546 #else
2547         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2548 #endif
2549 #endif
2550         }
2551
2552
2553 #ifdef YY_USE_PROTOS
2554 void yy_flush_buffer( YY_BUFFER_STATE b )
2555 #else
2556 void yy_flush_buffer( b )
2557 YY_BUFFER_STATE b;
2558 #endif
2559
2560         {
2561         if ( ! b )
2562                 return;
2563
2564         b->yy_n_chars = 0;
2565
2566         /* We always need two end-of-buffer characters.  The first causes
2567          * a transition to the end-of-buffer state.  The second causes
2568          * a jam in that state.
2569          */
2570         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2571         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2572
2573         b->yy_buf_pos = &b->yy_ch_buf[0];
2574
2575         b->yy_at_bol = 1;
2576         b->yy_buffer_status = YY_BUFFER_NEW;
2577
2578         if ( b == yy_current_buffer )
2579                 yy_load_buffer_state();
2580         }
2581
2582
2583 #ifndef YY_NO_SCAN_BUFFER
2584 #ifdef YY_USE_PROTOS
2585 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2586 #else
2587 YY_BUFFER_STATE yy_scan_buffer( base, size )
2588 char *base;
2589 yy_size_t size;
2590 #endif
2591         {
2592         YY_BUFFER_STATE b;
2593
2594         if ( size < 2 ||
2595              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2596              base[size-1] != YY_END_OF_BUFFER_CHAR )
2597                 /* They forgot to leave room for the EOB's. */
2598                 return 0;
2599
2600         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2601         if ( ! b )
2602                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2603
2604         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2605         b->yy_buf_pos = b->yy_ch_buf = base;
2606         b->yy_is_our_buffer = 0;
2607         b->yy_input_file = 0;
2608         b->yy_n_chars = b->yy_buf_size;
2609         b->yy_is_interactive = 0;
2610         b->yy_at_bol = 1;
2611         b->yy_fill_buffer = 0;
2612         b->yy_buffer_status = YY_BUFFER_NEW;
2613
2614         yy_switch_to_buffer( b );
2615
2616         return b;
2617         }
2618 #endif
2619
2620
2621 #ifndef YY_NO_SCAN_STRING
2622 #ifdef YY_USE_PROTOS
2623 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2624 #else
2625 YY_BUFFER_STATE yy_scan_string( yy_str )
2626 yyconst char *yy_str;
2627 #endif
2628         {
2629         int len;
2630         for ( len = 0; yy_str[len]; ++len )
2631                 ;
2632
2633         return yy_scan_bytes( yy_str, len );
2634         }
2635 #endif
2636
2637
2638 #ifndef YY_NO_SCAN_BYTES
2639 #ifdef YY_USE_PROTOS
2640 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2641 #else
2642 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2643 yyconst char *bytes;
2644 int len;
2645 #endif
2646         {
2647         YY_BUFFER_STATE b;
2648         char *buf;
2649         yy_size_t n;
2650         int i;
2651
2652         /* Get memory for full buffer, including space for trailing EOB's. */
2653         n = len + 2;
2654         buf = (char *) yy_flex_alloc( n );
2655         if ( ! buf )
2656                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2657
2658         for ( i = 0; i < len; ++i )
2659                 buf[i] = bytes[i];
2660
2661         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2662
2663         b = yy_scan_buffer( buf, n );
2664         if ( ! b )
2665                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2666
2667         /* It's okay to grow etc. this buffer, and we should throw it
2668          * away when we're done.
2669          */
2670         b->yy_is_our_buffer = 1;
2671
2672         return b;
2673         }
2674 #endif
2675
2676
2677 #ifndef YY_NO_PUSH_STATE
2678 #ifdef YY_USE_PROTOS
2679 static void yy_push_state( int new_state )
2680 #else
2681 static void yy_push_state( new_state )
2682 int new_state;
2683 #endif
2684         {
2685         if ( yy_start_stack_ptr >= yy_start_stack_depth )
2686                 {
2687                 yy_size_t new_size;
2688
2689                 yy_start_stack_depth += YY_START_STACK_INCR;
2690                 new_size = yy_start_stack_depth * sizeof( int );
2691
2692                 if ( ! yy_start_stack )
2693                         yy_start_stack = (int *) yy_flex_alloc( new_size );
2694
2695                 else
2696                         yy_start_stack = (int *) yy_flex_realloc(
2697                                         (void *) yy_start_stack, new_size );
2698
2699                 if ( ! yy_start_stack )
2700                         YY_FATAL_ERROR(
2701                         "out of memory expanding start-condition stack" );
2702                 }
2703
2704         yy_start_stack[yy_start_stack_ptr++] = YY_START;
2705
2706         BEGIN(new_state);
2707         }
2708 #endif
2709
2710
2711 #ifndef YY_NO_POP_STATE
2712 static void yy_pop_state()
2713         {
2714         if ( --yy_start_stack_ptr < 0 )
2715                 YY_FATAL_ERROR( "start-condition stack underflow" );
2716
2717         BEGIN(yy_start_stack[yy_start_stack_ptr]);
2718         }
2719 #endif
2720
2721
2722 #ifndef YY_NO_TOP_STATE
2723 static int yy_top_state()
2724         {
2725         return yy_start_stack[yy_start_stack_ptr - 1];
2726         }
2727 #endif
2728
2729 #ifndef YY_EXIT_FAILURE
2730 #define YY_EXIT_FAILURE 2
2731 #endif
2732
2733 #ifdef YY_USE_PROTOS
2734 static void yy_fatal_error( yyconst char msg[] )
2735 #else
2736 static void yy_fatal_error( msg )
2737 char msg[];
2738 #endif
2739         {
2740         (void) fprintf( stderr, "%s\n", msg );
2741         exit( YY_EXIT_FAILURE );
2742         }
2743
2744
2745
2746 /* Redefine yyless() so it works in section 3 code. */
2747
2748 #undef yyless
2749 #define yyless(n) \
2750         do \
2751                 { \
2752                 /* Undo effects of setting up yytext. */ \
2753                 yytext[yyleng] = yy_hold_char; \
2754                 yy_c_buf_p = yytext + n; \
2755                 yy_hold_char = *yy_c_buf_p; \
2756                 *yy_c_buf_p = '\0'; \
2757                 yyleng = n; \
2758                 } \
2759         while ( 0 )
2760
2761
2762 /* Internal utility routines. */
2763
2764 #ifndef yytext_ptr
2765 #ifdef YY_USE_PROTOS
2766 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2767 #else
2768 static void yy_flex_strncpy( s1, s2, n )
2769 char *s1;
2770 yyconst char *s2;
2771 int n;
2772 #endif
2773         {
2774         register int i;
2775         for ( i = 0; i < n; ++i )
2776                 s1[i] = s2[i];
2777         }
2778 #endif
2779
2780 #ifdef YY_NEED_STRLEN
2781 #ifdef YY_USE_PROTOS
2782 static int yy_flex_strlen( yyconst char *s )
2783 #else
2784 static int yy_flex_strlen( s )
2785 yyconst char *s;
2786 #endif
2787         {
2788         register int n;
2789         for ( n = 0; s[n]; ++n )
2790                 ;
2791
2792         return n;
2793         }
2794 #endif
2795
2796
2797 #ifdef YY_USE_PROTOS
2798 static void *yy_flex_alloc( yy_size_t size )
2799 #else
2800 static void *yy_flex_alloc( size )
2801 yy_size_t size;
2802 #endif
2803         {
2804         return (void *) malloc( size );
2805         }
2806
2807 #ifdef YY_USE_PROTOS
2808 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2809 #else
2810 static void *yy_flex_realloc( ptr, size )
2811 void *ptr;
2812 yy_size_t size;
2813 #endif
2814         {
2815         /* The cast to (char *) in the following accommodates both
2816          * implementations that use char* generic pointers, and those
2817          * that use void* generic pointers.  It works with the latter
2818          * because both ANSI C and C++ allow castless assignment from
2819          * any pointer type to void*, and deal with argument conversions
2820          * as though doing an assignment.
2821          */
2822         return (void *) realloc( (char *) ptr, size );
2823         }
2824
2825 #ifdef YY_USE_PROTOS
2826 static void yy_flex_free( void *ptr )
2827 #else
2828 static void yy_flex_free( ptr )
2829 void *ptr;
2830 #endif
2831         {
2832         free( ptr );
2833         }
2834
2835 #if YY_MAIN
2836 int main()
2837         {
2838         yylex();
2839         return 0;
2840         }
2841 #endif
2842 #line 303 "swf5compiler.flex"
2843
2844 static int getinput() {
2845 #ifdef __cplusplus
2846                                         return yyinput();
2847 #else
2848                                         return input();
2849 #endif
2850 }
2851
2852 int swf5wrap()
2853 {
2854   return 1;
2855 }
2856
2857 static void countline()
2858 {
2859   if(sLineNumber != 0)
2860     msgline[column] = 0;
2861
2862   ++sLineNumber;
2863   column = 0;
2864   msgline = msgbufs[sLineNumber & 1];
2865 }
2866
2867 static int LineNumber(void)
2868 {
2869    return (sLineNumber + 1);
2870 }
2871
2872 static int ColumnNumber(void)
2873 {
2874    return column;
2875 }
2876
2877 static char *LineText(void)
2878 {
2879   msgline[column] = 0;
2880   return msgline;
2881 }
2882
2883 static void comment()
2884 {
2885    // Handle block comments
2886
2887    int c, c1;
2888
2889 loop:
2890    // We have the start of a comment so look skip everything up to the
2891    // end of the comment character
2892    while ((c = getinput()) != '*' && c != EOF)
2893    {
2894       if(column < 1023)
2895          msgline[column] = c;
2896
2897       ++column;
2898
2899       // keep the line number in synch
2900       if (c == '\n')
2901       {
2902          // start the output (matches the algorithim in the lexx above)
2903          countline();
2904       }
2905
2906       if (swf5debug) putchar(c);
2907    }
2908
2909    // is this the end of comment character
2910    if ((c1 = getinput()) != '/' && c != EOF)
2911    {
2912       // false start as this was no end of comment
2913       do_unput5(c1);
2914       goto loop;
2915    }
2916
2917    // write out the start of the end of comment
2918    if (c != EOF)
2919       if (swf5debug) putchar(c);
2920
2921    // write out the end of the end of comment
2922    if (c1 != EOF) 
2923       if (swf5debug) putchar(c1);
2924 }
2925
2926 static void comment1()
2927 {
2928    // Handle comment of type 1 (ie '//')
2929
2930    int c;
2931
2932    // this is a line comment
2933    while ((c = getinput()) != '\n' && c != EOF)
2934    {
2935       if (swf5debug) putchar(c);
2936
2937       if(column < 1023)
2938          msgline[column] = c;
2939
2940       ++column;
2941    };
2942
2943    // keep the line number in synch
2944    if (c == '\n')
2945    {
2946       if (swf5debug) putchar(c);
2947
2948       countline();
2949    }
2950 }
2951
2952 static void count(void)
2953 {
2954    int n;
2955
2956    // Count the characters to maintain the current column position
2957    if (yytext[0] == '\n')
2958    {
2959       if (swf5debug) printf("\n");
2960    }
2961    else
2962    {
2963       if (swf5debug) printf("%s", yytext);
2964
2965       for(n=0; n<yyleng; ++n, ++column)
2966       {
2967         if(column < 1023)
2968           msgline[column] = yytext[n];
2969       }
2970
2971       //-- keep writing the stuff to standard output
2972       //column += yyleng;
2973    }
2974 }
2975
2976 static void printprog()
2977 {
2978   if(sLineNumber)
2979     SWF_warn("\n%s", msgbufs[(sLineNumber-1)&1]);
2980
2981   if(column < 1023)
2982     msgline[column] = 0;
2983
2984   SWF_warn("\n%s", msgline);
2985 }
2986
2987 static void warning(char *msg)
2988 {
2989    // print a warning message
2990    printprog();
2991    SWF_warn("\n%*s", ColumnNumber(), "^");
2992    SWF_warn("\nLine %4.4d:  Reason: '%s' \n", LineNumber(), msg);
2993 }
2994
2995 void swf5error(char *msg)
2996 {
2997   // report a error
2998   if(strlen(yytext))
2999   {
3000     SWF_error("\n%s\n%*s\nLine %i:  Reason: '%s'\n",
3001               LineText(), ColumnNumber(), "^", LineNumber(), msg);
3002   }
3003   else
3004   {
3005     SWF_error("\nLine %d: Reason: 'Unexpected EOF found while looking for input.'\n", LineNumber());
3006   }
3007 }