X-Git-Url: http://git.asbjorn.it/?a=blobdiff_plain;f=lib%2Fas3%2Fparser.y;h=28371166914e086fc5562792b060206c13202a92;hb=a950e0e0a0fc121fcd827170a241bda385f92b7f;hp=5853162ba97db5614fc4382084bf60771cc002b5;hpb=6a32d8fe4841a4f6fde015b92bff160fb93de037;p=swftools.git

diff --git a/lib/as3/parser.y b/lib/as3/parser.y
index 5853162..2837116 100644
--- a/lib/as3/parser.y
+++ b/lib/as3/parser.y
@@ -41,16 +41,16 @@
 %union tokenunion {
     tokenptr_t token;
 
-    struct _class_signature*class_signature;
-    struct _class_signature_list*class_signature_list;
+    class_signature_t*class_signature;
+    class_signature_list_t*class_signature_list;
 
     int number_int;
     unsigned int number_uint;
     double number_float;
-    struct _code*code;
-    struct _typedcode value;
-    struct _typedcode_list*value_list;
-    struct _writeable writeable;
+    code_t*code;
+    typedcode_t value;
+    typedcode_list_t*value_list;
+    writeable_t writeable;
     char*string;
 }
 
@@ -149,7 +149,6 @@
 %type <code> ASSIGNMENT FOR_INIT
 %type <token> IMPORT
 %type <class_signature> MAYBETYPE
-%type <token> PACKAGESPEC
 %type <token> GETSET
 %type <token> PARAM
 %type <token> PARAMS
@@ -257,7 +256,7 @@ static char* concat3str(const char* t1, const char* t2, const char* t3)
 }
 
 typedef struct _import {
-    char*path;
+    char*package;
 } import_t;
 
 DECLARE_LIST(import);
@@ -275,7 +274,10 @@ typedef struct _state {
     code_t*initcode;
 
     abc_method_body_t*m;
-    import_list_t*imports;
+    
+    import_list_t*wildcard_imports;
+    dict_t*imports;
+    char has_own_imports;
    
     /* class data */
     char*classname;
@@ -303,14 +305,26 @@ static void new_state()
         memcpy(s, state, sizeof(state_t)); //shallow copy
     sl->next = state_stack;
     sl->state = s;
-    if(oldstate)
+    if(oldstate) {
         s->local_var_base = array_length(oldstate->vars) + oldstate->local_var_base;
+    }
+    if(!s->imports) {
+        s->imports = dict_new();
+    }
     state_stack = sl;
     state = s;
     state->level++;
     state->vars = array_new();
     state->initcode = 0;
+    state->has_own_imports = 0;
 }
+static void state_has_imports()
+{
+    state->wildcard_imports = list_clone(state->wildcard_imports);
+    state->imports = dict_clone(state->imports);
+    state->has_own_imports = 1;
+}
+
 static void old_state()
 {
     if(!state_stack || !state_stack->next)
@@ -320,6 +334,14 @@ static void old_state()
     state_stack = state_stack->next;
     free(old);
     state = state_stack->state;
+    /*if(state->initcode) {
+        printf("residual initcode\n");
+        code_dump(state->initcode, 0, 0, "", stdout);
+    }*/
+    if(oldstate->has_own_imports) {
+        list_free(oldstate->wildcard_imports);
+        dict_destroy(oldstate->imports);oldstate->imports=0;
+    }
     state->initcode = code_append(state->initcode, oldstate->initcode);
 }
 void initialize_state()
@@ -370,7 +392,7 @@ static void endpackage()
 }
 
 char*globalclass=0;
