added a distinctive prefix
authorkramm <kramm>
Wed, 12 Nov 2008 10:29:21 +0000 (10:29 +0000)
committerkramm <kramm>
Wed, 12 Nov 2008 10:29:21 +0000 (10:29 +0000)
lib/action/lex.swf4.c
lib/action/lex.swf5.c
lib/action/swf5compiler.tab.c
lib/action/swf5compiler.tab.h

index 4977168..79fc20b 100644 (file)
@@ -1,49 +1,92 @@
-#define yy_create_buffer swf4_create_buffer
-#define yy_delete_buffer swf4_delete_buffer
-#define yy_scan_buffer swf4_scan_buffer
-#define yy_scan_string swf4_scan_string
-#define yy_scan_bytes swf4_scan_bytes
-#define yy_flex_debug swf4_flex_debug
-#define yy_init_buffer swf4_init_buffer
-#define yy_flush_buffer swf4_flush_buffer
-#define yy_load_buffer_state swf4_load_buffer_state
-#define yy_switch_to_buffer swf4_switch_to_buffer
-#define yyin swf4in
-#define yyleng swf4leng
-#define yylex swf4lex
-#define yyout swf4out
-#define yyrestart swf4restart
-#define yytext swf4text
-#define yywrap swf4wrap
 
-/* A lexical scanner generated by flex */
+#line 3 "lex.swf4.c"
 
-/* Scanner skeleton version:
- * $Header: /cvsroot/swftools/swftools/lib/action/lex.swf4.c,v 1.1 2008/05/24 17:09:25 kramm Exp $
- */
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
 
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
+#define YY_FLEX_SUBMINOR_VERSION 33
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
 
+/* begin standard C headers. */
 #include <stdio.h>
-#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
 
+/* end standard C headers. */
 
-/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
-#ifdef c_plusplus
-#ifndef __cplusplus
-#define __cplusplus
-#endif
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
 #endif
 
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+#endif /* ! C99 */
 
-#ifdef __cplusplus
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
 
-#include <stdlib.h>
+#endif /* ! FLEXINT_H */
 
-/* Use prototypes in function declarations. */
-#define YY_USE_PROTOS
+#ifdef __cplusplus
 
 /* The "const" storage-class-modifier is valid. */
 #define YY_USE_CONST
 
 #if __STDC__
 
-#define YY_USE_PROTOS
 #define YY_USE_CONST
 
 #endif /* __STDC__ */
 #endif /* ! __cplusplus */
 
-#ifdef __TURBOC__
- #pragma warn -rch
- #pragma warn -use
-#include <io.h>
-#include <stdlib.h>
-#define YY_USE_CONST
-#define YY_USE_PROTOS
-#endif
-
 #ifdef YY_USE_CONST
 #define yyconst const
 #else
 #define yyconst
 #endif
 
-
-#ifdef YY_USE_PROTOS
-#define YY_PROTO(proto) proto
-#else
-#define YY_PROTO(proto) ()
-#endif
-
 /* Returned upon end-of-file. */
 #define YY_NULL 0
 
  * but we do it the disgusting crufty way forced on us by the ()-less
  * definition of BEGIN.
  */
-#define BEGIN yy_start = 1 + 2 *
+#define BEGIN (yy_start) = 1 + 2 *
 
 /* Translate the current start state into a value that can be later handed
  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  * compatibility.
  */
-#define YY_START ((yy_start - 1) / 2)
+#define YY_START (((yy_start) - 1) / 2)
 #define YYSTATE YY_START
 
 /* Action number for EOF rule of a given start state. */
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 
 /* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE yyrestart( yyin )
+#define YY_NEW_FILE swf4restart(swf4in  )
 
 #define YY_END_OF_BUFFER_CHAR 0
 
 /* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
 #define YY_BUF_SIZE 16384
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+extern int swf4leng;
 
-extern int yyleng;
-extern FILE *yyin, *yyout;
+extern FILE *swf4in, *swf4out;
 
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
 
-/* The funky do-while in the following #define is used to turn the definition
- * int a single C statement (which needs a semi-colon terminator).  This
- * avoids problems with code like:
- *
- *     if ( condition_holds )
- *             yyless( 5 );
- *     else
- *             do_something_else();
- *
- * Prior to using the do-while the compiler would get upset at the
- * "else" because it interpreted the "if" statement as being all
- * done when it reached the ';' after the yyless() call.
- */
-
-/* Return all but the first 'n' matched characters back to the input stream. */
-
+    #define YY_LESS_LINENO(n)
+    
+/* Return all but the first "n" matched characters back to the input stream. */
 #define yyless(n) \
        do \
                { \
-               /* Undo effects of setting up yytext. */ \
-               *yy_cp = yy_hold_char; \
+               /* Undo effects of setting up swf4text. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+               *yy_cp = (yy_hold_char); \
                YY_RESTORE_YY_MORE_OFFSET \
-               yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
-               YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+               (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+               YY_DO_BEFORE_ACTION; /* set up swf4text again */ \
                } \
        while ( 0 )
 
-#define unput(c) yyunput( c, yytext_ptr )
+#define unput(c) yyunput( c, (yytext_ptr)  )
 
 /* The following is because we cannot portably get our hands on size_t
  * (without autoconf's help, which isn't available because we want
  * flex-generated scanners to compile on their own).
  */
-typedef unsigned int yy_size_t;
 
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef unsigned int yy_size_t;
+#endif
 
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
        {
        FILE *yy_input_file;
@@ -195,12 +225,16 @@ struct yy_buffer_state
         */
        int yy_at_bol;
 
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+    
        /* Whether to try to fill the input buffer when we reach the
         * end of it.
         */
        int yy_fill_buffer;
 
        int yy_buffer_status;
+
 #define YY_BUFFER_NEW 0
 #define YY_BUFFER_NORMAL 1
        /* When an EOF's been seen but there's still some text to process
@@ -210,99 +244,135 @@ struct yy_buffer_state
         * possible backing-up.
         *
         * When we actually see the EOF, we change the status to "new"
-        * (via yyrestart()), so that the user can continue scanning by
-        * just pointing yyin at a new input file.
+        * (via swf4restart()), so that the user can continue scanning by
+        * just pointing swf4in at a new input file.
         */
 #define YY_BUFFER_EOF_PENDING 2
+
        };
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
 
-static YY_BUFFER_STATE yy_current_buffer = 0;
+/* Stack of input buffers. */
+static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
+static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
+static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 
 /* We provide macros for accessing buffer states in case in the
  * future we want to put the buffer states in a more general
  * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
  */
-#define YY_CURRENT_BUFFER yy_current_buffer
+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
+                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
+                          : NULL)
 
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 
-/* yy_hold_char holds the character lost when yytext is formed. */
+/* yy_hold_char holds the character lost when swf4text is formed. */
 static char yy_hold_char;
-
 static int yy_n_chars;         /* number of characters read into yy_ch_buf */
-
-
-int yyleng;
+int swf4leng;
 
 /* Points to current character in buffer. */
 static char *yy_c_buf_p = (char *) 0;
-static int yy_init = 1;                /* whether we need to initialize */
+static int yy_init = 0;                /* whether we need to initialize */
 static int yy_start = 0;       /* start state number */
 
-/* Flag which is used to allow yywrap()'s to do buffer switches
- * instead of setting up a fresh yyin.  A bit of a hack ...
+/* Flag which is used to allow swf4wrap()'s to do buffer switches
+ * instead of setting up a fresh swf4in.  A bit of a hack ...
  */
 static int yy_did_buffer_switch_on_eof;
 
-void yyrestart YY_PROTO(( FILE *input_file ));
+void swf4restart (FILE *input_file  );
+void swf4_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
+YY_BUFFER_STATE swf4_create_buffer (FILE *file,int size  );
+void swf4_delete_buffer (YY_BUFFER_STATE b  );
+void swf4_flush_buffer (YY_BUFFER_STATE b  );
+void swf4push_buffer_state (YY_BUFFER_STATE new_buffer  );
+void swf4pop_buffer_state (void );
+
+static void swf4ensure_buffer_stack (void );
+static void swf4_load_buffer_state (void );
+static void swf4_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 
-void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
-void yy_load_buffer_state YY_PROTO(( void ));
-YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
-void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
-void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
+#define YY_FLUSH_BUFFER swf4_flush_buffer(YY_CURRENT_BUFFER )
 
-YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
-YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
-YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
+YY_BUFFER_STATE swf4_scan_buffer (char *base,yy_size_t size  );
+YY_BUFFER_STATE swf4_scan_string (yyconst char *yy_str  );
+YY_BUFFER_STATE swf4_scan_bytes (yyconst char *bytes,int len  );
 
-static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
-static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
-static void yy_flex_free YY_PROTO(( void * ));
+void *swf4alloc (yy_size_t  );
+void *swf4realloc (void *,yy_size_t  );
+void swf4free (void *  );
 
