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