f16d85035e9e627cdf9be95848e61c7b9cef1cb4
[swftools.git] / lib / as3 / parser.y
1 /* parser.lex
2
3    Routines for compiling Flash2 AVM2 ABC Actionscript
4
5    Extension module for the rfxswf library.
6    Part of the swftools package.
7
8    Copyright (c) 2008 Matthias Kramm <kramm@quiss.org>
9  
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.
14
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.
19
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 */
23 %{
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <memory.h>
27 #include "abc.h"
28 #include "pool.h"
29 #include "files.h"
30 #include "common.h"
31 #include "tokenizer.h"
32 #include "registry.h"
33 #include "code.h"
34 #include "opcodes.h"
35 #include "compiler.h"
36 #include "expr.h"
37
38 extern int a3_lex();
39
40 %}
41
42 //%glr-parser
43 //%expect-rr 1
44 %error-verbose
45
46 %union tokenunion {
47     enum yytokentype token;
48
49     classinfo_t*classinfo;
50     classinfo_list_t*classinfo_list;
51     slotinfo_t*slotinfo;
52     slotinfo_list_t*slotinfo_list;
53
54     int number_int;
55     unsigned int number_uint;
56     double number_float;
57     code_t*code;
58     typedcode_t value;
59     //typedcode_list_t*value_list;
60     codeandnumber_t value_list;
61     param_t* param;
62     params_t params;
63     string_t str;
64     char*id;
65     constant_t*constant;
66     for_start_t for_start;
67     abc_exception_t *exception;
68     regexp_t regexp;
69     modifiers_t flags;
70     namespace_decl_t* namespace_decl;
71     node_t*node;
72     struct {
73         abc_exception_list_t *l;
74         code_t*finally;
75     } catch_list;
76 }
77
78
79 %token<id> T_IDENTIFIER T_NAMESPACE
80 %token<str> T_STRING
81 %token<regexp> T_REGEXP
82 %token<token> T_EMPTY
83 %token<number_int> T_INT
84 %token<number_uint> T_UINT
85 %token<number_float> T_FLOAT
86
87 %token<id> T_FOR "for"
88 %token<id> T_WHILE "while"
89 %token<id> T_DO "do"
90 %token<id> T_SWITCH "switch"
91
92 %token<token> KW_IMPLEMENTS "implements"
93 %token<token> KW_NAMESPACE "namespace"
94 %token<token> KW_PACKAGE "package"
95 %token<token> KW_PROTECTED "protected"
96 %token<token> KW_PUBLIC "public"
97 %token<token> KW_PRIVATE "private"
98 %token<token> KW_USE "use"
99 %token<token> KW_INTERNAL "internal"
100 %token<token> KW_NEW "new"
101 %token<token> KW_NATIVE "native"
102 %token<token> KW_FUNCTION "function"
103 %token<token> KW_FINALLY "finally"
104 %token<token> KW_UNDEFINED "undefined"
105 %token<token> KW_NAN "NaN"
106 %token<token> KW_CONTINUE "continue"
107 %token<token> KW_CLASS "class"
108 %token<token> KW_CONST "const"
109 %token<token> KW_CATCH "catch"
110 %token<token> KW_CASE "case"
111 %token<token> KW_SET "set"
112 %token<token> KW_VOID "void"
113 %token<token> KW_THROW "throw"
114 %token<token> KW_STATIC "static"
115 %token<token> KW_WITH "with"
116 %token<token> KW_INSTANCEOF "instanceof"
117 %token<token> KW_IMPORT "import"
118 %token<token> KW_RETURN "return"
119 %token<token> KW_TYPEOF "typeof"
120 %token<token> KW_INTERFACE "interface"
121 %token<token> KW_NULL "null"
122 %token<token> KW_VAR "var"
123 %token<token> KW_DYNAMIC "dynamic"
124 %token<token> KW_OVERRIDE "override"
125 %token<token> KW_FINAL "final"
126 %token<token> KW_EACH "each"
127 %token<token> KW_GET "get"
128 %token<token> KW_TRY "try"
129 %token<token> KW_SUPER "super"
130 %token<token> KW_EXTENDS "extends"
131 %token<token> KW_FALSE "false"
132 %token<token> KW_TRUE "true"
133 %token<token> KW_BOOLEAN "Boolean"
134 %token<token> KW_UINT "uint"
135 %token<token> KW_INT "int"
136 %token<token> KW_NUMBER "Number"
137 %token<token> KW_STRING "String"
138 %token<token> KW_DEFAULT "default"
139 %token<token> KW_DELETE "delete"
140 %token<token> KW_IF "if"
141 %token<token> KW_ELSE  "else"
142 %token<token> KW_BREAK   "break"
143 %token<token> KW_IS "is"
144 %token<token> KW_IN "in"
145 %token<token> KW_AS "as"
146
147 %token<token> T_DICTSTART "{ (dictionary)"
148 %token<token> T_EQEQ "=="
149 %token<token> T_EQEQEQ "==="
150 %token<token> T_NE "!="
151 %token<token> T_NEE "!=="
152 %token<token> T_LE "<="
153 %token<token> T_GE ">="
154 %token<token> T_ORBY "|=" 
155 %token<token> T_DIVBY "/=" 
156 %token<token> T_MODBY "%="
157 %token<token> T_MULBY "*="
158 %token<token> T_ANDBY "&="
159 %token<token> T_PLUSBY "+=" 
160 %token<token> T_MINUSBY "-="
161 %token<token> T_XORBY "^="
162 %token<token> T_SHRBY ">>="
163 %token<token> T_SHLBY "<<="
164 %token<token> T_USHRBY ">>>="
165 %token<token> T_OROR "||"
166 %token<token> T_ANDAND "&&"
167 %token<token> T_COLONCOLON "::"
168 %token<token> T_MINUSMINUS "--"
169 %token<token> T_PLUSPLUS "++"
170 %token<token> T_DOTDOT ".."
171 %token<token> T_DOTDOTDOT "..."
172 %token<token> T_SHL "<<"
173 %token<token> T_USHR ">>>"
174 %token<token> T_SHR ">>"
175
176 %type <number_int> CONDITIONAL_COMPILATION
177 %type <for_start> FOR_START
178 %type <id> X_IDENTIFIER PACKAGE FOR_IN_INIT MAYBE_IDENTIFIER
179 %type <namespace_decl>  NAMESPACE_ID
180 %type <token> VARCONST
181 %type <code> CODE
182 %type <code> CODEPIECE CODE_STATEMENT
183 %type <code> CODEBLOCK MAYBECODE MAYBE_CASE_LIST CASE_LIST DEFAULT CASE SWITCH WITH
184 %type <code> PACKAGE_DECLARATION SLOT_DECLARATION SLOT_LIST ONE_SLOT
185 %type <code> FUNCTION_DECLARATION PACKAGE_INITCODE
186 %type <code> VARIABLE_DECLARATION ONE_VARIABLE VARIABLE_LIST THROW
187 %type <exception> CATCH FINALLY
188 %type <catch_list> CATCH_LIST CATCH_FINALLY_LIST
189 %type <code> CLASS_DECLARATION
190 %type <code> NAMESPACE_DECLARATION
191 %type <code> INTERFACE_DECLARATION
192 %type <code> VOIDEXPRESSION
193 %type <value> EXPRESSION NONCOMMAEXPRESSION
194 %type <node> MAYBEEXPRESSION
195 %type <value> DELETE
196 %type <node> E COMMA_EXPRESSION
197 %type <code> FOR FOR_IN IF WHILE DO_WHILE MAYBEELSE BREAK RETURN CONTINUE TRY 
198 %type <value> INNERFUNCTION
199 %type <code> USE_NAMESPACE
200 %type <code> FOR_INIT
201 %type <code> IMPORT
202 %type <classinfo> MAYBETYPE
203 %type <token> GETSET
204 %type <param> PARAM
205 %type <params> PARAM_LIST
206 %type <params> MAYBE_PARAM_LIST
207 %type <flags> MAYBE_MODIFIERS
208 %type <flags> MODIFIER_LIST
209 %type <flags> MODIFIER
210 %type <constant> CONSTANT MAYBECONSTANT
211 %type <classinfo_list> IMPLEMENTS_LIST
212 %type <classinfo> EXTENDS CLASS_SPEC
213 %type <classinfo_list> EXTENDS_LIST
214
215 %type <classinfo> CLASS PACKAGEANDCLASS
216 %type <classinfo_list> CLASS_SPEC_LIST
217
218 %type <classinfo> TYPE
219 //%type <token> VARIABLE
220 %type <value> VAR_READ MEMBER
221 %type <value> NEW
222 //%type <token> T_IDENTIFIER
223 %type <value> FUNCTIONCALL
224 %type <value_list> MAYBE_EXPRESSION_LIST EXPRESSION_LIST EXPRESSION_LIST_AND_COMMA MAYBE_PARAM_VALUES MAYBE_EXPRPAIR_LIST EXPRPAIR_LIST WITH_HEAD
225
226 // precedence: from low to high
227
228 %left prec_none
229
230 %left below_semicolon
231 %left ';'
232 %left ','
233 %nonassoc below_assignment // for ?:, contrary to spec
234 %right '=' "*=" "/=" "%=" "+=" "-=" "<<=" ">>=" ">>>=" "&=" "^=" "|="
235 %right '?' ':'
236 %left "||"
237 %left "&&"
238 %left '|'
239 %left '^'
240 %nonassoc '&'
241 %nonassoc "==" "!=" "===" "!=="
242 %nonassoc "is" "as" "in"
243 %nonassoc "<=" '<' ">=" '>' "instanceof" // TODO: support "a < b < c" syntax?
244 %left "<<" ">>" ">>>" 
245 %left below_minus
246 %left '-' '+'
247 %left '/' '*' '%'
248 %left plusplus_prefix minusminus_prefix '~' '!' "void" "delete" "typeof" //FIXME: *unary* + - should be here, too
249 %left "--" "++" 
250 %nonassoc below_curly
251
252 %left '('
253 %left new2
254 %left '[' ']' "new" '{' "{ (dictionary)" '.' ".." "::" '@'
255
256 %left T_IDENTIFIER
257 %left above_identifier
258 %left below_else
259 %nonassoc "else"
260
261 // needed for "return" precedence:
262 %nonassoc T_STRING T_REGEXP
263 %nonassoc T_INT T_UINT T_FLOAT KW_NAN
264 %nonassoc "false" "true" "null" "undefined" "super" "function"
265 %left above_function
266
267
268      
269 %{
270
271 static int a3_error(char*s)
272 {
273    syntaxerror("%s", s); 
274    return 0; //make gcc happy
275 }
276
277 static void parsererror(const char*file, int line, const char*f)
278 {
279     syntaxerror("internal error in %s, %s:%d", f, file, line);
280 }
281
282 #define parserassert(b) {if(!(b)) parsererror(__FILE__, __LINE__,__func__);}
283
284
285 static char* concat2(const char* t1, const char* t2)
286 {
287     int l1 = strlen(t1);
288     int l2 = strlen(t2);
289     char*text = malloc(l1+l2+1);
290     memcpy(text   , t1, l1);
291     memcpy(text+l1, t2, l2);
292     text[l1+l2] = 0;
293     return text;
294 }
295 static char* concat3(const char* t1, const char* t2, const char* t3)
296 {
297     int l1 = strlen(t1);
298     int l2 = strlen(t2);
299     int l3 = strlen(t3);
300     char*text = malloc(l1+l2+l3+1);
301     memcpy(text   , t1, l1);
302     memcpy(text+l1, t2, l2);
303     memcpy(text+l1+l2, t3, l3);
304     text[l1+l2+l3] = 0;
305     return text;
306 }
307
308 typedef struct _import {
309     char*package;
310 } import_t;
311 DECLARE_LIST(import);
312
313 DECLARE(methodstate);
314 DECLARE_LIST(methodstate);
315
316 typedef struct _classstate {
317     /* class data */
318     classinfo_t*info;
319     abc_class_t*abc;
320    
321     methodstate_t*init;
322     methodstate_t*static_init;
323     //code_t*init;
324     //code_t*static_init;
325
326     char has_constructor;
327 } classstate_t;
328
329 struct _methodstate {
330     /* method data */
331     methodinfo_t*info;
332     char has_exceptions;
333     char late_binding;
334     char is_constructor;
335     char has_super;
336     char is_global;
337     int variable_count;
338
339     dict_t*unresolved_variables;
340
341     char inner;
342     char uses_parent_function;
343     int uses_slots;
344     dict_t*slots;
345     int activation_var;
346
347     abc_method_t*abc;
348     int var_index; // for inner methods
349     int slot_index; // for inner methods
350     char is_a_slot; // for inner methods
351
352     code_t*header;
353
354     code_t*scope_code;
355     abc_exception_list_t*exceptions;
356     
357     methodstate_list_t*innerfunctions;
358 };
359
360 typedef struct _state {
361     struct _state*old;
362     int level;
363     
364     char*package;     
365     import_list_t*wildcard_imports;
366     dict_t*import_toplevel_packages;
367     dict_t*imports;
368
369     namespace_list_t*active_namespace_urls;
370     
371     char has_own_imports;
372     char new_vars; // e.g. transition between two functions
373   
374     classstate_t*cls;   
375     methodstate_t*method;
376
377     char*exception_name;
378
379     int switch_var;
380     
381     dict_t*vars;
382 } state_t;
383
384 typedef struct _global {
385     abc_file_t*file;
386     abc_script_t*init;
387     dict_t*token2info;
388     dict_t*file2token2info;
389 } global_t;
390
391 static global_t*global = 0;
392 static state_t* state = 0;
393
394 DECLARE_LIST(state);
395
396 #define MULTINAME(m,x) \
397     multiname_t m;\
398     namespace_t m##_ns;\
399     (x)->package; \
400     registry_fill_multiname(&m, &m##_ns, (slotinfo_t*)(x));
401                     
402 #define MEMBER_MULTINAME(m,f,n) \
403     multiname_t m;\
404     namespace_t m##_ns;\
405     if(f) { \
406         if((m##_ns.access = ((slotinfo_t*)(f))->access)==ACCESS_NAMESPACE) \
407             m##_ns.name = ((slotinfo_t*)(f))->package; \
408         else \
409             m##_ns.name = ""; \
410         m.type = QNAME; \
411         m.ns = &m##_ns; \
412         m.namespace_set = 0; \
413         m.name = ((slotinfo_t*)(f))->name; \
414     } else { \
415         m.type = MULTINAME; \
416         m.ns =0; \
417         m.namespace_set = &nopackage_namespace_set; \
418         m.name = n; \
419     }
420
421 /* warning: list length of namespace set is undefined */
422 #define MULTINAME_LATE(m, access, package) \
423     namespace_t m##_ns = {access, package}; \
424     namespace_set_t m##_nsset; \
425     namespace_list_t m##_l;m##_l.next = 0; \
426     m##_nsset.namespaces = &m##_l; \
427     m##_nsset = m##_nsset; \
428     m##_l.namespace = &m##_ns; \
429     multiname_t m = {MULTINAMEL, 0, &m##_nsset, 0};
430
431 static namespace_t ns1 = {ACCESS_PRIVATE, ""};
432 static namespace_t ns2 = {ACCESS_PROTECTED, ""};
433 static namespace_t ns3 = {ACCESS_PACKAGEINTERNAL, ""};
434 static namespace_t ns4 = {ACCESS_PACKAGE, ""};
435 static namespace_list_t nl4 = {&ns4,0};
436 static namespace_list_t nl3 = {&ns3,&nl4};
437 static namespace_list_t nl2 = {&ns2,&nl3};
438 static namespace_list_t nl1 = {&ns1,&nl2};
439 static namespace_set_t nopackage_namespace_set = {&nl1};
440
441 static dict_t*definitions=0;
442 void as3_set_define(const char*c)
443 {
444     if(!definitions) 
445         definitions = dict_new();
446     if(!dict_contains(definitions,c))
447         dict_put(definitions,c,0);
448 }
449
450 static void new_state()
451 {
452     NEW(state_t, s);
453     state_t*oldstate = state;
454     if(state)
455         memcpy(s, state, sizeof(state_t)); //shallow copy
456     if(!s->imports) {
457         s->imports = dict_new();
458     }
459     if(!s->import_toplevel_packages) {
460         s->import_toplevel_packages = dict_new(); 
461     }
462     state = s;
463     state->level++;
464     state->has_own_imports = 0;    
465     state->vars = dict_new(); 
466     state->old = oldstate;
467     state->new_vars = 0;
468
469     trie_remember(active_namespaces);
470    
471     if(oldstate)
472         state->active_namespace_urls = list_clone(oldstate->active_namespace_urls);
473 }
474
475 static void state_destroy(state_t*state)
476 {
477     if(state->has_own_imports) {
478         list_free(state->wildcard_imports);
479         dict_destroy(state->imports);state->imports=0;
480     }
481     if(state->imports && (!state->old || state->old->imports!=state->imports)) {
482         dict_destroy(state->imports);state->imports=0;
483     }
484     if(state->vars) {
485         int t;
486         for(t=0;t<state->vars->hashsize;t++) {
487             dictentry_t*e =state->vars->slots[t];
488             while(e) {
489                 free(e->data);e->data=0;
490                 e = e->next;
491             }
492         }
493         dict_destroy(state->vars);state->vars=0;
494     }
495     
496     list_free(state->active_namespace_urls)
497     state->active_namespace_urls = 0;
498     
499     free(state);
500 }
501
502 static void old_state()
503 {
504     trie_rollback(active_namespaces);
505
506     if(!state || !state->old)
507         syntaxerror("invalid nesting");
508     state_t*leaving = state;
509     
510     state = state->old;
511
512     if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) {
513         free(leaving->method);
514         leaving->method=0;
515     }
516     if(as3_pass>1 && leaving->cls && leaving->cls != state->cls) {
517         free(leaving->cls);
518         leaving->cls=0;
519     }
520
521     state_destroy(leaving);
522 }
523
524 static code_t* method_header(methodstate_t*m);
525 static code_t* wrap_function(code_t*c,code_t*header, code_t*body);
526 static void function_initvars(methodstate_t*m, params_t*params, int flags, char var0);
527
528
529 static char* internal_filename_package = 0;
530 void initialize_file(char*filename)
531 {
532     if(state) {
533         syntaxerror("invalid call to initialize_file during parsing of another file");
534     }
535     
536     active_namespaces = trie_new();
537
538     new_state();
539     state->package = internal_filename_package = strdup(filename);
540     
541     global->token2info = dict_lookup(global->file2token2info, 
542                                      current_filename // use long version
543                                     );
544     if(!global->token2info) {
545         global->token2info = dict_new2(&ptr_type);
546         dict_put(global->file2token2info, current_filename, global->token2info);
547     }
548   
549     if(as3_pass==1) {
550         state->method = rfx_calloc(sizeof(methodstate_t));
551         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
552         state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope
553     } else {
554         state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
555         if(!state->method)
556             syntaxerror("internal error: skewed tokencount");
557         function_initvars(state->method, 0, 0, 1);
558         global->init = abc_initscript(global->file);
559     }
560 }
561
562 void finish_file()
563 {
564     if(!state || state->level!=1) {
565         syntaxerror("unexpected end of file in pass %d", as3_pass);
566     }
567     
568     if(as3_pass==2) {
569         dict_del(global->file2token2info, current_filename);
570
571         code_t*header = method_header(state->method);
572         code_t*c = wrap_function(header, 0, global->init->method->body->code);
573         global->init->method->body->code = c;
574         free(state->method);state->method=0;
575     }
576
577     //free(state->package);state->package=0; // used in registry
578     state_destroy(state);state=0;
579 }
580
581 void initialize_parser()
582 {
583     global = rfx_calloc(sizeof(global_t));
584     global->file = abc_file_new();
585     global->file->flags &= ~ABCFILE_LAZY;
586     global->file2token2info = dict_new();
587     global->token2info = 0;
588 }
589
590 void* finish_parser()
591 {
592     dict_free_all(global->file2token2info, 1, (void*)dict_destroy);
593     global->token2info=0;
594     return global->file;
595 }
596
597 typedef struct _variable {
598     int index;
599     classinfo_t*type;
600     char init;
601     char is_parameter;
602     methodstate_t*is_inner_method;
603 } variable_t;
604
605 static variable_t* find_variable(state_t*s, char*name)
606 {
607     while(s) {
608         variable_t*v = 0;
609         v = dict_lookup(s->vars, name);
610         if(v) return v;
611         if(s->new_vars) break;
612         s = s->old;
613     }
614     return 0;
615 }
616 static variable_t* find_slot(state_t*s, const char*name)
617 {
618     if(s->method && s->method->slots)
619         return dict_lookup(s->method->slots, name);
620     return 0;
621 }
622
623 static variable_t* find_variable_safe(state_t*s, char*name)
624 {
625     variable_t* v = find_variable(s, name);
626     if(!v)
627         syntaxerror("undefined variable: %s", name);
628     return v;
629 }
630
631 static char variable_exists(char*name) 
632 {
633     return dict_contains(state->vars, name);
634 }
635
636 static code_t*defaultvalue(code_t*c, classinfo_t*type)
637 {
638     if(TYPE_IS_INT(type)) {
639        c = abc_pushbyte(c, 0);
640     } else if(TYPE_IS_UINT(type)) {
641        c = abc_pushuint(c, 0);
642     } else if(TYPE_IS_FLOAT(type)) {
643        c = abc_pushnan(c);
644     } else if(TYPE_IS_BOOLEAN(type)) {
645        c = abc_pushfalse(c);
646     } else if(!type) {
647        //c = abc_pushundefined(c);
648         syntaxerror("internal error: can't generate default value for * type");
649     } else {
650        c = abc_pushnull(c);
651        MULTINAME(m, type);
652        c = abc_coerce2(c, &m);
653     }
654     return c;
655 }
656
657 static int alloc_local()
658 {
659     return state->method->variable_count++;
660 }
661
662 static variable_t* new_variable2(const char*name, classinfo_t*type, char init, char maybeslot)
663 {
664     if(maybeslot) {
665         variable_t*v = find_slot(state, name);
666         if(v)
667             return v;
668     }
669
670     NEW(variable_t, v);
671     v->index = alloc_local();
672     v->type = type;
673     v->init = init;
674  
675     if(name) 
676         dict_put(state->vars, name, v);
677
678     return v;
679 }
680 static int new_variable(const char*name, classinfo_t*type, char init, char maybeslot)
681 {
682     return new_variable2(name, type, init, maybeslot)->index;
683 }
684
685 #define TEMPVARNAME "__as3_temp__"
686 int gettempvar()
687 {
688     variable_t*v = find_variable(state, TEMPVARNAME);
689     int i;
690     if(v) 
691         i = v->index;
692     else
693         i = new_variable(TEMPVARNAME, 0, 0, 0);
694     parserassert(i);
695     return i;
696 }
697
698 static code_t* var_block(code_t*body) 
699 {
700     code_t*c = 0;
701     code_t*k = 0;
702     int t;
703     int num=0;
704     for(t=0;t<state->vars->hashsize;t++) {
705         dictentry_t*e = state->vars->slots[t];
706         while(e) {
707             variable_t*v = (variable_t*)e->data;
708             if(v->type && v->init) {
709                 c = defaultvalue(c, v->type);
710                 c = abc_setlocal(c, v->index);
711                 k = abc_kill(k, v->index); 
712                 num++;
713             }
714             e = e->next;
715         }
716     }
717
718     if(k) {
719         code_t*x = body;
720         while(x) {
721             if(x->opcode== OPCODE___BREAK__ ||
722                x->opcode== OPCODE___CONTINUE__) {
723                /* link kill code before break/continue */
724                 code_t*e = code_dup(k);
725                 code_t*s = code_start(e);
726                 s->prev = x->prev;
727                 if(x->prev) {
728                     x->prev->next = s;
729                 }
730                 e->next = x;
731                 x->prev = e;
732             }
733             x = x->prev;
734         }
735     }
736     
737     c = code_append(c, body);
738     c = code_append(c, k);
739     return c;
740 }
741
742 static void unknown_variable(char*name) 
743 {
744     if(!state->method->unresolved_variables)
745         state->method->unresolved_variables = dict_new();
746     if(!dict_contains(state->method->unresolved_variables, name))
747         dict_put(state->method->unresolved_variables, name, 0);
748 }
749
750 static code_t* add_scope_code(code_t*c, methodstate_t*m, char init)
751 {
752     if(m->uses_slots || (m->late_binding && !m->inner)) { //???? especially inner functions need the pushscope
753         c = abc_getlocal_0(c);
754         c = abc_pushscope(c);
755     }
756     if(m->uses_slots) {
757         /* FIXME: this alloc_local() causes variable indexes to be
758            different in pass2 than in pass1 */
759         if(!m->activation_var)
760             m->activation_var = alloc_local();
761         if(init) {
762             c = abc_newactivation(c);
763             c = abc_dup(c);
764             c = abc_pushscope(c);
765             c = abc_setlocal(c, m->activation_var);
766         } else {
767             c = abc_getlocal(c, m->activation_var);
768             c = abc_pushscope(c);
769         }
770     }
771     return c;
772 }
773
774 static code_t* method_header(methodstate_t*m)
775 {
776     code_t*c = 0;
777
778     c = add_scope_code(c, m, 1);
779
780     methodstate_list_t*l = m->innerfunctions;
781     while(l) {
782         parserassert(l->methodstate->abc);
783         if(m->uses_slots && l->methodstate->is_a_slot) {
784             c = abc_getscopeobject(c, 1);
785             c = abc_newfunction(c, l->methodstate->abc);
786             c = abc_dup(c);
787             c = abc_setlocal(c, l->methodstate->var_index);
788             c = abc_setslot(c, l->methodstate->slot_index);
789         } else {
790             c = abc_newfunction(c, l->methodstate->abc);
791             c = abc_setlocal(c, l->methodstate->var_index);
792         }
793         free(l->methodstate);l->methodstate=0;
794         l = l->next;
795     }
796     if(m->header) {
797         c = code_append(c, m->header);
798         m->header = 0;
799     }
800     if(m->is_constructor && !m->has_super) {
801         // call default constructor
802         c = abc_getlocal_0(c);
803         c = abc_constructsuper(c, 0);
804     }
805
806     if(m->slots) {
807         /* all parameters that are used by inner functions
808            need to be copied from local to slot */
809         parserassert(m->activation_var);
810         DICT_ITERATE_ITEMS(m->slots,char*,name,variable_t*,v) {
811             if(v->is_parameter) {
812                 c = abc_getlocal(c, m->activation_var); 
813                 c = abc_getlocal(c, v->index); 
814                 c = abc_setslot(c, v->index); 
815             }
816         }
817     }
818     list_free(m->innerfunctions);
819     m->innerfunctions = 0;
820     return c;
821 }
822     
823
824 static code_t* wrap_function(code_t*c,code_t*header, code_t*body)
825 {
826     c = code_append(c, header);
827     c = code_append(c, var_block(body));
828     /* append return if necessary */
829     if(!c || (c->opcode != OPCODE_RETURNVOID && 
830               c->opcode != OPCODE_RETURNVALUE)) {
831         c = abc_returnvoid(c);
832     }
833     return c;
834 }
835
836 static void startpackage(char*name)
837 {
838     new_state();
839     state->package = strdup(name);
840 }
841 static void endpackage()
842 {
843     //used e.g. in classinfo_register:
844     //free(state->package);state->package=0;
845     old_state();
846 }
847
848 #define FLAG_PUBLIC 256
849 #define FLAG_PROTECTED 512
850 #define FLAG_PRIVATE 1024
851 #define FLAG_PACKAGEINTERNAL 2048
852 #define FLAG_NAMESPACE 4096
853
854 static namespace_t modifiers2access(modifiers_t*mod)
855 {
856     namespace_t ns;
857     ns.access = 0;
858     ns.name = "";
859     if(mod->flags&FLAG_NAMESPACE)  {
860         if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL)) 
861             syntaxerror("invalid combination of access levels and namespaces");
862         ns.access = ACCESS_NAMESPACE;
863         state_t*s = state;
864         const char*url = (const char*)trie_lookup(active_namespaces, mod->ns);
865         if(!url) {
866             /* shouldn't happen- the tokenizer only reports something as a namespace
867                if it was already registered */
868             trie_dump(active_namespaces);
869             syntaxerror("unknown namespace: %s", mod->ns);
870         }
871         ns.name = url;
872     } else if(mod->flags&FLAG_PUBLIC)  {
873         if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL)) 
874             syntaxerror("invalid combination of access levels");
875         ns.access = ACCESS_PACKAGE;
876     } else if(mod->flags&FLAG_PRIVATE) {
877         if(mod->flags&(FLAG_PUBLIC|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL)) 
878             syntaxerror("invalid combination of access levels");
879         ns.access = ACCESS_PRIVATE;
880     } else if(mod->flags&FLAG_PROTECTED) {
881         if(mod->flags&(FLAG_PUBLIC|FLAG_PRIVATE|FLAG_PACKAGEINTERNAL)) 
882             syntaxerror("invalid combination of access levels");
883         ns.access = ACCESS_PROTECTED;
884     } else {
885         ns.access = ACCESS_PACKAGEINTERNAL;
886     }
887     return ns;
888 }
889 static slotinfo_t* find_class(const char*name);
890
891 static memberinfo_t* findmember_nsset(classinfo_t*cls, const char*name, char recurse)
892 {
893     return registry_findmember_nsset(cls, state->active_namespace_urls, name, recurse);
894 }
895
896 static void function_initvars(methodstate_t*m, params_t*params, int flags, char var0)
897 {
898     if(var0) {
899         int index = -1;
900         if(m->inner)
901             index = new_variable("this", 0, 0, 0);
902         else if(!m->is_global)
903             index = new_variable((flags&FLAG_STATIC)?"class":"this", state->cls?state->cls->info:0, 0, 0);
904         else
905             index = new_variable("globalscope", 0, 0, 0);
906         parserassert(!index);
907     }
908
909     if(m->uses_slots) {
910         /* as variables and slots share the same number, make sure
911            that those variable indices are reserved. It's up to the
912            optimizer to later shuffle the variables down to lower
913            indices */
914         m->variable_count = m->uses_slots;
915     }
916
917     if(params) {
918         param_list_t*p=0;
919         for(p=params->list;p;p=p->next) {
920             variable_t*v = new_variable2(p->param->name, p->param->type, 0, 1);
921             v->is_parameter = 1;
922         }
923     }
924
925     methodstate_list_t*l = m->innerfunctions;
926     while(l) {
927         methodstate_t*m = l->methodstate;
928         
929         variable_t* v = new_variable2(m->info->name, TYPE_FUNCTION(m->info), 0, 1);
930         m->var_index = v->index;
931         m->slot_index = v->index;
932         v->is_inner_method = m;
933
934         l = l->next;
935     }
936     
937     if(as3_pass==2) {
938         m->scope_code = add_scope_code(m->scope_code, m, 0);
939     }
940     
941     if(as3_pass==2 && m->slots) {
942         /* exchange unresolved identifiers with the actual objects */
943         DICT_ITERATE_ITEMS(m->slots, char*, name, variable_t*, v) {
944             if(v->type && v->type->kind == INFOTYPE_UNRESOLVED) {
945                 classinfo_t*type = (classinfo_t*)registry_resolve((slotinfo_t*)v->type);
946                 if(!type || type->kind != INFOTYPE_CLASS) {
947                     syntaxerror("Couldn't find class %s::%s (%s)", v->type->package, v->type->name, name);
948                 }
949                 v->type = type;
950             }
951         }
952     }
953 }
954
955
956 char*as3_globalclass=0;
957 static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, classinfo_list_t*implements)
958 {
959     if(state->cls) {
960         syntaxerror("inner classes now allowed"); 
961     }
962
963     new_state();
964     token_list_t*t=0;
965     classinfo_list_t*mlist=0;
966
967     if(mod->flags&~(FLAG_PACKAGEINTERNAL|FLAG_PUBLIC|FLAG_FINAL|FLAG_DYNAMIC|FLAG_INTERFACE))
968         syntaxerror("invalid modifier(s)");
969
970     if((mod->flags&(FLAG_PUBLIC|FLAG_PACKAGEINTERNAL)) == (FLAG_PUBLIC|FLAG_PACKAGEINTERNAL))
971         syntaxerror("public and internal not supported at the same time.");
972     
973     //if(!(mod->flags&FLAG_INTERFACE) && !extends) {
974     if(!(mod->flags&FLAG_INTERFACE) && !extends) {
975         // all classes extend object
976         extends = registry_getobjectclass();
977     }
978
979     /* create the class name, together with the proper attributes */
980     int access=0;
981     char*package=0;
982
983     if(!(mod->flags&FLAG_PUBLIC) && state->package==internal_filename_package) {
984         access = ACCESS_PRIVATE; package = internal_filename_package;
985     } else if(!(mod->flags&FLAG_PUBLIC) && state->package!=internal_filename_package) {
986         access = ACCESS_PACKAGEINTERNAL; package = state->package;
987     } else if(state->package!=internal_filename_package) {
988         access = ACCESS_PACKAGE; package = state->package;
989     } else {
990         syntaxerror("public classes only allowed inside a package");
991     }
992
993     if(as3_pass==1) {
994         state->cls = rfx_calloc(sizeof(classstate_t));
995         state->cls->init = rfx_calloc(sizeof(methodstate_t));
996         state->cls->static_init = rfx_calloc(sizeof(methodstate_t));
997         state->cls->static_init->variable_count=1;
998         /* notice: we make no effort to initialize the top variable (local0) here,
999            even though it has special meaning. We just rely on the facat
1000            that pass 1 won't do anything with variables */
1001         
1002         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->cls);
1003
1004         /* set current method to constructor- all code within the class-level (except
1005            static variable initializations) will be executed during construction time */
1006         state->method = state->cls->init;
1007
1008         if(registry_find(package, classname)) {
1009             syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, classname);
1010         }
1011         /* build info struct */
1012         int num_interfaces = (list_length(implements));
1013         state->cls->info = classinfo_register(access, package, classname, num_interfaces);
1014         state->cls->info->flags |= mod->flags & (FLAG_DYNAMIC|FLAG_INTERFACE|FLAG_FINAL);
1015         
1016         int pos = 0;
1017         classinfo_list_t*l = implements;
1018         for(l=implements;l;l=l->next) {
1019             state->cls->info->interfaces[pos++] = l->classinfo;
1020         }
1021     }
1022     
1023     if(as3_pass == 2) {
1024         state->cls = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1025         
1026         state->method = state->cls->init;
1027         parserassert(state->cls && state->cls->info);
1028        
1029         function_initvars(state->cls->init, 0, 0, 1);
1030         function_initvars(state->cls->static_init, 0, 0, 0);
1031
1032         if(extends && (extends->flags & FLAG_FINAL))
1033             syntaxerror("Can't extend final class '%s'", extends->name);
1034         
1035         int pos = 0;
1036         while(state->cls->info->interfaces[pos]) {
1037             if(!(state->cls->info->interfaces[pos]->flags & FLAG_INTERFACE))
1038                 syntaxerror("'%s' is not an interface", 
1039                     state->cls->info->interfaces[pos]->name);
1040             pos++;
1041         }
1042
1043         /* fill out interfaces and extends (we couldn't resolve those during the first pass) */
1044         state->cls->info->superclass = extends;
1045
1046         /* generate the abc code for this class */
1047         MULTINAME(classname2,state->cls->info);
1048         multiname_t*extends2 = sig2mname(extends);
1049
1050         state->cls->abc = abc_class_new(global->file, &classname2, extends2);
1051         if(state->cls->info->flags&FLAG_FINAL) abc_class_final(state->cls->abc);
1052         if(!(state->cls->info->flags&FLAG_DYNAMIC)) abc_class_sealed(state->cls->abc);
1053         if(state->cls->info->flags&FLAG_INTERFACE) {
1054             abc_class_interface(state->cls->abc);
1055         }
1056
1057         abc_class_protectedNS(state->cls->abc, classname);
1058
1059         for(mlist=implements;mlist;mlist=mlist->next) {
1060             MULTINAME(m, mlist->classinfo);
1061             abc_class_add_interface(state->cls->abc, &m);
1062         }
1063
1064         /* write the construction code for this class to the global init
1065            function */
1066         int slotindex = abc_initscript_addClassTrait(global->init, &classname2, state->cls->abc);
1067
1068         abc_method_body_t*m = global->init->method->body;
1069         __ getglobalscope(m);
1070         classinfo_t*s = extends;
1071
1072         int count=0;
1073         
1074         while(s) {
1075             //TODO: take a look at the current scope stack, maybe 
1076             //      we can re-use something
1077             s = s->superclass;
1078             if(!s) 
1079             break;
1080            
1081             multiname_t*s2 = sig2mname(s);
1082             __ getlex2(m, s2);
1083             multiname_destroy(s2);
1084
1085             __ pushscope(m); count++;
1086             m->code = m->code->prev->prev; // invert
1087         }
1088         /* continue appending after last op end */
1089         while(m->code && m->code->next) m->code = m->code->next; 
1090
1091         /* TODO: if this is one of *our* classes, we can also 
1092                  do a getglobalscope/getslot <nr> (which references
1093                  the init function's slots) */
1094         if(extends2) {
1095             __ getlex2(m, extends2);
1096             __ dup(m);
1097             /* notice: we get a Verify Error #1107 if the top elemnt on the scope
1098                stack is not the superclass */
1099             __ pushscope(m);count++;
1100         } else {
1101             __ pushnull(m);
1102             /* notice: we get a verify error #1107 if the top element on the scope 
1103                stack is not the global object */
1104             __ getlocal_0(m);
1105             __ pushscope(m);count++;
1106         }
1107         __ newclass(m,state->cls->abc);
1108         while(count--) {
1109             __ popscope(m);
1110         }
1111         __ setslot(m, slotindex);
1112         multiname_destroy(extends2);
1113
1114         /* flash.display.MovieClip handling */
1115
1116         if(!as3_globalclass && (mod->flags&FLAG_PUBLIC) && slotinfo_equals((slotinfo_t*)registry_getMovieClip(),(slotinfo_t*)extends)) {
1117             if(state->package && state->package[0]) {
1118                 as3_globalclass = concat3(state->package, ".", classname);
1119             } else {
1120                 as3_globalclass = strdup(classname);
1121             }
1122         }
1123     }
1124 }
1125
1126 static void endclass()
1127 {
1128     if(as3_pass == 2) {
1129         if(!state->cls->has_constructor && !(state->cls->info->flags&FLAG_INTERFACE)) {
1130             code_t*c = 0;
1131             c = abc_getlocal_0(c);
1132             c = abc_constructsuper(c, 0);
1133             state->cls->init->header = code_append(state->cls->init->header, c);
1134             state->cls->has_constructor=1;
1135         }
1136         if(state->cls->init) {
1137             if(state->cls->info->flags&FLAG_INTERFACE) {
1138                 if(state->cls->init->header) 
1139                     syntaxerror("interface can not have class-level code");
1140             } else {
1141                 abc_method_t*m = abc_class_getconstructor(state->cls->abc, 0);
1142                 code_t*c = method_header(state->cls->init);
1143                 m->body->code = wrap_function(c, 0, m->body->code);
1144             }
1145         }
1146         if(state->cls->static_init) {
1147             abc_method_t*m = abc_class_getstaticconstructor(state->cls->abc, 0);
1148             code_t*c = method_header(state->cls->static_init);
1149             m->body->code = wrap_function(c, 0, m->body->code);
1150         }
1151     }
1152
1153     old_state();
1154 }
1155
1156 void check_code_for_break(code_t*c)
1157 {
1158     while(c) {
1159         if(c->opcode == OPCODE___BREAK__) {
1160             char*name = string_cstr(c->data[0]);
1161             syntaxerror("Unresolved \"break %s\"", name);
1162         }
1163         if(c->opcode == OPCODE___CONTINUE__) {
1164             char*name = string_cstr(c->data[0]);
1165             syntaxerror("Unresolved \"continue %s\"", name);
1166         }
1167         if(c->opcode == OPCODE___RETHROW__) {
1168             syntaxerror("Unresolved \"rethrow\"");
1169         }
1170         if(c->opcode == OPCODE___FALLTHROUGH__) {
1171             syntaxerror("Unresolved \"fallthrough\"");
1172         }
1173         if(c->opcode == OPCODE___PUSHPACKAGE__) {
1174             char*name = string_cstr(c->data[0]);
1175             syntaxerror("Can't reference a package (%s) as such", name);
1176         }
1177         c=c->prev;
1178     }
1179 }
1180
1181 static void check_constant_against_type(classinfo_t*t, constant_t*c)
1182 {
1183 #define xassert(b) if(!(b)) syntaxerror("Invalid default value %s for type '%s'", constant_tostring(c), t->name)
1184    if(TYPE_IS_NUMBER(t)) {
1185         xassert(c->type == CONSTANT_FLOAT
1186              || c->type == CONSTANT_INT
1187              || c->type == CONSTANT_UINT);
1188    } else if(TYPE_IS_UINT(t)) {
1189         xassert(c->type == CONSTANT_UINT ||
1190                (c->type == CONSTANT_INT && c->i>=0));
1191    } else if(TYPE_IS_INT(t)) {
1192         xassert(c->type == CONSTANT_INT);
1193    } else if(TYPE_IS_BOOLEAN(t)) {
1194         xassert(c->type == CONSTANT_TRUE
1195              || c->type == CONSTANT_FALSE);
1196    }
1197 }
1198
1199 static void check_override(memberinfo_t*m, int flags)
1200 {
1201     if(!m)
1202         return;
1203     if(m->parent == state->cls->info)
1204         syntaxerror("class '%s' already contains a method/slot '%s'", m->parent->name, m->name);
1205     if(!m->parent)
1206         syntaxerror("internal error: overriding method %s, which doesn't have parent", m->name);
1207     if(m->access==ACCESS_PRIVATE)
1208         return;
1209     if(m->flags & FLAG_FINAL)
1210         syntaxerror("can't override final member %s", m->name);
1211     
1212     /* allow this. it's no issue.
1213     if((m->flags & FLAG_STATIC) && !(flags&FLAG_STATIC))
1214         syntaxerror("can't override static member %s", m->name);*/
1215
1216     if(!(m->flags & FLAG_STATIC) && (flags&FLAG_STATIC))
1217         syntaxerror("can't override non-static member %s with static declaration", m->name);
1218
1219     if(!(flags&FLAG_OVERRIDE) && !(flags&FLAG_STATIC) && !(m->flags&FLAG_STATIC)) {
1220         if(m->parent && !(m->parent->flags&FLAG_INTERFACE)) {
1221             if(m->kind == INFOTYPE_METHOD)
1222                 syntaxerror("can't override without explicit 'override' declaration");
1223             else
1224                 syntaxerror("can't override '%s'", m->name);
1225         }
1226     }
1227 }
1228
1229 static methodinfo_t*registerfunction(enum yytokentype getset, modifiers_t*mod, char*name, params_t*params, classinfo_t*return_type, int slot)
1230 {
1231     methodinfo_t*minfo = 0;
1232     namespace_t ns = modifiers2access(mod);
1233     if(!state->cls) {
1234         //package method
1235         minfo = methodinfo_register_global(ns.access, state->package, name);
1236         minfo->return_type = 0; // save this for pass 2
1237     } else if(getset != KW_GET && getset != KW_SET) {
1238         //class method
1239         memberinfo_t* m = registry_findmember(state->cls->info, ns.name, name, 0);
1240         if(m) {
1241             syntaxerror("class already contains a %s '%s'", infotypename((slotinfo_t*)m), m->name);
1242         }
1243         minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);
1244         minfo->return_type = 0; // save this for pass 2 
1245         // getslot on a member slot only returns "undefined", so no need
1246         // to actually store these
1247         //state->minfo->slot = state->method->abc->method->trait->slot_id;
1248     } else {
1249         //class getter/setter
1250         int gs = getset==KW_GET?SUBTYPE_GET:SUBTYPE_SET;
1251         classinfo_t*type=0;
1252         if(getset == KW_GET) {
1253             type = return_type;
1254         } else if(params->list && params->list->param && !params->list->next) {
1255             type = params->list->param->type;
1256         } else
1257             syntaxerror("setter function needs to take exactly one argument");
1258         // not sure wether to look into superclasses here, too
1259         minfo = (methodinfo_t*)registry_findmember(state->cls->info, ns.name, name, 1);
1260         if(minfo) {
1261             if(minfo->kind!=INFOTYPE_SLOT)
1262                 syntaxerror("class already contains a method called '%s'", name);
1263             if(!(minfo->subtype & (SUBTYPE_GETSET)))
1264                 syntaxerror("class already contains a field called '%s'", name);
1265             if(minfo->subtype & gs)
1266                 syntaxerror("getter/setter for '%s' already defined", name);
1267             /* make a setter or getter into a getset */
1268             minfo->subtype |= gs;
1269             
1270             /*
1271             FIXME: this check needs to be done in pass 2
1272             
1273             if((!minfo->return_type != !type) ||
1274                 (minfo->return_type && type && 
1275                  !strcmp(minfo->return_type->name, type->name))) {
1276                 syntaxerror("different type in getter and setter: %s and %s", 
1277                     minfo->return_type?minfo->return_type->name:"*", 
1278                     type?type->name:"*");
1279             }*/
1280         } else {
1281             minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);
1282             minfo->kind = INFOTYPE_SLOT; //hack
1283             minfo->subtype = gs;
1284             minfo->return_type = 0;
1285         }
1286         /* can't assign a slot as getter and setter might have different slots */
1287         //minfo->slot = slot;
1288     }
1289     if(mod->flags&FLAG_FINAL) minfo->flags |= FLAG_FINAL;
1290     if(mod->flags&FLAG_STATIC) minfo->flags |= FLAG_STATIC;
1291     if(mod->flags&FLAG_OVERRIDE) minfo->flags |= FLAG_OVERRIDE;
1292
1293     return minfo;
1294 }
1295
1296 static void innerfunction(char*name, params_t*params, classinfo_t*return_type)
1297 {
1298     //parserassert(state->method && state->method->info);
1299
1300     methodstate_t*parent_method = state->method;
1301
1302     if(as3_pass==1) {
1303         return_type = 0; // not valid in pass 1
1304     }
1305
1306     new_state();
1307     state->new_vars = 1;
1308    
1309     if(as3_pass == 1) {
1310         state->method = rfx_calloc(sizeof(methodstate_t));
1311         state->method->inner = 1;
1312         state->method->variable_count = 0;
1313         state->method->abc = rfx_calloc(sizeof(abc_method_t));
1314
1315         NEW(methodinfo_t,minfo);
1316         minfo->kind = INFOTYPE_METHOD;
1317         minfo->access = ACCESS_PACKAGEINTERNAL;
1318         minfo->name = name;
1319         state->method->info = minfo;
1320
1321         if(parent_method)
1322             list_append(parent_method->innerfunctions, state->method);
1323
1324         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
1325     
1326         function_initvars(state->method, params, 0, 1);
1327     }
1328
1329     if(as3_pass == 2) {
1330         state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1331         state->method->variable_count = 0;
1332         parserassert(state->method);
1333
1334         state->method->info->return_type = return_type;
1335         function_initvars(state->method, params, 0, 1);
1336     }
1337 }
1338
1339 static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,
1340                           params_t*params, classinfo_t*return_type)
1341 {
1342     if(state->method && state->method->info) {
1343         syntaxerror("not able to start another method scope");
1344     }
1345     new_state();
1346     state->new_vars = 1;
1347     
1348     if(as3_pass == 1) {
1349         state->method = rfx_calloc(sizeof(methodstate_t));
1350         state->method->has_super = 0;
1351
1352         if(state->cls) {
1353             state->method->is_constructor = !strcmp(state->cls->info->name,name);
1354         } else {
1355             state->method->is_global = 1;
1356             state->method->late_binding = 1; // for global methods, always push local_0 on the scope stack
1357         }
1358         if(state->method->is_constructor)
1359             name = "__as3_constructor__";
1360
1361         state->method->info = registerfunction(getset, mod, name, params, return_type, 0);
1362        
1363         function_initvars(state->method, params, mod->flags, 1);
1364         
1365         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
1366     }
1367
1368     if(as3_pass == 2) {
1369         state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1370         state->method->variable_count = 0;
1371         parserassert(state->method);
1372                 
1373         if(state->cls) {
1374             memberinfo_t*m = registry_findmember(state->cls->info, mod->ns, name, 2);
1375             check_override(m, mod->flags);
1376         }
1377             
1378         if(state->cls) { 
1379             state->cls->has_constructor |= state->method->is_constructor;
1380         }
1381         
1382         state->method->info->return_type = return_type;
1383         function_initvars(state->method, params, mod->flags, 1);
1384     } 
1385 }
1386
1387 static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*name,
1388                           params_t*params, classinfo_t*return_type, code_t*body)
1389 {
1390     if(as3_pass==1) {
1391         // store inner methods in variables
1392         function_initvars(state->method, 0, 0, 0);
1393
1394         methodstate_list_t*ml = state->method->innerfunctions;
1395         
1396         dict_t*xvars = dict_new();
1397
1398         while(ml) {
1399             methodstate_t*m = ml->methodstate;
1400             parserassert(m->inner);
1401             if(m->unresolved_variables) {
1402                 dict_t*d = m->unresolved_variables;
1403                 int t;
1404                 for(t=0;t<d->hashsize;t++) {
1405                     dictentry_t*l = d->slots[t]; 
1406                     while(l) {
1407                         /* check parent method's variables */
1408                         variable_t*v;
1409                         if((v=find_variable(state, l->key))) {
1410                             m->uses_parent_function = 1;
1411                             state->method->uses_slots = 1;
1412                             dict_put(xvars, l->key, 0);
1413                         }
1414                         l = l->next;
1415                     }
1416                     if(l) break;
1417                 }
1418
1419                 dict_destroy(m->unresolved_variables);
1420                 m->unresolved_variables = 0;
1421             }
1422             ml = ml->next;
1423         }
1424         
1425         if(state->method->uses_slots) {
1426             state->method->slots = dict_new();
1427             int i = 1;
1428             DICT_ITERATE_ITEMS(state->vars, char*, name, variable_t*, v) {
1429                 if(!name) syntaxerror("internal error");
1430                 if(v->index && dict_contains(xvars, name)) {
1431                     v->init = 0;
1432                     v->index = i++;
1433                     if(v->is_inner_method) {
1434                         v->is_inner_method->is_a_slot = 1;
1435                     }
1436                     //v->type = 0;
1437                     dict_put(state->method->slots, name, v);
1438                 }
1439             }
1440             state->method->uses_slots = i;
1441             dict_destroy(state->vars);state->vars = 0;
1442         }
1443         old_state();
1444         return 0;
1445     }
1446
1447     if(as3_pass==2) {
1448         /*if(state->method->uses_parent_function){
1449             syntaxerror("accessing variables of parent function from inner functions not supported yet");
1450         }*/
1451
1452         abc_method_t*f = 0;
1453
1454         multiname_t*type2 = sig2mname(return_type);
1455         int slot = 0;
1456         if(state->method->inner) {
1457             f = state->method->abc;
1458             abc_method_init(f, global->file, type2, 1);
1459         } else if(state->method->is_constructor) {
1460             f = abc_class_getconstructor(state->cls->abc, type2);
1461         } else if(!state->method->is_global) {
1462             namespace_t mname_ns = modifiers2access(mod);
1463             multiname_t mname = {QNAME, &mname_ns, 0, name};
1464
1465             if(mod->flags&FLAG_STATIC)
1466                 f = abc_class_staticmethod(state->cls->abc, type2, &mname);
1467             else
1468                 f = abc_class_method(state->cls->abc, type2, &mname);
1469             slot = f->trait->slot_id;
1470         } else {
1471             namespace_t mname_ns = {state->method->info->access, state->package};
1472             multiname_t mname = {QNAME, &mname_ns, 0, name};
1473
1474             f = abc_method_new(global->file, type2, 1);
1475             trait_t*t = trait_new_method(&global->init->traits, multiname_clone(&mname), f);
1476             //abc_code_t*c = global->init->method->body->code;
1477         }
1478         //flash doesn't seem to allow us to access function slots
1479         //state->method->info->slot = slot;
1480
1481         if(mod && mod->flags&FLAG_OVERRIDE) f->trait->attributes |= TRAIT_ATTR_OVERRIDE;
1482         if(getset == KW_GET) f->trait->kind = TRAIT_GETTER;
1483         if(getset == KW_SET) f->trait->kind = TRAIT_SETTER;
1484         if(params->varargs) f->flags |= METHOD_NEED_REST;
1485
1486         char opt=0;
1487         param_list_t*p=0;
1488         for(p=params->list;p;p=p->next) {
1489             if(params->varargs && !p->next) {
1490                 break; //varargs: omit last parameter in function signature
1491             }
1492             multiname_t*m = sig2mname(p->param->type);
1493             list_append(f->parameters, m);
1494             if(p->param->value) {
1495                 check_constant_against_type(p->param->type, p->param->value);
1496                 opt=1;list_append(f->optional_parameters, p->param->value);
1497             } else if(opt) {
1498                 syntaxerror("non-optional parameter not allowed after optional parameters");
1499             }
1500         }
1501         if(state->method->slots) {
1502             DICT_ITERATE_ITEMS(state->method->slots, char*, name, variable_t*, v) {
1503                 if(v->index) {
1504                     multiname_t*mname = multiname_new(namespace_new(ACCESS_PACKAGE, ""), name);
1505                     multiname_t*type = sig2mname(v->type);
1506                     trait_t*t = trait_new_member(&f->body->traits, type, mname, 0);
1507                     t->slot_id = v->index;
1508                 }
1509             }
1510         }
1511
1512         check_code_for_break(body);
1513
1514         /* Seems this works now.
1515         if(state->method->exceptions && state->method->uses_slots) {
1516            as3_warning("try/catch and activation not supported yet within the same method");
1517         }*/
1518
1519         if(f->body) {
1520             f->body->code = body;
1521             f->body->exceptions = state->method->exceptions;
1522         } else { //interface
1523             if(body)
1524                 syntaxerror("interface methods can't have a method body");
1525         }
1526
1527         old_state();
1528         return f;
1529     }
1530         
1531     return 0;
1532 }
1533
1534 void breakjumpsto(code_t*c, char*name, code_t*jump) 
1535 {
1536     while(c) {
1537         if(c->opcode == OPCODE___BREAK__) {
1538             string_t*name2 = c->data[0];
1539             if(!name2->len || !strncmp(name2->str, name, name2->len)) {
1540                 c->opcode = OPCODE_JUMP;
1541                 c->branch = jump;
1542             }
1543         }
1544         c=c->prev;
1545     }
1546 }
1547 void continuejumpsto(code_t*c, char*name, code_t*jump) 
1548 {
1549     while(c) {
1550         if(c->opcode == OPCODE___CONTINUE__) {
1551             string_t*name2 = c->data[0];
1552             if(!name2->len || !strncmp(name2->str, name, name2->len)) {
1553                 c->opcode = OPCODE_JUMP;
1554                 c->branch = jump;
1555             }
1556         }
1557         c = c->prev;
1558     }
1559 }
1560
1561 #define IS_NUMBER_OR_INT(a) (TYPE_IS_INT((a)) || TYPE_IS_UINT((a)) || TYPE_IS_NUMBER((a)))
1562
1563 code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
1564 {
1565     if(from==to)
1566         return c;
1567     if(!to) {
1568         return abc_coerce_a(c);
1569     }
1570     MULTINAME(m, to);
1571     if(!from) {
1572         // cast an "any" type to a specific type. subject to
1573         // runtime exceptions
1574         return abc_coerce2(c, &m);
1575     }
1576     
1577     if((TYPE_IS_NUMBER(from) || TYPE_IS_UINT(from) || TYPE_IS_INT(from)) &&
1578        (TYPE_IS_NUMBER(to) || TYPE_IS_UINT(to) || TYPE_IS_INT(to))) {
1579         // allow conversion between number types
1580         if(TYPE_IS_UINT(to))
1581             return abc_convert_u(c);
1582         else if(TYPE_IS_INT(to))
1583             return abc_convert_i(c);
1584         else if(TYPE_IS_NUMBER(to))
1585             return abc_convert_d(c);
1586         return abc_coerce2(c, &m);
1587     }
1588
1589     if(TYPE_IS_BOOLEAN(to))
1590         return abc_convert_b(c);
1591     if(TYPE_IS_STRING(to))
1592         return abc_convert_s(c);
1593     if(TYPE_IS_OBJECT(to))
1594         return abc_convert_o(c);
1595
1596     classinfo_t*supertype = from;
1597     while(supertype) {
1598         if(supertype == to) {
1599              // target type is one of from's superclasses
1600              return abc_coerce2(c, &m);
1601         }
1602         int t=0;
1603         while(supertype->interfaces[t]) {
1604             if(supertype->interfaces[t]==to) {
1605                 // target type is one of from's interfaces
1606                 return abc_coerce2(c, &m);
1607             }
1608             t++;
1609         }
1610         supertype = supertype->superclass;
1611     }
1612     if(TYPE_IS_FUNCTION(from) && TYPE_IS_FUNCTION(to))
1613         return c;
1614     if(TYPE_IS_CLASS(from) && TYPE_IS_CLASS(to))
1615         return c;
1616     if(TYPE_IS_NULL(from) && !IS_NUMBER_OR_INT(to))
1617         return c;
1618
1619     as3_error("can't convert type %s%s%s to %s%s%s", 
1620         from->package, from->package[0]?".":"", from->name, 
1621         to->package, to->package[0]?".":"", to->name);
1622
1623     return c;
1624 }
1625 /* move to ast.c todo end */
1626
1627 char is_pushundefined(code_t*c)
1628 {
1629     return (c && !c->prev && !c->next && c->opcode == OPCODE_PUSHUNDEFINED);
1630 }
1631
1632 static const char* get_package_from_name(const char*name)
1633 {
1634     /* try explicit imports */
1635     dictentry_t* e = dict_get_slot(state->imports, name);
1636     while(e) {
1637         if(!strcmp(e->key, name)) {
1638             slotinfo_t*c = (slotinfo_t*)e->data;
1639             if(c) return c->package;
1640         }
1641         e = e->next;
1642     }
1643     return 0;
1644 }
1645 static namespace_list_t*get_current_imports()
1646 {
1647     namespace_list_t*searchlist = 0;
1648     
1649     list_append(searchlist, namespace_new_package(state->package));
1650
1651     import_list_t*l = state->wildcard_imports;
1652     while(l) {
1653         namespace_t*ns = namespace_new_package(l->import->package);
1654         list_append(searchlist, ns);
1655         l = l->next;
1656     }
1657     list_append(searchlist, namespace_new_package(""));
1658     list_append(searchlist, namespace_new_package(internal_filename_package));
1659     return searchlist;
1660 }
1661
1662 static slotinfo_t* find_class(const char*name)
1663 {
1664     slotinfo_t*c=0;
1665
1666     c = registry_find(state->package, name);
1667     if(c) return c;
1668
1669     /* try explicit imports */
1670     dictentry_t* e = dict_get_slot(state->imports, name);
1671     if(c) return c;
1672     while(e) {
1673         if(!strcmp(e->key, name)) {
1674             c = (slotinfo_t*)e->data;
1675             if(c) return c;
1676         }
1677         e = e->next;
1678     }
1679
1680     /* try package.* imports */
1681     import_list_t*l = state->wildcard_imports;
1682     while(l) {
1683         //printf("does package %s contain a class %s?\n", l->import->package, name);
1684         c = registry_find(l->import->package, name);
1685         if(c) return c;
1686         l = l->next;
1687     }
1688
1689     /* try global package */
1690     c = registry_find("", name);
1691     if(c) return c;
1692   
1693     /* try local "filename" package */
1694     c = registry_find(internal_filename_package, name);
1695     if(c) return c;
1696
1697     return 0;
1698 }
1699 typedcode_t push_class(slotinfo_t*a)
1700 {
1701     typedcode_t x;
1702     x.c = 0;
1703     x.t = 0;
1704     if(a->access == ACCESS_PACKAGEINTERNAL &&
1705        strcmp(a->package, state->package) &&
1706        strcmp(a->package, internal_filename_package)
1707        ) {
1708        syntaxerror("Can't access internal %s %s in package '%s' from package '%s'",
1709             infotypename(a), a->name, a->package, state->package);
1710     }
1711
1712     if(a->kind != INFOTYPE_CLASS) {
1713         MULTINAME(m, a);
1714         x.c = abc_findpropstrict2(x.c, &m);
1715         x.c = abc_getproperty2(x.c, &m);
1716         if(a->kind == INFOTYPE_METHOD) {
1717             methodinfo_t*f = (methodinfo_t*)a;
1718             x.t = TYPE_FUNCTION(f);
1719         } else {
1720             varinfo_t*v = (varinfo_t*)a;
1721             x.t = v->type;
1722         }
1723     } else {
1724         classinfo_t*c = (classinfo_t*)a;
1725         if(c->slot) {
1726             x.c = abc_getglobalscope(x.c);
1727             x.c = abc_getslot(x.c, c->slot);
1728         } else {
1729             MULTINAME(m, c);
1730             x.c = abc_getlex2(x.c, &m);
1731         }
1732         x.t = TYPE_CLASS(c);
1733     }
1734     return x;
1735 }
1736
1737
1738 char is_break_or_jump(code_t*c)
1739 {
1740     if(!c)
1741         return 0;
1742     if(c->opcode == OPCODE_JUMP ||
1743        c->opcode == OPCODE___BREAK__ ||
1744        c->opcode == OPCODE___CONTINUE__ ||
1745        c->opcode == OPCODE_THROW ||
1746        c->opcode == OPCODE_RETURNVOID ||
1747        c->opcode == OPCODE_RETURNVALUE) {
1748        return 1;
1749     }
1750     return 0;
1751 }
1752
1753 #define IS_FINALLY_TARGET(op) \
1754         ((op) == OPCODE___CONTINUE__ || \
1755          (op) == OPCODE___BREAK__ || \
1756          (op) == OPCODE_RETURNVOID || \
1757          (op) == OPCODE_RETURNVALUE || \
1758          (op) == OPCODE___RETHROW__)
1759
1760 static code_t* insert_finally_lookup(code_t*c, code_t*finally, int tempvar)
1761 {
1762 #define NEED_EXTRA_STACK_ARG
1763     code_t*finally_label = abc_nop(0);
1764     NEW(lookupswitch_t, l);
1765     //_lookupswitch
1766
1767     code_t*i = c;
1768     int count=0;
1769     while(i) {
1770         code_t*prev = i->prev;
1771         if(IS_FINALLY_TARGET(i->opcode)) {
1772            code_t*p = prev;
1773            char needvalue=0;
1774            if(i->opcode == OPCODE___RETHROW__ ||
1775               i->opcode == OPCODE_RETURNVALUE) {
1776                if(i->opcode == OPCODE___RETHROW__)
1777                  i->opcode = OPCODE_THROW;
1778                needvalue=1;
1779                p = abc_coerce_a(p);
1780                p = abc_setlocal(p, tempvar);
1781            }
1782            p = abc_pushbyte(p, count++);
1783            p = abc_jump(p, finally_label);
1784            code_t*target = p = abc_label(p);
1785 #ifdef NEED_EXTRA_STACK_ARG
1786            p = abc_pop(p);
1787 #endif
1788            if(needvalue) {
1789                p = abc_getlocal(p, tempvar);
1790            }
1791
1792            p->next = i;i->prev = p;
1793            list_append(l->targets, target);
1794         }
1795         i = prev;
1796     }
1797
1798     code_t*j,*f;
1799     c = abc_pushbyte(c, -1);
1800     c = code_append(c, finally_label);
1801     c = code_append(c, finally);
1802
1803 #ifdef NEED_EXTRA_STACK_ARG
1804     c = abc_dup(c);
1805 #endif
1806     c = abc_lookupswitch(c, l);
1807     c = l->def = abc_label(c);
1808 #ifdef NEED_EXTRA_STACK_ARG
1809     c = abc_pop(c);
1810 #endif
1811
1812     return c;
1813 }
1814
1815 static code_t* insert_finally_simple(code_t*c, code_t*finally, int tempvar)
1816 {
1817     code_t*i = c;
1818     while(i) {
1819         code_t*prev = i->prev;
1820         if(IS_FINALLY_TARGET(i->opcode)) {
1821            if(i->opcode == OPCODE___RETHROW__)
1822                 i->opcode = OPCODE_THROW;
1823            code_t*end = code_dup(finally);
1824            code_t*start = code_start(end);
1825            if(prev) prev->next = start;
1826            start->prev = prev;
1827            i->prev = end;
1828            end->next = i;
1829         }
1830         i = prev;
1831     }
1832     return code_append(c, finally);
1833 }
1834
1835 code_t* insert_finally(code_t*c, code_t*finally, int tempvar)
1836 {
1837     if(!finally)
1838         return c;
1839     code_t*i = c;
1840     char cantdup=0;
1841     int num_insertion_points=0;
1842     while(i) {
1843         if(IS_FINALLY_TARGET(i->opcode))
1844             num_insertion_points++;
1845         i = i->prev;
1846     }
1847     i = finally;
1848     int code_size=0;
1849     while(i) {
1850         code_size++;
1851         if(i->branch || i->opcode == OPCODE_LOOKUPSWITCH) {
1852             cantdup=1;
1853         }
1854         i = i->prev;
1855     }
1856     int simple_version_cost = (1+num_insertion_points)*code_size;
1857     int lookup_version_cost = 4*num_insertion_points + 5;
1858
1859     if(cantdup || simple_version_cost > lookup_version_cost) {
1860         //printf("(use lookup) simple=%d > lookup=%d\n", simple_version_cost, lookup_version_cost);
1861         return insert_finally_lookup(c, finally, tempvar);
1862     } else {
1863         //printf("(use simple) simple=%d < lookup=%d\n", simple_version_cost, lookup_version_cost);
1864         return insert_finally_simple(c, finally, tempvar);
1865     }
1866 }
1867
1868 #define PASS1 }} if(as3_pass == 1) {{
1869 #define PASS1END }} if(as3_pass == 2) {{
1870 #define PASS2 }} if(as3_pass == 2) {{
1871 #define PASS12 }} if(as3_pass == 1 || as3_pass == 2) {{
1872 #define PASS12END }} if(as3_pass == 2) {{
1873 #define PASS_ALWAYS }} {{
1874
1875 %}
1876
1877 %%
1878
1879 /* ------------ code blocks / statements ---------------- */
1880
1881 PROGRAM: MAYBE_PROGRAM_CODE_LIST
1882
1883 MAYBE_PROGRAM_CODE_LIST: | PROGRAM_CODE_LIST 
1884 PROGRAM_CODE_LIST: PROGRAM_CODE 
1885                  | PROGRAM_CODE_LIST PROGRAM_CODE
1886
1887 PROGRAM_CODE: PACKAGE_DECLARATION 
1888             | INTERFACE_DECLARATION 
1889             | CLASS_DECLARATION
1890             | FUNCTION_DECLARATION
1891             | SLOT_DECLARATION
1892             | PACKAGE_INITCODE
1893             | CONDITIONAL_COMPILATION '{' MAYBE_PROGRAM_CODE_LIST '}' {PASS_ALWAYS as3_pass=$1;}
1894             | ';'
1895
1896 MAYBE_INPACKAGE_CODE_LIST: | INPACKAGE_CODE_LIST
1897 INPACKAGE_CODE_LIST: INPACKAGE_CODE 
1898                    | INPACKAGE_CODE_LIST INPACKAGE_CODE
1899
1900 INPACKAGE_CODE: INTERFACE_DECLARATION 
1901               | CLASS_DECLARATION
1902               | FUNCTION_DECLARATION
1903               | SLOT_DECLARATION
1904               | PACKAGE_INITCODE
1905               | CONDITIONAL_COMPILATION '{' MAYBE_INPACKAGE_CODE_LIST '}' {PASS_ALWAYS as3_pass=$1;}
1906               | ';'
1907
1908 MAYBECODE: CODE {$$=$1;}
1909 MAYBECODE: {$$=code_new();}
1910
1911 CODE: CODE CODEPIECE {$$=code_append($1,$2);}
1912 CODE: CODEPIECE {$$=$1;}
1913
1914 // code which may appear outside of methods
1915 CODE_STATEMENT: IMPORT 
1916 CODE_STATEMENT: FOR 
1917 CODE_STATEMENT: FOR_IN 
1918 CODE_STATEMENT: WHILE 
1919 CODE_STATEMENT: DO_WHILE 
1920 CODE_STATEMENT: SWITCH 
1921 CODE_STATEMENT: IF
1922 CODE_STATEMENT: WITH
1923 CODE_STATEMENT: TRY
1924 CODE_STATEMENT: VOIDEXPRESSION 
1925 CODE_STATEMENT: USE_NAMESPACE
1926 CODE_STATEMENT: NAMESPACE_DECLARATION
1927 CODE_STATEMENT: '{' CODE '}' {$$=$2;}
1928 CODE_STATEMENT: '{' '}' {$$=0;}
1929
1930 // code which may appear in methods
1931 CODEPIECE: ';' {$$=0;}
1932 CODEPIECE: CODE_STATEMENT
1933 CODEPIECE: VARIABLE_DECLARATION
1934 CODEPIECE: BREAK
1935 CODEPIECE: CONTINUE
1936 CODEPIECE: RETURN
1937 CODEPIECE: THROW
1938 CODEPIECE: CONDITIONAL_COMPILATION '{' CODE '}' {PASS_ALWAYS as3_pass=$1;}
1939
1940 //CODEBLOCK :  '{' CODE '}' {$$=$2;}
1941 //CODEBLOCK :  '{' '}'      {$$=0;}
1942 CODEBLOCK :  CODEPIECE ';'             {$$=$1;}
1943 CODEBLOCK :  CODEPIECE %prec below_semicolon {$$=$1;}
1944
1945 /* ------------ package init code ------------------- */
1946
1947 PACKAGE_INITCODE: CODE_STATEMENT {
1948     code_t**cc = &global->init->method->body->code;
1949     *cc = code_append(*cc, $1);
1950 }
1951
1952 /* ------------ conditional compilation ------------- */
1953
1954 CONDITIONAL_COMPILATION: T_IDENTIFIER "::" T_IDENTIFIER {
1955     PASS12
1956     $$=as3_pass;
1957     char*key = concat3($1,"::",$3);
1958     if(!definitions || !dict_contains(definitions, key)) {
1959         as3_pass=0;
1960     }
1961     free(key);
1962 }
1963
1964 /* ------------ variables --------------------------- */
1965
1966 %code {
1967     char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
1968     {
1969         return 1; // FIXME
1970     }
1971 };
1972
1973 MAYBEEXPRESSION : '=' E {$$=$2;}
1974                 |       {$$=mkdummynode();}
1975
1976 VARIABLE_DECLARATION : "var" VARIABLE_LIST {$$=$2;}
1977 VARIABLE_DECLARATION : "const" VARIABLE_LIST {$$=$2;}
1978
1979 VARIABLE_LIST: ONE_VARIABLE                   {$$ = $1;}
1980 VARIABLE_LIST: VARIABLE_LIST ',' ONE_VARIABLE {$$ = code_append($1, $3);}
1981
1982 ONE_VARIABLE: T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION
1983 {
1984 PASS12
1985     if(variable_exists($1))
1986         syntaxerror("Variable %s already defined", $1);
1987 PASS1
1988     new_variable($1, 0, 1, 0);
1989 PASS2
1990    
1991     char slot = 0;
1992     int index = 0;
1993     if(state->method->uses_slots) {
1994         variable_t* v = find_slot(state, $1);
1995         if(v && !v->init) {
1996             // this variable is stored in a slot
1997             v->init = 1;
1998             v->type = $2;
1999             slot = 1;
2000             index = v->index;
2001         }
2002     }
2003     if(!index) {
2004         index = new_variable($1, $2, 1, 0);
2005     }
2006
2007     $$ = slot?abc_getscopeobject(0, 1):0;
2008     
2009     typedcode_t v = node_read($3);
2010     if(!is_subtype_of(v.t, $2)) {
2011         syntaxerror("Can't convert %s to %s", v.t->name, $2->name);
2012     }
2013     if($2) {
2014         if(v.c->prev || v.c->opcode != OPCODE_PUSHUNDEFINED) {
2015             $$ = code_append($$, v.c);
2016             $$ = converttype($$, v.t, $2);
2017         } else {
2018             code_free(v.c);
2019             $$ = defaultvalue($$, $2);
2020         }
2021     } else {
2022         if(v.c->prev || v.c->opcode != OPCODE_PUSHUNDEFINED) {
2023             $$ = code_append($$, v.c);
2024             $$ = abc_coerce_a($$);
2025         } else {
2026             // don't do anything
2027             code_free(v.c);
2028             code_free($$);
2029             $$ = 0;
2030             break;
2031         }
2032     }
2033     if(slot) {
2034         $$ = abc_setslot($$, index);
2035     } else {
2036         $$ = abc_setlocal($$, index);
2037     }
2038 }
2039
2040 /* ------------ control flow ------------------------- */
2041
2042 MAYBEELSE:  %prec below_else {$$ = code_new();}
2043 MAYBEELSE: "else" CODEBLOCK {$$=$2;}
2044 //MAYBEELSE: ';' "else" CODEBLOCK {$$=$3;}
2045
2046 IF : "if" '(' {PASS12 new_state();} EXPRESSION ')' CODEBLOCK MAYBEELSE {
2047      
2048     $$ = code_new();
2049     $$ = code_append($$, $4.c);
2050     code_t*myjmp,*myif = $$ = abc_iffalse($$, 0);
2051    
2052     $$ = code_append($$, $6);
2053     if($7) {
2054         myjmp = $$ = abc_jump($$, 0);
2055     }
2056     myif->branch = $$ = abc_nop($$);
2057     if($7) {
2058         $$ = code_append($$, $7);
2059         myjmp->branch = $$ = abc_nop($$);
2060     }
2061     $$ = var_block($$);
2062     PASS12 old_state();
2063 }
2064
2065 FOR_INIT : {$$=code_new();}
2066 FOR_INIT : VARIABLE_DECLARATION
2067 FOR_INIT : VOIDEXPRESSION
2068
2069 // TODO: why doesn't an %prec above_identifier resolve the r-r conflict here?
2070 //       (I don't see any easy way to revolve this conflict otherwise, as we
2071 //        can't touch VAR_READ without upsetting the precedence about "return")
2072 FOR_IN_INIT : "var" T_IDENTIFIER MAYBETYPE {
2073     PASS1 $$=$2;new_variable($2,0,1,0);
2074     PASS2 $$=$2;new_variable($2,$3,1,0);
2075 }
2076 FOR_IN_INIT : T_IDENTIFIER {
2077     PASS12
2078     $$=$1;
2079 }
2080
2081 FOR_START : T_FOR '(' {PASS12 new_state();$$.name=$1;$$.each=0;}
2082 FOR_START : T_FOR "each" '(' {PASS12 new_state();$$.name=$1;$$.each=1;}
2083
2084 FOR : FOR_START FOR_INIT ';' EXPRESSION ';' VOIDEXPRESSION ')' CODEBLOCK {
2085     if($1.each) syntaxerror("invalid syntax: ; not allowed in for each statement");
2086     $$ = code_new();
2087     $$ = code_append($$, $2);
2088     code_t*loopstart = $$ = abc_label($$);
2089     $$ = code_append($$, $4.c);
2090     code_t*myif = $$ = abc_iffalse($$, 0);
2091     $$ = code_append($$, $8);
2092     code_t*cont = $$ = abc_nop($$);
2093     $$ = code_append($$, $6);
2094     $$ = abc_jump($$, loopstart);
2095     code_t*out = $$ = abc_nop($$);
2096     breakjumpsto($$, $1.name, out);
2097     continuejumpsto($$, $1.name, cont);
2098     myif->branch = out;
2099
2100     $$ = var_block($$);
2101     PASS12 old_state();
2102 }
2103
2104 FOR_IN : FOR_START FOR_IN_INIT "in" EXPRESSION ')' CODEBLOCK {
2105     variable_t*var = find_variable(state, $2);
2106     if(!var) {
2107         syntaxerror("variable %s not known in this scope", $2);
2108     }
2109
2110     char*tmp1name = concat2($2, "__tmp1__");
2111     int it = new_variable(tmp1name, TYPE_INT, 0, 0);
2112     char*tmp2name = concat2($2, "__array__");
2113     int array = new_variable(tmp1name, 0, 0, 0);
2114
2115     $$ = code_new();
2116     $$ = code_append($$, $4.c);
2117     $$ = abc_coerce_a($$);
2118     $$ = abc_setlocal($$, array);
2119     $$ = abc_pushbyte($$, 0);
2120     $$ = abc_setlocal($$, it);
2121
2122     code_t*loopstart = $$ = abc_label($$);
2123     
2124     $$ = abc_hasnext2($$, array, it);
2125     code_t*myif = $$ = abc_iffalse($$, 0);
2126     $$ = abc_getlocal($$, array);
2127     $$ = abc_getlocal($$, it);
2128     if(!$1.each)
2129         $$ = abc_nextname($$);
2130     else
2131         $$ = abc_nextvalue($$);
2132     $$ = converttype($$, 0, var->type);
2133     $$ = abc_setlocal($$, var->index);
2134
2135     $$ = code_append($$, $6);
2136     $$ = abc_jump($$, loopstart);
2137     
2138     code_t*out = $$ = abc_nop($$);
2139     breakjumpsto($$, $1.name, out);
2140     continuejumpsto($$, $1.name, loopstart);
2141     
2142     myif->branch = out;
2143
2144     $$ = var_block($$);
2145
2146     free(tmp1name);
2147     free(tmp2name);
2148
2149     PASS12 old_state();
2150 }
2151
2152 WHILE : T_WHILE '(' {PASS12 new_state();} EXPRESSION ')' CODEBLOCK {
2153
2154     $$ = code_new();
2155
2156     code_t*myjmp = $$ = abc_jump($$, 0);
2157     code_t*loopstart = $$ = abc_label($$);
2158     $$ = code_append($$, $6);
2159     code_t*cont = $$ = abc_nop($$);
2160     myjmp->branch = cont;
2161     $$ = code_append($$, $4.c);
2162     $$ = abc_iftrue($$, loopstart);
2163     code_t*out = $$ = abc_nop($$);
2164     breakjumpsto($$, $1, out);
2165     continuejumpsto($$, $1, cont);
2166
2167     $$ = var_block($$);
2168     PASS12 old_state();
2169 }
2170
2171 DO_WHILE : T_DO {PASS12 new_state();} CODEBLOCK "while" '(' EXPRESSION ')' {
2172     $$ = code_new();
2173     code_t*loopstart = $$ = abc_label($$);
2174     $$ = code_append($$, $3);
2175     code_t*cont = $$ = abc_nop($$);
2176     $$ = code_append($$, $6.c);
2177     $$ = abc_iftrue($$, loopstart);
2178     code_t*out = $$ = abc_nop($$);
2179     breakjumpsto($$, $1, out);
2180     continuejumpsto($$, $1, cont);
2181     
2182     $$ = var_block($$);
2183     PASS12 old_state();
2184 }
2185
2186 BREAK : "break" %prec prec_none {
2187     $$ = abc___break__(0, "");
2188 }
2189 BREAK : "break" T_IDENTIFIER {
2190     $$ = abc___break__(0, $2);
2191 }
2192 CONTINUE : "continue" %prec prec_none {
2193     $$ = abc___continue__(0, "");
2194 }
2195 CONTINUE : "continue" T_IDENTIFIER {
2196     $$ = abc___continue__(0, $2);
2197 }
2198
2199 MAYBE_CASE_LIST :           {$$=0;}
2200 MAYBE_CASE_LIST : CASE_LIST {$$=$1;}
2201 MAYBE_CASE_LIST : DEFAULT   {$$=$1;}
2202 MAYBE_CASE_LIST : CASE_LIST DEFAULT {$$=code_append($1,$2);}
2203 CASE_LIST: CASE             {$$=$1;}
2204 CASE_LIST: CASE_LIST CASE   {$$=code_append($$,$2);}
2205
2206 CASE: "case" E ':' MAYBECODE {
2207     $$ = abc_getlocal(0, state->switch_var);
2208     $$ = code_append($$, node_read($2).c);
2209     code_t*j = $$ = abc_ifne($$, 0);
2210     $$ = code_append($$, $4);
2211     if($$->opcode != OPCODE___BREAK__) {
2212         $$ = abc___fallthrough__($$, "");
2213     }
2214     code_t*e = $$ = abc_nop($$);
2215     j->branch = e;
2216 }
2217 DEFAULT: "default" ':' MAYBECODE {
2218     $$ = $3;
2219 }
2220 SWITCH : T_SWITCH '(' {PASS12 new_state();state->switch_var=alloc_local();} E ')' '{' MAYBE_CASE_LIST '}' {
2221     $$ = node_read($4).c;
2222     $$ = abc_setlocal($$, state->switch_var);
2223     $$ = code_append($$, $7);
2224
2225     code_t*out = $$ = abc_kill($$, state->switch_var);
2226     breakjumpsto($$, $1, out);
2227     
2228     code_t*c = $$,*lastblock=0;
2229     while(c) {
2230         if(c->opcode == OPCODE_IFNE) {
2231             if(!c->next) syntaxerror("internal error in fallthrough handling");
2232             lastblock=c->next;
2233         } else if(c->opcode == OPCODE___FALLTHROUGH__) {
2234             if(lastblock) {
2235                 c->opcode = OPCODE_JUMP;
2236                 c->branch = lastblock;
2237             } else {
2238                 /* fall through end of switch */
2239                 c->opcode = OPCODE_NOP;
2240             }
2241         }
2242         c=c->prev;
2243     }
2244    
2245     $$ = var_block($$);
2246     PASS12 old_state();
2247 }
2248
2249 /* ------------ try / catch /finally ---------------- */
2250
2251 CATCH: "catch" '(' T_IDENTIFIER MAYBETYPE ')' {PASS12 new_state();
2252                                                       state->exception_name=$3;
2253                                                PASS1 new_variable($3, 0, 0, 0);
2254                                                PASS2 new_variable($3, $4, 0, 0);
2255                                               } 
2256         '{' MAYBECODE '}' {
2257     namespace_t name_ns = {ACCESS_PACKAGE, ""};
2258     multiname_t name = {QNAME, &name_ns, 0, $3};
2259     
2260     NEW(abc_exception_t, e)
2261     e->exc_type = sig2mname($4);
2262     e->var_name = multiname_clone(&name);
2263     $$ = e;
2264
2265     code_t*c = 0;
2266     int i = find_variable_safe(state, $3)->index;
2267     e->target = c = abc_nop(0);
2268     c = abc_setlocal(c, i);
2269     c = code_append(c, code_dup(state->method->scope_code));
2270     c = code_append(c, $8);
2271     c = abc_kill(c, i);
2272
2273     c = var_block(c);
2274     PASS12 old_state();
2275 }
2276 FINALLY: "finally" '{' {PASS12 new_state();state->exception_name=0;} MAYBECODE '}' {
2277     $4 = var_block($4);
2278     if(!$4) {
2279         $$=0;
2280     } else {
2281         NEW(abc_exception_t, e)
2282         e->exc_type = 0; //all exceptions
2283         e->var_name = 0; //no name
2284         e->target = 0;
2285         e->to = abc_nop(0);
2286         e->to = code_append(e->to, $4);
2287         $$ = e;
2288     }
2289     PASS12 old_state();
2290 }
2291
2292 CATCH_LIST: CATCH {$$.l=list_new();$$.finally=0;list_append($$.l,$1);}
2293 CATCH_LIST: CATCH_LIST CATCH {$$=$1;list_append($$.l,$2);}
2294 CATCH_FINALLY_LIST: CATCH_LIST {$$=$1;}
2295 CATCH_FINALLY_LIST: CATCH_LIST FINALLY {
2296     $$ = $1;
2297     $$.finally = 0;
2298     if($2) {
2299         list_append($$.l,$2);
2300         $$.finally = $2->to;$2->to=0;
2301     }
2302 }
2303 CATCH_FINALLY_LIST: FINALLY {
2304     $$.l=list_new();
2305     $$.finally = 0;
2306     if($1) {
2307         list_append($$.l,$1);
2308         $$.finally = $1->to;$1->to=0;
2309     }
2310 }
2311
2312 TRY : "try" '{' {PASS12 new_state();
2313                  state->method->has_exceptions=1;
2314                  state->method->late_binding=1;//for invariant scope_code
2315                 } MAYBECODE '}' CATCH_FINALLY_LIST {
2316     code_t*out = abc_nop(0);
2317
2318     code_t*start = abc_nop(0);
2319     $$ = code_append(start, $4);
2320     if(!is_break_or_jump($4)) {
2321         $$ = abc_jump($$, out);
2322     }
2323     code_t*end = $$ = abc_nop($$);
2324   
2325     int tmp;
2326     if($6.finally)
2327         tmp = new_variable("__finally__", 0, 0, 0);
2328     
2329     abc_exception_list_t*l = $6.l;
2330     int count=0;
2331     while(l) {
2332         abc_exception_t*e = l->abc_exception;
2333         if(e->var_name) {
2334             $$ = code_append($$, e->target);
2335             $$ = abc_jump($$, out);
2336         } else {
2337             parserassert((ptroff_t)$6.finally);
2338             // finally block
2339             e->target = $$ = abc_nop($$);
2340             $$ = code_append($$, code_dup(state->method->scope_code));
2341             $$ = abc___rethrow__($$);
2342         }
2343         
2344         e->from = start;
2345         e->to = end;
2346
2347         l = l->next;
2348     }
2349     $$ = code_append($$, out);
2350
2351     $$ = insert_finally($$, $6.finally, tmp);
2352         
2353     list_concat(state->method->exceptions, $6.l);
2354    
2355     $$ = var_block($$);
2356     PASS12 old_state();
2357 }
2358
2359 /* ------------ throw ------------------------------- */
2360
2361 THROW : "throw" EXPRESSION {
2362     $$=$2.c;
2363     $$=abc_throw($$);
2364 }
2365 THROW : "throw" %prec prec_none {
2366     if(!state->exception_name)
2367         syntaxerror("re-throw only possible within a catch block");
2368     variable_t*v = find_variable(state, state->exception_name);
2369     $$=code_new();
2370     $$=abc_getlocal($$, v->index);
2371     $$=abc_throw($$);
2372 }
2373
2374 /* ------------ with -------------------------------- */
2375
2376 WITH_HEAD : "with" '(' EXPRESSION ')' {
2377      new_state();
2378      if(state->method->has_exceptions) {
2379          int v = alloc_local();
2380          state->method->scope_code = abc_getlocal(state->method->scope_code, v);
2381          state->method->scope_code = abc_pushwith(state->method->scope_code);
2382          $$.number = v;
2383      }
2384      $$.cc = $3.c;
2385
2386 WITH : WITH_HEAD CODEBLOCK {
2387      /* remove getlocal;pushwith from scope code again */
2388      state->method->scope_code = code_cutlast(code_cutlast(state->method->scope_code));
2389
2390      $$ = $1.cc;
2391      if(state->method->has_exceptions) {
2392          $$ = abc_dup($$);
2393          $$ = abc_setlocal($$, $1.number);
2394      }
2395      $$ = abc_pushwith($$);
2396      $$ = code_append($$, $2);
2397      $$ = abc_popscope($$);
2398      old_state();
2399 }
2400
2401 /* ------------ packages and imports ---------------- */
2402
2403 X_IDENTIFIER: T_IDENTIFIER
2404             | "package" {PASS12 $$="package";}
2405             | T_NAMESPACE {PASS12 $$=$1;}
2406
2407 PACKAGE: PACKAGE '.' X_IDENTIFIER {PASS12 $$ = concat3($1,".",$3);free($1);$1=0;}
2408 PACKAGE: X_IDENTIFIER             {PASS12 $$=strdup($1);}
2409
2410 PACKAGE_DECLARATION : "package" PACKAGE '{' {PASS12 startpackage($2);free($2);$2=0;}
2411                                 MAYBE_INPACKAGE_CODE_LIST '}' {PASS12 endpackage();$$=0;}
2412 PACKAGE_DECLARATION : "package" '{' {PASS12 startpackage("");} 
2413                                 MAYBE_INPACKAGE_CODE_LIST '}' {PASS12 endpackage();$$=0;}
2414
2415 %code {
2416     static void state_has_imports()
2417     {
2418         state->wildcard_imports = list_clone(state->wildcard_imports);
2419         state->imports = dict_clone(state->imports);
2420         state->has_own_imports = 1;
2421     }
2422     static void import_toplevel(const char*package)
2423     {
2424         char* s = strdup(package);
2425         while(1) {
2426             dict_put(state->import_toplevel_packages, s, 0);
2427             char*x = strrchr(s, '.');
2428             if(!x)
2429                 break;
2430             *x = 0;
2431         }
2432         free(s);
2433     }
2434 };
2435 IMPORT : "import" PACKAGEANDCLASS {
2436        PASS12
2437        slotinfo_t*s = registry_find($2->package, $2->name);
2438        if(!s && as3_pass==1) {// || !(s->flags&FLAG_BUILTIN)) {
2439            as3_schedule_class($2->package, $2->name);
2440        }
2441        classinfo_t*c = $2;
2442        if(!c) 
2443             syntaxerror("Couldn't import class\n");
2444        state_has_imports();
2445        dict_put(state->imports, c->name, c);
2446        import_toplevel(c->package);
2447        $$=0;
2448 }
2449 IMPORT : "import" PACKAGE '.' '*' {
2450        PASS12
2451        if(strncmp("flash.", $2, 6) && as3_pass==1) {
2452            as3_schedule_package($2);
2453        }
2454
2455        NEW(import_t,i);
2456        i->package = $2;
2457        state_has_imports();
2458        list_append(state->wildcard_imports, i);
2459        import_toplevel(i->package);
2460        $$=0;
2461 }
2462
2463 /* ------------ classes and interfaces (header) -------------- */
2464
2465 MAYBE_MODIFIERS : %prec above_function {PASS12 $$.flags=0;$$.ns=0;}
2466 MAYBE_MODIFIERS : MODIFIER_LIST        {PASS12 $$=$1;}
2467 MODIFIER_LIST : MODIFIER               {PASS12 $$=$1;}
2468 MODIFIER_LIST : MODIFIER_LIST MODIFIER {
2469     PASS12 
2470     $$.flags=$1.flags|$2.flags;
2471     if($1.ns && $2.ns) syntaxerror("only one namespace allowed in one declaration");
2472     $$.ns=$1.ns?$1.ns:$2.ns;
2473
2474 }
2475 MODIFIER : KW_PUBLIC {PASS12 $$.flags=FLAG_PUBLIC;$$.ns=0;}
2476          | KW_PRIVATE {PASS12 $$.flags=FLAG_PRIVATE;$$.ns=0;}
2477          | KW_PROTECTED {PASS12 $$.flags=FLAG_PROTECTED;$$.ns=0;}
2478          | KW_STATIC {PASS12 $$.flags=FLAG_STATIC;$$.ns=0;}
2479          | KW_DYNAMIC {PASS12 $$.flags=FLAG_DYNAMIC;$$.ns=0;}
2480          | KW_FINAL {PASS12 $$.flags=FLAG_FINAL;$$.ns=0;}
2481          | KW_OVERRIDE {PASS12 $$.flags=FLAG_OVERRIDE;$$.ns=0;}
2482          | KW_NATIVE {PASS12 $$.flags=FLAG_NATIVE;$$.ns=0;}
2483          | KW_INTERNAL {PASS12 $$.flags=FLAG_PACKAGEINTERNAL;$$.ns=0;}
2484          | T_NAMESPACE {PASS12 $$.flags=FLAG_NAMESPACE;
2485                                $$.ns=$1;
2486                        }
2487
2488 EXTENDS : {PASS12 $$=0;}
2489 EXTENDS : KW_EXTENDS CLASS_SPEC {PASS12 $$=$2;}
2490
2491 EXTENDS_LIST : {PASS12 $$=list_new();}
2492 EXTENDS_LIST : KW_EXTENDS CLASS_SPEC_LIST {PASS12 $$=$2;}
2493
2494 IMPLEMENTS_LIST : {PASS12 $$=list_new();}
2495 IMPLEMENTS_LIST : KW_IMPLEMENTS CLASS_SPEC_LIST {PASS12 $$=$2;}
2496
2497 CLASS_DECLARATION : MAYBE_MODIFIERS "class" T_IDENTIFIER 
2498                               EXTENDS IMPLEMENTS_LIST 
2499                               '{' {PASS12 startclass(&$1,$3,$4,$5);} 
2500                               MAYBE_CLASS_BODY 
2501                               '}' {PASS12 endclass();$$=0;}
2502
2503 INTERFACE_DECLARATION : MAYBE_MODIFIERS "interface" T_IDENTIFIER 
2504                               EXTENDS_LIST 
2505                               '{' {PASS12 $1.flags|=FLAG_INTERFACE;
2506                                           startclass(&$1,$3,0,$4);}
2507                               MAYBE_INTERFACE_BODY 
2508                               '}' {PASS12 endclass();$$=0;}
2509
2510 /* ------------ classes and interfaces (body) -------------- */
2511
2512 MAYBE_CLASS_BODY : 
2513 MAYBE_CLASS_BODY : CLASS_BODY
2514 CLASS_BODY : CLASS_BODY_ITEM
2515 CLASS_BODY : CLASS_BODY CLASS_BODY_ITEM
2516 CLASS_BODY_ITEM : ';'
2517 CLASS_BODY_ITEM : CONDITIONAL_COMPILATION '{' MAYBE_CLASS_BODY '}' {PASS_ALWAYS as3_pass=$1;}
2518 CLASS_BODY_ITEM : SLOT_DECLARATION
2519 CLASS_BODY_ITEM : FUNCTION_DECLARATION
2520
2521 CLASS_BODY_ITEM : CODE_STATEMENT {
2522     code_t*c = state->cls->static_init->header;
2523     c = code_append(c, $1);  
2524     state->cls->static_init->header = c;
2525 }
2526
2527 MAYBE_INTERFACE_BODY : 
2528 MAYBE_INTERFACE_BODY : INTERFACE_BODY
2529 INTERFACE_BODY : IDECLARATION
2530 INTERFACE_BODY : INTERFACE_BODY IDECLARATION
2531 IDECLARATION : ';'
2532 IDECLARATION : "var" T_IDENTIFIER {
2533     syntaxerror("variable declarations not allowed in interfaces");
2534 }
2535 IDECLARATION : MAYBE_MODIFIERS "function" GETSET T_IDENTIFIER '(' MAYBE_PARAM_LIST ')' MAYBETYPE {
2536     PASS12
2537     $1.flags |= FLAG_PUBLIC;
2538     if($1.flags&(FLAG_PRIVATE|FLAG_PACKAGEINTERNAL|FLAG_PROTECTED)) {
2539         syntaxerror("invalid method modifiers: interface methods always need to be public");
2540     }
2541     startfunction(&$1,$3,$4,&$6,$8);
2542     endfunction(&$1,$3,$4,&$6,$8, 0);
2543     list_deep_free($6.list);
2544 }
2545
2546 /* ------------ classes and interfaces (body, slots ) ------- */
2547
2548 %code {
2549     static int slotstate_varconst = 0;
2550     static modifiers_t*slotstate_flags = 0;
2551     static void setslotstate(modifiers_t* flags, int varconst)
2552     {
2553         slotstate_varconst = varconst;
2554         slotstate_flags = flags;
2555         if(state->cls) {
2556             if(flags && flags->flags&FLAG_STATIC) {
2557                 state->method = state->cls->static_init;
2558             } else {
2559                 state->method = state->cls->init;
2560             }
2561         } else {
2562             parserassert(state->method);
2563         }
2564     }
2565 };
2566
2567 VARCONST: "var" | "const"
2568
2569 SLOT_DECLARATION: MAYBE_MODIFIERS VARCONST {PASS12 setslotstate(&$1,$2);} SLOT_LIST {PASS12 $$=$4;setslotstate(0, 0);}
2570
2571 SLOT_LIST: ONE_SLOT               {PASS12 $$=0;}
2572 SLOT_LIST: SLOT_LIST ',' ONE_SLOT {PASS12 $$=0;}
2573
2574 ONE_SLOT: T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION
2575 {
2576 PASS12
2577     int flags = slotstate_flags->flags;
2578     namespace_t ns = modifiers2access(slotstate_flags);
2579
2580     if(as3_pass == 1) {
2581
2582         varinfo_t* info = 0;
2583         if(state->cls) {
2584             memberinfo_t*i = registry_findmember(state->cls->info, ns.name, $1, 1);
2585             if(i) {
2586                 check_override(i, flags);
2587             }
2588             info = varinfo_register_onclass(state->cls->info, ns.access, ns.name, $1);
2589         } else {
2590             slotinfo_t*i = registry_find(state->package, $1);
2591             if(i) {
2592                 syntaxerror("package %s already contains '%s'", state->package, $1);
2593             }
2594             if(ns.name && ns.name[0]) {
2595                 syntaxerror("namespaces not allowed on package-level variables");
2596             }
2597             info = varinfo_register_global(ns.access, state->package, $1);
2598         }
2599
2600         info->type = $2;
2601         info->flags = flags;
2602         
2603         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, info);
2604     }
2605
2606     if(as3_pass == 2) {
2607         varinfo_t*info = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
2608
2609         /* slot name */
2610         multiname_t mname = {QNAME, &ns, 0, $1};
2611       
2612         trait_list_t**traits;
2613         code_t**code;
2614         if(!state->cls) {
2615             // global variable
2616             ns.name = state->package;
2617             traits = &global->init->traits;
2618             code = &global->init->method->body->code;
2619         } else if(flags&FLAG_STATIC) {
2620             // static variable
2621             traits = &state->cls->abc->static_traits;
2622             code = &state->cls->static_init->header;
2623         } else {
2624             // instance variable
2625             traits = &state->cls->abc->traits;
2626             code = &state->cls->init->header;
2627         }
2628         
2629         trait_t*t=0;
2630         if($2) {
2631             MULTINAME(m, $2);
2632             t = trait_new_member(traits, multiname_clone(&m), multiname_clone(&mname), 0);
2633         } else {
2634             t = trait_new_member(traits, 0, multiname_clone(&mname), 0);
2635         }
2636         info->slot = t->slot_id;
2637        
2638         constant_t cval = $3->type->eval($3);
2639         if(cval.type!=CONSTANT_UNKNOWN) {
2640             /* compile time constant */
2641             t->value = malloc(sizeof(constant_t));
2642             memcpy(t->value, &cval, sizeof(constant_t));
2643         } else {
2644             typedcode_t v = node_read($3);
2645             /* initalization code (if needed) */
2646             code_t*c = 0;
2647             if(v.c && !is_pushundefined(v.c)) {
2648                 c = abc_getlocal_0(c);
2649                 c = code_append(c, v.c);
2650                 c = converttype(c, v.t, $2);
2651                 c = abc_setslot(c, t->slot_id);
2652             }
2653             *code = code_append(*code, c);
2654         }
2655
2656         if(slotstate_varconst==KW_CONST) {
2657             t->kind= TRAIT_CONST;
2658         }
2659     }
2660
2661     $$=0;
2662 }
2663
2664 /* ------------ constants -------------------------------------- */
2665
2666 MAYBECONSTANT: {$$=0;}
2667 MAYBECONSTANT: '=' CONSTANT {$$=$2;}
2668
2669 //CONSTANT : T_NAMESPACE {$$ = constant_new_namespace($1);}
2670 CONSTANT : T_INT {$$ = constant_new_int($1);}
2671 CONSTANT : T_UINT {
2672     $$ = constant_new_uint($1);
2673 }
2674 CONSTANT : T_FLOAT {$$ = constant_new_float($1);}
2675 CONSTANT : T_STRING {$$ = constant_new_string2($1.str,$1.len);free((char*)$1.str);}
2676 CONSTANT : "true" {$$ = constant_new_true($1);}
2677 CONSTANT : "false" {$$ = constant_new_false($1);}
2678 CONSTANT : "null" {$$ = constant_new_null($1);}
2679 CONSTANT : "undefined" {$$ = constant_new_undefined($1);}
2680 CONSTANT : KW_NAN {$$ = constant_new_float(__builtin_nan(""));}
2681
2682 /*
2683 CONSTANT : T_IDENTIFIER {
2684     if(!strcmp($1, "NaN")) {
2685         $$ = constant_new_float(__builtin_nan(""));
2686     } else {
2687         as3_warning("Couldn't evaluate constant value of %s", $1);
2688         $$ = constant_new_null($1);
2689     }
2690 }*/
2691
2692 /* ------------ classes and interfaces (body, functions) ------- */
2693
2694 // non-vararg version
2695 MAYBE_PARAM_LIST: {
2696     PASS12
2697     memset(&$$,0,sizeof($$));
2698 }
2699 MAYBE_PARAM_LIST: PARAM_LIST {
2700     PASS12
2701     $$=$1;
2702 }
2703
2704 // vararg version
2705 MAYBE_PARAM_LIST: "..." PARAM {
2706     PASS12
2707     memset(&$$,0,sizeof($$));
2708     $$.varargs=1;
2709     list_append($$.list, $2);
2710 }
2711 MAYBE_PARAM_LIST: PARAM_LIST ',' "..." PARAM {
2712     PASS12
2713     $$ =$1;
2714     $$.varargs=1;
2715     list_append($$.list, $4);
2716 }
2717
2718 // non empty
2719 PARAM_LIST: PARAM_LIST ',' PARAM {
2720     PASS12
2721     $$ = $1;
2722     list_append($$.list, $3);
2723 }
2724 PARAM_LIST: PARAM {
2725     PASS12
2726     memset(&$$,0,sizeof($$));
2727     list_append($$.list, $1);
2728 }
2729
2730 PARAM:  T_IDENTIFIER ':' TYPE MAYBECONSTANT {
2731      PASS12
2732      $$ = rfx_calloc(sizeof(param_t));
2733      $$->name=$1;
2734      $$->type = $3;
2735      PASS2
2736      $$->value = $4;
2737 }
2738 PARAM:  T_IDENTIFIER MAYBECONSTANT {
2739      PASS12
2740      $$ = rfx_calloc(sizeof(param_t));
2741      $$->name=$1;
2742      $$->type = TYPE_ANY;
2743      PASS2
2744      $$->value = $2;
2745 }
2746 GETSET : "get"
2747        | "set"
2748        | {PASS12 $$=0;}
2749
2750 FUNCTION_DECLARATION: MAYBE_MODIFIERS "function" GETSET T_IDENTIFIER '(' MAYBE_PARAM_LIST ')' 
2751                       MAYBETYPE '{' {PASS12 startfunction(&$1,$3,$4,&$6,$8);} MAYBECODE '}' 
2752 {
2753     PASS1 
2754     endfunction(&$1,$3,$4,&$6,0,0);
2755     PASS2
2756     if(!state->method->info) syntaxerror("internal error");
2757     
2758     code_t*c = method_header(state->method);
2759     c = wrap_function(c, 0, $11);
2760
2761     endfunction(&$1,$3,$4,&$6,$8,c);
2762     PASS12
2763     list_deep_free($6.list);
2764     $$=0;
2765 }
2766
2767 MAYBE_IDENTIFIER: T_IDENTIFIER
2768 MAYBE_IDENTIFIER: {PASS12 $$=0;}
2769 INNERFUNCTION: "function" MAYBE_IDENTIFIER '(' MAYBE_PARAM_LIST ')' MAYBETYPE 
2770                '{' {PASS12 innerfunction($2,&$4,$6);} MAYBECODE '}'
2771 {
2772     PASS1
2773     endfunction(0,0,$2,&$4,0,0);
2774     PASS2
2775     methodinfo_t*f = state->method->info;
2776     if(!f || !f->kind) syntaxerror("internal error");
2777     
2778     code_t*c = method_header(state->method);
2779     c = wrap_function(c, 0, $9);
2780
2781     int index = state->method->var_index;
2782     endfunction(0,0,$2,&$4,$6,c);
2783     
2784     $$.c = abc_getlocal(0, index);
2785     $$.t = TYPE_FUNCTION(f);
2786
2787     PASS12 list_deep_free($4.list);
2788 }
2789
2790
2791 /* ------------- package + class ids --------------- */
2792
2793 CLASS: X_IDENTIFIER {
2794     PASS1 NEW(unresolvedinfo_t,c);
2795           memset(c, 0, sizeof(*c));
2796           c->kind = INFOTYPE_UNRESOLVED;
2797           c->name = $1;
2798           c->package = get_package_from_name($1);
2799           if(!c->package) {
2800               c->nsset = get_current_imports();
2801               /* make the compiler look for this class in the current directory,
2802                  just in case: */
2803               as3_schedule_class_noerror(state->package, $1);
2804           }
2805           $$ = (classinfo_t*)c;
2806     PASS2
2807     slotinfo_t*s = find_class($1);
2808     if(!s) syntaxerror("Could not find class/method %s (current package: %s)\n", $1, state->package);
2809     $$ = (classinfo_t*)s;
2810 }
2811
2812 PACKAGEANDCLASS : PACKAGE '.' X_IDENTIFIER {
2813     PASS1 NEW(unresolvedinfo_t,c);
2814           memset(c, 0, sizeof(*c));
2815           c->kind = INFOTYPE_UNRESOLVED;
2816           c->package = $1;
2817           c->name = $3;
2818           $$ = (classinfo_t*)c;
2819     PASS2
2820     slotinfo_t*s = registry_find($1, $3);
2821     if(!s) syntaxerror("Couldn't find class/method %s.%s\n", $1, $3);
2822     free($1);$1=0;
2823     $$ = (classinfo_t*)s;
2824 }
2825
2826 CLASS_SPEC: PACKAGEANDCLASS
2827           | CLASS
2828
2829 CLASS_SPEC_LIST : CLASS_SPEC {PASS12 $$=list_new();list_append($$, $1);}
2830 CLASS_SPEC_LIST : CLASS_SPEC_LIST ',' CLASS_SPEC {PASS12 $$=$1;list_append($$,$3);}
2831
2832 TYPE : CLASS_SPEC {PASS12 $$=$1;}
2833      | '*'        {PASS12 $$=TYPE_ANY;}
2834      | "void"     {PASS12 $$=TYPE_ANY;}
2835     /*
2836      |  "String"  {$$=registry_getstringclass();}
2837      |  "int"     {$$=registry_getintclass();}
2838      |  "uint"    {$$=registry_getuintclass();}
2839      |  "Boolean" {$$=registry_getbooleanclass();}
2840      |  "Number"  {$$=registry_getnumberclass();}
2841     */
2842
2843 MAYBETYPE: ':' TYPE {PASS12 $$=$2;}
2844 MAYBETYPE:          {PASS12 $$=0;}
2845
2846 /* ----------function calls, delete, constructor calls ------ */
2847
2848 MAYBE_PARAM_VALUES :  %prec prec_none {$$.cc=0;$$.number=0;}
2849 MAYBE_PARAM_VALUES : '(' MAYBE_EXPRESSION_LIST ')' {$$=$2;}
2850
2851 MAYBE_EXPRESSION_LIST : {$$.cc=0;$$.number=0;}
2852 MAYBE_EXPRESSION_LIST : EXPRESSION_LIST
2853 MAYBE_EXPRESSION_LIST : EXPRESSION_LIST_AND_COMMA
2854
2855 EXPRESSION_LIST : NONCOMMAEXPRESSION             {$$.number=1;
2856                                                   $$.cc = $1.c;
2857                                                  }
2858
2859 EXPRESSION_LIST_AND_COMMA: EXPRESSION_LIST ',' {$$ = $1;}
2860 EXPRESSION_LIST : EXPRESSION_LIST_AND_COMMA NONCOMMAEXPRESSION {
2861                                                   $$.number= $1.number+1;
2862                                                   $$.cc = code_append($1.cc, $2.c);
2863                                                   }
2864                
2865 XX : %prec new2
2866 NEW : "new" E XX MAYBE_PARAM_VALUES {
2867     typedcode_t v = node_read($2);
2868     $$.c = v.c;
2869     if($$.c->opcode == OPCODE_COERCE_A) $$.c = code_cutlast($$.c);
2870     
2871     code_t*paramcode = $4.cc;
2872     if($$.c->opcode == OPCODE_GETPROPERTY) {
2873         multiname_t*name = $$.c->data[0];$$.c->data[0]=0;
2874         $$.c = code_cutlast($$.c);
2875         $$.c = code_append($$.c, paramcode);
2876         $$.c = abc_constructprop2($$.c, name, $4.number);
2877         multiname_destroy(name);
2878     } else if($$.c->opcode == OPCODE_GETSLOT) {
2879         int slot = (int)(ptroff_t)$$.c->data[0];
2880         trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);//FIXME
2881         multiname_t*name = t->name;
2882         $$.c = code_cutlast($$.c);
2883         $$.c = code_append($$.c, paramcode);
2884         $$.c = abc_constructprop2($$.c, name, $4.number);
2885     } else {
2886         $$.c = code_append($$.c, paramcode);
2887         $$.c = abc_construct($$.c, $4.number);
2888     }
2889    
2890     $$.t = TYPE_ANY;
2891     if(TYPE_IS_CLASS(v.t) && v.t->data) {
2892         $$.t = v.t->data;
2893     } else {
2894         $$.c = abc_coerce_a($$.c);
2895         $$.t = TYPE_ANY;
2896     }
2897 }
2898
2899 /* TODO: use abc_call (for calling local variables),
2900          abc_callstatic (for calling own methods) 
2901          call (for closures)
2902 */
2903 FUNCTIONCALL : E '(' MAYBE_EXPRESSION_LIST ')' {
2904    
2905     typedcode_t v = node_read($1);
2906     $$.c = v.c;
2907     if($$.c->opcode == OPCODE_COERCE_A) {
2908         $$.c = code_cutlast($$.c);
2909     }
2910     code_t*paramcode = $3.cc;
2911
2912     $$.t = TYPE_ANY;
2913     if($$.c->opcode == OPCODE_GETPROPERTY) {
2914         multiname_t*name = $$.c->data[0];$$.c->data[0]=0;
2915         $$.c = code_cutlast($$.c);
2916         $$.c = code_append($$.c, paramcode);
2917         $$.c = abc_callproperty2($$.c, name, $3.number);
2918         multiname_destroy(name);
2919     } else if($$.c->opcode == OPCODE_GETSLOT && $$.c->prev->opcode != OPCODE_GETSCOPEOBJECT) {
2920         int slot = (int)(ptroff_t)$$.c->data[0];
2921         trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);
2922         if(t->kind!=TRAIT_METHOD) {
2923             //ok: flash allows to assign closures to members.
2924         }
2925         multiname_t*name = t->name;
2926         $$.c = code_cutlast($$.c);
2927         $$.c = code_append($$.c, paramcode);
2928         //$$.c = abc_callmethod($$.c, t->method, len); //#1051 illegal early access binding
2929         $$.c = abc_callproperty2($$.c, name, $3.number);
2930     } else if($$.c->opcode == OPCODE_GETSUPER) {
2931         multiname_t*name = $$.c->data[0];$$.c->data[0]=0;
2932         $$.c = code_cutlast($$.c);
2933         $$.c = code_append($$.c, paramcode);
2934         $$.c = abc_callsuper2($$.c, name, $3.number);
2935         multiname_destroy(name);
2936     } else {
2937         $$.c = abc_getglobalscope($$.c);
2938         $$.c = code_append($$.c, paramcode);
2939         $$.c = abc_call($$.c, $3.number);
2940     }
2941    
2942     if(TYPE_IS_FUNCTION(v.t) && v.t->data) {
2943         $$.t = ((methodinfo_t*)(v.t->data))->return_type;
2944     } else {
2945         $$.c = abc_coerce_a($$.c);
2946         $$.t = TYPE_ANY;
2947     }
2948 }
2949
2950 FUNCTIONCALL : "super" '(' MAYBE_EXPRESSION_LIST ')' {
2951     if(!state->cls) syntaxerror("super() not allowed outside of a class");
2952     if(!state->method) syntaxerror("super() not allowed outside of a function");
2953     if(!state->method->is_constructor) syntaxerror("super() not allowed outside of a constructor");
2954
2955     $$.c = code_new();
2956     $$.c = abc_getlocal_0($$.c);
2957
2958     $$.c = code_append($$.c, $3.cc);
2959     /*
2960     this is dependent on the control path, check this somewhere else
2961     if(state->method->has_super)
2962         syntaxerror("constructor may call super() only once");
2963     */
2964     state->method->has_super = 1;
2965
2966     $$.c = abc_constructsuper($$.c, $3.number);
2967     $$.c = abc_pushundefined($$.c);
2968     $$.t = TYPE_ANY;
2969 }
2970
2971 DELETE: "delete" E {
2972     typedcode_t v = node_read($2);
2973     $$.c = v.c;
2974     if($$.c->opcode == OPCODE_COERCE_A) {
2975         $$.c = code_cutlast($$.c);
2976     }
2977     multiname_t*name = 0;
2978     if($$.c->opcode == OPCODE_GETPROPERTY) {
2979         $$.c->opcode = OPCODE_DELETEPROPERTY;
2980     } else if($$.c->opcode == OPCODE_GETSLOT) {
2981         int slot = (int)(ptroff_t)$$.c->data[0];
2982         multiname_t*name = traits_find_slotid(state->cls->abc->traits,slot)->name;
2983         $$.c = code_cutlast($$.c);
2984         $$.c = abc_deleteproperty2($$.c, name);
2985     } else {
2986         $$.c = abc_getlocal_0($$.c);
2987         MULTINAME_LATE(m, v.t?v.t->access:ACCESS_PACKAGE, "");
2988         $$.c = abc_deleteproperty2($$.c, &m);
2989     }
2990     $$.t = TYPE_BOOLEAN;
2991 }
2992
2993 RETURN: "return" %prec prec_none {
2994     $$ = abc_returnvoid(0);
2995 }
2996 RETURN: "return" EXPRESSION {
2997     $$ = $2.c;
2998     $$ = abc_returnvalue($$);
2999 }
3000
3001 // ----------------------- expression types -------------------------------------
3002
3003 NONCOMMAEXPRESSION : E %prec below_minus {
3004     $$ = node_read($1);
3005 }
3006 EXPRESSION : COMMA_EXPRESSION {
3007     $$ = node_read($1);
3008 }
3009 COMMA_EXPRESSION : E %prec below_minus {
3010     $$ = mkmultinode(&node_comma, $1);
3011 }
3012 COMMA_EXPRESSION : COMMA_EXPRESSION ',' E %prec below_minus {
3013     $$ = multinode_extend($1, $3);
3014 }
3015 VOIDEXPRESSION : E %prec below_minus { 
3016     $$ = node_exec($1); 
3017 }
3018 VOIDEXPRESSION : VOIDEXPRESSION ',' E %prec below_minus { 
3019     $$ = $1;
3020     $$ = code_append($$, node_exec($3)); 
3021 }
3022
3023 MAYBE_EXPRPAIR_LIST : {$$.cc=0;$$.number=0;}
3024 MAYBE_EXPRPAIR_LIST : EXPRPAIR_LIST {$$=$1;}
3025
3026 EXPRPAIR_LIST : NONCOMMAEXPRESSION ':' NONCOMMAEXPRESSION {
3027     $$.cc = 0;
3028     $$.cc = code_append($$.cc, $1.c);
3029     $$.cc = code_append($$.cc, $3.c);
3030     $$.number = 2;
3031 }
3032 EXPRPAIR_LIST : EXPRPAIR_LIST ',' NONCOMMAEXPRESSION ':' NONCOMMAEXPRESSION {
3033     $$.cc = $1.cc;
3034     $$.number = $1.number+2;
3035     $$.cc = code_append($$.cc, $3.c);
3036     $$.cc = code_append($$.cc, $5.c);
3037 }
3038
3039 // ----------------------- expression evaluation -------------------------------------
3040
3041 E : INNERFUNCTION %prec prec_none {$$ = mkcodenode($1);}
3042 E : VAR_READ %prec T_IDENTIFIER   {$$ = mkcodenode($1);}
3043 E : MEMBER %prec '.'              {$$ = mkcodenode($1);}
3044 E : NEW                           {$$ = mkcodenode($1);}
3045 E : DELETE                        {$$ = mkcodenode($1);}
3046 E : FUNCTIONCALL                  {$$ = mkcodenode($1);}
3047
3048 E : CONSTANT { 
3049     $$ = mkconstnode($1);
3050 }
3051
3052 /* regexp */
3053 E : T_REGEXP {
3054     typedcode_t v;
3055     v.c = 0;
3056     namespace_t ns = {ACCESS_PACKAGE, ""};
3057     multiname_t m = {QNAME, &ns, 0, "RegExp"};
3058     if(!$1.options) {
3059         v.c = abc_getlex2(v.c, &m);
3060         v.c = abc_pushstring(v.c, $1.pattern);
3061         v.c = abc_construct(v.c, 1);
3062     } else {
3063         v.c = abc_getlex2(v.c, &m);
3064         v.c = abc_pushstring(v.c, $1.pattern);
3065         v.c = abc_pushstring(v.c, $1.options);
3066         v.c = abc_construct(v.c, 2);
3067     }
3068     v.t = TYPE_REGEXP;
3069     $$ = mkcodenode(v);
3070 }
3071
3072 /* array */
3073 E : '[' MAYBE_EXPRESSION_LIST ']' {
3074     typedcode_t v;
3075     v.c = code_new();
3076     v.c = code_append(v.c, $2.cc);
3077     v.c = abc_newarray(v.c, $2.number);
3078     v.t = registry_getarrayclass();
3079     $$ = mkcodenode(v);
3080 }
3081
3082 /* dictionary */
3083 E : "{ (dictionary)" MAYBE_EXPRPAIR_LIST '}' {
3084     typedcode_t v;
3085     v.c = code_new();
3086     v.c = code_append(v.c, $2.cc);
3087     v.c = abc_newobject(v.c, $2.number/2);
3088     v.t = registry_getobjectclass();
3089     $$ =  mkcodenode(v);
3090 }
3091
3092 E : E '<' E {$$ = mknode2(&node_lt,$1,$3);}
3093 E : E '>' E {$$ = mknode2(&node_gt,$1,$3);}
3094 E : E "<=" E {$$ = mknode2(&node_le,$1,$3);}
3095 E : E ">=" E {$$ = mknode2(&node_ge,$1,$3);}
3096 E : E "==" E {$$ = mknode2(&node_eqeq,$1,$3);}
3097 E : E "===" E {$$ = mknode2(&node_eqeqeq,$1,$3);}
3098 E : E "!==" E {$$ = mknode2(&node_noteqeq,$1,$3);}
3099 E : E "!=" E {$$ = mknode2(&node_noteq,$1,$3);}
3100 E : E "||" E {$$ = mknode2(&node_oror,$1,$3);}
3101 E : E "&&" E {$$ = mknode2(&node_andand,$1,$3);}
3102 E : '!' E    {$$ = mknode1(&node_not, $2);}
3103 E : '~' E    {$$ = mknode1(&node_bitnot, $2);}
3104 E : E '&' E {$$ = mknode2(&node_bitand, $1, $3);}
3105 E : E '^' E {$$ = mknode2(&node_bitxor, $1, $3);}
3106 E : E '|' E {$$ = mknode2(&node_bitor, $1, $3);}
3107 E : E ">>" E {$$ = mknode2(&node_shr, $1, $3);}
3108 E : E ">>>" E {$$ = mknode2(&node_ushr, $1, $3);}
3109 E : E "<<" E {$$ = mknode2(&node_shl, $1, $3);}
3110 E : E '/' E {$$ = mknode2(&node_div, $1, $3);}
3111 E : E '%' E {$$ = mknode2(&node_mod, $1, $3);}
3112 E : E '+' E {$$ = mknode2(&node_plus, $1, $3);}
3113 E : E '-' E {$$ = mknode2(&node_minus, $1, $3);}
3114 E : E '*' E {$$ = mknode2(&node_multiply, $1, $3);}
3115 E : E "in" E {$$ = mknode2(&node_in, $1, $3);}
3116 E : E "as" E {$$ = mknode2(&node_as, $1, $3);}
3117 E : E "instanceof" E {$$ = mknode2(&node_instanceof, $1, $3);}
3118 E : E "is" E {$$ = mknode2(&node_is, $1, $3);}
3119 E : "typeof" '(' E ')' {$$ = mknode1(&node_typeof, $3);}
3120 E : "void" E {$$ = mknode1(&node_void, $2);}
3121 E : "void" { $$ = mkconstnode(constant_new_undefined());}
3122 E : '(' COMMA_EXPRESSION ')' { $$=$2;}
3123 E : '-' E {$$ = mknode1(&node_neg, $2);}
3124 E : E '[' E ']' {$$ = mknode2(&node_arraylookup, $1,$3);}
3125 E : E "*=" E {$$ = mknode2(&node_muleq, $1, $3);}
3126 E : E "%=" E {$$ = mknode2(&node_modeq, $1, $3);}
3127 E : E "<<=" E {$$ = mknode2(&node_shleq, $1, $3);}
3128 E : E ">>=" E {$$ = mknode2(&node_shreq, $1, $3);}
3129 E : E ">>>=" E {$$ = mknode2(&node_ushreq, $1, $3);}
3130 E : E "/=" E { $$ = mknode2(&node_diveq, $1, $3);}
3131 E : E "|=" E { $$ = mknode2(&node_bitoreq, $1, $3);}
3132 E : E "^=" E { $$ = mknode2(&node_bitxoreq, $1, $3);}
3133 E : E "&=" E { $$ = mknode2(&node_bitandeq, $1, $3);}
3134 E : E "+=" E { $$ = mknode2(&node_pluseq, $1, $3);}
3135 E : E "-=" E { $$ = mknode2(&node_minuseq, $1, $3);}
3136 E : E '=' E { $$ = mknode2(&node_assign, $1, $3);}
3137 E : E '?' E ':' E %prec below_assignment { $$ = mknode3(&node_tenary, $1, $3, $5);}
3138
3139 E : E "++" { $$ = mknode1(&node_rplusplus, $1);}
3140 E : E "--" { $$ = mknode1(&node_rminusminus, $1);}
3141 E : "++" %prec plusplus_prefix E {$$ = mknode1(&node_lplusplus, $2); }
3142 E : "--" %prec minusminus_prefix E {$$ = mknode1(&node_lminusminus, $2); }
3143
3144 E : "super" '.' T_IDENTIFIER 
3145            { if(!state->cls->info)
3146                   syntaxerror("super keyword not allowed outside a class");
3147               classinfo_t*t = state->cls->info->superclass;
3148               if(!t) t = TYPE_OBJECT;
3149               memberinfo_t*f = findmember_nsset(t, $3, 1);
3150               MEMBER_MULTINAME(m, f, $3);
3151               typedcode_t v;
3152               v.c = 0;
3153               v.c = abc_getlocal_0(v.c);
3154               v.c = abc_getsuper2(v.c, &m);
3155               v.t = slotinfo_gettype((slotinfo_t*)f);
3156               $$ = mkcodenode(v);
3157            }
3158
3159 E : '@' T_IDENTIFIER {
3160               // attribute TODO
3161               $$ = mkdummynode();
3162               as3_warning("ignored @ operator");
3163            }
3164
3165 E : E '.' '@' T_IDENTIFIER {
3166               // child attribute  TODO
3167               $$ = mkdummynode();
3168               as3_warning("ignored .@ operator");
3169            }
3170
3171 E : E '.' T_IDENTIFIER "::" T_IDENTIFIER {
3172               // namespace declaration TODO
3173               $$ = mkdummynode();
3174               as3_warning("ignored :: operator");
3175            }
3176
3177 E : E ".." T_IDENTIFIER {
3178               // descendants TODO
3179               $$ = mkdummynode();
3180               as3_warning("ignored .. operator");
3181            }
3182
3183 E : E '.' '(' E ')' {
3184               // filter TODO
3185               $$ = mkdummynode();
3186               as3_warning("ignored .() operator");
3187            }
3188
3189 //E : E "::" '[' E ']' {
3190 //              // qualified expression TODO
3191 //              $$.c = abc_pushundefined(0);
3192 //              $$.t = 0;
3193 //              as3_warning("ignored ::[] operator");
3194 //           }
3195
3196 MEMBER : E '.' T_IDENTIFIER {
3197     typedcode_t v1 = node_read($1);
3198     $$.c = v1.c;
3199     classinfo_t*t = v1.t;
3200     char is_static = 0;
3201     if(TYPE_IS_CLASS(t) && t->data) {
3202         t = t->data;
3203         is_static = 1;
3204     }
3205     if(t) {
3206         if(t->subtype==INFOTYPE_UNRESOLVED) {
3207             syntaxerror("syntaxerror: trying to resolve property '%s' on incomplete object '%s'", $3, t->name);
3208         }
3209         memberinfo_t*f = findmember_nsset(t, $3, 1);
3210         char noslot = 0;
3211         if(f && !is_static != !(f->flags&FLAG_STATIC))
3212            noslot=1;
3213         if(f && f->slot && !noslot) {
3214             $$.c = abc_getslot($$.c, f->slot);
3215         } else {
3216             if(!f) {
3217                 as3_warning("Access of undefined property '%s' in %s", $3, t->name);
3218             }
3219             
3220             MEMBER_MULTINAME(m, f, $3);
3221             $$.c = abc_getproperty2($$.c, &m);
3222         }
3223         /* determine type */
3224         $$.t = slotinfo_gettype((slotinfo_t*)f);
3225         if(!$$.t)
3226            $$.c = abc_coerce_a($$.c);
3227     } else if(v1.c && v1.c->opcode == OPCODE___PUSHPACKAGE__) {
3228         string_t*package = v1.c->data[0];
3229         char*package2 = concat3(package->str, ".", $3);
3230
3231         slotinfo_t*a = registry_find(package->str, $3);
3232         if(a) {
3233             $$ = push_class(a);
3234         } else if(dict_contains(state->import_toplevel_packages, package2) ||
3235                   registry_ispackage(package2)) {
3236             $$.c = v1.c;
3237             $$.c->data[0] = string_new4(package2);
3238             $$.t = 0;
3239         } else {
3240             syntaxerror("couldn't resolve %s", package2);
3241         }
3242     } else {
3243         /* when resolving a property on an unknown type, we do know the
3244            name of the property (and don't seem to need the package), but
3245            we need to make avm2 try out all access modes */
3246         as3_warning("Resolving %s on unknown type", $3);
3247         multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, $3};
3248         $$.c = abc_getproperty2($$.c, &m);
3249         $$.c = abc_coerce_a($$.c);
3250         $$.t = TYPE_ANY;
3251     }
3252 }
3253
3254 VAR_READ : T_IDENTIFIER {
3255     PASS1
3256     /* Queue unresolved identifiers for checking against the parent
3257        function's variables.
3258        We consider everything which is not a local variable "unresolved".
3259        This encompasses class names, members of the surrounding class
3260        etc. which is *correct* because local variables of the parent function
3261        would shadow those.
3262        */
3263     if(state->method->inner && !find_variable(state, $1)) {
3264         unknown_variable($1);
3265     }
3266    
3267     /* let the compiler know that it might want to check the current directory/package
3268        for this identifier- maybe there's a file $1.as defining $1. */
3269     as3_schedule_class_noerror(state->package, $1);
3270     PASS2
3271
3272     $$.t = 0;
3273     $$.c = 0;
3274     slotinfo_t*a = 0;
3275     memberinfo_t*f = 0;
3276
3277     variable_t*v;
3278     /* look at variables */
3279     if((v = find_variable(state, $1))) {
3280         // $1 is a local variable
3281         $$.c = abc_getlocal($$.c, v->index);
3282         $$.t = v->type;
3283         break;
3284     }
3285     if((v = find_slot(state, $1))) {
3286         $$.c = abc_getscopeobject($$.c, 1);
3287         $$.c = abc_getslot($$.c, v->index);
3288         $$.t = v->type;
3289         break;
3290     }
3291
3292     int i_am_static = (state->method && state->method->info)?(state->method->info->flags&FLAG_STATIC):FLAG_STATIC;
3293
3294     /* look at current class' members */
3295     if(!state->method->inner && 
3296         state->cls && 
3297         (f = findmember_nsset(state->cls->info, $1, 1)) &&
3298         (f->flags&FLAG_STATIC) >= i_am_static) 
3299     {
3300         // $1 is a function in this class
3301         int var_is_static = (f->flags&FLAG_STATIC);
3302
3303         if(f->kind == INFOTYPE_METHOD) {
3304             $$.t = TYPE_FUNCTION(f);
3305         } else {
3306             $$.t = f->type;
3307         }
3308         if(var_is_static && !i_am_static) {
3309         /* access to a static member from a non-static location.
3310            do this via findpropstrict:
3311            there doesn't seem to be any non-lookup way to access
3312            static properties of a class */
3313             state->method->late_binding = 1;
3314             $$.t = f->type;
3315             namespace_t ns = {f->access, f->package};
3316             multiname_t m = {QNAME, &ns, 0, $1};
3317             $$.c = abc_findpropstrict2($$.c, &m);
3318             $$.c = abc_getproperty2($$.c, &m);
3319             break;
3320         } else if(f->slot>0) {
3321             $$.c = abc_getlocal_0($$.c);
3322             $$.c = abc_getslot($$.c, f->slot);
3323             break;
3324         } else {
3325             namespace_t ns = {f->access, f->package};
3326             multiname_t m = {QNAME, &ns, 0, $1};
3327             $$.c = abc_getlocal_0($$.c);
3328             $$.c = abc_getproperty2($$.c, &m);
3329             break;
3330         }
3331     } 
3332     
3333     /* look at actual classes, in the current package and imported */
3334     if((a = find_class($1))) {
3335         $$ = push_class(a);
3336         break;
3337     }
3338
3339     /* look through package prefixes */
3340     if(dict_contains(state->import_toplevel_packages, $1) || 
3341        registry_ispackage($1)) {
3342         $$.c = abc___pushpackage__($$.c, $1);
3343         $$.t = 0;
3344         break;
3345     }
3346
3347     /* unknown object, let the avm2 resolve it */
3348     if(1) {
3349         //as3_softwarning("Couldn't resolve '%s', doing late binding", $1);
3350         as3_warning("Couldn't resolve '%s', doing late binding", $1);
3351         state->method->late_binding = 1;
3352                 
3353         multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, $1};
3354
3355         $$.t = 0;
3356         $$.c = abc_findpropstrict2($$.c, &m);
3357         $$.c = abc_getproperty2($$.c, &m);
3358     }
3359 }
3360
3361 // ----------------- namespaces -------------------------------------------------
3362
3363 NAMESPACE_ID : "namespace" T_IDENTIFIER {
3364     PASS12
3365     NEW(namespace_decl_t,n);
3366     n->name = $2;
3367     n->url = $2;
3368     $$=n;
3369 }
3370 NAMESPACE_ID : "namespace" T_IDENTIFIER '=' T_IDENTIFIER {
3371     PASS12
3372     NEW(namespace_decl_t,n);
3373     n->name = $2;
3374     n->url = $4;
3375     $$=n;
3376 }
3377 NAMESPACE_ID : "namespace" T_IDENTIFIER '=' T_STRING {
3378     PASS12
3379     NEW(namespace_decl_t,n);
3380     n->name = $2;
3381     n->url = $4.str;
3382     $$=n;
3383 }
3384 NAMESPACE_DECLARATION : MAYBE_MODIFIERS NAMESPACE_ID {
3385     PASS12
3386     trie_put(active_namespaces, $2->name, (void*)$2->url);
3387
3388     namespace_t access = modifiers2access(&$1);
3389     varinfo_t* var = varinfo_register_global(access.access, state->package, $2->name);
3390     var->type = TYPE_NAMESPACE;
3391     namespace_t ns;
3392     ns.access = ACCESS_NAMESPACE;
3393     ns.name = $2->url;
3394     var->value = constant_new_namespace(&ns);
3395
3396     $$=0;
3397 }
3398
3399 %code {
3400     void add_active_url(const char*url)
3401     {
3402         NEW(namespace_t,n);
3403         n->name = url;
3404         list_append(state->active_namespace_urls, n);
3405     }
3406 };
3407
3408 USE_NAMESPACE : "use" "namespace" CLASS_SPEC {
3409     PASS12
3410     const char*url = $3->name;
3411
3412     varinfo_t*s = (varinfo_t*)$3;
3413     if(s->kind == INFOTYPE_UNRESOLVED) {
3414         s = (varinfo_t*)registry_resolve((slotinfo_t*)s);
3415         if(!s)
3416             syntaxerror("Couldn't resolve namespace %s", $3->name);
3417     }
3418
3419     if(!s || s->kind != INFOTYPE_SLOT)
3420         syntaxerror("%s.%s is not a public namespace (%d)", $3->package, $3->name, s?s->kind:-1);
3421     if(!s->value || !NS_TYPE(s->value->type))
3422         syntaxerror("%s.%s is not a namespace", $3->package, $3->name);
3423     url = s->value->ns->name;
3424
3425     trie_put(active_namespaces, $3->name, (void*)url);
3426     add_active_url(url);
3427     $$=0;
3428 }
3429