%union tokenunion {
tokenptr_t token;
- class_signature_t*class_signature;
- class_signature_list_t*class_signature_list;
+ classinfo_t*classinfo;
+ classinfo_list_t*classinfo_list;
int number_int;
unsigned int number_uint;
code_t*code;
typedcode_t value;
typedcode_list_t*value_list;
+ param_t* param;
+ param_list_t* param_list;
writeable_t writeable;
char*string;
}
%token<token> KW_SET "set"
%token<token> KW_STATIC
%token<token> KW_IMPORT "import"
+%token<token> KW_RETURN "return"
%token<token> KW_INTERFACE "interface"
-%token<token> KW_NULL
+%token<token> KW_NULL "null"
%token<token> KW_VAR "var"
%token<token> KW_DYNAMIC
%token<token> KW_OVERRIDE
%token<token> T_STAR '*'
%token<token> T_DOT '.'
+%type <token> X_IDENTIFIER
%type <code> CODE
%type <code> CODEPIECE
%type <code> CODEBLOCK MAYBECODE
%type <value> E
%type <writeable> LH
%type <value> CONSTANT
-%type <code> FOR IF WHILE MAYBEELSE BREAK
+%type <code> FOR IF WHILE MAYBEELSE BREAK RETURN
%type <token> USE_NAMESPACE
%type <code> ASSIGNMENT FOR_INIT
%type <token> IMPORT
-%type <class_signature> MAYBETYPE
-%type <token> PACKAGESPEC
+%type <classinfo> MAYBETYPE
%type <token> GETSET
-%type <token> PARAM
-%type <token> PARAMS
-%type <token> PARAM_LIST
+%type <param> PARAM
+%type <param_list> PARAM_LIST
+%type <param_list> MAYBE_PARAM_LIST
%type <token> MODIFIERS
%type <token> MODIFIER_LIST
-%type <class_signature_list> IMPLEMENTS_LIST
-%type <class_signature> EXTENDS
-%type <class_signature_list> EXTENDS_LIST
-%type <class_signature> PACKAGEANDCLASS
-%type <class_signature_list> PACKAGEANDCLASS_LIST
-%type <token> MULTILEVELIDENTIFIER
-%type <class_signature> TYPE
+%type <classinfo_list> IMPLEMENTS_LIST
+%type <classinfo> EXTENDS
+%type <classinfo_list> EXTENDS_LIST
+%type <classinfo> CLASS PACKAGEANDCLASS QNAME
+%type <classinfo_list> QNAME_LIST
+%type <classinfo> TYPE
%type <token> VAR
//%type <token> VARIABLE
%type <value> VAR_READ
%type <value> NEW
-%type <token> X_IDENTIFIER
+//%type <token> T_IDENTIFIER
%type <token> MODIFIER
%type <token> PACKAGE
%type <value> FUNCTIONCALL
-%type <value_list> MAYBE_EXPRESSION_LIST EXPRESSION_LIST
+%type <value_list> 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
%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
}
typedef struct _import {
- char*path;
+ char*package;
} import_t;
DECLARE_LIST(import);
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;
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)
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()
}
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, classinfo_t*extends, classinfo_list_t*implements, char interface)
{
if(state->cls) {
syntaxerror("inner classes now allowed");
state->classname = name->text;
token_list_t*t=0;
- class_signature_list_t*mlist=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");
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->classinfo?mlist->classinfo->name:0);
}
- printf("\n");*/
+ printf("\n");
+ */
char public=0,internal=0,final=0,sealed=1;
for(t=modifiers->tokens;t;t=t->next) {
syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, state->classname);
}
- class_signature_t* classname = class_signature_register(access, package, state->classname);
+ classinfo_t* classname = classinfo_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);
+ 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, classname2, state->cls);
+ int slotindex = abc_initscript_addClassTrait(state->init, &classname2, state->cls);
abc_method_body_t*m = state->init->method->body;
__ getglobalscope(m);
- class_signature_t*s = extends;
+ classinfo_t*s = extends;
int count=0;
__ getlex2(m, s2);
multiname_destroy(s2);
- __ pushscope(m);
+ __ 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;
/* 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);
+ /* 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);
/* flash.display.MovieClip handling */
- if(!globalclass && public && class_signature_equals(registry_getMovieClip(),extends)) {
+ 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);*/
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)
+ param_list_t*params, classinfo_t*type)
{
token_list_t*t;
new_state();
}
multiname_t*type2 = sig2mname(type);
-
if(!strcmp(state->classname,name->text)) {
state->m = abc_class_constructor(state->cls, type2, 0);
} else {
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);
-
- 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 token_t* empty_token()
{
NEW(token_t,t);
list->text[l1+l2+l3]=0;
}
-int find_variable(char*name, class_signature_t**m)
+static int find_variable(char*name, classinfo_t**m)
{
state_list_t* s = state_stack;
while(s) {
}
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;t<state->vars->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;
+ }
}
-class_signature_t*join_types(class_signature_t*type1, class_signature_t*type2, char op)
+classinfo_t*join_types(classinfo_t*type1, classinfo_t*type2, char op)
{
return registry_getanytype(); // FIXME
}
-char is_subtype_of(class_signature_t*type, class_signature_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;
+}
%}
CODEPIECE: FOR {$$=$1}
CODEPIECE: WHILE {$$=$1}
CODEPIECE: BREAK {$$=$1}
+CODEPIECE: RETURN {$$=$1}
CODEPIECE: IF {$$=$1}
CODEPIECE: ASSIGNMENT {$$=$1}
CODEPIECE: NAMESPACE_DECLARATION {/*TODO*/$$=code_new();}
/* ------------ 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()
}
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;
- 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
//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);
$$ = 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" {
/* ------------ 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;
+}
+
+RETURN: "return" %prec prec_none {
+ $$ = abc_returnvoid(0);
+}
+RETURN: "return" EXPRESSION {
+ $$ = $2.c;
+ $$ = abc_returnvalue($$);
+}
-TYPE : PACKAGEANDCLASS {$$=$1;}
+TYPE : QNAME {$$=$1;}
| '*' {$$=registry_getanytype();}
| "String" {$$=registry_getstringclass();}
| "int" {$$=registry_getintclass();}
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
//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);
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;
}
$$.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);
$$.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);
- MULTINAME(m, registry_getintclass());
- $$.c=abc_coerce2($$.c, &m); // 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);
- MULTINAME(m, registry_getintclass());
- $$.c=abc_coerce2($$.c, &m); // 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);
- MULTINAME(m, registry_getintclass());
- $$.c=abc_coerce2($$.c, &m); //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);
- MULTINAME(m, registry_getintclass());
- $$.c=abc_coerce2($$.c, &m); //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
//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
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
git.asbjorn.biz / swftools.git / blobdiff