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             use_temp_var = 1;
 928             prefix = abc_dup(prefix); // we need the object, too
 929         }
 930     } else if(r->opcode == OPCODE_GETSLOT) {
 931         write->opcode = OPCODE_SETSLOT;
 932         write->data[0] = r->data[0];
 933         if(!justassign) {
 934             use_temp_var = 1;
 935             prefix = abc_dup(prefix); // we need the object, too
 936         }
 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(prefix) {
 995             c = code_append(c, prefix);
 996             c = abc_dup(c);
 997         }
 998         c = code_append(c, middlepart);
 999         c = code_append(c, write);
1000         c = code_append(c, r);
1001     }
1002
1003     return c;
1004 }
1005
1006
1007 %}
1008
1009
1010 %%
1011
1012 /* ------------ code blocks / statements ---------------- */
1013
1014 PROGRAM: MAYBECODE
1015
1016 MAYBECODE: CODE {$$=$1;}
1017 MAYBECODE:      {$$=code_new();}
1018
1019 CODE: CODE CODEPIECE {$$=code_append($1,$2);}
1020 CODE: CODEPIECE {$$=$1;}
1021
1022 CODEPIECE: PACKAGE_DECLARATION   {$$=code_new();/*enters a scope*/}
1023 CODEPIECE: CLASS_DECLARATION     {$$=code_new();/*enters a scope*/}
1024 CODEPIECE: FUNCTION_DECLARATION  {$$=code_new();/*enters a scope*/}
1025 CODEPIECE: INTERFACE_DECLARATION {$$=code_new();}
1026 CODEPIECE: IMPORT                {$$=code_new();/*adds imports to current scope*/}
1027 CODEPIECE: ';'                   {$$=code_new();}
1028 CODEPIECE: VARIABLE_DECLARATION  {$$=$1}
1029 CODEPIECE: VOIDEXPRESSION        {$$=$1}
1030 CODEPIECE: FOR                   {$$=$1}
1031 CODEPIECE: WHILE                 {$$=$1}
1032 CODEPIECE: BREAK                 {$$=$1}
1033 CODEPIECE: RETURN                {$$=$1}
1034 CODEPIECE: IF                    {$$=$1}
1035 CODEPIECE: NAMESPACE_DECLARATION {/*TODO*/$$=code_new();}
1036 CODEPIECE: USE_NAMESPACE         {/*TODO*/$$=code_new();}
1037
1038 CODEBLOCK :  '{' MAYBECODE '}' {$$=$2;}
1039 CODEBLOCK :  CODEPIECE ';'             {$$=$1;}
1040 CODEBLOCK :  CODEPIECE %prec below_semicolon {$$=$1;}
1041
1042 /* ------------ variables --------------------------- */
1043
1044 MAYBEEXPRESSION : '=' NONCOMMAEXPRESSION {$$=$2;}
1045                 |                {$$.c=abc_pushundefined(0);
1046                                   $$.t=TYPE_ANY;
1047                                  }
1048
1049 VAR : "const" | "var"
1050 VARIABLE_DECLARATION : VAR VARIABLE_LIST {$$=$2;}
1051
1052 VARIABLE_LIST: ONE_VARIABLE                   {$$ = $1;}
1053 VARIABLE_LIST: VARIABLE_LIST ',' ONE_VARIABLE {$$ = code_append($1, $3);}
1054
1055 ONE_VARIABLE: {} T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION
1056 {
1057     if(variable_exists($2))
1058         syntaxerror("Variable %s already defined", $2);
1059
1060     if(!is_subtype_of($4.t, $3)) {
1061         syntaxerror("Can't convert %s to %s", $4.t->name,
1062                                               $3->name);
1063     }
1064
1065     int index = new_variable($2, $3);
1066
1067     if($3) {
1068         if($4.c->prev || $4.c->opcode != OPCODE_PUSHUNDEFINED) {
1069             $$ = $4.c;
1070             $$ = converttype($$, $4.t, $3);
1071             $$ = abc_setlocal($$, index);
1072         } else {
1073             $$ = defaultvalue(0, $3);
1074             $$ = abc_setlocal($$, index);
1075         }
1076
1077         /* if this is a typed variable:
1078            push default value for type on stack */
1079         if($3) {
1080             state->initcode = defaultvalue(state->initcode, $3);
1081             state->initcode = abc_setlocal(state->initcode, index);
1082         }
1083     } else {
1084         if($4.c->prev || $4.c->opcode != OPCODE_PUSHUNDEFINED) {
1085             $$ = $4.c;
1086             $$ = abc_coerce_a($$);
1087             $$ = abc_setlocal($$, index);
1088         } else {
1089             $$ = code_new();
1090         }
1091     }
1092
1093     /* that's the default for a local register, anyway
1094         else {
1095         state->initcode = abc_pushundefined(state->initcode);
1096         state->initcode = abc_setlocal(state->initcode, index);
1097     }*/
1098     //printf("variable %s -> %d (%s)\n", $2->text, index, $4.t?$4.t->name:"");
1099 }
1100
1101 /* ------------ control flow ------------------------- */
1102
1103 MAYBEELSE:  %prec prec_none {$$ = code_new();}
1104 MAYBEELSE: "else" CODEBLOCK {$$=$2;}
1105 //MAYBEELSE: ';' "else" CODEBLOCK {$$=$3;}
1106
1107 IF  : "if" '(' {new_state();} EXPRESSION ')' CODEBLOCK MAYBEELSE {
1108     $$ = state->initcode;state->initcode=0;
1109
1110     $$ = code_append($$, $4.c);
1111     code_t*myjmp,*myif = $$ = abc_iffalse($$, 0);
1112
1113     $$ = code_append($$, $6);
1114     if($7) {
1115         myjmp = $$ = abc_jump($$, 0);
1116     }
1117     myif->branch = $$ = abc_label($$);
1118     if($7) {
1119         $$ = code_append($$, $7);
1120         myjmp->branch = $$ = abc_label($$);
1121     }
1122
1123     $$ = killvars($$);old_state();
1124 }
1125
1126 FOR_INIT : {$$=code_new();}
1127 FOR_INIT : VARIABLE_DECLARATION
1128 FOR_INIT : VOIDEXPRESSION
1129
1130 FOR : "for" '(' {new_state();} FOR_INIT ';' EXPRESSION ';' VOIDEXPRESSION ')' CODEBLOCK {
1131     $$ = state->initcode;state->initcode=0;
1132
1133     $$ = code_append($$, $4);
1134     code_t*loopstart = $$ = abc_label($$);
1135     $$ = code_append($$, $6.c);
1136     code_t*myif = $$ = abc_iffalse($$, 0);
1137     $$ = code_append($$, $10);
1138     $$ = code_append($$, $8);
1139     $$ = abc_jump($$, loopstart);
1140     code_t*out = $$ = abc_label($$);
1141     breakjumpsto($$, out);
1142     myif->branch = out;
1143
1144     $$ = killvars($$);old_state();
1145 }
1146
1147 WHILE : "while" '(' {new_state();} EXPRESSION ')' CODEBLOCK {
1148     $$ = state->initcode;state->initcode=0;
1149
1150     code_t*myjmp = $$ = abc_jump($$, 0);
1151     code_t*loopstart = $$ = abc_label($$);
1152     $$ = code_append($$, $6);
1153     myjmp->branch = $$ = abc_label($$);
1154     $$ = code_append($$, $4.c);
1155     $$ = abc_iftrue($$, loopstart);
1156     code_t*out = $$ = abc_label($$);
1157     breakjumpsto($$, out);
1158
1159     $$ = killvars($$);old_state();
1160 }
1161
1162 BREAK : "break" {
1163     $$ = abc___break__(0);
1164 }
1165
1166 /* ------------ packages and imports ---------------- */
1167
1168 X_IDENTIFIER: T_IDENTIFIER
1169             | "package" {$$="package";}
1170
1171 PACKAGE: PACKAGE '.' X_IDENTIFIER {$$ = concat3str($1,".",$3);}
1172 PACKAGE: X_IDENTIFIER             {$$=$1;}
1173
1174 PACKAGE_DECLARATION : "package" PACKAGE '{' {startpackage($2)} MAYBECODE '}' {endpackage()}
1175 PACKAGE_DECLARATION : "package" '{' {startpackage("")} MAYBECODE '}' {endpackage()}
1176
1177 IMPORT : "import" QNAME {
1178        classinfo_t*c = $2;
1179        if(!c)
1180             syntaxerror("Couldn't import class\n");
1181        state_has_imports();
1182        dict_put(state->imports, c->name, c);
1183        $$=0;
1184 }
1185 IMPORT : "import" PACKAGE '.' '*' {
1186        NEW(import_t,i);
1187        i->package = $2;
1188        state_has_imports();
1189        list_append(state->wildcard_imports, i);
1190        $$=0;
1191 }
1192
1193 /* ------------ classes and interfaces (header) -------------- */
1194
1195 MAYBE_MODIFIERS : {$$=0;}
1196 MAYBE_MODIFIERS : MODIFIER_LIST {$$=$1}
1197 MODIFIER_LIST : MODIFIER               {$$=$1;}
1198 MODIFIER_LIST : MODIFIER_LIST MODIFIER {$$=$1|$2;}
1199
1200 MODIFIER : KW_PUBLIC {$$=FLAG_PUBLIC;}
1201          | KW_PRIVATE {$$=FLAG_PRIVATE;}
1202          | KW_PROTECTED {$$=FLAG_PROTECTED;}
1203          | KW_STATIC {$$=FLAG_STATIC;}
1204          | KW_DYNAMIC {$$=FLAG_DYNAMIC;}
1205          | KW_FINAL {$$=FLAG_FINAL;}
1206          | KW_OVERRIDE {$$=FLAG_OVERRIDE;}
1207          | KW_NATIVE {$$=FLAG_NATIVE;}
1208          | KW_INTERNAL {$$=FLAG_INTERNAL;}
1209
1210 EXTENDS : {$$=registry_getobjectclass();}
1211 EXTENDS : KW_EXTENDS QNAME {$$=$2;}
1212
1213 EXTENDS_LIST : {$$=list_new();}
1214 EXTENDS_LIST : KW_EXTENDS QNAME_LIST {$$=$2;}
1215
1216 IMPLEMENTS_LIST : {$$=list_new();}
1217 IMPLEMENTS_LIST : KW_IMPLEMENTS QNAME_LIST {$$=$2;}
1218
1219 CLASS_DECLARATION : MAYBE_MODIFIERS "class" T_IDENTIFIER
1220                               EXTENDS IMPLEMENTS_LIST
1221                               '{' {startclass($1,$3,$4,$5, 0);}
1222                               MAYBE_DECLARATION_LIST
1223                               '}' {endclass();}
1224
1225 INTERFACE_DECLARATION : MAYBE_MODIFIERS "interface" T_IDENTIFIER
1226                               EXTENDS_LIST
1227                               '{' {startclass($1,$3,0,$4,1);}
1228                               MAYBE_IDECLARATION_LIST
1229                               '}' {endclass();}
1230
1231 /* ------------ classes and interfaces (body) -------------- */
1232
1233 MAYBE_DECLARATION_LIST :
1234 MAYBE_DECLARATION_LIST : DECLARATION_LIST
1235 DECLARATION_LIST : DECLARATION
1236 DECLARATION_LIST : DECLARATION_LIST DECLARATION
1237 DECLARATION : ';'
1238 DECLARATION : SLOT_DECLARATION
1239 DECLARATION : FUNCTION_DECLARATION
1240
1241 MAYBE_IDECLARATION_LIST :
1242 MAYBE_IDECLARATION_LIST : IDECLARATION_LIST
1243 IDECLARATION_LIST : IDECLARATION
1244 IDECLARATION_LIST : IDECLARATION_LIST IDECLARATION
1245 IDECLARATION : ';'
1246 IDECLARATION : "var" T_IDENTIFIER {
1247     syntaxerror("variable declarations not allowed in interfaces");
1248 }
1249 IDECLARATION : MAYBE_MODIFIERS "function" GETSET T_IDENTIFIER '(' MAYBE_PARAM_LIST ')' MAYBETYPE {
1250     if($1&(FLAG_PUBLIC|FLAG_PRIVATE|FLAG_INTERNAL|FLAG_PROTECTED)) {
1251         syntaxerror("invalid method modifiers: interface methods are always public");
1252     }
1253     startfunction(0,$1,$3,$4,&$6,$8);
1254     endfunction(0);
1255 }
1256
1257 /* ------------ classes and interfaces (body, slots ) ------- */
1258
1259 VARCONST: "var" | "const"
1260 SLOT_DECLARATION: MAYBE_MODIFIERS VARCONST T_IDENTIFIER MAYBETYPE MAYBEEXPRESSION {
1261
1262     memberinfo_t* info = memberinfo_register(state->clsinfo, $3, MEMBER_SLOT);
1263     info->type = $4;
1264
1265     trait_t*t=0;
1266     if($4) {
1267         MULTINAME(m, $4);
1268         t=abc_class_slot(state->cls, $3, &m);
1269     } else {
1270         t=abc_class_slot(state->cls, $3, 0);
1271     }
1272     if($2==KW_CONST) {
1273         t->kind= TRAIT_CONST;
1274     }
1275     info->slot = t->slot_id;
1276     if($5.c && !is_pushundefined($5.c)) {
1277         code_t*c = 0;
1278         c = abc_getlocal_0(c);
1279         c = code_append(c, $5.c);
1280         c = converttype(c, $5.t, $4);
1281         c = abc_setslot(c, t->slot_id);
1282         //c = abc_setproperty(c, $3);
1283         state->cls_init = code_append(state->cls_init, c);
1284     }
1285 }
1286
1287 /* ------------ constants -------------------------------------- */
1288
1289 MAYBESTATICCONSTANT: {$$=0;}
1290 MAYBESTATICCONSTANT: '=' STATICCONSTANT {$$=$2;}
1291
1292 STATICCONSTANT : T_BYTE {$$ = constant_new_int($1);}
1293 STATICCONSTANT : T_INT {$$ = constant_new_int($1);}
1294 STATICCONSTANT : T_UINT {$$ = constant_new_uint($1);}
1295 STATICCONSTANT : T_FLOAT {$$ = constant_new_float($1);}
1296 STATICCONSTANT : T_STRING {$$ = constant_new_string2($1.str,$1.len);}
1297 //STATICCONSTANT : T_NAMESPACE {$$ = constant_new_namespace($1);}
1298 STATICCONSTANT : KW_TRUE {$$ = constant_new_true($1);}
1299 STATICCONSTANT : KW_FALSE {$$ = constant_new_false($1);}
1300 STATICCONSTANT : KW_NULL {$$ = constant_new_null($1);}
1301
1302 /* ------------ classes and interfaces (body, functions) ------- */
1303
1304 // non-vararg version
1305 MAYBE_PARAM_LIST: {
1306     memset(&$$,0,sizeof($$));
1307 }
1308 MAYBE_PARAM_LIST: PARAM_LIST {
1309     $$=$1;
1310 }
1311
1312 // vararg version
1313 MAYBE_PARAM_LIST: "..." PARAM {
1314     memset(&$$,0,sizeof($$));
1315     $$.varargs=1;
1316     list_append($$.list, $2);
1317 }
1318 MAYBE_PARAM_LIST: PARAM_LIST ',' "..." PARAM {
1319     $$ =$1;
1320     $$.varargs=1;
1321     list_append($$.list, $4);
1322 }
1323
1324 // non empty
1325 PARAM_LIST: PARAM_LIST ',' PARAM {
1326     $$ = $1;
1327     list_append($$.list, $3);
1328 }
1329 PARAM_LIST: PARAM {
1330     memset(&$$,0,sizeof($$));
1331     list_append($$.list, $1);
1332 }
1333
1334 PARAM:  T_IDENTIFIER ':' TYPE MAYBESTATICCONSTANT {
1335      $$ = malloc(sizeof(param_t));
1336      $$->name=$1;
1337      $$->type = $3;
1338      $$->value = $4;
1339 }
1340 PARAM:  T_IDENTIFIER MAYBESTATICCONSTANT {
1341      $$ = malloc(sizeof(param_t));
1342      $$->name=$1;
1343      $$->type = TYPE_ANY;
1344      $$->value = $2;
1345 }
1346 GETSET : "get" {$$=$1;}
1347        | "set" {$$=$1;}
1348        |       {$$=0;}
1349
1350 FUNCTION_DECLARATION: MAYBE_MODIFIERS "function" GETSET T_IDENTIFIER '(' MAYBE_PARAM_LIST ')'
1351                       MAYBETYPE '{' {startfunction(0,$1,$3,$4,&$6,$8)} MAYBECODE '}'
1352 {
1353     if(!state->m) syntaxerror("internal error: undefined function");
1354     endfunction($11);
1355 }
1356
1357 /* ------------- package + class ids --------------- */
1358
1359 CLASS: T_IDENTIFIER {
1360
1361     /* try current package */
1362     $$ = registry_findclass(state->package, $1);
1363
1364     /* try explicit imports */
1365     dictentry_t* e = dict_get_slot(state->imports, $1);
1366     while(e) {
1367         if($$)
1368             break;
1369         if(!strcmp(e->key, $1)) {
1370             $$ = (classinfo_t*)e->data;
1371         }
1372         e = e->next;
1373     }
1374
1375     /* try package.* imports */
1376     import_list_t*l = state->wildcard_imports;
1377     while(l) {
1378         if($$)
1379             break;
1380         //printf("does package %s contain a class %s?\n", l->import->package, $1);
1381         $$ = registry_findclass(l->import->package, $1);
1382         l = l->next;
1383     }
1384
1385     /* try global package */
1386     if(!$$) {
1387         $$ = registry_findclass("", $1);
1388     }
1389
1390     if(!$$) syntaxerror("Could not find class %s\n", $1);
1391 }
1392
1393 PACKAGEANDCLASS : PACKAGE '.' T_IDENTIFIER {
1394     $$ = registry_findclass($1, $3);
1395     if(!$$) syntaxerror("Couldn't find class %s.%s\n", $1, $3);
1396 }
1397
1398 QNAME: PACKAGEANDCLASS
1399      | CLASS
1400
1401 QNAME_LIST : QNAME {$$=list_new();list_append($$, $1);}
1402 QNAME_LIST : QNAME_LIST ',' QNAME {$$=$1;list_append($$,$3);}
1403
1404 TYPE : QNAME      {$$=$1;}
1405      | '*'        {$$=registry_getanytype();}
1406      |  "String"  {$$=registry_getstringclass();}
1407      |  "int"     {$$=registry_getintclass();}
1408      |  "uint"    {$$=registry_getuintclass();}
1409      |  "Boolean" {$$=registry_getbooleanclass();}
1410      |  "Number"  {$$=registry_getnumberclass();}
1411
1412 MAYBETYPE: ':' TYPE {$$=$2;}
1413 MAYBETYPE:          {$$=0;}
1414
1415 /* ----------function calls, constructor calls ------ */
1416
1417 MAYBE_PARAM_VALUES :  %prec prec_none {$$=0;}
1418 MAYBE_PARAM_VALUES : '(' MAYBE_EXPRESSION_LIST ')' {$$=$2}
1419
1420 MAYBE_EXPRESSION_LIST : {$$=0;}
1421 MAYBE_EXPRESSION_LIST : EXPRESSION_LIST
1422 EXPRESSION_LIST : NONCOMMAEXPRESSION             {$$=list_new();
1423                                                   typedcode_t*t = malloc(sizeof(typedcode_t));
1424                                                   *t = $1;
1425                                                   list_append($$, t);}
1426 EXPRESSION_LIST : EXPRESSION_LIST ',' NONCOMMAEXPRESSION {$$=$1;
1427                                                   typedcode_t*t = malloc(sizeof(typedcode_t));
1428                                                   *t = $3;
1429                                                   list_append($$, t);}
1430
1431 NEW : "new" CLASS MAYBE_PARAM_VALUES {
1432     MULTINAME(m, $2);
1433     $$.c = code_new();
1434
1435     /* TODO: why do we have to *find* our own classes? */
1436     $$.c = abc_findpropstrict2($$.c, &m);
1437
1438     typedcode_list_t*l = $3;
1439     int len = 0;
1440     while(l) {
1441         $$.c = code_append($$.c, l->typedcode->c); // push parameters on stack
1442         l = l->next;
1443         len ++;
1444     }
1445     $$.c = abc_constructprop2($$.c, &m, len);
1446     $$.t = $2;
1447 }
1448
1449 /* TODO: use abc_call (for calling local variables),
1450          abc_callstatic (for calling own methods)
1451          call (for closures)
1452 */
1453 FUNCTIONCALL : E '(' MAYBE_EXPRESSION_LIST ')' {
1454     typedcode_list_t*l = $3;
1455     int len = 0;
1456     code_t*paramcode = 0;
1457     while(l) {
1458         paramcode = code_append(paramcode, l->typedcode->c); // push parameters on stack
1459         l = l->next;
1460         len ++;
1461     }
1462
1463     $$.c = $1.c;
1464     if($$.c->opcode == OPCODE_COERCE_A) {
1465         $$.c = code_cutlast($$.c);
1466     }
1467
1468     $$.t = TYPE_ANY;
1469     multiname_t*name = 0;
1470     if($$.c->opcode == OPCODE_GETPROPERTY) {
1471         name = multiname_clone($$.c->data[0]);
1472         $$.c = code_cutlast($$.c);
1473         $$.c = code_append($$.c, paramcode);
1474         $$.c = abc_callproperty2($$.c, name, len);
1475     } else if($$.c->opcode == OPCODE_GETSLOT) {
1476         int slot = (int)(ptroff_t)$$.c->data[0];
1477         trait_t*t = abc_class_find_slotid(state->cls,slot);//FIXME
1478         if(t->kind!=TRAIT_METHOD) {
1479             //flash allows to assign closures to members.
1480             //syntaxerror("not a function");
1481         }
1482         name = t->name;
1483         $$.c = code_cutlast($$.c);
1484         $$.c = code_append($$.c, paramcode);
1485         //$$.c = abc_callmethod($$.c, t->method, len); //#1051 illegal early access binding
1486         $$.c = abc_callproperty2($$.c, name, len);
1487     } else {
1488         $$.c = abc_getlocal_0($$.c);
1489         $$.c = code_append($$.c, paramcode);
1490         $$.c = abc_call($$.c, len);
1491     }
1492
1493     memberinfo_t*f = 0;
1494
1495     if(TYPE_IS_FUNCTION($1.t) &&
1496        (f = registry_findmember($1.t, "call"))) {
1497         $$.t = f->return_type;
1498     } else {
1499         $$.c = abc_coerce_a($$.c);
1500         $$.t = TYPE_ANY;
1501     }
1502 }
1503
1504 RETURN: "return" %prec prec_none {
1505     $$ = abc_returnvoid(0);
1506 }
1507 RETURN: "return" EXPRESSION {
1508     $$ = $2.c;
1509     $$ = abc_returnvalue($$);
1510 }
1511 // ----------------------- expression types -------------------------------------
1512
1513 NONCOMMAEXPRESSION : E        %prec prec_belowminus {$$=$1;}
1514 EXPRESSION : E                %prec prec_belowminus {$$ = $1;}
1515 EXPRESSION : EXPRESSION ',' E %prec prec_belowminus {
1516     $$.c = $1.c;
1517     $$.c = cut_last_push($$.c);
1518     $$.c = code_append($$.c,$3.c);
1519     $$.t = $3.t;
1520 }
1521 VOIDEXPRESSION : EXPRESSION %prec prec_belowminus {$$=cut_last_push($1.c);}
1522
1523 // ----------------------- expression evaluation -------------------------------------
1524
1525 E : CONSTANT
1526 E : VAR_READ %prec T_IDENTIFIER {$$ = $1;}
1527 E : NEW                         {$$ = $1;}
1528 E : T_REGEXP                    {$$.c = abc_pushundefined(0); /* FIXME */
1529                                  $$.t = TYPE_ANY;
1530                                 }
1531
1532 CONSTANT : T_BYTE {$$.c = abc_pushbyte(0, $1);
1533                    //MULTINAME(m, registry_getintclass());
1534                    //$$.c = abc_coerce2($$.c, &m); // FIXME
1535                    $$.t = TYPE_INT;
1536                   }
1537 CONSTANT : T_SHORT {$$.c = abc_pushshort(0, $1);
1538                     $$.t = TYPE_INT;
1539                    }
1540 CONSTANT : T_INT {$$.c = abc_pushint(0, $1);
1541                   $$.t = TYPE_INT;
1542                  }
1543 CONSTANT : T_UINT {$$.c = abc_pushuint(0, $1);
1544                    $$.t = TYPE_UINT;
1545                   }
1546 CONSTANT : T_FLOAT {$$.c = abc_pushdouble(0, $1);
1547                     $$.t = TYPE_FLOAT;
1548                    }
1549 CONSTANT : T_STRING {$$.c = abc_pushstring2(0, &$1);
1550                      $$.t = TYPE_STRING;
1551                     }
1552 CONSTANT : KW_TRUE {$$.c = abc_pushtrue(0);
1553                     $$.t = TYPE_BOOLEAN;
1554                    }
1555 CONSTANT : KW_FALSE {$$.c = abc_pushfalse(0);
1556                      $$.t = TYPE_BOOLEAN;
1557                     }
1558 CONSTANT : KW_NULL {$$.c = abc_pushnull(0);
1559                     $$.t = TYPE_NULL;
1560                    }
1561
1562 E : FUNCTIONCALL
1563 E : E '<' E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterequals($$.c);$$.c=abc_not($$.c);
1564              $$.t = TYPE_BOOLEAN;
1565             }
1566 E : E '>' E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterthan($$.c);
1567              $$.t = TYPE_BOOLEAN;
1568             }
1569 E : E "<=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterthan($$.c);$$.c=abc_not($$.c);
1570               $$.t = TYPE_BOOLEAN;
1571              }
1572 E : E ">=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_greaterequals($$.c);
1573               $$.t = TYPE_BOOLEAN;
1574              }
1575 E : E "==" E {$$.c = code_append($1.c,$3.c);$$.c = abc_equals($$.c);
1576               $$.t = TYPE_BOOLEAN;
1577              }
1578 E : E "===" E {$$.c = code_append($1.c,$3.c);$$.c = abc_strictequals($$.c);
1579               $$.t = TYPE_BOOLEAN;
1580              }
1581 E : E "!=" E {$$.c = code_append($1.c,$3.c);$$.c = abc_equals($$.c);$$.c = abc_not($$.c);
1582               $$.t = TYPE_BOOLEAN;
1583              }
1584
1585 E : E "||" E {$$.t = join_types($1.t, $3.t, 'O');
1586               $$.c = $1.c;
1587               $$.c = converttype($$.c, $1.t, $$.t);
1588               $$.c = abc_dup($$.c);
1589               code_t*jmp = $$.c = abc_iftrue($$.c, 0);
1590               $$.c = cut_last_push($$.c);
1591               $$.c = code_append($$.c,$3.c);
1592               $$.c = converttype($$.c, $3.t, $$.t);
1593               code_t*label = $$.c = abc_label($$.c);
1594               jmp->branch = label;
1595              }
1596 E : E "&&" E {
1597               $$.t = join_types($1.t, $3.t, 'A');
1598               /*printf("%08x:\n",$1.t);
1599               code_dump($1.c, 0, 0, "", stdout);
1600               printf("%08x:\n",$3.t);
1601               code_dump($3.c, 0, 0, "", stdout);
1602               printf("joining %08x and %08x to %08x\n", $1.t, $3.t, $$.t);*/
1603               $$.c = $1.c;
1604               $$.c = converttype($$.c, $1.t, $$.t);
1605               $$.c = abc_dup($$.c);
1606               code_t*jmp = $$.c = abc_iffalse($$.c, 0);
1607               $$.c = cut_last_push($$.c);
1608               $$.c = code_append($$.c,$3.c);
1609               $$.c = converttype($$.c, $3.t, $$.t);
1610               code_t*label = $$.c = abc_label($$.c);
1611               jmp->branch = label;
1612              }
1613
1614 E : '!' E    {$$.c=$2.c;
1615               $$.c = abc_not($$.c);
1616               $$.t = TYPE_BOOLEAN;
1617              }
1618
1619 E : E '-' E
1620 E : E '/' E
1621 E : E '+' E {$$.c = code_append($1.c,$3.c);$$.c = abc_add($$.c);$$.c=abc_coerce_a($$.c);
1622              $$.t = join_types($1.t, $3.t, '+');
1623             }
1624 E : E '%' E {$$.c = code_append($1.c,$3.c);$$.c = abc_modulo($$.c);$$.c=abc_coerce_a($$.c);
1625              $$.t = join_types($1.t, $3.t, '%');
1626             }
1627 E : E '*' E {$$.c = code_append($1.c,$3.c);$$.c = abc_multiply($$.c);$$.c=abc_coerce_a($$.c);
1628              $$.t = join_types($1.t, $3.t, '*');
1629             }
1630
1631 E : E "as" E
1632 E : E "is" E
1633 E : '(' E ')' {$$=$2;}
1634 E : '-' E {$$=$2;}
1635
1636 E : E '[' E ']' {
1637   $$.c = $1.c;
1638   $$.c = code_append($$.c, $3.c);
1639
1640   MULTINAME_LATE(m, $1.t?$1.t->access:ACCESS_PACKAGE, "");
1641   $$.c = abc_getproperty2($$.c, &m);
1642 }
1643
1644 E : E "*=" E {
1645                code_t*c = $3.c;
1646                if(TYPE_IS_INT($3.t) || TYPE_IS_UINT($3.t)) {
1647                 c=abc_multiply_i(c);
1648                } else {
1649                 c=abc_multiply(c);
1650                }
1651                c=converttype(c, join_types($1.t, $3.t, '*'), $1.t);
1652                $$.c = toreadwrite($1.c, c, 0, 0);
1653                $$.t = $1.t;
1654               }
1655 E : E "%=" E {
1656                code_t*c = abc_modulo($3.c);
1657                c=converttype(c, join_types($1.t, $3.t, '%'), $1.t);
1658                $$.c = toreadwrite($1.c, c, 0, 0);
1659                $$.t = $1.t;
1660               }
1661 E : E "<<=" E {
1662                code_t*c = abc_lshift($3.c);
1663                c=converttype(c, join_types($1.t, $3.t, '<'), $1.t);
1664                $$.c = toreadwrite($1.c, c, 0, 0);
1665                $$.t = $1.t;
1666               }
1667 E : E ">>=" E {
1668                code_t*c = abc_rshift($3.c);
1669                c=converttype(c, join_types($1.t, $3.t, '>'), $1.t);
1670                $$.c = toreadwrite($1.c, c, 0, 0);
1671                $$.t = $1.t;
1672               }
1673 E : E ">>>=" E {
1674                code_t*c = abc_urshift($3.c);
1675                c=converttype(c, join_types($1.t, $3.t, 'U'), $1.t);
1676                $$.c = toreadwrite($1.c, c, 0, 0);
1677                $$.t = $1.t;
1678               }
1679 E : E "/=" E {
1680                code_t*c = abc_divide($3.c);
1681                c=converttype(c, join_types($1.t, $3.t, '/'), $1.t);
1682                $$.c = toreadwrite($1.c, c, 0, 0);
1683                $$.t = $1.t;
1684               }
1685 E : E "+=" E {
1686                code_t*c = $3.c;
1687                if(TYPE_IS_INT($3.t) || TYPE_IS_UINT($3.t)) {
1688                 c=abc_add_i(c);
1689                } else {
1690                 c=abc_add(c);
1691                }
1692                c=converttype(c, join_types($1.t, $3.t, '+'), $1.t);
1693
1694                $$.c = toreadwrite($1.c, c, 0, 0);
1695                $$.t = $1.t;
1696               }
1697 E : E "-=" E { code_t*c = $3.c;
1698                if(TYPE_IS_INT($3.t) || TYPE_IS_UINT($3.t)) {
1699                 c=abc_subtract_i(c);
1700                } else {
1701                 c=abc_subtract(c);
1702                }
1703                c=converttype(c, join_types($1.t, $3.t, '-'), $1.t);
1704
1705                $$.c = toreadwrite($1.c, c, 0, 0);
1706                $$.t = $1.t;
1707              }
1708 E : E '=' E { code_t*c = 0;
1709               c = code_append(c, $3.c);
1710               c = converttype(c, $3.t, $1.t);
1711               $$.c = toreadwrite($1.c, c, 1, 0);
1712               $$.t = $1.t;
1713             }
1714
1715 // TODO: use inclocal where appropriate
1716 E : E "++" { code_t*c = 0;
1717              classinfo_t*type = $1.t;
1718              if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
1719                  c=abc_increment_i(c);
1720                  type = TYPE_INT;
1721              } else {
1722                  c=abc_increment(c);
1723                  type = TYPE_NUMBER;
1724              }
1725              c=converttype(c, type, $1.t);
1726              $$.c = toreadwrite($1.c, c, 0, 1);
1727              $$.t = $1.t;
1728            }
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_decrement_i(c);
1733                  type = TYPE_INT;
1734              } else {
1735                  c=abc_decrement(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
1743 E : "++" E { code_t*c = 0;
1744              classinfo_t*type = $2.t;
1745              if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
1746                  c=abc_increment_i(c);
1747                  type = TYPE_INT;
1748              } else {
1749                  c=abc_increment(c);
1750                  type = TYPE_NUMBER;
1751              }
1752              c=converttype(c, type, $2.t);
1753              $$.c = toreadwrite($2.c, c, 0, 0);
1754              $$.t = $2.t;
1755            }
1756
1757 E : "--" E { code_t*c = 0;
1758              classinfo_t*type = $2.t;
1759              if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
1760                  c=abc_decrement_i(c);
1761                  type = TYPE_INT;
1762              } else {
1763                  c=abc_decrement(c);
1764                  type = TYPE_NUMBER;
1765              }
1766              c=converttype(c, type, $2.t);
1767              $$.c = toreadwrite($2.c, c, 0, 0);
1768              $$.t = $2.t;
1769            }
1770
1771 E : E '.' T_IDENTIFIER
1772             {$$.c = $1.c;
1773              if($$.t) {
1774                  memberinfo_t*f = registry_findmember($$.t, $3);
1775
1776                  if(f && f->slot) {
1777                      $$.c = abc_getslot($$.c, f->slot);
1778                  } else {
1779                      namespace_t ns = {$$.t->access, ""}; // needs to be "", not $$.t->package
1780                      multiname_t m = {QNAME, &ns, 0, $3};
1781                      $$.c = abc_getproperty2($$.c, &m);
1782                  }
1783                  /* determine type */
1784                  if(f) {
1785                     if(f->kind == MEMBER_METHOD) {
1786                         $$.t = TYPE_FUNCTION(f);
1787                     } else {
1788                         $$.t = f->type;
1789                     }
1790                  } else {
1791                     $$.c = abc_coerce_a($$.c);
1792                     $$.t = registry_getanytype();
1793                  }
1794              } else {
1795                  namespace_t ns = {ACCESS_PACKAGE, ""};
1796                  multiname_t m = {QNAME, &ns, 0, $3};
1797                  $$.c = abc_getproperty2($$.c, &m);
1798                  $$.c = abc_coerce_a($$.c);
1799                  $$.t = registry_getanytype();
1800              }
1801             }
1802
1803 VAR_READ : T_IDENTIFIER {
1804     $$.t = 0;
1805     $$.c = 0;
1806     int i;
1807     memberinfo_t*f = 0;
1808     if((i = find_variable($1, &$$.t)) >= 0) {
1809         // $1 is a local variable
1810         $$.c = abc_getlocal($$.c, i);
1811     } else if((f = registry_findmember(state->clsinfo, $1))) {
1812         // $1 is a function in this class
1813         if(f->kind == MEMBER_METHOD) {
1814             $$.t = TYPE_FUNCTION(f);
1815         } else {
1816             $$.t = f->type;
1817         }
1818         if(f->slot>0) {
1819             $$.c = abc_getlocal_0($$.c);
1820             $$.c = abc_getslot($$.c, f->slot);
1821         } else {
1822             namespace_t ns = {state->clsinfo->access, ""};
1823             multiname_t m = {QNAME, &ns, 0, $1};
1824             $$.c = abc_getlocal_0($$.c);
1825             $$.c = abc_getproperty2($$.c, &m);
1826         }
1827     } else {
1828         // let the avm2 resolve $1
1829         if(strcmp($1,"trace"))
1830         warning("Couldn't resolve %s, doing late binding", $1);
1831         state->late_binding = 1;
1832
1833         $$.t = 0;
1834         $$.c = abc_findpropstrict($$.c, $1);
1835         $$.c = abc_getproperty($$.c, $1);
1836     }
1837 }
1838
1839 //TODO:
1840 //VARIABLE : VARIABLE ".." T_IDENTIFIER // descendants
1841 //VARIABLE : VARIABLE "::" VARIABLE // namespace declaration
1842 //VARIABLE : VARIABLE "::" '[' EXPRESSION ']' // qualified expression
1843
1844 // ----------------- namespaces -------------------------------------------------
1845
1846 NAMESPACE_DECLARATION : MAYBE_MODIFIERS "namespace" T_IDENTIFIER {$$=$2;}
1847 NAMESPACE_DECLARATION : MAYBE_MODIFIERS "namespace" T_IDENTIFIER '=' T_IDENTIFIER {$$=$2;}
1848 NAMESPACE_DECLARATION : MAYBE_MODIFIERS "namespace" T_IDENTIFIER '=' T_STRING {$$=$2;}
1849
1850 USE_NAMESPACE : "use" "namespace" T_IDENTIFIER
1851