some cleanups, extended testcases forward2, override_ns

[swftools.git] / lib / as3 / parser.y

diff --git a/lib/as3/parser.y b/lib/as3/parser.y
index 95a7e17..c692c9d 100644 (file)
--- a/lib/as3/parser.y
+++ b/lib/as3/parser.y
@@ -1,4 +1,4 @@
-/* parser.lex
+/* parser.y

 
    Routines for compiling Flash2 AVM2 ABC Actionscript
 
 
    Routines for compiling Flash2 AVM2 ABC Actionscript
 

@@ -271,7 +271,6 @@ extern int a3_lex();
 %nonassoc "false" "true" "null" "undefined" "super" "function"
 %left above_function
 
 %nonassoc "false" "true" "null" "undefined" "super" "function"
 %left above_function
 

-

      
 %{
 
      
 %{
 

@@ -346,6 +345,7 @@ struct _methodstate {
     int variable_count;
 
     dict_t*unresolved_variables;
     int variable_count;
 
     dict_t*unresolved_variables;

+    dict_t*allvars; // all variables (in all sublevels, but not for inner functions)

 
     char inner;
     char uses_parent_function;
 
     char inner;
     char uses_parent_function;

@@ -369,6 +369,23 @@ struct _methodstate {
     methodstate_list_t*innerfunctions;
 };
 
     methodstate_list_t*innerfunctions;
 };
 

+methodstate_t*methodstate_new()
+{
+    NEW(methodstate_t,m);
+    m->allvars = dict_new();
+    return m;
+}
+void methodstate_destroy(methodstate_t*m) 
+{
+    dict_destroy(m->unresolved_variables); m->unresolved_variables = 0;
+    list_free(m->innerfunctions);m->innerfunctions=0;
+
+    if(m->allvars) {
+        DICT_ITERATE_DATA(m->allvars, void*, data) {free(data);}
+        m->allvars = 0;
+    }
+}
+

 typedef struct _state {
     struct _state*old;
     int level;
 typedef struct _state {
     struct _state*old;
     int level;

@@ -392,7 +409,6 @@ typedef struct _state {
     int switch_var;
     
     dict_t*vars;
     int switch_var;
     
     dict_t*vars;

-    dict_t*allvars; // also contains variables from sublevels

 } state_t;
 
 typedef struct _global {
 } state_t;
 
 typedef struct _global {

@@ -504,13 +520,6 @@ static void state_destroy(state_t*state)
     if(state->vars) {
         dict_destroy(state->vars);state->vars=0;
     }
     if(state->vars) {
         dict_destroy(state->vars);state->vars=0;
     }

-    if(state->new_vars && state->allvars) {
-        parserassert(!state->old || state->old->allvars != state->allvars);
-        DICT_ITERATE_DATA(state->allvars, void*, data) {
-            free(data);
-        }
-        dict_destroy(state->allvars);
-    }

     
     list_free(state->active_namespace_urls)
     state->active_namespace_urls = 0;
     
     list_free(state->active_namespace_urls)
     state->active_namespace_urls = 0;

@@ -529,8 +538,7 @@ static void old_state()
     state = state->old;
 
     if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) {
     state = state->old;
 
     if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) {

-        free(leaving->method);
-        leaving->method=0;
+        methodstate_destroy(leaving->method);leaving->method=0;

     }
     if(as3_pass>1 && leaving->cls && leaving->cls != state->cls) {
         free(leaving->cls);
     }
     if(as3_pass>1 && leaving->cls && leaving->cls != state->cls) {
         free(leaving->cls);

@@ -556,7 +564,6 @@ void initialize_file(char*filename)
 
     new_state();
     state->package = internal_filename_package = strdup(filename);
 
     new_state();
     state->package = internal_filename_package = strdup(filename);

-    state->allvars = dict_new();

     
     global->token2info = dict_lookup(global->file2token2info, 
                                      current_filename // use long version
     
     global->token2info = dict_lookup(global->file2token2info, 
                                      current_filename // use long version

@@ -570,6 +577,7 @@ void initialize_file(char*filename)
         state->method = rfx_calloc(sizeof(methodstate_t));
         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
         state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope
         state->method = rfx_calloc(sizeof(methodstate_t));
         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
         state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope

+       state->method->allvars = dict_new();

     } else {
         state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
         state->method->variable_count = 0;
     } else {
         state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
         state->method->variable_count = 0;

@@ -630,10 +638,10 @@ typedef struct _variable {
     methodstate_t*is_inner_method;
 } variable_t;
 
     methodstate_t*is_inner_method;
 } variable_t;
 

-static variable_t* find_variable(state_t*s, char*name)
+static variable_t* find_variable(state_t*s, const char*name)

 {
     if(s->method->no_variable_scoping) {
 {
     if(s->method->no_variable_scoping) {

-        return dict_lookup(s->allvars, name);
+        return dict_lookup(s->method->allvars, name);

     } else {
         state_t*top = s;
         while(s) {
     } else {
         state_t*top = s;
         while(s) {

@@ -646,10 +654,10 @@ static variable_t* find_variable(state_t*s, char*name)
         return 0;
     }
 }
         return 0;
     }
 }

-static variable_t* find_slot(state_t*s, const char*name)
+static variable_t* find_slot(methodstate_t*m, const char*name)

 {
 {

-    if(s->method && s->method->slots)
-        return dict_lookup(s->method->slots, name);
+    if(m && m->slots)
+        return dict_lookup(m->slots, name);

     return 0;
 }
 
     return 0;
 }
 

@@ -668,6 +676,7 @@ static char variable_exists(char*name)
 
 static code_t*defaultvalue(code_t*c, classinfo_t*type)
 {
 
 static code_t*defaultvalue(code_t*c, classinfo_t*type)
 {

+    parserassert(!type || type->kind!=INFOTYPE_UNRESOLVED);

     if(TYPE_IS_INT(type)) {
        c = abc_pushbyte(c, 0);
     } else if(TYPE_IS_UINT(type)) {
     if(TYPE_IS_INT(type)) {
        c = abc_pushbyte(c, 0);
     } else if(TYPE_IS_UINT(type)) {

@@ -695,10 +704,10 @@ static int alloc_local()
     return state->method->variable_count++;
 }
 
     return state->method->variable_count++;
 }
 

-static variable_t* new_variable2(const char*name, classinfo_t*type, char init, char maybeslot)
+static variable_t* new_variable2(methodstate_t*method, const char*name, classinfo_t*type, char init, char maybeslot)

 {
     if(maybeslot) {
 {
     if(maybeslot) {

-        variable_t*v = find_slot(state, name);
+        variable_t*v = find_slot(method, name);

         if(v) {
             alloc_local(); 
             return v;
         if(v) {
             alloc_local(); 
             return v;

@@ -711,29 +720,31 @@ static variable_t* new_variable2(const char*name, classinfo_t*type, char init, c
     v->init = v->kill = init;
  
     if(name) {
     v->init = v->kill = init;
  
     if(name) {

-        if(!state->method->no_variable_scoping) 
+        if(!method->no_variable_scoping) 

         {
         {

-            if(dict_contains(state->vars, name))
+            if(dict_contains(state->vars, name)) {

                 syntaxerror("variable %s already defined", name);
                 syntaxerror("variable %s already defined", name);

+            }

             dict_put(state->vars, name, v);
         }
             dict_put(state->vars, name, v);
         }

-        if(state->method->no_variable_scoping && 
+        if(method->no_variable_scoping && 

            as3_pass==2 && 
            as3_pass==2 && 

-           dict_contains(state->allvars, name)) 
+           dict_contains(state->method->allvars, name)) 

         {
         {

-            variable_t*v = dict_lookup(state->allvars, name);
-            if(v->type != type)
+            variable_t*v = dict_lookup(state->method->allvars, name);
+            if(v->type != type && (!v->type || v->type->kind!=INFOTYPE_UNRESOLVED)) {

                 syntaxerror("variable %s already defined.", name);
                 syntaxerror("variable %s already defined.", name);

+           }

             return v;
         }
             return v;
         }

-        dict_put(state->allvars, name, v);
+        dict_put(state->method->allvars, name, v);

     }
 
     return v;
 }
     }
 
     return v;
 }

-static int new_variable(const char*name, classinfo_t*type, char init, char maybeslot)
+static int new_variable(methodstate_t*method, const char*name, classinfo_t*type, char init, char maybeslot)

 {
 {

-    return new_variable2(name, type, init, maybeslot)->index;
+    return new_variable2(method, name, type, init, maybeslot)->index;

 }
 
 #define TEMPVARNAME "__as3_temp__"
 }
 
 #define TEMPVARNAME "__as3_temp__"

@@ -744,7 +755,7 @@ int gettempvar()
     if(v) 
         i = v->index;
     else
     if(v) 
         i = v->index;
     else

-        i = new_variable(TEMPVARNAME, 0, 0, 0);
+        i = new_variable(state->method, TEMPVARNAME, 0, 0, 0);

     parserassert(i);
     return i;
 }
     parserassert(i);
     return i;
 }

@@ -798,7 +809,7 @@ static void unknown_variable(char*name)
 
 static code_t* add_scope_code(code_t*c, methodstate_t*m, char init)
 {
 
 static code_t* add_scope_code(code_t*c, methodstate_t*m, char init)
 {

-    if(m->uses_slots || (m->late_binding && !m->inner)) { //???? especially inner functions need the pushscope
+    if(m->uses_slots || m->innerfunctions || (m->late_binding && !m->inner)) {

         c = abc_getlocal_0(c);
         c = abc_pushscope(c);
     }
         c = abc_getlocal_0(c);
         c = abc_pushscope(c);
     }

@@ -874,7 +885,7 @@ static code_t* method_header(methodstate_t*m)
 static code_t* wrap_function(code_t*c,code_t*header, code_t*body)
 {
     c = code_append(c, header);
 static code_t* wrap_function(code_t*c,code_t*header, code_t*body)
 {
     c = code_append(c, header);

-    c = code_append(c, var_block(body, state->method->no_variable_scoping?state->allvars:state->vars));
+    c = code_append(c, var_block(body, state->method->no_variable_scoping?state->method->allvars:state->vars));

     /* append return if necessary */
     if(!c || (c->opcode != OPCODE_RETURNVOID && 
               c->opcode != OPCODE_RETURNVALUE)) {
     /* append return if necessary */
     if(!c || (c->opcode != OPCODE_RETURNVOID && 
               c->opcode != OPCODE_RETURNVALUE)) {

@@ -911,7 +922,7 @@ static namespace_t modifiers2access(modifiers_t*mod)
             syntaxerror("invalid combination of access levels and namespaces");
         ns.access = ACCESS_NAMESPACE;
         state_t*s = state;
             syntaxerror("invalid combination of access levels and namespaces");
         ns.access = ACCESS_NAMESPACE;
         state_t*s = state;

-        const char*url = (const char*)trie_lookup(active_namespaces, mod->ns);
+        const char*url = (const char*)trie_lookup(active_namespaces, (unsigned char*)mod->ns);

         if(!url) {
             /* shouldn't happen- the tokenizer only reports something as a namespace
                if it was already registered */
         if(!url) {
             /* shouldn't happen- the tokenizer only reports something as a namespace
                if it was already registered */

@@ -938,9 +949,9 @@ static namespace_t modifiers2access(modifiers_t*mod)
 }
 static slotinfo_t* find_class(const char*name);
 
 }
 static slotinfo_t* find_class(const char*name);
 

-static memberinfo_t* findmember_nsset(classinfo_t*cls, const char*name, char recurse)
+static memberinfo_t* findmember_nsset(classinfo_t*cls, const char*name, char recurse, char is_static)

 {
 {

-    return registry_findmember_nsset(cls, state->active_namespace_urls, name, recurse);
+    return registry_findmember_nsset(cls, state->active_namespace_urls, name, recurse, is_static);

 }
 
 static void innerfunctions2vars(methodstate_t*m)
 }
 
 static void innerfunctions2vars(methodstate_t*m)

@@ -949,7 +960,7 @@ static void innerfunctions2vars(methodstate_t*m)
     while(l) {
         methodstate_t*m = l->methodstate;
         
     while(l) {
         methodstate_t*m = l->methodstate;
         

-        variable_t* v = new_variable2(m->info->name, TYPE_FUNCTION(m->info), 0, 0);
+        variable_t* v = new_variable2(state->method, m->info->name, TYPE_FUNCTION(m->info), 0, 0);

         m->var_index = v->index;
         if(m->is_a_slot)
             m->slot_index = m->is_a_slot;
         m->var_index = v->index;
         if(m->is_a_slot)
             m->slot_index = m->is_a_slot;

@@ -963,25 +974,30 @@ static void function_initvars(methodstate_t*m, char has_params, params_t*params,
     if(var0) {
         int index = -1;
         if(m->inner)
     if(var0) {
         int index = -1;
         if(m->inner)

-            index = new_variable("this", 0, 0, 0);
+            index = new_variable(m, "this", 0, 0, 0);

         else if(!m->is_global)
         else if(!m->is_global)

-            index = new_variable((flags&FLAG_STATIC)?"class":"this", state->cls?state->cls->info:0, 0, 0);
+            index = new_variable(m, (flags&FLAG_STATIC)?"class":"this", state->cls?state->cls->info:0, 0, 0);

         else
         else

-            index = new_variable("globalscope", 0, 0, 0);
+            index = new_variable(m, "globalscope", 0, 0, 0);
+        if(index) {
+            DICT_ITERATE_ITEMS(state->vars, char*, name, variable_t*, v) {
+                printf("%s %d\n", name, v->index);
+            }
+        }

         parserassert(!index);
     }
 
     if(has_params) {
         param_list_t*p=0;
         for(p=params->list;p;p=p->next) {
         parserassert(!index);
     }
 
     if(has_params) {
         param_list_t*p=0;
         for(p=params->list;p;p=p->next) {

-            variable_t*v = new_variable2(p->param->name, p->param->type, 0, 1);
+            variable_t*v = new_variable2(m, p->param->name, p->param->type, 0, 1);

             v->is_parameter = 1;
         }
         if(as3_pass==2 && m->need_arguments) {
             /* arguments can never be used by an innerfunction (the inner functions
                have their own arguments var), so it's ok to  not initialize this until
                pass 2. (We don't know whether we need it before, anyway) */
             v->is_parameter = 1;
         }
         if(as3_pass==2 && m->need_arguments) {
             /* arguments can never be used by an innerfunction (the inner functions
                have their own arguments var), so it's ok to  not initialize this until
                pass 2. (We don't know whether we need it before, anyway) */

-            variable_t*v = new_variable2("arguments", TYPE_ARRAY, 0, 0);
+            variable_t*v = new_variable2(m, "arguments", TYPE_ARRAY, 0, 0);

             m->need_arguments = v->index;
         }
     }
             m->need_arguments = v->index;
         }
     }

@@ -992,15 +1008,26 @@ static void function_initvars(methodstate_t*m, char has_params, params_t*params,
         m->scope_code = add_scope_code(m->scope_code, m, 0);
         if(m->slots) {
             /* exchange unresolved identifiers with the actual objects */
         m->scope_code = add_scope_code(m->scope_code, m, 0);
         if(m->slots) {
             /* exchange unresolved identifiers with the actual objects */

-            DICT_ITERATE_ITEMS(m->slots, char*, name, variable_t*, v) {
-                if(v->type && v->type->kind == INFOTYPE_UNRESOLVED) {
-                    classinfo_t*type = (classinfo_t*)registry_resolve((slotinfo_t*)v->type);
+            DICT_ITERATE_ITEMS(m->slots, char*, name, variable_t*, v1) {
+                if(v1->type && v1->type->kind == INFOTYPE_UNRESOLVED) {
+                    classinfo_t*type = (classinfo_t*)registry_resolve((slotinfo_t*)v1->type);

                     if(!type || type->kind != INFOTYPE_CLASS) {
                     if(!type || type->kind != INFOTYPE_CLASS) {

-                        syntaxerror("Couldn't find class %s::%s (%s)", v->type->package, v->type->name, name);
+                        syntaxerror("Couldn't find class %s::%s (%s)", v1->type->package, v1->type->name, name);

                     }
                     }

-                    v->type = type;
+                    v1->type = type;

                 }
             }
                 }
             }

+       }
+       if(m->allvars) {
+            DICT_ITERATE_ITEMS(m->allvars, char*, name2, variable_t*, v2) {
+                if(v2->type && v2->type->kind == INFOTYPE_UNRESOLVED) {
+                    classinfo_t*type = (classinfo_t*)registry_resolve((slotinfo_t*)v2->type);
+                    if(!type || type->kind != INFOTYPE_CLASS) {
+                        syntaxerror("Couldn't find class %s::%s (%s)", v2->type->package, v2->type->name, name2);
+                    }
+                    v2->type = type;
+                }
+           }

         }
     }
 }
         }
     }
 }

@@ -1048,10 +1075,9 @@ static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, cl
 
     if(as3_pass==1) {
         state->cls = rfx_calloc(sizeof(classstate_t));
 
     if(as3_pass==1) {
         state->cls = rfx_calloc(sizeof(classstate_t));

-        state->cls->init = rfx_calloc(sizeof(methodstate_t));
-        state->cls->static_init = rfx_calloc(sizeof(methodstate_t));
+        state->cls->init = methodstate_new();
+        state->cls->static_init = methodstate_new();

         state->cls->static_init->is_static=FLAG_STATIC;
         state->cls->static_init->is_static=FLAG_STATIC;

-        state->cls->static_init->variable_count=1;

         /* notice: we make no effort to initialize the top variable (local0) here,
            even though it has special meaning. We just rely on the fact
            that pass 1 won't do anything with variables */
         /* notice: we make no effort to initialize the top variable (local0) here,
            even though it has special meaning. We just rely on the fact
            that pass 1 won't do anything with variables */

@@ -1081,10 +1107,12 @@ static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, cl
     if(as3_pass == 2) {
         state->cls = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
     
     if(as3_pass == 2) {
         state->cls = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
     

-        state->method = state->cls->init;

         parserassert(state->cls && state->cls->info);
        
         parserassert(state->cls && state->cls->info);
        

+        state->method = state->cls->static_init;
+

         function_initvars(state->cls->init, 0, 0, 0, 1);
         function_initvars(state->cls->init, 0, 0, 0, 1);

+        state->cls->static_init->variable_count=1;

         function_initvars(state->cls->static_init, 0, 0, 0, 0);
 
         if(extends && (extends->flags & FLAG_FINAL))
         function_initvars(state->cls->static_init, 0, 0, 0, 0);
 
         if(extends && (extends->flags & FLAG_FINAL))

@@ -1225,7 +1253,7 @@ static void check_override(memberinfo_t*m, int flags)
 {
     if(!m)
         return;
 {
     if(!m)
         return;

-    if(m->parent == state->cls->info)
+    if(m->parent == state->cls->info && !((flags^m->flags)&FLAG_STATIC))

         syntaxerror("class '%s' already contains a method/slot '%s'", m->parent->name, m->name);
     if(!m->parent)
         syntaxerror("internal error: overriding method %s, which doesn't have parent", m->name);
         syntaxerror("class '%s' already contains a method/slot '%s'", m->parent->name, m->name);
     if(!m->parent)
         syntaxerror("internal error: overriding method %s, which doesn't have parent", m->name);

@@ -1261,11 +1289,11 @@ static methodinfo_t*registerfunction(enum yytokentype getset, modifiers_t*mod, c
         minfo->return_type = return_type;
     } else if(getset != KW_GET && getset != KW_SET) {
         //class method
         minfo->return_type = return_type;
     } else if(getset != KW_GET && getset != KW_SET) {
         //class method

-        memberinfo_t* m = registry_findmember(state->cls->info, ns.name, name, 0);
+        memberinfo_t* m = registry_findmember(state->cls->info, ns.name, name, 0, mod->flags&FLAG_STATIC);

         if(m) {
             syntaxerror("class already contains a %s '%s'", infotypename((slotinfo_t*)m), m->name);
         }
         if(m) {
             syntaxerror("class already contains a %s '%s'", infotypename((slotinfo_t*)m), m->name);
         }

-        minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);
+        minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name, mod->flags&FLAG_STATIC);

         minfo->return_type = return_type;
         // getslot on a member slot only returns "undefined", so no need
         // to actually store these
         minfo->return_type = return_type;
         // getslot on a member slot only returns "undefined", so no need
         // to actually store these

@@ -1281,7 +1309,7 @@ static methodinfo_t*registerfunction(enum yytokentype getset, modifiers_t*mod, c
         } else
             syntaxerror("setter function needs to take exactly one argument");
         // not sure wether to look into superclasses here, too
         } else
             syntaxerror("setter function needs to take exactly one argument");
         // not sure wether to look into superclasses here, too

-        minfo = (methodinfo_t*)registry_findmember(state->cls->info, ns.name, name, 1);
+        minfo = (methodinfo_t*)registry_findmember(state->cls->info, ns.name, name, 1, mod->flags&FLAG_STATIC);

         if(minfo) {
             if(minfo->kind!=INFOTYPE_VAR)
                 syntaxerror("class already contains a method called '%s'", name);
         if(minfo) {
             if(minfo->kind!=INFOTYPE_VAR)
                 syntaxerror("class already contains a method called '%s'", name);

@@ -1303,7 +1331,7 @@ static methodinfo_t*registerfunction(enum yytokentype getset, modifiers_t*mod, c
                     type?type->name:"*");
             }*/
         } else {
                     type?type->name:"*");
             }*/
         } else {

-            minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);
+            minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name, mod->flags&FLAG_STATIC);

             minfo->kind = INFOTYPE_VAR; //hack
             minfo->subtype = gs;
             minfo->return_type = type;
             minfo->kind = INFOTYPE_VAR; //hack
             minfo->subtype = gs;
             minfo->return_type = type;

@@ -1324,21 +1352,27 @@ static void innerfunction(char*name, params_t*params, classinfo_t*return_type)
     //parserassert(state->method && state->method->info);
 
     methodstate_t*parent_method = state->method;
     //parserassert(state->method && state->method->info);
 
     methodstate_t*parent_method = state->method;

+    variable_t*v = 0;

 
     if(as3_pass==1) {
         return_type = 0; // not valid in pass 1
 
     if(as3_pass==1) {
         return_type = 0; // not valid in pass 1

+        if(name) {
+            v = new_variable2(parent_method, name, 0, 0, 0);
+        }

     }
 
     new_state();
     state->new_vars = 1;
     }
 
     new_state();
     state->new_vars = 1;

-    state->allvars = dict_new();

    
     if(as3_pass == 1) {
    
     if(as3_pass == 1) {

-        state->method = rfx_calloc(sizeof(methodstate_t));
+        state->method = methodstate_new();

         state->method->inner = 1;
         state->method->is_static = parent_method->is_static;
         state->method->variable_count = 0;
         state->method->abc = rfx_calloc(sizeof(abc_method_t));
         state->method->inner = 1;
         state->method->is_static = parent_method->is_static;
         state->method->variable_count = 0;
         state->method->abc = rfx_calloc(sizeof(abc_method_t));

+        if(v) {
+            v->is_inner_method = state->method;
+        }

 
         NEW(methodinfo_t,minfo);
         minfo->kind = INFOTYPE_METHOD;
 
         NEW(methodinfo_t,minfo);
         minfo->kind = INFOTYPE_METHOD;

@@ -1372,10 +1406,9 @@ static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,
     }
     new_state();
     state->new_vars = 1;
     }
     new_state();
     state->new_vars = 1;

-    state->allvars = dict_new();

 
     if(as3_pass == 1) {
 
     if(as3_pass == 1) {

-        state->method = rfx_calloc(sizeof(methodstate_t));
+        state->method = methodstate_new();

         state->method->has_super = 0;
         state->method->is_static = mod->flags&FLAG_STATIC;
 
         state->method->has_super = 0;
         state->method->is_static = mod->flags&FLAG_STATIC;
 

@@ -1401,7 +1434,7 @@ static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,
         parserassert(state->method);
                 
         if(state->cls) {
         parserassert(state->method);
                 
         if(state->cls) {

-            memberinfo_t*m = registry_findmember(state->cls->info, mod->ns, name, 2);
+            memberinfo_t*m = registry_findmember(state->cls->info, mod->ns, name, 2, mod->flags&FLAG_STATIC);

             check_override(m, mod->flags);
         }
             
             check_override(m, mod->flags);
         }
             

@@ -1413,51 +1446,57 @@ static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,
     } 
 }
 
     } 
 }
 

+static void insert_unresolved(methodstate_t*m, dict_t*xvars, dict_t*allvars)
+{
+    parserassert(m->inner);
+    if(m->unresolved_variables) {
+        dict_t*d = m->unresolved_variables;
+        int t;
+        DICT_ITERATE_KEY(d, char*, id) {
+            /* check parent method's variables */
+            variable_t*v;
+            if(dict_contains(allvars, id)) {
+                m->uses_parent_function = 1;
+                state->method->uses_slots = 1;
+                dict_put(xvars, id, 0);
+            }
+        }
+    }
+    methodstate_list_t*ml = m->innerfunctions;
+    while(ml) {
+        insert_unresolved(ml->methodstate, xvars, allvars);
+        ml = ml->next;
+    }
+}
+

 static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*name,
                           params_t*params, classinfo_t*return_type, code_t*body)
 {
     if(as3_pass==1) {
 static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*name,
                           params_t*params, classinfo_t*return_type, code_t*body)
 {
     if(as3_pass==1) {

-        innerfunctions2vars(state->method);
-
-        methodstate_list_t*ml = state->method->innerfunctions;
-        

         dict_t*xvars = dict_new();
         
         if(state->method->unresolved_variables) {
             DICT_ITERATE_KEY(state->method->unresolved_variables, char*, vname) {
         dict_t*xvars = dict_new();
         
         if(state->method->unresolved_variables) {
             DICT_ITERATE_KEY(state->method->unresolved_variables, char*, vname) {

-                if(dict_contains(state->allvars, vname)) {
-                    state->method->no_variable_scoping = 1;
-                    as3_warning("function %s uses forward or outer block variable references (%s): switching into compatiblity mode", name, vname);
-                    break;
+                if(!state->method->no_variable_scoping && dict_contains(state->method->allvars, vname)) {
+                    variable_t*v = dict_lookup(state->method->allvars, vname);
+                    if(!v->is_inner_method) {
+                        state->method->no_variable_scoping = 1;
+                        as3_warning("function %s uses forward or outer block variable references (%s): switching into compatibility mode", name, vname);
+                    }

                 }
             }
         }
 
                 }
             }
         }
 

+        methodstate_list_t*ml = state->method->innerfunctions;

         while(ml) {
         while(ml) {

-            methodstate_t*m = ml->methodstate;
-            parserassert(m->inner);
-            if(m->unresolved_variables) {
-                dict_t*d = m->unresolved_variables;
-                int t;
-                DICT_ITERATE_KEY(d, char*, id) {
-                    /* check parent method's variables */
-                    variable_t*v;
-                    if((v=find_variable(state, id))) {
-                        m->uses_parent_function = 1;
-                        state->method->uses_slots = 1;
-                        dict_put(xvars, id, 0);
-                    }
-                }
-                dict_destroy(m->unresolved_variables);
-                m->unresolved_variables = 0;
-            }
+            insert_unresolved(ml->methodstate, xvars, state->method->allvars);

             ml = ml->next;
         }
         
         if(state->method->uses_slots) {
             state->method->slots = dict_new();
             int i = 1;
             ml = ml->next;
         }
         
         if(state->method->uses_slots) {
             state->method->slots = dict_new();
             int i = 1;

-            DICT_ITERATE_ITEMS(state->vars, char*, name, variable_t*, v) {
+            DICT_ITERATE_ITEMS(state->method->allvars, char*, name, variable_t*, v) {

                 if(!name) syntaxerror("internal error");
                 if(v->index && dict_contains(xvars, name)) {
                     v->init = v->kill = 0;
                 if(!name) syntaxerror("internal error");
                 if(v->index && dict_contains(xvars, name)) {
                     v->init = v->kill = 0;

@@ -1472,7 +1511,6 @@ static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*
             state->method->uses_slots = i;
             dict_destroy(state->vars);state->vars = 0;
             parserassert(state->new_vars);
             state->method->uses_slots = i;
             dict_destroy(state->vars);state->vars = 0;
             parserassert(state->new_vars);

-            dict_destroy(state->allvars);state->allvars = 0;

         }
         old_state();
         return 0;
         }
         old_state();
         return 0;

@@ -1658,6 +1696,7 @@ code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
     if(TYPE_IS_NULL(from) && !IS_NUMBER_OR_INT(to))
         return c;
 
     if(TYPE_IS_NULL(from) && !IS_NUMBER_OR_INT(to))
         return c;
 

+

     as3_error("can't convert type %s%s%s to %s%s%s", 
         from->package, from->package[0]?".":"", from->name, 
         to->package, to->package[0]?".":"", to->name);
     as3_error("can't convert type %s%s%s to %s%s%s", 
         from->package, from->package[0]?".":"", from->name, 
         to->package, to->package[0]?".":"", to->name);

@@ -2074,17 +2113,17 @@ VARIABLE_LIST: VARIABLE_LIST ',' ONE_VARIABLE {$$ = code_append($1, $3);}
 ONE_VARIABLE: T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION
 {
 PASS12
 ONE_VARIABLE: T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION
 {
 PASS12

-    if(variable_exists($1))
+    if(variable_exists($1)) 

         syntaxerror("Variable %s already defined", $1);
 PASS1
         syntaxerror("Variable %s already defined", $1);
 PASS1

-    new_variable($1, 0, 1, 0);
+    new_variable(state->method, $1, $2, 1, 0);

 PASS2
    
     char slot = 0;
     int index = 0;
     variable_t*v = 0;
     if(state->method->uses_slots) {
 PASS2
    
     char slot = 0;
     int index = 0;
     variable_t*v = 0;
     if(state->method->uses_slots) {

-        v = find_slot(state, $1);
+        v = find_slot(state->method, $1);

         if(v && !v->init) {
             // this variable is stored in a slot
             v->init = 1;
         if(v && !v->init) {
             // this variable is stored in a slot
             v->init = 1;

@@ -2093,7 +2132,7 @@ PASS2
         }
     }
     if(!v) {
         }
     }
     if(!v) {

-        v = new_variable2($1, $2, 1, 0);
+        v = new_variable2(state->method, $1, $2, 1, 0);

     }
 
     $$ = slot?abc_getscopeobject(0, 1):0;
     }
 
     $$ = slot?abc_getscopeobject(0, 1):0;

@@ -2164,8 +2203,8 @@ FOR_INIT : VOIDEXPRESSION
 //       (I don't see any easy way to revolve this conflict otherwise, as we
 //        can't touch VAR_READ without upsetting the precedence about "return")
 FOR_IN_INIT : "var" T_IDENTIFIER MAYBETYPE {
 //       (I don't see any easy way to revolve this conflict otherwise, as we
 //        can't touch VAR_READ without upsetting the precedence about "return")
 FOR_IN_INIT : "var" T_IDENTIFIER MAYBETYPE {

-    PASS1 $$=$2;new_variable($2,0,1,0);
-    PASS2 $$=$2;new_variable($2,$3,1,0);
+    PASS1 $$=$2;new_variable(state->method, $2,0,1,0);
+    PASS2 $$=$2;new_variable(state->method, $2,$3,1,0);

 }
 FOR_IN_INIT : T_IDENTIFIER {
     PASS12
 }
 FOR_IN_INIT : T_IDENTIFIER {
     PASS12

@@ -2196,10 +2235,9 @@ FOR : FOR_START FOR_INIT ';' EXPRESSION ';' VOIDEXPRESSION ')' IF_CODEBLOCK {
 }
 
 FOR_IN : FOR_START FOR_IN_INIT "in" EXPRESSION ')' IF_CODEBLOCK {
 }
 
 FOR_IN : FOR_START FOR_IN_INIT "in" EXPRESSION ')' IF_CODEBLOCK {

-    variable_t*var = find_variable(state, $2);
-    if(!var) {
-        syntaxerror("variable %s not known in this scope", $2);
-    }
+    node_t*n = resolve_identifier($2);
+    typedcode_t w = node_write(n);
+    

     int it = alloc_local();
     int array = alloc_local();
 
     int it = alloc_local();
     int array = alloc_local();
 

@@ -2220,8 +2258,9 @@ FOR_IN : FOR_START FOR_IN_INIT "in" EXPRESSION ')' IF_CODEBLOCK {
         $$ = abc_nextname($$);
     else
         $$ = abc_nextvalue($$);
         $$ = abc_nextname($$);
     else
         $$ = abc_nextvalue($$);

-    $$ = converttype($$, 0, var->type);
-    $$ = abc_setlocal($$, var->index);
+
+    $$ = converttype($$, 0, w.t);
+    $$ = code_append($$, w.c);

 
     $$ = code_append($$, $6);
     $$ = abc_jump($$, loopstart);
 
     $$ = code_append($$, $6);
     $$ = abc_jump($$, loopstart);

@@ -2235,6 +2274,7 @@ FOR_IN : FOR_START FOR_IN_INIT "in" EXPRESSION ')' IF_CODEBLOCK {
     $$ = abc_kill($$, it);
     $$ = abc_kill($$, array);
 
     $$ = abc_kill($$, it);
     $$ = abc_kill($$, array);
 

+    $$ = var_block($$, state->vars);

     PASS12 old_state();
 }
 
     PASS12 old_state();
 }
 

@@ -2333,8 +2373,8 @@ SWITCH : T_SWITCH '(' {PASS12 new_state();state->switch_var=alloc_local();} E ')
 
 CATCH: "catch" '(' T_IDENTIFIER MAYBETYPE ')' {PASS12 new_state();
                                                       state->exception_name=$3;
 
 CATCH: "catch" '(' T_IDENTIFIER MAYBETYPE ')' {PASS12 new_state();
                                                       state->exception_name=$3;

-                                               PASS1 new_variable($3, 0, 0, 0);
-                                               PASS2 new_variable($3, $4, 0, 0);
+                                               PASS1 new_variable(state->method, $3, $4, 0, 0);
+                                               PASS2 new_variable(state->method, $3, $4, 0, 0);

                                               } 
         '{' MAYBECODE '}' {
     namespace_t name_ns = {ACCESS_PACKAGE, ""};
                                               } 
         '{' MAYBECODE '}' {
     namespace_t name_ns = {ACCESS_PACKAGE, ""};

@@ -2532,6 +2572,9 @@ IMPORT : "import" PACKAGEANDCLASS {
        if(!s && as3_pass==1) {// || !(s->flags&FLAG_BUILTIN)) {
            as3_schedule_class($2->package, $2->name);
        }
        if(!s && as3_pass==1) {// || !(s->flags&FLAG_BUILTIN)) {
            as3_schedule_class($2->package, $2->name);
        }

+       /*if(s && s->kind == INFOTYPE_VAR && TYPE_IS_NAMESPACE(s->type)) {
+           trie_put(active_namespaces, (unsigned char*)$2->name, 0);
+       }*/

        state_has_imports();
        dict_put(state->imports, $2->name, $2);
        import_toplevel($2->package);
        state_has_imports();
        dict_put(state->imports, $2->name, $2);
        import_toplevel($2->package);

@@ -2608,6 +2651,7 @@ CLASS_BODY_ITEM : ';'
 CLASS_BODY_ITEM : CONDITIONAL_COMPILATION '{' MAYBE_CLASS_BODY '}' {PASS_ALWAYS as3_pass=$1;}
 CLASS_BODY_ITEM : SLOT_DECLARATION
 CLASS_BODY_ITEM : FUNCTION_DECLARATION
 CLASS_BODY_ITEM : CONDITIONAL_COMPILATION '{' MAYBE_CLASS_BODY '}' {PASS_ALWAYS as3_pass=$1;}
 CLASS_BODY_ITEM : SLOT_DECLARATION
 CLASS_BODY_ITEM : FUNCTION_DECLARATION

+CLASS_BODY_ITEM : '[' EMBED_START E ']' {PASS_ALWAYS as3_pass=$2;PASS1 as3_warning("embed command ignored");}

 
 CLASS_BODY_ITEM : CODE_STATEMENT {
     code_t*c = state->cls->static_init->header;
 
 CLASS_BODY_ITEM : CODE_STATEMENT {
     code_t*c = state->cls->static_init->header;

@@ -2713,11 +2757,11 @@ PASS12
 
         varinfo_t* info = 0;
         if(state->cls) {
 
         varinfo_t* info = 0;
         if(state->cls) {

-            memberinfo_t*i = registry_findmember(state->cls->info, ns.name, $1, 1);
+            memberinfo_t*i = registry_findmember(state->cls->info, ns.name, $1, 1, slotstate_flags->flags&FLAG_STATIC);

             if(i) {
                 check_override(i, flags);
             }
             if(i) {
                 check_override(i, flags);
             }

-            info = varinfo_register_onclass(state->cls->info, ns.access, ns.name, $1);
+            info = varinfo_register_onclass(state->cls->info, ns.access, ns.name, $1, slotstate_flags->flags&FLAG_STATIC);

         } else {
             slotinfo_t*i = registry_find(state->package, $1);
             if(i) {
         } else {
             slotinfo_t*i = registry_find(state->package, $1);
             if(i) {

@@ -3101,6 +3145,9 @@ NEW : "new" E XX MAYBE_PARAM_VALUES {
         $$.c = code_append($$.c, paramcode);
         $$.c = abc_constructprop2($$.c, name, $4.number);
         multiname_destroy(name);
         $$.c = code_append($$.c, paramcode);
         $$.c = abc_constructprop2($$.c, name, $4.number);
         multiname_destroy(name);

+    } else if(is_getlocal($$.c)) {
+        $$.c = code_append($$.c, paramcode);
+        $$.c = abc_construct($$.c, $4.number);

     } else if(TYPE_IS_CLASS(v.t) && v.t->data) {
         code_free($$.c);
         classinfo_t*c = v.t->data;
     } else if(TYPE_IS_CLASS(v.t) && v.t->data) {
         code_free($$.c);
         classinfo_t*c = v.t->data;

@@ -3401,7 +3448,7 @@ E : "super" '.' T_IDENTIFIER
                   syntaxerror("super keyword not allowed outside a class");
               classinfo_t*t = state->cls->info->superclass;
               if(!t) t = TYPE_OBJECT;
                   syntaxerror("super keyword not allowed outside a class");
               classinfo_t*t = state->cls->info->superclass;
               if(!t) t = TYPE_OBJECT;

-              memberinfo_t*f = findmember_nsset(t, $3, 1);
+              memberinfo_t*f = findmember_nsset(t, $3, 1, 0);

               MEMBER_MULTINAME(m, f, $3);
               typedcode_t v;
               v.c = 0;
               MEMBER_MULTINAME(m, f, $3);
               typedcode_t v;
               v.c = 0;

@@ -3479,29 +3526,46 @@ ID_OR_NS : T_NAMESPACE {$$=(char*)$1;}
 SUBNODE: X_IDENTIFIER
        | '*' {$$="*";}
 
 SUBNODE: X_IDENTIFIER
        | '*' {$$="*";}
 

-/*
-MAYBE_NS: T_IDENTIFIER "::" {$$=$1;}
-        | T_NAMESPACE "::" {$$=(char*)$1;}
-        | '*' "::" {$$="*";}
-        | {$$=0;}*/
+%code {
+    node_t* resolve_identifier(const char*name);
+    node_t* get_descendants(node_t*e,const char*ns,const char*subnode,char multi, char attr)
+    {
+       typedcode_t v = node_read(e);
+       typedcode_t w;
+
+       multiname_t m = {0,0,0,subnode};
+       namespace_t zero = {ZERONAMESPACE,"*"};
+       if(!strcmp(ns,"*")) {
+           m.ns = &zero;
+           m.type = attr?QNAMEA:QNAME;
+       } else {
+           typedcode_t w = node_read(resolve_identifier(ns));
+           if(!TYPE_IS_NAMESPACE(w.t)) {
+               as3_softwarning("%s might not be a namespace", ns);
+           }
+           v.c = code_append(v.c, w.c);
+           v.c = converttype(v.c, w.t, TYPE_NAMESPACE);
+           m.type = attr?RTQNAMEA:RTQNAME;
+       }
+
+       if(!multi) {
+           v.c = abc_getproperty2(v.c, &m);
+       } else {
+           v.c = abc_getdescendants2(v.c, &m);
+       }
+
+       if(TYPE_IS_XML(v.t)) {
+           v.t = TYPE_XMLLIST;
+       } else {
+           v.c = abc_coerce_a(v.c);
+           v.t = TYPE_ANY;
+       }
+       return mkcodenode(v);
+    }
+};

 
 E : E '.' ID_OR_NS "::" SUBNODE {
 
 E : E '.' ID_OR_NS "::" SUBNODE {

-    typedcode_t v = node_read($1);
-    typedcode_t w = node_read(resolve_identifier($3));
-    v.c = code_append(v.c, w.c);
-    if(!TYPE_IS_NAMESPACE(w.t)) {
-        as3_softwarning("%s might not be a namespace", $3);
-    }
-    v.c = converttype(v.c, w.t, TYPE_NAMESPACE);
-    multiname_t m = {RTQNAME, 0, 0, $5};
-    v.c = abc_getproperty2(v.c, &m);
-    if(TYPE_IS_XML(v.t)) {
-        v.t = TYPE_XMLLIST;
-    } else {
-        v.c = abc_coerce_a(v.c);
-        v.t = TYPE_ANY;
-    }
-    $$ = mkcodenode(v);
+    $$ = get_descendants($1, $3, $5, 0, 0);

 }
 E : E ".." SUBNODE {
     typedcode_t v = node_read($1);
 }
 E : E ".." SUBNODE {
     typedcode_t v = node_read($1);

@@ -3510,6 +3574,9 @@ E : E ".." SUBNODE {
     v.t = TYPE_XMLLIST;
     $$ = mkcodenode(v);
 }
     v.t = TYPE_XMLLIST;
     $$ = mkcodenode(v);
 }

+E : E ".." ID_OR_NS "::" SUBNODE {
+    $$ = get_descendants($1, $3, $5, 1, 0);
+}

 E : E '.' '[' E ']' {
     typedcode_t v = node_read($1);
     typedcode_t w = node_read($4);
 E : E '.' '[' E ']' {
     typedcode_t v = node_read($1);
     typedcode_t w = node_read($4);

@@ -3528,6 +3595,11 @@ E : E '.' '@' SUBNODE {
     v.t = TYPE_STRING;
     $$ = mkcodenode(v);
 }
     v.t = TYPE_STRING;
     $$ = mkcodenode(v);
 }

+
+E : E '.' '@' ID_OR_NS "::" SUBNODE {
+    $$ = get_descendants($1, $4, $6, 0, 1);
+}
+

 E : E ".." '@' SUBNODE {
     typedcode_t v = node_read($1);
     multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, $4};
 E : E ".." '@' SUBNODE {
     typedcode_t v = node_read($1);
     multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, $4};

@@ -3535,6 +3607,10 @@ E : E ".." '@' SUBNODE {
     v.t = TYPE_STRING;
     $$ = mkcodenode(v);
 }
     v.t = TYPE_STRING;
     $$ = mkcodenode(v);
 }

+E : E ".." '@' ID_OR_NS "::" SUBNODE {
+    $$ = get_descendants($1, $4, $6, 1, 1);
+}
+

 E : E '.' '@' '[' E ']' {
     typedcode_t v = node_read($1);
     typedcode_t w = node_read($5);
 E : E '.' '@' '[' E ']' {
     typedcode_t v = node_read($1);
     typedcode_t w = node_read($5);

@@ -3565,7 +3641,7 @@ MEMBER : E '.' SUBNODE {
         t = t->data;
         is_static = 1;
     }
         t = t->data;
         is_static = 1;
     }

-    if(TYPE_IS_XML(t)) {
+    if(TYPE_IS_XML(t) && !findmember_nsset(t, $3, 1, is_static)) {

         multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, $3};
         $$.c = abc_getproperty2($$.c, &m);
         $$.c = abc_coerce_a($$.c);
         multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, $3};
         $$.c = abc_getproperty2($$.c, &m);
         $$.c = abc_coerce_a($$.c);

@@ -3574,7 +3650,7 @@ MEMBER : E '.' SUBNODE {
         if(t->subtype==INFOTYPE_UNRESOLVED) {
             syntaxerror("syntaxerror: trying to resolve property '%s' on incomplete object '%s'", $3, t->name);
         }
         if(t->subtype==INFOTYPE_UNRESOLVED) {
             syntaxerror("syntaxerror: trying to resolve property '%s' on incomplete object '%s'", $3, t->name);
         }

-        memberinfo_t*f = findmember_nsset(t, $3, 1);
+        memberinfo_t*f = findmember_nsset(t, $3, 1, is_static);

         char noslot = 0;
         if(f && !is_static != !(f->flags&FLAG_STATIC))
            noslot=1;
         char noslot = 0;
         if(f && !is_static != !(f->flags&FLAG_STATIC))
            noslot=1;

@@ -3622,7 +3698,15 @@ MEMBER : E '.' SUBNODE {
 }
 
 %code {
 }
 
 %code {

-    node_t* resolve_identifier(char*name)
+    node_t* var_read(variable_t*v)
+    {
+        typedcode_t o;
+       o.c = abc_getlocal(0, v->index);
+       o.t = v->type;
+       return mkcodenode(o);
+    }
+
+    node_t* resolve_identifier(const char*name)

     {
         typedcode_t o;
         o.t = 0;
     {
         typedcode_t o;
         o.t = 0;

@@ -3635,11 +3719,9 @@ MEMBER : E '.' SUBNODE {
         /* look at variables */
         if((v = find_variable(state, name))) {
             // name is a local variable
         /* look at variables */
         if((v = find_variable(state, name))) {
             // name is a local variable

-            o.c = abc_getlocal(o.c, v->index);
-            o.t = v->type;
-            return mkcodenode(o);
+           return var_read(v);

         }
         }

-        if((v = find_slot(state, name))) {
+        if((v = find_slot(state->method, name))) {

             o.c = abc_getscopeobject(o.c, 1);
             o.c = abc_getslot(o.c, v->index);
             o.t = v->type;
             o.c = abc_getscopeobject(o.c, 1);
             o.c = abc_getslot(o.c, v->index);
             o.t = v->type;

@@ -3648,55 +3730,65 @@ MEMBER : E '.' SUBNODE {
 
         int i_am_static = state->method->is_static;
 
 
         int i_am_static = state->method->is_static;
 

-        /* look at current class' members */
-        if(!state->method->inner && 
-           !state->xmlfilter &&
-            state->cls && 
-            (f = findmember_nsset(state->cls->info, name, 1)))
-        {
-            // name is a member or attribute in this class
-            int var_is_static = (f->flags&FLAG_STATIC);
-
-            if(f->kind == INFOTYPE_VAR && (f->flags&FLAG_CONST)) {
-                /* if the variable is a constant (and we know what is evaluates to), we
-                   can just use the value itself */
-                varinfo_t*v = (varinfo_t*)f;
-                if(v->value) {
-                    return mkconstnode(v->value);
-                }
-            }
-           
-            if(var_is_static >= i_am_static) {
-                if(f->kind == INFOTYPE_METHOD) {
-                    o.t = TYPE_FUNCTION(f);
-                } else {
-                    o.t = f->type;
-                }
-
-                if(var_is_static && !i_am_static) {
-                /* access to a static member from a non-static location.
-                   do this via findpropstrict:
-                   there doesn't seem to be any non-lookup way to access
-                   static properties of a class */
-                    state->method->late_binding = 1;
-                    o.t = f->type;
-                    namespace_t ns = {f->access, f->package};
-                    multiname_t m = {QNAME, &ns, 0, name};
-                    o.c = abc_findpropstrict2(o.c, &m);
-                    o.c = abc_getproperty2(o.c, &m);
-                    return mkcodenode(o);
-                } else if(f->slot>0) {
-                    o.c = abc_getlocal_0(o.c);
-                    o.c = abc_getslot(o.c, f->slot);
-                    return mkcodenode(o);
-                } else {
-                    MEMBER_MULTINAME(m, f, name);
-                    o.c = abc_getlocal_0(o.c);
-                    o.c = abc_getproperty2(o.c, &m);
-                    return mkcodenode(o);
-                }
-            }
-        } 
+        if(!state->method->inner && !state->xmlfilter && state->cls)
+       {
+           /* look at current class' members */
+           if((f = findmember_nsset(state->cls->info, name, 1, i_am_static)))
+           {
+               // name is a member or attribute in this class
+               int var_is_static = (f->flags&FLAG_STATIC);
+
+               if(f->kind == INFOTYPE_VAR && (f->flags&FLAG_CONST)) {
+                   /* if the variable is a constant (and we know what is evaluates to), we
+                      can just use the value itself */
+                   varinfo_t*v = (varinfo_t*)f;
+                   if(v->value) {
+                       return mkconstnode(v->value);
+                   }
+               }
+              
+               if(var_is_static >= i_am_static) {
+                   if(f->kind == INFOTYPE_METHOD) {
+                       o.t = TYPE_FUNCTION(f);
+                   } else {
+                       o.t = f->type;
+                   }
+
+                   if(var_is_static && !i_am_static) {
+                   /* access to a static member from a non-static location.
+                      do this via findpropstrict:
+                      there doesn't seem to be any non-lookup way to access
+                      static properties of a class */
+                       state->method->late_binding = 1;
+                       o.t = f->type;
+                       namespace_t ns = {f->access, f->package};
+                       multiname_t m = {QNAME, &ns, 0, name};
+                       o.c = abc_findpropstrict2(o.c, &m);
+                       o.c = abc_getproperty2(o.c, &m);
+                       return mkcodenode(o);
+                   } else if(f->slot>0) {
+                       o.c = abc_getlocal_0(o.c);
+                       o.c = abc_getslot(o.c, f->slot);
+                       return mkcodenode(o);
+                   } else {
+                       MEMBER_MULTINAME(m, f, name);
+                       o.c = abc_getlocal_0(o.c);
+                       o.c = abc_getproperty2(o.c, &m);
+                       return mkcodenode(o);
+                   }
+               }
+           } 
+           /* special case: it's allowed to access non-static constants
+              from a static context */
+           if(i_am_static && (f=findmember_nsset(state->cls->info, name, 1, 0))) {
+               if(f->kind == INFOTYPE_VAR && (f->flags&FLAG_CONST)) {
+                   varinfo_t*v = (varinfo_t*)f;
+                   if(v->value) {
+                       return mkconstnode(v->value);
+                   }
+               }
+           }
+       }

         
         /* look at actual classes, in the current package and imported */
         if(!state->xmlfilter && (a = find_class(name))) {
         
         /* look at actual classes, in the current package and imported */
         if(!state->xmlfilter && (a = find_class(name))) {

@@ -3713,7 +3805,7 @@ MEMBER : E '.' SUBNODE {
         if(!state->xmlfilter && 
            (dict_contains(state->import_toplevel_packages, name) || 
             registry_ispackage(name))) {
         if(!state->xmlfilter && 
            (dict_contains(state->import_toplevel_packages, name) || 
             registry_ispackage(name))) {

-            o.c = abc___pushpackage__(o.c, name);
+            o.c = abc___pushpackage__(o.c, (char*)name);

             o.t = 0;
             return mkcodenode(o); //?
         }
             o.t = 0;
             return mkcodenode(o); //?
         }

@@ -3736,6 +3828,12 @@ MEMBER : E '.' SUBNODE {
     }
 };
 
     }
 };
 

+/* TODO: causes 16 r/r conflicts */
+VAR_READ : T_NAMESPACE {
+    PASS2 
+    $$ = resolve_identifier($1);
+}
+

 VAR_READ : T_IDENTIFIER {
     PASS1
     /* Queue unresolved identifiers for checking against the parent
 VAR_READ : T_IDENTIFIER {
     PASS1
     /* Queue unresolved identifiers for checking against the parent

@@ -3793,7 +3891,7 @@ NAMESPACE_ID : "namespace" T_IDENTIFIER '=' T_STRING {
 }
 NAMESPACE_DECLARATION : MAYBE_MODIFIERS NAMESPACE_ID {
     PASS12
 }
 NAMESPACE_DECLARATION : MAYBE_MODIFIERS NAMESPACE_ID {
     PASS12

-    trie_put(active_namespaces, $2->name, (void*)$2->url);
+    trie_put(active_namespaces, (unsigned char*)$2->name, (void*)$2->url);

 
     namespace_t access = modifiers2access(&$1);
     varinfo_t* var = varinfo_register_global(access.access, state->package, $2->name);
 
     namespace_t access = modifiers2access(&$1);
     varinfo_t* var = varinfo_register_global(access.access, state->package, $2->name);

@@ -3815,13 +3913,13 @@ NAMESPACE_DECLARATION : MAYBE_MODIFIERS NAMESPACE_ID {
 
 DEFAULT_NAMESPACE : "default xml" "namespace" '=' E 
 {
 
 DEFAULT_NAMESPACE : "default xml" "namespace" '=' E 
 {

-    as3_warning("default xml namespaces not supported yet");

     $$ = 0;
     $$ = 0;

+    $$ = code_append($$, node_read($4).c);
+    $$ = abc_dxnslate($$);

 }
 
 USE_NAMESPACE : "use" "namespace" CLASS_SPEC {
     PASS12
 }
 
 USE_NAMESPACE : "use" "namespace" CLASS_SPEC {
     PASS12

-    const char*url = $3->name;

 
     varinfo_t*s = (varinfo_t*)$3;
     if(s->kind == INFOTYPE_UNRESOLVED) {
 
     varinfo_t*s = (varinfo_t*)$3;
     if(s->kind == INFOTYPE_UNRESOLVED) {

@@ -3834,9 +3932,9 @@ USE_NAMESPACE : "use" "namespace" CLASS_SPEC {
         syntaxerror("%s.%s is not a public namespace (%d)", $3->package, $3->name, s?s->kind:-1);
     if(!s->value || !NS_TYPE(s->value->type))
         syntaxerror("%s.%s is not a namespace", $3->package, $3->name);
         syntaxerror("%s.%s is not a public namespace (%d)", $3->package, $3->name, s?s->kind:-1);
     if(!s->value || !NS_TYPE(s->value->type))
         syntaxerror("%s.%s is not a namespace", $3->package, $3->name);

-    url = s->value->ns->name;

 
 

-    trie_put(active_namespaces, $3->name, (void*)url);
+    const char*url = s->value->ns->name;
+    trie_put(active_namespaces, (unsigned char*)$3->name, (void*)url);

     add_active_url(url);
     $$=0;
 }
     add_active_url(url);
     $$=0;
 }