X-Git-Url: http://git.asbjorn.it/?a=blobdiff_plain;f=lib%2Fas3%2Fparser.y;h=516f5d30701108f673917b3968a9da1b0f65351e;hb=2a819eb7bb914f004ba919f621c4e82fcb2bffed;hp=59e7f6a474a59b0d727a4143f7b9f4d6e7cdfc5c;hpb=11515db43fbe7f5d4b740203bc5716cf3a80ab95;p=swftools.git diff --git a/lib/as3/parser.y b/lib/as3/parser.y index 59e7f6a..516f5d3 100644 --- a/lib/as3/parser.y +++ b/lib/as3/parser.y @@ -40,15 +40,19 @@ %union tokenunion { tokenptr_t token; - multiname_t*multiname; - multiname_list_t*multiname_list; + + classinfo_t*classinfo; + classinfo_list_t*classinfo_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; + param_t* param; + param_list_t* param_list; + writeable_t writeable; char*string; } @@ -80,8 +84,9 @@ %token KW_SET "set" %token KW_STATIC %token KW_IMPORT "import" +%token KW_RETURN "return" %token KW_INTERFACE "interface" -%token KW_NULL +%token KW_NULL "null" %token KW_VAR "var" %token KW_DYNAMIC %token KW_OVERRIDE @@ -127,6 +132,7 @@ %token T_STAR '*' %token T_DOT '.' +%type X_IDENTIFIER %type CODE %type CODEPIECE %type CODEBLOCK MAYBECODE @@ -142,36 +148,34 @@ %type E %type LH %type CONSTANT -%type FOR IF WHILE MAYBEELSE BREAK +%type FOR IF WHILE MAYBEELSE BREAK RETURN %type USE_NAMESPACE %type ASSIGNMENT FOR_INIT %type IMPORT -%type MAYBETYPE -%type PACKAGESPEC +%type MAYBETYPE %type GETSET -%type PARAM -%type PARAMS -%type PARAM_LIST +%type PARAM +%type PARAM_LIST +%type MAYBE_PARAM_LIST %type MODIFIERS %type MODIFIER_LIST -%type IMPLEMENTS_LIST -%type EXTENDS -%type EXTENDS_LIST -%type PACKAGEANDCLASS -%type PACKAGEANDCLASS_LIST -%type MULTILEVELIDENTIFIER -%type TYPE +%type IMPLEMENTS_LIST +%type EXTENDS +%type EXTENDS_LIST +%type CLASS PACKAGEANDCLASS QNAME +%type QNAME_LIST +%type TYPE %type VAR //%type VARIABLE %type VAR_READ %type NEW -%type X_IDENTIFIER +//%type T_IDENTIFIER %type MODIFIER %type PACKAGE %type FUNCTIONCALL -%type MAYBE_EXPRESSION_LIST EXPRESSION_LIST +%type MAYBE_EXPRESSION_LIST EXPRESSION_LIST MAYBE_PARAM_VALUES -// precendence: from low to high +// precedence: from low to high // http://livedocs.adobe.com/flash/9.0/main/wwhelp/wwhimpl/common/html/wwhelp.htm?context=LiveDocs_Parts&file=00000012.html %left prec_none @@ -187,7 +191,7 @@ %nonassoc '|' %nonassoc '^' %nonassoc '&' -%nonassoc "!=" "==" "<=" '<' ">=" '>' // TODO: support "a < b < c" syntax? +%nonassoc "!=" "==" "===" "<=" '<' ">=" '>' // TODO: support "a < b < c" syntax? %nonassoc "is" %left '-' %left '+' @@ -208,6 +212,12 @@ %left ';' %nonassoc "else" %left '(' + +// needed for "return" precedence: +%nonassoc T_STRING T_REGEXP +%nonassoc T_INT T_UINT T_BYTE T_SHORT T_FLOAT +%nonassoc "new" "false" "true" "null" + %left prec_highest @@ -255,7 +265,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); @@ -273,7 +283,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; @@ -287,6 +300,8 @@ static state_t* state = 0; DECLARE_LIST(state); +#define MULTINAME(m,x) multiname_t m;namespace_t m##_ns;registry_fill_multiname(&m, &m##_ns, x); + static state_list_t*state_stack=0; static void new_state() @@ -299,14 +314,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) @@ -316,6 +343,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() @@ -356,34 +391,36 @@ static void startpackage(token_t*t) } new_state(); char*name = t?t->text:""; - printf("entering package \"%s\"\n", name); + /*printf("entering package \"%s\"\n", name);*/ state->package = name; } static void endpackage() { - printf("leaving package \"%s\"\n", state->package); + /*printf("leaving package \"%s\"\n", state->package);*/ old_state(); } char*globalclass=0; -static void startclass(token_t*modifiers, token_t*name, multiname_t*extends, multiname_list_t*implements) +static void startclass(token_t*modifiers, token_t*name, classinfo_t*extends, classinfo_list_t*implements, char interface) { if(state->cls) { syntaxerror("inner classes now allowed"); } new_state(); state->classname = name->text; - printf("entering class %s\n", name->text); + token_list_t*t=0; + classinfo_list_t*mlist=0; + /*printf("entering class %s\n", name->text); printf(" modifiers: ");for(t=modifiers->tokens;t;t=t->next) printf("%s ", t->token->text);printf("\n"); - printf(" extends: %s\n", multiname_tostring(extends)); - - multiname_list_t*mlist=0; + 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 ", multiname_tostring(mlist->multiname)); + printf("%s ", mlist->classinfo?mlist->classinfo->name:0); } printf("\n"); + */ char public=0,internal=0,final=0,sealed=1; for(t=modifiers->tokens;t;t=t->next) { @@ -403,43 +440,61 @@ static void startclass(token_t*modifiers, token_t*name, multiname_t*extends, mul syntaxerror("public and internal not supported at the same time."); /* create the class name, together with the proper attributes */ - multiname_t* classname = 0; - if(!public && !state->package) - classname = multiname_new(namespace_new_private(current_filename), state->classname); - else if(!public && state->package) - classname = multiname_new(namespace_new_packageinternal(state->package), state->classname); - else if(state->package) - classname = multiname_new(namespace_new_package(state->package), state->classname); - else + int access=0; + char*package=0; + + if(!public && !state->package) { + access = ACCESS_PRIVATE; package = current_filename; + } else if(!public && state->package) { + access = ACCESS_PACKAGEINTERNAL; package = state->package; + } else if(state->package) { + access = ACCESS_PACKAGE; package = state->package; + } else { syntaxerror("public classes only allowed inside a package"); + } + + if(registry_findclass(package, state->classname)) { + syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, state->classname); + } + + classinfo_t* classname = classinfo_register(access, package, state->classname); - state->cls = abc_class_new(state->file, classname, extends); + MULTINAME(classname2,classname); + + multiname_t*extends2 = sig2mname(extends); + + 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) { - abc_class_add_interface(state->cls, mlist->multiname); + MULTINAME(m, mlist->classinfo); + abc_class_add_interface(state->cls, &m); } /* now write the construction code for this class */ - int slotindex = abc_initscript_addClassTrait(state->init, classname, state->cls); + int slotindex = abc_initscript_addClassTrait(state->init, &classname2, state->cls); abc_method_body_t*m = state->init->method->body; __ getglobalscope(m); - multiname_t*s = extends; + classinfo_t*s = extends; int count=0; while(s) { //TODO: take a look at the current scope stack, maybe // we can re-use something - s = registry_getsuperclass(s); + s = s->superclass; if(!s) break; - __ getlex2(m, s); - __ pushscope(m); + + multiname_t*s2 = sig2mname(s); + __ getlex2(m, s2); + multiname_destroy(s2); + + __ pushscope(m); count++; m->code = m->code->prev->prev; // invert - count++; } /* continue appending after last op end */ while(m->code && m->code->next) m->code = m->code->next; @@ -447,79 +502,92 @@ static void startclass(token_t*modifiers, token_t*name, multiname_t*extends, mul /* TODO: if this is one of *our* classes, we can also do a getglobalscope/getslot (which references the init function's slots) */ - __ getlex2(m, extends); - __ dup(m); - __ pushscope(m); // we get a Verify Error #1107 if this is not the top scope + if(extends2) { + __ getlex2(m, extends2); + __ dup(m); + /* notice: we get a Verify Error #1107 if the top elemnt on the scope + stack is not the superclass */ + __ pushscope(m);count++; + } else { + __ pushnull(m); + /* notice: we get a verify error #1107 if the top element on the scope + stack is not the global object */ + __ getlocal_0(m); + __ pushscope(m);count++; + } __ newclass(m,state->cls); while(count--) { __ popscope(m); } __ setslot(m, slotindex); - if(!globalclass && public && multiname_equals(registry_getMovieClip(),extends)) { + /* flash.display.MovieClip handling */ + if(!globalclass && public && classinfo_equals(registry_getMovieClip(),extends)) { if(state->package && state->package[0]) { globalclass = concat3str(state->package, ".", state->classname); } else { globalclass = strdup(state->classname); } } + multiname_destroy(extends2); } static void endclass() { - printf("leaving class %s\n", state->classname); + /*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, multiname_t*type) + param_list_t*params, classinfo_t*type) { token_list_t*t; new_state(); state->function = name->text; - printf("entering function %s\n", name->text); + + /*printf("entering function %s\n", name->text); if(ns) printf(" namespace: %s\n", ns->text); printf(" getset: %s\n", getset->text); printf(" params: ");for(t=params->tokens;t;t=t->next) printf("%s ", t->token->text);printf("\n"); printf(" mod: ");for(t=mod->tokens;t;t=t->next) printf("%s ", t->token->text);printf("\n"); - printf(" type: %s\n", multiname_tostring(type)); - print_imports(); + if(type) + printf(" type: %s.%s\n", type->package, type->name); + print_imports();*/ if(state->m) { syntaxerror("not able to start another method scope"); } + multiname_t*type2 = sig2mname(type); if(!strcmp(state->classname,name->text)) { - state->m = abc_class_constructor(state->cls, type, 0); + state->m = abc_class_constructor(state->cls, type2, 0); } else { - state->m = abc_class_method(state->cls, type, name->text, 0); + state->m = abc_class_method(state->cls, type2, name->text, 0); + } + param_list_t*p; + for(p=params;p;p=p->next) { + multiname_t*m = sig2mname(p->param->type); + list_append(state->m->method->parameters, m); } + + /* state->vars is initialized by state_new */ array_append(state->vars, "this", 0); + for(p=params;p;p=p->next) { + array_append(state->vars, p->param->name, 0); + } __ getlocal_0(state->m); __ pushscope(state->m); } 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); @@ -548,7 +616,7 @@ void extend_s(token_t*list, char*seperator, token_t*add) { list->text[l1+l2+l3]=0; } -int find_variable(char*name, multiname_t**m) +static int find_variable(char*name, classinfo_t**m) { state_list_t* s = state_stack; while(s) { @@ -561,32 +629,89 @@ int find_variable(char*name, multiname_t**m) } s = s->next; } - syntaxerror("undefined variable: %s", name); + return -1; +} +static int find_variable_safe(char*name, classinfo_t**m) +{ + int i = find_variable(name, m); + if(i<0) + syntaxerror("undefined variable: %s", name); + return i; +} +static char variable_exists(char*name) +{ + return array_contains(state->vars, name); +} +static int new_variable(char*name, classinfo_t*type) +{ + return array_append(state->vars, name, type) + state->local_var_base; +} +code_t* killvars(code_t*c) +{ + int t; + for(t=0;tvars->num;t++) { + classinfo_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; +} + +char is_subtype_of(classinfo_t*type, classinfo_t*supertype) +{ + return 1; // FIXME +} + +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; + } } -multiname_t*join_types(multiname_t*type1, multiname_t*type2, char op) +classinfo_t*join_types(classinfo_t*type1, classinfo_t*type2, char op) { return registry_getanytype(); // FIXME } -char is_subtype_of(multiname_t*type, multiname_t*supertype) +code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to) { - return 1; // FIXME + if(from==to) + return c; + 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; } -#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()) +code_t*defaultvalue(code_t*c, classinfo_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; +} %} @@ -613,6 +738,7 @@ CODEPIECE: VOIDEXPRESSION {$$=$1} CODEPIECE: FOR {$$=$1} CODEPIECE: WHILE {$$=$1} CODEPIECE: BREAK {$$=$1} +CODEPIECE: RETURN {$$=$1} CODEPIECE: IF {$$=$1} CODEPIECE: ASSIGNMENT {$$=$1} CODEPIECE: NAMESPACE_DECLARATION {/*TODO*/$$=code_new();} @@ -625,9 +751,12 @@ CODEBLOCK : CODEPIECE %prec below_semicolon {$$=$1;} /* ------------ functions --------------------------- */ -FUNCTION_DECLARATION: MODIFIERS "function" GETSET T_IDENTIFIER '(' PARAMS ')' +FUNCTION_DECLARATION: MODIFIERS "function" GETSET T_IDENTIFIER '(' MAYBE_PARAM_LIST ')' 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() } @@ -641,36 +770,54 @@ 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", multiname_tostring($4.t), multiname_tostring($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 { - multiname_t*type=0; - int i = find_variable($1->text, &type); + classinfo_t*type=0; + int i = find_variable_safe($1->text, &type); $$ = $3.c; if(!type && $3.t) { // convert to "any" type, the register is untyped @@ -688,7 +835,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); @@ -700,33 +849,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" { @@ -735,12 +894,174 @@ BREAK : "break" { /* ------------ packages and imports ---------------- */ -PACKAGE_DECLARATION : "package" MULTILEVELIDENTIFIER '{' {startpackage($2)} MAYBECODE '}' {endpackage()} +X_IDENTIFIER: T_IDENTIFIER + | "package" + +PACKAGE: PACKAGE '.' X_IDENTIFIER {$$ = concat3($1,$2,$3);} +PACKAGE: X_IDENTIFIER {$$=$1;} + +PACKAGE_DECLARATION : "package" PACKAGE '{' {startpackage($2)} MAYBECODE '}' {endpackage()} PACKAGE_DECLARATION : "package" '{' {startpackage(0)} MAYBECODE '}' {endpackage()} -IMPORT : "import" PACKAGESPEC {addimport($2);} +IMPORT : "import" QNAME { + classinfo_t*c = $2; + if(!c) + syntaxerror("Couldn't import class\n"); + state_has_imports(); + dict_put(state->imports, c->name, 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 QNAME {$$=$2;} + +EXTENDS_LIST : {$$=list_new();} +EXTENDS_LIST : KW_EXTENDS QNAME_LIST {$$=$2;} + +IMPLEMENTS_LIST : {$$=list_new();} +IMPLEMENTS_LIST : KW_IMPLEMENTS QNAME_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();} + +/* ------------- package + class ids --------------- */ + +CLASS: T_IDENTIFIER { + + /* try current package */ + $$ = registry_findclass(state->package, $1->text); + + /* try explicit imports */ + dictentry_t* e = dict_get_slot(state->imports, $1->text); + while(e) { + if($$) + break; + if(!strcmp(e->key, $1->text)) { + $$ = (classinfo_t*)e->data; + } + e = e->next; + } + + /* try package.* imports */ + 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; + } + + /* try global package */ + if(!$$) { + $$ = registry_findclass("", $1->text); + } + + 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); +} + +QNAME: PACKAGEANDCLASS + | CLASS + + +/* ----------function calls, constructor calls ------ */ + +MAYBE_PARAM_VALUES : %prec prec_none {$$=0;} +MAYBE_PARAM_VALUES : '(' MAYBE_EXPRESSION_LIST ')' {$$=$2} + +MAYBE_EXPRESSION_LIST : {$$=0;} +MAYBE_EXPRESSION_LIST : EXPRESSION_LIST +EXPRESSION_LIST : EXPRESSION {$$=list_new(); + typedcode_t*t = malloc(sizeof(typedcode_t)); + *t = $1; + list_append($$, t);} +EXPRESSION_LIST : EXPRESSION_LIST ',' EXPRESSION {$$=$1; + typedcode_t*t = malloc(sizeof(typedcode_t)); + *t = $3; + list_append($$, t);} + +NEW : "new" CLASS MAYBE_PARAM_VALUES { + MULTINAME(m, $2); + $$.c = code_new(); + $$.c = abc_findpropstrict2($$.c, &m); + typedcode_list_t*l = $3; + int len = 0; + while(l) { + $$.c = code_append($$.c, l->typedcode->c); // push parameters on stack + l = l->next; + len ++; + } + $$.c = abc_constructprop2($$.c, &m, len); + $$.t = $2; +} + +/* TODO: use abc_call (for calling local variables), + abc_callstatic (for calling own methods) + call (for closures) +*/ +FUNCTIONCALL : E '(' MAYBE_EXPRESSION_LIST ')' { + typedcode_list_t*l = $3; + int len = 0; + code_t*paramcode = 0; + while(l) { + paramcode = code_append(paramcode, l->typedcode->c); // push parameters on stack + l = l->next; + len ++; + } + + $$.c = $1.c; + if($$.c->opcode == OPCODE_GETPROPERTY) { + multiname_t*name = multiname_clone($$.c->data[0]); + $$.c = code_cutlast($$.c); + $$.c = code_append($$.c, paramcode); + $$.c = abc_callproperty2($$.c, name, len); + } else { + int i = find_variable_safe("this", 0); + $$.c = abc_getlocal($$.c, i); + $$.c = code_append($$.c, paramcode); + $$.c = abc_call($$.c, len); + } + /* TODO: look up the functions's return value */ + $$.t = TYPE_ANY; +} -TYPE : PACKAGEANDCLASS {$$=$1;} +RETURN: "return" %prec prec_none { + $$ = abc_returnvoid(0); +} +RETURN: "return" EXPRESSION { + $$ = $2.c; + $$ = abc_returnvalue($$); +} + +TYPE : QNAME {$$=$1;} | '*' {$$=registry_getanytype();} | "String" {$$=registry_getstringclass();} | "int" {$$=registry_getintclass();} @@ -752,7 +1073,7 @@ MAYBETYPE: ':' TYPE {$$=$2;} MAYBETYPE: {$$=0;} //FUNCTION_HEADER: NAMESPACE MODIFIERS T_FUNCTION GETSET T_IDENTIFIER '(' PARAMS ')' -FUNCTION_HEADER: MODIFIERS "function" GETSET T_IDENTIFIER '(' PARAMS ')' +FUNCTION_HEADER: MODIFIERS "function" GETSET T_IDENTIFIER '(' MAYBE_PARAM_LIST ')' MAYBETYPE NAMESPACE_DECLARATION : MODIFIERS KW_NAMESPACE T_IDENTIFIER @@ -763,7 +1084,8 @@ NAMESPACE_DECLARATION : MODIFIERS KW_NAMESPACE T_IDENTIFIER '=' T_STRING //NAMESPACE : T_IDENTIFIER {$$=$1}; CONSTANT : T_BYTE {$$.c = abc_pushbyte(0, $1); - $$.c = abc_coerce2($$.c, registry_getintclass()); // FIXME + //MULTINAME(m, registry_getintclass()); + //$$.c = abc_coerce2($$.c, &m); // FIXME $$.t = TYPE_INT; } CONSTANT : T_SHORT {$$.c = abc_pushshort(0, $1); @@ -794,14 +1116,12 @@ CONSTANT : KW_NULL {$$.c = abc_pushnull(0); USE_NAMESPACE : "use" "namespace" T_IDENTIFIER -EXPRESSION : E %prec prec_none /*precendence below '-x'*/ {$$ = $1;} +EXPRESSION : E %prec prec_none /*precedence below '-x'*/ {$$ = $1;} VOIDEXPRESSION : E %prec prec_none {$$=$1.c;/*calculate and discard*/$$=abc_pop($$);} E : CONSTANT E : VAR_READ %prec T_IDENTIFIER {$$ = $1;} -E : NEW {$$.c = abc_pushundefined(0); /* FIXME */ - $$.t = TYPE_ANY; - } +E : NEW {$$ = $1;} E : T_REGEXP {$$.c = abc_pushundefined(0); /* FIXME */ $$.t = TYPE_ANY; } @@ -828,6 +1148,55 @@ E : E "!=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_equals($$.c);$$.c = abc_n $$.t = TYPE_BOOLEAN; } +E : E "||" E {$$.t = join_types($1.t, $3.t, 'O'); + $$.c = $1.c; + $$.c = converttype($$.c, $1.t, $$.t); + $$.c = abc_dup($$.c); + code_t*jmp = $$.c = abc_iftrue($$.c, 0); + $$.c = abc_pop($$.c); + $$.c = code_append($$.c,$3.c); + $$.c = converttype($$.c, $1.t, $$.t); + code_t*label = $$.c = abc_label($$.c); + jmp->branch = label; + } +E : E "&&" E {$$.t = join_types($1.t, $3.t, 'A'); + $$.c = $1.c; + $$.c = converttype($$.c, $1.t, $$.t); + $$.c = abc_dup($$.c); + code_t*jmp = $$.c = abc_iffalse($$.c, 0); + $$.c = abc_pop($$.c); + $$.c = code_append($$.c,$3.c); + $$.c = converttype($$.c, $1.t, $$.t); + code_t*label = $$.c = abc_label($$.c); + jmp->branch = label; + } + +//E : E '.' T_IDENTIFIER '(' ')' +// {$$.c = 0; // FIXME +// $$.t = 0; +// } + +E : E '.' T_IDENTIFIER + {$$.c = $1.c; + if($$.t) { + namespace_t ns = {$$.t->access, (char*)$$.t->package}; + multiname_t m = {QNAME, &ns, 0, $3->text}; + $$.c = abc_getproperty2($$.c, &m); + /* FIXME: get type of ($1.t).$3 */ + $$.t = registry_getanytype(); + } else { + namespace_t ns = {ACCESS_PACKAGE, ""}; + multiname_t m = {QNAME, &ns, 0, $3->text}; + $$.c = abc_getproperty2($$.c, &m); + $$.t = registry_getanytype(); + } + } + +E : '!' E {$$.c=$2.c; + $$.c = abc_not($$.c); + $$.t = TYPE_BOOLEAN; + } + E : E '-' E E : E '/' E E : E '+' E {$$.c = code_append($1.c,$3.c);$$.c = abc_add($$.c);$$.c=abc_coerce_a($$.c); @@ -840,73 +1209,68 @@ E : E '*' E {$$.c = code_append($1.c,$3.c);$$.c = abc_multiply($$.c);$$.c=abc_co $$.t = join_types($1.t, $3.t, '*'); } -E : E "as" TYPE -E : E "is" TYPE +E : E "as" E +E : E "is" E E : '(' E ')' {$$=$2;} E : '-' E {$$=$2;} E : LH "+=" E {$$.c = $1.read;$$.c=code_append($$.c,$3.c);$$.c=abc_add($$.c); - $$.c=abc_coerce2($$.c, registry_getintclass()); // FIXME + classinfo_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); - $$.c=abc_coerce2($$.c, registry_getintclass()); // FIXME + classinfo_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); - $$.c=abc_coerce2($$.c, registry_getintclass()); //FIXME +E : LH "++" {$$.c = $1.read; + classinfo_t*type = $1.type; + if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) { + $$.c=abc_increment_i($$.c); + } else { + $$.c=abc_increment($$.c); + 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); - $$.c=abc_coerce2($$.c, registry_getintclass()); //FIXME +E : LH "--" {$$.c = $1.read; + classinfo_t*type = $1.type; + if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) { + $$.c=abc_decrement_i($$.c); + } else { + $$.c=abc_decrement($$.c); + type = TYPE_NUMBER; + } + $$.c=converttype($$.c, type, $1.type); $$.c=abc_dup($$.c);$$.c=code_append($$.c,$1.write); $$.t = $1.type; } LH: T_IDENTIFIER { - int i = find_variable($1->text, &$$.type); + int i = find_variable_safe($1->text, &$$.type); $$.read = abc_getlocal(0, i); $$.write = abc_setlocal(0, i); } -NEW : "new" T_IDENTIFIER {$$.c=0;$$.t=0;/*FIXME*/} - | "new" T_IDENTIFIER '(' ')' {$$.c=0;$$.t=0;/*FIXME*/} - | "new" T_IDENTIFIER '(' EXPRESSION_LIST ')' {$$.c=0;$$.t=0;/*FIXME*/} - -FUNCTIONCALL : T_IDENTIFIER '(' MAYBE_EXPRESSION_LIST ')' { - /* TODO: use abc_call (for calling local variables), - abc_callstatic (for calling own methods) */ - $$.c = code_new(); - $$.c = abc_findpropstrict($$.c, $1->text); - typedcode_list_t*l = $3; - // push parameters on stack - int len = 0; - while(l) { - $$.c = code_append($$.c, l->typedcode.c); - l = l->nxt; - len ++; - } - $$.c = abc_callproperty($$.c, $1->text, len); -} - -MAYBE_EXPRESSION_LIST : {$$=0;} -MAYBE_EXPRESSION_LIST : EXPRESSION_LIST -EXPRESSION_LIST : EXPRESSION {$$=malloc(sizeof(typedcode_list_t)); - $$->nxt = 0; - $$->typedcode = $1;} -EXPRESSION_LIST : EXPRESSION_LIST ',' EXPRESSION {$$=malloc(sizeof(typedcode_list_t)); - $$->nxt = $1; - $$->typedcode = $3; - } VAR_READ : T_IDENTIFIER { - int i = find_variable($1->text, &$$.t); - $$.c = abc_getlocal(0, i); + $$.t = 0; + $$.c = 0; + int i = find_variable($1->text, &$$.t); + if(i>=0) { + $$.c = abc_getlocal($$.c, i); + } else { + $$.t = 0; + $$.c = abc_findpropstrict($$.c, $1->text); + $$.c = abc_getproperty($$.c, $1->text); + } } //VARIABLE : T_IDENTIFIER @@ -916,32 +1280,18 @@ VAR_READ : T_IDENTIFIER { //VARIABLE : VARIABLE "::" '[' EXPRESSION ']' // qualified expression //VARIABLE : VARIABLE '[' EXPRESSION ']' // unqualified expression -// 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 +MAYBE_PARAM_LIST: {$$=list_new();} +MAYBE_PARAM_LIST: PARAM_LIST {$$=$1;} +PARAM_LIST: PARAM_LIST ',' PARAM {$$ =$1; list_append($$, $3);} +PARAM_LIST: PARAM {$$ = list_new();list_append($$, $1);} +PARAM: T_IDENTIFIER ':' TYPE {$$ = malloc(sizeof(param_t)); + $$->name=$1->text;$$->type = $3;} +PARAM: T_IDENTIFIER {$$ = malloc(sizeof(param_t)); + $$->name=$1->text;$$->type = TYPE_ANY;} DECLARATION : VARIABLE_DECLARATION DECLARATION : FUNCTION_DECLARATION @@ -949,28 +1299,11 @@ 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);} - -MULTILEVELIDENTIFIER : MULTILEVELIDENTIFIER '.' X_IDENTIFIER {$$=$1;extend_s($$, ".", $3)} -MULTILEVELIDENTIFIER : T_IDENTIFIER {$$=$1;extend($$,$1)}; - -PACKAGEANDCLASS_LIST : PACKAGEANDCLASS {$$=list_new();list_append($$, $1);} -PACKAGEANDCLASS_LIST : PACKAGEANDCLASS_LIST ',' PACKAGEANDCLASS {$$=$1;list_append($$,$3);} +QNAME_LIST : QNAME {$$=list_new();list_append($$, $1);} +QNAME_LIST : QNAME_LIST ',' QNAME {$$=$1;list_append($$,$3);} MAYBE_DECLARATION_LIST : MAYBE_DECLARATION_LIST : DECLARATION_LIST