-#define yy_new_buffer yy_create_buffer
+#define yy_new_buffer swf4_create_buffer
 
 #define yy_set_interactive(is_interactive) \
        { \
-       if ( ! yy_current_buffer ) \
-               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
-       yy_current_buffer->yy_is_interactive = is_interactive; \
+       if ( ! YY_CURRENT_BUFFER ){ \
+        swf4ensure_buffer_stack (); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            swf4_create_buffer(swf4in,YY_BUF_SIZE ); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
        }
 
 #define yy_set_bol(at_bol) \
        { \
-       if ( ! yy_current_buffer ) \
-               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
-       yy_current_buffer->yy_at_bol = at_bol; \
+       if ( ! YY_CURRENT_BUFFER ){\
+        swf4ensure_buffer_stack (); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            swf4_create_buffer(swf4in,YY_BUF_SIZE ); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
        }
 
-#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
 
 typedef unsigned char YY_CHAR;
-FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+
+FILE *swf4in = (FILE *) 0, *swf4out = (FILE *) 0;
+
 typedef int yy_state_type;
-extern char *yytext;
-#define yytext_ptr yytext
 
-static yy_state_type yy_get_previous_state YY_PROTO(( void ));
-static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
-static int yy_get_next_buffer YY_PROTO(( void ));
-static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
+extern int swf4lineno;
+
+int swf4lineno = 1;
+
+extern char *swf4text;
+#define yytext_ptr swf4text
+
+static yy_state_type yy_get_previous_state (void );
+static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
+static int yy_get_next_buffer (void );
+static void yy_fatal_error (yyconst char msg[]  );
 
 /* Done after the current pattern has been matched and before the
- * corresponding action - sets up yytext.
+ * corresponding action - sets up swf4text.
  */
 #define YY_DO_BEFORE_ACTION \
-       yytext_ptr = yy_bp; \
-       yyleng = (int) (yy_cp - yy_bp); \
-       yy_hold_char = *yy_cp; \
+       (yytext_ptr) = yy_bp; \
+       swf4leng = (size_t) (yy_cp - yy_bp); \
+       (yy_hold_char) = *yy_cp; \
        *yy_cp = '\0'; \
-       yy_c_buf_p = yy_cp;
+       (yy_c_buf_p) = yy_cp;
 
 #define YY_NUM_RULES 95
 #define YY_END_OF_BUFFER 96
-static yyconst short int yy_accept[320] =
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+       {
+       flex_int32_t yy_verify;
+       flex_int32_t yy_nxt;
+       };
+static yyconst flex_int16_t yy_accept[320] =
     {   0,
         0,    0,   96,   94,   56,   93,   94,   82,   94,   79,
        94,   83,   84,   80,   77,   89,   78,   90,   81,    1,
@@ -341,7 +411,7 @@ static yyconst short int yy_accept[320] =
        47,   47,   47,   47,   47,   18,   29,   39,    0
     } ;
 
-static yyconst int yy_ec[256] =
+static yyconst flex_int32_t yy_ec[256] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
         2,    2,    4,    1,    1,    1,    1,    1,    1,    1,
@@ -373,7 +443,7 @@ static yyconst int yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst int yy_meta[56] =
+static yyconst flex_int32_t yy_meta[56] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         2,    1,    1,    1,    3,    4,    5,    5,    1,    1,
@@ -383,7 +453,7 @@ static yyconst int yy_meta[56] =
         6,    6,    1,    1,    1
     } ;
 
-static yyconst short int yy_base[327] =
+static yyconst flex_int16_t yy_base[327] =
     {   0,
         0,    0,  626,  627,  627,  627,  622,  602,   53,  616,
        54,  627,  627,  600,   46,  627,   47,   48,   55,   57,
@@ -423,7 +493,7 @@ static yyconst short int yy_base[327] =
       562,  567,  570,  573,  577,  580
     } ;
 
-static yyconst short int yy_def[327] =
+static yyconst flex_int16_t yy_def[327] =
     {   0,
       319,    1,  319,  319,  319,  319,  319,  319,  320,  319,
       321,  319,  319,  319,  319,  319,  319,  319,  322,  319,
@@ -463,7 +533,7 @@ static yyconst short int yy_def[327] =
       319,  319,  319,  319,  319,  319
     } ;
 
-static yyconst short int yy_nxt[683] =
+static yyconst flex_int16_t yy_nxt[683] =
     {   0,
         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
        14,   15,   16,   17,   18,   19,   20,   20,   21,   22,
@@ -542,7 +612,7 @@ static yyconst short int yy_nxt[683] =
       319,  319
     } ;
 
-static yyconst short int yy_chk[683] =
+static yyconst flex_int16_t yy_chk[683] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -624,6 +694,9 @@ static yyconst short int yy_chk[683] =
 static yy_state_type yy_last_accepting_state;
 static char *yy_last_accepting_cpos;
 
+extern int swf4_flex_debug;
+int swf4_flex_debug = 0;
+
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.
  */
@@ -631,9 +704,8 @@ static char *yy_last_accepting_cpos;
 #define yymore() yymore_used_but_not_detected
 #define YY_MORE_ADJ 0
 #define YY_RESTORE_YY_MORE_OFFSET
-char *yytext;
+char *swf4text;
 #line 1 "swf4compiler.flex"
-#define INITIAL 0
 #line 2 "swf4compiler.flex"
 
 #include <math.h>
@@ -698,7 +770,7 @@ static void unescape(char *buf)
 void swf4ParseInit(const char *script, int debug)
 {
   checkByteOrder();
-  yyrestart(NULL);
+  swf4restart(NULL);
 
   swf4debug = debug;
 
@@ -721,7 +793,23 @@ void swf4ParseInit(const char *script, int debug)
  static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 
  void do_unput4(const char c) { unput(c); }
-#line 725 "lex.swf4.c"
+#line 797 "lex.swf4.c"
+
+#define INITIAL 0
+
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+static int yy_init_globals (void );
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -729,65 +817,30 @@ void swf4ParseInit(const char *script, int debug)
 
 #ifndef YY_SKIP_YYWRAP
 #ifdef __cplusplus
-extern "C" int yywrap YY_PROTO(( void ));
+extern "C" int swf4wrap (void );
 #else
-extern int yywrap YY_PROTO(( void ));
+extern int swf4wrap (void );
 #endif
 #endif
 
-#ifndef YY_NO_UNPUT
-static void yyunput YY_PROTO(( int c, char *buf_ptr ));
-#endif
-
+    static void yyunput (int c,char *buf_ptr  );
+    
 #ifndef yytext_ptr
-static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
+static void yy_flex_strncpy (char *,yyconst char *,int );
 #endif
 
 #ifdef YY_NEED_STRLEN
-static int yy_flex_strlen YY_PROTO(( yyconst char * ));
+static int yy_flex_strlen (yyconst char * );
 #endif
 
 #ifndef YY_NO_INPUT
+
 #ifdef __cplusplus
-static int yyinput YY_PROTO(( void ));
+static int yyinput (void );
 #else
-static int input YY_PROTO(( void ));
-#endif
+static int input (void );
 #endif
 
-#if YY_STACK_USED
-static int yy_start_stack_ptr = 0;
-static int yy_start_stack_depth = 0;
-static int *yy_start_stack = 0;
-#ifndef YY_NO_PUSH_STATE
-static void yy_push_state YY_PROTO(( int new_state ));
-#endif
-#ifndef YY_NO_POP_STATE
-static void yy_pop_state YY_PROTO(( void ));
-#endif
-#ifndef YY_NO_TOP_STATE
-static int yy_top_state YY_PROTO(( void ));
-#endif
-
-#else
-#define YY_NO_PUSH_STATE 1
-#define YY_NO_POP_STATE 1
-#define YY_NO_TOP_STATE 1
-#endif
-
-#ifdef YY_MALLOC_DECL
-YY_MALLOC_DECL
-#else
-#if __STDC__
-#ifndef __cplusplus
-#include <stdlib.h>
-#endif
-#else
-/* Just try to get by without declaring the routines.  This will fail
- * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
- * or sizeof(void*) != sizeof(int).
- */
-#endif
 #endif
 
 /* Amount of stuff to slurp up with each read. */
@@ -796,12 +849,11 @@ YY_MALLOC_DECL
 #endif
 
 /* Copy whatever the last rule matched to the standard output. */
-
 #ifndef ECHO
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
-#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
+#define ECHO (void) fwrite( swf4text, swf4leng, 1, swf4out )
 #endif
 
 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
@@ -809,21 +861,35 @@ YY_MALLOC_DECL
  */
 #ifndef YY_INPUT
 #define YY_INPUT(buf,result,max_size) \
-       if ( yy_current_buffer->yy_is_interactive ) \
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
                { \
-               int c = '*', n; \
+               int c = '*'; \
+               size_t n; \
                for ( n = 0; n < max_size && \
-                            (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+                            (c = getc( swf4in )) != EOF && c != '\n'; ++n ) \
                        buf[n] = (char) c; \
                if ( c == '\n' ) \
                        buf[n++] = (char) c; \
-               if ( c == EOF && ferror( yyin ) ) \
+               if ( c == EOF && ferror( swf4in ) ) \
                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
                result = n; \
                } \
-       else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
-                 && ferror( yyin ) ) \
-               YY_FATAL_ERROR( "input in flex scanner failed" );
+       else \
+               { \
+               errno=0; \
+               while ( (result = fread(buf, 1, max_size, swf4in))==0 && ferror(swf4in)) \
+                       { \
+                       if( errno != EINTR) \
+                               { \
+                               YY_FATAL_ERROR( "input in flex scanner failed" ); \
+                               break; \
+                               } \
+                       errno=0; \
+                       clearerr(swf4in); \
+                       } \
+               }\
+\
+
 #endif
 
 /* No semi-colon after return; correct usage is to write "yyterminate();" -
@@ -844,14 +910,20 @@ YY_MALLOC_DECL
 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 #endif
 
+/* end tables serialization structures and prototypes */
+
 /* Default declaration of generated scanner - a define so the user can
  * easily add parameters.
  */
 #ifndef YY_DECL
-#define YY_DECL int yylex YY_PROTO(( void ))
-#endif
+#define YY_DECL_IS_OURS 1
 
-/* Code executed at the beginning of each rule, after yytext and yyleng
+extern int swf4lex (void);
+
+#define YY_DECL int swf4lex (void)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after swf4text and swf4leng
  * have been set up.
  */
 #ifndef YY_USER_ACTION
@@ -866,62 +938,66 @@ YY_MALLOC_DECL
 #define YY_RULE_SETUP \
        YY_USER_ACTION
 
+/** The main scanner function which does all the work.
+ */
 YY_DECL
-       {
+{
        register yy_state_type yy_current_state;
-       register char *yy_cp = NULL, *yy_bp = NULL;
+       register char *yy_cp, *yy_bp;
        register int yy_act;
-
+    
 #line 96 "swf4compiler.flex"
 
 
-#line 879 "lex.swf4.c"
+#line 953 "lex.swf4.c"
 
-       if ( yy_init )
+       if ( !(yy_init) )
                {
-               yy_init = 0;
+               (yy_init) = 1;
 
 #ifdef YY_USER_INIT
                YY_USER_INIT;
 #endif
 
-               if ( ! yy_start )
-                       yy_start = 1;   /* first start state */
+               if ( ! (yy_start) )
+                       (yy_start) = 1; /* first start state */
 
-               if ( ! yyin )
-                       yyin = stdin;
+               if ( ! swf4in )
+                       swf4in = stdin;
 
-               if ( ! yyout )
-                       yyout = stdout;
+               if ( ! swf4out )
+                       swf4out = stdout;
 
-               if ( ! yy_current_buffer )
-                       yy_current_buffer =
-                               yy_create_buffer( yyin, YY_BUF_SIZE );
+               if ( ! YY_CURRENT_BUFFER ) {
+                       swf4ensure_buffer_stack ();
+                       YY_CURRENT_BUFFER_LVALUE =
+                               swf4_create_buffer(swf4in,YY_BUF_SIZE );
+               }
 
-               yy_load_buffer_state();
+               swf4_load_buffer_state( );
                }
 
        while ( 1 )             /* loops until end-of-file is reached */
                {
-               yy_cp = yy_c_buf_p;
+               yy_cp = (yy_c_buf_p);
 
-               /* Support of yytext. */
-               *yy_cp = yy_hold_char;
+               /* Support of swf4text. */
+               *yy_cp = (yy_hold_char);
 
                /* yy_bp points to the position in yy_ch_buf of the start of
                 * the current run.
                 */
                yy_bp = yy_cp;
 
-               yy_current_state = yy_start;
+               yy_current_state = (yy_start);
 yy_match:
                do
                        {
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
                        if ( yy_accept[yy_current_state] )
                                {
-                               yy_last_accepting_state = yy_current_state;
-                               yy_last_accepting_cpos = yy_cp;
+                               (yy_last_accepting_state) = yy_current_state;
+                               (yy_last_accepting_cpos) = yy_cp;
                                }
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                                {
@@ -938,36 +1014,34 @@ yy_find_action:
                yy_act = yy_accept[yy_current_state];
                if ( yy_act == 0 )
                        { /* have to back up */
-                       yy_cp = yy_last_accepting_cpos;
-                       yy_current_state = yy_last_accepting_state;
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
                        yy_act = yy_accept[yy_current_state];
                        }
 
                YY_DO_BEFORE_ACTION;
 
-
 do_action:     /* This label is used only to access EOF actions. */
 
-
                switch ( yy_act )
        { /* beginning of action switch */
                        case 0: /* must back up */
                        /* undo the effects of YY_DO_BEFORE_ACTION */
-                       *yy_cp = yy_hold_char;
-                       yy_cp = yy_last_accepting_cpos;
-                       yy_current_state = yy_last_accepting_state;
+                       *yy_cp = (yy_hold_char);
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
                        goto yy_find_action;
 
 case 1:
 YY_RULE_SETUP
 #line 98 "swf4compiler.flex"
-{ count();     swf4lval.str = strdup(yytext);
+{ count();     swf4lval.str = strdup(swf4text);
                                        return NUMBER;          }
        YY_BREAK
 case 2:
 YY_RULE_SETUP
 #line 100 "swf4compiler.flex"
-{ count();     swf4lval.str = strdup(yytext);
+{ count();     swf4lval.str = strdup(swf4text);
                                        return NUMBER;          }
        YY_BREAK
 case 3:
@@ -1202,41 +1276,44 @@ YY_RULE_SETUP
 case 47:
 YY_RULE_SETUP
 #line 164 "swf4compiler.flex"
-{ count();     swf4lval.str = strdup(yytext);
+{ count();     swf4lval.str = strdup(swf4text);
                                        return IDENTIFIER;      }
        YY_BREAK
 case 48:
 YY_RULE_SETUP
 #line 167 "swf4compiler.flex"
-{ count();     swf4lval.str = strdup(yytext);
+{ count();     swf4lval.str = strdup(swf4text);
                                        return PATH;    }
        YY_BREAK
 case 49:
 YY_RULE_SETUP
 #line 170 "swf4compiler.flex"
-{ count();     swf4lval.str = strdup(yytext);
+{ count();     swf4lval.str = strdup(swf4text);
                                        return PATH;    }
        YY_BREAK
 case 50:
+/* rule 50 can match eol */
 YY_RULE_SETUP
 #line 173 "swf4compiler.flex"
-{ count();     swf4lval.str = strdup(yytext+1);
+{ count();     swf4lval.str = strdup(swf4text+1);
                                        swf4lval.str[strlen(swf4lval.str)-1]=0;
                                         unescape(swf4lval.str);
                                        return STRING;          }
        YY_BREAK
 case 51:
+/* rule 51 can match eol */
 YY_RULE_SETUP
 #line 178 "swf4compiler.flex"
-{ count();     swf4lval.str = strdup(yytext+1);
+{ count();     swf4lval.str = strdup(swf4text+1);
                                        swf4lval.str[strlen(swf4lval.str)-1]=0;
                                         unescape(swf4lval.str);
                                        return STRING;          }
        YY_BREAK
 case 52:
-*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
-yy_c_buf_p = yy_cp -= 1;
-YY_DO_BEFORE_ACTION; /* set up yytext again */
+/* rule 52 can match eol */
+*yy_cp = (yy_hold_char); /* undo effects of setting up swf4text */
+(yy_c_buf_p) = yy_cp -= 1;
+YY_DO_BEFORE_ACTION; /* set up swf4text again */
 YY_RULE_SETUP
 #line 183 "swf4compiler.flex"
 { count();     swf4lval.str = strdup("");
@@ -1244,9 +1321,10 @@ YY_RULE_SETUP
                                        return STRING;          }
        YY_BREAK
 case 53:
-*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
-yy_c_buf_p = yy_cp -= 1;
-YY_DO_BEFORE_ACTION; /* set up yytext again */
+/* rule 53 can match eol */
+*yy_cp = (yy_hold_char); /* undo effects of setting up swf4text */
+(yy_c_buf_p) = yy_cp -= 1;
+YY_DO_BEFORE_ACTION; /* set up swf4text again */
 YY_RULE_SETUP
 #line 187 "swf4compiler.flex"
 { count();     swf4lval.str = strdup("");
@@ -1449,49 +1527,50 @@ YY_RULE_SETUP
 { count();     return ':'; }
        YY_BREAK
 case 93:
+/* rule 93 can match eol */
 YY_RULE_SETUP
 #line 233 "swf4compiler.flex"
 { count();     column = 0;
-                                       strcpy(szLine, yytext + 1);
+                                       strcpy(szLine, swf4text + 1);
                                        ++sLineNumber;  yyless(1);      }
        YY_BREAK
 case 94:
 YY_RULE_SETUP
 #line 237 "swf4compiler.flex"
-printf( "Unrecognized character: %s\n", yytext );
+printf( "Unrecognized character: %s\n", swf4text );
        YY_BREAK
 case 95:
 YY_RULE_SETUP
 #line 239 "swf4compiler.flex"
 ECHO;
        YY_BREAK
-#line 1469 "lex.swf4.c"
+#line 1548 "lex.swf4.c"
 case YY_STATE_EOF(INITIAL):
        yyterminate();
 
        case YY_END_OF_BUFFER:
                {
                /* Amount of text matched not including the EOB char. */
-               int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
+               int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 
                /* Undo the effects of YY_DO_BEFORE_ACTION. */
-               *yy_cp = yy_hold_char;
+               *yy_cp = (yy_hold_char);
                YY_RESTORE_YY_MORE_OFFSET
 
-               if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+               if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
                        {
                        /* We're scanning a new file or input source.  It's
                         * possible that this happened because the user
-                        * just pointed yyin at a new source and called
-                        * yylex().  If so, then we have to assure
-                        * consistency between yy_current_buffer and our
+                        * just pointed swf4in at a new source and called
+                        * swf4lex().  If so, then we have to assure
+                        * consistency between YY_CURRENT_BUFFER and our
                         * globals.  Here is the right place to do so, because
                         * this is the first action (other than possibly a
                         * back-up) that will match for the new input source.
                         */
-                       yy_n_chars = yy_current_buffer->yy_n_chars;
-                       yy_current_buffer->yy_input_file = yyin;
-                       yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+                       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+                       YY_CURRENT_BUFFER_LVALUE->yy_input_file = swf4in;
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
                        }
 
                /* Note that here we test for yy_c_buf_p "<=" to the position
@@ -1501,13 +1580,13 @@ case YY_STATE_EOF(INITIAL):
                 * end-of-buffer state).  Contrast this with the test
                 * in input().
                 */
-               if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+               if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
                        { /* This was really a NUL. */
                        yy_state_type yy_next_state;
 
-                       yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+                       (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
 
-                       yy_current_state = yy_get_previous_state();
+                       yy_current_state = yy_get_previous_state(  );
 
                        /* Okay, we're now positioned to make the NUL
                         * transition.  We couldn't have
@@ -1520,41 +1599,41 @@ case YY_STATE_EOF(INITIAL):
 
                        yy_next_state = yy_try_NUL_trans( yy_current_state );
 
-                       yy_bp = yytext_ptr + YY_MORE_ADJ;
+                       yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 
                        if ( yy_next_state )
                                {
                                /* Consume the NUL. */
-                               yy_cp = ++yy_c_buf_p;
+                               yy_cp = ++(yy_c_buf_p);
                                yy_current_state = yy_next_state;
                                goto yy_match;
                                }
 
                        else
                                {
-                               yy_cp = yy_c_buf_p;
+                               yy_cp = (yy_c_buf_p);
                                goto yy_find_action;
                                }
                        }
 
-               else switch ( yy_get_next_buffer() )
+               else switch ( yy_get_next_buffer(  ) )
                        {
                        case EOB_ACT_END_OF_FILE:
                                {
-                               yy_did_buffer_switch_on_eof = 0;
+                               (yy_did_buffer_switch_on_eof) = 0;
 
-                               if ( yywrap() )
+                               if ( swf4wrap( ) )
                                        {
                                        /* Note: because we've taken care in
                                         * yy_get_next_buffer() to have set up
-                                        * yytext, we can now set up
+                                        * swf4text, we can now set up
                                         * yy_c_buf_p so that if some total
                                         * hoser (like flex itself) wants to
                                         * call the scanner after we return the
                                         * YY_NULL, it'll still work - another
                                         * YY_NULL will get returned.
                                         */
-                                       yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+                                       (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
 
                                        yy_act = YY_STATE_EOF(YY_START);
                                        goto do_action;
@@ -1562,30 +1641,30 @@ case YY_STATE_EOF(INITIAL):
 
                                else
                                        {
-                                       if ( ! yy_did_buffer_switch_on_eof )
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
                                                YY_NEW_FILE;
                                        }
                                break;
                                }
 
                        case EOB_ACT_CONTINUE_SCAN:
-                               yy_c_buf_p =
-                                       yytext_ptr + yy_amount_of_matched_text;
+                               (yy_c_buf_p) =
+                                       (yytext_ptr) + yy_amount_of_matched_text;
 
-                               yy_current_state = yy_get_previous_state();
+                               yy_current_state = yy_get_previous_state(  );
 
-                               yy_cp = yy_c_buf_p;
-                               yy_bp = yytext_ptr + YY_MORE_ADJ;
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_match;
 
                        case EOB_ACT_LAST_MATCH:
-                               yy_c_buf_p =
-                               &yy_current_buffer->yy_ch_buf[yy_n_chars];
+                               (yy_c_buf_p) =
+                               &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
 
-                               yy_current_state = yy_get_previous_state();
+                               yy_current_state = yy_get_previous_state(  );
 
-                               yy_cp = yy_c_buf_p;
-                               yy_bp = yytext_ptr + YY_MORE_ADJ;
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_find_action;
                        }
                break;
@@ -1596,8 +1675,7 @@ case YY_STATE_EOF(INITIAL):
                        "fatal flex scanner internal error--no action found" );
        } /* end of action switch */
                } /* end of scanning one token */
-       } /* end of yylex */
-
+} /* end of swf4lex */
 
 /* yy_get_next_buffer - try to read in a new buffer
  *
@@ -1606,21 +1684,20 @@ case YY_STATE_EOF(INITIAL):
  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  *     EOB_ACT_END_OF_FILE - end of file
  */
-
-static int yy_get_next_buffer()
-       {
-       register char *dest = yy_current_buffer->yy_ch_buf;
-       register char *source = yytext_ptr;
+static int yy_get_next_buffer (void)
+{
+       register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+       register char *source = (yytext_ptr);
        register int number_to_move, i;
        int ret_val;
 
-       if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+       if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
                YY_FATAL_ERROR(
                "fatal flex scanner internal error--end of buffer missed" );
 
-       if ( yy_current_buffer->yy_fill_buffer == 0 )
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
                { /* Don't try to fill the buffer, so this is an EOF. */
-               if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+               if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
                        {
                        /* We matched a single character, the EOB, so
                         * treat this as a final EOF.
@@ -1640,34 +1717,30 @@ static int yy_get_next_buffer()
        /* Try to read more data. */
 
        /* First move last chars to start of buffer. */
-       number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
+       number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
 
        for ( i = 0; i < number_to_move; ++i )
                *(dest++) = *(source++);
 
-       if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
                /* don't do the read, it's not guaranteed to return an EOF,
                 * just force an EOF
                 */
-               yy_current_buffer->yy_n_chars = yy_n_chars = 0;
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
 
        else
                {
-               int num_to_read =
-                       yy_current_buffer->yy_buf_size - number_to_move - 1;
+                       int num_to_read =
+                       YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
                while ( num_to_read <= 0 )
                        { /* Not enough room in the buffer - grow it. */
-#ifdef YY_USES_REJECT
-                       YY_FATAL_ERROR(
-"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
-#else
 
                        /* just a shorter name for the current buffer */
-                       YY_BUFFER_STATE b = yy_current_buffer;
+                       YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
 
                        int yy_c_buf_p_offset =
-                               (int) (yy_c_buf_p - b->yy_ch_buf);
+                               (int) ((yy_c_buf_p) - b->yy_ch_buf);
 
                        if ( b->yy_is_our_buffer )
                                {
@@ -1680,8 +1753,7 @@ static int yy_get_next_buffer()
 
                                b->yy_ch_buf = (char *)
                                        /* Include room in for 2 EOB chars. */
-                                       yy_flex_realloc( (void *) b->yy_ch_buf,
-                                                        b->yy_buf_size + 2 );
+                                       swf4realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
                                }
                        else
                                /* Can't grow it, we don't own it. */
@@ -1691,35 +1763,35 @@ static int yy_get_next_buffer()
                                YY_FATAL_ERROR(
                                "fatal error - scanner input buffer overflow" );
 
-                       yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+                       (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
 
-                       num_to_read = yy_current_buffer->yy_buf_size -
+                       num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
                                                number_to_move - 1;
-#endif
+
                        }
 
                if ( num_to_read > YY_READ_BUF_SIZE )
                        num_to_read = YY_READ_BUF_SIZE;
 
                /* Read in more data. */
-               YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
-                       yy_n_chars, num_to_read );
+               YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+                       (yy_n_chars), num_to_read );
 
-               yy_current_buffer->yy_n_chars = yy_n_chars;
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }
 
-       if ( yy_n_chars == 0 )
+       if ( (yy_n_chars) == 0 )
                {
                if ( number_to_move == YY_MORE_ADJ )
                        {
                        ret_val = EOB_ACT_END_OF_FILE;
-                       yyrestart( yyin );
+                       swf4restart(swf4in  );
                        }
 
                else
                        {
                        ret_val = EOB_ACT_LAST_MATCH;
-                       yy_current_buffer->yy_buffer_status =
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
                                YY_BUFFER_EOF_PENDING;
                        }
                }
@@ -1727,32 +1799,31 @@ static int yy_get_next_buffer()
        else
                ret_val = EOB_ACT_CONTINUE_SCAN;
 
-       yy_n_chars += number_to_move;
-       yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
-       yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+       (yy_n_chars) += number_to_move;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
 
-       yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
+       (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
 
        return ret_val;
-       }
-
+}
 
 /* yy_get_previous_state - get the state just before the EOB char was reached */
 
-static yy_state_type yy_get_previous_state()
-       {
+    static yy_state_type yy_get_previous_state (void)
+{
        register yy_state_type yy_current_state;
        register char *yy_cp;
+    
+       yy_current_state = (yy_start);
 
-       yy_current_state = yy_start;
-
-       for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+       for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
                {
                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
                if ( yy_accept[yy_current_state] )
                        {
-                       yy_last_accepting_state = yy_current_state;
-                       yy_last_accepting_cpos = yy_cp;
+                       (yy_last_accepting_state) = yy_current_state;
+                       (yy_last_accepting_cpos) = yy_cp;
                        }
                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                        {
@@ -1764,30 +1835,23 @@ static yy_state_type yy_get_previous_state()
                }
 
        return yy_current_state;
-       }
-
+}
 
 /* yy_try_NUL_trans - try to make a transition on the NUL character
  *
  * synopsis
  *     next_state = yy_try_NUL_trans( current_state );
  */
-
-#ifdef YY_USE_PROTOS
-static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
-#else
-static yy_state_type yy_try_NUL_trans( yy_current_state )
-yy_state_type yy_current_state;
-#endif
-       {
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
+{
        register int yy_is_jam;
-       register char *yy_cp = yy_c_buf_p;
+       register char *yy_cp = (yy_c_buf_p);
 
        register YY_CHAR yy_c = 1;
        if ( yy_accept[yy_current_state] )
                {
-               yy_last_accepting_state = yy_current_state;
-               yy_last_accepting_cpos = yy_cp;
+               (yy_last_accepting_state) = yy_current_state;
+               (yy_last_accepting_cpos) = yy_cp;
                }
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                {
@@ -1799,80 +1863,73 @@ yy_state_type yy_current_state;
        yy_is_jam = (yy_current_state == 319);
 
        return yy_is_jam ? 0 : yy_current_state;
-       }
-
+}
 
-#ifndef YY_NO_UNPUT
-#ifdef YY_USE_PROTOS
-static void yyunput( int c, register char *yy_bp )
-#else
-static void yyunput( c, yy_bp )
-int c;
-register char *yy_bp;
-#endif
-       {
-       register char *yy_cp = yy_c_buf_p;
+    static void yyunput (int c, register char * yy_bp )
+{
+       register char *yy_cp;
+    
+    yy_cp = (yy_c_buf_p);
 
-       /* undo effects of setting up yytext */
-       *yy_cp = yy_hold_char;
+       /* undo effects of setting up swf4text */
+       *yy_cp = (yy_hold_char);
 
-       if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+       if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
                { /* need to shift things up to make room */
                /* +2 for EOB chars. */
-               register int number_to_move = yy_n_chars + 2;
-               register char *dest = &yy_current_buffer->yy_ch_buf[
-                                       yy_current_buffer->yy_buf_size + 2];
+               register int number_to_move = (yy_n_chars) + 2;
+               register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+                                       YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
                register char *source =
-                               &yy_current_buffer->yy_ch_buf[number_to_move];
+                               &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
 
-               while ( source > yy_current_buffer->yy_ch_buf )
+               while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
                        *--dest = *--source;
 
                yy_cp += (int) (dest - source);
                yy_bp += (int) (dest - source);
-               yy_current_buffer->yy_n_chars =
-                       yy_n_chars = yy_current_buffer->yy_buf_size;
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+                       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
 
-               if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+               if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
                }
 
        *--yy_cp = (char) c;
 
+       (yytext_ptr) = yy_bp;
+       (yy_hold_char) = *yy_cp;
+       (yy_c_buf_p) = yy_cp;
+}
 
-       yytext_ptr = yy_bp;
-       yy_hold_char = *yy_cp;
-       yy_c_buf_p = yy_cp;
-       }
-#endif /* ifndef YY_NO_UNPUT */
-
-
+#ifndef YY_NO_INPUT
 #ifdef __cplusplus
-static int yyinput()
+    static int yyinput (void)
 #else
-static int input()
+    static int input  (void)
 #endif
-       {
-       int c;
 
-       *yy_c_buf_p = yy_hold_char;
+{
+       int c;
+    
+       *(yy_c_buf_p) = (yy_hold_char);
 
-       if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+       if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
                {
                /* yy_c_buf_p now points to the character we want to return.
                 * If this occurs *before* the EOB characters, then it's a
                 * valid NUL; if not, then we've hit the end of the buffer.
                 */
-               if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+               if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
                        /* This was really a NUL. */
-                       *yy_c_buf_p = '\0';
+                       *(yy_c_buf_p) = '\0';
 
                else
                        { /* need more input */
-                       int offset = yy_c_buf_p - yytext_ptr;
-                       ++yy_c_buf_p;
+                       int offset = (yy_c_buf_p) - (yytext_ptr);
+                       ++(yy_c_buf_p);
 
-                       switch ( yy_get_next_buffer() )
+                       switch ( yy_get_next_buffer(  ) )
                                {
                                case EOB_ACT_LAST_MATCH:
                                        /* This happens because yy_g_n_b()
@@ -1886,16 +1943,16 @@ static int input()
                                         */
 
                                        /* Reset buffer status. */
-                                       yyrestart( yyin );
+                                       swf4restart(swf4in );
 
-                                       /* fall through */
+                                       /*FALLTHROUGH*/
 
                                case EOB_ACT_END_OF_FILE:
                                        {
-                                       if ( yywrap() )
+                                       if ( swf4wrap( ) )
                                                return EOF;
 
-                                       if ( ! yy_did_buffer_switch_on_eof )
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
                                                YY_NEW_FILE;
 #ifdef __cplusplus
                                        return yyinput();
@@ -1905,167 +1962,179 @@ static int input()
                                        }
 
                                case EOB_ACT_CONTINUE_SCAN:
-                                       yy_c_buf_p = yytext_ptr + offset;
+                                       (yy_c_buf_p) = (yytext_ptr) + offset;
                                        break;
                                }
                        }
                }
 
-       c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
-       *yy_c_buf_p = '\0';     /* preserve yytext */
-       yy_hold_char = *++yy_c_buf_p;
-
+       c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
+       *(yy_c_buf_p) = '\0';   /* preserve swf4text */
+       (yy_hold_char) = *++(yy_c_buf_p);
 
        return c;
-       }
-
-
-#ifdef YY_USE_PROTOS
-void yyrestart( FILE *input_file )
-#else
-void yyrestart( input_file )
-FILE *input_file;
-#endif
-       {
-       if ( ! yy_current_buffer )
-               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+}
+#endif /* ifndef YY_NO_INPUT */
 
-       yy_init_buffer( yy_current_buffer, input_file );
-       yy_load_buffer_state();
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * 
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void swf4restart  (FILE * input_file )
+{
+    
+       if ( ! YY_CURRENT_BUFFER ){
+        swf4ensure_buffer_stack ();
+               YY_CURRENT_BUFFER_LVALUE =
+            swf4_create_buffer(swf4in,YY_BUF_SIZE );
        }
 
+       swf4_init_buffer(YY_CURRENT_BUFFER,input_file );
+       swf4_load_buffer_state( );
+}
 
-#ifdef YY_USE_PROTOS
-void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
-#else
-void yy_switch_to_buffer( new_buffer )
-YY_BUFFER_STATE new_buffer;
-#endif
-       {
-       if ( yy_current_buffer == new_buffer )
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * 
+ */
+    void swf4_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
+{
+    
+       /* TODO. We should be able to replace this entire function body
+        * with
+        *              swf4pop_buffer_state();
+        *              swf4push_buffer_state(new_buffer);
+     */
+       swf4ensure_buffer_stack ();
+       if ( YY_CURRENT_BUFFER == new_buffer )
                return;
 
-       if ( yy_current_buffer )
+       if ( YY_CURRENT_BUFFER )
                {
                /* Flush out information for old buffer. */
-               *yy_c_buf_p = yy_hold_char;
-               yy_current_buffer->yy_buf_pos = yy_c_buf_p;
-               yy_current_buffer->yy_n_chars = yy_n_chars;
+               *(yy_c_buf_p) = (yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }
 
-       yy_current_buffer = new_buffer;
-       yy_load_buffer_state();
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
+       swf4_load_buffer_state( );
 
        /* We don't actually know whether we did this switch during
-        * EOF (yywrap()) processing, but the only time this flag
-        * is looked at is after yywrap() is called, so it's safe
+        * EOF (swf4wrap()) processing, but the only time this flag
+        * is looked at is after swf4wrap() is called, so it's safe
         * to go ahead and always set it.
         */
-       yy_did_buffer_switch_on_eof = 1;
-       }
-
-
-#ifdef YY_USE_PROTOS
-void yy_load_buffer_state( void )
-#else
-void yy_load_buffer_state()
-#endif
-       {
-       yy_n_chars = yy_current_buffer->yy_n_chars;
-       yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
-       yyin = yy_current_buffer->yy_input_file;
-       yy_hold_char = *yy_c_buf_p;
-       }
+       (yy_did_buffer_switch_on_eof) = 1;
+}
 
+static void swf4_load_buffer_state  (void)
+{
+       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+       (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+       swf4in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+       (yy_hold_char) = *(yy_c_buf_p);
+}
 
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
-#else
-YY_BUFFER_STATE yy_create_buffer( file, size )
-FILE *file;
-int size;
-#endif
-       {
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * 
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE swf4_create_buffer  (FILE * file, int  size )
+{
        YY_BUFFER_STATE b;
-
-       b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+    
+       b = (YY_BUFFER_STATE) swf4alloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
-               YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+               YY_FATAL_ERROR( "out of dynamic memory in swf4_create_buffer()" );
 
        b->yy_buf_size = size;
 
        /* yy_ch_buf has to be 2 characters longer than the size given because
         * we need to put in 2 end-of-buffer characters.
         */
-       b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
+       b->yy_ch_buf = (char *) swf4alloc(b->yy_buf_size + 2  );
        if ( ! b->yy_ch_buf )
-               YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+               YY_FATAL_ERROR( "out of dynamic memory in swf4_create_buffer()" );
 
        b->yy_is_our_buffer = 1;
 
-       yy_init_buffer( b, file );
+       swf4_init_buffer(b,file );
 
        return b;
-       }
-
+}
 
-#ifdef YY_USE_PROTOS
-void yy_delete_buffer( YY_BUFFER_STATE b )
-#else
-void yy_delete_buffer( b )
-YY_BUFFER_STATE b;
-#endif
-       {
+/** Destroy the buffer.
+ * @param b a buffer created with swf4_create_buffer()
+ * 
+ */
+    void swf4_delete_buffer (YY_BUFFER_STATE  b )
+{
+    
        if ( ! b )
                return;
 
-       if ( b == yy_current_buffer )
-               yy_current_buffer = (YY_BUFFER_STATE) 0;
+       if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+               YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 
        if ( b->yy_is_our_buffer )
-               yy_flex_free( (void *) b->yy_ch_buf );
-
-       yy_flex_free( (void *) b );
-       }
-
+               swf4free((void *) b->yy_ch_buf  );
 
+       swf4free((void *) b  );
+}
 
-#ifdef YY_USE_PROTOS
-void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#ifndef _UNISTD_H /* assume unistd.h has isatty() for us */
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __THROW /* this is a gnuism */
+extern int isatty (int ) __THROW;
 #else
-void yy_init_buffer( b, file )
-YY_BUFFER_STATE b;
-FILE *file;
+extern int isatty (int );
 #endif
+#ifdef __cplusplus
+}
+#endif
+#endif
+    
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a swf4restart() or at EOF.
+ */
+    static void swf4_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
 
-
-       {
-       yy_flush_buffer( b );
+{
+       int oerrno = errno;
+    
+       swf4_flush_buffer(b );
 
        b->yy_input_file = file;
        b->yy_fill_buffer = 1;
 
-#if YY_ALWAYS_INTERACTIVE
-       b->yy_is_interactive = 1;
-#else
-#if YY_NEVER_INTERACTIVE
-       b->yy_is_interactive = 0;
-#else
-       b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
-#endif
-#endif
-       }
-
+    /* If b is the current buffer, then swf4_init_buffer was _probably_
+     * called from swf4restart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
 
-#ifdef YY_USE_PROTOS
-void yy_flush_buffer( YY_BUFFER_STATE b )
-#else
-void yy_flush_buffer( b )
-YY_BUFFER_STATE b;
-#endif
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+    
+       errno = oerrno;
+}
 
-       {
-       if ( ! b )
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * 
+ */
+    void swf4_flush_buffer (YY_BUFFER_STATE  b )
+{
+       if ( ! b )
                return;
 
        b->yy_n_chars = 0;
@@ -2082,31 +2151,123 @@ YY_BUFFER_STATE b;
        b->yy_at_bol = 1;
        b->yy_buffer_status = YY_BUFFER_NEW;
 
-       if ( b == yy_current_buffer )
-               yy_load_buffer_state();
+       if ( b == YY_CURRENT_BUFFER )
+               swf4_load_buffer_state( );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  
+ */
+void swf4push_buffer_state (YY_BUFFER_STATE new_buffer )
+{
+       if (new_buffer == NULL)
+               return;
+
+       swf4ensure_buffer_stack();
+
+       /* This block is copied from swf4_switch_to_buffer. */
+       if ( YY_CURRENT_BUFFER )
+               {
+               /* Flush out information for old buffer. */
+               *(yy_c_buf_p) = (yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+               }
+
+       /* Only push if top exists. Otherwise, replace top. */
+       if (YY_CURRENT_BUFFER)
+               (yy_buffer_stack_top)++;
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+       /* copied from swf4_switch_to_buffer. */
+       swf4_load_buffer_state( );
+       (yy_did_buffer_switch_on_eof) = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  
+ */
+void swf4pop_buffer_state (void)
+{
+       if (!YY_CURRENT_BUFFER)
+               return;
+
+       swf4_delete_buffer(YY_CURRENT_BUFFER );
+       YY_CURRENT_BUFFER_LVALUE = NULL;
+       if ((yy_buffer_stack_top) > 0)
+               --(yy_buffer_stack_top);
+
+       if (YY_CURRENT_BUFFER) {
+               swf4_load_buffer_state( );
+               (yy_did_buffer_switch_on_eof) = 1;
        }
+}
 
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void swf4ensure_buffer_stack (void)
+{
+       int num_to_alloc;
+    
+       if (!(yy_buffer_stack)) {
+
+               /* First allocation is just for 2 elements, since we don't know if this
+                * scanner will even need a stack. We use 2 instead of 1 to avoid an
+                * immediate realloc on the next call.
+         */
+               num_to_alloc = 1;
+               (yy_buffer_stack) = (struct yy_buffer_state**)swf4alloc
+                                                               (num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+               
+               memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+                               
+               (yy_buffer_stack_max) = num_to_alloc;
+               (yy_buffer_stack_top) = 0;
+               return;
+       }
 
-#ifndef YY_NO_SCAN_BUFFER
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
-#else
-YY_BUFFER_STATE yy_scan_buffer( base, size )
-char *base;
-yy_size_t size;
-#endif
-       {
-       YY_BUFFER_STATE b;
+       if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
+
+               /* Increase the buffer to prepare for a possible push. */
+               int grow_size = 8 /* arbitrary grow size */;
 
+               num_to_alloc = (yy_buffer_stack_max) + grow_size;
+               (yy_buffer_stack) = (struct yy_buffer_state**)swf4realloc
+                                                               ((yy_buffer_stack),
+                                                               num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+
+               /* zero only the new slots.*/
+               memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
+               (yy_buffer_stack_max) = num_to_alloc;
+       }
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * 
+ * @return the newly allocated buffer state object. 
+ */
+YY_BUFFER_STATE swf4_scan_buffer  (char * base, yy_size_t  size )
+{
+       YY_BUFFER_STATE b;
+    
        if ( size < 2 ||
             base[size-2] != YY_END_OF_BUFFER_CHAR ||
             base[size-1] != YY_END_OF_BUFFER_CHAR )
                /* They forgot to leave room for the EOB's. */
                return 0;
 
-       b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+       b = (YY_BUFFER_STATE) swf4alloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
-               YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+               YY_FATAL_ERROR( "out of dynamic memory in swf4_scan_buffer()" );
 
        b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
        b->yy_buf_pos = b->yy_ch_buf = base;
@@ -2118,58 +2279,53 @@ yy_size_t size;
        b->yy_fill_buffer = 0;
        b->yy_buffer_status = YY_BUFFER_NEW;
 
-       yy_switch_to_buffer( b );
+       swf4_switch_to_buffer(b  );
 
        return b;
-       }
-#endif
-
-
-#ifndef YY_NO_SCAN_STRING
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
-#else
-YY_BUFFER_STATE yy_scan_string( yy_str )
-yyconst char *yy_str;
-#endif
-       {
-       int len;
-       for ( len = 0; yy_str[len]; ++len )
-               ;
-
-       return yy_scan_bytes( yy_str, len );
-       }
-#endif
+}
 
+/** Setup the input buffer state to scan a string. The next call to swf4lex() will
+ * scan from a @e copy of @a str.
+ * @param str a NUL-terminated string to scan
+ * 
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       swf4_scan_bytes() instead.
+ */
+YY_BUFFER_STATE swf4_scan_string (yyconst char * yystr )
+{
+    
+       return swf4_scan_bytes(yystr,strlen(yystr) );
+}
 
-#ifndef YY_NO_SCAN_BYTES
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
-#else
-YY_BUFFER_STATE yy_scan_bytes( bytes, len )
-yyconst char *bytes;
-int len;
-#endif
-       {
+/** Setup the input buffer state to scan the given bytes. The next call to swf4lex() will
+ * scan from a @e copy of @a bytes.
+ * @param bytes the byte buffer to scan
+ * @param len the number of bytes in the buffer pointed to by @a bytes.
+ * 
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE swf4_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
+{
        YY_BUFFER_STATE b;
        char *buf;
        yy_size_t n;
        int i;
-
+    
        /* Get memory for full buffer, including space for trailing EOB's. */
-       n = len + 2;
-       buf = (char *) yy_flex_alloc( n );
+       n = _yybytes_len + 2;
+       buf = (char *) swf4alloc(n  );
        if ( ! buf )
-               YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+               YY_FATAL_ERROR( "out of dynamic memory in swf4_scan_bytes()" );
 
-       for ( i = 0; i < len; ++i )
-               buf[i] = bytes[i];
+       for ( i = 0; i < _yybytes_len; ++i )
+               buf[i] = yybytes[i];
 
-       buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+       buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 
-       b = yy_scan_buffer( buf, n );
+       b = swf4_scan_buffer(buf,n );
        if ( ! b )
-               YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+               YY_FATAL_ERROR( "bad buffer in swf4_scan_bytes()" );
 
        /* It's okay to grow etc. this buffer, and we should throw it
         * away when we're done.
@@ -2177,148 +2333,196 @@ int len;
        b->yy_is_our_buffer = 1;
 
        return b;
-       }
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
 #endif
 
+static void yy_fatal_error (yyconst char* msg )
+{
+       (void) fprintf( stderr, "%s\n", msg );
+       exit( YY_EXIT_FAILURE );
+}
 
-#ifndef YY_NO_PUSH_STATE
-#ifdef YY_USE_PROTOS
-static void yy_push_state( int new_state )
-#else
-static void yy_push_state( new_state )
-int new_state;
-#endif
-       {
-       if ( yy_start_stack_ptr >= yy_start_stack_depth )
-               {
-               yy_size_t new_size;
+/* Redefine yyless() so it works in section 3 code. */
 
-               yy_start_stack_depth += YY_START_STACK_INCR;
-               new_size = yy_start_stack_depth * sizeof( int );
+#undef yyless
+#define yyless(n) \
+       do \
+               { \
+               /* Undo effects of setting up swf4text. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+               swf4text[swf4leng] = (yy_hold_char); \
+               (yy_c_buf_p) = swf4text + yyless_macro_arg; \
+               (yy_hold_char) = *(yy_c_buf_p); \
+               *(yy_c_buf_p) = '\0'; \
+               swf4leng = yyless_macro_arg; \
+               } \
+       while ( 0 )
 
-               if ( ! yy_start_stack )
-                       yy_start_stack = (int *) yy_flex_alloc( new_size );
+/* Accessor  methods (get/set functions) to struct members. */
 
-               else
-                       yy_start_stack = (int *) yy_flex_realloc(
-                                       (void *) yy_start_stack, new_size );
+/** Get the current line number.
+ * 
+ */
+int swf4get_lineno  (void)
+{
+        
+    return swf4lineno;
+}
 
-               if ( ! yy_start_stack )
-                       YY_FATAL_ERROR(
-                       "out of memory expanding start-condition stack" );
-               }
+/** Get the input stream.
+ * 
+ */
+FILE *swf4get_in  (void)
+{
+        return swf4in;
+}
 
-       yy_start_stack[yy_start_stack_ptr++] = YY_START;
+/** Get the output stream.
+ * 
+ */
+FILE *swf4get_out  (void)
+{
+        return swf4out;
+}
 
-       BEGIN(new_state);
-       }
-#endif
+/** Get the length of the current token.
+ * 
+ */
+int swf4get_leng  (void)
+{
+        return swf4leng;
+}
 
+/** Get the current token.
+ * 
+ */
 
-#ifndef YY_NO_POP_STATE
-static void yy_pop_state()
-       {
-       if ( --yy_start_stack_ptr < 0 )
-               YY_FATAL_ERROR( "start-condition stack underflow" );
+char *swf4get_text  (void)
+{
+        return swf4text;
+}
 
-       BEGIN(yy_start_stack[yy_start_stack_ptr]);
-       }
-#endif
+/** Set the current line number.
+ * @param line_number
+ * 
+ */
+void swf4set_lineno (int  line_number )
+{
+    
+    swf4lineno = line_number;
+}
 
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param in_str A readable stream.
+ * 
+ * @see swf4_switch_to_buffer
+ */
+void swf4set_in (FILE *  in_str )
+{
+        swf4in = in_str ;
+}
 
-#ifndef YY_NO_TOP_STATE
-static int yy_top_state()
-       {
-       return yy_start_stack[yy_start_stack_ptr - 1];
-       }
-#endif
+void swf4set_out (FILE *  out_str )
+{
+        swf4out = out_str ;
+}
 
-#ifndef YY_EXIT_FAILURE
-#define YY_EXIT_FAILURE 2
-#endif
+int swf4get_debug  (void)
+{
+        return swf4_flex_debug;
+}
 
-#ifdef YY_USE_PROTOS
-static void yy_fatal_error( yyconst char msg[] )
+void swf4set_debug (int  bdebug )
+{
+        swf4_flex_debug = bdebug ;
+}
+
+static int yy_init_globals (void)
+{
+        /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from swf4lex_destroy(), so don't allocate here.
+     */
+
+    (yy_buffer_stack) = 0;
+    (yy_buffer_stack_top) = 0;
+    (yy_buffer_stack_max) = 0;
+    (yy_c_buf_p) = (char *) 0;
+    (yy_init) = 0;
+    (yy_start) = 0;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    swf4in = stdin;
+    swf4out = stdout;
 #else
-static void yy_fatal_error( msg )
-char msg[];
+    swf4in = (FILE *) 0;
+    swf4out = (FILE *) 0;
 #endif
-       {
-       (void) fprintf( stderr, "%s\n", msg );
-       exit( YY_EXIT_FAILURE );
-       }
 
+    /* For future reference: Set errno on error, since we are called by
+     * swf4lex_init()
+     */
+    return 0;
+}
 
+/* swf4lex_destroy is for both reentrant and non-reentrant scanners. */
+int swf4lex_destroy  (void)
+{
+    
+    /* Pop the buffer stack, destroying each element. */
+       while(YY_CURRENT_BUFFER){
+               swf4_delete_buffer(YY_CURRENT_BUFFER  );
+               YY_CURRENT_BUFFER_LVALUE = NULL;
+               swf4pop_buffer_state();
+       }
 
-/* Redefine yyless() so it works in section 3 code. */
+       /* Destroy the stack itself. */
+       swf4free((yy_buffer_stack) );
+       (yy_buffer_stack) = NULL;
 
-#undef yyless
-#define yyless(n) \
-       do \
-               { \
-               /* Undo effects of setting up yytext. */ \
-               yytext[yyleng] = yy_hold_char; \
-               yy_c_buf_p = yytext + n; \
-               yy_hold_char = *yy_c_buf_p; \
-               *yy_c_buf_p = '\0'; \
-               yyleng = n; \
-               } \
-       while ( 0 )
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * swf4lex() is called, initialization will occur. */
+    yy_init_globals( );
 
+    return 0;
+}
 
-/* Internal utility routines. */
+/*
+ * Internal utility routines.
+ */
 
 #ifndef yytext_ptr
-#ifdef YY_USE_PROTOS
-static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
-#else
-static void yy_flex_strncpy( s1, s2, n )
-char *s1;
-yyconst char *s2;
-int n;
-#endif
-       {
+static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
+{
        register int i;
        for ( i = 0; i < n; ++i )
                s1[i] = s2[i];
-       }
+}
 #endif
 
 #ifdef YY_NEED_STRLEN
-#ifdef YY_USE_PROTOS
-static int yy_flex_strlen( yyconst char *s )
-#else
-static int yy_flex_strlen( s )
-yyconst char *s;
-#endif
-       {
+static int yy_flex_strlen (yyconst char * s )
+{
        register int n;
        for ( n = 0; s[n]; ++n )
                ;
 
        return n;
-       }
+}
 #endif
 
-
-#ifdef YY_USE_PROTOS
-static void *yy_flex_alloc( yy_size_t size )
-#else
-static void *yy_flex_alloc( size )
-yy_size_t size;
-#endif
-       {
+void *swf4alloc (yy_size_t  size )
+{
        return (void *) malloc( size );
-       }
+}
 
-#ifdef YY_USE_PROTOS
-static void *yy_flex_realloc( void *ptr, yy_size_t size )
-#else
-static void *yy_flex_realloc( ptr, size )
-void *ptr;
-yy_size_t size;
-#endif
-       {
+void *swf4realloc  (void * ptr, yy_size_t  size )
+{
        /* The cast to (char *) in the following accommodates both
         * implementations that use char* generic pointers, and those
         * that use void* generic pointers.  It works with the latter
@@ -2327,27 +2531,18 @@ yy_size_t size;
         * as though doing an assignment.
         */
        return (void *) realloc( (char *) ptr, size );
-       }
+}
 
-#ifdef YY_USE_PROTOS
-static void yy_flex_free( void *ptr )
-#else
-static void yy_flex_free( ptr )
-void *ptr;
-#endif
-       {
-       free( ptr );
-       }
+void swf4free (void * ptr )
+{
+       free( (char *) ptr );   /* see swf4realloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
 
-#if YY_MAIN
-int main()
-       {
-       yylex();
-       return 0;
-       }
-#endif
 #line 239 "swf4compiler.flex"
 
+
 static int getinput() {
 #ifdef __cplusplus
                                        return yyinput();
@@ -2461,22 +2656,22 @@ static void count(void)
    int n;
 
    // Count the characters to maintain the current column position
-   if (yytext[0] == '\n')
+   if (swf4text[0] == '\n')
    {
       if (swf4debug) printf("\n");
    }
    else
    {
-      if (swf4debug) printf("%s", yytext);
+      if (swf4debug) printf("%s", swf4text);
 
-      for(n=0; n<yyleng; ++n, ++column)
+      for(n=0; n<swf4leng; ++n, ++column)
       {
        if(column < 1023)
-         msgline[column] = yytext[n];
+         msgline[column] = swf4text[n];
       }
 
       //-- keep writing the stuff to standard output
-      //column += yyleng;
+      //column += swf4leng;
    }
 }
 
@@ -2502,7 +2697,7 @@ static void warning(char *msg)
 void swf4error(char *msg)
 {
   // report a error
-  if(strlen(yytext))
+  if(strlen(swf4text))
   {
     SWF_error("\n%s\n%*s\nLine %i:  Reason: '%s'\n",
              LineText(), ColumnNumber(), "^", LineNumber(), msg);
@@ -2512,3 +2707,4 @@ void swf4error(char *msg)
     SWF_error("\nLine %d: Reason: 'Unexpected EOF found while looking for input.'\n", LineNumber());
   }
 }
+
index cd270be..b2f6b73 100644 (file)
@@ -1,49 +1,92 @@
-#define yy_create_buffer swf5_create_buffer
-#define yy_delete_buffer swf5_delete_buffer
-#define yy_scan_buffer swf5_scan_buffer
-#define yy_scan_string swf5_scan_string
-#define yy_scan_bytes swf5_scan_bytes
-#define yy_flex_debug swf5_flex_debug
-#define yy_init_buffer swf5_init_buffer
-#define yy_flush_buffer swf5_flush_buffer
-#define yy_load_buffer_state swf5_load_buffer_state
-#define yy_switch_to_buffer swf5_switch_to_buffer
-#define yyin swf5in
-#define yyleng swf5leng
-#define yylex swf5lex
-#define yyout swf5out
-#define yyrestart swf5restart
-#define yytext swf5text
-#define yywrap swf5wrap
 
-/* A lexical scanner generated by flex */
+#line 3 "lex.swf5.c"
 
-/* Scanner skeleton version:
- * $Header: /cvsroot/swftools/swftools/lib/action/lex.swf5.c,v 1.1 2008/05/24 17:09:56 kramm Exp $
- */
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
 
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
+#define YY_FLEX_SUBMINOR_VERSION 33
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
 
+/* begin standard C headers. */
 #include <stdio.h>
-#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
 
+/* end standard C headers. */
 
-/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
-#ifdef c_plusplus
-#ifndef __cplusplus
-#define __cplusplus
-#endif
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
 #endif
 
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+#endif /* ! C99 */
 
-#ifdef __cplusplus
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
 
-#include <stdlib.h>
+#endif /* ! FLEXINT_H */
 
-/* Use prototypes in function declarations. */
-#define YY_USE_PROTOS
+#ifdef __cplusplus
 
 /* The "const" storage-class-modifier is valid. */
 #define YY_USE_CONST
 
 #if __STDC__
 
-#define YY_USE_PROTOS
 #define YY_USE_CONST
 
 #endif /* __STDC__ */
 #endif /* ! __cplusplus */
 
-#ifdef __TURBOC__
- #pragma warn -rch
- #pragma warn -use
-#include <io.h>
-#include <stdlib.h>
-#define YY_USE_CONST
-#define YY_USE_PROTOS
-#endif
-
 #ifdef YY_USE_CONST
 #define yyconst const
 #else
 #define yyconst
 #endif
 
-
-#ifdef YY_USE_PROTOS
-#define YY_PROTO(proto) proto
-#else
-#define YY_PROTO(proto) ()
-#endif
-
 /* Returned upon end-of-file. */
 #define YY_NULL 0
 
  * but we do it the disgusting crufty way forced on us by the ()-less
  * definition of BEGIN.
  */
-#define BEGIN yy_start = 1 + 2 *
+#define BEGIN (yy_start) = 1 + 2 *
 
 /* Translate the current start state into a value that can be later handed
  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  * compatibility.
  */
-#define YY_START ((yy_start - 1) / 2)
+#define YY_START (((yy_start) - 1) / 2)
 #define YYSTATE YY_START
 
 /* Action number for EOF rule of a given start state. */
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 
 /* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE yyrestart( yyin )
+#define YY_NEW_FILE swf5restart(swf5in  )
 
 #define YY_END_OF_BUFFER_CHAR 0
 
 /* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
 #define YY_BUF_SIZE 16384
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
 
-extern int yyleng;
-extern FILE *yyin, *yyout;
+extern int swf5leng;
+
+extern FILE *swf5in, *swf5out;
 
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
 
-/* The funky do-while in the following #define is used to turn the definition
- * int a single C statement (which needs a semi-colon terminator).  This
- * avoids problems with code like:
- *
- *     if ( condition_holds )
- *             yyless( 5 );
- *     else
- *             do_something_else();
- *
- * Prior to using the do-while the compiler would get upset at the
- * "else" because it interpreted the "if" statement as being all
- * done when it reached the ';' after the yyless() call.
- */
-
-/* Return all but the first 'n' matched characters back to the input stream. */
-
+    #define YY_LESS_LINENO(n)
+    
+/* Return all but the first "n" matched characters back to the input stream. */
 #define yyless(n) \
        do \
                { \
-               /* Undo effects of setting up yytext. */ \
-               *yy_cp = yy_hold_char; \
+               /* Undo effects of setting up swf5text. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+               *yy_cp = (yy_hold_char); \
                YY_RESTORE_YY_MORE_OFFSET \
-               yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
-               YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+               (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+               YY_DO_BEFORE_ACTION; /* set up swf5text again */ \
                } \
        while ( 0 )
 
-#define unput(c) yyunput( c, yytext_ptr )
+#define unput(c) yyunput( c, (yytext_ptr)  )
 
 /* The following is because we cannot portably get our hands on size_t
  * (without autoconf's help, which isn't available because we want
  * flex-generated scanners to compile on their own).
  */
-typedef unsigned int yy_size_t;
 
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef unsigned int yy_size_t;
+#endif
 
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
        {
        FILE *yy_input_file;
@@ -195,12 +225,16 @@ struct yy_buffer_state
         */
        int yy_at_bol;
 
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+    
        /* Whether to try to fill the input buffer when we reach the
         * end of it.
         */
        int yy_fill_buffer;
 
        int yy_buffer_status;
+
 #define YY_BUFFER_NEW 0
 #define YY_BUFFER_NORMAL 1
        /* When an EOF's been seen but there's still some text to process
@@ -210,99 +244,135 @@ struct yy_buffer_state
         * possible backing-up.
         *
         * When we actually see the EOF, we change the status to "new"
-        * (via yyrestart()), so that the user can continue scanning by
-        * just pointing yyin at a new input file.
+        * (via swf5restart()), so that the user can continue scanning by
+        * just pointing swf5in at a new input file.
         */
 #define YY_BUFFER_EOF_PENDING 2
+
        };
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
 
-static YY_BUFFER_STATE yy_current_buffer = 0;
+/* Stack of input buffers. */
+static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
+static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
+static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 
 /* We provide macros for accessing buffer states in case in the
  * future we want to put the buffer states in a more general
  * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
  */
-#define YY_CURRENT_BUFFER yy_current_buffer
+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
+                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
+                          : NULL)
 
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 
-/* yy_hold_char holds the character lost when yytext is formed. */
+/* yy_hold_char holds the character lost when swf5text is formed. */
 static char yy_hold_char;
-
 static int yy_n_chars;         /* number of characters read into yy_ch_buf */
-
-
-int yyleng;
+int swf5leng;
 
 /* Points to current character in buffer. */
 static char *yy_c_buf_p = (char *) 0;
-static int yy_init = 1;                /* whether we need to initialize */
+static int yy_init = 0;                /* whether we need to initialize */
 static int yy_start = 0;       /* start state number */
 
-/* Flag which is used to allow yywrap()'s to do buffer switches
- * instead of setting up a fresh yyin.  A bit of a hack ...
+/* Flag which is used to allow swf5wrap()'s to do buffer switches
+ * instead of setting up a fresh swf5in.  A bit of a hack ...
  */
 static int yy_did_buffer_switch_on_eof;
 
-void yyrestart YY_PROTO(( FILE *input_file ));
+void swf5restart (FILE *input_file  );
+void swf5_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
+YY_BUFFER_STATE swf5_create_buffer (FILE *file,int size  );
+void swf5_delete_buffer (YY_BUFFER_STATE b  );
+void swf5_flush_buffer (YY_BUFFER_STATE b  );
+void swf5push_buffer_state (YY_BUFFER_STATE new_buffer  );
+void swf5pop_buffer_state (void );
 
-void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
-void yy_load_buffer_state YY_PROTO(( void ));
-YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
-void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
-void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
+static void swf5ensure_buffer_stack (void );
+static void swf5_load_buffer_state (void );
+static void swf5_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 
-YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
-YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
-YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
+#define YY_FLUSH_BUFFER swf5_flush_buffer(YY_CURRENT_BUFFER )
 
-static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
-static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
-static void yy_flex_free YY_PROTO(( void * ));
+YY_BUFFER_STATE swf5_scan_buffer (char *base,yy_size_t size  );
+YY_BUFFER_STATE swf5_scan_string (yyconst char *yy_str  );
+YY_BUFFER_STATE swf5_scan_bytes (yyconst char *bytes,int len  );
 
-#define yy_new_buffer yy_create_buffer
+void *swf5alloc (yy_size_t  );
+void *swf5realloc (void *,yy_size_t  );
+void swf5free (void *  );
+
+#define yy_new_buffer swf5_create_buffer
 
 #define yy_set_interactive(is_interactive) \
        { \
-       if ( ! yy_current_buffer ) \
-               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
-       yy_current_buffer->yy_is_interactive = is_interactive; \
+       if ( ! YY_CURRENT_BUFFER ){ \
+        swf5ensure_buffer_stack (); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            swf5_create_buffer(swf5in,YY_BUF_SIZE ); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
        }
 
 #define yy_set_bol(at_bol) \
        { \
-       if ( ! yy_current_buffer ) \
-               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
-       yy_current_buffer->yy_at_bol = at_bol; \
+       if ( ! YY_CURRENT_BUFFER ){\
+        swf5ensure_buffer_stack (); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            swf5_create_buffer(swf5in,YY_BUF_SIZE ); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
        }
 
-#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
 
 typedef unsigned char YY_CHAR;
-FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+
+FILE *swf5in = (FILE *) 0, *swf5out = (FILE *) 0;
+
 typedef int yy_state_type;
-extern char *yytext;
-#define yytext_ptr yytext
 
-static yy_state_type yy_get_previous_state YY_PROTO(( void ));
-static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
-static int yy_get_next_buffer YY_PROTO(( void ));
-static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
+extern int swf5lineno;
+
+int swf5lineno = 1;
+
+extern char *swf5text;
+#define yytext_ptr swf5text
+
+static yy_state_type yy_get_previous_state (void );
+static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
+static int yy_get_next_buffer (void );
+static void yy_fatal_error (yyconst char msg[]  );
 
 /* Done after the current pattern has been matched and before the
- * corresponding action - sets up yytext.
+ * corresponding action - sets up swf5text.
  */
 #define YY_DO_BEFORE_ACTION \
-       yytext_ptr = yy_bp; \
-       yyleng = (int) (yy_cp - yy_bp); \
-       yy_hold_char = *yy_cp; \
+       (yytext_ptr) = yy_bp; \
+       swf5leng = (size_t) (yy_cp - yy_bp); \
+       (yy_hold_char) = *yy_cp; \
        *yy_cp = '\0'; \
-       yy_c_buf_p = yy_cp;
+       (yy_c_buf_p) = yy_cp;
 
 #define YY_NUM_RULES 166
 #define YY_END_OF_BUFFER 167
-static yyconst short int yy_accept[650] =
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+       {
+       flex_int32_t yy_verify;
+       flex_int32_t yy_nxt;
+       };
+static yyconst flex_int16_t yy_accept[650] =
     {   0,
         0,    0,    0,    0,  167,  165,  119,  164,  165,  152,
       165,  151,  146,  165,  153,  154,  149,  144,  159,  145,
@@ -377,7 +447,7 @@ static yyconst short int yy_accept[650] =
       100,  112,  112,   54,  112,   51,  112,   53,    0
     } ;
 
-static yyconst int yy_ec[256] =
+static yyconst flex_int32_t yy_ec[256] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
         2,    2,    4,    1,    1,    1,    1,    1,    1,    1,
@@ -409,7 +479,7 @@ static yyconst int yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst int yy_meta[63] =
+static yyconst flex_int32_t yy_meta[63] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    2,    2,    2,
@@ -420,7 +490,7 @@ static yyconst int yy_meta[63] =
         1,    1
     } ;
 
-static yyconst short int yy_base[654] =
+static yyconst flex_int16_t yy_base[654] =
     {   0,
         0,    0,   29,    0,  741,  742,  742,  742,  737,  713,
        67,  742,   64,   76,  742,  742,  712,   67,  742,   68,
@@ -496,7 +566,7 @@ static yyconst short int yy_base[654] =
       320,  322,   66
     } ;
 
-static yyconst short int yy_def[654] =
+static yyconst flex_int16_t yy_def[654] =
     {   0,
       649,    1,    1,    3,  649,  649,  649,  649,  649,  649,
       650,  649,  649,  651,  649,  649,  649,  649,  649,  649,
@@ -572,7 +642,7 @@ static yyconst short int yy_def[654] =
       649,  649,  649
     } ;
 
-static yyconst short int yy_nxt[805] =
+static yyconst flex_int16_t yy_nxt[805] =
     {   0,
         6,    7,    8,    9,   10,   11,   12,   13,   14,   15,
        16,   17,   18,   19,   20,   21,   22,   23,   24,   24,
@@ -665,7 +735,7 @@ static yyconst short int yy_nxt[805] =
       649,  649,  649,  649
     } ;
 
-static yyconst short int yy_chk[805] =
+static yyconst flex_int16_t yy_chk[805] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -761,6 +831,9 @@ static yyconst short int yy_chk[805] =
 static yy_state_type yy_last_accepting_state;
 static char *yy_last_accepting_cpos;
 
+extern int swf5_flex_debug;
+int swf5_flex_debug = 0;
+
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.
  */
@@ -768,9 +841,8 @@ static char *yy_last_accepting_cpos;
 #define yymore() yymore_used_but_not_detected
 #define YY_MORE_ADJ 0
 #define YY_RESTORE_YY_MORE_OFFSET
-char *yytext;
+char *swf5text;
 #line 1 "swf5compiler.flex"
-#define INITIAL 0
 #line 2 "swf5compiler.flex"
 
 #include <math.h>
@@ -836,7 +908,7 @@ static void unescape(char *buf)
 void swf5ParseInit(const char *script, int debug)
 {
   checkByteOrder();
-  yyrestart(NULL);
+  swf5restart(NULL);
 
   swf5debug = debug;
 
@@ -847,7 +919,6 @@ void swf5ParseInit(const char *script, int debug)
   msgline = msgbufs[0];
 }
 
-#define asm 1
 
 #line 82 "swf5compiler.flex"
  // forward declaration needed by the following function
@@ -861,7 +932,24 @@ void swf5ParseInit(const char *script, int debug)
  static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 
  void do_unput5(const char c) { unput(c); }
-#line 865 "lex.swf5.c"
+#line 936 "lex.swf5.c"
+
+#define INITIAL 0
+#define asm 1
+
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+static int yy_init_globals (void );
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -869,65 +957,30 @@ void swf5ParseInit(const char *script, int debug)
 
 #ifndef YY_SKIP_YYWRAP
 #ifdef __cplusplus
-extern "C" int yywrap YY_PROTO(( void ));
+extern "C" int swf5wrap (void );
 #else
-extern int yywrap YY_PROTO(( void ));
+extern int swf5wrap (void );
 #endif
 #endif
 
-#ifndef YY_NO_UNPUT
-static void yyunput YY_PROTO(( int c, char *buf_ptr ));
-#endif
-
+    static void yyunput (int c,char *buf_ptr  );
+    
 #ifndef yytext_ptr
-static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
+static void yy_flex_strncpy (char *,yyconst char *,int );
 #endif
 
 #ifdef YY_NEED_STRLEN
-static int yy_flex_strlen YY_PROTO(( yyconst char * ));
+static int yy_flex_strlen (yyconst char * );
 #endif
 
 #ifndef YY_NO_INPUT
-#ifdef __cplusplus
-static int yyinput YY_PROTO(( void ));
-#else
-static int input YY_PROTO(( void ));
-#endif
-#endif
-
-#if YY_STACK_USED
-static int yy_start_stack_ptr = 0;
-static int yy_start_stack_depth = 0;
-static int *yy_start_stack = 0;
-#ifndef YY_NO_PUSH_STATE
-static void yy_push_state YY_PROTO(( int new_state ));
-#endif
-#ifndef YY_NO_POP_STATE
-static void yy_pop_state YY_PROTO(( void ));
-#endif
-#ifndef YY_NO_TOP_STATE
-static int yy_top_state YY_PROTO(( void ));
-#endif
 
+#ifdef __cplusplus
+static int yyinput (void );
 #else
-#define YY_NO_PUSH_STATE 1
-#define YY_NO_POP_STATE 1
-#define YY_NO_TOP_STATE 1
+static int input (void );
 #endif
 
-#ifdef YY_MALLOC_DECL
-YY_MALLOC_DECL
-#else
-#if __STDC__
-#ifndef __cplusplus
-#include <stdlib.h>
-#endif
-#else
-/* Just try to get by without declaring the routines.  This will fail
- * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
- * or sizeof(void*) != sizeof(int).
- */
-#endif
 #endif
 
 /* Amount of stuff to slurp up with each read. */
@@ -936,12 +989,11 @@ YY_MALLOC_DECL
 #endif
 
 /* Copy whatever the last rule matched to the standard output. */
-
 #ifndef ECHO
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
-#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
+#define ECHO (void) fwrite( swf5text, swf5leng, 1, swf5out )
 #endif
 
 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
@@ -949,21 +1001,35 @@ YY_MALLOC_DECL
  */
 #ifndef YY_INPUT
 #define YY_INPUT(buf,result,max_size) \
-       if ( yy_current_buffer->yy_is_interactive ) \
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
                { \
-               int c = '*', n; \
+               int c = '*'; \
+               size_t n; \
                for ( n = 0; n < max_size && \
-                            (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+                            (c = getc( swf5in )) != EOF && c != '\n'; ++n ) \
                        buf[n] = (char) c; \
                if ( c == '\n' ) \
                        buf[n++] = (char) c; \
-               if ( c == EOF && ferror( yyin ) ) \
+               if ( c == EOF && ferror( swf5in ) ) \
                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
                result = n; \
                } \
-       else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
-                 && ferror( yyin ) ) \
-               YY_FATAL_ERROR( "input in flex scanner failed" );
+       else \
+               { \
+               errno=0; \
+               while ( (result = fread(buf, 1, max_size, swf5in))==0 && ferror(swf5in)) \
+                       { \
+                       if( errno != EINTR) \
+                               { \
+                               YY_FATAL_ERROR( "input in flex scanner failed" ); \
+                               break; \
+                               } \
+                       errno=0; \
+                       clearerr(swf5in); \
+                       } \
+               }\
+\
+
 #endif
 
 /* No semi-colon after return; correct usage is to write "yyterminate();" -
@@ -984,14 +1050,20 @@ YY_MALLOC_DECL
 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 #endif
 
+/* end tables serialization structures and prototypes */
+
 /* Default declaration of generated scanner - a define so the user can
  * easily add parameters.
  */
 #ifndef YY_DECL
-#define YY_DECL int yylex YY_PROTO(( void ))
-#endif
+#define YY_DECL_IS_OURS 1
+
+extern int swf5lex (void);
 
-/* Code executed at the beginning of each rule, after yytext and yyleng
+#define YY_DECL int swf5lex (void)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after swf5text and swf5leng
  * have been set up.
  */
 #ifndef YY_USER_ACTION
@@ -1006,62 +1078,66 @@ YY_MALLOC_DECL
 #define YY_RULE_SETUP \
        YY_USER_ACTION
 
+/** The main scanner function which does all the work.
+ */
 YY_DECL
-       {
+{
        register yy_state_type yy_current_state;
-       register char *yy_cp = NULL, *yy_bp = NULL;
+       register char *yy_cp, *yy_bp;
        register int yy_act;
-
+    
 #line 98 "swf5compiler.flex"
 
 
-#line 1019 "lex.swf5.c"
+#line 1093 "lex.swf5.c"
 
-       if ( yy_init )
+       if ( !(yy_init) )
                {
-               yy_init = 0;
+               (yy_init) = 1;
 
 #ifdef YY_USER_INIT
                YY_USER_INIT;
 #endif
 
-               if ( ! yy_start )
-                       yy_start = 1;   /* first start state */
+               if ( ! (yy_start) )
+                       (yy_start) = 1; /* first start state */
 
-               if ( ! yyin )
-                       yyin = stdin;
+               if ( ! swf5in )
+                       swf5in = stdin;
 
-               if ( ! yyout )
-                       yyout = stdout;
+               if ( ! swf5out )
+                       swf5out = stdout;
 
-               if ( ! yy_current_buffer )
-                       yy_current_buffer =
-                               yy_create_buffer( yyin, YY_BUF_SIZE );
+               if ( ! YY_CURRENT_BUFFER ) {
+                       swf5ensure_buffer_stack ();
+                       YY_CURRENT_BUFFER_LVALUE =
+                               swf5_create_buffer(swf5in,YY_BUF_SIZE );
+               }
 
-               yy_load_buffer_state();
+               swf5_load_buffer_state( );
                }
 
        while ( 1 )             /* loops until end-of-file is reached */
                {
-               yy_cp = yy_c_buf_p;
+               yy_cp = (yy_c_buf_p);
 
-               /* Support of yytext. */
-               *yy_cp = yy_hold_char;
+               /* Support of swf5text. */
+               *yy_cp = (yy_hold_char);
 
                /* yy_bp points to the position in yy_ch_buf of the start of
                 * the current run.
                 */
                yy_bp = yy_cp;
 
-               yy_current_state = yy_start;
+               yy_current_state = (yy_start);
 yy_match:
                do
                        {
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
                        if ( yy_accept[yy_current_state] )
                                {
-                               yy_last_accepting_state = yy_current_state;
-                               yy_last_accepting_cpos = yy_cp;
+                               (yy_last_accepting_state) = yy_current_state;
+                               (yy_last_accepting_cpos) = yy_cp;
                                }
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                                {
@@ -1078,48 +1154,46 @@ yy_find_action:
                yy_act = yy_accept[yy_current_state];
                if ( yy_act == 0 )
                        { /* have to back up */
-                       yy_cp = yy_last_accepting_cpos;
-                       yy_current_state = yy_last_accepting_state;
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
                        yy_act = yy_accept[yy_current_state];
                        }
 
                YY_DO_BEFORE_ACTION;
 
-
 do_action:     /* This label is used only to access EOF actions. */
 
-
                switch ( yy_act )
        { /* beginning of action switch */
                        case 0: /* must back up */
                        /* undo the effects of YY_DO_BEFORE_ACTION */
-                       *yy_cp = yy_hold_char;
-                       yy_cp = yy_last_accepting_cpos;
-                       yy_current_state = yy_last_accepting_state;
+                       *yy_cp = (yy_hold_char);
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
                        goto yy_find_action;
 
 case 1:
 YY_RULE_SETUP
 #line 100 "swf5compiler.flex"
-{ count();     swf5lval.intVal = strtoul(yytext, NULL, 0);
+{ count();     swf5lval.intVal = strtoul(swf5text, NULL, 0);
                                        return INTEGER;         }
        YY_BREAK
 case 2:
 YY_RULE_SETUP
 #line 102 "swf5compiler.flex"
-{ count();     swf5lval.intVal = strtoul(yytext, NULL, 0);
+{ count();     swf5lval.intVal = strtoul(swf5text, NULL, 0);
                                        return INTEGER;         }
        YY_BREAK
 case 3:
 YY_RULE_SETUP
 #line 104 "swf5compiler.flex"
-{ count();     swf5lval.intVal = atoi(yytext);
+{ count();     swf5lval.intVal = atoi(swf5text);
                                        return INTEGER;         }
        YY_BREAK
 case 4:
 YY_RULE_SETUP
 #line 106 "swf5compiler.flex"
-{ count();     swf5lval.doubleVal = atof(yytext);
+{ count();     swf5lval.doubleVal = atof(swf5text);
                                        return DOUBLE;          }
        YY_BREAK
 case 5:
@@ -1661,35 +1735,38 @@ YY_RULE_SETUP
 case 111:
 YY_RULE_SETUP
 #line 223 "swf5compiler.flex"
-{ count();     swf5lval.str = strdup(yytext+2);
+{ count();     swf5lval.str = strdup(swf5text+2);
                                        return REGISTER;        }
        YY_BREAK
 case 112:
 YY_RULE_SETUP
 #line 227 "swf5compiler.flex"
-{ count();     swf5lval.str = strdup(yytext);
+{ count();     swf5lval.str = strdup(swf5text);
                                        return IDENTIFIER;      }
        YY_BREAK
 case 113:
+/* rule 113 can match eol */
 YY_RULE_SETUP
 #line 230 "swf5compiler.flex"
-{ count();     swf5lval.str = strdup(yytext+1);
+{ count();     swf5lval.str = strdup(swf5text+1);
                                        swf5lval.str[strlen(swf5lval.str)-1]=0;
                                         unescape(swf5lval.str);
                                        return STRING;          }
        YY_BREAK
 case 114:
+/* rule 114 can match eol */
 YY_RULE_SETUP
 #line 235 "swf5compiler.flex"
-{ count();     swf5lval.str = strdup(yytext+1);
+{ count();     swf5lval.str = strdup(swf5text+1);
                                        swf5lval.str[strlen(swf5lval.str)-1]=0;
                                         unescape(swf5lval.str);
                                        return STRING;          }
        YY_BREAK
 case 115:
-*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
-yy_c_buf_p = yy_cp -= 1;
-YY_DO_BEFORE_ACTION; /* set up yytext again */
+/* rule 115 can match eol */
+*yy_cp = (yy_hold_char); /* undo effects of setting up swf5text */
+(yy_c_buf_p) = yy_cp -= 1;
+YY_DO_BEFORE_ACTION; /* set up swf5text again */
 YY_RULE_SETUP
 #line 240 "swf5compiler.flex"
 { count();     swf5lval.str = strdup("");
@@ -1697,9 +1774,10 @@ YY_RULE_SETUP
                                        return STRING;          }
        YY_BREAK
 case 116:
-*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
-yy_c_buf_p = yy_cp -= 1;
-YY_DO_BEFORE_ACTION; /* set up yytext again */
+/* rule 116 can match eol */
+*yy_cp = (yy_hold_char); /* undo effects of setting up swf5text */
+(yy_c_buf_p) = yy_cp -= 1;
+YY_DO_BEFORE_ACTION; /* set up swf5text again */
 YY_RULE_SETUP
 #line 244 "swf5compiler.flex"
 { count();     swf5lval.str = strdup("");
@@ -1942,22 +2020,23 @@ YY_RULE_SETUP
 { count();     return '~'; }
        YY_BREAK
 case 164:
+/* rule 164 can match eol */
 YY_RULE_SETUP
 #line 298 "swf5compiler.flex"
-{ count();     strcpy(szLine, yytext + 1);
+{ count();     strcpy(szLine, swf5text + 1);
                                        countline();    yyless(1);      }
        YY_BREAK
 case 165:
 YY_RULE_SETUP
 #line 301 "swf5compiler.flex"
-SWF_error("Unrecognized character: %s\n", yytext);
+SWF_error("Unrecognized character: %s\n", swf5text);
        YY_BREAK
 case 166:
 YY_RULE_SETUP
 #line 303 "swf5compiler.flex"
 ECHO;
        YY_BREAK
-#line 1961 "lex.swf5.c"
+#line 2040 "lex.swf5.c"
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(asm):
        yyterminate();
@@ -1965,26 +2044,26 @@ case YY_STATE_EOF(asm):
        case YY_END_OF_BUFFER:
                {
                /* Amount of text matched not including the EOB char. */
-               int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
+               int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 
                /* Undo the effects of YY_DO_BEFORE_ACTION. */
-               *yy_cp = yy_hold_char;
+               *yy_cp = (yy_hold_char);
                YY_RESTORE_YY_MORE_OFFSET
 
-               if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+               if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
                        {
                        /* We're scanning a new file or input source.  It's
                         * possible that this happened because the user
-                        * just pointed yyin at a new source and called
-                        * yylex().  If so, then we have to assure
-                        * consistency between yy_current_buffer and our
+                        * just pointed swf5in at a new source and called
+                        * swf5lex().  If so, then we have to assure
+                        * consistency between YY_CURRENT_BUFFER and our
                         * globals.  Here is the right place to do so, because
                         * this is the first action (other than possibly a
                         * back-up) that will match for the new input source.
                         */
-                       yy_n_chars = yy_current_buffer->yy_n_chars;
-                       yy_current_buffer->yy_input_file = yyin;
-                       yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+                       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+                       YY_CURRENT_BUFFER_LVALUE->yy_input_file = swf5in;
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
                        }
 
                /* Note that here we test for yy_c_buf_p "<=" to the position
@@ -1994,13 +2073,13 @@ case YY_STATE_EOF(asm):
                 * end-of-buffer state).  Contrast this with the test
                 * in input().
                 */
-               if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+               if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
                        { /* This was really a NUL. */
                        yy_state_type yy_next_state;
 
-                       yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+                       (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
 
-                       yy_current_state = yy_get_previous_state();
+                       yy_current_state = yy_get_previous_state(  );
 
                        /* Okay, we're now positioned to make the NUL
                         * transition.  We couldn't have
@@ -2013,41 +2092,41 @@ case YY_STATE_EOF(asm):
 
                        yy_next_state = yy_try_NUL_trans( yy_current_state );
 
-                       yy_bp = yytext_ptr + YY_MORE_ADJ;
+                       yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 
                        if ( yy_next_state )
                                {
                                /* Consume the NUL. */
-                               yy_cp = ++yy_c_buf_p;
+                               yy_cp = ++(yy_c_buf_p);
                                yy_current_state = yy_next_state;
                                goto yy_match;
                                }
 
                        else
                                {
-                               yy_cp = yy_c_buf_p;
+                               yy_cp = (yy_c_buf_p);
                                goto yy_find_action;
                                }
                        }
 
-               else switch ( yy_get_next_buffer() )
+               else switch ( yy_get_next_buffer(  ) )
                        {
                        case EOB_ACT_END_OF_FILE:
                                {
-                               yy_did_buffer_switch_on_eof = 0;
+                               (yy_did_buffer_switch_on_eof) = 0;
 
-                               if ( yywrap() )
+                               if ( swf5wrap( ) )
                                        {
                                        /* Note: because we've taken care in
                                         * yy_get_next_buffer() to have set up
-                                        * yytext, we can now set up
+                                        * swf5text, we can now set up
                                         * yy_c_buf_p so that if some total
                                         * hoser (like flex itself) wants to
                                         * call the scanner after we return the
                                         * YY_NULL, it'll still work - another
                                         * YY_NULL will get returned.
                                         */
-                                       yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+                                       (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
 
                                        yy_act = YY_STATE_EOF(YY_START);
                                        goto do_action;
@@ -2055,30 +2134,30 @@ case YY_STATE_EOF(asm):
 
                                else
                                        {
-                                       if ( ! yy_did_buffer_switch_on_eof )
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
                                                YY_NEW_FILE;
                                        }
                                break;
                                }
 
                        case EOB_ACT_CONTINUE_SCAN:
-                               yy_c_buf_p =
-                                       yytext_ptr + yy_amount_of_matched_text;
+                               (yy_c_buf_p) =
+                                       (yytext_ptr) + yy_amount_of_matched_text;
 
-                               yy_current_state = yy_get_previous_state();
+                               yy_current_state = yy_get_previous_state(  );
 
-                               yy_cp = yy_c_buf_p;
-                               yy_bp = yytext_ptr + YY_MORE_ADJ;
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_match;
 
                        case EOB_ACT_LAST_MATCH:
-                               yy_c_buf_p =
-                               &yy_current_buffer->yy_ch_buf[yy_n_chars];
+                               (yy_c_buf_p) =
+                               &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
 
-                               yy_current_state = yy_get_previous_state();
+                               yy_current_state = yy_get_previous_state(  );
 
-                               yy_cp = yy_c_buf_p;
-                               yy_bp = yytext_ptr + YY_MORE_ADJ;
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_find_action;
                        }
                break;
@@ -2089,8 +2168,7 @@ case YY_STATE_EOF(asm):
                        "fatal flex scanner internal error--no action found" );
        } /* end of action switch */
                } /* end of scanning one token */
-       } /* end of yylex */
-
+} /* end of swf5lex */
 
 /* yy_get_next_buffer - try to read in a new buffer
  *
@@ -2099,21 +2177,20 @@ case YY_STATE_EOF(asm):
  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  *     EOB_ACT_END_OF_FILE - end of file
  */
-
-static int yy_get_next_buffer()
-       {
-       register char *dest = yy_current_buffer->yy_ch_buf;
-       register char *source = yytext_ptr;
+static int yy_get_next_buffer (void)
+{
+       register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+       register char *source = (yytext_ptr);
        register int number_to_move, i;
        int ret_val;
 
-       if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+       if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
                YY_FATAL_ERROR(
                "fatal flex scanner internal error--end of buffer missed" );
 
-       if ( yy_current_buffer->yy_fill_buffer == 0 )
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
                { /* Don't try to fill the buffer, so this is an EOF. */
-               if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+               if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
                        {
                        /* We matched a single character, the EOB, so
                         * treat this as a final EOF.
@@ -2133,34 +2210,30 @@ static int yy_get_next_buffer()
        /* Try to read more data. */
 
        /* First move last chars to start of buffer. */
-       number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
+       number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
 
        for ( i = 0; i < number_to_move; ++i )
                *(dest++) = *(source++);
 
-       if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
                /* don't do the read, it's not guaranteed to return an EOF,
                 * just force an EOF
                 */
-               yy_current_buffer->yy_n_chars = yy_n_chars = 0;
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
 
        else
                {
-               int num_to_read =
-                       yy_current_buffer->yy_buf_size - number_to_move - 1;
+                       int num_to_read =
+                       YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
                while ( num_to_read <= 0 )
                        { /* Not enough room in the buffer - grow it. */
-#ifdef YY_USES_REJECT
-                       YY_FATAL_ERROR(
-"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
-#else
 
                        /* just a shorter name for the current buffer */
-                       YY_BUFFER_STATE b = yy_current_buffer;
+                       YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
 
                        int yy_c_buf_p_offset =
-                               (int) (yy_c_buf_p - b->yy_ch_buf);
+                               (int) ((yy_c_buf_p) - b->yy_ch_buf);
 
                        if ( b->yy_is_our_buffer )
                                {
@@ -2173,8 +2246,7 @@ static int yy_get_next_buffer()
 
                                b->yy_ch_buf = (char *)
                                        /* Include room in for 2 EOB chars. */
-                                       yy_flex_realloc( (void *) b->yy_ch_buf,
-                                                        b->yy_buf_size + 2 );
+                                       swf5realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
                                }
                        else
                                /* Can't grow it, we don't own it. */
@@ -2184,35 +2256,35 @@ static int yy_get_next_buffer()
                                YY_FATAL_ERROR(
                                "fatal error - scanner input buffer overflow" );
 
-                       yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+                       (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
 
-                       num_to_read = yy_current_buffer->yy_buf_size -
+                       num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
                                                number_to_move - 1;
-#endif
+
                        }
 
                if ( num_to_read > YY_READ_BUF_SIZE )
                        num_to_read = YY_READ_BUF_SIZE;
 
                /* Read in more data. */
-               YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
-                       yy_n_chars, num_to_read );
+               YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+                       (yy_n_chars), num_to_read );
 
-               yy_current_buffer->yy_n_chars = yy_n_chars;
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }
 
-       if ( yy_n_chars == 0 )
+       if ( (yy_n_chars) == 0 )
                {
                if ( number_to_move == YY_MORE_ADJ )
                        {
                        ret_val = EOB_ACT_END_OF_FILE;
-                       yyrestart( yyin );
+                       swf5restart(swf5in  );
                        }
 
                else
                        {
                        ret_val = EOB_ACT_LAST_MATCH;
-                       yy_current_buffer->yy_buffer_status =
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
                                YY_BUFFER_EOF_PENDING;
                        }
                }
@@ -2220,32 +2292,31 @@ static int yy_get_next_buffer()
        else
                ret_val = EOB_ACT_CONTINUE_SCAN;
 
-       yy_n_chars += number_to_move;
-       yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
-       yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+       (yy_n_chars) += number_to_move;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
 
-       yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
+       (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
 
        return ret_val;
-       }
-
+}
 
 /* yy_get_previous_state - get the state just before the EOB char was reached */
 
-static yy_state_type yy_get_previous_state()
-       {
+    static yy_state_type yy_get_previous_state (void)
+{
        register yy_state_type yy_current_state;
        register char *yy_cp;
+    
+       yy_current_state = (yy_start);
 
-       yy_current_state = yy_start;
-
-       for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+       for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
                {
                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
                if ( yy_accept[yy_current_state] )
                        {
-                       yy_last_accepting_state = yy_current_state;
-                       yy_last_accepting_cpos = yy_cp;
+                       (yy_last_accepting_state) = yy_current_state;
+                       (yy_last_accepting_cpos) = yy_cp;
                        }
                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                        {
@@ -2257,30 +2328,23 @@ static yy_state_type yy_get_previous_state()
                }
 
        return yy_current_state;
-       }
-
+}
 
 /* yy_try_NUL_trans - try to make a transition on the NUL character
  *
  * synopsis
  *     next_state = yy_try_NUL_trans( current_state );
  */
-
-#ifdef YY_USE_PROTOS
-static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
-#else
-static yy_state_type yy_try_NUL_trans( yy_current_state )
-yy_state_type yy_current_state;
-#endif
-       {
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
+{
        register int yy_is_jam;
-       register char *yy_cp = yy_c_buf_p;
+       register char *yy_cp = (yy_c_buf_p);
 
        register YY_CHAR yy_c = 1;
        if ( yy_accept[yy_current_state] )
                {
-               yy_last_accepting_state = yy_current_state;
-               yy_last_accepting_cpos = yy_cp;
+               (yy_last_accepting_state) = yy_current_state;
+               (yy_last_accepting_cpos) = yy_cp;
                }
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                {
@@ -2292,80 +2356,73 @@ yy_state_type yy_current_state;
        yy_is_jam = (yy_current_state == 649);
 
        return yy_is_jam ? 0 : yy_current_state;
-       }
-
+}
 
-#ifndef YY_NO_UNPUT
-#ifdef YY_USE_PROTOS
-static void yyunput( int c, register char *yy_bp )
-#else
-static void yyunput( c, yy_bp )
-int c;
-register char *yy_bp;
-#endif
-       {
-       register char *yy_cp = yy_c_buf_p;
+    static void yyunput (int c, register char * yy_bp )
+{
+       register char *yy_cp;
+    
+    yy_cp = (yy_c_buf_p);
 
-       /* undo effects of setting up yytext */
-       *yy_cp = yy_hold_char;
+       /* undo effects of setting up swf5text */
+       *yy_cp = (yy_hold_char);
 
-       if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+       if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
                { /* need to shift things up to make room */
                /* +2 for EOB chars. */
-               register int number_to_move = yy_n_chars + 2;
-               register char *dest = &yy_current_buffer->yy_ch_buf[
-                                       yy_current_buffer->yy_buf_size + 2];
+               register int number_to_move = (yy_n_chars) + 2;
+               register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+                                       YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
                register char *source =
-                               &yy_current_buffer->yy_ch_buf[number_to_move];
+                               &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
 
-               while ( source > yy_current_buffer->yy_ch_buf )
+               while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
                        *--dest = *--source;
 
                yy_cp += (int) (dest - source);
                yy_bp += (int) (dest - source);
-               yy_current_buffer->yy_n_chars =
-                       yy_n_chars = yy_current_buffer->yy_buf_size;
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+                       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
 
-               if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+               if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
                }
 
        *--yy_cp = (char) c;
 
+       (yytext_ptr) = yy_bp;
+       (yy_hold_char) = *yy_cp;
+       (yy_c_buf_p) = yy_cp;
+}
 
-       yytext_ptr = yy_bp;
-       yy_hold_char = *yy_cp;
-       yy_c_buf_p = yy_cp;
-       }
-#endif /* ifndef YY_NO_UNPUT */
-
-
+#ifndef YY_NO_INPUT
 #ifdef __cplusplus
-static int yyinput()
+    static int yyinput (void)
 #else
-static int input()
+    static int input  (void)
 #endif
-       {
-       int c;
 
-       *yy_c_buf_p = yy_hold_char;
+{
+       int c;
+    
+       *(yy_c_buf_p) = (yy_hold_char);
 
-       if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+       if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
                {
                /* yy_c_buf_p now points to the character we want to return.
                 * If this occurs *before* the EOB characters, then it's a
                 * valid NUL; if not, then we've hit the end of the buffer.
                 */
-               if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+               if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
                        /* This was really a NUL. */
-                       *yy_c_buf_p = '\0';
+                       *(yy_c_buf_p) = '\0';
 
                else
                        { /* need more input */
-                       int offset = yy_c_buf_p - yytext_ptr;
-                       ++yy_c_buf_p;
+                       int offset = (yy_c_buf_p) - (yytext_ptr);
+                       ++(yy_c_buf_p);
 
-                       switch ( yy_get_next_buffer() )
+                       switch ( yy_get_next_buffer(  ) )
                                {
                                case EOB_ACT_LAST_MATCH:
                                        /* This happens because yy_g_n_b()
@@ -2379,16 +2436,16 @@ static int input()
                                         */
 
                                        /* Reset buffer status. */
-                                       yyrestart( yyin );
+                                       swf5restart(swf5in );
 
-                                       /* fall through */
+                                       /*FALLTHROUGH*/
 
                                case EOB_ACT_END_OF_FILE:
                                        {
-                                       if ( yywrap() )
+                                       if ( swf5wrap( ) )
                                                return EOF;
 
-                                       if ( ! yy_did_buffer_switch_on_eof )
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
                                                YY_NEW_FILE;
 #ifdef __cplusplus
                                        return yyinput();
@@ -2398,167 +2455,179 @@ static int input()
                                        }
 
                                case EOB_ACT_CONTINUE_SCAN:
-                                       yy_c_buf_p = yytext_ptr + offset;
+                                       (yy_c_buf_p) = (yytext_ptr) + offset;
                                        break;
                                }
                        }
                }
 
-       c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
-       *yy_c_buf_p = '\0';     /* preserve yytext */
-       yy_hold_char = *++yy_c_buf_p;
-
+       c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
+       *(yy_c_buf_p) = '\0';   /* preserve swf5text */
+       (yy_hold_char) = *++(yy_c_buf_p);
 
        return c;
-       }
-
-
-#ifdef YY_USE_PROTOS
-void yyrestart( FILE *input_file )
-#else
-void yyrestart( input_file )
-FILE *input_file;
-#endif
-       {
-       if ( ! yy_current_buffer )
-               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+}
+#endif /* ifndef YY_NO_INPUT */
 
-       yy_init_buffer( yy_current_buffer, input_file );
-       yy_load_buffer_state();
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * 
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void swf5restart  (FILE * input_file )
+{
+    
+       if ( ! YY_CURRENT_BUFFER ){
+        swf5ensure_buffer_stack ();
+               YY_CURRENT_BUFFER_LVALUE =
+            swf5_create_buffer(swf5in,YY_BUF_SIZE );
        }
 
+       swf5_init_buffer(YY_CURRENT_BUFFER,input_file );
+       swf5_load_buffer_state( );
+}
 
-#ifdef YY_USE_PROTOS
-void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
-#else
-void yy_switch_to_buffer( new_buffer )
-YY_BUFFER_STATE new_buffer;
-#endif
-       {
-       if ( yy_current_buffer == new_buffer )
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * 
+ */
+    void swf5_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
+{
+    
+       /* TODO. We should be able to replace this entire function body
+        * with
+        *              swf5pop_buffer_state();
+        *              swf5push_buffer_state(new_buffer);
+     */
+       swf5ensure_buffer_stack ();
+       if ( YY_CURRENT_BUFFER == new_buffer )
                return;
 
-       if ( yy_current_buffer )
+       if ( YY_CURRENT_BUFFER )
                {
                /* Flush out information for old buffer. */
-               *yy_c_buf_p = yy_hold_char;
-               yy_current_buffer->yy_buf_pos = yy_c_buf_p;
-               yy_current_buffer->yy_n_chars = yy_n_chars;
+               *(yy_c_buf_p) = (yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }
 
-       yy_current_buffer = new_buffer;
-       yy_load_buffer_state();
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
+       swf5_load_buffer_state( );
 
        /* We don't actually know whether we did this switch during
-        * EOF (yywrap()) processing, but the only time this flag
-        * is looked at is after yywrap() is called, so it's safe
+        * EOF (swf5wrap()) processing, but the only time this flag
+        * is looked at is after swf5wrap() is called, so it's safe
         * to go ahead and always set it.
         */
-       yy_did_buffer_switch_on_eof = 1;
-       }
-
-
-#ifdef YY_USE_PROTOS
-void yy_load_buffer_state( void )
-#else
-void yy_load_buffer_state()
-#endif
-       {
-       yy_n_chars = yy_current_buffer->yy_n_chars;
-       yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
-       yyin = yy_current_buffer->yy_input_file;
-       yy_hold_char = *yy_c_buf_p;
-       }
+       (yy_did_buffer_switch_on_eof) = 1;
+}
 
+static void swf5_load_buffer_state  (void)
+{
+       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+       (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+       swf5in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+       (yy_hold_char) = *(yy_c_buf_p);
+}
 
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
-#else
-YY_BUFFER_STATE yy_create_buffer( file, size )
-FILE *file;
-int size;
-#endif
-       {
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * 
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE swf5_create_buffer  (FILE * file, int  size )
+{
        YY_BUFFER_STATE b;
-
-       b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+    
+       b = (YY_BUFFER_STATE) swf5alloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
-               YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+               YY_FATAL_ERROR( "out of dynamic memory in swf5_create_buffer()" );
 
        b->yy_buf_size = size;
 
        /* yy_ch_buf has to be 2 characters longer than the size given because
         * we need to put in 2 end-of-buffer characters.
         */
-       b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
+       b->yy_ch_buf = (char *) swf5alloc(b->yy_buf_size + 2  );
        if ( ! b->yy_ch_buf )
-               YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+               YY_FATAL_ERROR( "out of dynamic memory in swf5_create_buffer()" );
 
        b->yy_is_our_buffer = 1;
 
-       yy_init_buffer( b, file );
+       swf5_init_buffer(b,file );
 
        return b;
-       }
-
+}
 
-#ifdef YY_USE_PROTOS
-void yy_delete_buffer( YY_BUFFER_STATE b )
-#else
-void yy_delete_buffer( b )
-YY_BUFFER_STATE b;
-#endif
-       {
+/** Destroy the buffer.
+ * @param b a buffer created with swf5_create_buffer()
+ * 
+ */
+    void swf5_delete_buffer (YY_BUFFER_STATE  b )
+{
+    
        if ( ! b )
                return;
 
-       if ( b == yy_current_buffer )
-               yy_current_buffer = (YY_BUFFER_STATE) 0;
+       if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+               YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 
        if ( b->yy_is_our_buffer )
-               yy_flex_free( (void *) b->yy_ch_buf );
-
-       yy_flex_free( (void *) b );
-       }
-
+               swf5free((void *) b->yy_ch_buf  );
 
+       swf5free((void *) b  );
+}
 
-#ifdef YY_USE_PROTOS
-void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#ifndef _UNISTD_H /* assume unistd.h has isatty() for us */
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __THROW /* this is a gnuism */
+extern int isatty (int ) __THROW;
 #else
-void yy_init_buffer( b, file )
-YY_BUFFER_STATE b;
-FILE *file;
+extern int isatty (int );
 #endif
+#ifdef __cplusplus
+}
+#endif
+#endif
+    
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a swf5restart() or at EOF.
+ */
+    static void swf5_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
 
-
-       {
-       yy_flush_buffer( b );
+{
+       int oerrno = errno;
+    
+       swf5_flush_buffer(b );
 
        b->yy_input_file = file;
        b->yy_fill_buffer = 1;
 
-#if YY_ALWAYS_INTERACTIVE
-       b->yy_is_interactive = 1;
-#else
-#if YY_NEVER_INTERACTIVE
-       b->yy_is_interactive = 0;
-#else
-       b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
-#endif
-#endif
-       }
-
+    /* If b is the current buffer, then swf5_init_buffer was _probably_
+     * called from swf5restart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
 
-#ifdef YY_USE_PROTOS
-void yy_flush_buffer( YY_BUFFER_STATE b )
-#else
-void yy_flush_buffer( b )
-YY_BUFFER_STATE b;
-#endif
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+    
+       errno = oerrno;
+}
 
-       {
-       if ( ! b )
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * 
+ */
+    void swf5_flush_buffer (YY_BUFFER_STATE  b )
+{
+       if ( ! b )
                return;
 
        b->yy_n_chars = 0;
@@ -2575,31 +2644,123 @@ YY_BUFFER_STATE b;
        b->yy_at_bol = 1;
        b->yy_buffer_status = YY_BUFFER_NEW;
 
-       if ( b == yy_current_buffer )
-               yy_load_buffer_state();
+       if ( b == YY_CURRENT_BUFFER )
+               swf5_load_buffer_state( );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  
+ */
+void swf5push_buffer_state (YY_BUFFER_STATE new_buffer )
+{
+       if (new_buffer == NULL)
+               return;
+
+       swf5ensure_buffer_stack();
+
+       /* This block is copied from swf5_switch_to_buffer. */
+       if ( YY_CURRENT_BUFFER )
+               {
+               /* Flush out information for old buffer. */
+               *(yy_c_buf_p) = (yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+               }
+
+       /* Only push if top exists. Otherwise, replace top. */
+       if (YY_CURRENT_BUFFER)
+               (yy_buffer_stack_top)++;
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+       /* copied from swf5_switch_to_buffer. */
+       swf5_load_buffer_state( );
+       (yy_did_buffer_switch_on_eof) = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  
+ */
+void swf5pop_buffer_state (void)
+{
+       if (!YY_CURRENT_BUFFER)
+               return;
+
+       swf5_delete_buffer(YY_CURRENT_BUFFER );
+       YY_CURRENT_BUFFER_LVALUE = NULL;
+       if ((yy_buffer_stack_top) > 0)
+               --(yy_buffer_stack_top);
+
+       if (YY_CURRENT_BUFFER) {
+               swf5_load_buffer_state( );
+               (yy_did_buffer_switch_on_eof) = 1;
        }
+}
 
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void swf5ensure_buffer_stack (void)
+{
+       int num_to_alloc;
+    
+       if (!(yy_buffer_stack)) {
+
+               /* First allocation is just for 2 elements, since we don't know if this
+                * scanner will even need a stack. We use 2 instead of 1 to avoid an
+                * immediate realloc on the next call.
+         */
+               num_to_alloc = 1;
+               (yy_buffer_stack) = (struct yy_buffer_state**)swf5alloc
+                                                               (num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+               
+               memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+                               
+               (yy_buffer_stack_max) = num_to_alloc;
+               (yy_buffer_stack_top) = 0;
+               return;
+       }
 
-#ifndef YY_NO_SCAN_BUFFER
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
-#else
-YY_BUFFER_STATE yy_scan_buffer( base, size )
-char *base;
-yy_size_t size;
-#endif
-       {
-       YY_BUFFER_STATE b;
+       if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
+
+               /* Increase the buffer to prepare for a possible push. */
+               int grow_size = 8 /* arbitrary grow size */;
+
+               num_to_alloc = (yy_buffer_stack_max) + grow_size;
+               (yy_buffer_stack) = (struct yy_buffer_state**)swf5realloc
+                                                               ((yy_buffer_stack),
+                                                               num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+
+               /* zero only the new slots.*/
+               memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
+               (yy_buffer_stack_max) = num_to_alloc;
+       }
+}
 
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * 
+ * @return the newly allocated buffer state object. 
+ */
+YY_BUFFER_STATE swf5_scan_buffer  (char * base, yy_size_t  size )
+{
+       YY_BUFFER_STATE b;
+    
        if ( size < 2 ||
             base[size-2] != YY_END_OF_BUFFER_CHAR ||
             base[size-1] != YY_END_OF_BUFFER_CHAR )
                /* They forgot to leave room for the EOB's. */
                return 0;
 
-       b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+       b = (YY_BUFFER_STATE) swf5alloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
-               YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+               YY_FATAL_ERROR( "out of dynamic memory in swf5_scan_buffer()" );
 
        b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
        b->yy_buf_pos = b->yy_ch_buf = base;
@@ -2611,58 +2772,53 @@ yy_size_t size;
        b->yy_fill_buffer = 0;
        b->yy_buffer_status = YY_BUFFER_NEW;
 
-       yy_switch_to_buffer( b );
+       swf5_switch_to_buffer(b  );
 
        return b;
-       }
-#endif
-
-
-#ifndef YY_NO_SCAN_STRING
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
-#else
-YY_BUFFER_STATE yy_scan_string( yy_str )
-yyconst char *yy_str;
-#endif
-       {
-       int len;
-       for ( len = 0; yy_str[len]; ++len )
-               ;
-
-       return yy_scan_bytes( yy_str, len );
-       }
-#endif
+}
 
+/** Setup the input buffer state to scan a string. The next call to swf5lex() will
+ * scan from a @e copy of @a str.
+ * @param str a NUL-terminated string to scan
+ * 
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       swf5_scan_bytes() instead.
+ */
+YY_BUFFER_STATE swf5_scan_string (yyconst char * yystr )
+{
+    
+       return swf5_scan_bytes(yystr,strlen(yystr) );
+}
 
-#ifndef YY_NO_SCAN_BYTES
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
-#else
-YY_BUFFER_STATE yy_scan_bytes( bytes, len )
-yyconst char *bytes;
-int len;
-#endif
-       {
+/** Setup the input buffer state to scan the given bytes. The next call to swf5lex() will
+ * scan from a @e copy of @a bytes.
+ * @param bytes the byte buffer to scan
+ * @param len the number of bytes in the buffer pointed to by @a bytes.
+ * 
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE swf5_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
+{
        YY_BUFFER_STATE b;
        char *buf;
        yy_size_t n;
        int i;
-
+    
        /* Get memory for full buffer, including space for trailing EOB's. */
-       n = len + 2;
-       buf = (char *) yy_flex_alloc( n );
+       n = _yybytes_len + 2;
+       buf = (char *) swf5alloc(n  );
        if ( ! buf )
-               YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+               YY_FATAL_ERROR( "out of dynamic memory in swf5_scan_bytes()" );
 
-       for ( i = 0; i < len; ++i )
-               buf[i] = bytes[i];
+       for ( i = 0; i < _yybytes_len; ++i )
+               buf[i] = yybytes[i];
 
-       buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+       buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 
-       b = yy_scan_buffer( buf, n );
+       b = swf5_scan_buffer(buf,n );
        if ( ! b )
-               YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+               YY_FATAL_ERROR( "bad buffer in swf5_scan_bytes()" );
 
        /* It's okay to grow etc. this buffer, and we should throw it
         * away when we're done.
@@ -2670,148 +2826,196 @@ int len;
        b->yy_is_our_buffer = 1;
 
        return b;
-       }
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
 #endif
 
+static void yy_fatal_error (yyconst char* msg )
+{
+       (void) fprintf( stderr, "%s\n", msg );
+       exit( YY_EXIT_FAILURE );
+}
 
-#ifndef YY_NO_PUSH_STATE
-#ifdef YY_USE_PROTOS
-static void yy_push_state( int new_state )
-#else
-static void yy_push_state( new_state )
-int new_state;
-#endif
-       {
-       if ( yy_start_stack_ptr >= yy_start_stack_depth )
-               {
-               yy_size_t new_size;
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+       do \
+               { \
+               /* Undo effects of setting up swf5text. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+               swf5text[swf5leng] = (yy_hold_char); \
+               (yy_c_buf_p) = swf5text + yyless_macro_arg; \
+               (yy_hold_char) = *(yy_c_buf_p); \
+               *(yy_c_buf_p) = '\0'; \
+               swf5leng = yyless_macro_arg; \
+               } \
+       while ( 0 )
 
-               yy_start_stack_depth += YY_START_STACK_INCR;
-               new_size = yy_start_stack_depth * sizeof( int );
+/* Accessor  methods (get/set functions) to struct members. */
 
-               if ( ! yy_start_stack )
-                       yy_start_stack = (int *) yy_flex_alloc( new_size );
+/** Get the current line number.
+ * 
+ */
+int swf5get_lineno  (void)
+{
+        
+    return swf5lineno;
+}
 
-               else
-                       yy_start_stack = (int *) yy_flex_realloc(
-                                       (void *) yy_start_stack, new_size );
+/** Get the input stream.
+ * 
+ */
+FILE *swf5get_in  (void)
+{
+        return swf5in;
+}
 
-               if ( ! yy_start_stack )
-                       YY_FATAL_ERROR(
-                       "out of memory expanding start-condition stack" );
-               }
+/** Get the output stream.
+ * 
+ */
+FILE *swf5get_out  (void)
+{
+        return swf5out;
+}
 
-       yy_start_stack[yy_start_stack_ptr++] = YY_START;
+/** Get the length of the current token.
+ * 
+ */
+int swf5get_leng  (void)
+{
+        return swf5leng;
+}
 
-       BEGIN(new_state);
-       }
-#endif
+/** Get the current token.
+ * 
+ */
 
+char *swf5get_text  (void)
+{
+        return swf5text;
+}
 
-#ifndef YY_NO_POP_STATE
-static void yy_pop_state()
-       {
-       if ( --yy_start_stack_ptr < 0 )
-               YY_FATAL_ERROR( "start-condition stack underflow" );
+/** Set the current line number.
+ * @param line_number
+ * 
+ */
+void swf5set_lineno (int  line_number )
+{
+    
+    swf5lineno = line_number;
+}
 
-       BEGIN(yy_start_stack[yy_start_stack_ptr]);
-       }
-#endif
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param in_str A readable stream.
+ * 
+ * @see swf5_switch_to_buffer
+ */
+void swf5set_in (FILE *  in_str )
+{
+        swf5in = in_str ;
+}
 
+void swf5set_out (FILE *  out_str )
+{
+        swf5out = out_str ;
+}
 
-#ifndef YY_NO_TOP_STATE
-static int yy_top_state()
-       {
-       return yy_start_stack[yy_start_stack_ptr - 1];
-       }
-#endif
+int swf5get_debug  (void)
+{
+        return swf5_flex_debug;
+}
 
-#ifndef YY_EXIT_FAILURE
-#define YY_EXIT_FAILURE 2
-#endif
+void swf5set_debug (int  bdebug )
+{
+        swf5_flex_debug = bdebug ;
+}
 
-#ifdef YY_USE_PROTOS
-static void yy_fatal_error( yyconst char msg[] )
+static int yy_init_globals (void)
+{
+        /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from swf5lex_destroy(), so don't allocate here.
+     */
+
+    (yy_buffer_stack) = 0;
+    (yy_buffer_stack_top) = 0;
+    (yy_buffer_stack_max) = 0;
+    (yy_c_buf_p) = (char *) 0;
+    (yy_init) = 0;
+    (yy_start) = 0;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    swf5in = stdin;
+    swf5out = stdout;
 #else
-static void yy_fatal_error( msg )
-char msg[];
+    swf5in = (FILE *) 0;
+    swf5out = (FILE *) 0;
 #endif
-       {
-       (void) fprintf( stderr, "%s\n", msg );
-       exit( YY_EXIT_FAILURE );
-       }
 
+    /* For future reference: Set errno on error, since we are called by
+     * swf5lex_init()
+     */
+    return 0;
+}
 
+/* swf5lex_destroy is for both reentrant and non-reentrant scanners. */
+int swf5lex_destroy  (void)
+{
+    
+    /* Pop the buffer stack, destroying each element. */
+       while(YY_CURRENT_BUFFER){
+               swf5_delete_buffer(YY_CURRENT_BUFFER  );
+               YY_CURRENT_BUFFER_LVALUE = NULL;
+               swf5pop_buffer_state();
+       }
 
-/* Redefine yyless() so it works in section 3 code. */
+       /* Destroy the stack itself. */
+       swf5free((yy_buffer_stack) );
+       (yy_buffer_stack) = NULL;
 
-#undef yyless
-#define yyless(n) \
-       do \
-               { \
-               /* Undo effects of setting up yytext. */ \
-               yytext[yyleng] = yy_hold_char; \
-               yy_c_buf_p = yytext + n; \
-               yy_hold_char = *yy_c_buf_p; \
-               *yy_c_buf_p = '\0'; \
-               yyleng = n; \
-               } \
-       while ( 0 )
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * swf5lex() is called, initialization will occur. */
+    yy_init_globals( );
 
+    return 0;
+}
 
-/* Internal utility routines. */
+/*
+ * Internal utility routines.
+ */
 
 #ifndef yytext_ptr
-#ifdef YY_USE_PROTOS
-static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
-#else
-static void yy_flex_strncpy( s1, s2, n )
-char *s1;
-yyconst char *s2;
-int n;
-#endif
-       {
+static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
+{
        register int i;
        for ( i = 0; i < n; ++i )
                s1[i] = s2[i];
-       }
+}
 #endif
 
 #ifdef YY_NEED_STRLEN
-#ifdef YY_USE_PROTOS
-static int yy_flex_strlen( yyconst char *s )
-#else
-static int yy_flex_strlen( s )
-yyconst char *s;
-#endif
-       {
+static int yy_flex_strlen (yyconst char * s )
+{
        register int n;
        for ( n = 0; s[n]; ++n )
                ;
 
        return n;
-       }
+}
 #endif
 
-
-#ifdef YY_USE_PROTOS
-static void *yy_flex_alloc( yy_size_t size )
-#else
-static void *yy_flex_alloc( size )
-yy_size_t size;
-#endif
-       {
+void *swf5alloc (yy_size_t  size )
+{
        return (void *) malloc( size );
-       }
+}
 
-#ifdef YY_USE_PROTOS
-static void *yy_flex_realloc( void *ptr, yy_size_t size )
-#else
-static void *yy_flex_realloc( ptr, size )
-void *ptr;
-yy_size_t size;
-#endif
-       {
+void *swf5realloc  (void * ptr, yy_size_t  size )
+{
        /* The cast to (char *) in the following accommodates both
         * implementations that use char* generic pointers, and those
         * that use void* generic pointers.  It works with the latter
@@ -2820,27 +3024,18 @@ yy_size_t size;
         * as though doing an assignment.
         */
        return (void *) realloc( (char *) ptr, size );
-       }
+}
 
-#ifdef YY_USE_PROTOS
-static void yy_flex_free( void *ptr )
-#else
-static void yy_flex_free( ptr )
-void *ptr;
-#endif
-       {
-       free( ptr );
-       }
+void swf5free (void * ptr )
+{
+       free( (char *) ptr );   /* see swf5realloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
 
-#if YY_MAIN
-int main()
-       {
-       yylex();
-       return 0;
-       }
-#endif
 #line 303 "swf5compiler.flex"
 
+
 static int getinput() {
 #ifdef __cplusplus
                                        return yyinput();
@@ -2954,22 +3149,22 @@ static void count(void)
    int n;
 
    // Count the characters to maintain the current column position
-   if (yytext[0] == '\n')
+   if (swf5text[0] == '\n')
    {
       if (swf5debug) printf("\n");
    }
    else
    {
-      if (swf5debug) printf("%s", yytext);
+      if (swf5debug) printf("%s", swf5text);
 
-      for(n=0; n<yyleng; ++n, ++column)
+      for(n=0; n<swf5leng; ++n, ++column)
       {
        if(column < 1023)
-         msgline[column] = yytext[n];
+         msgline[column] = swf5text[n];
       }
 
       //-- keep writing the stuff to standard output
-      //column += yyleng;
+      //column += swf5leng;
    }
 }
 
@@ -2995,7 +3190,7 @@ static void warning(char *msg)
 void swf5error(char *msg)
 {
   // report a error
-  if(strlen(yytext))
+  if(strlen(swf5text))
   {
     SWF_error("\n%s\n%*s\nLine %i:  Reason: '%s'\n",
              LineText(), ColumnNumber(), "^", LineNumber(), msg);
@@ -3005,3 +3200,4 @@ void swf5error(char *msg)
     SWF_error("\nLine %d: Reason: 'Unexpected EOF found while looking for input.'\n", LineNumber());
   }
 }
+
index db78533..33dc4a3 100644 (file)
@@ -1,7 +1,9 @@
-/* A Bison parser, made by GNU Bison 1.875.  */
+/* A Bison parser, made by GNU Bison 2.3.  */
 
-/* Skeleton parser for Yacc-like parsing with Bison,
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
+/* Skeleton implementation for Bison's Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
 
-/* As a special exception, when this file is copied by Bison into a
-   Bison output file, you may use that output file without restriction.
-   This special exception was added by the Free Software Foundation
-   in version 1.24 of Bison.  */
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
 
-/* Written by Richard Stallman by simplifying the original so called
-   ``semantic'' parser.  */
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
 
 /* All symbols defined below should begin with yy or YY, to avoid
    infringing on user name space.  This should be done even for local
@@ -36,6 +46,9 @@
 /* Identify Bison output.  */
 #define YYBISON 1
 
+/* Bison version.  */
+#define YYBISON_VERSION "2.3"
+
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
 
@@ -45,8 +58,7 @@
 /* Using locations.  */
 #define YYLSP_NEEDED 0
 
-/* If NAME_PREFIX is specified substitute the variables and functions
-   names.  */
+/* Substitute the variable and function names.  */
 #define yyparse swf5parse
 #define yylex   swf5lex
 #define yyerror swf5error
      POSTFIX = 389
    };
 #endif
+/* Tokens.  */
 #define BREAK 258
 #define CONTINUE 259
 #define FUNCTION 260
@@ -360,9 +373,15 @@ Buffer bf, bc;
 # define YYERROR_VERBOSE 0
 #endif
 
-#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
 #line 21 "swf5compiler.y"
-typedef union YYSTYPE {
+{
   Buffer action;
   char *str;
   SWFGetUrl2Method getURLMethod;
@@ -382,9 +401,10 @@ typedef union YYSTYPE {
   {
        Buffer obj, ident, memexpr;
   } lval;
-} YYSTYPE;
-/* Line 191 of yacc.c.  */
-#line 387 "swf5compiler.tab.c"
+}
+/* Line 187 of yacc.c.  */
+#line 407 "swf5compiler.tab.c"
+       YYSTYPE;
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
 # define YYSTYPE_IS_TRIVIAL 1
@@ -395,49 +415,171 @@ typedef union YYSTYPE {
 /* Copy the second part of user declarations.  */
 
 
-/* Line 214 of yacc.c.  */
-#line 399 "swf5compiler.tab.c"
+/* Line 216 of yacc.c.  */
+#line 420 "swf5compiler.tab.c"
 
-#if ! defined (yyoverflow) || YYERROR_VERBOSE
+#ifdef short
+# undef short
+#endif
 
-/* The parser invokes alloca or malloc; define the necessary symbols.  */
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
 
-# if YYSTACK_USE_ALLOCA
-#  define YYSTACK_ALLOC alloca
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#elif (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+typedef signed char yytype_int8;
+#else
+typedef short int yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
 # else
-#  ifndef YYSTACK_USE_ALLOCA
-#   if defined (alloca) || defined (_ALLOCA_H)
-#    define YYSTACK_ALLOC alloca
+#  define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(msgid) msgid
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(e) ((void) (e))
+#else
+# define YYUSE(e) /* empty */
+#endif
+
+/* Identity function, used to suppress warnings about constant conditions.  */
+#ifndef lint
+# define YYID(n) (n)
+#else
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static int
+YYID (int i)
+#else
+static int
+YYID (i)
+    int i;
+#endif
+{
+  return i;
+}
+#endif
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
 #   else
-#    ifdef __GNUC__
-#     define YYSTACK_ALLOC __builtin_alloca
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#     ifndef _STDLIB_H
+#      define _STDLIB_H 1
+#     endif
 #    endif
 #   endif
 #  endif
 # endif
 
 # ifdef YYSTACK_ALLOC
-   /* Pacify GCC's `empty if-body' warning. */
-#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+   /* Pacify GCC's `empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
 # else
-#  if defined (__STDC__) || defined (__cplusplus)
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined _STDLIB_H \
+       && ! ((defined YYMALLOC || defined malloc) \
+            && (defined YYFREE || defined free)))
 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#   define YYSIZE_T size_t
+#   ifndef _STDLIB_H
+#    define _STDLIB_H 1
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
 #  endif
-#  define YYSTACK_ALLOC malloc
-#  define YYSTACK_FREE free
 # endif
-#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 
 
-#if (! defined (yyoverflow) \
-     && (! defined (__cplusplus) \
-        || (YYSTYPE_IS_TRIVIAL)))
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+        || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {
-  short yyss;
+  yytype_int16 yyss;
   YYSTYPE yyvs;
   };
 
@@ -447,24 +589,24 @@ union yyalloc
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */
 # define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (short) + sizeof (YYSTYPE))                                \
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
       + YYSTACK_GAP_MAXIMUM)
 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
 # ifndef YYCOPY
-#  if 1 < __GNUC__
+#  if defined __GNUC__ && 1 < __GNUC__
 #   define YYCOPY(To, From, Count) \
       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 #  else
 #   define YYCOPY(To, From, Count)             \
       do                                       \
        {                                       \
-         register YYSIZE_T yyi;                \
+         YYSIZE_T yyi;                         \
          for (yyi = 0; yyi < (Count); yyi++)   \
            (To)[yyi] = (From)[yyi];            \
        }                                       \
-      while (0)
+      while (YYID (0))
 #  endif
 # endif
 
@@ -482,39 +624,33 @@ union yyalloc
        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
        yyptr += yynewbytes / sizeof (*yyptr);                          \
       }                                                                        \
-    while (0)
+    while (YYID (0))
 
 #endif
 
-#if defined (__STDC__) || defined (__cplusplus)
-   typedef signed char yysigned_char;
-#else
-   typedef short yysigned_char;
-#endif
-
-/* YYFINAL -- State number of the termination state. */
+/* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  3
 /* YYLAST -- Last index in YYTABLE.  */
 #define YYLAST   5253
 
-/* YYNTOKENS -- Number of terminals. */
+/* YYNTOKENS -- Number of terminals.  */
 #define YYNTOKENS  159
-/* YYNNTS -- Number of nonterminals. */
+/* YYNNTS -- Number of nonterminals.  */
 #define YYNNTS  57
-/* YYNRULES -- Number of rules. */
+/* YYNRULES -- Number of rules.  */
 #define YYNRULES  348
-/* YYNRULES -- Number of states. */
+/* YYNRULES -- Number of states.  */
 #define YYNSTATES  616
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
 #define YYMAXUTOK   389
 
-#define YYTRANSLATE(YYX)                                               \
+#define YYTRANSLATE(YYX)                                               \
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
-static const unsigned char yytranslate[] =
+static const yytype_uint8 yytranslate[] =
 {
        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -560,7 +696,7 @@ static const unsigned char yytranslate[] =
 #if YYDEBUG
 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
    YYRHS.  */
-static const unsigned short yyprhs[] =
+static const yytype_uint16 yyprhs[] =
 {
        0,     0,     3,     4,     7,     8,    10,    13,    15,    17,
       19,    22,    25,    27,    31,    33,    36,    38,    40,    42,
@@ -599,8 +735,8 @@ static const unsigned short yyprhs[] =
     1022,  1024,  1026,  1028,  1030,  1032,  1034,  1036,  1039
 };
 
-/* YYRHS -- A `-1'-separated list of the rules' RHS. */
-static const short yyrhs[] =
+/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
+static const yytype_int16 yyrhs[] =
 {
      160,     0,    -1,    -1,   161,   162,    -1,    -1,   163,    -1,
      162,   163,    -1,   166,    -1,   179,    -1,   166,    -1,   164,
@@ -710,7 +846,7 @@ static const short yyrhs[] =
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
-static const unsigned short yyrline[] =
+static const yytype_uint16 yyrline[] =
 {
        0,   152,   152,   152,   160,   164,   165,   169,   171,   176,
      179,   185,   189,   190,   191,   192,   193,   194,   195,   196,
@@ -750,54 +886,54 @@ static const unsigned short yyrline[] =
 };
 #endif
 
-#if YYDEBUG || YYERROR_VERBOSE
-/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
-   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 static const char *const yytname[] =
 {
-  "$end", "error", "$undefined", "BREAK", "CONTINUE", "FUNCTION", "ELSE", 
-  "SWITCH", "CASE", "DEFAULT", "FOR", "IN", "IF", "WHILE", "DO", "VAR", 
-  "NEW", "DELETE", "RETURN", "END", "WITH", "ASM", "EVAL", "RANDOM", 
-  "GETTIMER", "LENGTH", "CONCAT", "SUBSTR", "TRACE", "INT", "ORD", "CHR", 
-  "GETURL", "GETURL1", "NEXTFRAME", "PREVFRAME", "PLAY", "STOP", 
-  "TOGGLEQUALITY", "STOPSOUNDS", "DUP", "SWAP", "POP", "PUSH", 
-  "SETREGISTER", "CALLFUNCTION", "CALLMETHOD", "AND", "OR", "XOR", 
-  "MODULO", "ADD", "LESSTHAN", "EQUALS", "INC", "DEC", "TYPEOF", 
-  "INSTANCEOF", "ENUMERATE", "INITOBJECT", "INITARRAY", "GETMEMBER", 
-  "SETMEMBER", "SHIFTLEFT", "SHIFTRIGHT", "SHIFTRIGHT2", "VAREQUALS", 
-  "OLDADD", "SUBTRACT", "MULTIPLY", "DIVIDE", "OLDEQUALS", "OLDLESSTHAN", 
-  "LOGICALAND", "LOGICALOR", "NOT", "STRINGEQ", "STRINGLENGTH", 
-  "SUBSTRING", "GETVARIABLE", "SETVARIABLE", "SETTARGETEXPRESSION", 
-  "DUPLICATEMOVIECLIP", "REMOVEMOVIECLIP", "STRINGLESSTHAN", "MBLENGTH", 
-  "MBSUBSTRING", "MBORD", "MBCHR", "BRANCHALWAYS", "BRANCHIFTRUE", 
-  "GETURL2", "POST", "GET", "LOADVARIABLES", "LOADMOVIE", 
-  "LOADVARIABLESNUM", "LOADMOVIENUM", "CALLFRAME", "STARTDRAG", 
-  "STOPDRAG", "GOTOFRAME", "SETTARGET", "NULLVAL", "INTEGER", "DOUBLE", 
-  "BOOLEAN", "REGISTER", "STRING", "IDENTIFIER", "\"==\"", "\"<=\"", 
-  "\">=\"", "\"!=\"", "\"&&\"", "\"||\"", "\"++\"", "\"--\"", "\"+=\"", 
-  "\"/=\"", "\"*=\"", "\"-=\"", "\"%=\"", "\"&=\"", "\"|=\"", "\"<<\"", 
-  "\">>\"", "\">>>\"", "\"<<=\"", "\">>=\"", "\">>>=\"", "NOELSE", "','", 
-  "'='", "\"^=\"", "'?'", "':'", "'<'", "'>'", "'&'", "'|'", "'^'", "'+'", 
-  "'-'", "'*'", "'/'", "'%'", "'!'", "'~'", "UMINUS", "POSTFIX", "'.'", 
-  "'['", "']'", "'{'", "'}'", "';'", "'('", "')'", "$accept", "program", 
-  "@1", "code", "anycode", "stmts", "emptybraces", "stmt", "with_stmt", 
-  "return_stmt", "assign_stmts", "if_stmt", "expr_opt", "switch_init", 
-  "switch_stmt", "switch_cases", "switch_case", "identifier", 
-  "formals_list", "function_init", "function_decl", "obj_ref", 
-  "while_init", "do_init", "for_init", "for_in_init", "iter_stmt", 
-  "assign_stmts_opt", "cont_stmt", "break_stmt", "urlmethod", "level", 
-  "void_function_call", "function_call", "expr_list", 
-  "anon_function_decl", "method_call", "objexpr", "objexpr_list", 
-  "assignop", "incdecop", "lvalue_expr", "lvalue", "expr", "expr_or_obj", 
-  "primary", "init_vars", "init_var", "assign_stmt", "@2", "opcode_list", 
-  "with", "@3", "push_item", "push_list", "opcode", "@4", 0
+  "$end", "error", "$undefined", "BREAK", "CONTINUE", "FUNCTION", "ELSE",
+  "SWITCH", "CASE", "DEFAULT", "FOR", "IN", "IF", "WHILE", "DO", "VAR",
+  "NEW", "DELETE", "RETURN", "END", "WITH", "ASM", "EVAL", "RANDOM",
+  "GETTIMER", "LENGTH", "CONCAT", "SUBSTR", "TRACE", "INT", "ORD", "CHR",
+  "GETURL", "GETURL1", "NEXTFRAME", "PREVFRAME", "PLAY", "STOP",
+  "TOGGLEQUALITY", "STOPSOUNDS", "DUP", "SWAP", "POP", "PUSH",
+  "SETREGISTER", "CALLFUNCTION", "CALLMETHOD", "AND", "OR", "XOR",
+  "MODULO", "ADD", "LESSTHAN", "EQUALS", "INC", "DEC", "TYPEOF",
+  "INSTANCEOF", "ENUMERATE", "INITOBJECT", "INITARRAY", "GETMEMBER",
+  "SETMEMBER", "SHIFTLEFT", "SHIFTRIGHT", "SHIFTRIGHT2", "VAREQUALS",
+  "OLDADD", "SUBTRACT", "MULTIPLY", "DIVIDE", "OLDEQUALS", "OLDLESSTHAN",
+  "LOGICALAND", "LOGICALOR", "NOT", "STRINGEQ", "STRINGLENGTH",
+  "SUBSTRING", "GETVARIABLE", "SETVARIABLE", "SETTARGETEXPRESSION",
+  "DUPLICATEMOVIECLIP", "REMOVEMOVIECLIP", "STRINGLESSTHAN", "MBLENGTH",
+  "MBSUBSTRING", "MBORD", "MBCHR", "BRANCHALWAYS", "BRANCHIFTRUE",
+  "GETURL2", "POST", "GET", "LOADVARIABLES", "LOADMOVIE",
+  "LOADVARIABLESNUM", "LOADMOVIENUM", "CALLFRAME", "STARTDRAG", "STOPDRAG",
+  "GOTOFRAME", "SETTARGET", "NULLVAL", "INTEGER", "DOUBLE", "BOOLEAN",
+  "REGISTER", "STRING", "IDENTIFIER", "\"==\"", "\"<=\"", "\">=\"",
+  "\"!=\"", "\"&&\"", "\"||\"", "\"++\"", "\"--\"", "\"+=\"", "\"/=\"",
+  "\"*=\"", "\"-=\"", "\"%=\"", "\"&=\"", "\"|=\"", "\"<<\"", "\">>\"",
+  "\">>>\"", "\"<<=\"", "\">>=\"", "\">>>=\"", "NOELSE", "','", "'='",
+  "\"^=\"", "'?'", "':'", "'<'", "'>'", "'&'", "'|'", "'^'", "'+'", "'-'",
+  "'*'", "'/'", "'%'", "'!'", "'~'", "UMINUS", "POSTFIX", "'.'", "'['",
+  "']'", "'{'", "'}'", "';'", "'('", "')'", "$accept", "program", "@1",
+  "code", "anycode", "stmts", "emptybraces", "stmt", "with_stmt",
+  "return_stmt", "assign_stmts", "if_stmt", "expr_opt", "switch_init",
+  "switch_stmt", "switch_cases", "switch_case", "identifier",
+  "formals_list", "function_init", "function_decl", "obj_ref",
+  "while_init", "do_init", "for_init", "for_in_init", "iter_stmt",
+  "assign_stmts_opt", "cont_stmt", "break_stmt", "urlmethod", "level",
+  "void_function_call", "function_call", "expr_list", "anon_function_decl",
+  "method_call", "objexpr", "objexpr_list", "assignop", "incdecop",
+  "lvalue_expr", "lvalue", "expr", "expr_or_obj", "primary", "init_vars",
+  "init_var", "assign_stmt", "@2", "opcode_list", "with", "@3",
+  "push_item", "push_list", "opcode", "@4", 0
 };
 #endif
 
 # ifdef YYPRINT
 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
    token YYLEX-NUM.  */
-static const unsigned short yytoknum[] =
+static const yytype_uint16 yytoknum[] =
 {
        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
@@ -819,7 +955,7 @@ static const unsigned short yytoknum[] =
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-static const unsigned char yyr1[] =
+static const yytype_uint8 yyr1[] =
 {
        0,   159,   161,   160,   160,   162,   162,   163,   163,   164,
      164,   165,   166,   166,   166,   166,   166,   166,   166,   166,
@@ -859,7 +995,7 @@ static const unsigned char yyr1[] =
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-static const unsigned char yyr2[] =
+static const yytype_uint8 yyr2[] =
 {
        0,     2,     0,     2,     0,     1,     2,     1,     1,     1,
        2,     2,     1,     3,     1,     2,     1,     1,     1,     1,
@@ -901,7 +1037,7 @@ static const unsigned char yyr2[] =
 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
    means the default is an error.  */
-static const unsigned short yydefact[] =
+static const yytype_uint16 yydefact[] =
 {
        2,     0,     0,     1,     0,     0,   120,    32,     0,     0,
      127,   128,     0,    40,    41,     0,     0,     0,     0,    42,
@@ -967,8 +1103,8 @@ static const unsigned short yydefact[] =
        0,     0,     0,   139,     0,   158
 };
 
-/* YYDEFGOTO[NTERM-NUM]. */
-static const short yydefgoto[] =
+/* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int16 yydefgoto[] =
 {
       -1,     1,     2,   104,   105,   225,   106,   226,   108,   109,
      251,   110,   492,   111,   112,   562,   590,   113,   363,   181,
@@ -981,7 +1117,7 @@ static const short yydefgoto[] =
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
 #define YYPACT_NINF -496
-static const short yypact[] =
+static const yytype_int16 yypact[] =
 {
       17,    30,   908,  -496,  -136,  -123,  -496,  -496,  -126,  -105,
     -496,  -496,  4178,  -496,  4003,  1907,  -101,  -120,   -88,   -80,
@@ -1048,7 +1184,7 @@ static const short yypact[] =
 };
 
 /* YYPGOTO[NTERM-NUM].  */
-static const short yypgoto[] =
+static const yytype_int16 yypgoto[] =
 {
     -496,  -496,  -496,  -496,   162,  -495,    28,    44,  -496,  -496,
     -496,  -496,  -496,  -496,  -496,  -496,  -496,    20,   -66,     4,
@@ -1063,7 +1199,7 @@ static const short yypgoto[] =
    number is the opposite.  If zero, do what YYDEFACT says.
    If YYTABLE_NINF, syntax error.  */
 #define YYTABLE_NINF -213
-static const short yytable[] =
+static const yytype_int16 yytable[] =
 {
      122,   254,   485,   334,   587,   588,   114,   -36,   -36,   540,
      511,  -148,   162,   356,   356,   501,   123,    -4,   501,   359,
@@ -1593,7 +1729,7 @@ static const short yytable[] =
      446,   447,   448,   449
 };
 
-static const short yycheck[] =
+static const yytype_int16 yycheck[] =
 {
        2,   130,    11,   223,     8,     9,     2,     8,     9,   504,
      450,   132,    14,   132,   132,   132,     2,     0,   132,   132,
@@ -2125,7 +2261,7 @@ static const short yycheck[] =
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */
-static const unsigned char yystos[] =
+static const yytype_uint8 yystos[] =
 {
        0,   160,   161,     0,     3,     4,     5,     7,    10,    12,
       13,    14,    15,    16,    17,    18,    20,    21,    22,    23,
@@ -2191,22 +2327,6 @@ static const unsigned char yystos[] =
      202,     3,   132,   156,   202,   158
 };
 
-#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
-# define YYSIZE_T __SIZE_TYPE__
-#endif
-#if ! defined (YYSIZE_T) && defined (size_t)
-# define YYSIZE_T size_t
-#endif
-#if ! defined (YYSIZE_T)
-# if defined (__STDC__) || defined (__cplusplus)
-#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYSIZE_T size_t
-# endif
-#endif
-#if ! defined (YYSIZE_T)
-# define YYSIZE_T unsigned int
-#endif
-
 #define yyerrok                (yyerrstatus = 0)
 #define yyclearin      (yychar = YYEMPTY)
 #define YYEMPTY                (-2)
@@ -2214,7 +2334,7 @@ static const unsigned char yystos[] =
 
 #define YYACCEPT       goto yyacceptlab
 #define YYABORT                goto yyabortlab
-#define YYERROR                goto yyerrlab1
+#define YYERROR                goto yyerrorlab
 
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
@@ -2232,30 +2352,63 @@ do                                                              \
       yychar = (Token);                                                \
       yylval = (Value);                                                \
       yytoken = YYTRANSLATE (yychar);                          \
-      YYPOPSTACK;                                              \
+      YYPOPSTACK (1);                                          \
       goto yybackup;                                           \
     }                                                          \
   else                                                         \
-    {                                                          \
-      yyerror ("syntax error: cannot back up");\
+    {                                                          \
+      yyerror (YY_("syntax error: cannot back up")); \
       YYERROR;                                                 \
     }                                                          \
-while (0)
+while (YYID (0))
+
 
 #define YYTERROR       1
 #define YYERRCODE      256
 
-/* YYLLOC_DEFAULT -- Compute the default location (before the actions
-   are run).  */
 
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
 #ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)         \
-  Current.first_line   = Rhs[1].first_line;      \
-  Current.first_column = Rhs[1].first_column;    \
-  Current.last_line    = Rhs[N].last_line;       \
-  Current.last_column  = Rhs[N].last_column;
+# define YYLLOC_DEFAULT(Current, Rhs, N)                               \
+    do                                                                 \
+      if (YYID (N))                                                    \
+       {                                                               \
+         (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
+         (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
+         (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
+         (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
+       }                                                               \
+      else                                                             \
+       {                                                               \
+         (Current).first_line   = (Current).last_line   =              \
+           YYRHSLOC (Rhs, 0).last_line;                                \
+         (Current).first_column = (Current).last_column =              \
+           YYRHSLOC (Rhs, 0).last_column;                              \
+       }                                                               \
+    while (YYID (0))
 #endif
 
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+#ifndef YY_LOCATION_PRINT
+# if YYLTYPE_IS_TRIVIAL
+#  define YY_LOCATION_PRINT(File, Loc)                 \
+     fprintf (File, "%d.%d-%d.%d",                     \
+             (Loc).first_line, (Loc).first_column,     \
+             (Loc).last_line,  (Loc).last_column)
+# else
+#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
+#endif
+
+
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
 #ifdef YYLEX_PARAM
@@ -2276,42 +2429,96 @@ while (0)
 do {                                           \
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
-} while (0)
+} while (YYID (0))
 
-# define YYDSYMPRINT(Args)                     \
-do {                                           \
-  if (yydebug)                                 \
-    yysymprint Args;                           \
-} while (0)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                   \
+do {                                                                     \
+  if (yydebug)                                                           \
+    {                                                                    \
+      YYFPRINTF (stderr, "%s ", Title);                                          \
+      yy_symbol_print (stderr,                                           \
+                 Type, Value); \
+      YYFPRINTF (stderr, "\n");                                                  \
+    }                                                                    \
+} while (YYID (0))
 
-# define YYDSYMPRINTF(Title, Token, Value, Location)           \
-do {                                                           \
-  if (yydebug)                                                 \
-    {                                                          \
-      YYFPRINTF (stderr, "%s ", Title);                                \
-      yysymprint (stderr,                                      \
-                  Token, Value);       \
-      YYFPRINTF (stderr, "\n");                                        \
-    }                                                          \
-} while (0)
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+#else
+static void
+yy_symbol_value_print (yyoutput, yytype, yyvaluep)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE const * const yyvaluep;
+#endif
+{
+  if (!yyvaluep)
+    return;
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# else
+  YYUSE (yyoutput);
+# endif
+  switch (yytype)
+    {
+      default:
+       break;
+    }
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+#else
+static void
+yy_symbol_print (yyoutput, yytype, yyvaluep)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE const * const yyvaluep;
+#endif
+{
+  if (yytype < YYNTOKENS)
+    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+  else
+    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
+  YYFPRINTF (yyoutput, ")");
+}
 
 /*------------------------------------------------------------------.
 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
-| TOP (cinluded).                                                   |
+| TOP (included).                                                   |
 `------------------------------------------------------------------*/
 
-#if defined (__STDC__) || defined (__cplusplus)
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
 static void
-yy_stack_print (short *bottom, short *top)
+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
 #else
 static void
 yy_stack_print (bottom, top)
-    short *bottom;
-    short *top;
+    yytype_int16 *bottom;
+    yytype_int16 *top;
 #endif
 {
   YYFPRINTF (stderr, "Stack now");
-  for (/* Nothing. */; bottom <= top; ++bottom)
+  for (; bottom <= top; ++bottom)
     YYFPRINTF (stderr, " %d", *bottom);
   YYFPRINTF (stderr, "\n");
 }
@@ -2320,45 +2527,52 @@ yy_stack_print (bottom, top)
 do {                                                           \
   if (yydebug)                                                 \
     yy_stack_print ((Bottom), (Top));                          \
-} while (0)
+} while (YYID (0))
 
 
 /*------------------------------------------------.
 | Report that the YYRULE is going to be reduced.  |
 `------------------------------------------------*/
 
-#if defined (__STDC__) || defined (__cplusplus)
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
 static void
-yy_reduce_print (int yyrule)
+yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
 #else
 static void
-yy_reduce_print (yyrule)
+yy_reduce_print (yyvsp, yyrule)
+    YYSTYPE *yyvsp;
     int yyrule;
 #endif
 {
+  int yynrhs = yyr2[yyrule];
   int yyi;
-  unsigned int yylineno = yyrline[yyrule];
-  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
-             yyrule - 1, yylineno);
-  /* Print the symbols being reduced, and their result.  */
-  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
-    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
-  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
+  unsigned long int yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+            yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      fprintf (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
+                      &(yyvsp[(yyi + 1) - (yynrhs)])
+                                      );
+      fprintf (stderr, "\n");
+    }
 }
 
 # define YY_REDUCE_PRINT(Rule)         \
 do {                                   \
   if (yydebug)                         \
-    yy_reduce_print (Rule);            \
-} while (0)
+    yy_reduce_print (yyvsp, Rule); \
+} while (YYID (0))
 
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)
-# define YYDSYMPRINT(Args)
-# define YYDSYMPRINTF(Title, Token, Value, Location)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 # define YY_STACK_PRINT(Bottom, Top)
 # define YY_REDUCE_PRINT(Rule)
 #endif /* !YYDEBUG */
@@ -2373,13 +2587,9 @@ int yydebug;
    if the built-in stack extension method is used).
 
    Do not make this value too large; the results are undefined if
-   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
    evaluated with infinite-precision integer arithmetic.  */
 
-#if YYMAXDEPTH == 0
-# undef YYMAXDEPTH
-#endif
-
 #ifndef YYMAXDEPTH
 # define YYMAXDEPTH 10000
 #endif
@@ -2389,45 +2599,47 @@ int yydebug;
 #if YYERROR_VERBOSE
 
 # ifndef yystrlen
-#  if defined (__GLIBC__) && defined (_STRING_H)
+#  if defined __GLIBC__ && defined _STRING_H
 #   define yystrlen strlen
 #  else
 /* Return the length of YYSTR.  */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
 static YYSIZE_T
-#   if defined (__STDC__) || defined (__cplusplus)
 yystrlen (const char *yystr)
-#   else
+#else
+static YYSIZE_T
 yystrlen (yystr)
-     const char *yystr;
-#   endif
+    const char *yystr;
+#endif
 {
-  register const char *yys = yystr;
-
-  while (*yys++ != '\0')
+  YYSIZE_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)
     continue;
-
-  return yys - yystr - 1;
+  return yylen;
 }
 #  endif
 # endif
 
 # ifndef yystpcpy
-#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
 #   define yystpcpy stpcpy
 #  else
 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
    YYDEST.  */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
 static char *
-#   if defined (__STDC__) || defined (__cplusplus)
 yystpcpy (char *yydest, const char *yysrc)
-#   else
+#else
+static char *
 yystpcpy (yydest, yysrc)
-     char *yydest;
-     const char *yysrc;
-#   endif
+    char *yydest;
+    const char *yysrc;
+#endif
 {
-  register char *yyd = yydest;
-  register const char *yys = yysrc;
+  char *yyd = yydest;
+  const char *yys = yysrc;
 
   while ((*yyd++ = *yys++) != '\0')
     continue;
@@ -2437,70 +2649,192 @@ yystpcpy (yydest, yysrc)
 #  endif
 # endif
 
-#endif /* !YYERROR_VERBOSE */
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYSIZE_T yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+       switch (*++yyp)
+         {
+         case '\'':
+         case ',':
+           goto do_not_strip_quotes;
+
+         case '\\':
+           if (*++yyp != '\\')
+             goto do_not_strip_quotes;
+           /* Fall through.  */
+         default:
+           if (yyres)
+             yyres[yyn] = *yyp;
+           yyn++;
+           break;
+
+         case '"':
+           if (yyres)
+             yyres[yyn] = '\0';
+           return yyn;
+         }
+    do_not_strip_quotes: ;
+    }
 
-\f
+  if (! yyres)
+    return yystrlen (yystr);
 
-#if YYDEBUG
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
 
-#if defined (__STDC__) || defined (__cplusplus)
-static void
-yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
-#else
-static void
-yysymprint (yyoutput, yytype, yyvaluep)
-    FILE *yyoutput;
-    int yytype;
-    YYSTYPE *yyvaluep;
-#endif
+/* Copy into YYRESULT an error message about the unexpected token
+   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
+   including the terminating null byte.  If YYRESULT is null, do not
+   copy anything; just return the number of bytes that would be
+   copied.  As a special case, return 0 if an ordinary "syntax error"
+   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
+   size calculation.  */
+static YYSIZE_T
+yysyntax_error (char *yyresult, int yystate, int yychar)
 {
-  /* Pacify ``unused variable'' warnings.  */
-  (void) yyvaluep;
+  int yyn = yypact[yystate];
 
-  if (yytype < YYNTOKENS)
-    {
-      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
-# ifdef YYPRINT
-      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
-# endif
-    }
+  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
+    return 0;
   else
-    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
-
-  switch (yytype)
     {
-      default:
-        break;
+      int yytype = YYTRANSLATE (yychar);
+      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+      YYSIZE_T yysize = yysize0;
+      YYSIZE_T yysize1;
+      int yysize_overflow = 0;
+      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+      int yyx;
+
+# if 0
+      /* This is so xgettext sees the translatable formats that are
+        constructed on the fly.  */
+      YY_("syntax error, unexpected %s");
+      YY_("syntax error, unexpected %s, expecting %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
+# endif
+      char *yyfmt;
+      char const *yyf;
+      static char const yyunexpected[] = "syntax error, unexpected %s";
+      static char const yyexpecting[] = ", expecting %s";
+      static char const yyor[] = " or %s";
+      char yyformat[sizeof yyunexpected
+                   + sizeof yyexpecting - 1
+                   + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+                      * (sizeof yyor - 1))];
+      char const *yyprefix = yyexpecting;
+
+      /* Start YYX at -YYN if negative to avoid negative indexes in
+        YYCHECK.  */
+      int yyxbegin = yyn < 0 ? -yyn : 0;
+
+      /* Stay within bounds of both yycheck and yytname.  */
+      int yychecklim = YYLAST - yyn + 1;
+      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+      int yycount = 1;
+
+      yyarg[0] = yytname[yytype];
+      yyfmt = yystpcpy (yyformat, yyunexpected);
+
+      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+       if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+         {
+           if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+             {
+               yycount = 1;
+               yysize = yysize0;
+               yyformat[sizeof yyunexpected - 1] = '\0';
+               break;
+             }
+           yyarg[yycount++] = yytname[yyx];
+           yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+           yysize_overflow |= (yysize1 < yysize);
+           yysize = yysize1;
+           yyfmt = yystpcpy (yyfmt, yyprefix);
+           yyprefix = yyor;
+         }
+
+      yyf = YY_(yyformat);
+      yysize1 = yysize + yystrlen (yyf);
+      yysize_overflow |= (yysize1 < yysize);
+      yysize = yysize1;
+
+      if (yysize_overflow)
+       return YYSIZE_MAXIMUM;
+
+      if (yyresult)
+       {
+         /* Avoid sprintf, as that infringes on the user's name space.
+            Don't have undefined behavior even if the translation
+            produced a string with the wrong number of "%s"s.  */
+         char *yyp = yyresult;
+         int yyi = 0;
+         while ((*yyp = *yyf) != '\0')
+           {
+             if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+               {
+                 yyp += yytnamerr (yyp, yyarg[yyi++]);
+                 yyf += 2;
+               }
+             else
+               {
+                 yyp++;
+                 yyf++;
+               }
+           }
+       }
+      return yysize;
     }
-  YYFPRINTF (yyoutput, ")");
 }
+#endif /* YYERROR_VERBOSE */
+\f
 
-#endif /* ! YYDEBUG */
 /*-----------------------------------------------.
 | Release the memory associated to this symbol.  |
 `-----------------------------------------------*/
 
-#if defined (__STDC__) || defined (__cplusplus)
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
 static void
-yydestruct (int yytype, YYSTYPE *yyvaluep)
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
 #else
 static void
-yydestruct (yytype, yyvaluep)
+yydestruct (yymsg, yytype, yyvaluep)
+    const char *yymsg;
     int yytype;
     YYSTYPE *yyvaluep;
 #endif
 {
-  /* Pacify ``unused variable'' warnings.  */
-  (void) yyvaluep;
+  YYUSE (yyvaluep);
+
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 
   switch (yytype)
     {
 
       default:
-        break;
+       break;
     }
 }
 \f
@@ -2508,13 +2842,13 @@ yydestruct (yytype, yyvaluep)
 /* Prevent warnings from -Wmissing-prototypes.  */
 
 #ifdef YYPARSE_PARAM
-# if defined (__STDC__) || defined (__cplusplus)
+#if defined __STDC__ || defined __cplusplus
 int yyparse (void *YYPARSE_PARAM);
-# else
+#else
 int yyparse ();
-# endif
+#endif
 #else /* ! YYPARSE_PARAM */
-#if defined (__STDC__) || defined (__cplusplus)
+#if defined __STDC__ || defined __cplusplus
 int yyparse (void);
 #else
 int yyparse ();
@@ -2523,10 +2857,10 @@ int yyparse ();
 
 
 
-/* The lookahead symbol.  */
+/* The look-ahead symbol.  */
 int yychar;
 
-/* The semantic value of the lookahead symbol.  */
+/* The semantic value of the look-ahead symbol.  */
 YYSTYPE yylval;
 
 /* Number of syntax errors so far.  */
@@ -2539,14 +2873,18 @@ int yynerrs;
 `----------*/
 
 #ifdef YYPARSE_PARAM
-# if defined (__STDC__) || defined (__cplusplus)
-int yyparse (void *YYPARSE_PARAM)
-# else
-int yyparse (YYPARSE_PARAM)
-  void *YYPARSE_PARAM;
-# endif
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (void *YYPARSE_PARAM)
+#else
+int
+yyparse (YYPARSE_PARAM)
+    void *YYPARSE_PARAM;
+#endif
 #else /* ! YYPARSE_PARAM */
-#if defined (__STDC__) || defined (__cplusplus)
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
 int
 yyparse (void)
 #else
@@ -2557,13 +2895,19 @@ yyparse ()
 #endif
 {
   
-  register int yystate;
-  register int yyn;
+  int yystate;
+  int yyn;
   int yyresult;
   /* Number of tokens to shift before error messages enabled.  */
   int yyerrstatus;
-  /* Lookahead token as an internal (translated) token number.  */
+  /* Look-ahead token as an internal (translated) token number.  */
   int yytoken = 0;
+#if YYERROR_VERBOSE
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
 
   /* Three stacks and their tools:
      `yyss': related to states,
@@ -2574,18 +2918,18 @@ yyparse ()
      to reallocate them elsewhere.  */
 
   /* The state stack.  */
-  short        yyssa[YYINITDEPTH];
-  short *yyss = yyssa;
-  register short *yyssp;
+  yytype_int16 yyssa[YYINITDEPTH];
+  yytype_int16 *yyss = yyssa;
+  yytype_int16 *yyssp;
 
   /* The semantic value stack.  */
   YYSTYPE yyvsa[YYINITDEPTH];
   YYSTYPE *yyvs = yyvsa;
-  register YYSTYPE *yyvsp;
+  YYSTYPE *yyvsp;
 
 
 
-#define YYPOPSTACK   (yyvsp--, yyssp--)
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
 
   YYSIZE_T yystacksize = YYINITDEPTH;
 
@@ -2594,9 +2938,9 @@ yyparse ()
   YYSTYPE yyval;
 
 
-  /* When reducing, the number of symbols on the RHS of the reduced
-     rule.  */
-  int yylen;
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
 
   YYDPRINTF ((stderr, "Starting parse\n"));
 
@@ -2620,8 +2964,7 @@ yyparse ()
 `------------------------------------------------------------*/
  yynewstate:
   /* In all cases, when you get here, the value and location stacks
-     have just been pushed. so pushing a state here evens the stacks.
-     */
+     have just been pushed.  So pushing a state here evens the stacks.  */
   yyssp++;
 
  yysetstate:
@@ -2634,18 +2977,18 @@ yyparse ()
 
 #ifdef yyoverflow
       {
-       /* Give user a chance to reallocate the stack. Use copies of
+       /* Give user a chance to reallocate the stack.  Use copies of
           these so that the &'s don't force the real ones into
           memory.  */
        YYSTYPE *yyvs1 = yyvs;
-       short *yyss1 = yyss;
+       yytype_int16 *yyss1 = yyss;
 
 
        /* Each stack pointer address is followed by the size of the
           data in use in that stack, in bytes.  This used to be a
           conditional around just the two extra args, but that might
           be undefined if yyoverflow is a macro.  */
-       yyoverflow ("parser stack overflow",
+       yyoverflow (YY_("memory exhausted"),
                    &yyss1, yysize * sizeof (*yyssp),
                    &yyvs1, yysize * sizeof (*yyvsp),
 
@@ -2656,21 +2999,21 @@ yyparse ()
       }
 #else /* no yyoverflow */
 # ifndef YYSTACK_RELOCATE
-      goto yyoverflowlab;
+      goto yyexhaustedlab;
 # else
       /* Extend the stack our own way.  */
       if (YYMAXDEPTH <= yystacksize)
-       goto yyoverflowlab;
+       goto yyexhaustedlab;
       yystacksize *= 2;
       if (YYMAXDEPTH < yystacksize)
        yystacksize = YYMAXDEPTH;
 
       {
-       short *yyss1 = yyss;
+       yytype_int16 *yyss1 = yyss;
        union yyalloc *yyptr =
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
        if (! yyptr)
-         goto yyoverflowlab;
+         goto yyexhaustedlab;
        YYSTACK_RELOCATE (yyss);
        YYSTACK_RELOCATE (yyvs);
 
@@ -2701,19 +3044,17 @@ yyparse ()
 `-----------*/
 yybackup:
 
-/* Do appropriate processing given the current state.  */
-/* Read a lookahead token if we need one and don't already have one.  */
-/* yyresume: */
-
-  /* First try to decide what to do without reference to lookahead token.  */
+  /* Do appropriate processing given the current state.  Read a
+     look-ahead token if we need one and don't already have one.  */
 
+  /* First try to decide what to do without reference to look-ahead token.  */
   yyn = yypact[yystate];
   if (yyn == YYPACT_NINF)
     goto yydefault;
 
-  /* Not known => get a lookahead token if don't already have one.  */
+  /* Not known => get a look-ahead token if don't already have one.  */
 
-  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
   if (yychar == YYEMPTY)
     {
       YYDPRINTF ((stderr, "Reading a token: "));
@@ -2728,7 +3069,7 @@ yybackup:
   else
     {
       yytoken = YYTRANSLATE (yychar);
-      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
     }
 
   /* If the proper action on seeing token YYTOKEN is to reduce or to
@@ -2748,22 +3089,21 @@ yybackup:
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  /* Shift the lookahead token.  */
-  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
-
-  /* Discard the token being shifted unless it is eof.  */
-  if (yychar != YYEOF)
-    yychar = YYEMPTY;
-
-  *++yyvsp = yylval;
-
-
   /* Count tokens shifted since error; after three, turn off error
      status.  */
   if (yyerrstatus)
     yyerrstatus--;
 
+  /* Shift the look-ahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+  /* Discard the shifted token unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
+
   yystate = yyn;
+  *++yyvsp = yylval;
+
   goto yynewstate;
 
 
@@ -2821,23 +3161,23 @@ yyreduce:
 
   case 7:
 #line 170 "swf5compiler.y"
-    { bufferConcat(bc, yyvsp[0].action); ;}
+    { bufferConcat(bc, (yyvsp[(1) - (1)].action)); ;}
     break;
 
   case 8:
 #line 172 "swf5compiler.y"
-    { bufferConcat(bf, yyvsp[0].action); ;}
+    { bufferConcat(bf, (yyvsp[(1) - (1)].action)); ;}
     break;
 
   case 9:
 #line 177 "swf5compiler.y"
-    { yyval.action = yyvsp[0].action; ;}
+    { (yyval.action) = (yyvsp[(1) - (1)].action); ;}
     break;
 
   case 10:
 #line 180 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action;
-                 bufferConcat(yyval.action, yyvsp[0].action); ;}
+    { (yyval.action) = (yyvsp[(1) - (2)].action);
+                 bufferConcat((yyval.action), (yyvsp[(2) - (2)].action)); ;}
     break;
 
   case 11:
@@ -2847,31 +3187,31 @@ yyreduce:
 
   case 12:
 #line 189 "swf5compiler.y"
-    { yyval.action = NULL; ;}
+    { (yyval.action) = NULL; ;}
     break;
 
   case 13:
 #line 190 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action; ;}
+    { (yyval.action) = (yyvsp[(2) - (3)].action); ;}
     break;
 
   case 14:
 #line 191 "swf5compiler.y"
-    { yyval.action = NULL; ;}
+    { (yyval.action) = NULL; ;}
     break;
 
   case 15:
 #line 192 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action; ;}
+    { (yyval.action) = (yyvsp[(1) - (2)].action); ;}
     break;
 
   case 23:
 #line 204 "swf5compiler.y"
-    { yyval.action = yyvsp[-4].action;
-                 bufferWriteOp(yyval.action, SWFACTION_WITH);
-                 bufferWriteS16(yyval.action, 2);
-                 bufferWriteS16(yyval.action, bufferLength(yyvsp[-1].action));
-                 bufferConcat(yyval.action, yyvsp[-1].action); ;}
+    { (yyval.action) = (yyvsp[(3) - (7)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_WITH);
+                 bufferWriteS16((yyval.action), 2);
+                 bufferWriteS16((yyval.action), bufferLength((yyvsp[(6) - (7)].action)));
+                 bufferConcat((yyval.action), (yyvsp[(6) - (7)].action)); ;}
     break;
 
   case 24:
@@ -2879,11 +3219,11 @@ yyreduce:
     { int tmp = chkctx(CTX_FUNCTION);
                  if(tmp < 0)
                        swf5error("return outside function");
-                 yyval.action = newBuffer();
+                 (yyval.action) = newBuffer();
                  while(--tmp >= 0)
-                       bufferWriteOp(yyval.action, SWFACTION_POP);
-                 bufferWriteNull(yyval.action);
-                 bufferWriteOp(yyval.action, SWFACTION_RETURN); ;}
+                       bufferWriteOp((yyval.action), SWFACTION_POP);
+                 bufferWriteNull((yyval.action));
+                 bufferWriteOp((yyval.action), SWFACTION_RETURN); ;}
     break;
 
   case 25:
@@ -2891,49 +3231,49 @@ yyreduce:
     { int tmp = chkctx(CTX_FUNCTION);
                  if(tmp < 0)
                        swf5error("return outside function");
-                 yyval.action = newBuffer();
+                 (yyval.action) = newBuffer();
                  while(--tmp >= 0)
-                       bufferWriteOp(yyval.action, SWFACTION_POP);
-                 bufferConcat(yyval.action, yyvsp[-1].action);
-                 bufferWriteOp(yyval.action, SWFACTION_RETURN); ;}
+                       bufferWriteOp((yyval.action), SWFACTION_POP);
+                 bufferConcat((yyval.action), (yyvsp[(2) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_RETURN); ;}
     break;
 
   case 27:
 #line 237 "swf5compiler.y"
-    { bufferConcat(yyvsp[-2].action, yyvsp[0].action); ;}
+    { bufferConcat((yyvsp[(1) - (3)].action), (yyvsp[(3) - (3)].action)); ;}
     break;
 
   case 28:
 #line 242 "swf5compiler.y"
-    { yyval.action = yyvsp[-4].action;
-                 bufferWriteOp(yyval.action, SWFACTION_BRANCHIFTRUE);
-                 bufferWriteS16(yyval.action, 2);
-                 bufferWriteS16(yyval.action, bufferLength(yyvsp[0].action)+5);
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_BRANCHALWAYS);
-                 bufferWriteS16(yyval.action, 2);
-                 bufferWriteS16(yyval.action, bufferLength(yyvsp[-2].action));
-                 bufferConcat(yyval.action, yyvsp[-2].action); ;}
+    { (yyval.action) = (yyvsp[(3) - (7)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_BRANCHIFTRUE);
+                 bufferWriteS16((yyval.action), 2);
+                 bufferWriteS16((yyval.action), bufferLength((yyvsp[(7) - (7)].action))+5);
+                 bufferConcat((yyval.action), (yyvsp[(7) - (7)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_BRANCHALWAYS);
+                 bufferWriteS16((yyval.action), 2);
+                 bufferWriteS16((yyval.action), bufferLength((yyvsp[(5) - (7)].action)));
+                 bufferConcat((yyval.action), (yyvsp[(5) - (7)].action)); ;}
     break;
 
   case 29:
 #line 253 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferWriteOp(yyval.action, SWFACTION_LOGICALNOT);
-                 bufferWriteOp(yyval.action, SWFACTION_BRANCHIFTRUE);
-                 bufferWriteS16(yyval.action, 2);
-                 bufferWriteS16(yyval.action, bufferLength(yyvsp[0].action));
-                 bufferConcat(yyval.action, yyvsp[0].action); ;}
+    { (yyval.action) = (yyvsp[(3) - (5)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_LOGICALNOT);
+                 bufferWriteOp((yyval.action), SWFACTION_BRANCHIFTRUE);
+                 bufferWriteS16((yyval.action), 2);
+                 bufferWriteS16((yyval.action), bufferLength((yyvsp[(5) - (5)].action)));
+                 bufferConcat((yyval.action), (yyvsp[(5) - (5)].action)); ;}
     break;
 
   case 30:
 #line 262 "swf5compiler.y"
-    { yyval.action = NULL; ;}
+    { (yyval.action) = NULL; ;}
     break;
 
   case 31:
 #line 263 "swf5compiler.y"
-    { yyval.action = yyvsp[0].action; ;}
+    { (yyval.action) = (yyvsp[(1) - (1)].action); ;}
     break;
 
   case 32:
@@ -2943,10 +3283,10 @@ yyreduce:
 
   case 33:
 #line 274 "swf5compiler.y"
-    { yyval.action = yyvsp[-4].action;
-                 bufferResolveSwitch(yyval.action, &yyvsp[-1].switchcases);
-                 bufferResolveJumps(yyval.action);
-                 bufferWriteOp(yyval.action, SWFACTION_POP);
+    { (yyval.action) = (yyvsp[(3) - (7)].action);
+                 bufferResolveSwitch((yyval.action), &(yyvsp[(6) - (7)].switchcases));
+                 bufferResolveJumps((yyval.action));
+                 bufferWriteOp((yyval.action), SWFACTION_POP);
                  delctx(CTX_SWITCH);
  /* FIXME: continue in switch continues surrounding loop, if any */
        ;}
@@ -2954,442 +3294,442 @@ yyreduce:
 
   case 34:
 #line 286 "swf5compiler.y"
-    { yyval.switchcases.count = 0;
-                 yyval.switchcases.list = 0; ;}
+    { (yyval.switchcases).count = 0;
+                 (yyval.switchcases).list = 0; ;}
     break;
 
   case 35:
 #line 290 "swf5compiler.y"
-    { yyval.switchcases = yyvsp[-1].switchcases;
-                 yyval.switchcases.list = (struct switchcase*) realloc(yyval.switchcases.list, (yyval.switchcases.count+1) * sizeof(struct switchcase));
-                 yyval.switchcases.list[yyval.switchcases.count] = yyvsp[0].switchcase;
-                 yyval.switchcases.count++; ;}
+    { (yyval.switchcases) = (yyvsp[(1) - (2)].switchcases);
+                 (yyval.switchcases).list = (struct switchcase*) realloc((yyval.switchcases).list, ((yyval.switchcases).count+1) * sizeof(struct switchcase));
+                 (yyval.switchcases).list[(yyval.switchcases).count] = (yyvsp[(2) - (2)].switchcase);
+                 (yyval.switchcases).count++; ;}
     break;
 
   case 36:
 #line 298 "swf5compiler.y"
-    { yyval.switchcase.cond = yyvsp[-4].action;
-                 yyval.switchcase.action = yyvsp[-2].action;
-                 yyval.switchcase.isbreak = 1; ;}
+    { (yyval.switchcase).cond = (yyvsp[(2) - (6)].action);
+                 (yyval.switchcase).action = (yyvsp[(4) - (6)].action);
+                 (yyval.switchcase).isbreak = 1; ;}
     break;
 
   case 37:
 #line 303 "swf5compiler.y"
-    { yyval.switchcase.cond = yyvsp[-2].action;
-                 yyval.switchcase.action = yyvsp[0].action;
-                 yyval.switchcase.isbreak = 0; ;}
+    { (yyval.switchcase).cond = (yyvsp[(2) - (4)].action);
+                 (yyval.switchcase).action = (yyvsp[(4) - (4)].action);
+                 (yyval.switchcase).isbreak = 0; ;}
     break;
 
   case 38:
 #line 308 "swf5compiler.y"
-    { yyval.switchcase.cond = NULL;
-                 yyval.switchcase.action = yyvsp[0].action;
-                 yyval.switchcase.isbreak = 0; ;}
+    { (yyval.switchcase).cond = NULL;
+                 (yyval.switchcase).action = (yyvsp[(3) - (3)].action);
+                 (yyval.switchcase).isbreak = 0; ;}
     break;
 
   case 40:
 #line 318 "swf5compiler.y"
-    { yyval.str = strdup("new"); ;}
+    { (yyval.str) = strdup("new"); ;}
     break;
 
   case 41:
 #line 319 "swf5compiler.y"
-    { yyval.str = strdup("delete"); ;}
+    { (yyval.str) = strdup("delete"); ;}
     break;
 
   case 42:
 #line 320 "swf5compiler.y"
-    { yyval.str = strdup("random"); ;}
+    { (yyval.str) = strdup("random"); ;}
     break;
 
   case 43:
 #line 321 "swf5compiler.y"
-    { yyval.str = strdup("getTimer"); ;}
+    { (yyval.str) = strdup("getTimer"); ;}
     break;
 
   case 44:
 #line 322 "swf5compiler.y"
-    { yyval.str = strdup("length"); ;}
+    { (yyval.str) = strdup("length"); ;}
     break;
 
   case 45:
 #line 323 "swf5compiler.y"
-    { yyval.str = strdup("concat"); ;}
+    { (yyval.str) = strdup("concat"); ;}
     break;
 
   case 46:
 #line 324 "swf5compiler.y"
-    { yyval.str = strdup("substr"); ;}
+    { (yyval.str) = strdup("substr"); ;}
     break;
 
   case 47:
 #line 325 "swf5compiler.y"
-    { yyval.str = strdup("trace"); ;}
+    { (yyval.str) = strdup("trace"); ;}
     break;
 
   case 48:
 #line 326 "swf5compiler.y"
-    { yyval.str = strdup("int"); ;}
+    { (yyval.str) = strdup("int"); ;}
     break;
 
   case 49:
 #line 327 "swf5compiler.y"
-    { yyval.str = strdup("ord"); ;}
+    { (yyval.str) = strdup("ord"); ;}
     break;
 
   case 50:
 #line 328 "swf5compiler.y"
-    { yyval.str = strdup("chr"); ;}
+    { (yyval.str) = strdup("chr"); ;}
     break;
 
   case 51:
 #line 329 "swf5compiler.y"
-    { yyval.str = strdup("getURL"); ;}
+    { (yyval.str) = strdup("getURL"); ;}
     break;
 
   case 52:
 #line 330 "swf5compiler.y"
-    { yyval.str = strdup("getURL1"); ;}
+    { (yyval.str) = strdup("getURL1"); ;}
     break;
 
   case 53:
 #line 331 "swf5compiler.y"
-    { yyval.str = strdup("nextFrame"); ;}
+    { (yyval.str) = strdup("nextFrame"); ;}
     break;
 
   case 54:
 #line 332 "swf5compiler.y"
-    { yyval.str = strdup("prevFrame"); ;}
+    { (yyval.str) = strdup("prevFrame"); ;}
     break;
 
   case 55:
 #line 333 "swf5compiler.y"
-    { yyval.str = strdup("play"); ;}
+    { (yyval.str) = strdup("play"); ;}
     break;
 
   case 56:
 #line 334 "swf5compiler.y"
-    { yyval.str = strdup("stop"); ;}
+    { (yyval.str) = strdup("stop"); ;}
     break;
 
   case 57:
 #line 335 "swf5compiler.y"
-    { yyval.str = strdup("toggleQuality"); ;}
+    { (yyval.str) = strdup("toggleQuality"); ;}
     break;
 
   case 58:
 #line 336 "swf5compiler.y"
-    { yyval.str = strdup("stopSounds"); ;}
+    { (yyval.str) = strdup("stopSounds"); ;}
     break;
 
   case 59:
 #line 337 "swf5compiler.y"
-    { yyval.str = strdup("dup"); ;}
+    { (yyval.str) = strdup("dup"); ;}
     break;
 
   case 60:
 #line 338 "swf5compiler.y"
-    { yyval.str = strdup("swap"); ;}
+    { (yyval.str) = strdup("swap"); ;}
     break;
 
   case 61:
 #line 339 "swf5compiler.y"
-    { yyval.str = strdup("pop"); ;}
+    { (yyval.str) = strdup("pop"); ;}
     break;
 
   case 62:
 #line 340 "swf5compiler.y"
-    { yyval.str = strdup("push"); ;}
+    { (yyval.str) = strdup("push"); ;}
     break;
 
   case 63:
 #line 341 "swf5compiler.y"
-    { yyval.str = strdup("setRegister"); ;}
+    { (yyval.str) = strdup("setRegister"); ;}
     break;
 
   case 64:
 #line 342 "swf5compiler.y"
-    { yyval.str = strdup("callFunction"); ;}
+    { (yyval.str) = strdup("callFunction"); ;}
     break;
 
   case 65:
 #line 343 "swf5compiler.y"
-    { yyval.str = strdup("callMethod"); ;}
+    { (yyval.str) = strdup("callMethod"); ;}
     break;
 
   case 66:
 #line 344 "swf5compiler.y"
-    { yyval.str = strdup("and"); ;}
+    { (yyval.str) = strdup("and"); ;}
     break;
 
   case 67:
 #line 345 "swf5compiler.y"
-    { yyval.str = strdup("or"); ;}
+    { (yyval.str) = strdup("or"); ;}
     break;
 
   case 68:
 #line 346 "swf5compiler.y"
-    { yyval.str = strdup("xor"); ;}
+    { (yyval.str) = strdup("xor"); ;}
     break;
 
   case 69:
 #line 347 "swf5compiler.y"
-    { yyval.str = strdup("modulo"); ;}
+    { (yyval.str) = strdup("modulo"); ;}
     break;
 
   case 70:
 #line 348 "swf5compiler.y"
-    { yyval.str = strdup("add"); ;}
+    { (yyval.str) = strdup("add"); ;}
     break;
 
   case 71:
 #line 349 "swf5compiler.y"
-    { yyval.str = strdup("lessThan"); ;}
+    { (yyval.str) = strdup("lessThan"); ;}
     break;
 
   case 72:
 #line 350 "swf5compiler.y"
-    { yyval.str = strdup("equals"); ;}
+    { (yyval.str) = strdup("equals"); ;}
     break;
 
   case 73:
 #line 351 "swf5compiler.y"
-    { yyval.str = strdup("inc"); ;}
+    { (yyval.str) = strdup("inc"); ;}
     break;
 
   case 74:
 #line 352 "swf5compiler.y"
-    { yyval.str = strdup("dec"); ;}
+    { (yyval.str) = strdup("dec"); ;}
     break;
 
   case 75:
 #line 353 "swf5compiler.y"
-    { yyval.str = strdup("typeof"); ;}
+    { (yyval.str) = strdup("typeof"); ;}
     break;
 
   case 76:
 #line 354 "swf5compiler.y"
-    { yyval.str = strdup("instanceof"); ;}
+    { (yyval.str) = strdup("instanceof"); ;}
     break;
 
   case 77:
 #line 355 "swf5compiler.y"
-    { yyval.str = strdup("enumerate"); ;}
+    { (yyval.str) = strdup("enumerate"); ;}
     break;
 
   case 78:
 #line 356 "swf5compiler.y"
-    { yyval.str = strdup("initobject"); ;}
+    { (yyval.str) = strdup("initobject"); ;}
     break;
 
   case 79:
 #line 357 "swf5compiler.y"
-    { yyval.str = strdup("initarray"); ;}
+    { (yyval.str) = strdup("initarray"); ;}
     break;
 
   case 80:
 #line 358 "swf5compiler.y"
-    { yyval.str = strdup("getmember"); ;}
+    { (yyval.str) = strdup("getmember"); ;}
     break;
 
   case 81:
 #line 359 "swf5compiler.y"
-    { yyval.str = strdup("setmember"); ;}
+    { (yyval.str) = strdup("setmember"); ;}
     break;
 
   case 82:
 #line 360 "swf5compiler.y"
-    { yyval.str = strdup("shiftleft"); ;}
+    { (yyval.str) = strdup("shiftleft"); ;}
     break;
 
   case 83:
 #line 361 "swf5compiler.y"
-    { yyval.str = strdup("shiftright"); ;}
+    { (yyval.str) = strdup("shiftright"); ;}
     break;
 
   case 84:
 #line 362 "swf5compiler.y"
-    { yyval.str = strdup("shiftright2"); ;}
+    { (yyval.str) = strdup("shiftright2"); ;}
     break;
 
   case 85:
 #line 363 "swf5compiler.y"
-    { yyval.str = strdup("varequals"); ;}
+    { (yyval.str) = strdup("varequals"); ;}
     break;
 
   case 86:
 #line 364 "swf5compiler.y"
-    { yyval.str = strdup("oldAdd"); ;}
+    { (yyval.str) = strdup("oldAdd"); ;}
     break;
 
   case 87:
 #line 365 "swf5compiler.y"
-    { yyval.str = strdup("subtract"); ;}
+    { (yyval.str) = strdup("subtract"); ;}
     break;
 
   case 88:
 #line 366 "swf5compiler.y"
-    { yyval.str = strdup("multiply"); ;}
+    { (yyval.str) = strdup("multiply"); ;}
     break;
 
   case 89:
 #line 367 "swf5compiler.y"
-    { yyval.str = strdup("divide"); ;}
+    { (yyval.str) = strdup("divide"); ;}
     break;
 
   case 90:
 #line 368 "swf5compiler.y"
-    { yyval.str = strdup("oldequals"); ;}
+    { (yyval.str) = strdup("oldequals"); ;}
     break;
 
   case 91:
 #line 369 "swf5compiler.y"
-    { yyval.str = strdup("oldlessthan"); ;}
+    { (yyval.str) = strdup("oldlessthan"); ;}
     break;
 
   case 92:
 #line 370 "swf5compiler.y"
-    { yyval.str = strdup("logicaland"); ;}
+    { (yyval.str) = strdup("logicaland"); ;}
     break;
 
   case 93:
 #line 371 "swf5compiler.y"
-    { yyval.str = strdup("logicalor"); ;}
+    { (yyval.str) = strdup("logicalor"); ;}
     break;
 
   case 94:
 #line 372 "swf5compiler.y"
-    { yyval.str = strdup("not"); ;}
+    { (yyval.str) = strdup("not"); ;}
     break;
 
   case 95:
 #line 373 "swf5compiler.y"
-    { yyval.str = strdup("stringeq"); ;}
+    { (yyval.str) = strdup("stringeq"); ;}
     break;
 
   case 96:
 #line 374 "swf5compiler.y"
-    { yyval.str = strdup("stringlength"); ;}
+    { (yyval.str) = strdup("stringlength"); ;}
     break;
 
   case 97:
 #line 375 "swf5compiler.y"
-    { yyval.str = strdup("substring"); ;}
+    { (yyval.str) = strdup("substring"); ;}
     break;
 
   case 98:
 #line 376 "swf5compiler.y"
-    { yyval.str = strdup("getvariable"); ;}
+    { (yyval.str) = strdup("getvariable"); ;}
     break;
 
   case 99:
 #line 377 "swf5compiler.y"
-    { yyval.str = strdup("setvariable"); ;}
+    { (yyval.str) = strdup("setvariable"); ;}
     break;
 
   case 100:
 #line 378 "swf5compiler.y"
-    { yyval.str = strdup("settargetexpression"); ;}
+    { (yyval.str) = strdup("settargetexpression"); ;}
     break;
 
   case 101:
 #line 379 "swf5compiler.y"
-    { yyval.str = strdup("duplicatemovieclip"); ;}
+    { (yyval.str) = strdup("duplicatemovieclip"); ;}
     break;
 
   case 102:
 #line 380 "swf5compiler.y"
-    { yyval.str = strdup("removemovieclip"); ;}
+    { (yyval.str) = strdup("removemovieclip"); ;}
     break;
 
   case 103:
 #line 381 "swf5compiler.y"
-    { yyval.str = strdup("startdrag"); ;}
+    { (yyval.str) = strdup("startdrag"); ;}
     break;
 
   case 104:
 #line 382 "swf5compiler.y"
-    { yyval.str = strdup("stopdrag"); ;}
+    { (yyval.str) = strdup("stopdrag"); ;}
     break;
 
   case 105:
 #line 383 "swf5compiler.y"
-    { yyval.str = strdup("stringlessthan"); ;}
+    { (yyval.str) = strdup("stringlessthan"); ;}
     break;
 
   case 106:
 #line 384 "swf5compiler.y"
-    { yyval.str = strdup("mblength"); ;}
+    { (yyval.str) = strdup("mblength"); ;}
     break;
 
   case 107:
 #line 385 "swf5compiler.y"
-    { yyval.str = strdup("mbsubstring"); ;}
+    { (yyval.str) = strdup("mbsubstring"); ;}
     break;
 
   case 108:
 #line 386 "swf5compiler.y"
-    { yyval.str = strdup("mbord"); ;}
+    { (yyval.str) = strdup("mbord"); ;}
     break;
 
   case 109:
 #line 387 "swf5compiler.y"
-    { yyval.str = strdup("mbchr"); ;}
+    { (yyval.str) = strdup("mbchr"); ;}
     break;
 
   case 110:
 #line 388 "swf5compiler.y"
-    { yyval.str = strdup("branchalways"); ;}
+    { (yyval.str) = strdup("branchalways"); ;}
     break;
 
   case 111:
 #line 389 "swf5compiler.y"
-    { yyval.str = strdup("branchiftrue"); ;}
+    { (yyval.str) = strdup("branchiftrue"); ;}
     break;
 
   case 112:
 #line 390 "swf5compiler.y"
-    { yyval.str = strdup("getURL2"); ;}
+    { (yyval.str) = strdup("getURL2"); ;}
     break;
 
   case 113:
 #line 391 "swf5compiler.y"
-    { yyval.str = strdup("post"); ;}
+    { (yyval.str) = strdup("post"); ;}
     break;
 
   case 114:
 #line 392 "swf5compiler.y"
-    { yyval.str = strdup("get"); ;}
+    { (yyval.str) = strdup("get"); ;}
     break;
 
   case 115:
 #line 393 "swf5compiler.y"
-    { yyval.str = strdup("loadvariables"); ;}
+    { (yyval.str) = strdup("loadvariables"); ;}
     break;
 
   case 116:
 #line 394 "swf5compiler.y"
-    { yyval.str = strdup("loadMovie"); ;}
+    { (yyval.str) = strdup("loadMovie"); ;}
     break;
 
   case 117:
 #line 399 "swf5compiler.y"
-    { yyval.exprlist.buffer = newBuffer();
-                 yyval.exprlist.count = 0; ;}
+    { (yyval.exprlist).buffer = newBuffer();
+                 (yyval.exprlist).count = 0; ;}
     break;
 
   case 118:
 #line 403 "swf5compiler.y"
-    { yyval.exprlist.buffer = newBuffer();
-                 bufferWriteHardString(yyval.exprlist.buffer, (byte*)yyvsp[0].str, strlen(yyvsp[0].str)+1);
-                 yyval.exprlist.count = 1; ;}
+    { (yyval.exprlist).buffer = newBuffer();
+                 bufferWriteHardString((yyval.exprlist).buffer, (byte*)(yyvsp[(1) - (1)].str), strlen((yyvsp[(1) - (1)].str))+1);
+                 (yyval.exprlist).count = 1; ;}
     break;
 
   case 119:
 #line 408 "swf5compiler.y"
-    { yyval.exprlist = yyvsp[-2].exprlist;
-                 bufferWriteHardString(yyval.exprlist.buffer, (byte*)yyvsp[0].str, strlen(yyvsp[0].str)+1);
-                 ++yyval.exprlist.count; ;}
+    { (yyval.exprlist) = (yyvsp[(1) - (3)].exprlist);
+                 bufferWriteHardString((yyval.exprlist).buffer, (byte*)(yyvsp[(3) - (3)].str), strlen((yyvsp[(3) - (3)].str))+1);
+                 ++(yyval.exprlist).count; ;}
     break;
 
   case 120:
@@ -3399,38 +3739,38 @@ yyreduce:
 
   case 121:
 #line 420 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_DEFINEFUNCTION);
-                 bufferWriteS16(yyval.action, strlen(yyvsp[-4].str) +
-                                    bufferLength(yyvsp[-2].exprlist.buffer) + 5);
-                 bufferWriteHardString(yyval.action, (byte*) yyvsp[-4].str, strlen(yyvsp[-4].str)+1);
-                 bufferWriteS16(yyval.action, yyvsp[-2].exprlist.count);
-                 bufferConcat(yyval.action, yyvsp[-2].exprlist.buffer);
-                 bufferWriteS16(yyval.action, bufferLength(yyvsp[0].action));
-                 bufferConcat(yyval.action, yyvsp[0].action);
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_DEFINEFUNCTION);
+                 bufferWriteS16((yyval.action), strlen((yyvsp[(2) - (6)].str)) +
+                                    bufferLength((yyvsp[(4) - (6)].exprlist).buffer) + 5);
+                 bufferWriteHardString((yyval.action), (byte*) (yyvsp[(2) - (6)].str), strlen((yyvsp[(2) - (6)].str))+1);
+                 bufferWriteS16((yyval.action), (yyvsp[(4) - (6)].exprlist).count);
+                 bufferConcat((yyval.action), (yyvsp[(4) - (6)].exprlist).buffer);
+                 bufferWriteS16((yyval.action), bufferLength((yyvsp[(6) - (6)].action)));
+                 bufferConcat((yyval.action), (yyvsp[(6) - (6)].action));
                  delctx(CTX_FUNCTION); ;}
     break;
 
   case 122:
 #line 434 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteString(yyval.action, yyvsp[0].str, strlen(yyvsp[0].str)+1);
-                 free(yyvsp[0].str); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteString((yyval.action), (yyvsp[(1) - (1)].str), strlen((yyvsp[(1) - (1)].str))+1);
+                 free((yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 123:
 #line 439 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferWriteString(yyval.action, yyvsp[0].str, strlen(yyvsp[0].str)+1);
-                 bufferWriteOp(yyval.action, SWFACTION_GETMEMBER);
-                 free(yyvsp[0].str); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferWriteString((yyval.action), (yyvsp[(3) - (3)].str), strlen((yyvsp[(3) - (3)].str))+1);
+                 bufferWriteOp((yyval.action), SWFACTION_GETMEMBER);
+                 free((yyvsp[(3) - (3)].str)); ;}
     break;
 
   case 124:
 #line 445 "swf5compiler.y"
-    { yyval.action = yyvsp[-3].action;
-                 bufferConcat(yyval.action, yyvsp[-1].action);
-                 bufferWriteOp(yyval.action, SWFACTION_GETMEMBER); ;}
+    { (yyval.action) = (yyvsp[(1) - (4)].action);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (4)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_GETMEMBER); ;}
     break;
 
   case 127:
@@ -3455,67 +3795,67 @@ yyreduce:
 
   case 131:
 #line 476 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferWriteOp(yyval.action, SWFACTION_LOGICALNOT);
-                 bufferWriteOp(yyval.action, SWFACTION_BRANCHIFTRUE);
-                 bufferWriteS16(yyval.action, 2);
-                 bufferWriteS16(yyval.action, bufferLength(yyvsp[0].action)+5);
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_BRANCHALWAYS);
-                 bufferWriteS16(yyval.action, 2);
-                 bufferWriteS16(yyval.action, -(bufferLength(yyval.action)+2));
-                 bufferResolveJumps(yyval.action);
+    { (yyval.action) = (yyvsp[(3) - (5)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_LOGICALNOT);
+                 bufferWriteOp((yyval.action), SWFACTION_BRANCHIFTRUE);
+                 bufferWriteS16((yyval.action), 2);
+                 bufferWriteS16((yyval.action), bufferLength((yyvsp[(5) - (5)].action))+5);
+                 bufferConcat((yyval.action), (yyvsp[(5) - (5)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_BRANCHALWAYS);
+                 bufferWriteS16((yyval.action), 2);
+                 bufferWriteS16((yyval.action), -(bufferLength((yyval.action))+2));
+                 bufferResolveJumps((yyval.action));
                  delctx(CTX_LOOP); ;}
     break;
 
   case 132:
 #line 489 "swf5compiler.y"
-    { if(yyvsp[-4].action)
-                       {       yyval.action = yyvsp[-4].action;
-                               bufferConcat(yyval.action, yyvsp[-1].action);
+    { if((yyvsp[(2) - (6)].action))
+                       {       (yyval.action) = (yyvsp[(2) - (6)].action);
+                               bufferConcat((yyval.action), (yyvsp[(5) - (6)].action));
                        }
                        else
-                               yyval.action = yyvsp[-1].action;
-                 bufferWriteOp(yyval.action, SWFACTION_BRANCHIFTRUE);
-                 bufferWriteS16(yyval.action, 2);
-                 bufferWriteS16(yyval.action, -(bufferLength(yyval.action)+2));
-                 bufferResolveJumps(yyval.action);
+                               (yyval.action) = (yyvsp[(5) - (6)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_BRANCHIFTRUE);
+                 bufferWriteS16((yyval.action), 2);
+                 bufferWriteS16((yyval.action), -(bufferLength((yyval.action))+2));
+                 bufferResolveJumps((yyval.action));
                  delctx(CTX_LOOP); ;}
     break;
 
   case 133:
 #line 502 "swf5compiler.y"
     {
-                 if(yyvsp[-7].action)
-                   yyval.action = yyvsp[-7].action;
+                 if((yyvsp[(3) - (10)].action))
+                   (yyval.action) = (yyvsp[(3) - (10)].action);
                  else
-                   yyval.action = newBuffer();
+                   (yyval.action) = newBuffer();
 
-                 if(yyvsp[-3].action)
+                 if((yyvsp[(7) - (10)].action))
                  {
-                    bufferWriteOp(yyval.action, SWFACTION_BRANCHALWAYS);
-                    bufferWriteS16(yyval.action, 2);
-                    bufferWriteS16(yyval.action, bufferLength(yyvsp[-3].action));
+                    bufferWriteOp((yyval.action), SWFACTION_BRANCHALWAYS);
+                    bufferWriteS16((yyval.action), 2);
+                    bufferWriteS16((yyval.action), bufferLength((yyvsp[(7) - (10)].action)));
                  }
                  else
-                   yyvsp[-3].action = newBuffer();
+                   (yyvsp[(7) - (10)].action) = newBuffer();
 
-                 if(yyvsp[-5].action)
+                 if((yyvsp[(5) - (10)].action))
                  {
-                   bufferConcat(yyvsp[-3].action, yyvsp[-5].action);
-                    bufferWriteOp(yyvsp[-3].action, SWFACTION_LOGICALNOT);
-                    bufferWriteOp(yyvsp[-3].action, SWFACTION_BRANCHIFTRUE);
-                    bufferWriteS16(yyvsp[-3].action, 2);
-                    bufferWriteS16(yyvsp[-3].action, bufferLength(yyvsp[0].action)+5);
+                   bufferConcat((yyvsp[(7) - (10)].action), (yyvsp[(5) - (10)].action));
+                    bufferWriteOp((yyvsp[(7) - (10)].action), SWFACTION_LOGICALNOT);
+                    bufferWriteOp((yyvsp[(7) - (10)].action), SWFACTION_BRANCHIFTRUE);
+                    bufferWriteS16((yyvsp[(7) - (10)].action), 2);
+                    bufferWriteS16((yyvsp[(7) - (10)].action), bufferLength((yyvsp[(10) - (10)].action))+5);
                   }
 
-                  bufferConcat(yyvsp[-3].action, yyvsp[0].action);
-                  bufferWriteOp(yyvsp[-3].action, SWFACTION_BRANCHALWAYS);
-                  bufferWriteS16(yyvsp[-3].action, 2);
-                  bufferWriteS16(yyvsp[-3].action, -(bufferLength(yyvsp[-3].action)+2));
-                  bufferResolveJumps(yyvsp[-3].action);
+                  bufferConcat((yyvsp[(7) - (10)].action), (yyvsp[(10) - (10)].action));
+                  bufferWriteOp((yyvsp[(7) - (10)].action), SWFACTION_BRANCHALWAYS);
+                  bufferWriteS16((yyvsp[(7) - (10)].action), 2);
+                  bufferWriteS16((yyvsp[(7) - (10)].action), -(bufferLength((yyvsp[(7) - (10)].action))+2));
+                  bufferResolveJumps((yyvsp[(7) - (10)].action));
 
-                  bufferConcat(yyval.action, yyvsp[-3].action);
+                  bufferConcat((yyval.action), (yyvsp[(7) - (10)].action));
                                  delctx(CTX_LOOP);
                 ;}
     break;
@@ -3525,8 +3865,8 @@ yyreduce:
     { Buffer b2, b3;
                  int tmp;
 
-                 yyval.action = yyvsp[-3].action;
-                 bufferWriteOp(yyval.action, SWFACTION_ENUMERATE);     
+                 (yyval.action) = (yyvsp[(5) - (8)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_ENUMERATE);   
 
                  b2 = newBuffer();
                  bufferWriteSetRegister(b2, 0);
@@ -3540,18 +3880,18 @@ yyreduce:
                  b3 = newBuffer();
 /* basically a lvalue could be used here rather than an ident !!! */
 /* probably by using reg1 for the test rather than reg0 */
-                 bufferWriteString(b3, yyvsp[-5].str, strlen(yyvsp[-5].str)+1);
+                 bufferWriteString(b3, (yyvsp[(3) - (8)].str), strlen((yyvsp[(3) - (8)].str))+1);
                  bufferWriteRegister(b3, 0);
                  bufferWriteOp(b3, SWFACTION_SETVARIABLE);
-                 bufferConcat(b3, yyvsp[0].action);
+                 bufferConcat(b3, (yyvsp[(8) - (8)].action));
                  bufferWriteS16(b2, bufferLength(b3) + 5);
                  tmp = bufferLength(b2) + bufferLength(b3) + 5;
-                 bufferConcat(yyval.action, b2);
+                 bufferConcat((yyval.action), b2);
                  bufferWriteOp(b3, SWFACTION_BRANCHALWAYS);
                  bufferWriteS16(b3, 2);
                  bufferWriteS16(b3, -tmp);
                  bufferResolveJumps(b3);
-                 bufferConcat(yyval.action, b3);
+                 bufferConcat((yyval.action), b3);
                  delctx(CTX_FOR_IN); ;}
     break;
 
@@ -3560,8 +3900,8 @@ yyreduce:
     { Buffer b2, b3;
                  int tmp;
 
-                 yyval.action = yyvsp[-3].action;
-                 bufferWriteOp(yyval.action, SWFACTION_ENUMERATE);     
+                 (yyval.action) = (yyvsp[(6) - (9)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_ENUMERATE);   
 
                  b2 = newBuffer();
                  bufferWriteSetRegister(b2, 0);
@@ -3574,34 +3914,34 @@ yyreduce:
                  // add size later
 
                  b3 = newBuffer();
-                 bufferWriteString(b3, yyvsp[-5].str, strlen(yyvsp[-5].str)+1);
+                 bufferWriteString(b3, (yyvsp[(4) - (9)].str), strlen((yyvsp[(4) - (9)].str))+1);
                  bufferWriteRegister(b3, 0);
                  bufferWriteOp(b3, SWFACTION_VAREQUALS);
-                 bufferConcat(b3, yyvsp[0].action);
+                 bufferConcat(b3, (yyvsp[(9) - (9)].action));
                  bufferWriteS16(b2, bufferLength(b3) + 5);
                  tmp = bufferLength(b2) + bufferLength(b3) + 5;
-                 bufferConcat(yyval.action, b2);
+                 bufferConcat((yyval.action), b2);
                  bufferWriteOp(b3, SWFACTION_BRANCHALWAYS);
                  bufferWriteS16(b3, 2);
                  bufferWriteS16(b3, -tmp);
                  bufferResolveJumps(b3);
-                 bufferConcat(yyval.action, b3);
+                 bufferConcat((yyval.action), b3);
                  delctx(CTX_FOR_IN); ;}
     break;
 
   case 136:
 #line 603 "swf5compiler.y"
-    { yyval.action = NULL; ;}
+    { (yyval.action) = NULL; ;}
     break;
 
   case 138:
 #line 611 "swf5compiler.y"
     { if(chkctx(CTX_CONTINUE) < 0)
                        swf5error("continue outside loop");
-                 yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_BRANCHALWAYS);
-                 bufferWriteS16(yyval.action, 2);
-                 bufferWriteS16(yyval.action, MAGIC_CONTINUE_NUMBER); ;}
+                 (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_BRANCHALWAYS);
+                 bufferWriteS16((yyval.action), 2);
+                 bufferWriteS16((yyval.action), MAGIC_CONTINUE_NUMBER); ;}
     break;
 
   case 139:
@@ -3609,727 +3949,727 @@ yyreduce:
     { int tmp = chkctx(CTX_BREAK);
                  if(tmp < 0)
                        swf5error("break outside switch / loop");
-                 yyval.action = newBuffer();
+                 (yyval.action) = newBuffer();
                  if(tmp)       /* break out of a for .. in */
-                       bufferWriteOp(yyval.action, SWFACTION_POP);
-                 bufferWriteOp(yyval.action, SWFACTION_BRANCHALWAYS);
-                 bufferWriteS16(yyval.action, 2);
-                 bufferWriteS16(yyval.action, MAGIC_BREAK_NUMBER); ;}
+                       bufferWriteOp((yyval.action), SWFACTION_POP);
+                 bufferWriteOp((yyval.action), SWFACTION_BRANCHALWAYS);
+                 bufferWriteS16((yyval.action), 2);
+                 bufferWriteS16((yyval.action), MAGIC_BREAK_NUMBER); ;}
     break;
 
   case 140:
 #line 634 "swf5compiler.y"
-    { yyval.getURLMethod = GETURL_METHOD_NOSEND; ;}
+    { (yyval.getURLMethod) = GETURL_METHOD_NOSEND; ;}
     break;
 
   case 141:
 #line 636 "swf5compiler.y"
-    { yyval.getURLMethod = GETURL_METHOD_GET; ;}
+    { (yyval.getURLMethod) = GETURL_METHOD_GET; ;}
     break;
 
   case 142:
 #line 638 "swf5compiler.y"
-    { yyval.getURLMethod = GETURL_METHOD_POST; ;}
+    { (yyval.getURLMethod) = GETURL_METHOD_POST; ;}
     break;
 
   case 143:
 #line 640 "swf5compiler.y"
-    { if(strcmp(yyvsp[0].str, "GET") == 0)
-                                   yyval.getURLMethod = GETURL_METHOD_GET;
-                                 else if(strcmp(yyvsp[0].str, "POST") == 0)
-                                   yyval.getURLMethod = GETURL_METHOD_POST; ;}
+    { if(strcmp((yyvsp[(2) - (2)].str), "GET") == 0)
+                                   (yyval.getURLMethod) = GETURL_METHOD_GET;
+                                 else if(strcmp((yyvsp[(2) - (2)].str), "POST") == 0)
+                                   (yyval.getURLMethod) = GETURL_METHOD_POST; ;}
     break;
 
   case 144:
 #line 648 "swf5compiler.y"
     { char *lvlstring = (char*) malloc(12*sizeof(char));
-                 sprintf(lvlstring, "_level%d", yyvsp[0].intVal);
-                 yyval.action = newBuffer();
-                 bufferWriteString(yyval.action, lvlstring, strlen(lvlstring)+1);
+                 sprintf(lvlstring, "_level%d", (yyvsp[(1) - (1)].intVal));
+                 (yyval.action) = newBuffer();
+                 bufferWriteString((yyval.action), lvlstring, strlen(lvlstring)+1);
                  free(lvlstring); ;}
     break;
 
   case 145:
 #line 655 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteString(yyval.action, "_level", 7);
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_STRINGCONCAT); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteString((yyval.action), "_level", 7);
+                 bufferConcat((yyval.action), (yyvsp[(1) - (1)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_STRINGCONCAT); ;}
     break;
 
   case 146:
 #line 663 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].exprlist.buffer;
-                 bufferWriteInt(yyval.action, yyvsp[-1].exprlist.count);
-                 bufferWriteString(yyval.action, yyvsp[-3].str, strlen(yyvsp[-3].str)+1);
-                 bufferWriteOp(yyval.action, SWFACTION_CALLFUNCTION);
-                 bufferWriteOp(yyval.action, SWFACTION_POP);
-                 free(yyvsp[-3].str); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].exprlist).buffer;
+                 bufferWriteInt((yyval.action), (yyvsp[(3) - (4)].exprlist).count);
+                 bufferWriteString((yyval.action), (yyvsp[(1) - (4)].str), strlen((yyvsp[(1) - (4)].str))+1);
+                 bufferWriteOp((yyval.action), SWFACTION_CALLFUNCTION);
+                 bufferWriteOp((yyval.action), SWFACTION_POP);
+                 free((yyvsp[(1) - (4)].str)); ;}
     break;
 
   case 147:
 #line 671 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteString(yyval.action, yyvsp[0].str, strlen(yyvsp[0].str)+1);
-                 free(yyvsp[0].str);
-                 bufferWriteOp(yyval.action, SWFACTION_DELETE); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteString((yyval.action), (yyvsp[(2) - (2)].str), strlen((yyvsp[(2) - (2)].str))+1);
+                 free((yyvsp[(2) - (2)].str));
+                 bufferWriteOp((yyval.action), SWFACTION_DELETE); ;}
     break;
 
   case 148:
 #line 677 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
+    { (yyval.action) = (yyvsp[(2) - (4)].action);
                  // bufferWriteOp($$, SWFACTION_GETVARIABLE);
-                 bufferWriteString(yyval.action, yyvsp[0].str, strlen(yyvsp[0].str)+1);
-                 free(yyvsp[0].str);
-                 bufferWriteOp(yyval.action, SWFACTION_DELETEVAR); ;}
+                 bufferWriteString((yyval.action), (yyvsp[(4) - (4)].str), strlen((yyvsp[(4) - (4)].str))+1);
+                 free((yyvsp[(4) - (4)].str));
+                 bufferWriteOp((yyval.action), SWFACTION_DELETEVAR); ;}
     break;
 
   case 149:
 #line 684 "swf5compiler.y"
-    { yyval.action = yyvsp[-3].action;
+    { (yyval.action) = (yyvsp[(2) - (5)].action);
                  // bufferWriteOp($$, SWFACTION_GETVARIABLE);
-                 bufferConcat(yyval.action, yyvsp[-1].action);
+                 bufferConcat((yyval.action), (yyvsp[(4) - (5)].action));
                  // bufferWriteOp($$, SWFACTION_GETVARIABLE);
-                 bufferWriteOp(yyval.action, SWFACTION_DELETEVAR); ;}
+                 bufferWriteOp((yyval.action), SWFACTION_DELETEVAR); ;}
     break;
 
   case 150:
 #line 691 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action;
-                 bufferWriteOp(yyval.action, SWFACTION_TRACE); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_TRACE); ;}
     break;
 
   case 151:
 #line 695 "swf5compiler.y"
-    { yyval.action = yyvsp[-4].action;
-                 bufferConcat(yyval.action, yyvsp[-2].action);
-                 bufferWriteOp(yyval.action, SWFACTION_GETURL2);
-                 bufferWriteS16(yyval.action, 1);
-                 bufferWriteU8(yyval.action, yyvsp[-1].getURLMethod); ;}
+    { (yyval.action) = (yyvsp[(3) - (7)].action);
+                 bufferConcat((yyval.action), (yyvsp[(5) - (7)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_GETURL2);
+                 bufferWriteS16((yyval.action), 1);
+                 bufferWriteU8((yyval.action), (yyvsp[(6) - (7)].getURLMethod)); ;}
     break;
 
   case 152:
 #line 702 "swf5compiler.y"
-    { yyval.action = yyvsp[-4].action;
-                 bufferConcat(yyval.action, yyvsp[-2].action);
-                 bufferWriteOp(yyval.action, SWFACTION_GETURL2);
-                 bufferWriteS16(yyval.action, 1);
-                 bufferWriteU8(yyval.action, 0xc0+yyvsp[-1].getURLMethod); ;}
+    { (yyval.action) = (yyvsp[(3) - (7)].action);
+                 bufferConcat((yyval.action), (yyvsp[(5) - (7)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_GETURL2);
+                 bufferWriteS16((yyval.action), 1);
+                 bufferWriteU8((yyval.action), 0xc0+(yyvsp[(6) - (7)].getURLMethod)); ;}
     break;
 
   case 153:
 #line 709 "swf5compiler.y"
-    { yyval.action = yyvsp[-4].action;
-                 bufferConcat(yyval.action, yyvsp[-2].action);
-                 bufferWriteOp(yyval.action, SWFACTION_GETURL2);
-                 bufferWriteS16(yyval.action, 1);
-                 bufferWriteU8(yyval.action, 0x80+yyvsp[-1].getURLMethod); ;}
+    { (yyval.action) = (yyvsp[(3) - (7)].action);
+                 bufferConcat((yyval.action), (yyvsp[(5) - (7)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_GETURL2);
+                 bufferWriteS16((yyval.action), 1);
+                 bufferWriteU8((yyval.action), 0x80+(yyvsp[(6) - (7)].getURLMethod)); ;}
     break;
 
   case 154:
 #line 716 "swf5compiler.y"
-    { yyval.action = yyvsp[-4].action;
-                 bufferConcat(yyval.action, yyvsp[-2].action);
-                 bufferWriteOp(yyval.action, SWFACTION_GETURL2);
-                 bufferWriteS16(yyval.action, 1);
-                 bufferWriteU8(yyval.action, 0x40+yyvsp[-1].getURLMethod); ;}
+    { (yyval.action) = (yyvsp[(3) - (7)].action);
+                 bufferConcat((yyval.action), (yyvsp[(5) - (7)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_GETURL2);
+                 bufferWriteS16((yyval.action), 1);
+                 bufferWriteU8((yyval.action), 0x40+(yyvsp[(6) - (7)].getURLMethod)); ;}
     break;
 
   case 155:
 #line 723 "swf5compiler.y"
-    { yyval.action = yyvsp[-4].action;
-                 bufferConcat(yyval.action, yyvsp[-2].action);
-                 bufferWriteOp(yyval.action, SWFACTION_GETURL2);
-                 bufferWriteS16(yyval.action, 1);
-                 bufferWriteU8(yyval.action, yyvsp[-1].getURLMethod); ;}
+    { (yyval.action) = (yyvsp[(3) - (7)].action);
+                 bufferConcat((yyval.action), (yyvsp[(5) - (7)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_GETURL2);
+                 bufferWriteS16((yyval.action), 1);
+                 bufferWriteU8((yyval.action), (yyvsp[(6) - (7)].getURLMethod)); ;}
     break;
 
   case 156:
 #line 730 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action;
-                 bufferWriteOp(yyval.action, SWFACTION_CALLFRAME);
-                 bufferWriteS16(yyval.action, 0); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_CALLFRAME);
+                 bufferWriteS16((yyval.action), 0); ;}
     break;
 
   case 157:
 #line 736 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteString(yyval.action, "0", 2); /* no constraint */
-                 bufferConcat(yyval.action, yyvsp[-1].action);
-                 bufferConcat(yyval.action, yyvsp[-3].action);
-                 bufferWriteOp(yyval.action, SWFACTION_STARTDRAGMOVIE); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteString((yyval.action), "0", 2); /* no constraint */
+                 bufferConcat((yyval.action), (yyvsp[(5) - (6)].action));
+                 bufferConcat((yyval.action), (yyvsp[(3) - (6)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_STARTDRAGMOVIE); ;}
     break;
 
   case 158:
 #line 743 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferConcat(yyval.action, yyvsp[-7].action);
-                 bufferConcat(yyval.action, yyvsp[-3].action);
-                 bufferConcat(yyval.action, yyvsp[-5].action);
-                 bufferConcat(yyval.action, yyvsp[-1].action);
-                 bufferWriteString(yyval.action, "1", 2); /* has constraint */
-                 bufferConcat(yyval.action, yyvsp[-9].action);
-                 bufferConcat(yyval.action, yyvsp[-11].action);
-                 bufferWriteOp(yyval.action, SWFACTION_STARTDRAGMOVIE); ;}
+    { (yyval.action) = newBuffer();
+                 bufferConcat((yyval.action), (yyvsp[(7) - (14)].action));
+                 bufferConcat((yyval.action), (yyvsp[(11) - (14)].action));
+                 bufferConcat((yyval.action), (yyvsp[(9) - (14)].action));
+                 bufferConcat((yyval.action), (yyvsp[(13) - (14)].action));
+                 bufferWriteString((yyval.action), "1", 2); /* has constraint */
+                 bufferConcat((yyval.action), (yyvsp[(5) - (14)].action));
+                 bufferConcat((yyval.action), (yyvsp[(3) - (14)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_STARTDRAGMOVIE); ;}
     break;
 
   case 159:
 #line 754 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_STOPDRAGMOVIE); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_STOPDRAGMOVIE); ;}
     break;
 
   case 160:
 #line 759 "swf5compiler.y"
-    { yyval.action = yyvsp[-5].action;
-                 bufferConcat(yyval.action, yyvsp[-3].action);
-                 bufferConcat(yyval.action, yyvsp[-1].action);
-                 bufferWriteInt(yyval.action, 16384); /* magic number */
-                 bufferWriteOp(yyval.action, SWFACTION_ADD);
-                 bufferWriteOp(yyval.action, SWFACTION_DUPLICATECLIP); ;}
+    { (yyval.action) = (yyvsp[(3) - (8)].action);
+                 bufferConcat((yyval.action), (yyvsp[(5) - (8)].action));
+                 bufferConcat((yyval.action), (yyvsp[(7) - (8)].action));
+                 bufferWriteInt((yyval.action), 16384); /* magic number */
+                 bufferWriteOp((yyval.action), SWFACTION_ADD);
+                 bufferWriteOp((yyval.action), SWFACTION_DUPLICATECLIP); ;}
     break;
 
   case 161:
 #line 767 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action;
-                 bufferWriteOp(yyval.action, SWFACTION_REMOVECLIP); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_REMOVECLIP); ;}
     break;
 
   case 162:
 #line 771 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_GETURL);
-                 bufferWriteS16(yyval.action, strlen(yyvsp[-3].str) + strlen(yyvsp[-1].str) + 2);
-                 bufferWriteHardString(yyval.action, (byte*)yyvsp[-3].str, strlen(yyvsp[-3].str));
-                 bufferWriteU8(yyval.action, 0);
-                 bufferWriteHardString(yyval.action, (byte*)yyvsp[-1].str, strlen(yyvsp[-1].str));
-                 bufferWriteU8(yyval.action, 0); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_GETURL);
+                 bufferWriteS16((yyval.action), strlen((yyvsp[(3) - (6)].str)) + strlen((yyvsp[(5) - (6)].str)) + 2);
+                 bufferWriteHardString((yyval.action), (byte*)(yyvsp[(3) - (6)].str), strlen((yyvsp[(3) - (6)].str)));
+                 bufferWriteU8((yyval.action), 0);
+                 bufferWriteHardString((yyval.action), (byte*)(yyvsp[(5) - (6)].str), strlen((yyvsp[(5) - (6)].str)));
+                 bufferWriteU8((yyval.action), 0); ;}
     break;
 
   case 163:
 #line 781 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_NEXTFRAME); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_NEXTFRAME); ;}
     break;
 
   case 164:
 #line 785 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_PREVFRAME); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_PREVFRAME); ;}
     break;
 
   case 165:
 #line 789 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_PLAY); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_PLAY); ;}
     break;
 
   case 166:
 #line 793 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_STOP); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_STOP); ;}
     break;
 
   case 167:
 #line 797 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_STOPSOUNDS); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_STOPSOUNDS); ;}
     break;
 
   case 168:
 #line 801 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_TOGGLEQUALITY); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_TOGGLEQUALITY); ;}
     break;
 
   case 169:
 #line 805 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_GOTOFRAME);
-                 bufferWriteS16(yyval.action, 2);
-                 bufferWriteS16(yyval.action, yyvsp[-1].intVal); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_GOTOFRAME);
+                 bufferWriteS16((yyval.action), 2);
+                 bufferWriteS16((yyval.action), (yyvsp[(3) - (4)].intVal)); ;}
     break;
 
   case 170:
 #line 811 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_GOTOLABEL);
-                 bufferWriteS16(yyval.action, strlen(yyvsp[-1].str)+1);
-                 bufferWriteHardString(yyval.action, (byte*)yyvsp[-1].str, strlen(yyvsp[-1].str)+1);
-                 free(yyvsp[-1].str); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_GOTOLABEL);
+                 bufferWriteS16((yyval.action), strlen((yyvsp[(3) - (4)].str))+1);
+                 bufferWriteHardString((yyval.action), (byte*)(yyvsp[(3) - (4)].str), strlen((yyvsp[(3) - (4)].str))+1);
+                 free((yyvsp[(3) - (4)].str)); ;}
     break;
 
   case 171:
 #line 818 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action;
-                 bufferWriteOp(yyval.action, SWFACTION_GOTOEXPRESSION);
-                 bufferWriteS16(yyval.action, 1);
-                 bufferWriteU8(yyval.action, 0); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_GOTOEXPRESSION);
+                 bufferWriteS16((yyval.action), 1);
+                 bufferWriteU8((yyval.action), 0); ;}
     break;
 
   case 172:
 #line 824 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_SETTARGET);
-                 bufferWriteS16(yyval.action, strlen(yyvsp[-1].str)+1);
-                 bufferWriteHardString(yyval.action, (byte*)yyvsp[-1].str, strlen(yyvsp[-1].str)+1);
-                 free(yyvsp[-1].str); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_SETTARGET);
+                 bufferWriteS16((yyval.action), strlen((yyvsp[(3) - (4)].str))+1);
+                 bufferWriteHardString((yyval.action), (byte*)(yyvsp[(3) - (4)].str), strlen((yyvsp[(3) - (4)].str))+1);
+                 free((yyvsp[(3) - (4)].str)); ;}
     break;
 
   case 173:
 #line 831 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action;
-                 bufferWriteOp(yyval.action, SWFACTION_SETTARGETEXPRESSION); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_SETTARGETEXPRESSION); ;}
     break;
 
   case 174:
 #line 840 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].exprlist.buffer;
-                 bufferWriteInt(yyval.action, yyvsp[-1].exprlist.count);
-                 bufferWriteString(yyval.action, yyvsp[-3].str, strlen(yyvsp[-3].str)+1);
-                 bufferWriteOp(yyval.action, SWFACTION_CALLFUNCTION);
-                 free(yyvsp[-3].str); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].exprlist).buffer;
+                 bufferWriteInt((yyval.action), (yyvsp[(3) - (4)].exprlist).count);
+                 bufferWriteString((yyval.action), (yyvsp[(1) - (4)].str), strlen((yyvsp[(1) - (4)].str))+1);
+                 bufferWriteOp((yyval.action), SWFACTION_CALLFUNCTION);
+                 free((yyvsp[(1) - (4)].str)); ;}
     break;
 
   case 175:
 #line 847 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action;
-                 bufferWriteOp(yyval.action, SWFACTION_GETVARIABLE); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_GETVARIABLE); ;}
     break;
 
   case 176:
 #line 851 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_GETTIMER); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_GETTIMER); ;}
     break;
 
   case 177:
 #line 855 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action;
-                 bufferWriteOp(yyval.action, SWFACTION_RANDOM); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_RANDOM); ;}
     break;
 
   case 178:
 #line 859 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action;
-                 bufferWriteOp(yyval.action, SWFACTION_STRINGLENGTH); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_STRINGLENGTH); ;}
     break;
 
   case 179:
 #line 863 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action;
-                 bufferWriteOp(yyval.action, SWFACTION_INT); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_INT); ;}
     break;
 
   case 180:
 #line 867 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action;
-                 bufferWriteOp(yyval.action, SWFACTION_ORD); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_ORD); ;}
     break;
 
   case 181:
 #line 871 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action;
-                 bufferWriteOp(yyval.action, SWFACTION_CHR); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_CHR); ;}
     break;
 
   case 182:
 #line 875 "swf5compiler.y"
-    { yyval.action = yyvsp[-3].action;
-                 bufferConcat(yyval.action, yyvsp[-1].action);
-                 bufferWriteOp(yyval.action, SWFACTION_STRINGCONCAT); ;}
+    { (yyval.action) = (yyvsp[(3) - (6)].action);
+                 bufferConcat((yyval.action), (yyvsp[(5) - (6)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_STRINGCONCAT); ;}
     break;
 
   case 183:
 #line 880 "swf5compiler.y"
-    { yyval.action = yyvsp[-5].action;
-                 bufferConcat(yyval.action, yyvsp[-3].action);
-                 bufferConcat(yyval.action, yyvsp[-1].action);
-                 bufferWriteOp(yyval.action, SWFACTION_SUBSTRING); ;}
+    { (yyval.action) = (yyvsp[(3) - (8)].action);
+                 bufferConcat((yyval.action), (yyvsp[(5) - (8)].action));
+                 bufferConcat((yyval.action), (yyvsp[(7) - (8)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_SUBSTRING); ;}
     break;
 
   case 184:
 #line 886 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action;
-                 bufferWriteOp(yyval.action, SWFACTION_TYPEOF); ;}
+    { (yyval.action) = (yyvsp[(3) - (4)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_TYPEOF); ;}
     break;
 
   case 185:
 #line 894 "swf5compiler.y"
-    { yyval.exprlist.buffer = newBuffer();
-                 yyval.exprlist.count = 0; ;}
+    { (yyval.exprlist).buffer = newBuffer();
+                 (yyval.exprlist).count = 0; ;}
     break;
 
   case 186:
 #line 898 "swf5compiler.y"
-    { yyval.exprlist.buffer = yyvsp[0].action;
-                 yyval.exprlist.count = 1; ;}
+    { (yyval.exprlist).buffer = (yyvsp[(1) - (1)].action);
+                 (yyval.exprlist).count = 1; ;}
     break;
 
   case 187:
 #line 903 "swf5compiler.y"
     { Buffer tmp = newBuffer();
-                 bufferConcat(tmp, yyvsp[0].action);
-                 bufferConcat(tmp, yyval.exprlist.buffer);
-                 yyval.exprlist.buffer = tmp;
-                 ++yyval.exprlist.count;  ;}
+                 bufferConcat(tmp, (yyvsp[(3) - (3)].action));
+                 bufferConcat(tmp, (yyval.exprlist).buffer);
+                 (yyval.exprlist).buffer = tmp;
+                 ++(yyval.exprlist).count;  ;}
     break;
 
   case 188:
 #line 912 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteOp(yyval.action, SWFACTION_DEFINEFUNCTION);
-                 bufferWriteS16(yyval.action, bufferLength(yyvsp[-2].exprlist.buffer) + 5);
-                 bufferWriteU8(yyval.action, 0); /* empty function name */
-                 bufferWriteS16(yyval.action, yyvsp[-2].exprlist.count);
-                 bufferConcat(yyval.action, yyvsp[-2].exprlist.buffer);
-                 bufferWriteS16(yyval.action, bufferLength(yyvsp[0].action));
-                 bufferConcat(yyval.action, yyvsp[0].action);
+    { (yyval.action) = newBuffer();
+                 bufferWriteOp((yyval.action), SWFACTION_DEFINEFUNCTION);
+                 bufferWriteS16((yyval.action), bufferLength((yyvsp[(3) - (5)].exprlist).buffer) + 5);
+                 bufferWriteU8((yyval.action), 0); /* empty function name */
+                 bufferWriteS16((yyval.action), (yyvsp[(3) - (5)].exprlist).count);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (5)].exprlist).buffer);
+                 bufferWriteS16((yyval.action), bufferLength((yyvsp[(5) - (5)].action)));
+                 bufferConcat((yyval.action), (yyvsp[(5) - (5)].action));
                  delctx(CTX_FUNCTION); ;}
     break;
 
   case 189:
 #line 925 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].exprlist.buffer;
-                 bufferWriteInt(yyval.action, yyvsp[-1].exprlist.count);
-                 bufferConcat(yyval.action, yyvsp[-5].action);
-                 bufferWriteString(yyval.action, yyvsp[-3].str, strlen(yyvsp[-3].str)+1);
-                 bufferWriteOp(yyval.action, SWFACTION_CALLMETHOD);
-                 free(yyvsp[-3].str); ;}
+    { (yyval.action) = (yyvsp[(5) - (6)].exprlist).buffer;
+                 bufferWriteInt((yyval.action), (yyvsp[(5) - (6)].exprlist).count);
+                 bufferConcat((yyval.action), (yyvsp[(1) - (6)].action));
+                 bufferWriteString((yyval.action), (yyvsp[(3) - (6)].str), strlen((yyvsp[(3) - (6)].str))+1);
+                 bufferWriteOp((yyval.action), SWFACTION_CALLMETHOD);
+                 free((yyvsp[(3) - (6)].str)); ;}
     break;
 
   case 190:
 #line 933 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].exprlist.buffer;
-                 bufferWriteInt(yyval.action, yyvsp[-1].exprlist.count);
-                 bufferConcat(yyval.action, yyvsp[-6].action);
-                 bufferConcat(yyval.action, yyvsp[-4].action);
-                 bufferWriteOp(yyval.action, SWFACTION_CALLMETHOD); ;}
+    { (yyval.action) = (yyvsp[(6) - (7)].exprlist).buffer;
+                 bufferWriteInt((yyval.action), (yyvsp[(6) - (7)].exprlist).count);
+                 bufferConcat((yyval.action), (yyvsp[(1) - (7)].action));
+                 bufferConcat((yyval.action), (yyvsp[(3) - (7)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_CALLMETHOD); ;}
     break;
 
   case 191:
 #line 942 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteString(yyval.action, yyvsp[-2].str, strlen(yyvsp[-2].str)+1);
-                 bufferConcat(yyval.action, yyvsp[0].action); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteString((yyval.action), (yyvsp[(1) - (3)].str), strlen((yyvsp[(1) - (3)].str))+1);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action)); ;}
     break;
 
   case 192:
 #line 949 "swf5compiler.y"
-    { yyval.exprlist.buffer = yyvsp[0].action;
-                 yyval.exprlist.count = 1; ;}
+    { (yyval.exprlist).buffer = (yyvsp[(1) - (1)].action);
+                 (yyval.exprlist).count = 1; ;}
     break;
 
   case 193:
 #line 953 "swf5compiler.y"
-    { bufferConcat(yyval.exprlist.buffer, yyvsp[0].action);
-                 ++yyval.exprlist.count;  ;}
+    { bufferConcat((yyval.exprlist).buffer, (yyvsp[(3) - (3)].action));
+                 ++(yyval.exprlist).count;  ;}
     break;
 
   case 194:
 #line 958 "swf5compiler.y"
-    { yyval.op = SWFACTION_NEWADD; ;}
+    { (yyval.op) = SWFACTION_NEWADD; ;}
     break;
 
   case 195:
 #line 959 "swf5compiler.y"
-    { yyval.op = SWFACTION_SUBTRACT; ;}
+    { (yyval.op) = SWFACTION_SUBTRACT; ;}
     break;
 
   case 196:
 #line 960 "swf5compiler.y"
-    { yyval.op = SWFACTION_MULTIPLY; ;}
+    { (yyval.op) = SWFACTION_MULTIPLY; ;}
     break;
 
   case 197:
 #line 961 "swf5compiler.y"
-    { yyval.op = SWFACTION_DIVIDE; ;}
+    { (yyval.op) = SWFACTION_DIVIDE; ;}
     break;
 
   case 198:
 #line 962 "swf5compiler.y"
-    { yyval.op = SWFACTION_MODULO; ;}
+    { (yyval.op) = SWFACTION_MODULO; ;}
     break;
 
   case 199:
 #line 963 "swf5compiler.y"
-    { yyval.op = SWFACTION_BITWISEAND; ;}
+    { (yyval.op) = SWFACTION_BITWISEAND; ;}
     break;
 
   case 200:
 #line 964 "swf5compiler.y"
-    { yyval.op = SWFACTION_BITWISEOR; ;}
+    { (yyval.op) = SWFACTION_BITWISEOR; ;}
     break;
 
   case 201:
 #line 965 "swf5compiler.y"
-    { yyval.op = SWFACTION_BITWISEXOR; ;}
+    { (yyval.op) = SWFACTION_BITWISEXOR; ;}
     break;
 
   case 202:
 #line 966 "swf5compiler.y"
-    { yyval.op = SWFACTION_SHIFTLEFT; ;}
+    { (yyval.op) = SWFACTION_SHIFTLEFT; ;}
     break;
 
   case 203:
 #line 967 "swf5compiler.y"
-    { yyval.op = SWFACTION_SHIFTRIGHT; ;}
+    { (yyval.op) = SWFACTION_SHIFTRIGHT; ;}
     break;
 
   case 204:
 #line 968 "swf5compiler.y"
-    { yyval.op = SWFACTION_SHIFTRIGHT2; ;}
+    { (yyval.op) = SWFACTION_SHIFTRIGHT2; ;}
     break;
 
   case 205:
 #line 972 "swf5compiler.y"
-    { yyval.op = SWFACTION_INCREMENT; ;}
+    { (yyval.op) = SWFACTION_INCREMENT; ;}
     break;
 
   case 206:
 #line 973 "swf5compiler.y"
-    { yyval.op = SWFACTION_DECREMENT; ;}
+    { (yyval.op) = SWFACTION_DECREMENT; ;}
     break;
 
   case 207:
 #line 992 "swf5compiler.y"
-    { if(yyvsp[0].lval.obj)
+    { if((yyvsp[(1) - (1)].lval).obj)
                  {
-                   yyval.action = yyvsp[0].lval.obj;
+                   (yyval.action) = (yyvsp[(1) - (1)].lval).obj;
 
-                   if(yyvsp[0].lval.ident)
-                     bufferConcat(yyval.action, yyvsp[0].lval.ident);
+                   if((yyvsp[(1) - (1)].lval).ident)
+                     bufferConcat((yyval.action), (yyvsp[(1) - (1)].lval).ident);
                    else
-                     bufferConcat(yyval.action, yyvsp[0].lval.memexpr);
+                     bufferConcat((yyval.action), (yyvsp[(1) - (1)].lval).memexpr);
 
-                   bufferWriteOp(yyval.action, SWFACTION_GETMEMBER);
+                   bufferWriteOp((yyval.action), SWFACTION_GETMEMBER);
                  }
                  else
                  {
-                   yyval.action = yyvsp[0].lval.ident;
-                   bufferWriteOp(yyval.action, SWFACTION_GETVARIABLE);
+                   (yyval.action) = (yyvsp[(1) - (1)].lval).ident;
+                   bufferWriteOp((yyval.action), SWFACTION_GETVARIABLE);
                  }
                ;}
     break;
 
   case 210:
 #line 1016 "swf5compiler.y"
-    { yyval.lval.ident = newBuffer();
-                 bufferWriteString(yyval.lval.ident, yyvsp[0].str, strlen(yyvsp[0].str)+1);
-                 free(yyvsp[0].str);
-                 yyval.lval.obj = 0;
-                 yyval.lval.memexpr = 0; ;}
+    { (yyval.lval).ident = newBuffer();
+                 bufferWriteString((yyval.lval).ident, (yyvsp[(1) - (1)].str), strlen((yyvsp[(1) - (1)].str))+1);
+                 free((yyvsp[(1) - (1)].str));
+                 (yyval.lval).obj = 0;
+                 (yyval.lval).memexpr = 0; ;}
     break;
 
   case 211:
 #line 1023 "swf5compiler.y"
-    { yyval.lval.obj = yyvsp[-2].action;
-                 yyval.lval.ident = newBuffer();
-                 bufferWriteString(yyval.lval.ident, yyvsp[0].str, strlen(yyvsp[0].str)+1);
-                 yyval.lval.memexpr = 0; ;}
+    { (yyval.lval).obj = (yyvsp[(1) - (3)].action);
+                 (yyval.lval).ident = newBuffer();
+                 bufferWriteString((yyval.lval).ident, (yyvsp[(3) - (3)].str), strlen((yyvsp[(3) - (3)].str))+1);
+                 (yyval.lval).memexpr = 0; ;}
     break;
 
   case 212:
 #line 1029 "swf5compiler.y"
-    { yyval.lval.obj = yyvsp[-3].action;
-                 yyval.lval.memexpr = yyvsp[-1].action;
-                 yyval.lval.ident = 0; ;}
+    { (yyval.lval).obj = (yyvsp[(1) - (4)].action);
+                 (yyval.lval).memexpr = (yyvsp[(3) - (4)].action);
+                 (yyval.lval).ident = 0; ;}
     break;
 
   case 214:
 #line 1040 "swf5compiler.y"
-    { yyval.action = yyvsp[0].action;
-                 bufferWriteInt(yyvsp[0].action, -1);
-                 bufferWriteOp(yyvsp[0].action, SWFACTION_MULTIPLY); ;}
+    { (yyval.action) = (yyvsp[(2) - (2)].action);
+                 bufferWriteInt((yyvsp[(2) - (2)].action), -1);
+                 bufferWriteOp((yyvsp[(2) - (2)].action), SWFACTION_MULTIPLY); ;}
     break;
 
   case 215:
 #line 1045 "swf5compiler.y"
-    { yyval.action = yyvsp[0].action;
-                 bufferWriteInt(yyvsp[0].action, 0xffffffff);
-                 bufferWriteOp(yyvsp[0].action, SWFACTION_BITWISEXOR); ;}
+    { (yyval.action) = (yyvsp[(2) - (2)].action);
+                 bufferWriteInt((yyvsp[(2) - (2)].action), 0xffffffff);
+                 bufferWriteOp((yyvsp[(2) - (2)].action), SWFACTION_BITWISEXOR); ;}
     break;
 
   case 216:
 #line 1050 "swf5compiler.y"
-    { yyval.action = yyvsp[0].action;
-                 bufferWriteOp(yyvsp[0].action, SWFACTION_LOGICALNOT); ;}
+    { (yyval.action) = (yyvsp[(2) - (2)].action);
+                 bufferWriteOp((yyvsp[(2) - (2)].action), SWFACTION_LOGICALNOT); ;}
     break;
 
   case 217:
 #line 1054 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferWriteOp(yyval.action, SWFACTION_DUP);
-                 bufferWriteOp(yyval.action, SWFACTION_BRANCHIFTRUE);
-                 bufferWriteS16(yyval.action, 2);
-                 bufferWriteS16(yyval.action, bufferLength(yyvsp[0].action)+1);
-                 bufferWriteOp(yyval.action, SWFACTION_POP);
-                 bufferConcat(yyval.action, yyvsp[0].action); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_DUP);
+                 bufferWriteOp((yyval.action), SWFACTION_BRANCHIFTRUE);
+                 bufferWriteS16((yyval.action), 2);
+                 bufferWriteS16((yyval.action), bufferLength((yyvsp[(3) - (3)].action))+1);
+                 bufferWriteOp((yyval.action), SWFACTION_POP);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action)); ;}
     break;
 
   case 218:
 #line 1063 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferWriteOp(yyval.action, SWFACTION_DUP);
-                 bufferWriteOp(yyval.action, SWFACTION_LOGICALNOT);
-                 bufferWriteOp(yyval.action, SWFACTION_BRANCHIFTRUE);
-                 bufferWriteS16(yyval.action, 2);
-                 bufferWriteS16(yyval.action, bufferLength(yyvsp[0].action)+1);
-                 bufferWriteOp(yyval.action, SWFACTION_POP);
-                 bufferConcat(yyval.action, yyvsp[0].action); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_DUP);
+                 bufferWriteOp((yyval.action), SWFACTION_LOGICALNOT);
+                 bufferWriteOp((yyval.action), SWFACTION_BRANCHIFTRUE);
+                 bufferWriteS16((yyval.action), 2);
+                 bufferWriteS16((yyval.action), bufferLength((yyvsp[(3) - (3)].action))+1);
+                 bufferWriteOp((yyval.action), SWFACTION_POP);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action)); ;}
     break;
 
   case 219:
 #line 1073 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_MULTIPLY); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_MULTIPLY); ;}
     break;
 
   case 220:
 #line 1078 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_DIVIDE); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_DIVIDE); ;}
     break;
 
   case 221:
 #line 1083 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_MODULO); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_MODULO); ;}
     break;
 
   case 222:
 #line 1088 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_NEWADD); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_NEWADD); ;}
     break;
 
   case 223:
 #line 1093 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_SUBTRACT); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_SUBTRACT); ;}
     break;
 
   case 224:
 #line 1098 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_BITWISEAND); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_BITWISEAND); ;}
     break;
 
   case 225:
 #line 1103 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_BITWISEOR); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_BITWISEOR); ;}
     break;
 
   case 226:
 #line 1108 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_BITWISEXOR); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_BITWISEXOR); ;}
     break;
 
   case 227:
 #line 1113 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_NEWLESSTHAN); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_NEWLESSTHAN); ;}
     break;
 
   case 228:
 #line 1118 "swf5compiler.y"
-    { yyval.action = yyvsp[0].action;
-                 bufferConcat(yyval.action, yyvsp[-2].action);
-                 bufferWriteOp(yyval.action, SWFACTION_NEWLESSTHAN); ;}
+    { (yyval.action) = (yyvsp[(3) - (3)].action);
+                 bufferConcat((yyval.action), (yyvsp[(1) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_NEWLESSTHAN); ;}
     break;
 
   case 229:
 #line 1123 "swf5compiler.y"
-    { yyval.action = yyvsp[0].action;
-                 bufferConcat(yyval.action, yyvsp[-2].action);
-                 bufferWriteOp(yyval.action, SWFACTION_NEWLESSTHAN);
-                 bufferWriteOp(yyval.action, SWFACTION_LOGICALNOT); ;}
+    { (yyval.action) = (yyvsp[(3) - (3)].action);
+                 bufferConcat((yyval.action), (yyvsp[(1) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_NEWLESSTHAN);
+                 bufferWriteOp((yyval.action), SWFACTION_LOGICALNOT); ;}
     break;
 
   case 230:
 #line 1129 "swf5compiler.y"
-    { bufferConcat(yyvsp[-2].action, yyvsp[0].action);
-                 bufferWriteOp(yyvsp[-2].action, SWFACTION_NEWLESSTHAN);
-                 bufferWriteOp(yyvsp[-2].action, SWFACTION_LOGICALNOT); ;}
+    { bufferConcat((yyvsp[(1) - (3)].action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyvsp[(1) - (3)].action), SWFACTION_NEWLESSTHAN);
+                 bufferWriteOp((yyvsp[(1) - (3)].action), SWFACTION_LOGICALNOT); ;}
     break;
 
   case 231:
 #line 1134 "swf5compiler.y"
-    { bufferConcat(yyvsp[-2].action, yyvsp[0].action);
-                 bufferWriteOp(yyvsp[-2].action, SWFACTION_NEWEQUALS); ;}
+    { bufferConcat((yyvsp[(1) - (3)].action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyvsp[(1) - (3)].action), SWFACTION_NEWEQUALS); ;}
     break;
 
   case 232:
 #line 1138 "swf5compiler.y"
-    { bufferConcat(yyvsp[-2].action, yyvsp[0].action);
-                 bufferWriteOp(yyvsp[-2].action, SWFACTION_NEWEQUALS);
-                 bufferWriteOp(yyvsp[-2].action, SWFACTION_LOGICALNOT); ;}
+    { bufferConcat((yyvsp[(1) - (3)].action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyvsp[(1) - (3)].action), SWFACTION_NEWEQUALS);
+                 bufferWriteOp((yyvsp[(1) - (3)].action), SWFACTION_LOGICALNOT); ;}
     break;
 
   case 233:
 #line 1143 "swf5compiler.y"
-    { bufferConcat(yyvsp[-2].action, yyvsp[0].action);
-                 bufferWriteOp(yyvsp[-2].action, SWFACTION_SHIFTLEFT); ;}
+    { bufferConcat((yyvsp[(1) - (3)].action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyvsp[(1) - (3)].action), SWFACTION_SHIFTLEFT); ;}
     break;
 
   case 234:
 #line 1147 "swf5compiler.y"
-    { bufferConcat(yyvsp[-2].action, yyvsp[0].action);
-                 bufferWriteOp(yyvsp[-2].action, SWFACTION_SHIFTRIGHT); ;}
+    { bufferConcat((yyvsp[(1) - (3)].action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyvsp[(1) - (3)].action), SWFACTION_SHIFTRIGHT); ;}
     break;
 
   case 235:
 #line 1151 "swf5compiler.y"
-    { bufferConcat(yyvsp[-2].action, yyvsp[0].action);
-                 bufferWriteOp(yyvsp[-2].action, SWFACTION_SHIFTRIGHT2); ;}
+    { bufferConcat((yyvsp[(1) - (3)].action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyvsp[(1) - (3)].action), SWFACTION_SHIFTRIGHT2); ;}
     break;
 
   case 236:
 #line 1155 "swf5compiler.y"
-    { bufferWriteOp(yyvsp[-4].action, SWFACTION_BRANCHIFTRUE);
-                 bufferWriteS16(yyvsp[-4].action, 2);
-                 bufferWriteS16(yyvsp[-4].action, bufferLength(yyvsp[0].action)+5);
-                 bufferConcat(yyvsp[-4].action, yyvsp[0].action);
-                 bufferWriteOp(yyvsp[-4].action, SWFACTION_BRANCHALWAYS);
-                 bufferWriteS16(yyvsp[-4].action, 2);
-                 bufferWriteS16(yyvsp[-4].action, bufferLength(yyvsp[-2].action));
-                 bufferConcat(yyvsp[-4].action, yyvsp[-2].action); ;}
+    { bufferWriteOp((yyvsp[(1) - (5)].action), SWFACTION_BRANCHIFTRUE);
+                 bufferWriteS16((yyvsp[(1) - (5)].action), 2);
+                 bufferWriteS16((yyvsp[(1) - (5)].action), bufferLength((yyvsp[(5) - (5)].action))+5);
+                 bufferConcat((yyvsp[(1) - (5)].action), (yyvsp[(5) - (5)].action));
+                 bufferWriteOp((yyvsp[(1) - (5)].action), SWFACTION_BRANCHALWAYS);
+                 bufferWriteS16((yyvsp[(1) - (5)].action), 2);
+                 bufferWriteS16((yyvsp[(1) - (5)].action), bufferLength((yyvsp[(3) - (5)].action)));
+                 bufferConcat((yyvsp[(1) - (5)].action), (yyvsp[(3) - (5)].action)); ;}
     break;
 
   case 237:
 #line 1165 "swf5compiler.y"
-    { if(yyvsp[-2].lval.obj) /* obj[memexpr] or obj.ident */
+    { if((yyvsp[(1) - (3)].lval).obj) /* obj[memexpr] or obj.ident */
                  {
-                   yyval.action = yyvsp[-2].lval.obj;
+                   (yyval.action) = (yyvsp[(1) - (3)].lval).obj;
 
-                   if(yyvsp[-2].lval.ident)
-                     bufferConcat(yyval.action, yyvsp[-2].lval.ident);
+                   if((yyvsp[(1) - (3)].lval).ident)
+                     bufferConcat((yyval.action), (yyvsp[(1) - (3)].lval).ident);
                    else
-                     bufferConcat(yyval.action, yyvsp[-2].lval.memexpr);
+                     bufferConcat((yyval.action), (yyvsp[(1) - (3)].lval).memexpr);
 
-                   bufferConcat(yyval.action, yyvsp[0].action);
-                   bufferWriteSetRegister(yyval.action, 0);
-                   bufferWriteOp(yyval.action, SWFACTION_SETMEMBER);
-                   bufferWriteRegister(yyval.action, 0);
+                   bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                   bufferWriteSetRegister((yyval.action), 0);
+                   bufferWriteOp((yyval.action), SWFACTION_SETMEMBER);
+                   bufferWriteRegister((yyval.action), 0);
                  }
                  else /* just ident */
                  {
-                   yyval.action = yyvsp[0].action;
-                   bufferWriteOp(yyval.action, SWFACTION_DUP);
-                   bufferConcat(yyval.action, yyvsp[-2].lval.ident);
-                   bufferWriteOp(yyval.action, SWFACTION_SWAP);
-                   bufferWriteOp(yyval.action, SWFACTION_SETVARIABLE);
+                   (yyval.action) = (yyvsp[(3) - (3)].action);
+                   bufferWriteOp((yyval.action), SWFACTION_DUP);
+                   bufferConcat((yyval.action), (yyvsp[(1) - (3)].lval).ident);
+                   bufferWriteOp((yyval.action), SWFACTION_SWAP);
+                   bufferWriteOp((yyval.action), SWFACTION_SETVARIABLE);
                  }
 /* tricky case missing here: lvalue ASSIGN expr */
 /* like in x = y += z; */
@@ -4338,209 +4678,209 @@ yyreduce:
 
   case 238:
 #line 1192 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_INSTANCEOF); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_INSTANCEOF); ;}
     break;
 
   case 240:
 #line 1202 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteInt(yyval.action, 0);
-                 bufferWriteString(yyval.action, yyvsp[0].str, strlen(yyvsp[0].str)+1);
-                 bufferWriteOp(yyval.action, SWFACTION_NEW); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteInt((yyval.action), 0);
+                 bufferWriteString((yyval.action), (yyvsp[(2) - (2)].str), strlen((yyvsp[(2) - (2)].str))+1);
+                 bufferWriteOp((yyval.action), SWFACTION_NEW); ;}
     break;
 
   case 241:
 #line 1208 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].exprlist.buffer;
-                 bufferWriteInt(yyval.action, yyvsp[-1].exprlist.count);
-                 bufferWriteString(yyval.action, yyvsp[-3].str, strlen(yyvsp[-3].str)+1);
-                 bufferWriteOp(yyval.action, SWFACTION_NEW); ;}
+    { (yyval.action) = (yyvsp[(4) - (5)].exprlist).buffer;
+                 bufferWriteInt((yyval.action), (yyvsp[(4) - (5)].exprlist).count);
+                 bufferWriteString((yyval.action), (yyvsp[(2) - (5)].str), strlen((yyvsp[(2) - (5)].str))+1);
+                 bufferWriteOp((yyval.action), SWFACTION_NEW); ;}
     break;
 
   case 242:
 #line 1214 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].exprlist.buffer;
-                 bufferWriteInt(yyval.action, yyvsp[-1].exprlist.count);
-                 bufferWriteOp(yyval.action, SWFACTION_INITARRAY); ;}
+    { (yyval.action) = (yyvsp[(2) - (3)].exprlist).buffer;
+                 bufferWriteInt((yyval.action), (yyvsp[(2) - (3)].exprlist).count);
+                 bufferWriteOp((yyval.action), SWFACTION_INITARRAY); ;}
     break;
 
   case 243:
 #line 1219 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteInt(yyval.action, 0);
-                 bufferWriteOp(yyval.action, SWFACTION_INITOBJECT); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteInt((yyval.action), 0);
+                 bufferWriteOp((yyval.action), SWFACTION_INITOBJECT); ;}
     break;
 
   case 244:
 #line 1224 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].exprlist.buffer;
-                 bufferWriteInt(yyval.action, yyvsp[-1].exprlist.count);
-                 bufferWriteOp(yyval.action, SWFACTION_INITOBJECT); ;}
+    { (yyval.action) = (yyvsp[(2) - (3)].exprlist).buffer;
+                 bufferWriteInt((yyval.action), (yyvsp[(2) - (3)].exprlist).count);
+                 bufferWriteOp((yyval.action), SWFACTION_INITOBJECT); ;}
     break;
 
   case 249:
 #line 1240 "swf5compiler.y"
-    { if(yyvsp[0].lval.obj)
+    { if((yyvsp[(2) - (2)].lval).obj)
                  {
-                   if(yyvsp[0].lval.ident)     // expr . identifier
+                   if((yyvsp[(2) - (2)].lval).ident)   // expr . identifier
                    {
-                     yyval.action = yyvsp[0].lval.obj;
-                     bufferWriteOp(yyval.action, SWFACTION_DUP);             /* a, a */
-                     bufferWriteBuffer(yyval.action, yyvsp[0].lval.ident);        /* a, a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i, a */
-                     bufferConcat(yyval.action, yyvsp[0].lval.ident);             /* a, i, a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_GETMEMBER);
-                     bufferWriteOp(yyval.action, yyvsp[-1].op);
-                     bufferWriteSetRegister(yyval.action, 0);
-                     bufferWriteOp(yyval.action, SWFACTION_SETMEMBER); /* a.i = a.i+1 */
-                     bufferWriteRegister(yyval.action, 0);           /* a.i+1 */
+                     (yyval.action) = (yyvsp[(2) - (2)].lval).obj;
+                     bufferWriteOp((yyval.action), SWFACTION_DUP);           /* a, a */
+                     bufferWriteBuffer((yyval.action), (yyvsp[(2) - (2)].lval).ident);        /* a, a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i, a */
+                     bufferConcat((yyval.action), (yyvsp[(2) - (2)].lval).ident);             /* a, i, a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_GETMEMBER);
+                     bufferWriteOp((yyval.action), (yyvsp[(1) - (2)].op));
+                     bufferWriteSetRegister((yyval.action), 0);
+                     bufferWriteOp((yyval.action), SWFACTION_SETMEMBER); /* a.i = a.i+1 */
+                     bufferWriteRegister((yyval.action), 0);         /* a.i+1 */
                    }
                    else        // expr [ expr ]
                    {
-                     yyval.action = yyvsp[0].lval.memexpr;                           /* i */
-                     bufferConcat(yyval.action, yyvsp[0].lval.obj);                  /* i, a */
-                     bufferWriteSetRegister(yyval.action, 0);  /* ($2.memexpr can use reg0) */
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_DUP);             /* a, i, i */
-                     bufferWriteRegister(yyval.action, 0);           /* a, i, i, a */
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i, a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_GETMEMBER); /* a, i, a[i] */
-                     bufferWriteOp(yyval.action, yyvsp[-1].op);                      /* a, i, a[i]+1 */
-                     bufferWriteSetRegister(yyval.action, 0);
-                     bufferWriteOp(yyval.action, SWFACTION_SETMEMBER); /* a[i] = a[i]+1 */
-                     bufferWriteRegister(yyval.action, 0);           /* a[i]+1 */
+                     (yyval.action) = (yyvsp[(2) - (2)].lval).memexpr;                       /* i */
+                     bufferConcat((yyval.action), (yyvsp[(2) - (2)].lval).obj);                      /* i, a */
+                     bufferWriteSetRegister((yyval.action), 0);        /* ($2.memexpr can use reg0) */
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_DUP);           /* a, i, i */
+                     bufferWriteRegister((yyval.action), 0);         /* a, i, i, a */
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i, a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_GETMEMBER); /* a, i, a[i] */
+                     bufferWriteOp((yyval.action), (yyvsp[(1) - (2)].op));                   /* a, i, a[i]+1 */
+                     bufferWriteSetRegister((yyval.action), 0);
+                     bufferWriteOp((yyval.action), SWFACTION_SETMEMBER); /* a[i] = a[i]+1 */
+                     bufferWriteRegister((yyval.action), 0);         /* a[i]+1 */
                    }
                  }
                  else  // identifier
                  {
-                   yyval.action = newBuffer();
-                   bufferWriteBuffer(yyval.action, yyvsp[0].lval.ident);
-                   bufferWriteOp(yyval.action, SWFACTION_GETVARIABLE);
-                   bufferWriteOp(yyval.action, yyvsp[-1].op);
-                   bufferWriteOp(yyval.action, SWFACTION_DUP);
-                   bufferConcat(yyval.action, yyvsp[0].lval.ident);
-                   bufferWriteOp(yyval.action, SWFACTION_SWAP);
-                   bufferWriteOp(yyval.action, SWFACTION_SETVARIABLE);
+                   (yyval.action) = newBuffer();
+                   bufferWriteBuffer((yyval.action), (yyvsp[(2) - (2)].lval).ident);
+                   bufferWriteOp((yyval.action), SWFACTION_GETVARIABLE);
+                   bufferWriteOp((yyval.action), (yyvsp[(1) - (2)].op));
+                   bufferWriteOp((yyval.action), SWFACTION_DUP);
+                   bufferConcat((yyval.action), (yyvsp[(2) - (2)].lval).ident);
+                   bufferWriteOp((yyval.action), SWFACTION_SWAP);
+                   bufferWriteOp((yyval.action), SWFACTION_SETVARIABLE);
                  }
                ;}
     break;
 
   case 250:
 #line 1285 "swf5compiler.y"
-    { if(yyvsp[-1].lval.obj)
+    { if((yyvsp[(1) - (2)].lval).obj)
                  {
-                   if(yyvsp[-1].lval.ident)
+                   if((yyvsp[(1) - (2)].lval).ident)
                    {
-                     yyval.action = yyvsp[-1].lval.obj;                              /* a */
-                     bufferWriteOp(yyval.action, SWFACTION_DUP);             /* a, a */
-                     bufferWriteBuffer(yyval.action, yyvsp[-1].lval.ident);        /* a, a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_GETMEMBER); /* a, a.i */
-                     bufferWriteSetRegister(yyval.action, 0);
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a.i, a */
-                     bufferConcat(yyval.action, yyvsp[-1].lval.ident);             /* a.i, a, i */
-                     bufferWriteRegister(yyval.action, 0);             /* a.i, a, i, a.i */
-                     bufferWriteOp(yyval.action, yyvsp[0].op);               /* a.i, a, i, a.i+1 */
-                     bufferWriteOp(yyval.action, SWFACTION_SETMEMBER);
+                     (yyval.action) = (yyvsp[(1) - (2)].lval).obj;                           /* a */
+                     bufferWriteOp((yyval.action), SWFACTION_DUP);           /* a, a */
+                     bufferWriteBuffer((yyval.action), (yyvsp[(1) - (2)].lval).ident);        /* a, a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_GETMEMBER); /* a, a.i */
+                     bufferWriteSetRegister((yyval.action), 0);
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a.i, a */
+                     bufferConcat((yyval.action), (yyvsp[(1) - (2)].lval).ident);             /* a.i, a, i */
+                     bufferWriteRegister((yyval.action), 0);             /* a.i, a, i, a.i */
+                     bufferWriteOp((yyval.action), (yyvsp[(2) - (2)].op));                   /* a.i, a, i, a.i+1 */
+                     bufferWriteOp((yyval.action), SWFACTION_SETMEMBER);
                    }
                    else
                    {
-                     yyval.action = yyvsp[-1].lval.memexpr;
-                     bufferConcat(yyval.action, yyvsp[-1].lval.obj);               /* i, a */
-                     bufferWriteSetRegister(yyval.action, 0);
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_DUP);             /* a, i, i */
-                     bufferWriteRegister(yyval.action, 0);             /* a, i, i, a */
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i, a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_GETMEMBER); /* a, i, a[i] */
-                     bufferWriteSetRegister(yyval.action, 0);
-                     bufferWriteOp(yyval.action, yyvsp[0].op);               /* a, i, a[i]+1 */
-                     bufferWriteOp(yyval.action, SWFACTION_SETMEMBER);
-                     bufferWriteRegister(yyval.action, 0);             /* a[i] */
+                     (yyval.action) = (yyvsp[(1) - (2)].lval).memexpr;
+                     bufferConcat((yyval.action), (yyvsp[(1) - (2)].lval).obj);               /* i, a */
+                     bufferWriteSetRegister((yyval.action), 0);
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_DUP);           /* a, i, i */
+                     bufferWriteRegister((yyval.action), 0);             /* a, i, i, a */
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i, a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_GETMEMBER); /* a, i, a[i] */
+                     bufferWriteSetRegister((yyval.action), 0);
+                     bufferWriteOp((yyval.action), (yyvsp[(2) - (2)].op));                   /* a, i, a[i]+1 */
+                     bufferWriteOp((yyval.action), SWFACTION_SETMEMBER);
+                     bufferWriteRegister((yyval.action), 0);             /* a[i] */
                    }
                  }
                  else
                  {
-                   yyval.action = newBuffer();
-                   bufferWriteBuffer(yyval.action, yyvsp[-1].lval.ident);
-                   bufferWriteOp(yyval.action, SWFACTION_GETVARIABLE);
-                   bufferWriteOp(yyval.action, SWFACTION_DUP);
-                   bufferWriteOp(yyval.action, yyvsp[0].op);
-                   bufferConcat(yyval.action, yyvsp[-1].lval.ident);
-                   bufferWriteOp(yyval.action, SWFACTION_SWAP);
-                   bufferWriteOp(yyval.action, SWFACTION_SETVARIABLE);
+                   (yyval.action) = newBuffer();
+                   bufferWriteBuffer((yyval.action), (yyvsp[(1) - (2)].lval).ident);
+                   bufferWriteOp((yyval.action), SWFACTION_GETVARIABLE);
+                   bufferWriteOp((yyval.action), SWFACTION_DUP);
+                   bufferWriteOp((yyval.action), (yyvsp[(2) - (2)].op));
+                   bufferConcat((yyval.action), (yyvsp[(1) - (2)].lval).ident);
+                   bufferWriteOp((yyval.action), SWFACTION_SWAP);
+                   bufferWriteOp((yyval.action), SWFACTION_SETVARIABLE);
                  }
                ;}
     break;
 
   case 251:
 #line 1330 "swf5compiler.y"
-    { yyval.action = yyvsp[-1].action; ;}
+    { (yyval.action) = (yyvsp[(2) - (3)].action); ;}
     break;
 
   case 252:
 #line 1333 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteInt(yyval.action, -yyvsp[0].intVal); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteInt((yyval.action), -(yyvsp[(2) - (2)].intVal)); ;}
     break;
 
   case 253:
 #line 1337 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteInt(yyval.action, yyvsp[0].intVal); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteInt((yyval.action), (yyvsp[(1) - (1)].intVal)); ;}
     break;
 
   case 254:
 #line 1341 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteDouble(yyval.action, -yyvsp[0].doubleVal); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteDouble((yyval.action), -(yyvsp[(2) - (2)].doubleVal)); ;}
     break;
 
   case 255:
 #line 1345 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteDouble(yyval.action, yyvsp[0].doubleVal); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteDouble((yyval.action), (yyvsp[(1) - (1)].doubleVal)); ;}
     break;
 
   case 256:
 #line 1349 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteBoolean(yyval.action, yyvsp[0].intVal); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteBoolean((yyval.action), (yyvsp[(1) - (1)].intVal)); ;}
     break;
 
   case 257:
 #line 1353 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteNull(yyval.action); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteNull((yyval.action)); ;}
     break;
 
   case 258:
 #line 1357 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteString(yyval.action, yyvsp[0].str, strlen(yyvsp[0].str)+1);
-                 free(yyvsp[0].str); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteString((yyval.action), (yyvsp[(1) - (1)].str), strlen((yyvsp[(1) - (1)].str))+1);
+                 free((yyvsp[(1) - (1)].str)); ;}
     break;
 
   case 260:
 #line 1366 "swf5compiler.y"
-    { yyval.action = yyvsp[-2].action;
-                 bufferConcat(yyval.action, yyvsp[0].action); ;}
+    { (yyval.action) = (yyvsp[(1) - (3)].action);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action)); ;}
     break;
 
   case 261:
 #line 1372 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteString(yyval.action, yyvsp[-2].str, strlen(yyvsp[-2].str)+1);
-                 bufferConcat(yyval.action, yyvsp[0].action);
-                 bufferWriteOp(yyval.action, SWFACTION_VAREQUALS); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteString((yyval.action), (yyvsp[(1) - (3)].str), strlen((yyvsp[(1) - (3)].str))+1);
+                 bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                 bufferWriteOp((yyval.action), SWFACTION_VAREQUALS); ;}
     break;
 
   case 262:
 #line 1378 "swf5compiler.y"
-    { yyval.action = newBuffer();
-                 bufferWriteString(yyval.action, yyvsp[0].str, strlen(yyvsp[0].str)+1);
-                 bufferWriteOp(yyval.action, SWFACTION_VAR); ;}
+    { (yyval.action) = newBuffer();
+                 bufferWriteString((yyval.action), (yyvsp[(1) - (1)].str), strlen((yyvsp[(1) - (1)].str))+1);
+                 bufferWriteOp((yyval.action), SWFACTION_VAR); ;}
     break;
 
   case 263:
@@ -4550,599 +4890,598 @@ yyreduce:
 
   case 264:
 #line 1387 "swf5compiler.y"
-    { yyval.action = asmBuffer; ;}
+    { (yyval.action) = asmBuffer; ;}
     break;
 
   case 265:
 #line 1390 "swf5compiler.y"
-    { yyval.action = yyvsp[0].action; ;}
+    { (yyval.action) = (yyvsp[(2) - (2)].action); ;}
     break;
 
   case 267:
 #line 1395 "swf5compiler.y"
-    { yyval.action = yyvsp[0].action;
-                 bufferWriteOp(yyval.action, SWFACTION_POP); ;}
+    { (yyval.action) = (yyvsp[(1) - (1)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_POP); ;}
     break;
 
   case 268:
 #line 1399 "swf5compiler.y"
-    { yyval.action = yyvsp[0].action;
-                 bufferWriteOp(yyval.action, SWFACTION_POP); ;}
+    { (yyval.action) = (yyvsp[(1) - (1)].action);
+                 bufferWriteOp((yyval.action), SWFACTION_POP); ;}
     break;
 
   case 269:
 #line 1403 "swf5compiler.y"
-    { if(yyvsp[0].lval.obj)
+    { if((yyvsp[(2) - (2)].lval).obj)
                  {
-                   if(yyvsp[0].lval.ident)
+                   if((yyvsp[(2) - (2)].lval).ident)
                    {
-                     yyval.action = yyvsp[0].lval.obj;                       /* a */
-                     bufferWriteOp(yyval.action, SWFACTION_DUP);             /* a, a */
-                     bufferWriteBuffer(yyval.action, yyvsp[0].lval.ident);           /* a, a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_GETMEMBER); /* a, a.i */
-                     bufferWriteOp(yyval.action, yyvsp[-1].op);                      /* a, a.i+1 */
-                     bufferConcat(yyval.action, yyvsp[0].lval.ident);        /* a, a.i+1, i */
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i, a.i+1 */
-                     bufferWriteOp(yyval.action, SWFACTION_SETMEMBER); /* a.i = a.i+1 */
+                     (yyval.action) = (yyvsp[(2) - (2)].lval).obj;                           /* a */
+                     bufferWriteOp((yyval.action), SWFACTION_DUP);           /* a, a */
+                     bufferWriteBuffer((yyval.action), (yyvsp[(2) - (2)].lval).ident);       /* a, a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_GETMEMBER); /* a, a.i */
+                     bufferWriteOp((yyval.action), (yyvsp[(1) - (2)].op));                   /* a, a.i+1 */
+                     bufferConcat((yyval.action), (yyvsp[(2) - (2)].lval).ident);            /* a, a.i+1, i */
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i, a.i+1 */
+                     bufferWriteOp((yyval.action), SWFACTION_SETMEMBER); /* a.i = a.i+1 */
                    }
                    else
                    {
                      /* weird contortions so that $2.memexpr can use reg 0 */
-                     yyval.action = yyvsp[0].lval.memexpr;                           /* i */
-                     bufferConcat(yyval.action, yyvsp[0].lval.obj);                  /* i, a */
-                     bufferWriteSetRegister(yyval.action, 0);
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_DUP);             /* a, i, i */
-                     bufferWriteRegister(yyval.action, 0);           /* a, i, i, a */
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i, a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_GETMEMBER); /* a, i, a[i] */
-                     bufferWriteOp(yyval.action, yyvsp[-1].op);                      /* a, i, a[i]+1 */
-                     bufferWriteOp(yyval.action, SWFACTION_SETMEMBER); /* a[i] = a[i]+1 */
+                     (yyval.action) = (yyvsp[(2) - (2)].lval).memexpr;                       /* i */
+                     bufferConcat((yyval.action), (yyvsp[(2) - (2)].lval).obj);                      /* i, a */
+                     bufferWriteSetRegister((yyval.action), 0);
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_DUP);           /* a, i, i */
+                     bufferWriteRegister((yyval.action), 0);         /* a, i, i, a */
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i, a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_GETMEMBER); /* a, i, a[i] */
+                     bufferWriteOp((yyval.action), (yyvsp[(1) - (2)].op));                   /* a, i, a[i]+1 */
+                     bufferWriteOp((yyval.action), SWFACTION_SETMEMBER); /* a[i] = a[i]+1 */
                    }
                  }
                  else
                  {
-                   yyval.action = yyvsp[0].lval.ident;
-                   bufferWriteOp(yyval.action, SWFACTION_DUP);
-                   bufferWriteOp(yyval.action, SWFACTION_GETVARIABLE);
-                   bufferWriteOp(yyval.action, yyvsp[-1].op);
-                   bufferWriteOp(yyval.action, SWFACTION_SETVARIABLE);
+                   (yyval.action) = (yyvsp[(2) - (2)].lval).ident;
+                   bufferWriteOp((yyval.action), SWFACTION_DUP);
+                   bufferWriteOp((yyval.action), SWFACTION_GETVARIABLE);
+                   bufferWriteOp((yyval.action), (yyvsp[(1) - (2)].op));
+                   bufferWriteOp((yyval.action), SWFACTION_SETVARIABLE);
                  }
                ;}
     break;
 
   case 270:
 #line 1442 "swf5compiler.y"
-    { if(yyvsp[-1].lval.obj)
+    { if((yyvsp[(1) - (2)].lval).obj)
                  {
-                   if(yyvsp[-1].lval.ident)
+                   if((yyvsp[(1) - (2)].lval).ident)
                    {
-                     yyval.action = yyvsp[-1].lval.obj;                              /* a */
-                     bufferWriteOp(yyval.action, SWFACTION_DUP);       /* a, a */
-                     bufferWriteBuffer(yyval.action, yyvsp[-1].lval.ident);          /* a, a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_GETMEMBER); /* a, a.i */
-                     bufferWriteOp(yyval.action, yyvsp[0].op);                  /* a, a.i+1 */
-                     bufferConcat(yyval.action, yyvsp[-1].lval.ident);             /* a, a.i+1, i */
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i, a.i+1 */
-                     bufferWriteOp(yyval.action, SWFACTION_SETMEMBER); /* a.i = a.i+1 */
+                     (yyval.action) = (yyvsp[(1) - (2)].lval).obj;                           /* a */
+                     bufferWriteOp((yyval.action), SWFACTION_DUP);       /* a, a */
+                     bufferWriteBuffer((yyval.action), (yyvsp[(1) - (2)].lval).ident);       /* a, a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_GETMEMBER); /* a, a.i */
+                     bufferWriteOp((yyval.action), (yyvsp[(2) - (2)].op));                  /* a, a.i+1 */
+                     bufferConcat((yyval.action), (yyvsp[(1) - (2)].lval).ident);             /* a, a.i+1, i */
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i, a.i+1 */
+                     bufferWriteOp((yyval.action), SWFACTION_SETMEMBER); /* a.i = a.i+1 */
                    }
                    else
                    {
                      /* weird contortions so that $1.memexpr can use reg 0 */
-                     yyval.action = yyvsp[-1].lval.memexpr;    /* i */
-                     bufferConcat(yyval.action, yyvsp[-1].lval.obj);                 /* i, a */
-                     bufferWriteSetRegister(yyval.action, 0);
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_DUP);       /* a, i, i */
-                     bufferWriteRegister(yyval.action, 0);             /* a, i, i, a */
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i, a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_GETMEMBER); /* a, i, a[i] */
-                     bufferWriteOp(yyval.action, yyvsp[0].op);                  /* a, i, a[i]+1 */
-                     bufferWriteOp(yyval.action, SWFACTION_SETMEMBER); /* a[i] = a[i]+1 */
+                     (yyval.action) = (yyvsp[(1) - (2)].lval).memexpr; /* i */
+                     bufferConcat((yyval.action), (yyvsp[(1) - (2)].lval).obj);                      /* i, a */
+                     bufferWriteSetRegister((yyval.action), 0);
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_DUP);       /* a, i, i */
+                     bufferWriteRegister((yyval.action), 0);             /* a, i, i, a */
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i, a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_GETMEMBER); /* a, i, a[i] */
+                     bufferWriteOp((yyval.action), (yyvsp[(2) - (2)].op));                  /* a, i, a[i]+1 */
+                     bufferWriteOp((yyval.action), SWFACTION_SETMEMBER); /* a[i] = a[i]+1 */
                    }
                  }
                  else
                  {
-                   yyval.action = yyvsp[-1].lval.ident;
-                   bufferWriteOp(yyval.action, SWFACTION_DUP); 
-                   bufferWriteOp(yyval.action, SWFACTION_GETVARIABLE);
-                   bufferWriteOp(yyval.action, yyvsp[0].op);
-                   bufferWriteOp(yyval.action, SWFACTION_SETVARIABLE);
+                   (yyval.action) = (yyvsp[(1) - (2)].lval).ident;
+                   bufferWriteOp((yyval.action), SWFACTION_DUP);       
+                   bufferWriteOp((yyval.action), SWFACTION_GETVARIABLE);
+                   bufferWriteOp((yyval.action), (yyvsp[(2) - (2)].op));
+                   bufferWriteOp((yyval.action), SWFACTION_SETVARIABLE);
                  }
                ;}
     break;
 
   case 271:
 #line 1481 "swf5compiler.y"
-    { if(yyvsp[-2].lval.obj)
+    { if((yyvsp[(1) - (3)].lval).obj)
                  {
-                   yyval.action = yyvsp[-2].lval.obj;
+                   (yyval.action) = (yyvsp[(1) - (3)].lval).obj;
 
-                   if(yyvsp[-2].lval.ident)
-                     bufferConcat(yyval.action, yyvsp[-2].lval.ident);
+                   if((yyvsp[(1) - (3)].lval).ident)
+                     bufferConcat((yyval.action), (yyvsp[(1) - (3)].lval).ident);
                    else
-                     bufferConcat(yyval.action, yyvsp[-2].lval.memexpr);
+                     bufferConcat((yyval.action), (yyvsp[(1) - (3)].lval).memexpr);
 
-                   bufferConcat(yyval.action, yyvsp[0].action);
-                   bufferWriteOp(yyval.action, SWFACTION_SETMEMBER);
+                   bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                   bufferWriteOp((yyval.action), SWFACTION_SETMEMBER);
                  }
                  else
                  {
-                   yyval.action = yyvsp[-2].lval.ident;
-                   bufferConcat(yyval.action, yyvsp[0].action);
-                   bufferWriteOp(yyval.action, SWFACTION_SETVARIABLE);
+                   (yyval.action) = (yyvsp[(1) - (3)].lval).ident;
+                   bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                   bufferWriteOp((yyval.action), SWFACTION_SETVARIABLE);
                  }
                ;}
     break;
 
   case 272:
 #line 1502 "swf5compiler.y"
-    { if(yyvsp[-2].lval.obj)
+    { if((yyvsp[(1) - (3)].lval).obj)
                  {
-                   if(yyvsp[-2].lval.ident)
+                   if((yyvsp[(1) - (3)].lval).ident)
                    {
-                     yyval.action = yyvsp[-2].lval.obj;                              /* a */
-                     bufferWriteOp(yyval.action, SWFACTION_DUP);             /* a, a */
-                     bufferWriteBuffer(yyval.action, yyvsp[-2].lval.ident);          /* a, a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_GETMEMBER); /* a, a.i */
-                     bufferConcat(yyval.action, yyvsp[0].action);                    /* a, a.i, v */
-                     bufferWriteOp(yyval.action, yyvsp[-1].op);                      /* a, a.i+v */
-                     bufferConcat(yyval.action, yyvsp[-2].lval.ident);       /* a, a.i+v, i */
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i, a.i+v */
-                     bufferWriteOp(yyval.action, SWFACTION_SETMEMBER); /* a.i = a.i+v */
+                     (yyval.action) = (yyvsp[(1) - (3)].lval).obj;                           /* a */
+                     bufferWriteOp((yyval.action), SWFACTION_DUP);           /* a, a */
+                     bufferWriteBuffer((yyval.action), (yyvsp[(1) - (3)].lval).ident);       /* a, a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_GETMEMBER); /* a, a.i */
+                     bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));                /* a, a.i, v */
+                     bufferWriteOp((yyval.action), (yyvsp[(2) - (3)].op));                   /* a, a.i+v */
+                     bufferConcat((yyval.action), (yyvsp[(1) - (3)].lval).ident);            /* a, a.i+v, i */
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i, a.i+v */
+                     bufferWriteOp((yyval.action), SWFACTION_SETMEMBER); /* a.i = a.i+v */
                    }
                    else
                    {
-                     yyval.action = yyvsp[-2].lval.memexpr;                          /* i */
-                     bufferConcat(yyval.action, yyvsp[-2].lval.obj);                 /* i, a */
-                     bufferWriteSetRegister(yyval.action, 0);
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_DUP);             /* a, i, i */
-                     bufferWriteRegister(yyval.action, 0);           /* a, i, i, a */
-                     bufferWriteOp(yyval.action, SWFACTION_SWAP);      /* a, i, a, i */
-                     bufferWriteOp(yyval.action, SWFACTION_GETMEMBER); /* a, i, a[i] */
-                     bufferConcat(yyval.action, yyvsp[0].action);                    /* a, i, a[i], v */
-                     bufferWriteOp(yyval.action, yyvsp[-1].op);                      /* a, i, a[i]+v */
-                     bufferWriteOp(yyval.action, SWFACTION_SETMEMBER); /* a[i] = a[i]+v */
+                     (yyval.action) = (yyvsp[(1) - (3)].lval).memexpr;                       /* i */
+                     bufferConcat((yyval.action), (yyvsp[(1) - (3)].lval).obj);                      /* i, a */
+                     bufferWriteSetRegister((yyval.action), 0);
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_DUP);           /* a, i, i */
+                     bufferWriteRegister((yyval.action), 0);         /* a, i, i, a */
+                     bufferWriteOp((yyval.action), SWFACTION_SWAP);      /* a, i, a, i */
+                     bufferWriteOp((yyval.action), SWFACTION_GETMEMBER); /* a, i, a[i] */
+                     bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));                /* a, i, a[i], v */
+                     bufferWriteOp((yyval.action), (yyvsp[(2) - (3)].op));                   /* a, i, a[i]+v */
+                     bufferWriteOp((yyval.action), SWFACTION_SETMEMBER); /* a[i] = a[i]+v */
                    }
                  }
                  else
                  {
-                   yyval.action = yyvsp[-2].lval.ident;
-                   bufferWriteOp(yyval.action, SWFACTION_DUP);
-                   bufferWriteOp(yyval.action, SWFACTION_GETVARIABLE);
-                   bufferConcat(yyval.action, yyvsp[0].action);
-                   bufferWriteOp(yyval.action, yyvsp[-1].op);
-                   bufferWriteOp(yyval.action, SWFACTION_SETVARIABLE);
+                   (yyval.action) = (yyvsp[(1) - (3)].lval).ident;
+                   bufferWriteOp((yyval.action), SWFACTION_DUP);
+                   bufferWriteOp((yyval.action), SWFACTION_GETVARIABLE);
+                   bufferConcat((yyval.action), (yyvsp[(3) - (3)].action));
+                   bufferWriteOp((yyval.action), (yyvsp[(2) - (3)].op));
+                   bufferWriteOp((yyval.action), SWFACTION_SETVARIABLE);
                  }
                ;}
     break;
 
   case 274:
 #line 1547 "swf5compiler.y"
-    { yyval.len = yyvsp[-1].len + yyvsp[0].len; ;}
+    { (yyval.len) = (yyvsp[(1) - (2)].len) + (yyvsp[(2) - (2)].len); ;}
     break;
 
   case 275:
 #line 1552 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer,
+    { (yyval.len) = bufferWriteOp(asmBuffer,
                                                     SWFACTION_WITH); ;}
     break;
 
   case 276:
 #line 1554 "swf5compiler.y"
-    { yyval.len = yyvsp[-2].len + yyvsp[-1].len;
-                                 bufferPatchLength(asmBuffer, yyvsp[-1].len); ;}
+    { (yyval.len) = (yyvsp[(2) - (4)].len) + (yyvsp[(3) - (4)].len);
+                                 bufferPatchLength(asmBuffer, (yyvsp[(3) - (4)].len)); ;}
     break;
 
   case 277:
 #line 1559 "swf5compiler.y"
-    { yyval.len = bufferWriteConstantString(asmBuffer,(byte*) yyvsp[0].str,
-                                                                strlen(yyvsp[0].str)+1); ;}
+    { (yyval.len) = bufferWriteConstantString(asmBuffer,(byte*) (yyvsp[(1) - (1)].str),
+                                                                strlen((yyvsp[(1) - (1)].str))+1); ;}
     break;
 
   case 278:
 #line 1562 "swf5compiler.y"
     { bufferWriteU8(asmBuffer, PUSH_INT);
-                                 yyval.len = bufferWriteInt(asmBuffer, yyvsp[0].intVal)+1; ;}
+                                 (yyval.len) = bufferWriteInt(asmBuffer, (yyvsp[(1) - (1)].intVal))+1; ;}
     break;
 
   case 279:
 #line 1565 "swf5compiler.y"
     { bufferWriteU8(asmBuffer, PUSH_DOUBLE);
-                                 yyval.len = bufferWriteDouble(asmBuffer, yyvsp[0].doubleVal)+1; ;}
+                                 (yyval.len) = bufferWriteDouble(asmBuffer, (yyvsp[(1) - (1)].doubleVal))+1; ;}
     break;
 
   case 280:
 #line 1568 "swf5compiler.y"
     { bufferWriteU8(asmBuffer, PUSH_BOOLEAN);
-                                 yyval.len = bufferWriteU8(asmBuffer, yyvsp[0].intVal)+1; ;}
+                                 (yyval.len) = bufferWriteU8(asmBuffer, (yyvsp[(1) - (1)].intVal))+1; ;}
     break;
 
   case 281:
 #line 1571 "swf5compiler.y"
