lib/as3/parser.tab.c

   1
   2 /* A Bison parser, made by GNU Bison 2.4.  */
   3
   4 /* Skeleton implementation for Bison's Yacc-like parsers in C
   5
   6       Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   7    Free Software Foundation, Inc.
   8
   9    This program is free software: you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation, either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 /* As a special exception, you may create a larger work that contains
  23    part or all of the Bison parser skeleton and distribute that work
  24    under terms of your choice, so long as that work isn't itself a
  25    parser generator using the skeleton or a modified version thereof
  26    as a parser skeleton.  Alternatively, if you modify or redistribute
  27    the parser skeleton itself, you may (at your option) remove this
  28    special exception, which will cause the skeleton and the resulting
  29    Bison output files to be licensed under the GNU General Public
  30    License without this special exception.
  31
  32    This special exception was added by the Free Software Foundation in
  33    version 2.2 of Bison.  */
  34
  35 /* C LALR(1) parser skeleton written by Richard Stallman, by
  36    simplifying the original so-called "semantic" parser.  */
  37
  38 /* All symbols defined below should begin with yy or YY, to avoid
  39    infringing on user name space.  This should be done even for local
  40    variables, as they might otherwise be expanded by user macros.
  41    There are some unavoidable exceptions within include files to
  42    define necessary library symbols; they are noted "INFRINGES ON
  43    USER NAME SPACE" below.  */
  44
  45 /* Identify Bison output.  */
  46 #define YYBISON 1
  47
  48 /* Bison version.  */
  49 #define YYBISON_VERSION "2.4"
  50
  51 /* Skeleton name.  */
  52 #define YYSKELETON_NAME "./skeleton.m4"
  53
  54 /* Pure parsers.  */
  55 #define YYPURE 0
  56
  57 /* Push parsers.  */
  58 #define YYPUSH 0
  59
  60 /* Pull parsers.  */
  61 #define YYPULL 1
  62
  63 /* Using locations.  */
  64 #define YYLSP_NEEDED 0
  65
  66 /* Substitute the variable and function names.  */
  67 #define yyparse         a3_parse
  68 #define yylex           a3_lex
  69 #define yyerror         a3_error
  70 #define yylval          a3_lval
  71 #define yychar          a3_char
  72 #define yydebug         a3_debug
  73 #define yynerrs         a3_nerrs
  74
  75
  76 /* Copy the first part of user declarations.  */
  77
  78 /* Line 198 of skeleton.m4  */
  79 #line 23 "parser.y"
  80
  81 #include <stdlib.h>
  82 #include <stdio.h>
  83 #include <memory.h>
  84 #include "abc.h"
  85 #include "pool.h"
  86 #include "files.h"
  87 #include "tokenizer.h"
  88 #include "registry.h"
  89 #include "code.h"
  90 #include "opcodes.h"
  91 #include "compiler.h"
  92
  93 extern int a3_lex();
  94
  95
  96
  97 /* Line 198 of skeleton.m4  */
  98 #line 99 "parser.tab.c"
  99
 100 /* Enabling traces.  */
 101 #ifndef YYDEBUG
 102 # define YYDEBUG 0
 103 #endif
 104
 105 /* Enabling verbose error messages.  */
 106 #ifdef YYERROR_VERBOSE
 107 # undef YYERROR_VERBOSE
 108 # define YYERROR_VERBOSE 1
 109 #else
 110 # define YYERROR_VERBOSE 1
 111 #endif
 112
 113 /* Enabling the token table.  */
 114 #ifndef YYTOKEN_TABLE
 115 # define YYTOKEN_TABLE 0
 116 #endif
 117
 118
 119 /* Tokens.  */
 120 #ifndef YYTOKENTYPE
 121 # define YYTOKENTYPE
 122    /* Put the tokens into the symbol table, so that GDB and other debuggers
 123       know about them.  */
 124    enum yytokentype {
 125      T_IDENTIFIER = 258,
 126      T_NAMESPACE = 259,
 127      T_STRING = 260,
 128      T_REGEXP = 261,
 129      T_EMPTY = 262,
 130      T_INT = 263,
 131      T_UINT = 264,
 132      T_BYTE = 265,
 133      T_SHORT = 266,
 134      T_FLOAT = 267,
 135      T_FOR = 268,
 136      T_WHILE = 269,
 137      T_DO = 270,
 138      T_SWITCH = 271,
 139      KW_IMPLEMENTS = 272,
 140      KW_NAMESPACE = 273,
 141      KW_PACKAGE = 274,
 142      KW_PROTECTED = 275,
 143      KW_PUBLIC = 276,
 144      KW_PRIVATE = 277,
 145      KW_USE = 278,
 146      KW_INTERNAL = 279,
 147      KW_NEW = 280,
 148      KW_NATIVE = 281,
 149      KW_FUNCTION = 282,
 150      KW_FINALLY = 283,
 151      KW_UNDEFINED = 284,
 152      KW_CONTINUE = 285,
 153      KW_CLASS = 286,
 154      KW_CONST = 287,
 155      KW_CATCH = 288,
 156      KW_CASE = 289,
 157      KW_SET = 290,
 158      KW_VOID = 291,
 159      KW_THROW = 292,
 160      KW_STATIC = 293,
 161      KW_WITH = 294,
 162      KW_INSTANCEOF = 295,
 163      KW_IMPORT = 296,
 164      KW_RETURN = 297,
 165      KW_TYPEOF = 298,
 166      KW_INTERFACE = 299,
 167      KW_NULL = 300,
 168      KW_VAR = 301,
 169      KW_DYNAMIC = 302,
 170      KW_OVERRIDE = 303,
 171      KW_FINAL = 304,
 172      KW_EACH = 305,
 173      KW_GET = 306,
 174      KW_TRY = 307,
 175      KW_SUPER = 308,
 176      KW_EXTENDS = 309,
 177      KW_FALSE = 310,
 178      KW_TRUE = 311,
 179      KW_BOOLEAN = 312,
 180      KW_UINT = 313,
 181      KW_INT = 314,
 182      KW_NUMBER = 315,
 183      KW_STRING = 316,
 184      KW_DEFAULT = 317,
 185      KW_DELETE = 318,
 186      KW_IF = 319,
 187      KW_ELSE = 320,
 188      KW_BREAK = 321,
 189      KW_IS = 322,
 190      KW_IN = 323,
 191      KW_AS = 324,
 192      T_DICTSTART = 325,
 193      T_EQEQ = 326,
 194      T_EQEQEQ = 327,
 195      T_NE = 328,
 196      T_NEE = 329,
 197      T_LE = 330,
 198      T_GE = 331,
 199      T_ORBY = 332,
 200      T_DIVBY = 333,
 201      T_MODBY = 334,
 202      T_MULBY = 335,
 203      T_PLUSBY = 336,
 204      T_MINUSBY = 337,
 205      T_XORBY = 338,
 206      T_SHRBY = 339,
 207      T_SHLBY = 340,
 208      T_USHRBY = 341,
 209      T_OROR = 342,
 210      T_ANDAND = 343,
 211      T_COLONCOLON = 344,
 212      T_MINUSMINUS = 345,
 213      T_PLUSPLUS = 346,
 214      T_DOTDOT = 347,
 215      T_DOTDOTDOT = 348,
 216      T_SHL = 349,
 217      T_USHR = 350,
 218      T_SHR = 351,
 219      prec_none = 352,
 220      below_semicolon = 353,
 221      below_assignment = 354,
 222      below_minus = 356,
 223      minusminus_prefix = 357,
 224      plusplus_prefix = 358,
 225      below_curly = 359,
 226      new2 = 360,
 227      above_identifier = 361,
 228      below_else = 362,
 229      above_function = 363
 230    };
 231 #endif
 232
 233
 234
 235 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 236 typedef union
 237 /* Line 223 of skeleton.m4  */
 238 #line 44 "parser.y"
 239 tokenunion
 240 {
 241
 242 /* Line 223 of skeleton.m4  */
 243 #line 44 "parser.y"
 244
 245     enum yytokentype token;
 246
 247     classinfo_t*classinfo;
 248     classinfo_list_t*classinfo_list;
 249     slotinfo_t*slotinfo;
 250     slotinfo_list_t*slotinfo_list;
 251
 252     int number_int;
 253     unsigned int number_uint;
 254     double number_float;
 255     code_t*code;
 256     typedcode_t value;
 257     //typedcode_list_t*value_list;
 258     codeandnumber_t value_list;
 259     param_t* param;
 260     params_t params;
 261     string_t str;
 262     char*id;
 263     constant_t*constant;
 264     for_start_t for_start;
 265     abc_exception_t *exception;
 266     regexp_t regexp;
 267     modifiers_t flags;
 268     namespace_decl_t* namespace_decl;
 269     struct {
 270         abc_exception_list_t *l;
 271         code_t*finally;
 272     } catch_list;
 273
 274
 275
 276 /* Line 223 of skeleton.m4  */
 277 #line 278 "parser.tab.c"
 278 } YYSTYPE;
 279 # define YYSTYPE_IS_TRIVIAL 1
 280 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 281 # define YYSTYPE_IS_DECLARED 1
 282 #endif
 283
 284
 285 /* Copy the second part of user declarations.  */
 286
 287 /* Line 273 of skeleton.m4  */
 288 #line 265 "parser.y"
 289
 290
 291 static int a3_error(char*s)
 292 {
 293    syntaxerror("%s", s);
 294    return 0; //make gcc happy
 295 }
 296
 297
 298 static char* concat2(const char* t1, const char* t2)
 299 {
 300     int l1 = strlen(t1);
 301     int l2 = strlen(t2);
 302     char*text = malloc(l1+l2+1);
 303     memcpy(text   , t1, l1);
 304     memcpy(text+l1, t2, l2);
 305     text[l1+l2] = 0;
 306     return text;
 307 }
 308 static char* concat3(const char* t1, const char* t2, const char* t3)
 309 {
 310     int l1 = strlen(t1);
 311     int l2 = strlen(t2);
 312     int l3 = strlen(t3);
 313     char*text = malloc(l1+l2+l3+1);
 314     memcpy(text   , t1, l1);
 315     memcpy(text+l1, t2, l2);
 316     memcpy(text+l1+l2, t3, l3);
 317     text[l1+l2+l3] = 0;
 318     return text;
 319 }
 320
 321 typedef struct _import {
 322     char*package;
 323 } import_t;
 324
 325 DECLARE_LIST(import);
 326
 327 DECLARE(methodstate);
 328 DECLARE_LIST(methodstate);
 329
 330 typedef struct _classstate {
 331     /* class data */
 332     classinfo_t*info;
 333     abc_class_t*abc;
 334
 335     methodstate_t*init;
 336     methodstate_t*static_init;
 337     //code_t*init;
 338     //code_t*static_init;
 339
 340     char has_constructor;
 341 } classstate_t;
 342
 343 struct _methodstate {
 344     /* method data */
 345     methodinfo_t*info;
 346     char has_exceptions;
 347     char late_binding;
 348     char is_constructor;
 349     char has_super;
 350     char is_global;
 351     int variable_count;
 352
 353     dict_t*unresolved_variables;
 354
 355     char inner;
 356     char uses_parent_function;
 357     int uses_slots;
 358     dict_t*slots;
 359
 360     abc_method_t*abc;
 361     int var_index; // for inner methods
 362     int slot_index; // for inner methods
 363     char is_a_slot; // for inner methods
 364
 365     code_t*header;
 366
 367     code_t*scope_code;
 368     abc_exception_list_t*exceptions;
 369
 370     methodstate_list_t*innerfunctions;
 371 };
 372
 373 typedef struct _state {
 374     struct _state*old;
 375     int level;
 376
 377     char*package;
 378     import_list_t*wildcard_imports;
 379     dict_t*import_toplevel_packages;
 380     dict_t*imports;
 381
 382     char has_own_imports;
 383     char new_vars; // e.g. transition between two functions
 384
 385     classstate_t*cls;
 386     methodstate_t*method;
 387
 388     char*exception_name;
 389
 390     int switch_var;
 391
 392     dict_t*vars;
 393 } state_t;
 394
 395 typedef struct _global {
 396     abc_file_t*file;
 397     abc_script_t*init;
 398     dict_t*token2info;
 399     dict_t*file2token2info;
 400 } global_t;
 401
 402 static global_t*global = 0;
 403 static state_t* state = 0;
 404
 405 DECLARE_LIST(state);
 406
 407 #define MULTINAME(m,x) \
 408     multiname_t m;\
 409     namespace_t m##_ns;\
 410     (x)->package; \
 411     registry_fill_multiname(&m, &m##_ns, (slotinfo_t*)(x));
 412
 413 #define MEMBER_MULTINAME(m,f,n) \
 414     multiname_t m;\
 415     namespace_t m##_ns;\
 416     if(f) { \
 417         if((m##_ns.access = ((slotinfo_t*)(f))->access)==ACCESS_NAMESPACE) \
 418             m##_ns.name = ((slotinfo_t*)(f))->package; \
 419         else \
 420             m##_ns.name = ""; \
 421         m.type = QNAME; \
 422         m.ns = &m##_ns; \
 423         m.namespace_set = 0; \
 424         m.name = ((slotinfo_t*)(f))->name; \
 425     } else { \
 426         m.type = MULTINAME; \
 427         m.ns =0; \
 428         m.namespace_set = &nopackage_namespace_set; \
 429         m.name = n; \
 430     }
 431
 432 /* warning: list length of namespace set is undefined */
 433 #define MULTINAME_LATE(m, access, package) \
 434     namespace_t m##_ns = {access, package}; \
 435     namespace_set_t m##_nsset; \
 436     namespace_list_t m##_l;m##_l.next = 0; \
 437     m##_nsset.namespaces = &m##_l; \
 438     m##_nsset = m##_nsset; \
 439     m##_l.namespace = &m##_ns; \
 440     multiname_t m = {MULTINAMEL, 0, &m##_nsset, 0};
 441
 442 static namespace_t ns1 = {ACCESS_PRIVATE, ""};
 443 static namespace_t ns2 = {ACCESS_PROTECTED, ""};
 444 static namespace_t ns3 = {ACCESS_PACKAGEINTERNAL, ""};
 445 static namespace_t ns4 = {ACCESS_PACKAGE, ""};
 446 static namespace_list_t nl4 = {&ns4,0};
 447 static namespace_list_t nl3 = {&ns3,&nl4};
 448 static namespace_list_t nl2 = {&ns2,&nl3};
 449 static namespace_list_t nl1 = {&ns1,&nl2};
 450 static namespace_set_t nopackage_namespace_set = {&nl1};
 451
 452 static void new_state()
 453 {
 454     NEW(state_t, s);
 455     state_t*oldstate = state;
 456     if(state)
 457         memcpy(s, state, sizeof(state_t)); //shallow copy
 458     if(!s->imports) {
 459         s->imports = dict_new();
 460     }
 461     if(!s->import_toplevel_packages) {
 462         s->import_toplevel_packages = dict_new();
 463     }
 464     state = s;
 465     state->level++;
 466     state->has_own_imports = 0;
 467     state->vars = dict_new();
 468     state->old = oldstate;
 469     state->new_vars = 0;
 470
 471     trie_remember(active_namespaces);
 472 }
 473 static void state_has_imports()
 474 {
 475     state->wildcard_imports = list_clone(state->wildcard_imports);
 476     state->imports = dict_clone(state->imports);
 477     state->has_own_imports = 1;
 478 }
 479 static void import_toplevel(const char*package)
 480 {
 481     char* s = strdup(package);
 482     while(1) {
 483         dict_put(state->import_toplevel_packages, s, 0);
 484         char*x = strrchr(s, '.');
 485         if(!x)
 486             break;
 487         *x = 0;
 488     }
 489     free(s);
 490 }
 491
 492 static void state_destroy(state_t*state)
 493 {
 494     if(state->has_own_imports) {
 495         list_free(state->wildcard_imports);
 496         dict_destroy(state->imports);state->imports=0;
 497     }
 498     if(state->imports && (!state->old || state->old->imports!=state->imports)) {
 499         dict_destroy(state->imports);state->imports=0;
 500     }
 501     if(state->vars) {
 502         int t;
 503         for(t=0;t<state->vars->hashsize;t++) {
 504             dictentry_t*e =state->vars->slots[t];
 505             while(e) {
 506                 free(e->data);e->data=0;
 507                 e = e->next;
 508             }
 509         }
 510         dict_destroy(state->vars);state->vars=0;
 511     }
 512
 513     free(state);
 514 }
 515
 516 static void old_state()
 517 {
 518     trie_rollback(active_namespaces);
 519
 520     if(!state || !state->old)
 521         syntaxerror("invalid nesting");
 522     state_t*leaving = state;
 523
 524     state = state->old;
 525
 526     if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) {
 527         free(leaving->method);
 528         leaving->method=0;
 529     }
 530     if(as3_pass>1 && leaving->cls && leaving->cls != state->cls) {
 531         free(leaving->cls);
 532         leaving->cls=0;
 533     }
 534
 535     state_destroy(leaving);
 536 }
 537
 538 static code_t* method_header(methodstate_t*m);
 539 static code_t* wrap_function(code_t*c,code_t*header, code_t*body);
 540 static void function_initvars(methodstate_t*m, params_t*params, int flags, char var0);
 541
 542
 543 static char* internal_filename_package = 0;
 544 void initialize_file(char*filename)
 545 {
 546     if(state) {
 547         syntaxerror("invalid call to initialize_file during parsing of another file");
 548     }
 549
 550     active_namespaces = trie_new();
 551
 552     new_state();
 553     state->package = internal_filename_package = strdup(filename);
 554
 555     global->token2info = dict_lookup(global->file2token2info,
 556                                      current_filename // use long version
 557                                     );
 558     if(!global->token2info) {
 559         global->token2info = dict_new2(&ptr_type);
 560         dict_put(global->file2token2info, current_filename, global->token2info);
 561     }
 562
 563     if(as3_pass==1) {
 564         state->method = rfx_calloc(sizeof(methodstate_t));
 565         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
 566         state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope
 567     } else {
 568         state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
 569         function_initvars(state->method, 0, 0, 1);
 570         global->init = abc_initscript(global->file);
 571     }
 572 }
 573
 574 void finish_file()
 575 {
 576     if(!state || state->level!=1) {
 577         syntaxerror("unexpected end of file in pass %d", as3_pass);
 578     }
 579
 580     if(as3_pass==2) {
 581         code_t*header = method_header(state->method);
 582         code_t*c = wrap_function(header, 0, global->init->method->body->code);
 583         global->init->method->body->code = c;
 584         free(state->method);state->method=0;
 585     }
 586
 587     //free(state->package);state->package=0; // used in registry
 588     state_destroy(state);state=0;
 589 }
 590
 591 void initialize_parser()
 592 {
 593     global = rfx_calloc(sizeof(global_t));
 594     global->file = abc_file_new();
 595     global->file->flags &= ~ABCFILE_LAZY;
 596     global->file2token2info = dict_new();
 597     global->token2info = 0;
 598 }
 599
 600 void* finish_parser()
 601 {
 602     dict_free_all(global->file2token2info, 1, (void*)dict_destroy);
 603
 604     global->token2info=0;
 605
 606     return global->file;
 607 }
 608
 609
 610 static void xx_scopetest()
 611 {
 612     /* findpropstrict doesn't just return a scope object- it
 613        also makes it "active" somehow. Push local_0 on the
 614        scope stack and read it back with findpropstrict, it'll
 615        contain properties like "trace". Trying to find the same
 616        property on a "vanilla" local_0 yields only a "undefined" */
 617     //c = abc_findpropstrict(c, "[package]::trace");
 618
 619     /*c = abc_getlocal_0(c);
 620     c = abc_findpropstrict(c, "[package]::trace");
 621     c = abc_coerce_a(c);
 622     c = abc_setlocal_1(c);
 623
 624     c = abc_pushbyte(c, 0);
 625     c = abc_setlocal_2(c);
 626
 627     code_t*xx = c = abc_label(c);
 628     c = abc_findpropstrict(c, "[package]::trace");
 629     c = abc_pushstring(c, "prop:");
 630     c = abc_hasnext2(c, 1, 2);
 631     c = abc_dup(c);
 632     c = abc_setlocal_3(c);
 633     c = abc_callpropvoid(c, "[package]::trace", 2);
 634     c = abc_getlocal_3(c);
 635     c = abc_kill(c, 3);
 636     c = abc_iftrue(c,xx);*/
 637 }
 638
 639 typedef struct _variable {
 640     int index;
 641     classinfo_t*type;
 642     char init;
 643     methodstate_t*is_inner_method;
 644 } variable_t;
 645
 646 static variable_t* find_variable(state_t*s, char*name)
 647 {
 648     while(s) {
 649         variable_t*v = 0;
 650         v = dict_lookup(s->vars, name);
 651         if(v) return v;
 652         if(s->new_vars) break;
 653         s = s->old;
 654     }
 655     return 0;
 656 }
 657 static variable_t* find_slot(state_t*s, const char*name)
 658 {
 659     if(s->method && s->method->slots)
 660         return dict_lookup(s->method->slots, name);
 661     return 0;
 662 }
 663
 664 static variable_t* find_variable_safe(state_t*s, char*name)
 665 {
 666     variable_t* v = find_variable(s, name);
 667     if(!v)
 668         syntaxerror("undefined variable: %s", name);
 669     return v;
 670 }
 671 static char variable_exists(char*name)
 672 {
 673     return dict_contains(state->vars, name);
 674 }
 675 code_t*defaultvalue(code_t*c, classinfo_t*type);
 676
 677 static int alloc_local()
 678 {
 679     return state->method->variable_count++;
 680 }
 681
 682 static variable_t* new_variable2(const char*name, classinfo_t*type, char init, char maybeslot)
 683 {
 684     if(maybeslot) {
 685         variable_t*v = find_slot(state, name);
 686         if(v)
 687             return v;
 688     }
 689
 690     NEW(variable_t, v);
 691     v->index = alloc_local();
 692     v->type = type;
 693     v->init = init;
 694
 695     if(name)
 696         dict_put(state->vars, name, v);
 697
 698     return v;
 699 }
 700 static int new_variable(const char*name, classinfo_t*type, char init, char maybeslot)
 701 {
 702     return new_variable2(name, type, init, maybeslot)->index;
 703 }
 704
 705 #define TEMPVARNAME "__as3_temp__"
 706 static int gettempvar()
 707 {
 708     variable_t*v = find_variable(state, TEMPVARNAME);
 709     if(v)
 710         return v->index;
 711     return new_variable(TEMPVARNAME, 0, 0, 0);
 712 }
 713
 714 code_t* var_block(code_t*body)
 715 {
 716     code_t*c = 0;
 717     code_t*k = 0;
 718     int t;
 719     int num=0;
 720     for(t=0;t<state->vars->hashsize;t++) {
 721         dictentry_t*e = state->vars->slots[t];
 722         while(e) {
 723             variable_t*v = (variable_t*)e->data;
 724             if(v->type && v->init) {
 725                 c = defaultvalue(c, v->type);
 726                 c = abc_setlocal(c, v->index);
 727                 k = abc_kill(k, v->index);
 728                 num++;
 729             }
 730             e = e->next;
 731         }
 732     }
 733
 734     if(k) {
 735         code_t*x = body;
 736         while(x) {
 737             if(x->opcode== OPCODE___BREAK__ ||
 738                x->opcode== OPCODE___CONTINUE__) {
 739                /* link kill code before break/continue */
 740                 code_t*e = code_dup(k);
 741                 code_t*s = code_start(e);
 742                 s->prev = x->prev;
 743                 if(x->prev) {
 744                     x->prev->next = s;
 745                 }
 746                 e->next = x;
 747                 x->prev = e;
 748             }
 749             x = x->prev;
 750         }
 751     }
 752
 753     c = code_append(c, body);
 754     c = code_append(c, k);
 755     return c;
 756 }
 757
 758 void unknown_variable(char*name)
 759 {
 760     if(!state->method->unresolved_variables)
 761         state->method->unresolved_variables = dict_new();
 762     if(!dict_contains(state->method->unresolved_variables, name))
 763         dict_put(state->method->unresolved_variables, name, 0);
 764 }
 765
 766 #define parserassert(b) {if(!(b)) parsererror(__FILE__, __LINE__,__func__);}
 767
 768 static void parsererror(const char*file, int line, const char*f)
 769 {
 770     syntaxerror("internal error in %s, %s:%d", f, file, line);
 771 }
 772
 773
 774 static code_t* add_scope_code(code_t*c, methodstate_t*m)
 775 {
 776     if(m->uses_slots || (m->late_binding && !m->inner)) {
 777         c = abc_getlocal_0(c);
 778         c = abc_pushscope(c);
 779     }
 780     if(m->uses_slots) {
 781         /* FIXME: does this need to be the same activation object as
 782                   in the function header? */
 783         c = abc_newactivation(c);
 784         c = abc_pushscope(c);
 785     }
 786     return c;
 787 }
 788
 789 static code_t* method_header(methodstate_t*m)
 790 {
 791     code_t*c = 0;
 792
 793     c = add_scope_code(c, m);
 794
 795     methodstate_list_t*l = m->innerfunctions;
 796     while(l) {
 797         parserassert(l->methodstate->abc);
 798         if(m->uses_slots && l->methodstate->is_a_slot) {
 799             c = abc_getscopeobject(c, 1);
 800             c = abc_newfunction(c, l->methodstate->abc);
 801             c = abc_dup(c);
 802             c = abc_setlocal(c, l->methodstate->var_index);
 803             c = abc_setslot(c, l->methodstate->slot_index);
 804         } else {
 805             c = abc_newfunction(c, l->methodstate->abc);
 806             c = abc_setlocal(c, l->methodstate->var_index);
 807         }
 808         free(l->methodstate);l->methodstate=0;
 809         l = l->next;
 810     }
 811     if(m->header) {
 812         c = code_append(c, m->header);
 813         m->header = 0;
 814     }
 815     if(m->is_constructor && !m->has_super) {
 816         // call default constructor
 817         c = abc_getlocal_0(c);
 818         c = abc_constructsuper(c, 0);
 819     }
 820     list_free(m->innerfunctions);
 821     m->innerfunctions = 0;
 822     return c;
 823 }
 824
 825
 826 static code_t* wrap_function(code_t*c,code_t*header, code_t*body)
 827 {
 828     c = code_append(c, header);
 829     c = code_append(c, var_block(body));
 830     /* append return if necessary */
 831     if(!c || (c->opcode != OPCODE_RETURNVOID &&
 832               c->opcode != OPCODE_RETURNVALUE)) {
 833         c = abc_returnvoid(c);
 834     }
 835     return c;
 836 }
 837
 838
 839 static void startpackage(char*name)
 840 {
 841     new_state();
 842     /*printf("entering package \"%s\"\n", name);*/
 843     state->package = strdup(name);
 844 }
 845 static void endpackage()
 846 {
 847     /*printf("leaving package \"%s\"\n", state->package);*/
 848
 849     //used e.g. in classinfo_register:
 850     //free(state->package);state->package=0;
 851
 852     old_state();
 853 }
 854
 855 #define FLAG_PUBLIC 256
 856 #define FLAG_PROTECTED 512
 857 #define FLAG_PRIVATE 1024
 858 #define FLAG_PACKAGEINTERNAL 2048
 859 #define FLAG_NAMESPACE 4096
 860
 861 static namespace_t modifiers2access(modifiers_t*mod)
 862 {
 863     namespace_t ns;
 864     ns.access = 0;
 865     ns.name = "";
 866     if(mod->flags&FLAG_NAMESPACE)  {
 867         if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
 868             syntaxerror("invalid combination of access levels and namespaces");
 869         ns.access = ACCESS_NAMESPACE;
 870         state_t*s = state;
 871         const char*url = (const char*)trie_lookup(active_namespaces, mod->ns);
 872         if(!url) {
 873             /* shouldn't happen- the tokenizer only reports something as a namespace
 874                if it was already registered */
 875             syntaxerror("unknown namespace: %s", mod->ns);
 876         }
 877         ns.name = url;
 878     } else if(mod->flags&FLAG_PUBLIC)  {
 879         if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
 880             syntaxerror("invalid combination of access levels");
 881         ns.access = ACCESS_PACKAGE;
 882     } else if(mod->flags&FLAG_PRIVATE) {
 883         if(mod->flags&(FLAG_PUBLIC|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
 884             syntaxerror("invalid combination of access levels");
 885         ns.access = ACCESS_PRIVATE;
 886     } else if(mod->flags&FLAG_PROTECTED) {
 887         if(mod->flags&(FLAG_PUBLIC|FLAG_PRIVATE|FLAG_PACKAGEINTERNAL))
 888             syntaxerror("invalid combination of access levels");
 889         ns.access = ACCESS_PROTECTED;
 890     } else {
 891         ns.access = ACCESS_PACKAGEINTERNAL;
 892     }
 893     return ns;
 894 }
 895 static slotinfo_t* find_class(const char*name);
 896
 897 memberinfo_t* findmember_nsset(classinfo_t*cls, const char*name, char recurse)
 898 {
 899     /* FIXME- we need to loop through namespaces here */
 900     return registry_findmember(cls, "", name, recurse);
 901 }
 902
 903 static void function_initvars(methodstate_t*m, params_t*params, int flags, char var0)
 904 {
 905     if(var0) {
 906         int index = -1;
 907         if(m->inner)
 908             index = new_variable("this", 0, 0, 0);
 909         else if(!m->is_global)
 910             index = new_variable((flags&FLAG_STATIC)?"class":"this", state->cls?state->cls->info:0, 0, 0);
 911         else
 912             index = new_variable("globalscope", 0, 0, 0);
 913         if(index)
 914             *(int*)0=0;
 915         parserassert(!index);
 916     }
 917
 918     if(m->uses_slots) {
 919         /* as variables and slots share the same number, make sure
 920            that those variable indices are reserved. It's up to the
 921            optimizer to later shuffle the variables down to lower
 922            indices */
 923         m->variable_count = m->uses_slots;
 924     }
 925
 926     if(params) {
 927         param_list_t*p=0;
 928         for(p=params->list;p;p=p->next) {
 929             new_variable(p->param->name, p->param->type, 0, 1);
 930         }
 931     }
 932
 933     if(as3_pass==2) {
 934         m->scope_code = add_scope_code(m->scope_code, m);
 935     }
 936
 937
 938     methodstate_list_t*l = m->innerfunctions;
 939     while(l) {
 940         methodstate_t*m = l->methodstate;
 941
 942         variable_t* v = new_variable2(m->info->name, TYPE_FUNCTION(m->info), 0, 1);
 943         m->var_index = v->index;
 944         m->slot_index = v->index;
 945         v->is_inner_method = m;
 946
 947         l = l->next;
 948     }
 949
 950     if(as3_pass==2 && m->slots) {
 951         /* exchange unresolved identifiers with the actual objects */
 952         DICT_ITERATE_ITEMS(m->slots, char*, name, variable_t*, v) {
 953             if(v->type && v->type->kind == INFOTYPE_UNRESOLVED) {
 954                 v->type = (classinfo_t*)registry_resolve((slotinfo_t*)v->type);
 955                 if(!v->type || v->type->kind != INFOTYPE_CLASS) {
 956                     syntaxerror("Couldn't find class %s", v->type->name);
 957                 }
 958             }
 959         }
 960     }
 961 }
 962
 963
 964 char*as3_globalclass=0;
 965 static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, classinfo_list_t*implements)
 966 {
 967     if(state->cls) {
 968         syntaxerror("inner classes now allowed");
 969     }
 970
 971     new_state();
 972     token_list_t*t=0;
 973     classinfo_list_t*mlist=0;
 974
 975     if(mod->flags&~(FLAG_PACKAGEINTERNAL|FLAG_PUBLIC|FLAG_FINAL|FLAG_DYNAMIC|FLAG_INTERFACE))
 976         syntaxerror("invalid modifier(s)");
 977
 978     if((mod->flags&(FLAG_PUBLIC|FLAG_PACKAGEINTERNAL)) == (FLAG_PUBLIC|FLAG_PACKAGEINTERNAL))
 979         syntaxerror("public and internal not supported at the same time.");
 980
 981     //if(!(mod->flags&FLAG_INTERFACE) && !extends) {
 982     if(!(mod->flags&FLAG_INTERFACE) && !extends) {
 983         // all classes extend object
 984         extends = registry_getobjectclass();
 985     }
 986
 987     /* create the class name, together with the proper attributes */
 988     int access=0;
 989     char*package=0;
 990
 991     if(!(mod->flags&FLAG_PUBLIC) && state->package==internal_filename_package) {
 992         access = ACCESS_PRIVATE; package = internal_filename_package;
 993     } else if(!(mod->flags&FLAG_PUBLIC) && state->package!=internal_filename_package) {
 994         access = ACCESS_PACKAGEINTERNAL; package = state->package;
 995     } else if(state->package!=internal_filename_package) {
 996         access = ACCESS_PACKAGE; package = state->package;
 997     } else {
 998         syntaxerror("public classes only allowed inside a package");
 999     }
1000
1001     if(as3_pass==1) {
1002         state->cls = rfx_calloc(sizeof(classstate_t));
1003         state->cls->init = rfx_calloc(sizeof(methodstate_t));
1004         state->cls->static_init = rfx_calloc(sizeof(methodstate_t));
1005         /* notice: we make no effort to initialize the top variable (local0) here,
1006            even though it has special meaning. We just rely on the facat
1007            that pass 1 won't do anything with variables */
1008
1009         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->cls);
1010
1011         /* set current method to constructor- all code within the class-level (except
1012            static variable initializations) will be executed during construction time */
1013         state->method = state->cls->init;
1014
1015         if(registry_find(package, classname)) {
1016             syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, classname);
1017         }
1018         /* build info struct */
1019         int num_interfaces = (list_length(implements));
1020         state->cls->info = classinfo_register(access, package, classname, num_interfaces);
1021         state->cls->info->flags |= mod->flags & (FLAG_DYNAMIC|FLAG_INTERFACE|FLAG_FINAL);
1022
1023         int pos = 0;
1024         classinfo_list_t*l = implements;
1025         for(l=implements;l;l=l->next) {
1026             state->cls->info->interfaces[pos++] = l->classinfo;
1027         }
1028     }
1029
1030     if(as3_pass == 2) {
1031         state->cls = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1032
1033         state->method = state->cls->init;
1034         parserassert(state->cls && state->cls->info);
1035
1036         function_initvars(state->cls->init, 0, 0, 1);
1037         function_initvars(state->cls->static_init, 0, 0, 0);
1038
1039         if(extends && (extends->flags & FLAG_FINAL))
1040             syntaxerror("Can't extend final class '%s'", extends->name);
1041
1042         int pos = 0;
1043         while(state->cls->info->interfaces[pos]) {
1044             if(!(state->cls->info->interfaces[pos]->flags & FLAG_INTERFACE))
1045                 syntaxerror("'%s' is not an interface",
1046                     state->cls->info->interfaces[pos]->name);
1047             pos++;
1048         }
1049
1050         /* fill out interfaces and extends (we couldn't resolve those during the first pass) */
1051         state->cls->info->superclass = extends;
1052
1053         /* generate the abc code for this class */
1054         MULTINAME(classname2,state->cls->info);
1055         multiname_t*extends2 = sig2mname(extends);
1056
1057         state->cls->abc = abc_class_new(global->file, &classname2, extends2);
1058         if(state->cls->info->flags&FLAG_FINAL) abc_class_final(state->cls->abc);
1059         if(!(state->cls->info->flags&FLAG_DYNAMIC)) abc_class_sealed(state->cls->abc);
1060         if(state->cls->info->flags&FLAG_INTERFACE) {
1061             abc_class_interface(state->cls->abc);
1062         }
1063
1064         abc_class_protectedNS(state->cls->abc, classname);
1065
1066         for(mlist=implements;mlist;mlist=mlist->next) {
1067             MULTINAME(m, mlist->classinfo);
1068             abc_class_add_interface(state->cls->abc, &m);
1069         }
1070
1071         /* write the construction code for this class to the global init
1072            function */
1073         int slotindex = abc_initscript_addClassTrait(global->init, &classname2, state->cls->abc);
1074
1075         abc_method_body_t*m = global->init->method->body;
1076         __ getglobalscope(m);
1077         classinfo_t*s = extends;
1078
1079         int count=0;
1080
1081         while(s) {
1082             //TODO: take a look at the current scope stack, maybe
1083             //      we can re-use something
1084             s = s->superclass;
1085             if(!s)
1086             break;
1087
1088             multiname_t*s2 = sig2mname(s);
1089             __ getlex2(m, s2);
1090             multiname_destroy(s2);
1091
1092             __ pushscope(m); count++;
1093             m->code = m->code->prev->prev; // invert
1094         }
1095         /* continue appending after last op end */
1096         while(m->code && m->code->next) m->code = m->code->next;
1097
1098         /* TODO: if this is one of *our* classes, we can also
1099                  do a getglobalscope/getslot <nr> (which references
1100                  the init function's slots) */
1101         if(extends2) {
1102             __ getlex2(m, extends2);
1103             __ dup(m);
1104             /* notice: we get a Verify Error #1107 if the top elemnt on the scope
1105                stack is not the superclass */
1106             __ pushscope(m);count++;
1107         } else {
1108             __ pushnull(m);
1109             /* notice: we get a verify error #1107 if the top element on the scope
1110                stack is not the global object */
1111             __ getlocal_0(m);
1112             __ pushscope(m);count++;
1113         }
1114         __ newclass(m,state->cls->abc);
1115         while(count--) {
1116             __ popscope(m);
1117         }
1118         __ setslot(m, slotindex);
1119         multiname_destroy(extends2);
1120
1121         /* flash.display.MovieClip handling */
1122
1123         if(!as3_globalclass && (mod->flags&FLAG_PUBLIC) && slotinfo_equals((slotinfo_t*)registry_getMovieClip(),(slotinfo_t*)extends)) {
1124             if(state->package && state->package[0]) {
1125                 as3_globalclass = concat3(state->package, ".", classname);
1126             } else {
1127                 as3_globalclass = strdup(classname);
1128             }
1129         }
1130     }
1131 }
1132
1133 static int slotstate_varconst = 0;
1134 static modifiers_t*slotstate_flags = 0;
1135 static void setslotstate(modifiers_t* flags, int varconst)
1136 {
1137     slotstate_varconst = varconst;
1138     slotstate_flags = flags;
1139     if(state->cls) {
1140         if(flags && flags->flags&FLAG_STATIC) {
1141             state->method = state->cls->static_init;
1142         } else {
1143             state->method = state->cls->init;
1144         }
1145     } else {
1146         parserassert(state->method);
1147     }
1148 }
1149
1150 static void endclass()
1151 {
1152     if(as3_pass == 2) {
1153         if(!state->cls->has_constructor && !(state->cls->info->flags&FLAG_INTERFACE)) {
1154             code_t*c = 0;
1155             c = abc_getlocal_0(c);
1156             c = abc_constructsuper(c, 0);
1157             state->cls->init->header = code_append(state->cls->init->header, c);
1158             state->cls->has_constructor=1;
1159         }
1160         if(state->cls->init) {
1161             if(state->cls->info->flags&FLAG_INTERFACE) {
1162                 if(state->cls->init->header)
1163                     syntaxerror("interface can not have class-level code");
1164             } else {
1165                 abc_method_t*m = abc_class_getconstructor(state->cls->abc, 0);
1166                 code_t*c = method_header(state->cls->init);
1167                 m->body->code = wrap_function(c, 0, m->body->code);
1168             }
1169         }
1170         if(state->cls->static_init) {
1171             abc_method_t*m = abc_class_getstaticconstructor(state->cls->abc, 0);
1172             code_t*c = method_header(state->cls->static_init);
1173             m->body->code = wrap_function(c, 0, m->body->code);
1174         }
1175     }
1176
1177     old_state();
1178 }
1179
1180 void check_code_for_break(code_t*c)
1181 {
1182     while(c) {
1183         if(c->opcode == OPCODE___BREAK__) {
1184             char*name = string_cstr(c->data[0]);
1185             syntaxerror("Unresolved \"break %s\"", name);
1186         }
1187         if(c->opcode == OPCODE___CONTINUE__) {
1188             char*name = string_cstr(c->data[0]);
1189             syntaxerror("Unresolved \"continue %s\"", name);
1190         }
1191         if(c->opcode == OPCODE___PUSHPACKAGE__) {
1192             char*name = string_cstr(c->data[0]);
1193             syntaxerror("Can't reference a package (%s) as such", name);
1194         }
1195         c=c->prev;
1196     }
1197 }
1198
1199
1200 static void check_constant_against_type(classinfo_t*t, constant_t*c)
1201 {
1202     return;
1203 #define xassert(b) if(!(b)) syntaxerror("Invalid default value %s for type '%s'", constant_tostring(c), t->name)
1204    if(TYPE_IS_NUMBER(t)) {
1205         xassert(c->type == CONSTANT_FLOAT
1206              || c->type == CONSTANT_INT
1207              || c->type == CONSTANT_UINT);
1208    } else if(TYPE_IS_UINT(t)) {
1209         xassert(c->type == CONSTANT_UINT ||
1210                (c->type == CONSTANT_INT && c->i>=0));
1211    } else if(TYPE_IS_INT(t)) {
1212         xassert(c->type == CONSTANT_INT);
1213    } else if(TYPE_IS_BOOLEAN(t)) {
1214         xassert(c->type == CONSTANT_TRUE
1215              || c->type == CONSTANT_FALSE);
1216    }
1217 }
1218
1219 static void check_override(memberinfo_t*m, int flags)
1220 {
1221     if(!m)
1222         return;
1223     if(m->parent == state->cls->info)
1224         syntaxerror("class '%s' already contains a method/slot '%s'", m->parent->name, m->name);
1225     if(!m->parent)
1226         syntaxerror("internal error: overriding method %s, which doesn't have parent", m->name);
1227     if(m->access==ACCESS_PRIVATE)
1228         return;
1229     if(m->flags & FLAG_FINAL)
1230         syntaxerror("can't override final member %s", m->name);
1231
1232     /* allow this. it's no issue.
1233     if((m->flags & FLAG_STATIC) && !(flags&FLAG_STATIC))
1234         syntaxerror("can't override static member %s", m->name);*/
1235
1236     if(!(m->flags & FLAG_STATIC) && (flags&FLAG_STATIC))
1237         syntaxerror("can't override non-static member %s with static declaration", m->name);
1238
1239     if(!(flags&FLAG_OVERRIDE) && !(flags&FLAG_STATIC) && !(m->flags&FLAG_STATIC)) {
1240         if(m->parent && !(m->parent->flags&FLAG_INTERFACE)) {
1241             if(m->kind == INFOTYPE_METHOD)
1242                 syntaxerror("can't override without explicit 'override' declaration");
1243             else
1244                 syntaxerror("can't override '%s'", m->name);
1245         }
1246     }
1247 }
1248
1249 static methodinfo_t*registerfunction(enum yytokentype getset, modifiers_t*mod, char*name, params_t*params, classinfo_t*return_type, int slot)
1250 {
1251     methodinfo_t*minfo = 0;
1252     namespace_t ns = modifiers2access(mod);
1253     if(!state->cls) {
1254         //package method
1255         minfo = methodinfo_register_global(ns.access, state->package, name);
1256         minfo->return_type = 0; // save this for pass 2
1257     } else if(getset != KW_GET && getset != KW_SET) {
1258         //class method
1259         memberinfo_t* m = registry_findmember(state->cls->info, ns.name, name, 0);
1260         if(m) {
1261             printf("%s.%s | %s.%s\n",
1262                 m->package, m->name,
1263                 ns.name, name);
1264             syntaxerror("class already contains a %s '%s'", infotypename((slotinfo_t*)m), m->name);
1265         }
1266         minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);
1267         minfo->return_type = 0; // save this for pass 2
1268         // getslot on a member slot only returns "undefined", so no need
1269         // to actually store these
1270         //state->minfo->slot = state->method->abc->method->trait->slot_id;
1271     } else {
1272         //class getter/setter
1273         int gs = getset==KW_GET?SUBTYPE_GET:SUBTYPE_SET;
1274         classinfo_t*type=0;
1275         if(getset == KW_GET) {
1276             type = return_type;
1277         } else if(params->list && params->list->param && !params->list->next) {
1278             type = params->list->param->type;
1279         } else
1280             syntaxerror("setter function needs to take exactly one argument");
1281         // not sure wether to look into superclasses here, too
1282         minfo = (methodinfo_t*)registry_findmember(state->cls->info, ns.name, name, 1);
1283         if(minfo) {
1284             if(minfo->kind!=INFOTYPE_SLOT)
1285                 syntaxerror("class already contains a method called '%s'", name);
1286             if(!(minfo->subtype & (SUBTYPE_GETSET)))
1287                 syntaxerror("class already contains a field called '%s'", name);
1288             if(minfo->subtype & gs)
1289                 syntaxerror("getter/setter for '%s' already defined", name);
1290             /* make a setter or getter into a getset */
1291             minfo->subtype |= gs;
1292
1293             /*
1294             FIXME: this check needs to be done in pass 2
1295
1296             if((!minfo->return_type != !type) ||
1297                 (minfo->return_type && type &&
1298                  !strcmp(minfo->return_type->name, type->name))) {
1299                 syntaxerror("different type in getter and setter: %s and %s",
1300                     minfo->return_type?minfo->return_type->name:"*",
1301                     type?type->name:"*");
1302             }*/
1303         } else {
1304             minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);
1305             minfo->kind = INFOTYPE_SLOT; //hack
1306             minfo->subtype = gs;
1307             minfo->return_type = 0;
1308         }
1309         /* can't assign a slot as getter and setter might have different slots */
1310         //minfo->slot = slot;
1311     }
1312     if(mod->flags&FLAG_FINAL) minfo->flags |= FLAG_FINAL;
1313     if(mod->flags&FLAG_STATIC) minfo->flags |= FLAG_STATIC;
1314     if(mod->flags&FLAG_OVERRIDE) minfo->flags |= FLAG_OVERRIDE;
1315
1316     return minfo;
1317 }
1318
1319 static void innerfunction(char*name, params_t*params, classinfo_t*return_type)
1320 {
1321     //parserassert(state->method && state->method->info);
1322
1323     methodstate_t*parent_method = state->method;
1324
1325     if(as3_pass==1) {
1326         return_type = 0; // not valid in pass 1
1327     }
1328
1329     new_state();
1330     state->new_vars = 1;
1331
1332     if(as3_pass == 1) {
1333         state->method = rfx_calloc(sizeof(methodstate_t));
1334         state->method->inner = 1;
1335         state->method->variable_count = 0;
1336         state->method->abc = rfx_calloc(sizeof(abc_method_t));
1337
1338         NEW(methodinfo_t,minfo);
1339         minfo->kind = INFOTYPE_METHOD;
1340         minfo->access = ACCESS_PACKAGEINTERNAL;
1341         minfo->name = name;
1342         state->method->info = minfo;
1343
1344         if(parent_method)
1345             list_append(parent_method->innerfunctions, state->method);
1346
1347         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
1348
1349         function_initvars(state->method, params, 0, 1);
1350     }
1351
1352     if(as3_pass == 2) {
1353         state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1354         state->method->variable_count = 0;
1355         parserassert(state->method);
1356
1357         state->method->info->return_type = return_type;
1358         function_initvars(state->method, params, 0, 1);
1359     }
1360 }
1361
1362 static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,
1363                           params_t*params, classinfo_t*return_type)
1364 {
1365     if(state->method && state->method->info) {
1366         syntaxerror("not able to start another method scope");
1367     }
1368     new_state();
1369     state->new_vars = 1;
1370
1371     if(as3_pass == 1) {
1372         state->method = rfx_calloc(sizeof(methodstate_t));
1373         state->method->has_super = 0;
1374
1375         if(state->cls) {
1376             state->method->is_constructor = !strcmp(state->cls->info->name,name);
1377         } else {
1378             state->method->is_global = 1;
1379             state->method->late_binding = 1; // for global methods, always push local_0 on the scope stack
1380         }
1381         if(state->method->is_constructor)
1382             name = "__as3_constructor__";
1383
1384         state->method->info = registerfunction(getset, mod, name, params, return_type, 0);
1385
1386         function_initvars(state->method, params, mod->flags, 1);
1387
1388         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
1389     }
1390
1391     if(as3_pass == 2) {
1392         state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1393         state->method->variable_count = 0;
1394         parserassert(state->method);
1395
1396         if(state->cls) {
1397             memberinfo_t*m = registry_findmember(state->cls->info, mod->ns, name, 2);
1398             check_override(m, mod->flags);
1399         }
1400
1401         if(state->cls) {
1402             state->cls->has_constructor |= state->method->is_constructor;
1403         }
1404
1405         state->method->info->return_type = return_type;
1406         function_initvars(state->method, params, mod->flags, 1);
1407     }
1408 }
1409
1410 static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*name,
1411                           params_t*params, classinfo_t*return_type, code_t*body)
1412 {
1413     if(as3_pass==1) {
1414         // store inner methods in variables
1415         function_initvars(state->method, 0, 0, 0);
1416
1417         methodstate_list_t*ml = state->method->innerfunctions;
1418
1419         dict_t*xvars = dict_new();
1420
1421         while(ml) {
1422             methodstate_t*m = ml->methodstate;
1423             parserassert(m->inner);
1424             if(m->unresolved_variables) {
1425                 dict_t*d = m->unresolved_variables;
1426                 int t;
1427                 for(t=0;t<d->hashsize;t++) {
1428                     dictentry_t*l = d->slots[t];
1429                     while(l) {
1430                         /* check parent method's variables */
1431                         variable_t*v;
1432                         if((v=find_variable(state, l->key))) {
1433                             m->uses_parent_function = 1;
1434                             state->method->uses_slots = 1;
1435                             dict_put(xvars, l->key, 0);
1436                         }
1437                         l = l->next;
1438                     }
1439                     if(l) break;
1440                 }
1441
1442                 dict_destroy(m->unresolved_variables);
1443                 m->unresolved_variables = 0;
1444             }
1445             ml = ml->next;
1446         }
1447
1448         if(state->method->uses_slots) {
1449             state->method->slots = dict_new();
1450             int i = 1;
1451             DICT_ITERATE_ITEMS(state->vars, char*, name, variable_t*, v) {
1452                 if(!name) syntaxerror("internal error");
1453                 if(v->index && dict_contains(xvars, name)) {
1454                     v->init = 0;
1455                     v->index = i++;
1456                     if(v->is_inner_method) {
1457                         v->is_inner_method->is_a_slot = 1;
1458                     }
1459                     //v->type = 0;
1460                     dict_put(state->method->slots, name, v);
1461                 }
1462             }
1463             state->method->uses_slots = i;
1464             dict_destroy(state->vars);state->vars = 0;
1465         }
1466         old_state();
1467         return 0;
1468     }
1469
1470     if(as3_pass==2) {
1471         /*if(state->method->uses_parent_function){
1472             syntaxerror("accessing variables of parent function from inner functions not supported yet");
1473         }*/
1474
1475         abc_method_t*f = 0;
1476
1477         multiname_t*type2 = sig2mname(return_type);
1478         int slot = 0;
1479         if(state->method->inner) {
1480             f = state->method->abc;
1481             abc_method_init(f, global->file, type2, 1);
1482         } else if(state->method->is_constructor) {
1483             f = abc_class_getconstructor(state->cls->abc, type2);
1484         } else if(!state->method->is_global) {
1485             namespace_t mname_ns = modifiers2access(mod);
1486             multiname_t mname = {QNAME, &mname_ns, 0, name};
1487
1488             if(mod->flags&FLAG_STATIC)
1489                 f = abc_class_staticmethod(state->cls->abc, type2, &mname);
1490             else
1491                 f = abc_class_method(state->cls->abc, type2, &mname);
1492             slot = f->trait->slot_id;
1493         } else {
1494             namespace_t mname_ns = {state->method->info->access, state->package};
1495             multiname_t mname = {QNAME, &mname_ns, 0, name};
1496
1497             f = abc_method_new(global->file, type2, 1);
1498             trait_t*t = trait_new_method(&global->init->traits, multiname_clone(&mname), f);
1499             //abc_code_t*c = global->init->method->body->code;
1500         }
1501         //flash doesn't seem to allow us to access function slots
1502         //state->method->info->slot = slot;
1503
1504         if(mod && mod->flags&FLAG_OVERRIDE) f->trait->attributes |= TRAIT_ATTR_OVERRIDE;
1505         if(getset == KW_GET) f->trait->kind = TRAIT_GETTER;
1506         if(getset == KW_SET) f->trait->kind = TRAIT_SETTER;
1507         if(params->varargs) f->flags |= METHOD_NEED_REST;
1508
1509         char opt=0;
1510         param_list_t*p=0;
1511         for(p=params->list;p;p=p->next) {
1512             if(params->varargs && !p->next) {
1513                 break; //varargs: omit last parameter in function signature
1514             }
1515             multiname_t*m = sig2mname(p->param->type);
1516             list_append(f->parameters, m);
1517             if(p->param->value) {
1518                 check_constant_against_type(p->param->type, p->param->value);
1519                 opt=1;list_append(f->optional_parameters, p->param->value);
1520             } else if(opt) {
1521                 syntaxerror("non-optional parameter not allowed after optional parameters");
1522             }
1523         }
1524         if(state->method->slots) {
1525             DICT_ITERATE_ITEMS(state->method->slots, char*, name, variable_t*, v) {
1526                 if(v->index) {
1527                     multiname_t*mname = multiname_new(namespace_new(ACCESS_PACKAGE, ""), name);
1528                     multiname_t*type = sig2mname(v->type);
1529                     trait_t*t = trait_new_member(&f->body->traits, type, mname, 0);
1530                     t->slot_id = v->index;
1531                 }
1532             }
1533         }
1534
1535         check_code_for_break(body);
1536
1537         /* Seems this works now.
1538         if(state->method->exceptions && state->method->uses_slots) {
1539            as3_warning("try/catch and activation not supported yet within the same method");
1540         }*/
1541
1542         if(f->body) {
1543             f->body->code = body;
1544             f->body->exceptions = state->method->exceptions;
1545         } else { //interface
1546             if(body)
1547                 syntaxerror("interface methods can't have a method body");
1548         }
1549
1550         old_state();
1551         return f;
1552     }
1553
1554     return 0;
1555 }
1556
1557 char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
1558 {
1559     return 1; // FIXME
1560 }
1561
1562 void breakjumpsto(code_t*c, char*name, code_t*jump)
1563 {
1564     while(c) {
1565         if(c->opcode == OPCODE___BREAK__) {
1566             string_t*name2 = c->data[0];
1567             if(!name2->len || !strncmp(name2->str, name, name2->len)) {
1568                 c->opcode = OPCODE_JUMP;
1569                 c->branch = jump;
1570             }
1571         }
1572         c=c->prev;
1573     }
1574 }
1575 void continuejumpsto(code_t*c, char*name, code_t*jump)
1576 {
1577     while(c) {
1578         if(c->opcode == OPCODE___CONTINUE__) {
1579             string_t*name2 = c->data[0];
1580             if(!name2->len || !strncmp(name2->str, name, name2->len)) {
1581                 c->opcode = OPCODE_JUMP;
1582                 c->branch = jump;
1583             }
1584         }
1585         c = c->prev;
1586     }
1587 }
1588
1589 #define IS_INT(a) (TYPE_IS_INT((a)) || TYPE_IS_UINT((a)))
1590 #define IS_NUMBER_OR_INT(a) (TYPE_IS_INT((a)) || TYPE_IS_UINT((a)) || TYPE_IS_NUMBER((a)))
1591 #define BOTH_INT(a,b) (IS_INT(a) && IS_INT(b))
1592
1593 classinfo_t*join_types(classinfo_t*type1, classinfo_t*type2, char op)
1594 {
1595     if(!type1 || !type2)
1596         return registry_getanytype();
1597     if(TYPE_IS_ANY(type1) || TYPE_IS_ANY(type2))
1598         return registry_getanytype();
1599
1600     if(op=='+') {
1601         if(IS_NUMBER_OR_INT(type1) && IS_NUMBER_OR_INT(type2)) {
1602             return TYPE_NUMBER;
1603         } else {
1604             return TYPE_ANY;
1605         }
1606     }
1607
1608     if(type1 == type2)
1609         return type1;
1610     return registry_getanytype();
1611 }
1612 code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
1613 {
1614     if(from==to)
1615         return c;
1616     if(!to) {
1617         return abc_coerce_a(c);
1618     }
1619     MULTINAME(m, to);
1620     if(!from) {
1621         // cast an "any" type to a specific type. subject to
1622         // runtime exceptions
1623         return abc_coerce2(c, &m);
1624     }
1625
1626     if((TYPE_IS_NUMBER(from) || TYPE_IS_UINT(from) || TYPE_IS_INT(from)) &&
1627        (TYPE_IS_NUMBER(to) || TYPE_IS_UINT(to) || TYPE_IS_INT(to))) {
1628         // allow conversion between number types
1629         return abc_coerce2(c, &m);
1630     }
1631     //printf("%s.%s\n", from.package, from.name);
1632     //printf("%s.%s\n", to.package, to.name);
1633
1634     classinfo_t*supertype = from;
1635     while(supertype) {
1636         if(supertype == to) {
1637              // target type is one of from's superclasses
1638              return abc_coerce2(c, &m);
1639         }
1640         int t=0;
1641         while(supertype->interfaces[t]) {
1642             if(supertype->interfaces[t]==to) {
1643                 // target type is one of from's interfaces
1644                 return abc_coerce2(c, &m);
1645             }
1646             t++;
1647         }
1648         supertype = supertype->superclass;
1649     }
1650     if(TYPE_IS_FUNCTION(from) && TYPE_IS_FUNCTION(to))
1651         return c;
1652     if(TYPE_IS_CLASS(from) && TYPE_IS_CLASS(to))
1653         return c;
1654     if(TYPE_IS_NULL(from) && !IS_NUMBER_OR_INT(to))
1655         return c;
1656
1657     as3_error("can't convert type %s%s%s to %s%s%s",
1658         from->package, from->package?".":"", from->name,
1659         to->package, to->package?".":"", to->name);
1660     return c;
1661 }
1662
1663 code_t*defaultvalue(code_t*c, classinfo_t*type)
1664 {
1665     if(TYPE_IS_INT(type)) {
1666        c = abc_pushbyte(c, 0);
1667     } else if(TYPE_IS_UINT(type)) {
1668        c = abc_pushuint(c, 0);
1669     } else if(TYPE_IS_FLOAT(type)) {
1670        c = abc_pushnan(c);
1671     } else if(TYPE_IS_BOOLEAN(type)) {
1672        c = abc_pushfalse(c);
1673     } else if(!type) {
1674        //c = abc_pushundefined(c);
1675     } else {
1676        c = abc_pushnull(c);
1677        MULTINAME(m, type);
1678        c = abc_coerce2(c, &m);
1679     }
1680     return c;
1681 }
1682
1683 char is_pushundefined(code_t*c)
1684 {
1685     return (c && !c->prev && !c->next && c->opcode == OPCODE_PUSHUNDEFINED);
1686 }
1687
1688 static const char* get_package_from_name(const char*name)
1689 {
1690     /* try explicit imports */
1691     dictentry_t* e = dict_get_slot(state->imports, name);
1692     while(e) {
1693         if(!strcmp(e->key, name)) {
1694             slotinfo_t*c = (slotinfo_t*)e->data;
1695             if(c) return c->package;
1696         }
1697         e = e->next;
1698     }
1699     return 0;
1700 }
1701 static namespace_list_t*get_current_imports()
1702 {
1703     namespace_list_t*searchlist = 0;
1704
1705     list_append(searchlist, namespace_new_package(state->package));
1706
1707     import_list_t*l = state->wildcard_imports;
1708     while(l) {
1709         namespace_t*ns = namespace_new_package(l->import->package);
1710         list_append(searchlist, ns);
1711         l = l->next;
1712     }
1713     list_append(searchlist, namespace_new_package(""));
1714     list_append(searchlist, namespace_new_package(internal_filename_package));
1715     return searchlist;
1716 }
1717
1718 static slotinfo_t* find_class(const char*name)
1719 {
1720     slotinfo_t*c=0;
1721
1722     c = registry_find(state->package, name);
1723     if(c) return c;
1724
1725     /* try explicit imports */
1726     dictentry_t* e = dict_get_slot(state->imports, name);
1727     if(c) return c;
1728     while(e) {
1729         if(!strcmp(e->key, name)) {
1730             c = (slotinfo_t*)e->data;
1731             if(c) return c;
1732         }
1733         e = e->next;
1734     }
1735
1736     /* try package.* imports */
1737     import_list_t*l = state->wildcard_imports;
1738     while(l) {
1739         //printf("does package %s contain a class %s?\n", l->import->package, name);
1740         c = registry_find(l->import->package, name);
1741         if(c) return c;
1742         l = l->next;
1743     }
1744
1745     /* try global package */
1746     c = registry_find("", name);
1747     if(c) return c;
1748
1749     /* try local "filename" package */
1750     c = registry_find(internal_filename_package, name);
1751     if(c) return c;
1752
1753     return 0;
1754 }
1755 typedcode_t push_class(slotinfo_t*a)
1756 {
1757     typedcode_t x;
1758     x.c = 0;
1759     x.t = 0;
1760     if(a->access == ACCESS_PACKAGEINTERNAL &&
1761        strcmp(a->package, state->package) &&
1762        strcmp(a->package, internal_filename_package)
1763        ) {
1764        syntaxerror("Can't access internal %s %s in package '%s' from package '%s'",
1765             infotypename(a), a->name, a->package, state->package);
1766     }
1767
1768     if(a->kind != INFOTYPE_CLASS) {
1769         MULTINAME(m, a);
1770         x.c = abc_findpropstrict2(x.c, &m);
1771         x.c = abc_getproperty2(x.c, &m);
1772         if(a->kind == INFOTYPE_METHOD) {
1773             methodinfo_t*f = (methodinfo_t*)a;
1774             x.t = TYPE_FUNCTION(f);
1775         } else {
1776             varinfo_t*v = (varinfo_t*)a;
1777             x.t = v->type;
1778         }
1779     } else {
1780         classinfo_t*c = (classinfo_t*)a;
1781         if(c->slot) {
1782             x.c = abc_getglobalscope(x.c);
1783             x.c = abc_getslot(x.c, c->slot);
1784         } else {
1785             MULTINAME(m, c);
1786             x.c = abc_getlex2(x.c, &m);
1787         }
1788         x.t = TYPE_CLASS(c);
1789     }
1790     return x;
1791 }
1792
1793 static char is_getlocal(code_t*c)
1794 {
1795     if(!c || c->prev || c->next)
1796         return 0;
1797     return(c->opcode == OPCODE_GETLOCAL
1798         || c->opcode == OPCODE_GETLOCAL_0
1799         || c->opcode == OPCODE_GETLOCAL_1
1800         || c->opcode == OPCODE_GETLOCAL_2
1801         || c->opcode == OPCODE_GETLOCAL_3);
1802 }
1803 static int getlocalnr(code_t*c)
1804 {
1805     if(c->opcode == OPCODE_GETLOCAL) {return (ptroff_t)c->data[0];}
1806     else if(c->opcode == OPCODE_GETLOCAL_0) {return 0;}
1807     else if(c->opcode == OPCODE_GETLOCAL_1) {return 1;}
1808     else if(c->opcode == OPCODE_GETLOCAL_2) {return 2;}
1809     else if(c->opcode == OPCODE_GETLOCAL_3) {return 3;}
1810     else syntaxerror("Internal error: opcode %02x is not a getlocal call", c->opcode);
1811     return 0;
1812 }
1813
1814 static code_t* toreadwrite(code_t*in, code_t*middlepart, char justassign, char readbefore)
1815 {
1816     /* converts this:
1817
1818        [prefix code] [read instruction]
1819
1820        to this:
1821
1822        [prefix code] ([dup]) [read instruction] [middlepart] [setvar] [write instruction] [getvar]
1823     */
1824     if(in && in->opcode == OPCODE_COERCE_A) {
1825         in = code_cutlast(in);
1826     }
1827     if(in->next)
1828         syntaxerror("internal error");
1829
1830     /* chop off read instruction */
1831     code_t*prefix = in;
1832     code_t*r = in;
1833     if(r->prev) {
1834         prefix = r->prev;r->prev = 0;
1835         prefix->next=0;
1836     } else {
1837         prefix = 0;
1838     }
1839
1840     char use_temp_var = readbefore;
1841
1842     /* generate the write instruction, and maybe append a dup to the prefix code */
1843     code_t* write = abc_nop(0);
1844     if(r->opcode == OPCODE_GETPROPERTY) {
1845         write->opcode = OPCODE_SETPROPERTY;
1846         multiname_t*m = (multiname_t*)r->data[0];
1847         write->data[0] = multiname_clone(m);
1848         if(m->type == QNAME || m->type == MULTINAME) {
1849             if(!justassign) {
1850                 prefix = abc_dup(prefix); // we need the object, too
1851             }
1852             use_temp_var = 1;
1853         } else if(m->type == MULTINAMEL) {
1854             if(!justassign) {
1855                 /* dupping two values on the stack requires 5 operations and one register-
1856                    couldn't adobe just have given us a dup2? */
1857                 int temp = gettempvar();
1858                 prefix = abc_setlocal(prefix, temp);
1859                 prefix = abc_dup(prefix);
1860                 prefix = abc_getlocal(prefix, temp);
1861                 prefix = abc_swap(prefix);
1862                 prefix = abc_getlocal(prefix, temp);
1863                 if(!use_temp_var);
1864                     prefix = abc_kill(prefix, temp);
1865             }
1866             use_temp_var = 1;
1867         } else {
1868             syntaxerror("illegal lvalue: can't assign a value to this expression (not a qname/multiname)");
1869         }
1870     } else if(r->opcode == OPCODE_GETSLOT) {
1871         write->opcode = OPCODE_SETSLOT;
1872         write->data[0] = r->data[0];
1873         if(!justassign) {
1874             prefix = abc_dup(prefix); // we need the object, too
1875         }
1876         use_temp_var = 1;
1877     } else if(r->opcode == OPCODE_GETLOCAL) {
1878         write->opcode = OPCODE_SETLOCAL;
1879         write->data[0] = r->data[0];
1880     } else if(r->opcode == OPCODE_GETLOCAL_0) {
1881         write->opcode = OPCODE_SETLOCAL_0;
1882     } else if(r->opcode == OPCODE_GETLOCAL_1) {
1883         write->opcode = OPCODE_SETLOCAL_1;
1884     } else if(r->opcode == OPCODE_GETLOCAL_2) {
1885         write->opcode = OPCODE_SETLOCAL_2;
1886     } else if(r->opcode == OPCODE_GETLOCAL_3) {
1887         write->opcode = OPCODE_SETLOCAL_3;
1888     } else if(r->opcode == OPCODE_GETSUPER) {
1889         write->opcode = OPCODE_SETSUPER;
1890         multiname_t*m = (multiname_t*)r->data[0];
1891         write->data[0] = multiname_clone(m);
1892     } else {
1893         code_dump(r);
1894         syntaxerror("illegal lvalue: can't assign a value to this expression");
1895     }
1896     code_t* c = 0;
1897
1898     int temp = -1;
1899     if(!justassign) {
1900         if(use_temp_var) {
1901             /* with getproperty/getslot, we have to be extra careful not
1902                to execute the read code twice, as it might have side-effects
1903                (e.g. if the property is in fact a setter/getter combination)
1904
1905                So read the value, modify it, and write it again,
1906                using prefix only once and making sure (by using a temporary
1907                register) that the return value is what we just wrote */
1908             temp = gettempvar();
1909             c = code_append(c, prefix);
1910             c = code_append(c, r);
1911             if(readbefore) {
1912                 c = abc_dup(c);
1913                 c = abc_setlocal(c, temp);
1914             }
1915             c = code_append(c, middlepart);
1916             if(!readbefore) {
1917                 c = abc_dup(c);
1918                 c = abc_setlocal(c, temp);
1919             }
1920             c = code_append(c, write);
1921             c = abc_getlocal(c, temp);
1922             c = abc_kill(c, temp);
1923         } else {
1924             /* if we're allowed to execute the read code twice *and*
1925                the middlepart doesn't modify the code, things are easier.
1926             */
1927             code_t* r2 = code_dup(r);
1928             //c = code_append(c, prefix);
1929             parserassert(!prefix);
1930             c = code_append(c, r);
1931             c = code_append(c, middlepart);
1932             c = code_append(c, write);
1933             c = code_append(c, r2);
1934         }
1935     } else {
1936         /* even smaller version: overwrite the value without reading
1937            it out first */
1938         if(!use_temp_var) {
1939             if(prefix) {
1940                 c = code_append(c, prefix);
1941                 c = abc_dup(c);
1942             }
1943             c = code_append(c, middlepart);
1944             c = code_append(c, write);
1945             c = code_append(c, r);
1946         } else {
1947             code_free(r);r=0;
1948             temp = gettempvar();
1949             if(prefix) {
1950                 c = code_append(c, prefix);
1951             }
1952             c = code_append(c, middlepart);
1953             c = abc_dup(c);
1954             c = abc_setlocal(c, temp);
1955             c = code_append(c, write);
1956             c = abc_getlocal(c, temp);
1957             c = abc_kill(c, temp);
1958         }
1959     }
1960     return c;
1961 }
1962
1963 char is_break_or_jump(code_t*c)
1964 {
1965     if(!c)
1966         return 0;
1967     if(c->opcode == OPCODE_JUMP ||
1968        c->opcode == OPCODE___BREAK__ ||
1969        c->opcode == OPCODE___CONTINUE__ ||
1970        c->opcode == OPCODE_THROW ||
1971        c->opcode == OPCODE_RETURNVOID ||
1972        c->opcode == OPCODE_RETURNVALUE) {
1973        return 1;
1974     }
1975     return 0;
1976 }
1977
1978 #define IS_FINALLY_TARGET(op) \
1979         ((op) == OPCODE___CONTINUE__ || \
1980          (op) == OPCODE___BREAK__ || \
1981          (op) == OPCODE_RETURNVOID || \
1982          (op) == OPCODE_RETURNVALUE || \
1983          (op) == OPCODE___RETHROW__)
1984
1985 static code_t* insert_finally_lookup(code_t*c, code_t*finally, int tempvar)
1986 {
1987 #define NEED_EXTRA_STACK_ARG
1988     code_t*finally_label = abc_nop(0);
1989     NEW(lookupswitch_t, l);
1990     //_lookupswitch
1991
1992     code_t*i = c;
1993     int count=0;
1994     while(i) {
1995         code_t*prev = i->prev;
1996         if(IS_FINALLY_TARGET(i->opcode)) {
1997            code_t*p = prev;
1998            char needvalue=0;
1999            if(i->opcode == OPCODE___RETHROW__ ||
2000               i->opcode == OPCODE_RETURNVALUE) {
2001                if(i->opcode == OPCODE___RETHROW__)
2002                  i->opcode = OPCODE_THROW;
2003                needvalue=1;
2004                p = abc_coerce_a(p);
2005                p = abc_setlocal(p, tempvar);
2006            }
2007            p = abc_pushbyte(p, count++);
2008            p = abc_jump(p, finally_label);
2009            code_t*target = p = abc_label(p);
2010 #ifdef NEED_EXTRA_STACK_ARG
2011            p = abc_pop(p);
2012 #endif
2013            if(needvalue) {
2014                p = abc_getlocal(p, tempvar);
2015            }
2016
2017            p->next = i;i->prev = p;
2018            list_append(l->targets, target);
2019         }
2020         i = prev;
2021     }
2022
2023     code_t*j,*f;
2024     c = abc_pushbyte(c, -1);
2025     c = code_append(c, finally_label);
2026     c = code_append(c, finally);
2027
2028 #ifdef NEED_EXTRA_STACK_ARG
2029     c = abc_dup(c);
2030 #endif
2031     c = abc_lookupswitch(c, l);
2032     c = l->def = abc_label(c);
2033 #ifdef NEED_EXTRA_STACK_ARG
2034     c = abc_pop(c);
2035 #endif
2036
2037     return c;
2038 }
2039
2040 static code_t* insert_finally_simple(code_t*c, code_t*finally, int tempvar)
2041 {
2042     code_t*i = c;
2043     while(i) {
2044         code_t*prev = i->prev;
2045         if(IS_FINALLY_TARGET(i->opcode)) {
2046            if(i->opcode == OPCODE___RETHROW__)
2047                 i->opcode = OPCODE_THROW;
2048            code_t*end = code_dup(finally);
2049            code_t*start = code_start(end);
2050            if(prev) prev->next = start;
2051            start->prev = prev;
2052            i->prev = end;
2053            end->next = i;
2054         }
2055         i = prev;
2056     }
2057     return code_append(c, finally);
2058 }
2059
2060 code_t* insert_finally(code_t*c, code_t*finally, int tempvar)
2061 {
2062     if(!finally)
2063         return c;
2064     code_t*i = c;
2065     char cantdup=0;
2066     int num_insertion_points=0;
2067     while(i) {
2068         if(IS_FINALLY_TARGET(i->opcode))
2069             num_insertion_points++;
2070         i = i->prev;
2071     }
2072     i = finally;
2073     int code_size=0;
2074     while(i) {
2075         code_size++;
2076         if(i->branch || i->opcode == OPCODE_LOOKUPSWITCH) {
2077             cantdup=1;
2078         }
2079         i = i->prev;
2080     }
2081     int simple_version_cost = (1+num_insertion_points)*code_size;
2082     int lookup_version_cost = 4*num_insertion_points + 5;
2083
2084     if(cantdup || simple_version_cost > lookup_version_cost) {
2085         //printf("(use lookup) simple=%d > lookup=%d\n", simple_version_cost, lookup_version_cost);
2086         return insert_finally_lookup(c, finally, tempvar);
2087     } else {
2088         //printf("(use simple) simple=%d < lookup=%d\n", simple_version_cost, lookup_version_cost);
2089         return insert_finally_simple(c, finally, tempvar);
2090     }
2091 }
2092
2093 #define PASS1 }} if(as3_pass == 1) {{
2094 #define PASS1END }} if(as3_pass == 2) {{
2095 #define PASS2 }} if(as3_pass == 2) {{
2096 #define PASS12 }} {{
2097 #define PASS12END }} if(as3_pass == 2) {{
2098
2099
2100
2101 /* Line 273 of skeleton.m4  */
2102 #line 2103 "parser.tab.c"
2103
2104 #ifdef short
2105 # undef short
2106 #endif
2107
2108 #ifdef YYTYPE_UINT8
2109 typedef YYTYPE_UINT8 yytype_uint8;
2110 #else
2111 typedef unsigned char yytype_uint8;
2112 #endif
2113
2114 #ifdef YYTYPE_INT8
2115 typedef YYTYPE_INT8 yytype_int8;
2116 #elif (defined __STDC__ || defined __C99__FUNC__ \
2117      || defined __cplusplus || defined _MSC_VER)
2118 typedef signed char yytype_int8;
2119 #else
2120 typedef short int yytype_int8;
2121 #endif
2122
2123 #ifdef YYTYPE_UINT16
2124 typedef YYTYPE_UINT16 yytype_uint16;
2125 #else
2126 typedef unsigned short int yytype_uint16;
2127 #endif
2128
2129 #ifdef YYTYPE_INT16
2130 typedef YYTYPE_INT16 yytype_int16;
2131 #else
2132 typedef short int yytype_int16;
2133 #endif
2134
2135 #ifndef YYSIZE_T
2136 # ifdef __SIZE_TYPE__
2137 #  define YYSIZE_T __SIZE_TYPE__
2138 # elif defined size_t
2139 #  define YYSIZE_T size_t
2140 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
2141      || defined __cplusplus || defined _MSC_VER)
2142 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
2143 #  define YYSIZE_T size_t
2144 # else
2145 #  define YYSIZE_T unsigned int
2146 # endif
2147 #endif
2148
2149 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
2150
2151 #ifndef YY_
2152 # if YYENABLE_NLS
2153 #  if ENABLE_NLS
2154 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
2155 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
2156 #  endif
2157 # endif
2158 # ifndef YY_
2159 #  define YY_(msgid) msgid
2160 # endif
2161 #endif
2162
2163 /* Suppress unused-variable warnings by "using" E.  */
2164 #if ! defined lint || defined __GNUC__
2165 # define YYUSE(e) ((void) (e))
2166 #else
2167 # define YYUSE(e) /* empty */
2168 #endif
2169
2170 /* Identity function, used to suppress warnings about constant conditions.  */
2171 #ifndef lint
2172 # define YYID(n) (n)
2173 #else
2174 #if (defined __STDC__ || defined __C99__FUNC__ \
2175      || defined __cplusplus || defined _MSC_VER)
2176 static int
2177 YYID (int yyi)
2178 #else
2179 static int
2180 YYID (yyi)
2181     int yyi;
2182 #endif
2183 {
2184   return yyi;
2185 }
2186 #endif
2187
2188 #if ! defined yyoverflow || YYERROR_VERBOSE
2189
2190 /* The parser invokes alloca or malloc; define the necessary symbols.  */
2191
2192 # ifdef YYSTACK_USE_ALLOCA
2193 #  if YYSTACK_USE_ALLOCA
2194 #   ifdef __GNUC__
2195 #    define YYSTACK_ALLOC __builtin_alloca
2196 #   elif defined __BUILTIN_VA_ARG_INCR
2197 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
2198 #   elif defined _AIX
2199 #    define YYSTACK_ALLOC __alloca
2200 #   elif defined _MSC_VER
2201 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
2202 #    define alloca _alloca
2203 #   else
2204 #    define YYSTACK_ALLOC alloca
2205 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
2206      || defined __cplusplus || defined _MSC_VER)
2207 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
2208 #     ifndef _STDLIB_H
2209 #      define _STDLIB_H 1
2210 #     endif
2211 #    endif
2212 #   endif
2213 #  endif
2214 # endif
2215
2216 # ifdef YYSTACK_ALLOC
2217    /* Pacify GCC's `empty if-body' warning.  */
2218 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
2219 #  ifndef YYSTACK_ALLOC_MAXIMUM
2220     /* The OS might guarantee only one guard page at the bottom of the stack,
2221        and a page size can be as small as 4096 bytes.  So we cannot safely
2222        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
2223        to allow for a few compiler-allocated temporary stack slots.  */
2224 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
2225 #  endif
2226 # else
2227 #  define YYSTACK_ALLOC YYMALLOC
2228 #  define YYSTACK_FREE YYFREE
2229 #  ifndef YYSTACK_ALLOC_MAXIMUM
2230 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
2231 #  endif
2232 #  if (defined __cplusplus && ! defined _STDLIB_H \
2233        && ! ((defined YYMALLOC || defined malloc) \
2234              && (defined YYFREE || defined free)))
2235 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
2236 #   ifndef _STDLIB_H
2237 #    define _STDLIB_H 1
2238 #   endif
2239 #  endif
2240 #  ifndef YYMALLOC
2241 #   define YYMALLOC malloc
2242 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
2243      || defined __cplusplus || defined _MSC_VER)
2244 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
2245 #   endif
2246 #  endif
2247 #  ifndef YYFREE
2248 #   define YYFREE free
2249 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
2250      || defined __cplusplus || defined _MSC_VER)
2251 void free (void *); /* INFRINGES ON USER NAME SPACE */
2252 #   endif
2253 #  endif
2254 # endif
2255 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
2256
2257
2258 #if (! defined yyoverflow \
2259      && (! defined __cplusplus \
2260          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
2261
2262 /* A type that is properly aligned for any stack member.  */
2263 union yyalloc
2264 {
2265   yytype_int16 yyss_alloc;
2266   YYSTYPE yyvs_alloc;
2267 };
2268
2269 /* The size of the maximum gap between one aligned stack and the next.  */
2270 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
2271
2272 /* The size of an array large to enough to hold all stacks, each with
2273    N elements.  */
2274 # define YYSTACK_BYTES(N) \
2275      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
2276       + YYSTACK_GAP_MAXIMUM)
2277
2278 /* Copy COUNT objects from FROM to TO.  The source and destination do
2279    not overlap.  */
2280 # ifndef YYCOPY
2281 #  if defined __GNUC__ && 1 < __GNUC__
2282 #   define YYCOPY(To, From, Count) \
2283       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
2284 #  else
2285 #   define YYCOPY(To, From, Count)              \
2286       do                                        \
2287         {                                       \
2288           YYSIZE_T yyi;                         \
2289           for (yyi = 0; yyi < (Count); yyi++)   \
2290             (To)[yyi] = (From)[yyi];            \
2291         }                                       \
2292       while (YYID (0))
2293 #  endif
2294 # endif
2295
2296 /* Relocate STACK from its old location to the new one.  The
2297    local variables YYSIZE and YYSTACKSIZE give the old and new number of
2298    elements in the stack, and YYPTR gives the new location of the
2299    stack.  Advance YYPTR to a properly aligned location for the next
2300    stack.  */
2301 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
2302     do                                                                  \
2303       {                                                                 \
2304         YYSIZE_T yynewbytes;                                            \
2305         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
2306         Stack = &yyptr->Stack_alloc;                                    \
2307         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
2308         yyptr += yynewbytes / sizeof (*yyptr);                          \
2309       }                                                                 \
2310     while (YYID (0))
2311
2312 #endif
2313
2314 /* YYFINAL -- State number of the termination state.  */
2315 #define YYFINAL  147
2316 /* YYLAST -- Last index in YYTABLE.  */
2317 #define YYLAST   3001
2318
2319 /* YYNTOKENS -- Number of terminals.  */
2320 #define YYNTOKENS  134
2321 /* YYNNTS -- Number of nonterminals.  */
2322 #define YYNNTS  114
2323 /* YYNRULES -- Number of rules.  */
2324 #define YYNRULES  309
2325 /* YYNRULES -- Number of states.  */
2326 #define YYNSTATES  521
2327
2328 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
2329 #define YYUNDEFTOK  2
2330 #define YYMAXUTOK   363
2331
2332 #define YYTRANSLATE(YYX)                                                \
2333   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
2334
2335 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
2336 static const yytype_uint8 yytranslate[] =
2337 {
2338        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2339        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2340        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2341        2,     2,     2,   118,     2,     2,     2,   116,   108,     2,
2342      122,   133,   115,   113,   100,   112,   127,   114,     2,     2,
2343        2,     2,     2,     2,     2,     2,     2,     2,   105,    99,
2344      109,   102,   110,   104,   128,     2,     2,     2,     2,     2,
2345        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2346        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2347        2,   124,     2,   125,   107,     2,     2,     2,     2,     2,
2348        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2349        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2350        2,     2,     2,   126,   106,   132,   117,     2,     2,     2,
2351        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2352        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2353        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2354        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2355        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2356        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2357        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2358        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2359        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2360        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2361        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2362        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2363        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
2364        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
2365       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
2366       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
2367       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
2368       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
2369       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
2370       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
2371       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
2372       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
2373       95,    96,    97,    98,   101,   103,   111,   119,   120,   121,
2374      123,   129,   130,   131
2375 };
2376
2377 #if YYDEBUG
2378 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
2379    YYRHS.  */
2380 static const yytype_uint16 yyprhs[] =
2381 {
2382        0,     0,     3,     5,     6,     8,    10,    13,    15,    17,
2383       19,    21,    23,    25,    30,    32,    33,    35,    37,    40,
2384       42,    44,    46,    48,    50,    55,    57,    59,    60,    63,
2385       65,    67,    69,    71,    73,    75,    77,    79,    81,    83,
2386       85,    87,    89,    93,    96,    98,   100,   102,   104,   106,
2387      108,   110,   115,   118,   120,   122,   126,   129,   130,   133,
2388      136,   138,   142,   146,   147,   150,   151,   159,   160,   162,
2389      164,   168,   170,   173,   177,   186,   193,   194,   201,   202,
2390      210,   212,   215,   217,   220,   221,   223,   225,   228,   230,
2391      233,   238,   242,   243,   252,   253,   263,   264,   270,   272,
2392      275,   277,   280,   282,   283,   290,   293,   295,   300,   303,
2393      305,   307,   309,   313,   315,   316,   323,   324,   330,   333,
2394      338,   339,   341,   343,   346,   348,   350,   352,   354,   356,
2395      358,   360,   362,   364,   366,   367,   370,   371,   374,   375,
2396      378,   379,   389,   390,   399,   400,   402,   404,   407,   409,
2397      414,   416,   418,   420,   421,   423,   425,   428,   430,   433,
2398      442,   444,   446,   447,   452,   454,   458,   462,   463,   466,
2399      468,   470,   472,   474,   476,   478,   480,   482,   484,   485,
2400      487,   490,   495,   499,   501,   506,   509,   511,   513,   514,
2401      515,   528,   530,   531,   532,   543,   545,   549,   551,   553,
2402      555,   559,   561,   563,   565,   568,   569,   570,   574,   575,
2403      577,   579,   581,   584,   587,   588,   593,   598,   603,   606,
2404      608,   611,   613,   615,   619,   621,   623,   625,   627,   629,
2405      631,   633,   635,   637,   639,   641,   643,   645,   647,   649,
2406      651,   653,   655,   659,   663,   667,   671,   675,   679,   683,
2407      687,   691,   695,   698,   701,   705,   709,   713,   717,   721,
2408      725,   729,   733,   737,   741,   745,   749,   753,   757,   761,
2409      766,   769,   771,   775,   778,   783,   787,   788,   790,   794,
2410      800,   804,   808,   812,   816,   820,   824,   828,   832,   836,
2411      840,   844,   848,   854,   857,   860,   863,   866,   870,   873,
2412      878,   884,   888,   894,   898,   900,   903,   908,   913,   916
2413 };
2414
2415 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
2416 static const yytype_int16 yyrhs[] =
2417 {
2418      135,     0,    -1,   136,    -1,    -1,   137,    -1,   138,    -1,
2419      137,   138,    -1,   186,    -1,   198,    -1,   196,    -1,   217,
2420       -1,   207,    -1,   147,    -1,   148,   126,   136,   132,    -1,
2421       99,    -1,    -1,   140,    -1,   141,    -1,   140,   141,    -1,
2422      198,    -1,   196,    -1,   217,    -1,   207,    -1,   147,    -1,
2423      148,   126,   139,   132,    -1,    99,    -1,   143,    -1,    -1,
2424      143,   145,    -1,   145,    -1,   189,    -1,   159,    -1,   160,
2425       -1,   161,    -1,   163,    -1,   171,    -1,   154,    -1,   183,
2426       -1,   179,    -1,   239,    -1,   247,    -1,   246,    -1,   126,
2427      143,   132,    -1,   126,   132,    -1,    99,    -1,   144,    -1,
2428      150,    -1,   165,    -1,   166,    -1,   236,    -1,   181,    -1,
2429      148,   126,   143,   132,    -1,   145,    99,    -1,   145,    -1,
2430      144,    -1,     3,    89,     3,    -1,   102,   237,    -1,    -1,
2431       46,   151,    -1,    32,   151,    -1,   152,    -1,   151,   100,
2432      152,    -1,     3,   227,   149,    -1,    -1,    65,   146,    -1,
2433       -1,    64,   122,   155,   238,   133,   146,   153,    -1,    -1,
2434      150,    -1,   239,    -1,    46,     3,   227,    -1,     3,    -1,
2435       13,   122,    -1,    13,    50,   122,    -1,   158,   156,    99,
2436      238,    99,   239,   133,   146,    -1,   158,   157,    68,   238,
2437      133,   146,    -1,    -1,    14,   122,   162,   238,   133,   146,
2438       -1,    -1,    15,   164,   146,    14,   122,   238,   133,    -1,
2439       66,    -1,    66,     3,    -1,    30,    -1,    30,     3,    -1,
2440       -1,   168,    -1,   170,    -1,   168,   170,    -1,   169,    -1,
2441      168,   169,    -1,    34,   240,   105,   142,    -1,    62,   105,
2442      142,    -1,    -1,    16,   122,   172,   240,   133,   126,   167,
2443      132,    -1,    -1,    33,   122,     3,   227,   133,   174,   126,
2444      142,   132,    -1,    -1,    28,   126,   176,   142,   132,    -1,
2445      173,    -1,   177,   173,    -1,   177,    -1,   177,   175,    -1,
2446      175,    -1,    -1,    52,   126,   180,   142,   132,   178,    -1,
2447       37,   238,    -1,    37,    -1,    39,   122,   238,   133,    -1,
2448      182,   146,    -1,     3,    -1,    19,    -1,     4,    -1,   185,
2449      127,   184,    -1,   184,    -1,    -1,    19,   185,   126,   187,
2450      139,   132,    -1,    -1,    19,   126,   188,   139,   132,    -1,
2451       41,   223,    -1,    41,   185,   127,   115,    -1,    -1,   191,
2452       -1,   192,    -1,   191,   192,    -1,    21,    -1,    22,    -1,
2453       20,    -1,    38,    -1,    47,    -1,    49,    -1,    48,    -1,
2454       26,    -1,    24,    -1,     4,    -1,    -1,    54,   224,    -1,
2455       -1,    54,   225,    -1,    -1,    17,   225,    -1,    -1,   190,
2456       31,     3,   193,   195,   126,   197,   200,   132,    -1,    -1,
2457      190,    44,     3,   194,   126,   199,   203,   132,    -1,    -1,
2458      201,    -1,   202,    -1,   201,   202,    -1,    99,    -1,   148,
2459      126,   200,   132,    -1,   207,    -1,   217,    -1,   144,    -1,
2460       -1,   204,    -1,   205,    -1,   204,   205,    -1,    99,    -1,
2461       46,     3,    -1,   190,    27,   216,     3,   122,   213,   133,
2462      227,    -1,    46,    -1,    32,    -1,    -1,   190,   206,   208,
2463      209,    -1,   210,    -1,   209,   100,   210,    -1,     3,   227,
2464      149,    -1,    -1,   102,   212,    -1,    10,    -1,     8,    -1,
2465        9,    -1,    12,    -1,     5,    -1,    56,    -1,    55,    -1,
2466       45,    -1,     3,    -1,    -1,   214,    -1,    93,   215,    -1,
2467      214,   100,    93,   215,    -1,   214,   100,   215,    -1,   215,
2468       -1,     3,   105,   226,   211,    -1,     3,   211,    -1,    51,
2469       -1,    35,    -1,    -1,    -1,   190,    27,   216,     3,   122,
2470      213,   133,   227,   126,   218,   142,   132,    -1,     3,    -1,
2471       -1,    -1,    27,   219,   122,   213,   133,   227,   126,   221,
2472      142,   132,    -1,   184,    -1,   185,   127,   184,    -1,   223,
2473       -1,   222,    -1,   224,    -1,   225,   100,   224,    -1,   224,
2474       -1,   115,    -1,    36,    -1,   105,   226,    -1,    -1,    -1,
2475      122,   229,   133,    -1,    -1,   230,    -1,   231,    -1,   237,
2476       -1,   230,   100,    -1,   231,   237,    -1,    -1,    25,   240,
2477      232,   228,    -1,   240,   122,   229,   133,    -1,    53,   122,
2478      229,   133,    -1,    63,   240,    -1,    42,    -1,    42,   238,
2479       -1,   240,    -1,   240,    -1,   238,   100,   240,    -1,   238,
2480       -1,   220,    -1,   241,    -1,   244,    -1,   233,    -1,   235,
2481       -1,   234,    -1,     6,    -1,    10,    -1,    11,    -1,     8,
2482       -1,     9,    -1,    12,    -1,     5,    -1,    29,    -1,    56,
2483       -1,    55,    -1,    45,    -1,   240,   109,   240,    -1,   240,
2484      110,   240,    -1,   240,    75,   240,    -1,   240,    76,   240,
2485       -1,   240,    71,   240,    -1,   240,    72,   240,    -1,   240,
2486       74,   240,    -1,   240,    73,   240,    -1,   240,    87,   240,
2487       -1,   240,    88,   240,    -1,   118,   240,    -1,   117,   240,
2488       -1,   240,   108,   240,    -1,   240,   107,   240,    -1,   240,
2489      106,   240,    -1,   240,    96,   240,    -1,   240,    95,   240,
2490       -1,   240,    94,   240,    -1,   240,   114,   240,    -1,   240,
2491      116,   240,    -1,   240,   113,   240,    -1,   240,   112,   240,
2492       -1,   240,   115,   240,    -1,   240,    68,   240,    -1,   240,
2493       69,   240,    -1,   240,    40,   240,    -1,   240,    67,   240,
2494       -1,    43,   122,   240,   133,    -1,    36,   240,    -1,    36,
2495       -1,   122,   238,   133,    -1,   112,   240,    -1,   240,   124,
2496      240,   125,    -1,   124,   229,   125,    -1,    -1,   243,    -1,
2497      237,   105,   237,    -1,   243,   100,   237,   105,   237,    -1,
2498       70,   242,   132,    -1,   240,    80,   240,    -1,   240,    79,
2499      240,    -1,   240,    85,   240,    -1,   240,    84,   240,    -1,
2500      240,    86,   240,    -1,   240,    78,   240,    -1,   240,    77,
2501      240,    -1,   240,    83,   240,    -1,   240,    81,   240,    -1,
2502      240,    82,   240,    -1,   240,   102,   240,    -1,   240,   104,
2503      240,   105,   240,    -1,   240,    91,    -1,   240,    90,    -1,
2504       91,   240,    -1,    90,   240,    -1,    53,   127,     3,    -1,
2505      128,     3,    -1,   240,   127,   128,     3,    -1,   240,   127,
2506        3,    89,     3,    -1,   240,    92,     3,    -1,   240,   127,
2507      122,   240,   133,    -1,   240,   127,     3,    -1,     3,    -1,
2508       18,     3,    -1,    18,     3,   102,     3,    -1,    18,     3,
2509      102,     5,    -1,   190,   245,    -1,    23,    18,   224,    -1
2510 };
2511
2512 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
2513 static const yytype_uint16 yyrline[] =
2514 {
2515        0,  2081,  2081,  2083,  2083,  2084,  2085,  2087,  2088,  2089,
2516     2090,  2091,  2092,  2093,  2094,  2096,  2096,  2097,  2098,  2100,
2517     2101,  2102,  2103,  2104,  2105,  2106,  2108,  2109,  2111,  2112,
2518     2115,  2116,  2117,  2118,  2119,  2120,  2121,  2122,  2123,  2124,
2519     2125,  2126,  2127,  2128,  2131,  2132,  2133,  2134,  2135,  2136,
2520     2137,  2138,  2142,  2143,  2147,  2154,  2158,  2159,  2163,  2164,
2521     2166,  2167,  2169,  2230,  2231,  2234,  2234,  2253,  2254,  2255,
2522     2260,  2264,  2269,  2270,  2272,  2292,  2340,  2340,  2359,  2359,
2523     2374,  2377,  2380,  2383,  2387,  2388,  2389,  2390,  2391,  2392,
2524     2394,  2405,  2408,  2408,  2439,  2439,  2464,  2464,  2480,  2481,
2525     2482,  2483,  2491,  2500,  2500,  2549,  2553,  2564,  2574,  2591,
2526     2592,  2593,  2595,  2596,  2598,  2598,  2600,  2600,  2603,  2619,
2527     2636,  2637,  2638,  2639,  2646,  2647,  2648,  2649,  2650,  2651,
2528     2652,  2653,  2654,  2655,  2659,  2660,  2662,  2663,  2665,  2666,
2529     2670,  2668,  2676,  2674,  2683,  2684,  2685,  2686,  2687,  2688,
2530     2689,  2690,  2692,  2698,  2699,  2700,  2701,  2702,  2703,  2706,
2531     2719,  2719,  2721,  2721,  2723,  2724,  2726,  2801,  2802,  2804,
2532     2805,  2806,  2807,  2808,  2810,  2811,  2812,  2813,  2825,  2829,
2533     2835,  2841,  2849,  2854,  2860,  2868,  2876,  2877,  2878,  2881,
2534     2880,  2897,  2898,  2900,  2899,  2923,  2942,  2956,  2957,  2959,
2535     2960,  2962,  2963,  2964,  2973,  2974,  2978,  2979,  2981,  2982,
2536     2983,  2985,  2989,  2990,  2995,  2996,  3032,  3078,  3099,  3120,
2537     3123,  3130,  3131,  3132,  3138,  3144,  3146,  3148,  3150,  3152,
2538     3154,  3156,  3173,  3178,  3181,  3184,  3187,  3190,  3193,  3196,
2539     3199,  3202,  3206,  3209,  3212,  3215,  3218,  3221,  3224,  3227,
2540     3231,  3242,  3260,  3265,  3270,  3275,  3280,  3285,  3289,  3293,
2541     3298,  3302,  3306,  3315,  3324,  3334,  3339,  3351,  3357,  3362,
2542     3368,  3374,  3378,  3380,  3391,  3400,  3407,  3408,  3410,  3416,
2543     3425,  3432,  3444,  3450,  3456,  3462,  3468,  3474,  3480,  3486,
2544     3499,  3510,  3517,  3530,  3557,  3571,  3585,  3599,  3614,  3621,
2545     3628,  3635,  3642,  3653,  3703,  3808,  3815,  3822,  3829,  3844
2546 };
2547 #endif
2548
2549 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
2550 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2551    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
2552 static const char *const yytname[] =
2553 {
2554   "$end", "error", "$undefined", "T_IDENTIFIER", "T_NAMESPACE",
2555   "T_STRING", "T_REGEXP", "T_EMPTY", "T_INT", "T_UINT", "T_BYTE",
2556   "T_SHORT", "T_FLOAT", "\"for\"", "\"while\"", "\"do\"", "\"switch\"",
2557   "\"implements\"", "\"namespace\"", "\"package\"", "\"protected\"",
2558   "\"public\"", "\"private\"", "\"use\"", "\"internal\"", "\"new\"",
2559   "\"native\"", "\"function\"", "\"finally\"", "\"undefined\"",
2560   "\"continue\"", "\"class\"", "\"const\"", "\"catch\"", "\"case\"",
2561   "\"set\"", "\"void\"", "\"throw\"", "\"static\"", "\"with\"",
2562   "\"instanceof\"", "\"import\"", "\"return\"", "\"typeof\"",
2563   "\"interface\"", "\"null\"", "\"var\"", "\"dynamic\"", "\"override\"",
2564   "\"final\"", "\"each\"", "\"get\"", "\"try\"", "\"super\"",
2565   "\"extends\"", "\"false\"", "\"true\"", "\"Boolean\"", "\"uint\"",
2566   "\"int\"", "\"Number\"", "\"String\"", "\"default\"", "\"delete\"",
2567   "\"if\"", "\"else\"", "\"break\"", "\"is\"", "\"in\"", "\"as\"",
2568   "\"{ (dictionary)\"", "\"==\"", "\"===\"", "\"!=\"", "\"!==\"", "\"<=\"",
2569   "\">=\"", "\"|=\"", "\"/=\"", "\"%=\"", "\"*=\"", "\"+=\"", "\"-=\"",
2570   "\"^=\"", "\">>=\"", "\"<<=\"", "\">>>=\"", "\"||\"", "\"&&\"", "\"::\"",
2571   "\"--\"", "\"++\"", "\"..\"", "\"...\"", "\"<<\"", "\">>>\"", "\">>\"",
2572   "prec_none", "below_semicolon", "';'", "','", "below_assignment", "'='",
2573   "\"&=\"", "'?'", "':'", "'|'", "'^'", "'&'", "'<'", "'>'", "below_minus",
2574   "'-'", "'+'", "'/'", "'*'", "'%'", "'~'", "'!'", "minusminus_prefix",
2575   "plusplus_prefix", "below_curly", "'('", "new2", "'['", "']'", "'{'",
2576   "'.'", "'@'", "above_identifier", "below_else", "above_function", "'}'",
2577   "')'", "$accept", "PROGRAM", "MAYBE_PROGRAM_CODE_LIST",
2578   "PROGRAM_CODE_LIST", "PROGRAM_CODE", "MAYBE_INPACKAGE_CODE_LIST",
2579   "INPACKAGE_CODE_LIST", "INPACKAGE_CODE", "MAYBECODE", "CODE",
2580   "CODE_STATEMENT", "CODEPIECE", "CODEBLOCK", "PACKAGE_INITCODE",
2581   "CONDITIONAL_COMPILATION", "MAYBEEXPRESSION", "VARIABLE_DECLARATION",
2582   "VARIABLE_LIST", "ONE_VARIABLE", "MAYBEELSE", "IF", "$@1", "FOR_INIT",
2583   "FOR_IN_INIT", "FOR_START", "FOR", "FOR_IN", "WHILE", "$@2", "DO_WHILE",
2584   "$@3", "BREAK", "CONTINUE", "MAYBE_CASE_LIST", "CASE_LIST", "CASE",
2585   "DEFAULT", "SWITCH", "$@4", "CATCH", "$@5", "FINALLY", "$@6",
2586   "CATCH_LIST", "CATCH_FINALLY_LIST", "TRY", "$@7", "THROW", "WITH_HEAD",
2587   "WITH", "X_IDENTIFIER", "PACKAGE", "PACKAGE_DECLARATION", "$@8", "$@9",
2588   "IMPORT", "MAYBE_MODIFIERS", "MODIFIER_LIST", "MODIFIER", "EXTENDS",
2589   "EXTENDS_LIST", "IMPLEMENTS_LIST", "CLASS_DECLARATION", "$@10",
2590   "INTERFACE_DECLARATION", "$@11", "MAYBE_CLASS_BODY", "CLASS_BODY",
2591   "CLASS_BODY_ITEM", "MAYBE_INTERFACE_BODY", "INTERFACE_BODY",
2592   "IDECLARATION", "VARCONST", "SLOT_DECLARATION", "$@12", "SLOT_LIST",
2593   "ONE_SLOT", "MAYBESTATICCONSTANT", "STATICCONSTANT", "MAYBE_PARAM_LIST",
2594   "PARAM_LIST", "PARAM", "GETSET", "FUNCTION_DECLARATION", "$@13",
2595   "MAYBE_IDENTIFIER", "INNERFUNCTION", "$@14", "CLASS", "PACKAGEANDCLASS",
2596   "CLASS_SPEC", "CLASS_SPEC_LIST", "TYPE", "MAYBETYPE",
2597   "MAYBE_PARAM_VALUES", "MAYBE_EXPRESSION_LIST", "EXPRESSION_LIST",
2598   "EXPRESSION_LIST_AND_COMMA", "XX", "NEW", "FUNCTIONCALL", "DELETE",
2599   "RETURN", "NONCOMMAEXPRESSION", "EXPRESSION", "VOIDEXPRESSION", "E",
2600   "CONSTANT", "MAYBE_EXPRPAIR_LIST", "EXPRPAIR_LIST", "VAR_READ",
2601   "NAMESPACE_ID", "NAMESPACE_DECLARATION", "USE_NAMESPACE", 0
2602 };
2603 #endif
2604
2605 # ifdef YYPRINT
2606 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
2607    token YYLEX-NUM.  */
2608 static const yytype_uint16 yytoknum[] =
2609 {
2610        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
2611      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
2612      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
2613      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
2614      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
2615      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
2616      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
2617      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
2618      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
2619      345,   346,   347,   348,   349,   350,   351,   352,   353,    59,
2620       44,   354,    61,   355,    63,    58,   124,    94,    38,    60,
2621       62,   356,    45,    43,    47,    42,    37,   126,    33,   357,
2622      358,   359,    40,   360,    91,    93,   123,    46,    64,   361,
2623      362,   363,   125,    41
2624 };
2625 # endif
2626
2627 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
2628 static const yytype_uint8 yyr1[] =
2629 {
2630        0,   134,   135,   136,   136,   137,   137,   138,   138,   138,
2631      138,   138,   138,   138,   138,   139,   139,   140,   140,   141,
2632      141,   141,   141,   141,   141,   141,   142,   142,   143,   143,
2633      144,   144,   144,   144,   144,   144,   144,   144,   144,   144,
2634      144,   144,   144,   144,   145,   145,   145,   145,   145,   145,
2635      145,   145,   146,   146,   147,   148,   149,   149,   150,   150,
2636      151,   151,   152,   153,   153,   155,   154,   156,   156,   156,
2637      157,   157,   158,   158,   159,   160,   162,   161,   164,   163,
2638      165,   165,   166,   166,   167,   167,   167,   167,   168,   168,
2639      169,   170,   172,   171,   174,   173,   176,   175,   177,   177,
2640      178,   178,   178,   180,   179,   181,   181,   182,   183,   184,
2641      184,   184,   185,   185,   187,   186,   188,   186,   189,   189,
2642      190,   190,   191,   191,   192,   192,   192,   192,   192,   192,
2643      192,   192,   192,   192,   193,   193,   194,   194,   195,   195,
2644      197,   196,   199,   198,   200,   200,   201,   201,   202,   202,
2645      202,   202,   202,   203,   203,   204,   204,   205,   205,   205,
2646      206,   206,   208,   207,   209,   209,   210,   211,   211,   212,
2647      212,   212,   212,   212,   212,   212,   212,   212,   213,   213,
2648      213,   213,   214,   214,   215,   215,   216,   216,   216,   218,
2649      217,   219,   219,   221,   220,   222,   223,   224,   224,   225,
2650      225,   226,   226,   226,   227,   227,   228,   228,   229,   229,
2651      229,   230,   231,   230,   232,   233,   234,   234,   235,   236,
2652      236,   237,   238,   238,   239,   240,   240,   240,   240,   240,
2653      240,   240,   241,   241,   241,   241,   241,   241,   241,   241,
2654      241,   241,   240,   240,   240,   240,   240,   240,   240,   240,
2655      240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
2656      240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
2657      240,   240,   240,   240,   240,   240,   242,   242,   243,   243,
2658      240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
2659      240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
2660      240,   240,   240,   240,   244,   245,   245,   245,   246,   247
2661 };
2662
2663 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
2664 static const yytype_uint8 yyr2[] =
2665 {
2666        0,     2,     1,     0,     1,     1,     2,     1,     1,     1,
2667        1,     1,     1,     4,     1,     0,     1,     1,     2,     1,
2668        1,     1,     1,     1,     4,     1,     1,     0,     2,     1,
2669        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2670        1,     1,     3,     2,     1,     1,     1,     1,     1,     1,
2671        1,     4,     2,     1,     1,     3,     2,     0,     2,     2,
2672        1,     3,     3,     0,     2,     0,     7,     0,     1,     1,
2673        3,     1,     2,     3,     8,     6,     0,     6,     0,     7,
2674        1,     2,     1,     2,     0,     1,     1,     2,     1,     2,
2675        4,     3,     0,     8,     0,     9,     0,     5,     1,     2,
2676        1,     2,     1,     0,     6,     2,     1,     4,     2,     1,
2677        1,     1,     3,     1,     0,     6,     0,     5,     2,     4,
2678        0,     1,     1,     2,     1,     1,     1,     1,     1,     1,
2679        1,     1,     1,     1,     0,     2,     0,     2,     0,     2,
2680        0,     9,     0,     8,     0,     1,     1,     2,     1,     4,
2681        1,     1,     1,     0,     1,     1,     2,     1,     2,     8,
2682        1,     1,     0,     4,     1,     3,     3,     0,     2,     1,
2683        1,     1,     1,     1,     1,     1,     1,     1,     0,     1,
2684        2,     4,     3,     1,     4,     2,     1,     1,     0,     0,
2685       12,     1,     0,     0,    10,     1,     3,     1,     1,     1,
2686        3,     1,     1,     1,     2,     0,     0,     3,     0,     1,
2687        1,     1,     2,     2,     0,     4,     4,     4,     2,     1,
2688        2,     1,     1,     3,     1,     1,     1,     1,     1,     1,
2689        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2690        1,     1,     3,     3,     3,     3,     3,     3,     3,     3,
2691        3,     3,     2,     2,     3,     3,     3,     3,     3,     3,
2692        3,     3,     3,     3,     3,     3,     3,     3,     3,     4,
2693        2,     1,     3,     2,     4,     3,     0,     1,     3,     5,
2694        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
2695        3,     3,     5,     2,     2,     2,     2,     3,     2,     4,
2696        5,     3,     5,     3,     1,     2,     4,     4,     2,     3
2697 };
2698
2699 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
2700    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
2701    means the default is an error.  */
2702 static const yytype_uint16 yydefact[] =
2703 {
2704      120,   304,   133,   237,   231,   234,   235,   232,   233,   236,
2705        0,     0,    78,     0,     0,   126,   124,   125,     0,   132,
2706        0,   131,   192,   238,   271,   127,     0,     0,     0,   241,
2707      128,   130,   129,     0,     0,   240,   239,     0,     0,   276,
2708        0,     0,    14,     0,     0,     0,     0,   208,   120,     0,
2709        0,     2,   120,     5,    54,    12,     0,    36,    67,    31,
2710       32,    33,    34,    35,    38,   120,    37,     7,    30,     0,
2711      121,   122,     9,     8,    11,    10,   225,   228,   230,   229,
2712      224,    39,   222,   226,   227,    41,    40,     0,     0,    72,
2713       76,   120,    92,   109,   111,   110,   116,   113,     0,     0,
2714      304,   214,   191,     0,   270,     0,     0,   118,     0,   103,
2715      208,     0,   218,    65,     0,   221,     0,   277,   296,   295,
2716      273,   253,   252,     0,     0,   209,   210,   211,    82,     0,
2717      106,   219,     0,    80,    44,    43,   120,    45,    29,     0,
2718       46,    47,    48,    50,     0,    49,   298,     1,     6,   120,
2719      304,     0,    68,     0,     0,    69,    53,   108,     0,   188,
2720        0,   161,     0,   160,   162,   308,   123,     0,     0,     0,
2721        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2722        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2723      294,   293,     0,     0,     0,     0,     0,     0,     0,     0,
2724        0,     0,     0,     0,     0,     0,     0,     0,   208,     0,
2725        0,    55,    73,     0,     0,     0,   120,   114,     0,   195,
2726        0,   198,   197,   309,   206,   178,     0,     0,     0,    27,
2727        0,   297,     0,     0,   280,     0,   272,   275,   212,   213,
2728       83,   205,    59,    60,   105,   220,    58,    81,    42,    28,
2729      120,     0,   205,     0,     0,    52,   305,   187,   186,     0,
2730      134,   136,     0,   223,   267,   268,   265,   266,   246,   247,
2731      249,   248,   244,   245,   287,   286,   282,   281,   289,   290,
2732      288,   284,   283,   285,   250,   251,   301,   259,   258,   257,
2733      291,     0,   256,   255,   254,   242,   243,   263,   262,   260,
2734      264,   261,     0,     0,   303,     0,     0,     0,     0,     0,
2735       25,     0,   120,    17,    23,     0,    20,    19,    22,    21,
2736      120,   112,     0,   208,   215,   167,     0,     0,   179,   183,
2737      107,   119,   196,   269,     0,    26,   217,     0,   278,     0,
2738        0,    57,     0,   120,    13,    57,     0,     0,     0,     0,
2739        0,   138,     0,     0,   205,   163,   164,     0,   216,   274,
2740        0,     0,   299,   120,     0,     0,   117,    18,   120,     0,
2741        0,     0,     0,   185,   180,   205,     0,     0,   120,     0,
2742      203,   202,   201,   204,     0,    62,    61,    51,     0,   120,
2743      306,   307,   178,   135,     0,     0,   199,   137,   142,    57,
2744        0,   292,   300,   302,    77,     0,    84,     0,   115,   207,
2745      177,   173,   170,   171,   169,   172,   176,   175,   174,   168,
2746      167,     0,     0,   182,     0,     0,    98,   102,   100,   104,
2747       63,   279,    56,     0,    75,     0,   139,   140,     0,   120,
2748      166,   165,    79,     0,     0,     0,    85,    88,    86,    24,
2749      184,   193,   181,    96,     0,    99,   101,   120,    66,   120,
2750      205,   120,   200,     0,   157,     0,     0,   120,   155,     0,
2751       27,    93,    89,    87,    27,    27,   205,    64,    74,     0,
2752      148,   152,     0,     0,     0,   120,   146,   150,   151,   158,
2753      188,   143,   156,    27,    91,     0,     0,     0,   189,   120,
2754      141,   147,     0,    90,   194,    97,    94,    27,     0,     0,
2755        0,     0,   149,   178,    27,   190,     0,     0,   205,    95,
2756      159
2757 };
2758
2759 /* YYDEFGOTO[NTERM-NUM].  */
2760 static const yytype_int16 yydefgoto[] =
2761 {
2762       -1,    50,    51,    52,    53,   311,   312,   313,   334,   335,
2763      137,   138,   157,   314,   139,   385,   140,   246,   243,   458,
2764       57,   232,   153,   154,    58,    59,    60,    61,   213,    62,
2765       91,   141,   142,   445,   446,   447,   448,    63,   215,   426,
2766      510,   427,   475,   428,   429,    64,   229,   143,    65,    66,
2767      219,   220,    67,   320,   216,    68,   144,    70,    71,   351,
2768      353,   395,   316,   461,   317,   439,   484,   485,   486,   466,
2769      467,   468,   164,   318,   262,   355,   356,   373,   419,   327,
2770      328,   329,   259,   319,   507,   103,    76,   474,   221,   222,
2771      382,   397,   383,   341,   324,   124,   125,   126,   224,    77,
2772       78,    79,   145,   127,    80,    81,    82,    83,   116,   117,
2773       84,   165,    85,    86
2774 };
2775
2776 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2777    STATE-NUM.  */
2778 #define YYPACT_NINF -403
2779 static const yytype_int16 yypact[] =
2780 {
2781     1674,   -70,  -403,  -403,  -403,  -403,  -403,  -403,  -403,  -403,
2782      -15,   -72,  -403,   -52,    19,  -403,  -403,  -403,    80,  -403,
2783     2094,  -403,    99,  -403,  2164,  -403,   -16,    42,    -5,  -403,
2784     -403,  -403,  -403,    -1,     5,  -403,  -403,  2094,    13,  2094,
2785     2094,  2094,  -403,  2094,  2094,  2094,  2094,  2094,   634,   123,
2786      128,  -403,   504,  -403,  -403,  -403,     8,  -403,  2024,  -403,
2787     -403,  -403,  -403,  -403,  -403,  1926,  -403,  -403,  -403,   240,
2788      361,  -403,  -403,  -403,  -403,  -403,  -403,  -403,  -403,  -403,
2789       38,  -403,  2569,  -403,  -403,  -403,  -403,   137,    20,  -403,
2790     -403,  1926,  -403,  -403,  -403,  -403,  -403,  -403,   -87,    42,
2791     -403,   -67,  -403,    21,   -48,  2094,    79,  -403,  2094,  -403,
2792     2094,   138,   -48,  -403,    43,  2569,    76,   107,   -48,   -48,
2793      604,   -48,   -48,   -29,    84,   110,  2094,  -403,   210,   211,
2794     2094,  2094,   211,   212,  -403,  -403,   764,  -403,  -403,    85,
2795     -403,  -403,  -403,  -403,   209,  -403,  -403,  -403,  -403,  1024,
2796      158,   232,  -403,   139,   171,  -403,   141,  -403,   238,    12,
2797      239,  -403,   247,  -403,  -403,  -403,  -403,  2094,  2094,  2094,
2798     2094,  2094,  2094,  2094,  2094,  2094,  2094,  2094,  2094,  2094,
2799     2094,  2094,  2094,  2094,  2094,  2094,  2094,  2094,  2094,  2094,
2800     -403,  -403,   249,  2094,  2094,  2094,  2094,  2094,  2094,  2094,
2801     2094,  2094,  2094,  2094,  2094,  2094,  2094,  2094,  2094,  2094,
2802       11,  -403,  -403,  2094,   229,  2094,  1154,  -403,    42,   133,
2803      135,  -403,  -403,  -403,   142,    15,   -10,    90,  2189,  1800,
2804      130,  -403,  2094,  2094,  -403,  2094,  -403,  -403,  -403,  -403,
2805     -403,   161,   169,  -403,    38,    38,   169,  -403,  -403,  -403,
2806     1926,   149,   161,  2094,  2094,  -403,   168,  -403,  -403,   280,
2807      231,   233,   286,  2569,  1016,   496,   496,   496,   322,   322,
2808      322,   322,  1016,  1016,  2569,  2569,  2569,  2569,  2569,  2569,
2809     2569,  2569,  2569,  2569,  2630,  2691,  -403,   368,   368,   368,
2810     2569,  2386,  2752,  2813,  2874,  1016,  1016,   604,   604,   -48,
2811      -48,   -48,   157,  2447,   202,  2094,   291,    14,   173,  2260,
2812     -403,   165,  1284,  -403,  -403,   172,  -403,  -403,  -403,  -403,
2813     1154,  -403,    42,  2094,  -403,   -43,   296,   167,   201,  -403,
2814     -403,  -403,   175,  -403,   174,  1800,  -403,    44,  -403,   200,
2815       63,   207,   211,   894,  -403,   -27,   -11,    46,   113,   189,
2816       42,   298,    42,   190,   161,   217,  -403,  2094,  -403,  -403,
2817      315,  2323,  -403,  1926,  2094,   193,  -403,  -403,  1154,   192,
2818      194,    75,    63,  -403,  -403,   161,    26,    96,  1926,  2094,
2819     -403,  -403,  -403,  -403,  2094,  -403,  -403,  -403,  2094,  1926,
2820     -403,  -403,    15,  -403,    42,   199,  -403,   230,  -403,   207,
2821      286,  2569,  -403,  -403,  -403,   103,    24,   197,  -403,  -403,
2822     -403,  -403,  -403,  -403,  -403,  -403,  -403,  -403,  -403,  -403,
2823      234,   205,   296,  -403,   206,   213,  -403,  -403,    96,  -403,
2824      268,  -403,  -403,   204,  -403,   215,   230,  -403,    42,   208,
2825     -403,  -403,  -403,  2094,   236,   214,    24,  -403,  -403,  -403,
2826     -403,  -403,  -403,  -403,   335,  -403,  -403,  1926,  -403,  1926,
2827      161,  1414,  -403,   339,  -403,   316,   219,   227,  -403,  2508,
2828     1800,  -403,  -403,  -403,  1800,  1800,   161,  -403,  -403,   223,
2829     -403,  -403,   226,   250,   221,  1544,  -403,  -403,  -403,  -403,
2830       12,  -403,  -403,  1800,  -403,   222,   224,   225,  -403,  1414,
2831     -403,  -403,   354,  -403,  -403,  -403,  -403,  1800,   228,   241,
2832      235,   243,  -403,    15,  1800,  -403,   244,   246,   161,  -403,
2833     -403
2834 };
2835
2836 /* YYPGOTO[NTERM-NUM].  */
2837 static const yytype_int16 yypgoto[] =
2838 {
2839     -403,  -403,   218,  -403,   312,  -299,  -403,    61,  -402,   -31,
2840        1,   -55,   -85,    48,     2,   -23,   321,   251,    58,  -403,
2841     -403,  -403,  -403,  -403,  -403,  -403,  -403,  -403,  -403,  -403,
2842     -403,  -403,  -403,  -403,  -403,   -62,   -60,  -403,  -403,   -40,
2843     -403,   -36,  -403,  -403,  -403,  -403,  -403,  -403,  -403,  -403,
2844        6,    50,  -403,  -403,  -403,  -403,     0,  -403,   331,  -403,
2845     -403,  -403,    49,  -403,    51,  -403,   -96,  -403,   -80,  -403,
2846     -403,   -61,  -403,     3,  -403,  -403,     7,     9,  -403,  -376,
2847     -403,  -311,   -79,     4,  -403,  -403,  -403,  -403,  -403,   388,
2848      -91,    25,    52,  -239,  -403,   -98,  -403,  -403,  -403,  -403,
2849     -403,  -403,  -403,   -34,    -9,   -49,   -13,  -403,  -403,  -403,
2850     -403,  -403,  -403,  -403
2851 };
2852
2853 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
2854    positive, shift that token.  If negative, reduce the rule which
2855    number is the opposite.  If zero, do what YYDEFACT says.
2856    If YYTABLE_NINF, syntax error.  */
2857 #define YYTABLE_NINF -155
2858 static const yytype_int16 yytable[] =
2859 {
2860       69,    54,    56,    74,    75,   114,   214,   101,   223,   155,
2861      156,   104,   230,   345,   304,   374,   435,   136,   325,    87,
2862       97,   369,    93,    94,   112,   192,   115,   118,   119,   325,
2863      120,   121,   122,    97,   115,    88,   156,   123,    95,   217,
2864      218,   -70,   190,   191,   192,    93,    94,   257,    55,    72,
2865       90,    73,    69,    54,    56,    74,    75,   209,   443,   371,
2866      210,    95,   372,   258,    98,   423,    93,    94,   494,   407,
2867       92,   167,   495,   496,   208,   384,   209,   106,   410,   210,
2868      411,   249,    95,   412,   413,   414,   444,   415,   388,   167,
2869      167,   503,   239,    93,    94,   228,   226,   115,    99,   380,
2870       55,    72,   102,    73,   236,   511,   105,    89,   326,    95,
2871      302,   452,   517,   115,   167,   399,   390,   108,   391,   422,
2872      416,   244,   245,   330,   424,   109,   146,   110,   147,   425,
2873      417,   418,   111,   305,   149,   113,   421,   516,   167,   306,
2874      211,   231,   212,   225,   167,    96,   167,   363,   233,    69,
2875       54,    56,    74,    75,   263,   264,   265,   266,   267,   268,
2876      269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
2877      279,   280,   281,   282,   283,   284,   285,   378,   381,   389,
2878      287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
2879      297,   298,   299,   300,   301,   115,   303,    55,    72,   338,
2880       73,   339,   309,   167,   307,   331,   227,   235,   234,   237,
2881      238,   250,     2,   240,   241,   247,    69,    54,   315,   343,
2882      115,   479,   115,   337,   321,   370,   -71,   158,    15,    16,
2883       17,     2,    19,   332,    21,   252,   442,   497,   253,   254,
2884      255,   256,   260,   308,   346,   347,    25,    15,    16,    17,
2885      261,    19,   286,    21,   463,    30,    31,    32,   158,   393,
2886     -113,   396,   322,   336,   323,    25,   340,   159,   158,   342,
2887      348,   160,   161,   463,    30,    31,    32,   159,   404,   520,
2888      249,   344,   161,   349,   162,   350,   163,   352,   249,   354,
2889      358,   360,   361,   430,   362,   364,   163,   366,   368,   325,
2890      375,   376,  -112,   396,   434,   379,   377,   464,   156,   384,
2891      115,   392,    69,    54,   315,   394,   398,   400,   402,   406,
2892       69,    54,   315,   156,   408,   437,   464,   409,   332,   449,
2893      438,   451,   453,   457,   156,   454,   371,   459,   476,   433,
2894     -153,   470,   489,   490,   401,   431,   471,   462,   460,   498,
2895      432,   491,   499,   500,   504,   405,   505,   509,   506,  -154,
2896      512,   514,   168,   513,   148,     2,   115,   251,    69,    54,
2897      315,   115,   477,   367,   478,   515,   440,   518,   519,   152,
2898      242,    15,    16,    17,   472,    19,   473,    21,   455,   169,
2899      170,   171,   456,  -155,  -155,  -155,  -155,   176,   177,    25,
2900      386,   166,   156,   508,   156,   501,   492,   441,    30,    31,
2901       32,   502,   190,   191,   192,   107,   193,   194,   195,   436,
2902        0,     0,     0,     0,   420,     0,     0,     0,     0,   450,
2903      469,   201,   202,     0,   203,   204,   205,   206,   207,   465,
2904        0,     0,     0,     0,   208,     0,   209,     0,     0,   210,
2905        0,     0,     0,     0,     0,     0,     0,     0,   190,   191,
2906      192,   483,   481,   482,   487,   488,     0,   465,     0,     0,
2907        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2908      203,   204,   205,   206,   207,   483,   481,   482,   487,   488,
2909      208,     0,   209,     0,     0,   210,     0,     0,     0,   483,
2910      481,   482,   487,   488,    -4,     0,     0,     1,     2,     3,
2911        4,     0,     5,     6,     7,     8,     9,    10,    11,    12,
2912       13,     0,     0,    14,    15,    16,    17,    18,    19,    20,
2913       21,     0,     0,    23,     0,     0,   168,     0,     0,     0,
2914       24,     0,    25,    26,     0,    27,     0,    28,     0,    29,
2915        0,    30,    31,    32,     0,     0,    33,    34,     0,    35,
2916       36,     0,     0,  -155,  -155,  -155,     0,    37,    38,     0,
2917        0,   176,   177,     0,    39,     0,     0,     0,     0,     0,
2918        0,     0,     0,     0,     0,     0,   190,   191,   192,     0,
2919      193,   194,   195,     0,    40,    41,     0,     0,     0,     0,
2920        0,     0,     0,    42,     0,   201,   202,     0,   203,   204,
2921      205,   206,   207,     0,     0,     0,    43,     0,   208,     0,
2922      209,    44,    45,   210,     0,     0,    46,     0,    47,     0,
2923       48,     0,    49,     0,     0,     0,    -4,     1,     2,     3,
2924        4,     0,     5,     6,     7,     8,     9,    10,    11,    12,
2925       13,     0,     0,     0,    15,    16,    17,    18,    19,    20,
2926       21,    22,     0,    23,   128,     0,   129,     0,     0,     0,
2927       24,   130,    25,    26,     0,    27,   131,    28,     0,    29,
2928      132,    30,    31,    32,     0,     0,    33,    34,     0,    35,
2929       36,     0,     0,     0,   190,   191,   192,    37,    38,     0,
2930      133,     0,     0,     0,    39,     0,     0,     0,     0,     0,
2931        0,     0,     0,     0,     0,     0,     0,     0,   205,   206,
2932      207,     0,     0,     0,    40,    41,   208,     0,   209,     0,
2933        0,   210,     0,   134,     0,     0,     0,     0,     0,     0,
2934        0,     0,     0,     0,     0,     0,    43,     0,     0,     0,
2935        0,    44,    45,     0,     0,     0,    46,     0,    47,     0,
2936       48,     0,    49,     0,     0,     0,   135,     1,     2,     3,
2937        4,     0,     5,     6,     7,     8,     9,    10,    11,    12,
2938       13,     0,     0,     0,    15,    16,    17,    18,    19,    20,
2939       21,    22,     0,    23,   128,     0,   129,     0,     0,     0,
2940       24,   130,    25,    26,     0,    27,   131,    28,     0,    29,
2941      132,    30,    31,    32,     0,     0,    33,    34,     0,    35,
2942       36,     0,     0,     0,     0,     0,     0,    37,    38,     0,
2943      133,     0,     0,     0,    39,     0,     0,     0,     0,     0,
2944        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2945        0,     0,     0,     0,    40,    41,     0,     0,     0,     0,
2946        0,     0,     0,   134,     0,     0,     0,     0,     0,     0,
2947        0,     0,     0,     0,     0,     0,    43,     0,     0,     0,
2948        0,    44,    45,     0,     0,     0,    46,     0,    47,     0,
2949       48,     0,    49,     0,     0,     0,   248,     1,     2,     3,
2950        4,     0,     5,     6,     7,     8,     9,    10,    11,    12,
2951       13,     0,     0,     0,    15,    16,    17,    18,    19,    20,
2952       21,    22,     0,    23,   128,     0,   129,     0,     0,     0,
2953       24,   130,    25,    26,     0,    27,   131,    28,     0,    29,
2954      132,    30,    31,    32,     0,     0,    33,    34,     0,    35,
2955       36,     0,     0,     0,     0,     0,     0,    37,    38,     0,
2956      133,     0,     0,     0,    39,     0,     0,     0,     0,     0,
2957        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2958        0,     0,     0,     0,    40,    41,     0,     0,     0,     0,
2959        0,     0,     0,   134,     0,     0,     0,     0,     0,     0,
2960        0,     0,     0,     0,     0,     0,    43,     0,     0,     0,
2961        0,    44,    45,     0,     0,     0,    46,     0,    47,     0,
2962       48,     0,    49,     0,     0,     0,   387,     1,     2,     3,
2963        4,     0,     5,     6,     7,     8,     9,    10,    11,    12,
2964       13,     0,     0,    14,    15,    16,    17,    18,    19,    20,
2965       21,     0,     0,    23,     0,     0,  -155,     0,     0,     0,
2966       24,     0,    25,    26,     0,    27,     0,    28,     0,    29,
2967        0,    30,    31,    32,     0,     0,    33,    34,     0,    35,
2968       36,     0,     0,     0,     0,     0,     0,    37,    38,     0,
2969        0,  -155,  -155,     0,    39,     0,     0,     0,     0,     0,
2970        0,     0,     0,     0,     0,     0,   190,   191,   192,     0,
2971      193,   194,   195,     0,    40,    41,     0,     0,     0,     0,
2972        0,     0,     0,    42,     0,  -155,  -155,     0,   203,   204,
2973      205,   206,   207,     0,     0,     0,    43,     0,   208,     0,
2974      209,    44,    45,   210,     0,     0,    46,     0,    47,     0,
2975       48,     0,    49,     0,     0,     0,    -3,     1,     2,     3,
2976        4,     0,     5,     6,     7,     8,     9,    10,    11,    12,
2977       13,     0,     0,     0,    15,    16,    17,    18,    19,    20,
2978       21,     0,     0,    23,     0,     0,     0,     0,     0,     0,
2979       24,     0,    25,    26,     0,    27,     0,    28,     0,    29,
2980        0,    30,    31,    32,     0,     0,    33,    34,     0,    35,
2981       36,     0,     0,     0,     0,     0,     0,    37,    38,     0,
2982        0,     0,     0,     0,    39,     0,     0,     0,     0,     0,
2983        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2984        0,     0,     0,     0,    40,    41,     0,     0,     0,     0,
2985        0,     0,     0,   310,     0,     0,     0,     0,     0,     0,
2986        0,     0,     0,     0,     0,     0,    43,     0,     0,     0,
2987        0,    44,    45,     0,     0,     0,    46,     0,    47,     0,
2988       48,     0,    49,     0,     0,     0,   -15,     1,     2,     3,
2989        4,     0,     5,     6,     7,     8,     9,    10,    11,    12,
2990       13,     0,     0,     0,    15,    16,    17,    18,    19,    20,
2991       21,     0,     0,    23,     0,     0,     0,     0,     0,     0,
2992       24,     0,    25,    26,     0,    27,     0,    28,     0,    29,
2993        0,    30,    31,    32,     0,     0,    33,    34,     0,    35,
2994       36,     0,     0,     0,     0,     0,     0,    37,    38,     0,
2995        0,     0,     0,     0,    39,     0,     0,     0,     0,     0,
2996        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2997        0,     0,     0,     0,    40,    41,     0,     0,     0,     0,
2998        0,     0,     0,   310,     0,     0,     0,     0,     0,     0,
2999        0,     0,     0,     0,     0,     0,    43,     0,     0,     0,
3000        0,    44,    45,     0,     0,     0,    46,     0,    47,     0,
3001       48,     0,    49,     0,     0,     0,   -16,     1,     2,     3,
3002        4,     0,     5,     6,     7,     8,     9,    10,    11,    12,
3003       13,     0,     0,     0,    15,    16,    17,    18,    19,    20,
3004       21,     0,     0,    23,     0,     0,     0,     0,     0,     0,
3005       24,     0,    25,    26,     0,    27,     0,    28,     0,    29,
3006        0,    30,    31,    32,     0,     0,    33,    34,     0,    35,
3007       36,     0,     0,     0,     0,     0,     0,    37,    38,     0,
3008        0,     0,     0,     0,    39,     0,     0,     0,     0,     0,
3009        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3010        0,     0,     0,     0,    40,    41,     0,     0,     0,     0,
3011        0,     0,     0,   480,     0,     0,     0,     0,     0,     0,
3012        0,     0,     0,     0,     0,     0,    43,     0,     0,     0,
3013        0,    44,    45,     0,     0,     0,    46,     0,    47,     0,
3014       48,     0,    49,     0,     0,     0,  -144,     1,     2,     3,
3015        4,     0,     5,     6,     7,     8,     9,    10,    11,    12,
3016       13,     0,     0,     0,    15,    16,    17,    18,    19,    20,
3017       21,     0,     0,    23,     0,     0,     0,     0,     0,     0,
3018       24,     0,    25,    26,     0,    27,     0,    28,     0,    29,
3019        0,    30,    31,    32,     0,     0,    33,    34,     0,    35,
3020       36,     0,     0,     0,     0,     0,     0,    37,    38,     0,
3021        0,     0,     0,     0,    39,     0,     0,     0,     0,     0,
3022        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3023        0,     0,     0,     0,    40,    41,     0,     0,     0,     0,
3024        0,     0,     0,   480,     0,     0,     0,     0,     0,     0,
3025        0,     0,     0,     0,     0,     0,    43,     0,     0,     0,
3026        0,    44,    45,     0,     0,     0,    46,     0,    47,     0,
3027       48,     0,    49,     0,    -3,     0,  -145,     1,     2,     3,
3028        4,     0,     5,     6,     7,     8,     9,    10,    11,    12,
3029       13,     0,     0,    14,    15,    16,    17,    18,    19,    20,
3030       21,     0,     0,    23,     0,     0,     0,     0,     0,     0,
3031       24,     0,    25,    26,     0,    27,     0,    28,     0,    29,
3032        0,    30,    31,    32,     0,     0,    33,    34,     0,    35,
3033       36,     0,     0,     0,     0,     0,     0,    37,    38,     0,
3034        0,     0,     0,     0,    39,     0,     0,     0,     0,     0,
3035        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3036        0,     0,     0,     0,    40,    41,     0,     0,     0,     0,
3037        0,     0,     0,    42,     0,     0,     0,     0,     0,     0,
3038        0,     0,     0,     0,     0,     0,    43,     0,     0,     0,
3039        0,    44,    45,     0,     0,     0,    46,     0,    47,     0,
3040       48,     0,    49,     1,     2,     3,     4,     0,     5,     6,
3041        7,     8,     9,    10,    11,    12,    13,     0,  -120,     0,
3042       15,    16,    17,    18,    19,    20,    21,    22,     0,    23,
3043      128,     0,   129,     0,     0,     0,    24,   130,    25,    26,
3044        0,    27,   131,    28,     0,    29,   132,    30,    31,    32,
3045        0,     0,    33,    34,     0,    35,    36,     0,     0,     0,
3046        0,     0,     0,    37,    38,     0,   133,     0,     0,     0,
3047       39,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3048        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3049       40,    41,     0,     0,     0,     0,     0,     0,     0,   134,
3050        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3051        0,     0,    43,     0,     0,     0,     0,    44,    45,     0,
3052        0,     0,    46,     0,    47,     0,    48,     0,    49,     1,
3053        2,     3,     4,     0,     5,     6,     7,     8,     9,    10,
3054       11,    12,    13,     0,     0,     0,    15,    16,    17,    18,
3055       19,    20,    21,    22,     0,    23,   128,     0,   129,     0,
3056        0,     0,    24,   130,    25,    26,     0,    27,   131,    28,
3057        0,    29,   132,    30,    31,    32,     0,     0,    33,    34,
3058        0,    35,    36,     0,     0,     0,     0,     0,     0,    37,
3059       38,     0,   133,     0,     0,     0,    39,     0,     0,     0,
3060        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3061        0,     0,     0,     0,     0,     0,    40,    41,     0,     0,
3062        0,     0,     0,     0,     0,   134,     0,   150,     0,     3,
3063        4,     0,     5,     6,     7,     8,     9,     0,    43,     0,
3064        0,     0,     0,    44,    45,     0,     0,     0,    46,    20,
3065       47,    22,    48,    23,    49,     0,   129,     0,     0,     0,
3066       24,     0,     0,     0,     0,     0,     0,    28,     0,    29,
3067      151,     0,     0,     0,     0,     0,     0,    34,     0,    35,
3068       36,     0,     0,     0,     0,     0,     0,    37,     0,     0,
3069        0,     0,     0,     0,    39,     0,     0,   100,     0,     3,
3070        4,     0,     5,     6,     7,     8,     9,     0,     0,     0,
3071        0,     0,     0,     0,    40,    41,     0,     0,     0,    20,
3072        0,    22,     0,    23,     0,     0,     0,     0,     0,     0,
3073       24,     0,     0,     0,     0,     0,    43,    28,     0,    29,
3074        0,    44,    45,     0,     0,     0,    46,    34,    47,    35,
3075       36,     0,    49,     0,     0,     0,     0,    37,     0,     0,
3076        0,     0,     0,     0,    39,     0,     0,   100,     0,     3,
3077        4,     0,     5,     6,     7,     8,     9,     0,     0,     0,
3078        0,     0,     0,     0,    40,    41,     0,     0,     0,    20,
3079        0,    22,     0,    23,     0,     0,     0,     0,     0,     0,
3080        0,     0,     0,     0,     0,     0,    43,     0,     0,    29,
3081        0,    44,    45,     0,     0,     0,    46,    34,    47,    35,
3082       36,     0,    49,     0,     0,     0,     0,     0,     0,   168,
3083        0,     0,     0,     0,    39,     0,     0,     0,     0,     0,
3084        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3085        0,     0,     0,     0,    40,    41,   169,   170,   171,     0,
3086      172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
3087      182,   183,   184,   185,   186,   187,   188,   189,     0,   190,
3088      191,   192,     0,   193,   194,   195,    46,     0,    47,     0,
3089        0,   196,    49,   197,     0,   198,   199,   200,   201,   202,
3090      168,   203,   204,   205,   206,   207,     0,     0,     0,     0,
3091        0,   208,     0,   209,     0,     0,   210,     0,     0,     0,
3092        0,     0,   333,     0,     0,     0,     0,   169,   170,   171,
3093        0,   172,   173,   174,   175,   176,   177,   178,   179,   180,
3094      181,   182,   183,   184,   185,   186,   187,   188,   189,     0,
3095      190,   191,   192,     0,   193,   194,   195,     0,     0,     0,
3096        0,     0,   196,   168,   197,     0,   198,   199,   200,   201,
3097      202,     0,   203,   204,   205,   206,   207,     0,     0,     0,
3098        0,     0,   208,     0,   209,     0,     0,   210,     0,     0,
3099      169,   170,   171,   365,   172,   173,   174,   175,   176,   177,
3100      178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
3101      188,   189,     0,   190,   191,   192,     0,   193,   194,   195,
3102        0,     0,     0,     0,     0,   196,   168,   197,     0,   198,
3103      199,   200,   201,   202,     0,   203,   204,   205,   206,   207,
3104        0,     0,     0,     0,     0,   208,     0,   209,     0,     0,
3105      210,     0,     0,   169,   170,   171,   403,   172,   173,   174,
3106      175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
3107      185,   186,   187,   188,   189,     0,   190,   191,   192,     0,
3108      193,   194,   195,     0,     0,     0,     0,   168,   196,     0,
3109      197,   357,   198,   199,   200,   201,   202,     0,   203,   204,
3110      205,   206,   207,     0,     0,     0,     0,     0,   208,     0,
3111      209,     0,     0,   210,   169,   170,   171,     0,   172,   173,
3112      174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
3113      184,   185,   186,   187,   188,   189,     0,   190,   191,   192,
3114        0,   193,   194,   195,     0,     0,     0,     0,   168,   196,
3115        0,   197,     0,   198,   199,   200,   201,   202,     0,   203,
3116      204,   205,   206,   207,     0,     0,     0,     0,     0,   208,
3117        0,   209,   359,     0,   210,   169,   170,   171,     0,   172,
3118      173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
3119      183,   184,   185,   186,   187,   188,   189,     0,   190,   191,
3120      192,     0,   193,   194,   195,     0,     0,     0,     0,   168,
3121      196,     0,   197,   493,   198,   199,   200,   201,   202,     0,
3122      203,   204,   205,   206,   207,     0,     0,     0,     0,     0,
3123      208,     0,   209,     0,     0,   210,   169,   170,   171,     0,
3124      172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
3125      182,   183,   184,   185,   186,   187,   188,   189,     0,   190,
3126      191,   192,     0,   193,   194,   195,     0,     0,     0,     0,
3127      168,   196,     0,   197,     0,   198,   199,   200,   201,   202,
3128        0,   203,   204,   205,   206,   207,     0,     0,     0,     0,
3129        0,   208,     0,   209,     0,     0,   210,   169,   170,   171,
3130        0,   172,   173,   174,   175,   176,   177,     0,     0,     0,
3131        0,     0,     0,     0,     0,     0,     0,     0,   189,     0,
3132      190,   191,   192,     0,   193,   194,   195,     0,     0,     0,
3133        0,   168,     0,     0,     0,     0,   198,   199,   200,   201,
3134      202,     0,   203,   204,   205,   206,   207,     0,     0,     0,
3135        0,     0,   208,     0,   209,     0,     0,   210,   169,   170,
3136      171,     0,   172,   173,   174,   175,   176,   177,     0,     0,
3137        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3138        0,   190,   191,   192,     0,   193,   194,   195,     0,     0,
3139        0,     0,   168,     0,     0,     0,     0,   198,   199,   200,
3140      201,   202,     0,   203,   204,   205,   206,   207,     0,     0,
3141        0,     0,     0,   208,     0,   209,     0,     0,   210,   169,
3142      170,   171,     0,   172,   173,   174,   175,   176,   177,     0,
3143        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3144        0,     0,   190,   191,   192,     0,   193,   194,   195,     0,
3145        0,     0,     0,   168,     0,     0,     0,     0,     0,   199,
3146      200,   201,   202,     0,   203,   204,   205,   206,   207,     0,
3147        0,     0,     0,     0,   208,     0,   209,     0,     0,   210,
3148      169,   170,   171,     0,   172,   173,   174,   175,   176,   177,
3149        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3150        0,     0,     0,   190,   191,   192,     0,   193,   194,   195,
3151        0,     0,     0,     0,   168,     0,     0,     0,     0,     0,
3152        0,   200,   201,   202,     0,   203,   204,   205,   206,   207,
3153        0,     0,     0,     0,     0,   208,     0,   209,     0,     0,
3154      210,   169,   170,   171,     0,   172,   173,   174,   175,   176,
3155      177,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3156        0,     0,     0,     0,   190,   191,   192,     0,   193,   194,
3157      195,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3158        0,     0,  -155,   201,   202,     0,   203,   204,   205,   206,
3159      207,     0,     0,     0,     0,     0,   208,     0,   209,     0,
3160        0,   210
3161 };
3162
3163 static const yytype_int16 yycheck[] =
3164 {
3165        0,     0,     0,     0,     0,    39,    91,    20,    99,    58,
3166       65,    24,   110,   252,     3,   326,   392,    48,     3,    89,
3167       14,   320,     3,     4,    37,    92,    39,    40,    41,     3,
3168       43,    44,    45,    27,    47,    50,    91,    46,    19,   126,
3169      127,    68,    90,    91,    92,     3,     4,    35,     0,     0,
3170      122,     0,    52,    52,    52,    52,    52,   124,    34,   102,
3171      127,    19,   105,    51,    14,   376,     3,     4,   470,   368,
3172      122,   100,   474,   475,   122,   102,   124,    27,     3,   127,
3173        5,   136,    19,     8,     9,    10,    62,    12,    99,   100,
3174      100,   493,   126,     3,     4,   108,   105,   110,    18,    36,
3175       52,    52,     3,    52,   133,   507,   122,   122,    93,    19,
3176      208,   422,   514,   126,   100,   354,     3,   122,     5,    93,
3177       45,   130,   131,   133,    28,   126,     3,   122,     0,    33,
3178       55,    56,   127,   122,   126,   122,   375,   513,   100,   128,
3179        3,     3,   122,   122,   100,   126,   100,   133,   105,   149,
3180      149,   149,   149,   149,   167,   168,   169,   170,   171,   172,
3181      173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
3182      183,   184,   185,   186,   187,   188,   189,   133,   115,   133,
3183      193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
3184      203,   204,   205,   206,   207,   208,   209,   149,   149,   233,
3185      149,   235,   215,   100,   213,   115,   127,   100,   132,   125,
3186      100,   126,     4,     3,     3,     3,   216,   216,   216,   250,
3187      233,   460,   235,   232,   218,   323,    68,    18,    20,    21,
3188       22,     4,    24,   227,    26,     3,   133,   476,    99,    68,
3189       99,     3,     3,    14,   253,   254,    38,    20,    21,    22,
3190        3,    24,     3,    26,    46,    47,    48,    49,    18,   350,
3191      127,   352,   127,   133,   122,    38,   105,    27,    18,   100,
3192      102,    31,    32,    46,    47,    48,    49,    27,   363,   518,
3193      335,   132,    32,     3,    44,    54,    46,    54,   343,     3,
3194      133,    89,   305,   378,     3,   122,    46,   132,   126,     3,
3195      133,   100,   127,   394,   389,   105,   132,    99,   363,   102,
3196      323,   122,   312,   312,   312,    17,   126,   100,     3,   126,
3197      320,   320,   320,   378,   132,   126,    99,   133,   322,   132,
3198      100,   126,   126,    65,   389,   122,   102,   133,     3,   388,
3199      132,   105,     3,    27,   357,   379,   132,   438,   133,   126,
3200      384,   132,   126,   132,   132,   364,   132,     3,   133,   132,
3201      132,   126,    40,   122,    52,     4,   379,   149,   368,   368,
3202      368,   384,   457,   312,   459,   132,   399,   133,   132,    58,
3203      129,    20,    21,    22,   446,    24,   446,    26,   428,    67,
3204       68,    69,   428,    71,    72,    73,    74,    75,    76,    38,
3205      342,    70,   457,   499,   459,   485,   467,   400,    47,    48,
3206       49,   490,    90,    91,    92,    27,    94,    95,    96,   394,
3207       -1,    -1,    -1,    -1,   372,    -1,    -1,    -1,    -1,   420,
3208      443,   109,   110,    -1,   112,   113,   114,   115,   116,   439,
3209       -1,    -1,    -1,    -1,   122,    -1,   124,    -1,    -1,   127,
3210       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    91,
3211       92,   461,   461,   461,   461,   461,    -1,   467,    -1,    -1,
3212       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3213      112,   113,   114,   115,   116,   485,   485,   485,   485,   485,
3214      122,    -1,   124,    -1,    -1,   127,    -1,    -1,    -1,   499,
3215      499,   499,   499,   499,     0,    -1,    -1,     3,     4,     5,
3216        6,    -1,     8,     9,    10,    11,    12,    13,    14,    15,
3217       16,    -1,    -1,    19,    20,    21,    22,    23,    24,    25,
3218       26,    -1,    -1,    29,    -1,    -1,    40,    -1,    -1,    -1,
3219       36,    -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,
3220       -1,    47,    48,    49,    -1,    -1,    52,    53,    -1,    55,
3221       56,    -1,    -1,    67,    68,    69,    -1,    63,    64,    -1,
3222       -1,    75,    76,    -1,    70,    -1,    -1,    -1,    -1,    -1,
3223       -1,    -1,    -1,    -1,    -1,    -1,    90,    91,    92,    -1,
3224       94,    95,    96,    -1,    90,    91,    -1,    -1,    -1,    -1,
3225       -1,    -1,    -1,    99,    -1,   109,   110,    -1,   112,   113,
3226      114,   115,   116,    -1,    -1,    -1,   112,    -1,   122,    -1,
3227      124,   117,   118,   127,    -1,    -1,   122,    -1,   124,    -1,
3228      126,    -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,
3229        6,    -1,     8,     9,    10,    11,    12,    13,    14,    15,
3230       16,    -1,    -1,    -1,    20,    21,    22,    23,    24,    25,
3231       26,    27,    -1,    29,    30,    -1,    32,    -1,    -1,    -1,
3232       36,    37,    38,    39,    -1,    41,    42,    43,    -1,    45,
3233       46,    47,    48,    49,    -1,    -1,    52,    53,    -1,    55,
3234       56,    -1,    -1,    -1,    90,    91,    92,    63,    64,    -1,
3235       66,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,
3236       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   114,   115,
3237      116,    -1,    -1,    -1,    90,    91,   122,    -1,   124,    -1,
3238       -1,   127,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,
3239       -1,    -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,
3240       -1,   117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,
3241      126,    -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,
3242        6,    -1,     8,     9,    10,    11,    12,    13,    14,    15,
3243       16,    -1,    -1,    -1,    20,    21,    22,    23,    24,    25,
3244       26,    27,    -1,    29,    30,    -1,    32,    -1,    -1,    -1,
3245       36,    37,    38,    39,    -1,    41,    42,    43,    -1,    45,
3246       46,    47,    48,    49,    -1,    -1,    52,    53,    -1,    55,
3247       56,    -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,
3248       66,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,
3249       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3250       -1,    -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,
3251       -1,    -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,
3252       -1,    -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,
3253       -1,   117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,
3254      126,    -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,
3255        6,    -1,     8,     9,    10,    11,    12,    13,    14,    15,
3256       16,    -1,    -1,    -1,    20,    21,    22,    23,    24,    25,
3257       26,    27,    -1,    29,    30,    -1,    32,    -1,    -1,    -1,
3258       36,    37,    38,    39,    -1,    41,    42,    43,    -1,    45,
3259       46,    47,    48,    49,    -1,    -1,    52,    53,    -1,    55,
3260       56,    -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,
3261       66,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,
3262       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3263       -1,    -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,
3264       -1,    -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,
3265       -1,    -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,
3266       -1,   117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,
3267      126,    -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,
3268        6,    -1,     8,     9,    10,    11,    12,    13,    14,    15,
3269       16,    -1,    -1,    19,    20,    21,    22,    23,    24,    25,
3270       26,    -1,    -1,    29,    -1,    -1,    40,    -1,    -1,    -1,
3271       36,    -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,
3272       -1,    47,    48,    49,    -1,    -1,    52,    53,    -1,    55,
3273       56,    -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,
3274       -1,    75,    76,    -1,    70,    -1,    -1,    -1,    -1,    -1,
3275       -1,    -1,    -1,    -1,    -1,    -1,    90,    91,    92,    -1,
3276       94,    95,    96,    -1,    90,    91,    -1,    -1,    -1,    -1,
3277       -1,    -1,    -1,    99,    -1,   109,   110,    -1,   112,   113,
3278      114,   115,   116,    -1,    -1,    -1,   112,    -1,   122,    -1,
3279      124,   117,   118,   127,    -1,    -1,   122,    -1,   124,    -1,
3280      126,    -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,
3281        6,    -1,     8,     9,    10,    11,    12,    13,    14,    15,
3282       16,    -1,    -1,    -1,    20,    21,    22,    23,    24,    25,
3283       26,    -1,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,
3284       36,    -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,
3285       -1,    47,    48,    49,    -1,    -1,    52,    53,    -1,    55,
3286       56,    -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,
3287       -1,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,
3288       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3289       -1,    -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,
3290       -1,    -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,
3291       -1,    -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,
3292       -1,   117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,
3293      126,    -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,
3294        6,    -1,     8,     9,    10,    11,    12,    13,    14,    15,
3295       16,    -1,    -1,    -1,    20,    21,    22,    23,    24,    25,
3296       26,    -1,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,
3297       36,    -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,
3298       -1,    47,    48,    49,    -1,    -1,    52,    53,    -1,    55,
3299       56,    -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,
3300       -1,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,
3301       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3302       -1,    -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,
3303       -1,    -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,
3304       -1,    -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,
3305       -1,   117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,
3306      126,    -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,
3307        6,    -1,     8,     9,    10,    11,    12,    13,    14,    15,
3308       16,    -1,    -1,    -1,    20,    21,    22,    23,    24,    25,
3309       26,    -1,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,
3310       36,    -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,
3311       -1,    47,    48,    49,    -1,    -1,    52,    53,    -1,    55,
3312       56,    -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,
3313       -1,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,
3314       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3315       -1,    -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,
3316       -1,    -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,
3317       -1,    -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,
3318       -1,   117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,
3319      126,    -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,
3320        6,    -1,     8,     9,    10,    11,    12,    13,    14,    15,
3321       16,    -1,    -1,    -1,    20,    21,    22,    23,    24,    25,
3322       26,    -1,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,
3323       36,    -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,
3324       -1,    47,    48,    49,    -1,    -1,    52,    53,    -1,    55,
3325       56,    -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,
3326       -1,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,
3327       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3328       -1,    -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,
3329       -1,    -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,
3330       -1,    -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,
3331       -1,   117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,
3332      126,    -1,   128,    -1,     0,    -1,   132,     3,     4,     5,
3333        6,    -1,     8,     9,    10,    11,    12,    13,    14,    15,
3334       16,    -1,    -1,    19,    20,    21,    22,    23,    24,    25,
3335       26,    -1,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,
3336       36,    -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,
3337       -1,    47,    48,    49,    -1,    -1,    52,    53,    -1,    55,
3338       56,    -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,
3339       -1,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,
3340       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3341       -1,    -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,
3342       -1,    -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,
3343       -1,    -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,
3344       -1,   117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,
3345      126,    -1,   128,     3,     4,     5,     6,    -1,     8,     9,
3346       10,    11,    12,    13,    14,    15,    16,    -1,    18,    -1,
3347       20,    21,    22,    23,    24,    25,    26,    27,    -1,    29,
3348       30,    -1,    32,    -1,    -1,    -1,    36,    37,    38,    39,
3349       -1,    41,    42,    43,    -1,    45,    46,    47,    48,    49,
3350       -1,    -1,    52,    53,    -1,    55,    56,    -1,    -1,    -1,
3351       -1,    -1,    -1,    63,    64,    -1,    66,    -1,    -1,    -1,
3352       70,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3353       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3354       90,    91,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,
3355       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3356       -1,    -1,   112,    -1,    -1,    -1,    -1,   117,   118,    -1,
3357       -1,    -1,   122,    -1,   124,    -1,   126,    -1,   128,     3,
3358        4,     5,     6,    -1,     8,     9,    10,    11,    12,    13,
3359       14,    15,    16,    -1,    -1,    -1,    20,    21,    22,    23,
3360       24,    25,    26,    27,    -1,    29,    30,    -1,    32,    -1,
3361       -1,    -1,    36,    37,    38,    39,    -1,    41,    42,    43,
3362       -1,    45,    46,    47,    48,    49,    -1,    -1,    52,    53,
3363       -1,    55,    56,    -1,    -1,    -1,    -1,    -1,    -1,    63,
3364       64,    -1,    66,    -1,    -1,    -1,    70,    -1,    -1,    -1,
3365       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3366       -1,    -1,    -1,    -1,    -1,    -1,    90,    91,    -1,    -1,
3367       -1,    -1,    -1,    -1,    -1,    99,    -1,     3,    -1,     5,
3368        6,    -1,     8,     9,    10,    11,    12,    -1,   112,    -1,
3369       -1,    -1,    -1,   117,   118,    -1,    -1,    -1,   122,    25,
3370      124,    27,   126,    29,   128,    -1,    32,    -1,    -1,    -1,
3371       36,    -1,    -1,    -1,    -1,    -1,    -1,    43,    -1,    45,
3372       46,    -1,    -1,    -1,    -1,    -1,    -1,    53,    -1,    55,
3373       56,    -1,    -1,    -1,    -1,    -1,    -1,    63,    -1,    -1,
3374       -1,    -1,    -1,    -1,    70,    -1,    -1,     3,    -1,     5,
3375        6,    -1,     8,     9,    10,    11,    12,    -1,    -1,    -1,
3376       -1,    -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    25,
3377       -1,    27,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,
3378       36,    -1,    -1,    -1,    -1,    -1,   112,    43,    -1,    45,
3379       -1,   117,   118,    -1,    -1,    -1,   122,    53,   124,    55,
3380       56,    -1,   128,    -1,    -1,    -1,    -1,    63,    -1,    -1,
3381       -1,    -1,    -1,    -1,    70,    -1,    -1,     3,    -1,     5,
3382        6,    -1,     8,     9,    10,    11,    12,    -1,    -1,    -1,
3383       -1,    -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    25,
3384       -1,    27,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,
3385       -1,    -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    45,
3386       -1,   117,   118,    -1,    -1,    -1,   122,    53,   124,    55,
3387       56,    -1,   128,    -1,    -1,    -1,    -1,    -1,    -1,    40,
3388       -1,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,
3389       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3390       -1,    -1,    -1,    -1,    90,    91,    67,    68,    69,    -1,
3391       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
3392       81,    82,    83,    84,    85,    86,    87,    88,    -1,    90,
3393       91,    92,    -1,    94,    95,    96,   122,    -1,   124,    -1,
3394       -1,   102,   128,   104,    -1,   106,   107,   108,   109,   110,
3395       40,   112,   113,   114,   115,   116,    -1,    -1,    -1,    -1,
3396       -1,   122,    -1,   124,    -1,    -1,   127,    -1,    -1,    -1,
3397       -1,    -1,   133,    -1,    -1,    -1,    -1,    67,    68,    69,
3398       -1,    71,    72,    73,    74,    75,    76,    77,    78,    79,
3399       80,    81,    82,    83,    84,    85,    86,    87,    88,    -1,
3400       90,    91,    92,    -1,    94,    95,    96,    -1,    -1,    -1,
3401       -1,    -1,   102,    40,   104,    -1,   106,   107,   108,   109,
3402      110,    -1,   112,   113,   114,   115,   116,    -1,    -1,    -1,
3403       -1,    -1,   122,    -1,   124,    -1,    -1,   127,    -1,    -1,
3404       67,    68,    69,   133,    71,    72,    73,    74,    75,    76,
3405       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
3406       87,    88,    -1,    90,    91,    92,    -1,    94,    95,    96,
3407       -1,    -1,    -1,    -1,    -1,   102,    40,   104,    -1,   106,
3408      107,   108,   109,   110,    -1,   112,   113,   114,   115,   116,
3409       -1,    -1,    -1,    -1,    -1,   122,    -1,   124,    -1,    -1,
3410      127,    -1,    -1,    67,    68,    69,   133,    71,    72,    73,
3411       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
3412       84,    85,    86,    87,    88,    -1,    90,    91,    92,    -1,
3413       94,    95,    96,    -1,    -1,    -1,    -1,    40,   102,    -1,
3414      104,   105,   106,   107,   108,   109,   110,    -1,   112,   113,
3415      114,   115,   116,    -1,    -1,    -1,    -1,    -1,   122,    -1,
3416      124,    -1,    -1,   127,    67,    68,    69,    -1,    71,    72,
3417       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3418       83,    84,    85,    86,    87,    88,    -1,    90,    91,    92,
3419       -1,    94,    95,    96,    -1,    -1,    -1,    -1,    40,   102,
3420       -1,   104,    -1,   106,   107,   108,   109,   110,    -1,   112,
3421      113,   114,   115,   116,    -1,    -1,    -1,    -1,    -1,   122,
3422       -1,   124,   125,    -1,   127,    67,    68,    69,    -1,    71,
3423       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
3424       82,    83,    84,    85,    86,    87,    88,    -1,    90,    91,
3425       92,    -1,    94,    95,    96,    -1,    -1,    -1,    -1,    40,
3426      102,    -1,   104,   105,   106,   107,   108,   109,   110,    -1,
3427      112,   113,   114,   115,   116,    -1,    -1,    -1,    -1,    -1,
3428      122,    -1,   124,    -1,    -1,   127,    67,    68,    69,    -1,
3429       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
3430       81,    82,    83,    84,    85,    86,    87,    88,    -1,    90,
3431       91,    92,    -1,    94,    95,    96,    -1,    -1,    -1,    -1,
3432       40,   102,    -1,   104,    -1,   106,   107,   108,   109,   110,
3433       -1,   112,   113,   114,   115,   116,    -1,    -1,    -1,    -1,
3434       -1,   122,    -1,   124,    -1,    -1,   127,    67,    68,    69,
3435       -1,    71,    72,    73,    74,    75,    76,    -1,    -1,    -1,
3436       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,
3437       90,    91,    92,    -1,    94,    95,    96,    -1,    -1,    -1,
3438       -1,    40,    -1,    -1,    -1,    -1,   106,   107,   108,   109,
3439      110,    -1,   112,   113,   114,   115,   116,    -1,    -1,    -1,
3440       -1,    -1,   122,    -1,   124,    -1,    -1,   127,    67,    68,
3441       69,    -1,    71,    72,    73,    74,    75,    76,    -1,    -1,
3442       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3443       -1,    90,    91,    92,    -1,    94,    95,    96,    -1,    -1,
3444       -1,    -1,    40,    -1,    -1,    -1,    -1,   106,   107,   108,
3445      109,   110,    -1,   112,   113,   114,   115,   116,    -1,    -1,
3446       -1,    -1,    -1,   122,    -1,   124,    -1,    -1,   127,    67,
3447       68,    69,    -1,    71,    72,    73,    74,    75,    76,    -1,
3448       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3449       -1,    -1,    90,    91,    92,    -1,    94,    95,    96,    -1,
3450       -1,    -1,    -1,    40,    -1,    -1,    -1,    -1,    -1,   107,
3451      108,   109,   110,    -1,   112,   113,   114,   115,   116,    -1,
3452       -1,    -1,    -1,    -1,   122,    -1,   124,    -1,    -1,   127,
3453       67,    68,    69,    -1,    71,    72,    73,    74,    75,    76,
3454       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3455       -1,    -1,    -1,    90,    91,    92,    -1,    94,    95,    96,
3456       -1,    -1,    -1,    -1,    40,    -1,    -1,    -1,    -1,    -1,
3457       -1,   108,   109,   110,    -1,   112,   113,   114,   115,   116,
3458       -1,    -1,    -1,    -1,    -1,   122,    -1,   124,    -1,    -1,
3459      127,    67,    68,    69,    -1,    71,    72,    73,    74,    75,
3460       76,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3461       -1,    -1,    -1,    -1,    90,    91,    92,    -1,    94,    95,
3462       96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3463       -1,    -1,   108,   109,   110,    -1,   112,   113,   114,   115,
3464      116,    -1,    -1,    -1,    -1,    -1,   122,    -1,   124,    -1,
3465       -1,   127
3466 };
3467
3468 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
3469    symbol of state STATE-NUM.  */
3470 static const yytype_uint8 yystos[] =
3471 {
3472        0,     3,     4,     5,     6,     8,     9,    10,    11,    12,
3473       13,    14,    15,    16,    19,    20,    21,    22,    23,    24,
3474       25,    26,    27,    29,    36,    38,    39,    41,    43,    45,
3475       47,    48,    49,    52,    53,    55,    56,    63,    64,    70,
3476       90,    91,    99,   112,   117,   118,   122,   124,   126,   128,
3477      135,   136,   137,   138,   144,   147,   148,   154,   158,   159,
3478      160,   161,   163,   171,   179,   182,   183,   186,   189,   190,
3479      191,   192,   196,   198,   207,   217,   220,   233,   234,   235,
3480      238,   239,   240,   241,   244,   246,   247,    89,    50,   122,
3481      122,   164,   122,     3,     4,    19,   126,   184,   185,    18,
3482        3,   240,     3,   219,   240,   122,   185,   223,   122,   126,
3483      122,   127,   240,   122,   237,   240,   242,   243,   240,   240,
3484      240,   240,   240,   238,   229,   230,   231,   237,    30,    32,
3485       37,    42,    46,    66,    99,   132,   143,   144,   145,   148,
3486      150,   165,   166,   181,   190,   236,     3,     0,   138,   126,
3487        3,    46,   150,   156,   157,   239,   145,   146,    18,    27,
3488       31,    32,    44,    46,   206,   245,   192,   100,    40,    67,
3489       68,    69,    71,    72,    73,    74,    75,    76,    77,    78,
3490       79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
3491       90,    91,    92,    94,    95,    96,   102,   104,   106,   107,
3492      108,   109,   110,   112,   113,   114,   115,   116,   122,   124,
3493      127,     3,   122,   162,   146,   172,   188,   126,   127,   184,
3494      185,   222,   223,   224,   232,   122,   238,   127,   240,   180,
3495      229,     3,   155,   105,   132,   100,   133,   125,   100,   237,
3496        3,     3,   151,   152,   238,   238,   151,     3,   132,   145,
3497      126,   136,     3,    99,    68,    99,     3,    35,    51,   216,
3498        3,     3,   208,   240,   240,   240,   240,   240,   240,   240,
3499      240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
3500      240,   240,   240,   240,   240,   240,     3,   240,   240,   240,
3501      240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
3502      240,   240,   229,   240,     3,   122,   128,   238,    14,   240,
3503       99,   139,   140,   141,   147,   148,   196,   198,   207,   217,
3504      187,   184,   127,   122,   228,     3,    93,   213,   214,   215,
3505      133,   115,   184,   133,   142,   143,   133,   238,   237,   237,
3506      105,   227,   100,   143,   132,   227,   238,   238,   102,     3,
3507       54,   193,    54,   194,     3,   209,   210,   105,   133,   125,
3508       89,   240,     3,   133,   122,   133,   132,   141,   126,   139,
3509      229,   102,   105,   211,   215,   133,   100,   132,   133,   105,
3510       36,   115,   224,   226,   102,   149,   152,   132,    99,   133,
3511        3,     5,   122,   224,    17,   195,   224,   225,   126,   227,
3512      100,   240,     3,   133,   146,   238,   126,   139,   132,   133,
3513        3,     5,     8,     9,    10,    12,    45,    55,    56,   212,
3514      226,   227,    93,   215,    28,    33,   173,   175,   177,   178,
3515      146,   237,   237,   239,   146,   213,   225,   126,   100,   199,
3516      149,   210,   133,    34,    62,   167,   168,   169,   170,   132,
3517      211,   126,   215,   126,   122,   173,   175,    65,   153,   133,
3518      133,   197,   224,    46,    99,   190,   203,   204,   205,   240,
3519      105,   132,   169,   170,   221,   176,     3,   146,   146,   227,
3520       99,   144,   148,   190,   200,   201,   202,   207,   217,     3,
3521       27,   132,   205,   105,   142,   142,   142,   227,   126,   126,
3522      132,   202,   216,   142,   132,   132,   133,   218,   200,     3,
3523      174,   142,   132,   122,   126,   132,   213,   142,   133,   132,
3524      227
3525 };
3526
3527 #define yyerrok         (yyerrstatus = 0)
3528 #define yyclearin       (yychar = YYEMPTY)
3529 #define YYEMPTY         (-2)
3530 #define YYEOF           0
3531
3532 #define YYACCEPT        goto yyacceptlab
3533 #define YYABORT         goto yyabortlab
3534 #define YYERROR         goto yyerrorlab
3535
3536
3537 /* Like YYERROR except do call yyerror.  This remains here temporarily
3538    to ease the transition to the new meaning of YYERROR, for GCC.
3539    Once GCC version 2 has supplanted version 1, this can go.  */
3540
3541 #define YYFAIL          goto yyerrlab
3542
3543 #define YYRECOVERING()  (!!yyerrstatus)
3544
3545 #define YYBACKUP(Token, Value)                                  \
3546 do                                                              \
3547   if (yychar == YYEMPTY && yylen == 1)                          \
3548     {                                                           \
3549       yychar = (Token);                                         \
3550       yylval = (Value);                                         \
3551       yytoken = YYTRANSLATE (yychar);                           \
3552       YYPOPSTACK (1);                                           \
3553       goto yybackup;                                            \
3554     }                                                           \
3555   else                                                          \
3556     {                                                           \
3557       yyerror (YY_("syntax error: cannot back up")); \
3558       YYERROR;                                                  \
3559     }                                                           \
3560 while (YYID (0))
3561
3562
3563 #define YYTERROR        1
3564 #define YYERRCODE       256
3565
3566
3567 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
3568    If N is 0, then set CURRENT to the empty location which ends
3569    the previous symbol: RHS[0] (always defined).  */
3570
3571 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
3572 #ifndef YYLLOC_DEFAULT
3573 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
3574     do                                                                  \
3575       if (YYID (N))                                                    \
3576         {                                                               \
3577           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
3578           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
3579           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
3580           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
3581         }                                                               \
3582       else                                                              \
3583         {                                                               \
3584           (Current).first_line   = (Current).last_line   =              \
3585             YYRHSLOC (Rhs, 0).last_line;                                \
3586           (Current).first_column = (Current).last_column =              \
3587             YYRHSLOC (Rhs, 0).last_column;                              \
3588         }                                                               \
3589     while (YYID (0))
3590 #endif
3591
3592
3593 /* YY_LOCATION_PRINT -- Print the location on the stream.
3594    This macro was not mandated originally: define only if we know
3595    we won't break user code: when these are the locations we know.  */
3596
3597 #ifndef YY_LOCATION_PRINT
3598 # if YYLTYPE_IS_TRIVIAL
3599 #  define YY_LOCATION_PRINT(File, Loc)                  \
3600      fprintf (File, "%d.%d-%d.%d",                      \
3601               (Loc).first_line, (Loc).first_column,     \
3602               (Loc).last_line,  (Loc).last_column)
3603 # else
3604 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
3605 # endif
3606 #endif
3607
3608
3609 /* YYLEX -- calling `yylex' with the right arguments.  */
3610
3611 #ifdef YYLEX_PARAM
3612 # define YYLEX yylex (YYLEX_PARAM)
3613 #else
3614 # define YYLEX yylex ()
3615 #endif
3616
3617 /* Enable debugging if requested.  */
3618 #if YYDEBUG
3619
3620 # ifndef YYFPRINTF
3621 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
3622 #  define YYFPRINTF fprintf
3623 # endif
3624
3625 # define YYDPRINTF(Args)                        \
3626 do {                                            \
3627   if (yydebug)                                  \
3628     YYFPRINTF Args;                             \
3629 } while (YYID (0))
3630
3631 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
3632 do {                                                                      \
3633   if (yydebug)                                                            \
3634     {                                                                     \
3635       YYFPRINTF (stderr, "%s ", Title);                                   \
3636       yy_symbol_print (stderr,                                            \
3637                   Type, Value); \
3638       YYFPRINTF (stderr, "\n");                                           \
3639     }                                                                     \
3640 } while (YYID (0))
3641
3642
3643 /*--------------------------------.
3644 | Print this symbol on YYOUTPUT.  |
3645 `--------------------------------*/
3646
3647 /*ARGSUSED*/
3648 #if (defined __STDC__ || defined __C99__FUNC__ \
3649      || defined __cplusplus || defined _MSC_VER)
3650 static void
3651 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
3652 #else
3653 static void
3654 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
3655     FILE *yyoutput;
3656     int yytype;
3657     YYSTYPE const * const yyvaluep;
3658 #endif
3659 {
3660   if (!yyvaluep)
3661     return;
3662 # ifdef YYPRINT
3663   if (yytype < YYNTOKENS)
3664     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
3665 # else
3666   YYUSE (yyoutput);
3667 # endif
3668   switch (yytype)
3669     {
3670       default:
3671         break;
3672     }
3673 }
3674
3675
3676 /*--------------------------------.
3677 | Print this symbol on YYOUTPUT.  |
3678 `--------------------------------*/
3679
3680 #if (defined __STDC__ || defined __C99__FUNC__ \
3681      || defined __cplusplus || defined _MSC_VER)
3682 static void
3683 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
3684 #else
3685 static void
3686 yy_symbol_print (yyoutput, yytype, yyvaluep)
3687     FILE *yyoutput;
3688     int yytype;
3689     YYSTYPE const * const yyvaluep;
3690 #endif
3691 {
3692   if (yytype < YYNTOKENS)
3693     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
3694   else
3695     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
3696
3697   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
3698   YYFPRINTF (yyoutput, ")");
3699 }
3700
3701 /*------------------------------------------------------------------.
3702 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
3703 | TOP (included).                                                   |
3704 `------------------------------------------------------------------*/
3705
3706 #if (defined __STDC__ || defined __C99__FUNC__ \
3707      || defined __cplusplus || defined _MSC_VER)
3708 static void
3709 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
3710 #else
3711 static void
3712 yy_stack_print (yybottom, yytop)
3713     yytype_int16 *yybottom;
3714     yytype_int16 *yytop;
3715 #endif
3716 {
3717   YYFPRINTF (stderr, "Stack now");
3718   for (; yybottom <= yytop; yybottom++)
3719     {
3720       int yybot = *yybottom;
3721       YYFPRINTF (stderr, " %d", yybot);
3722     }
3723   YYFPRINTF (stderr, "\n");
3724 }
3725
3726 # define YY_STACK_PRINT(Bottom, Top)                            \
3727 do {                                                            \
3728   if (yydebug)                                                  \
3729     yy_stack_print ((Bottom), (Top));                           \
3730 } while (YYID (0))
3731
3732
3733 /*------------------------------------------------.
3734 | Report that the YYRULE is going to be reduced.  |
3735 `------------------------------------------------*/
3736
3737 #if (defined __STDC__ || defined __C99__FUNC__ \
3738      || defined __cplusplus || defined _MSC_VER)
3739 static void
3740 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
3741 #else
3742 static void
3743 yy_reduce_print (yyvsp, yyrule)
3744     YYSTYPE *yyvsp;
3745     int yyrule;
3746 #endif
3747 {
3748   int yynrhs = yyr2[yyrule];
3749   int yyi;
3750   unsigned long int yylno = yyrline[yyrule];
3751   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
3752              yyrule - 1, yylno);
3753   /* The symbols being reduced.  */
3754   for (yyi = 0; yyi < yynrhs; yyi++)
3755     {
3756       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
3757       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
3758                        &(yyvsp[(yyi + 1) - (yynrhs)])
3759                                        );
3760       YYFPRINTF (stderr, "\n");
3761     }
3762 }
3763
3764 # define YY_REDUCE_PRINT(Rule)          \
3765 do {                                    \
3766   if (yydebug)                          \
3767     yy_reduce_print (yyvsp, Rule); \
3768 } while (YYID (0))
3769
3770 /* Nonzero means print parse trace.  It is left uninitialized so that
3771    multiple parsers can coexist.  */
3772 int yydebug;
3773 #else /* !YYDEBUG */
3774 # define YYDPRINTF(Args)
3775 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
3776 # define YY_STACK_PRINT(Bottom, Top)
3777 # define YY_REDUCE_PRINT(Rule)
3778 #endif /* !YYDEBUG */
3779
3780
3781 /* YYINITDEPTH -- initial size of the parser's stacks.  */
3782 #ifndef YYINITDEPTH
3783 # define YYINITDEPTH 200
3784 #endif
3785
3786 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
3787    if the built-in stack extension method is used).
3788
3789    Do not make this value too large; the results are undefined if
3790    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
3791    evaluated with infinite-precision integer arithmetic.  */
3792
3793 #ifndef YYMAXDEPTH
3794 # define YYMAXDEPTH 10000
3795 #endif
3796
3797 \f
3798
3799 #if YYERROR_VERBOSE
3800
3801 # ifndef yystrlen
3802 #  if defined __GLIBC__ && defined _STRING_H
3803 #   define yystrlen strlen
3804 #  else
3805 /* Return the length of YYSTR.  */
3806 #if (defined __STDC__ || defined __C99__FUNC__ \
3807      || defined __cplusplus || defined _MSC_VER)
3808 static YYSIZE_T
3809 yystrlen (const char *yystr)
3810 #else
3811 static YYSIZE_T
3812 yystrlen (yystr)
3813     const char *yystr;
3814 #endif
3815 {
3816   YYSIZE_T yylen;
3817   for (yylen = 0; yystr[yylen]; yylen++)
3818     continue;
3819   return yylen;
3820 }
3821 #  endif
3822 # endif
3823
3824 # ifndef yystpcpy
3825 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
3826 #   define yystpcpy stpcpy
3827 #  else
3828 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
3829    YYDEST.  */
3830 #if (defined __STDC__ || defined __C99__FUNC__ \
3831      || defined __cplusplus || defined _MSC_VER)
3832 static char *
3833 yystpcpy (char *yydest, const char *yysrc)
3834 #else
3835 static char *
3836 yystpcpy (yydest, yysrc)
3837     char *yydest;
3838     const char *yysrc;
3839 #endif
3840 {
3841   char *yyd = yydest;
3842   const char *yys = yysrc;
3843
3844   while ((*yyd++ = *yys++) != '\0')
3845     continue;
3846
3847   return yyd - 1;
3848 }
3849 #  endif
3850 # endif
3851
3852 # ifndef yytnamerr
3853 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
3854    quotes and backslashes, so that it's suitable for yyerror.  The
3855    heuristic is that double-quoting is unnecessary unless the string
3856    contains an apostrophe, a comma, or backslash (other than
3857    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
3858    null, do not copy; instead, return the length of what the result
3859    would have been.  */
3860 static YYSIZE_T
3861 yytnamerr (char *yyres, const char *yystr)
3862 {
3863   if (*yystr == '"')
3864     {
3865       YYSIZE_T yyn = 0;
3866       char const *yyp = yystr;
3867
3868       for (;;)
3869         switch (*++yyp)
3870           {
3871           case '\'':
3872           case ',':
3873             goto do_not_strip_quotes;
3874
3875           case '\\':
3876             if (*++yyp != '\\')
3877               goto do_not_strip_quotes;
3878             /* Fall through.  */
3879           default:
3880             if (yyres)
3881               yyres[yyn] = *yyp;
3882             yyn++;
3883             break;
3884
3885           case '"':
3886             if (yyres)
3887               yyres[yyn] = '\0';
3888             return yyn;
3889           }
3890     do_not_strip_quotes: ;
3891     }
3892
3893   if (! yyres)
3894     return yystrlen (yystr);
3895
3896   return yystpcpy (yyres, yystr) - yyres;
3897 }
3898 # endif
3899
3900 /* Copy into YYRESULT an error message about the unexpected token
3901    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
3902    including the terminating null byte.  If YYRESULT is null, do not
3903    copy anything; just return the number of bytes that would be
3904    copied.  As a special case, return 0 if an ordinary "syntax error"
3905    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
3906    size calculation.  */
3907 static YYSIZE_T
3908 yysyntax_error (char *yyresult, int yystate, int yychar)
3909 {
3910   int yyn = yypact[yystate];
3911
3912   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
3913     return 0;
3914   else
3915     {
3916       int yytype = YYTRANSLATE (yychar);
3917       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
3918       YYSIZE_T yysize = yysize0;
3919       YYSIZE_T yysize1;
3920       int yysize_overflow = 0;
3921       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
3922       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
3923       int yyx;
3924
3925 # if 0
3926       /* This is so xgettext sees the translatable formats that are
3927          constructed on the fly.  */
3928       YY_("syntax error, unexpected %s");
3929       YY_("syntax error, unexpected %s, expecting %s");
3930       YY_("syntax error, unexpected %s, expecting %s or %s");
3931       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
3932       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
3933 # endif
3934       char *yyfmt;
3935       char const *yyf;
3936       static char const yyunexpected[] = "syntax error, unexpected %s";
3937       static char const yyexpecting[] = ", expecting %s";
3938       static char const yyor[] = " or %s";
3939       char yyformat[sizeof yyunexpected
3940                     + sizeof yyexpecting - 1
3941                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
3942                        * (sizeof yyor - 1))];
3943       char const *yyprefix = yyexpecting;
3944
3945       /* Start YYX at -YYN if negative to avoid negative indexes in
3946          YYCHECK.  */
3947       int yyxbegin = yyn < 0 ? -yyn : 0;
3948
3949       /* Stay within bounds of both yycheck and yytname.  */
3950       int yychecklim = YYLAST - yyn + 1;
3951       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
3952       int yycount = 1;
3953
3954       yyarg[0] = yytname[yytype];
3955       yyfmt = yystpcpy (yyformat, yyunexpected);
3956
3957       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3958         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3959           {
3960             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
3961               {
3962                 yycount = 1;
3963                 yysize = yysize0;
3964                 yyformat[sizeof yyunexpected - 1] = '\0';
3965                 break;
3966               }
3967             yyarg[yycount++] = yytname[yyx];
3968             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
3969             yysize_overflow |= (yysize1 < yysize);
3970             yysize = yysize1;
3971             yyfmt = yystpcpy (yyfmt, yyprefix);
3972             yyprefix = yyor;
3973           }
3974
3975       yyf = YY_(yyformat);
3976       yysize1 = yysize + yystrlen (yyf);
3977       yysize_overflow |= (yysize1 < yysize);
3978       yysize = yysize1;
3979
3980       if (yysize_overflow)
3981         return YYSIZE_MAXIMUM;
3982
3983       if (yyresult)
3984         {
3985           /* Avoid sprintf, as that infringes on the user's name space.
3986              Don't have undefined behavior even if the translation
3987              produced a string with the wrong number of "%s"s.  */
3988           char *yyp = yyresult;
3989           int yyi = 0;
3990           while ((*yyp = *yyf) != '\0')
3991             {
3992               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
3993                 {
3994                   yyp += yytnamerr (yyp, yyarg[yyi++]);
3995                   yyf += 2;
3996                 }
3997               else
3998                 {
3999                   yyp++;
4000                   yyf++;
4001                 }
4002             }
4003         }
4004       return yysize;
4005     }
4006 }
4007 #endif /* YYERROR_VERBOSE */
4008 \f
4009
4010 /*-----------------------------------------------.
4011 | Release the memory associated to this symbol.  |
4012 `-----------------------------------------------*/
4013
4014 /*ARGSUSED*/
4015 #if (defined __STDC__ || defined __C99__FUNC__ \
4016      || defined __cplusplus || defined _MSC_VER)
4017 static void
4018 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
4019 #else
4020 static void
4021 yydestruct (yymsg, yytype, yyvaluep)
4022     const char *yymsg;
4023     int yytype;
4024     YYSTYPE *yyvaluep;
4025 #endif
4026 {
4027   YYUSE (yyvaluep);
4028
4029   if (!yymsg)
4030     yymsg = "Deleting";
4031   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4032
4033   switch (yytype)
4034     {
4035
4036       default:
4037         break;
4038     }
4039 }
4040
4041 /* Prevent warnings from -Wmissing-prototypes.  */
4042 #ifdef YYPARSE_PARAM
4043 #if defined __STDC__ || defined __cplusplus
4044 int yyparse (void *YYPARSE_PARAM);
4045 #else
4046 int yyparse ();
4047 #endif
4048 #else /* ! YYPARSE_PARAM */
4049 #if defined __STDC__ || defined __cplusplus
4050 int yyparse (void);
4051 #else
4052 int yyparse ();
4053 #endif
4054 #endif /* ! YYPARSE_PARAM */
4055
4056
4057 /* The lookahead symbol.  */
4058 int yychar;
4059
4060 /* The semantic value of the lookahead symbol.  */
4061 YYSTYPE yylval;
4062
4063 /* Number of syntax errors so far.  */
4064 int yynerrs;
4065
4066
4067
4068 /*-------------------------.
4069 | yyparse or yypush_parse.  |
4070 `-------------------------*/
4071
4072 #ifdef YYPARSE_PARAM
4073 #if (defined __STDC__ || defined __C99__FUNC__ \
4074      || defined __cplusplus || defined _MSC_VER)
4075 int
4076 yyparse (void *YYPARSE_PARAM)
4077 #else
4078 int
4079 yyparse (YYPARSE_PARAM)
4080     void *YYPARSE_PARAM;
4081 #endif
4082 #else /* ! YYPARSE_PARAM */
4083 #if (defined __STDC__ || defined __C99__FUNC__ \
4084      || defined __cplusplus || defined _MSC_VER)
4085 int
4086 yyparse (void)
4087 #else
4088 int
4089 yyparse ()
4090
4091 #endif
4092 #endif
4093 {
4094
4095
4096     int yystate;
4097     /* Number of tokens to shift before error messages enabled.  */
4098     int yyerrstatus;
4099
4100     /* The stacks and their tools:
4101        `yyss': related to states.
4102        `yyvs': related to semantic values.
4103
4104        Refer to the stacks thru separate pointers, to allow yyoverflow
4105        to reallocate them elsewhere.  */
4106
4107     /* The state stack.  */
4108     yytype_int16 yyssa[YYINITDEPTH];
4109     yytype_int16 *yyss;
4110     yytype_int16 *yyssp;
4111
4112     /* The semantic value stack.  */
4113     YYSTYPE yyvsa[YYINITDEPTH];
4114     YYSTYPE *yyvs;
4115     YYSTYPE *yyvsp;
4116
4117     YYSIZE_T yystacksize;
4118
4119   int yyn;
4120   int yyresult;
4121   /* Lookahead token as an internal (translated) token number.  */
4122   int yytoken;
4123   /* The variables used to return semantic value and location from the
4124      action routines.  */
4125   YYSTYPE yyval;
4126
4127 #if YYERROR_VERBOSE
4128   /* Buffer for error messages, and its allocated size.  */
4129   char yymsgbuf[128];
4130   char *yymsg = yymsgbuf;
4131   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
4132 #endif
4133
4134 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
4135
4136   /* The number of symbols on the RHS of the reduced rule.
4137      Keep to zero when no symbol should be popped.  */
4138   int yylen = 0;
4139
4140   yytoken = 0;
4141   yyss = yyssa;
4142   yyvs = yyvsa;
4143   yystacksize = YYINITDEPTH;
4144
4145   YYDPRINTF ((stderr, "Starting parse\n"));
4146
4147   yystate = 0;
4148   yyerrstatus = 0;
4149   yynerrs = 0;
4150   yychar = YYEMPTY; /* Cause a token to be read.  */
4151
4152   /* Initialize stack pointers.
4153      Waste one element of value and location stack
4154      so that they stay on the same level as the state stack.
4155      The wasted elements are never initialized.  */
4156   yyssp = yyss;
4157   yyvsp = yyvs;
4158
4159   goto yysetstate;
4160
4161 /*------------------------------------------------------------.
4162 | yynewstate -- Push a new state, which is found in yystate.  |
4163 `------------------------------------------------------------*/
4164  yynewstate:
4165   /* In all cases, when you get here, the value and location stacks
4166      have just been pushed.  So pushing a state here evens the stacks.  */
4167   yyssp++;
4168
4169  yysetstate:
4170   *yyssp = yystate;
4171
4172   if (yyss + yystacksize - 1 <= yyssp)
4173     {
4174       /* Get the current used size of the three stacks, in elements.  */
4175       YYSIZE_T yysize = yyssp - yyss + 1;
4176
4177 #ifdef yyoverflow
4178       {
4179         /* Give user a chance to reallocate the stack.  Use copies of
4180            these so that the &'s don't force the real ones into
4181            memory.  */
4182         YYSTYPE *yyvs1 = yyvs;
4183         yytype_int16 *yyss1 = yyss;
4184
4185         /* Each stack pointer address is followed by the size of the
4186            data in use in that stack, in bytes.  This used to be a
4187            conditional around just the two extra args, but that might
4188            be undefined if yyoverflow is a macro.  */
4189         yyoverflow (YY_("memory exhausted"),
4190                     &yyss1, yysize * sizeof (*yyssp),
4191                     &yyvs1, yysize * sizeof (*yyvsp),
4192                     &yystacksize);
4193
4194         yyss = yyss1;
4195         yyvs = yyvs1;
4196       }
4197 #else /* no yyoverflow */
4198 # ifndef YYSTACK_RELOCATE
4199       goto yyexhaustedlab;
4200 # else
4201       /* Extend the stack our own way.  */
4202       if (YYMAXDEPTH <= yystacksize)
4203         goto yyexhaustedlab;
4204       yystacksize *= 2;
4205       if (YYMAXDEPTH < yystacksize)
4206         yystacksize = YYMAXDEPTH;
4207
4208       {
4209         yytype_int16 *yyss1 = yyss;
4210         union yyalloc *yyptr =
4211           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
4212         if (! yyptr)
4213           goto yyexhaustedlab;
4214         YYSTACK_RELOCATE (yyss_alloc, yyss);
4215         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
4216 #  undef YYSTACK_RELOCATE
4217         if (yyss1 != yyssa)
4218           YYSTACK_FREE (yyss1);
4219       }
4220 # endif
4221 #endif /* no yyoverflow */
4222
4223       yyssp = yyss + yysize - 1;
4224       yyvsp = yyvs + yysize - 1;
4225
4226       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
4227                   (unsigned long int) yystacksize));
4228
4229       if (yyss + yystacksize - 1 <= yyssp)
4230         YYABORT;
4231     }
4232
4233   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
4234
4235   if (yystate == YYFINAL)
4236     YYACCEPT;
4237
4238   goto yybackup;
4239
4240 /*-----------.
4241 | yybackup.  |
4242 `-----------*/
4243 yybackup:
4244
4245   /* Do appropriate processing given the current state.  Read a
4246      lookahead token if we need one and don't already have one.  */
4247
4248   /* First try to decide what to do without reference to lookahead token.  */
4249   yyn = yypact[yystate];
4250   if (yyn == YYPACT_NINF)
4251     goto yydefault;
4252
4253   /* Not known => get a lookahead token if don't already have one.  */
4254
4255   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
4256   if (yychar == YYEMPTY)
4257     {
4258       YYDPRINTF ((stderr, "Reading a token: "));
4259       yychar = YYLEX;
4260     }
4261
4262   if (yychar <= YYEOF)
4263     {
4264       yychar = yytoken = YYEOF;
4265       YYDPRINTF ((stderr, "Now at end of input.\n"));
4266     }
4267   else
4268     {
4269       yytoken = YYTRANSLATE (yychar);
4270       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
4271     }
4272
4273   /* If the proper action on seeing token YYTOKEN is to reduce or to
4274      detect an error, take that action.  */
4275   yyn += yytoken;
4276   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
4277     goto yydefault;
4278   yyn = yytable[yyn];
4279   if (yyn <= 0)
4280     {
4281       if (yyn == 0 || yyn == YYTABLE_NINF)
4282         goto yyerrlab;
4283       yyn = -yyn;
4284       goto yyreduce;
4285     }
4286
4287   /* Count tokens shifted since error; after three, turn off error
4288      status.  */
4289   if (yyerrstatus)
4290     yyerrstatus--;
4291
4292   /* Shift the lookahead token.  */
4293   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
4294
4295   /* Discard the shifted token.  */
4296   yychar = YYEMPTY;
4297
4298   yystate = yyn;
4299   *++yyvsp = yylval;
4300
4301   goto yynewstate;
4302
4303
4304 /*-----------------------------------------------------------.
4305 | yydefault -- do the default action for the current state.  |
4306 `-----------------------------------------------------------*/
4307 yydefault:
4308   yyn = yydefact[yystate];
4309   if (yyn == 0)
4310     goto yyerrlab;
4311   goto yyreduce;
4312
4313
4314 /*-----------------------------.
4315 | yyreduce -- Do a reduction.  |
4316 `-----------------------------*/
4317 yyreduce:
4318   /* yyn is the number of a rule to reduce with.  */
4319   yylen = yyr2[yyn];
4320
4321   /* If YYLEN is nonzero, implement the default value of the action:
4322      `$$ = $1'.
4323
4324      Otherwise, the following line sets YYVAL to garbage.
4325      This behavior is undocumented and Bison
4326      users should not rely upon it.  Assigning to YYVAL
4327      unconditionally makes the parser a bit smaller, and it avoids a
4328      GCC warning that YYVAL may be used uninitialized.  */
4329   yyval = yyvsp[1-yylen];
4330
4331
4332   YY_REDUCE_PRINT (yyn);
4333   switch (yyn)
4334     {
4335
4336     case 26:
4337     if(as3_pass==2) {
4338
4339 /* Line 1464 of skeleton.m4  */
4340 #line 2108 "parser.y"
4341     {(yyval.code)=(yyvsp[(1) - (1)].code);}
4342     }
4343     break;
4344
4345
4346
4347     case 27:
4348     if(as3_pass==2) {
4349
4350 /* Line 1464 of skeleton.m4  */
4351 #line 2109 "parser.y"
4352     {(yyval.code)=code_new();}
4353     }
4354     break;
4355
4356
4357
4358     case 28:
4359     if(as3_pass==2) {
4360
4361 /* Line 1464 of skeleton.m4  */
4362 #line 2111 "parser.y"
4363     {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));}
4364     }
4365     break;
4366
4367
4368
4369     case 29:
4370     if(as3_pass==2) {
4371
4372 /* Line 1464 of skeleton.m4  */
4373 #line 2112 "parser.y"
4374     {(yyval.code)=(yyvsp[(1) - (1)].code);}
4375     }
4376     break;
4377
4378
4379
4380     case 42:
4381     if(as3_pass==2) {
4382
4383 /* Line 1464 of skeleton.m4  */
4384 #line 2127 "parser.y"
4385     {(yyval.code)=(yyvsp[(2) - (3)].code);}
4386     }
4387     break;
4388
4389
4390
4391     case 43:
4392     if(as3_pass==2) {
4393
4394 /* Line 1464 of skeleton.m4  */
4395 #line 2128 "parser.y"
4396     {(yyval.code)=0;}
4397     }
4398     break;
4399
4400
4401
4402     case 44:
4403     if(as3_pass==2) {
4404
4405 /* Line 1464 of skeleton.m4  */
4406 #line 2131 "parser.y"
4407     {(yyval.code)=0;}
4408     }
4409     break;
4410
4411
4412
4413     case 51:
4414     if(as3_pass==2) {
4415
4416 /* Line 1464 of skeleton.m4  */
4417 #line 2138 "parser.y"
4418     {(yyval.code)=(yyvsp[(3) - (4)].code);}
4419     }
4420     break;
4421
4422
4423
4424     case 52:
4425     if(as3_pass==2) {
4426
4427 /* Line 1464 of skeleton.m4  */
4428 #line 2142 "parser.y"
4429     {(yyval.code)=(yyvsp[(1) - (2)].code);}
4430     }
4431     break;
4432
4433
4434
4435     case 53:
4436     if(as3_pass==2) {
4437
4438 /* Line 1464 of skeleton.m4  */
4439 #line 2143 "parser.y"
4440     {(yyval.code)=(yyvsp[(1) - (1)].code);}
4441     }
4442     break;
4443
4444
4445
4446     case 54:
4447     if(as3_pass==2) {
4448
4449 /* Line 1464 of skeleton.m4  */
4450 #line 2147 "parser.y"
4451     {
4452     code_t**cc = &global->init->method->body->code;
4453     *cc = code_append(*cc, (yyvsp[(1) - (1)].code));
4454 }
4455     }
4456     break;
4457
4458
4459
4460     case 56:
4461     if(as3_pass==2) {
4462
4463 /* Line 1464 of skeleton.m4  */
4464 #line 2158 "parser.y"
4465     {(yyval.value)=(yyvsp[(2) - (2)].value);}
4466     }
4467     break;
4468
4469
4470
4471     case 57:
4472     if(as3_pass==2) {
4473
4474 /* Line 1464 of skeleton.m4  */
4475 #line 2159 "parser.y"
4476     {(yyval.value).c=abc_pushundefined(0);
4477                                   (yyval.value).t=TYPE_ANY;
4478                                  }
4479     }
4480     break;
4481
4482
4483
4484     case 58:
4485     if(as3_pass==2) {
4486
4487 /* Line 1464 of skeleton.m4  */
4488 #line 2163 "parser.y"
4489     {(yyval.code)=(yyvsp[(2) - (2)].code);}
4490     }
4491     break;
4492
4493
4494
4495     case 59:
4496     if(as3_pass==2) {
4497
4498 /* Line 1464 of skeleton.m4  */
4499 #line 2164 "parser.y"
4500     {(yyval.code)=(yyvsp[(2) - (2)].code);}
4501     }
4502     break;
4503
4504
4505
4506     case 60:
4507     if(as3_pass==2) {
4508
4509 /* Line 1464 of skeleton.m4  */
4510 #line 2166 "parser.y"
4511     {(yyval.code) = (yyvsp[(1) - (1)].code);}
4512     }
4513     break;
4514
4515
4516
4517     case 61:
4518     if(as3_pass==2) {
4519
4520 /* Line 1464 of skeleton.m4  */
4521 #line 2167 "parser.y"
4522     {(yyval.code) = code_append((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
4523     }
4524     break;
4525
4526
4527
4528     case 62:
4529     if(as3_pass==2) {
4530
4531 /* Line 1464 of skeleton.m4  */
4532 #line 2170 "parser.y"
4533     {
4534 PASS12
4535     if(variable_exists((yyvsp[(1) - (3)].id)))
4536         syntaxerror("Variable %s already defined", (yyvsp[(1) - (3)].id));
4537 PASS1
4538     new_variable((yyvsp[(1) - (3)].id), 0, 1, 0);
4539 PASS2
4540
4541     if(!is_subtype_of((yyvsp[(3) - (3)].value).t, (yyvsp[(2) - (3)].classinfo))) {
4542         syntaxerror("Can't convert %s to %s", (yyvsp[(3) - (3)].value).t->name,
4543                                               (yyvsp[(2) - (3)].classinfo)->name);
4544     }
4545
4546     char slot = 0;
4547     int index = 0;
4548     if(state->method->uses_slots) {
4549         variable_t* v = find_slot(state, (yyvsp[(1) - (3)].id));
4550         if(v && !v->init) {
4551             // this variable is stored in a slot
4552             v->init = 1;
4553             v->type = (yyvsp[(2) - (3)].classinfo);
4554             slot = 1;
4555             index = v->index;
4556         }
4557     }
4558     if(!index) {
4559         index = new_variable((yyvsp[(1) - (3)].id), (yyvsp[(2) - (3)].classinfo), 1, 0);
4560     }
4561
4562     (yyval.code) = slot?abc_getscopeobject(0, 1):0;
4563
4564     if((yyvsp[(2) - (3)].classinfo)) {
4565         if((yyvsp[(3) - (3)].value).c->prev || (yyvsp[(3) - (3)].value).c->opcode != OPCODE_PUSHUNDEFINED) {
4566             (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (3)].value).c);
4567             (yyval.code) = converttype((yyval.code), (yyvsp[(3) - (3)].value).t, (yyvsp[(2) - (3)].classinfo));
4568         } else {
4569             code_free((yyvsp[(3) - (3)].value).c);
4570             (yyval.code) = defaultvalue((yyval.code), (yyvsp[(2) - (3)].classinfo));
4571         }
4572     } else {
4573         if((yyvsp[(3) - (3)].value).c->prev || (yyvsp[(3) - (3)].value).c->opcode != OPCODE_PUSHUNDEFINED) {
4574             (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (3)].value).c);
4575             (yyval.code) = abc_coerce_a((yyval.code));
4576         } else {
4577             // don't do anything
4578             code_free((yyvsp[(3) - (3)].value).c);
4579             code_free((yyval.code));
4580             (yyval.code) = 0;
4581             break;
4582         }
4583     }
4584     if(slot) {
4585         (yyval.code) = abc_setslot((yyval.code), index);
4586     } else {
4587         (yyval.code) = abc_setlocal((yyval.code), index);
4588     }
4589 }
4590     }
4591     break;
4592
4593
4594
4595     case 63:
4596     if(as3_pass==2) {
4597
4598 /* Line 1464 of skeleton.m4  */
4599 #line 2230 "parser.y"
4600     {(yyval.code) = code_new();}
4601     }
4602     break;
4603
4604
4605
4606     case 64:
4607     if(as3_pass==2) {
4608
4609 /* Line 1464 of skeleton.m4  */
4610 #line 2231 "parser.y"
4611     {(yyval.code)=(yyvsp[(2) - (2)].code);}
4612     }
4613     break;
4614
4615
4616
4617     case 65:
4618     if(as3_pass==2) {
4619
4620 /* Line 1464 of skeleton.m4  */
4621 #line 2234 "parser.y"
4622     {PASS12 new_state();}
4623     }
4624     break;
4625
4626
4627
4628     case 66:
4629     if(as3_pass==2) {
4630
4631 /* Line 1464 of skeleton.m4  */
4632 #line 2234 "parser.y"
4633     {
4634
4635     (yyval.code) = code_new();
4636     (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (7)].value).c);
4637     code_t*myjmp,*myif = (yyval.code) = abc_iffalse((yyval.code), 0);
4638
4639     (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (7)].code));
4640     if((yyvsp[(7) - (7)].code)) {
4641         myjmp = (yyval.code) = abc_jump((yyval.code), 0);
4642     }
4643     myif->branch = (yyval.code) = abc_nop((yyval.code));
4644     if((yyvsp[(7) - (7)].code)) {
4645         (yyval.code) = code_append((yyval.code), (yyvsp[(7) - (7)].code));
4646         myjmp->branch = (yyval.code) = abc_nop((yyval.code));
4647     }
4648     (yyval.code) = var_block((yyval.code));
4649     PASS12 old_state();
4650 }
4651     }
4652     break;
4653
4654
4655
4656     case 67:
4657     if(as3_pass==2) {
4658
4659 /* Line 1464 of skeleton.m4  */
4660 #line 2253 "parser.y"
4661     {(yyval.code)=code_new();}
4662     }
4663     break;
4664
4665
4666
4667     case 70:
4668     if(as3_pass==2) {
4669
4670 /* Line 1464 of skeleton.m4  */
4671 #line 2260 "parser.y"
4672     {
4673     PASS1 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable((yyvsp[(2) - (3)].id),0,1,0);
4674     PASS2 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable((yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].classinfo),1,0);
4675 }
4676     }
4677     break;
4678
4679
4680
4681     case 71:
4682     if(as3_pass==2) {
4683
4684 /* Line 1464 of skeleton.m4  */
4685 #line 2264 "parser.y"
4686     {
4687     PASS12
4688     (yyval.id)=(yyvsp[(1) - (1)].id);
4689 }
4690     }
4691     break;
4692
4693
4694
4695     case 72:
4696     if(as3_pass==2) {
4697
4698 /* Line 1464 of skeleton.m4  */
4699 #line 2269 "parser.y"
4700     {PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (2)].id);(yyval.for_start).each=0;}
4701     }
4702     break;
4703
4704
4705
4706     case 73:
4707     if(as3_pass==2) {
4708
4709 /* Line 1464 of skeleton.m4  */
4710 #line 2270 "parser.y"
4711     {PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (3)].id);(yyval.for_start).each=1;}
4712     }
4713     break;
4714
4715
4716
4717     case 74:
4718     if(as3_pass==2) {
4719
4720 /* Line 1464 of skeleton.m4  */
4721 #line 2272 "parser.y"
4722     {
4723     if((yyvsp[(1) - (8)].for_start).each) syntaxerror("invalid syntax: ; not allowed in for each statement");
4724     (yyval.code) = code_new();
4725     (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (8)].code));
4726     code_t*loopstart = (yyval.code) = abc_label((yyval.code));
4727     (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (8)].value).c);
4728     code_t*myif = (yyval.code) = abc_iffalse((yyval.code), 0);
4729     (yyval.code) = code_append((yyval.code), (yyvsp[(8) - (8)].code));
4730     code_t*cont = (yyval.code) = abc_nop((yyval.code));
4731     (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (8)].code));
4732     (yyval.code) = abc_jump((yyval.code), loopstart);
4733     code_t*out = (yyval.code) = abc_nop((yyval.code));
4734     breakjumpsto((yyval.code), (yyvsp[(1) - (8)].for_start).name, out);
4735     continuejumpsto((yyval.code), (yyvsp[(1) - (8)].for_start).name, cont);
4736     myif->branch = out;
4737
4738     (yyval.code) = var_block((yyval.code));
4739     PASS12 old_state();
4740 }
4741     }
4742     break;
4743
4744
4745
4746     case 75:
4747     if(as3_pass==2) {
4748
4749 /* Line 1464 of skeleton.m4  */
4750 #line 2292 "parser.y"
4751     {
4752     variable_t*var = find_variable(state, (yyvsp[(2) - (6)].id));
4753     if(!var) {
4754         syntaxerror("variable %s not known in this scope", (yyvsp[(2) - (6)].id));
4755     }
4756
4757     char*tmp1name = concat2((yyvsp[(2) - (6)].id), "__tmp1__");
4758     int it = new_variable(tmp1name, TYPE_INT, 0, 0);
4759     char*tmp2name = concat2((yyvsp[(2) - (6)].id), "__array__");
4760     int array = new_variable(tmp1name, 0, 0, 0);
4761
4762     (yyval.code) = code_new();
4763     (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (6)].value).c);
4764     (yyval.code) = abc_coerce_a((yyval.code));
4765     (yyval.code) = abc_setlocal((yyval.code), array);
4766     (yyval.code) = abc_pushbyte((yyval.code), 0);
4767     (yyval.code) = abc_setlocal((yyval.code), it);
4768
4769     code_t*loopstart = (yyval.code) = abc_label((yyval.code));
4770
4771     (yyval.code) = abc_hasnext2((yyval.code), array, it);
4772     code_t*myif = (yyval.code) = abc_iffalse((yyval.code), 0);
4773     (yyval.code) = abc_getlocal((yyval.code), array);
4774     (yyval.code) = abc_getlocal((yyval.code), it);
4775     if(!(yyvsp[(1) - (6)].for_start).each)
4776         (yyval.code) = abc_nextname((yyval.code));
4777     else
4778         (yyval.code) = abc_nextvalue((yyval.code));
4779     (yyval.code) = converttype((yyval.code), 0, var->type);
4780     (yyval.code) = abc_setlocal((yyval.code), var->index);
4781
4782     (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (6)].code));
4783     (yyval.code) = abc_jump((yyval.code), loopstart);
4784
4785     code_t*out = (yyval.code) = abc_nop((yyval.code));
4786     breakjumpsto((yyval.code), (yyvsp[(1) - (6)].for_start).name, out);
4787     continuejumpsto((yyval.code), (yyvsp[(1) - (6)].for_start).name, loopstart);
4788
4789     myif->branch = out;
4790
4791     (yyval.code) = var_block((yyval.code));
4792
4793     free(tmp1name);
4794     free(tmp2name);
4795
4796     PASS12 old_state();
4797 }
4798     }
4799     break;
4800
4801
4802
4803     case 76:
4804     if(as3_pass==2) {
4805
4806 /* Line 1464 of skeleton.m4  */
4807 #line 2340 "parser.y"
4808     {PASS12 new_state();}
4809     }
4810     break;
4811
4812
4813
4814     case 77:
4815     if(as3_pass==2) {
4816
4817 /* Line 1464 of skeleton.m4  */
4818 #line 2340 "parser.y"
4819     {
4820
4821     (yyval.code) = code_new();
4822
4823     code_t*myjmp = (yyval.code) = abc_jump((yyval.code), 0);
4824     code_t*loopstart = (yyval.code) = abc_label((yyval.code));
4825     (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (6)].code));
4826     code_t*cont = (yyval.code) = abc_nop((yyval.code));
4827     myjmp->branch = cont;
4828     (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (6)].value).c);
4829     (yyval.code) = abc_iftrue((yyval.code), loopstart);
4830     code_t*out = (yyval.code) = abc_nop((yyval.code));
4831     breakjumpsto((yyval.code), (yyvsp[(1) - (6)].id), out);
4832     continuejumpsto((yyval.code), (yyvsp[(1) - (6)].id), cont);
4833
4834     (yyval.code) = var_block((yyval.code));
4835     PASS12 old_state();
4836 }
4837     }
4838     break;
4839
4840
4841
4842     case 78:
4843     if(as3_pass==2) {
4844
4845 /* Line 1464 of skeleton.m4  */
4846 #line 2359 "parser.y"
4847     {PASS12 new_state();}
4848     }
4849     break;
4850
4851
4852
4853     case 79:
4854     if(as3_pass==2) {
4855
4856 /* Line 1464 of skeleton.m4  */
4857 #line 2359 "parser.y"
4858     {
4859     (yyval.code) = code_new();
4860     code_t*loopstart = (yyval.code) = abc_label((yyval.code));
4861     (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (7)].code));
4862     code_t*cont = (yyval.code) = abc_nop((yyval.code));
4863     (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (7)].value).c);
4864     (yyval.code) = abc_iftrue((yyval.code), loopstart);
4865     code_t*out = (yyval.code) = abc_nop((yyval.code));
4866     breakjumpsto((yyval.code), (yyvsp[(1) - (7)].id), out);
4867     continuejumpsto((yyval.code), (yyvsp[(1) - (7)].id), cont);
4868
4869     (yyval.code) = var_block((yyval.code));
4870     PASS12 old_state();
4871 }
4872     }
4873     break;
4874
4875
4876
4877     case 80:
4878     if(as3_pass==2) {
4879
4880 /* Line 1464 of skeleton.m4  */
4881 #line 2374 "parser.y"
4882     {
4883     (yyval.code) = abc___break__(0, "");
4884 }
4885     }
4886     break;
4887
4888
4889
4890     case 81:
4891     if(as3_pass==2) {
4892
4893 /* Line 1464 of skeleton.m4  */
4894 #line 2377 "parser.y"
4895     {
4896     (yyval.code) = abc___break__(0, (yyvsp[(2) - (2)].id));
4897 }
4898     }
4899     break;
4900
4901
4902
4903     case 82:
4904     if(as3_pass==2) {
4905
4906 /* Line 1464 of skeleton.m4  */
4907 #line 2380 "parser.y"
4908     {
4909     (yyval.code) = abc___continue__(0, "");
4910 }
4911     }
4912     break;
4913
4914
4915
4916     case 83:
4917     if(as3_pass==2) {
4918
4919 /* Line 1464 of skeleton.m4  */
4920 #line 2383 "parser.y"
4921     {
4922     (yyval.code) = abc___continue__(0, (yyvsp[(2) - (2)].id));
4923 }
4924     }
4925     break;
4926
4927
4928
4929     case 84:
4930     if(as3_pass==2) {
4931
4932 /* Line 1464 of skeleton.m4  */
4933 #line 2387 "parser.y"
4934     {(yyval.code)=0;}
4935     }
4936     break;
4937
4938
4939
4940     case 85:
4941     if(as3_pass==2) {
4942
4943 /* Line 1464 of skeleton.m4  */
4944 #line 2388 "parser.y"
4945     {(yyval.code)=(yyvsp[(1) - (1)].code);}
4946     }
4947     break;
4948
4949
4950
4951     case 86:
4952     if(as3_pass==2) {
4953
4954 /* Line 1464 of skeleton.m4  */
4955 #line 2389 "parser.y"
4956     {(yyval.code)=(yyvsp[(1) - (1)].code);}
4957     }
4958     break;
4959
4960
4961
4962     case 87:
4963     if(as3_pass==2) {
4964
4965 /* Line 1464 of skeleton.m4  */
4966 #line 2390 "parser.y"
4967     {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));}
4968     }
4969     break;
4970
4971
4972
4973     case 88:
4974     if(as3_pass==2) {
4975
4976 /* Line 1464 of skeleton.m4  */
4977 #line 2391 "parser.y"
4978     {(yyval.code)=(yyvsp[(1) - (1)].code);}
4979     }
4980     break;
4981
4982
4983
4984     case 89:
4985     if(as3_pass==2) {
4986
4987 /* Line 1464 of skeleton.m4  */
4988 #line 2392 "parser.y"
4989     {(yyval.code)=code_append((yyval.code),(yyvsp[(2) - (2)].code));}
4990     }
4991     break;
4992
4993
4994
4995     case 90:
4996     if(as3_pass==2) {
4997
4998 /* Line 1464 of skeleton.m4  */
4999 #line 2394 "parser.y"
5000     {
5001     (yyval.code) = abc_getlocal(0, state->switch_var);
5002     (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (4)].value).c);
5003     code_t*j = (yyval.code) = abc_ifne((yyval.code), 0);
5004     (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (4)].code));
5005     if((yyval.code)->opcode != OPCODE___BREAK__) {
5006         (yyval.code) = abc___fallthrough__((yyval.code), "");
5007     }
5008     code_t*e = (yyval.code) = abc_nop((yyval.code));
5009     j->branch = e;
5010 }
5011     }
5012     break;
5013
5014
5015
5016     case 91:
5017     if(as3_pass==2) {
5018
5019 /* Line 1464 of skeleton.m4  */
5020 #line 2405 "parser.y"
5021     {
5022     (yyval.code) = (yyvsp[(3) - (3)].code);
5023 }
5024     }
5025     break;
5026
5027
5028
5029     case 92:
5030     if(as3_pass==2) {
5031
5032 /* Line 1464 of skeleton.m4  */
5033 #line 2408 "parser.y"
5034     {PASS12 new_state();state->switch_var=alloc_local();}
5035     }
5036     break;
5037
5038
5039
5040     case 93:
5041     if(as3_pass==2) {
5042
5043 /* Line 1464 of skeleton.m4  */
5044 #line 2408 "parser.y"
5045     {
5046     (yyval.code)=(yyvsp[(4) - (8)].value).c;
5047     (yyval.code) = abc_setlocal((yyval.code), state->switch_var);
5048     (yyval.code) = code_append((yyval.code), (yyvsp[(7) - (8)].code));
5049
5050     code_t*out = (yyval.code) = abc_kill((yyval.code), state->switch_var);
5051     breakjumpsto((yyval.code), (yyvsp[(1) - (8)].id), out);
5052
5053     code_t*c = (yyval.code),*lastblock=0;
5054     while(c) {
5055         if(c->opcode == OPCODE_IFNE) {
5056             if(!c->next) syntaxerror("internal error in fallthrough handling");
5057             lastblock=c->next;
5058         } else if(c->opcode == OPCODE___FALLTHROUGH__) {
5059             if(lastblock) {
5060                 c->opcode = OPCODE_JUMP;
5061                 c->branch = lastblock;
5062             } else {
5063                 /* fall through end of switch */
5064                 c->opcode = OPCODE_NOP;
5065             }
5066         }
5067         c=c->prev;
5068     }
5069
5070     (yyval.code) = var_block((yyval.code));
5071     PASS12 old_state();
5072 }
5073     }
5074     break;
5075
5076
5077
5078     case 94:
5079     if(as3_pass==2) {
5080
5081 /* Line 1464 of skeleton.m4  */
5082 #line 2439 "parser.y"
5083     {PASS12 new_state();
5084                                                       state->exception_name=(yyvsp[(3) - (5)].id);
5085                                                PASS1 new_variable((yyvsp[(3) - (5)].id), 0, 0, 0);
5086                                                PASS2 new_variable((yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].classinfo), 0, 0);
5087                                               }
5088     }
5089     break;
5090
5091
5092
5093     case 95:
5094     if(as3_pass==2) {
5095
5096 /* Line 1464 of skeleton.m4  */
5097 #line 2444 "parser.y"
5098     {
5099     namespace_t name_ns = {ACCESS_PACKAGE, ""};
5100     multiname_t name = {QNAME, &name_ns, 0, (yyvsp[(3) - (9)].id)};
5101
5102     NEW(abc_exception_t, e)
5103     e->exc_type = sig2mname((yyvsp[(4) - (9)].classinfo));
5104     e->var_name = multiname_clone(&name);
5105     (yyval.exception) = e;
5106
5107     code_t*c = 0;
5108     int i = find_variable_safe(state, (yyvsp[(3) - (9)].id))->index;
5109     e->target = c = abc_nop(0);
5110     c = abc_setlocal(c, i);
5111     c = code_append(c, code_dup(state->method->scope_code));
5112     c = code_append(c, (yyvsp[(8) - (9)].code));
5113     c = abc_kill(c, i);
5114
5115     c = var_block(c);
5116     PASS12 old_state();
5117 }
5118     }
5119     break;
5120
5121
5122
5123     case 96:
5124     if(as3_pass==2) {
5125
5126 /* Line 1464 of skeleton.m4  */
5127 #line 2464 "parser.y"
5128     {PASS12 new_state();state->exception_name=0;}
5129     }
5130     break;
5131
5132
5133
5134     case 97:
5135     if(as3_pass==2) {
5136
5137 /* Line 1464 of skeleton.m4  */
5138 #line 2464 "parser.y"
5139     {
5140     (yyvsp[(4) - (5)].code) = var_block((yyvsp[(4) - (5)].code));
5141     if(!(yyvsp[(4) - (5)].code)) {
5142         (yyval.exception)=0;
5143     } else {
5144         NEW(abc_exception_t, e)
5145         e->exc_type = 0; //all exceptions
5146         e->var_name = 0; //no name
5147         e->target = 0;
5148         e->to = abc_nop(0);
5149         e->to = code_append(e->to, (yyvsp[(4) - (5)].code));
5150         (yyval.exception) = e;
5151     }
5152     PASS12 old_state();
5153 }
5154     }
5155     break;
5156
5157
5158
5159     case 98:
5160     if(as3_pass==2) {
5161
5162 /* Line 1464 of skeleton.m4  */
5163 #line 2480 "parser.y"
5164     {(yyval.catch_list).l=list_new();(yyval.catch_list).finally=0;list_append((yyval.catch_list).l,(yyvsp[(1) - (1)].exception));}
5165     }
5166     break;
5167
5168
5169
5170     case 99:
5171     if(as3_pass==2) {
5172
5173 /* Line 1464 of skeleton.m4  */
5174 #line 2481 "parser.y"
5175     {(yyval.catch_list)=(yyvsp[(1) - (2)].catch_list);list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));}
5176     }
5177     break;
5178
5179
5180
5181     case 100:
5182     if(as3_pass==2) {
5183
5184 /* Line 1464 of skeleton.m4  */
5185 #line 2482 "parser.y"
5186     {(yyval.catch_list)=(yyvsp[(1) - (1)].catch_list);}
5187     }
5188     break;
5189
5190
5191
5192     case 101:
5193     if(as3_pass==2) {
5194
5195 /* Line 1464 of skeleton.m4  */
5196 #line 2483 "parser.y"
5197     {
5198     (yyval.catch_list) = (yyvsp[(1) - (2)].catch_list);
5199     (yyval.catch_list).finally = 0;
5200     if((yyvsp[(2) - (2)].exception)) {
5201         list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));
5202         (yyval.catch_list).finally = (yyvsp[(2) - (2)].exception)->to;(yyvsp[(2) - (2)].exception)->to=0;
5203     }
5204 }
5205     }
5206     break;
5207
5208
5209
5210     case 102:
5211     if(as3_pass==2) {
5212
5213 /* Line 1464 of skeleton.m4  */
5214 #line 2491 "parser.y"
5215     {
5216     (yyval.catch_list).l=list_new();
5217     (yyval.catch_list).finally = 0;
5218     if((yyvsp[(1) - (1)].exception)) {
5219         list_append((yyval.catch_list).l,(yyvsp[(1) - (1)].exception));
5220         (yyval.catch_list).finally = (yyvsp[(1) - (1)].exception)->to;(yyvsp[(1) - (1)].exception)->to=0;
5221     }
5222 }
5223     }
5224     break;
5225
5226
5227
5228     case 103:
5229     if(as3_pass==2) {
5230
5231 /* Line 1464 of skeleton.m4  */
5232 #line 2500 "parser.y"
5233     {PASS12 new_state();
5234                  state->method->has_exceptions=1;
5235                  state->method->late_binding=1;//for invariant scope_code
5236                 }
5237     }
5238     break;
5239
5240
5241
5242     case 104:
5243     if(as3_pass==2) {
5244
5245 /* Line 1464 of skeleton.m4  */
5246 #line 2503 "parser.y"
5247     {
5248     code_t*out = abc_nop(0);
5249
5250     code_t*start = abc_nop(0);
5251     (yyval.code) = code_append(start, (yyvsp[(4) - (6)].code));
5252     if(!is_break_or_jump((yyvsp[(4) - (6)].code))) {
5253         (yyval.code) = abc_jump((yyval.code), out);
5254     }
5255     code_t*end = (yyval.code) = abc_nop((yyval.code));
5256
5257     int tmp;
5258     if((yyvsp[(6) - (6)].catch_list).finally)
5259         tmp = new_variable("__finally__", 0, 0, 0);
5260
5261     abc_exception_list_t*l = (yyvsp[(6) - (6)].catch_list).l;
5262     int count=0;
5263     while(l) {
5264         abc_exception_t*e = l->abc_exception;
5265         if(e->var_name) {
5266             (yyval.code) = code_append((yyval.code), e->target);
5267             (yyval.code) = abc_jump((yyval.code), out);
5268         } else {
5269             parserassert((ptroff_t)(yyvsp[(6) - (6)].catch_list).finally);
5270             // finally block
5271             e->target = (yyval.code) = abc_nop((yyval.code));
5272             (yyval.code) = code_append((yyval.code), code_dup(state->method->scope_code));
5273             (yyval.code) = abc___rethrow__((yyval.code));
5274         }
5275
5276         e->from = start;
5277         e->to = end;
5278
5279         l = l->next;
5280     }
5281     (yyval.code) = code_append((yyval.code), out);
5282
5283     (yyval.code) = insert_finally((yyval.code), (yyvsp[(6) - (6)].catch_list).finally, tmp);
5284
5285     list_concat(state->method->exceptions, (yyvsp[(6) - (6)].catch_list).l);
5286
5287     (yyval.code) = var_block((yyval.code));
5288     PASS12 old_state();
5289 }
5290     }
5291     break;
5292
5293
5294
5295     case 105:
5296     if(as3_pass==2) {
5297
5298 /* Line 1464 of skeleton.m4  */
5299 #line 2549 "parser.y"
5300     {
5301     (yyval.code)=(yyvsp[(2) - (2)].value).c;
5302     (yyval.code)=abc_throw((yyval.code));
5303 }
5304     }
5305     break;
5306
5307
5308
5309     case 106:
5310     if(as3_pass==2) {
5311
5312 /* Line 1464 of skeleton.m4  */
5313 #line 2553 "parser.y"
5314     {
5315     if(!state->exception_name)
5316         syntaxerror("re-throw only possible within a catch block");
5317     variable_t*v = find_variable(state, state->exception_name);
5318     (yyval.code)=code_new();
5319     (yyval.code)=abc_getlocal((yyval.code), v->index);
5320     (yyval.code)=abc_throw((yyval.code));
5321 }
5322     }
5323     break;
5324
5325
5326
5327     case 107:
5328     if(as3_pass==2) {
5329
5330 /* Line 1464 of skeleton.m4  */
5331 #line 2564 "parser.y"
5332     {
5333      new_state();
5334      if(state->method->has_exceptions) {
5335          int v = alloc_local();
5336          state->method->scope_code = abc_getlocal(state->method->scope_code, v);
5337          state->method->scope_code = abc_pushwith(state->method->scope_code);
5338          (yyval.value_list).number = v;
5339      }
5340      (yyval.value_list).cc = (yyvsp[(3) - (4)].value).c;
5341 }
5342     }
5343     break;
5344
5345
5346
5347     case 108:
5348     if(as3_pass==2) {
5349
5350 /* Line 1464 of skeleton.m4  */
5351 #line 2574 "parser.y"
5352     {
5353      /* remove getlocal;pushwith from scope code again */
5354      state->method->scope_code = code_cutlast(code_cutlast(state->method->scope_code));
5355
5356      (yyval.code) = (yyvsp[(1) - (2)].value_list).cc;
5357      if(state->method->has_exceptions) {
5358          (yyval.code) = abc_dup((yyval.code));
5359          (yyval.code) = abc_setlocal((yyval.code), (yyvsp[(1) - (2)].value_list).number);
5360      }
5361      (yyval.code) = abc_pushwith((yyval.code));
5362      (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (2)].code));
5363      (yyval.code) = abc_popscope((yyval.code));
5364      old_state();
5365 }
5366     }
5367     break;
5368
5369
5370
5371     case 110:
5372     if(as3_pass==2) {
5373
5374 /* Line 1464 of skeleton.m4  */
5375 #line 2592 "parser.y"
5376     {PASS12 (yyval.id)="package";}
5377     }
5378     break;
5379
5380
5381
5382     case 111:
5383     if(as3_pass==2) {
5384
5385 /* Line 1464 of skeleton.m4  */
5386 #line 2593 "parser.y"
5387     {PASS12 (yyval.id)=(yyvsp[(1) - (1)].id);}
5388     }
5389     break;
5390
5391
5392
5393     case 112:
5394     if(as3_pass==2) {
5395
5396 /* Line 1464 of skeleton.m4  */
5397 #line 2595 "parser.y"
5398     {PASS12 (yyval.id) = concat3((yyvsp[(1) - (3)].id),".",(yyvsp[(3) - (3)].id));free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;}
5399     }
5400     break;
5401
5402
5403
5404     case 113:
5405     if(as3_pass==2) {
5406
5407 /* Line 1464 of skeleton.m4  */
5408 #line 2596 "parser.y"
5409     {PASS12 (yyval.id)=strdup((yyvsp[(1) - (1)].id));}
5410     }
5411     break;
5412
5413
5414
5415     case 114:
5416     if(as3_pass==2) {
5417
5418 /* Line 1464 of skeleton.m4  */
5419 #line 2598 "parser.y"
5420     {PASS12 startpackage((yyvsp[(2) - (3)].id));free((yyvsp[(2) - (3)].id));(yyvsp[(2) - (3)].id)=0;}
5421     }
5422     break;
5423
5424
5425
5426     case 115:
5427     if(as3_pass==2) {
5428
5429 /* Line 1464 of skeleton.m4  */
5430 #line 2599 "parser.y"
5431     {PASS12 endpackage();(yyval.code)=0;}
5432     }
5433     break;
5434
5435
5436
5437     case 116:
5438     if(as3_pass==2) {
5439
5440 /* Line 1464 of skeleton.m4  */
5441 #line 2600 "parser.y"
5442     {PASS12 startpackage("");}
5443     }
5444     break;
5445
5446
5447
5448     case 117:
5449     if(as3_pass==2) {
5450
5451 /* Line 1464 of skeleton.m4  */
5452 #line 2601 "parser.y"
5453     {PASS12 endpackage();(yyval.code)=0;}
5454     }
5455     break;
5456
5457
5458
5459     case 118:
5460     if(as3_pass==2) {
5461
5462 /* Line 1464 of skeleton.m4  */
5463 #line 2603 "parser.y"
5464     {
5465        PASS12
5466        slotinfo_t*s = registry_find((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);
5467        if(!s && as3_pass==1) {// || !(s->flags&FLAG_BUILTIN)) {
5468            as3_schedule_class((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);
5469        }
5470
5471        PASS2
5472        classinfo_t*c = (yyvsp[(2) - (2)].classinfo);
5473        if(!c)
5474             syntaxerror("Couldn't import class\n");
5475        state_has_imports();
5476        dict_put(state->imports, c->name, c);
5477        import_toplevel(c->package);
5478        (yyval.code)=0;
5479 }
5480     }
5481     break;
5482
5483
5484
5485     case 119:
5486     if(as3_pass==2) {
5487
5488 /* Line 1464 of skeleton.m4  */
5489 #line 2619 "parser.y"
5490     {
5491        PASS12
5492        if(strncmp("flash.", (yyvsp[(2) - (4)].id), 6) && as3_pass==1) {
5493            as3_schedule_package((yyvsp[(2) - (4)].id));
5494        }
5495
5496        PASS2
5497        NEW(import_t,i);
5498        i->package = (yyvsp[(2) - (4)].id);
5499        state_has_imports();
5500        list_append(state->wildcard_imports, i);
5501        import_toplevel(i->package);
5502        (yyval.code)=0;
5503 }
5504     }
5505     break;
5506
5507
5508
5509     case 120:
5510     if(as3_pass==2) {
5511
5512 /* Line 1464 of skeleton.m4  */
5513 #line 2636 "parser.y"
5514     {PASS12 (yyval.flags).flags=0;(yyval.flags).ns=0;}
5515     }
5516     break;
5517
5518
5519
5520     case 121:
5521     if(as3_pass==2) {
5522
5523 /* Line 1464 of skeleton.m4  */
5524 #line 2637 "parser.y"
5525     {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}
5526     }
5527     break;
5528
5529
5530
5531     case 122:
5532     if(as3_pass==2) {
5533
5534 /* Line 1464 of skeleton.m4  */
5535 #line 2638 "parser.y"
5536     {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}
5537     }
5538     break;
5539
5540
5541
5542     case 123:
5543     if(as3_pass==2) {
5544
5545 /* Line 1464 of skeleton.m4  */
5546 #line 2639 "parser.y"
5547     {
5548     PASS12
5549     (yyval.flags).flags=(yyvsp[(1) - (2)].flags).flags|(yyvsp[(2) - (2)].flags).flags;
5550     if((yyvsp[(1) - (2)].flags).ns && (yyvsp[(2) - (2)].flags).ns) syntaxerror("only one namespace allowed in one declaration");
5551     (yyval.flags).ns=(yyvsp[(1) - (2)].flags).ns?(yyvsp[(1) - (2)].flags).ns:(yyvsp[(2) - (2)].flags).ns;
5552
5553 }
5554     }
5555     break;
5556
5557
5558
5559     case 124:
5560     if(as3_pass==2) {
5561
5562 /* Line 1464 of skeleton.m4  */
5563 #line 2646 "parser.y"
5564     {PASS12 (yyval.flags).flags=FLAG_PUBLIC;(yyval.flags).ns=0;}
5565     }
5566     break;
5567
5568
5569
5570     case 125:
5571     if(as3_pass==2) {
5572
5573 /* Line 1464 of skeleton.m4  */
5574 #line 2647 "parser.y"
5575     {PASS12 (yyval.flags).flags=FLAG_PRIVATE;(yyval.flags).ns=0;}
5576     }
5577     break;
5578
5579
5580
5581     case 126:
5582     if(as3_pass==2) {
5583
5584 /* Line 1464 of skeleton.m4  */
5585 #line 2648 "parser.y"
5586     {PASS12 (yyval.flags).flags=FLAG_PROTECTED;(yyval.flags).ns=0;}
5587     }
5588     break;
5589
5590
5591
5592     case 127:
5593     if(as3_pass==2) {
5594
5595 /* Line 1464 of skeleton.m4  */
5596 #line 2649 "parser.y"
5597     {PASS12 (yyval.flags).flags=FLAG_STATIC;(yyval.flags).ns=0;}
5598     }
5599     break;
5600
5601
5602
5603     case 128:
5604     if(as3_pass==2) {
5605
5606 /* Line 1464 of skeleton.m4  */
5607 #line 2650 "parser.y"
5608     {PASS12 (yyval.flags).flags=FLAG_DYNAMIC;(yyval.flags).ns=0;}
5609     }
5610     break;
5611
5612
5613
5614     case 129:
5615     if(as3_pass==2) {
5616
5617 /* Line 1464 of skeleton.m4  */
5618 #line 2651 "parser.y"
5619     {PASS12 (yyval.flags).flags=FLAG_FINAL;(yyval.flags).ns=0;}
5620     }
5621     break;
5622
5623
5624
5625     case 130:
5626     if(as3_pass==2) {
5627
5628 /* Line 1464 of skeleton.m4  */
5629 #line 2652 "parser.y"
5630     {PASS12 (yyval.flags).flags=FLAG_OVERRIDE;(yyval.flags).ns=0;}
5631     }
5632     break;
5633
5634
5635
5636     case 131:
5637     if(as3_pass==2) {
5638
5639 /* Line 1464 of skeleton.m4  */
5640 #line 2653 "parser.y"
5641     {PASS12 (yyval.flags).flags=FLAG_NATIVE;(yyval.flags).ns=0;}
5642     }
5643     break;
5644
5645
5646
5647     case 132:
5648     if(as3_pass==2) {
5649
5650 /* Line 1464 of skeleton.m4  */
5651 #line 2654 "parser.y"
5652     {PASS12 (yyval.flags).flags=FLAG_PACKAGEINTERNAL;(yyval.flags).ns=0;}
5653     }
5654     break;
5655
5656
5657
5658     case 133:
5659     if(as3_pass==2) {
5660
5661 /* Line 1464 of skeleton.m4  */
5662 #line 2655 "parser.y"
5663     {PASS12 (yyval.flags).flags=FLAG_NAMESPACE;
5664                                (yyval.flags).ns=(yyvsp[(1) - (1)].id);
5665                        }
5666     }
5667     break;
5668
5669
5670
5671     case 134:
5672     if(as3_pass==2) {
5673
5674 /* Line 1464 of skeleton.m4  */
5675 #line 2659 "parser.y"
5676     {PASS12 (yyval.classinfo)=0;}
5677     }
5678     break;
5679
5680
5681
5682     case 135:
5683     if(as3_pass==2) {
5684
5685 /* Line 1464 of skeleton.m4  */
5686 #line 2660 "parser.y"
5687     {PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
5688     }
5689     break;
5690
5691
5692
5693     case 136:
5694     if(as3_pass==2) {
5695
5696 /* Line 1464 of skeleton.m4  */
5697 #line 2662 "parser.y"
5698     {PASS12 (yyval.classinfo_list)=list_new();}
5699     }
5700     break;
5701
5702
5703
5704     case 137:
5705     if(as3_pass==2) {
5706
5707 /* Line 1464 of skeleton.m4  */
5708 #line 2663 "parser.y"
5709     {PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
5710     }
5711     break;
5712
5713
5714
5715     case 138:
5716     if(as3_pass==2) {
5717
5718 /* Line 1464 of skeleton.m4  */
5719 #line 2665 "parser.y"
5720     {PASS12 (yyval.classinfo_list)=list_new();}
5721     }
5722     break;
5723
5724
5725
5726     case 139:
5727     if(as3_pass==2) {
5728
5729 /* Line 1464 of skeleton.m4  */
5730 #line 2666 "parser.y"
5731     {PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
5732     }
5733     break;
5734
5735
5736
5737     case 140:
5738     if(as3_pass==2) {
5739
5740 /* Line 1464 of skeleton.m4  */
5741 #line 2670 "parser.y"
5742     {PASS12 startclass(&(yyvsp[(1) - (6)].flags),(yyvsp[(3) - (6)].id),(yyvsp[(4) - (6)].classinfo),(yyvsp[(5) - (6)].classinfo_list));}
5743     }
5744     break;
5745
5746
5747
5748     case 141:
5749     if(as3_pass==2) {
5750
5751 /* Line 1464 of skeleton.m4  */
5752 #line 2672 "parser.y"
5753     {PASS12 endclass();(yyval.code)=0;}
5754     }
5755     break;
5756
5757
5758
5759     case 142:
5760     if(as3_pass==2) {
5761
5762 /* Line 1464 of skeleton.m4  */
5763 #line 2676 "parser.y"
5764     {PASS12 (yyvsp[(1) - (5)].flags).flags|=FLAG_INTERFACE;
5765                                           startclass(&(yyvsp[(1) - (5)].flags),(yyvsp[(3) - (5)].id),0,(yyvsp[(4) - (5)].classinfo_list));}
5766     }
5767     break;
5768
5769
5770
5771     case 143:
5772     if(as3_pass==2) {
5773
5774 /* Line 1464 of skeleton.m4  */
5775 #line 2679 "parser.y"
5776     {PASS12 endclass();(yyval.code)=0;}
5777     }
5778     break;
5779
5780
5781
5782     case 152:
5783     if(as3_pass==2) {
5784
5785 /* Line 1464 of skeleton.m4  */
5786 #line 2692 "parser.y"
5787     {
5788     code_t*c = state->cls->static_init->header;
5789     c = code_append(c, (yyvsp[(1) - (1)].code));
5790     state->cls->static_init->header = c;
5791 }
5792     }
5793     break;
5794
5795
5796
5797     case 158:
5798     if(as3_pass==2) {
5799
5800 /* Line 1464 of skeleton.m4  */
5801 #line 2703 "parser.y"
5802     {
5803     syntaxerror("variable declarations not allowed in interfaces");
5804 }
5805     }
5806     break;
5807
5808
5809
5810     case 159:
5811     if(as3_pass==2) {
5812
5813 /* Line 1464 of skeleton.m4  */
5814 #line 2706 "parser.y"
5815     {
5816     PASS12
5817     (yyvsp[(1) - (8)].flags).flags |= FLAG_PUBLIC;
5818     if((yyvsp[(1) - (8)].flags).flags&(FLAG_PRIVATE|FLAG_PACKAGEINTERNAL|FLAG_PROTECTED)) {
5819         syntaxerror("invalid method modifiers: interface methods always need to be public");
5820     }
5821     startfunction(&(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo));
5822     endfunction(&(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo), 0);
5823     list_deep_free((yyvsp[(6) - (8)].params).list);
5824 }
5825     }
5826     break;
5827
5828
5829
5830     case 162:
5831     if(as3_pass==2) {
5832
5833 /* Line 1464 of skeleton.m4  */
5834 #line 2721 "parser.y"
5835     {setslotstate(&(yyvsp[(1) - (2)].flags),(yyvsp[(2) - (2)].token));}
5836     }
5837     break;
5838
5839
5840
5841     case 163:
5842     if(as3_pass==2) {
5843
5844 /* Line 1464 of skeleton.m4  */
5845 #line 2721 "parser.y"
5846     {(yyval.code)=(yyvsp[(4) - (4)].code);setslotstate(0, 0);}
5847     }
5848     break;
5849
5850
5851
5852     case 164:
5853     if(as3_pass==2) {
5854
5855 /* Line 1464 of skeleton.m4  */
5856 #line 2723 "parser.y"
5857     {(yyval.code) = (yyvsp[(1) - (1)].code);}
5858     }
5859     break;
5860
5861
5862
5863     case 165:
5864     if(as3_pass==2) {
5865
5866 /* Line 1464 of skeleton.m4  */
5867 #line 2724 "parser.y"
5868     {(yyval.code) = code_append((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
5869     }
5870     break;
5871
5872
5873
5874     case 166:
5875     if(as3_pass==2) {
5876
5877 /* Line 1464 of skeleton.m4  */
5878 #line 2727 "parser.y"
5879     {
5880     int flags = slotstate_flags->flags;
5881     namespace_t ns = modifiers2access(slotstate_flags);
5882
5883     varinfo_t* info = 0;
5884     if(state->cls) {
5885         memberinfo_t*i = registry_findmember(state->cls->info, ns.name, (yyvsp[(1) - (3)].id), 1);
5886         if(i) {
5887             check_override(i, flags);
5888         }
5889         info = varinfo_register_onclass(state->cls->info, ns.access, ns.name, (yyvsp[(1) - (3)].id));
5890     } else {
5891         slotinfo_t*i = registry_find(state->package, (yyvsp[(1) - (3)].id));
5892         if(i) {
5893             syntaxerror("package %s already contains '%s'", state->package, (yyvsp[(1) - (3)].id));
5894         }
5895         if(ns.name && ns.name[0]) {
5896             syntaxerror("namespaces not allowed on package-level variables");
5897         }
5898         info = varinfo_register_global(ns.access, state->package, (yyvsp[(1) - (3)].id));
5899     }
5900
5901     info->type = (yyvsp[(2) - (3)].classinfo);
5902     info->flags = flags;
5903
5904     /* slot name */
5905     multiname_t mname = {QNAME, &ns, 0, (yyvsp[(1) - (3)].id)};
5906
5907     trait_list_t**traits;
5908     code_t**code;
5909     if(!state->cls) {
5910         // global variable
5911         ns.name = state->package;
5912         traits = &global->init->traits;
5913         code = &global->init->method->body->code;
5914     } else if(flags&FLAG_STATIC) {
5915         // static variable
5916         traits = &state->cls->abc->static_traits;
5917         code = &state->cls->static_init->header;
5918     } else {
5919         // instance variable
5920         traits = &state->cls->abc->traits;
5921         code = &state->cls->init->header;
5922     }
5923
5924     trait_t*t=0;
5925     if((yyvsp[(2) - (3)].classinfo)) {
5926         MULTINAME(m, (yyvsp[(2) - (3)].classinfo));
5927         t = trait_new_member(traits, multiname_clone(&m), multiname_clone(&mname), 0);
5928     } else {
5929         t = trait_new_member(traits, 0, multiname_clone(&mname), 0);
5930     }
5931     info->slot = t->slot_id;
5932
5933     /* initalization code (if needed) */
5934     code_t*c = 0;
5935     if((yyvsp[(3) - (3)].value).c && !is_pushundefined((yyvsp[(3) - (3)].value).c)) {
5936         c = abc_getlocal_0(c);
5937         c = code_append(c, (yyvsp[(3) - (3)].value).c);
5938         c = converttype(c, (yyvsp[(3) - (3)].value).t, (yyvsp[(2) - (3)].classinfo));
5939         c = abc_setslot(c, t->slot_id);
5940     }
5941
5942     *code = code_append(*code, c);
5943
5944     if(slotstate_varconst==KW_CONST) {
5945         t->kind= TRAIT_CONST;
5946     }
5947
5948     (yyval.code)=0;
5949 }
5950     }
5951     break;
5952
5953
5954
5955     case 167:
5956     if(as3_pass==2) {
5957
5958 /* Line 1464 of skeleton.m4  */
5959 #line 2801 "parser.y"
5960     {(yyval.constant)=0;}
5961     }
5962     break;
5963
5964
5965
5966     case 168:
5967     if(as3_pass==2) {
5968
5969 /* Line 1464 of skeleton.m4  */
5970 #line 2802 "parser.y"
5971     {(yyval.constant)=(yyvsp[(2) - (2)].constant);}
5972     }
5973     break;
5974
5975
5976
5977     case 169:
5978     if(as3_pass==2) {
5979
5980 /* Line 1464 of skeleton.m4  */
5981 #line 2804 "parser.y"
5982     {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_uint));}
5983     }
5984     break;
5985
5986
5987
5988     case 170:
5989     if(as3_pass==2) {
5990
5991 /* Line 1464 of skeleton.m4  */
5992 #line 2805 "parser.y"
5993     {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_int));}
5994     }
5995     break;
5996
5997
5998
5999     case 171:
6000     if(as3_pass==2) {
6001
6002 /* Line 1464 of skeleton.m4  */
6003 #line 2806 "parser.y"
6004     {(yyval.constant) = constant_new_uint((yyvsp[(1) - (1)].number_uint));}
6005     }
6006     break;
6007
6008
6009
6010     case 172:
6011     if(as3_pass==2) {
6012
6013 /* Line 1464 of skeleton.m4  */
6014 #line 2807 "parser.y"
6015     {(yyval.constant) = constant_new_float((yyvsp[(1) - (1)].number_float));}
6016     }
6017     break;
6018
6019
6020
6021     case 173:
6022     if(as3_pass==2) {
6023
6024 /* Line 1464 of skeleton.m4  */
6025 #line 2808 "parser.y"
6026     {(yyval.constant) = constant_new_string2((yyvsp[(1) - (1)].str).str,(yyvsp[(1) - (1)].str).len);free((char*)(yyvsp[(1) - (1)].str).str);}
6027     }
6028     break;
6029
6030
6031
6032     case 174:
6033     if(as3_pass==2) {
6034
6035 /* Line 1464 of skeleton.m4  */
6036 #line 2810 "parser.y"
6037     {(yyval.constant) = constant_new_true((yyvsp[(1) - (1)].token));}
6038     }
6039     break;
6040
6041
6042
6043     case 175:
6044     if(as3_pass==2) {
6045
6046 /* Line 1464 of skeleton.m4  */
6047 #line 2811 "parser.y"
6048     {(yyval.constant) = constant_new_false((yyvsp[(1) - (1)].token));}
6049     }
6050     break;
6051
6052
6053
6054     case 176:
6055     if(as3_pass==2) {
6056
6057 /* Line 1464 of skeleton.m4  */
6058 #line 2812 "parser.y"
6059     {(yyval.constant) = constant_new_null((yyvsp[(1) - (1)].token));}
6060     }
6061     break;
6062
6063
6064
6065     case 177:
6066     if(as3_pass==2) {
6067
6068 /* Line 1464 of skeleton.m4  */
6069 #line 2813 "parser.y"
6070     {
6071     if(!strcmp((yyvsp[(1) - (1)].id), "NaN")) {
6072         (yyval.constant) = constant_new_float(__builtin_nan(""));
6073     } else {
6074         as3_warning("Couldn't evaluate constant value of %s", (yyvsp[(1) - (1)].id));
6075         (yyval.constant) = constant_new_null((yyvsp[(1) - (1)].id));
6076     }
6077 }
6078     }
6079     break;
6080
6081
6082
6083     case 178:
6084     if(as3_pass==2) {
6085
6086 /* Line 1464 of skeleton.m4  */
6087 #line 2825 "parser.y"
6088     {
6089     PASS12
6090     memset(&(yyval.params),0,sizeof((yyval.params)));
6091 }
6092     }
6093     break;
6094
6095
6096
6097     case 179:
6098     if(as3_pass==2) {
6099
6100 /* Line 1464 of skeleton.m4  */
6101 #line 2829 "parser.y"
6102     {
6103     PASS12
6104     (yyval.params)=(yyvsp[(1) - (1)].params);
6105 }
6106     }
6107     break;
6108
6109
6110
6111     case 180:
6112     if(as3_pass==2) {
6113
6114 /* Line 1464 of skeleton.m4  */
6115 #line 2835 "parser.y"
6116     {
6117     PASS12
6118     memset(&(yyval.params),0,sizeof((yyval.params)));
6119     (yyval.params).varargs=1;
6120     list_append((yyval.params).list, (yyvsp[(2) - (2)].param));
6121 }
6122     }
6123     break;
6124
6125
6126
6127     case 181:
6128     if(as3_pass==2) {
6129
6130 /* Line 1464 of skeleton.m4  */
6131 #line 2841 "parser.y"
6132     {
6133     PASS12
6134     (yyval.params) =(yyvsp[(1) - (4)].params);
6135     (yyval.params).varargs=1;
6136     list_append((yyval.params).list, (yyvsp[(4) - (4)].param));
6137 }
6138     }
6139     break;
6140
6141
6142
6143     case 182:
6144     if(as3_pass==2) {
6145
6146 /* Line 1464 of skeleton.m4  */
6147 #line 2849 "parser.y"
6148     {
6149     PASS12
6150     (yyval.params) = (yyvsp[(1) - (3)].params);
6151     list_append((yyval.params).list, (yyvsp[(3) - (3)].param));
6152 }
6153     }
6154     break;
6155
6156
6157
6158     case 183:
6159     if(as3_pass==2) {
6160
6161 /* Line 1464 of skeleton.m4  */
6162 #line 2854 "parser.y"
6163     {
6164     PASS12
6165     memset(&(yyval.params),0,sizeof((yyval.params)));
6166     list_append((yyval.params).list, (yyvsp[(1) - (1)].param));
6167 }
6168     }
6169     break;
6170
6171
6172
6173     case 184:
6174     if(as3_pass==2) {
6175
6176 /* Line 1464 of skeleton.m4  */
6177 #line 2860 "parser.y"
6178     {
6179      PASS12
6180      (yyval.param) = rfx_calloc(sizeof(param_t));
6181      (yyval.param)->name=(yyvsp[(1) - (4)].id);
6182      (yyval.param)->type = (yyvsp[(3) - (4)].classinfo);
6183      PASS2
6184      (yyval.param)->value = (yyvsp[(4) - (4)].constant);
6185 }
6186     }
6187     break;
6188
6189
6190
6191     case 185:
6192     if(as3_pass==2) {
6193
6194 /* Line 1464 of skeleton.m4  */
6195 #line 2868 "parser.y"
6196     {
6197      PASS12
6198      (yyval.param) = rfx_calloc(sizeof(param_t));
6199      (yyval.param)->name=(yyvsp[(1) - (2)].id);
6200      (yyval.param)->type = TYPE_ANY;
6201      PASS2
6202      (yyval.param)->value = (yyvsp[(2) - (2)].constant);
6203 }
6204     }
6205     break;
6206
6207
6208
6209     case 188:
6210     if(as3_pass==2) {
6211
6212 /* Line 1464 of skeleton.m4  */
6213 #line 2878 "parser.y"
6214     {PASS12 (yyval.token)=0;}
6215     }
6216     break;
6217
6218
6219
6220     case 189:
6221     if(as3_pass==2) {
6222
6223 /* Line 1464 of skeleton.m4  */
6224 #line 2881 "parser.y"
6225     {PASS12 startfunction(&(yyvsp[(1) - (9)].flags),(yyvsp[(3) - (9)].token),(yyvsp[(4) - (9)].id),&(yyvsp[(6) - (9)].params),(yyvsp[(8) - (9)].classinfo));}
6226     }
6227     break;
6228
6229
6230
6231     case 190:
6232     if(as3_pass==2) {
6233
6234 /* Line 1464 of skeleton.m4  */
6235 #line 2882 "parser.y"
6236     {
6237     PASS1
6238     endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),0,0);
6239     PASS2
6240     if(!state->method->info) syntaxerror("internal error");
6241
6242     code_t*c = method_header(state->method);
6243     c = wrap_function(c, 0, (yyvsp[(11) - (12)].code));
6244
6245     endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),(yyvsp[(8) - (12)].classinfo),c);
6246     PASS12
6247     list_deep_free((yyvsp[(6) - (12)].params).list);
6248     (yyval.code)=0;
6249 }
6250     }
6251     break;
6252
6253
6254
6255     case 192:
6256     if(as3_pass==2) {
6257
6258 /* Line 1464 of skeleton.m4  */
6259 #line 2898 "parser.y"
6260     {PASS12 (yyval.id)=0;}
6261     }
6262     break;
6263
6264
6265
6266     case 193:
6267     if(as3_pass==2) {
6268
6269 /* Line 1464 of skeleton.m4  */
6270 #line 2900 "parser.y"
6271     {PASS12 innerfunction((yyvsp[(2) - (7)].id),&(yyvsp[(4) - (7)].params),(yyvsp[(6) - (7)].classinfo));}
6272     }
6273     break;
6274
6275
6276
6277     case 194:
6278     if(as3_pass==2) {
6279
6280 /* Line 1464 of skeleton.m4  */
6281 #line 2901 "parser.y"
6282     {
6283     PASS1
6284     endfunction(0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),0,0);
6285     PASS2
6286     methodinfo_t*f = state->method->info;
6287     if(!f || !f->kind) syntaxerror("internal error");
6288
6289     code_t*c = method_header(state->method);
6290     c = wrap_function(c, 0, (yyvsp[(9) - (10)].code));
6291
6292     int index = state->method->var_index;
6293     endfunction(0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),(yyvsp[(6) - (10)].classinfo),c);
6294
6295     (yyval.value).c = abc_getlocal(0, index);
6296     (yyval.value).t = TYPE_FUNCTION(f);
6297
6298     PASS12 list_deep_free((yyvsp[(4) - (10)].params).list);
6299 }
6300     }
6301     break;
6302
6303
6304
6305     case 195:
6306     if(as3_pass==2) {
6307
6308 /* Line 1464 of skeleton.m4  */
6309 #line 2923 "parser.y"
6310     {
6311     PASS1 NEW(unresolvedinfo_t,c);
6312           memset(c, 0, sizeof(*c));
6313           c->kind = INFOTYPE_UNRESOLVED;
6314           c->name = (yyvsp[(1) - (1)].id);
6315           c->package = get_package_from_name((yyvsp[(1) - (1)].id));
6316           if(!c->package) {
6317               c->nsset = get_current_imports();
6318               /* make the compiler look for this class in the current directory,
6319                  just in case: */
6320               as3_schedule_class_noerror(state->package, (yyvsp[(1) - (1)].id));
6321           }
6322           (yyval.classinfo) = (classinfo_t*)c;
6323     PASS2
6324     slotinfo_t*s = find_class((yyvsp[(1) - (1)].id));
6325     if(!s) syntaxerror("Could not find class/method %s (current package: %s)\n", (yyvsp[(1) - (1)].id), state->package);
6326     (yyval.classinfo) = (classinfo_t*)s;
6327 }
6328     }
6329     break;
6330
6331
6332
6333     case 196:
6334     if(as3_pass==2) {
6335
6336 /* Line 1464 of skeleton.m4  */
6337 #line 2942 "parser.y"
6338     {
6339     PASS1 NEW(unresolvedinfo_t,c);
6340           memset(c, 0, sizeof(*c));
6341           c->kind = INFOTYPE_UNRESOLVED;
6342           c->package = (yyvsp[(1) - (3)].id);
6343           c->name = (yyvsp[(3) - (3)].id);
6344           (yyval.classinfo) = (classinfo_t*)c;
6345     PASS2
6346     slotinfo_t*s = registry_find((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
6347     if(!s) syntaxerror("Couldn't find class/method %s.%s\n", (yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
6348     free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;
6349     (yyval.classinfo) = (classinfo_t*)s;
6350 }
6351     }
6352     break;
6353
6354
6355
6356     case 199:
6357     if(as3_pass==2) {
6358
6359 /* Line 1464 of skeleton.m4  */
6360 #line 2959 "parser.y"
6361     {PASS12 (yyval.classinfo_list)=list_new();list_append((yyval.classinfo_list), (yyvsp[(1) - (1)].classinfo));}
6362     }
6363     break;
6364
6365
6366
6367     case 200:
6368     if(as3_pass==2) {
6369
6370 /* Line 1464 of skeleton.m4  */
6371 #line 2960 "parser.y"
6372     {PASS12 (yyval.classinfo_list)=(yyvsp[(1) - (3)].classinfo_list);list_append((yyval.classinfo_list),(yyvsp[(3) - (3)].classinfo));}
6373     }
6374     break;
6375
6376
6377
6378     case 201:
6379     if(as3_pass==2) {
6380
6381 /* Line 1464 of skeleton.m4  */
6382 #line 2962 "parser.y"
6383     {PASS12 (yyval.classinfo)=(yyvsp[(1) - (1)].classinfo);}
6384     }
6385     break;
6386
6387
6388
6389     case 202:
6390     if(as3_pass==2) {
6391
6392 /* Line 1464 of skeleton.m4  */
6393 #line 2963 "parser.y"
6394     {PASS12 (yyval.classinfo)=registry_getanytype();}
6395     }
6396     break;
6397
6398
6399
6400     case 203:
6401     if(as3_pass==2) {
6402
6403 /* Line 1464 of skeleton.m4  */
6404 #line 2964 "parser.y"
6405     {PASS12 (yyval.classinfo)=registry_getanytype();}
6406     }
6407     break;
6408
6409
6410
6411     case 204:
6412     if(as3_pass==2) {
6413
6414 /* Line 1464 of skeleton.m4  */
6415 #line 2973 "parser.y"
6416     {PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
6417     }
6418     break;
6419
6420
6421
6422     case 205:
6423     if(as3_pass==2) {
6424
6425 /* Line 1464 of skeleton.m4  */
6426 #line 2974 "parser.y"
6427     {PASS12 (yyval.classinfo)=0;}
6428     }
6429     break;
6430
6431
6432
6433     case 206:
6434     if(as3_pass==2) {
6435
6436 /* Line 1464 of skeleton.m4  */
6437 #line 2978 "parser.y"
6438     {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
6439     }
6440     break;
6441
6442
6443
6444     case 207:
6445     if(as3_pass==2) {
6446
6447 /* Line 1464 of skeleton.m4  */
6448 #line 2979 "parser.y"
6449     {(yyval.value_list)=(yyvsp[(2) - (3)].value_list);}
6450     }
6451     break;
6452
6453
6454
6455     case 208:
6456     if(as3_pass==2) {
6457
6458 /* Line 1464 of skeleton.m4  */
6459 #line 2981 "parser.y"
6460     {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
6461     }
6462     break;
6463
6464
6465
6466     case 211:
6467     if(as3_pass==2) {
6468
6469 /* Line 1464 of skeleton.m4  */
6470 #line 2985 "parser.y"
6471     {(yyval.value_list).number=1;
6472                                                   (yyval.value_list).cc = (yyvsp[(1) - (1)].value).c;
6473                                                  }
6474     }
6475     break;
6476
6477
6478
6479     case 212:
6480     if(as3_pass==2) {
6481
6482 /* Line 1464 of skeleton.m4  */
6483 #line 2989 "parser.y"
6484     {(yyval.value_list) = (yyvsp[(1) - (2)].value_list);}
6485     }
6486     break;
6487
6488
6489
6490     case 213:
6491     if(as3_pass==2) {
6492
6493 /* Line 1464 of skeleton.m4  */
6494 #line 2990 "parser.y"
6495     {
6496                                                   (yyval.value_list).number= (yyvsp[(1) - (2)].value_list).number+1;
6497                                                   (yyval.value_list).cc = code_append((yyvsp[(1) - (2)].value_list).cc, (yyvsp[(2) - (2)].value).c);
6498                                                   }
6499     }
6500     break;
6501
6502
6503
6504     case 215:
6505     if(as3_pass==2) {
6506
6507 /* Line 1464 of skeleton.m4  */
6508 #line 2996 "parser.y"
6509     {
6510     (yyval.value).c = (yyvsp[(2) - (4)].value).c;
6511     if((yyval.value).c->opcode == OPCODE_COERCE_A) (yyval.value).c = code_cutlast((yyval.value).c);
6512
6513     code_t*paramcode = (yyvsp[(4) - (4)].value_list).cc;
6514     if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
6515         multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
6516         (yyval.value).c = code_cutlast((yyval.value).c);
6517         (yyval.value).c = code_append((yyval.value).c, paramcode);
6518         (yyval.value).c = abc_constructprop2((yyval.value).c, name, (yyvsp[(4) - (4)].value_list).number);
6519         multiname_destroy(name);
6520     } else if((yyval.value).c->opcode == OPCODE_GETSLOT) {
6521         int slot = (int)(ptroff_t)(yyval.value).c->data[0];
6522         trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);//FIXME
6523         multiname_t*name = t->name;
6524         (yyval.value).c = code_cutlast((yyval.value).c);
6525         (yyval.value).c = code_append((yyval.value).c, paramcode);
6526         (yyval.value).c = abc_constructprop2((yyval.value).c, name, (yyvsp[(4) - (4)].value_list).number);
6527     } else {
6528         (yyval.value).c = code_append((yyval.value).c, paramcode);
6529         (yyval.value).c = abc_construct((yyval.value).c, (yyvsp[(4) - (4)].value_list).number);
6530     }
6531
6532     (yyval.value).t = TYPE_ANY;
6533     if(TYPE_IS_CLASS((yyvsp[(2) - (4)].value).t) && (yyvsp[(2) - (4)].value).t->data) {
6534         (yyval.value).t = (yyvsp[(2) - (4)].value).t->data;
6535     } else {
6536         (yyval.value).c = abc_coerce_a((yyval.value).c);
6537         (yyval.value).t = TYPE_ANY;
6538     }
6539 }
6540     }
6541     break;
6542
6543
6544
6545     case 216:
6546     if(as3_pass==2) {
6547
6548 /* Line 1464 of skeleton.m4  */
6549 #line 3032 "parser.y"
6550     {
6551
6552     (yyval.value).c = (yyvsp[(1) - (4)].value).c;
6553     if((yyval.value).c->opcode == OPCODE_COERCE_A) {
6554         (yyval.value).c = code_cutlast((yyval.value).c);
6555     }
6556     code_t*paramcode = (yyvsp[(3) - (4)].value_list).cc;
6557
6558     (yyval.value).t = TYPE_ANY;
6559     if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
6560         multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
6561         (yyval.value).c = code_cutlast((yyval.value).c);
6562         (yyval.value).c = code_append((yyval.value).c, paramcode);
6563         (yyval.value).c = abc_callproperty2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);
6564         multiname_destroy(name);
6565     } else if((yyval.value).c->opcode == OPCODE_GETSLOT && (yyval.value).c->prev->opcode != OPCODE_GETSCOPEOBJECT) {
6566         int slot = (int)(ptroff_t)(yyval.value).c->data[0];
6567         trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);
6568         if(t->kind!=TRAIT_METHOD) {
6569             //ok: flash allows to assign closures to members.
6570         }
6571         multiname_t*name = t->name;
6572         (yyval.value).c = code_cutlast((yyval.value).c);
6573         (yyval.value).c = code_append((yyval.value).c, paramcode);
6574         //$$.c = abc_callmethod($$.c, t->method, len); //#1051 illegal early access binding
6575         (yyval.value).c = abc_callproperty2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);
6576     } else if((yyval.value).c->opcode == OPCODE_GETSUPER) {
6577         multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
6578         (yyval.value).c = code_cutlast((yyval.value).c);
6579         (yyval.value).c = code_append((yyval.value).c, paramcode);
6580         (yyval.value).c = abc_callsuper2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);
6581         multiname_destroy(name);
6582     } else {
6583         (yyval.value).c = abc_getglobalscope((yyval.value).c);
6584         (yyval.value).c = code_append((yyval.value).c, paramcode);
6585         (yyval.value).c = abc_call((yyval.value).c, (yyvsp[(3) - (4)].value_list).number);
6586     }
6587
6588     if(TYPE_IS_FUNCTION((yyvsp[(1) - (4)].value).t) && (yyvsp[(1) - (4)].value).t->data) {
6589         (yyval.value).t = ((methodinfo_t*)((yyvsp[(1) - (4)].value).t->data))->return_type;
6590     } else {
6591         (yyval.value).c = abc_coerce_a((yyval.value).c);
6592         (yyval.value).t = TYPE_ANY;
6593     }
6594 }
6595     }
6596     break;
6597
6598
6599
6600     case 217:
6601     if(as3_pass==2) {
6602
6603 /* Line 1464 of skeleton.m4  */
6604 #line 3078 "parser.y"
6605     {
6606     if(!state->cls) syntaxerror("super() not allowed outside of a class");
6607     if(!state->method) syntaxerror("super() not allowed outside of a function");
6608     if(!state->method->is_constructor) syntaxerror("super() not allowed outside of a constructor");
6609
6610     (yyval.value).c = code_new();
6611     (yyval.value).c = abc_getlocal_0((yyval.value).c);
6612
6613     (yyval.value).c = code_append((yyval.value).c, (yyvsp[(3) - (4)].value_list).cc);
6614     /*
6615     this is dependent on the control path, check this somewhere else
6616     if(state->method->has_super)
6617         syntaxerror("constructor may call super() only once");
6618     */
6619     state->method->has_super = 1;
6620
6621     (yyval.value).c = abc_constructsuper((yyval.value).c, (yyvsp[(3) - (4)].value_list).number);
6622     (yyval.value).c = abc_pushundefined((yyval.value).c);
6623     (yyval.value).t = TYPE_ANY;
6624 }
6625     }
6626     break;
6627
6628
6629
6630     case 218:
6631     if(as3_pass==2) {
6632
6633 /* Line 1464 of skeleton.m4  */
6634 #line 3099 "parser.y"
6635     {
6636     (yyval.value).c = (yyvsp[(2) - (2)].value).c;
6637     if((yyval.value).c->opcode == OPCODE_COERCE_A) {
6638         (yyval.value).c = code_cutlast((yyval.value).c);
6639     }
6640     multiname_t*name = 0;
6641     if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
6642         (yyval.value).c->opcode = OPCODE_DELETEPROPERTY;
6643     } else if((yyval.value).c->opcode == OPCODE_GETSLOT) {
6644         int slot = (int)(ptroff_t)(yyval.value).c->data[0];
6645         multiname_t*name = traits_find_slotid(state->cls->abc->traits,slot)->name;
6646         (yyval.value).c = code_cutlast((yyval.value).c);
6647         (yyval.value).c = abc_deleteproperty2((yyval.value).c, name);
6648     } else {
6649         (yyval.value).c = abc_getlocal_0((yyval.value).c);
6650         MULTINAME_LATE(m, (yyvsp[(2) - (2)].value).t?(yyvsp[(2) - (2)].value).t->access:ACCESS_PACKAGE, "");
6651         (yyval.value).c = abc_deleteproperty2((yyval.value).c, &m);
6652     }
6653     (yyval.value).t = TYPE_BOOLEAN;
6654 }
6655     }
6656     break;
6657
6658
6659
6660     case 219:
6661     if(as3_pass==2) {
6662
6663 /* Line 1464 of skeleton.m4  */
6664 #line 3120 "parser.y"
6665     {
6666     (yyval.code) = abc_returnvoid(0);
6667 }
6668     }
6669     break;
6670
6671
6672
6673     case 220:
6674     if(as3_pass==2) {
6675
6676 /* Line 1464 of skeleton.m4  */
6677 #line 3123 "parser.y"
6678     {
6679     (yyval.code) = (yyvsp[(2) - (2)].value).c;
6680     (yyval.code) = abc_returnvalue((yyval.code));
6681 }
6682     }
6683     break;
6684
6685
6686
6687     case 221:
6688     if(as3_pass==2) {
6689
6690 /* Line 1464 of skeleton.m4  */
6691 #line 3130 "parser.y"
6692     {(yyval.value)=(yyvsp[(1) - (1)].value);}
6693     }
6694     break;
6695
6696
6697
6698     case 222:
6699     if(as3_pass==2) {
6700
6701 /* Line 1464 of skeleton.m4  */
6702 #line 3131 "parser.y"
6703     {(yyval.value) = (yyvsp[(1) - (1)].value);}
6704     }
6705     break;
6706
6707
6708
6709     case 223:
6710     if(as3_pass==2) {
6711
6712 /* Line 1464 of skeleton.m4  */
6713 #line 3132 "parser.y"
6714     {
6715     (yyval.value).c = (yyvsp[(1) - (3)].value).c;
6716     (yyval.value).c = cut_last_push((yyval.value).c);
6717     (yyval.value).c = code_append((yyval.value).c,(yyvsp[(3) - (3)].value).c);
6718     (yyval.value).t = (yyvsp[(3) - (3)].value).t;
6719 }
6720     }
6721     break;
6722
6723
6724
6725     case 224:
6726     if(as3_pass==2) {
6727
6728 /* Line 1464 of skeleton.m4  */
6729 #line 3138 "parser.y"
6730     {
6731     (yyval.code)=cut_last_push((yyvsp[(1) - (1)].value).c);
6732 }
6733     }
6734     break;
6735
6736
6737
6738     case 225:
6739     if(as3_pass==2) {
6740
6741 /* Line 1464 of skeleton.m4  */
6742 #line 3144 "parser.y"
6743     {(yyval.value) = (yyvsp[(1) - (1)].value);}
6744     }
6745     break;
6746
6747
6748
6749     case 227:
6750     if(as3_pass==2) {
6751
6752 /* Line 1464 of skeleton.m4  */
6753 #line 3148 "parser.y"
6754     {(yyval.value) = (yyvsp[(1) - (1)].value);}
6755     }
6756     break;
6757
6758
6759
6760     case 228:
6761     if(as3_pass==2) {
6762
6763 /* Line 1464 of skeleton.m4  */
6764 #line 3150 "parser.y"
6765     {(yyval.value) = (yyvsp[(1) - (1)].value);}
6766     }
6767     break;
6768
6769
6770
6771     case 229:
6772     if(as3_pass==2) {
6773
6774 /* Line 1464 of skeleton.m4  */
6775 #line 3152 "parser.y"
6776     {(yyval.value) = (yyvsp[(1) - (1)].value);}
6777     }
6778     break;
6779
6780
6781
6782     case 231:
6783     if(as3_pass==2) {
6784
6785 /* Line 1464 of skeleton.m4  */
6786 #line 3156 "parser.y"
6787     {
6788     (yyval.value).c = 0;
6789     namespace_t ns = {ACCESS_PACKAGE, ""};
6790     multiname_t m = {QNAME, &ns, 0, "RegExp"};
6791     if(!(yyvsp[(1) - (1)].regexp).options) {
6792         (yyval.value).c = abc_getlex2((yyval.value).c, &m);
6793         (yyval.value).c = abc_pushstring((yyval.value).c, (yyvsp[(1) - (1)].regexp).pattern);
6794         (yyval.value).c = abc_construct((yyval.value).c, 1);
6795     } else {
6796         (yyval.value).c = abc_getlex2((yyval.value).c, &m);
6797         (yyval.value).c = abc_pushstring((yyval.value).c, (yyvsp[(1) - (1)].regexp).pattern);
6798         (yyval.value).c = abc_pushstring((yyval.value).c, (yyvsp[(1) - (1)].regexp).options);
6799         (yyval.value).c = abc_construct((yyval.value).c, 2);
6800     }
6801     (yyval.value).t = TYPE_REGEXP;
6802 }
6803     }
6804     break;
6805
6806
6807
6808     case 232:
6809     if(as3_pass==2) {
6810
6811 /* Line 1464 of skeleton.m4  */
6812 #line 3173 "parser.y"
6813     {(yyval.value).c = abc_pushbyte(0, (yyvsp[(1) - (1)].number_uint));
6814                    //MULTINAME(m, registry_getintclass());
6815                    //$$.c = abc_coerce2($$.c, &m); // FIXME
6816                    (yyval.value).t = TYPE_INT;
6817                   }
6818     }
6819     break;
6820
6821
6822
6823     case 233:
6824     if(as3_pass==2) {
6825
6826 /* Line 1464 of skeleton.m4  */
6827 #line 3178 "parser.y"
6828     {(yyval.value).c = abc_pushshort(0, (yyvsp[(1) - (1)].number_uint));
6829                     (yyval.value).t = TYPE_INT;
6830                    }
6831     }
6832     break;
6833
6834
6835
6836     case 234:
6837     if(as3_pass==2) {
6838
6839 /* Line 1464 of skeleton.m4  */
6840 #line 3181 "parser.y"
6841     {(yyval.value).c = abc_pushint(0, (yyvsp[(1) - (1)].number_int));
6842                   (yyval.value).t = TYPE_INT;
6843                  }
6844     }
6845     break;
6846
6847
6848
6849     case 235:
6850     if(as3_pass==2) {
6851
6852 /* Line 1464 of skeleton.m4  */
6853 #line 3184 "parser.y"
6854     {(yyval.value).c = abc_pushuint(0, (yyvsp[(1) - (1)].number_uint));
6855                    (yyval.value).t = TYPE_UINT;
6856                   }
6857     }
6858     break;
6859
6860
6861
6862     case 236:
6863     if(as3_pass==2) {
6864
6865 /* Line 1464 of skeleton.m4  */
6866 #line 3187 "parser.y"
6867     {(yyval.value).c = abc_pushdouble(0, (yyvsp[(1) - (1)].number_float));
6868                     (yyval.value).t = TYPE_FLOAT;
6869                    }
6870     }
6871     break;
6872
6873
6874
6875     case 237:
6876     if(as3_pass==2) {
6877
6878 /* Line 1464 of skeleton.m4  */
6879 #line 3190 "parser.y"
6880     {(yyval.value).c = abc_pushstring2(0, &(yyvsp[(1) - (1)].str));free((char*)(yyvsp[(1) - (1)].str).str);
6881                      (yyval.value).t = TYPE_STRING;
6882                     }
6883     }
6884     break;
6885
6886
6887
6888     case 238:
6889     if(as3_pass==2) {
6890
6891 /* Line 1464 of skeleton.m4  */
6892 #line 3193 "parser.y"
6893     {(yyval.value).c = abc_pushundefined(0);
6894                     (yyval.value).t = TYPE_ANY;
6895                    }
6896     }
6897     break;
6898
6899
6900
6901     case 239:
6902     if(as3_pass==2) {
6903
6904 /* Line 1464 of skeleton.m4  */
6905 #line 3196 "parser.y"
6906     {(yyval.value).c = abc_pushtrue(0);
6907                     (yyval.value).t = TYPE_BOOLEAN;
6908                    }
6909     }
6910     break;
6911
6912
6913
6914     case 240:
6915     if(as3_pass==2) {
6916
6917 /* Line 1464 of skeleton.m4  */
6918 #line 3199 "parser.y"
6919     {(yyval.value).c = abc_pushfalse(0);
6920                      (yyval.value).t = TYPE_BOOLEAN;
6921                     }
6922     }
6923     break;
6924
6925
6926
6927     case 241:
6928     if(as3_pass==2) {
6929
6930 /* Line 1464 of skeleton.m4  */
6931 #line 3202 "parser.y"
6932     {(yyval.value).c = abc_pushnull(0);
6933                     (yyval.value).t = TYPE_NULL;
6934                    }
6935     }
6936     break;
6937
6938
6939
6940     case 242:
6941     if(as3_pass==2) {
6942
6943 /* Line 1464 of skeleton.m4  */
6944 #line 3206 "parser.y"
6945     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_greaterequals((yyval.value).c);(yyval.value).c=abc_not((yyval.value).c);
6946              (yyval.value).t = TYPE_BOOLEAN;
6947             }
6948     }
6949     break;
6950
6951
6952
6953     case 243:
6954     if(as3_pass==2) {
6955
6956 /* Line 1464 of skeleton.m4  */
6957 #line 3209 "parser.y"
6958     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_greaterthan((yyval.value).c);
6959              (yyval.value).t = TYPE_BOOLEAN;
6960             }
6961     }
6962     break;
6963
6964
6965
6966     case 244:
6967     if(as3_pass==2) {
6968
6969 /* Line 1464 of skeleton.m4  */
6970 #line 3212 "parser.y"
6971     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_greaterthan((yyval.value).c);(yyval.value).c=abc_not((yyval.value).c);
6972               (yyval.value).t = TYPE_BOOLEAN;
6973              }
6974     }
6975     break;
6976
6977
6978
6979     case 245:
6980     if(as3_pass==2) {
6981
6982 /* Line 1464 of skeleton.m4  */
6983 #line 3215 "parser.y"
6984     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_greaterequals((yyval.value).c);
6985               (yyval.value).t = TYPE_BOOLEAN;
6986              }
6987     }
6988     break;
6989
6990
6991
6992     case 246:
6993     if(as3_pass==2) {
6994
6995 /* Line 1464 of skeleton.m4  */
6996 #line 3218 "parser.y"
6997     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_equals((yyval.value).c);
6998               (yyval.value).t = TYPE_BOOLEAN;
6999              }
7000     }
7001     break;
7002
7003
7004
7005     case 247:
7006     if(as3_pass==2) {
7007
7008 /* Line 1464 of skeleton.m4  */
7009 #line 3221 "parser.y"
7010     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_strictequals((yyval.value).c);
7011               (yyval.value).t = TYPE_BOOLEAN;
7012               }
7013     }
7014     break;
7015
7016
7017
7018     case 248:
7019     if(as3_pass==2) {
7020
7021 /* Line 1464 of skeleton.m4  */
7022 #line 3224 "parser.y"
7023     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_strictequals((yyval.value).c);(yyval.value).c = abc_not((yyval.value).c);
7024               (yyval.value).t = TYPE_BOOLEAN;
7025              }
7026     }
7027     break;
7028
7029
7030
7031     case 249:
7032     if(as3_pass==2) {
7033
7034 /* Line 1464 of skeleton.m4  */
7035 #line 3227 "parser.y"
7036     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_equals((yyval.value).c);(yyval.value).c = abc_not((yyval.value).c);
7037               (yyval.value).t = TYPE_BOOLEAN;
7038              }
7039     }
7040     break;
7041
7042
7043
7044     case 250:
7045     if(as3_pass==2) {
7046
7047 /* Line 1464 of skeleton.m4  */
7048 #line 3231 "parser.y"
7049     {(yyval.value).t = join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, 'O');
7050               (yyval.value).c = (yyvsp[(1) - (3)].value).c;
7051               (yyval.value).c = converttype((yyval.value).c, (yyvsp[(1) - (3)].value).t, (yyval.value).t);
7052               (yyval.value).c = abc_dup((yyval.value).c);
7053               code_t*jmp = (yyval.value).c = abc_iftrue((yyval.value).c, 0);
7054               (yyval.value).c = cut_last_push((yyval.value).c);
7055               (yyval.value).c = code_append((yyval.value).c,(yyvsp[(3) - (3)].value).c);
7056               (yyval.value).c = converttype((yyval.value).c, (yyvsp[(3) - (3)].value).t, (yyval.value).t);
7057               code_t*label = (yyval.value).c = abc_label((yyval.value).c);
7058               jmp->branch = label;
7059              }
7060     }
7061     break;
7062
7063
7064
7065     case 251:
7066     if(as3_pass==2) {
7067
7068 /* Line 1464 of skeleton.m4  */
7069 #line 3242 "parser.y"
7070     {
7071               (yyval.value).t = join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, 'A');
7072               /*printf("%08x:\n",$1.t);
7073               code_dump($1.c, 0, 0, "", stdout);
7074               printf("%08x:\n",$3.t);
7075               code_dump($3.c, 0, 0, "", stdout);
7076               printf("joining %08x and %08x to %08x\n", $1.t, $3.t, $$.t);*/
7077               (yyval.value).c = (yyvsp[(1) - (3)].value).c;
7078               (yyval.value).c = converttype((yyval.value).c, (yyvsp[(1) - (3)].value).t, (yyval.value).t);
7079               (yyval.value).c = abc_dup((yyval.value).c);
7080               code_t*jmp = (yyval.value).c = abc_iffalse((yyval.value).c, 0);
7081               (yyval.value).c = cut_last_push((yyval.value).c);
7082               (yyval.value).c = code_append((yyval.value).c,(yyvsp[(3) - (3)].value).c);
7083               (yyval.value).c = converttype((yyval.value).c, (yyvsp[(3) - (3)].value).t, (yyval.value).t);
7084               code_t*label = (yyval.value).c = abc_label((yyval.value).c);
7085               jmp->branch = label;
7086              }
7087     }
7088     break;
7089
7090
7091
7092     case 252:
7093     if(as3_pass==2) {
7094
7095 /* Line 1464 of skeleton.m4  */
7096 #line 3260 "parser.y"
7097     {(yyval.value).c=(yyvsp[(2) - (2)].value).c;
7098               (yyval.value).c = abc_not((yyval.value).c);
7099               (yyval.value).t = TYPE_BOOLEAN;
7100              }
7101     }
7102     break;
7103
7104
7105
7106     case 253:
7107     if(as3_pass==2) {
7108
7109 /* Line 1464 of skeleton.m4  */
7110 #line 3265 "parser.y"
7111     {(yyval.value).c=(yyvsp[(2) - (2)].value).c;
7112               (yyval.value).c = abc_bitnot((yyval.value).c);
7113               (yyval.value).t = TYPE_INT;
7114              }
7115     }
7116     break;
7117
7118
7119
7120     case 254:
7121     if(as3_pass==2) {
7122
7123 /* Line 1464 of skeleton.m4  */
7124 #line 3270 "parser.y"
7125     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
7126              (yyval.value).c = abc_bitand((yyval.value).c);
7127              (yyval.value).t = TYPE_INT;
7128             }
7129     }
7130     break;
7131
7132
7133
7134     case 255:
7135     if(as3_pass==2) {
7136
7137 /* Line 1464 of skeleton.m4  */
7138 #line 3275 "parser.y"
7139     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
7140              (yyval.value).c = abc_bitxor((yyval.value).c);
7141              (yyval.value).t = TYPE_INT;
7142             }
7143     }
7144     break;
7145
7146
7147
7148     case 256:
7149     if(as3_pass==2) {
7150
7151 /* Line 1464 of skeleton.m4  */
7152 #line 3280 "parser.y"
7153     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
7154              (yyval.value).c = abc_bitor((yyval.value).c);
7155              (yyval.value).t = TYPE_INT;
7156             }
7157     }
7158     break;
7159
7160
7161
7162     case 257:
7163     if(as3_pass==2) {
7164
7165 /* Line 1464 of skeleton.m4  */
7166 #line 3285 "parser.y"
7167     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
7168              (yyval.value).c = abc_rshift((yyval.value).c);
7169              (yyval.value).t = TYPE_INT;
7170             }
7171     }
7172     break;
7173
7174
7175
7176     case 258:
7177     if(as3_pass==2) {
7178
7179 /* Line 1464 of skeleton.m4  */
7180 #line 3289 "parser.y"
7181     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
7182              (yyval.value).c = abc_urshift((yyval.value).c);
7183              (yyval.value).t = TYPE_INT;
7184             }
7185     }
7186     break;
7187
7188
7189
7190     case 259:
7191     if(as3_pass==2) {
7192
7193 /* Line 1464 of skeleton.m4  */
7194 #line 3293 "parser.y"
7195     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
7196              (yyval.value).c = abc_lshift((yyval.value).c);
7197              (yyval.value).t = TYPE_INT;
7198             }
7199     }
7200     break;
7201
7202
7203
7204     case 260:
7205     if(as3_pass==2) {
7206
7207 /* Line 1464 of skeleton.m4  */
7208 #line 3298 "parser.y"
7209     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
7210              (yyval.value).c = abc_divide((yyval.value).c);
7211              (yyval.value).t = TYPE_NUMBER;
7212             }
7213     }
7214     break;
7215
7216
7217
7218     case 261:
7219     if(as3_pass==2) {
7220
7221 /* Line 1464 of skeleton.m4  */
7222 #line 3302 "parser.y"
7223     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
7224              (yyval.value).c = abc_modulo((yyval.value).c);
7225              (yyval.value).t = TYPE_NUMBER;
7226             }
7227     }
7228     break;
7229
7230
7231
7232     case 262:
7233     if(as3_pass==2) {
7234
7235 /* Line 1464 of skeleton.m4  */
7236 #line 3306 "parser.y"
7237     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
7238              if(BOTH_INT((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t)) {
7239                 (yyval.value).c = abc_add_i((yyval.value).c);
7240                 (yyval.value).t = TYPE_INT;
7241              } else {
7242                 (yyval.value).c = abc_add((yyval.value).c);
7243                 (yyval.value).t = join_types((yyvsp[(1) - (3)].value).t,(yyvsp[(3) - (3)].value).t,'+');
7244              }
7245             }
7246     }
7247     break;
7248
7249
7250
7251     case 263:
7252     if(as3_pass==2) {
7253
7254 /* Line 1464 of skeleton.m4  */
7255 #line 3315 "parser.y"
7256     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
7257              if(BOTH_INT((yyvsp[(1) - (3)].value).t,(yyvsp[(3) - (3)].value).t)) {
7258                 (yyval.value).c = abc_subtract_i((yyval.value).c);
7259                 (yyval.value).t = TYPE_INT;
7260              } else {
7261                 (yyval.value).c = abc_subtract((yyval.value).c);
7262                 (yyval.value).t = TYPE_NUMBER;
7263              }
7264             }
7265     }
7266     break;
7267
7268
7269
7270     case 264:
7271     if(as3_pass==2) {
7272
7273 /* Line 1464 of skeleton.m4  */
7274 #line 3324 "parser.y"
7275     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
7276              if(BOTH_INT((yyvsp[(1) - (3)].value).t,(yyvsp[(3) - (3)].value).t)) {
7277                 (yyval.value).c = abc_multiply_i((yyval.value).c);
7278                 (yyval.value).t = TYPE_INT;
7279              } else {
7280                 (yyval.value).c = abc_multiply((yyval.value).c);
7281                 (yyval.value).t = TYPE_NUMBER;
7282              }
7283             }
7284     }
7285     break;
7286
7287
7288
7289     case 265:
7290     if(as3_pass==2) {
7291
7292 /* Line 1464 of skeleton.m4  */
7293 #line 3334 "parser.y"
7294     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
7295               (yyval.value).c = abc_in((yyval.value).c);
7296               (yyval.value).t = TYPE_BOOLEAN;
7297              }
7298     }
7299     break;
7300
7301
7302
7303     case 266:
7304     if(as3_pass==2) {
7305
7306 /* Line 1464 of skeleton.m4  */
7307 #line 3339 "parser.y"
7308     {char use_astype=0; // flash player's astype works differently than astypelate
7309               if(use_astype && TYPE_IS_CLASS((yyvsp[(3) - (3)].value).t) && (yyvsp[(3) - (3)].value).t->data) {
7310                 MULTINAME(m, (classinfo_t*)((yyvsp[(3) - (3)].value).t->data));
7311                 (yyval.value).c = abc_astype2((yyvsp[(1) - (3)].value).c, &m);
7312                 (yyval.value).t = (yyvsp[(3) - (3)].value).t->data;
7313               } else {
7314                 (yyval.value).c = code_append((yyvsp[(1) - (3)].value).c, (yyvsp[(3) - (3)].value).c);
7315                 (yyval.value).c = abc_astypelate((yyval.value).c);
7316                 (yyval.value).t = TYPE_ANY;
7317               }
7318              }
7319     }
7320     break;
7321
7322
7323
7324     case 267:
7325     if(as3_pass==2) {
7326
7327 /* Line 1464 of skeleton.m4  */
7328 #line 3352 "parser.y"
7329     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c, (yyvsp[(3) - (3)].value).c);
7330               (yyval.value).c = abc_instanceof((yyval.value).c);
7331               (yyval.value).t = TYPE_BOOLEAN;
7332              }
7333     }
7334     break;
7335
7336
7337
7338     case 268:
7339     if(as3_pass==2) {
7340
7341 /* Line 1464 of skeleton.m4  */
7342 #line 3357 "parser.y"
7343     {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c, (yyvsp[(3) - (3)].value).c);
7344               (yyval.value).c = abc_istypelate((yyval.value).c);
7345               (yyval.value).t = TYPE_BOOLEAN;
7346              }
7347     }
7348     break;
7349
7350
7351
7352     case 269:
7353     if(as3_pass==2) {
7354
7355 /* Line 1464 of skeleton.m4  */
7356 #line 3362 "parser.y"
7357     {
7358               (yyval.value).c = (yyvsp[(3) - (4)].value).c;
7359               (yyval.value).c = abc_typeof((yyval.value).c);
7360               (yyval.value).t = TYPE_STRING;
7361              }
7362     }
7363     break;
7364
7365
7366
7367     case 270:
7368     if(as3_pass==2) {
7369
7370 /* Line 1464 of skeleton.m4  */
7371 #line 3368 "parser.y"
7372     {
7373               (yyval.value).c = cut_last_push((yyvsp[(2) - (2)].value).c);
7374               (yyval.value).c = abc_pushundefined((yyval.value).c);
7375               (yyval.value).t = TYPE_ANY;
7376              }
7377     }
7378     break;
7379
7380
7381
7382     case 271:
7383     if(as3_pass==2) {
7384
7385 /* Line 1464 of skeleton.m4  */
7386 #line 3374 "parser.y"
7387     { (yyval.value).c = abc_pushundefined(0);
7388              (yyval.value).t = TYPE_ANY;
7389            }
7390     }
7391     break;
7392
7393
7394
7395     case 272:
7396     if(as3_pass==2) {
7397
7398 /* Line 1464 of skeleton.m4  */
7399 #line 3378 "parser.y"
7400     {(yyval.value)=(yyvsp[(2) - (3)].value);}
7401     }
7402     break;
7403
7404
7405
7406     case 273:
7407     if(as3_pass==2) {
7408
7409 /* Line 1464 of skeleton.m4  */
7410 #line 3380 "parser.y"
7411     {
7412   (yyval.value)=(yyvsp[(2) - (2)].value);
7413   if(IS_INT((yyvsp[(2) - (2)].value).t)) {
7414    (yyval.value).c=abc_negate_i((yyval.value).c);
7415    (yyval.value).t = TYPE_INT;
7416   } else {
7417    (yyval.value).c=abc_negate((yyval.value).c);
7418    (yyval.value).t = TYPE_NUMBER;
7419   }
7420 }
7421     }
7422     break;
7423
7424
7425
7426     case 274:
7427     if(as3_pass==2) {
7428
7429 /* Line 1464 of skeleton.m4  */
7430 #line 3391 "parser.y"
7431     {
7432   (yyval.value).c = (yyvsp[(1) - (4)].value).c;
7433   (yyval.value).c = code_append((yyval.value).c, (yyvsp[(3) - (4)].value).c);
7434
7435   MULTINAME_LATE(m, (yyvsp[(1) - (4)].value).t?(yyvsp[(1) - (4)].value).t->access:ACCESS_PACKAGE, "");
7436   (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
7437   (yyval.value).t = 0; // array elements have unknown type
7438 }
7439     }
7440     break;
7441
7442
7443
7444     case 275:
7445     if(as3_pass==2) {
7446
7447 /* Line 1464 of skeleton.m4  */
7448 #line 3400 "parser.y"
7449     {
7450     (yyval.value).c = code_new();
7451     (yyval.value).c = code_append((yyval.value).c, (yyvsp[(2) - (3)].value_list).cc);
7452     (yyval.value).c = abc_newarray((yyval.value).c, (yyvsp[(2) - (3)].value_list).number);
7453     (yyval.value).t = registry_getarrayclass();
7454 }
7455     }
7456     break;
7457
7458
7459
7460     case 276:
7461     if(as3_pass==2) {
7462
7463 /* Line 1464 of skeleton.m4  */
7464 #line 3407 "parser.y"
7465     {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
7466     }
7467     break;
7468
7469
7470
7471     case 277:
7472     if(as3_pass==2) {
7473
7474 /* Line 1464 of skeleton.m4  */
7475 #line 3408 "parser.y"
7476     {(yyval.value_list)=(yyvsp[(1) - (1)].value_list);}
7477     }
7478     break;
7479
7480
7481
7482     case 278:
7483     if(as3_pass==2) {
7484
7485 /* Line 1464 of skeleton.m4  */
7486 #line 3410 "parser.y"
7487     {
7488     (yyval.value_list).cc = 0;
7489     (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(1) - (3)].value).c);
7490     (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (3)].value).c);
7491     (yyval.value_list).number = 2;
7492 }
7493     }
7494     break;
7495
7496
7497
7498     case 279:
7499     if(as3_pass==2) {
7500
7501 /* Line 1464 of skeleton.m4  */
7502 #line 3416 "parser.y"
7503     {
7504     (yyval.value_list).cc = (yyvsp[(1) - (5)].value_list).cc;
7505     (yyval.value_list).number = (yyvsp[(1) - (5)].value_list).number+2;
7506     (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (5)].value).c);
7507     (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(5) - (5)].value).c);
7508 }
7509     }
7510     break;
7511
7512
7513
7514     case 280:
7515     if(as3_pass==2) {
7516
7517 /* Line 1464 of skeleton.m4  */
7518 #line 3425 "parser.y"
7519     {
7520     (yyval.value).c = code_new();
7521     (yyval.value).c = code_append((yyval.value).c, (yyvsp[(2) - (3)].value_list).cc);
7522     (yyval.value).c = abc_newobject((yyval.value).c, (yyvsp[(2) - (3)].value_list).number/2);
7523     (yyval.value).t = registry_getobjectclass();
7524 }
7525     }
7526     break;
7527
7528
7529
7530     case 281:
7531     if(as3_pass==2) {
7532
7533 /* Line 1464 of skeleton.m4  */
7534 #line 3432 "parser.y"
7535     {
7536                code_t*c = (yyvsp[(3) - (3)].value).c;
7537                if(BOTH_INT((yyvsp[(1) - (3)].value).t,(yyvsp[(3) - (3)].value).t)) {
7538                 c=abc_multiply_i(c);
7539                } else {
7540                 c=abc_multiply(c);
7541                }
7542                c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '*'), (yyvsp[(1) - (3)].value).t);
7543                (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
7544                (yyval.value).t = (yyvsp[(1) - (3)].value).t;
7545               }
7546     }
7547     break;
7548
7549
7550
7551     case 282:
7552     if(as3_pass==2) {
7553
7554 /* Line 1464 of skeleton.m4  */
7555 #line 3444 "parser.y"
7556     {
7557                code_t*c = abc_modulo((yyvsp[(3) - (3)].value).c);
7558                c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '%'), (yyvsp[(1) - (3)].value).t);
7559                (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
7560                (yyval.value).t = (yyvsp[(1) - (3)].value).t;
7561               }
7562     }
7563     break;
7564
7565
7566
7567     case 283:
7568     if(as3_pass==2) {
7569
7570 /* Line 1464 of skeleton.m4  */
7571 #line 3450 "parser.y"
7572     {
7573                code_t*c = abc_lshift((yyvsp[(3) - (3)].value).c);
7574                c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '<'), (yyvsp[(1) - (3)].value).t);
7575                (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
7576                (yyval.value).t = (yyvsp[(1) - (3)].value).t;
7577               }
7578     }
7579     break;
7580
7581
7582
7583     case 284:
7584     if(as3_pass==2) {
7585
7586 /* Line 1464 of skeleton.m4  */
7587 #line 3456 "parser.y"
7588     {
7589                code_t*c = abc_rshift((yyvsp[(3) - (3)].value).c);
7590                c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '>'), (yyvsp[(1) - (3)].value).t);
7591                (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
7592                (yyval.value).t = (yyvsp[(1) - (3)].value).t;
7593               }
7594     }
7595     break;
7596
7597
7598
7599     case 285:
7600     if(as3_pass==2) {
7601
7602 /* Line 1464 of skeleton.m4  */
7603 #line 3462 "parser.y"
7604     {
7605                code_t*c = abc_urshift((yyvsp[(3) - (3)].value).c);
7606                c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, 'U'), (yyvsp[(1) - (3)].value).t);
7607                (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
7608                (yyval.value).t = (yyvsp[(1) - (3)].value).t;
7609               }
7610     }
7611     break;
7612
7613
7614
7615     case 286:
7616     if(as3_pass==2) {
7617
7618 /* Line 1464 of skeleton.m4  */
7619 #line 3468 "parser.y"
7620     {
7621                code_t*c = abc_divide((yyvsp[(3) - (3)].value).c);
7622                c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '/'), (yyvsp[(1) - (3)].value).t);
7623                (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
7624                (yyval.value).t = (yyvsp[(1) - (3)].value).t;
7625               }
7626     }
7627     break;
7628
7629
7630
7631     case 287:
7632     if(as3_pass==2) {
7633
7634 /* Line 1464 of skeleton.m4  */
7635 #line 3474 "parser.y"
7636     {
7637                code_t*c = abc_bitor((yyvsp[(3) - (3)].value).c);
7638                c=converttype(c, TYPE_INT, (yyvsp[(1) - (3)].value).t);
7639                (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
7640                (yyval.value).t = (yyvsp[(1) - (3)].value).t;
7641               }
7642     }
7643     break;
7644
7645
7646
7647     case 288:
7648     if(as3_pass==2) {
7649
7650 /* Line 1464 of skeleton.m4  */
7651 #line 3480 "parser.y"
7652     {
7653                code_t*c = abc_bitxor((yyvsp[(3) - (3)].value).c);
7654                c=converttype(c, TYPE_INT, (yyvsp[(1) - (3)].value).t);
7655                (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
7656                (yyval.value).t = (yyvsp[(1) - (3)].value).t;
7657               }
7658     }
7659     break;
7660
7661
7662
7663     case 289:
7664     if(as3_pass==2) {
7665
7666 /* Line 1464 of skeleton.m4  */
7667 #line 3486 "parser.y"
7668     {
7669                code_t*c = (yyvsp[(3) - (3)].value).c;
7670
7671                if(TYPE_IS_INT((yyvsp[(1) - (3)].value).t)) {
7672                 c=abc_add_i(c);
7673                } else {
7674                 c=abc_add(c);
7675                 c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '+'), (yyvsp[(1) - (3)].value).t);
7676                }
7677
7678                (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
7679                (yyval.value).t = (yyvsp[(1) - (3)].value).t;
7680               }
7681     }
7682     break;
7683
7684
7685
7686     case 290:
7687     if(as3_pass==2) {
7688
7689 /* Line 1464 of skeleton.m4  */
7690 #line 3499 "parser.y"
7691     { code_t*c = (yyvsp[(3) - (3)].value).c;
7692                if(TYPE_IS_INT((yyvsp[(1) - (3)].value).t)) {
7693                 c=abc_subtract_i(c);
7694                } else {
7695                 c=abc_subtract(c);
7696                 c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '-'), (yyvsp[(1) - (3)].value).t);
7697                }
7698
7699                (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
7700                (yyval.value).t = (yyvsp[(1) - (3)].value).t;
7701              }
7702     }
7703     break;
7704
7705
7706
7707     case 291:
7708     if(as3_pass==2) {
7709
7710 /* Line 1464 of skeleton.m4  */
7711 #line 3510 "parser.y"
7712     { code_t*c = 0;
7713               c = code_append(c, (yyvsp[(3) - (3)].value).c);
7714               c = converttype(c, (yyvsp[(3) - (3)].value).t, (yyvsp[(1) - (3)].value).t);
7715               (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 1, 0);
7716               (yyval.value).t = (yyvsp[(1) - (3)].value).t;
7717             }
7718     }
7719     break;
7720
7721
7722
7723     case 292:
7724     if(as3_pass==2) {
7725
7726 /* Line 1464 of skeleton.m4  */
7727 #line 3517 "parser.y"
7728     {
7729               (yyval.value).t = join_types((yyvsp[(3) - (5)].value).t,(yyvsp[(5) - (5)].value).t,'?');
7730               (yyval.value).c = (yyvsp[(1) - (5)].value).c;
7731               code_t*j1 = (yyval.value).c = abc_iffalse((yyval.value).c, 0);
7732               (yyval.value).c = code_append((yyval.value).c, (yyvsp[(3) - (5)].value).c);
7733               (yyval.value).c = converttype((yyval.value).c, (yyvsp[(3) - (5)].value).t, (yyval.value).t);
7734               code_t*j2 = (yyval.value).c = abc_jump((yyval.value).c, 0);
7735               (yyval.value).c = j1->branch = abc_label((yyval.value).c);
7736               (yyval.value).c = code_append((yyval.value).c, (yyvsp[(5) - (5)].value).c);
7737               (yyval.value).c = converttype((yyval.value).c, (yyvsp[(5) - (5)].value).t, (yyval.value).t);
7738               (yyval.value).c = j2->branch = abc_label((yyval.value).c);
7739             }
7740     }
7741     break;
7742
7743
7744
7745     case 293:
7746     if(as3_pass==2) {
7747
7748 /* Line 1464 of skeleton.m4  */
7749 #line 3530 "parser.y"
7750     { code_t*c = 0;
7751              classinfo_t*type = (yyvsp[(1) - (2)].value).t;
7752              if(is_getlocal((yyvsp[(1) - (2)].value).c) && (TYPE_IS_INT((yyvsp[(1) - (2)].value).t) || TYPE_IS_NUMBER((yyvsp[(1) - (2)].value).t))) {
7753                  int nr = getlocalnr((yyvsp[(1) - (2)].value).c);
7754                  code_free((yyvsp[(1) - (2)].value).c);(yyvsp[(1) - (2)].value).c=0;
7755                  if(TYPE_IS_INT((yyvsp[(1) - (2)].value).t)) {
7756                     (yyval.value).c = abc_getlocal(0, nr);
7757                     (yyval.value).c = abc_inclocal_i((yyval.value).c, nr);
7758                  } else if(TYPE_IS_NUMBER((yyvsp[(1) - (2)].value).t)) {
7759                     (yyval.value).c = abc_getlocal(0, nr);
7760                     (yyval.value).c = abc_inclocal((yyval.value).c, nr);
7761                  } else syntaxerror("internal error");
7762              } else {
7763                  if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
7764                      c=abc_increment_i(c);
7765                      type = TYPE_INT;
7766                  } else {
7767                      c=abc_increment(c);
7768                      type = TYPE_NUMBER;
7769                  }
7770                  c=converttype(c, type, (yyvsp[(1) - (2)].value).t);
7771                  (yyval.value).c = toreadwrite((yyvsp[(1) - (2)].value).c, c, 0, 1);
7772                  (yyval.value).t = (yyvsp[(1) - (2)].value).t;
7773              }
7774            }
7775     }
7776     break;
7777
7778
7779
7780     case 294:
7781     if(as3_pass==2) {
7782
7783 /* Line 1464 of skeleton.m4  */
7784 #line 3557 "parser.y"
7785     { code_t*c = 0;
7786              classinfo_t*type = (yyvsp[(1) - (2)].value).t;
7787              if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
7788                  c=abc_decrement_i(c);
7789                  type = TYPE_INT;
7790              } else {
7791                  c=abc_decrement(c);
7792                  type = TYPE_NUMBER;
7793              }
7794              c=converttype(c, type, (yyvsp[(1) - (2)].value).t);
7795              (yyval.value).c = toreadwrite((yyvsp[(1) - (2)].value).c, c, 0, 1);
7796              (yyval.value).t = (yyvsp[(1) - (2)].value).t;
7797             }
7798     }
7799     break;
7800
7801
7802
7803     case 295:
7804     if(as3_pass==2) {
7805
7806 /* Line 1464 of skeleton.m4  */
7807 #line 3571 "parser.y"
7808     { code_t*c = 0;
7809              classinfo_t*type = (yyvsp[(2) - (2)].value).t;
7810              if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
7811                  c=abc_increment_i(c);
7812                  type = TYPE_INT;
7813              } else {
7814                  c=abc_increment(c);
7815                  type = TYPE_NUMBER;
7816              }
7817              c=converttype(c, type, (yyvsp[(2) - (2)].value).t);
7818              (yyval.value).c = toreadwrite((yyvsp[(2) - (2)].value).c, c, 0, 0);
7819              (yyval.value).t = (yyvsp[(2) - (2)].value).t;
7820            }
7821     }
7822     break;
7823
7824
7825
7826     case 296:
7827     if(as3_pass==2) {
7828
7829 /* Line 1464 of skeleton.m4  */
7830 #line 3585 "parser.y"
7831     { code_t*c = 0;
7832              classinfo_t*type = (yyvsp[(2) - (2)].value).t;
7833              if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
7834                  c=abc_decrement_i(c);
7835                  type = TYPE_INT;
7836              } else {
7837                  c=abc_decrement(c);
7838                  type = TYPE_NUMBER;
7839              }
7840              c=converttype(c, type, (yyvsp[(2) - (2)].value).t);
7841              (yyval.value).c = toreadwrite((yyvsp[(2) - (2)].value).c, c, 0, 0);
7842              (yyval.value).t = (yyvsp[(2) - (2)].value).t;
7843            }
7844     }
7845     break;
7846
7847
7848
7849     case 297:
7850     if(as3_pass==2) {
7851
7852 /* Line 1464 of skeleton.m4  */
7853 #line 3600 "parser.y"
7854     { if(!state->cls->info)
7855                   syntaxerror("super keyword not allowed outside a class");
7856               classinfo_t*t = state->cls->info->superclass;
7857               if(!t) t = TYPE_OBJECT;
7858
7859               memberinfo_t*f = findmember_nsset(t, (yyvsp[(3) - (3)].id), 1);
7860
7861               MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
7862               (yyval.value).c = 0;
7863               (yyval.value).c = abc_getlocal_0((yyval.value).c);
7864               (yyval.value).c = abc_getsuper2((yyval.value).c, &m);
7865               (yyval.value).t = slotinfo_gettype((slotinfo_t*)f);
7866            }
7867     }
7868     break;
7869
7870
7871
7872     case 298:
7873     if(as3_pass==2) {
7874
7875 /* Line 1464 of skeleton.m4  */
7876 #line 3614 "parser.y"
7877     {
7878               // attribute TODO
7879               (yyval.value).c = abc_pushundefined(0);
7880               (yyval.value).t = 0;
7881               as3_warning("ignored @ operator");
7882            }
7883     }
7884     break;
7885
7886
7887
7888     case 299:
7889     if(as3_pass==2) {
7890
7891 /* Line 1464 of skeleton.m4  */
7892 #line 3621 "parser.y"
7893     {
7894               // child attribute  TODO
7895               (yyval.value).c = abc_pushundefined(0);
7896               (yyval.value).t = 0;
7897               as3_warning("ignored .@ operator");
7898            }
7899     }
7900     break;
7901
7902
7903
7904     case 300:
7905     if(as3_pass==2) {
7906
7907 /* Line 1464 of skeleton.m4  */
7908 #line 3628 "parser.y"
7909     {
7910               // namespace declaration TODO
7911               (yyval.value).c = abc_pushundefined(0);
7912               (yyval.value).t = 0;
7913               as3_warning("ignored :: operator");
7914            }
7915     }
7916     break;
7917
7918
7919
7920     case 301:
7921     if(as3_pass==2) {
7922
7923 /* Line 1464 of skeleton.m4  */
7924 #line 3635 "parser.y"
7925     {
7926               // descendants TODO
7927               (yyval.value).c = abc_pushundefined(0);
7928               (yyval.value).t = 0;
7929               as3_warning("ignored .. operator");
7930            }
7931     }
7932     break;
7933
7934
7935
7936     case 302:
7937     if(as3_pass==2) {
7938
7939 /* Line 1464 of skeleton.m4  */
7940 #line 3642 "parser.y"
7941     {
7942               // filter TODO
7943               (yyval.value).c = abc_pushundefined(0);
7944               (yyval.value).t = 0;
7945               as3_warning("ignored .() operator");
7946            }
7947     }
7948     break;
7949
7950
7951
7952     case 303:
7953     if(as3_pass==2) {
7954
7955 /* Line 1464 of skeleton.m4  */
7956 #line 3653 "parser.y"
7957     {
7958     (yyval.value).c = (yyvsp[(1) - (3)].value).c;
7959     classinfo_t*t = (yyvsp[(1) - (3)].value).t;
7960     char is_static = 0;
7961     if(TYPE_IS_CLASS(t) && t->data) {
7962         t = t->data;
7963         is_static = 1;
7964     }
7965     if(t) {
7966         if(t->subtype==INFOTYPE_UNRESOLVED) {
7967             syntaxerror("syntaxerror: trying to resolve property '%s' on incomplete object '%s'", (yyvsp[(3) - (3)].id), t->name);
7968         }
7969         memberinfo_t*f = findmember_nsset(t, (yyvsp[(3) - (3)].id), 1);
7970         char noslot = 0;
7971         if(f && !is_static != !(f->flags&FLAG_STATIC))
7972            noslot=1;
7973         if(f && f->slot && !noslot) {
7974             (yyval.value).c = abc_getslot((yyval.value).c, f->slot);
7975         } else {
7976             MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
7977             (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
7978         }
7979         /* determine type */
7980         (yyval.value).t = slotinfo_gettype((slotinfo_t*)f);
7981         if(!(yyval.value).t)
7982            (yyval.value).c = abc_coerce_a((yyval.value).c);
7983     } else if((yyvsp[(1) - (3)].value).c && (yyvsp[(1) - (3)].value).c->opcode == OPCODE___PUSHPACKAGE__) {
7984         string_t*package = (yyvsp[(1) - (3)].value).c->data[0];
7985         char*package2 = concat3(package->str, ".", (yyvsp[(3) - (3)].id));
7986         if(dict_contains(state->import_toplevel_packages, package2)) {
7987             (yyval.value).c = (yyvsp[(1) - (3)].value).c;
7988             (yyval.value).c->data[0] = string_new4(package2);
7989             (yyval.value).t = 0;
7990         } else {
7991             slotinfo_t*a = registry_find(package->str, (yyvsp[(3) - (3)].id));
7992             if(!a)
7993                 syntaxerror("couldn't resolve %s", package2);
7994             (yyval.value) = push_class(a);
7995         }
7996     } else {
7997         /* when resolving a property on an unknown type, we do know the
7998            name of the property (and don't seem to need the package), but
7999            we need to make avm2 try out all access modes */
8000         multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
8001         (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
8002         (yyval.value).c = abc_coerce_a((yyval.value).c);
8003         (yyval.value).t = registry_getanytype();
8004     }
8005 }
8006     }
8007     break;
8008
8009
8010
8011     case 304:
8012     if(as3_pass==2) {
8013
8014 /* Line 1464 of skeleton.m4  */
8015 #line 3703 "parser.y"
8016     {
8017     PASS1
8018     /* Queue unresolved identifiers for checking against the parent
8019        function's variables.
8020        We consider everything which is not a local variable "unresolved".
8021        This encompasses class names, members of the surrounding class
8022        etc. which is *correct* because local variables of the parent function
8023        would shadow those.
8024        */
8025     if(state->method->inner && !find_variable(state, (yyvsp[(1) - (1)].id))) {
8026         unknown_variable((yyvsp[(1) - (1)].id));
8027     }
8028
8029     /* let the compiler know that it might check the current directory/package
8030        for this identifier- maybe there's a file $1.as defining $1. */
8031     as3_schedule_class_noerror(state->package, (yyvsp[(1) - (1)].id));
8032     PASS2
8033
8034     (yyval.value).t = 0;
8035     (yyval.value).c = 0;
8036     slotinfo_t*a = 0;
8037     memberinfo_t*f = 0;
8038
8039     variable_t*v;
8040     /* look at variables */
8041     if((v = find_variable(state, (yyvsp[(1) - (1)].id)))) {
8042         // $1 is a local variable
8043         (yyval.value).c = abc_getlocal((yyval.value).c, v->index);
8044         (yyval.value).t = v->type;
8045         break;
8046     }
8047     if((v = find_slot(state, (yyvsp[(1) - (1)].id)))) {
8048         (yyval.value).c = abc_getscopeobject((yyval.value).c, 1);
8049         (yyval.value).c = abc_getslot((yyval.value).c, v->index);
8050         (yyval.value).t = v->type;
8051         break;
8052     }
8053
8054     int i_am_static = (state->method && state->method->info)?(state->method->info->flags&FLAG_STATIC):FLAG_STATIC;
8055
8056     /* look at current class' members */
8057     if(state->cls && (f = findmember_nsset(state->cls->info, (yyvsp[(1) - (1)].id), 1)) &&
8058         (f->flags&FLAG_STATIC) >= i_am_static) {
8059         // $1 is a function in this class
8060         int var_is_static = (f->flags&FLAG_STATIC);
8061
8062         if(f->kind == INFOTYPE_METHOD) {
8063             (yyval.value).t = TYPE_FUNCTION(f);
8064         } else {
8065             (yyval.value).t = f->type;
8066         }
8067         if(var_is_static && !i_am_static) {
8068         /* access to a static member from a non-static location.
8069            do this via findpropstrict:
8070            there doesn't seem to be any non-lookup way to access
8071            static properties of a class */
8072             state->method->late_binding = 1;
8073             (yyval.value).t = f->type;
8074             namespace_t ns = {f->access, ""};
8075             multiname_t m = {QNAME, &ns, 0, (yyvsp[(1) - (1)].id)};
8076             (yyval.value).c = abc_findpropstrict2((yyval.value).c, &m);
8077             (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
8078             break;
8079         } else if(f->slot>0) {
8080             (yyval.value).c = abc_getlocal_0((yyval.value).c);
8081             (yyval.value).c = abc_getslot((yyval.value).c, f->slot);
8082             break;
8083         } else {
8084             namespace_t ns = {f->access, ""};
8085             multiname_t m = {QNAME, &ns, 0, (yyvsp[(1) - (1)].id)};
8086             (yyval.value).c = abc_getlocal_0((yyval.value).c);
8087             (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
8088             break;
8089         }
8090     }
8091
8092     /* look at actual classes, in the current package and imported */
8093     if((a = find_class((yyvsp[(1) - (1)].id)))) {
8094         (yyval.value) = push_class(a);
8095         break;
8096     }
8097
8098     /* look through package prefixes */
8099     if(dict_contains(state->import_toplevel_packages, (yyvsp[(1) - (1)].id))) {
8100         (yyval.value).c = abc___pushpackage__((yyval.value).c, (yyvsp[(1) - (1)].id));
8101         (yyval.value).t = 0;
8102         break;
8103     }
8104
8105     /* unknown object, let the avm2 resolve it */
8106     if(1) {
8107         //as3_softwarning("Couldn't resolve '%s', doing late binding", $1);
8108         as3_warning("Couldn't resolve '%s', doing late binding", (yyvsp[(1) - (1)].id));
8109         state->method->late_binding = 1;
8110
8111         multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(1) - (1)].id)};
8112
8113         (yyval.value).t = 0;
8114         (yyval.value).c = abc_findpropstrict2((yyval.value).c, &m);
8115         (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
8116     }
8117 }
8118     }
8119     break;
8120
8121
8122
8123     case 305:
8124     if(as3_pass==2) {
8125
8126 /* Line 1464 of skeleton.m4  */
8127 #line 3808 "parser.y"
8128     {
8129     PASS12
8130     NEW(namespace_decl_t,n);
8131     n->name = (yyvsp[(2) - (2)].id);
8132     n->url = (yyvsp[(2) - (2)].id);
8133     (yyval.namespace_decl)=n;
8134 }
8135     }
8136     break;
8137
8138
8139
8140     case 306:
8141     if(as3_pass==2) {
8142
8143 /* Line 1464 of skeleton.m4  */
8144 #line 3815 "parser.y"
8145     {
8146     PASS12
8147     NEW(namespace_decl_t,n);
8148     n->name = (yyvsp[(2) - (4)].id);
8149     n->url = (yyvsp[(4) - (4)].id);
8150     (yyval.namespace_decl)=n;
8151 }
8152     }
8153     break;
8154
8155
8156
8157     case 307:
8158     if(as3_pass==2) {
8159
8160 /* Line 1464 of skeleton.m4  */
8161 #line 3822 "parser.y"
8162     {
8163     PASS12
8164     NEW(namespace_decl_t,n);
8165     n->name = (yyvsp[(2) - (4)].id);
8166     n->url = (yyvsp[(4) - (4)].str).str;
8167     (yyval.namespace_decl)=n;
8168 }
8169     }
8170     break;
8171
8172
8173
8174     case 308:
8175     if(as3_pass==2) {
8176
8177 /* Line 1464 of skeleton.m4  */
8178 #line 3829 "parser.y"
8179     {
8180     PASS12
8181     trie_put(active_namespaces, (yyvsp[(2) - (2)].namespace_decl)->name, (void*)(yyvsp[(2) - (2)].namespace_decl)->url);
8182
8183     namespace_t access = modifiers2access(&(yyvsp[(1) - (2)].flags));
8184     varinfo_t* var = varinfo_register_global(access.access, state->package, (yyvsp[(2) - (2)].namespace_decl)->name);
8185     var->type = TYPE_NAMESPACE;
8186     namespace_t ns;
8187     ns.access = ACCESS_NAMESPACE;
8188     ns.name = (yyvsp[(2) - (2)].namespace_decl)->url;
8189     var->value = constant_new_namespace(&ns);
8190
8191     (yyval.code)=0;
8192 }
8193     }
8194     break;
8195
8196
8197
8198     case 309:
8199     if(as3_pass==2) {
8200
8201 /* Line 1464 of skeleton.m4  */
8202 #line 3844 "parser.y"
8203     {
8204     PASS12
8205     char*url = 0;
8206     trie_put(active_namespaces, (yyvsp[(3) - (3)].classinfo)->name, url);
8207     (yyval.code)=0;
8208 }
8209     }
8210     break;
8211
8212
8213
8214
8215 /* Line 1464 of skeleton.m4  */
8216 #line 8217 "parser.tab.c"
8217       default: break;
8218     }
8219   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
8220
8221   YYPOPSTACK (yylen);
8222   yylen = 0;
8223   YY_STACK_PRINT (yyss, yyssp);
8224
8225   *++yyvsp = yyval;
8226
8227   /* Now `shift' the result of the reduction.  Determine what state
8228      that goes to, based on the state we popped back to and the rule
8229      number reduced by.  */
8230
8231   yyn = yyr1[yyn];
8232
8233   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
8234   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
8235     yystate = yytable[yystate];
8236   else
8237     yystate = yydefgoto[yyn - YYNTOKENS];
8238
8239   goto yynewstate;
8240
8241
8242 /*------------------------------------.
8243 | yyerrlab -- here on detecting error |
8244 `------------------------------------*/
8245 yyerrlab:
8246   /* If not already recovering from an error, report this error.  */
8247   if (!yyerrstatus)
8248     {
8249       ++yynerrs;
8250 #if ! YYERROR_VERBOSE
8251       yyerror (YY_("syntax error"));
8252 #else
8253       {
8254         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
8255         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
8256           {
8257             YYSIZE_T yyalloc = 2 * yysize;
8258             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
8259               yyalloc = YYSTACK_ALLOC_MAXIMUM;
8260             if (yymsg != yymsgbuf)
8261               YYSTACK_FREE (yymsg);
8262             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
8263             if (yymsg)
8264               yymsg_alloc = yyalloc;
8265             else
8266               {
8267                 yymsg = yymsgbuf;
8268                 yymsg_alloc = sizeof yymsgbuf;
8269               }
8270           }
8271
8272         if (0 < yysize && yysize <= yymsg_alloc)
8273           {
8274             (void) yysyntax_error (yymsg, yystate, yychar);
8275             yyerror (yymsg);
8276           }
8277         else
8278           {
8279             yyerror (YY_("syntax error"));
8280             if (yysize != 0)
8281               goto yyexhaustedlab;
8282           }
8283       }
8284 #endif
8285     }
8286
8287
8288
8289   if (yyerrstatus == 3)
8290     {
8291       /* If just tried and failed to reuse lookahead token after an
8292          error, discard it.  */
8293
8294       if (yychar <= YYEOF)
8295         {
8296           /* Return failure if at end of input.  */
8297           if (yychar == YYEOF)
8298             YYABORT;
8299         }
8300       else
8301         {
8302           yydestruct ("Error: discarding",
8303                       yytoken, &yylval);
8304           yychar = YYEMPTY;
8305         }
8306     }
8307
8308   /* Else will try to reuse lookahead token after shifting the error
8309      token.  */
8310   goto yyerrlab1;
8311
8312
8313 /*---------------------------------------------------.
8314 | yyerrorlab -- error raised explicitly by YYERROR.  |
8315 `---------------------------------------------------*/
8316 yyerrorlab:
8317
8318   /* Pacify compilers like GCC when the user code never invokes
8319      YYERROR and the label yyerrorlab therefore never appears in user
8320      code.  */
8321   if (/*CONSTCOND*/ 0)
8322      goto yyerrorlab;
8323
8324   /* Do not reclaim the symbols of the rule which action triggered
8325      this YYERROR.  */
8326   YYPOPSTACK (yylen);
8327   yylen = 0;
8328   YY_STACK_PRINT (yyss, yyssp);
8329   yystate = *yyssp;
8330   goto yyerrlab1;
8331
8332
8333 /*-------------------------------------------------------------.
8334 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
8335 `-------------------------------------------------------------*/
8336 yyerrlab1:
8337   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
8338
8339   for (;;)
8340     {
8341       yyn = yypact[yystate];
8342       if (yyn != YYPACT_NINF)
8343         {
8344           yyn += YYTERROR;
8345           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
8346             {
8347               yyn = yytable[yyn];
8348               if (0 < yyn)
8349                 break;
8350             }
8351         }
8352
8353       /* Pop the current state because it cannot handle the error token.  */
8354       if (yyssp == yyss)
8355         YYABORT;
8356
8357
8358       yydestruct ("Error: popping",
8359                   yystos[yystate], yyvsp);
8360       YYPOPSTACK (1);
8361       yystate = *yyssp;
8362       YY_STACK_PRINT (yyss, yyssp);
8363     }
8364
8365   *++yyvsp = yylval;
8366
8367
8368   /* Shift the error token.  */
8369   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
8370
8371   yystate = yyn;
8372   goto yynewstate;
8373
8374
8375 /*-------------------------------------.
8376 | yyacceptlab -- YYACCEPT comes here.  |
8377 `-------------------------------------*/
8378 yyacceptlab:
8379   yyresult = 0;
8380   goto yyreturn;
8381
8382 /*-----------------------------------.
8383 | yyabortlab -- YYABORT comes here.  |
8384 `-----------------------------------*/
8385 yyabortlab:
8386   yyresult = 1;
8387   goto yyreturn;
8388
8389 #if !defined(yyoverflow) || YYERROR_VERBOSE
8390 /*-------------------------------------------------.
8391 | yyexhaustedlab -- memory exhaustion comes here.  |
8392 `-------------------------------------------------*/
8393 yyexhaustedlab:
8394   yyerror (YY_("memory exhausted"));
8395   yyresult = 2;
8396   /* Fall through.  */
8397 #endif
8398
8399 yyreturn:
8400   if (yychar != YYEMPTY)
8401      yydestruct ("Cleanup: discarding lookahead",
8402                  yytoken, &yylval);
8403   /* Do not reclaim the symbols of the rule which action triggered
8404      this YYABORT or YYACCEPT.  */
8405   YYPOPSTACK (yylen);
8406   YY_STACK_PRINT (yyss, yyssp);
8407   while (yyssp != yyss)
8408     {
8409       yydestruct ("Cleanup: popping",
8410                   yystos[*yyssp], yyvsp);
8411       YYPOPSTACK (1);
8412     }
8413 #ifndef yyoverflow
8414   if (yyss != yyssa)
8415     YYSTACK_FREE (yyss);
8416 #endif
8417 #if YYERROR_VERBOSE
8418   if (yymsg != yymsgbuf)
8419     YYSTACK_FREE (yymsg);
8420 #endif
8421   /* Make sure YYID is used.  */
8422   return YYID (yyresult);
8423 }
8424
8425
8426