#include "abc.h"
#include "pool.h"
#include "files.h"
+#include "common.h"
#include "tokenizer.h"
#include "registry.h"
#include "code.h"
#include "opcodes.h"
#include "compiler.h"
+#include "ast.h"
extern int a3_lex();
abc_exception_t *exception;
regexp_t regexp;
modifiers_t flags;
+ namespace_decl_t* namespace_decl;
struct {
abc_exception_list_t *l;
code_t*finally;
%token<token> T_EMPTY
%token<number_int> T_INT
%token<number_uint> T_UINT
-%token<number_uint> T_BYTE
-%token<number_uint> T_SHORT
%token<number_float> T_FLOAT
%token<id> T_FOR "for"
%token<token> KW_FUNCTION "function"
%token<token> KW_FINALLY "finally"
%token<token> KW_UNDEFINED "undefined"
+%token<token> KW_NAN "NaN"
%token<token> KW_CONTINUE "continue"
%token<token> KW_CLASS "class"
%token<token> KW_CONST "const"
%token<token> T_USHR ">>>"
%token<token> T_SHR ">>"
+%type <number_int> CONDITIONAL_COMPILATION
%type <for_start> FOR_START
-%type <id> X_IDENTIFIER PACKAGE FOR_IN_INIT MAYBE_IDENTIFIER NAMESPACE_ID
+%type <id> X_IDENTIFIER PACKAGE FOR_IN_INIT MAYBE_IDENTIFIER
+%type <namespace_decl> NAMESPACE_ID
%type <token> VARCONST
%type <code> CODE
%type <code> CODEPIECE CODE_STATEMENT
%type <value> EXPRESSION NONCOMMAEXPRESSION
%type <value> MAYBEEXPRESSION
%type <value> E DELETE
-%type <value> CONSTANT
%type <code> FOR FOR_IN IF WHILE DO_WHILE MAYBEELSE BREAK RETURN CONTINUE TRY
%type <value> INNERFUNCTION
%type <code> USE_NAMESPACE
%type <flags> MAYBE_MODIFIERS
%type <flags> MODIFIER_LIST
%type <flags> MODIFIER
-%type <constant> STATICCONSTANT MAYBESTATICCONSTANT
+%type <constant> CONSTANT MAYBECONSTANT
%type <classinfo_list> IMPLEMENTS_LIST
%type <classinfo> EXTENDS CLASS_SPEC
%type <classinfo_list> EXTENDS_LIST
%type <value> NEW
//%type <token> T_IDENTIFIER
%type <value> FUNCTIONCALL
-%type <value_list> MAYBE_EXPRESSION_LIST EXPRESSION_LIST EXPRESSION_LIST_AND_COMMA MAYBE_PARAM_VALUES MAYBE_EXPRPAIR_LIST EXPRPAIR_LIST
+%type <value_list> MAYBE_EXPRESSION_LIST EXPRESSION_LIST EXPRESSION_LIST_AND_COMMA MAYBE_PARAM_VALUES MAYBE_EXPRPAIR_LIST EXPRPAIR_LIST WITH_HEAD
// precedence: from low to high
// needed for "return" precedence:
%nonassoc T_STRING T_REGEXP
-%nonassoc T_INT T_UINT T_BYTE T_SHORT T_FLOAT
+%nonassoc T_INT T_UINT T_FLOAT KW_NAN
%nonassoc "false" "true" "null" "undefined" "super" "function"
%left above_function
return 0; //make gcc happy
}
+static void parsererror(const char*file, int line, const char*f)
+{
+ syntaxerror("internal error in %s, %s:%d", f, file, line);
+}
+
+#define parserassert(b) {if(!(b)) parsererror(__FILE__, __LINE__,__func__);}
+
static char* concat2(const char* t1, const char* t2)
{
typedef struct _import {
char*package;
} import_t;
-
DECLARE_LIST(import);
DECLARE(methodstate);
struct _methodstate {
/* method data */
methodinfo_t*info;
+ char has_exceptions;
char late_binding;
char is_constructor;
char has_super;
char uses_parent_function;
int uses_slots;
dict_t*slots;
+ int activation_var;
abc_method_t*abc;
int var_index; // for inner methods
char is_a_slot; // for inner methods
code_t*header;
+
+ code_t*scope_code;
abc_exception_list_t*exceptions;
methodstate_list_t*innerfunctions;
import_list_t*wildcard_imports;
dict_t*import_toplevel_packages;
dict_t*imports;
- namespace_list_t*active_namespaces;
+
+ namespace_list_t*active_namespace_urls;
+
char has_own_imports;
char new_vars; // e.g. transition between two functions
methodstate_t*method;
char*exception_name;
+
+ int switch_var;
dict_t*vars;
} state_t;
static namespace_list_t nl1 = {&ns1,&nl2};
static namespace_set_t nopackage_namespace_set = {&nl1};
+static dict_t*definitions=0;
+void as3_set_definition(const char*c)
+{
+ if(!definitions)
+ definitions = dict_new();
+ if(!dict_contains(definitions,c))
+ dict_put(definitions,c,0);
+}
+
static void new_state()
{
NEW(state_t, s);
state->vars = dict_new();
state->old = oldstate;
state->new_vars = 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 import_toplevel(const char*package)
-{
- char* s = strdup(package);
- while(1) {
- dict_put(state->import_toplevel_packages, s, 0);
- char*x = strrchr(s, '.');
- if(!x)
- break;
- *x = 0;
- }
- free(s);
+
+ trie_remember(active_namespaces);
+
+ if(oldstate)
+ state->active_namespace_urls = list_clone(oldstate->active_namespace_urls);
}
static void state_destroy(state_t*state)
dict_destroy(state->vars);state->vars=0;
}
+ list_free(state->active_namespace_urls)
+ state->active_namespace_urls = 0;
+
free(state);
}
static void old_state()
{
+ trie_rollback(active_namespaces);
+
if(!state || !state->old)
syntaxerror("invalid nesting");
state_t*leaving = state;
state = state->old;
-
+
if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) {
free(leaving->method);
leaving->method=0;
free(leaving->cls);
leaving->cls=0;
}
-
+
state_destroy(leaving);
}
if(state) {
syntaxerror("invalid call to initialize_file during parsing of another file");
}
+
+ active_namespaces = trie_new();
+
new_state();
state->package = internal_filename_package = strdup(filename);
if(as3_pass==1) {
state->method = rfx_calloc(sizeof(methodstate_t));
dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
+ state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope
} else {
state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
function_initvars(state->method, 0, 0, 1);
global->init = abc_initscript(global->file);
- state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope
}
}
void* finish_parser()
{
dict_free_all(global->file2token2info, 1, (void*)dict_destroy);
-
global->token2info=0;
-
return global->file;
}
-
-static void xx_scopetest()
-{
- /* findpropstrict doesn't just return a scope object- it
- also makes it "active" somehow. Push local_0 on the
- scope stack and read it back with findpropstrict, it'll
- contain properties like "trace". Trying to find the same
- property on a "vanilla" local_0 yields only a "undefined" */
- //c = abc_findpropstrict(c, "[package]::trace");
-
- /*c = abc_getlocal_0(c);
- c = abc_findpropstrict(c, "[package]::trace");
- c = abc_coerce_a(c);
- c = abc_setlocal_1(c);
-
- c = abc_pushbyte(c, 0);
- c = abc_setlocal_2(c);
-
- code_t*xx = c = abc_label(c);
- c = abc_findpropstrict(c, "[package]::trace");
- c = abc_pushstring(c, "prop:");
- c = abc_hasnext2(c, 1, 2);
- c = abc_dup(c);
- c = abc_setlocal_3(c);
- c = abc_callpropvoid(c, "[package]::trace", 2);
- c = abc_getlocal_3(c);
- c = abc_kill(c, 3);
- c = abc_iftrue(c,xx);*/
-}
-
typedef struct _variable {
int index;
classinfo_t*type;
char init;
+ char is_parameter;
methodstate_t*is_inner_method;
} variable_t;
syntaxerror("undefined variable: %s", name);
return v;
}
+
static char variable_exists(char*name)
{
return dict_contains(state->vars, name);
}
-code_t*defaultvalue(code_t*c, classinfo_t*type);
+
+static code_t*defaultvalue(code_t*c, classinfo_t*type)
+{
+ if(TYPE_IS_INT(type)) {
+ c = abc_pushbyte(c, 0);
+ } else if(TYPE_IS_UINT(type)) {
+ c = abc_pushuint(c, 0);
+ } else if(TYPE_IS_FLOAT(type)) {
+ c = abc_pushnan(c);
+ } else if(TYPE_IS_BOOLEAN(type)) {
+ c = abc_pushfalse(c);
+ } else if(!type) {
+ //c = abc_pushundefined(c);
+ syntaxerror("internal error: can't generate default value for * type");
+ } else {
+ c = abc_pushnull(c);
+ MULTINAME(m, type);
+ c = abc_coerce2(c, &m);
+ }
+ return c;
+}
+
+static int alloc_local()
+{
+ return state->method->variable_count++;
+}
static variable_t* new_variable2(const char*name, classinfo_t*type, char init, char maybeslot)
{
}
NEW(variable_t, v);
- v->index = state->method->variable_count++;
+ v->index = alloc_local();
v->type = type;
v->init = init;
-
- dict_put(state->vars, name, v);
+
+ if(name)
+ dict_put(state->vars, name, v);
return v;
}
return new_variable(TEMPVARNAME, 0, 0, 0);
}
-code_t* var_block(code_t*body)
+static code_t* var_block(code_t*body)
{
code_t*c = 0;
code_t*k = 0;
return c;
}
-void unknown_variable(char*name)
+static void unknown_variable(char*name)
{
if(!state->method->unresolved_variables)
state->method->unresolved_variables = dict_new();
dict_put(state->method->unresolved_variables, name, 0);
}
-#define parserassert(b) {if(!(b)) parsererror(__FILE__, __LINE__,__func__);}
-
-static void parsererror(const char*file, int line, const char*f)
+static code_t* add_scope_code(code_t*c, methodstate_t*m, char init)
{
- syntaxerror("internal error in %s, %s:%d", f, file, line);
-}
-
-
-static code_t* method_header(methodstate_t*m)
-{
- code_t*c = 0;
- if(m->uses_slots || (m->late_binding && !m->inner)) {
+ if(m->uses_slots || (m->late_binding && !m->inner)) { //???? especially inner functions need the pushscope
c = abc_getlocal_0(c);
c = abc_pushscope(c);
}
if(m->uses_slots) {
- c = abc_newactivation(c);
- c = abc_pushscope(c);
+ /* FIXME: this alloc_local() causes variable indexes to be
+ different in pass2 than in pass1 */
+ if(!m->activation_var)
+ m->activation_var = alloc_local();
+ if(init) {
+ c = abc_newactivation(c);
+ c = abc_dup(c);
+ c = abc_pushscope(c);
+ c = abc_setlocal(c, m->activation_var);
+ } else {
+ c = abc_getlocal(c, m->activation_var);
+ c = abc_pushscope(c);
+ }
}
+ return c;
+}
+
+static code_t* method_header(methodstate_t*m)
+{
+ code_t*c = 0;
+
+ c = add_scope_code(c, m, 1);
+
methodstate_list_t*l = m->innerfunctions;
while(l) {
parserassert(l->methodstate->abc);
c = abc_getlocal_0(c);
c = abc_constructsuper(c, 0);
}
+
+ if(m->slots) {
+ /* all parameters that are used by inner functions
+ need to be copied from local to slot */
+ parserassert(m->activation_var);
+ DICT_ITERATE_ITEMS(m->slots,char*,name,variable_t*,v) {
+ if(v->is_parameter) {
+ c = abc_getlocal(c, m->activation_var);
+ c = abc_getlocal(c, v->index);
+ c = abc_setslot(c, v->index);
+ }
+ }
+ }
list_free(m->innerfunctions);
m->innerfunctions = 0;
return c;
return c;
}
-
static void startpackage(char*name)
{
new_state();
- /*printf("entering package \"%s\"\n", name);*/
state->package = strdup(name);
}
static void endpackage()
{
- /*printf("leaving package \"%s\"\n", state->package);*/
-
//used e.g. in classinfo_register:
//free(state->package);state->package=0;
-
old_state();
}
if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
syntaxerror("invalid combination of access levels and namespaces");
ns.access = ACCESS_NAMESPACE;
- ns.name = mod->ns;
+ state_t*s = state;
+ const char*url = (const char*)trie_lookup(active_namespaces, mod->ns);
+ if(!url) {
+ /* shouldn't happen- the tokenizer only reports something as a namespace
+ if it was already registered */
+ trie_dump(active_namespaces);
+ syntaxerror("unknown namespace: %s", mod->ns);
+ }
+ ns.name = url;
} else if(mod->flags&FLAG_PUBLIC) {
if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
syntaxerror("invalid combination of access levels");
}
static slotinfo_t* find_class(const char*name);
+static memberinfo_t* findmember_nsset(classinfo_t*cls, const char*name, char recurse)
+{
+ return registry_findmember_nsset(cls, state->active_namespace_urls, name, recurse);
+}
+
static void function_initvars(methodstate_t*m, params_t*params, int flags, char var0)
{
if(var0) {
*(int*)0=0;
parserassert(!index);
}
+
if(m->uses_slots) {
/* as variables and slots share the same number, make sure
that those variable indices are reserved. It's up to the
optimizer to later shuffle the variables down to lower
indices */
m->variable_count = m->uses_slots;
- DICT_ITERATE_ITEMS(m->slots, char*, name, variable_t*, v) {
- if(v->type) {
- if(v->type->package)
- v->type = (classinfo_t*)registry_find(v->type->package, v->type->name);
- else
- v->type = (classinfo_t*)find_class(v->type->name);
- if(!v->type || v->type->kind != INFOTYPE_CLASS) {
- syntaxerror("Couldn't find class %s", v->type->name);
- }
- }
- }
}
if(params) {
param_list_t*p=0;
for(p=params->list;p;p=p->next) {
- new_variable(p->param->name, p->param->type, 0, 1);
+ variable_t*v = new_variable2(p->param->name, p->param->type, 0, 1);
+ v->is_parameter = 1;
}
}
-
+
methodstate_list_t*l = m->innerfunctions;
while(l) {
methodstate_t*m = l->methodstate;
+
variable_t* v = new_variable2(m->info->name, TYPE_FUNCTION(m->info), 0, 1);
m->var_index = v->index;
m->slot_index = v->index;
v->is_inner_method = m;
+
l = l->next;
}
+
+ if(as3_pass==2) {
+ m->scope_code = add_scope_code(m->scope_code, m, 0);
+ }
+
+ if(as3_pass==2 && m->slots) {
+ /* exchange unresolved identifiers with the actual objects */
+ DICT_ITERATE_ITEMS(m->slots, char*, name, variable_t*, v) {
+ if(v->type && v->type->kind == INFOTYPE_UNRESOLVED) {
+ classinfo_t*type = (classinfo_t*)registry_resolve((slotinfo_t*)v->type);
+ if(!type || type->kind != INFOTYPE_CLASS) {
+ syntaxerror("Couldn't find class %s::%s (%s)", v->type->package, v->type->name, name);
+ }
+ v->type = type;
+ }
+ }
+ }
}
if((mod->flags&(FLAG_PUBLIC|FLAG_PACKAGEINTERNAL)) == (FLAG_PUBLIC|FLAG_PACKAGEINTERNAL))
syntaxerror("public and internal not supported at the same time.");
+ //if(!(mod->flags&FLAG_INTERFACE) && !extends) {
if(!(mod->flags&FLAG_INTERFACE) && !extends) {
// all classes extend object
extends = registry_getobjectclass();
int num_interfaces = (list_length(implements));
state->cls->info = classinfo_register(access, package, classname, num_interfaces);
state->cls->info->flags |= mod->flags & (FLAG_DYNAMIC|FLAG_INTERFACE|FLAG_FINAL);
+
+ int pos = 0;
+ classinfo_list_t*l = implements;
+ for(l=implements;l;l=l->next) {
+ state->cls->info->interfaces[pos++] = l->classinfo;
+ }
}
if(as3_pass == 2) {
if(extends && (extends->flags & FLAG_FINAL))
syntaxerror("Can't extend final class '%s'", extends->name);
+
+ int pos = 0;
+ while(state->cls->info->interfaces[pos]) {
+ if(!(state->cls->info->interfaces[pos]->flags & FLAG_INTERFACE))
+ syntaxerror("'%s' is not an interface",
+ state->cls->info->interfaces[pos]->name);
+ pos++;
+ }
/* fill out interfaces and extends (we couldn't resolve those during the first pass) */
state->cls->info->superclass = extends;
- int pos = 0;
- classinfo_list_t*l = implements;
- for(l=implements;l;l=l->next) {
- if(!(l->classinfo->flags & FLAG_INTERFACE))
- syntaxerror("'%s' is not an interface", l->classinfo->name);
- state->cls->info->interfaces[pos++] = l->classinfo;
- }
/* generate the abc code for this class */
MULTINAME(classname2,state->cls->info);
}
}
-static int slotstate_varconst = 0;
-static modifiers_t*slotstate_flags = 0;
-static void setslotstate(modifiers_t* flags, int varconst)
-{
- slotstate_varconst = varconst;
- slotstate_flags = flags;
- if(state->cls) {
- if(flags && flags->flags&FLAG_STATIC) {
- state->method = state->cls->static_init;
- } else {
- state->method = state->cls->init;
- }
- } else {
- parserassert(state->method);
- }
-}
-
static void endclass()
{
if(as3_pass == 2) {
char*name = string_cstr(c->data[0]);
syntaxerror("Unresolved \"continue %s\"", name);
}
+ if(c->opcode == OPCODE___RETHROW__) {
+ syntaxerror("Unresolved \"rethrow\"");
+ }
+ if(c->opcode == OPCODE___FALLTHROUGH__) {
+ syntaxerror("Unresolved \"fallthrough\"");
+ }
if(c->opcode == OPCODE___PUSHPACKAGE__) {
char*name = string_cstr(c->data[0]);
syntaxerror("Can't reference a package (%s) as such", name);
}
}
-
static void check_constant_against_type(classinfo_t*t, constant_t*c)
{
#define xassert(b) if(!(b)) syntaxerror("Invalid default value %s for type '%s'", constant_tostring(c), t->name)
//class method
memberinfo_t* m = registry_findmember(state->cls->info, ns.name, name, 0);
if(m) {
- printf("%s.%s | %s.%s\n",
- m->package, m->name,
- ns.name, name);
syntaxerror("class already contains a %s '%s'", infotypename((slotinfo_t*)m), m->name);
}
minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);
static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*name,
params_t*params, classinfo_t*return_type, code_t*body)
{
- int flags = mod?mod->flags:0;
-
if(as3_pass==1) {
// store inner methods in variables
function_initvars(state->method, 0, 0, 0);
state->method->slots = dict_new();
int i = 1;
DICT_ITERATE_ITEMS(state->vars, char*, name, variable_t*, v) {
+ if(!name) syntaxerror("internal error");
if(v->index && dict_contains(xvars, name)) {
v->init = 0;
v->index = i++;
} else if(state->method->is_constructor) {
f = abc_class_getconstructor(state->cls->abc, type2);
} else if(!state->method->is_global) {
- namespace_t mname_ns = {state->method->info->access, ""};
+ namespace_t mname_ns = modifiers2access(mod);
multiname_t mname = {QNAME, &mname_ns, 0, name};
- if(flags&FLAG_STATIC)
+ if(mod->flags&FLAG_STATIC)
f = abc_class_staticmethod(state->cls->abc, type2, &mname);
else
f = abc_class_method(state->cls->abc, type2, &mname);
//flash doesn't seem to allow us to access function slots
//state->method->info->slot = slot;
- if(flags&FLAG_OVERRIDE) f->trait->attributes |= TRAIT_ATTR_OVERRIDE;
+ if(mod && mod->flags&FLAG_OVERRIDE) f->trait->attributes |= TRAIT_ATTR_OVERRIDE;
if(getset == KW_GET) f->trait->kind = TRAIT_GETTER;
if(getset == KW_SET) f->trait->kind = TRAIT_SETTER;
if(params->varargs) f->flags |= METHOD_NEED_REST;
check_code_for_break(body);
- if(state->method->exceptions &&
- (state->method->late_binding || state->method->uses_slots)) {
- //syntaxerror("try/catch and activation or late binding not supported yet within the same method");
- as3_warning("try/catch and activation or late binding not supported yet within the same method");
- }
+ /* Seems this works now.
+ if(state->method->exceptions && state->method->uses_slots) {
+ as3_warning("try/catch and activation not supported yet within the same method");
+ }*/
if(f->body) {
f->body->code = body;
return 0;
}
-char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
-{
- return 1; // FIXME
-}
-
void breakjumpsto(code_t*c, char*name, code_t*jump)
{
while(c) {
}
}
+/* TODO: move this to ast.c */
#define IS_INT(a) (TYPE_IS_INT((a)) || TYPE_IS_UINT((a)))
#define IS_NUMBER_OR_INT(a) (TYPE_IS_INT((a)) || TYPE_IS_UINT((a)) || TYPE_IS_NUMBER((a)))
#define BOTH_INT(a,b) (IS_INT(a) && IS_INT(b))
-
-classinfo_t*join_types(classinfo_t*type1, classinfo_t*type2, char op)
+static classinfo_t*join_types(classinfo_t*type1, classinfo_t*type2, char op)
{
if(!type1 || !type2)
return registry_getanytype();
return type1;
return registry_getanytype();
}
+static char is_getlocal(code_t*c)
+{
+ if(!c || c->prev || c->next)
+ return 0;
+ return(c->opcode == OPCODE_GETLOCAL
+ || c->opcode == OPCODE_GETLOCAL_0
+ || c->opcode == OPCODE_GETLOCAL_1
+ || c->opcode == OPCODE_GETLOCAL_2
+ || c->opcode == OPCODE_GETLOCAL_3);
+}
+static int getlocalnr(code_t*c)
+{
+ if(c->opcode == OPCODE_GETLOCAL) {return (ptroff_t)c->data[0];}
+ else if(c->opcode == OPCODE_GETLOCAL_0) {return 0;}
+ else if(c->opcode == OPCODE_GETLOCAL_1) {return 1;}
+ else if(c->opcode == OPCODE_GETLOCAL_2) {return 2;}
+ else if(c->opcode == OPCODE_GETLOCAL_3) {return 3;}
+ else syntaxerror("Internal error: opcode %02x is not a getlocal call", c->opcode);
+ return 0;
+}
code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
{
if(from==to)
if((TYPE_IS_NUMBER(from) || TYPE_IS_UINT(from) || TYPE_IS_INT(from)) &&
(TYPE_IS_NUMBER(to) || TYPE_IS_UINT(to) || TYPE_IS_INT(to))) {
// allow conversion between number types
+ if(TYPE_IS_UINT(to))
+ return abc_convert_u(c);
+ else if(TYPE_IS_INT(to))
+ return abc_convert_i(c);
+ else if(TYPE_IS_NUMBER(to))
+ return abc_convert_d(c);
return abc_coerce2(c, &m);
}
- //printf("%s.%s\n", from.package, from.name);
- //printf("%s.%s\n", to.package, to.name);
+
+ if(TYPE_IS_BOOLEAN(to))
+ return abc_convert_b(c);
+ if(TYPE_IS_STRING(to))
+ return abc_convert_s(c);
+ if(TYPE_IS_OBJECT(to))
+ return abc_convert_o(c);
classinfo_t*supertype = from;
while(supertype) {
return c;
as3_error("can't convert type %s%s%s to %s%s%s",
- from->package, from->package?".":"", from->name,
- to->package, to->package?".":"", to->name);
- return c;
-}
+ from->package, from->package[0]?".":"", from->name,
+ to->package, to->package[0]?".":"", to->name);
-code_t*defaultvalue(code_t*c, classinfo_t*type)
-{
- if(TYPE_IS_INT(type)) {
- c = abc_pushbyte(c, 0);
- } else if(TYPE_IS_UINT(type)) {
- c = abc_pushuint(c, 0);
- } else if(TYPE_IS_FLOAT(type)) {
- c = abc_pushnan(c);
- } else if(TYPE_IS_BOOLEAN(type)) {
- c = abc_pushfalse(c);
- } else if(!type) {
- //c = abc_pushundefined(c);
- } else {
- c = abc_pushnull(c);
- MULTINAME(m, type);
- c = abc_coerce2(c, &m);
- }
return c;
}
+/* move to ast.c todo end */
char is_pushundefined(code_t*c)
{
return (c && !c->prev && !c->next && c->opcode == OPCODE_PUSHUNDEFINED);
}
+static const char* get_package_from_name(const char*name)
+{
+ /* try explicit imports */
+ dictentry_t* e = dict_get_slot(state->imports, name);
+ while(e) {
+ if(!strcmp(e->key, name)) {
+ slotinfo_t*c = (slotinfo_t*)e->data;
+ if(c) return c->package;
+ }
+ e = e->next;
+ }
+ return 0;
+}
+static namespace_list_t*get_current_imports()
+{
+ namespace_list_t*searchlist = 0;
+
+ list_append(searchlist, namespace_new_package(state->package));
+
+ import_list_t*l = state->wildcard_imports;
+ while(l) {
+ namespace_t*ns = namespace_new_package(l->import->package);
+ list_append(searchlist, ns);
+ l = l->next;
+ }
+ list_append(searchlist, namespace_new_package(""));
+ list_append(searchlist, namespace_new_package(internal_filename_package));
+ return searchlist;
+}
+
static slotinfo_t* find_class(const char*name)
{
slotinfo_t*c=0;
return x;
}
-static char is_getlocal(code_t*c)
-{
- if(!c || c->prev || c->next)
- return 0;
- return(c->opcode == OPCODE_GETLOCAL
- || c->opcode == OPCODE_GETLOCAL_0
- || c->opcode == OPCODE_GETLOCAL_1
- || c->opcode == OPCODE_GETLOCAL_2
- || c->opcode == OPCODE_GETLOCAL_3);
-}
-static int getlocalnr(code_t*c)
-{
- if(c->opcode == OPCODE_GETLOCAL) {return (ptroff_t)c->data[0];}
- else if(c->opcode == OPCODE_GETLOCAL_0) {return 0;}
- else if(c->opcode == OPCODE_GETLOCAL_1) {return 1;}
- else if(c->opcode == OPCODE_GETLOCAL_2) {return 2;}
- else if(c->opcode == OPCODE_GETLOCAL_3) {return 3;}
- else syntaxerror("Internal error: opcode %02x is not a getlocal call", c->opcode);
- return 0;
-}
-static code_t* toreadwrite(code_t*in, code_t*middlepart, char justassign, char readbefore)
+code_t* toreadwrite(code_t*in, code_t*middlepart, char justassign, char readbefore, char pushvalue)
{
/* converts this:
temp = gettempvar();
c = code_append(c, prefix);
c = code_append(c, r);
- if(readbefore) {
+ if(pushvalue && readbefore) {
c = abc_dup(c);
c = abc_setlocal(c, temp);
}
c = code_append(c, middlepart);
- if(!readbefore) {
+ if(pushvalue && !readbefore) {
c = abc_dup(c);
c = abc_setlocal(c, temp);
}
c = code_append(c, write);
- c = abc_getlocal(c, temp);
- c = abc_kill(c, temp);
+ if(pushvalue) {
+ c = abc_getlocal(c, temp);
+ c = abc_kill(c, temp);
+ }
} else {
/* if we're allowed to execute the read code twice *and*
the middlepart doesn't modify the code, things are easier.
*/
- code_t* r2 = code_dup(r);
//c = code_append(c, prefix);
parserassert(!prefix);
+ code_t* r2 = 0;
+ if(pushvalue) {
+ r2 = code_dup(r);
+ }
c = code_append(c, r);
c = code_append(c, middlepart);
c = code_append(c, write);
- c = code_append(c, r2);
+ if(pushvalue) {
+ c = code_append(c, r2);
+ }
}
} else {
/* even smaller version: overwrite the value without reading
}
c = code_append(c, middlepart);
c = code_append(c, write);
- c = code_append(c, r);
+ if(pushvalue) {
+ c = code_append(c, r);
+ }
} else {
code_free(r);r=0;
temp = gettempvar();
c = code_append(c, prefix);
}
c = code_append(c, middlepart);
- c = abc_dup(c);
- c = abc_setlocal(c, temp);
+ if(pushvalue) {
+ c = abc_dup(c);
+ c = abc_setlocal(c, temp);
+ }
c = code_append(c, write);
- c = abc_getlocal(c, temp);
- c = abc_kill(c, temp);
+ if(pushvalue) {
+ c = abc_getlocal(c, temp);
+ c = abc_kill(c, temp);
+ }
}
}
return c;
return 0;
}
-
#define IS_FINALLY_TARGET(op) \
((op) == OPCODE___CONTINUE__ || \
(op) == OPCODE___BREAK__ || \
int lookup_version_cost = 4*num_insertion_points + 5;
if(cantdup || simple_version_cost > lookup_version_cost) {
- printf("lookup %d > *%d*\n", simple_version_cost, lookup_version_cost);
+ //printf("(use lookup) simple=%d > lookup=%d\n", simple_version_cost, lookup_version_cost);
return insert_finally_lookup(c, finally, tempvar);
} else {
- printf("simple *%d* < %d\n", simple_version_cost, lookup_version_cost);
+ //printf("(use simple) simple=%d < lookup=%d\n", simple_version_cost, lookup_version_cost);
return insert_finally_simple(c, finally, tempvar);
}
}
#define PASS1 }} if(as3_pass == 1) {{
#define PASS1END }} if(as3_pass == 2) {{
#define PASS2 }} if(as3_pass == 2) {{
-#define PASS12 }} {{
+#define PASS12 }} if(as3_pass == 1 || as3_pass == 2) {{
#define PASS12END }} if(as3_pass == 2) {{
+#define PASS_ALWAYS }} {{
%}
| FUNCTION_DECLARATION
| SLOT_DECLARATION
| PACKAGE_INITCODE
- | CONDITIONAL_COMPILATION '{' MAYBE_PROGRAM_CODE_LIST '}' // conditional compilation
+ | CONDITIONAL_COMPILATION '{' MAYBE_PROGRAM_CODE_LIST '}' {PASS_ALWAYS as3_pass=$1;}
| ';'
MAYBE_INPACKAGE_CODE_LIST: | INPACKAGE_CODE_LIST
| FUNCTION_DECLARATION
| SLOT_DECLARATION
| PACKAGE_INITCODE
- | CONDITIONAL_COMPILATION '{' MAYBE_INPACKAGE_CODE_LIST '}' // conditional compilation
+ | CONDITIONAL_COMPILATION '{' MAYBE_INPACKAGE_CODE_LIST '}' {PASS_ALWAYS as3_pass=$1;}
| ';'
MAYBECODE: CODE {$$=$1;}
CODEPIECE: CONTINUE
CODEPIECE: RETURN
CODEPIECE: THROW
-CODEPIECE: CONDITIONAL_COMPILATION '{' CODE '}' {$$=$3;}
+CODEPIECE: CONDITIONAL_COMPILATION '{' CODE '}' {PASS_ALWAYS as3_pass=$1;}
//CODEBLOCK : '{' CODE '}' {$$=$2;}
//CODEBLOCK : '{' '}' {$$=0;}
/* ------------ conditional compilation ------------- */
-CONDITIONAL_COMPILATION: T_IDENTIFIER "::" T_IDENTIFIER
+CONDITIONAL_COMPILATION: T_IDENTIFIER "::" T_IDENTIFIER {
+ PASS12
+ $$=as3_pass;
+ char*key = concat3($1,"::",$3);
+ if(!definitions || !dict_contains(definitions, key)) {
+ as3_pass=0;
+ }
+ free(key);
+}
/* ------------ variables --------------------------- */
+%code {
+ char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
+ {
+ return 1; // FIXME
+ }
+};
+
MAYBEEXPRESSION : '=' NONCOMMAEXPRESSION {$$=$2;}
| {$$.c=abc_pushundefined(0);
$$.t=TYPE_ANY;
CASE_LIST: CASE_LIST CASE {$$=code_append($$,$2);}
CASE: "case" E ':' MAYBECODE {
- $$ = abc_dup(0);
+ $$ = abc_getlocal(0, state->switch_var);
$$ = code_append($$, $2.c);
code_t*j = $$ = abc_ifne($$, 0);
$$ = code_append($$, $4);
DEFAULT: "default" ':' MAYBECODE {
$$ = $3;
}
-SWITCH : T_SWITCH '(' {PASS12 new_state();} E ')' '{' MAYBE_CASE_LIST '}' {
+SWITCH : T_SWITCH '(' {PASS12 new_state();state->switch_var=alloc_local();} E ')' '{' MAYBE_CASE_LIST '}' {
$$=$4.c;
+ $$ = abc_setlocal($$, state->switch_var);
$$ = code_append($$, $7);
- code_t*out = $$ = abc_pop($$);
+
+ code_t*out = $$ = abc_kill($$, state->switch_var);
breakjumpsto($$, $1, out);
code_t*c = $$,*lastblock=0;
int i = find_variable_safe(state, $3)->index;
e->target = c = abc_nop(0);
c = abc_setlocal(c, i);
+ c = code_append(c, code_dup(state->method->scope_code));
c = code_append(c, $8);
c = abc_kill(c, i);
}
}
-TRY : "try" '{' {PASS12 new_state();} MAYBECODE '}' CATCH_FINALLY_LIST {
+TRY : "try" '{' {PASS12 new_state();
+ state->method->has_exceptions=1;
+ state->method->late_binding=1;//for invariant scope_code
+ } MAYBECODE '}' CATCH_FINALLY_LIST {
code_t*out = abc_nop(0);
code_t*start = abc_nop(0);
parserassert((ptroff_t)$6.finally);
// finally block
e->target = $$ = abc_nop($$);
+ $$ = code_append($$, code_dup(state->method->scope_code));
$$ = abc___rethrow__($$);
}
/* ------------ with -------------------------------- */
-WITH : "with" '(' EXPRESSION ')' CODEBLOCK {
- $$ = $3.c;
+WITH_HEAD : "with" '(' EXPRESSION ')' {
+ new_state();
+ if(state->method->has_exceptions) {
+ int v = alloc_local();
+ state->method->scope_code = abc_getlocal(state->method->scope_code, v);
+ state->method->scope_code = abc_pushwith(state->method->scope_code);
+ $$.number = v;
+ }
+ $$.cc = $3.c;
+}
+WITH : WITH_HEAD CODEBLOCK {
+ /* remove getlocal;pushwith from scope code again */
+ state->method->scope_code = code_cutlast(code_cutlast(state->method->scope_code));
+
+ $$ = $1.cc;
+ if(state->method->has_exceptions) {
+ $$ = abc_dup($$);
+ $$ = abc_setlocal($$, $1.number);
+ }
$$ = abc_pushwith($$);
- $$ = code_append($$, $5);
+ $$ = code_append($$, $2);
$$ = abc_popscope($$);
+ old_state();
}
/* ------------ packages and imports ---------------- */
X_IDENTIFIER: T_IDENTIFIER
| "package" {PASS12 $$="package";}
+ | T_NAMESPACE {PASS12 $$=$1;}
PACKAGE: PACKAGE '.' X_IDENTIFIER {PASS12 $$ = concat3($1,".",$3);free($1);$1=0;}
PACKAGE: X_IDENTIFIER {PASS12 $$=strdup($1);}
PACKAGE_DECLARATION : "package" '{' {PASS12 startpackage("");}
MAYBE_INPACKAGE_CODE_LIST '}' {PASS12 endpackage();$$=0;}
+%code {
+ 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 import_toplevel(const char*package)
+ {
+ char* s = strdup(package);
+ while(1) {
+ dict_put(state->import_toplevel_packages, s, 0);
+ char*x = strrchr(s, '.');
+ if(!x)
+ break;
+ *x = 0;
+ }
+ free(s);
+ }
+};
IMPORT : "import" PACKAGEANDCLASS {
PASS12
slotinfo_t*s = registry_find($2->package, $2->name);
if(!s && as3_pass==1) {// || !(s->flags&FLAG_BUILTIN)) {
as3_schedule_class($2->package, $2->name);
}
-
- PASS2
classinfo_t*c = $2;
if(!c)
syntaxerror("Couldn't import class\n");
as3_schedule_package($2);
}
- PASS2
NEW(import_t,i);
i->package = $2;
state_has_imports();
$$.ns=$1.ns?$1.ns:$2.ns;
}
-
MODIFIER : KW_PUBLIC {PASS12 $$.flags=FLAG_PUBLIC;$$.ns=0;}
| KW_PRIVATE {PASS12 $$.flags=FLAG_PRIVATE;$$.ns=0;}
| KW_PROTECTED {PASS12 $$.flags=FLAG_PROTECTED;$$.ns=0;}
$$.ns=$1;
}
-EXTENDS : {$$=0;}
-EXTENDS : KW_EXTENDS CLASS_SPEC {$$=$2;}
+EXTENDS : {PASS12 $$=0;}
+EXTENDS : KW_EXTENDS CLASS_SPEC {PASS12 $$=$2;}
EXTENDS_LIST : {PASS12 $$=list_new();}
EXTENDS_LIST : KW_EXTENDS CLASS_SPEC_LIST {PASS12 $$=$2;}
CLASS_BODY : CLASS_BODY_ITEM
CLASS_BODY : CLASS_BODY CLASS_BODY_ITEM
CLASS_BODY_ITEM : ';'
-CLASS_BODY_ITEM : CONDITIONAL_COMPILATION '{' MAYBE_CLASS_BODY '}'
+CLASS_BODY_ITEM : CONDITIONAL_COMPILATION '{' MAYBE_CLASS_BODY '}' {PASS_ALWAYS as3_pass=$1;}
CLASS_BODY_ITEM : SLOT_DECLARATION
CLASS_BODY_ITEM : FUNCTION_DECLARATION
/* ------------ classes and interfaces (body, slots ) ------- */
+%code {
+ static int slotstate_varconst = 0;
+ static modifiers_t*slotstate_flags = 0;
+ static void setslotstate(modifiers_t* flags, int varconst)
+ {
+ slotstate_varconst = varconst;
+ slotstate_flags = flags;
+ if(state->cls) {
+ if(flags && flags->flags&FLAG_STATIC) {
+ state->method = state->cls->static_init;
+ } else {
+ state->method = state->cls->init;
+ }
+ } else {
+ parserassert(state->method);
+ }
+ }
+};
+
VARCONST: "var" | "const"
-SLOT_DECLARATION: MAYBE_MODIFIERS VARCONST {setslotstate(&$1,$2);} SLOT_LIST {$$=$4;setslotstate(0, 0);}
+SLOT_DECLARATION: MAYBE_MODIFIERS VARCONST {PASS12 setslotstate(&$1,$2);} SLOT_LIST {PASS12 $$=$4;setslotstate(0, 0);}
-SLOT_LIST: ONE_SLOT {$$ = $1;}
-SLOT_LIST: SLOT_LIST ',' ONE_SLOT {$$ = code_append($1, $3);}
+SLOT_LIST: ONE_SLOT {PASS12 $$=0;}
+SLOT_LIST: SLOT_LIST ',' ONE_SLOT {PASS12 $$=0;}
ONE_SLOT: T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION
{
+PASS12
int flags = slotstate_flags->flags;
namespace_t ns = modifiers2access(slotstate_flags);
- varinfo_t* info = 0;
- if(state->cls) {
- memberinfo_t*i = registry_findmember(state->cls->info, ns.name, $1, 1);
- if(i) {
- check_override(i, flags);
- }
- info = varinfo_register_onclass(state->cls->info, ns.access, ns.name, $1);
- } else {
- slotinfo_t*i = registry_find(state->package, $1);
- if(i) {
- syntaxerror("package %s already contains '%s'", state->package, $1);
- }
- if(ns.name && ns.name[0]) {
- syntaxerror("namespaces not allowed on package-level variables");
- }
- info = varinfo_register_global(ns.access, state->package, $1);
- }
+ if(as3_pass == 1) {
- info->type = $2;
- info->flags = flags;
+ varinfo_t* info = 0;
+ if(state->cls) {
+ memberinfo_t*i = registry_findmember(state->cls->info, ns.name, $1, 1);
+ if(i) {
+ check_override(i, flags);
+ }
+ info = varinfo_register_onclass(state->cls->info, ns.access, ns.name, $1);
+ } else {
+ slotinfo_t*i = registry_find(state->package, $1);
+ if(i) {
+ syntaxerror("package %s already contains '%s'", state->package, $1);
+ }
+ if(ns.name && ns.name[0]) {
+ syntaxerror("namespaces not allowed on package-level variables");
+ }
+ info = varinfo_register_global(ns.access, state->package, $1);
+ }
- /* slot name */
- multiname_t mname = {QNAME, &ns, 0, $1};
-
- trait_list_t**traits;
- code_t**code;
- if(!state->cls) {
- // global variable
- ns.name = state->package;
- traits = &global->init->traits;
- code = &global->init->method->body->code;
- } else if(flags&FLAG_STATIC) {
- // static variable
- traits = &state->cls->abc->static_traits;
- code = &state->cls->static_init->header;
- } else {
- // instance variable
- traits = &state->cls->abc->traits;
- code = &state->cls->init->header;
- }
-
- trait_t*t=0;
- if($2) {
- MULTINAME(m, $2);
- t = trait_new_member(traits, multiname_clone(&m), multiname_clone(&mname), 0);
- } else {
- t = trait_new_member(traits, 0, multiname_clone(&mname), 0);
- }
- info->slot = t->slot_id;
-
- /* initalization code (if needed) */
- code_t*c = 0;
- if($3.c && !is_pushundefined($3.c)) {
- c = abc_getlocal_0(c);
- c = code_append(c, $3.c);
- c = converttype(c, $3.t, $2);
- c = abc_setslot(c, t->slot_id);
+ info->type = $2;
+ info->flags = flags;
+
+ dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, info);
}
- *code = code_append(*code, c);
+ if(as3_pass == 2) {
+ varinfo_t*info = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
+
+ /* slot name */
+ multiname_t mname = {QNAME, &ns, 0, $1};
+
+ trait_list_t**traits;
+ code_t**code;
+ if(!state->cls) {
+ // global variable
+ ns.name = state->package;
+ traits = &global->init->traits;
+ code = &global->init->method->body->code;
+ } else if(flags&FLAG_STATIC) {
+ // static variable
+ traits = &state->cls->abc->static_traits;
+ code = &state->cls->static_init->header;
+ } else {
+ // instance variable
+ traits = &state->cls->abc->traits;
+ code = &state->cls->init->header;
+ }
+
+ trait_t*t=0;
+ if($2) {
+ MULTINAME(m, $2);
+ t = trait_new_member(traits, multiname_clone(&m), multiname_clone(&mname), 0);
+ } else {
+ t = trait_new_member(traits, 0, multiname_clone(&mname), 0);
+ }
+ info->slot = t->slot_id;
+
+ /* initalization code (if needed) */
+ code_t*c = 0;
+ if($3.c && !is_pushundefined($3.c)) {
+ c = abc_getlocal_0(c);
+ c = code_append(c, $3.c);
+ c = converttype(c, $3.t, $2);
+ c = abc_setslot(c, t->slot_id);
+ }
- if(slotstate_varconst==KW_CONST) {
- t->kind= TRAIT_CONST;
+ *code = code_append(*code, c);
+
+ if(slotstate_varconst==KW_CONST) {
+ t->kind= TRAIT_CONST;
+ }
}
$$=0;
/* ------------ constants -------------------------------------- */
-MAYBESTATICCONSTANT: {$$=0;}
-MAYBESTATICCONSTANT: '=' STATICCONSTANT {$$=$2;}
-
-STATICCONSTANT : T_BYTE {$$ = constant_new_int($1);}
-STATICCONSTANT : T_INT {$$ = constant_new_int($1);}
-STATICCONSTANT : T_UINT {$$ = constant_new_uint($1);}
-STATICCONSTANT : T_FLOAT {$$ = constant_new_float($1);}
-STATICCONSTANT : T_STRING {$$ = constant_new_string2($1.str,$1.len);free((char*)$1.str);}
-//STATICCONSTANT : T_NAMESPACE {$$ = constant_new_namespace($1);}
-STATICCONSTANT : "true" {$$ = constant_new_true($1);}
-STATICCONSTANT : "false" {$$ = constant_new_false($1);}
-STATICCONSTANT : "null" {$$ = constant_new_null($1);}
-STATICCONSTANT : T_IDENTIFIER {
+MAYBECONSTANT: {$$=0;}
+MAYBECONSTANT: '=' CONSTANT {$$=$2;}
+
+//CONSTANT : T_NAMESPACE {$$ = constant_new_namespace($1);}
+CONSTANT : T_INT {$$ = constant_new_int($1);}
+CONSTANT : T_UINT {
+ $$ = constant_new_uint($1);
+}
+CONSTANT : T_FLOAT {$$ = constant_new_float($1);}
+CONSTANT : T_STRING {$$ = constant_new_string2($1.str,$1.len);free((char*)$1.str);}
+CONSTANT : "true" {$$ = constant_new_true($1);}
+CONSTANT : "false" {$$ = constant_new_false($1);}
+CONSTANT : "null" {$$ = constant_new_null($1);}
+CONSTANT : "undefined" {$$ = constant_new_undefined($1);}
+CONSTANT : KW_NAN {$$ = constant_new_float(__builtin_nan(""));}
+
+/*
+CONSTANT : T_IDENTIFIER {
if(!strcmp($1, "NaN")) {
$$ = constant_new_float(__builtin_nan(""));
} else {
as3_warning("Couldn't evaluate constant value of %s", $1);
$$ = constant_new_null($1);
}
-}
+}*/
/* ------------ classes and interfaces (body, functions) ------- */
list_append($$.list, $1);
}
-PARAM: T_IDENTIFIER ':' TYPE MAYBESTATICCONSTANT {
+PARAM: T_IDENTIFIER ':' TYPE MAYBECONSTANT {
PASS12
$$ = rfx_calloc(sizeof(param_t));
$$->name=$1;
PASS2
$$->value = $4;
}
-PARAM: T_IDENTIFIER MAYBESTATICCONSTANT {
+PARAM: T_IDENTIFIER MAYBECONSTANT {
PASS12
$$ = rfx_calloc(sizeof(param_t));
$$->name=$1;
/* ------------- package + class ids --------------- */
-CLASS: T_IDENTIFIER {
- PASS1 static classinfo_t c;
- memset(&c, 0, sizeof(c));
- c.kind = INFOTYPE_CLASS;
- c.subtype = 255;
- c.name = $1;
- $$ = &c;
-
- /* let the compiler know that we might be looking for this soon */
- as3_schedule_class_noerror(state->package, $1);
+CLASS: X_IDENTIFIER {
+ PASS1 NEW(unresolvedinfo_t,c);
+ memset(c, 0, sizeof(*c));
+ c->kind = INFOTYPE_UNRESOLVED;
+ c->name = $1;
+ c->package = get_package_from_name($1);
+ if(!c->package) {
+ c->nsset = get_current_imports();
+ /* make the compiler look for this class in the current directory,
+ just in case: */
+ as3_schedule_class_noerror(state->package, $1);
+ }
+ $$ = (classinfo_t*)c;
PASS2
slotinfo_t*s = find_class($1);
if(!s) syntaxerror("Could not find class/method %s (current package: %s)\n", $1, state->package);
$$ = (classinfo_t*)s;
}
-PACKAGEANDCLASS : PACKAGE '.' T_IDENTIFIER {
- PASS1 static classinfo_t c;
- memset(&c, 0, sizeof(c));
- c.kind = INFOTYPE_CLASS;
- c.subtype = 255;
- c.package = $1;
- c.name = $3;
- $$ = &c;
+PACKAGEANDCLASS : PACKAGE '.' X_IDENTIFIER {
+ PASS1 NEW(unresolvedinfo_t,c);
+ memset(c, 0, sizeof(*c));
+ c->kind = INFOTYPE_UNRESOLVED;
+ c->package = $1;
+ c->name = $3;
+ $$ = (classinfo_t*)c;
PASS2
slotinfo_t*s = registry_find($1, $3);
if(!s) syntaxerror("Couldn't find class/method %s.%s\n", $1, $3);
/* ----------function calls, delete, constructor calls ------ */
-MAYBE_PARAM_VALUES : %prec prec_none {$$.cc=0;$$.len=0;}
+MAYBE_PARAM_VALUES : %prec prec_none {$$.cc=0;$$.number=0;}
MAYBE_PARAM_VALUES : '(' MAYBE_EXPRESSION_LIST ')' {$$=$2;}
-MAYBE_EXPRESSION_LIST : {$$.cc=0;$$.len=0;}
+MAYBE_EXPRESSION_LIST : {$$.cc=0;$$.number=0;}
MAYBE_EXPRESSION_LIST : EXPRESSION_LIST
MAYBE_EXPRESSION_LIST : EXPRESSION_LIST_AND_COMMA
-EXPRESSION_LIST : NONCOMMAEXPRESSION {$$.len=1;
+EXPRESSION_LIST : NONCOMMAEXPRESSION {$$.number=1;
$$.cc = $1.c;
}
EXPRESSION_LIST_AND_COMMA: EXPRESSION_LIST ',' {$$ = $1;}
EXPRESSION_LIST : EXPRESSION_LIST_AND_COMMA NONCOMMAEXPRESSION {
- $$.len= $1.len+1;
+ $$.number= $1.number+1;
$$.cc = code_append($1.cc, $2.c);
}
multiname_t*name = $$.c->data[0];$$.c->data[0]=0;
$$.c = code_cutlast($$.c);
$$.c = code_append($$.c, paramcode);
- $$.c = abc_constructprop2($$.c, name, $4.len);
+ $$.c = abc_constructprop2($$.c, name, $4.number);
multiname_destroy(name);
} else if($$.c->opcode == OPCODE_GETSLOT) {
int slot = (int)(ptroff_t)$$.c->data[0];
multiname_t*name = t->name;
$$.c = code_cutlast($$.c);
$$.c = code_append($$.c, paramcode);
- $$.c = abc_constructprop2($$.c, name, $4.len);
+ $$.c = abc_constructprop2($$.c, name, $4.number);
} else {
$$.c = code_append($$.c, paramcode);
- $$.c = abc_construct($$.c, $4.len);
+ $$.c = abc_construct($$.c, $4.number);
}
$$.t = TYPE_ANY;
multiname_t*name = $$.c->data[0];$$.c->data[0]=0;
$$.c = code_cutlast($$.c);
$$.c = code_append($$.c, paramcode);
- $$.c = abc_callproperty2($$.c, name, $3.len);
+ $$.c = abc_callproperty2($$.c, name, $3.number);
multiname_destroy(name);
} else if($$.c->opcode == OPCODE_GETSLOT && $$.c->prev->opcode != OPCODE_GETSCOPEOBJECT) {
int slot = (int)(ptroff_t)$$.c->data[0];
$$.c = code_cutlast($$.c);
$$.c = code_append($$.c, paramcode);
//$$.c = abc_callmethod($$.c, t->method, len); //#1051 illegal early access binding
- $$.c = abc_callproperty2($$.c, name, $3.len);
+ $$.c = abc_callproperty2($$.c, name, $3.number);
} else if($$.c->opcode == OPCODE_GETSUPER) {
multiname_t*name = $$.c->data[0];$$.c->data[0]=0;
$$.c = code_cutlast($$.c);
$$.c = code_append($$.c, paramcode);
- $$.c = abc_callsuper2($$.c, name, $3.len);
+ $$.c = abc_callsuper2($$.c, name, $3.number);
multiname_destroy(name);
} else {
$$.c = abc_getglobalscope($$.c);
$$.c = code_append($$.c, paramcode);
- $$.c = abc_call($$.c, $3.len);
+ $$.c = abc_call($$.c, $3.number);
}
if(TYPE_IS_FUNCTION($1.t) && $1.t->data) {
*/
state->method->has_super = 1;
- $$.c = abc_constructsuper($$.c, $3.len);
+ $$.c = abc_constructsuper($$.c, $3.number);
$$.c = abc_pushundefined($$.c);
$$.t = TYPE_ANY;
}
// ----------------------- expression evaluation -------------------------------------
E : INNERFUNCTION %prec prec_none {$$ = $1;}
-//V : CONSTANT {$$ = 0;}
-E : CONSTANT
-//V : VAR_READ %prec T_IDENTIFIER {$$ = 0;}
-E : VAR_READ %prec T_IDENTIFIER {$$ = $1;}
-//V : NEW {$$ = $1.c;}
-E : NEW {$$ = $1;}
-//V : DELETE {$$ = $1.c;}
-E : DELETE {$$ = $1;}
+E : VAR_READ %prec T_IDENTIFIER {$$ = $1;}
+E : NEW {$$ = $1;}
+E : DELETE {$$ = $1;}
E : FUNCTIONCALL
+E : CONSTANT {
+ node_t*n = mkconstnode($1);
+ $$ = node_read(n);
+}
+
E : T_REGEXP {
$$.c = 0;
namespace_t ns = {ACCESS_PACKAGE, ""};
$$.t = TYPE_REGEXP;
}
-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_pushstring2(0, &$1);free((char*)$1.str);
- $$.t = TYPE_STRING;
- }
-CONSTANT : "undefined" {$$.c = abc_pushundefined(0);
- $$.t = TYPE_ANY;
- }
-CONSTANT : "true" {$$.c = abc_pushtrue(0);
- $$.t = TYPE_BOOLEAN;
- }
-CONSTANT : "false" {$$.c = abc_pushfalse(0);
- $$.t = TYPE_BOOLEAN;
- }
-CONSTANT : "null" {$$.c = abc_pushnull(0);
- $$.t = TYPE_NULL;
- }
-
E : E '<' E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterequals($$.c);$$.c=abc_not($$.c);
$$.t = TYPE_BOOLEAN;
}
E : '(' EXPRESSION ')' {$$=$2;} //allow commas in here, too
E : '-' E {
- $$=$2;
+ $$.c = $2.c;
if(IS_INT($2.t)) {
$$.c=abc_negate_i($$.c);
$$.t = TYPE_INT;
E : '[' MAYBE_EXPRESSION_LIST ']' {
$$.c = code_new();
$$.c = code_append($$.c, $2.cc);
- $$.c = abc_newarray($$.c, $2.len);
+ $$.c = abc_newarray($$.c, $2.number);
$$.t = registry_getarrayclass();
}
-MAYBE_EXPRPAIR_LIST : {$$.cc=0;$$.len=0;}
+MAYBE_EXPRPAIR_LIST : {$$.cc=0;$$.number=0;}
MAYBE_EXPRPAIR_LIST : EXPRPAIR_LIST {$$=$1;}
EXPRPAIR_LIST : NONCOMMAEXPRESSION ':' NONCOMMAEXPRESSION {
$$.cc = 0;
$$.cc = code_append($$.cc, $1.c);
$$.cc = code_append($$.cc, $3.c);
- $$.len = 2;
+ $$.number = 2;
}
EXPRPAIR_LIST : EXPRPAIR_LIST ',' NONCOMMAEXPRESSION ':' NONCOMMAEXPRESSION {
$$.cc = $1.cc;
- $$.len = $1.len+2;
+ $$.number = $1.number+2;
$$.cc = code_append($$.cc, $3.c);
$$.cc = code_append($$.cc, $5.c);
}
E : "{ (dictionary)" MAYBE_EXPRPAIR_LIST '}' {
$$.c = code_new();
$$.c = code_append($$.c, $2.cc);
- $$.c = abc_newobject($$.c, $2.len/2);
+ $$.c = abc_newobject($$.c, $2.number/2);
$$.t = registry_getobjectclass();
}
c=abc_multiply(c);
}
c=converttype(c, join_types($1.t, $3.t, '*'), $1.t);
- $$.c = toreadwrite($1.c, c, 0, 0);
+ $$.c = toreadwrite($1.c, c, 0, 0, 1);
$$.t = $1.t;
}
E : E "%=" E {
code_t*c = abc_modulo($3.c);
c=converttype(c, join_types($1.t, $3.t, '%'), $1.t);
- $$.c = toreadwrite($1.c, c, 0, 0);
+ $$.c = toreadwrite($1.c, c, 0, 0, 1);
$$.t = $1.t;
}
E : E "<<=" E {
code_t*c = abc_lshift($3.c);
c=converttype(c, join_types($1.t, $3.t, '<'), $1.t);
- $$.c = toreadwrite($1.c, c, 0, 0);
+ $$.c = toreadwrite($1.c, c, 0, 0, 1);
$$.t = $1.t;
}
E : E ">>=" E {
code_t*c = abc_rshift($3.c);
c=converttype(c, join_types($1.t, $3.t, '>'), $1.t);
- $$.c = toreadwrite($1.c, c, 0, 0);
+ $$.c = toreadwrite($1.c, c, 0, 0, 1);
$$.t = $1.t;
}
E : E ">>>=" E {
code_t*c = abc_urshift($3.c);
c=converttype(c, join_types($1.t, $3.t, 'U'), $1.t);
- $$.c = toreadwrite($1.c, c, 0, 0);
+ $$.c = toreadwrite($1.c, c, 0, 0, 1);
$$.t = $1.t;
}
E : E "/=" E {
code_t*c = abc_divide($3.c);
c=converttype(c, join_types($1.t, $3.t, '/'), $1.t);
- $$.c = toreadwrite($1.c, c, 0, 0);
+ $$.c = toreadwrite($1.c, c, 0, 0, 1);
$$.t = $1.t;
}
E : E "|=" E {
code_t*c = abc_bitor($3.c);
c=converttype(c, TYPE_INT, $1.t);
- $$.c = toreadwrite($1.c, c, 0, 0);
+ $$.c = toreadwrite($1.c, c, 0, 0, 1);
$$.t = $1.t;
}
E : E "^=" E {
code_t*c = abc_bitxor($3.c);
c=converttype(c, TYPE_INT, $1.t);
- $$.c = toreadwrite($1.c, c, 0, 0);
+ $$.c = toreadwrite($1.c, c, 0, 0, 1);
$$.t = $1.t;
}
E : E "+=" E {
c=converttype(c, join_types($1.t, $3.t, '+'), $1.t);
}
- $$.c = toreadwrite($1.c, c, 0, 0);
+ $$.c = toreadwrite($1.c, c, 0, 0, 1);
$$.t = $1.t;
}
E : E "-=" E { code_t*c = $3.c;
c=converttype(c, join_types($1.t, $3.t, '-'), $1.t);
}
- $$.c = toreadwrite($1.c, c, 0, 0);
+ $$.c = toreadwrite($1.c, c, 0, 0, 1);
$$.t = $1.t;
}
E : E '=' E { code_t*c = 0;
c = code_append(c, $3.c);
c = converttype(c, $3.t, $1.t);
- $$.c = toreadwrite($1.c, c, 1, 0);
+ $$.c = toreadwrite($1.c, c, 1, 0, 1);
$$.t = $1.t;
}
type = TYPE_NUMBER;
}
c=converttype(c, type, $1.t);
- $$.c = toreadwrite($1.c, c, 0, 1);
+ $$.c = toreadwrite($1.c, c, 0, 1, 1);
$$.t = $1.t;
}
}
type = TYPE_NUMBER;
}
c=converttype(c, type, $1.t);
- $$.c = toreadwrite($1.c, c, 0, 1);
+ $$.c = toreadwrite($1.c, c, 0, 1, 1);
$$.t = $1.t;
}
type = TYPE_NUMBER;
}
c=converttype(c, type, $2.t);
- $$.c = toreadwrite($2.c, c, 0, 0);
+ $$.c = toreadwrite($2.c, c, 0, 0, 1);
$$.t = $2.t;
}
type = TYPE_NUMBER;
}
c=converttype(c, type, $2.t);
- $$.c = toreadwrite($2.c, c, 0, 0);
+ $$.c = toreadwrite($2.c, c, 0, 0, 1);
$$.t = $2.t;
}
classinfo_t*t = state->cls->info->superclass;
if(!t) t = TYPE_OBJECT;
- memberinfo_t*f = registry_findmember_nsset(t, state->active_namespaces, $3, 1);
+ memberinfo_t*f = findmember_nsset(t, $3, 1);
MEMBER_MULTINAME(m, f, $3);
$$.c = 0;
as3_warning("ignored .() operator");
}
-//VARIABLE : VARIABLE "::" '[' EXPRESSION ']' // qualified expression
-
+//E : E "::" '[' E ']' {
+// // qualified expression TODO
+// $$.c = abc_pushundefined(0);
+// $$.t = 0;
+// as3_warning("ignored ::[] operator");
+// }
E : E '.' T_IDENTIFIER {
is_static = 1;
}
if(t) {
- if(t->subtype==0xff) {
+ if(t->subtype==INFOTYPE_UNRESOLVED) {
syntaxerror("syntaxerror: trying to resolve property '%s' on incomplete object '%s'", $3, t->name);
}
- memberinfo_t*f = registry_findmember_nsset(t, state->active_namespaces, $3, 1);
+ memberinfo_t*f = findmember_nsset(t, $3, 1);
char noslot = 0;
if(f && !is_static != !(f->flags&FLAG_STATIC))
noslot=1;
if(f && f->slot && !noslot) {
$$.c = abc_getslot($$.c, f->slot);
} else {
+ if(!f) {
+ as3_warning("Access of undefined property '%s' in %s", $3, t->name);
+ }
+
MEMBER_MULTINAME(m, f, $3);
$$.c = abc_getproperty2($$.c, &m);
}
} else if($1.c && $1.c->opcode == OPCODE___PUSHPACKAGE__) {
string_t*package = $1.c->data[0];
char*package2 = concat3(package->str, ".", $3);
- if(dict_contains(state->import_toplevel_packages, package2)) {
+
+ slotinfo_t*a = registry_find(package->str, $3);
+ if(a) {
+ $$ = push_class(a);
+ } else if(dict_contains(state->import_toplevel_packages, package2) ||
+ registry_ispackage(package2)) {
$$.c = $1.c;
$$.c->data[0] = string_new4(package2);
$$.t = 0;
} else {
- slotinfo_t*a = registry_find(package->str, $3);
- if(!a)
- syntaxerror("couldn't resolve %s", package2);
- $$ = push_class(a);
+ syntaxerror("couldn't resolve %s", package2);
}
} else {
/* when resolving a property on an unknown type, we do know the
name of the property (and don't seem to need the package), but
we need to make avm2 try out all access modes */
+ as3_warning("Resolving %s on unknown type", $3);
multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, $3};
$$.c = abc_getproperty2($$.c, &m);
$$.c = abc_coerce_a($$.c);
unknown_variable($1);
}
- /* let the compiler know that it might check the current directory/package
+ /* let the compiler know that it might want to check the current directory/package
for this identifier- maybe there's a file $1.as defining $1. */
as3_schedule_class_noerror(state->package, $1);
PASS2
int i_am_static = (state->method && state->method->info)?(state->method->info->flags&FLAG_STATIC):FLAG_STATIC;
/* look at current class' members */
- if(state->cls && (f = registry_findmember_nsset(state->cls->info, state->active_namespaces, $1, 1)) &&
- (f->flags&FLAG_STATIC) >= i_am_static) {
+ if(!state->method->inner &&
+ state->cls &&
+ (f = findmember_nsset(state->cls->info, $1, 1)) &&
+ (f->flags&FLAG_STATIC) >= i_am_static)
+ {
// $1 is a function in this class
int var_is_static = (f->flags&FLAG_STATIC);
static properties of a class */
state->method->late_binding = 1;
$$.t = f->type;
- namespace_t ns = {f->access, ""};
+ namespace_t ns = {f->access, f->package};
multiname_t m = {QNAME, &ns, 0, $1};
$$.c = abc_findpropstrict2($$.c, &m);
$$.c = abc_getproperty2($$.c, &m);
$$.c = abc_getslot($$.c, f->slot);
break;
} else {
- namespace_t ns = {f->access, ""};
+ namespace_t ns = {f->access, f->package};
multiname_t m = {QNAME, &ns, 0, $1};
$$.c = abc_getlocal_0($$.c);
$$.c = abc_getproperty2($$.c, &m);
}
/* look through package prefixes */
- if(dict_contains(state->import_toplevel_packages, $1)) {
+ if(dict_contains(state->import_toplevel_packages, $1) ||
+ registry_ispackage($1)) {
$$.c = abc___pushpackage__($$.c, $1);
$$.t = 0;
break;
NAMESPACE_ID : "namespace" T_IDENTIFIER {
PASS12
- tokenizer_register_namespace($2);
- $$=$2;
+ NEW(namespace_decl_t,n);
+ n->name = $2;
+ n->url = $2;
+ $$=n;
}
-
-NAMESPACE_DECLARATION : MAYBE_MODIFIERS NAMESPACE_ID {
- $$=0;
+NAMESPACE_ID : "namespace" T_IDENTIFIER '=' T_IDENTIFIER {
+ PASS12
+ NEW(namespace_decl_t,n);
+ n->name = $2;
+ n->url = $4;
+ $$=n;
}
-NAMESPACE_DECLARATION : MAYBE_MODIFIERS NAMESPACE_ID '=' T_IDENTIFIER {
- $$=0;
+NAMESPACE_ID : "namespace" T_IDENTIFIER '=' T_STRING {
+ PASS12
+ NEW(namespace_decl_t,n);
+ n->name = $2;
+ n->url = $4.str;
+ $$=n;
}
-NAMESPACE_DECLARATION : MAYBE_MODIFIERS NAMESPACE_ID '=' T_STRING {
+NAMESPACE_DECLARATION : MAYBE_MODIFIERS NAMESPACE_ID {
+ PASS12
+ trie_put(active_namespaces, $2->name, (void*)$2->url);
+
+ namespace_t access = modifiers2access(&$1);
+ varinfo_t* var = varinfo_register_global(access.access, state->package, $2->name);
+ var->type = TYPE_NAMESPACE;
+ namespace_t ns;
+ ns.access = ACCESS_NAMESPACE;
+ ns.name = $2->url;
+ var->value = constant_new_namespace(&ns);
+
$$=0;
}
+
+%code {
+ void add_active_url(const char*url)
+ {
+ NEW(namespace_t,n);
+ n->name = url;
+ list_append(state->active_namespace_urls, n);
+ }
+};
+
USE_NAMESPACE : "use" "namespace" CLASS_SPEC {
PASS12
- tokenizer_register_namespace($3->name);
+ const char*url = $3->name;
+
+ varinfo_t*s = (varinfo_t*)$3;
+ if(s->kind == INFOTYPE_UNRESOLVED) {
+ s = (varinfo_t*)registry_resolve((slotinfo_t*)s);
+ if(!s)
+ syntaxerror("Couldn't resolve namespace %s", $3->name);
+ }
+
+ if(!s || s->kind != INFOTYPE_SLOT)
+ syntaxerror("%s.%s is not a public namespace (%d)", $3->package, $3->name, s?s->kind:-1);
+ if(!s->value || !NS_TYPE(s->value->type))
+ syntaxerror("%s.%s is not a namespace", $3->package, $3->name);
+ url = s->value->ns->name;
+
+ trie_put(active_namespaces, $3->name, (void*)url);
+ add_active_url(url);
$$=0;
}