-    { yyval.len = bufferWriteU8(asmBuffer, PUSH_NULL); ;}
+    { (yyval.len) = bufferWriteU8(asmBuffer, PUSH_NULL); ;}
     break;
 
   case 282:
 #line 1573 "swf5compiler.y"
     { bufferWriteU8(asmBuffer, PUSH_REGISTER);
-                                 yyval.len = bufferWriteU8(asmBuffer,
-                                                    (char)atoi(yyvsp[0].str))+1; ;}
+                                 (yyval.len) = bufferWriteU8(asmBuffer,
+                                                    (char)atoi((yyvsp[(1) - (1)].str)))+1; ;}
     break;
 
   case 283:
 #line 1580 "swf5compiler.y"
-    { yyval.len = yyvsp[0].len; ;}
+    { (yyval.len) = (yyvsp[(1) - (1)].len); ;}
     break;
 
   case 284:
 #line 1581 "swf5compiler.y"
-    { yyval.len += yyvsp[0].len; ;}
+    { (yyval.len) += (yyvsp[(3) - (3)].len); ;}
     break;
 
   case 285:
 #line 1585 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer,
+    { (yyval.len) = bufferWriteOp(asmBuffer,
                                                     SWFACTION_PUSHDATA);
-                                 yyval.len += bufferWriteS16(asmBuffer, 0); ;}
+                                 (yyval.len) += bufferWriteS16(asmBuffer, 0); ;}
     break;
 
   case 286:
 #line 1588 "swf5compiler.y"
