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