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"
42 enum yytokentype token;
45 classinfo_t*classinfo;
46 classinfo_list_t*classinfo_list;
49 unsigned int number_uint;
53 typedcode_list_t*value_list;
62 %token<id> T_IDENTIFIER
64 %token<token> T_REGEXP
66 %token<number_int> T_INT
67 %token<number_uint> T_UINT
68 %token<number_uint> T_BYTE
69 %token<number_uint> T_SHORT
70 %token<number_float> T_FLOAT
72 %token<token> KW_IMPLEMENTS
73 %token<token> KW_NAMESPACE "namespace"
74 %token<token> KW_PACKAGE "package"
75 %token<token> KW_PROTECTED
76 %token<token> KW_PUBLIC
77 %token<token> KW_PRIVATE
78 %token<token> KW_USE "use"
79 %token<token> KW_INTERNAL
80 %token<token> KW_NEW "new"
81 %token<token> KW_NATIVE
82 %token<token> KW_FUNCTION "function"
83 %token<token> KW_FOR "for"
84 %token<token> KW_CLASS "class"
85 %token<token> KW_CONST "const"
86 %token<token> KW_SET "set"
87 %token<token> KW_STATIC
88 %token<token> KW_IMPORT "import"
89 %token<token> KW_RETURN "return"
90 %token<token> KW_INTERFACE "interface"
91 %token<token> KW_NULL "null"
92 %token<token> KW_VAR "var"
93 %token<token> KW_DYNAMIC
94 %token<token> KW_OVERRIDE
95 %token<token> KW_FINAL
96 %token<token> KW_GET "get"
97 %token<token> KW_EXTENDS
98 %token<token> KW_FALSE "false"
99 %token<token> KW_TRUE "true"
100 %token<token> KW_BOOLEAN "Boolean"
101 %token<token> KW_UINT "uint"
102 %token<token> KW_INT "int"
103 %token<token> KW_WHILE "while"
104 %token<token> KW_NUMBER "Number"
105 %token<token> KW_STRING "String"
106 %token<token> KW_IF "if"
107 %token<token> KW_ELSE "else"
108 %token<token> KW_BREAK "break"
109 %token<token> KW_IS "is"
110 %token<token> KW_AS "as"
112 %token<token> T_EQEQ "=="
113 %token<token> T_EQEQEQ "==="
114 %token<token> T_NE "!="
115 %token<token> T_LE "<="
116 %token<token> T_GE ">="
117 %token<token> T_DIVBY "/="
118 %token<token> T_MODBY "%="
119 %token<token> T_MULBY "*="
120 %token<token> T_PLUSBY "+="
121 %token<token> T_MINUSBY "-="
122 %token<token> T_SHRBY ">>="
123 %token<token> T_SHLBY "<<="
124 %token<token> T_USHRBY ">>>="
125 %token<token> T_OROR "||"
126 %token<token> T_ANDAND "&&"
127 %token<token> T_COLONCOLON "::"
128 %token<token> T_MINUSMINUS "--"
129 %token<token> T_PLUSPLUS "++"
130 %token<token> T_DOTDOT ".."
131 %token<token> T_DOTDOTDOT "..."
132 %token<token> T_SHL "<<"
133 %token<token> T_USHR ">>>"
134 %token<token> T_SHR ">>"
135 %token<token> T_SEMICOLON ';'
136 %token<token> T_STAR '*'
137 %token<token> T_DOT '.'
139 %type <id> X_IDENTIFIER PACKAGE
140 %type <token> VARCONST
142 %type <code> CODEPIECE
143 %type <code> CODEBLOCK MAYBECODE
144 %type <token> PACKAGE_DECLARATION
145 %type <token> FUNCTION_DECLARATION
146 %type <code> VARIABLE_DECLARATION ONE_VARIABLE VARIABLE_LIST
147 %type <token> CLASS_DECLARATION
148 %type <token> NAMESPACE_DECLARATION
149 %type <token> INTERFACE_DECLARATION
150 %type <code> VOIDEXPRESSION
151 %type <value> EXPRESSION NONCOMMAEXPRESSION
152 %type <value> MAYBEEXPRESSION
154 %type <value> CONSTANT
155 %type <code> FOR IF WHILE MAYBEELSE BREAK RETURN
156 %type <token> USE_NAMESPACE
157 %type <code> FOR_INIT
159 %type <classinfo> MAYBETYPE
162 %type <params> PARAM_LIST
163 %type <params> MAYBE_PARAM_LIST
164 %type <flags> MAYBE_MODIFIERS
165 %type <flags> MODIFIER_LIST
166 %type <constant> STATICCONSTANT MAYBESTATICCONSTANT
167 %type <classinfo_list> IMPLEMENTS_LIST
168 %type <classinfo> EXTENDS
169 %type <classinfo_list> EXTENDS_LIST
170 %type <classinfo> CLASS PACKAGEANDCLASS QNAME
171 %type <classinfo_list> QNAME_LIST
172 %type <classinfo> TYPE
174 //%type <token> VARIABLE
175 %type <value> VAR_READ
177 //%type <token> T_IDENTIFIER
178 %type <token> MODIFIER
179 %type <value> FUNCTIONCALL
180 %type <value_list> MAYBE_EXPRESSION_LIST EXPRESSION_LIST MAYBE_PARAM_VALUES
182 // precedence: from low to high
183 // http://livedocs.adobe.com/flash/9.0/main/wwhelp/wwhimpl/common/html/wwhelp.htm?context=LiveDocs_Parts&file=00000012.html
187 %right '=' "/=" "%=" "*=" "+=" "-=" ">>=" "<<=" ">>>="
193 %nonassoc "!=" "==" "===" "<=" '<' ">=" '>' // TODO: support "a < b < c" syntax?
195 %left prec_belowminus
210 %nonassoc T_IDENTIFIER
211 %left below_semicolon
216 // needed for "return" precedence:
217 %nonassoc T_STRING T_REGEXP
218 %nonassoc T_INT T_UINT T_BYTE T_SHORT T_FLOAT
219 %nonassoc "new" "false" "true" "null"
226 static int yyerror(char*s)
228 syntaxerror("%s", s);
230 static char* concat3str(const char* t1, const char* t2, const char* t3)
235 char*text = malloc(l1+l2+l3+1);
236 memcpy(text , t1, l1);
237 memcpy(text+l1, t2, l2);
238 memcpy(text+l1+l2, t3, l3);
243 typedef struct _import {
247 DECLARE_LIST(import);
249 typedef struct _state {
257 /* code that needs to be executed at the start of
258 a method (like initializing local registers) */
261 import_list_t*wildcard_imports;
263 char has_own_imports;
269 code_t*cls_static_init;
279 typedef struct _global {
283 static global_t*global = 0;
284 static state_t* state = 0;
288 #define MULTINAME(m,x) multiname_t m;namespace_t m##_ns;registry_fill_multiname(&m, &m##_ns, x);
290 /* warning: list length of namespace set is undefined */
291 #define MULTINAME_LATE(m, access, package) \
292 namespace_t m##_ns = {access, package}; \
293 namespace_set_t m##_nsset; \
294 namespace_list_t m##_l;m##_l.next = 0; \
295 m##_nsset.namespaces = &m##_l; \
296 m##_nsset = m##_nsset; \
297 m##_l.namespace = &m##_ns; \
298 multiname_t m = {MULTINAMEL, 0, &m##_nsset, 0};
300 static state_list_t*state_stack=0;
302 static void init_globals()
304 global = rfx_calloc(sizeof(global_t));
307 static void new_state()
310 NEW(state_list_t, sl);
312 state_t*oldstate = state;
314 memcpy(s, state, sizeof(state_t)); //shallow copy
315 sl->next = state_stack;
318 s->imports = dict_new();
323 state->vars = dict_new();
325 state->has_own_imports = 0;
327 static void state_has_imports()
329 state->wildcard_imports = list_clone(state->wildcard_imports);
330 state->imports = dict_clone(state->imports);
331 state->has_own_imports = 1;
334 static void old_state()
336 if(!state_stack || !state_stack->next)
337 syntaxerror("invalid nesting");
338 state_t*oldstate = state;
339 state_list_t*old = state_stack;
340 state_stack = state_stack->next;
342 state = state_stack->state;
343 /*if(state->initcode) {
344 printf("residual initcode\n");
345 code_dump(state->initcode, 0, 0, "", stdout);
347 if(oldstate->has_own_imports) {
348 list_free(oldstate->wildcard_imports);
349 dict_destroy(oldstate->imports);oldstate->imports=0;
351 state->initcode = code_append(state->initcode, oldstate->initcode);
353 void initialize_state()
358 state->file = abc_file_new();
359 state->file->flags &= ~ABCFILE_LAZY;
361 state->init = abc_initscript(state->file, 0, 0);
362 code_t*c = state->init->method->body->code;
364 c = abc_getlocal_0(c);
365 c = abc_pushscope(c);
367 /* findpropstrict doesn't just return a scope object- it
368 also makes it "active" somehow. Push local_0 on the
369 scope stack and read it back with findpropstrict, it'll
370 contain properties like "trace". Trying to find the same
371 property on a "vanilla" local_0 yields only a "undefined" */
372 //c = abc_findpropstrict(c, "[package]::trace");
374 /*c = abc_getlocal_0(c);
375 c = abc_findpropstrict(c, "[package]::trace");
377 c = abc_setlocal_1(c);
379 c = abc_pushbyte(c, 0);
380 c = abc_setlocal_2(c);
382 code_t*xx = c = abc_label(c);
383 c = abc_findpropstrict(c, "[package]::trace");
384 c = abc_pushstring(c, "prop:");
385 c = abc_hasnext2(c, 1, 2);
387 c = abc_setlocal_3(c);
388 c = abc_callpropvoid(c, "[package]::trace", 2);
389 c = abc_getlocal_3(c);
391 c = abc_iftrue(c,xx);*/
393 c = abc_findpropstrict(c, "[package]::trace");
394 c = abc_pushstring(c, "[entering global init function]");
395 c = abc_callpropvoid(c, "[package]::trace", 1);
397 state->init->method->body->code = c;
399 void* finalize_state()
401 if(state->level!=1) {
402 syntaxerror("unexpected end of file");
404 abc_method_body_t*m = state->init->method->body;
407 __ findpropstrict(m, "[package]::trace");
408 __ pushstring(m, "[leaving global init function]");
409 __ callpropvoid(m, "[package]::trace", 1);
415 static void startpackage(char*name)
418 syntaxerror("Packages can not be nested.");
421 /*printf("entering package \"%s\"\n", name);*/
422 state->package = name;
424 static void endpackage()
426 /*printf("leaving package \"%s\"\n", state->package);*/
431 static void startclass(int flags, char*classname, classinfo_t*extends, classinfo_list_t*implements, char interface)
434 syntaxerror("inner classes now allowed");
439 classinfo_list_t*mlist=0;
440 /*printf("entering class %s\n", name);
441 printf(" modifiers: ");for(t=modifiers->tokens;t;t=t->next) printf("%s ", t->token);printf("\n");
443 printf(" extends: %s.%s\n", extends->package, extends->name);
444 printf(" implements (%d): ", list_length(implements));
445 for(mlist=implements;mlist;mlist=mlist->next) {
446 printf("%s ", mlist->classinfo?mlist->classinfo->name:0);
451 if(flags&~(FLAG_INTERNAL|FLAG_PUBLIC|FLAG_FINAL))
452 syntaxerror("invalid modifier(s)");
454 if((flags&(FLAG_PUBLIC|FLAG_INTERNAL)) == (FLAG_PUBLIC|FLAG_INTERNAL))
455 syntaxerror("public and internal not supported at the same time.");
457 /* create the class name, together with the proper attributes */
461 if(!(flags&FLAG_PUBLIC) && !state->package) {
462 access = ACCESS_PRIVATE; package = current_filename;
463 } else if(!(flags&FLAG_PUBLIC) && state->package) {
464 access = ACCESS_PACKAGEINTERNAL; package = state->package;
465 } else if(state->package) {
466 access = ACCESS_PACKAGE; package = state->package;
468 syntaxerror("public classes only allowed inside a package");
471 if(registry_findclass(package, classname)) {
472 syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, classname);
475 /* build info struct */
476 int num_interfaces = (list_length(implements));
477 state->clsinfo = classinfo_register(access, package, classname, num_interfaces);
478 state->clsinfo->superclass = extends;
480 classinfo_list_t*l = implements;
481 for(l=implements;l;l=l->next) {
482 state->clsinfo->interfaces[pos++] = l->classinfo;
485 MULTINAME(classname2,state->clsinfo);
487 multiname_t*extends2 = sig2mname(extends);
490 state->cls_init = abc_getlocal_0(state->cls_init);
491 state->cls_init = abc_constructsuper(state->cls_init, 0);
494 state->cls = abc_class_new(state->file, &classname2, extends2);
495 if(flags&FLAG_FINAL) abc_class_final(state->cls);
496 if(flags&FLAG_DYNAMIC) abc_class_sealed(state->cls);
497 if(interface) abc_class_interface(state->cls);
499 for(mlist=implements;mlist;mlist=mlist->next) {
500 MULTINAME(m, mlist->classinfo);
501 abc_class_add_interface(state->cls, &m);
504 /* now write the construction code for this class */
505 int slotindex = abc_initscript_addClassTrait(state->init, &classname2, state->cls);
507 abc_method_body_t*m = state->init->method->body;
508 __ getglobalscope(m);
509 classinfo_t*s = extends;
514 //TODO: take a look at the current scope stack, maybe
515 // we can re-use something
520 multiname_t*s2 = sig2mname(s);
522 multiname_destroy(s2);
524 __ pushscope(m); count++;
525 m->code = m->code->prev->prev; // invert
527 /* continue appending after last op end */
528 while(m->code && m->code->next) m->code = m->code->next;
530 /* TODO: if this is one of *our* classes, we can also
531 do a getglobalscope/getslot <nr> (which references
532 the init function's slots) */
534 __ getlex2(m, extends2);
536 /* notice: we get a Verify Error #1107 if the top elemnt on the scope
537 stack is not the superclass */
538 __ pushscope(m);count++;
541 /* notice: we get a verify error #1107 if the top element on the scope
542 stack is not the global object */
544 __ pushscope(m);count++;
546 __ newclass(m,state->cls);
550 __ setslot(m, slotindex);
552 /* flash.display.MovieClip handling */
553 if(!globalclass && (flags&FLAG_PUBLIC) && classinfo_equals(registry_getMovieClip(),extends)) {
554 if(state->package && state->package[0]) {
555 globalclass = concat3str(state->package, ".", classname);
557 globalclass = strdup(classname);
560 multiname_destroy(extends2);
563 static void endclass()
565 if(state->cls_init) {
566 if(!state->cls->constructor) {
567 abc_method_t*m = abc_class_constructor(state->cls, 0, 0);
568 m->body->code = code_append(m->body->code, state->cls_init);
569 m->body->code = abc_returnvoid(m->body->code);
571 code_t*c = state->cls->constructor->body->code;
572 c = code_append(state->cls_init, c);
573 state->cls->constructor->body->code = c;
577 if(state->cls_static_init) {
578 if(!state->cls->static_constructor) {
579 abc_method_t*m = abc_class_staticconstructor(state->cls, 0, 0);
580 m->body->code = state->cls_static_init;
582 state->cls->static_constructor->body->code =
583 code_append(state->cls_static_init, state->cls->static_constructor->body->code);
590 typedef struct _variable {
595 static int find_variable(char*name, classinfo_t**m)
597 state_list_t* s = state_stack;
599 variable_t*v = dict_lookup(s->state->vars, name);
610 static int find_variable_safe(char*name, classinfo_t**m)
612 int i = find_variable(name, m);
614 syntaxerror("undefined variable: %s", name);
617 static char variable_exists(char*name)
619 return dict_lookup(state->vars, name)!=0;
621 static int new_variable(char*name, classinfo_t*type)
624 v->index = global->variable_count;
626 dict_put(state->vars, name, v);
627 return global->variable_count++;
629 #define TEMPVARNAME "__as3_temp__"
630 static int gettempvar()
632 int i = find_variable(TEMPVARNAME, 0);
634 return new_variable(TEMPVARNAME, 0);
640 code_t* killvars(code_t*c)
643 for(t=0;t<state->vars->hashsize;t++) {
644 dictentry_t*e =state->vars->slots[t];
646 variable_t*v = (variable_t*)e->data;
647 //do this always, otherwise register types don't match
648 //in the verifier when doing nested loops
649 //if(!TYPE_IS_BUILTIN_SIMPLE(type)) {
650 c = abc_kill(c, v->index);
658 static void check_constant_against_type(classinfo_t*t, constant_t*c)
660 #define xassert(b) if(!(b)) syntaxerror("Invalid default value %s for type '%s'", constant_tostring(c), t->name)
661 if(TYPE_IS_NUMBER(t)) {
662 xassert(c->type == CONSTANT_FLOAT
663 || c->type == CONSTANT_INT
664 || c->type == CONSTANT_UINT);
665 } else if(TYPE_IS_UINT(t)) {
666 xassert(c->type == CONSTANT_UINT ||
667 (c->type == CONSTANT_INT && c->i>0));
668 } else if(TYPE_IS_INT(t)) {
669 xassert(c->type == CONSTANT_INT);
670 } else if(TYPE_IS_BOOLEAN(t)) {
671 xassert(c->type == CONSTANT_TRUE
672 || c->type == CONSTANT_FALSE);
676 static memberinfo_t*registerfunction(enum yytokentype getset, char*name, params_t*params, classinfo_t*return_type, int slot)
678 memberinfo_t*minfo = 0;
679 if(getset != KW_GET && getset != KW_SET) {
680 if(registry_findmember(state->clsinfo, name)) {
681 syntaxerror("class already contains a member/method called '%s'", name);
683 minfo = memberinfo_register(state->clsinfo, name, MEMBER_METHOD);
684 minfo->return_type = return_type;
685 // getslot on a member slot only returns "undefined", so no need
686 // to actually store these
687 //state->minfo->slot = state->m->method->trait->slot_id;
689 int gs = getset==KW_GET?MEMBER_GET:MEMBER_SET;
693 else if(params->list)
694 type = params->list->param->type;
695 if((minfo=registry_findmember(state->clsinfo, name))) {
696 if(minfo->kind & ~(MEMBER_GET|MEMBER_SET))
697 syntaxerror("class already contains a member or method called '%s'", name);
699 syntaxerror("getter/setter for '%s' already defined", name);
700 /* make a setter or getter into a getset */
705 if(type && minfo->type != type)
706 syntaxerror("different type in getter and setter");
708 minfo = memberinfo_register(state->clsinfo, name, gs);
711 /* can't assign a slot as getter and setter might have different slots */
712 //minfo->slot = slot;
717 static void startfunction(token_t*ns, int flags, enum yytokentype getset, char*name,
718 params_t*params, classinfo_t*return_type)
722 global->variable_count = 0;
723 state->function = name;
726 syntaxerror("not able to start another method scope");
729 multiname_t*type2 = sig2mname(return_type);
730 if(!strcmp(state->clsinfo->name,name)) {
731 state->m = abc_class_constructor(state->cls, type2, 0);
733 state->m = abc_class_method(state->cls, type2, name, 0);
734 int slot = state->m->trait->slot_id;
735 state->minfo = registerfunction(getset, name, params, return_type, slot);
738 if(getset == KW_GET) state->m->trait->kind = TRAIT_GETTER;
739 if(getset == KW_SET) state->m->trait->kind = TRAIT_SETTER;
740 if(params->varargs) state->m->flags |= METHOD_NEED_REST;
744 for(p=params->list;p;p=p->next) {
745 if(params->varargs && !p->next) {
746 break; //varargs: omit last parameter in function signature
748 multiname_t*m = sig2mname(p->param->type);
749 list_append(state->m->parameters, m);
750 if(p->param->value) {
751 check_constant_against_type(p->param->type, p->param->value);
752 opt=1;list_append(state->m->optional_parameters, p->param->value);
754 syntaxerror("non-optional parameter not allowed after optional parameters");
758 /* state->vars is initialized by state_new */
759 if(new_variable("this", state->clsinfo)!=0) syntaxerror("Internal error");
761 for(p=params->list;p;p=p->next) {
762 new_variable(p->param->name, p->param->type);
765 static void endfunction(code_t*body)
768 if(!(state->cls->flags & CLASS_INTERFACE)) {
770 if(state->late_binding) {
771 c = abc_getlocal_0(c);
772 c = abc_pushscope(c);
774 c = code_append(c, state->initcode);
775 c = code_append(c, body);
777 /* append return if necessary */
778 if(!c || c->opcode != OPCODE_RETURNVOID &&
779 c->opcode != OPCODE_RETURNVALUE) {
780 c = abc_returnvoid(c);
782 if(state->m->body->code) syntaxerror("internal error");
783 state->m->body->code = c;
790 char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
795 void breakjumpsto(code_t*c, code_t*jump)
800 if(c->opcode == OPCODE___BREAK__) {
801 c->opcode = OPCODE_JUMP;
808 classinfo_t*join_types(classinfo_t*type1, classinfo_t*type2, char op)
811 return registry_getanytype();
812 if(TYPE_IS_ANY(type1) || TYPE_IS_ANY(type2))
813 return registry_getanytype();
816 return registry_getanytype();
818 code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
823 return abc_coerce_a(c);
827 // cast an "any" type to a specific type. subject to
828 // runtime exceptions
829 return abc_coerce2(c, &m);
832 if(TYPE_IS_NUMBER(from) && TYPE_IS_UINT(to)) {
833 return abc_coerce2(c, &m);
835 if(TYPE_IS_NUMBER(from) && TYPE_IS_INT(to)) {
836 return abc_coerce2(c, &m);
838 /* these are subject to overflow */
839 if(TYPE_IS_INT(from) && TYPE_IS_UINT(to)) {
840 return abc_coerce2(c, &m);
842 if(TYPE_IS_UINT(from) && TYPE_IS_INT(to)) {
843 return abc_coerce2(c, &m);
846 classinfo_t*supertype = from;
848 if(supertype == to) {
849 // target type is one of from's superclasses
850 return abc_coerce2(c, &m);
853 while(supertype->interfaces[t]) {
854 if(supertype->interfaces[t]==to) {
855 // to type is one of from's interfaces
856 return abc_coerce2(c, &m);
860 supertype = supertype->superclass;
862 if(TYPE_IS_FUNCTION(from) && TYPE_IS_FUNCTION(to))
864 syntaxerror("can't convert type %s to %s", from->name, to->name);
867 code_t*defaultvalue(code_t*c, classinfo_t*type)
869 if(TYPE_IS_INT(type) || TYPE_IS_UINT(type) || TYPE_IS_FLOAT(type)) {
870 c = abc_pushbyte(c, 0);
871 } else if(TYPE_IS_BOOLEAN(type)) {
872 c = abc_pushfalse(c);
879 char is_pushundefined(code_t*c)
881 return (c && !c->prev && !c->next && c->opcode == OPCODE_PUSHUNDEFINED);
884 void parserassert(int b)
886 if(!b) syntaxerror("internal error: assertion failed");
889 static code_t* toreadwrite(code_t*in, code_t*middlepart, char justassign, char readbefore)
893 [prefix code] [read instruction]
897 [prefix code] ([dup]) [read instruction] [middlepart] [setvar] [write instruction] [getvar]
900 if(in && in->opcode == OPCODE_COERCE_A) {
901 in = code_cutlast(in);
904 syntaxerror("internal error");
906 /* chop off read instruction */
910 prefix = r->prev;r->prev = 0;
916 char use_temp_var = readbefore;
918 /* generate the write instruction, and maybe append a dup to the prefix code */
919 code_t* write = abc_nop(0);
920 if(r->opcode == OPCODE_GETPROPERTY) {
921 write->opcode = OPCODE_SETPROPERTY;
922 multiname_t*m = (multiname_t*)r->data[0];
923 write->data[0] = multiname_clone(m);
925 syntaxerror("illegal lvalue: can't assign a value to this expression (not a qname)");
927 prefix = abc_dup(prefix); // we need the object, too
930 } else if(r->opcode == OPCODE_GETSLOT) {
931 write->opcode = OPCODE_SETSLOT;
932 write->data[0] = r->data[0];
934 prefix = abc_dup(prefix); // we need the object, too
937 } else if(r->opcode == OPCODE_GETLOCAL) {
938 write->opcode = OPCODE_SETLOCAL;
939 write->data[0] = r->data[0];
940 } else if(r->opcode == OPCODE_GETLOCAL_0) {
941 write->opcode = OPCODE_SETLOCAL_0;
942 } else if(r->opcode == OPCODE_GETLOCAL_1) {
943 write->opcode = OPCODE_SETLOCAL_1;
944 } else if(r->opcode == OPCODE_GETLOCAL_2) {
945 write->opcode = OPCODE_SETLOCAL_2;
946 } else if(r->opcode == OPCODE_GETLOCAL_3) {
947 write->opcode = OPCODE_SETLOCAL_3;
949 code_dump(r, 0, 0, "", stdout);
950 syntaxerror("illegal lvalue: can't assign a value to this expression");
957 /* with getproperty/getslot, we have to be extra careful not
958 to execute the read code twice, as it might have side-effects
959 (e.g. if the property is in fact a setter/getter combination)
961 So read the value, modify it, and write it again,
962 using prefix only once and making sure (by using a temporary
963 register) that the return value is what we just wrote */
965 c = code_append(c, prefix);
966 c = code_append(c, r);
969 c = abc_setlocal(c, temp);
971 c = code_append(c, middlepart);
974 c = abc_setlocal(c, temp);
976 c = code_append(c, write);
977 c = abc_getlocal(c, temp);
978 c = abc_kill(c, temp);
980 /* if we're allowed to execute the read code twice *and*
981 the middlepart doesn't modify the code, things are easier.
983 code_t* r2 = code_dup(r);
984 //c = code_append(c, prefix);
985 parserassert(!prefix);
986 c = code_append(c, r);
987 c = code_append(c, middlepart);
988 c = code_append(c, write);
989 c = code_append(c, r2);
992 /* even smaller version: overwrite the value without reading
996 c = code_append(c, prefix);
999 c = code_append(c, middlepart);
1000 c = code_append(c, write);
1001 c = code_append(c, r);
1003 temp = gettempvar();
1005 c = code_append(c, prefix);
1008 c = code_append(c, middlepart);
1010 c = abc_setlocal(c, temp);
1011 c = code_append(c, write);
1012 c = abc_getlocal(c, temp);
1025 /* ------------ code blocks / statements ---------------- */
1029 MAYBECODE: CODE {$$=$1;}
1030 MAYBECODE: {$$=code_new();}
1032 CODE: CODE CODEPIECE {$$=code_append($1,$2);}
1033 CODE: CODEPIECE {$$=$1;}
1035 CODEPIECE: PACKAGE_DECLARATION {$$=code_new();/*enters a scope*/}
1036 CODEPIECE: CLASS_DECLARATION {$$=code_new();/*enters a scope*/}
1037 CODEPIECE: FUNCTION_DECLARATION {$$=code_new();/*enters a scope*/}
1038 CODEPIECE: INTERFACE_DECLARATION {$$=code_new();}
1039 CODEPIECE: IMPORT {$$=code_new();/*adds imports to current scope*/}
1040 CODEPIECE: ';' {$$=code_new();}
1041 CODEPIECE: VARIABLE_DECLARATION {$$=$1}
1042 CODEPIECE: VOIDEXPRESSION {$$=$1}
1043 CODEPIECE: FOR {$$=$1}
1044 CODEPIECE: WHILE {$$=$1}
1045 CODEPIECE: BREAK {$$=$1}
1046 CODEPIECE: RETURN {$$=$1}
1047 CODEPIECE: IF {$$=$1}
1048 CODEPIECE: NAMESPACE_DECLARATION {/*TODO*/$$=code_new();}
1049 CODEPIECE: USE_NAMESPACE {/*TODO*/$$=code_new();}
1051 CODEBLOCK : '{' MAYBECODE '}' {$$=$2;}
1052 CODEBLOCK : CODEPIECE ';' {$$=$1;}
1053 CODEBLOCK : CODEPIECE %prec below_semicolon {$$=$1;}
1055 /* ------------ variables --------------------------- */
1057 MAYBEEXPRESSION : '=' NONCOMMAEXPRESSION {$$=$2;}
1058 | {$$.c=abc_pushundefined(0);
1062 VAR : "const" | "var"
1063 VARIABLE_DECLARATION : VAR VARIABLE_LIST {$$=$2;}
1065 VARIABLE_LIST: ONE_VARIABLE {$$ = $1;}
1066 VARIABLE_LIST: VARIABLE_LIST ',' ONE_VARIABLE {$$ = code_append($1, $3);}
1068 ONE_VARIABLE: {} T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION
1070 if(variable_exists($2))
1071 syntaxerror("Variable %s already defined", $2);
1073 if(!is_subtype_of($4.t, $3)) {
1074 syntaxerror("Can't convert %s to %s", $4.t->name,
1078 int index = new_variable($2, $3);
1081 if($4.c->prev || $4.c->opcode != OPCODE_PUSHUNDEFINED) {
1083 $$ = converttype($$, $4.t, $3);
1084 $$ = abc_setlocal($$, index);
1086 $$ = defaultvalue(0, $3);
1087 $$ = abc_setlocal($$, index);
1090 /* if this is a typed variable:
1091 push default value for type on stack */
1093 state->initcode = defaultvalue(state->initcode, $3);
1094 state->initcode = abc_setlocal(state->initcode, index);
1097 if($4.c->prev || $4.c->opcode != OPCODE_PUSHUNDEFINED) {
1099 $$ = abc_coerce_a($$);
1100 $$ = abc_setlocal($$, index);
1106 /* that's the default for a local register, anyway
1108 state->initcode = abc_pushundefined(state->initcode);
1109 state->initcode = abc_setlocal(state->initcode, index);
1111 //printf("variable %s -> %d (%s)\n", $2->text, index, $4.t?$4.t->name:"");
1114 /* ------------ control flow ------------------------- */
1116 MAYBEELSE: %prec prec_none {$$ = code_new();}
1117 MAYBEELSE: "else" CODEBLOCK {$$=$2;}
1118 //MAYBEELSE: ';' "else" CODEBLOCK {$$=$3;}
1120 IF : "if" '(' {new_state();} EXPRESSION ')' CODEBLOCK MAYBEELSE {
1121 $$ = state->initcode;state->initcode=0;
1123 $$ = code_append($$, $4.c);
1124 code_t*myjmp,*myif = $$ = abc_iffalse($$, 0);
1126 $$ = code_append($$, $6);
1128 myjmp = $$ = abc_jump($$, 0);
1130 myif->branch = $$ = abc_label($$);
1132 $$ = code_append($$, $7);
1133 myjmp->branch = $$ = abc_label($$);
1136 $$ = killvars($$);old_state();
1139 FOR_INIT : {$$=code_new();}
1140 FOR_INIT : VARIABLE_DECLARATION
1141 FOR_INIT : VOIDEXPRESSION
1143 FOR : "for" '(' {new_state();} FOR_INIT ';' EXPRESSION ';' VOIDEXPRESSION ')' CODEBLOCK {
1144 $$ = state->initcode;state->initcode=0;
1146 $$ = code_append($$, $4);
1147 code_t*loopstart = $$ = abc_label($$);
1148 $$ = code_append($$, $6.c);
1149 code_t*myif = $$ = abc_iffalse($$, 0);
1150 $$ = code_append($$, $10);
1151 $$ = code_append($$, $8);
1152 $$ = abc_jump($$, loopstart);
1153 code_t*out = $$ = abc_label($$);
1154 breakjumpsto($$, out);
1157 $$ = killvars($$);old_state();
1160 WHILE : "while" '(' {new_state();} EXPRESSION ')' CODEBLOCK {
1161 $$ = state->initcode;state->initcode=0;
1163 code_t*myjmp = $$ = abc_jump($$, 0);
1164 code_t*loopstart = $$ = abc_label($$);
1165 $$ = code_append($$, $6);
1166 myjmp->branch = $$ = abc_label($$);
1167 $$ = code_append($$, $4.c);
1168 $$ = abc_iftrue($$, loopstart);
1169 code_t*out = $$ = abc_label($$);
1170 breakjumpsto($$, out);
1172 $$ = killvars($$);old_state();
1176 $$ = abc___break__(0);
1179 /* ------------ packages and imports ---------------- */
1181 X_IDENTIFIER: T_IDENTIFIER
1182 | "package" {$$="package";}
1184 PACKAGE: PACKAGE '.' X_IDENTIFIER {$$ = concat3str($1,".",$3);}
1185 PACKAGE: X_IDENTIFIER {$$=$1;}
1187 PACKAGE_DECLARATION : "package" PACKAGE '{' {startpackage($2)} MAYBECODE '}' {endpackage()}
1188 PACKAGE_DECLARATION : "package" '{' {startpackage("")} MAYBECODE '}' {endpackage()}
1190 IMPORT : "import" QNAME {
1193 syntaxerror("Couldn't import class\n");
1194 state_has_imports();
1195 dict_put(state->imports, c->name, c);
1198 IMPORT : "import" PACKAGE '.' '*' {
1201 state_has_imports();
1202 list_append(state->wildcard_imports, i);
1206 /* ------------ classes and interfaces (header) -------------- */
1208 MAYBE_MODIFIERS : {$$=0;}
1209 MAYBE_MODIFIERS : MODIFIER_LIST {$$=$1}
1210 MODIFIER_LIST : MODIFIER {$$=$1;}
1211 MODIFIER_LIST : MODIFIER_LIST MODIFIER {$$=$1|$2;}
1213 MODIFIER : KW_PUBLIC {$$=FLAG_PUBLIC;}
1214 | KW_PRIVATE {$$=FLAG_PRIVATE;}
1215 | KW_PROTECTED {$$=FLAG_PROTECTED;}
1216 | KW_STATIC {$$=FLAG_STATIC;}
1217 | KW_DYNAMIC {$$=FLAG_DYNAMIC;}
1218 | KW_FINAL {$$=FLAG_FINAL;}
1219 | KW_OVERRIDE {$$=FLAG_OVERRIDE;}
1220 | KW_NATIVE {$$=FLAG_NATIVE;}
1221 | KW_INTERNAL {$$=FLAG_INTERNAL;}
1223 EXTENDS : {$$=registry_getobjectclass();}
1224 EXTENDS : KW_EXTENDS QNAME {$$=$2;}
1226 EXTENDS_LIST : {$$=list_new();}
1227 EXTENDS_LIST : KW_EXTENDS QNAME_LIST {$$=$2;}
1229 IMPLEMENTS_LIST : {$$=list_new();}
1230 IMPLEMENTS_LIST : KW_IMPLEMENTS QNAME_LIST {$$=$2;}
1232 CLASS_DECLARATION : MAYBE_MODIFIERS "class" T_IDENTIFIER
1233 EXTENDS IMPLEMENTS_LIST
1234 '{' {startclass($1,$3,$4,$5, 0);}
1235 MAYBE_DECLARATION_LIST
1238 INTERFACE_DECLARATION : MAYBE_MODIFIERS "interface" T_IDENTIFIER
1240 '{' {startclass($1,$3,0,$4,1);}
1241 MAYBE_IDECLARATION_LIST
1244 /* ------------ classes and interfaces (body) -------------- */
1246 MAYBE_DECLARATION_LIST :
1247 MAYBE_DECLARATION_LIST : DECLARATION_LIST
1248 DECLARATION_LIST : DECLARATION
1249 DECLARATION_LIST : DECLARATION_LIST DECLARATION
1251 DECLARATION : SLOT_DECLARATION
1252 DECLARATION : FUNCTION_DECLARATION
1254 MAYBE_IDECLARATION_LIST :
1255 MAYBE_IDECLARATION_LIST : IDECLARATION_LIST
1256 IDECLARATION_LIST : IDECLARATION
1257 IDECLARATION_LIST : IDECLARATION_LIST IDECLARATION
1259 IDECLARATION : "var" T_IDENTIFIER {
1260 syntaxerror("variable declarations not allowed in interfaces");
1262 IDECLARATION : MAYBE_MODIFIERS "function" GETSET T_IDENTIFIER '(' MAYBE_PARAM_LIST ')' MAYBETYPE {
1263 if($1&(FLAG_PUBLIC|FLAG_PRIVATE|FLAG_INTERNAL|FLAG_PROTECTED)) {
1264 syntaxerror("invalid method modifiers: interface methods are always public");
1266 startfunction(0,$1,$3,$4,&$6,$8);
1270 /* ------------ classes and interfaces (body, slots ) ------- */
1272 VARCONST: "var" | "const"
1273 SLOT_DECLARATION: MAYBE_MODIFIERS VARCONST T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION {
1275 memberinfo_t* info = memberinfo_register(state->clsinfo, $3, MEMBER_SLOT);
1281 t=abc_class_slot(state->cls, $3, &m);
1283 t=abc_class_slot(state->cls, $3, 0);
1286 t->kind= TRAIT_CONST;
1288 info->slot = t->slot_id;
1289 if($5.c && !is_pushundefined($5.c)) {
1291 c = abc_getlocal_0(c);
1292 c = code_append(c, $5.c);
1293 c = converttype(c, $5.t, $4);
1294 c = abc_setslot(c, t->slot_id);
1295 //c = abc_setproperty(c, $3);
1296 state->cls_init = code_append(state->cls_init, c);
1300 /* ------------ constants -------------------------------------- */
1302 MAYBESTATICCONSTANT: {$$=0;}
1303 MAYBESTATICCONSTANT: '=' STATICCONSTANT {$$=$2;}
1305 STATICCONSTANT : T_BYTE {$$ = constant_new_int($1);}
1306 STATICCONSTANT : T_INT {$$ = constant_new_int($1);}
1307 STATICCONSTANT : T_UINT {$$ = constant_new_uint($1);}
1308 STATICCONSTANT : T_FLOAT {$$ = constant_new_float($1);}
1309 STATICCONSTANT : T_STRING {$$ = constant_new_string2($1.str,$1.len);}
1310 //STATICCONSTANT : T_NAMESPACE {$$ = constant_new_namespace($1);}
1311 STATICCONSTANT : KW_TRUE {$$ = constant_new_true($1);}
1312 STATICCONSTANT : KW_FALSE {$$ = constant_new_false($1);}
1313 STATICCONSTANT : KW_NULL {$$ = constant_new_null($1);}
1315 /* ------------ classes and interfaces (body, functions) ------- */
1317 // non-vararg version
1319 memset(&$$,0,sizeof($$));
1321 MAYBE_PARAM_LIST: PARAM_LIST {
1326 MAYBE_PARAM_LIST: "..." PARAM {
1327 memset(&$$,0,sizeof($$));
1329 list_append($$.list, $2);
1331 MAYBE_PARAM_LIST: PARAM_LIST ',' "..." PARAM {
1334 list_append($$.list, $4);
1338 PARAM_LIST: PARAM_LIST ',' PARAM {
1340 list_append($$.list, $3);
1343 memset(&$$,0,sizeof($$));
1344 list_append($$.list, $1);
1347 PARAM: T_IDENTIFIER ':' TYPE MAYBESTATICCONSTANT {
1348 $$ = malloc(sizeof(param_t));
1353 PARAM: T_IDENTIFIER MAYBESTATICCONSTANT {
1354 $$ = malloc(sizeof(param_t));
1356 $$->type = TYPE_ANY;
1359 GETSET : "get" {$$=$1;}
1363 FUNCTION_DECLARATION: MAYBE_MODIFIERS "function" GETSET T_IDENTIFIER '(' MAYBE_PARAM_LIST ')'
1364 MAYBETYPE '{' {startfunction(0,$1,$3,$4,&$6,$8)} MAYBECODE '}'
1366 if(!state->m) syntaxerror("internal error: undefined function");
1370 /* ------------- package + class ids --------------- */
1372 CLASS: T_IDENTIFIER {
1374 /* try current package */
1375 $$ = registry_findclass(state->package, $1);
1377 /* try explicit imports */
1378 dictentry_t* e = dict_get_slot(state->imports, $1);
1382 if(!strcmp(e->key, $1)) {
1383 $$ = (classinfo_t*)e->data;
1388 /* try package.* imports */
1389 import_list_t*l = state->wildcard_imports;
1393 //printf("does package %s contain a class %s?\n", l->import->package, $1);
1394 $$ = registry_findclass(l->import->package, $1);
1398 /* try global package */
1400 $$ = registry_findclass("", $1);
1403 if(!$$) syntaxerror("Could not find class %s\n", $1);
1406 PACKAGEANDCLASS : PACKAGE '.' T_IDENTIFIER {
1407 $$ = registry_findclass($1, $3);
1408 if(!$$) syntaxerror("Couldn't find class %s.%s\n", $1, $3);
1411 QNAME: PACKAGEANDCLASS
1414 QNAME_LIST : QNAME {$$=list_new();list_append($$, $1);}
1415 QNAME_LIST : QNAME_LIST ',' QNAME {$$=$1;list_append($$,$3);}
1417 TYPE : QNAME {$$=$1;}
1418 | '*' {$$=registry_getanytype();}
1419 | "String" {$$=registry_getstringclass();}
1420 | "int" {$$=registry_getintclass();}
1421 | "uint" {$$=registry_getuintclass();}
1422 | "Boolean" {$$=registry_getbooleanclass();}
1423 | "Number" {$$=registry_getnumberclass();}
1425 MAYBETYPE: ':' TYPE {$$=$2;}
1428 /* ----------function calls, constructor calls ------ */
1430 MAYBE_PARAM_VALUES : %prec prec_none {$$=0;}
1431 MAYBE_PARAM_VALUES : '(' MAYBE_EXPRESSION_LIST ')' {$$=$2}
1433 MAYBE_EXPRESSION_LIST : {$$=0;}
1434 MAYBE_EXPRESSION_LIST : EXPRESSION_LIST
1435 EXPRESSION_LIST : NONCOMMAEXPRESSION {$$=list_new();
1436 typedcode_t*t = malloc(sizeof(typedcode_t));
1438 list_append($$, t);}
1439 EXPRESSION_LIST : EXPRESSION_LIST ',' NONCOMMAEXPRESSION {$$=$1;
1440 typedcode_t*t = malloc(sizeof(typedcode_t));
1442 list_append($$, t);}
1444 NEW : "new" CLASS MAYBE_PARAM_VALUES {
1448 /* TODO: why do we have to *find* our own classes? */
1449 $$.c = abc_findpropstrict2($$.c, &m);
1451 typedcode_list_t*l = $3;
1454 $$.c = code_append($$.c, l->typedcode->c); // push parameters on stack
1458 $$.c = abc_constructprop2($$.c, &m, len);
1462 /* TODO: use abc_call (for calling local variables),
1463 abc_callstatic (for calling own methods)
1466 FUNCTIONCALL : E '(' MAYBE_EXPRESSION_LIST ')' {
1467 typedcode_list_t*l = $3;
1469 code_t*paramcode = 0;
1471 paramcode = code_append(paramcode, l->typedcode->c); // push parameters on stack
1477 if($$.c->opcode == OPCODE_COERCE_A) {
1478 $$.c = code_cutlast($$.c);
1482 multiname_t*name = 0;
1483 if($$.c->opcode == OPCODE_GETPROPERTY) {
1484 name = multiname_clone($$.c->data[0]);
1485 $$.c = code_cutlast($$.c);
1486 $$.c = code_append($$.c, paramcode);
1487 $$.c = abc_callproperty2($$.c, name, len);
1488 } else if($$.c->opcode == OPCODE_GETSLOT) {
1489 int slot = (int)(ptroff_t)$$.c->data[0];
1490 trait_t*t = abc_class_find_slotid(state->cls,slot);//FIXME
1491 if(t->kind!=TRAIT_METHOD) {
1492 //flash allows to assign closures to members.
1493 //syntaxerror("not a function");
1496 $$.c = code_cutlast($$.c);
1497 $$.c = code_append($$.c, paramcode);
1498 //$$.c = abc_callmethod($$.c, t->method, len); //#1051 illegal early access binding
1499 $$.c = abc_callproperty2($$.c, name, len);
1501 $$.c = abc_getlocal_0($$.c);
1502 $$.c = code_append($$.c, paramcode);
1503 $$.c = abc_call($$.c, len);
1508 if(TYPE_IS_FUNCTION($1.t) &&
1509 (f = registry_findmember($1.t, "call"))) {
1510 $$.t = f->return_type;
1512 $$.c = abc_coerce_a($$.c);
1517 RETURN: "return" %prec prec_none {
1518 $$ = abc_returnvoid(0);
1520 RETURN: "return" EXPRESSION {
1522 $$ = abc_returnvalue($$);
1524 // ----------------------- expression types -------------------------------------
1526 NONCOMMAEXPRESSION : E %prec prec_belowminus {$$=$1;}
1527 EXPRESSION : E %prec prec_belowminus {$$ = $1;}
1528 EXPRESSION : EXPRESSION ',' E %prec prec_belowminus {
1530 $$.c = cut_last_push($$.c);
1531 $$.c = code_append($$.c,$3.c);
1534 VOIDEXPRESSION : EXPRESSION %prec prec_belowminus {$$=cut_last_push($1.c);}
1536 // ----------------------- expression evaluation -------------------------------------
1539 E : VAR_READ %prec T_IDENTIFIER {$$ = $1;}
1541 E : T_REGEXP {$$.c = abc_pushundefined(0); /* FIXME */
1545 CONSTANT : T_BYTE {$$.c = abc_pushbyte(0, $1);
1546 //MULTINAME(m, registry_getintclass());
1547 //$$.c = abc_coerce2($$.c, &m); // FIXME
1550 CONSTANT : T_SHORT {$$.c = abc_pushshort(0, $1);
1553 CONSTANT : T_INT {$$.c = abc_pushint(0, $1);
1556 CONSTANT : T_UINT {$$.c = abc_pushuint(0, $1);
1559 CONSTANT : T_FLOAT {$$.c = abc_pushdouble(0, $1);
1562 CONSTANT : T_STRING {$$.c = abc_pushstring2(0, &$1);
1565 CONSTANT : KW_TRUE {$$.c = abc_pushtrue(0);
1566 $$.t = TYPE_BOOLEAN;
1568 CONSTANT : KW_FALSE {$$.c = abc_pushfalse(0);
1569 $$.t = TYPE_BOOLEAN;
1571 CONSTANT : KW_NULL {$$.c = abc_pushnull(0);
1576 E : E '<' E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterequals($$.c);$$.c=abc_not($$.c);
1577 $$.t = TYPE_BOOLEAN;
1579 E : E '>' E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterthan($$.c);
1580 $$.t = TYPE_BOOLEAN;
1582 E : E "<=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterthan($$.c);$$.c=abc_not($$.c);
1583 $$.t = TYPE_BOOLEAN;
1585 E : E ">=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterequals($$.c);
1586 $$.t = TYPE_BOOLEAN;
1588 E : E "==" E {$$.c = code_append($1.c,$3.c);$$.c = abc_equals($$.c);
1589 $$.t = TYPE_BOOLEAN;
1591 E : E "===" E {$$.c = code_append($1.c,$3.c);$$.c = abc_strictequals($$.c);
1592 $$.t = TYPE_BOOLEAN;
1594 E : E "!=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_equals($$.c);$$.c = abc_not($$.c);
1595 $$.t = TYPE_BOOLEAN;
1598 E : E "||" E {$$.t = join_types($1.t, $3.t, 'O');
1600 $$.c = converttype($$.c, $1.t, $$.t);
1601 $$.c = abc_dup($$.c);
1602 code_t*jmp = $$.c = abc_iftrue($$.c, 0);
1603 $$.c = cut_last_push($$.c);
1604 $$.c = code_append($$.c,$3.c);
1605 $$.c = converttype($$.c, $3.t, $$.t);
1606 code_t*label = $$.c = abc_label($$.c);
1607 jmp->branch = label;
1610 $$.t = join_types($1.t, $3.t, 'A');
1611 /*printf("%08x:\n",$1.t);
1612 code_dump($1.c, 0, 0, "", stdout);
1613 printf("%08x:\n",$3.t);
1614 code_dump($3.c, 0, 0, "", stdout);
1615 printf("joining %08x and %08x to %08x\n", $1.t, $3.t, $$.t);*/
1617 $$.c = converttype($$.c, $1.t, $$.t);
1618 $$.c = abc_dup($$.c);
1619 code_t*jmp = $$.c = abc_iffalse($$.c, 0);
1620 $$.c = cut_last_push($$.c);
1621 $$.c = code_append($$.c,$3.c);
1622 $$.c = converttype($$.c, $3.t, $$.t);
1623 code_t*label = $$.c = abc_label($$.c);
1624 jmp->branch = label;
1627 E : '!' E {$$.c=$2.c;
1628 $$.c = abc_not($$.c);
1629 $$.t = TYPE_BOOLEAN;
1634 E : E '+' E {$$.c = code_append($1.c,$3.c);$$.c = abc_add($$.c);$$.c=abc_coerce_a($$.c);
1635 $$.t = join_types($1.t, $3.t, '+');
1637 E : E '%' E {$$.c = code_append($1.c,$3.c);$$.c = abc_modulo($$.c);$$.c=abc_coerce_a($$.c);
1638 $$.t = join_types($1.t, $3.t, '%');
1640 E : E '*' E {$$.c = code_append($1.c,$3.c);$$.c = abc_multiply($$.c);$$.c=abc_coerce_a($$.c);
1641 $$.t = join_types($1.t, $3.t, '*');
1646 E : '(' E ')' {$$=$2;}
1651 $$.c = code_append($$.c, $3.c);
1653 MULTINAME_LATE(m, $1.t?$1.t->access:ACCESS_PACKAGE, "");
1654 $$.c = abc_getproperty2($$.c, &m);
1659 if(TYPE_IS_INT($3.t) || TYPE_IS_UINT($3.t)) {
1660 c=abc_multiply_i(c);
1664 c=converttype(c, join_types($1.t, $3.t, '*'), $1.t);
1665 $$.c = toreadwrite($1.c, c, 0, 0);
1669 code_t*c = abc_modulo($3.c);
1670 c=converttype(c, join_types($1.t, $3.t, '%'), $1.t);
1671 $$.c = toreadwrite($1.c, c, 0, 0);
1675 code_t*c = abc_lshift($3.c);
1676 c=converttype(c, join_types($1.t, $3.t, '<'), $1.t);
1677 $$.c = toreadwrite($1.c, c, 0, 0);
1681 code_t*c = abc_rshift($3.c);
1682 c=converttype(c, join_types($1.t, $3.t, '>'), $1.t);
1683 $$.c = toreadwrite($1.c, c, 0, 0);
1687 code_t*c = abc_urshift($3.c);
1688 c=converttype(c, join_types($1.t, $3.t, 'U'), $1.t);
1689 $$.c = toreadwrite($1.c, c, 0, 0);
1693 code_t*c = abc_divide($3.c);
1694 c=converttype(c, join_types($1.t, $3.t, '/'), $1.t);
1695 $$.c = toreadwrite($1.c, c, 0, 0);
1700 if(TYPE_IS_INT($3.t) || TYPE_IS_UINT($3.t)) {
1705 c=converttype(c, join_types($1.t, $3.t, '+'), $1.t);
1707 $$.c = toreadwrite($1.c, c, 0, 0);
1710 E : E "-=" E { code_t*c = $3.c;
1711 if(TYPE_IS_INT($3.t) || TYPE_IS_UINT($3.t)) {
1712 c=abc_subtract_i(c);
1716 c=converttype(c, join_types($1.t, $3.t, '-'), $1.t);
1718 $$.c = toreadwrite($1.c, c, 0, 0);
1721 E : E '=' E { code_t*c = 0;
1722 c = code_append(c, $3.c);
1723 c = converttype(c, $3.t, $1.t);
1724 $$.c = toreadwrite($1.c, c, 1, 0);
1728 // TODO: use inclocal where appropriate
1729 E : E "++" { code_t*c = 0;
1730 classinfo_t*type = $1.t;
1731 if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
1732 c=abc_increment_i(c);
1738 c=converttype(c, type, $1.t);
1739 $$.c = toreadwrite($1.c, c, 0, 1);
1742 E : E "--" { code_t*c = 0;
1743 classinfo_t*type = $1.t;
1744 if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
1745 c=abc_decrement_i(c);
1751 c=converttype(c, type, $1.t);
1752 $$.c = toreadwrite($1.c, c, 0, 1);
1756 E : "++" E { code_t*c = 0;
1757 classinfo_t*type = $2.t;
1758 if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
1759 c=abc_increment_i(c);
1765 c=converttype(c, type, $2.t);
1766 $$.c = toreadwrite($2.c, c, 0, 0);
1770 E : "--" E { code_t*c = 0;
1771 classinfo_t*type = $2.t;
1772 if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
1773 c=abc_decrement_i(c);
1779 c=converttype(c, type, $2.t);
1780 $$.c = toreadwrite($2.c, c, 0, 0);
1784 E : E '.' T_IDENTIFIER
1787 memberinfo_t*f = registry_findmember($$.t, $3);
1790 $$.c = abc_getslot($$.c, f->slot);
1792 namespace_t ns = {$$.t->access, ""}; // needs to be "", not $$.t->package
1793 multiname_t m = {QNAME, &ns, 0, $3};
1794 $$.c = abc_getproperty2($$.c, &m);
1796 /* determine type */
1798 if(f->kind == MEMBER_METHOD) {
1799 $$.t = TYPE_FUNCTION(f);
1804 $$.c = abc_coerce_a($$.c);
1805 $$.t = registry_getanytype();
1808 namespace_t ns = {ACCESS_PACKAGE, ""};
1809 multiname_t m = {QNAME, &ns, 0, $3};
1810 $$.c = abc_getproperty2($$.c, &m);
1811 $$.c = abc_coerce_a($$.c);
1812 $$.t = registry_getanytype();
1816 VAR_READ : T_IDENTIFIER {
1821 if((i = find_variable($1, &$$.t)) >= 0) {
1822 // $1 is a local variable
1823 $$.c = abc_getlocal($$.c, i);
1824 } else if((f = registry_findmember(state->clsinfo, $1))) {
1825 // $1 is a function in this class
1826 if(f->kind == MEMBER_METHOD) {
1827 $$.t = TYPE_FUNCTION(f);
1832 $$.c = abc_getlocal_0($$.c);
1833 $$.c = abc_getslot($$.c, f->slot);
1835 namespace_t ns = {state->clsinfo->access, ""};
1836 multiname_t m = {QNAME, &ns, 0, $1};
1837 $$.c = abc_getlocal_0($$.c);
1838 $$.c = abc_getproperty2($$.c, &m);
1841 // let the avm2 resolve $1
1842 if(strcmp($1,"trace"))
1843 warning("Couldn't resolve %s, doing late binding", $1);
1844 state->late_binding = 1;
1847 $$.c = abc_findpropstrict($$.c, $1);
1848 $$.c = abc_getproperty($$.c, $1);
1853 //VARIABLE : VARIABLE ".." T_IDENTIFIER // descendants
1854 //VARIABLE : VARIABLE "::" VARIABLE // namespace declaration
1855 //VARIABLE : VARIABLE "::" '[' EXPRESSION ']' // qualified expression
1857 // ----------------- namespaces -------------------------------------------------
1859 NAMESPACE_DECLARATION : MAYBE_MODIFIERS "namespace" T_IDENTIFIER {$$=$2;}
1860 NAMESPACE_DECLARATION : MAYBE_MODIFIERS "namespace" T_IDENTIFIER '=' T_IDENTIFIER {$$=$2;}
1861 NAMESPACE_DECLARATION : MAYBE_MODIFIERS "namespace" T_IDENTIFIER '=' T_STRING {$$=$2;}
1863 USE_NAMESPACE : "use" "namespace" T_IDENTIFIER