lib/as3/parser.tab.c

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