-    { yyval.len = yyvsp[-1].len + yyvsp[0].len;
-                                 bufferPatchLength(asmBuffer, yyvsp[0].len); ;}
+    { (yyval.len) = (yyvsp[(2) - (3)].len) + (yyvsp[(3) - (3)].len);
+                                 bufferPatchLength(asmBuffer, (yyvsp[(3) - (3)].len)); ;}
     break;
 
   case 288:
 #line 1594 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_SETREGISTER);
-                                 yyval.len += bufferWriteS16(asmBuffer, 1);
-                                 yyval.len += bufferWriteU8(asmBuffer,
-                                                     (char)atoi(yyvsp[0].str)); ;}
+                                 (yyval.len) += bufferWriteS16(asmBuffer, 1);
+                                 (yyval.len) += bufferWriteU8(asmBuffer,
+                                                     (char)atoi((yyvsp[(2) - (2)].str))); ;}
     break;
 
   case 289:
 #line 1600 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer,
+    { (yyval.len) = bufferWriteOp(asmBuffer,
                                                     SWFACTION_CALLFUNCTION); ;}
     break;
 
   case 290:
 #line 1602 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer,
+    { (yyval.len) = bufferWriteOp(asmBuffer,
                                                     SWFACTION_RETURN); ;}
     break;
 
   case 291:
 #line 1604 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_CALLMETHOD); ;}
     break;
 
   case 292:
 #line 1606 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_BITWISEAND); ;}
     break;
 
   case 293:
 #line 1608 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_BITWISEOR); ;}
     break;
 
   case 294:
 #line 1610 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_BITWISEXOR); ;}
     break;
 
   case 295:
 #line 1612 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_MODULO); ;}
     break;
 
   case 296:
 #line 1614 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_NEWADD); ;}
     break;
 
   case 297:
 #line 1616 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_NEWLESSTHAN); ;}
     break;
 
   case 298:
 #line 1618 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_NEWEQUALS); ;}
     break;
 
   case 299:
 #line 1620 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_INCREMENT); ;}
     break;
 
   case 300:
 #line 1622 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_DECREMENT); ;}
     break;
 
   case 301:
 #line 1624 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_TYPEOF); ;}
     break;
 
   case 302:
 #line 1626 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_INSTANCEOF); ;}
     break;
 
   case 303:
 #line 1628 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_ENUMERATE); ;}
     break;
 
   case 304:
 #line 1630 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_DELETE); ;}
     break;
 
   case 305:
 #line 1632 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_NEW); ;}
     break;
 
   case 306:
 #line 1634 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_INITARRAY); ;}
     break;
 
   case 307:
 #line 1636 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_INITOBJECT); ;}
     break;
 
   case 308:
 #line 1638 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_GETMEMBER); ;}
     break;
 
   case 309:
 #line 1640 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_SETMEMBER); ;}
     break;
 
   case 310:
 #line 1642 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_SHIFTLEFT); ;}
     break;
 
   case 311:
 #line 1644 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_SHIFTRIGHT); ;}
     break;
 
   case 312:
 #line 1646 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_SHIFTRIGHT2); ;}
     break;
 
   case 313:
 #line 1648 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_VAR); ;}
     break;
 
   case 314:
 #line 1650 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, 
