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