-static void startclass(token_t*modifiers, token_t*name, class_signature_t*extends, class_signature_list_t*implements)
+static void startclass(token_t*modifiers, token_t*name, class_signature_t*extends, class_signature_list_t*implements, char interface)
 {
     if(state->cls) {
         syntaxerror("inner classes now allowed"); 
@@ -384,12 +406,12 @@ static void startclass(token_t*modifiers, token_t*name, class_signature_t*extend
     printf("  modifiers: ");for(t=modifiers->tokens;t;t=t->next) printf("%s ", t->token->text);printf("\n");
     if(extends) 
         printf("  extends: %s.%s\n", extends->package, extends->name);
-
     printf("  implements (%d): ", list_length(implements));
     for(mlist=implements;mlist;mlist=mlist->next)  {
-        printf("%s ", mlist->class_signature->name);
+        printf("%s ", mlist->class_signature?mlist->class_signature->name:0);
     }
-    printf("\n");*/
+    printf("\n");
+    */
 
     char public=0,internal=0,final=0,sealed=1;
     for(t=modifiers->tokens;t;t=t->next) {
@@ -428,12 +450,14 @@ static void startclass(token_t*modifiers, token_t*name, class_signature_t*extend
     
     class_signature_t* classname = class_signature_register(access, package, state->classname);
 
+    MULTINAME(classname2,classname);
+    
     multiname_t*extends2 = sig2mname(extends);
-    multiname_t*classname2 = sig2mname(classname);
 
-    state->cls = abc_class_new(state->file, classname2, extends2);
+    state->cls = abc_class_new(state->file, &classname2, extends2);
     if(final) abc_class_final(state->cls);
     if(sealed) abc_class_sealed(state->cls);
+    if(interface) abc_class_interface(state->cls);
 
     for(mlist=implements;mlist;mlist=mlist->next) {
         MULTINAME(m, mlist->class_signature);
@@ -441,7 +465,7 @@ static void startclass(token_t*modifiers, token_t*name, class_signature_t*extend
     }
 
     /* now write the construction code for this class */
-    int slotindex = abc_initscript_addClassTrait(state->init, classname2, state->cls);
+    int slotindex = abc_initscript_addClassTrait(state->init, &classname2, state->cls);
 
     abc_method_body_t*m = state->init->method->body;
     __ getglobalscope(m);
@@ -470,9 +494,13 @@ static void startclass(token_t*modifiers, token_t*name, class_signature_t*extend
     /* TODO: if this is one of *our* classes, we can also 
              do a getglobalscope/getslot <nr> (which references
              the init function's slots) */
-    __ getlex2(m, extends2);
-    __ dup(m);
-    __ pushscope(m); // we get a Verify Error #1107 if this is not the top scope
+    if(extends2) {
+        __ getlex2(m, extends2);
+        __ dup(m);
+        __ pushscope(m); // we get a Verify Error #1107 if this is not the top scope
+    } else {
+        __ pushnull(m);
+    }
     __ newclass(m,state->cls);
     while(count--) {
         __ popscope(m);
@@ -487,6 +515,7 @@ static void startclass(token_t*modifiers, token_t*name, class_signature_t*extend
             globalclass = strdup(state->classname);
         }
     }
+    multiname_destroy(extends2);
 }
 
 static void endclass()
@@ -494,20 +523,6 @@ static void endclass()
     /*printf("leaving class %s\n", state->classname);*/
     old_state();
 }
-static void addimport(token_t*t)
-{
-    NEW(import_t,i);
-    i->path = t->text;
-    list_append(state->imports, i);
-}
-static void print_imports()
-{
-    import_list_t*l = state->imports;
-    while(l) {
-        printf("  import %s\n", l->import->path);
-        l = l->next;
-    }
-}
 static void startfunction(token_t*ns, token_t*mod, token_t*getset, token_t*name,
                           token_t*params, class_signature_t*type)
 {
@@ -536,6 +551,7 @@ static void startfunction(token_t*ns, token_t*mod, token_t*getset, token_t*name,
     } else {
         state->m = abc_class_method(state->cls, type2, name->text, 0);
     }
+    /* state->vars is initialized by state_new */
     array_append(state->vars, "this", 0);
 
     __ getlocal_0(state->m);
@@ -545,11 +561,13 @@ static void startfunction(token_t*ns, token_t*mod, token_t*getset, token_t*name,
 }
 static void endfunction()
 {
-    printf("leaving function %s\n", state->function);
+    /*printf("leaving function %s\n", state->function);*/
     __ returnvoid(state->m);
 
     old_state();
 }
+
+
 static token_t* empty_token()
 {
     NEW(token_t,t);
@@ -578,7 +596,7 @@ void extend_s(token_t*list, char*seperator, token_t*add) {
     list->text[l1+l2+l3]=0;
 }
 
-int find_variable(char*name, class_signature_t**m)
+static int find_variable(char*name, class_signature_t**m)
 {
     state_list_t* s = state_stack;
     while(s) {
@@ -592,6 +610,27 @@ int find_variable(char*name, class_signature_t**m)
         s = s->next;
     }
     syntaxerror("undefined variable: %s", name);
+} 
+static char variable_exists(char*name) 
+{
+    return array_contains(state->vars, name);
+}
+static int new_variable(char*name, class_signature_t*type)
+{
+    return array_append(state->vars, name, type) + state->local_var_base;
+}
+code_t* killvars(code_t*c) 
+{
+    int t;
+    for(t=0;t<state->vars->num;t++) {
+        class_signature_t*type = array_getvalue(state->vars, t);
+        //do this always, otherwise register types don't match
+        //in the verifier when doing nested loops
+        //if(!TYPE_IS_BUILTIN_SIMPLE(type)) {
+            c = abc_kill(c, t+state->local_var_base);
+        //}
+    }
+    return c;
 }
 
 class_signature_t*join_types(class_signature_t*type1, class_signature_t*type2, char op)
@@ -603,20 +642,46 @@ char is_subtype_of(class_signature_t*type, class_signature_t*supertype)
     return 1; // FIXME
 }
 
-#define TYPE_ANY                  registry_getanytype()
-#define TYPE_IS_ANY(t)    ((t) == registry_getanytype())
-#define TYPE_INT                  registry_getintclass()
-#define TYPE_IS_INT(t)    ((t) == registry_getintclass())
-#define TYPE_UINT                 registry_getuintclass()
-#define TYPE_IS_UINT(t)   ((t) == registry_getuintclass())
-#define TYPE_FLOAT                registry_getnumberclass()
-#define TYPE_IS_FLOAT(t)  ((t) == registry_getnumberclass())
-#define TYPE_BOOLEAN              registry_getbooleanclass()
-#define TYPE_IS_BOOLEAN(t)((t) == registry_getbooleanclass())
-#define TYPE_STRING               registry_getstringclass()
-#define TYPE_IS_STRING(t) ((t) == registry_getstringclass())
-#define TYPE_NULL                 registry_getnullclass()
-#define TYPE_IS_NULL(t)   ((t) == registry_getnullclass())
+void breakjumpsto(code_t*c, code_t*jump) 
+{
+    while(c->prev) 
+        c=c->prev;
+    while(c) {
+        if(c->opcode == OPCODE___BREAK__) {
+            c->opcode = OPCODE_JUMP;
+            c->branch = jump;
+        }
+        c = c->next;
+    }
+}
+code_t*converttype(code_t*c, class_signature_t*from, class_signature_t*to)
+{
+    if(!to) {
+        /*TODO: can omit this if from is zero? */
+        return abc_coerce_a(c);
+    }
+    if(TYPE_IS_NUMBER(from) && TYPE_IS_UINT(to)) {
+        MULTINAME(m, TYPE_UINT);
+        return abc_coerce2(c, &m);
+    }
+    if(TYPE_IS_NUMBER(from) && TYPE_IS_INT(to)) {
+        MULTINAME(m, TYPE_INT);
+        return abc_coerce2(c, &m);
+    }
+    return c;
+}
+
+code_t*defaultvalue(code_t*c, class_signature_t*type)
+{
+    if(TYPE_IS_INT(type) || TYPE_IS_UINT(type) || TYPE_IS_FLOAT(type)) {
+       c = abc_pushbyte(c, 0);
+    } else if(TYPE_IS_BOOLEAN(type)) {
+       c = abc_pushfalse(c);
+    } else {
+       c = abc_pushnull(c);
+    }
+    return c;
+}
 
 %}
 
@@ -658,6 +723,9 @@ CODEBLOCK :  CODEPIECE %prec below_semicolon {$$=$1;}
 FUNCTION_DECLARATION: MODIFIERS "function" GETSET T_IDENTIFIER '(' PARAMS ')' 
                       MAYBETYPE '{' {startfunction(0,$1,$3,$4,$6,$8)} MAYBECODE '}' {
     if(!state->m) syntaxerror("internal error: undefined function");
+    state->initcode = abc_nop(state->initcode);
+    state->initcode = abc_nop(state->initcode);
+    state->initcode = abc_nop(state->initcode);
     state->m->code = code_append(state->initcode, $11);state->initcode=0;
     endfunction()
 }
@@ -671,33 +739,50 @@ MAYBEEXPRESSION : '=' EXPRESSION {$$=$2;}
 
 VAR : "const" | "var"
 VARIABLE_DECLARATION : VAR T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION {
-    if(array_contains(state->vars, $2->text))
+    if(variable_exists($2->text))
         syntaxerror("Variable %s already defined", $2->text);
-    $$ = $4.c;
    
     if(!is_subtype_of($4.t, $3)) {
         syntaxerror("Can't convert %s to %s", $4.t->name, 
                                               $3->name);
     }
 
-    int index = array_append(state->vars, $2->text, $3) + state->local_var_base;
-    $$ = abc_setlocal($$, index);
-
+    int index = new_variable($2->text, $3);
+    
     if($3) {
-        if(TYPE_IS_INT($3) || TYPE_IS_UINT($3) || TYPE_IS_FLOAT($3)) {
-            state->initcode = abc_pushbyte(state->initcode, 32);
-        } else if(TYPE_IS_BOOLEAN($3)) {
-            state->initcode = abc_pushfalse(state->initcode);
+        if($4.c->prev || $4.c->opcode != OPCODE_PUSHUNDEFINED) {
+            $$ = $4.c;
+            $$ = converttype($$, $4.t, $3);
+            $$ = abc_setlocal($$, index);
         } else {
-            state->initcode = abc_pushnull(state->initcode);
+            $$ = defaultvalue(0, $3);
+            $$ = abc_setlocal($$, index);
         }
+
+        /* push default value for type on stack */
+        state->initcode = defaultvalue(state->initcode, $3);
         state->initcode = abc_setlocal(state->initcode, index);
-    } /*else {
-        // that's the default for a local register, anyway
+    } else {
+        /* only bother to actually set this variable if its syntax is either
+            var x:type;
+           or
+            var x=expr;
+        */
+        if($4.c->prev || $4.c->opcode != OPCODE_PUSHUNDEFINED) {
+            $$ = $4.c;
+            $$ = abc_coerce_a($$);
+            $$ = abc_setlocal($$, index);
+        } else {
+            $$ = code_new();
+        }
+    }
+    
+    /* that's the default for a local register, anyway
+        else {
         state->initcode = abc_pushundefined(state->initcode);
         state->initcode = abc_setlocal(state->initcode, index);
     }*/
-    printf("variable %s -> %d (%s)\n", $2->text, index, $4.t->name);
+    printf("variable %s -> %d (%s)\n", $2->text, index, $4.t?$4.t->name:"");
 }
 ASSIGNMENT :           T_IDENTIFIER '=' EXPRESSION {
     class_signature_t*type=0;
@@ -719,7 +804,9 @@ MAYBEELSE: "else" CODEBLOCK {$$=$2;}
 //MAYBEELSE: ';' "else" CODEBLOCK {$$=$3;}
 
 IF  : "if" '(' {new_state();} EXPRESSION ')' CODEBLOCK MAYBEELSE {
-    $$=$4.c;
+    $$ = state->initcode;state->initcode=0;
+
+    $$ = code_append($$, $4.c);
     code_t*myjmp,*myif = $$ = abc_iffalse($$, 0);
    
     $$ = code_append($$, $6);
@@ -731,33 +818,43 @@ IF  : "if" '(' {new_state();} EXPRESSION ')' CODEBLOCK MAYBEELSE {
         $$ = code_append($$, $7);
         myjmp->branch = $$ = abc_label($$);
     }
-    old_state();
+    
+    $$ = killvars($$);old_state();
 }
 
 FOR_INIT : {$$=code_new();}
 FOR_INIT : ASSIGNMENT | VARIABLE_DECLARATION | VOIDEXPRESSION
 
 FOR : "for" '(' {new_state();} FOR_INIT ';' EXPRESSION ';' VOIDEXPRESSION ')' CODEBLOCK {
-    $$ = $4;
+    $$ = state->initcode;state->initcode=0;
+
+    $$ = code_append($$, $4);
     code_t*loopstart = $$ = abc_label($$);
     $$ = code_append($$, $6.c);
     code_t*myif = $$ = abc_iffalse($$, 0);
     $$ = code_append($$, $10);
     $$ = code_append($$, $8);
     $$ = abc_jump($$, loopstart);
-    $$ = abc_label($$);
-    myif->branch = $$;
-    old_state();
+    code_t*out = $$ = abc_label($$);
+    breakjumpsto($$, out);
+    myif->branch = out;
+
+    $$ = killvars($$);old_state();
 }
 
 WHILE : "while" '(' {new_state();} EXPRESSION ')' CODEBLOCK {
-    code_t*myjmp = $$ = abc_jump(0, 0);
+    $$ = state->initcode;state->initcode=0;
+
+    code_t*myjmp = $$ = abc_jump($$, 0);
     code_t*loopstart = $$ = abc_label($$);
     $$ = code_append($$, $6);
     myjmp->branch = $$ = abc_label($$);
     $$ = code_append($$, $4.c);
     $$ = abc_iftrue($$, loopstart);
-    old_state();
+    code_t*out = $$ = abc_label($$);
+    breakjumpsto($$, out);
+
+    $$ = killvars($$);old_state();
 }
 
 BREAK : "break" {
@@ -769,7 +866,52 @@ BREAK : "break" {
 PACKAGE_DECLARATION : "package" MULTILEVELIDENTIFIER '{' {startpackage($2)} MAYBECODE '}' {endpackage()}
 PACKAGE_DECLARATION : "package" '{' {startpackage(0)} MAYBECODE '}' {endpackage()}
 
-IMPORT : "import" PACKAGESPEC {addimport($2);}
+PACKAGE: PACKAGE '.' X_IDENTIFIER {$$ = concat3($1,$2,$3);}
+PACKAGE: X_IDENTIFIER             {$$=$1;}
+
+IMPORT : "import" PACKAGE '.' X_IDENTIFIER {
+       class_signature_t*c = registry_findclass($2->text, $4->text);
+       if(!c) 
+            syntaxerror("Couldn't import %s.%s\n", $2->text, $4->text);
+       state_has_imports();
+       dict_put(state->imports, $4->text, c);
+       $$=0;
+}
+IMPORT : "import" PACKAGE '.' '*' {
+       NEW(import_t,i);
+       i->package = $2->text;
+       state_has_imports();
+       list_append(state->wildcard_imports, i);
+       $$=0;
+}
+
+/* ------------ classes and interfaces -------------- */
+
+MODIFIERS : {$$=empty_token();}
+MODIFIERS : MODIFIER_LIST {$$=$1}
+MODIFIER_LIST : MODIFIER MODIFIER_LIST {extend($2,$1);$$=$2;}
+MODIFIER_LIST : MODIFIER               {$$=empty_token();extend($$,$1);}
+MODIFIER : KW_PUBLIC | KW_PRIVATE | KW_PROTECTED | KW_STATIC | KW_DYNAMIC | KW_FINAL | KW_OVERRIDE | KW_NATIVE | KW_INTERNAL
+
+EXTENDS : {$$=registry_getobjectclass();}
+EXTENDS : KW_EXTENDS PACKAGEANDCLASS {$$=$2;}
+
+EXTENDS_LIST : {$$=list_new();}
+EXTENDS_LIST : KW_EXTENDS PACKAGEANDCLASS_LIST {$$=$2;}
+
+IMPLEMENTS_LIST : {$$=list_new();}
+IMPLEMENTS_LIST : KW_IMPLEMENTS PACKAGEANDCLASS_LIST {$$=$2;}
+
+CLASS_DECLARATION : MODIFIERS "class" T_IDENTIFIER 
+                              EXTENDS IMPLEMENTS_LIST 
+                              '{' {startclass($1,$3,$4,$5, 0);} 
+                              MAYBE_DECLARATION_LIST 
+                              '}' {endclass();}
+INTERFACE_DECLARATION : MODIFIERS "interface" T_IDENTIFIER 
+                              EXTENDS_LIST 
+                              '{' {startclass($1,$3,0,$4,1);}
+                              MAYBE_IDECLARATION_LIST 
+                              '}' {endclass();}
 
 TYPE : PACKAGEANDCLASS {$$=$1;}
      | '*'        {$$=registry_getanytype();}
@@ -794,8 +936,8 @@ NAMESPACE_DECLARATION : MODIFIERS KW_NAMESPACE T_IDENTIFIER '=' T_STRING
 //NAMESPACE : T_IDENTIFIER {$$=$1};
 
 CONSTANT : T_BYTE {$$.c = abc_pushbyte(0, $1);
-                   MULTINAME(m, registry_getintclass());
-                   $$.c = abc_coerce2($$.c, &m); // FIXME
+                   //MULTINAME(m, registry_getintclass());
+                   //$$.c = abc_coerce2($$.c, &m); // FIXME
                    $$.t = TYPE_INT;
                   }
 CONSTANT : T_SHORT {$$.c = abc_pushshort(0, $1);
@@ -878,28 +1020,30 @@ E : '(' E ')' {$$=$2;}
 E : '-' E {$$=$2;}
 
 E : LH "+=" E {$$.c = $1.read;$$.c=code_append($$.c,$3.c);$$.c=abc_add($$.c);
-               MULTINAME(m, registry_getintclass());
-               $$.c=abc_coerce2($$.c, &m); // FIXME
+               class_signature_t*type = join_types($1.type, $3.t, '+');
+               $$.c=converttype($$.c, type, $1.type);
                $$.c=abc_dup($$.c);$$.c=code_append($$.c,$1.write);
                $$.t = $1.type;
               }
 E : LH "-=" E {$$.c = $1.read;$$.c=code_append($$.c,$3.c);$$.c=abc_add($$.c);
-               MULTINAME(m, registry_getintclass());
-               $$.c=abc_coerce2($$.c, &m); // FIXME
+               class_signature_t*type = join_types($1.type, $3.t, '-');
+               $$.c=converttype($$.c, type, $1.type);
                $$.c=abc_dup($$.c);$$.c=code_append($$.c,$1.write);
                $$.t = $1.type;
               }
 
 // TODO: use inclocal where appropriate
 E : LH "++" {$$.c = $1.read;$$.c=abc_increment($$.c);
-             MULTINAME(m, registry_getintclass());
-             $$.c=abc_coerce2($$.c, &m); //FIXME
+             class_signature_t*type = $1.type;
+             if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) type = TYPE_NUMBER;
+             $$.c=converttype($$.c, type, $1.type);
              $$.c=abc_dup($$.c);$$.c=code_append($$.c,$1.write);
              $$.t = $1.type;
             }
 E : LH "--" {$$.c = $1.read;$$.c=abc_decrement($$.c);
-             MULTINAME(m, registry_getintclass());
-             $$.c=abc_coerce2($$.c, &m); //FIXME
+             class_signature_t*type = $1.type;
+             if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) type = TYPE_NUMBER;
+             $$.c=converttype($$.c, 0, $1.type);
              $$.c=abc_dup($$.c);$$.c=code_append($$.c,$1.write);
              $$.t = $1.type;
             }
@@ -955,52 +1099,51 @@ VAR_READ : T_IDENTIFIER {
 // keywords which also may be identifiers
 X_IDENTIFIER : T_IDENTIFIER | KW_PACKAGE
 
-PACKAGESPEC : PACKAGESPEC '.' PACKAGESPEC {if($1->text[0]=='*') syntaxerror("wildcard in the middle of path");
-                                           $$ = concat3($1,$2,$3);}
-PACKAGESPEC : X_IDENTIFIER                {$$=$1;}
-PACKAGESPEC : '*'                         {$$=$1;}
-
 GETSET : "get" {$$=$1;}
        | "set" {$$=$1;}
        |       {$$=empty_token();}
 
-CLASS_DECLARATION : MODIFIERS "class" T_IDENTIFIER EXTENDS IMPLEMENTS_LIST '{' {startclass($1,$3,$4,$5);} MAYBE_DECLARATION_LIST '}' {endclass();}
-INTERFACE_DECLARATION : MODIFIERS "interface" T_IDENTIFIER EXTENDS_LIST '{' MAYBE_IDECLARATION_LIST '}'
-
 PARAMS: {$$=empty_token();}
 PARAMS: PARAM_LIST {$$=$1;}
 PARAM_LIST: PARAM_LIST ',' PARAM {extend($1,$3);$$=$1;}
 PARAM_LIST: PARAM                {$$=empty_token();extend($$,$1);}
 PARAM:  T_IDENTIFIER ':' TYPE {$$=$1;}
 
-MODIFIERS : {$$=empty_token();}
-MODIFIERS : MODIFIER_LIST {$$=$1}
-MODIFIER_LIST : MODIFIER MODIFIER_LIST {extend($2,$1);$$=$2;}
-MODIFIER_LIST : MODIFIER               {$$=empty_token();extend($$,$1);}
-MODIFIER : KW_PUBLIC | KW_PRIVATE | KW_PROTECTED | KW_STATIC | KW_DYNAMIC | KW_FINAL | KW_OVERRIDE | KW_NATIVE | KW_INTERNAL
-
 DECLARATION : VARIABLE_DECLARATION
 DECLARATION : FUNCTION_DECLARATION
 
 IDECLARATION : VARIABLE_DECLARATION
 IDECLARATION : FUNCTION_DECLARATION
 
-IMPLEMENTS_LIST : {$$=list_new();}
-IMPLEMENTS_LIST : KW_IMPLEMENTS PACKAGEANDCLASS_LIST {$$=$2;}
-
-EXTENDS : {$$=registry_getobjectclass();}
-EXTENDS : KW_EXTENDS PACKAGEANDCLASS {$$=$2;}
-
-EXTENDS_LIST : {$$=list_new();}
-EXTENDS_LIST : KW_EXTENDS PACKAGEANDCLASS_LIST {$$=$2;}
-
 //IDENTIFIER_LIST : T_IDENTIFIER ',' IDENTIFIER_LIST {extend($3,$1);$$=$3;}
 //IDENTIFIER_LIST : T_IDENTIFIER                     {$$=empty_token();extend($$,$1);}
 
-PACKAGEANDCLASS : T_IDENTIFIER {$$ = registry_findclass(state->package, $1->text);}
-PACKAGEANDCLASS : PACKAGE '.' T_IDENTIFIER {$$ = registry_findclass($1->text, $3->text);}
-PACKAGE : X_IDENTIFIER
-PACKAGE : PACKAGE '.' X_IDENTIFIER {$$=$1;extend_s($$,".",$3);}
+PACKAGEANDCLASS : T_IDENTIFIER {
+    $$ = registry_findclass(state->package, $1->text);
+    import_list_t*l = state->wildcard_imports;
+    while(l) {
+        if($$)
+            break;
+        //printf("does package %s contain a class %s?\n", l->import->package, $1->text);
+        $$ = registry_findclass(l->import->package, $1->text);
+        l = l->next;
+    }
+    dictentry_t* e = dict_get_slot(state->imports, $1->text);
+    while(e) {
+        if($$)
+            break;
+        if(!strcmp(e->key, $1->text)) {
+            $$ = (class_signature_t*)e->data;
+        }
+        e = e->next;
+    }
+    if(!$$) syntaxerror("Could not find class %s\n", $1->text);
+}
+PACKAGEANDCLASS : PACKAGE '.' T_IDENTIFIER {
+    $$ = registry_findclass($1->text, $3->text);
+    if(!$$) syntaxerror("Couldn't find class %s.%s\n", $1->text, $3->text);
+}
+
 
 MULTILEVELIDENTIFIER : MULTILEVELIDENTIFIER '.' X_IDENTIFIER {$$=$1;extend_s($$, ".", $3)}
 MULTILEVELIDENTIFIER : T_IDENTIFIER                 {$$=$1;extend($$,$1)};