+    { (yyval.len) = bufferWriteOp(asmBuffer, 
                                                     SWFACTION_VAREQUALS); ;}
     break;
 
   case 315:
 #line 1654 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_ADD); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_ADD); ;}
     break;
 
   case 316:
 #line 1655 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_SUBTRACT); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_SUBTRACT); ;}
     break;
 
   case 317:
 #line 1656 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_MULTIPLY); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_MULTIPLY); ;}
     break;
 
   case 318:
 #line 1657 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_DIVIDE); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_DIVIDE); ;}
     break;
 
   case 319:
 #line 1658 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_EQUAL); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_EQUAL); ;}
     break;
 
   case 320:
 #line 1659 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_LESSTHAN); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_LESSTHAN); ;}
     break;
 
   case 321:
 #line 1660 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_LOGICALAND); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_LOGICALAND); ;}
     break;
 
   case 322:
 #line 1661 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_LOGICALOR); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_LOGICALOR); ;}
     break;
 
   case 323:
 #line 1662 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_LOGICALNOT); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_LOGICALNOT); ;}
     break;
 
   case 324:
 #line 1663 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_STRINGEQ); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_STRINGEQ); ;}
     break;
 
   case 325:
 #line 1664 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_STRINGLENGTH); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_STRINGLENGTH); ;}
     break;
 
   case 326:
 #line 1665 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_SUBSTRING); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_SUBSTRING); ;}
     break;
 
   case 327:
 #line 1666 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_INT); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_INT); ;}
     break;
 
   case 328:
 #line 1667 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_DUP); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_DUP); ;}
     break;
 
   case 329:
 #line 1668 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_SWAP); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_SWAP); ;}
     break;
 
   case 330:
 #line 1669 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_POP); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_POP); ;}
     break;
 
   case 331:
 #line 1670 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_GETVARIABLE); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_GETVARIABLE); ;}
     break;
 
   case 332:
 #line 1671 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_SETVARIABLE); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_SETVARIABLE); ;}
     break;
 
   case 333:
 #line 1672 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_SETTARGETEXPRESSION); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_SETTARGETEXPRESSION); ;}
     break;
 
   case 334:
 #line 1673 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_STRINGCONCAT); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_STRINGCONCAT); ;}
     break;
 
   case 335:
 #line 1674 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_DUPLICATECLIP); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_DUPLICATECLIP); ;}
     break;
 
   case 336:
 #line 1675 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_REMOVECLIP); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_REMOVECLIP); ;}
     break;
 
   case 337:
 #line 1676 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_TRACE); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_TRACE); ;}
     break;
 
   case 338:
 #line 1677 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_STRINGCOMPARE); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_STRINGCOMPARE); ;}
     break;
 
   case 339:
 #line 1678 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_RANDOM); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_RANDOM); ;}
     break;
 
   case 340:
 #line 1679 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_MBLENGTH); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_MBLENGTH); ;}
     break;
 
   case 341:
 #line 1680 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_ORD); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_ORD); ;}
     break;
 
   case 342:
 #line 1681 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_CHR); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_CHR); ;}
     break;
 
   case 343:
 #line 1682 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_GETTIMER); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_GETTIMER); ;}
     break;
 
   case 344:
 #line 1683 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_MBSUBSTRING); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_MBSUBSTRING); ;}
     break;
 
   case 345:
 #line 1684 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_MBORD); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_MBORD); ;}
     break;
 
   case 346:
 #line 1685 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_MBCHR); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_MBCHR); ;}
     break;
 
   case 347:
 #line 1688 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_BRANCHALWAYS);
