X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fas3%2Fparser.y;h=c64fb41d6757a50367855a9ac4bf38b4d28a8949;hb=d625d3512dabbc51ed13bc411369bb87344b0475;hp=19ef427acab58e6824411da56cf6dd5761297c86;hpb=fc0fd602a9d1a1efc009d95ca5e676e13aca5d30;p=swftools.git diff --git a/lib/as3/parser.y b/lib/as3/parser.y index 19ef427..c64fb41 100644 --- a/lib/as3/parser.y +++ b/lib/as3/parser.y @@ -1,3 +1,25 @@ +/* parser.lex + + Routines for compiling Flash2 AVM2 ABC Actionscript + + Extension module for the rfxswf library. + Part of the swftools package. + + Copyright (c) 2008 Matthias Kramm + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ %{ #include #include @@ -7,6 +29,9 @@ #include "files.h" #include "tokenizer.h" #include "registry.h" +#include "code.h" +#include "opcodes.h" + %} //%glr-parser @@ -15,47 +40,73 @@ %union tokenunion { tokenptr_t token; - multiname_t*multiname; - multiname_list_t*multiname_list; + + class_signature_t*class_signature; + class_signature_list_t*class_signature_list; + + int number_int; + unsigned int number_uint; + double number_float; + code_t*code; + typedcode_t value; + typedcode_list_t*value_list; + writeable_t writeable; + char*string; } %token T_IDENTIFIER -%token T_STRING +%token T_STRING %token T_REGEXP -%token T_IMPLEMENTS -%token T_NAMESPACE -%token T_PACKAGE -%token T_PROTECTED -%token T_PUBLIC -%token T_PRIVATE -%token T_UINT -%token T_USE -%token T_INTERNAL -%token T_INT -%token T_NEW -%token T_NATIVE -%token T_FUNCTION -%token T_FOR -%token T_CLASS -%token T_CONST -%token T_SET -%token T_STATIC -%token T_IMPORT -%token T_INTERFACE -%token T_NUMBER -%token T_NULL -%token T_FALSE -%token T_TRUE -%token T_BOOLEAN -%token T_VAR -%token T_DYNAMIC -%token T_OVERRIDE -%token T_FINAL -%token T_GET -%token T_EXTENDS %token T_EMPTY +%token T_INT +%token T_UINT +%token T_BYTE +%token T_SHORT +%token T_FLOAT + +%token KW_IMPLEMENTS +%token KW_NAMESPACE "namespace" +%token KW_PACKAGE "package" +%token KW_PROTECTED +%token KW_PUBLIC +%token KW_PRIVATE +%token KW_USE "use" +%token KW_INTERNAL +%token KW_NEW "new" +%token KW_NATIVE +%token KW_FUNCTION "function" +%token KW_FOR "for" +%token KW_CLASS "class" +%token KW_CONST "const" +%token KW_SET "set" +%token KW_STATIC +%token KW_IMPORT "import" +%token KW_INTERFACE "interface" +%token KW_NULL +%token KW_VAR "var" +%token KW_DYNAMIC +%token KW_OVERRIDE +%token KW_FINAL +%token KW_GET "get" +%token KW_EXTENDS +%token KW_FALSE "false" +%token KW_TRUE "true" +%token KW_BOOLEAN "Boolean" +%token KW_UINT "uint" +%token KW_INT "int" +%token KW_WHILE "while" +%token KW_NUMBER "Number" +%token KW_STRING "String" +%token KW_IF "if" +%token KW_ELSE "else" +%token KW_BREAK "break" +%token KW_IS "is" +%token KW_AS "as" + %token T_EQEQ "==" +%token T_EQEQEQ "===" +%token T_NE "!=" %token T_LE "<=" %token T_GE ">=" %token T_DIVBY "/=" @@ -74,15 +125,58 @@ %token T_SHL "<<" %token T_USHR ">>>" %token T_SHR ">>" -%token T_IS "is" -%token T_AS "as" %token T_SEMICOLON ';' %token T_STAR '*' %token T_DOT '.' +%type CODE +%type CODEPIECE +%type CODEBLOCK MAYBECODE +%type PACKAGE_DECLARATION +%type FUNCTION_DECLARATION +%type VARIABLE_DECLARATION +%type CLASS_DECLARATION +%type NAMESPACE_DECLARATION +%type INTERFACE_DECLARATION +%type VOIDEXPRESSION +%type EXPRESSION +%type MAYBEEXPRESSION +%type E +%type LH +%type CONSTANT +%type FOR IF WHILE MAYBEELSE BREAK +%type USE_NAMESPACE +%type ASSIGNMENT FOR_INIT +%type IMPORT +%type MAYBETYPE +%type PACKAGESPEC +%type GETSET +%type PARAM +%type PARAMS +%type 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 VAR +//%type VARIABLE +%type VAR_READ +%type NEW +%type X_IDENTIFIER +%type MODIFIER +%type PACKAGE +%type FUNCTIONCALL +%type MAYBE_EXPRESSION_LIST EXPRESSION_LIST + // precendence: 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 %right '?' ':' %nonassoc '=' %nonassoc "/=" "%=" @@ -95,7 +189,7 @@ %nonassoc '|' %nonassoc '^' %nonassoc '&' -%nonassoc "!=" "==" "<=" '<' ">=" '>' // TODO: support "a < b < c" syntax? +%nonassoc "!=" "==" "===" "<=" '<' ">=" '>' // TODO: support "a < b < c" syntax? %nonassoc "is" %left '-' %left '+' @@ -111,45 +205,12 @@ %left '[' %nonassoc "as" %left '.' ".." "::" +%nonassoc T_IDENTIFIER +%left below_semicolon +%left ';' +%nonassoc "else" %left '(' - -%type CODE -%type CODEPIECE -%type PACKAGE_DECLARATION -%type FUNCTION_DECLARATION -%type VARIABLE_DECLARATION -%type CLASS_DECLARATION -%type NAMESPACE_DECLARATION -%type INTERFACE_DECLARATION -%type EXPRESSION -%type E -%type CONSTANT -%type FOR -%type USE -%type ASSIGNMENT -%type IMPORT -%type MAYBETYPE -%type PACKAGESPEC -%type GETSET -%type PARAM -%type PARAMS -%type 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 VAR -%type VARIABLE -%type NEW -%type FUNCTIONCALL -%type X_IDENTIFIER -%type MODIFIER -%type PACKAGE +%left prec_highest %{ @@ -182,6 +243,18 @@ static token_t* concat3(token_t* t1, token_t* t2, token_t* t3) t->text[l1+l2+l3] = 0; return t; } +static char* concat3str(const char* t1, const char* t2, const char* t3) +{ + int l1 = strlen(t1); + int l2 = strlen(t2); + int l3 = strlen(t3); + char*text = malloc(l1+l2+l3+1); + memcpy(text , t1, l1); + memcpy(text+l1, t2, l2); + memcpy(text+l1+l2, t3, l3); + text[l1+l2+l3] = 0; + return text; +} typedef struct _import { char*path; @@ -197,67 +270,92 @@ typedef struct _state { char*package; char*function; + /* code that needs to be executed at the start of + a method (like initializing local registers) */ + code_t*initcode; + + abc_method_body_t*m; import_list_t*imports; /* class data */ char*classname; abc_class_t*cls; + array_t*vars; + int local_var_base; } state_t; 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; -void initialize_state() +static void new_state() { NEW(state_t, s); NEW(state_list_t, sl); + + state_t*oldstate = state; + if(state) + memcpy(s, state, sizeof(state_t)); //shallow copy + sl->next = state_stack; + sl->state = s; + if(oldstate) + s->local_var_base = array_length(oldstate->vars) + oldstate->local_var_base; state_stack = sl; - state = sl->state = s; + state = s; + state->level++; + state->vars = array_new(); + state->initcode = 0; +} +static void old_state() +{ + if(!state_stack || !state_stack->next) + syntaxerror("invalid nesting"); + state_t*oldstate = state; + state_list_t*old = state_stack; + 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); + }*/ + state->initcode = code_append(state->initcode, oldstate->initcode); +} +void initialize_state() +{ + new_state(); state->file = abc_file_new(); - state->level = 0; + state->file->flags &= ~ABCFILE_LAZY; state->init = abc_initscript(state->file, 0, 0); abc_method_body_t*m = state->init->method->body; __ getlocal_0(m); __ pushscope(m); + __ findpropstrict(m, "[package]::trace"); + __ pushstring(m, "[entering global init function]"); + __ callpropvoid(m, "[package]::trace", 1); } void* finalize_state() { - if(state->level) { + if(state->level!=1) { syntaxerror("unexpected end of file"); } abc_method_body_t*m = state->init->method->body; //__ popscope(m); + + __ findpropstrict(m, "[package]::trace"); + __ pushstring(m, "[leaving global init function]"); + __ callpropvoid(m, "[package]::trace", 1); __ returnvoid(m); return state->file; } -static void new_state() -{ - NEW(state_t, s); - NEW(state_list_t, sl); - memcpy(s, state, sizeof(state_t)); //shallow copy - sl->next = state_stack; - sl->state = s; - state_stack = sl; - state = s; - state->level++; -} -static void old_state() -{ - if(!state_stack || !state_stack->next) - syntaxerror("invalid nesting"); - state_t*oldstate = state; - state_list_t*old = state_stack; - state_stack = state_stack->next; - free(old); - state = state_stack->state; -} static void startpackage(token_t*t) { @@ -266,43 +364,46 @@ 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(); } -static void startclass(token_t*modifiers, token_t*name, multiname_t*extends, multiname_list_t*implements) +char*globalclass=0; +static void startclass(token_t*modifiers, token_t*name, class_signature_t*extends, class_signature_list_t*implements) { 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; + class_signature_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)); + if(extends) + printf(" extends: %s.%s\n", extends->package, extends->name); - multiname_list_t*mlist=0; printf(" implements (%d): ", list_length(implements)); for(mlist=implements;mlist;mlist=mlist->next) { - printf("%s ", multiname_tostring(mlist->multiname)); + printf("%s ", mlist->class_signature->name); } - printf("\n"); + printf("\n");*/ char public=0,internal=0,final=0,sealed=1; for(t=modifiers->tokens;t;t=t->next) { - if(t->token->type == T_INTERNAL) { + if(t->token->type == KW_INTERNAL) { /* the programmer is being explicit- being internal is the default anyway */ internal = 1; - } else if(t->token->type == T_PUBLIC) { + } else if(t->token->type == KW_PUBLIC) { public = 1; - } else if(t->token->type == T_FINAL) { + } else if(t->token->type == KW_FINAL) { final = 1; } else { syntaxerror("modifier \"%s\" not supported in class declaration", t->token->text); @@ -312,55 +413,89 @@ 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"); + } - state->cls = abc_class_new(state->file, classname, extends); + if(registry_findclass(package, state->classname)) { + syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, state->classname); + } + + class_signature_t* classname = class_signature_register(access, package, state->classname); + + multiname_t*extends2 = sig2mname(extends); + multiname_t*classname2 = sig2mname(classname); + + state->cls = abc_class_new(state->file, classname2, extends2); if(final) abc_class_final(state->cls); if(sealed) abc_class_sealed(state->cls); for(mlist=implements;mlist;mlist=mlist->next) { - abc_class_add_interface(state->cls, mlist->multiname); + MULTINAME(m, mlist->class_signature); + 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; + class_signature_t*s = extends; + int count=0; + while(s) { - //TODO: invert //TODO: take a look at the current scope stack, maybe // we can re-use something - __ getlex2(m, s); + s = s->superclass; + if(!s) + break; + + multiname_t*s2 = sig2mname(s); + __ getlex2(m, s2); + multiname_destroy(s2); + __ pushscope(m); - s = registry_getsuperclass(s); + 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; + /* 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); + __ getlex2(m, extends2); + __ dup(m); + __ pushscope(m); // we get a Verify Error #1107 if this is not the top scope __ newclass(m,state->cls); - while(count--) { __ popscope(m); } __ setslot(m, slotindex); + + /* flash.display.MovieClip handling */ + if(!globalclass && public && class_signature_equals(registry_getMovieClip(),extends)) { + if(state->package && state->package[0]) { + globalclass = concat3str(state->package, ".", state->classname); + } else { + globalclass = strdup(state->classname); + } + } } 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) @@ -378,41 +513,50 @@ static void print_imports() } } static void startfunction(token_t*ns, token_t*mod, token_t*getset, token_t*name, - token_t*params, multiname_t*type) + token_t*params, class_signature_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); - abc_method_body_t* m=0; if(!strcmp(state->classname,name->text)) { - m = abc_class_constructor(state->cls, type, 0); + state->m = abc_class_constructor(state->cls, type2, 0); } else { - m = abc_class_method(state->cls, type, name->text, 0); + 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); + __ pushscope(state->m); + + multiname_destroy(type2); } static void endfunction() { - printf("leaving function %s\n", state->function); + /*printf("leaving function %s\n", state->function);*/ + __ returnvoid(state->m); + old_state(); } -static int newvariable(token_t*mod, token_t*varconst, token_t*name, multiname_t*type) -{ - token_list_t*t; - printf("defining new variable %s\n", name->text); - printf(" mod: ");for(t=mod->tokens;t;t=t->next) printf("%s ", t->token->text);printf("\n"); - printf(" access: ");printf("%s\n", varconst->text); - printf(" type: ");printf("%s\n", multiname_tostring(type)); -} + + static token_t* empty_token() { NEW(token_t,t); @@ -441,143 +585,475 @@ void extend_s(token_t*list, char*seperator, token_t*add) { list->text[l1+l2+l3]=0; } +static int find_variable(char*name, class_signature_t**m) +{ + state_list_t* s = state_stack; + while(s) { + int i = array_find(s->state->vars, name); + if(i>=0) { + if(m) { + *m = array_getvalue(s->state->vars, i); + } + return i + s->state->local_var_base; + } + 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;tvars->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) +{ + return registry_getanytype(); // FIXME +} +char is_subtype_of(class_signature_t*type, class_signature_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; + } +} +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; +} + %} + %% +/* ------------ code blocks / statements ---------------- */ + PROGRAM: MAYBECODE -MAYBECODE: CODE -MAYBECODE: +MAYBECODE: CODE {$$=$1;} +MAYBECODE: {$$=code_new();} + +CODE: CODE CODEPIECE {$$=code_append($1,$2);} +CODE: CODEPIECE {$$=$1;} + +CODEPIECE: PACKAGE_DECLARATION {$$=code_new();/*enters a scope*/} +CODEPIECE: CLASS_DECLARATION {$$=code_new();/*enters a scope*/} +CODEPIECE: INTERFACE_DECLARATION {/*TODO*/$$=code_new();} +CODEPIECE: IMPORT {$$=code_new();/*adds imports to current scope*/} +CODEPIECE: ';' {$$=code_new();} +CODEPIECE: VARIABLE_DECLARATION {$$=$1} +CODEPIECE: VOIDEXPRESSION {$$=$1} +CODEPIECE: FOR {$$=$1} +CODEPIECE: WHILE {$$=$1} +CODEPIECE: BREAK {$$=$1} +CODEPIECE: IF {$$=$1} +CODEPIECE: ASSIGNMENT {$$=$1} +CODEPIECE: NAMESPACE_DECLARATION {/*TODO*/$$=code_new();} +CODEPIECE: FUNCTION_DECLARATION {/*TODO*/$$=code_new();} +CODEPIECE: USE_NAMESPACE {/*TODO*/$$=code_new();} + +CODEBLOCK : '{' MAYBECODE '}' {$$=$2;} +CODEBLOCK : CODEPIECE ';' {$$=$1;} +CODEBLOCK : CODEPIECE %prec below_semicolon {$$=$1;} + +/* ------------ functions --------------------------- */ + +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() +} -CODE: CODE CODEPIECE {$$=$1;} -CODE: CODEPIECE {$$=empty_token();} +/* ------------ variables --------------------------- */ -CODEPIECE: ';' -CODEPIECE: VARIABLE_DECLARATION {$$=$1;} -CODEPIECE: PACKAGE_DECLARATION -CODEPIECE: IMPORT -CODEPIECE: NAMESPACE_DECLARATION -CODEPIECE: CLASS_DECLARATION -CODEPIECE: INTERFACE_DECLARATION -CODEPIECE: FUNCTION_DECLARATION -CODEPIECE: EXPRESSION -CODEPIECE: FOR -CODEPIECE: USE -CODEPIECE: ASSIGNMENT +MAYBEEXPRESSION : '=' EXPRESSION {$$=$2;} + | {$$.c=abc_pushundefined(0); + $$.t=TYPE_ANY; + } -PACKAGE_DECLARATION : T_PACKAGE MULTILEVELIDENTIFIER '{' {startpackage($2)} MAYBECODE '}' {endpackage()} -PACKAGE_DECLARATION : T_PACKAGE '{' {startpackage(0)} MAYBECODE '}' {endpackage()} +VAR : "const" | "var" +VARIABLE_DECLARATION : VAR T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION { + if(variable_exists($2->text)) + syntaxerror("Variable %s already defined", $2->text); + + if(!is_subtype_of($4.t, $3)) { + syntaxerror("Can't convert %s to %s", $4.t->name, + $3->name); + } -IMPORT : T_IMPORT PACKAGESPEC {addimport($2);} + int index = new_variable($2->text, $3); + + if($3) { + if($4.c->prev || $4.c->opcode != OPCODE_PUSHUNDEFINED) { + $$ = $4.c; + $$ = converttype($$, $4.t, $3); + $$ = abc_setlocal($$, index); + } else { + $$ = 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 { + /* 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?$4.t->name:""); +} +ASSIGNMENT : T_IDENTIFIER '=' EXPRESSION { + class_signature_t*type=0; + int i = find_variable($1->text, &type); + $$ = $3.c; + if(!type && $3.t) { + // convert to "any" type, the register is untyped + $$ = abc_coerce_a($$); + } else { + // TODO: convert ints to strings etc. + } + $$ = abc_setlocal($$, i); +} + +/* ------------ control flow ------------------------- */ + +MAYBEELSE: %prec prec_none {$$ = code_new();} +MAYBEELSE: "else" CODEBLOCK {$$=$2;} +//MAYBEELSE: ';' "else" CODEBLOCK {$$=$3;} + +IF : "if" '(' {new_state();} EXPRESSION ')' CODEBLOCK MAYBEELSE { + $$ = state->initcode;state->initcode=0; + + $$ = code_append($$, $4.c); + code_t*myjmp,*myif = $$ = abc_iffalse($$, 0); + + $$ = code_append($$, $6); + if($7) { + myjmp = $$ = abc_jump($$, 0); + } + myif->branch = $$ = abc_label($$); + if($7) { + $$ = code_append($$, $7); + myjmp->branch = $$ = abc_label($$); + } + + $$ = killvars($$);old_state(); +} + +FOR_INIT : {$$=code_new();} +FOR_INIT : ASSIGNMENT | VARIABLE_DECLARATION | VOIDEXPRESSION + +FOR : "for" '(' {new_state();} FOR_INIT ';' EXPRESSION ';' VOIDEXPRESSION ')' CODEBLOCK { + $$ = 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); + code_t*out = $$ = abc_label($$); + breakjumpsto($$, out); + myif->branch = out; + + $$ = killvars($$);old_state(); +} + +WHILE : "while" '(' {new_state();} EXPRESSION ')' CODEBLOCK { + $$ = 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); + code_t*out = $$ = abc_label($$); + breakjumpsto($$, out); + + $$ = killvars($$);old_state(); +} + +BREAK : "break" { + $$ = abc___break__(0); +} + +/* ------------ packages and imports ---------------- */ + +PACKAGE_DECLARATION : "package" MULTILEVELIDENTIFIER '{' {startpackage($2)} MAYBECODE '}' {endpackage()} +PACKAGE_DECLARATION : "package" '{' {startpackage(0)} MAYBECODE '}' {endpackage()} + +IMPORT : "import" PACKAGESPEC {addimport($2);} TYPE : PACKAGEANDCLASS {$$=$1;} | '*' {$$=registry_getanytype();} - | T_STRING {$$=registry_getstringclass();} - | T_INT {$$=registry_getintclass();} - | T_UINT {$$=registry_getuintclass();} - | T_BOOLEAN {$$=registry_getbooleanclass();} - | T_NUMBER {$$=registry_getnumberclass();} + | "String" {$$=registry_getstringclass();} + | "int" {$$=registry_getintclass();} + | "uint" {$$=registry_getuintclass();} + | "Boolean" {$$=registry_getbooleanclass();} + | "Number" {$$=registry_getnumberclass();} MAYBETYPE: ':' TYPE {$$=$2;} MAYBETYPE: {$$=0;} //FUNCTION_HEADER: NAMESPACE MODIFIERS T_FUNCTION GETSET T_IDENTIFIER '(' PARAMS ')' -FUNCTION_HEADER: MODIFIERS T_FUNCTION GETSET T_IDENTIFIER '(' PARAMS ')' +FUNCTION_HEADER: MODIFIERS "function" GETSET T_IDENTIFIER '(' PARAMS ')' MAYBETYPE -FUNCTION_DECLARATION: MODIFIERS T_FUNCTION GETSET T_IDENTIFIER '(' PARAMS ')' - MAYBETYPE '{' {startfunction(0,$1,$3,$4,$6,$8)} MAYBECODE '}' {endfunction()} -NAMESPACE_DECLARATION : MODIFIERS T_NAMESPACE T_IDENTIFIER -NAMESPACE_DECLARATION : MODIFIERS T_NAMESPACE T_IDENTIFIER '=' T_IDENTIFIER -NAMESPACE_DECLARATION : MODIFIERS T_NAMESPACE T_IDENTIFIER '=' T_STRING +NAMESPACE_DECLARATION : MODIFIERS KW_NAMESPACE T_IDENTIFIER +NAMESPACE_DECLARATION : MODIFIERS KW_NAMESPACE T_IDENTIFIER '=' T_IDENTIFIER +NAMESPACE_DECLARATION : MODIFIERS KW_NAMESPACE T_IDENTIFIER '=' T_STRING //NAMESPACE : {$$=empty_token();} //NAMESPACE : T_IDENTIFIER {$$=$1}; -CONSTANT : T_NUMBER -CONSTANT : T_STRING -CONSTANT : T_TRUE -CONSTANT : T_FALSE -CONSTANT : T_NULL - -VAR : T_CONST | T_VAR - -// type annotation -// TODO: NAMESPACE - -VARIABLE_DECLARATION : MODIFIERS VAR T_IDENTIFIER MAYBETYPE { - int i = newvariable($1,$2,$3,$4); -} -VARIABLE_DECLARATION : MODIFIERS VAR T_IDENTIFIER MAYBETYPE '=' EXPRESSION { - int i = newvariable($1,$2,$3,$4); - //setvariable(i,$6); -} - -EXPRESSION : E +CONSTANT : T_BYTE {$$.c = abc_pushbyte(0, $1); + //MULTINAME(m, registry_getintclass()); + //$$.c = abc_coerce2($$.c, &m); // FIXME + $$.t = TYPE_INT; + } +CONSTANT : T_SHORT {$$.c = abc_pushshort(0, $1); + $$.t = TYPE_INT; + } +CONSTANT : T_INT {$$.c = abc_pushint(0, $1); + $$.t = TYPE_INT; + } +CONSTANT : T_UINT {$$.c = abc_pushuint(0, $1); + $$.t = TYPE_UINT; + } +CONSTANT : T_FLOAT {$$.c = abc_pushdouble(0, $1); + $$.t = TYPE_FLOAT; + } +CONSTANT : T_STRING {$$.c = abc_pushstring(0, $1); + $$.t = TYPE_STRING; + } +CONSTANT : KW_TRUE {$$.c = abc_pushtrue(0); + $$.t = TYPE_BOOLEAN; + } +CONSTANT : KW_FALSE {$$.c = abc_pushfalse(0); + $$.t = TYPE_BOOLEAN; + } +CONSTANT : KW_NULL {$$.c = abc_pushnull(0); + $$.t = TYPE_NULL; + } + +USE_NAMESPACE : "use" "namespace" T_IDENTIFIER + + +EXPRESSION : E %prec prec_none /*precendence below '-x'*/ {$$ = $1;} +VOIDEXPRESSION : E %prec prec_none {$$=$1.c;/*calculate and discard*/$$=abc_pop($$);} E : CONSTANT -E : VARIABLE -E : NEW -E : T_REGEXP +E : VAR_READ %prec T_IDENTIFIER {$$ = $1;} +E : NEW {$$.c = abc_pushundefined(0); /* FIXME */ + $$.t = TYPE_ANY; + } +E : T_REGEXP {$$.c = abc_pushundefined(0); /* FIXME */ + $$.t = TYPE_ANY; + } E : FUNCTIONCALL -E : E '<' E -E : E '>' E -E : E "<=" E -E : E ">=" E -E : E "==" E -E : E '+' E +E : E '<' E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterequals($$.c);$$.c=abc_not($$.c); + $$.t = TYPE_BOOLEAN; + } +E : E '>' E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterthan($$.c); + $$.t = TYPE_BOOLEAN; + } +E : E "<=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterthan($$.c);$$.c=abc_not($$.c); + $$.t = TYPE_BOOLEAN; + } +E : E ">=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterequals($$.c); + $$.t = TYPE_BOOLEAN; + } +E : E "==" E {$$.c = code_append($1.c,$3.c);$$.c = abc_equals($$.c); + $$.t = TYPE_BOOLEAN; + } +E : E "===" E {$$.c = code_append($1.c,$3.c);$$.c = abc_strictequals($$.c); + $$.t = TYPE_BOOLEAN; + } +E : E "!=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_equals($$.c);$$.c = abc_not($$.c); + $$.t = TYPE_BOOLEAN; + } + E : E '-' E E : E '/' E -E : E '%' E -E : 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); + $$.t = join_types($1.t, $3.t, '+'); + } +E : E '%' E {$$.c = code_append($1.c,$3.c);$$.c = abc_modulo($$.c);$$.c=abc_coerce_a($$.c); + $$.t = join_types($1.t, $3.t, '%'); + } +E : E '*' E {$$.c = code_append($1.c,$3.c);$$.c = abc_multiply($$.c);$$.c=abc_coerce_a($$.c); + $$.t = join_types($1.t, $3.t, '*'); + } + E : E "as" TYPE E : E "is" TYPE +E : '(' E ')' {$$=$2;} +E : '-' E {$$=$2;} + +E : LH "+=" E {$$.c = $1.read;$$.c=code_append($$.c,$3.c);$$.c=abc_add($$.c); + 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); + 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); + 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); + 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; + } + +LH: T_IDENTIFIER { + int i = find_variable($1->text, &$$.type); + $$.read = abc_getlocal(0, i); + $$.write = abc_setlocal(0, i); +} -//E : '(' E ')' // conflicts with function calls: "a=f(c++);"<->"a=f;(c++)" -//E : '-' E // conflicts with non-assignment statements: "a=3-1;"<->"a=3;-1" - -NEW : T_NEW T_IDENTIFIER - | T_NEW T_IDENTIFIER '(' ')' - | T_NEW T_IDENTIFIER '(' EXPRESSION_LIST ')' - -FUNCTIONCALL : VARIABLE '(' EXPRESSION_LIST ')' -FUNCTIONCALL : VARIABLE '(' ')' - -EXPRESSION_LIST : EXPRESSION -EXPRESSION_LIST : EXPRESSION_LIST ',' EXPRESSION - -VARIABLE : T_IDENTIFIER -VARIABLE : VARIABLE '.' T_IDENTIFIER -VARIABLE : VARIABLE ".." T_IDENTIFIER // descendants -VARIABLE : VARIABLE "::" VARIABLE // namespace declaration -VARIABLE : VARIABLE "::" '[' EXPRESSION ']' // qualified expression -VARIABLE : VARIABLE '[' EXPRESSION ']' // unqualified expression - -ASSIGNMENT : VARIABLE '=' EXPRESSION -NEW_ASSIGNMENT : T_VAR VARIABLE MAYBETYPE '=' EXPRESSION +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); +} -FOR : T_FOR '(' NEW_ASSIGNMENT ';' EXPRESSION ';' EXPRESSION ')' '{' MAYBECODE '}' -FOR : T_FOR '(' ASSIGNMENT ';' EXPRESSION ';' EXPRESSION ')' '{' MAYBECODE '}' +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); +} -USE : T_USE T_NAMESPACE T_IDENTIFIER +//VARIABLE : T_IDENTIFIER +//VARIABLE : VARIABLE '.' T_IDENTIFIER +//VARIABLE : VARIABLE ".." T_IDENTIFIER // descendants +//VARIABLE : VARIABLE "::" VARIABLE // namespace declaration +//VARIABLE : VARIABLE "::" '[' EXPRESSION ']' // qualified expression +//VARIABLE : VARIABLE '[' EXPRESSION ']' // unqualified expression // keywords which also may be identifiers -X_IDENTIFIER : T_IDENTIFIER | T_PACKAGE +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 : T_GET {$$=$1;} - | T_SET {$$=$1;} +GETSET : "get" {$$=$1;} + | "set" {$$=$1;} | {$$=empty_token();} -CLASS_DECLARATION : MODIFIERS T_CLASS T_IDENTIFIER EXTENDS IMPLEMENTS_LIST '{' {startclass($1,$3,$4,$5);} MAYBE_DECLARATION_LIST '}' {endclass();} -INTERFACE_DECLARATION : MODIFIERS T_INTERFACE T_IDENTIFIER EXTENDS_LIST '{' MAYBE_IDECLARATION_LIST '}' +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;} @@ -589,7 +1065,7 @@ MODIFIERS : {$$=empty_token();} MODIFIERS : MODIFIER_LIST {$$=$1} MODIFIER_LIST : MODIFIER MODIFIER_LIST {extend($2,$1);$$=$2;} MODIFIER_LIST : MODIFIER {$$=empty_token();extend($$,$1);} -MODIFIER : T_PUBLIC | T_PRIVATE | T_PROTECTED | T_STATIC | T_DYNAMIC | T_FINAL | T_OVERRIDE | T_NATIVE | T_INTERNAL +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 @@ -598,13 +1074,13 @@ IDECLARATION : VARIABLE_DECLARATION IDECLARATION : FUNCTION_DECLARATION IMPLEMENTS_LIST : {$$=list_new();} -IMPLEMENTS_LIST : T_IMPLEMENTS PACKAGEANDCLASS_LIST {$$=$2;} +IMPLEMENTS_LIST : KW_IMPLEMENTS PACKAGEANDCLASS_LIST {$$=$2;} EXTENDS : {$$=registry_getobjectclass();} -EXTENDS : T_EXTENDS PACKAGEANDCLASS {$$=$2;} +EXTENDS : KW_EXTENDS PACKAGEANDCLASS {$$=$2;} EXTENDS_LIST : {$$=list_new();} -EXTENDS_LIST : T_EXTENDS PACKAGEANDCLASS_LIST {$$=$2;} +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);}