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