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