-                                 yyval.len += bufferWriteS16(asmBuffer, 2);
-                                 yyval.len += bufferBranchTarget(asmBuffer, yyvsp[0].str); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_BRANCHALWAYS);
+                                 (yyval.len) += bufferWriteS16(asmBuffer, 2);
+                                 (yyval.len) += bufferBranchTarget(asmBuffer, (yyvsp[(2) - (2)].str)); ;}
     break;
 
   case 348:
 #line 1692 "swf5compiler.y"
-    { yyval.len = bufferWriteOp(asmBuffer, SWFACTION_BRANCHIFTRUE);
-                                 yyval.len += bufferWriteS16(asmBuffer, 2);
-                                 yyval.len += bufferBranchTarget(asmBuffer, yyvsp[0].str); ;}
+    { (yyval.len) = bufferWriteOp(asmBuffer, SWFACTION_BRANCHIFTRUE);
+                                 (yyval.len) += bufferWriteS16(asmBuffer, 2);
+                                 (yyval.len) += bufferBranchTarget(asmBuffer, (yyvsp[(2) - (2)].str)); ;}
     break;
 
 
+/* Line 1267 of yacc.c.  */
+#line 5479 "swf5compiler.tab.c"
+      default: break;
     }
+  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
 
-/* Line 999 of yacc.c.  */
-#line 5140 "swf5compiler.tab.c"
-\f
-  yyvsp -= yylen;
-  yyssp -= yylen;
-
-
+  YYPOPSTACK (yylen);
+  yylen = 0;
   YY_STACK_PRINT (yyss, yyssp);
 
   *++yyvsp = yyval;
