lib/as3/parser.tab.c

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