%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;
- struct _code*code;
- struct _typedcode value;
- struct _typedcode_list*value_list;
- struct _writeable writeable;
+ code_t*code;
+ typedcode_t value;
+ typedcode_list_t*value_list;
+ writeable_t writeable;
char*string;
}
%type <token> USE_NAMESPACE
%type <code> ASSIGNMENT FOR_INIT
%type <token> IMPORT
-%type <multiname> MAYBETYPE
+%type <class_signature> MAYBETYPE
%type <token> PACKAGESPEC
%type <token> GETSET
%type <token> PARAM
%type <token> PARAM_LIST
%type <token> MODIFIERS
%type <token> MODIFIER_LIST
-%type <multiname_list> IMPLEMENTS_LIST
-%type <multiname> EXTENDS
-%type <multiname_list> EXTENDS_LIST
-%type <multiname> PACKAGEANDCLASS
-%type <multiname_list> PACKAGEANDCLASS_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 <multiname> TYPE
+%type <class_signature> TYPE
%type <token> VAR
//%type <token> VARIABLE
%type <value> VAR_READ
%nonassoc '|'
%nonassoc '^'
%nonassoc '&'
-%nonassoc "!=" "==" "<=" '<' ">=" '>' // TODO: support "a < b < c" syntax?
+%nonassoc "!=" "==" "===" "<=" '<' ">=" '>' // TODO: support "a < b < c" syntax?
%nonassoc "is"
%left '-'
%left '+'
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()
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();
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, 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) {
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: 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);
+
+ multiname_t*s2 = sig2mname(s);
+ __ getlex2(m, s2);
+ multiname_destroy(s2);
+
__ pushscope(m);
m->code = m->code->prev->prev; // invert
count++;
/* 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, 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);
}
__ setslot(m, slotindex);
- if(!globalclass && public && multiname_equals(registry_getMovieClip(),extends)) {
+ /* 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 {
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)
}
}
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);
+
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);
}
+ /* 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 token_t* empty_token()
{
NEW(token_t,t);
list->text[l1+l2+l3]=0;
}
-int find_variable(char*name, multiname_t**m)
+static int find_variable(char*name, class_signature_t**m)
{
state_list_t* s = state_stack;
while(s) {
s = s->next;
}
syntaxerror("undefined variable: %s", name);
+}
+static char variable_exists(char*name)
+{
+ return array_contains(state->vars, name);
+}
+static int new_variable(char*name, class_signature_t*type)
+{
+ return array_append(state->vars, name, type) + state->local_var_base;
+}
+code_t* killvars(code_t*c)
+{
+ int t;
+ for(t=0;t<state->vars->num;t++) {
+ class_signature_t*type = array_getvalue(state->vars, t);
+ //do this always, otherwise register types don't match
+ //in the verifier when doing nested loops
+ //if(!TYPE_IS_BUILTIN_SIMPLE(type)) {
+ c = abc_kill(c, t+state->local_var_base);
+ //}
+ }
+ return c;
}
-multiname_t*join_types(multiname_t*type1, multiname_t*type2, char op)
+class_signature_t*join_types(class_signature_t*type1, class_signature_t*type2, char op)
{
return registry_getanytype(); // FIXME
}
-char is_subtype_of(multiname_t*type, multiname_t*supertype)
+char is_subtype_of(class_signature_t*type, class_signature_t*supertype)
{
return 1; // FIXME
}
-#define TYPE_ANY registry_getanytype()
-#define TYPE_IS_ANY(t) ((t) == registry_getanytype())
-#define TYPE_INT registry_getintclass()
-#define TYPE_IS_INT(t) ((t) == registry_getintclass())
-#define TYPE_UINT registry_getuintclass()
-#define TYPE_IS_UINT(t) ((t) == registry_getuintclass())
-#define TYPE_FLOAT registry_getnumberclass()
-#define TYPE_IS_FLOAT(t) ((t) == registry_getnumberclass())
-#define TYPE_BOOLEAN registry_getbooleanclass()
-#define TYPE_IS_BOOLEAN(t)((t) == registry_getbooleanclass())
-#define TYPE_STRING registry_getstringclass()
-#define TYPE_IS_STRING(t) ((t) == registry_getstringclass())
-#define TYPE_NULL registry_getnullclass()
-#define TYPE_IS_NULL(t) ((t) == registry_getnullclass())
+void breakjumpsto(code_t*c, code_t*jump)
+{
+ while(c->prev)
+ c=c->prev;
+ while(c) {
+ if(c->opcode == OPCODE___BREAK__) {
+ c->opcode = OPCODE_JUMP;
+ c->branch = jump;
+ }
+ c = c->next;
+ }
+}
+code_t*converttype(code_t*c, class_signature_t*from, class_signature_t*to)
+{
+ if(!to) {
+ /*TODO: can omit this if from is zero? */
+ return abc_coerce_a(c);
+ }
+ if(TYPE_IS_NUMBER(from) && TYPE_IS_UINT(to)) {
+ MULTINAME(m, TYPE_UINT);
+ return abc_coerce2(c, &m);
+ }
+ if(TYPE_IS_NUMBER(from) && TYPE_IS_INT(to)) {
+ MULTINAME(m, TYPE_INT);
+ return abc_coerce2(c, &m);
+ }
+ return c;
+}
+
+code_t*defaultvalue(code_t*c, class_signature_t*type)
+{
+ if(TYPE_IS_INT(type) || TYPE_IS_UINT(type) || TYPE_IS_FLOAT(type)) {
+ c = abc_pushbyte(c, 0);
+ } else if(TYPE_IS_BOOLEAN(type)) {
+ c = abc_pushfalse(c);
+ } else {
+ c = abc_pushnull(c);
+ }
+ return c;
+}
%}
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()
}
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;
+ class_signature_t*type=0;
int i = find_variable($1->text, &type);
$$ = $3.c;
if(!type && $3.t) {
//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" {
//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);
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
+ 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);
- $$.c=abc_coerce2($$.c, registry_getintclass()); // FIXME
+ class_signature_t*type = join_types($1.type, $3.t, '-');
+ $$.c=converttype($$.c, type, $1.type);
$$.c=abc_dup($$.c);$$.c=code_append($$.c,$1.write);
$$.t = $1.type;
}
// TODO: use inclocal where appropriate
E : LH "++" {$$.c = $1.read;$$.c=abc_increment($$.c);
- $$.c=abc_coerce2($$.c, registry_getintclass()); //FIXME
+ class_signature_t*type = $1.type;
+ if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) type = TYPE_NUMBER;
+ $$.c=converttype($$.c, type, $1.type);
$$.c=abc_dup($$.c);$$.c=code_append($$.c,$1.write);
$$.t = $1.type;
}
E : LH "--" {$$.c = $1.read;$$.c=abc_decrement($$.c);
- $$.c=abc_coerce2($$.c, registry_getintclass()); //FIXME
+ class_signature_t*type = $1.type;
+ if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) type = TYPE_NUMBER;
+ $$.c=converttype($$.c, 0, $1.type);
$$.c=abc_dup($$.c);$$.c=code_append($$.c,$1.write);
$$.t = $1.type;
}
git.asbjorn.biz / swftools.git / blobdiff