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