lib/as3/parser.tab.c

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