3 Routines for compiling Flash2 AVM2 ABC Actionscript
5 Extension module for the rfxswf library.
6 Part of the swftools package.
8 Copyright (c) 2008 Matthias Kramm <kramm@quiss.org>
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
30 #include "tokenizer.h"
45 enum yytokentype token;
48 classinfo_t*classinfo;
49 classinfo_list_t*classinfo_list;
52 unsigned int number_uint;
56 //typedcode_list_t*value_list;
57 codeandnumber_t value_list;
63 for_start_t for_start;
64 abc_exception_t *exception;
67 abc_exception_list_t *l;
73 %token<id> T_IDENTIFIER T_NAMESPACE
75 %token<regexp> T_REGEXP
77 %token<number_int> T_INT
78 %token<number_uint> T_UINT
79 %token<number_uint> T_BYTE
80 %token<number_uint> T_SHORT
81 %token<number_float> T_FLOAT
83 %token<id> T_FOR "for"
84 %token<id> T_WHILE "while"
86 %token<id> T_SWITCH "switch"
88 %token<token> KW_IMPLEMENTS "implements"
89 %token<token> KW_NAMESPACE "namespace"
90 %token<token> KW_PACKAGE "package"
91 %token<token> KW_PROTECTED "protected"
92 %token<token> KW_PUBLIC "public"
93 %token<token> KW_PRIVATE "private"
94 %token<token> KW_USE "use"
95 %token<token> KW_INTERNAL "internal"
96 %token<token> KW_NEW "new"
97 %token<token> KW_NATIVE "native"
98 %token<token> KW_FUNCTION "function"
99 %token<token> KW_FINALLY "finally"
100 %token<token> KW_UNDEFINED "undefined"
101 %token<token> KW_CONTINUE "continue"
102 %token<token> KW_CLASS "class"
103 %token<token> KW_CONST "const"
104 %token<token> KW_CATCH "catch"
105 %token<token> KW_CASE "case"
106 %token<token> KW_SET "set"
107 %token<token> KW_VOID "void"
108 %token<token> KW_THROW "throw"
109 %token<token> KW_STATIC "static"
110 %token<token> KW_WITH "with"
111 %token<token> KW_INSTANCEOF "instanceof"
112 %token<token> KW_IMPORT "import"
113 %token<token> KW_RETURN "return"
114 %token<token> KW_TYPEOF "typeof"
115 %token<token> KW_INTERFACE "interface"
116 %token<token> KW_NULL "null"
117 %token<token> KW_VAR "var"
118 %token<token> KW_DYNAMIC "dynamic"
119 %token<token> KW_OVERRIDE "override"
120 %token<token> KW_FINAL "final"
121 %token<token> KW_EACH "each"
122 %token<token> KW_GET "get"
123 %token<token> KW_TRY "try"
124 %token<token> KW_SUPER "super"
125 %token<token> KW_EXTENDS "extends"
126 %token<token> KW_FALSE "false"
127 %token<token> KW_TRUE "true"
128 %token<token> KW_BOOLEAN "Boolean"
129 %token<token> KW_UINT "uint"
130 %token<token> KW_INT "int"
131 %token<token> KW_NUMBER "Number"
132 %token<token> KW_STRING "String"
133 %token<token> KW_DEFAULT "default"
134 %token<token> KW_DELETE "delete"
135 %token<token> KW_IF "if"
136 %token<token> KW_ELSE "else"
137 %token<token> KW_BREAK "break"
138 %token<token> KW_IS "is"
139 %token<token> KW_IN "in"
140 %token<token> KW_AS "as"
142 %token<token> T_DICTSTART "{ (dictionary)"
143 %token<token> T_EQEQ "=="
144 %token<token> T_EQEQEQ "==="
145 %token<token> T_NE "!="
146 %token<token> T_NEE "!=="
147 %token<token> T_LE "<="
148 %token<token> T_GE ">="
149 %token<token> T_ORBY "|="
150 %token<token> T_DIVBY "/="
151 %token<token> T_MODBY "%="
152 %token<token> T_MULBY "*="
153 %token<token> T_PLUSBY "+="
154 %token<token> T_MINUSBY "-="
155 %token<token> T_XORBY "^="
156 %token<token> T_SHRBY ">>="
157 %token<token> T_SHLBY "<<="
158 %token<token> T_USHRBY ">>>="
159 %token<token> T_OROR "||"
160 %token<token> T_ANDAND "&&"
161 %token<token> T_COLONCOLON "::"
162 %token<token> T_MINUSMINUS "--"
163 %token<token> T_PLUSPLUS "++"
164 %token<token> T_DOTDOT ".."
165 %token<token> T_DOTDOTDOT "..."
166 %token<token> T_SHL "<<"
167 %token<token> T_USHR ">>>"
168 %token<token> T_SHR ">>"
170 %type <for_start> FOR_START
171 %type <id> X_IDENTIFIER PACKAGE FOR_IN_INIT MAYBE_IDENTIFIER
172 %type <token> VARCONST
174 %type <code> CODEPIECE CODE_STATEMENT
175 %type <code> CODEBLOCK MAYBECODE MAYBE_CASE_LIST CASE_LIST DEFAULT CASE SWITCH WITH
176 %type <code> PACKAGE_DECLARATION SLOT_DECLARATION
177 %type <code> FUNCTION_DECLARATION PACKAGE_INITCODE
178 %type <code> VARIABLE_DECLARATION ONE_VARIABLE VARIABLE_LIST THROW
179 %type <exception> CATCH FINALLY
180 %type <catch_list> CATCH_LIST CATCH_FINALLY_LIST
181 %type <code> CLASS_DECLARATION
182 %type <code> NAMESPACE_DECLARATION
183 %type <code> INTERFACE_DECLARATION
184 %type <code> VOIDEXPRESSION
185 %type <value> EXPRESSION NONCOMMAEXPRESSION
186 %type <value> MAYBEEXPRESSION
187 %type <value> E DELETE
188 %type <value> CONSTANT
189 %type <code> FOR FOR_IN IF WHILE DO_WHILE MAYBEELSE BREAK RETURN CONTINUE TRY
190 %type <value> INNERFUNCTION
191 %type <code> USE_NAMESPACE
192 %type <code> FOR_INIT
194 %type <classinfo> MAYBETYPE
197 %type <params> PARAM_LIST
198 %type <params> MAYBE_PARAM_LIST
199 %type <flags> MAYBE_MODIFIERS
200 %type <flags> MODIFIER_LIST
201 %type <constant> STATICCONSTANT MAYBESTATICCONSTANT
202 %type <classinfo_list> IMPLEMENTS_LIST
203 %type <classinfo> EXTENDS
204 %type <classinfo_list> EXTENDS_LIST
205 %type <classinfo> CLASS PACKAGEANDCLASS CLASS_SPEC
206 %type <classinfo_list> CLASS_SPEC_LIST
207 %type <classinfo> TYPE
208 //%type <token> VARIABLE
209 %type <value> VAR_READ
211 //%type <token> T_IDENTIFIER
212 %type <token> MODIFIER
213 %type <value> FUNCTIONCALL
214 %type <value_list> MAYBE_EXPRESSION_LIST EXPRESSION_LIST EXPRESSION_LIST_AND_COMMA MAYBE_PARAM_VALUES MAYBE_EXPRPAIR_LIST EXPRPAIR_LIST
216 // precedence: from low to high
220 %left below_semicolon
223 %nonassoc below_assignment // for ?:, contrary to spec
224 %right '=' "*=" "/=" "%=" "+=" "-=" "<<=" ">>=" ">>>=" "&=" "^=" "|="
231 %nonassoc "==" "!=" "===" "!=="
232 %nonassoc "is" "as" "in"
233 %nonassoc "<=" '<' ">=" '>' "instanceof" // TODO: support "a < b < c" syntax?
234 %left "<<" ">>" ">>>"
238 %left plusplus_prefix minusminus_prefix '~' '!' "void" "delete" "typeof" //FIXME: *unary* + - should be here, too
240 %nonassoc below_curly
244 %left '[' ']' "new" '{' "{ (dictionary)" '.' ".." "::" '@'
246 %nonassoc T_IDENTIFIER
247 %left above_identifier
251 // needed for "return" precedence:
252 %nonassoc T_STRING T_REGEXP
253 %nonassoc T_INT T_UINT T_BYTE T_SHORT T_FLOAT
254 %nonassoc "false" "true" "null" "undefined" "super" "function"
261 static int a3_error(char*s)
263 syntaxerror("%s", s);
264 return 0; //make gcc happy
268 static char* concat2(const char* t1, const char* t2)
272 char*text = malloc(l1+l2+1);
273 memcpy(text , t1, l1);
274 memcpy(text+l1, t2, l2);
278 static char* concat3(const char* t1, const char* t2, const char* t3)
283 char*text = malloc(l1+l2+l3+1);
284 memcpy(text , t1, l1);
285 memcpy(text+l1, t2, l2);
286 memcpy(text+l1+l2, t3, l3);
291 typedef struct _import {
295 DECLARE_LIST(import);
297 DECLARE(methodstate);
298 DECLARE_LIST(methodstate);
300 typedef struct _classstate {
306 methodstate_t*static_init;
308 //code_t*static_init;
310 char has_constructor;
313 struct _methodstate {
324 int var_index; // for inner methods
327 abc_exception_list_t*exceptions;
329 methodstate_list_t*innerfunctions;
332 typedef struct _state {
337 import_list_t*wildcard_imports;
339 char has_own_imports;
340 char new_vars; // e.g. transition between two functions
343 methodstate_t*method;
350 typedef struct _global {
354 dict_t*file2token2info;
357 static global_t*global = 0;
358 static state_t* state = 0;
362 #define MULTINAME(m,x) \
366 registry_fill_multiname(&m, &m##_ns, (slotinfo_t*)(x));
368 #define MEMBER_MULTINAME(m,f,n) \
372 m##_ns.access = (f)->access; \
376 m.namespace_set = 0; \
379 m.type = MULTINAME; \
381 m.namespace_set = &nopackage_namespace_set; \
385 /* warning: list length of namespace set is undefined */
386 #define MULTINAME_LATE(m, access, package) \
387 namespace_t m##_ns = {access, package}; \
388 namespace_set_t m##_nsset; \
389 namespace_list_t m##_l;m##_l.next = 0; \
390 m##_nsset.namespaces = &m##_l; \
391 m##_nsset = m##_nsset; \
392 m##_l.namespace = &m##_ns; \
393 multiname_t m = {MULTINAMEL, 0, &m##_nsset, 0};
395 static namespace_t ns1 = {ACCESS_PRIVATE, ""};
396 static namespace_t ns2 = {ACCESS_PROTECTED, ""};
397 static namespace_t ns3 = {ACCESS_PACKAGEINTERNAL, ""};
398 static namespace_t ns4 = {ACCESS_PACKAGE, ""};
399 static namespace_list_t nl4 = {&ns4,0};
400 static namespace_list_t nl3 = {&ns3,&nl4};
401 static namespace_list_t nl2 = {&ns2,&nl3};
402 static namespace_list_t nl1 = {&ns1,&nl2};
403 static namespace_set_t nopackage_namespace_set = {&nl1};
405 static void new_state()
408 state_t*oldstate = state;
410 memcpy(s, state, sizeof(state_t)); //shallow copy
412 s->imports = dict_new();
416 state->has_own_imports = 0;
417 state->vars = dict_new();
418 state->old = oldstate;
420 static void state_has_imports()
422 state->wildcard_imports = list_clone(state->wildcard_imports);
423 state->imports = dict_clone(state->imports);
424 state->has_own_imports = 1;
427 static void state_destroy(state_t*state)
429 if(state->has_own_imports) {
430 list_free(state->wildcard_imports);
431 dict_destroy(state->imports);state->imports=0;
433 if(state->imports && (!state->old || state->old->imports!=state->imports)) {
434 dict_destroy(state->imports);state->imports=0;
438 for(t=0;t<state->vars->hashsize;t++) {
439 dictentry_t*e =state->vars->slots[t];
441 free(e->data);e->data=0;
445 dict_destroy(state->vars);state->vars=0;
451 static void old_state()
453 if(!state || !state->old)
454 syntaxerror("invalid nesting");
455 state_t*leaving = state;
459 if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) {
460 free(leaving->method);
463 if(as3_pass>1 && leaving->cls && leaving->cls != state->cls) {
468 state_destroy(leaving);
471 static code_t* method_header(methodstate_t*m);
472 static code_t* wrap_function(code_t*c,code_t*header, code_t*body);
473 static void function_initvars(methodstate_t*m, params_t*params, int flags);
476 static char* internal_filename_package = 0;
477 void initialize_file(char*filename)
480 syntaxerror("invalid call to initialize_file during parsing of another file");
483 state->package = internal_filename_package = strdup(filename);
485 global->token2info = dict_lookup(global->file2token2info,
486 current_filename // use long version
488 if(!global->token2info) {
489 global->token2info = dict_new2(&ptr_type);
490 dict_put(global->file2token2info, current_filename, global->token2info);
494 state->method = rfx_calloc(sizeof(methodstate_t));
495 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
497 state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
498 function_initvars(state->method, 0, 0);
499 global->init = abc_initscript(global->file);
500 state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope
506 if(!state || state->level!=1) {
507 syntaxerror("unexpected end of file in pass %d", as3_pass);
511 code_t*header = method_header(state->method);
512 code_t*c = wrap_function(header, 0, global->init->method->body->code);
513 global->init->method->body->code = c;
514 free(state->method);state->method=0;
517 //free(state->package);state->package=0; // used in registry
518 state_destroy(state);state=0;
521 void initialize_parser()
523 global = rfx_calloc(sizeof(global_t));
524 global->file = abc_file_new();
525 global->file->flags &= ~ABCFILE_LAZY;
526 global->file2token2info = dict_new();
527 global->token2info = 0;
530 void* finish_parser()
532 dict_free_all(global->file2token2info, 1, (void*)dict_destroy);
534 global->token2info=0;
540 static void xx_scopetest()
542 /* findpropstrict doesn't just return a scope object- it
543 also makes it "active" somehow. Push local_0 on the
544 scope stack and read it back with findpropstrict, it'll
545 contain properties like "trace". Trying to find the same
546 property on a "vanilla" local_0 yields only a "undefined" */
547 //c = abc_findpropstrict(c, "[package]::trace");
549 /*c = abc_getlocal_0(c);
550 c = abc_findpropstrict(c, "[package]::trace");
552 c = abc_setlocal_1(c);
554 c = abc_pushbyte(c, 0);
555 c = abc_setlocal_2(c);
557 code_t*xx = c = abc_label(c);
558 c = abc_findpropstrict(c, "[package]::trace");
559 c = abc_pushstring(c, "prop:");
560 c = abc_hasnext2(c, 1, 2);
562 c = abc_setlocal_3(c);
563 c = abc_callpropvoid(c, "[package]::trace", 2);
564 c = abc_getlocal_3(c);
566 c = abc_iftrue(c,xx);*/
570 typedef struct _variable {
576 static variable_t* find_variable(char*name)
582 v = dict_lookup(s->vars, name);
592 static variable_t* find_variable_safe(char*name)
594 variable_t* v = find_variable(name);
596 syntaxerror("undefined variable: %s", name);
599 static char variable_exists(char*name)
601 return dict_lookup(state->vars, name)!=0;
603 code_t*defaultvalue(code_t*c, classinfo_t*type);
604 static int new_variable(const char*name, classinfo_t*type, char init)
607 v->index = state->method->variable_count;
611 dict_put(state->vars, name, v);
613 return state->method->variable_count++;
615 #define TEMPVARNAME "__as3_temp__"
616 static int gettempvar()
618 variable_t*v = find_variable(TEMPVARNAME);
621 return new_variable(TEMPVARNAME, 0, 0);
624 code_t* var_block(code_t*body)
630 for(t=0;t<state->vars->hashsize;t++) {
631 dictentry_t*e = state->vars->slots[t];
633 variable_t*v = (variable_t*)e->data;
634 if(v->type && v->init) {
635 c = defaultvalue(c, v->type);
636 c = abc_setlocal(c, v->index);
637 k = abc_kill(k, v->index);
647 if(x->opcode== OPCODE___BREAK__ ||
648 x->opcode== OPCODE___CONTINUE__) {
649 /* link kill code before break/continue */
650 code_t*e = code_dup(k);
651 code_t*s = code_start(e);
663 c = code_append(c, body);
664 c = code_append(c, k);
668 #define parserassert(b) {if(!(b)) parsererror(__FILE__, __LINE__,__func__);}
670 static void parsererror(const char*file, int line, const char*f)
672 syntaxerror("internal error in %s, %s:%d", f, file, line);
676 static code_t* method_header(methodstate_t*m)
679 if(m->late_binding && !m->inner) {
680 c = abc_getlocal_0(c);
681 c = abc_pushscope(c);
683 /*if(m->innerfunctions) {
684 c = abc_newactivation(c);
685 c = abc_pushscope(c);
687 methodstate_list_t*l = m->innerfunctions;
689 parserassert(l->methodstate->abc);
690 c = abc_newfunction(c, l->methodstate->abc);
691 c = abc_setlocal(c, l->methodstate->var_index);
692 free(l->methodstate);l->methodstate=0;
696 c = code_append(c, m->header);
699 if(m->is_constructor && !m->has_super) {
700 // call default constructor
701 c = abc_getlocal_0(c);
702 c = abc_constructsuper(c, 0);
704 list_free(m->innerfunctions);
705 m->innerfunctions = 0;
710 static code_t* wrap_function(code_t*c,code_t*header, code_t*body)
712 c = code_append(c, header);
713 c = code_append(c, var_block(body));
714 /* append return if necessary */
715 if(!c || (c->opcode != OPCODE_RETURNVOID &&
716 c->opcode != OPCODE_RETURNVALUE)) {
717 c = abc_returnvoid(c);
723 static void startpackage(char*name)
726 /*printf("entering package \"%s\"\n", name);*/
727 state->package = strdup(name);
729 static void endpackage()
731 /*printf("leaving package \"%s\"\n", state->package);*/
733 //used e.g. in classinfo_register:
734 //free(state->package);state->package=0;
739 #define FLAG_PUBLIC 256
740 #define FLAG_PROTECTED 512
741 #define FLAG_PRIVATE 1024
742 #define FLAG_PACKAGEINTERNAL 2048
743 #define FLAG_NAMESPACE 4096
745 static int flags2access(int flags)
748 if(flags&FLAG_PUBLIC) {
749 if(access&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
750 syntaxerror("invalid combination of access levels");
751 access = ACCESS_PACKAGE;
752 } else if(flags&FLAG_PRIVATE) {
753 if(access&(FLAG_PUBLIC|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
754 syntaxerror("invalid combination of access levels");
755 access = ACCESS_PRIVATE;
756 } else if(flags&FLAG_PROTECTED) {
757 if(access&(FLAG_PUBLIC|FLAG_PRIVATE|FLAG_PACKAGEINTERNAL))
758 syntaxerror("invalid combination of access levels");
759 access = ACCESS_PROTECTED;
761 access = ACCESS_PACKAGEINTERNAL;
766 static void function_initvars(methodstate_t*m, params_t*params, int flags)
769 new_variable("this", 0, 0);
770 else if(!m->is_global)
771 new_variable((flags&FLAG_STATIC)?"class":"this", state->cls?state->cls->info:0, 0);
773 new_variable("globalscope", 0, 0);
777 for(p=params->list;p;p=p->next) {
778 new_variable(p->param->name, p->param->type, 0);
782 methodstate_list_t*l = m->innerfunctions;
784 methodstate_t*m = l->methodstate;
785 m->var_index = new_variable(m->info->name, TYPE_FUNCTION(m->info), 0);
791 char*as3_globalclass=0;
792 static void startclass(int flags, char*classname, classinfo_t*extends, classinfo_list_t*implements)
795 syntaxerror("inner classes now allowed");
799 classinfo_list_t*mlist=0;
801 if(flags&~(FLAG_PACKAGEINTERNAL|FLAG_PUBLIC|FLAG_FINAL|FLAG_DYNAMIC|FLAG_INTERFACE))
802 syntaxerror("invalid modifier(s)");
804 if((flags&(FLAG_PUBLIC|FLAG_PACKAGEINTERNAL)) == (FLAG_PUBLIC|FLAG_PACKAGEINTERNAL))
805 syntaxerror("public and internal not supported at the same time.");
807 /* create the class name, together with the proper attributes */
811 if(!(flags&FLAG_PUBLIC) && state->package==internal_filename_package) {
812 access = ACCESS_PRIVATE; package = internal_filename_package;
813 } else if(!(flags&FLAG_PUBLIC) && state->package!=internal_filename_package) {
814 access = ACCESS_PACKAGEINTERNAL; package = state->package;
815 } else if(state->package!=internal_filename_package) {
816 access = ACCESS_PACKAGE; package = state->package;
818 syntaxerror("public classes only allowed inside a package");
822 state->cls = rfx_calloc(sizeof(classstate_t));
823 state->cls->init = rfx_calloc(sizeof(methodstate_t));
824 state->cls->static_init = rfx_calloc(sizeof(methodstate_t));
825 /* notice: we make no effort to initialize the top variable (local0) here,
826 even though it has special meaning. We just rely on the facat
827 that pass 1 won't do anything with variables */
829 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->cls);
831 /* set current method to constructor- all code within the class-level (except
832 static variable initializations) will be executed during construction time */
833 state->method = state->cls->init;
835 if(registry_find(package, classname)) {
836 syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, classname);
838 /* build info struct */
839 int num_interfaces = (list_length(implements));
840 state->cls->info = classinfo_register(access, package, classname, num_interfaces);
841 state->cls->info->flags |= flags & (FLAG_DYNAMIC|FLAG_INTERFACE|FLAG_FINAL);
845 state->cls = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
847 state->method = state->cls->init;
848 parserassert(state->cls && state->cls->info);
850 function_initvars(state->cls->init, 0, 0);
851 function_initvars(state->cls->static_init, 0, 0);
853 if(extends && (extends->flags & FLAG_FINAL))
854 syntaxerror("Can't extend final class '%s'", extends->name);
856 /* fill out interfaces and extends (we couldn't resolve those during the first pass) */
857 state->cls->info->superclass = extends?extends:TYPE_OBJECT;
859 classinfo_list_t*l = implements;
860 for(l=implements;l;l=l->next) {
861 if(!(l->classinfo->flags & FLAG_INTERFACE))
862 syntaxerror("'%s' is not an interface", l->classinfo->name);
863 state->cls->info->interfaces[pos++] = l->classinfo;
866 /* generate the abc code for this class */
867 MULTINAME(classname2,state->cls->info);
868 multiname_t*extends2 = sig2mname(extends);
870 state->cls->abc = abc_class_new(global->file, &classname2, extends2);
871 if(state->cls->info->flags&FLAG_FINAL) abc_class_final(state->cls->abc);
872 if(!(state->cls->info->flags&FLAG_DYNAMIC)) abc_class_sealed(state->cls->abc);
873 if(state->cls->info->flags&FLAG_INTERFACE) {
874 abc_class_interface(state->cls->abc);
877 abc_class_protectedNS(state->cls->abc, classname);
879 for(mlist=implements;mlist;mlist=mlist->next) {
880 MULTINAME(m, mlist->classinfo);
881 abc_class_add_interface(state->cls->abc, &m);
884 /* write the construction code for this class to the global init
886 int slotindex = abc_initscript_addClassTrait(global->init, &classname2, state->cls->abc);
888 abc_method_body_t*m = global->init->method->body;
889 __ getglobalscope(m);
890 classinfo_t*s = extends;
895 //TODO: take a look at the current scope stack, maybe
896 // we can re-use something
901 multiname_t*s2 = sig2mname(s);
903 multiname_destroy(s2);
905 __ pushscope(m); count++;
906 m->code = m->code->prev->prev; // invert
908 /* continue appending after last op end */
909 while(m->code && m->code->next) m->code = m->code->next;
911 /* TODO: if this is one of *our* classes, we can also
912 do a getglobalscope/getslot <nr> (which references
913 the init function's slots) */
915 __ getlex2(m, extends2);
917 /* notice: we get a Verify Error #1107 if the top elemnt on the scope
918 stack is not the superclass */
919 __ pushscope(m);count++;
922 /* notice: we get a verify error #1107 if the top element on the scope
923 stack is not the global object */
925 __ pushscope(m);count++;
927 __ newclass(m,state->cls->abc);
931 __ setslot(m, slotindex);
932 multiname_destroy(extends2);
934 /* flash.display.MovieClip handling */
936 if(!as3_globalclass && (flags&FLAG_PUBLIC) && slotinfo_equals((slotinfo_t*)registry_getMovieClip(),(slotinfo_t*)extends)) {
937 if(state->package && state->package[0]) {
938 as3_globalclass = concat3(state->package, ".", classname);
940 as3_globalclass = strdup(classname);
946 static void setstaticfunction(int x)
950 state->method = state->cls->static_init;
952 state->method = state->cls->init;
955 parserassert(state->method);
959 static void endclass()
962 if(!state->cls->has_constructor && !(state->cls->info->flags&FLAG_INTERFACE)) {
964 c = abc_getlocal_0(c);
965 c = abc_constructsuper(c, 0);
966 state->cls->init->header = code_append(state->cls->init->header, c);
967 state->cls->has_constructor=1;
969 if(state->cls->init) {
970 if(state->cls->info->flags&FLAG_INTERFACE) {
971 if(state->cls->init->header)
972 syntaxerror("interface can not have class-level code");
974 abc_method_t*m = abc_class_getconstructor(state->cls->abc, 0);
975 code_t*c = method_header(state->cls->init);
976 m->body->code = wrap_function(c, 0, m->body->code);
979 if(state->cls->static_init) {
980 abc_method_t*m = abc_class_getstaticconstructor(state->cls->abc, 0);
981 code_t*c = method_header(state->cls->static_init);
982 m->body->code = wrap_function(c, 0, m->body->code);
989 void check_code_for_break(code_t*c)
992 if(c->opcode == OPCODE___BREAK__) {
993 char*name = string_cstr(c->data[0]);
994 syntaxerror("Unresolved \"break %s\"", name);
996 if(c->opcode == OPCODE___CONTINUE__) {
997 char*name = string_cstr(c->data[0]);
998 syntaxerror("Unresolved \"continue %s\"", name);
1005 static void check_constant_against_type(classinfo_t*t, constant_t*c)
1007 #define xassert(b) if(!(b)) syntaxerror("Invalid default value %s for type '%s'", constant_tostring(c), t->name)
1008 if(TYPE_IS_NUMBER(t)) {
1009 xassert(c->type == CONSTANT_FLOAT
1010 || c->type == CONSTANT_INT
1011 || c->type == CONSTANT_UINT);
1012 } else if(TYPE_IS_UINT(t)) {
1013 xassert(c->type == CONSTANT_UINT ||
1014 (c->type == CONSTANT_INT && c->i>0));
1015 } else if(TYPE_IS_INT(t)) {
1016 xassert(c->type == CONSTANT_INT);
1017 } else if(TYPE_IS_BOOLEAN(t)) {
1018 xassert(c->type == CONSTANT_TRUE
1019 || c->type == CONSTANT_FALSE);
1023 static void check_override(memberinfo_t*m, int flags)
1027 if(m->parent == state->cls->info)
1028 syntaxerror("class '%s' already contains a method/slot '%s'", m->parent->name, m->name);
1030 syntaxerror("internal error: overriding method %s, which doesn't have parent", m->name);
1031 if(m->access==ACCESS_PRIVATE)
1033 if(m->flags & FLAG_FINAL)
1034 syntaxerror("can't override final member %s", m->name);
1035 if((m->flags & FLAG_STATIC) && !(flags&FLAG_STATIC))
1036 syntaxerror("can't override static member %s", m->name);
1037 if(!(m->flags & FLAG_STATIC) && (flags&FLAG_STATIC))
1038 syntaxerror("can't override non-static member %s with static declaration", m->name);
1040 if(!(flags&FLAG_OVERRIDE)) {
1041 if(m->parent && !(m->parent->flags&FLAG_INTERFACE)) {
1042 if(m->kind == INFOTYPE_METHOD)
1043 syntaxerror("can't override without explicit 'override' declaration");
1045 syntaxerror("can't override '%s'", m->name);
1050 static methodinfo_t*registerfunction(enum yytokentype getset, int flags, char*name, params_t*params, classinfo_t*return_type, int slot)
1052 methodinfo_t*minfo = 0;
1053 U8 access = flags2access(flags);
1056 minfo = methodinfo_register_global(access, state->package, name);
1057 minfo->return_type = return_type;
1058 } else if(getset != KW_GET && getset != KW_SET) {
1060 memberinfo_t* m = registry_findmember(state->cls->info, name, 0);
1062 syntaxerror("class already contains a %s '%s'", infotypename((slotinfo_t*)m), m->name);
1064 minfo = methodinfo_register_onclass(state->cls->info, access, name);
1065 minfo->return_type = return_type;
1066 // getslot on a member slot only returns "undefined", so no need
1067 // to actually store these
1068 //state->minfo->slot = state->method->abc->method->trait->slot_id;
1070 //class getter/setter
1071 int gs = getset==KW_GET?SUBTYPE_GET:SUBTYPE_SET;
1073 if(getset == KW_GET)
1075 else if(params->list && params->list->param)
1076 type = params->list->param->type;
1077 // not sure wether to look into superclasses here, too
1078 minfo = (methodinfo_t*)registry_findmember(state->cls->info, name, 1);
1080 if(minfo->kind!=INFOTYPE_SLOT)
1081 syntaxerror("class already contains a method called '%s'", name);
1082 if(!(minfo->subtype & (SUBTYPE_GETSET)))
1083 syntaxerror("class already contains a field called '%s'", name);
1084 if(minfo->subtype & gs)
1085 syntaxerror("getter/setter for '%s' already defined", name);
1086 /* make a setter or getter into a getset */
1087 minfo->subtype |= gs;
1088 if(!minfo->return_type) {
1089 minfo->return_type = type;
1091 if(minfo && minfo->return_type != type)
1092 syntaxerror("different type in getter and setter");
1095 minfo = methodinfo_register_onclass(state->cls->info, access, name);
1096 minfo->kind = INFOTYPE_SLOT; //hack
1097 minfo->subtype = gs;
1098 minfo->return_type = type;
1100 /* can't assign a slot as getter and setter might have different slots */
1101 //minfo->slot = slot;
1103 if(flags&FLAG_FINAL) minfo->flags |= FLAG_FINAL;
1104 if(flags&FLAG_STATIC) minfo->flags |= FLAG_STATIC;
1105 if(flags&FLAG_OVERRIDE) minfo->flags |= FLAG_OVERRIDE;
1109 static void innerfunction(char*name, params_t*params, classinfo_t*return_type)
1111 //parserassert(state->method && state->method->info);
1113 methodstate_t*parent_method = state->method;
1122 state->new_vars = 1;
1125 state->method = rfx_calloc(sizeof(methodstate_t));
1126 state->method->inner = 1;
1127 state->method->variable_count = 0;
1128 state->method->abc = rfx_calloc(sizeof(abc_method_t));
1130 NEW(methodinfo_t,minfo);
1131 minfo->kind = INFOTYPE_METHOD;
1132 minfo->access = ACCESS_PACKAGEINTERNAL;
1134 state->method->info = minfo;
1137 list_append(parent_method->innerfunctions, state->method);
1139 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
1143 state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1144 parserassert(state->method);
1146 state->method->info->return_type = return_type;
1147 function_initvars(state->method, params, 0);
1151 static void startfunction(token_t*ns, int flags, enum yytokentype getset, char*name,
1152 params_t*params, classinfo_t*return_type)
1154 if(state->method && state->method->info) {
1155 syntaxerror("not able to start another method scope");
1160 state->method = rfx_calloc(sizeof(methodstate_t));
1161 state->method->has_super = 0;
1164 state->method->is_constructor = !strcmp(state->cls->info->name,name);
1166 state->method->is_global = 1;
1167 state->method->late_binding = 1; // for global methods, always push local_0 on the scope stack
1169 if(state->method->is_constructor)
1170 name = "__as3_constructor__";
1173 state->method->info = registerfunction(getset, flags, name, params, return_type, 0);
1175 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
1179 state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1180 parserassert(state->method);
1183 memberinfo_t*m = registry_findmember(state->cls->info, name, 2);
1184 check_override(m, flags);
1188 state->cls->has_constructor |= state->method->is_constructor;
1191 state->method->info->return_type = return_type;
1192 function_initvars(state->method, params, flags);
1196 static abc_method_t* endfunction(token_t*ns, int flags, enum yytokentype getset, char*name,
1197 params_t*params, classinfo_t*return_type, code_t*body)
1206 multiname_t*type2 = sig2mname(return_type);
1208 if(state->method->inner) {
1209 f = state->method->abc;
1210 abc_method_init(f, global->file, type2, 1);
1211 } else if(state->method->is_constructor) {
1212 f = abc_class_getconstructor(state->cls->abc, type2);
1213 } else if(!state->method->is_global) {
1214 namespace_t mname_ns = {state->method->info->access, ""};
1215 multiname_t mname = {QNAME, &mname_ns, 0, name};
1217 if(flags&FLAG_STATIC)
1218 f = abc_class_staticmethod(state->cls->abc, type2, &mname);
1220 f = abc_class_method(state->cls->abc, type2, &mname);
1221 slot = f->trait->slot_id;
1223 namespace_t mname_ns = {state->method->info->access, state->package};
1224 multiname_t mname = {QNAME, &mname_ns, 0, name};
1226 f = abc_method_new(global->file, type2, 1);
1227 trait_t*t = trait_new_method(&global->init->traits, multiname_clone(&mname), f);
1228 //abc_code_t*c = global->init->method->body->code;
1230 //flash doesn't seem to allow us to access function slots
1231 //state->method->info->slot = slot;
1233 if(flags&FLAG_OVERRIDE) f->trait->attributes |= TRAIT_ATTR_OVERRIDE;
1234 if(getset == KW_GET) f->trait->kind = TRAIT_GETTER;
1235 if(getset == KW_SET) f->trait->kind = TRAIT_SETTER;
1236 if(params->varargs) f->flags |= METHOD_NEED_REST;
1240 for(p=params->list;p;p=p->next) {
1241 if(params->varargs && !p->next) {
1242 break; //varargs: omit last parameter in function signature
1244 multiname_t*m = sig2mname(p->param->type);
1245 list_append(f->parameters, m);
1246 if(p->param->value) {
1247 check_constant_against_type(p->param->type, p->param->value);
1248 opt=1;list_append(f->optional_parameters, p->param->value);
1250 syntaxerror("non-optional parameter not allowed after optional parameters");
1253 check_code_for_break(body);
1256 f->body->code = body;
1257 f->body->exceptions = state->method->exceptions;
1258 } else { //interface
1260 syntaxerror("interface methods can't have a method body");
1267 char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
1272 void breakjumpsto(code_t*c, char*name, code_t*jump)
1275 if(c->opcode == OPCODE___BREAK__) {
1276 string_t*name2 = c->data[0];
1277 if(!name2->len || !strncmp(name2->str, name, name2->len)) {
1278 c->opcode = OPCODE_JUMP;
1285 void continuejumpsto(code_t*c, char*name, code_t*jump)
1288 if(c->opcode == OPCODE___CONTINUE__) {
1289 string_t*name2 = c->data[0];
1290 if(!name2->len || !strncmp(name2->str, name, name2->len)) {
1291 c->opcode = OPCODE_JUMP;
1299 #define IS_INT(a) (TYPE_IS_INT((a)) || TYPE_IS_UINT((a)))
1300 #define IS_NUMBER_OR_INT(a) (TYPE_IS_INT((a)) || TYPE_IS_UINT((a)) || TYPE_IS_NUMBER((a)))
1301 #define BOTH_INT(a,b) (IS_INT(a) && IS_INT(b))
1303 classinfo_t*join_types(classinfo_t*type1, classinfo_t*type2, char op)
1305 if(!type1 || !type2)
1306 return registry_getanytype();
1307 if(TYPE_IS_ANY(type1) || TYPE_IS_ANY(type2))
1308 return registry_getanytype();
1311 if(IS_NUMBER_OR_INT(type1) && IS_NUMBER_OR_INT(type2)) {
1320 return registry_getanytype();
1322 code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
1327 return abc_coerce_a(c);
1331 // cast an "any" type to a specific type. subject to
1332 // runtime exceptions
1333 return abc_coerce2(c, &m);
1336 if((TYPE_IS_NUMBER(from) || TYPE_IS_UINT(from) || TYPE_IS_INT(from)) &&
1337 (TYPE_IS_NUMBER(to) || TYPE_IS_UINT(to) || TYPE_IS_INT(to))) {
1338 // allow conversion between number types
1339 return abc_coerce2(c, &m);
1341 //printf("%s.%s\n", from.package, from.name);
1342 //printf("%s.%s\n", to.package, to.name);
1344 classinfo_t*supertype = from;
1346 if(supertype == to) {
1347 // target type is one of from's superclasses
1348 return abc_coerce2(c, &m);
1351 while(supertype->interfaces[t]) {
1352 if(supertype->interfaces[t]==to) {
1353 // target type is one of from's interfaces
1354 return abc_coerce2(c, &m);
1358 supertype = supertype->superclass;
1360 if(TYPE_IS_FUNCTION(from) && TYPE_IS_FUNCTION(to))
1362 if(TYPE_IS_CLASS(from) && TYPE_IS_CLASS(to))
1364 if(TYPE_IS_NULL(from) && !IS_NUMBER_OR_INT(to))
1366 syntaxerror("can't convert type %s to %s", from->name, to->name);
1367 return 0; // make gcc happy
1370 code_t*defaultvalue(code_t*c, classinfo_t*type)
1372 if(TYPE_IS_INT(type)) {
1373 c = abc_pushbyte(c, 0);
1374 } else if(TYPE_IS_UINT(type)) {
1375 c = abc_pushuint(c, 0);
1376 } else if(TYPE_IS_FLOAT(type)) {
1378 } else if(TYPE_IS_BOOLEAN(type)) {
1379 c = abc_pushfalse(c);
1381 //c = abc_pushundefined(c);
1383 c = abc_pushnull(c);
1385 c = abc_coerce2(c, &m);
1390 char is_pushundefined(code_t*c)
1392 return (c && !c->prev && !c->next && c->opcode == OPCODE_PUSHUNDEFINED);
1395 static slotinfo_t* find_class(char*name)
1399 c = registry_find(state->package, name);
1402 /* try explicit imports */
1403 dictentry_t* e = dict_get_slot(state->imports, name);
1406 if(!strcmp(e->key, name)) {
1407 c = (slotinfo_t*)e->data;
1413 /* try package.* imports */
1414 import_list_t*l = state->wildcard_imports;
1416 //printf("does package %s contain a class %s?\n", l->import->package, name);
1417 c = registry_find(l->import->package, name);
1422 /* try global package */
1423 c = registry_find("", name);
1426 /* try local "filename" package */
1427 c = registry_find(internal_filename_package, name);
1433 static char is_getlocal(code_t*c)
1435 if(!c || c->prev || c->next)
1437 return(c->opcode == OPCODE_GETLOCAL
1438 || c->opcode == OPCODE_GETLOCAL_0
1439 || c->opcode == OPCODE_GETLOCAL_1
1440 || c->opcode == OPCODE_GETLOCAL_2
1441 || c->opcode == OPCODE_GETLOCAL_3);
1443 static int getlocalnr(code_t*c)
1445 if(c->opcode == OPCODE_GETLOCAL) {return (ptroff_t)c->data[0];}
1446 else if(c->opcode == OPCODE_GETLOCAL_0) {return 0;}
1447 else if(c->opcode == OPCODE_GETLOCAL_1) {return 1;}
1448 else if(c->opcode == OPCODE_GETLOCAL_2) {return 2;}
1449 else if(c->opcode == OPCODE_GETLOCAL_3) {return 3;}
1450 else syntaxerror("Internal error: opcode %02x is not a getlocal call", c->opcode);
1454 static code_t* toreadwrite(code_t*in, code_t*middlepart, char justassign, char readbefore)
1458 [prefix code] [read instruction]
1462 [prefix code] ([dup]) [read instruction] [middlepart] [setvar] [write instruction] [getvar]
1464 if(in && in->opcode == OPCODE_COERCE_A) {
1465 in = code_cutlast(in);
1468 syntaxerror("internal error");
1470 /* chop off read instruction */
1474 prefix = r->prev;r->prev = 0;
1480 char use_temp_var = readbefore;
1482 /* generate the write instruction, and maybe append a dup to the prefix code */
1483 code_t* write = abc_nop(0);
1484 if(r->opcode == OPCODE_GETPROPERTY) {
1485 write->opcode = OPCODE_SETPROPERTY;
1486 multiname_t*m = (multiname_t*)r->data[0];
1487 write->data[0] = multiname_clone(m);
1488 if(m->type == QNAME || m->type == MULTINAME) {
1490 prefix = abc_dup(prefix); // we need the object, too
1493 } else if(m->type == MULTINAMEL) {
1495 /* dupping two values on the stack requires 5 operations and one register-
1496 couldn't adobe just have given us a dup2? */
1497 int temp = gettempvar();
1498 prefix = abc_setlocal(prefix, temp);
1499 prefix = abc_dup(prefix);
1500 prefix = abc_getlocal(prefix, temp);
1501 prefix = abc_swap(prefix);
1502 prefix = abc_getlocal(prefix, temp);
1504 prefix = abc_kill(prefix, temp);
1508 syntaxerror("illegal lvalue: can't assign a value to this expression (not a qname/multiname)");
1510 } else if(r->opcode == OPCODE_GETSLOT) {
1511 write->opcode = OPCODE_SETSLOT;
1512 write->data[0] = r->data[0];
1514 prefix = abc_dup(prefix); // we need the object, too
1517 } else if(r->opcode == OPCODE_GETLOCAL) {
1518 write->opcode = OPCODE_SETLOCAL;
1519 write->data[0] = r->data[0];
1520 } else if(r->opcode == OPCODE_GETLOCAL_0) {
1521 write->opcode = OPCODE_SETLOCAL_0;
1522 } else if(r->opcode == OPCODE_GETLOCAL_1) {
1523 write->opcode = OPCODE_SETLOCAL_1;
1524 } else if(r->opcode == OPCODE_GETLOCAL_2) {
1525 write->opcode = OPCODE_SETLOCAL_2;
1526 } else if(r->opcode == OPCODE_GETLOCAL_3) {
1527 write->opcode = OPCODE_SETLOCAL_3;
1530 syntaxerror("illegal lvalue: can't assign a value to this expression");
1537 /* with getproperty/getslot, we have to be extra careful not
1538 to execute the read code twice, as it might have side-effects
1539 (e.g. if the property is in fact a setter/getter combination)
1541 So read the value, modify it, and write it again,
1542 using prefix only once and making sure (by using a temporary
1543 register) that the return value is what we just wrote */
1544 temp = gettempvar();
1545 c = code_append(c, prefix);
1546 c = code_append(c, r);
1549 c = abc_setlocal(c, temp);
1551 c = code_append(c, middlepart);
1554 c = abc_setlocal(c, temp);
1556 c = code_append(c, write);
1557 c = abc_getlocal(c, temp);
1558 c = abc_kill(c, temp);
1560 /* if we're allowed to execute the read code twice *and*
1561 the middlepart doesn't modify the code, things are easier.
1563 code_t* r2 = code_dup(r);
1564 //c = code_append(c, prefix);
1565 parserassert(!prefix);
1566 c = code_append(c, r);
1567 c = code_append(c, middlepart);
1568 c = code_append(c, write);
1569 c = code_append(c, r2);
1572 /* even smaller version: overwrite the value without reading
1576 c = code_append(c, prefix);
1579 c = code_append(c, middlepart);
1580 c = code_append(c, write);
1581 c = code_append(c, r);
1584 temp = gettempvar();
1586 c = code_append(c, prefix);
1588 c = code_append(c, middlepart);
1590 c = abc_setlocal(c, temp);
1591 c = code_append(c, write);
1592 c = abc_getlocal(c, temp);
1593 c = abc_kill(c, temp);
1599 char is_break_or_jump(code_t*c)
1603 if(c->opcode == OPCODE_JUMP ||
1604 c->opcode == OPCODE___BREAK__ ||
1605 c->opcode == OPCODE___CONTINUE__ ||
1606 c->opcode == OPCODE_THROW ||
1607 c->opcode == OPCODE_RETURNVOID ||
1608 c->opcode == OPCODE_RETURNVALUE) {
1615 #define IS_FINALLY_TARGET(op) \
1616 ((op) == OPCODE___CONTINUE__ || \
1617 (op) == OPCODE___BREAK__ || \
1618 (op) == OPCODE_RETURNVOID || \
1619 (op) == OPCODE_RETURNVALUE || \
1620 (op) == OPCODE___RETHROW__)
1622 static code_t* insert_finally_lookup(code_t*c, code_t*finally, int tempvar)
1624 #define NEED_EXTRA_STACK_ARG
1625 code_t*finally_label = abc_nop(0);
1626 NEW(lookupswitch_t, l);
1632 code_t*prev = i->prev;
1633 if(IS_FINALLY_TARGET(i->opcode)) {
1636 if(i->opcode == OPCODE___RETHROW__ ||
1637 i->opcode == OPCODE_RETURNVALUE) {
1638 if(i->opcode == OPCODE___RETHROW__)
1639 i->opcode = OPCODE_THROW;
1641 p = abc_coerce_a(p);
1642 p = abc_setlocal(p, tempvar);
1644 p = abc_pushbyte(p, count++);
1645 p = abc_jump(p, finally_label);
1646 code_t*target = p = abc_label(p);
1647 #ifdef NEED_EXTRA_STACK_ARG
1651 p = abc_getlocal(p, tempvar);
1654 p->next = i;i->prev = p;
1655 list_append(l->targets, target);
1661 c = abc_pushbyte(c, -1);
1662 c = code_append(c, finally_label);
1663 c = code_append(c, finally);
1665 #ifdef NEED_EXTRA_STACK_ARG
1668 c = abc_lookupswitch(c, l);
1669 c = l->def = abc_label(c);
1670 #ifdef NEED_EXTRA_STACK_ARG
1677 static code_t* insert_finally_simple(code_t*c, code_t*finally, int tempvar)
1681 code_t*prev = i->prev;
1682 if(IS_FINALLY_TARGET(i->opcode)) {
1683 if(i->opcode == OPCODE___RETHROW__)
1684 i->opcode = OPCODE_THROW;
1685 code_t*end = code_dup(finally);
1686 code_t*start = code_start(end);
1687 if(prev) prev->next = start;
1694 return code_append(c, finally);
1697 code_t* insert_finally(code_t*c, code_t*finally, int tempvar)
1703 int num_insertion_points=0;
1705 if(IS_FINALLY_TARGET(i->opcode))
1706 num_insertion_points++;
1713 if(i->branch || i->opcode == OPCODE_LOOKUPSWITCH) {
1718 int simple_version_cost = (1+num_insertion_points)*code_size;
1719 int lookup_version_cost = 4*num_insertion_points + 5;
1721 if(cantdup || simple_version_cost > lookup_version_cost) {
1722 printf("lookup %d > *%d*\n", simple_version_cost, lookup_version_cost);
1723 return insert_finally_lookup(c, finally, tempvar);
1725 printf("simple *%d* < %d\n", simple_version_cost, lookup_version_cost);
1726 return insert_finally_simple(c, finally, tempvar);
1730 #define PASS1 }} if(as3_pass == 1) {{
1731 #define PASS1END }} if(as3_pass == 2) {{
1732 #define PASS2 }} if(as3_pass == 2) {{
1733 #define PASS12 }} {{
1734 #define PASS12END }} if(as3_pass == 2) {{
1740 /* ------------ code blocks / statements ---------------- */
1742 PROGRAM: MAYBE_PROGRAM_CODE_LIST
1744 MAYBE_PROGRAM_CODE_LIST: | PROGRAM_CODE_LIST
1745 PROGRAM_CODE_LIST: PROGRAM_CODE
1746 | PROGRAM_CODE_LIST PROGRAM_CODE
1748 PROGRAM_CODE: PACKAGE_DECLARATION
1749 | INTERFACE_DECLARATION
1751 | FUNCTION_DECLARATION
1754 | CONDITIONAL_COMPILATION '{' MAYBE_PROGRAM_CODE_LIST '}' // conditional compilation
1757 MAYBE_INPACKAGE_CODE_LIST: | INPACKAGE_CODE_LIST
1758 INPACKAGE_CODE_LIST: INPACKAGE_CODE
1759 | INPACKAGE_CODE_LIST INPACKAGE_CODE
1761 INPACKAGE_CODE: INTERFACE_DECLARATION
1763 | FUNCTION_DECLARATION
1766 | CONDITIONAL_COMPILATION '{' MAYBE_INPACKAGE_CODE_LIST '}' // conditional compilation
1769 MAYBECODE: CODE {$$=$1;}
1770 MAYBECODE: {$$=code_new();}
1772 CODE: CODE CODEPIECE {$$=code_append($1,$2);}
1773 CODE: CODEPIECE {$$=$1;}
1775 // code which also may appear outside a method
1776 CODE_STATEMENT: IMPORT
1778 CODE_STATEMENT: FOR_IN
1779 CODE_STATEMENT: WHILE
1780 CODE_STATEMENT: DO_WHILE
1781 CODE_STATEMENT: SWITCH
1783 CODE_STATEMENT: WITH
1785 CODE_STATEMENT: VOIDEXPRESSION
1786 CODE_STATEMENT: USE_NAMESPACE
1787 CODE_STATEMENT: '{' CODE '}' {$$=$2;}
1788 CODE_STATEMENT: '{' '}' {$$=0;}
1790 // code which may appear anywhere
1791 CODEPIECE: ';' {$$=0;}
1792 CODEPIECE: CODE_STATEMENT
1793 CODEPIECE: VARIABLE_DECLARATION
1798 CODEPIECE: CONDITIONAL_COMPILATION '{' CODE '}' {$$=$3;}
1800 CODEPIECE: NAMESPACE_DECLARATION {/*TODO*/$$=0;}
1802 //CODEBLOCK : '{' CODE '}' {$$=$2;}
1803 //CODEBLOCK : '{' '}' {$$=0;}
1804 CODEBLOCK : CODEPIECE ';' {$$=$1;}
1805 CODEBLOCK : CODEPIECE %prec below_semicolon {$$=$1;}
1807 /* ------------ package init code ------------------- */
1809 PACKAGE_INITCODE: CODE_STATEMENT {
1810 code_t**cc = &global->init->method->body->code;
1811 *cc = code_append(*cc, $1);
1814 /* ------------ conditional compilation ------------- */
1816 CONDITIONAL_COMPILATION: T_IDENTIFIER "::" T_IDENTIFIER
1818 /* ------------ variables --------------------------- */
1820 MAYBEEXPRESSION : '=' NONCOMMAEXPRESSION {$$=$2;}
1821 | {$$.c=abc_pushundefined(0);
1825 VARIABLE_DECLARATION : "var" VARIABLE_LIST {$$=$2;}
1826 VARIABLE_DECLARATION : "const" VARIABLE_LIST {$$=$2;}
1828 VARIABLE_LIST: ONE_VARIABLE {$$ = $1;}
1829 VARIABLE_LIST: VARIABLE_LIST ',' ONE_VARIABLE {$$ = code_append($1, $3);}
1831 ONE_VARIABLE: T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION
1833 if(variable_exists($1))
1834 syntaxerror("Variable %s already defined", $1);
1836 if(!is_subtype_of($3.t, $2)) {
1837 syntaxerror("Can't convert %s to %s", $3.t->name,
1841 int index = new_variable($1, $2, 1);
1844 if($3.c->prev || $3.c->opcode != OPCODE_PUSHUNDEFINED) {
1846 $$ = converttype($$, $3.t, $2);
1847 $$ = abc_setlocal($$, index);
1850 $$ = defaultvalue(0, $2);
1851 $$ = abc_setlocal($$, index);
1854 if($3.c->prev || $3.c->opcode != OPCODE_PUSHUNDEFINED) {
1856 $$ = abc_coerce_a($$);
1857 $$ = abc_setlocal($$, index);
1864 /* that's the default for a local register, anyway
1866 state->method->initcode = abc_pushundefined(state->method->initcode);
1867 state->method->initcode = abc_setlocal(state->method->initcode, index);
1869 //printf("variable %s -> %d (%s)\n", $2->text, index, $4.t?$4.t->name:"");
1872 /* ------------ control flow ------------------------- */
1874 MAYBEELSE: %prec below_else {$$ = code_new();}
1875 MAYBEELSE: "else" CODEBLOCK {$$=$2;}
1876 //MAYBEELSE: ';' "else" CODEBLOCK {$$=$3;}
1878 IF : "if" '(' {new_state();} EXPRESSION ')' CODEBLOCK MAYBEELSE {
1881 $$ = code_append($$, $4.c);
1882 code_t*myjmp,*myif = $$ = abc_iffalse($$, 0);
1884 $$ = code_append($$, $6);
1886 myjmp = $$ = abc_jump($$, 0);
1888 myif->branch = $$ = abc_nop($$);
1890 $$ = code_append($$, $7);
1891 myjmp->branch = $$ = abc_nop($$);
1897 FOR_INIT : {$$=code_new();}
1898 FOR_INIT : VARIABLE_DECLARATION
1899 FOR_INIT : VOIDEXPRESSION
1901 // TODO: why doesn't an %prec above_identifier resolve the r-r conflict here?
1902 FOR_IN_INIT : "var" T_IDENTIFIER MAYBETYPE {
1903 $$=$2;new_variable($2,$3,1);
1905 FOR_IN_INIT : T_IDENTIFIER {
1909 FOR_START : T_FOR '(' {new_state();$$.name=$1;$$.each=0;}
1910 FOR_START : T_FOR "each" '(' {new_state();$$.name=$1;$$.each=1;}
1912 FOR : FOR_START FOR_INIT ';' EXPRESSION ';' VOIDEXPRESSION ')' CODEBLOCK {
1913 if($1.each) syntaxerror("invalid syntax: ; not allowed in for each statement");
1915 $$ = code_append($$, $2);
1916 code_t*loopstart = $$ = abc_label($$);
1917 $$ = code_append($$, $4.c);
1918 code_t*myif = $$ = abc_iffalse($$, 0);
1919 $$ = code_append($$, $8);
1920 code_t*cont = $$ = abc_nop($$);
1921 $$ = code_append($$, $6);
1922 $$ = abc_jump($$, loopstart);
1923 code_t*out = $$ = abc_nop($$);
1924 breakjumpsto($$, $1.name, out);
1925 continuejumpsto($$, $1.name, cont);
1932 FOR_IN : FOR_START FOR_IN_INIT "in" EXPRESSION ')' CODEBLOCK {
1933 variable_t*var = find_variable($2);
1934 char*tmp1name = concat2($2, "__tmp1__");
1935 int it = new_variable(tmp1name, TYPE_INT, 0);
1936 char*tmp2name = concat2($2, "__array__");
1937 int array = new_variable(tmp1name, 0, 0);
1940 $$ = code_append($$, $4.c);
1941 $$ = abc_coerce_a($$);
1942 $$ = abc_setlocal($$, array);
1943 $$ = abc_pushbyte($$, 0);
1944 $$ = abc_setlocal($$, it);
1946 code_t*loopstart = $$ = abc_label($$);
1948 $$ = abc_hasnext2($$, array, it);
1949 code_t*myif = $$ = abc_iffalse($$, 0);
1950 $$ = abc_getlocal($$, array);
1951 $$ = abc_getlocal($$, it);
1953 $$ = abc_nextname($$);
1955 $$ = abc_nextvalue($$);
1956 $$ = converttype($$, 0, var->type);
1957 $$ = abc_setlocal($$, var->index);
1959 $$ = code_append($$, $6);
1960 $$ = abc_jump($$, loopstart);
1962 code_t*out = $$ = abc_nop($$);
1963 breakjumpsto($$, $1.name, out);
1964 continuejumpsto($$, $1.name, loopstart);
1975 WHILE : T_WHILE '(' {new_state();} EXPRESSION ')' CODEBLOCK {
1979 code_t*myjmp = $$ = abc_jump($$, 0);
1980 code_t*loopstart = $$ = abc_label($$);
1981 $$ = code_append($$, $6);
1982 code_t*cont = $$ = abc_nop($$);
1983 myjmp->branch = cont;
1984 $$ = code_append($$, $4.c);
1985 $$ = abc_iftrue($$, loopstart);
1986 code_t*out = $$ = abc_nop($$);
1987 breakjumpsto($$, $1, out);
1988 continuejumpsto($$, $1, cont);
1994 DO_WHILE : T_DO {new_state();} CODEBLOCK "while" '(' EXPRESSION ')' {
1996 code_t*loopstart = $$ = abc_label($$);
1997 $$ = code_append($$, $3);
1998 code_t*cont = $$ = abc_nop($$);
1999 $$ = code_append($$, $6.c);
2000 $$ = abc_iftrue($$, loopstart);
2001 code_t*out = $$ = abc_nop($$);
2002 breakjumpsto($$, $1, out);
2003 continuejumpsto($$, $1, cont);
2009 BREAK : "break" %prec prec_none {
2010 $$ = abc___break__(0, "");
2012 BREAK : "break" T_IDENTIFIER {
2013 $$ = abc___break__(0, $2);
2015 CONTINUE : "continue" %prec prec_none {
2016 $$ = abc___continue__(0, "");
2018 CONTINUE : "continue" T_IDENTIFIER {
2019 $$ = abc___continue__(0, $2);
2022 MAYBE_CASE_LIST : {$$=0;}
2023 MAYBE_CASE_LIST : CASE_LIST {$$=$1;}
2024 MAYBE_CASE_LIST : DEFAULT {$$=$1;}
2025 MAYBE_CASE_LIST : CASE_LIST DEFAULT {$$=code_append($1,$2);}
2026 CASE_LIST: CASE {$$=$1;}
2027 CASE_LIST: CASE_LIST CASE {$$=code_append($$,$2);}
2029 CASE: "case" E ':' MAYBECODE {
2031 $$ = code_append($$, $2.c);
2032 code_t*j = $$ = abc_ifne($$, 0);
2033 $$ = code_append($$, $4);
2034 if($$->opcode != OPCODE___BREAK__) {
2035 $$ = abc___fallthrough__($$, "");
2037 code_t*e = $$ = abc_nop($$);
2040 DEFAULT: "default" ':' MAYBECODE {
2043 SWITCH : T_SWITCH '(' {new_state();} E ')' '{' MAYBE_CASE_LIST '}' {
2045 $$ = code_append($$, $7);
2046 code_t*out = $$ = abc_pop($$);
2047 breakjumpsto($$, $1, out);
2049 code_t*c = $$,*lastblock=0;
2051 if(c->opcode == OPCODE_IFNE) {
2052 if(!c->next) syntaxerror("internal error in fallthrough handling");
2054 } else if(c->opcode == OPCODE___FALLTHROUGH__) {
2056 c->opcode = OPCODE_JUMP;
2057 c->branch = lastblock;
2059 /* fall through end of switch */
2060 c->opcode = OPCODE_NOP;
2070 /* ------------ try / catch /finally ---------------- */
2072 CATCH: "catch" '(' T_IDENTIFIER MAYBETYPE ')' {new_state();state->exception_name=$3;new_variable($3, $4, 0);}
2074 namespace_t name_ns = {ACCESS_PACKAGE, ""};
2075 multiname_t name = {QNAME, &name_ns, 0, $3};
2077 NEW(abc_exception_t, e)
2078 e->exc_type = sig2mname($4);
2079 e->var_name = multiname_clone(&name);
2083 int i = find_variable_safe($3)->index;
2084 e->target = c = abc_nop(0);
2085 c = abc_setlocal(c, i);
2086 c = code_append(c, $8);
2092 FINALLY: "finally" '{' {new_state();state->exception_name=0;} MAYBECODE '}' {
2098 NEW(abc_exception_t, e)
2099 e->exc_type = 0; //all exceptions
2100 e->var_name = 0; //no name
2103 e->to = code_append(e->to, $4);
2109 CATCH_LIST: CATCH {$$.l=list_new();$$.finally=0;list_append($$.l,$1);}
2110 CATCH_LIST: CATCH_LIST CATCH {$$=$1;list_append($$.l,$2);}
2111 CATCH_FINALLY_LIST: CATCH_LIST {$$=$1;}
2112 CATCH_FINALLY_LIST: CATCH_LIST FINALLY {
2116 list_append($$.l,$2);
2117 $$.finally = $2->to;$2->to=0;
2120 CATCH_FINALLY_LIST: FINALLY {
2124 list_append($$.l,$1);
2125 $$.finally = $1->to;$1->to=0;
2129 TRY : "try" '{' {new_state();} MAYBECODE '}' CATCH_FINALLY_LIST {
2130 code_t*out = abc_nop(0);
2132 code_t*start = abc_nop(0);
2133 $$ = code_append(start, $4);
2134 if(!is_break_or_jump($4)) {
2135 $$ = abc_jump($$, out);
2137 code_t*end = $$ = abc_nop($$);
2141 tmp = new_variable("__finally__", 0, 0);
2143 abc_exception_list_t*l = $6.l;
2146 abc_exception_t*e = l->abc_exception;
2148 $$ = code_append($$, e->target);
2149 $$ = abc_jump($$, out);
2151 parserassert((ptroff_t)$6.finally);
2153 e->target = $$ = abc_nop($$);
2154 $$ = abc___rethrow__($$);
2162 $$ = code_append($$, out);
2164 $$ = insert_finally($$, $6.finally, tmp);
2166 list_concat(state->method->exceptions, $6.l);
2172 /* ------------ throw ------------------------------- */
2174 THROW : "throw" EXPRESSION {
2178 THROW : "throw" %prec prec_none {
2179 if(!state->exception_name)
2180 syntaxerror("re-throw only possible within a catch block");
2181 variable_t*v = find_variable(state->exception_name);
2183 $$=abc_getlocal($$, v->index);
2187 /* ------------ with -------------------------------- */
2189 WITH : "with" '(' EXPRESSION ')' CODEBLOCK {
2191 $$ = abc_pushscope($$);
2192 $$ = code_append($$, $5);
2193 $$ = abc_popscope($$);
2196 /* ------------ packages and imports ---------------- */
2198 X_IDENTIFIER: T_IDENTIFIER
2199 | "package" {PASS12 $$="package";}
2201 PACKAGE: PACKAGE '.' X_IDENTIFIER {PASS12 $$ = concat3($1,".",$3);free($1);$1=0;}
2202 PACKAGE: X_IDENTIFIER {PASS12 $$=strdup($1);}
2204 PACKAGE_DECLARATION : "package" PACKAGE '{' {PASS12 startpackage($2);free($2);$2=0;}
2205 MAYBE_INPACKAGE_CODE_LIST '}' {PASS12 endpackage();$$=0;}
2206 PACKAGE_DECLARATION : "package" '{' {PASS12 startpackage("");}
2207 MAYBE_INPACKAGE_CODE_LIST '}' {PASS12 endpackage();$$=0;}
2209 IMPORT : "import" PACKAGEANDCLASS {
2211 if(!registry_find($2->package, $2->name)) {
2212 as3_schedule_class($2->package, $2->name);
2218 syntaxerror("Couldn't import class\n");
2219 state_has_imports();
2220 dict_put(state->imports, c->name, c);
2223 IMPORT : "import" PACKAGE '.' '*' {
2225 if(strncmp("flash.", $2, 6)) {
2226 as3_schedule_package($2);
2232 state_has_imports();
2233 list_append(state->wildcard_imports, i);
2237 /* ------------ classes and interfaces (header) -------------- */
2239 MAYBE_MODIFIERS : %prec above_function {PASS12 $$=0;}
2240 MAYBE_MODIFIERS : MODIFIER_LIST {PASS12 $$=$1;}
2241 MODIFIER_LIST : MODIFIER {PASS12 $$=$1;}
2242 MODIFIER_LIST : MODIFIER_LIST MODIFIER {PASS12 $$=$1|$2;}
2244 MODIFIER : KW_PUBLIC {PASS12 $$=FLAG_PUBLIC;}
2245 | KW_PRIVATE {PASS12 $$=FLAG_PRIVATE;}
2246 | KW_PROTECTED {PASS12 $$=FLAG_PROTECTED;}
2247 | KW_STATIC {PASS12 $$=FLAG_STATIC;}
2248 | KW_DYNAMIC {PASS12 $$=FLAG_DYNAMIC;}
2249 | KW_FINAL {PASS12 $$=FLAG_FINAL;}
2250 | KW_OVERRIDE {PASS12 $$=FLAG_OVERRIDE;}
2251 | KW_NATIVE {PASS12 $$=FLAG_NATIVE;}
2252 | KW_INTERNAL {PASS12 $$=FLAG_PACKAGEINTERNAL;}
2253 | T_NAMESPACE {PASS12 $$=FLAG_NAMESPACE;}
2255 EXTENDS : {$$=registry_getobjectclass();}
2256 EXTENDS : KW_EXTENDS CLASS_SPEC {$$=$2;}
2258 EXTENDS_LIST : {PASS12 $$=list_new();}
2259 EXTENDS_LIST : KW_EXTENDS CLASS_SPEC_LIST {PASS12 $$=$2;}
2261 IMPLEMENTS_LIST : {PASS12 $$=list_new();}
2262 IMPLEMENTS_LIST : KW_IMPLEMENTS CLASS_SPEC_LIST {PASS12 $$=$2;}
2264 CLASS_DECLARATION : MAYBE_MODIFIERS "class" T_IDENTIFIER
2265 EXTENDS IMPLEMENTS_LIST
2266 '{' {PASS12 startclass($1,$3,$4,$5);}
2268 '}' {PASS12 endclass();$$=0;}
2270 INTERFACE_DECLARATION : MAYBE_MODIFIERS "interface" T_IDENTIFIER
2272 '{' {PASS12 startclass($1|FLAG_INTERFACE,$3,0,$4);}
2273 MAYBE_INTERFACE_BODY
2274 '}' {PASS12 endclass();$$=0;}
2276 /* ------------ classes and interfaces (body) -------------- */
2279 MAYBE_CLASS_BODY : CLASS_BODY
2280 CLASS_BODY : CLASS_BODY_ITEM
2281 CLASS_BODY : CLASS_BODY CLASS_BODY_ITEM
2282 CLASS_BODY_ITEM : ';'
2283 CLASS_BODY_ITEM : CONDITIONAL_COMPILATION '{' MAYBE_CLASS_BODY '}'
2284 CLASS_BODY_ITEM : SLOT_DECLARATION
2285 CLASS_BODY_ITEM : FUNCTION_DECLARATION
2287 CLASS_BODY_ITEM : CODE_STATEMENT {
2288 code_t*c = state->cls->static_init->header;
2289 c = code_append(c, $1);
2290 state->cls->static_init->header = c;
2293 MAYBE_INTERFACE_BODY :
2294 MAYBE_INTERFACE_BODY : INTERFACE_BODY
2295 INTERFACE_BODY : IDECLARATION
2296 INTERFACE_BODY : INTERFACE_BODY IDECLARATION
2298 IDECLARATION : "var" T_IDENTIFIER {
2299 syntaxerror("variable declarations not allowed in interfaces");
2301 IDECLARATION : MAYBE_MODIFIERS "function" GETSET T_IDENTIFIER '(' MAYBE_PARAM_LIST ')' MAYBETYPE {
2304 if($1&(FLAG_PRIVATE|FLAG_PACKAGEINTERNAL|FLAG_PROTECTED)) {
2305 syntaxerror("invalid method modifiers: interface methods always need to be public");
2307 startfunction(0,$1,$3,$4,&$6,$8);
2308 endfunction(0,$1,$3,$4,&$6,$8, 0);
2309 list_deep_free($6.list);
2312 /* ------------ classes and interfaces (body, slots ) ------- */
2314 VARCONST: "var" | "const"
2316 SLOT_DECLARATION: MAYBE_MODIFIERS VARCONST T_IDENTIFIER {setstaticfunction($1);} MAYBETYPE MAYBEEXPRESSION {
2318 U8 access = flags2access($1);
2320 varinfo_t* info = 0;
2322 memberinfo_t*i = registry_findmember(state->cls->info, $3, 1);
2324 check_override(i, flags);
2326 info = varinfo_register_onclass(state->cls->info, access, $3);
2328 slotinfo_t*i = registry_find(state->package, $3);
2330 syntaxerror("package %s already contains '%s'", state->package, $3);
2332 info = varinfo_register_global(access, state->package, $3);
2336 info->flags = flags;
2339 namespace_t mname_ns = {access, ""};
2340 multiname_t mname = {QNAME, &mname_ns, 0, $3};
2342 trait_list_t**traits;
2346 mname_ns.name = state->package;
2347 traits = &global->init->traits;
2348 code = &global->init->method->body->code;
2349 } else if(flags&FLAG_STATIC) {
2351 traits = &state->cls->abc->static_traits;
2352 code = &state->cls->static_init->header;
2354 // instance variable
2355 traits = &state->cls->abc->traits;
2356 code = &state->cls->init->header;
2362 t = trait_new_member(traits, multiname_clone(&m), multiname_clone(&mname), 0);
2364 t = trait_new_member(traits, 0, multiname_clone(&mname), 0);
2366 info->slot = t->slot_id;
2368 /* initalization code (if needed) */
2370 if($6.c && !is_pushundefined($6.c)) {
2371 c = abc_getlocal_0(c);
2372 c = code_append(c, $6.c);
2373 c = converttype(c, $6.t, $5);
2374 c = abc_setslot(c, t->slot_id);
2377 *code = code_append(*code, c);
2380 t->kind= TRAIT_CONST;
2384 setstaticfunction(0);
2387 /* ------------ constants -------------------------------------- */
2389 MAYBESTATICCONSTANT: {$$=0;}
2390 MAYBESTATICCONSTANT: '=' STATICCONSTANT {$$=$2;}
2392 STATICCONSTANT : T_BYTE {$$ = constant_new_int($1);}
2393 STATICCONSTANT : T_INT {$$ = constant_new_int($1);}
2394 STATICCONSTANT : T_UINT {$$ = constant_new_uint($1);}
2395 STATICCONSTANT : T_FLOAT {$$ = constant_new_float($1);}
2396 STATICCONSTANT : T_STRING {$$ = constant_new_string2($1.str,$1.len);free((char*)$1.str);}
2397 //STATICCONSTANT : T_NAMESPACE {$$ = constant_new_namespace($1);}
2398 STATICCONSTANT : "true" {$$ = constant_new_true($1);}
2399 STATICCONSTANT : "false" {$$ = constant_new_false($1);}
2400 STATICCONSTANT : "null" {$$ = constant_new_null($1);}
2401 STATICCONSTANT : T_IDENTIFIER {
2403 as3_warning("Couldn't resolve %s", $1);
2404 $$ = constant_new_null($1);
2407 /* ------------ classes and interfaces (body, functions) ------- */
2409 // non-vararg version
2412 memset(&$$,0,sizeof($$));
2414 MAYBE_PARAM_LIST: PARAM_LIST {
2420 MAYBE_PARAM_LIST: "..." PARAM {
2422 memset(&$$,0,sizeof($$));
2424 list_append($$.list, $2);
2426 MAYBE_PARAM_LIST: PARAM_LIST ',' "..." PARAM {
2430 list_append($$.list, $4);
2434 PARAM_LIST: PARAM_LIST ',' PARAM {
2437 list_append($$.list, $3);
2441 memset(&$$,0,sizeof($$));
2442 list_append($$.list, $1);
2445 PARAM: T_IDENTIFIER ':' TYPE MAYBESTATICCONSTANT {
2448 $$ = malloc(sizeof(param_t));
2453 PARAM: T_IDENTIFIER MAYBESTATICCONSTANT {
2456 $$ = malloc(sizeof(param_t));
2458 $$->type = TYPE_ANY;
2461 GETSET : "get" {$$=$1;}
2465 FUNCTION_DECLARATION: MAYBE_MODIFIERS "function" GETSET T_IDENTIFIER '(' MAYBE_PARAM_LIST ')'
2466 MAYBETYPE '{' {PASS12 startfunction(0,$1,$3,$4,&$6,$8);} MAYBECODE '}'
2468 PASS1 old_state();list_deep_free($6.list);
2470 if(!state->method->info) syntaxerror("internal error");
2472 code_t*c = method_header(state->method);
2473 c = wrap_function(c, 0, $11);
2475 endfunction(0,$1,$3,$4,&$6,$8,c);
2476 list_deep_free($6.list);
2480 MAYBE_IDENTIFIER: T_IDENTIFIER
2481 MAYBE_IDENTIFIER: {PASS12 $$=0;}
2482 INNERFUNCTION: "function" MAYBE_IDENTIFIER '(' MAYBE_PARAM_LIST ')' MAYBETYPE
2483 '{' {PASS12 innerfunction($2,&$4,$6);} MAYBECODE '}'
2485 PASS1 old_state();list_deep_free($4.list);
2487 methodinfo_t*f = state->method->info;
2488 if(!f || !f->kind) syntaxerror("internal error");
2490 code_t*c = method_header(state->method);
2491 c = wrap_function(c, 0, $9);
2493 int index = state->method->var_index;
2494 endfunction(0,0,0,$2,&$4,$6,c);
2495 list_deep_free($4.list);
2497 $$.c = abc_getlocal(0, index);
2498 $$.t = TYPE_FUNCTION(f);
2502 /* ------------- package + class ids --------------- */
2504 CLASS: T_IDENTIFIER {
2507 /* try current package */
2508 slotinfo_t*s = find_class($1);
2509 if(!s) syntaxerror("Could not find class/method %s\n", $1);
2510 $$ = (classinfo_t*)s;
2513 PACKAGEANDCLASS : PACKAGE '.' T_IDENTIFIER {
2514 PASS1 static classinfo_t c;
2515 memset(&c, 0, sizeof(c));
2520 slotinfo_t*s = registry_find($1, $3);
2521 if(!s) syntaxerror("Couldn't find class/method %s.%s\n", $1, $3);
2523 $$ = (classinfo_t*)s;
2526 CLASS_SPEC: PACKAGEANDCLASS
2529 CLASS_SPEC_LIST : CLASS_SPEC {PASS12 $$=list_new();list_append($$, $1);}
2530 CLASS_SPEC_LIST : CLASS_SPEC_LIST ',' CLASS_SPEC {PASS12 $$=$1;list_append($$,$3);}
2532 TYPE : CLASS_SPEC {$$=$1;}
2533 | '*' {$$=registry_getanytype();}
2534 | "void" {$$=registry_getanytype();}
2536 | "String" {$$=registry_getstringclass();}
2537 | "int" {$$=registry_getintclass();}
2538 | "uint" {$$=registry_getuintclass();}
2539 | "Boolean" {$$=registry_getbooleanclass();}
2540 | "Number" {$$=registry_getnumberclass();}
2543 MAYBETYPE: ':' TYPE {$$=$2;}
2546 /* ----------function calls, delete, constructor calls ------ */
2548 MAYBE_PARAM_VALUES : %prec prec_none {$$.cc=0;$$.len=0;}
2549 MAYBE_PARAM_VALUES : '(' MAYBE_EXPRESSION_LIST ')' {$$=$2;}
2551 MAYBE_EXPRESSION_LIST : {$$.cc=0;$$.len=0;}
2552 MAYBE_EXPRESSION_LIST : EXPRESSION_LIST
2553 MAYBE_EXPRESSION_LIST : EXPRESSION_LIST_AND_COMMA
2555 EXPRESSION_LIST : NONCOMMAEXPRESSION {$$.len=1;
2559 EXPRESSION_LIST_AND_COMMA: EXPRESSION_LIST ',' {$$ = $1;}
2560 EXPRESSION_LIST : EXPRESSION_LIST_AND_COMMA NONCOMMAEXPRESSION {
2562 $$.cc = code_append($1.cc, $2.c);
2566 NEW : "new" E XX MAYBE_PARAM_VALUES {
2568 if($$.c->opcode == OPCODE_COERCE_A) $$.c = code_cutlast($$.c);
2570 code_t*paramcode = $4.cc;
2571 if($$.c->opcode == OPCODE_GETPROPERTY) {
2572 multiname_t*name = $$.c->data[0];$$.c->data[0]=0;
2573 $$.c = code_cutlast($$.c);
2574 $$.c = code_append($$.c, paramcode);
2575 $$.c = abc_constructprop2($$.c, name, $4.len);
2576 multiname_destroy(name);
2577 } else if($$.c->opcode == OPCODE_GETSLOT) {
2578 int slot = (int)(ptroff_t)$$.c->data[0];
2579 trait_t*t = abc_class_find_slotid(state->cls->abc,slot);//FIXME
2580 multiname_t*name = t->name;
2581 $$.c = code_cutlast($$.c);
2582 $$.c = code_append($$.c, paramcode);
2583 $$.c = abc_constructprop2($$.c, name, $4.len);
2585 $$.c = code_append($$.c, paramcode);
2586 $$.c = abc_construct($$.c, $4.len);
2590 if(TYPE_IS_CLASS($2.t) && $2.t->data) {
2593 $$.c = abc_coerce_a($$.c);
2598 /* TODO: use abc_call (for calling local variables),
2599 abc_callstatic (for calling own methods)
2602 FUNCTIONCALL : E '(' MAYBE_EXPRESSION_LIST ')' {
2605 if($$.c->opcode == OPCODE_COERCE_A) {
2606 $$.c = code_cutlast($$.c);
2608 code_t*paramcode = $3.cc;
2611 if($$.c->opcode == OPCODE_GETPROPERTY) {
2612 multiname_t*name = $$.c->data[0];$$.c->data[0]=0;
2613 $$.c = code_cutlast($$.c);
2614 $$.c = code_append($$.c, paramcode);
2615 $$.c = abc_callproperty2($$.c, name, $3.len);
2616 multiname_destroy(name);
2617 } else if($$.c->opcode == OPCODE_GETSLOT) {
2618 int slot = (int)(ptroff_t)$$.c->data[0];
2619 trait_t*t = abc_class_find_slotid(state->cls->abc,slot);//FIXME
2620 if(t->kind!=TRAIT_METHOD) {
2621 //ok: flash allows to assign closures to members.
2623 multiname_t*name = t->name;
2624 $$.c = code_cutlast($$.c);
2625 $$.c = code_append($$.c, paramcode);
2626 //$$.c = abc_callmethod($$.c, t->method, len); //#1051 illegal early access binding
2627 $$.c = abc_callproperty2($$.c, name, $3.len);
2628 } else if($$.c->opcode == OPCODE_GETSUPER) {
2629 multiname_t*name = $$.c->data[0];$$.c->data[0]=0;
2630 $$.c = code_cutlast($$.c);
2631 $$.c = code_append($$.c, paramcode);
2632 $$.c = abc_callsuper2($$.c, name, $3.len);
2633 multiname_destroy(name);
2635 $$.c = abc_getglobalscope($$.c);
2636 $$.c = code_append($$.c, paramcode);
2637 $$.c = abc_call($$.c, $3.len);
2640 if(TYPE_IS_FUNCTION($1.t) && $1.t->data) {
2641 $$.t = ((methodinfo_t*)($1.t->data))->return_type;
2643 $$.c = abc_coerce_a($$.c);
2648 FUNCTIONCALL : "super" '(' MAYBE_EXPRESSION_LIST ')' {
2649 if(!state->cls) syntaxerror("super() not allowed outside of a class");
2650 if(!state->method) syntaxerror("super() not allowed outside of a function");
2651 if(!state->method->is_constructor) syntaxerror("super() not allowed outside of a constructor");
2654 $$.c = abc_getlocal_0($$.c);
2656 $$.c = code_append($$.c, $3.cc);
2658 this is dependent on the control path, check this somewhere else
2659 if(state->method->has_super)
2660 syntaxerror("constructor may call super() only once");
2662 state->method->has_super = 1;
2664 $$.c = abc_constructsuper($$.c, $3.len);
2665 $$.c = abc_pushundefined($$.c);
2669 DELETE: "delete" E {
2671 if($$.c->opcode == OPCODE_COERCE_A) {
2672 $$.c = code_cutlast($$.c);
2674 multiname_t*name = 0;
2675 if($$.c->opcode == OPCODE_GETPROPERTY) {
2676 $$.c->opcode = OPCODE_DELETEPROPERTY;
2677 } else if($$.c->opcode == OPCODE_GETSLOT) {
2678 int slot = (int)(ptroff_t)$$.c->data[0];
2679 multiname_t*name = abc_class_find_slotid(state->cls->abc,slot)->name;
2680 $$.c = code_cutlast($$.c);
2681 $$.c = abc_deleteproperty2($$.c, name);
2683 $$.c = abc_getlocal_0($$.c);
2684 MULTINAME_LATE(m, $2.t?$2.t->access:ACCESS_PACKAGE, "");
2685 $$.c = abc_deleteproperty2($$.c, &m);
2687 $$.t = TYPE_BOOLEAN;
2690 RETURN: "return" %prec prec_none {
2691 $$ = abc_returnvoid(0);
2693 RETURN: "return" EXPRESSION {
2695 $$ = abc_returnvalue($$);
2698 // ----------------------- expression types -------------------------------------
2700 NONCOMMAEXPRESSION : E %prec below_minus {$$=$1;}
2701 EXPRESSION : E %prec below_minus {$$ = $1;}
2702 EXPRESSION : EXPRESSION ',' E %prec below_minus {
2704 $$.c = cut_last_push($$.c);
2705 $$.c = code_append($$.c,$3.c);
2708 VOIDEXPRESSION : EXPRESSION %prec below_minus {
2709 $$=cut_last_push($1.c);
2712 // ----------------------- expression evaluation -------------------------------------
2714 E : INNERFUNCTION %prec prec_none {$$ = $1;}
2715 //V : CONSTANT {$$ = 0;}
2717 //V : VAR_READ %prec T_IDENTIFIER {$$ = 0;}
2718 E : VAR_READ %prec T_IDENTIFIER {$$ = $1;}
2719 //V : NEW {$$ = $1.c;}
2721 //V : DELETE {$$ = $1.c;}
2722 E : DELETE {$$ = $1;}
2728 namespace_t ns = {ACCESS_PACKAGE, ""};
2729 multiname_t m = {QNAME, &ns, 0, "RegExp"};
2731 $$.c = abc_getlex2($$.c, &m);
2732 $$.c = abc_pushstring($$.c, $1.pattern);
2733 $$.c = abc_construct($$.c, 1);
2735 $$.c = abc_getlex2($$.c, &m);
2736 $$.c = abc_pushstring($$.c, $1.pattern);
2737 $$.c = abc_pushstring($$.c, $1.options);
2738 $$.c = abc_construct($$.c, 2);
2743 CONSTANT : T_BYTE {$$.c = abc_pushbyte(0, $1);
2744 //MULTINAME(m, registry_getintclass());
2745 //$$.c = abc_coerce2($$.c, &m); // FIXME
2748 CONSTANT : T_SHORT {$$.c = abc_pushshort(0, $1);
2751 CONSTANT : T_INT {$$.c = abc_pushint(0, $1);
2754 CONSTANT : T_UINT {$$.c = abc_pushuint(0, $1);
2757 CONSTANT : T_FLOAT {$$.c = abc_pushdouble(0, $1);
2760 CONSTANT : T_STRING {$$.c = abc_pushstring2(0, &$1);free((char*)$1.str);
2763 CONSTANT : "undefined" {$$.c = abc_pushundefined(0);
2766 CONSTANT : "true" {$$.c = abc_pushtrue(0);
2767 $$.t = TYPE_BOOLEAN;
2769 CONSTANT : "false" {$$.c = abc_pushfalse(0);
2770 $$.t = TYPE_BOOLEAN;
2772 CONSTANT : "null" {$$.c = abc_pushnull(0);
2776 E : E '<' E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterequals($$.c);$$.c=abc_not($$.c);
2777 $$.t = TYPE_BOOLEAN;
2779 E : E '>' E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterthan($$.c);
2780 $$.t = TYPE_BOOLEAN;
2782 E : E "<=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterthan($$.c);$$.c=abc_not($$.c);
2783 $$.t = TYPE_BOOLEAN;
2785 E : E ">=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterequals($$.c);
2786 $$.t = TYPE_BOOLEAN;
2788 E : E "==" E {$$.c = code_append($1.c,$3.c);$$.c = abc_equals($$.c);
2789 $$.t = TYPE_BOOLEAN;
2791 E : E "===" E {$$.c = code_append($1.c,$3.c);$$.c = abc_strictequals($$.c);
2792 $$.t = TYPE_BOOLEAN;
2794 E : E "!==" E {$$.c = code_append($1.c,$3.c);$$.c = abc_strictequals($$.c);$$.c = abc_not($$.c);
2795 $$.t = TYPE_BOOLEAN;
2797 E : E "!=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_equals($$.c);$$.c = abc_not($$.c);
2798 $$.t = TYPE_BOOLEAN;
2801 E : E "||" E {$$.t = join_types($1.t, $3.t, 'O');
2803 $$.c = converttype($$.c, $1.t, $$.t);
2804 $$.c = abc_dup($$.c);
2805 code_t*jmp = $$.c = abc_iftrue($$.c, 0);
2806 $$.c = cut_last_push($$.c);
2807 $$.c = code_append($$.c,$3.c);
2808 $$.c = converttype($$.c, $3.t, $$.t);
2809 code_t*label = $$.c = abc_label($$.c);
2810 jmp->branch = label;
2813 $$.t = join_types($1.t, $3.t, 'A');
2814 /*printf("%08x:\n",$1.t);
2815 code_dump($1.c, 0, 0, "", stdout);
2816 printf("%08x:\n",$3.t);
2817 code_dump($3.c, 0, 0, "", stdout);
2818 printf("joining %08x and %08x to %08x\n", $1.t, $3.t, $$.t);*/
2820 $$.c = converttype($$.c, $1.t, $$.t);
2821 $$.c = abc_dup($$.c);
2822 code_t*jmp = $$.c = abc_iffalse($$.c, 0);
2823 $$.c = cut_last_push($$.c);
2824 $$.c = code_append($$.c,$3.c);
2825 $$.c = converttype($$.c, $3.t, $$.t);
2826 code_t*label = $$.c = abc_label($$.c);
2827 jmp->branch = label;
2830 E : '!' E {$$.c=$2.c;
2831 $$.c = abc_not($$.c);
2832 $$.t = TYPE_BOOLEAN;
2835 E : '~' E {$$.c=$2.c;
2836 $$.c = abc_bitnot($$.c);
2840 E : E '&' E {$$.c = code_append($1.c,$3.c);
2841 $$.c = abc_bitand($$.c);
2845 E : E '^' E {$$.c = code_append($1.c,$3.c);
2846 $$.c = abc_bitxor($$.c);
2850 E : E '|' E {$$.c = code_append($1.c,$3.c);
2851 $$.c = abc_bitor($$.c);
2855 E : E ">>" E {$$.c = code_append($1.c,$3.c);
2856 $$.c = abc_rshift($$.c);
2859 E : E ">>>" E {$$.c = code_append($1.c,$3.c);
2860 $$.c = abc_urshift($$.c);
2863 E : E "<<" E {$$.c = code_append($1.c,$3.c);
2864 $$.c = abc_lshift($$.c);
2868 E : E '/' E {$$.c = code_append($1.c,$3.c);
2869 $$.c = abc_divide($$.c);
2872 E : E '%' E {$$.c = code_append($1.c,$3.c);
2873 $$.c = abc_modulo($$.c);
2876 E : E '+' E {$$.c = code_append($1.c,$3.c);
2877 if(BOTH_INT($1.t, $3.t)) {
2878 $$.c = abc_add_i($$.c);
2881 $$.c = abc_add($$.c);
2882 $$.t = join_types($1.t,$3.t,'+');
2885 E : E '-' E {$$.c = code_append($1.c,$3.c);
2886 if(BOTH_INT($1.t,$3.t)) {
2887 $$.c = abc_subtract_i($$.c);
2890 $$.c = abc_subtract($$.c);
2894 E : E '*' E {$$.c = code_append($1.c,$3.c);
2895 if(BOTH_INT($1.t,$3.t)) {
2896 $$.c = abc_multiply_i($$.c);
2899 $$.c = abc_multiply($$.c);
2904 E : E "in" E {$$.c = code_append($1.c,$3.c);
2905 $$.c = abc_in($$.c);
2906 $$.t = TYPE_BOOLEAN;
2909 E : E "as" E {char use_astype=0; // flash player's astype works differently than astypelate
2910 if(use_astype && TYPE_IS_CLASS($3.t) && $3.t->data) {
2911 MULTINAME(m, (classinfo_t*)($3.t->data));
2912 $$.c = abc_astype2($1.c, &m);
2915 $$.c = code_append($1.c, $3.c);
2916 $$.c = abc_astypelate($$.c);
2921 E : E "instanceof" E
2922 {$$.c = code_append($1.c, $3.c);
2923 $$.c = abc_instanceof($$.c);
2924 $$.t = TYPE_BOOLEAN;
2927 E : E "is" E {$$.c = code_append($1.c, $3.c);
2928 $$.c = abc_istypelate($$.c);
2929 $$.t = TYPE_BOOLEAN;
2932 E : "typeof" '(' E ')' {
2934 $$.c = abc_typeof($$.c);
2939 $$.c = cut_last_push($2.c);
2940 $$.c = abc_pushundefined($$.c);
2944 E : "void" { $$.c = abc_pushundefined(0);
2948 E : '(' EXPRESSION ')' {$$=$2;} //allow commas in here, too
2953 $$.c=abc_negate_i($$.c);
2956 $$.c=abc_negate($$.c);
2963 $$.c = code_append($$.c, $3.c);
2965 MULTINAME_LATE(m, $1.t?$1.t->access:ACCESS_PACKAGE, "");
2966 $$.c = abc_getproperty2($$.c, &m);
2967 $$.t = 0; // array elements have unknown type
2970 E : '[' MAYBE_EXPRESSION_LIST ']' {
2972 $$.c = code_append($$.c, $2.cc);
2973 $$.c = abc_newarray($$.c, $2.len);
2974 $$.t = registry_getarrayclass();
2977 MAYBE_EXPRPAIR_LIST : {$$.cc=0;$$.len=0;}
2978 MAYBE_EXPRPAIR_LIST : EXPRPAIR_LIST {$$=$1;}
2980 EXPRPAIR_LIST : NONCOMMAEXPRESSION ':' NONCOMMAEXPRESSION {
2982 $$.cc = code_append($$.cc, $1.c);
2983 $$.cc = code_append($$.cc, $3.c);
2986 EXPRPAIR_LIST : EXPRPAIR_LIST ',' NONCOMMAEXPRESSION ':' NONCOMMAEXPRESSION {
2989 $$.cc = code_append($$.cc, $3.c);
2990 $$.cc = code_append($$.cc, $5.c);
2995 E : "{ (dictionary)" MAYBE_EXPRPAIR_LIST '}' {
2997 $$.c = code_append($$.c, $2.cc);
2998 $$.c = abc_newobject($$.c, $2.len/2);
2999 $$.t = registry_getobjectclass();
3004 if(BOTH_INT($1.t,$3.t)) {
3005 c=abc_multiply_i(c);
3009 c=converttype(c, join_types($1.t, $3.t, '*'), $1.t);
3010 $$.c = toreadwrite($1.c, c, 0, 0);
3015 code_t*c = abc_modulo($3.c);
3016 c=converttype(c, join_types($1.t, $3.t, '%'), $1.t);
3017 $$.c = toreadwrite($1.c, c, 0, 0);
3021 code_t*c = abc_lshift($3.c);
3022 c=converttype(c, join_types($1.t, $3.t, '<'), $1.t);
3023 $$.c = toreadwrite($1.c, c, 0, 0);
3027 code_t*c = abc_rshift($3.c);
3028 c=converttype(c, join_types($1.t, $3.t, '>'), $1.t);
3029 $$.c = toreadwrite($1.c, c, 0, 0);
3033 code_t*c = abc_urshift($3.c);
3034 c=converttype(c, join_types($1.t, $3.t, 'U'), $1.t);
3035 $$.c = toreadwrite($1.c, c, 0, 0);
3039 code_t*c = abc_divide($3.c);
3040 c=converttype(c, join_types($1.t, $3.t, '/'), $1.t);
3041 $$.c = toreadwrite($1.c, c, 0, 0);
3045 code_t*c = abc_bitor($3.c);
3046 c=converttype(c, TYPE_INT, $1.t);
3047 $$.c = toreadwrite($1.c, c, 0, 0);
3051 code_t*c = abc_bitxor($3.c);
3052 c=converttype(c, TYPE_INT, $1.t);
3053 $$.c = toreadwrite($1.c, c, 0, 0);
3059 if(TYPE_IS_INT($1.t)) {
3063 c=converttype(c, join_types($1.t, $3.t, '+'), $1.t);
3066 $$.c = toreadwrite($1.c, c, 0, 0);
3069 E : E "-=" E { code_t*c = $3.c;
3070 if(TYPE_IS_INT($1.t)) {
3071 c=abc_subtract_i(c);
3074 c=converttype(c, join_types($1.t, $3.t, '-'), $1.t);
3077 $$.c = toreadwrite($1.c, c, 0, 0);
3080 E : E '=' E { code_t*c = 0;
3081 c = code_append(c, $3.c);
3082 c = converttype(c, $3.t, $1.t);
3083 $$.c = toreadwrite($1.c, c, 1, 0);
3087 E : E '?' E ':' E %prec below_assignment {
3088 $$.t = join_types($3.t,$5.t,'?');
3090 code_t*j1 = $$.c = abc_iffalse($$.c, 0);
3091 $$.c = code_append($$.c, $3.c);
3092 $$.c = converttype($$.c, $3.t, $$.t);
3093 code_t*j2 = $$.c = abc_jump($$.c, 0);
3094 $$.c = j1->branch = abc_label($$.c);
3095 $$.c = code_append($$.c, $5.c);
3096 $$.c = converttype($$.c, $3.t, $$.t);
3097 $$.c = j2->branch = abc_label($$.c);
3100 E : E "++" { code_t*c = 0;
3101 classinfo_t*type = $1.t;
3102 if((is_getlocal($1.c) && TYPE_IS_INT($1.t)) || TYPE_IS_NUMBER($1.t)) {
3103 int nr = getlocalnr($1.c);
3104 code_free($1.c);$1.c=0;
3105 if(TYPE_IS_INT($1.t)) {
3106 $$.c = abc_getlocal(0, nr);
3107 $$.c = abc_inclocal_i($$.c, nr);
3108 } else if(TYPE_IS_NUMBER($1.t)) {
3109 $$.c = abc_getlocal(0, nr);
3110 $$.c = abc_inclocal($$.c, nr);
3111 } else syntaxerror("internal error");
3113 if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
3114 c=abc_increment_i(c);
3120 c=converttype(c, type, $1.t);
3121 $$.c = toreadwrite($1.c, c, 0, 1);
3126 // TODO: use inclocal, like with ++
3127 E : E "--" { code_t*c = 0;
3128 classinfo_t*type = $1.t;
3129 if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
3130 c=abc_decrement_i(c);
3136 c=converttype(c, type, $1.t);
3137 $$.c = toreadwrite($1.c, c, 0, 1);
3141 E : "++" %prec plusplus_prefix E { code_t*c = 0;
3142 classinfo_t*type = $2.t;
3143 if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
3144 c=abc_increment_i(c);
3150 c=converttype(c, type, $2.t);
3151 $$.c = toreadwrite($2.c, c, 0, 0);
3155 E : "--" %prec minusminus_prefix E { code_t*c = 0;
3156 classinfo_t*type = $2.t;
3157 if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
3158 c=abc_decrement_i(c);
3164 c=converttype(c, type, $2.t);
3165 $$.c = toreadwrite($2.c, c, 0, 0);
3169 E : "super" '.' T_IDENTIFIER
3170 { if(!state->cls->info)
3171 syntaxerror("super keyword not allowed outside a class");
3172 classinfo_t*t = state->cls->info->superclass;
3173 if(!t) t = TYPE_OBJECT;
3175 memberinfo_t*f = registry_findmember(t, $3, 1);
3176 namespace_t ns = {f->access, ""};
3177 MEMBER_MULTINAME(m, f, $3);
3179 $$.c = abc_getlocal_0($$.c);
3180 $$.c = abc_getsuper2($$.c, &m);
3181 $$.t = slotinfo_gettype((slotinfo_t*)f);
3184 E : '@' T_IDENTIFIER {
3186 $$.c = abc_pushundefined(0);
3188 as3_warning("ignored @ operator");
3191 E : E '.' '@' T_IDENTIFIER {
3192 // child attribute TODO
3193 $$.c = abc_pushundefined(0);
3195 as3_warning("ignored .@ operator");
3198 E : E '.' T_IDENTIFIER "::" T_IDENTIFIER {
3199 // namespace declaration TODO
3200 $$.c = abc_pushundefined(0);
3202 as3_warning("ignored :: operator");
3205 E : E ".." T_IDENTIFIER {
3207 $$.c = abc_pushundefined(0);
3209 as3_warning("ignored .. operator");
3212 E : E '.' '(' E ')' {
3214 $$.c = abc_pushundefined(0);
3216 as3_warning("ignored .() operator");
3219 //VARIABLE : VARIABLE "::" '[' EXPRESSION ']' // qualified expression
3223 E : E '.' T_IDENTIFIER
3225 classinfo_t*t = $1.t;
3227 if(TYPE_IS_CLASS(t) && t->data) {
3232 memberinfo_t*f = registry_findmember(t, $3, 1);
3234 if(f && !is_static != !(f->flags&FLAG_STATIC))
3236 if(f && f->slot && !noslot) {
3237 $$.c = abc_getslot($$.c, f->slot);
3239 MEMBER_MULTINAME(m, f, $3);
3240 $$.c = abc_getproperty2($$.c, &m);
3242 /* determine type */
3243 $$.t = slotinfo_gettype((slotinfo_t*)f);
3245 $$.c = abc_coerce_a($$.c);
3247 /* when resolving a property on an unknown type, we do know the
3248 name of the property (and don't seem to need the package), but
3249 we need to make avm2 try out all access modes */
3250 multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, $3};
3251 $$.c = abc_getproperty2($$.c, &m);
3252 $$.c = abc_coerce_a($$.c);
3253 $$.t = registry_getanytype();
3257 VAR_READ : T_IDENTIFIER {
3264 /* look at variables */
3265 if((v = find_variable($1))) {
3266 // $1 is a local variable
3267 $$.c = abc_getlocal($$.c, v->index);
3272 int i_am_static = (state->method && state->method->info)?(state->method->info->flags&FLAG_STATIC):FLAG_STATIC;
3274 /* look at current class' members */
3275 if(state->cls && (f = registry_findmember(state->cls->info, $1, 1)) &&
3276 (f->flags&FLAG_STATIC) >= i_am_static) {
3277 // $1 is a function in this class
3278 int var_is_static = (f->flags&FLAG_STATIC);
3280 if(f->kind == INFOTYPE_METHOD) {
3281 $$.t = TYPE_FUNCTION(f);
3285 if(var_is_static && !i_am_static) {
3286 /* access to a static member from a non-static location.
3287 do this via findpropstrict:
3288 there doesn't seem to be any non-lookup way to access
3289 static properties of a class */
3290 state->method->late_binding = 1;
3292 namespace_t ns = {f->access, ""};
3293 multiname_t m = {QNAME, &ns, 0, $1};
3294 $$.c = abc_findpropstrict2($$.c, &m);
3295 $$.c = abc_getproperty2($$.c, &m);
3297 } else if(f->slot>0) {
3298 $$.c = abc_getlocal_0($$.c);
3299 $$.c = abc_getslot($$.c, f->slot);
3302 namespace_t ns = {f->access, ""};
3303 multiname_t m = {QNAME, &ns, 0, $1};
3304 $$.c = abc_getlocal_0($$.c);
3305 $$.c = abc_getproperty2($$.c, &m);
3310 /* look at actual classes, in the current package and imported */
3311 if((a = find_class($1))) {
3312 if(a->access == ACCESS_PACKAGEINTERNAL &&
3313 strcmp(a->package, state->package) &&
3314 strcmp(a->package, internal_filename_package)
3316 syntaxerror("Can't access internal %s %s in package '%s' from package '%s'",
3317 infotypename(a),$1, a->package, state->package);
3319 if(a->kind != INFOTYPE_CLASS) {
3321 $$.c = abc_findpropstrict2($$.c, &m);
3322 $$.c = abc_getproperty2($$.c, &m);
3323 if(a->kind == INFOTYPE_METHOD) {
3324 methodinfo_t*f = (methodinfo_t*)a;
3325 $$.t = TYPE_FUNCTION(f);
3327 varinfo_t*v = (varinfo_t*)a;
3331 classinfo_t*c = (classinfo_t*)a;
3333 $$.c = abc_getglobalscope($$.c);
3334 $$.c = abc_getslot($$.c, c->slot);
3337 $$.c = abc_getlex2($$.c, &m);
3339 $$.t = TYPE_CLASS(c);
3344 /* unknown object, let the avm2 resolve it */
3346 as3_softwarning("Couldn't resolve '%s', doing late binding", $1);
3347 state->method->late_binding = 1;
3349 multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, $1};
3352 $$.c = abc_findpropstrict2($$.c, &m);
3353 $$.c = abc_getproperty2($$.c, &m);
3357 // ----------------- namespaces -------------------------------------------------
3359 NAMESPACE_DECLARATION : MAYBE_MODIFIERS "namespace" T_IDENTIFIER {$$=0;}
3360 NAMESPACE_DECLARATION : MAYBE_MODIFIERS "namespace" T_IDENTIFIER '=' T_IDENTIFIER {$$=0;}
3361 NAMESPACE_DECLARATION : MAYBE_MODIFIERS "namespace" T_IDENTIFIER '=' T_STRING {$$=0;}
3363 USE_NAMESPACE : "use" "namespace" T_IDENTIFIER {
3365 tokenizer_register_namespace($3);