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 "tokenizer.h"
  31 #include "registry.h"
  32 #include "code.h"
  33 #include "opcodes.h"
  34
  35 %}
  36
  37 //%glr-parser
  38 //%expect-rr 1
  39 %error-verbose
  40
  41 %union tokenunion {
  42     enum yytokentype token;
  43     int flags;
  44
  45     classinfo_t*classinfo;
  46     classinfo_list_t*classinfo_list;
  47
  48     int number_int;
  49     unsigned int number_uint;
  50     double number_float;
  51     code_t*code;
  52     typedcode_t value;
  53     typedcode_list_t*value_list;
  54     param_t* param;
  55     params_t params;
  56     string_t str;
  57     char*id;
  58     constant_t*constant;
  59 }
  60
  61
  62 %token<id> T_IDENTIFIER
  63 %token<str> T_STRING
  64 %token<token> T_REGEXP
  65 %token<token> T_EMPTY
  66 %token<number_int> T_INT
  67 %token<number_uint> T_UINT
  68 %token<number_uint> T_BYTE
  69 %token<number_uint> T_SHORT
  70 %token<number_float> T_FLOAT
  71
  72 %token<token> KW_IMPLEMENTS
  73 %token<token> KW_NAMESPACE "namespace"
  74 %token<token> KW_PACKAGE "package"
  75 %token<token> KW_PROTECTED
  76 %token<token> KW_PUBLIC
  77 %token<token> KW_PRIVATE
  78 %token<token> KW_USE "use"
  79 %token<token> KW_INTERNAL
  80 %token<token> KW_NEW "new"
  81 %token<token> KW_NATIVE
  82 %token<token> KW_FUNCTION "function"
  83 %token<token> KW_UNDEFINED "undefined"
  84 %token<token> KW_FOR "for"
  85 %token<token> KW_CLASS "class"
  86 %token<token> KW_CONST "const"
  87 %token<token> KW_SET "set"
  88 %token<token> KW_VOID "void"
  89 %token<token> KW_STATIC
  90 %token<token> KW_INSTANCEOF "instanceof"
  91 %token<token> KW_IMPORT "import"
  92 %token<token> KW_RETURN "return"
  93 %token<token> KW_TYPEOF "typeof"
  94 %token<token> KW_INTERFACE "interface"
  95 %token<token> KW_NULL "null"
  96 %token<token> KW_VAR "var"
  97 %token<token> KW_DYNAMIC
  98 %token<token> KW_OVERRIDE
  99 %token<token> KW_FINAL
 100 %token<token> KW_GET "get"
 101 %token<token> KW_SUPER "super"
 102 %token<token> KW_EXTENDS
 103 %token<token> KW_FALSE "false"
 104 %token<token> KW_TRUE "true"
 105 %token<token> KW_BOOLEAN "Boolean"
 106 %token<token> KW_UINT "uint"
 107 %token<token> KW_INT "int"
 108 %token<token> KW_WHILE "while"
 109 %token<token> KW_NUMBER "Number"
 110 %token<token> KW_STRING "String"
 111 %token<token> KW_DELETE "delete"
 112 %token<token> KW_IF "if"
 113 %token<token> KW_ELSE  "else"
 114 %token<token> KW_BREAK   "break"
 115 %token<token> KW_IS "is"
 116 %token<token> KW_AS "as"
 117
 118 %token<token> T_EQEQ "=="
 119 %token<token> T_EQEQEQ "==="
 120 %token<token> T_NE "!="
 121 %token<token> T_NEE "!=="
 122 %token<token> T_LE "<="
 123 %token<token> T_GE ">="
 124 %token<token> T_DIVBY "/="
 125 %token<token> T_MODBY "%="
 126 %token<token> T_MULBY "*="
 127 %token<token> T_PLUSBY "+="
 128 %token<token> T_MINUSBY "-="
 129 %token<token> T_SHRBY ">>="
 130 %token<token> T_SHLBY "<<="
 131 %token<token> T_USHRBY ">>>="
 132 %token<token> T_OROR "||"
 133 %token<token> T_ANDAND "&&"
 134 %token<token> T_COLONCOLON "::"
 135 %token<token> T_MINUSMINUS "--"
 136 %token<token> T_PLUSPLUS "++"
 137 %token<token> T_DOTDOT ".."
 138 %token<token> T_DOTDOTDOT "..."
 139 %token<token> T_SHL "<<"
 140 %token<token> T_USHR ">>>"
 141 %token<token> T_SHR ">>"
 142
 143 %type <id> X_IDENTIFIER PACKAGE
 144 %type <token> VARCONST
 145 %type <code> CODE
 146 %type <code> CODEPIECE
 147 %type <code> CODEBLOCK MAYBECODE
 148 %type <token> PACKAGE_DECLARATION
 149 %type <token> FUNCTION_DECLARATION
 150 %type <code> VARIABLE_DECLARATION ONE_VARIABLE VARIABLE_LIST
 151 %type <token> CLASS_DECLARATION
 152 %type <token> NAMESPACE_DECLARATION
 153 %type <token> INTERFACE_DECLARATION
 154 %type <code> VOIDEXPRESSION
 155 %type <value> EXPRESSION NONCOMMAEXPRESSION
 156 %type <value> MAYBEEXPRESSION
 157 %type <value> E DELETE
 158 %type <value> CONSTANT
 159 %type <code> FOR IF WHILE MAYBEELSE BREAK RETURN
 160 %type <token> USE_NAMESPACE
 161 %type <code> FOR_INIT
 162 %type <token> IMPORT
 163 %type <classinfo> MAYBETYPE
 164 %type <token> GETSET
 165 %type <param> PARAM
 166 %type <params> PARAM_LIST
 167 %type <params> MAYBE_PARAM_LIST
 168 %type <flags> MAYBE_MODIFIERS
 169 %type <flags> MODIFIER_LIST
 170 %type <constant> STATICCONSTANT MAYBESTATICCONSTANT
 171 %type <classinfo_list> IMPLEMENTS_LIST
 172 %type <classinfo> EXTENDS
 173 %type <classinfo_list> EXTENDS_LIST
 174 %type <classinfo> CLASS PACKAGEANDCLASS QNAME
 175 %type <classinfo_list> QNAME_LIST
 176 %type <classinfo> TYPE
 177 %type <token> VAR
 178 //%type <token> VARIABLE
 179 %type <value> VAR_READ
 180 %type <value> NEW
 181 //%type <token> T_IDENTIFIER
 182 %type <token> MODIFIER
 183 %type <value> FUNCTIONCALL
 184 %type <value_list> MAYBE_EXPRESSION_LIST EXPRESSION_LIST MAYBE_PARAM_VALUES
 185
 186 // precedence: from low to high
 187
 188 %left prec_none
 189
 190 %left below_semicolon
 191 %left ';'
 192 %left ','
 193 %nonassoc below_assignment // for ?:, contrary to spec
 194 %right '=' "*=" "/=" "%=" "+=" "-=" "<<=" ">>=" ">>>=" "&=" "^=" "|="
 195 %right '?' ':'
 196 %left "||"
 197 %left "&&"
 198 %nonassoc '|'
 199 %nonassoc '^'
 200 %nonassoc '&'
 201 %nonassoc "==" "!=" "===" "!=="
 202 %nonassoc "is" "as"
 203 %nonassoc "<=" '<' ">=" '>' "instanceof" // TODO: support "a < b < c" syntax?
 204 %left "<<" ">>" ">>>"
 205 %left below_minus
 206 %left '-' '+'
 207 %left '/' '*' '%'
 208 %left plusplus_prefix minusminus_prefix '~' '!' "void" "delete" "typeof" //FIXME: *unary* + - should be here, too
 209 %left "--" "++"
 210 %left '[' ']' '{' "new" '.' ".." "::"
 211 %nonassoc T_IDENTIFIER
 212 %left below_else
 213 %nonassoc "else"
 214 %left '('
 215
 216 // needed for "return" precedence:
 217 %nonassoc T_STRING T_REGEXP
 218 %nonassoc T_INT T_UINT T_BYTE T_SHORT T_FLOAT
 219 %nonassoc "false" "true" "null" "undefined" "super"
 220
 221
 222 %{
 223
 224 static int yyerror(char*s)
 225 {
 226    syntaxerror("%s", s);
 227 }
 228 static char* concat3str(const char* t1, const char* t2, const char* t3)
 229 {
 230     int l1 = strlen(t1);
 231     int l2 = strlen(t2);
 232     int l3 = strlen(t3);
 233     char*text = malloc(l1+l2+l3+1);
 234     memcpy(text   , t1, l1);
 235     memcpy(text+l1, t2, l2);
 236     memcpy(text+l1+l2, t3, l3);
 237     text[l1+l2+l3] = 0;
 238     return text;
 239 }
 240
 241 typedef struct _import {
 242     char*package;
 243 } import_t;
 244
 245 DECLARE_LIST(import);
 246
 247 typedef struct _classstate {
 248     /* class data */
 249     classinfo_t*info;
 250     abc_class_t*abc;
 251     code_t*init;
 252     code_t*static_init;
 253 } classstate_t;
 254
 255 typedef struct _methodstate {
 256     /* method data */
 257     memberinfo_t*info;
 258     char late_binding;
 259     /* code that needs to be executed at the start of
 260        a method (like initializing local registers) */
 261     code_t*initcode;
 262     char is_constructor;
 263     char has_super;
 264 } methodstate_t;
 265
 266 typedef struct _state {
 267     int level;
 268
 269     char*package;
 270     import_list_t*wildcard_imports;
 271     dict_t*imports;
 272     char has_own_imports;
 273
 274     classstate_t*cls;
 275     methodstate_t*method;
 276
 277     dict_t*vars;
 278 } state_t;
 279
 280 typedef struct _global {
 281     abc_file_t*file;
 282     abc_script_t*init;
 283
 284     int variable_count;
 285 } global_t;
 286
 287 static global_t*global = 0;
 288 static state_t* state = 0;
 289
 290 DECLARE_LIST(state);
 291
 292 #define MULTINAME(m,x) \
 293     multiname_t m;\
 294     namespace_t m##_ns;\
 295     registry_fill_multiname(&m, &m##_ns, x);
 296
 297 #define MEMBER_MULTINAME(m,f,n) \
 298     multiname_t m;\
 299     namespace_t m##_ns;\
 300     if(f) { \
 301         m##_ns.access = flags2access(f->flags); \
 302         m##_ns.name = ""; \
 303         m.type = QNAME; \
 304         m.ns = &m##_ns; \
 305         m.namespace_set = 0; \
 306         m.name = f->name; \
 307     } else { \
 308         m.type = MULTINAME; \
 309         m.ns =0; \
 310         m.namespace_set = &nopackage_namespace_set; \
 311         m.name = n; \
 312     }
 313
 314 /* warning: list length of namespace set is undefined */
 315 #define MULTINAME_LATE(m, access, package) \
 316     namespace_t m##_ns = {access, package}; \
 317     namespace_set_t m##_nsset; \
 318     namespace_list_t m##_l;m##_l.next = 0; \
 319     m##_nsset.namespaces = &m##_l; \
 320     m##_nsset = m##_nsset; \
 321     m##_l.namespace = &m##_ns; \
 322     multiname_t m = {MULTINAMEL, 0, &m##_nsset, 0};
 323
 324 static namespace_t ns1 = {ACCESS_PRIVATE, ""};
 325 static namespace_t ns2 = {ACCESS_PROTECTED, ""};
 326 static namespace_t ns3 = {ACCESS_PACKAGEINTERNAL, ""};
 327 static namespace_t ns4 = {ACCESS_PACKAGE, ""};
 328 static namespace_list_t nl4 = {&ns4,0};
 329 static namespace_list_t nl3 = {&ns3,&nl4};
 330 static namespace_list_t nl2 = {&ns2,&nl3};
 331 static namespace_list_t nl1 = {&ns1,&nl2};
 332 static namespace_set_t nopackage_namespace_set = {&nl1};
 333
 334 static state_list_t*state_stack=0;
 335
 336 static void init_globals()
 337 {
 338     global = rfx_calloc(sizeof(global_t));
 339 }
 340
 341 static void new_state()
 342 {
 343     NEW(state_t, s);
 344     NEW(state_list_t, sl);
 345
 346     state_t*oldstate = state;
 347     if(state)
 348         memcpy(s, state, sizeof(state_t)); //shallow copy
 349     sl->next = state_stack;
 350     sl->state = s;
 351     if(!s->imports) {
 352         s->imports = dict_new();
 353     }
 354     state_stack = sl;
 355     state = s;
 356     state->level++;
 357     state->has_own_imports = 0;
 358     state->vars = dict_new();
 359 }
 360 static void state_has_imports()
 361 {
 362     state->wildcard_imports = list_clone(state->wildcard_imports);
 363     state->imports = dict_clone(state->imports);
 364     state->has_own_imports = 1;
 365 }
 366
 367 static void old_state()
 368 {
 369     if(!state_stack || !state_stack->next)
 370         syntaxerror("invalid nesting");
 371     state_t*oldstate = state;
 372     state_list_t*old = state_stack;
 373     state_stack = state_stack->next;
 374     free(old);
 375     state = state_stack->state;
 376     /*if(state->method->initcode) {
 377         printf("residual initcode\n");
 378         code_dump(state->method->initcode, 0, 0, "", stdout);
 379     }*/
 380     if(oldstate->has_own_imports) {
 381         list_free(oldstate->wildcard_imports);
 382         dict_destroy(oldstate->imports);oldstate->imports=0;
 383     }
 384 }
 385 void initialize_state()
 386 {
 387     init_globals();
 388     new_state();
 389
 390     global->file = abc_file_new();
 391     global->file->flags &= ~ABCFILE_LAZY;
 392
 393     global->init = abc_initscript(global->file, 0);
 394     code_t*c = global->init->method->body->code;
 395
 396     c = abc_getlocal_0(c);
 397     c = abc_pushscope(c);
 398
 399     /* findpropstrict doesn't just return a scope object- it
 400        also makes it "active" somehow. Push local_0 on the
 401        scope stack and read it back with findpropstrict, it'll
 402        contain properties like "trace". Trying to find the same
 403        property on a "vanilla" local_0 yields only a "undefined" */
 404     //c = abc_findpropstrict(c, "[package]::trace");
 405
 406     /*c = abc_getlocal_0(c);
 407     c = abc_findpropstrict(c, "[package]::trace");
 408     c = abc_coerce_a(c);
 409     c = abc_setlocal_1(c);
 410
 411     c = abc_pushbyte(c, 0);
 412     c = abc_setlocal_2(c);
 413
 414     code_t*xx = c = abc_label(c);
 415     c = abc_findpropstrict(c, "[package]::trace");
 416     c = abc_pushstring(c, "prop:");
 417     c = abc_hasnext2(c, 1, 2);
 418     c = abc_dup(c);
 419     c = abc_setlocal_3(c);
 420     c = abc_callpropvoid(c, "[package]::trace", 2);
 421     c = abc_getlocal_3(c);
 422     c = abc_kill(c, 3);
 423     c = abc_iftrue(c,xx);*/
 424
 425     c = abc_findpropstrict(c, "[package]::trace");
 426     c = abc_pushstring(c, "[entering global init function]");
 427     c = abc_callpropvoid(c, "[package]::trace", 1);
 428
 429     global->init->method->body->code = c;
 430 }
 431 void* finalize_state()
 432 {
 433     if(state->level!=1) {
 434         syntaxerror("unexpected end of file");
 435     }
 436     abc_method_body_t*m = global->init->method->body;
 437     //__ popscope(m);
 438
 439     __ findpropstrict(m, "[package]::trace");
 440     __ pushstring(m, "[leaving global init function]");
 441     __ callpropvoid(m, "[package]::trace", 1);
 442     __ returnvoid(m);
 443     return global->file;
 444 }
 445
 446
 447 static void startpackage(char*name)
 448 {
 449     if(state->package) {
 450         syntaxerror("Packages can not be nested.");
 451     }
 452     new_state();
 453     /*printf("entering package \"%s\"\n", name);*/
 454     state->package = name;
 455 }
 456 static void endpackage()
 457 {
 458     /*printf("leaving package \"%s\"\n", state->package);*/
 459     old_state();
 460 }
 461
 462 char*globalclass=0;
 463 static void startclass(int flags, char*classname, classinfo_t*extends, classinfo_list_t*implements, char interface)
 464 {
 465     if(state->cls) {
 466         syntaxerror("inner classes now allowed");
 467     }
 468     new_state();
 469     state->cls = rfx_calloc(sizeof(classstate_t));
 470
 471     token_list_t*t=0;
 472     classinfo_list_t*mlist=0;
 473     /*printf("entering class %s\n", name);
 474     printf("  modifiers: ");for(t=modifiers->tokens;t;t=t->next) printf("%s ", t->token);printf("\n");
 475     if(extends)
 476         printf("  extends: %s.%s\n", extends->package, extends->name);
 477     printf("  implements (%d): ", list_length(implements));
 478     for(mlist=implements;mlist;mlist=mlist->next)  {
 479         printf("%s ", mlist->classinfo?mlist->classinfo->name:0);
 480     }
 481     printf("\n");
 482     */
 483
 484     if(flags&~(FLAG_INTERNAL|FLAG_PUBLIC|FLAG_FINAL))
 485         syntaxerror("invalid modifier(s)");
 486
 487     if((flags&(FLAG_PUBLIC|FLAG_INTERNAL)) == (FLAG_PUBLIC|FLAG_INTERNAL))
 488         syntaxerror("public and internal not supported at the same time.");
 489
 490     /* create the class name, together with the proper attributes */
 491     int access=0;
 492     char*package=0;
 493
 494     if(!(flags&FLAG_PUBLIC) && !state->package) {
 495         access = ACCESS_PRIVATE; package = current_filename;
 496     } else if(!(flags&FLAG_PUBLIC) && state->package) {
 497         access = ACCESS_PACKAGEINTERNAL; package = state->package;
 498     } else if(state->package) {
 499         access = ACCESS_PACKAGE; package = state->package;
 500     } else {
 501         syntaxerror("public classes only allowed inside a package");
 502     }
 503
 504     if(registry_findclass(package, classname)) {
 505         syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, classname);
 506     }
 507
 508
 509     /* build info struct */
 510     int num_interfaces = (list_length(implements));
 511     state->cls->info = classinfo_register(access, package, classname, num_interfaces);
 512     state->cls->info->superclass = extends?extends:TYPE_OBJECT;
 513     int pos = 0;
 514     classinfo_list_t*l = implements;
 515     for(l=implements;l;l=l->next) {
 516         state->cls->info->interfaces[pos++] = l->classinfo;
 517     }
 518
 519     multiname_t*extends2 = sig2mname(extends);
 520
 521     MULTINAME(classname2,state->cls->info);
 522
 523     /*if(extends) {
 524         state->cls_init = abc_getlocal_0(state->cls_init);
 525         state->cls_init = abc_constructsuper(state->cls_init, 0);
 526     }*/
 527
 528     state->cls->abc = abc_class_new(global->file, &classname2, extends2);
 529     if(flags&FLAG_FINAL) abc_class_final(state->cls->abc);
 530     if(!(flags&FLAG_DYNAMIC)) abc_class_sealed(state->cls->abc);
 531     if(interface) abc_class_interface(state->cls->abc);
 532     abc_class_protectedNS(state->cls->abc, classname);
 533
 534     for(mlist=implements;mlist;mlist=mlist->next) {
 535         MULTINAME(m, mlist->classinfo);
 536         abc_class_add_interface(state->cls->abc, &m);
 537     }
 538
 539     /* now write the construction code for this class */
 540     int slotindex = abc_initscript_addClassTrait(global->init, &classname2, state->cls->abc);
 541
 542     abc_method_body_t*m = global->init->method->body;
 543     __ getglobalscope(m);
 544     classinfo_t*s = extends;
 545
 546     int count=0;
 547
 548     while(s) {
 549         //TODO: take a look at the current scope stack, maybe
 550         //      we can re-use something
 551         s = s->superclass;
 552         if(!s)
 553         break;
 554
 555         multiname_t*s2 = sig2mname(s);
 556         __ getlex2(m, s2);
 557         multiname_destroy(s2);
 558
 559         __ pushscope(m); count++;
 560         m->code = m->code->prev->prev; // invert
 561     }
 562     /* continue appending after last op end */
 563     while(m->code && m->code->next) m->code = m->code->next;
 564
 565     /* TODO: if this is one of *our* classes, we can also
 566              do a getglobalscope/getslot <nr> (which references
 567              the init function's slots) */
 568     if(extends2) {
 569         __ getlex2(m, extends2);
 570         __ dup(m);
 571         /* notice: we get a Verify Error #1107 if the top elemnt on the scope
 572            stack is not the superclass */
 573         __ pushscope(m);count++;
 574     } else {
 575         __ pushnull(m);
 576         /* notice: we get a verify error #1107 if the top element on the scope
 577            stack is not the global object */
 578         __ getlocal_0(m);
 579         __ pushscope(m);count++;
 580     }
 581     __ newclass(m,state->cls->abc);
 582     while(count--) {
 583         __ popscope(m);
 584     }
 585     __ setslot(m, slotindex);
 586
 587     /* flash.display.MovieClip handling */
 588     if(!globalclass && (flags&FLAG_PUBLIC) && classinfo_equals(registry_getMovieClip(),extends)) {
 589         if(state->package && state->package[0]) {
 590             globalclass = concat3str(state->package, ".", classname);
 591         } else {
 592             globalclass = strdup(classname);
 593         }
 594     }
 595     multiname_destroy(extends2);
 596 }
 597
 598 static void endclass()
 599 {
 600     if(state->cls->init) {
 601         if(!state->cls->abc->constructor) {
 602             abc_method_t*m = abc_class_constructor(state->cls->abc, 0);
 603             m->body->code = code_append(m->body->code, state->cls->init);
 604             m->body->code = abc_returnvoid(m->body->code);
 605         } else {
 606             code_t*c = state->cls->abc->constructor->body->code;
 607             c = code_append(state->cls->init, c);
 608             state->cls->abc->constructor->body->code = c;
 609
 610         }
 611     }
 612     if(state->cls->static_init) {
 613         if(!state->cls->abc->static_constructor) {
 614             abc_method_t*m = abc_class_staticconstructor(state->cls->abc, 0);
 615             m->body->code = code_append(m->body->code, state->cls->static_init);
 616             m->body->code = abc_returnvoid(m->body->code);
 617         } else {
 618             state->cls->abc->static_constructor->body->code =
 619                 code_append(state->cls->static_init, state->cls->abc->static_constructor->body->code);
 620         }
 621     }
 622
 623     old_state();
 624 }
 625
 626 typedef struct _variable {
 627     int index;
 628     classinfo_t*type;
 629 } variable_t;
 630
 631 static int find_variable(char*name, classinfo_t**m)
 632 {
 633     state_list_t* s = state_stack;
 634     while(s) {
 635         variable_t*v = 0;
 636         if(s->state->method)
 637             v = dict_lookup(s->state->vars, name);
 638         if(v) {
 639             if(m) {
 640                 *m = v->type;
 641             }
 642             return v->index;
 643         }
 644         s = s->next;
 645     }
 646     return -1;
 647 }
 648 static int find_variable_safe(char*name, classinfo_t**m)
 649 {
 650     int i = find_variable(name, m);
 651     if(i<0)
 652         syntaxerror("undefined variable: %s", name);
 653     return i;
 654 }
 655 static char variable_exists(char*name)
 656 {
 657     return dict_lookup(state->vars, name)!=0;
 658 }
 659 static int new_variable(char*name, classinfo_t*type)
 660 {
 661     NEW(variable_t, v);
 662     v->index = global->variable_count;
 663     v->type = type;
 664     dict_put(state->vars, name, v);
 665     return global->variable_count++;
 666 }
 667 #define TEMPVARNAME "__as3_temp__"
 668 static int gettempvar()
 669 {
 670     int i = find_variable(TEMPVARNAME, 0);
 671     if(i<0) {
 672         i = new_variable(TEMPVARNAME, 0);
 673     }
 674     return i;
 675 }
 676
 677 code_t* killvars(code_t*c)
 678 {
 679     int t;
 680     for(t=0;t<state->vars->hashsize;t++) {
 681         dictentry_t*e =state->vars->slots[t];
 682         while(e) {
 683             variable_t*v = (variable_t*)e->data;
 684             //do this always, otherwise register types don't match
 685             //in the verifier when doing nested loops
 686             //if(!TYPE_IS_BUILTIN_SIMPLE(type)) {
 687             c = abc_kill(c, v->index);
 688             e = e->next;
 689         }
 690     }
 691     return c;
 692 }
 693
 694
 695 static void check_constant_against_type(classinfo_t*t, constant_t*c)
 696 {
 697 #define xassert(b) if(!(b)) syntaxerror("Invalid default value %s for type '%s'", constant_tostring(c), t->name)
 698    if(TYPE_IS_NUMBER(t)) {
 699         xassert(c->type == CONSTANT_FLOAT
 700              || c->type == CONSTANT_INT
 701              || c->type == CONSTANT_UINT);
 702    } else if(TYPE_IS_UINT(t)) {
 703         xassert(c->type == CONSTANT_UINT ||
 704                (c->type == CONSTANT_INT && c->i>0));
 705    } else if(TYPE_IS_INT(t)) {
 706         xassert(c->type == CONSTANT_INT);
 707    } else if(TYPE_IS_BOOLEAN(t)) {
 708         xassert(c->type == CONSTANT_TRUE
 709              || c->type == CONSTANT_FALSE);
 710    }
 711 }
 712
 713 static memberinfo_t*registerfunction(enum yytokentype getset, int flags, char*name, params_t*params, classinfo_t*return_type, int slot)
 714 {
 715     memberinfo_t*minfo = 0;
 716     if(getset != KW_GET && getset != KW_SET) {
 717         if(registry_findmember(state->cls->info, name)) {
 718             syntaxerror("class already contains a member/method called '%s'", name);
 719         }
 720         minfo = memberinfo_register(state->cls->info, name, MEMBER_METHOD);
 721         minfo->return_type = return_type;
 722         // getslot on a member slot only returns "undefined", so no need
 723         // to actually store these
 724         //state->minfo->slot = state->method->abc->method->trait->slot_id;
 725     } else {
 726         int gs = getset==KW_GET?MEMBER_GET:MEMBER_SET;
 727         classinfo_t*type=0;
 728         if(getset == KW_GET)
 729             type = return_type;
 730         else if(params->list)
 731             type = params->list->param->type;
 732         if((minfo=registry_findmember(state->cls->info, name))) {
 733             if(minfo->kind & ~(MEMBER_GET|MEMBER_SET))
 734                 syntaxerror("class already contains a member or method called '%s'", name);
 735             if(minfo->kind & gs)
 736                 syntaxerror("getter/setter for '%s' already defined", name);
 737             /* make a setter or getter into a getset */
 738             minfo->kind |= gs;
 739             if(!minfo->type)
 740                 minfo->type = type;
 741             else
 742                 if(type && minfo->type != type)
 743                     syntaxerror("different type in getter and setter");
 744         } else {
 745             minfo = memberinfo_register(state->cls->info, name, gs);
 746             minfo->type = type;
 747         }
 748         /* can't assign a slot as getter and setter might have different slots */
 749         //minfo->slot = slot;
 750     }
 751     if(flags&FLAG_STATIC) minfo->flags |= FLAG_STATIC;
 752     if(flags&FLAG_PUBLIC) minfo->flags |= FLAG_PUBLIC;
 753     if(flags&FLAG_PRIVATE) minfo->flags |= FLAG_PRIVATE;
 754     if(flags&FLAG_PROTECTED) minfo->flags |= FLAG_PROTECTED;
 755     if(flags&FLAG_INTERNAL) minfo->flags |= FLAG_INTERNAL;
 756     return minfo;
 757 }
 758
 759 static int flags2access(int flags)
 760 {
 761     int access = 0;
 762     if(flags&FLAG_PUBLIC)  {
 763         if(access&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_INTERNAL)) syntaxerror("invalid combination of access levels");
 764         access = ACCESS_PACKAGE;
 765     } else if(flags&FLAG_PRIVATE) {
 766         if(access&(FLAG_PUBLIC|FLAG_PROTECTED|FLAG_INTERNAL)) syntaxerror("invalid combination of access levels");
 767         access = ACCESS_PRIVATE;
 768     } else if(flags&FLAG_PROTECTED) {
 769         if(access&(FLAG_PUBLIC|FLAG_PRIVATE|FLAG_INTERNAL)) syntaxerror("invalid combination of access levels");
 770         access = ACCESS_PROTECTED;
 771     } else {
 772         access = ACCESS_PACKAGEINTERNAL;
 773     }
 774     return access;
 775 }
 776
 777 static void startfunction(token_t*ns, int flags, enum yytokentype getset, char*name,
 778                           params_t*params, classinfo_t*return_type)
 779 {
 780     if(state->method) {
 781         syntaxerror("not able to start another method scope");
 782     }
 783     new_state();
 784     state->method = rfx_calloc(sizeof(methodstate_t));
 785     state->method->initcode = 0;
 786     state->method->is_constructor = !strcmp(state->cls->info->name,name);
 787     state->method->has_super = 0;
 788
 789     global->variable_count = 0;
 790
 791     /* state->vars is initialized by state_new */
 792     if(new_variable((flags&FLAG_STATIC)?"class":"this", state->cls->info)!=0) syntaxerror("Internal error");
 793     param_list_t*p=0;
 794     for(p=params->list;p;p=p->next) {
 795         new_variable(p->param->name, p->param->type);
 796     }
 797     if(state->method->is_constructor)
 798         name = "__as3_constructor__";
 799     state->method->info = registerfunction(getset, flags, name, params, return_type, 0);
 800 }
 801
 802 static void endfunction(token_t*ns, int flags, enum yytokentype getset, char*name,
 803                           params_t*params, classinfo_t*return_type, code_t*body)
 804 {
 805     namespace_t mname_ns = {flags2access(flags), ""};
 806     multiname_t mname = {QNAME, &mname_ns, 0, name};
 807
 808     abc_method_t*f = 0;
 809
 810     multiname_t*type2 = sig2mname(return_type);
 811     int slot = 0;
 812     if(state->method->is_constructor) {
 813         f = abc_class_constructor(state->cls->abc, type2);
 814     } else {
 815         if(flags&FLAG_STATIC)
 816             f = abc_class_staticmethod(state->cls->abc, type2, &mname);
 817         else
 818             f = abc_class_method(state->cls->abc, type2, &mname);
 819         slot = f->trait->slot_id;
 820     }
 821     //flash doesn't seem to allow us to access function slots
 822     //state->method->info->slot = slot;
 823
 824     if(getset == KW_GET) f->trait->kind = TRAIT_GETTER;
 825     if(getset == KW_SET) f->trait->kind = TRAIT_SETTER;
 826     if(params->varargs) f->flags |= METHOD_NEED_REST;
 827
 828     char opt=0;
 829     param_list_t*p=0;
 830     for(p=params->list;p;p=p->next) {
 831         if(params->varargs && !p->next) {
 832             break; //varargs: omit last parameter in function signature
 833         }
 834         multiname_t*m = sig2mname(p->param->type);
 835         list_append(f->parameters, m);
 836         if(p->param->value) {
 837             check_constant_against_type(p->param->type, p->param->value);
 838             opt=1;list_append(f->optional_parameters, p->param->value);
 839         } else if(opt) {
 840             syntaxerror("non-optional parameter not allowed after optional parameters");
 841         }
 842     }
 843     f->body->code = body;
 844
 845     old_state();
 846 }
 847
 848
 849
 850 char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
 851 {
 852     return 1; // FIXME
 853 }
 854
 855 void breakjumpsto(code_t*c, code_t*jump)
 856 {
 857     while(c->prev)
 858         c=c->prev;
 859     while(c) {
 860         if(c->opcode == OPCODE___BREAK__) {
 861             c->opcode = OPCODE_JUMP;
 862             c->branch = jump;
 863         }
 864         c = c->next;
 865     }
 866 }
 867
 868 classinfo_t*join_types(classinfo_t*type1, classinfo_t*type2, char op)
 869 {
 870     if(!type1 || !type2)
 871         return registry_getanytype();
 872     if(TYPE_IS_ANY(type1) || TYPE_IS_ANY(type2))
 873         return registry_getanytype();
 874     if(type1 == type2)
 875         return type1;
 876     return registry_getanytype();
 877 }
 878 code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
 879 {
 880     if(from==to)
 881         return c;
 882     if(!to) {
 883         return abc_coerce_a(c);
 884     }
 885     MULTINAME(m, to);
 886     if(!from) {
 887         // cast an "any" type to a specific type. subject to
 888         // runtime exceptions
 889         return abc_coerce2(c, &m);
 890     }
 891
 892     if(TYPE_IS_NUMBER(from) && TYPE_IS_UINT(to)) {
 893         return abc_coerce2(c, &m);
 894     }
 895     if(TYPE_IS_NUMBER(from) && TYPE_IS_INT(to)) {
 896         return abc_coerce2(c, &m);
 897     }
 898     /* these are subject to overflow */
 899     if(TYPE_IS_INT(from) && TYPE_IS_UINT(to)) {
 900         return abc_coerce2(c, &m);
 901     }
 902     if(TYPE_IS_UINT(from) && TYPE_IS_INT(to)) {
 903         return abc_coerce2(c, &m);
 904     }
 905
 906     classinfo_t*supertype = from;
 907     while(supertype) {
 908         if(supertype == to) {
 909              // target type is one of from's superclasses
 910              return abc_coerce2(c, &m);
 911         }
 912         int t=0;
 913         while(supertype->interfaces[t]) {
 914             if(supertype->interfaces[t]==to) {
 915                 // to type is one of from's interfaces
 916                 return abc_coerce2(c, &m);
 917             }
 918             t++;
 919         }
 920         supertype = supertype->superclass;
 921     }
 922     if(TYPE_IS_FUNCTION(from) && TYPE_IS_FUNCTION(to))
 923         return c;
 924     if(TYPE_IS_CLASS(from) && TYPE_IS_CLASS(to))
 925         return c;
 926     syntaxerror("can't convert type %s to %s", from->name, to->name);
 927 }
 928
 929 code_t*defaultvalue(code_t*c, classinfo_t*type)
 930 {
 931     if(TYPE_IS_INT(type)) {
 932        c = abc_pushbyte(c, 0);
 933     } else if(TYPE_IS_UINT(type)) {
 934        c = abc_pushuint(c, 0);
 935     } else if(TYPE_IS_FLOAT(type)) {
 936        c = abc_pushnan(c);
 937     } else if(TYPE_IS_BOOLEAN(type)) {
 938        c = abc_pushfalse(c);
 939     } else {
 940        c = abc_pushnull(c);
 941     }
 942     return c;
 943 }
 944
 945 char is_pushundefined(code_t*c)
 946 {
 947     return (c && !c->prev && !c->next && c->opcode == OPCODE_PUSHUNDEFINED);
 948 }
 949
 950 void parserassert(int b)
 951 {
 952     if(!b) syntaxerror("internal error: assertion failed");
 953 }
 954
 955 static classinfo_t* find_class(char*name)
 956 {
 957     classinfo_t*c=0;
 958
 959     c = registry_findclass(state->package, name);
 960
 961     /* try explicit imports */
 962     dictentry_t* e = dict_get_slot(state->imports, name);
 963     while(e) {
 964         if(c)
 965             break;
 966         if(!strcmp(e->key, name)) {
 967             c = (classinfo_t*)e->data;
 968         }
 969         e = e->next;
 970     }
 971
 972     /* try package.* imports */
 973     import_list_t*l = state->wildcard_imports;
 974     while(l) {
 975         if(c)
 976             break;
 977         //printf("does package %s contain a class %s?\n", l->import->package, name);
 978         c = registry_findclass(l->import->package, name);
 979         l = l->next;
 980     }
 981
 982     /* try global package */
 983     if(!c) {
 984         c = registry_findclass("", name);
 985     }
 986     return c;
 987 }
 988
 989 static code_t* toreadwrite(code_t*in, code_t*middlepart, char justassign, char readbefore)
 990 {
 991     /* converts this:
 992
 993        [prefix code] [read instruction]
 994
 995        to this:
 996
 997        [prefix code] ([dup]) [read instruction] [middlepart] [setvar] [write instruction] [getvar]
 998     */
 999
1000     if(in && in->opcode == OPCODE_COERCE_A) {
1001         in = code_cutlast(in);
1002     }
1003     if(in->next)
1004         syntaxerror("internal error");
1005
1006     /* chop off read instruction */
1007     code_t*prefix = in;
1008     code_t*r = in;
1009     if(r->prev) {
1010         prefix = r->prev;r->prev = 0;
1011         prefix->next=0;
1012     } else {
1013         prefix = 0;
1014     }
1015
1016     char use_temp_var = readbefore;
1017
1018     /* generate the write instruction, and maybe append a dup to the prefix code */
1019     code_t* write = abc_nop(0);
1020     if(r->opcode == OPCODE_GETPROPERTY) {
1021         write->opcode = OPCODE_SETPROPERTY;
1022         multiname_t*m = (multiname_t*)r->data[0];
1023         write->data[0] = multiname_clone(m);
1024         if(m->type == QNAME || m->type == MULTINAME) {
1025             if(!justassign) {
1026                 prefix = abc_dup(prefix); // we need the object, too
1027             }
1028             use_temp_var = 1;
1029         } else if(m->type == MULTINAMEL) {
1030             if(!justassign) {
1031                 /* dupping two values on the stack requires 5 operations and one register-
1032                    couldn't adobe just have given us a dup2? */
1033                 int temp = gettempvar();
1034                 prefix = abc_setlocal(prefix, temp);
1035                 prefix = abc_dup(prefix);
1036                 prefix = abc_getlocal(prefix, temp);
1037                 prefix = abc_swap(prefix);
1038                 prefix = abc_getlocal(prefix, temp);
1039             }
1040             use_temp_var = 1;
1041         } else {
1042             syntaxerror("illegal lvalue: can't assign a value to this expression (not a qname/multiname)");
1043         }
1044     } else if(r->opcode == OPCODE_GETSLOT) {
1045         write->opcode = OPCODE_SETSLOT;
1046         write->data[0] = r->data[0];
1047         if(!justassign) {
1048             prefix = abc_dup(prefix); // we need the object, too
1049         }
1050         use_temp_var = 1;
1051     } else if(r->opcode == OPCODE_GETLOCAL) {
1052         write->opcode = OPCODE_SETLOCAL;
1053         write->data[0] = r->data[0];
1054     } else if(r->opcode == OPCODE_GETLOCAL_0) {
1055         write->opcode = OPCODE_SETLOCAL_0;
1056     } else if(r->opcode == OPCODE_GETLOCAL_1) {
1057         write->opcode = OPCODE_SETLOCAL_1;
1058     } else if(r->opcode == OPCODE_GETLOCAL_2) {
1059         write->opcode = OPCODE_SETLOCAL_2;
1060     } else if(r->opcode == OPCODE_GETLOCAL_3) {
1061         write->opcode = OPCODE_SETLOCAL_3;
1062     } else {
1063         code_dump(r, 0, 0, "", stdout);
1064         syntaxerror("illegal lvalue: can't assign a value to this expression");
1065     }
1066     code_t* c = 0;
1067
1068     int temp = -1;
1069     if(!justassign) {
1070         if(use_temp_var) {
1071             /* with getproperty/getslot, we have to be extra careful not
1072                to execute the read code twice, as it might have side-effects
1073                (e.g. if the property is in fact a setter/getter combination)
1074
1075                So read the value, modify it, and write it again,
1076                using prefix only once and making sure (by using a temporary
1077                register) that the return value is what we just wrote */
1078             temp = gettempvar();
1079             c = code_append(c, prefix);
1080             c = code_append(c, r);
1081             if(readbefore) {
1082                 c = abc_dup(c);
1083                 c = abc_setlocal(c, temp);
1084             }
1085             c = code_append(c, middlepart);
1086             if(!readbefore) {
1087                 c = abc_dup(c);
1088                 c = abc_setlocal(c, temp);
1089             }
1090             c = code_append(c, write);
1091             c = abc_getlocal(c, temp);
1092             c = abc_kill(c, temp);
1093         } else {
1094             /* if we're allowed to execute the read code twice *and*
1095                the middlepart doesn't modify the code, things are easier.
1096             */
1097             code_t* r2 = code_dup(r);
1098             //c = code_append(c, prefix);
1099             parserassert(!prefix);
1100             c = code_append(c, r);
1101             c = code_append(c, middlepart);
1102             c = code_append(c, write);
1103             c = code_append(c, r2);
1104         }
1105     } else {
1106         /* even smaller version: overwrite the value without reading
1107            it out first */
1108         if(!use_temp_var) {
1109             if(prefix) {
1110                 c = code_append(c, prefix);
1111                 c = abc_dup(c);
1112             }
1113             c = code_append(c, middlepart);
1114             c = code_append(c, write);
1115             c = code_append(c, r);
1116         } else {
1117             temp = gettempvar();
1118             if(prefix) {
1119                 c = code_append(c, prefix);
1120                 c = abc_dup(c);
1121             }
1122             c = code_append(c, middlepart);
1123             c = abc_dup(c);
1124             c = abc_setlocal(c, temp);
1125             c = code_append(c, write);
1126             c = abc_getlocal(c, temp);
1127         }
1128     }
1129
1130     return c;
1131 }
1132
1133 #define IS_INT(a) (TYPE_IS_INT((a).t) || TYPE_IS_UINT((a).t))
1134 #define BOTH_INT(a,b) (IS_INT(a) && IS_INT(b))
1135
1136 %}
1137
1138
1139 %%
1140
1141 /* ------------ code blocks / statements ---------------- */
1142
1143 PROGRAM: MAYBECODE
1144
1145 MAYBECODE: CODE {$$=$1;/*TODO: do something with this code if we're not in a function*/}
1146 MAYBECODE:      {$$=code_new();}
1147
1148 CODE: CODE CODEPIECE {$$=code_append($1,$2);}
1149 CODE: CODEPIECE {$$=$1;}
1150
1151 CODEPIECE: PACKAGE_DECLARATION   {$$=code_new();/*enters a scope*/}
1152 CODEPIECE: CLASS_DECLARATION     {$$=code_new();/*enters a scope*/}
1153 CODEPIECE: FUNCTION_DECLARATION  {$$=code_new();/*enters a scope*/}
1154 CODEPIECE: INTERFACE_DECLARATION {$$=code_new();}
1155 CODEPIECE: IMPORT                {$$=code_new();/*adds imports to current scope*/}
1156 CODEPIECE: ';'                   {$$=code_new();}
1157 CODEPIECE: VARIABLE_DECLARATION  {$$=$1}
1158 CODEPIECE: VOIDEXPRESSION        {$$=$1}
1159 CODEPIECE: FOR                   {$$=$1}
1160 CODEPIECE: WHILE                 {$$=$1}
1161 CODEPIECE: BREAK                 {$$=$1}
1162 CODEPIECE: RETURN                {$$=$1}
1163 CODEPIECE: IF                    {$$=$1}
1164 CODEPIECE: NAMESPACE_DECLARATION {/*TODO*/$$=code_new();}
1165 CODEPIECE: USE_NAMESPACE         {/*TODO*/$$=code_new();}
1166
1167 CODEBLOCK :  '{' MAYBECODE '}' {$$=$2;}
1168 CODEBLOCK :  CODEPIECE ';'             {$$=$1;}
1169 CODEBLOCK :  CODEPIECE %prec below_semicolon {$$=$1;}
1170
1171 /* ------------ variables --------------------------- */
1172
1173 MAYBEEXPRESSION : '=' NONCOMMAEXPRESSION {$$=$2;}
1174                 |                {$$.c=abc_pushundefined(0);
1175                                   $$.t=TYPE_ANY;
1176                                  }
1177
1178 VAR : "const" | "var"
1179 VARIABLE_DECLARATION : VAR VARIABLE_LIST {$$=$2;}
1180
1181 VARIABLE_LIST: ONE_VARIABLE                   {$$ = $1;}
1182 VARIABLE_LIST: VARIABLE_LIST ',' ONE_VARIABLE {$$ = code_append($1, $3);}
1183
1184 ONE_VARIABLE: {} T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION
1185 {
1186     if(variable_exists($2))
1187         syntaxerror("Variable %s already defined", $2);
1188
1189     if(!is_subtype_of($4.t, $3)) {
1190         syntaxerror("Can't convert %s to %s", $4.t->name,
1191                                               $3->name);
1192     }
1193
1194     int index = new_variable($2, $3);
1195
1196     if($3) {
1197         if($4.c->prev || $4.c->opcode != OPCODE_PUSHUNDEFINED) {
1198             $$ = $4.c;
1199             $$ = converttype($$, $4.t, $3);
1200             $$ = abc_setlocal($$, index);
1201         } else {
1202             $$ = defaultvalue(0, $3);
1203             $$ = abc_setlocal($$, index);
1204         }
1205
1206         /* if this is a typed variable:
1207            push default value for type on stack */
1208         if($3) {
1209             state->method->initcode = defaultvalue(state->method->initcode, $3);
1210             state->method->initcode = abc_setlocal(state->method->initcode, index);
1211         }
1212     } else {
1213         if($4.c->prev || $4.c->opcode != OPCODE_PUSHUNDEFINED) {
1214             $$ = $4.c;
1215             $$ = abc_coerce_a($$);
1216             $$ = abc_setlocal($$, index);
1217         } else {
1218             $$ = code_new();
1219         }
1220     }
1221
1222     /* that's the default for a local register, anyway
1223         else {
1224         state->method->initcode = abc_pushundefined(state->method->initcode);
1225         state->method->initcode = abc_setlocal(state->method->initcode, index);
1226     }*/
1227     //printf("variable %s -> %d (%s)\n", $2->text, index, $4.t?$4.t->name:"");
1228 }
1229
1230 /* ------------ control flow ------------------------- */
1231
1232 MAYBEELSE:  %prec below_else {$$ = code_new();}
1233 MAYBEELSE: "else" CODEBLOCK {$$=$2;}
1234 //MAYBEELSE: ';' "else" CODEBLOCK {$$=$3;}
1235
1236 IF  : "if" '(' {new_state();} EXPRESSION ')' CODEBLOCK MAYBEELSE {
1237     $$ = code_new();
1238     $$ = code_append($$, $4.c);
1239     code_t*myjmp,*myif = $$ = abc_iffalse($$, 0);
1240
1241     $$ = code_append($$, $6);
1242     if($7) {
1243         myjmp = $$ = abc_jump($$, 0);
1244     }
1245     myif->branch = $$ = abc_nop($$);
1246     if($7) {
1247         $$ = code_append($$, $7);
1248         myjmp->branch = $$ = abc_nop($$);
1249     }
1250
1251     $$ = killvars($$);old_state();
1252 }
1253
1254 FOR_INIT : {$$=code_new();}
1255 FOR_INIT : VARIABLE_DECLARATION
1256 FOR_INIT : VOIDEXPRESSION
1257
1258 FOR : "for" '(' {new_state();} FOR_INIT ';' EXPRESSION ';' VOIDEXPRESSION ')' CODEBLOCK {
1259     $$ = code_new();
1260     $$ = code_append($$, $4);
1261     code_t*loopstart = $$ = abc_label($$);
1262     $$ = code_append($$, $6.c);
1263     code_t*myif = $$ = abc_iffalse($$, 0);
1264     $$ = code_append($$, $10);
1265     $$ = code_append($$, $8);
1266     $$ = abc_jump($$, loopstart);
1267     code_t*out = $$ = abc_nop($$);
1268     breakjumpsto($$, out);
1269     myif->branch = out;
1270
1271     $$ = killvars($$);old_state();
1272 }
1273
1274 WHILE : "while" '(' {new_state();} EXPRESSION ')' CODEBLOCK {
1275     $$ = code_new();
1276
1277     code_t*myjmp = $$ = abc_jump($$, 0);
1278     code_t*loopstart = $$ = abc_label($$);
1279     $$ = code_append($$, $6);
1280     myjmp->branch = $$ = abc_nop($$);
1281     $$ = code_append($$, $4.c);
1282     $$ = abc_iftrue($$, loopstart);
1283     code_t*out = $$ = abc_nop($$);
1284     breakjumpsto($$, out);
1285
1286     $$ = killvars($$);old_state();
1287 }
1288
1289 BREAK : "break" {
1290     $$ = abc___break__(0);
1291 }
1292
1293 /* ------------ packages and imports ---------------- */
1294
1295 X_IDENTIFIER: T_IDENTIFIER
1296             | "package" {$$="package";}
1297
1298 PACKAGE: PACKAGE '.' X_IDENTIFIER {$$ = concat3str($1,".",$3);}
1299 PACKAGE: X_IDENTIFIER             {$$=$1;}
1300
1301 PACKAGE_DECLARATION : "package" PACKAGE '{' {startpackage($2)} MAYBECODE '}' {endpackage()}
1302 PACKAGE_DECLARATION : "package" '{' {startpackage("")} MAYBECODE '}' {endpackage()}
1303
1304 IMPORT : "import" QNAME {
1305        classinfo_t*c = $2;
1306        if(!c)
1307             syntaxerror("Couldn't import class\n");
1308        state_has_imports();
1309        dict_put(state->imports, c->name, c);
1310        $$=0;
1311 }
1312 IMPORT : "import" PACKAGE '.' '*' {
1313        NEW(import_t,i);
1314        i->package = $2;
1315        state_has_imports();
1316        list_append(state->wildcard_imports, i);
1317        $$=0;
1318 }
1319
1320 /* ------------ classes and interfaces (header) -------------- */
1321
1322 MAYBE_MODIFIERS : {$$=0;}
1323 MAYBE_MODIFIERS : MODIFIER_LIST {$$=$1}
1324 MODIFIER_LIST : MODIFIER               {$$=$1;}
1325 MODIFIER_LIST : MODIFIER_LIST MODIFIER {$$=$1|$2;}
1326
1327 MODIFIER : KW_PUBLIC {$$=FLAG_PUBLIC;}
1328          | KW_PRIVATE {$$=FLAG_PRIVATE;}
1329          | KW_PROTECTED {$$=FLAG_PROTECTED;}
1330          | KW_STATIC {$$=FLAG_STATIC;}
1331          | KW_DYNAMIC {$$=FLAG_DYNAMIC;}
1332          | KW_FINAL {$$=FLAG_FINAL;}
1333          | KW_OVERRIDE {$$=FLAG_OVERRIDE;}
1334          | KW_NATIVE {$$=FLAG_NATIVE;}
1335          | KW_INTERNAL {$$=FLAG_INTERNAL;}
1336
1337 EXTENDS : {$$=registry_getobjectclass();}
1338 EXTENDS : KW_EXTENDS QNAME {$$=$2;}
1339
1340 EXTENDS_LIST : {$$=list_new();}
1341 EXTENDS_LIST : KW_EXTENDS QNAME_LIST {$$=$2;}
1342
1343 IMPLEMENTS_LIST : {$$=list_new();}
1344 IMPLEMENTS_LIST : KW_IMPLEMENTS QNAME_LIST {$$=$2;}
1345
1346 CLASS_DECLARATION : MAYBE_MODIFIERS "class" T_IDENTIFIER
1347                               EXTENDS IMPLEMENTS_LIST
1348                               '{' {startclass($1,$3,$4,$5, 0);}
1349                               MAYBE_DECLARATION_LIST
1350                               '}' {endclass();}
1351
1352 INTERFACE_DECLARATION : MAYBE_MODIFIERS "interface" T_IDENTIFIER
1353                               EXTENDS_LIST
1354                               '{' {startclass($1,$3,0,$4,1);}
1355                               MAYBE_IDECLARATION_LIST
1356                               '}' {endclass();}
1357
1358 /* ------------ classes and interfaces (body) -------------- */
1359
1360 MAYBE_DECLARATION_LIST :
1361 MAYBE_DECLARATION_LIST : DECLARATION_LIST
1362 DECLARATION_LIST : DECLARATION
1363 DECLARATION_LIST : DECLARATION_LIST DECLARATION
1364 DECLARATION : ';'
1365 DECLARATION : SLOT_DECLARATION
1366 DECLARATION : FUNCTION_DECLARATION
1367
1368 MAYBE_IDECLARATION_LIST :
1369 MAYBE_IDECLARATION_LIST : IDECLARATION_LIST
1370 IDECLARATION_LIST : IDECLARATION
1371 IDECLARATION_LIST : IDECLARATION_LIST IDECLARATION
1372 IDECLARATION : ';'
1373 IDECLARATION : "var" T_IDENTIFIER {
1374     syntaxerror("variable declarations not allowed in interfaces");
1375 }
1376 IDECLARATION : MAYBE_MODIFIERS "function" GETSET T_IDENTIFIER '(' MAYBE_PARAM_LIST ')' MAYBETYPE {
1377     $1 |= FLAG_PUBLIC;
1378     if($1&(FLAG_PRIVATE|FLAG_INTERNAL|FLAG_PROTECTED)) {
1379         syntaxerror("invalid method modifiers: interface methods always need to be public");
1380     }
1381     startfunction(0,$1,$3,$4,&$6,$8);
1382     endfunction(0,$1,$3,$4,&$6,$8, 0);
1383 }
1384
1385 /* ------------ classes and interfaces (body, slots ) ------- */
1386
1387 VARCONST: "var" | "const"
1388
1389 SLOT_DECLARATION: MAYBE_MODIFIERS VARCONST T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION {
1390     int flags = $1;
1391     memberinfo_t* info = memberinfo_register(state->cls->info, $3, MEMBER_SLOT);
1392     info->type = $4;
1393     info->flags = flags;
1394     trait_t*t=0;
1395
1396     namespace_t mname_ns = {flags2access(flags), ""};
1397     multiname_t mname = {QNAME, &mname_ns, 0, $3};
1398
1399     if(!(flags&FLAG_STATIC)) {
1400         if($4) {
1401             MULTINAME(m, $4);
1402             t=abc_class_slot(state->cls->abc, &mname, &m);
1403         } else {
1404             t=abc_class_slot(state->cls->abc, &mname, 0);
1405         }
1406         info->slot = t->slot_id;
1407     } else {
1408         if($4) {
1409             MULTINAME(m, $4);
1410             t=abc_class_staticslot(state->cls->abc, &mname, &m);
1411         } else {
1412             t=abc_class_staticslot(state->cls->abc, &mname, 0);
1413         }
1414         info->slot = t->slot_id;
1415     }
1416     if($5.c && !is_pushundefined($5.c)) {
1417         code_t*c = 0;
1418         c = abc_getlocal_0(c);
1419         c = code_append(c, $5.c);
1420         c = converttype(c, $5.t, $4);
1421         c = abc_setslot(c, t->slot_id);
1422         if(!(flags&FLAG_STATIC))
1423             state->cls->init = code_append(state->cls->init, c);
1424         else
1425             state->cls->static_init = code_append(state->cls->static_init, c);
1426     }
1427     if($2==KW_CONST) {
1428         t->kind= TRAIT_CONST;
1429     }
1430 }
1431
1432 /* ------------ constants -------------------------------------- */
1433
1434 MAYBESTATICCONSTANT: {$$=0;}
1435 MAYBESTATICCONSTANT: '=' STATICCONSTANT {$$=$2;}
1436
1437 STATICCONSTANT : T_BYTE {$$ = constant_new_int($1);}
1438 STATICCONSTANT : T_INT {$$ = constant_new_int($1);}
1439 STATICCONSTANT : T_UINT {$$ = constant_new_uint($1);}
1440 STATICCONSTANT : T_FLOAT {$$ = constant_new_float($1);}
1441 STATICCONSTANT : T_STRING {$$ = constant_new_string2($1.str,$1.len);}
1442 //STATICCONSTANT : T_NAMESPACE {$$ = constant_new_namespace($1);}
1443 STATICCONSTANT : "true" {$$ = constant_new_true($1);}
1444 STATICCONSTANT : "false" {$$ = constant_new_false($1);}
1445 STATICCONSTANT : "null" {$$ = constant_new_null($1);}
1446
1447 /* ------------ classes and interfaces (body, functions) ------- */
1448
1449 // non-vararg version
1450 MAYBE_PARAM_LIST: {
1451     memset(&$$,0,sizeof($$));
1452 }
1453 MAYBE_PARAM_LIST: PARAM_LIST {
1454     $$=$1;
1455 }
1456
1457 // vararg version
1458 MAYBE_PARAM_LIST: "..." PARAM {
1459     memset(&$$,0,sizeof($$));
1460     $$.varargs=1;
1461     list_append($$.list, $2);
1462 }
1463 MAYBE_PARAM_LIST: PARAM_LIST ',' "..." PARAM {
1464     $$ =$1;
1465     $$.varargs=1;
1466     list_append($$.list, $4);
1467 }
1468
1469 // non empty
1470 PARAM_LIST: PARAM_LIST ',' PARAM {
1471     $$ = $1;
1472     list_append($$.list, $3);
1473 }
1474 PARAM_LIST: PARAM {
1475     memset(&$$,0,sizeof($$));
1476     list_append($$.list, $1);
1477 }
1478
1479 PARAM:  T_IDENTIFIER ':' TYPE MAYBESTATICCONSTANT {
1480      $$ = malloc(sizeof(param_t));
1481      $$->name=$1;
1482      $$->type = $3;
1483      $$->value = $4;
1484 }
1485 PARAM:  T_IDENTIFIER MAYBESTATICCONSTANT {
1486      $$ = malloc(sizeof(param_t));
1487      $$->name=$1;
1488      $$->type = TYPE_ANY;
1489      $$->value = $2;
1490 }
1491 GETSET : "get" {$$=$1;}
1492        | "set" {$$=$1;}
1493        |       {$$=0;}
1494
1495 FUNCTION_DECLARATION: MAYBE_MODIFIERS "function" GETSET T_IDENTIFIER '(' MAYBE_PARAM_LIST ')'
1496                       MAYBETYPE '{' {startfunction(0,$1,$3,$4,&$6,$8)} MAYBECODE '}'
1497 {
1498     code_t*c = 0;
1499     if(state->method->late_binding) {
1500         c = abc_getlocal_0(c);
1501         c = abc_pushscope(c);
1502     }
1503     if(state->method->is_constructor && !state->method->has_super) {
1504         // generate default constructor
1505         c = abc_getlocal_0(c);
1506         c = abc_constructsuper(c, 0);
1507     }
1508
1509     c = code_append(c, state->method->initcode);
1510     c = code_append(c, $11);
1511
1512     /* append return if necessary */
1513     if(!c || c->opcode != OPCODE_RETURNVOID &&
1514              c->opcode != OPCODE_RETURNVALUE) {
1515         c = abc_returnvoid(c);
1516     }
1517     endfunction(0,$1,$3,$4,&$6,$8,c);
1518 }
1519
1520 /* ------------- package + class ids --------------- */
1521
1522 CLASS: T_IDENTIFIER {
1523
1524     /* try current package */
1525     $$ = find_class($1);
1526     if(!$$) syntaxerror("Could not find class %s\n", $1);
1527 }
1528
1529 PACKAGEANDCLASS : PACKAGE '.' T_IDENTIFIER {
1530     $$ = registry_findclass($1, $3);
1531     if(!$$) syntaxerror("Couldn't find class %s.%s\n", $1, $3);
1532 }
1533
1534 QNAME: PACKAGEANDCLASS
1535      | CLASS
1536
1537 QNAME_LIST : QNAME {$$=list_new();list_append($$, $1);}
1538 QNAME_LIST : QNAME_LIST ',' QNAME {$$=$1;list_append($$,$3);}
1539
1540 TYPE : QNAME      {$$=$1;}
1541      | '*'        {$$=registry_getanytype();}
1542     /*
1543      |  "String"  {$$=registry_getstringclass();}
1544      |  "int"     {$$=registry_getintclass();}
1545      |  "uint"    {$$=registry_getuintclass();}
1546      |  "Boolean" {$$=registry_getbooleanclass();}
1547      |  "Number"  {$$=registry_getnumberclass();}
1548     */
1549
1550 MAYBETYPE: ':' TYPE {$$=$2;}
1551 MAYBETYPE:          {$$=0;}
1552
1553 /* ----------function calls, delete, constructor calls ------ */
1554
1555 MAYBE_PARAM_VALUES :  %prec prec_none {$$=0;}
1556 MAYBE_PARAM_VALUES : '(' MAYBE_EXPRESSION_LIST ')' {$$=$2}
1557
1558 MAYBE_EXPRESSION_LIST : {$$=0;}
1559 MAYBE_EXPRESSION_LIST : EXPRESSION_LIST
1560 EXPRESSION_LIST : NONCOMMAEXPRESSION             {$$=list_new();
1561                                                   typedcode_t*t = malloc(sizeof(typedcode_t));
1562                                                   *t = $1;
1563                                                   list_append($$, t);}
1564 EXPRESSION_LIST : EXPRESSION_LIST ',' NONCOMMAEXPRESSION {$$=$1;
1565                                                   typedcode_t*t = malloc(sizeof(typedcode_t));
1566                                                   *t = $3;
1567                                                   list_append($$, t);}
1568
1569 NEW : "new" CLASS MAYBE_PARAM_VALUES {
1570     MULTINAME(m, $2);
1571     $$.c = code_new();
1572
1573     if($2->slot) {
1574         $$.c = abc_getglobalscope($$.c);
1575         $$.c = abc_getslot($$.c, $2->slot);
1576     } else {
1577         $$.c = abc_findpropstrict2($$.c, &m);
1578     }
1579
1580     typedcode_list_t*l = $3;
1581     int len = 0;
1582     while(l) {
1583         $$.c = code_append($$.c, l->typedcode->c); // push parameters on stack
1584         l = l->next;
1585         len ++;
1586     }
1587     if($2->slot)
1588         $$.c = abc_construct($$.c, len);
1589     else
1590         $$.c = abc_constructprop2($$.c, &m, len);
1591     $$.t = $2;
1592 }
1593
1594 /* TODO: use abc_call (for calling local variables),
1595          abc_callstatic (for calling own methods)
1596          call (for closures)
1597 */
1598 FUNCTIONCALL : E '(' MAYBE_EXPRESSION_LIST ')' {
1599     typedcode_list_t*l = $3;
1600     int len = 0;
1601     code_t*paramcode = 0;
1602     while(l) {
1603         paramcode = code_append(paramcode, l->typedcode->c); // push parameters on stack
1604         l = l->next;
1605         len ++;
1606     }
1607
1608     $$.c = $1.c;
1609     if($$.c->opcode == OPCODE_COERCE_A) {
1610         $$.c = code_cutlast($$.c);
1611     }
1612
1613     $$.t = TYPE_ANY;
1614     multiname_t*name = 0;
1615     if($$.c->opcode == OPCODE_GETPROPERTY) {
1616         name = multiname_clone($$.c->data[0]);
1617         $$.c = code_cutlast($$.c);
1618         $$.c = code_append($$.c, paramcode);
1619         $$.c = abc_callproperty2($$.c, name, len);
1620     } else if($$.c->opcode == OPCODE_GETSLOT) {
1621         int slot = (int)(ptroff_t)$$.c->data[0];
1622         trait_t*t = abc_class_find_slotid(state->cls->abc,slot);//FIXME
1623         if(t->kind!=TRAIT_METHOD) {
1624             //flash allows to assign closures to members.
1625             //syntaxerror("not a function");
1626         }
1627         name = t->name;
1628         $$.c = code_cutlast($$.c);
1629         $$.c = code_append($$.c, paramcode);
1630         //$$.c = abc_callmethod($$.c, t->method, len); //#1051 illegal early access binding
1631         $$.c = abc_callproperty2($$.c, name, len);
1632     } else if($$.c->opcode == OPCODE_GETSUPER) {
1633         name = multiname_clone($$.c->data[0]);
1634         $$.c = code_cutlast($$.c);
1635         $$.c = code_append($$.c, paramcode);
1636         $$.c = abc_callsuper2($$.c, name, len);
1637     } else {
1638         $$.c = abc_getlocal_0($$.c);
1639         $$.c = code_append($$.c, paramcode);
1640         $$.c = abc_call($$.c, len);
1641     }
1642
1643     memberinfo_t*f = 0;
1644
1645     if(TYPE_IS_FUNCTION($1.t) && $1.t->function) {
1646         $$.t = $1.t->function->return_type;
1647     } else {
1648         $$.c = abc_coerce_a($$.c);
1649         $$.t = TYPE_ANY;
1650     }
1651 }
1652 FUNCTIONCALL : "super" '(' MAYBE_EXPRESSION_LIST ')' {
1653     if(!state->cls) syntaxerror("super() not allowed outside of a class");
1654     if(!state->method) syntaxerror("super() not allowed outside of a function");
1655     if(!state->method->is_constructor) syntaxerror("super() not allowed outside of a constructor");
1656
1657     $$.c = code_new();
1658     $$.c = abc_getlocal_0($$.c);
1659     typedcode_list_t*l = 0;
1660     int len = 0;
1661     for(l=$3;l;l=l->next) {
1662         $$.c = code_append($$.c, l->typedcode->c);len++;
1663     }
1664     /*
1665     this is dependent on the control path, check this somewhere else
1666     if(state->method->has_super)
1667         syntaxerror("constructor may call super() only once");
1668     */
1669     state->method->has_super = 1;
1670     $$.c = abc_constructsuper($$.c, len);
1671     $$.c = abc_pushundefined($$.c);
1672     $$.t = TYPE_ANY;
1673 }
1674
1675 DELETE: "delete" E {
1676     $$.c = $2.c;
1677     if($$.c->opcode == OPCODE_COERCE_A) {
1678         $$.c = code_cutlast($$.c);
1679     }
1680     multiname_t*name = 0;
1681     if($$.c->opcode == OPCODE_GETPROPERTY) {
1682         $$.c->opcode = OPCODE_DELETEPROPERTY;
1683     } else if($$.c->opcode == OPCODE_GETSLOT) {
1684         int slot = (int)(ptroff_t)$$.c->data[0];
1685         multiname_t*name = abc_class_find_slotid(state->cls->abc,slot)->name;
1686         $$.c = code_cutlast($$.c);
1687         $$.c = abc_deleteproperty2($$.c, name);
1688     } else {
1689         $$.c = abc_getlocal_0($$.c);
1690         MULTINAME_LATE(m, $2.t?$2.t->access:ACCESS_PACKAGE, "");
1691         $$.c = abc_deleteproperty2($$.c, &m);
1692     }
1693     $$.t = TYPE_BOOLEAN;
1694 }
1695
1696 RETURN: "return" %prec prec_none {
1697     $$ = abc_returnvoid(0);
1698 }
1699 RETURN: "return" EXPRESSION {
1700     $$ = $2.c;
1701     $$ = abc_returnvalue($$);
1702 }
1703
1704 // ----------------------- expression types -------------------------------------
1705
1706 NONCOMMAEXPRESSION : E        %prec below_minus {$$=$1;}
1707 EXPRESSION : E                %prec below_minus {$$ = $1;}
1708 EXPRESSION : EXPRESSION ',' E %prec below_minus {
1709     $$.c = $1.c;
1710     $$.c = cut_last_push($$.c);
1711     $$.c = code_append($$.c,$3.c);
1712     $$.t = $3.t;
1713 }
1714 VOIDEXPRESSION : EXPRESSION %prec below_minus {
1715     $$=cut_last_push($1.c);
1716 }
1717
1718 // ----------------------- expression evaluation -------------------------------------
1719
1720 E : CONSTANT
1721 E : VAR_READ %prec T_IDENTIFIER {$$ = $1;}
1722 E : NEW                         {$$ = $1;}
1723 E : DELETE                      {$$ = $1;}
1724 E : T_REGEXP                    {$$.c = abc_pushundefined(0); /* FIXME */
1725                                  $$.t = TYPE_ANY;
1726                                 }
1727
1728 CONSTANT : T_BYTE {$$.c = abc_pushbyte(0, $1);
1729                    //MULTINAME(m, registry_getintclass());
1730                    //$$.c = abc_coerce2($$.c, &m); // FIXME
1731                    $$.t = TYPE_INT;
1732                   }
1733 CONSTANT : T_SHORT {$$.c = abc_pushshort(0, $1);
1734                     $$.t = TYPE_INT;
1735                    }
1736 CONSTANT : T_INT {$$.c = abc_pushint(0, $1);
1737                   $$.t = TYPE_INT;
1738                  }
1739 CONSTANT : T_UINT {$$.c = abc_pushuint(0, $1);
1740                    $$.t = TYPE_UINT;
1741                   }
1742 CONSTANT : T_FLOAT {$$.c = abc_pushdouble(0, $1);
1743                     $$.t = TYPE_FLOAT;
1744                    }
1745 CONSTANT : T_STRING {$$.c = abc_pushstring2(0, &$1);
1746                      $$.t = TYPE_STRING;
1747                     }
1748 CONSTANT : "undefined" {$$.c = abc_pushundefined(0);
1749                     $$.t = TYPE_ANY;
1750                    }
1751 CONSTANT : "true" {$$.c = abc_pushtrue(0);
1752                     $$.t = TYPE_BOOLEAN;
1753                    }
1754 CONSTANT : "false" {$$.c = abc_pushfalse(0);
1755                      $$.t = TYPE_BOOLEAN;
1756                     }
1757 CONSTANT : "null" {$$.c = abc_pushnull(0);
1758                     $$.t = TYPE_NULL;
1759                    }
1760
1761 E : FUNCTIONCALL
1762 E : E '<' E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterequals($$.c);$$.c=abc_not($$.c);
1763              $$.t = TYPE_BOOLEAN;
1764             }
1765 E : E '>' E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterthan($$.c);
1766              $$.t = TYPE_BOOLEAN;
1767             }
1768 E : E "<=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterthan($$.c);$$.c=abc_not($$.c);
1769               $$.t = TYPE_BOOLEAN;
1770              }
1771 E : E ">=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterequals($$.c);
1772               $$.t = TYPE_BOOLEAN;
1773              }
1774 E : E "==" E {$$.c = code_append($1.c,$3.c);$$.c = abc_equals($$.c);
1775               $$.t = TYPE_BOOLEAN;
1776              }
1777 E : E "===" E {$$.c = code_append($1.c,$3.c);$$.c = abc_strictequals($$.c);
1778               $$.t = TYPE_BOOLEAN;
1779               }
1780 E : E "!==" E {$$.c = code_append($1.c,$3.c);$$.c = abc_strictequals($$.c);$$.c = abc_not($$.c);
1781               $$.t = TYPE_BOOLEAN;
1782              }
1783 E : E "!=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_equals($$.c);$$.c = abc_not($$.c);
1784               $$.t = TYPE_BOOLEAN;
1785              }
1786
1787 E : E "||" E {$$.t = join_types($1.t, $3.t, 'O');
1788               $$.c = $1.c;
1789               $$.c = converttype($$.c, $1.t, $$.t);
1790               $$.c = abc_dup($$.c);
1791               code_t*jmp = $$.c = abc_iftrue($$.c, 0);
1792               $$.c = cut_last_push($$.c);
1793               $$.c = code_append($$.c,$3.c);
1794               $$.c = converttype($$.c, $3.t, $$.t);
1795               code_t*label = $$.c = abc_label($$.c);
1796               jmp->branch = label;
1797              }
1798 E : E "&&" E {
1799               $$.t = join_types($1.t, $3.t, 'A');
1800               /*printf("%08x:\n",$1.t);
1801               code_dump($1.c, 0, 0, "", stdout);
1802               printf("%08x:\n",$3.t);
1803               code_dump($3.c, 0, 0, "", stdout);
1804               printf("joining %08x and %08x to %08x\n", $1.t, $3.t, $$.t);*/
1805               $$.c = $1.c;
1806               $$.c = converttype($$.c, $1.t, $$.t);
1807               $$.c = abc_dup($$.c);
1808               code_t*jmp = $$.c = abc_iffalse($$.c, 0);
1809               $$.c = cut_last_push($$.c);
1810               $$.c = code_append($$.c,$3.c);
1811               $$.c = converttype($$.c, $3.t, $$.t);
1812               code_t*label = $$.c = abc_label($$.c);
1813               jmp->branch = label;
1814              }
1815
1816 E : '!' E    {$$.c=$2.c;
1817               $$.c = abc_not($$.c);
1818               $$.t = TYPE_BOOLEAN;
1819              }
1820
1821 E : '~' E    {$$.c=$2.c;
1822               $$.c = abc_bitnot($$.c);
1823               $$.t = TYPE_INT;
1824              }
1825
1826 E : E '&' E {$$.c = code_append($1.c,$3.c);
1827              $$.c = abc_bitand($$.c);
1828              $$.t = TYPE_INT;
1829             }
1830
1831 E : E '^' E {$$.c = code_append($1.c,$3.c);
1832              $$.c = abc_bitxor($$.c);
1833              $$.t = TYPE_INT;
1834             }
1835
1836 E : E '|' E {$$.c = code_append($1.c,$3.c);
1837              $$.c = abc_bitor($$.c);
1838              $$.t = TYPE_INT;
1839             }
1840
1841 E : E '-' E {$$.c = code_append($1.c,$3.c);
1842              if(BOTH_INT($1,$3)) {
1843                 $$.c = abc_subtract_i($$.c);
1844                 $$.t = TYPE_INT;
1845              } else {
1846                 $$.c = abc_subtract($$.c);
1847                 $$.t = TYPE_NUMBER;
1848              }
1849             }
1850 E : E ">>" E {$$.c = code_append($1.c,$3.c);
1851              $$.c = abc_rshift($$.c);
1852              $$.t = TYPE_INT;
1853             }
1854 E : E ">>>" E {$$.c = code_append($1.c,$3.c);
1855              $$.c = abc_urshift($$.c);
1856              $$.t = TYPE_INT;
1857             }
1858 E : E "<<" E {$$.c = code_append($1.c,$3.c);
1859              $$.c = abc_lshift($$.c);
1860              $$.t = TYPE_INT;
1861             }
1862
1863 E : E '/' E {$$.c = code_append($1.c,$3.c);
1864              $$.c = abc_divide($$.c);
1865              $$.t = TYPE_NUMBER;
1866             }
1867 E : E '+' E {$$.c = code_append($1.c,$3.c);
1868              $$.c = abc_add($$.c);
1869              $$.t = TYPE_NUMBER;
1870             }
1871 E : E '%' E {$$.c = code_append($1.c,$3.c);
1872              $$.c = abc_modulo($$.c);
1873              $$.t = TYPE_NUMBER;
1874             }
1875 E : E '*' E {$$.c = code_append($1.c,$3.c);
1876              if(BOTH_INT($1,$3)) {
1877                 $$.c = abc_multiply_i($$.c);
1878                 $$.t = TYPE_INT;
1879              } else {
1880                 $$.c = abc_multiply($$.c);
1881                 $$.t = TYPE_NUMBER;
1882              }
1883             }
1884
1885 E : E "as" E {char use_astype=0; // flash player's astype works differently than astypelate
1886               if(use_astype && TYPE_IS_CLASS($3.t)) {
1887                 MULTINAME(m,$3.t->cls);
1888                 $$.c = abc_astype2($1.c, &m);
1889                 $$.t = $3.t->cls;
1890               } else {
1891                 $$.c = code_append($1.c, $3.c);
1892                 $$.c = abc_astypelate($$.c);
1893                 $$.t = TYPE_ANY;
1894               }
1895              }
1896
1897 E : E "instanceof" E
1898              {$$.c = code_append($1.c, $3.c);
1899               $$.c = abc_instanceof($$.c);
1900               $$.t = TYPE_BOOLEAN;
1901              }
1902
1903 E : E "is" E {$$.c = code_append($1.c, $3.c);
1904               $$.c = abc_istypelate($$.c);
1905               $$.t = TYPE_BOOLEAN;
1906              }
1907
1908 E : "typeof" '(' E ')' {
1909               $$.c = $3.c;
1910               $$.c = abc_typeof($$.c);
1911               $$.t = TYPE_STRING;
1912              }
1913
1914 E : "void" E {
1915               $$.c = cut_last_push($2.c);
1916               $$.c = abc_pushundefined($$.c);
1917               $$.t = TYPE_ANY;
1918              }
1919
1920 E : "void" { $$.c = abc_pushundefined(0);
1921              $$.t = TYPE_ANY;
1922            }
1923
1924 E : '(' EXPRESSION ')' {$$=$2;} //allow commas in here, too
1925
1926 E : '-' E {
1927   $$=$2;
1928   if(IS_INT($2)) {
1929    $$.c=abc_negate_i($$.c);
1930    $$.t = TYPE_INT;
1931   } else {
1932    $$.c=abc_negate($$.c);
1933    $$.t = TYPE_NUMBER;
1934   }
1935 }
1936
1937 E : E '[' E ']' {
1938   $$.c = $1.c;
1939   $$.c = code_append($$.c, $3.c);
1940
1941   MULTINAME_LATE(m, $1.t?$1.t->access:ACCESS_PACKAGE, "");
1942   $$.c = abc_getproperty2($$.c, &m);
1943   $$.t = 0; // array elements have unknown type
1944 }
1945
1946 E : E "*=" E {
1947                code_t*c = $3.c;
1948                if(BOTH_INT($1,$3)) {
1949                 c=abc_multiply_i(c);
1950                } else {
1951                 c=abc_multiply(c);
1952                }
1953                c=converttype(c, join_types($1.t, $3.t, '*'), $1.t);
1954                $$.c = toreadwrite($1.c, c, 0, 0);
1955                $$.t = $1.t;
1956               }
1957
1958 E : E "%=" E {
1959                code_t*c = abc_modulo($3.c);
1960                c=converttype(c, join_types($1.t, $3.t, '%'), $1.t);
1961                $$.c = toreadwrite($1.c, c, 0, 0);
1962                $$.t = $1.t;
1963               }
1964 E : E "<<=" E {
1965                code_t*c = abc_lshift($3.c);
1966                c=converttype(c, join_types($1.t, $3.t, '<'), $1.t);
1967                $$.c = toreadwrite($1.c, c, 0, 0);
1968                $$.t = $1.t;
1969               }
1970 E : E ">>=" E {
1971                code_t*c = abc_rshift($3.c);
1972                c=converttype(c, join_types($1.t, $3.t, '>'), $1.t);
1973                $$.c = toreadwrite($1.c, c, 0, 0);
1974                $$.t = $1.t;
1975               }
1976 E : E ">>>=" E {
1977                code_t*c = abc_urshift($3.c);
1978                c=converttype(c, join_types($1.t, $3.t, 'U'), $1.t);
1979                $$.c = toreadwrite($1.c, c, 0, 0);
1980                $$.t = $1.t;
1981               }
1982 E : E "/=" E {
1983                code_t*c = abc_divide($3.c);
1984                c=converttype(c, join_types($1.t, $3.t, '/'), $1.t);
1985                $$.c = toreadwrite($1.c, c, 0, 0);
1986                $$.t = $1.t;
1987               }
1988 E : E "+=" E {
1989                code_t*c = $3.c;
1990                if(TYPE_IS_INT($3.t) || TYPE_IS_UINT($3.t)) {
1991                 c=abc_add_i(c);
1992                } else {
1993                 c=abc_add(c);
1994                }
1995                c=converttype(c, join_types($1.t, $3.t, '+'), $1.t);
1996
1997                $$.c = toreadwrite($1.c, c, 0, 0);
1998                $$.t = $1.t;
1999               }
2000 E : E "-=" E { code_t*c = $3.c;
2001                if(TYPE_IS_INT($3.t) || TYPE_IS_UINT($3.t)) {
2002                 c=abc_subtract_i(c);
2003                } else {
2004                 c=abc_subtract(c);
2005                }
2006                c=converttype(c, join_types($1.t, $3.t, '-'), $1.t);
2007
2008                $$.c = toreadwrite($1.c, c, 0, 0);
2009                $$.t = $1.t;
2010              }
2011 E : E '=' E { code_t*c = 0;
2012               c = code_append(c, $3.c);
2013               c = converttype(c, $3.t, $1.t);
2014               $$.c = toreadwrite($1.c, c, 1, 0);
2015               $$.t = $1.t;
2016             }
2017
2018 E : E '?' E ':' E %prec below_assignment {
2019               $$.c = $1.c;
2020               code_t*j1 = $$.c = abc_iffalse($$.c, 0);
2021               $$.c = code_append($$.c, $3.c);
2022               code_t*j2 = $$.c = abc_jump($$.c, 0);
2023               $$.c = j1->branch = abc_label($$.c);
2024               $$.c = code_append($$.c, $5.c);
2025               $$.c = j2->branch = abc_label($$.c);
2026               $$.t = join_types($3.t,$5.t,'?');
2027             }
2028
2029 // TODO: use inclocal where appropriate
2030 E : E "++" { code_t*c = 0;
2031              classinfo_t*type = $1.t;
2032              if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
2033                  c=abc_increment_i(c);
2034                  type = TYPE_INT;
2035              } else {
2036                  c=abc_increment(c);
2037                  type = TYPE_NUMBER;
2038              }
2039              c=converttype(c, type, $1.t);
2040              $$.c = toreadwrite($1.c, c, 0, 1);
2041              $$.t = $1.t;
2042            }
2043 E : E "--" { code_t*c = 0;
2044              classinfo_t*type = $1.t;
2045              if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
2046                  c=abc_decrement_i(c);
2047                  type = TYPE_INT;
2048              } else {
2049                  c=abc_decrement(c);
2050                  type = TYPE_NUMBER;
2051              }
2052              c=converttype(c, type, $1.t);
2053              $$.c = toreadwrite($1.c, c, 0, 1);
2054              $$.t = $1.t;
2055             }
2056
2057 E : "++" %prec plusplus_prefix E { code_t*c = 0;
2058              classinfo_t*type = $2.t;
2059              if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
2060                  c=abc_increment_i(c);
2061                  type = TYPE_INT;
2062              } else {
2063                  c=abc_increment(c);
2064                  type = TYPE_NUMBER;
2065              }
2066              c=converttype(c, type, $2.t);
2067              $$.c = toreadwrite($2.c, c, 0, 0);
2068              $$.t = $2.t;
2069            }
2070
2071 E : "--" %prec minusminus_prefix E { code_t*c = 0;
2072              classinfo_t*type = $2.t;
2073              if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
2074                  c=abc_decrement_i(c);
2075                  type = TYPE_INT;
2076              } else {
2077                  c=abc_decrement(c);
2078                  type = TYPE_NUMBER;
2079              }
2080              c=converttype(c, type, $2.t);
2081              $$.c = toreadwrite($2.c, c, 0, 0);
2082              $$.t = $2.t;
2083            }
2084
2085 E : "super" '.' T_IDENTIFIER
2086            { if(!state->cls->info)
2087                   syntaxerror("super keyword not allowed outside a class");
2088               classinfo_t*t = state->cls->info->superclass;
2089               if(!t) t = TYPE_OBJECT;
2090
2091               memberinfo_t*f = registry_findmember(t, $3);
2092               namespace_t ns = {flags2access(f->flags), ""};
2093               MEMBER_MULTINAME(m, f, $3);
2094               $$.c = 0;
2095               $$.c = abc_getlocal_0($$.c);
2096               $$.c = abc_getsuper2($$.c, &m);
2097               $$.t = memberinfo_gettype(f);
2098            }
2099
2100 E : E '.' T_IDENTIFIER
2101             {$$.c = $1.c;
2102              classinfo_t*t = $1.t;
2103              char is_static = 0;
2104              if(TYPE_IS_CLASS(t) && t->cls) {
2105                  t = t->cls;
2106                  is_static = 1;
2107              }
2108              if(t) {
2109                  memberinfo_t*f = registry_findmember(t, $3);
2110                  char noslot = 0;
2111                  if(f && !is_static != !(f->flags&FLAG_STATIC))
2112                     noslot=1;
2113                  if(f && f->slot && !noslot) {
2114                      $$.c = abc_getslot($$.c, f->slot);
2115                  } else {
2116                      MEMBER_MULTINAME(m, f, $3);
2117                      $$.c = abc_getproperty2($$.c, &m);
2118                  }
2119                  /* determine type */
2120                  $$.t = memberinfo_gettype(f);
2121                  if(!$$.t)
2122                     $$.c = abc_coerce_a($$.c);
2123              } else {
2124                  /* when resolving a property on an unknown type, we do know the
2125                     name of the property (and don't seem to need the package), but
2126                     we need to make avm2 try out all access modes */
2127                  multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, $3};
2128                  $$.c = abc_getproperty2($$.c, &m);
2129                  $$.c = abc_coerce_a($$.c);
2130                  $$.t = registry_getanytype();
2131              }
2132             }
2133
2134 VAR_READ : T_IDENTIFIER {
2135     $$.t = 0;
2136     $$.c = 0;
2137     int i;
2138     classinfo_t*a = 0;
2139     memberinfo_t*f = 0;
2140
2141     /* look at variables */
2142     if((i = find_variable($1, &$$.t)) >= 0) {
2143         // $1 is a local variable
2144         $$.c = abc_getlocal($$.c, i);
2145
2146     /* look at current class' members */
2147     } else if((f = registry_findmember(state->cls->info, $1))) {
2148         // $1 is a function in this class
2149         int var_is_static = (f->flags&FLAG_STATIC);
2150         int i_am_static = ((state->method && state->method->info)?(state->method->info->flags&FLAG_STATIC):FLAG_STATIC);
2151         if(var_is_static != i_am_static) {
2152             /* there doesn't seem to be any "static" way to access
2153                static properties of a class */
2154             state->method->late_binding = 1;
2155             $$.t = f->type;
2156             namespace_t ns = {flags2access(f->flags), ""};
2157             multiname_t m = {QNAME, &ns, 0, $1};
2158             $$.c = abc_findpropstrict2($$.c, &m);
2159             $$.c = abc_getproperty2($$.c, &m);
2160         } else {
2161             if(f->slot>0) {
2162                 $$.c = abc_getlocal_0($$.c);
2163                 $$.c = abc_getslot($$.c, f->slot);
2164             } else {
2165                 namespace_t ns = {flags2access(f->flags), ""};
2166                 multiname_t m = {QNAME, &ns, 0, $1};
2167                 $$.c = abc_getlocal_0($$.c);
2168                 $$.c = abc_getproperty2($$.c, &m);
2169             }
2170         }
2171         if(f->kind == MEMBER_METHOD) {
2172             $$.t = TYPE_FUNCTION(f);
2173         } else {
2174             $$.t = f->type;
2175         }
2176
2177     /* look at classes in the current package and imported classes */
2178     } else if((a = find_class($1))) {
2179         if(a->slot) {
2180             $$.c = abc_getglobalscope($$.c);
2181             $$.c = abc_getslot($$.c, a->slot);
2182         } else {
2183             MULTINAME(m, a);
2184             $$.c = abc_getlex2($$.c, &m);
2185         }
2186         $$.t = TYPE_CLASS(a);
2187
2188     /* unknown object, let the avm2 resolve it */
2189     } else {
2190         if(strcmp($1,"trace"))
2191             warning("Couldn't resolve '%s', doing late binding", $1);
2192         state->method->late_binding = 1;
2193
2194         multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, $1};
2195
2196         $$.t = 0;
2197         $$.c = abc_findpropstrict2($$.c, &m);
2198         $$.c = abc_getproperty2($$.c, &m);
2199     }
2200 }
2201
2202 //TODO:
2203 //VARIABLE : VARIABLE ".." T_IDENTIFIER // descendants
2204 //VARIABLE : VARIABLE "::" VARIABLE // namespace declaration
2205 //VARIABLE : VARIABLE "::" '[' EXPRESSION ']' // qualified expression
2206
2207 // ----------------- namespaces -------------------------------------------------
2208
2209 NAMESPACE_DECLARATION : MAYBE_MODIFIERS "namespace" T_IDENTIFIER {$$=$2;}
2210 NAMESPACE_DECLARATION : MAYBE_MODIFIERS "namespace" T_IDENTIFIER '=' T_IDENTIFIER {$$=$2;}
2211 NAMESPACE_DECLARATION : MAYBE_MODIFIERS "namespace" T_IDENTIFIER '=' T_STRING {$$=$2;}
2212
2213 USE_NAMESPACE : "use" "namespace" T_IDENTIFIER
2214