@@ -5171,92 +5510,92 @@ yyerrlab:
   if (!yyerrstatus)
     {
       ++yynerrs;
-#if YYERROR_VERBOSE
-      yyn = yypact[yystate];
-
-      if (YYPACT_NINF < yyn && yyn < YYLAST)
-       {
-         YYSIZE_T yysize = 0;
-         int yytype = YYTRANSLATE (yychar);
-         char *yymsg;
-         int yyx, yycount;
-
-         yycount = 0;
-         /* Start YYX at -YYN if negative to avoid negative indexes in
-            YYCHECK.  */
-         for (yyx = yyn < 0 ? -yyn : 0;
-              yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
-           if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-             yysize += yystrlen (yytname[yyx]) + 15, yycount++;
-         yysize += yystrlen ("syntax error, unexpected ") + 1;
-         yysize += yystrlen (yytname[yytype]);
-         yymsg = (char *) YYSTACK_ALLOC (yysize);
-         if (yymsg != 0)
-           {
-             char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
-             yyp = yystpcpy (yyp, yytname[yytype]);
-
-             if (yycount < 5)
-               {
-                 yycount = 0;
-                 for (yyx = yyn < 0 ? -yyn : 0;
-                      yyx < (int) (sizeof (yytname) / sizeof (char *));
-                      yyx++)
-                   if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-                     {
-                       const char *yyq = ! yycount ? ", expecting " : " or ";
-                       yyp = yystpcpy (yyp, yyq);
-                       yyp = yystpcpy (yyp, yytname[yyx]);
-                       yycount++;
-                     }
-               }
-             yyerror (yymsg);
+#if ! YYERROR_VERBOSE
+      yyerror (YY_("syntax error"));
+#else
+      {
+       YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
+       if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
+         {
+           YYSIZE_T yyalloc = 2 * yysize;
+           if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
+             yyalloc = YYSTACK_ALLOC_MAXIMUM;
+           if (yymsg != yymsgbuf)
              YYSTACK_FREE (yymsg);
-           }
-         else
-           yyerror ("syntax error; also virtual memory exhausted");
-       }
-      else
-#endif /* YYERROR_VERBOSE */
-       yyerror ("syntax error");
+           yymsg = (char *) YYSTACK_ALLOC (yyalloc);
+           if (yymsg)
+             yymsg_alloc = yyalloc;
+           else
+             {
+               yymsg = yymsgbuf;
+               yymsg_alloc = sizeof yymsgbuf;
+             }
+         }
+
+       if (0 < yysize && yysize <= yymsg_alloc)
+         {
+           (void) yysyntax_error (yymsg, yystate, yychar);
+           yyerror (yymsg);
+         }
+       else
+         {
+           yyerror (YY_("syntax error"));
+           if (yysize != 0)
+             goto yyexhaustedlab;
+         }
+      }
+#endif
     }
 
 
 
   if (yyerrstatus == 3)
     {
-      /* If just tried and failed to reuse lookahead token after an
+      /* If just tried and failed to reuse look-ahead token after an
         error, discard it.  */
 
-      /* Return failure if at end of input.  */
-      if (yychar == YYEOF)
-        {
-         /* Pop the error token.  */
-          YYPOPSTACK;
-         /* Pop the rest of the stack.  */
-         while (yyss < yyssp)
-           {
-             YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
-             yydestruct (yystos[*yyssp], yyvsp);
-             YYPOPSTACK;
-           }
-         YYABORT;
-        }
-
-      YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
-      yydestruct (yytoken, &yylval);
-      yychar = YYEMPTY;
-
+      if (yychar <= YYEOF)
+       {
+         /* Return failure if at end of input.  */
+         if (yychar == YYEOF)
+           YYABORT;
+       }
+      else
+       {
+         yydestruct ("Error: discarding",
+                     yytoken, &yylval);
+         yychar = YYEMPTY;
+       }
     }
 
-  /* Else will try to reuse lookahead token after shifting the error
+  /* Else will try to reuse look-ahead token after shifting the error
      token.  */
   goto yyerrlab1;
 
 
-/*----------------------------------------------------.
-| yyerrlab1 -- error raised explicitly by an action.  |
-`----------------------------------------------------*/
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (/*CONSTCOND*/ 0)
+     goto yyerrorlab;
+
+  /* Do not reclaim the symbols of the rule which action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
 yyerrlab1:
   yyerrstatus = 3;     /* Each real token shifted decrements this.  */
 
@@ -5278,22 +5617,23 @@ yyerrlab1:
       if (yyssp == yyss)
        YYABORT;
 
-      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
-      yydestruct (yystos[yystate], yyvsp);
-      yyvsp--;
-      yystate = *--yyssp;
 
+      yydestruct ("Error: popping",
+                 yystos[yystate], yyvsp);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
       YY_STACK_PRINT (yyss, yyssp);
     }
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  YYDPRINTF ((stderr, "Shifting error token, "));
-
   *++yyvsp = yylval;
 
 
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
   yystate = yyn;
   goto yynewstate;
 
