+/* parser.lex
+
+ Routines for compiling Flash2 AVM2 ABC Actionscript
+
+ Extension module for the rfxswf library.
+ Part of the swftools package.
+
+ Copyright (c) 2008 Matthias Kramm <kramm@quiss.org>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
%{
#include <stdlib.h>
#include <stdio.h>
#include "files.h"
#include "tokenizer.h"
#include "registry.h"
+#include "code.h"
+#include "opcodes.h"
+
%}
//%glr-parser
%union tokenunion {
tokenptr_t token;
- multiname_t*multiname;
- multiname_list_t*multiname_list;
+
+ classinfo_t*classinfo;
+ classinfo_list_t*classinfo_list;
+
+ int number_int;
+ unsigned int number_uint;
+ double number_float;
+ code_t*code;
+ typedcode_t value;
+ typedcode_list_t*value_list;
+ param_t* param;
+ params_t params;
+ char*string;
+ constant_t*constant;
}
%token<token> T_IDENTIFIER
-%token<token> T_STRING
+%token<string> T_STRING
%token<token> T_REGEXP
-%token<token> T_IMPLEMENTS
-%token<token> T_NAMESPACE
-%token<token> T_PACKAGE
-%token<token> T_PROTECTED
-%token<token> T_PUBLIC
-%token<token> T_PRIVATE
-%token<token> T_UINT
-%token<token> T_USE
-%token<token> T_INTERNAL
-%token<token> T_INT
-%token<token> T_NEW
-%token<token> T_NATIVE
-%token<token> T_FUNCTION
-%token<token> T_FOR
-%token<token> T_CLASS
-%token<token> T_CONST
-%token<token> T_SET
-%token<token> T_STATIC
-%token<token> T_IMPORT
-%token<token> T_INTERFACE
-%token<token> T_NUMBER
-%token<token> T_NULL
-%token<token> T_FALSE
-%token<token> T_TRUE
-%token<token> T_BOOLEAN
-%token<token> T_VAR
-%token<token> T_DYNAMIC
-%token<token> T_OVERRIDE
-%token<token> T_FINAL
-%token<token> T_GET
-%token<token> T_EXTENDS
%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<token> KW_IMPLEMENTS
+%token<token> KW_NAMESPACE "namespace"
+%token<token> KW_PACKAGE "package"
+%token<token> KW_PROTECTED
+%token<token> KW_PUBLIC
+%token<token> KW_PRIVATE
+%token<token> KW_USE "use"
+%token<token> KW_INTERNAL
+%token<token> KW_NEW "new"
+%token<token> KW_NATIVE
+%token<token> KW_FUNCTION "function"
+%token<token> KW_FOR "for"
+%token<token> KW_CLASS "class"
+%token<token> KW_CONST "const"
+%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 "null"
+%token<token> KW_VAR "var"
+%token<token> KW_DYNAMIC
+%token<token> KW_OVERRIDE
+%token<token> KW_FINAL
+%token<token> KW_GET "get"
+%token<token> KW_EXTENDS
+%token<token> KW_FALSE "false"
+%token<token> KW_TRUE "true"
+%token<token> KW_BOOLEAN "Boolean"
+%token<token> KW_UINT "uint"
+%token<token> KW_INT "int"
+%token<token> KW_WHILE "while"
+%token<token> KW_NUMBER "Number"
+%token<token> KW_STRING "String"
+%token<token> KW_IF "if"
+%token<token> KW_ELSE "else"
+%token<token> KW_BREAK "break"
+%token<token> KW_IS "is"
+%token<token> KW_AS "as"
+
%token<token> T_EQEQ "=="
+%token<token> T_EQEQEQ "==="
+%token<token> T_NE "!="
%token<token> T_LE "<="
%token<token> T_GE ">="
%token<token> T_DIVBY "/="
%token<token> T_MODBY "%="
+%token<token> T_MULBY "*="
%token<token> T_PLUSBY "+="
%token<token> T_MINUSBY "-="
%token<token> T_SHRBY ">>="
%token<token> T_MINUSMINUS "--"
%token<token> T_PLUSPLUS "++"
%token<token> T_DOTDOT ".."
+%token<token> T_DOTDOTDOT "..."
%token<token> T_SHL "<<"
%token<token> T_USHR ">>>"
%token<token> T_SHR ">>"
-%token<token> T_IS "is"
-%token<token> T_AS "as"
%token<token> T_SEMICOLON ';'
%token<token> T_STAR '*'
%token<token> T_DOT '.'
-// precendence: from low to high
+%type <token> X_IDENTIFIER VARCONST
+%type <code> CODE
+%type <code> CODEPIECE
+%type <code> CODEBLOCK MAYBECODE
+%type <token> PACKAGE_DECLARATION
+%type <token> FUNCTION_DECLARATION
+%type <code> VARIABLE_DECLARATION ONE_VARIABLE VARIABLE_LIST
+%type <token> CLASS_DECLARATION
+%type <token> NAMESPACE_DECLARATION
+%type <token> INTERFACE_DECLARATION
+%type <code> VOIDEXPRESSION
+%type <value> EXPRESSION NONCOMMAEXPRESSION
+%type <value> MAYBEEXPRESSION
+%type <value> E
+%type <value> CONSTANT
+%type <code> FOR IF WHILE MAYBEELSE BREAK RETURN
+%type <token> USE_NAMESPACE
+%type <code> FOR_INIT
+%type <token> IMPORT
+%type <classinfo> MAYBETYPE
+%type <token> GETSET
+%type <param> PARAM
+%type <params> PARAM_LIST
+%type <params> MAYBE_PARAM_LIST
+%type <token> MODIFIERS
+%type <token> MODIFIER_LIST
+%type <constant> STATICCONSTANT MAYBESTATICCONSTANT
+%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> T_IDENTIFIER
+%type <token> MODIFIER
+%type <token> PACKAGE
+%type <value> FUNCTIONCALL
+%type <value_list> MAYBE_EXPRESSION_LIST EXPRESSION_LIST MAYBE_PARAM_VALUES
+
+// 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
%right '?' ':'
-%nonassoc '='
-%nonassoc "/=" "%="
-%nonassoc "+=" "-="
-%nonassoc ">>="
-%nonassoc "<<="
-%nonassoc ">>>="
-%nonassoc "||"
-%nonassoc "&&"
+%right '=' "/=" "%=" "*=" "+=" "-=" ">>=" "<<=" ">>>="
+%left "||"
+%left "&&"
%nonassoc '|'
%nonassoc '^'
%nonassoc '&'
-%nonassoc "!=" "==" "<=" '<' ">=" '>' // TODO: support "a < b < c" syntax?
+%nonassoc "!=" "==" "===" "<=" '<' ">=" '>' // TODO: support "a < b < c" syntax?
%nonassoc "is"
+%left prec_belowminus
%left '-'
%left '+'
%left "<<"
%left '['
%nonassoc "as"
%left '.' ".." "::"
+%nonassoc T_IDENTIFIER
+%left below_semicolon
+%left ';'
+%nonassoc "else"
%left '('
-%type <token> CODE
-%type <token> CODEPIECE
-%type <token> PACKAGE_DECLARATION
-%type <token> FUNCTION_DECLARATION
-%type <token> VARIABLE_DECLARATION
-%type <token> CLASS_DECLARATION
-%type <token> NAMESPACE_DECLARATION
-%type <token> INTERFACE_DECLARATION
-%type <token> EXPRESSION
-%type <token> E
-%type <token> CONSTANT
-%type <token> FOR
-%type <token> USE
-%type <token> ASSIGNMENT
-%type <token> IMPORT
-%type <multiname> MAYBETYPE
-%type <token> PACKAGESPEC
-%type <token> GETSET
-%type <token> PARAM
-%type <token> PARAMS
-%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 <token> MULTILEVELIDENTIFIER
-%type <multiname> TYPE
-%type <token> VAR
-%type <token> VARIABLE
-%type <token> NEW
-%type <token> FUNCTIONCALL
-%type <token> X_IDENTIFIER
-%type <token> MODIFIER
-%type <token> PACKAGE
+// 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
%{
t->text[l1+l2+l3] = 0;
return t;
}
+static char* concat3str(const char* t1, const char* t2, const char* t3)
+{
+ int l1 = strlen(t1);
+ int l2 = strlen(t2);
+ int l3 = strlen(t3);
+ char*text = malloc(l1+l2+l3+1);
+ memcpy(text , t1, l1);
+ memcpy(text+l1, t2, l2);
+ memcpy(text+l1+l2, t3, l3);
+ text[l1+l2+l3] = 0;
+ return text;
+}
typedef struct _import {
- char*path;
+ char*package;
} import_t;
DECLARE_LIST(import);
char*package;
char*function;
- import_list_t*imports;
+ /* code that needs to be executed at the start of
+ a method (like initializing local registers) */
+ code_t*initcode;
+
+ import_list_t*wildcard_imports;
+ dict_t*imports;
+ char has_own_imports;
/* class data */
- char*classname;
+ classinfo_t*clsinfo;
abc_class_t*cls;
+ code_t*cls_init;
+ code_t*cls_static_init;
+
+ /* method data */
+ memberinfo_t*minfo;
+ abc_method_body_t*m;
+ dict_t*vars;
+ char late_binding;
} state_t;
+typedef struct _global {
+ int variable_count;
+} global_t;
+
+static global_t*global = 0;
static state_t* state = 0;
DECLARE_LIST(state);
-static state_list_t*state_stack=0;
+#define MULTINAME(m,x) multiname_t m;namespace_t m##_ns;registry_fill_multiname(&m, &m##_ns, x);
-void initialize_state()
-{
- NEW(state_t, s);
- NEW(state_list_t, sl);
- state_stack = sl;
- state = sl->state = s;
+/* warning: list length of namespace set is undefined */
+#define MULTINAME_LATE(m, access, package) \
+ namespace_t m##_ns = {access, package}; \
+ namespace_set_t m##_nsset; \
+ namespace_list_t m##_l;m##_l.next = 0; \
+ m##_nsset.namespaces = &m##_l; \
+ m##_nsset = m##_nsset; \
+ m##_l.namespace = &m##_ns; \
+ multiname_t m = {MULTINAMEL, 0, &m##_nsset, 0};
- state->file = abc_file_new();
- state->level = 0;
+static state_list_t*state_stack=0;
- state->init = abc_initscript(state->file, 0, 0);
- abc_method_body_t*m = state->init->method->body;
- __ getlocal_0(m);
- __ pushscope(m);
-}
-void* finalize_state()
+static void init_globals()
{
- if(state->level) {
- syntaxerror("unexpected end of file");
- }
- abc_method_body_t*m = state->init->method->body;
- //__ popscope(m);
- __ returnvoid(m);
- return state->file;
+ global = rfx_calloc(sizeof(global_t));
}
static void new_state()
{
NEW(state_t, s);
NEW(state_list_t, sl);
- memcpy(s, state, sizeof(state_t)); //shallow copy
+
+ state_t*oldstate = state;
+ if(state)
+ memcpy(s, state, sizeof(state_t)); //shallow copy
sl->next = state_stack;
sl->state = s;
+ if(!s->imports) {
+ s->imports = dict_new();
+ }
state_stack = sl;
state = s;
state->level++;
+ state->vars = dict_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()
+{
+ init_globals();
+ new_state();
+
+ state->file = abc_file_new();
+ state->file->flags &= ~ABCFILE_LAZY;
+
+ state->init = abc_initscript(state->file, 0, 0);
+ code_t*c = state->init->method->body->code;
+
+ c = abc_getlocal_0(c);
+ c = abc_pushscope(c);
+
+ /* 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);*/
+
+ c = abc_findpropstrict(c, "[package]::trace");
+ c = abc_pushstring(c, "[entering global init function]");
+ c = abc_callpropvoid(c, "[package]::trace", 1);
+
+ state->init->method->body->code = c;
+}
+void* finalize_state()
+{
+ if(state->level!=1) {
+ syntaxerror("unexpected end of file");
+ }
+ abc_method_body_t*m = state->init->method->body;
+ //__ popscope(m);
+
+ __ findpropstrict(m, "[package]::trace");
+ __ pushstring(m, "[leaving global init function]");
+ __ callpropvoid(m, "[package]::trace", 1);
+ __ returnvoid(m);
+ return state->file;
+}
+
static void startpackage(token_t*t)
{
}
new_state();
char*name = t?t->text:"";
- printf("entering package \"%s\"\n", name);
+ /*printf("entering package \"%s\"\n", name);*/
state->package = name;
}
static void endpackage()
{
- printf("leaving package \"%s\"\n", state->package);
+ /*printf("leaving package \"%s\"\n", state->package);*/
old_state();
}
-static void startclass(token_t*modifiers, token_t*name, multiname_t*extends, multiname_list_t*implements)
+char*globalclass=0;
+static void startclass(token_t*modifiers, token_t*name, classinfo_t*extends, classinfo_list_t*implements, char interface)
{
if(state->cls) {
syntaxerror("inner classes now allowed");
}
new_state();
- state->classname = name->text;
- printf("entering class %s\n", name->text);
+ char*classname = name->text;
+
token_list_t*t=0;
+ classinfo_list_t*mlist=0;
+ /*printf("entering class %s\n", name->text);
printf(" modifiers: ");for(t=modifiers->tokens;t;t=t->next) printf("%s ", t->token->text);printf("\n");
- printf(" extends: %s\n", multiname_tostring(extends));
-
- multiname_list_t*mlist=0;
+ if(extends)
+ printf(" extends: %s.%s\n", extends->package, extends->name);
printf(" implements (%d): ", list_length(implements));
for(mlist=implements;mlist;mlist=mlist->next) {
- printf("%s ", multiname_tostring(mlist->multiname));
+ printf("%s ", mlist->classinfo?mlist->classinfo->name:0);
}
printf("\n");
+ */
char public=0,internal=0,final=0,sealed=1;
for(t=modifiers->tokens;t;t=t->next) {
- if(t->token->type == T_INTERNAL) {
+ if(t->token->type == KW_INTERNAL) {
/* the programmer is being explicit-
being internal is the default anyway */
internal = 1;
- } else if(t->token->type == T_PUBLIC) {
+ } else if(t->token->type == KW_PUBLIC) {
public = 1;
- } else if(t->token->type == T_FINAL) {
+ } else if(t->token->type == KW_FINAL) {
final = 1;
} else {
syntaxerror("modifier \"%s\" not supported in class declaration", t->token->text);
syntaxerror("public and internal not supported at the same time.");
/* create the class name, together with the proper attributes */
- multiname_t* classname = 0;
- if(!public && !state->package)
- classname = multiname_new(namespace_new_private(current_filename), state->classname);
- else if(!public && state->package)
- classname = multiname_new(namespace_new_packageinternal(state->package), state->classname);
- else if(state->package)
- classname = multiname_new(namespace_new_package(state->package), state->classname);
- else
+ int access=0;
+ char*package=0;
+
+ if(!public && !state->package) {
+ access = ACCESS_PRIVATE; package = current_filename;
+ } else if(!public && state->package) {
+ access = ACCESS_PACKAGEINTERNAL; package = state->package;
+ } else if(state->package) {
+ access = ACCESS_PACKAGE; package = state->package;
+ } else {
syntaxerror("public classes only allowed inside a package");
+ }
+
+ if(registry_findclass(package, classname)) {
+ syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, classname);
+ }
+
+ state->clsinfo = classinfo_register(access, package, classname);
+
+ MULTINAME(classname2,state->clsinfo);
+
+ multiname_t*extends2 = sig2mname(extends);
- state->cls = abc_class_new(state->file, classname, extends);
+ /*if(extends) {
+ state->cls_init = abc_getlocal_0(state->cls_init);
+ state->cls_init = abc_constructsuper(state->cls_init, 0);
+ }*/
+
+ state->cls = abc_class_new(state->file, &classname2, extends2);
if(final) abc_class_final(state->cls);
if(sealed) abc_class_sealed(state->cls);
+ if(interface) abc_class_interface(state->cls);
for(mlist=implements;mlist;mlist=mlist->next) {
- abc_class_add_interface(state->cls, mlist->multiname);
+ MULTINAME(m, mlist->classinfo);
+ abc_class_add_interface(state->cls, &m);
}
/* now write the construction code for this class */
- int slotindex = abc_initscript_addClassTrait(state->init, classname, state->cls);
+ int slotindex = abc_initscript_addClassTrait(state->init, &classname2, state->cls);
abc_method_body_t*m = state->init->method->body;
__ getglobalscope(m);
- multiname_t*s = extends;
+ classinfo_t*s = extends;
+
int count=0;
+
while(s) {
- //TODO: invert
//TODO: take a look at the current scope stack, maybe
// we can re-use something
- __ getlex2(m, s);
- __ pushscope(m);
- s = registry_getsuperclass(s);
- count++;
+ s = s->superclass;
+ if(!s)
+ break;
+
+ multiname_t*s2 = sig2mname(s);
+ __ getlex2(m, s2);
+ multiname_destroy(s2);
+
+ __ pushscope(m); count++;
+ m->code = m->code->prev->prev; // invert
}
+ /* 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, extends);
+ 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 && classinfo_equals(registry_getMovieClip(),extends)) {
+ if(state->package && state->package[0]) {
+ globalclass = concat3str(state->package, ".", classname);
+ } else {
+ globalclass = strdup(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;
+ if(state->cls_init) {
+ if(!state->cls->constructor) {
+ abc_method_body_t*m = abc_class_constructor(state->cls, 0, 0);
+ m->code = code_append(m->code, state->cls_init);
+ m->code = abc_returnvoid(m->code);
+ } else {
+ code_t*c = state->cls->constructor->body->code;
+ c = code_append(state->cls_init, c);
+ state->cls->constructor->body->code = c;
+
+ }
}
-}
-static void startfunction(token_t*ns, token_t*mod, token_t*getset, token_t*name,
- token_t*params, multiname_t*type)
-{
- token_list_t*t;
- new_state();
- state->function = 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();
-
- abc_method_body_t* m=0;
- if(!strcmp(state->classname,name->text)) {
- m = abc_class_constructor(state->cls, type, 0);
- } else {
- m = abc_class_method(state->cls, type, name->text, 0);
+ if(state->cls_static_init) {
+ if(!state->cls->static_constructor) {
+ abc_method_body_t*m = abc_class_staticconstructor(state->cls, 0, 0);
+ m->code = state->cls_static_init;
+ } else {
+ state->cls->static_constructor->body->code =
+ code_append(state->cls_static_init, state->cls->static_constructor->body->code);
+ }
}
-}
-static void endfunction()
-{
- printf("leaving function %s\n", state->function);
old_state();
}
-static int newvariable(token_t*mod, token_t*varconst, token_t*name, multiname_t*type)
-{
- token_list_t*t;
- printf("defining new variable %s\n", name->text);
- printf(" mod: ");for(t=mod->tokens;t;t=t->next) printf("%s ", t->token->text);printf("\n");
- printf(" access: ");printf("%s\n", varconst->text);
- printf(" type: ");printf("%s\n", multiname_tostring(type));
-}
+
static token_t* empty_token()
{
NEW(token_t,t);
list->text[l1+l2+l3]=0;
}
-%}
+typedef struct _variable {
+ int index;
+ classinfo_t*type;
+} variable_t;
-%%
+static int find_variable(char*name, classinfo_t**m)
+{
+ state_list_t* s = state_stack;
+ while(s) {
+ variable_t*v = dict_lookup(s->state->vars, name);
+ if(v) {
+ if(m) {
+ *m = v->type;
+ }
+ return v->index;
+ }
+ s = s->next;
+ }
+ 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 dict_lookup(state->vars, name)!=0;
+}
+static int new_variable(char*name, classinfo_t*type)
+{
+ NEW(variable_t, v);
+ v->index = global->variable_count;
+ v->type = type;
+ dict_put(state->vars, name, v);
+ return global->variable_count++;
+}
+#define TEMPVARNAME "__as3_temp__"
+static int gettempvar()
+{
+ int i = find_variable(TEMPVARNAME, 0);
+ if(i<0) {
+ return new_variable(TEMPVARNAME, 0);
+ } else {
+ return i;
+ }
+}
-PROGRAM: MAYBECODE
+code_t* killvars(code_t*c)
+{
+ int t;
+ for(t=0;t<state->vars->hashsize;t++) {
+ dictentry_t*e =state->vars->slots[t];
+ while(e) {
+ variable_t*v = (variable_t*)e->data;
+ //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, v->index);
+ e = e->next;
+ }
+ }
+ return c;
+}
-MAYBECODE: CODE
-MAYBECODE:
-CODE: CODE CODEPIECE {$$=$1;}
-CODE: CODEPIECE {$$=empty_token();}
+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)
+ if(TYPE_IS_NUMBER(t)) {
+ xassert(c->type == CONSTANT_FLOAT
+ || c->type == CONSTANT_INT
+ || c->type == CONSTANT_UINT);
+ } else if(TYPE_IS_UINT(t)) {
+ xassert(c->type == CONSTANT_UINT ||
+ (c->type == CONSTANT_INT && c->i>0));
+ } else if(TYPE_IS_INT(t)) {
+ xassert(c->type == CONSTANT_INT);
+ } else if(TYPE_IS_BOOLEAN(t)) {
+ xassert(c->type == CONSTANT_TRUE
+ || c->type == CONSTANT_FALSE);
+ }
+}
-CODEPIECE: ';'
-CODEPIECE: VARIABLE_DECLARATION {$$=$1;}
-CODEPIECE: PACKAGE_DECLARATION
-CODEPIECE: IMPORT
-CODEPIECE: NAMESPACE_DECLARATION
-CODEPIECE: CLASS_DECLARATION
-CODEPIECE: INTERFACE_DECLARATION
-CODEPIECE: FUNCTION_DECLARATION
-CODEPIECE: EXPRESSION
-CODEPIECE: FOR
-CODEPIECE: USE
-CODEPIECE: ASSIGNMENT
+static void startfunction(token_t*ns, token_t*mod, token_t*getset, token_t*name,
+ params_t*params, classinfo_t*type)
+{
+ token_list_t*t;
+ new_state();
+ global->variable_count = 0;
+ state->function = name->text;
+
+ if(state->m) {
+ syntaxerror("not able to start another method scope");
+ }
-PACKAGE_DECLARATION : T_PACKAGE MULTILEVELIDENTIFIER '{' {startpackage($2)} MAYBECODE '}' {endpackage()}
-PACKAGE_DECLARATION : T_PACKAGE '{' {startpackage(0)} MAYBECODE '}' {endpackage()}
+ multiname_t*type2 = sig2mname(type);
+ if(!strcmp(state->clsinfo->name,name->text)) {
+ state->m = abc_class_constructor(state->cls, type2, 0);
+ } else {
+ state->minfo = memberinfo_register(state->clsinfo, name->text, MEMBER_METHOD);
+ state->minfo->return_type = type;
+ state->m = abc_class_method(state->cls, type2, name->text, 0);
+ // getslot on a member slot only returns "undefined", so no need
+ // to actually store these
+ //state->minfo->slot = state->m->method->trait->slot_id;
+ }
+ if(getset->type == KW_GET) {
+ state->m->method->trait->kind = TRAIT_GETTER;
+ }
+ if(getset->type == KW_SET) {
+ state->m->method->trait->kind = TRAIT_SETTER;
+ }
+ if(params->varargs) {
+ state->m->method->flags |= METHOD_NEED_REST;
+ }
-IMPORT : T_IMPORT PACKAGESPEC {addimport($2);}
+ char opt=0;
+ param_list_t*p=0;
+ for(p=params->list;p;p=p->next) {
+ if(params->varargs && !p->next) {
+ break; //varargs: omit last parameter in function signature
+ }
+ multiname_t*m = sig2mname(p->param->type);
+ list_append(state->m->method->parameters, m);
+ if(p->param->value) {
+ check_constant_against_type(p->param->type, p->param->value);
+ opt=1;list_append(state->m->method->optional_parameters, p->param->value);
+ } else if(opt) {
+ syntaxerror("non-optional parameter not allowed after optional parameters");
+ }
+ }
-TYPE : PACKAGEANDCLASS {$$=$1;}
- | '*' {$$=registry_getanytype();}
- | T_STRING {$$=registry_getstringclass();}
- | T_INT {$$=registry_getintclass();}
- | T_UINT {$$=registry_getuintclass();}
- | T_BOOLEAN {$$=registry_getbooleanclass();}
- | T_NUMBER {$$=registry_getnumberclass();}
+ /* state->vars is initialized by state_new */
+ if(new_variable("this", state->clsinfo)!=0) syntaxerror("Internal error");
-MAYBETYPE: ':' TYPE {$$=$2;}
-MAYBETYPE: {$$=0;}
+ for(p=params->list;p;p=p->next) {
+ new_variable(p->param->name, p->param->type);
+ }
+}
+static void endfunction(code_t*body)
+{
+ code_t*c = 0;
+ if(state->late_binding) {
+ c = abc_getlocal_0(c);
+ c = abc_pushscope(c);
+ }
+ c = code_append(c, state->initcode);
+ c = code_append(c, body);
-//FUNCTION_HEADER: NAMESPACE MODIFIERS T_FUNCTION GETSET T_IDENTIFIER '(' PARAMS ')'
-FUNCTION_HEADER: MODIFIERS T_FUNCTION GETSET T_IDENTIFIER '(' PARAMS ')'
- MAYBETYPE
-FUNCTION_DECLARATION: MODIFIERS T_FUNCTION GETSET T_IDENTIFIER '(' PARAMS ')'
- MAYBETYPE '{' {startfunction(0,$1,$3,$4,$6,$8)} MAYBECODE '}' {endfunction()}
+ /* append return if necessary */
+ if(!c || c->opcode != OPCODE_RETURNVOID &&
+ c->opcode != OPCODE_RETURNVALUE)
+ c = abc_returnvoid(c);
+
+ if(state->m->code) syntaxerror("internal error");
+ state->m->code = c;
+ old_state();
+}
-NAMESPACE_DECLARATION : MODIFIERS T_NAMESPACE T_IDENTIFIER
-NAMESPACE_DECLARATION : MODIFIERS T_NAMESPACE T_IDENTIFIER '=' T_IDENTIFIER
-NAMESPACE_DECLARATION : MODIFIERS T_NAMESPACE T_IDENTIFIER '=' T_STRING
-//NAMESPACE : {$$=empty_token();}
-//NAMESPACE : T_IDENTIFIER {$$=$1};
-CONSTANT : T_NUMBER
-CONSTANT : T_STRING
-CONSTANT : T_TRUE
-CONSTANT : T_FALSE
-CONSTANT : T_NULL
+char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
+{
+ return 1; // FIXME
+}
-VAR : T_CONST | T_VAR
+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;
+ }
+}
-// type annotation
-// TODO: NAMESPACE
+classinfo_t*join_types(classinfo_t*type1, classinfo_t*type2, char op)
+{
+ if(!type1 || !type2)
+ return registry_getanytype();
+ if(TYPE_IS_ANY(type1) || TYPE_IS_ANY(type2))
+ return registry_getanytype();
+ if(type1 == type2)
+ return type1;
+ return registry_getanytype();
+}
+code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
+{
+ 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;
+}
-VARIABLE_DECLARATION : MODIFIERS VAR T_IDENTIFIER MAYBETYPE {
- int i = newvariable($1,$2,$3,$4);
+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;
}
-VARIABLE_DECLARATION : MODIFIERS VAR T_IDENTIFIER MAYBETYPE '=' EXPRESSION {
- int i = newvariable($1,$2,$3,$4);
- //setvariable(i,$6);
+
+char is_pushundefined(code_t*c)
+{
+ return (c && !c->prev && !c->next && c->opcode == OPCODE_PUSHUNDEFINED);
}
-EXPRESSION : E
+void parserassert(int b)
+{
+ if(!b) syntaxerror("internal error: assertion failed");
+}
-E : CONSTANT
-E : VARIABLE
-E : NEW
-E : T_REGEXP
-E : FUNCTIONCALL
-E : E '<' E
-E : E '>' E
-E : E "<=" E
-E : E ">=" E
-E : E "==" E
-E : E '+' E
-E : E '-' E
-E : E '/' E
-E : E '%' E
-E : E '*' E
-E : E "++"
-E : E "--"
-E : E "as" TYPE
-E : E "is" TYPE
+static code_t* toreadwrite(code_t*in, code_t*middlepart, char justassign, char readbefore)
+{
+ /* converts this:
+
+ [prefix code] [read instruction]
+
+ to this:
+
+ [prefix code] ([dup]) [read instruction] [middlepart] [setvar] [write instruction] [getvar]
+ */
+
+ if(in && in->opcode == OPCODE_COERCE_A) {
+ in = code_cutlast(in);
+ }
+ if(in->next)
+ syntaxerror("internal error");
+
+ /* chop off read instruction */
+ code_t*prefix = in;
+ code_t*r = in;
+ if(r->prev) {
+ prefix = r->prev;r->prev = 0;
+ prefix->next=0;
+ } else {
+ prefix = 0;
+ }
+
+ char use_temp_var = readbefore;
+
+ /* generate the write instruction, and maybe append a dup to the prefix code */
+ code_t* write = abc_nop(0);
+ if(r->opcode == OPCODE_GETPROPERTY) {
+ write->opcode = OPCODE_SETPROPERTY;
+ multiname_t*m = (multiname_t*)r->data[0];
+ write->data[0] = multiname_clone(m);
+ if(m->type != QNAME)
+ syntaxerror("illegal lvalue: can't assign a value to this expression (not a qname)");
+ if(!justassign) {
+ use_temp_var = 1;
+ prefix = abc_dup(prefix); // we need the object, too
+ }
+ } else if(r->opcode == OPCODE_GETSLOT) {
+ write->opcode = OPCODE_SETSLOT;
+ write->data[0] = r->data[0];
+ if(!justassign) {
+ use_temp_var = 1;
+ prefix = abc_dup(prefix); // we need the object, too
+ }
+ } else if(r->opcode == OPCODE_GETLOCAL) {
+ write->opcode = OPCODE_SETLOCAL;
+ write->data[0] = r->data[0];
+ } else if(r->opcode == OPCODE_GETLOCAL_0) {
+ write->opcode = OPCODE_SETLOCAL_0;
+ } else if(r->opcode == OPCODE_GETLOCAL_1) {
+ write->opcode = OPCODE_SETLOCAL_1;
+ } else if(r->opcode == OPCODE_GETLOCAL_2) {
+ write->opcode = OPCODE_SETLOCAL_2;
+ } else if(r->opcode == OPCODE_GETLOCAL_3) {
+ write->opcode = OPCODE_SETLOCAL_3;
+ } else {
+ code_dump(r, 0, 0, "", stdout);
+ syntaxerror("illegal lvalue: can't assign a value to this expression");
+ }
+ code_t* c = 0;
+
+ int temp = -1;
+ if(!justassign) {
+ if(use_temp_var) {
+ /* with getproperty/getslot, we have to be extra careful not
+ to execute the read code twice, as it might have side-effects
+ (e.g. if the property is in fact a setter/getter combination)
+
+ So read the value, modify it, and write it again,
+ using prefix only once and making sure (by using a temporary
+ register) that the return value is what we just wrote */
+ temp = gettempvar();
+ c = code_append(c, prefix);
+ c = code_append(c, r);
+ if(readbefore) {
+ c = abc_dup(c);
+ c = abc_setlocal(c, temp);
+ }
+ c = code_append(c, middlepart);
+ if(!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);
+ } 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);
+ c = code_append(c, r);
+ c = code_append(c, middlepart);
+ c = code_append(c, write);
+ c = code_append(c, r2);
+ }
+ } else {
+ /* even smaller version: overwrite the value without reading
+ it out first */
+ if(prefix) {
+ c = code_append(c, prefix);
+ c = abc_dup(c);
+ }
+ c = code_append(c, middlepart);
+ c = code_append(c, write);
+ c = code_append(c, r);
+ }
-//E : '(' E ')' // conflicts with function calls: "a=f(c++);"<->"a=f;(c++)"
-//E : '-' E // conflicts with non-assignment statements: "a=3-1;"<->"a=3;-1"
+ return c;
+}
-NEW : T_NEW T_IDENTIFIER
- | T_NEW T_IDENTIFIER '(' ')'
- | T_NEW T_IDENTIFIER '(' EXPRESSION_LIST ')'
-FUNCTIONCALL : VARIABLE '(' EXPRESSION_LIST ')'
-FUNCTIONCALL : VARIABLE '(' ')'
+%}
-EXPRESSION_LIST : EXPRESSION
-EXPRESSION_LIST : EXPRESSION_LIST ',' EXPRESSION
-VARIABLE : T_IDENTIFIER
-VARIABLE : VARIABLE '.' T_IDENTIFIER
-VARIABLE : VARIABLE ".." T_IDENTIFIER // descendants
-VARIABLE : VARIABLE "::" VARIABLE // namespace declaration
-VARIABLE : VARIABLE "::" '[' EXPRESSION ']' // qualified expression
-VARIABLE : VARIABLE '[' EXPRESSION ']' // unqualified expression
+%%
-ASSIGNMENT : VARIABLE '=' EXPRESSION
-NEW_ASSIGNMENT : T_VAR VARIABLE MAYBETYPE '=' EXPRESSION
+/* ------------ code blocks / statements ---------------- */
-FOR : T_FOR '(' NEW_ASSIGNMENT ';' EXPRESSION ';' EXPRESSION ')' '{' MAYBECODE '}'
-FOR : T_FOR '(' ASSIGNMENT ';' EXPRESSION ';' EXPRESSION ')' '{' MAYBECODE '}'
+PROGRAM: MAYBECODE
-USE : T_USE T_NAMESPACE T_IDENTIFIER
+MAYBECODE: CODE {$$=$1;}
+MAYBECODE: {$$=code_new();}
+
+CODE: CODE CODEPIECE {$$=code_append($1,$2);}
+CODE: CODEPIECE {$$=$1;}
+
+CODEPIECE: PACKAGE_DECLARATION {$$=code_new();/*enters a scope*/}
+CODEPIECE: CLASS_DECLARATION {$$=code_new();/*enters a scope*/}
+CODEPIECE: FUNCTION_DECLARATION {$$=code_new();/*enters a scope*/}
+CODEPIECE: INTERFACE_DECLARATION {$$=code_new();}
+CODEPIECE: IMPORT {$$=code_new();/*adds imports to current scope*/}
+CODEPIECE: ';' {$$=code_new();}
+CODEPIECE: VARIABLE_DECLARATION {$$=$1}
+CODEPIECE: VOIDEXPRESSION {$$=$1}
+CODEPIECE: FOR {$$=$1}
+CODEPIECE: WHILE {$$=$1}
+CODEPIECE: BREAK {$$=$1}
+CODEPIECE: RETURN {$$=$1}
+CODEPIECE: IF {$$=$1}
+CODEPIECE: NAMESPACE_DECLARATION {/*TODO*/$$=code_new();}
+CODEPIECE: USE_NAMESPACE {/*TODO*/$$=code_new();}
+
+CODEBLOCK : '{' MAYBECODE '}' {$$=$2;}
+CODEBLOCK : CODEPIECE ';' {$$=$1;}
+CODEBLOCK : CODEPIECE %prec below_semicolon {$$=$1;}
+
+/* ------------ variables --------------------------- */
+
+MAYBEEXPRESSION : '=' NONCOMMAEXPRESSION {$$=$2;}
+ | {$$.c=abc_pushundefined(0);
+ $$.t=TYPE_ANY;
+ }
+
+VAR : "const" | "var"
+VARIABLE_DECLARATION : VAR VARIABLE_LIST {$$=$2;}
+
+VARIABLE_LIST: ONE_VARIABLE {$$ = $1;}
+VARIABLE_LIST: VARIABLE_LIST ',' ONE_VARIABLE {$$ = code_append($1, $3);}
+
+ONE_VARIABLE: {} T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION
+{
+ if(variable_exists($2->text))
+ syntaxerror("Variable %s already defined", $2->text);
+
+ if(!is_subtype_of($4.t, $3)) {
+ syntaxerror("Can't convert %s to %s", $4.t->name,
+ $3->name);
+ }
-// keywords which also may be identifiers
-X_IDENTIFIER : T_IDENTIFIER | T_PACKAGE
+ int index = new_variable($2->text, $3);
+
+ if($3) {
+ if($4.c->prev || $4.c->opcode != OPCODE_PUSHUNDEFINED) {
+ $$ = $4.c;
+ $$ = converttype($$, $4.t, $3);
+ $$ = abc_setlocal($$, index);
+ } else {
+ $$ = defaultvalue(0, $3);
+ $$ = abc_setlocal($$, index);
+ }
-PACKAGESPEC : PACKAGESPEC '.' PACKAGESPEC {if($1->text[0]=='*') syntaxerror("wildcard in the middle of path");
- $$ = concat3($1,$2,$3);}
-PACKAGESPEC : X_IDENTIFIER {$$=$1;}
-PACKAGESPEC : '*' {$$=$1;}
+ /* if this is a typed variable:
+ push default value for type on stack */
+ if($3) {
+ state->initcode = defaultvalue(state->initcode, $3);
+ state->initcode = abc_setlocal(state->initcode, index);
+ }
+ } else {
+ if($4.c->prev || $4.c->opcode != OPCODE_PUSHUNDEFINED) {
+ $$ = $4.c;
+ $$ = abc_coerce_a($$);
+ $$ = abc_setlocal($$, index);
+ } else {
+ $$ = code_new();
+ }
+ }
+
+ /* that's the default for a local register, anyway
+ else {
+ state->initcode = abc_pushundefined(state->initcode);
+ state->initcode = abc_setlocal(state->initcode, index);
+ }*/
+ printf("variable %s -> %d (%s)\n", $2->text, index, $4.t?$4.t->name:"");
+}
-GETSET : T_GET {$$=$1;}
- | T_SET {$$=$1;}
- | {$$=empty_token();}
+/* ------------ control flow ------------------------- */
-CLASS_DECLARATION : MODIFIERS T_CLASS T_IDENTIFIER EXTENDS IMPLEMENTS_LIST '{' {startclass($1,$3,$4,$5);} MAYBE_DECLARATION_LIST '}' {endclass();}
-INTERFACE_DECLARATION : MODIFIERS T_INTERFACE T_IDENTIFIER EXTENDS_LIST '{' MAYBE_IDECLARATION_LIST '}'
+MAYBEELSE: %prec prec_none {$$ = code_new();}
+MAYBEELSE: "else" CODEBLOCK {$$=$2;}
+//MAYBEELSE: ';' "else" CODEBLOCK {$$=$3;}
-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;}
+IF : "if" '(' {new_state();} EXPRESSION ')' CODEBLOCK MAYBEELSE {
+ $$ = state->initcode;state->initcode=0;
+
+ $$ = code_append($$, $4.c);
+ code_t*myjmp,*myif = $$ = abc_iffalse($$, 0);
+
+ $$ = code_append($$, $6);
+ if($7) {
+ myjmp = $$ = abc_jump($$, 0);
+ }
+ myif->branch = $$ = abc_label($$);
+ if($7) {
+ $$ = code_append($$, $7);
+ myjmp->branch = $$ = abc_label($$);
+ }
+
+ $$ = killvars($$);old_state();
+}
+
+FOR_INIT : {$$=code_new();}
+FOR_INIT : VARIABLE_DECLARATION
+FOR_INIT : VOIDEXPRESSION
+
+FOR : "for" '(' {new_state();} FOR_INIT ';' EXPRESSION ';' VOIDEXPRESSION ')' CODEBLOCK {
+ $$ = state->initcode;state->initcode=0;
+
+ $$ = code_append($$, $4);
+ code_t*loopstart = $$ = abc_label($$);
+ $$ = code_append($$, $6.c);
+ code_t*myif = $$ = abc_iffalse($$, 0);
+ $$ = code_append($$, $10);
+ $$ = code_append($$, $8);
+ $$ = abc_jump($$, loopstart);
+ code_t*out = $$ = abc_label($$);
+ breakjumpsto($$, out);
+ myif->branch = out;
+
+ $$ = killvars($$);old_state();
+}
+
+WHILE : "while" '(' {new_state();} EXPRESSION ')' CODEBLOCK {
+ $$ = state->initcode;state->initcode=0;
+
+ code_t*myjmp = $$ = abc_jump($$, 0);
+ code_t*loopstart = $$ = abc_label($$);
+ $$ = code_append($$, $6);
+ myjmp->branch = $$ = abc_label($$);
+ $$ = code_append($$, $4.c);
+ $$ = abc_iftrue($$, loopstart);
+ code_t*out = $$ = abc_label($$);
+ breakjumpsto($$, out);
+
+ $$ = killvars($$);old_state();
+}
+
+BREAK : "break" {
+ $$ = abc___break__(0);
+}
+
+/* ------------ packages and imports ---------------- */
+
+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" 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 (header) -------------- */
MODIFIERS : {$$=empty_token();}
MODIFIERS : MODIFIER_LIST {$$=$1}
MODIFIER_LIST : MODIFIER MODIFIER_LIST {extend($2,$1);$$=$2;}
MODIFIER_LIST : MODIFIER {$$=empty_token();extend($$,$1);}
-MODIFIER : T_PUBLIC | T_PRIVATE | T_PROTECTED | T_STATIC | T_DYNAMIC | T_FINAL | T_OVERRIDE | T_NATIVE | T_INTERNAL
-
-DECLARATION : VARIABLE_DECLARATION
-DECLARATION : FUNCTION_DECLARATION
-
-IDECLARATION : VARIABLE_DECLARATION
-IDECLARATION : FUNCTION_DECLARATION
-
-IMPLEMENTS_LIST : {$$=list_new();}
-IMPLEMENTS_LIST : T_IMPLEMENTS PACKAGEANDCLASS_LIST {$$=$2;}
+MODIFIER : KW_PUBLIC | KW_PRIVATE | KW_PROTECTED | KW_STATIC | KW_DYNAMIC | KW_FINAL | KW_OVERRIDE | KW_NATIVE | KW_INTERNAL
EXTENDS : {$$=registry_getobjectclass();}
-EXTENDS : T_EXTENDS PACKAGEANDCLASS {$$=$2;}
+EXTENDS : KW_EXTENDS QNAME {$$=$2;}
EXTENDS_LIST : {$$=list_new();}
-EXTENDS_LIST : T_EXTENDS PACKAGEANDCLASS_LIST {$$=$2;}
+EXTENDS_LIST : KW_EXTENDS QNAME_LIST {$$=$2;}
-//IDENTIFIER_LIST : T_IDENTIFIER ',' IDENTIFIER_LIST {extend($3,$1);$$=$3;}
-//IDENTIFIER_LIST : T_IDENTIFIER {$$=empty_token();extend($$,$1);}
+IMPLEMENTS_LIST : {$$=list_new();}
+IMPLEMENTS_LIST : KW_IMPLEMENTS QNAME_LIST {$$=$2;}
-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);}
+CLASS_DECLARATION : MODIFIERS "class" T_IDENTIFIER
+ EXTENDS IMPLEMENTS_LIST
+ '{' {startclass($1,$3,$4,$5, 0);}
+ MAYBE_DECLARATION_LIST
+ '}' {endclass();}
-MULTILEVELIDENTIFIER : MULTILEVELIDENTIFIER '.' X_IDENTIFIER {$$=$1;extend_s($$, ".", $3)}
-MULTILEVELIDENTIFIER : T_IDENTIFIER {$$=$1;extend($$,$1)};
+INTERFACE_DECLARATION : MODIFIERS "interface" T_IDENTIFIER
+ EXTENDS_LIST
+ '{' {startclass($1,$3,0,$4,1);}
+ MAYBE_IDECLARATION_LIST
+ '}' {endclass();}
-PACKAGEANDCLASS_LIST : PACKAGEANDCLASS {$$=list_new();list_append($$, $1);}
-PACKAGEANDCLASS_LIST : PACKAGEANDCLASS_LIST ',' PACKAGEANDCLASS {$$=$1;list_append($$,$3);}
+/* ------------ classes and interfaces (body) -------------- */
MAYBE_DECLARATION_LIST :
MAYBE_DECLARATION_LIST : DECLARATION_LIST
DECLARATION_LIST : DECLARATION
DECLARATION_LIST : DECLARATION_LIST DECLARATION
+DECLARATION : ';'
+DECLARATION : SLOT_DECLARATION
+DECLARATION : FUNCTION_DECLARATION
+
+/* ------------ classes and interfaces (body, slots ) ------- */
+
+VARCONST: "var" | "const"
+SLOT_DECLARATION: MODIFIERS VARCONST T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION {
+
+ memberinfo_t* info = memberinfo_register(state->clsinfo, $3->text, MEMBER_SLOT);
+ info->type = $4;
+
+ trait_t*t=0;
+ if($4) {
+ MULTINAME(m, $4);
+ t=abc_class_slot(state->cls, $3->text, &m);
+ } else {
+ t=abc_class_slot(state->cls, $3->text, 0);
+ }
+ if($2->type==KW_CONST) {
+ t->kind= TRAIT_CONST;
+ }
+ info->slot = t->slot_id;
+ if($5.c && !is_pushundefined($5.c)) {
+ code_t*c = 0;
+ c = abc_getlocal_0(c);
+ c = code_append(c, $5.c);
+ c = converttype(c, $5.t, $4);
+ c = abc_setslot(c, t->slot_id);
+ //c = abc_setproperty(c, $3->text);
+ state->cls_init = code_append(state->cls_init, c);
+ }
+}
+
+/* ------------ 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_string($1);}
+//STATICCONSTANT : T_NAMESPACE {$$ = constant_new_namespace($1);}
+STATICCONSTANT : KW_TRUE {$$ = constant_new_true($1);}
+STATICCONSTANT : KW_FALSE {$$ = constant_new_false($1);}
+STATICCONSTANT : KW_NULL {$$ = constant_new_null($1);}
+
+/* ------------ classes and interfaces (body, functions) ------- */
+
+// non-vararg version
+MAYBE_PARAM_LIST: {
+ memset(&$$,0,sizeof($$));
+}
+MAYBE_PARAM_LIST: PARAM_LIST {
+ $$=$1;
+}
+
+// vararg version
+MAYBE_PARAM_LIST: "..." PARAM {
+ memset(&$$,0,sizeof($$));
+ $$.varargs=1;
+ list_append($$.list, $2);
+}
+MAYBE_PARAM_LIST: PARAM_LIST ',' "..." PARAM {
+ $$ =$1;
+ $$.varargs=1;
+ list_append($$.list, $4);
+}
+
+// non empty
+PARAM_LIST: PARAM_LIST ',' PARAM {
+ $$ = $1;
+ list_append($$.list, $3);
+}
+PARAM_LIST: PARAM {
+ memset(&$$,0,sizeof($$));
+ list_append($$.list, $1);
+}
+PARAM: T_IDENTIFIER ':' TYPE MAYBESTATICCONSTANT {
+ $$ = malloc(sizeof(param_t));
+ $$->name=$1->text;
+ $$->type = $3;
+ $$->value = $4;
+}
+PARAM: T_IDENTIFIER MAYBESTATICCONSTANT {
+ $$ = malloc(sizeof(param_t));
+ $$->name=$1->text;$$->type = TYPE_ANY;
+}
+
+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");
+ endfunction($11);
+}
+
+/* ------------- 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 : NONCOMMAEXPRESSION {$$=list_new();
+ typedcode_t*t = malloc(sizeof(typedcode_t));
+ *t = $1;
+ list_append($$, t);}
+EXPRESSION_LIST : EXPRESSION_LIST ',' NONCOMMAEXPRESSION {$$=$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();
+
+ /* TODO: why do we have to *find* our own classes? */
+ $$.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_COERCE_A) {
+ $$.c = code_cutlast($$.c);
+ }
+
+ $$.t = TYPE_ANY;
+ multiname_t*name = 0;
+ if($$.c->opcode == OPCODE_GETPROPERTY) {
+ name = multiname_clone($$.c->data[0]);
+ $$.c = code_cutlast($$.c);
+ $$.c = code_append($$.c, paramcode);
+ $$.c = abc_callproperty2($$.c, name, len);
+ } else if($$.c->opcode == OPCODE_GETSLOT) {
+ int slot = (int)(ptroff_t)$$.c->data[0];
+ trait_t*t = abc_class_find_slotid(state->cls,slot);//FIXME
+ if(t->kind!=TRAIT_METHOD) {
+ //flash allows to assign closures to members.
+ //syntaxerror("not a function");
+ }
+ name = t->name;
+ $$.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, len);
+ } else {
+ $$.c = abc_getlocal_0($$.c);
+ $$.c = code_append($$.c, paramcode);
+ $$.c = abc_call($$.c, len);
+ }
+
+ memberinfo_t*f = 0;
+
+ if(TYPE_IS_FUNCTION($1.t) &&
+ (f = registry_findmember($1.t, "call"))) {
+ $$.t = f->return_type;
+ } else {
+ $$.c = abc_coerce_a($$.c);
+ $$.t = TYPE_ANY;
+ }
+}
+
+RETURN: "return" %prec prec_none {
+ $$ = abc_returnvoid(0);
+}
+RETURN: "return" EXPRESSION {
+ $$ = $2.c;
+ $$ = abc_returnvalue($$);
+}
+// ----------------------- expression types -------------------------------------
+
+NONCOMMAEXPRESSION : E %prec prec_belowminus {$$=$1;}
+EXPRESSION : E %prec prec_belowminus {$$ = $1;}
+EXPRESSION : EXPRESSION ',' E %prec prec_belowminus {
+ $$.c = $1.c;
+ $$.c = cut_last_push($$.c);
+ $$.c = code_append($$.c,$3.c);
+ $$.t = $3.t;
+}
+VOIDEXPRESSION : EXPRESSION %prec prec_belowminus {$$=cut_last_push($1.c);}
+
+// ----------------------- expression evaluation -------------------------------------
+
+E : CONSTANT
+E : VAR_READ %prec T_IDENTIFIER {$$ = $1;}
+E : NEW {$$ = $1;}
+E : T_REGEXP {$$.c = abc_pushundefined(0); /* FIXME */
+ $$.t = TYPE_ANY;
+ }
+E : FUNCTIONCALL
+E : E '<' E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterequals($$.c);$$.c=abc_not($$.c);
+ $$.t = TYPE_BOOLEAN;
+ }
+E : E '>' E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterthan($$.c);
+ $$.t = TYPE_BOOLEAN;
+ }
+E : E "<=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterthan($$.c);$$.c=abc_not($$.c);
+ $$.t = TYPE_BOOLEAN;
+ }
+E : E ">=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterequals($$.c);
+ $$.t = TYPE_BOOLEAN;
+ }
+E : E "==" E {$$.c = code_append($1.c,$3.c);$$.c = abc_equals($$.c);
+ $$.t = TYPE_BOOLEAN;
+ }
+E : E "===" E {$$.c = code_append($1.c,$3.c);$$.c = abc_strictequals($$.c);
+ $$.t = TYPE_BOOLEAN;
+ }
+E : E "!=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_equals($$.c);$$.c = abc_not($$.c);
+ $$.t = TYPE_BOOLEAN;
+ }
+
+E : E "||" E {$$.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 = cut_last_push($$.c);
+ $$.c = code_append($$.c,$3.c);
+ $$.c = converttype($$.c, $3.t, $$.t);
+ code_t*label = $$.c = abc_label($$.c);
+ jmp->branch = label;
+ }
+E : E "&&" E {
+ $$.t = join_types($1.t, $3.t, 'A');
+ /*printf("%08x:\n",$1.t);
+ code_dump($1.c, 0, 0, "", stdout);
+ printf("%08x:\n",$3.t);
+ code_dump($3.c, 0, 0, "", stdout);
+ printf("joining %08x and %08x to %08x\n", $1.t, $3.t, $$.t);*/
+ $$.c = $1.c;
+ $$.c = converttype($$.c, $1.t, $$.t);
+ $$.c = abc_dup($$.c);
+ code_t*jmp = $$.c = abc_iffalse($$.c, 0);
+ $$.c = cut_last_push($$.c);
+ $$.c = code_append($$.c,$3.c);
+ $$.c = converttype($$.c, $3.t, $$.t);
+ code_t*label = $$.c = abc_label($$.c);
+ jmp->branch = label;
+ }
+
+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 '%' E {$$.c = code_append($1.c,$3.c);$$.c = abc_modulo($$.c);$$.c=abc_coerce_a($$.c);
+ $$.t = join_types($1.t, $3.t, '%');
+ }
+E : E '*' E {$$.c = code_append($1.c,$3.c);$$.c = abc_multiply($$.c);$$.c=abc_coerce_a($$.c);
+ $$.t = join_types($1.t, $3.t, '*');
+ }
+
+E : E "as" E
+E : E "is" E
+E : '(' E ')' {$$=$2;}
+E : '-' E {$$=$2;}
+
+E : E '[' E ']' {
+ $$.c = $1.c;
+ $$.c = code_append($$.c, $3.c);
+
+ MULTINAME_LATE(m, $1.t?$1.t->access:ACCESS_PACKAGE, "");
+ $$.c = abc_getproperty2($$.c, &m);
+}
+
+E : E "*=" E {
+ code_t*c = $3.c;
+ if(TYPE_IS_INT($3.t) || TYPE_IS_UINT($3.t)) {
+ c=abc_multiply_i(c);
+ } else {
+ c=abc_multiply(c);
+ }
+ c=converttype(c, join_types($1.t, $3.t, '*'), $1.t);
+ $$.c = toreadwrite($1.c, c, 0, 0);
+ $$.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);
+ $$.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);
+ $$.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);
+ $$.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);
+ $$.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);
+ $$.t = $1.t;
+ }
+E : E "+=" E {
+ code_t*c = $3.c;
+ if(TYPE_IS_INT($3.t) || TYPE_IS_UINT($3.t)) {
+ c=abc_add_i(c);
+ } else {
+ c=abc_add(c);
+ }
+ c=converttype(c, join_types($1.t, $3.t, '+'), $1.t);
+
+ $$.c = toreadwrite($1.c, c, 0, 0);
+ $$.t = $1.t;
+ }
+E : E "-=" E { code_t*c = $3.c;
+ if(TYPE_IS_INT($3.t) || TYPE_IS_UINT($3.t)) {
+ c=abc_subtract_i(c);
+ } else {
+ c=abc_subtract(c);
+ }
+ c=converttype(c, join_types($1.t, $3.t, '-'), $1.t);
+
+ $$.c = toreadwrite($1.c, c, 0, 0);
+ $$.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);
+ $$.t = $1.t;
+ }
+
+// TODO: use inclocal where appropriate
+E : E "++" { code_t*c = 0;
+ classinfo_t*type = $1.t;
+ 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.t);
+ $$.c = toreadwrite($1.c, c, 0, 1);
+ $$.t = $1.t;
+ }
+E : E "--" { code_t*c = 0;
+ classinfo_t*type = $1.t;
+ 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.t);
+ $$.c = toreadwrite($1.c, c, 0, 1);
+ $$.t = $1.t;
+ }
+
+E : "++" E { code_t*c = 0;
+ classinfo_t*type = $2.t;
+ 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, $2.t);
+ $$.c = toreadwrite($2.c, c, 0, 0);
+ $$.t = $2.t;
+ }
+
+E : "--" E { code_t*c = 0;
+ classinfo_t*type = $2.t;
+ 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, $2.t);
+ $$.c = toreadwrite($2.c, c, 0, 0);
+ $$.t = $2.t;
+ }
+
+E : E '.' T_IDENTIFIER
+ {$$.c = $1.c;
+ if($$.t) {
+ memberinfo_t*f = registry_findmember($$.t, $3->text);
+
+ if(f && f->slot) {
+ $$.c = abc_getslot($$.c, f->slot);
+ } else {
+ namespace_t ns = {$$.t->access, ""}; // needs to be "", not $$.t->package
+ multiname_t m = {QNAME, &ns, 0, $3->text};
+ $$.c = abc_getproperty2($$.c, &m);
+ }
+ /* determine type */
+ if(f) {
+ if(f->kind == MEMBER_METHOD) {
+ $$.t = TYPE_FUNCTION(f);
+ } else {
+ $$.t = f->type;
+ }
+ } else {
+ $$.c = abc_coerce_a($$.c);
+ $$.t = registry_getanytype();
+ }
+ } else {
+ namespace_t ns = {ACCESS_PACKAGE, ""};
+ multiname_t m = {QNAME, &ns, 0, $3->text};
+ $$.c = abc_getproperty2($$.c, &m);
+ $$.c = abc_coerce_a($$.c);
+ $$.t = registry_getanytype();
+ }
+ }
+
+VAR_READ : T_IDENTIFIER {
+ $$.t = 0;
+ $$.c = 0;
+ int i;
+ memberinfo_t*f = 0;
+ if((i = find_variable($1->text, &$$.t)) >= 0) {
+ // $1 is a local variable
+ $$.c = abc_getlocal($$.c, i);
+ } else if((f = registry_findmember(state->clsinfo, $1->text))) {
+ // $1 is a function in this class
+ if(f->kind == MEMBER_METHOD) {
+ $$.t = TYPE_FUNCTION(f);
+ } else {
+ $$.t = f->type;
+ }
+ if(f->slot>0) {
+ $$.c = abc_getlocal_0($$.c);
+ $$.c = abc_getslot($$.c, f->slot);
+ } else {
+ namespace_t ns = {state->clsinfo->access, ""};
+ multiname_t m = {QNAME, &ns, 0, $1->text};
+ $$.c = abc_getlocal_0($$.c);
+ $$.c = abc_getproperty2($$.c, &m);
+ }
+ } else {
+ // let the avm2 resolve $1
+ if(strcmp($1->text,"trace"))
+ warning("Couldn't resolve %s, doing late binding", $1->text);
+ state->late_binding = 1;
+
+ $$.t = 0;
+ $$.c = abc_findpropstrict($$.c, $1->text);
+ $$.c = abc_getproperty($$.c, $1->text);
+ }
+}
+
+
+// ------------------------------------------------------------------------------
+
+
+TYPE : QNAME {$$=$1;}
+ | '*' {$$=registry_getanytype();}
+ | "String" {$$=registry_getstringclass();}
+ | "int" {$$=registry_getintclass();}
+ | "uint" {$$=registry_getuintclass();}
+ | "Boolean" {$$=registry_getbooleanclass();}
+ | "Number" {$$=registry_getnumberclass();}
+
+MAYBETYPE: ':' TYPE {$$=$2;}
+MAYBETYPE: {$$=0;}
+
+//FUNCTION_HEADER: NAMESPACE MODIFIERS T_FUNCTION GETSET T_IDENTIFIER '(' PARAMS ')'
+FUNCTION_HEADER: MODIFIERS "function" GETSET T_IDENTIFIER '(' MAYBE_PARAM_LIST ')'
+ MAYBETYPE
+
+NAMESPACE_DECLARATION : MODIFIERS KW_NAMESPACE T_IDENTIFIER
+NAMESPACE_DECLARATION : MODIFIERS KW_NAMESPACE T_IDENTIFIER '=' T_IDENTIFIER
+NAMESPACE_DECLARATION : MODIFIERS KW_NAMESPACE T_IDENTIFIER '=' T_STRING
+
+//NAMESPACE : {$$=empty_token();}
+//NAMESPACE : T_IDENTIFIER {$$=$1};
+
+CONSTANT : T_BYTE {$$.c = abc_pushbyte(0, $1);
+ //MULTINAME(m, registry_getintclass());
+ //$$.c = abc_coerce2($$.c, &m); // FIXME
+ $$.t = TYPE_INT;
+ }
+CONSTANT : T_SHORT {$$.c = abc_pushshort(0, $1);
+ $$.t = TYPE_INT;
+ }
+CONSTANT : T_INT {$$.c = abc_pushint(0, $1);
+ $$.t = TYPE_INT;
+ }
+CONSTANT : T_UINT {$$.c = abc_pushuint(0, $1);
+ $$.t = TYPE_UINT;
+ }
+CONSTANT : T_FLOAT {$$.c = abc_pushdouble(0, $1);
+ $$.t = TYPE_FLOAT;
+ }
+CONSTANT : T_STRING {$$.c = abc_pushstring(0, $1);
+ $$.t = TYPE_STRING;
+ }
+CONSTANT : KW_TRUE {$$.c = abc_pushtrue(0);
+ $$.t = TYPE_BOOLEAN;
+ }
+CONSTANT : KW_FALSE {$$.c = abc_pushfalse(0);
+ $$.t = TYPE_BOOLEAN;
+ }
+CONSTANT : KW_NULL {$$.c = abc_pushnull(0);
+ $$.t = TYPE_NULL;
+ }
+
+USE_NAMESPACE : "use" "namespace" T_IDENTIFIER
+
+
+//VARIABLE : T_IDENTIFIER
+//VARIABLE : VARIABLE '.' T_IDENTIFIER
+//VARIABLE : VARIABLE ".." T_IDENTIFIER // descendants
+//VARIABLE : VARIABLE "::" VARIABLE // namespace declaration
+//VARIABLE : VARIABLE "::" '[' EXPRESSION ']' // qualified expression
+//VARIABLE : VARIABLE '[' EXPRESSION ']' // unqualified expression
+
+GETSET : "get" {$$=$1;}
+ | "set" {$$=$1;}
+ | {$$=empty_token();}
+
+IDECLARATION : VARIABLE_DECLARATION
+IDECLARATION : FUNCTION_DECLARATION
+
+//IDENTIFIER_LIST : T_IDENTIFIER ',' IDENTIFIER_LIST {extend($3,$1);$$=$3;}
+//IDENTIFIER_LIST : T_IDENTIFIER {$$=empty_token();extend($$,$1);}
+
+QNAME_LIST : QNAME {$$=list_new();list_append($$, $1);}
+QNAME_LIST : QNAME_LIST ',' QNAME {$$=$1;list_append($$,$3);}
+
MAYBE_IDECLARATION_LIST :
MAYBE_IDECLARATION_LIST : IDECLARATION_LIST
git.asbjorn.biz / swftools.git / blobdiff