@@ -5313,21 +5653,39 @@ yyabortlab:
   goto yyreturn;
 
 #ifndef yyoverflow
-/*----------------------------------------------.
-| yyoverflowlab -- parser overflow comes here.  |
-`----------------------------------------------*/
-yyoverflowlab:
-  yyerror ("parser stack overflow");
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (YY_("memory exhausted"));
   yyresult = 2;
   /* Fall through.  */
 #endif
 
 yyreturn:
+  if (yychar != YYEOF && yychar != YYEMPTY)
+     yydestruct ("Cleanup: discarding lookahead",
+                yytoken, &yylval);
+  /* Do not reclaim the symbols of the rule which action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+                 yystos[*yyssp], yyvsp);
+      YYPOPSTACK (1);
+    }
 #ifndef yyoverflow
   if (yyss != yyssa)
     YYSTACK_FREE (yyss);
 #endif
-  return yyresult;
+#if YYERROR_VERBOSE
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);
+#endif
+  /* Make sure YYID is used.  */
+  return YYID (yyresult);
 }
 
 
index 8edd84b..389d169 100644 (file)
@@ -1,7 +1,9 @@
-/* A Bison parser, made by GNU Bison 1.875.  */
+/* A Bison parser, made by GNU Bison 2.3.  */
 
-/* Skeleton parser for Yacc-like parsing with Bison,
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
+/* Skeleton interface for Bison's Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
 
-/* As a special exception, when this file is copied by Bison into a
-   Bison output file, you may use that output file without restriction.
-   This special exception was added by the Free Software Foundation
-   in version 1.24 of Bison.  */
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
 
 /* Tokens.  */
 #ifndef YYTOKENTYPE
      POSTFIX = 389
    };
 #endif
+/* Tokens.  */
 #define BREAK 258
 #define CONTINUE 259
 #define FUNCTION 260
 
 
 
-#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
 #line 21 "swf5compiler.y"
-typedef union YYSTYPE {
+{
   Buffer action;
   char *str;
   SWFGetUrl2Method getURLMethod;
@@ -319,9 +331,10 @@ typedef union YYSTYPE {
   {
        Buffer obj, ident, memexpr;
   } lval;
-} YYSTYPE;
-/* Line 1240 of yacc.c.  */
-#line 324 "swf5compiler.tab.h"
+}
+/* Line 1489 of yacc.c.  */
+#line 337 "swf5compiler.tab.h"
+       YYSTYPE;
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
 # define YYSTYPE_IS_TRIVIAL 1
@@ -329,5 +342,3 @@ typedef union YYSTYPE {
 
 extern YYSTYPE swf5lval;
 
-
-