2 /* A Bison parser, made by GNU Bison 2.4.1. */
4 /* Skeleton implementation for Bison's Yacc-like parsers in C
6 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
7 Free Software Foundation, Inc.
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.
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.
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/>. */
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.
32 This special exception was added by the Free Software Foundation in
33 version 2.2 of Bison. */
35 /* C LALR(1) parser skeleton written by Richard Stallman, by
36 simplifying the original so-called "semantic" parser. */
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. */
45 /* Identify Bison output. */
49 #define YYBISON_VERSION "2.4.1"
52 #define YYSKELETON_NAME "./skeleton.m4"
63 /* Using locations. */
64 #define YYLSP_NEEDED 0
66 /* Substitute the variable and function names. */
67 #define yyparse a3_parse
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
76 /* Copy the first part of user declarations. */
78 /* Line 198 of skeleton.m4 */
88 #include "tokenizer.h"
100 /* Line 198 of skeleton.m4 */
101 #line 102 "parser.tab.c"
103 /* Enabling traces. */
108 /* Enabling verbose error messages. */
109 #ifdef YYERROR_VERBOSE
110 # undef YYERROR_VERBOSE
111 # define YYERROR_VERBOSE 1
113 # define YYERROR_VERBOSE 1
116 /* Enabling the token table. */
117 #ifndef YYTOKEN_TABLE
118 # define YYTOKEN_TABLE 0
125 /* Put the tokens into the symbol table, so that GDB and other debuggers
187 KW_DEFAULT_XML = 317,
224 below_semicolon = 354,
225 below_assignment = 355,
228 minusminus_prefix = 358,
229 plusplus_prefix = 359,
232 above_identifier = 362,
240 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
242 /* Line 223 of skeleton.m4 */
247 /* Line 223 of skeleton.m4 */
250 enum yytokentype token;
252 classinfo_t*classinfo;
253 classinfo_list_t*classinfo_list;
255 slotinfo_list_t*slotinfo_list;
258 unsigned int number_uint;
262 //typedcode_list_t*value_list;
263 codeandnumber_t value_list;
269 for_start_t for_start;
270 abc_exception_t *exception;
273 namespace_decl_t* namespace_decl;
276 abc_exception_list_t *l;
282 /* Line 223 of skeleton.m4 */
283 #line 284 "parser.tab.c"
285 # define YYSTYPE_IS_TRIVIAL 1
286 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
287 # define YYSTYPE_IS_DECLARED 1
291 /* Copy the second part of user declarations. */
293 /* Line 273 of skeleton.m4 */
297 static int a3_error(char*s)
299 syntaxerror("%s", s);
300 return 0; //make gcc happy
303 static void parsererror(const char*file, int line, const char*f)
305 syntaxerror("internal error in %s, %s:%d", f, file, line);
308 #define parserassert(b) {if(!(b)) parsererror(__FILE__, __LINE__,__func__);}
311 static char* concat2(const char* t1, const char* t2)
315 char*text = malloc(l1+l2+1);
316 memcpy(text , t1, l1);
317 memcpy(text+l1, t2, l2);
321 static char* concat3(const char* t1, const char* t2, const char* t3)
326 char*text = malloc(l1+l2+l3+1);
327 memcpy(text , t1, l1);
328 memcpy(text+l1, t2, l2);
329 memcpy(text+l1+l2, t3, l3);
334 typedef struct _import {
337 DECLARE_LIST(import);
339 DECLARE(methodstate);
340 DECLARE_LIST(methodstate);
342 typedef struct _classstate {
348 methodstate_t*static_init;
350 //code_t*static_init;
351 parsedclass_t*dependencies;
353 char has_constructor;
356 struct _methodstate {
367 dict_t*unresolved_variables;
368 dict_t*allvars; // all variables (in all sublevels, but not for inner functions)
371 char uses_parent_function;
372 char no_variable_scoping;
380 int var_index; // for inner methods
381 int slot_index; // for inner methods
382 char is_a_slot; // for inner methods
387 abc_exception_list_t*exceptions;
389 methodstate_list_t*innerfunctions;
392 methodstate_t*methodstate_new()
394 NEW(methodstate_t,m);
395 m->allvars = dict_new();
398 void methodstate_destroy(methodstate_t*m)
400 dict_destroy(m->unresolved_variables); m->unresolved_variables = 0;
401 list_free(m->innerfunctions);m->innerfunctions=0;
404 DICT_ITERATE_DATA(m->allvars, void*, data) {free(data);}
409 typedef struct _state {
414 import_list_t*wildcard_imports;
415 dict_t*import_toplevel_packages;
419 namespace_list_t*active_namespace_urls;
421 char has_own_imports;
422 char new_vars; // e.g. transition between two functions
423 char xmlfilter; // are we inside a xmlobj..() filter?
426 methodstate_t*method;
435 typedef struct _global {
438 parsedclass_list_t*classes;
439 abc_script_t*classinit;
441 abc_script_t*init; //package-level code
444 dict_t*file2token2info;
447 static global_t*global = 0;
448 static state_t* state = 0;
452 /* protected handling here is a big hack: we just assume the protectedns
453 is package:class. the correct approach would be to add the proper
454 namespace to all protected members in the registry, even though that
455 would slow down searching */
456 #define MEMBER_MULTINAME(m,f,n) \
460 m##_ns.access = ((slotinfo_t*)(f))->access; \
461 if(m##_ns.access == ACCESS_NAMESPACE) \
462 m##_ns.name = ((slotinfo_t*)(f))->package; \
463 else if(m##_ns.access == ACCESS_PROTECTED && (f)->parent) \
464 m##_ns.name = concat3((f)->parent->package,":",(f)->parent->name); \
469 m.namespace_set = 0; \
470 m.name = ((slotinfo_t*)(f))->name; \
472 m.type = MULTINAME; \
474 m.namespace_set = &nopackage_namespace_set; \
478 /* warning: list length of namespace set is undefined */
479 #define MULTINAME_LATE(m, access, package) \
480 namespace_t m##_ns = {access, package}; \
481 namespace_set_t m##_nsset; \
482 namespace_list_t m##_l;m##_l.next = 0; \
483 m##_nsset.namespaces = &m##_l; \
484 m##_nsset = m##_nsset; \
485 m##_l.namespace = &m##_ns; \
486 multiname_t m = {MULTINAMEL, 0, &m##_nsset, 0};
488 static namespace_t ns1 = {ACCESS_PRIVATE, ""};
489 static namespace_t ns2 = {ACCESS_PROTECTED, ""};
490 static namespace_t ns3 = {ACCESS_PACKAGEINTERNAL, ""};
491 static namespace_t stdns = {ACCESS_PACKAGE, ""};
492 static namespace_list_t nl4 = {&stdns,0};
493 static namespace_list_t nl3 = {&ns3,&nl4};
494 static namespace_list_t nl2 = {&ns2,&nl3};
495 static namespace_list_t nl1 = {&ns1,&nl2};
496 static namespace_set_t nopackage_namespace_set = {&nl1};
498 static dict_t*definitions=0;
499 void as3_set_define(const char*c)
502 definitions = dict_new();
503 if(!dict_contains(definitions,c))
504 dict_put(definitions,c,0);
507 static void new_state()
510 state_t*oldstate = state;
512 memcpy(s, state, sizeof(state_t)); //shallow copy
514 s->imports = dict_new();
516 if(!s->import_toplevel_packages) {
517 s->import_toplevel_packages = dict_new();
521 state->has_own_imports = 0;
522 state->vars = dict_new();
523 state->old = oldstate;
526 state->namespaces = dict_new();
529 state->active_namespace_urls = list_clone(oldstate->active_namespace_urls);
532 static void state_destroy(state_t*state)
534 if(state->has_own_imports) {
535 list_free(state->wildcard_imports);
536 dict_destroy(state->imports);state->imports=0;
538 if(state->imports && (!state->old || state->old->imports!=state->imports)) {
539 dict_destroy(state->imports);state->imports=0;
542 dict_destroy(state->vars);state->vars=0;
545 list_free(state->active_namespace_urls)
546 state->active_namespace_urls = 0;
551 static void old_state()
553 if(!state || !state->old)
554 syntaxerror("invalid nesting");
555 state_t*leaving = state;
559 if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) {
560 methodstate_destroy(leaving->method);leaving->method=0;
562 if(as3_pass>1 && leaving->cls && leaving->cls != state->cls) {
567 state_destroy(leaving);
570 static code_t* method_header(methodstate_t*m);
571 static code_t* wrap_function(code_t*c,code_t*header, code_t*body);
572 static void function_initvars(methodstate_t*m, char has_params, params_t*params, int flags, char var0);
575 static char* internal_filename_package = 0;
576 void initialize_file(char*filename)
579 syntaxerror("invalid call to initialize_file during parsing of another file");
583 state->package = internal_filename_package = strdup(filename);
585 global->token2info = dict_lookup(global->file2token2info,
586 current_filename // use long version
588 if(!global->token2info) {
589 global->token2info = dict_new2(&ptr_type);
590 dict_put(global->file2token2info, current_filename, global->token2info);
594 state->method = rfx_calloc(sizeof(methodstate_t));
595 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
596 state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope
597 state->method->allvars = dict_new();
599 state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
600 state->method->variable_count = 0;
602 syntaxerror("internal error: skewed tokencount");
603 function_initvars(state->method, 0, 0, 0, 1);
610 if(!state || state->level!=1) {
611 syntaxerror("unexpected end of file in pass %d", as3_pass);
615 dict_del(global->file2token2info, current_filename);
616 code_t*header = method_header(state->method);
617 //if(global->init->method->body->code || global->init->traits) {
619 code_t*c = wrap_function(header, 0, global->init->method->body->code);
620 global->init->method->body->code = abc_returnvoid(c);
621 free(state->method);state->method=0;
625 //free(state->package);state->package=0; // used in registry
626 state_destroy(state);state=0;
629 void initialize_parser()
631 global = rfx_calloc(sizeof(global_t));
632 global->file = abc_file_new();
633 global->file->flags &= ~ABCFILE_LAZY;
634 global->file2token2info = dict_new();
635 global->token2info = 0;
636 global->classinit = abc_initscript(global->file);
639 void* finish_parser()
641 dict_free_all(global->file2token2info, 1, (void*)dict_destroy);
642 global->token2info=0;
644 initcode_add_classlist(global->classinit, global->classes);
649 typedef struct _variable {
655 methodstate_t*is_inner_method;
658 static variable_t* find_variable(state_t*s, const char*name)
660 if(s->method->no_variable_scoping) {
661 return dict_lookup(s->method->allvars, name);
666 v = dict_lookup(s->vars, name);
668 if(s->new_vars) break;
674 static variable_t* find_slot(methodstate_t*m, const char*name)
677 return dict_lookup(m->slots, name);
681 static variable_t* find_variable_safe(state_t*s, char*name)
683 variable_t* v = find_variable(s, name);
685 syntaxerror("undefined variable: %s", name);
689 static char variable_exists(char*name)
691 return dict_contains(state->vars, name);
694 static code_t*defaultvalue(code_t*c, classinfo_t*type)
696 parserassert(!type || type->kind!=INFOTYPE_UNRESOLVED);
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)) {
703 } else if(TYPE_IS_BOOLEAN(type)) {
704 c = abc_pushfalse(c);
705 } else if(TYPE_IS_STRING(type)) {
709 //c = abc_pushundefined(c);
710 syntaxerror("internal error: can't generate default value for * type");
714 c = abc_coerce2(c, &m);
719 static int alloc_local()
721 return state->method->variable_count++;
724 static variable_t* new_variable2(methodstate_t*method, const char*name, classinfo_t*type, char init, char maybeslot)
727 variable_t*v = find_slot(method, name);
735 v->index = alloc_local();
737 v->init = v->kill = init;
740 if(!method->no_variable_scoping)
742 if(dict_contains(state->vars, name)) {
743 syntaxerror("variable %s already defined", name);
745 dict_put(state->vars, name, v);
747 if(method->no_variable_scoping &&
749 dict_contains(state->method->allvars, name))
751 variable_t*v = dict_lookup(state->method->allvars, name);
752 if(v->type != type && (!v->type || v->type->kind!=INFOTYPE_UNRESOLVED)) {
753 syntaxerror("variable %s already defined.", name);
757 dict_put(state->method->allvars, name, v);
762 static int new_variable(methodstate_t*method, const char*name, classinfo_t*type, char init, char maybeslot)
764 return new_variable2(method, name, type, init, maybeslot)->index;
767 #define TEMPVARNAME "__as3_temp__"
770 variable_t*v = find_variable(state, TEMPVARNAME);
775 i = new_variable(state->method, TEMPVARNAME, 0, 0, 0);
780 static code_t* var_block(code_t*body, dict_t*vars)
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);
790 if(v->type && v->kill) {
791 k = abc_kill(k, v->index);
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);
814 c = code_append(c, body);
815 c = code_append(c, k);
819 static void unknown_variable(char*name)
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);
827 static code_t* add_scope_code(code_t*c, methodstate_t*m, char init)
829 if(m->uses_slots || m->innerfunctions || (m->late_binding && !m->inner)) {
830 c = abc_getlocal_0(c);
831 c = abc_pushscope(c);
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();
840 c = abc_newactivation(c);
842 c = abc_pushscope(c);
843 c = abc_setlocal(c, m->activation_var);
845 c = abc_getlocal(c, m->activation_var);
846 c = abc_pushscope(c);
852 static code_t* method_header(methodstate_t*m)
856 c = add_scope_code(c, m, 1);
858 methodstate_list_t*l = m->innerfunctions;
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);
865 c = abc_setlocal(c, l->methodstate->var_index);
866 c = abc_setslot(c, l->methodstate->slot_index);
868 c = abc_newfunction(c, l->methodstate->abc);
869 c = abc_setlocal(c, l->methodstate->var_index);
871 free(l->methodstate);l->methodstate=0;
875 c = code_append(c, m->header);
878 if(m->is_constructor && !m->has_super) {
879 // call default constructor
880 c = abc_getlocal_0(c);
881 c = abc_constructsuper(c, 0);
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);
896 list_free(m->innerfunctions);
897 m->innerfunctions = 0;
902 static code_t* wrap_function(code_t*c,code_t*header, code_t*body)
904 c = code_append(c, header);
905 c = code_append(c, var_block(body, state->method->no_variable_scoping?state->method->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);
914 static void startpackage(char*name)
917 state->package = strdup(name);
919 static void endpackage()
921 //used e.g. in classinfo_register:
922 //free(state->package);state->package=0;
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
932 static slotinfo_t* find_class(const char*name);
934 const char* lookup_namespace(const char*name)
938 const char*url = dict_lookup(s->namespaces, name);
944 registry_find(state->package, name);
945 if(( a = (varinfo_t*)find_class(name) )) {
946 if(a->kind == INFOTYPE_VAR) {
947 if(!a->value || !NS_TYPE(a->value->type))
948 syntaxerror("%s.%s is not a namespace", a->package, a->name);
949 return a->value->ns->name;
955 static namespace_t modifiers2access(modifiers_t*mod)
960 if(mod->flags&FLAG_NAMESPACE) {
961 if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
962 syntaxerror("invalid combination of access levels and namespaces");
963 ns.access = ACCESS_NAMESPACE;
964 const char*url = lookup_namespace(mod->ns);
967 syntaxerror("unknown namespace: %s (pass %d)", mod->ns, as3_pass);
973 } else if(mod->flags&FLAG_PUBLIC) {
974 if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
975 syntaxerror("invalid combination of access levels");
976 ns.access = ACCESS_PACKAGE;
977 } else if(mod->flags&FLAG_PRIVATE) {
978 if(mod->flags&(FLAG_PUBLIC|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
979 syntaxerror("invalid combination of access levels");
980 ns.access = ACCESS_PRIVATE;
981 } else if(mod->flags&FLAG_PROTECTED) {
982 if(mod->flags&(FLAG_PUBLIC|FLAG_PRIVATE|FLAG_PACKAGEINTERNAL))
983 syntaxerror("invalid combination of access levels");
984 ns.access = ACCESS_PROTECTED;
986 ns.access = ACCESS_PACKAGEINTERNAL;
991 static memberinfo_t* findmember_nsset(classinfo_t*cls, const char*name, char recurse, char is_static)
993 return registry_findmember_nsset(cls, state->active_namespace_urls, name, recurse, is_static);
996 static void innerfunctions2vars(methodstate_t*m)
998 methodstate_list_t*l = m->innerfunctions;
1000 methodstate_t*m = l->methodstate;
1002 variable_t* v = new_variable2(state->method, m->info->name, TYPE_FUNCTION(m->info), 0, 0);
1003 m->var_index = v->index;
1005 m->slot_index = m->is_a_slot;
1006 v->is_inner_method = m;
1011 static void function_initvars(methodstate_t*m, char has_params, params_t*params, int flags, char var0)
1016 index = new_variable(m, "this", 0, 0, 0);
1017 else if(!m->is_global)
1018 index = new_variable(m, (flags&FLAG_STATIC)?"class":"this", state->cls?state->cls->info:0, 0, 0);
1020 index = new_variable(m, "globalscope", 0, 0, 0);
1022 DICT_ITERATE_ITEMS(state->vars, char*, name, variable_t*, v) {
1023 printf("%s %d\n", name, v->index);
1026 parserassert(!index);
1031 for(p=params->list;p;p=p->next) {
1032 variable_t*v = new_variable2(m, p->param->name, p->param->type, 0, 1);
1033 v->is_parameter = 1;
1035 if(as3_pass==2 && m->need_arguments) {
1036 /* arguments can never be used by an innerfunction (the inner functions
1037 have their own arguments var), so it's ok to not initialize this until
1038 pass 2. (We don't know whether we need it before, anyway) */
1039 variable_t*v = new_variable2(m, "arguments", TYPE_ARRAY, 0, 0);
1040 m->need_arguments = v->index;
1044 innerfunctions2vars(m);
1047 m->scope_code = add_scope_code(m->scope_code, m, 0);
1049 /* exchange unresolved identifiers with the actual objects */
1050 DICT_ITERATE_ITEMS(m->slots, char*, name, variable_t*, v1) {
1051 if(v1->type && v1->type->kind == INFOTYPE_UNRESOLVED) {
1052 classinfo_t*type = (classinfo_t*)registry_resolve((slotinfo_t*)v1->type);
1053 if(!type || type->kind != INFOTYPE_CLASS) {
1054 syntaxerror("Couldn't find class %s::%s (%s)", v1->type->package, v1->type->name, name);
1061 DICT_ITERATE_ITEMS(m->allvars, char*, name2, variable_t*, v2) {
1062 if(v2->type && v2->type->kind == INFOTYPE_UNRESOLVED) {
1063 classinfo_t*type = (classinfo_t*)registry_resolve((slotinfo_t*)v2->type);
1064 if(!type || type->kind != INFOTYPE_CLASS) {
1065 syntaxerror("Couldn't find class %s::%s (%s)", v2->type->package, v2->type->name, name2);
1075 char*as3_globalclass=0;
1076 static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, classinfo_list_t*implements)
1079 syntaxerror("inner classes now allowed");
1084 classinfo_list_t*mlist=0;
1086 if(mod->flags&~(FLAG_PACKAGEINTERNAL|FLAG_PUBLIC|FLAG_FINAL|FLAG_DYNAMIC|FLAG_INTERFACE))
1087 syntaxerror("invalid modifier(s)");
1089 if((mod->flags&(FLAG_PUBLIC|FLAG_PACKAGEINTERNAL)) == (FLAG_PUBLIC|FLAG_PACKAGEINTERNAL))
1090 syntaxerror("public and internal not supported at the same time.");
1092 if((mod->flags&(FLAG_PROTECTED|FLAG_STATIC)) == (FLAG_PROTECTED|FLAG_STATIC))
1093 syntaxerror("protected and static not supported at the same time.");
1095 //if(!(mod->flags&FLAG_INTERFACE) && !extends) {
1096 if(!(mod->flags&FLAG_INTERFACE) && !extends) {
1097 // all classes extend object
1098 extends = registry_getobjectclass();
1101 /* create the class name, together with the proper attributes */
1105 if(!(mod->flags&FLAG_PUBLIC) && state->package==internal_filename_package) {
1106 access = ACCESS_PRIVATE; package = internal_filename_package;
1107 } else if(!(mod->flags&FLAG_PUBLIC) && state->package!=internal_filename_package) {
1108 access = ACCESS_PACKAGEINTERNAL; package = state->package;
1109 } else if(state->package!=internal_filename_package) {
1110 access = ACCESS_PACKAGE; package = state->package;
1112 syntaxerror("public classes only allowed inside a package");
1116 state->cls = rfx_calloc(sizeof(classstate_t));
1117 state->cls->init = methodstate_new();
1118 state->cls->static_init = methodstate_new();
1119 state->cls->static_init->is_static=FLAG_STATIC;
1120 /* notice: we make no effort to initialize the top variable (local0) here,
1121 even though it has special meaning. We just rely on the fact
1122 that pass 1 won't do anything with variables */
1124 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->cls);
1126 /* set current method to constructor- all code within the class-level (except
1127 static variable initializations) will be executed during construction time */
1128 state->method = state->cls->init;
1130 if(registry_find(package, classname)) {
1131 syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, classname);
1133 /* build info struct */
1134 int num_interfaces = (list_length(implements));
1135 state->cls->info = classinfo_register(access, package, classname, num_interfaces);
1136 state->cls->info->flags |= mod->flags & (FLAG_DYNAMIC|FLAG_INTERFACE|FLAG_FINAL);
1137 state->cls->info->superclass = extends;
1140 classinfo_list_t*l = implements;
1141 for(l=implements;l;l=l->next) {
1142 state->cls->info->interfaces[pos++] = l->classinfo;
1147 state->cls = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1149 parserassert(state->cls && state->cls->info);
1151 state->method = state->cls->static_init;
1153 function_initvars(state->cls->init, 0, 0, 0, 1);
1154 state->cls->static_init->variable_count=1;
1155 function_initvars(state->cls->static_init, 0, 0, 0, 0);
1157 if(extends && (extends->flags & FLAG_FINAL))
1158 syntaxerror("Can't extend final class '%s'", extends->name);
1161 while(state->cls->info->interfaces[pos]) {
1162 if(!(state->cls->info->interfaces[pos]->flags & FLAG_INTERFACE))
1163 syntaxerror("'%s' is not an interface",
1164 state->cls->info->interfaces[pos]->name);
1168 /* generate the abc code for this class */
1169 MULTINAME(classname2,state->cls->info);
1170 multiname_t*extends2 = sig2mname(extends);
1172 /* don't add the class to the class index just yet- that will be done later
1174 state->cls->abc = abc_class_new(0, &classname2, extends2);
1175 state->cls->abc->file = global->file;
1177 multiname_destroy(extends2);
1178 if(state->cls->info->flags&FLAG_FINAL) abc_class_final(state->cls->abc);
1179 if(!(state->cls->info->flags&FLAG_DYNAMIC)) abc_class_sealed(state->cls->abc);
1180 if(state->cls->info->flags&FLAG_INTERFACE) {
1181 abc_class_interface(state->cls->abc);
1184 for(mlist=implements;mlist;mlist=mlist->next) {
1185 MULTINAME(m, mlist->classinfo);
1186 abc_class_add_interface(state->cls->abc, &m);
1189 state->cls->dependencies = parsedclass_new(state->cls->info, state->cls->abc);
1190 list_append(global->classes, state->cls->dependencies);
1192 /* flash.display.MovieClip handling */
1193 if(!as3_globalclass && (mod->flags&FLAG_PUBLIC) && slotinfo_equals((slotinfo_t*)registry_getMovieClip(),(slotinfo_t*)extends)) {
1194 if(state->package && state->package[0]) {
1195 as3_globalclass = concat3(state->package, ".", classname);
1197 as3_globalclass = strdup(classname);
1203 static void endclass()
1206 if(!state->cls->has_constructor && !(state->cls->info->flags&FLAG_INTERFACE)) {
1208 c = abc_getlocal_0(c);
1209 c = abc_constructsuper(c, 0);
1210 state->cls->init->header = code_append(state->cls->init->header, c);
1211 state->cls->has_constructor=1;
1213 if(state->cls->init) {
1214 if(state->cls->info->flags&FLAG_INTERFACE) {
1215 if(state->cls->init->header)
1216 syntaxerror("interface can not have class-level code");
1218 abc_method_t*m = abc_class_getconstructor(state->cls->abc, 0);
1219 code_t*c = method_header(state->cls->init);
1220 m->body->code = wrap_function(c, 0, m->body->code);
1223 if(state->cls->static_init) {
1224 abc_method_t*m = abc_class_getstaticconstructor(state->cls->abc, 0);
1225 code_t*c = method_header(state->cls->static_init);
1226 m->body->code = wrap_function(c, 0, m->body->code);
1229 trait_list_t*trait = state->cls->abc->traits;
1230 /* switch all protected members to the protected ns of this class */
1232 trait_t*t = trait->trait;
1233 if(t->name->ns->access == ACCESS_PROTECTED) {
1234 if(!state->cls->abc->protectedNS) {
1235 char*n = concat3(state->cls->info->package, ":", state->cls->info->name);
1236 state->cls->abc->protectedNS = namespace_new_protected(n);
1237 state->cls->abc->flags |= CLASS_PROTECTED_NS;
1239 t->name->ns->name = strdup(state->cls->abc->protectedNS->name);
1241 trait = trait->next;
1248 void check_code_for_break(code_t*c)
1251 if(c->opcode == OPCODE___BREAK__) {
1252 char*name = string_cstr(c->data[0]);
1253 syntaxerror("Unresolved \"break %s\"", name);
1255 if(c->opcode == OPCODE___CONTINUE__) {
1256 char*name = string_cstr(c->data[0]);
1257 syntaxerror("Unresolved \"continue %s\"", name);
1259 if(c->opcode == OPCODE___RETHROW__) {
1260 syntaxerror("Unresolved \"rethrow\"");
1262 if(c->opcode == OPCODE___FALLTHROUGH__) {
1263 syntaxerror("Unresolved \"fallthrough\"");
1265 if(c->opcode == OPCODE___PUSHPACKAGE__) {
1266 char*name = string_cstr(c->data[0]);
1267 syntaxerror("Can't reference a package (%s) as such", name);
1273 static void check_constant_against_type(classinfo_t*t, constant_t*c)
1275 #define xassert(b) if(!(b)) syntaxerror("Invalid default value %s for type '%s'", constant_tostring(c), t->name)
1276 if(TYPE_IS_NUMBER(t)) {
1277 xassert(c->type == CONSTANT_FLOAT
1278 || c->type == CONSTANT_INT
1279 || c->type == CONSTANT_UINT);
1280 } else if(TYPE_IS_UINT(t)) {
1281 xassert(c->type == CONSTANT_UINT ||
1282 (c->type == CONSTANT_INT && c->i>=0));
1283 } else if(TYPE_IS_INT(t)) {
1284 xassert(c->type == CONSTANT_INT);
1285 } else if(TYPE_IS_BOOLEAN(t)) {
1286 xassert(c->type == CONSTANT_TRUE
1287 || c->type == CONSTANT_FALSE);
1291 static void check_override(memberinfo_t*m, int flags)
1295 if(m->parent == state->cls->info && !((flags^m->flags)&FLAG_STATIC))
1296 syntaxerror("class '%s' already contains a method/slot '%s'", m->parent->name, m->name);
1298 syntaxerror("internal error: overriding method %s, which doesn't have parent", m->name);
1299 if(m->access==ACCESS_PRIVATE)
1301 if(m->flags & FLAG_FINAL)
1302 syntaxerror("can't override final member %s", m->name);
1304 /* allow this. it's no issue.
1305 if((m->flags & FLAG_STATIC) && !(flags&FLAG_STATIC))
1306 syntaxerror("can't override static member %s", m->name);*/
1308 if(!(m->flags & FLAG_STATIC) && (flags&FLAG_STATIC))
1309 syntaxerror("can't override non-static member %s with static declaration", m->name);
1311 if(!(flags&FLAG_OVERRIDE) && !(flags&FLAG_STATIC) && !(m->flags&FLAG_STATIC)) {
1312 if(m->parent && !(m->parent->flags&FLAG_INTERFACE)) {
1313 if(m->kind == INFOTYPE_METHOD)
1314 syntaxerror("can't override without explicit 'override' declaration");
1316 syntaxerror("can't override '%s'", m->name);
1321 static methodinfo_t*registerfunction(enum yytokentype getset, modifiers_t*mod, char*name, params_t*params, classinfo_t*return_type, int slot)
1323 methodinfo_t*minfo = 0;
1324 namespace_t ns = modifiers2access(mod);
1327 minfo = methodinfo_register_global(ns.access, state->package, name);
1328 minfo->return_type = return_type;
1329 } else if(getset != KW_GET && getset != KW_SET) {
1331 memberinfo_t* m = registry_findmember(state->cls->info, ns.name, name, 0, mod->flags&FLAG_STATIC);
1333 syntaxerror("class already contains a %s '%s'", infotypename((slotinfo_t*)m), m->name);
1335 minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name, mod->flags&FLAG_STATIC);
1336 minfo->return_type = return_type;
1337 // getslot on a member slot only returns "undefined", so no need
1338 // to actually store these
1339 //state->minfo->slot = state->method->abc->method->trait->slot_id;
1341 //class getter/setter
1342 int gs = getset==KW_GET?SUBTYPE_GET:SUBTYPE_SET;
1344 if(getset == KW_GET) {
1346 } else if(params->list && params->list->param && !params->list->next) {
1347 type = params->list->param->type;
1349 syntaxerror("setter function needs to take exactly one argument");
1350 // not sure wether to look into superclasses here, too
1351 minfo = (methodinfo_t*)registry_findmember(state->cls->info, ns.name, name, 1, mod->flags&FLAG_STATIC);
1353 if(minfo->kind!=INFOTYPE_VAR)
1354 syntaxerror("class already contains a method called '%s'", name);
1355 if(!(minfo->subtype & (SUBTYPE_GETSET)))
1356 syntaxerror("class already contains a field called '%s'", name);
1357 if(minfo->subtype & gs)
1358 syntaxerror("getter/setter for '%s' already defined", name);
1359 /* make a setter or getter into a getset */
1360 minfo->subtype |= gs;
1363 FIXME: this check needs to be done in pass 2
1365 if((!minfo->return_type != !type) ||
1366 (minfo->return_type && type &&
1367 !strcmp(minfo->return_type->name, type->name))) {
1368 syntaxerror("different type in getter and setter: %s and %s",
1369 minfo->return_type?minfo->return_type->name:"*",
1370 type?type->name:"*");
1373 minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name, mod->flags&FLAG_STATIC);
1374 minfo->kind = INFOTYPE_VAR; //hack
1375 minfo->subtype = gs;
1376 minfo->return_type = type;
1379 /* can't assign a slot as getter and setter might have different slots */
1380 //minfo->slot = slot;
1382 if(mod->flags&FLAG_FINAL) minfo->flags |= FLAG_FINAL;
1383 if(mod->flags&FLAG_STATIC) minfo->flags |= FLAG_STATIC;
1384 if(mod->flags&FLAG_OVERRIDE) minfo->flags |= FLAG_OVERRIDE;
1389 static void innerfunction(char*name, params_t*params, classinfo_t*return_type)
1391 //parserassert(state->method && state->method->info);
1393 methodstate_t*parent_method = state->method;
1397 return_type = 0; // not valid in pass 1
1399 v = new_variable2(parent_method, name, 0, 0, 0);
1404 state->new_vars = 1;
1407 state->method = methodstate_new();
1408 state->method->inner = 1;
1409 state->method->is_static = parent_method->is_static;
1410 state->method->variable_count = 0;
1411 state->method->abc = rfx_calloc(sizeof(abc_method_t));
1413 v->is_inner_method = state->method;
1416 NEW(methodinfo_t,minfo);
1417 minfo->kind = INFOTYPE_METHOD;
1418 minfo->access = ACCESS_PACKAGEINTERNAL;
1420 state->method->info = minfo;
1423 list_append(parent_method->innerfunctions, state->method);
1425 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
1427 function_initvars(state->method, 1, params, 0, 1);
1431 state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1432 state->method->variable_count = 0;
1433 parserassert(state->method);
1435 state->method->info->return_type = return_type;
1436 function_initvars(state->method, 1, params, 0, 1);
1440 static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,
1441 params_t*params, classinfo_t*return_type)
1443 if(state->method && state->method->info) {
1444 syntaxerror("not able to start another method scope");
1447 state->new_vars = 1;
1450 state->method = methodstate_new();
1451 state->method->has_super = 0;
1452 state->method->is_static = mod->flags&FLAG_STATIC;
1455 state->method->is_constructor = !strcmp(state->cls->info->name,name);
1457 state->method->is_global = 1;
1458 state->method->late_binding = 1; // for global methods, always push local_0 on the scope stack
1460 if(state->method->is_constructor)
1461 name = "__as3_constructor__";
1463 state->method->info = registerfunction(getset, mod, name, params, return_type, 0);
1465 function_initvars(state->method, 1, params, mod->flags, 1);
1467 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
1471 state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1472 state->method->variable_count = 0;
1473 parserassert(state->method);
1476 memberinfo_t*m = registry_findmember(state->cls->info, mod->ns, name, 2, mod->flags&FLAG_STATIC);
1477 check_override(m, mod->flags);
1481 state->cls->has_constructor |= state->method->is_constructor;
1484 function_initvars(state->method, 1, params, mod->flags, 1);
1488 static void insert_unresolved(methodstate_t*m, dict_t*xvars, dict_t*allvars)
1490 parserassert(m->inner);
1491 if(m->unresolved_variables) {
1492 dict_t*d = m->unresolved_variables;
1494 DICT_ITERATE_KEY(d, char*, id) {
1495 /* check parent method's variables */
1497 if(dict_contains(allvars, id)) {
1498 m->uses_parent_function = 1;
1499 state->method->uses_slots = 1;
1500 dict_put(xvars, id, 0);
1504 methodstate_list_t*ml = m->innerfunctions;
1506 insert_unresolved(ml->methodstate, xvars, allvars);
1511 static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*name,
1512 params_t*params, classinfo_t*return_type, code_t*body)
1515 dict_t*xvars = dict_new();
1517 if(state->method->unresolved_variables) {
1518 DICT_ITERATE_KEY(state->method->unresolved_variables, char*, vname) {
1519 if(!state->method->no_variable_scoping && dict_contains(state->method->allvars, vname)) {
1520 variable_t*v = dict_lookup(state->method->allvars, vname);
1521 if(!v->is_inner_method) {
1522 state->method->no_variable_scoping = 1;
1523 as3_warning("function %s uses forward or outer block variable references (%s): switching into compatibility mode", name, vname);
1529 methodstate_list_t*ml = state->method->innerfunctions;
1531 insert_unresolved(ml->methodstate, xvars, state->method->allvars);
1535 if(state->method->uses_slots) {
1536 state->method->slots = dict_new();
1538 DICT_ITERATE_ITEMS(state->method->allvars, char*, name, variable_t*, v) {
1539 if(!name) syntaxerror("internal error");
1540 if(v->index && dict_contains(xvars, name)) {
1541 v->init = v->kill = 0;
1543 if(v->is_inner_method) {
1544 v->is_inner_method->is_a_slot = i;
1547 dict_put(state->method->slots, name, v);
1550 state->method->uses_slots = i;
1551 dict_destroy(state->vars);state->vars = 0;
1552 parserassert(state->new_vars);
1559 /*if(state->method->uses_parent_function){
1560 syntaxerror("accessing variables of parent function from inner functions not supported yet");
1565 multiname_t*type2 = sig2mname(return_type);
1567 if(state->method->inner) {
1568 f = state->method->abc;
1569 abc_method_init(f, global->file, type2, 1);
1570 } else if(state->method->is_constructor) {
1571 f = abc_class_getconstructor(state->cls->abc, type2);
1572 } else if(!state->method->is_global) {
1573 namespace_t ns = modifiers2access(mod);
1574 multiname_t mname = {QNAME, &ns, 0, name};
1575 if(mod->flags&FLAG_STATIC)
1576 f = abc_class_staticmethod(state->cls->abc, type2, &mname);
1578 f = abc_class_method(state->cls->abc, type2, &mname);
1579 slot = f->trait->slot_id;
1581 namespace_t mname_ns = {state->method->info->access, state->package};
1582 multiname_t mname = {QNAME, &mname_ns, 0, name};
1584 f = abc_method_new(global->file, type2, 1);
1585 if(!global->init) global->init = abc_initscript(global->file);
1586 trait_t*t = trait_new_method(&global->init->traits, multiname_clone(&mname), f);
1587 //abc_code_t*c = global->init->method->body->code;
1589 //flash doesn't seem to allow us to access function slots
1590 //state->method->info->slot = slot;
1592 if(mod && mod->flags&FLAG_OVERRIDE) f->trait->attributes |= TRAIT_ATTR_OVERRIDE;
1593 if(getset == KW_GET) f->trait->kind = TRAIT_GETTER;
1594 if(getset == KW_SET) f->trait->kind = TRAIT_SETTER;
1595 if(params->varargs) f->flags |= METHOD_NEED_REST;
1596 if(state->method->need_arguments) f->flags |= METHOD_NEED_ARGUMENTS;
1600 for(p=params->list;p;p=p->next) {
1601 if(params->varargs && !p->next) {
1602 break; //varargs: omit last parameter in function signature
1604 multiname_t*m = sig2mname(p->param->type);
1605 list_append(f->parameters, m);
1606 if(p->param->value) {
1607 check_constant_against_type(p->param->type, p->param->value);
1608 opt=1;list_append(f->optional_parameters, p->param->value);
1610 syntaxerror("function %s: non-optional parameter not allowed after optional parameters", name);
1613 if(state->method->slots) {
1614 DICT_ITERATE_ITEMS(state->method->slots, char*, name, variable_t*, v) {
1616 multiname_t*mname = multiname_new(namespace_new(ACCESS_PACKAGE, ""), name);
1617 multiname_t*type = sig2mname(v->type);
1618 trait_t*t = trait_new_member(&f->body->traits, type, mname, 0);
1619 t->slot_id = v->index;
1624 check_code_for_break(body);
1626 /* Seems this works now.
1627 if(state->method->exceptions && state->method->uses_slots) {
1628 as3_warning("try/catch and activation not supported yet within the same method");
1632 f->body->code = body;
1633 f->body->exceptions = state->method->exceptions;
1634 } else { //interface
1636 syntaxerror("interface methods can't have a method body");
1646 void breakjumpsto(code_t*c, char*name, code_t*jump)
1649 if(c->opcode == OPCODE___BREAK__) {
1650 string_t*name2 = c->data[0];
1651 if(!name2->len || !strncmp(name2->str, name, name2->len)) {
1652 c->opcode = OPCODE_JUMP;
1659 void continuejumpsto(code_t*c, char*name, code_t*jump)
1662 if(c->opcode == OPCODE___CONTINUE__) {
1663 string_t*name2 = c->data[0];
1664 if(!name2->len || !strncmp(name2->str, name, name2->len)) {
1665 c->opcode = OPCODE_JUMP;
1673 code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
1678 return abc_coerce_a(c);
1682 // cast an "any" type to a specific type. subject to
1683 // runtime exceptions
1684 return abc_coerce2(c, &m);
1687 if((TYPE_IS_NUMBER(from) || TYPE_IS_UINT(from) || TYPE_IS_INT(from)) &&
1688 (TYPE_IS_NUMBER(to) || TYPE_IS_UINT(to) || TYPE_IS_INT(to))) {
1689 // allow conversion between number types
1690 if(TYPE_IS_UINT(to))
1691 return abc_convert_u(c);
1692 else if(TYPE_IS_INT(to))
1693 return abc_convert_i(c);
1694 else if(TYPE_IS_NUMBER(to))
1695 return abc_convert_d(c);
1696 return abc_coerce2(c, &m);
1699 if(TYPE_IS_XMLLIST(to) && TYPE_IS_XML(from))
1702 if(TYPE_IS_BOOLEAN(to))
1703 return abc_convert_b(c);
1704 if(TYPE_IS_STRING(to))
1705 return abc_convert_s(c);
1706 if(TYPE_IS_OBJECT(to))
1707 return abc_coerce2(c, &m);
1708 if(TYPE_IS_OBJECT(from) && TYPE_IS_XMLLIST(to))
1709 return abc_coerce2(c, &m);
1710 if(TYPE_IS_OBJECT(from) && TYPE_IS_ARRAY(to))
1711 return abc_coerce2(c, &m);
1713 classinfo_t*supertype = from;
1715 if(supertype == to) {
1716 /* target type is one of from's superclasses.
1717 (not sure we need this coerce - as far as the verifier
1718 is concerned, object==object (i think) */
1719 return abc_coerce2(c, &m);
1722 while(supertype->interfaces[t]) {
1723 if(supertype->interfaces[t]==to) {
1724 // target type is one of from's interfaces
1725 return abc_coerce2(c, &m);
1729 supertype = supertype->superclass;
1731 if(TYPE_IS_FUNCTION(from) && TYPE_IS_FUNCTION(to))
1733 if(TYPE_IS_CLASS(from) && TYPE_IS_CLASS(to))
1735 if(TYPE_IS_NULL(from) && !IS_NUMBER_OR_INT(to))
1739 as3_error("can't convert type %s%s%s to %s%s%s",
1740 from->package, from->package[0]?".":"", from->name,
1741 to->package, to->package[0]?".":"", to->name);
1745 code_t* coerce_to_type(code_t*c, classinfo_t*t)
1748 return abc_coerce_a(c);
1749 } else if(TYPE_IS_STRING(t)) {
1750 return abc_coerce_s(c);
1753 return abc_coerce2(c, &m);
1757 char is_pushundefined(code_t*c)
1759 return (c && !c->prev && !c->next && c->opcode == OPCODE_PUSHUNDEFINED);
1762 static const char* get_package_from_name(const char*name)
1764 /* try explicit imports */
1765 dictentry_t* e = dict_get_slot(state->imports, name);
1767 if(!strcmp(e->key, name)) {
1768 slotinfo_t*c = (slotinfo_t*)e->data;
1769 if(c) return c->package;
1775 static namespace_list_t*get_current_imports()
1777 namespace_list_t*searchlist = 0;
1779 list_append(searchlist, namespace_new_package(state->package));
1781 import_list_t*l = state->wildcard_imports;
1783 namespace_t*ns = namespace_new_package(l->import->package);
1784 list_append(searchlist, ns);
1787 list_append(searchlist, namespace_new_package(""));
1788 list_append(searchlist, namespace_new_package(internal_filename_package));
1792 static slotinfo_t* find_class(const char*name)
1796 c = registry_find(state->package, name);
1799 /* try explicit imports */
1800 dictentry_t* e = dict_get_slot(state->imports, name);
1803 if(!strcmp(e->key, name)) {
1804 c = (slotinfo_t*)e->data;
1810 /* try package.* imports */
1811 import_list_t*l = state->wildcard_imports;
1813 //printf("does package %s contain a class %s?\n", l->import->package, name);
1814 c = registry_find(l->import->package, name);
1819 /* try global package */
1820 c = registry_find("", name);
1823 /* try local "filename" package */
1824 c = registry_find(internal_filename_package, name);
1829 typedcode_t push_class(slotinfo_t*a)
1834 if(a->access == ACCESS_PACKAGEINTERNAL &&
1835 strcmp(a->package, state->package) &&
1836 strcmp(a->package, internal_filename_package)
1838 syntaxerror("Can't access internal %s %s in package '%s' from package '%s'",
1839 infotypename(a), a->name, a->package, state->package);
1843 if(a->kind != INFOTYPE_CLASS) {
1845 x.c = abc_findpropstrict2(x.c, &m);
1846 x.c = abc_getproperty2(x.c, &m);
1847 if(a->kind == INFOTYPE_METHOD) {
1848 methodinfo_t*f = (methodinfo_t*)a;
1849 x.t = TYPE_FUNCTION(f);
1851 varinfo_t*v = (varinfo_t*)a;
1856 if(state->cls && state->method == state->cls->static_init) {
1857 /* we're in the static initializer.
1858 record the fact that we're using this class here */
1859 parsedclass_add_dependency(state->cls->dependencies, (classinfo_t*)a);
1861 classinfo_t*c = (classinfo_t*)a;
1863 if(0) { //Error #1026: Slot 1 exceeds slotCount=0 of global
1864 x.c = abc_getglobalscope(x.c);
1865 x.c = abc_getslot(x.c, c->slot);
1868 x.c = abc_getlex2(x.c, &m);
1870 x.t = TYPE_CLASS(c);
1876 char is_break_or_jump(code_t*c)
1880 if(c->opcode == OPCODE_JUMP ||
1881 c->opcode == OPCODE___BREAK__ ||
1882 c->opcode == OPCODE___CONTINUE__ ||
1883 c->opcode == OPCODE_THROW ||
1884 c->opcode == OPCODE_RETURNVOID ||
1885 c->opcode == OPCODE_RETURNVALUE) {
1891 #define IS_FINALLY_TARGET(op) \
1892 ((op) == OPCODE___CONTINUE__ || \
1893 (op) == OPCODE___BREAK__ || \
1894 (op) == OPCODE_RETURNVOID || \
1895 (op) == OPCODE_RETURNVALUE || \
1896 (op) == OPCODE___RETHROW__)
1898 static code_t* insert_finally_lookup(code_t*c, code_t*finally, int tempvar)
1900 #define NEED_EXTRA_STACK_ARG
1901 code_t*finally_label = abc_nop(0);
1902 NEW(lookupswitch_t, l);
1908 code_t*prev = i->prev;
1909 if(IS_FINALLY_TARGET(i->opcode)) {
1912 if(i->opcode == OPCODE___RETHROW__ ||
1913 i->opcode == OPCODE_RETURNVALUE) {
1914 if(i->opcode == OPCODE___RETHROW__)
1915 i->opcode = OPCODE_THROW;
1917 p = abc_coerce_a(p);
1918 p = abc_setlocal(p, tempvar);
1920 p = abc_pushbyte(p, count++);
1921 p = abc_jump(p, finally_label);
1922 code_t*target = p = abc_label(p);
1923 #ifdef NEED_EXTRA_STACK_ARG
1927 p = abc_getlocal(p, tempvar);
1930 p->next = i;i->prev = p;
1931 list_append(l->targets, target);
1937 c = abc_pushbyte(c, -1);
1938 c = code_append(c, finally_label);
1939 c = code_append(c, finally);
1941 #ifdef NEED_EXTRA_STACK_ARG
1944 c = abc_lookupswitch(c, l);
1945 c = l->def = abc_label(c);
1946 #ifdef NEED_EXTRA_STACK_ARG
1953 static code_t* insert_finally_simple(code_t*c, code_t*finally, int tempvar)
1957 code_t*prev = i->prev;
1958 if(IS_FINALLY_TARGET(i->opcode)) {
1959 if(i->opcode == OPCODE___RETHROW__)
1960 i->opcode = OPCODE_THROW;
1961 code_t*end = code_dup(finally);
1962 code_t*start = code_start(end);
1963 if(prev) prev->next = start;
1970 return code_append(c, finally);
1973 code_t* insert_finally(code_t*c, code_t*finally, int tempvar)
1979 int num_insertion_points=0;
1981 if(IS_FINALLY_TARGET(i->opcode))
1982 num_insertion_points++;
1989 if(i->branch || i->opcode == OPCODE_LOOKUPSWITCH) {
1994 int simple_version_cost = (1+num_insertion_points)*code_size;
1995 int lookup_version_cost = 4*num_insertion_points + 5;
1997 if(cantdup || simple_version_cost > lookup_version_cost) {
1998 //printf("(use lookup) simple=%d > lookup=%d\n", simple_version_cost, lookup_version_cost);
1999 return insert_finally_lookup(c, finally, tempvar);
2001 //printf("(use simple) simple=%d < lookup=%d\n", simple_version_cost, lookup_version_cost);
2002 return insert_finally_simple(c, finally, tempvar);
2006 #define PASS1 }} if(as3_pass == 1) {{
2007 #define PASS1END }} if(as3_pass == 2) {{
2008 #define PASS2 }} if(as3_pass == 2) {{
2009 #define PASS12 }} if(as3_pass == 1 || as3_pass == 2) {{
2010 #define PASS12END }} if(as3_pass == 2) {{
2011 #define PASS_ALWAYS }} {{
2015 /* Line 273 of skeleton.m4 */
2016 #line 2017 "parser.tab.c"
2017 /* Unqualified %code blocks. */
2019 /* Line 274 of skeleton.m4 */
2020 #line 2107 "parser.y"
2022 char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
2026 char do_init_variable(char*name)
2028 if(!state->method->no_variable_scoping)
2030 if(!state->new_vars)
2036 /* Line 274 of skeleton.m4 */
2037 #line 2557 "parser.y"
2039 static void state_has_imports()
2041 state->wildcard_imports = list_clone(state->wildcard_imports);
2042 state->imports = dict_clone(state->imports);
2043 state->has_own_imports = 1;
2045 static void import_toplevel(const char*package)
2047 char* s = strdup(package);
2049 dict_put(state->import_toplevel_packages, s, 0);
2050 char*x = strrchr(s, '.');
2059 /* Line 274 of skeleton.m4 */
2060 #line 2700 "parser.y"
2062 static int slotstate_varconst = 0;
2063 static modifiers_t*slotstate_flags = 0;
2064 static void setslotstate(modifiers_t* flags, int varconst)
2066 slotstate_varconst = varconst;
2067 slotstate_flags = flags;
2070 if(flags->flags&FLAG_STATIC) {
2071 state->method = state->cls->static_init;
2073 state->method = state->cls->init;
2076 // reset to "default" state (all in class code is static by default) */
2077 state->method = state->cls->static_init;
2080 parserassert(state->method);
2083 static trait_t* add_abc_slot(modifiers_t* modifiers, const char*name, multiname_t*m, code_t***c)
2085 int flags = modifiers->flags;
2086 namespace_t ns = modifiers2access(modifiers);
2089 multiname_t mname = {QNAME, &ns, 0, name};
2091 trait_list_t**traits;
2095 if(!global->init) global->init = abc_initscript(global->file);
2096 ns.name = state->package;
2097 traits = &global->init->traits;
2098 code = &global->init->method->body->code;
2099 } else if(flags&FLAG_STATIC) {
2101 traits = &state->cls->abc->static_traits;
2102 code = &state->cls->static_init->header;
2104 // instance variable
2105 traits = &state->cls->abc->traits;
2106 code = &state->cls->init->header;
2108 if(ns.access == ACCESS_PROTECTED) {
2109 ns.name = concat3(state->cls->info->package,":",state->cls->info->name);
2115 *m = *multiname_clone(&mname);
2117 return trait_new_member(traits, 0, multiname_clone(&mname), 0);
2121 /* Line 274 of skeleton.m4 */
2122 #line 2874 "parser.y"
2124 static int xml_level = 0;
2127 /* Line 274 of skeleton.m4 */
2128 #line 3541 "parser.y"
2130 node_t* resolve_identifier(const char*name);
2131 node_t* get_descendants(node_t*e,const char*ns,const char*subnode,char multi, char attr)
2133 typedcode_t v = node_read(e);
2136 multiname_t m = {0,0,0,subnode};
2137 namespace_t zero = {ZERONAMESPACE,"*"};
2138 if(!strcmp(ns,"*")) {
2140 m.type = attr?QNAMEA:QNAME;
2142 typedcode_t w = node_read(resolve_identifier(ns));
2143 if(!TYPE_IS_NAMESPACE(w.t)) {
2144 as3_softwarning("%s might not be a namespace", ns);
2146 v.c = code_append(v.c, w.c);
2147 v.c = converttype(v.c, w.t, TYPE_NAMESPACE);
2148 m.type = attr?RTQNAMEA:RTQNAME;
2152 v.c = abc_getproperty2(v.c, &m);
2154 v.c = abc_getdescendants2(v.c, &m);
2157 if(TYPE_IS_XML(v.t)) {
2160 v.c = abc_coerce_a(v.c);
2163 return mkcodenode(v);
2167 /* Line 274 of skeleton.m4 */
2168 #line 3712 "parser.y"
2170 node_t* var_read(variable_t*v)
2173 o.c = abc_getlocal(0, v->index);
2175 return mkcodenode(o);
2178 node_t* resolve_identifier(const char*name)
2188 /* look at variables */
2189 if((v = find_variable(state, name))) {
2190 // name is a local variable
2193 if((v = find_slot(state->method, name))) {
2194 o.c = abc_getscopeobject(o.c, 1);
2195 o.c = abc_getslot(o.c, v->index);
2197 return mkcodenode(o);
2200 int i_am_static = state->method->is_static;
2202 if(!state->method->inner && !state->xmlfilter && state->cls)
2204 /* look at current class' members */
2205 if((f = findmember_nsset(state->cls->info, name, 1, i_am_static)))
2207 // name is a member or attribute in this class
2208 int var_is_static = (f->flags&FLAG_STATIC);
2210 if(f->kind == INFOTYPE_VAR && (f->flags&FLAG_CONST)) {
2211 /* if the variable is a constant (and we know what is evaluates to), we
2212 can just use the value itself */
2213 varinfo_t*v = (varinfo_t*)f;
2215 return mkconstnode(v->value);
2219 if(var_is_static >= i_am_static) {
2220 if(f->kind == INFOTYPE_METHOD) {
2221 o.t = TYPE_FUNCTION(f);
2226 if(var_is_static && !i_am_static) {
2227 /* access to a static member from a non-static location.
2228 do this via findpropstrict:
2229 there doesn't seem to be any non-lookup way to access
2230 static properties of a class */
2231 state->method->late_binding = 1;
2233 namespace_t ns = {f->access, f->package};
2234 multiname_t m = {QNAME, &ns, 0, name};
2235 o.c = abc_findpropstrict2(o.c, &m);
2236 o.c = abc_getproperty2(o.c, &m);
2237 return mkcodenode(o);
2238 } else if(f->slot>0) {
2239 o.c = abc_getlocal_0(o.c);
2240 o.c = abc_getslot(o.c, f->slot);
2241 return mkcodenode(o);
2243 MEMBER_MULTINAME(m, f, name);
2244 o.c = abc_getlocal_0(o.c);
2245 o.c = abc_getproperty2(o.c, &m);
2246 return mkcodenode(o);
2250 /* special case: it's allowed to access non-static constants
2251 from a static context */
2252 if(i_am_static && (f=findmember_nsset(state->cls->info, name, 1, 0))) {
2253 if(f->kind == INFOTYPE_VAR && (f->flags&FLAG_CONST)) {
2254 varinfo_t*v = (varinfo_t*)f;
2256 return mkconstnode(v->value);
2262 /* look at actual classes, in the current package and imported */
2263 if(!state->xmlfilter && (a = find_class(name))) {
2265 if(state->cls && state->cls->info == (classinfo_t*)a && i_am_static) {
2266 o.c = abc_getlocal_0(0);
2267 o.t = TYPE_CLASS((classinfo_t*)a);
2271 return mkcodenode(o);
2274 /* look through package prefixes */
2275 if(!state->xmlfilter &&
2276 (dict_contains(state->import_toplevel_packages, name) ||
2277 registry_ispackage(name))) {
2278 o.c = abc___pushpackage__(o.c, (char*)name);
2280 return mkcodenode(o); //?
2283 /* unknown object, let the avm2 resolve it */
2285 if(!state->method->inner && !state->xmlfilter) {
2286 /* we really should make inner functions aware of the class context */
2287 as3_warning("Couldn't resolve '%s', doing late binding", name);
2289 state->method->late_binding = 1;
2291 multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, name};
2294 o.c = abc_findpropstrict2(o.c, &m);
2295 o.c = abc_getproperty2(o.c, &m);
2296 return mkcodenode(o);
2301 /* Line 274 of skeleton.m4 */
2302 #line 3869 "parser.y"
2304 void add_active_url(const char*url)
2308 list_append(state->active_namespace_urls, n);
2313 /* Line 274 of skeleton.m4 */
2314 #line 2315 "parser.tab.c"
2321 typedef YYTYPE_UINT8 yytype_uint8;
2323 typedef unsigned char yytype_uint8;
2327 typedef YYTYPE_INT8 yytype_int8;
2328 #elif (defined __STDC__ || defined __C99__FUNC__ \
2329 || defined __cplusplus || defined _MSC_VER)
2330 typedef signed char yytype_int8;
2332 typedef short int yytype_int8;
2335 #ifdef YYTYPE_UINT16
2336 typedef YYTYPE_UINT16 yytype_uint16;
2338 typedef unsigned short int yytype_uint16;
2342 typedef YYTYPE_INT16 yytype_int16;
2344 typedef short int yytype_int16;
2348 # ifdef __SIZE_TYPE__
2349 # define YYSIZE_T __SIZE_TYPE__
2350 # elif defined size_t
2351 # define YYSIZE_T size_t
2352 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
2353 || defined __cplusplus || defined _MSC_VER)
2354 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
2355 # define YYSIZE_T size_t
2357 # define YYSIZE_T unsigned int
2361 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
2366 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
2367 # define YY_(msgid) dgettext ("bison-runtime", msgid)
2371 # define YY_(msgid) msgid
2375 /* Suppress unused-variable warnings by "using" E. */
2376 #if ! defined lint || defined __GNUC__
2377 # define YYUSE(e) ((void) (e))
2379 # define YYUSE(e) /* empty */
2382 /* Identity function, used to suppress warnings about constant conditions. */
2384 # define YYID(n) (n)
2386 #if (defined __STDC__ || defined __C99__FUNC__ \
2387 || defined __cplusplus || defined _MSC_VER)
2400 #if ! defined yyoverflow || YYERROR_VERBOSE
2402 /* The parser invokes alloca or malloc; define the necessary symbols. */
2404 # ifdef YYSTACK_USE_ALLOCA
2405 # if YYSTACK_USE_ALLOCA
2407 # define YYSTACK_ALLOC __builtin_alloca
2408 # elif defined __BUILTIN_VA_ARG_INCR
2409 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
2411 # define YYSTACK_ALLOC __alloca
2412 # elif defined _MSC_VER
2413 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
2414 # define alloca _alloca
2416 # define YYSTACK_ALLOC alloca
2417 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
2418 || defined __cplusplus || defined _MSC_VER)
2419 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
2421 # define _STDLIB_H 1
2428 # ifdef YYSTACK_ALLOC
2429 /* Pacify GCC's `empty if-body' warning. */
2430 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
2431 # ifndef YYSTACK_ALLOC_MAXIMUM
2432 /* The OS might guarantee only one guard page at the bottom of the stack,
2433 and a page size can be as small as 4096 bytes. So we cannot safely
2434 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
2435 to allow for a few compiler-allocated temporary stack slots. */
2436 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
2439 # define YYSTACK_ALLOC YYMALLOC
2440 # define YYSTACK_FREE YYFREE
2441 # ifndef YYSTACK_ALLOC_MAXIMUM
2442 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
2444 # if (defined __cplusplus && ! defined _STDLIB_H \
2445 && ! ((defined YYMALLOC || defined malloc) \
2446 && (defined YYFREE || defined free)))
2447 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
2449 # define _STDLIB_H 1
2453 # define YYMALLOC malloc
2454 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
2455 || defined __cplusplus || defined _MSC_VER)
2456 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
2460 # define YYFREE free
2461 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
2462 || defined __cplusplus || defined _MSC_VER)
2463 void free (void *); /* INFRINGES ON USER NAME SPACE */
2467 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
2470 #if (! defined yyoverflow \
2471 && (! defined __cplusplus \
2472 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
2474 /* A type that is properly aligned for any stack member. */
2477 yytype_int16 yyss_alloc;
2481 /* The size of the maximum gap between one aligned stack and the next. */
2482 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
2484 /* The size of an array large to enough to hold all stacks, each with
2486 # define YYSTACK_BYTES(N) \
2487 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
2488 + YYSTACK_GAP_MAXIMUM)
2490 /* Copy COUNT objects from FROM to TO. The source and destination do
2493 # if defined __GNUC__ && 1 < __GNUC__
2494 # define YYCOPY(To, From, Count) \
2495 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
2497 # define YYCOPY(To, From, Count) \
2501 for (yyi = 0; yyi < (Count); yyi++) \
2502 (To)[yyi] = (From)[yyi]; \
2508 /* Relocate STACK from its old location to the new one. The
2509 local variables YYSIZE and YYSTACKSIZE give the old and new number of
2510 elements in the stack, and YYPTR gives the new location of the
2511 stack. Advance YYPTR to a properly aligned location for the next
2513 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
2516 YYSIZE_T yynewbytes; \
2517 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
2518 Stack = &yyptr->Stack_alloc; \
2519 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
2520 yyptr += yynewbytes / sizeof (*yyptr); \
2526 /* YYFINAL -- State number of the termination state. */
2528 /* YYLAST -- Last index in YYTABLE. */
2531 /* YYNTOKENS -- Number of terminals. */
2532 #define YYNTOKENS 135
2533 /* YYNNTS -- Number of nonterminals. */
2535 /* YYNRULES -- Number of rules. */
2536 #define YYNRULES 356
2537 /* YYNRULES -- Number of states. */
2538 #define YYNSTATES 612
2540 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
2541 #define YYUNDEFTOK 2
2542 #define YYMAXUTOK 364
2544 #define YYTRANSLATE(YYX) \
2545 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
2547 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
2548 static const yytype_uint8 yytranslate[] =
2550 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2551 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2552 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2553 2, 2, 2, 119, 2, 2, 2, 117, 108, 2,
2554 123, 134, 116, 114, 101, 113, 128, 115, 2, 2,
2555 2, 2, 2, 2, 2, 2, 2, 2, 105, 100,
2556 110, 103, 111, 104, 129, 2, 2, 2, 2, 2,
2557 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2558 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2559 2, 125, 2, 126, 107, 2, 2, 2, 2, 2,
2560 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2561 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2562 2, 2, 2, 127, 106, 133, 118, 2, 2, 2,
2563 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2564 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2565 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2566 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2567 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2568 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2569 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2570 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2571 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2572 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2573 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2574 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2575 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
2576 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2577 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2578 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2579 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
2580 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
2581 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2582 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
2583 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
2584 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
2585 95, 96, 97, 98, 99, 102, 109, 112, 120, 121,
2586 122, 124, 130, 131, 132
2590 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
2592 static const yytype_uint16 yyprhs[] =
2594 0, 0, 3, 5, 6, 8, 10, 13, 15, 17,
2595 19, 21, 23, 25, 30, 32, 33, 35, 37, 40,
2596 42, 44, 46, 48, 50, 55, 60, 62, 64, 65,
2597 68, 70, 72, 74, 76, 78, 80, 82, 84, 86,
2598 88, 90, 92, 94, 96, 100, 103, 105, 107, 109,
2599 111, 113, 115, 117, 122, 125, 127, 129, 130, 134,
2600 137, 138, 141, 144, 146, 150, 154, 155, 158, 159,
2601 162, 169, 170, 172, 174, 178, 180, 183, 187, 196,
2602 203, 209, 216, 218, 221, 223, 226, 227, 229, 231,
2603 234, 236, 239, 244, 248, 249, 258, 259, 269, 270,
2604 276, 278, 281, 283, 286, 288, 289, 296, 299, 301,
2605 306, 309, 311, 313, 315, 317, 321, 323, 324, 331,
2606 332, 338, 341, 344, 349, 350, 352, 354, 357, 359,
2607 361, 363, 365, 367, 369, 371, 373, 375, 377, 378,
2608 381, 382, 385, 386, 389, 390, 400, 401, 410, 411,
2609 413, 415, 418, 420, 425, 427, 429, 434, 436, 437,
2610 439, 441, 444, 446, 449, 458, 460, 462, 463, 468,
2611 470, 474, 478, 479, 482, 484, 486, 488, 490, 492,
2612 494, 496, 498, 500, 502, 504, 506, 507, 508, 513,
2613 514, 519, 520, 523, 526, 529, 532, 536, 538, 540,
2614 541, 543, 550, 561, 573, 575, 578, 580, 584, 588,
2615 592, 596, 597, 599, 602, 607, 611, 613, 618, 621,
2616 623, 625, 626, 627, 640, 642, 643, 644, 655, 657,
2617 661, 663, 665, 667, 671, 673, 675, 677, 680, 681,
2618 682, 686, 687, 689, 691, 693, 696, 699, 700, 705,
2619 710, 715, 718, 720, 723, 725, 727, 729, 733, 735,
2620 739, 740, 742, 744, 746, 748, 750, 752, 756, 762,
2621 764, 766, 768, 770, 772, 774, 776, 778, 780, 782,
2622 786, 790, 794, 798, 802, 806, 810, 814, 818, 822,
2623 826, 830, 833, 836, 840, 844, 848, 852, 856, 860,
2624 864, 868, 872, 876, 880, 884, 888, 892, 896, 899,
2625 902, 904, 908, 911, 916, 920, 924, 928, 932, 936,
2626 940, 944, 948, 952, 956, 960, 964, 970, 973, 976,
2627 979, 982, 986, 989, 990, 997, 999, 1001, 1003, 1005,
2628 1011, 1015, 1021, 1027, 1032, 1039, 1044, 1051, 1058, 1065,
2629 1069, 1071, 1074, 1079, 1084, 1087, 1092
2632 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
2633 static const yytype_int16 yyrhs[] =
2635 136, 0, -1, 137, -1, -1, 138, -1, 139, -1,
2636 138, 139, -1, 187, -1, 199, -1, 197, -1, 233,
2637 -1, 208, -1, 148, -1, 150, 127, 137, 133, -1,
2638 100, -1, -1, 141, -1, 142, -1, 141, 142, -1,
2639 199, -1, 197, -1, 233, -1, 208, -1, 148, -1,
2640 150, 127, 140, 133, -1, 125, 149, 260, 126, -1,
2641 100, -1, 144, -1, -1, 144, 146, -1, 146, -1,
2642 268, -1, 190, -1, 162, -1, 163, -1, 164, -1,
2643 165, -1, 172, -1, 158, -1, 184, -1, 180, -1,
2644 256, -1, 269, -1, 267, -1, 127, 144, 133, -1,
2645 127, 133, -1, 100, -1, 145, -1, 152, -1, 166,
2646 -1, 167, -1, 252, -1, 182, -1, 150, 127, 144,
2647 133, -1, 146, 100, -1, 146, -1, 145, -1, -1,
2648 3, 90, 3, -1, 103, 260, -1, -1, 45, 153,
2649 -1, 31, 153, -1, 154, -1, 153, 101, 154, -1,
2650 3, 243, 151, -1, -1, 156, 147, -1, -1, 65,
2651 155, -1, 64, 123, 254, 134, 155, 157, -1, -1,
2652 152, -1, 256, -1, 45, 3, 243, -1, 3, -1,
2653 10, 123, -1, 10, 49, 123, -1, 161, 159, 100,
2654 254, 100, 256, 134, 155, -1, 161, 160, 68, 254,
2655 134, 155, -1, 11, 123, 254, 134, 155, -1, 12,
2656 155, 11, 123, 254, 134, -1, 66, -1, 66, 3,
2657 -1, 29, -1, 29, 3, -1, -1, 169, -1, 171,
2658 -1, 169, 171, -1, 170, -1, 169, 170, -1, 33,
2659 260, 105, 143, -1, 61, 105, 143, -1, -1, 13,
2660 123, 173, 260, 134, 127, 168, 133, -1, -1, 32,
2661 123, 3, 243, 134, 175, 127, 143, 133, -1, -1,
2662 26, 127, 177, 143, 133, -1, 174, -1, 178, 174,
2663 -1, 178, -1, 178, 176, -1, 176, -1, -1, 51,
2664 127, 181, 143, 133, 179, -1, 36, 254, -1, 36,
2665 -1, 38, 123, 254, 134, -1, 183, 147, -1, 3,
2666 -1, 16, -1, 15, -1, 28, -1, 186, 128, 185,
2667 -1, 185, -1, -1, 16, 186, 127, 188, 140, 133,
2668 -1, -1, 16, 127, 189, 140, 133, -1, 40, 3,
2669 -1, 40, 239, -1, 40, 186, 128, 116, -1, -1,
2670 192, -1, 193, -1, 192, 193, -1, 19, -1, 20,
2671 -1, 17, -1, 37, -1, 46, -1, 48, -1, 47,
2672 -1, 24, -1, 22, -1, 3, -1, -1, 53, 240,
2673 -1, -1, 53, 241, -1, -1, 14, 241, -1, -1,
2674 191, 30, 3, 194, 196, 127, 198, 201, 133, -1,
2675 -1, 191, 43, 3, 195, 127, 200, 204, 133, -1,
2676 -1, 202, -1, 203, -1, 202, 203, -1, 100, -1,
2677 150, 127, 201, 133, -1, 208, -1, 233, -1, 125,
2678 149, 260, 126, -1, 145, -1, -1, 205, -1, 206,
2679 -1, 205, 206, -1, 100, -1, 45, 3, -1, 191,
2680 25, 232, 3, 123, 229, 134, 243, -1, 45, -1,
2681 31, -1, -1, 191, 207, 209, 210, -1, 211, -1,
2682 210, 101, 211, -1, 3, 243, 151, -1, -1, 103,
2683 260, -1, 7, -1, 8, -1, 9, -1, 4, -1,
2684 55, -1, 54, -1, 44, -1, 27, -1, 28, -1,
2685 226, -1, 110, -1, 111, -1, -1, -1, 127, 260,
2686 219, 133, -1, -1, 127, 260, 221, 133, -1, -1,
2687 222, 218, -1, 222, 4, -1, 222, 111, -1, 226,
2688 222, -1, 223, 226, 222, -1, 3, -1, 220, -1,
2689 -1, 227, -1, 215, 224, 225, 115, 217, 111, -1,
2690 215, 224, 225, 216, 222, 110, 115, 224, 217, 111,
2691 -1, 215, 224, 225, 216, 222, 223, 110, 115, 224,
2692 217, 111, -1, 228, -1, 227, 228, -1, 220, -1,
2693 220, 103, 4, -1, 220, 103, 220, -1, 3, 103,
2694 220, -1, 3, 103, 4, -1, -1, 230, -1, 94,
2695 231, -1, 230, 101, 94, 231, -1, 230, 101, 231,
2696 -1, 231, -1, 3, 105, 242, 212, -1, 3, 212,
2697 -1, 50, -1, 34, -1, -1, -1, 191, 25, 232,
2698 3, 123, 229, 134, 243, 127, 234, 143, 133, -1,
2699 3, -1, -1, -1, 25, 235, 123, 229, 134, 243,
2700 127, 237, 143, 133, -1, 185, -1, 186, 128, 185,
2701 -1, 239, -1, 238, -1, 240, -1, 241, 101, 240,
2702 -1, 240, -1, 116, -1, 35, -1, 105, 242, -1,
2703 -1, -1, 123, 245, 134, -1, -1, 246, -1, 247,
2704 -1, 253, -1, 246, 101, -1, 247, 253, -1, -1,
2705 23, 260, 248, 244, -1, 260, 123, 245, 134, -1,
2706 52, 123, 245, 134, -1, 63, 260, -1, 41, -1,
2707 41, 254, -1, 260, -1, 255, -1, 260, -1, 255,
2708 101, 260, -1, 260, -1, 256, 101, 260, -1, -1,
2709 259, -1, 3, -1, 4, -1, 7, -1, 8, -1,
2710 9, -1, 258, 105, 253, -1, 259, 101, 258, 105,
2711 253, -1, 236, -1, 264, -1, 249, -1, 251, -1,
2712 250, -1, 265, -1, 213, -1, 214, -1, 5, -1,
2713 18, -1, 125, 245, 126, -1, 70, 257, 133, -1,
2714 260, 110, 260, -1, 260, 111, 260, -1, 260, 75,
2715 260, -1, 260, 76, 260, -1, 260, 71, 260, -1,
2716 260, 72, 260, -1, 260, 74, 260, -1, 260, 73,
2717 260, -1, 260, 88, 260, -1, 260, 89, 260, -1,
2718 119, 260, -1, 118, 260, -1, 260, 108, 260, -1,
2719 260, 107, 260, -1, 260, 106, 260, -1, 260, 97,
2720 260, -1, 260, 96, 260, -1, 260, 95, 260, -1,
2721 260, 115, 260, -1, 260, 117, 260, -1, 260, 114,
2722 260, -1, 260, 113, 260, -1, 260, 116, 260, -1,
2723 260, 68, 260, -1, 260, 69, 260, -1, 260, 39,
2724 260, -1, 260, 67, 260, -1, 42, 260, -1, 35,
2725 260, -1, 35, -1, 123, 255, 134, -1, 113, 260,
2726 -1, 260, 125, 260, 126, -1, 260, 80, 260, -1,
2727 260, 79, 260, -1, 260, 86, 260, -1, 260, 85,
2728 260, -1, 260, 87, 260, -1, 260, 78, 260, -1,
2729 260, 77, 260, -1, 260, 84, 260, -1, 260, 81,
2730 260, -1, 260, 82, 260, -1, 260, 83, 260, -1,
2731 260, 103, 260, -1, 260, 104, 260, 105, 260, -1,
2732 260, 92, -1, 260, 91, -1, 92, 260, -1, 91,
2733 260, -1, 52, 128, 3, -1, 129, 3, -1, -1,
2734 260, 128, 123, 261, 260, 134, -1, 3, -1, 116,
2735 -1, 185, -1, 116, -1, 260, 128, 262, 90, 263,
2736 -1, 260, 93, 263, -1, 260, 93, 262, 90, 263,
2737 -1, 260, 128, 125, 260, 126, -1, 260, 128, 129,
2738 263, -1, 260, 128, 129, 262, 90, 263, -1, 260,
2739 93, 129, 263, -1, 260, 93, 129, 262, 90, 263,
2740 -1, 260, 128, 129, 125, 260, 126, -1, 260, 93,
2741 129, 125, 260, 126, -1, 260, 128, 263, -1, 3,
2742 -1, 15, 3, -1, 15, 3, 103, 3, -1, 15,
2743 3, 103, 4, -1, 191, 266, -1, 62, 15, 103,
2744 260, -1, 21, 15, 240, -1
2747 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
2748 static const yytype_uint16 yyrline[] =
2750 0, 1998, 1998, 2000, 2000, 2001, 2002, 2004, 2005, 2006,
2751 2007, 2008, 2009, 2010, 2011, 2013, 2013, 2014, 2015, 2017,
2752 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2026, 2027, 2029,
2753 2032, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043,
2754 2044, 2045, 2046, 2047, 2048, 2049, 2052, 2053, 2054, 2055,
2755 2056, 2057, 2058, 2059, 2071, 2072, 2076, 2087, 2095, 2122,
2756 2123, 2125, 2126, 2128, 2129, 2131, 2192, 2192, 2196, 2197,
2757 2200, 2216, 2217, 2218, 2223, 2227, 2232, 2233, 2235, 2255,
2758 2299, 2315, 2327, 2330, 2333, 2336, 2340, 2341, 2342, 2343,
2759 2344, 2345, 2347, 2358, 2361, 2361, 2392, 2392, 2417, 2417,
2760 2433, 2434, 2435, 2436, 2444, 2453, 2453, 2502, 2506, 2517,
2761 2527, 2544, 2545, 2546, 2547, 2549, 2550, 2552, 2552, 2554,
2762 2554, 2578, 2586, 2600, 2616, 2617, 2618, 2619, 2626, 2627,
2763 2628, 2629, 2630, 2631, 2632, 2633, 2634, 2635, 2639, 2640,
2764 2642, 2643, 2645, 2646, 2650, 2648, 2656, 2654, 2663, 2664,
2765 2665, 2666, 2667, 2668, 2669, 2670, 2671, 2673, 2679, 2680,
2766 2681, 2682, 2683, 2684, 2687, 2760, 2760, 2762, 2762, 2764,
2767 2765, 2767, 2851, 2852, 2860, 2861, 2864, 2865, 2866, 2867,
2768 2868, 2869, 2870, 2878, 2889, 2890, 2891, 2893, 2893, 2896,
2769 2896, 2899, 2900, 2903, 2908, 2911, 2914, 2917, 2920, 2924,
2770 2927, 2931, 2935, 2940, 2946, 2949, 2952, 2955, 2960, 2963,
2771 2966, 2976, 2980, 2986, 2992, 3000, 3005, 3011, 3019, 3027,
2772 3028, 3029, 3032, 3031, 3048, 3049, 3051, 3050, 3074, 3094,
2773 3109, 3110, 3112, 3113, 3115, 3116, 3117, 3126, 3127, 3131,
2774 3132, 3134, 3135, 3136, 3138, 3142, 3143, 3148, 3149, 3196,
2775 3246, 3267, 3289, 3292, 3299, 3302, 3305, 3308, 3311, 3314,
2776 3319, 3320, 3322, 3323, 3324, 3325, 3326, 3328, 3334, 3343,
2777 3344, 3345, 3346, 3347, 3348, 3350, 3354, 3359, 3377, 3388,
2778 3398, 3407, 3408, 3409, 3410, 3411, 3412, 3413, 3414, 3415,
2779 3416, 3417, 3418, 3419, 3420, 3421, 3422, 3423, 3424, 3425,
2780 3426, 3427, 3428, 3429, 3430, 3431, 3432, 3433, 3434, 3435,
2781 3436, 3437, 3438, 3439, 3440, 3441, 3442, 3443, 3444, 3445,
2782 3446, 3447, 3448, 3449, 3450, 3451, 3452, 3454, 3455, 3456,
2783 3457, 3459, 3474, 3482, 3482, 3536, 3537, 3538, 3539, 3579,
2784 3582, 3589, 3592, 3603, 3611, 3615, 3622, 3626, 3636, 3647,
2785 3844, 3878, 3885, 3892, 3899, 3921, 3928
2789 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
2790 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2791 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
2792 static const char *const yytname[] =
2794 "$end", "error", "$undefined", "T_IDENTIFIER", "T_STRING", "T_REGEXP",
2795 "T_EMPTY", "T_INT", "T_UINT", "T_FLOAT", "\"for\"", "\"while\"",
2796 "\"do\"", "\"switch\"", "\"implements\"", "\"namespace\"", "\"package\"",
2797 "\"protected\"", "\"arguments\"", "\"public\"", "\"private\"", "\"use\"",
2798 "\"internal\"", "\"new\"", "\"native\"", "\"function\"", "\"finally\"",
2799 "\"undefined\"", "\"NaN\"", "\"continue\"", "\"class\"", "\"const\"",
2800 "\"catch\"", "\"case\"", "\"set\"", "\"void\"", "\"throw\"",
2801 "\"static\"", "\"with\"", "\"instanceof\"", "\"import\"", "\"return\"",
2802 "\"typeof\"", "\"interface\"", "\"null\"", "\"var\"", "\"dynamic\"",
2803 "\"override\"", "\"final\"", "\"each\"", "\"get\"", "\"try\"",
2804 "\"super\"", "\"extends\"", "\"false\"", "\"true\"", "\"Boolean\"",
2805 "\"uint\"", "\"int\"", "\"Number\"", "\"String\"", "\"default\"",
2806 "\"default xml\"", "\"delete\"", "\"if\"", "\"else\"", "\"break\"",
2807 "\"is\"", "\"in\"", "\"as\"", "\"{ (dictionary)\"", "\"==\"", "\"===\"",
2808 "\"!=\"", "\"!==\"", "\"<=\"", "\">=\"", "\"|=\"", "\"/=\"", "\"%=\"",
2809 "\"*=\"", "\"&=\"", "\"+=\"", "\"-=\"", "\"^=\"", "\">>=\"", "\"<<=\"",
2810 "\">>>=\"", "\"||\"", "\"&&\"", "\"::\"", "\"--\"", "\"++\"", "\"..\"",
2811 "\"...\"", "\"<<\"", "\">>>\"", "\">>\"", "prec_none", "below_semicolon",
2812 "';'", "','", "below_assignment", "'='", "'?'", "':'", "'|'", "'^'",
2813 "'&'", "below_lt", "'<'", "'>'", "below_minus", "'-'", "'+'", "'/'",
2814 "'*'", "'%'", "'~'", "'!'", "minusminus_prefix", "plusplus_prefix",
2815 "below_curly", "'('", "new2", "'['", "']'", "'{'", "'.'", "'@'",
2816 "above_identifier", "below_else", "above_function", "'}'", "')'",
2817 "$accept", "PROGRAM", "MAYBE_PROGRAM_CODE_LIST", "PROGRAM_CODE_LIST",
2818 "PROGRAM_CODE", "MAYBE_INPACKAGE_CODE_LIST", "INPACKAGE_CODE_LIST",
2819 "INPACKAGE_CODE", "MAYBECODE", "CODE", "CODE_STATEMENT", "CODEPIECE",
2820 "CODEBLOCK", "PACKAGE_INITCODE", "EMBED_START",
2821 "CONDITIONAL_COMPILATION", "MAYBEEXPRESSION", "VARIABLE_DECLARATION",
2822 "VARIABLE_LIST", "ONE_VARIABLE", "IF_CODEBLOCK", "$@1", "MAYBEELSE",
2823 "IF", "FOR_INIT", "FOR_IN_INIT", "FOR_START", "FOR", "FOR_IN", "WHILE",
2824 "DO_WHILE", "BREAK", "CONTINUE", "MAYBE_CASE_LIST", "CASE_LIST", "CASE",
2825 "DEFAULT", "SWITCH", "$@2", "CATCH", "$@3", "FINALLY", "$@4",
2826 "CATCH_LIST", "CATCH_FINALLY_LIST", "TRY", "$@5", "THROW", "WITH_HEAD",
2827 "WITH", "X_IDENTIFIER", "PACKAGE", "PACKAGE_DECLARATION", "$@6", "$@7",
2828 "IMPORT", "MAYBE_MODIFIERS", "MODIFIER_LIST", "MODIFIER", "EXTENDS",
2829 "EXTENDS_LIST", "IMPLEMENTS_LIST", "CLASS_DECLARATION", "$@8",
2830 "INTERFACE_DECLARATION", "$@9", "MAYBE_CLASS_BODY", "CLASS_BODY",
2831 "CLASS_BODY_ITEM", "MAYBE_INTERFACE_BODY", "INTERFACE_BODY",
2832 "IDECLARATION", "VARCONST", "SLOT_DECLARATION", "$@10", "SLOT_LIST",
2833 "ONE_SLOT", "MAYBECONSTANT", "CONSTANT", "XML", "OPEN", "CLOSE",
2834 "CLOSE2", "XMLEXPR1", "$@11", "XMLEXPR2", "$@12", "XMLTEXT", "XML2",
2835 "XML_ID_OR_EXPR", "MAYBE_XMLATTRIBUTES", "XMLNODE", "XMLATTRIBUTES",
2836 "XMLATTRIBUTE", "MAYBE_PARAM_LIST", "PARAM_LIST", "PARAM", "GETSET",
2837 "FUNCTION_DECLARATION", "$@13", "MAYBE_IDENTIFIER", "INNERFUNCTION",
2838 "$@14", "CLASS", "PACKAGEANDCLASS", "CLASS_SPEC", "CLASS_SPEC_LIST",
2839 "TYPE", "MAYBETYPE", "MAYBE_PARAM_VALUES", "MAYBE_EXPRESSION_LIST",
2840 "EXPRESSION_LIST", "EXPRESSION_LIST_AND_COMMA", "XX", "NEW",
2841 "FUNCTIONCALL", "DELETE", "RETURN", "NONCOMMAEXPRESSION", "EXPRESSION",
2842 "COMMA_EXPRESSION", "VOIDEXPRESSION", "MAYBE_DICT_EXPRPAIR_LIST",
2843 "DICTLH", "DICT_EXPRPAIR_LIST", "E", "$@15", "ID_OR_NS", "SUBNODE",
2844 "MEMBER", "VAR_READ", "NAMESPACE_ID", "NAMESPACE_DECLARATION",
2845 "DEFAULT_NAMESPACE", "USE_NAMESPACE", 0
2850 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
2852 static const yytype_uint16 yytoknum[] =
2854 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
2855 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
2856 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
2857 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
2858 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
2859 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
2860 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
2861 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
2862 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
2863 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
2864 59, 44, 355, 61, 63, 58, 124, 94, 38, 356,
2865 60, 62, 357, 45, 43, 47, 42, 37, 126, 33,
2866 358, 359, 360, 40, 361, 91, 93, 123, 46, 64,
2867 362, 363, 364, 125, 41
2871 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
2872 static const yytype_uint16 yyr1[] =
2874 0, 135, 136, 137, 137, 138, 138, 139, 139, 139,
2875 139, 139, 139, 139, 139, 140, 140, 141, 141, 142,
2876 142, 142, 142, 142, 142, 142, 142, 143, 143, 144,
2877 144, 145, 145, 145, 145, 145, 145, 145, 145, 145,
2878 145, 145, 145, 145, 145, 145, 146, 146, 146, 146,
2879 146, 146, 146, 146, 147, 147, 148, 149, 150, 151,
2880 151, 152, 152, 153, 153, 154, 156, 155, 157, 157,
2881 158, 159, 159, 159, 160, 160, 161, 161, 162, 163,
2882 164, 165, 166, 166, 167, 167, 168, 168, 168, 168,
2883 169, 169, 170, 171, 173, 172, 175, 174, 177, 176,
2884 178, 178, 179, 179, 179, 181, 180, 182, 182, 183,
2885 184, 185, 185, 185, 185, 186, 186, 188, 187, 189,
2886 187, 190, 190, 190, 191, 191, 192, 192, 193, 193,
2887 193, 193, 193, 193, 193, 193, 193, 193, 194, 194,
2888 195, 195, 196, 196, 198, 197, 200, 199, 201, 201,
2889 202, 202, 203, 203, 203, 203, 203, 203, 204, 204,
2890 205, 205, 206, 206, 206, 207, 207, 209, 208, 210,
2891 210, 211, 212, 212, 213, 213, 213, 213, 213, 213,
2892 213, 213, 213, 214, 215, 216, 217, 219, 218, 221,
2893 220, 222, 222, 222, 222, 223, 223, 224, 224, 225,
2894 225, 226, 226, 226, 227, 227, 228, 228, 228, 228,
2895 228, 229, 229, 229, 229, 230, 230, 231, 231, 232,
2896 232, 232, 234, 233, 235, 235, 237, 236, 238, 239,
2897 240, 240, 241, 241, 242, 242, 242, 243, 243, 244,
2898 244, 245, 245, 245, 246, 247, 246, 248, 249, 250,
2899 250, 251, 252, 252, 253, 254, 255, 255, 256, 256,
2900 257, 257, 258, 258, 258, 258, 258, 259, 259, 260,
2901 260, 260, 260, 260, 260, 260, 260, 260, 260, 260,
2902 260, 260, 260, 260, 260, 260, 260, 260, 260, 260,
2903 260, 260, 260, 260, 260, 260, 260, 260, 260, 260,
2904 260, 260, 260, 260, 260, 260, 260, 260, 260, 260,
2905 260, 260, 260, 260, 260, 260, 260, 260, 260, 260,
2906 260, 260, 260, 260, 260, 260, 260, 260, 260, 260,
2907 260, 260, 260, 261, 260, 262, 262, 263, 263, 260,
2908 260, 260, 260, 260, 260, 260, 260, 260, 260, 264,
2909 265, 266, 266, 266, 267, 268, 269
2912 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
2913 static const yytype_uint8 yyr2[] =
2915 0, 2, 1, 0, 1, 1, 2, 1, 1, 1,
2916 1, 1, 1, 4, 1, 0, 1, 1, 2, 1,
2917 1, 1, 1, 1, 4, 4, 1, 1, 0, 2,
2918 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2919 1, 1, 1, 1, 3, 2, 1, 1, 1, 1,
2920 1, 1, 1, 4, 2, 1, 1, 0, 3, 2,
2921 0, 2, 2, 1, 3, 3, 0, 2, 0, 2,
2922 6, 0, 1, 1, 3, 1, 2, 3, 8, 6,
2923 5, 6, 1, 2, 1, 2, 0, 1, 1, 2,
2924 1, 2, 4, 3, 0, 8, 0, 9, 0, 5,
2925 1, 2, 1, 2, 1, 0, 6, 2, 1, 4,
2926 2, 1, 1, 1, 1, 3, 1, 0, 6, 0,
2927 5, 2, 2, 4, 0, 1, 1, 2, 1, 1,
2928 1, 1, 1, 1, 1, 1, 1, 1, 0, 2,
2929 0, 2, 0, 2, 0, 9, 0, 8, 0, 1,
2930 1, 2, 1, 4, 1, 1, 4, 1, 0, 1,
2931 1, 2, 1, 2, 8, 1, 1, 0, 4, 1,
2932 3, 3, 0, 2, 1, 1, 1, 1, 1, 1,
2933 1, 1, 1, 1, 1, 1, 0, 0, 4, 0,
2934 4, 0, 2, 2, 2, 2, 3, 1, 1, 0,
2935 1, 6, 10, 11, 1, 2, 1, 3, 3, 3,
2936 3, 0, 1, 2, 4, 3, 1, 4, 2, 1,
2937 1, 0, 0, 12, 1, 0, 0, 10, 1, 3,
2938 1, 1, 1, 3, 1, 1, 1, 2, 0, 0,
2939 3, 0, 1, 1, 1, 2, 2, 0, 4, 4,
2940 4, 2, 1, 2, 1, 1, 1, 3, 1, 3,
2941 0, 1, 1, 1, 1, 1, 1, 3, 5, 1,
2942 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
2943 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
2944 3, 2, 2, 3, 3, 3, 3, 3, 3, 3,
2945 3, 3, 3, 3, 3, 3, 3, 3, 2, 2,
2946 1, 3, 2, 4, 3, 3, 3, 3, 3, 3,
2947 3, 3, 3, 3, 3, 3, 5, 2, 2, 2,
2948 2, 3, 2, 0, 6, 1, 1, 1, 1, 5,
2949 3, 5, 5, 4, 6, 4, 6, 6, 6, 3,
2953 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
2954 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
2955 means the default is an error. */
2956 static const yytype_uint16 yydefact[] =
2958 124, 350, 177, 277, 174, 175, 176, 0, 0, 66,
2959 0, 0, 130, 278, 128, 129, 0, 136, 0, 135,
2960 225, 181, 182, 310, 131, 0, 0, 0, 180, 132,
2961 134, 133, 0, 0, 179, 178, 0, 0, 0, 260,
2962 0, 0, 14, 184, 0, 0, 0, 0, 241, 124,
2963 0, 0, 2, 124, 5, 56, 12, 0, 38, 71,
2964 33, 34, 35, 36, 37, 40, 124, 39, 7, 32,
2965 0, 125, 126, 9, 8, 11, 275, 276, 0, 183,
2966 10, 269, 271, 273, 272, 41, 258, 270, 274, 43,
2967 31, 42, 0, 0, 76, 0, 0, 124, 94, 111,
2968 113, 112, 114, 119, 116, 0, 0, 350, 247, 224,
2969 0, 309, 0, 121, 0, 122, 308, 105, 241, 0,
2970 0, 251, 0, 262, 263, 264, 265, 266, 0, 0,
2971 261, 330, 329, 312, 292, 291, 0, 256, 0, 242,
2972 243, 244, 254, 84, 0, 108, 252, 0, 82, 46,
2973 45, 124, 47, 30, 0, 48, 49, 50, 52, 0,
2974 51, 332, 1, 6, 124, 350, 0, 72, 0, 0,
2975 73, 55, 110, 0, 221, 0, 166, 0, 165, 167,
2976 354, 137, 127, 197, 0, 198, 199, 0, 0, 0,
2977 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2978 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2979 0, 328, 327, 0, 0, 0, 0, 0, 0, 0,
2980 0, 0, 0, 0, 0, 0, 0, 0, 0, 241,
2981 0, 0, 58, 77, 0, 255, 0, 67, 0, 124,
2982 117, 0, 228, 0, 231, 230, 356, 239, 211, 0,
2983 0, 28, 0, 331, 0, 0, 280, 0, 0, 0,
2984 311, 279, 245, 246, 85, 238, 62, 63, 107, 253,
2985 61, 83, 44, 29, 124, 0, 238, 0, 0, 54,
2986 351, 220, 219, 0, 138, 140, 0, 189, 0, 206,
2987 0, 200, 204, 259, 306, 307, 304, 305, 285, 286,
2988 288, 287, 283, 284, 320, 319, 315, 314, 322, 323,
2989 324, 321, 317, 316, 318, 289, 290, 111, 338, 0,
2990 337, 0, 340, 298, 297, 296, 325, 0, 295, 294,
2991 293, 281, 282, 302, 301, 299, 303, 300, 0, 0,
2992 333, 0, 0, 0, 349, 66, 0, 0, 26, 57,
2993 0, 124, 17, 23, 0, 20, 19, 22, 21, 124,
2994 115, 0, 241, 248, 172, 0, 0, 212, 216, 109,
2995 123, 229, 0, 27, 250, 355, 66, 267, 0, 257,
2996 0, 60, 0, 124, 13, 60, 0, 0, 0, 0,
2997 0, 142, 0, 0, 238, 168, 169, 0, 0, 0,
2998 185, 186, 191, 205, 0, 0, 345, 0, 0, 249,
2999 313, 0, 0, 0, 0, 343, 0, 80, 0, 0,
3000 0, 120, 18, 124, 0, 0, 0, 0, 218, 213,
3001 238, 0, 0, 68, 0, 236, 235, 234, 237, 0,
3002 65, 64, 53, 0, 66, 352, 353, 211, 139, 0,
3003 0, 232, 141, 146, 60, 0, 190, 210, 209, 207,
3004 208, 0, 0, 0, 0, 338, 341, 326, 0, 342,
3005 0, 0, 339, 81, 86, 0, 0, 118, 240, 173,
3006 172, 0, 0, 215, 0, 0, 100, 104, 102, 106,
3007 66, 70, 268, 59, 0, 79, 0, 143, 144, 0,
3008 124, 171, 170, 201, 193, 184, 194, 0, 192, 0,
3009 191, 348, 346, 334, 347, 344, 0, 0, 0, 87,
3010 90, 88, 25, 24, 217, 226, 214, 98, 0, 101,
3011 103, 69, 66, 238, 124, 233, 0, 162, 0, 0,
3012 124, 160, 0, 187, 184, 191, 195, 0, 28, 95,
3013 91, 89, 28, 28, 238, 78, 0, 152, 57, 157,
3014 0, 0, 0, 124, 150, 154, 155, 163, 221, 147,
3015 161, 186, 0, 0, 196, 28, 93, 0, 0, 0,
3016 222, 0, 124, 145, 151, 0, 0, 188, 186, 92,
3017 227, 99, 96, 28, 0, 0, 0, 202, 0, 0,
3018 0, 156, 153, 211, 203, 28, 223, 0, 0, 238,
3022 /* YYDEFGOTO[NTERM-NUM]. */
3023 static const yytype_int16 yydefgoto[] =
3025 -1, 51, 52, 53, 54, 350, 351, 352, 372, 373,
3026 152, 153, 172, 353, 420, 154, 440, 155, 270, 267,
3027 96, 97, 491, 58, 168, 169, 59, 60, 61, 62,
3028 63, 156, 157, 518, 519, 520, 521, 64, 238, 486,
3029 599, 487, 553, 488, 489, 65, 251, 158, 66, 67,
3030 320, 243, 68, 359, 239, 69, 159, 71, 72, 391,
3031 393, 450, 355, 534, 356, 500, 562, 563, 564, 539,
3032 540, 541, 179, 357, 286, 395, 396, 428, 76, 77,
3033 78, 402, 461, 508, 572, 185, 397, 462, 509, 186,
3034 290, 79, 291, 292, 366, 367, 368, 283, 358, 593,
3035 110, 81, 552, 244, 245, 437, 452, 438, 381, 363,
3036 138, 139, 140, 247, 82, 83, 84, 160, 141, 234,
3037 235, 85, 128, 129, 130, 86, 411, 321, 322, 87,
3041 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
3043 #define YYPACT_NINF -508
3044 static const yytype_int16 yypact[] =
3046 1734, 1659, -508, -508, -508, -508, -508, -3, -45, -508,
3047 -10, 93, -508, -508, -508, -508, 51, -508, 2068, -508,
3048 84, -508, -508, 2125, -508, -5, 73, 2068, -508, -508,
3049 -508, -508, 8, -49, -508, -508, 121, 2068, 22, 381,
3050 2068, 2068, -508, -508, 2068, 2068, 2068, 2068, 2068, 714,
3051 144, 155, -508, 587, -508, -508, -508, 32, -508, 429,
3052 -508, -508, -508, -508, -508, -508, 1988, -508, -508, -508,
3053 126, 469, -508, -508, -508, -508, -508, -508, 15, -508,
3054 -508, -508, -508, -508, -508, 131, 2882, -508, -508, -508,
3055 -508, -508, 219, 111, -508, 2068, 224, 1988, -508, -508,
3056 -508, -508, -508, -508, -508, -23, 279, -508, -55, -508,
3057 115, -43, 2068, 116, 118, -508, -43, -508, 2068, 240,
3058 145, -43, 2068, -508, -508, -508, -508, -508, 125, 154,
3059 148, -43, -43, 386, -43, -43, -39, 2820, 135, 163,
3060 2068, -508, 2820, 264, 265, 2068, 2068, 265, 274, -508,
3061 -508, 841, -508, -508, 161, -508, -508, -508, -508, 275,
3062 -508, -508, -508, -508, 1095, 225, 297, -508, 201, 235,
3063 131, 205, -508, 305, 90, 307, -508, 308, -508, -508,
3064 -508, -508, -508, -508, 2068, -508, 16, 2068, 2068, 2068,
3065 2068, 2068, 2068, 2068, 2068, 2068, 2068, 2068, 2068, 2068,
3066 2068, 2068, 2068, 2068, 2068, 2068, 2068, 2068, 2068, 2068,
3067 2068, -508, -508, 44, 2068, 2068, 2068, 2068, 2068, 2068,
3068 2068, 2068, 2068, 2068, 2068, 2068, 2068, 2068, 2068, 2068,
3069 2068, 146, -508, -508, 179, 217, 198, -508, 2068, 1222,
3070 -508, 279, 194, 199, -508, -508, -508, 207, 23, 197,
3071 342, 1861, 202, -508, 2068, 204, -508, 2068, 381, 2068,
3072 -508, -508, -508, -508, -508, 223, 234, -508, -508, -508,
3073 234, -508, -508, -508, 1988, 211, 223, 2068, 2068, -508,
3074 236, -508, -508, 343, 296, 301, 353, 2820, 259, 260,
3075 -4, 16, -508, 2820, 1087, 579, 579, 579, 3254, 3254,
3076 3254, 3254, 1087, 1087, 2820, 2820, 2820, 2820, 2820, 2820,
3077 2820, 2820, 2820, 2820, 2820, 2944, 3006, 282, 285, 257,
3078 -508, 286, -508, 679, 679, 679, 2820, 2324, 3068, 3130,
3079 3192, 1087, 1087, 386, 386, -43, -43, -43, 230, 2386,
3080 -508, 2068, 281, 289, -508, -508, 2068, 2184, -508, 243,
3081 238, 1349, -508, -508, 254, -508, -508, -508, -508, 1222,
3082 -508, 279, 2068, -508, 47, 380, 252, 293, -508, -508,
3083 -508, 272, 269, 1861, -508, 2820, -508, -508, 299, 2820,
3084 271, 304, 265, 968, -508, -26, 309, 276, 122, 288,
3085 279, 398, 279, 290, 223, 312, -508, 283, 12, 17,
3086 -508, -508, -508, -508, 2068, 325, -508, 352, 2068, -508,
3087 -508, 2068, 2448, 2068, 328, -508, 352, -508, 287, 292,
3088 2068, -508, -508, 1222, 298, 310, 2068, 271, -508, -508,
3089 223, 38, 67, 355, 2068, -508, -508, -508, -508, 2068,
3090 -508, -508, -508, 2068, -508, -508, -508, 23, -508, 279,
3091 302, -508, 329, -508, 304, 353, -508, -508, -508, -508,
3092 -508, 315, 19, 2510, 352, -508, -508, 2820, 2254, -508,
3093 2572, 352, -508, -508, 42, 2634, 306, -508, -508, 2820,
3094 332, 314, 380, -508, 316, 319, -508, -508, 67, -508,
3095 -508, -508, -508, 2820, -36, -508, 311, 329, -508, 279,
3096 233, -508, -508, -508, -508, 331, -508, 2068, -508, 338,
3097 -508, -508, -508, -508, -508, -508, 2068, 344, 317, 42,
3098 -508, -508, -508, -508, -508, -508, -508, -508, 448, -508,
3099 -508, -508, -508, 223, 1476, -508, 450, -508, 430, 326,
3100 295, -508, 15, 2820, 346, -508, 26, 2696, 1861, -508,
3101 -508, -508, 1861, 1861, 223, -508, 336, -508, 243, -508,
3102 339, 206, 334, 1603, -508, -508, -508, -508, 90, -508,
3103 -508, -508, 337, 15, 26, 1861, -508, 347, 349, 335,
3104 -508, 2068, 1476, -508, -508, 462, 364, -508, -508, -508,
3105 -508, -508, -508, 1861, 2758, 354, 362, -508, 365, 363,
3106 361, -508, -508, 23, -508, 1861, -508, 371, 374, 223,
3110 /* YYPGOTO[NTERM-NUM]. */
3111 static const yytype_int16 yypgoto[] =
3113 -508, -508, 333, -508, 443, -339, -508, 147, -228, -41,
3114 1, -57, 411, 37, -48, 2, 59, 459, 375, 140,
3115 -332, -508, -508, -508, -508, -508, -508, -508, -508, -508,
3116 -508, -508, -508, -508, -508, 5, 6, -508, -508, 35,
3117 -508, 39, -508, -508, -508, -508, -508, -508, -508, -508,
3118 13, 41, -508, -508, -508, -508, 0, -508, 455, -508,
3119 -508, -508, 61, -508, 63, -508, -53, -508, -35, -508,
3120 -508, -9, -508, 3, -508, -508, 75, 52, -508, -508,
3121 -508, -508, -507, -508, -508, -169, -508, -459, -508, -471,
3122 -508, -440, -508, 242, -433, -508, -334, -27, 4, -508,
3123 -508, -508, -508, -508, 517, -101, 95, 123, -231, -508,
3124 -106, -508, -508, -508, -508, -508, -508, -508, -130, -54,
3125 498, -52, -508, 291, -508, -12, -508, -204, -188, -508,
3126 -508, -508, -508, -508, -508
3129 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
3130 positive, shift that token. If negative, reduce the rule which
3131 number is the opposite. If zero, do what YYDEFACT says.
3132 If YYTABLE_NINF, syntax error. */
3133 #define YYTABLE_NINF -337
3134 static const yytype_int16 yytable[] =
3136 70, 55, 57, 75, 80, 246, 108, 170, 151, 171,
3137 263, 111, 252, 417, 496, 116, 457, 289, 183, 288,
3138 424, 459, 510, 504, 104, 121, 364, 343, 131, 132,
3139 504, 429, 133, 134, 135, 137, 142, 56, 213, 104,
3140 171, 364, -74, 344, 433, 385, 93, 317, 211, 212,
3141 213, 546, 105, 70, 55, 57, 75, 80, 249, 100,
3142 101, 73, 259, 74, 586, 187, 106, 114, 255, 545,
3143 230, 571, 102, 231, 118, 516, 113, 439, 95, 119,
3144 229, 598, 230, 137, 476, 231, 574, 109, 100, 101,
3145 56, 268, 269, 484, 273, 260, 99, 483, 532, 485,
3146 137, 102, 588, 517, 240, 241, 142, 400, 100, 101,
3147 137, 401, 495, 98, 73, 405, 74, 365, 112, 242,
3148 94, 102, 289, 338, 281, 445, 446, 377, 142, 505,
3149 506, 406, 482, 137, 137, 117, 120, 506, 414, 184,
3150 282, 173, 184, 184, 184, 122, 507, 161, 526, 317,
3151 426, 174, 427, 507, 415, 162, 175, 176, 531, 164,
3152 318, 100, 101, 454, 70, 55, 57, 75, 80, 177,
3153 607, 178, 287, 319, 102, 293, 294, 295, 296, 297,
3154 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
3155 308, 309, 310, 311, 312, 313, 314, 315, 316, 481,
3156 555, 56, 323, 324, 325, 326, 327, 328, 329, 330,
3157 331, 332, 333, 334, 335, 336, 337, 142, 339, 466,
3158 103, 173, 232, 386, 387, 73, 347, 74, 472, 458,
3159 460, 174, 187, 383, 233, 236, 181, 176, 248, 70,
3160 55, 354, 375, 253, -111, 142, 250, 379, 254, 258,
3161 12, 178, 14, 15, 360, 17, 425, 19, 256, 257,
3162 317, 261, 318, 371, 262, 137, 137, 264, 265, 340,
3163 24, 341, 100, 101, 99, 342, 512, 271, 536, 29,
3164 30, 31, 99, 515, 317, 102, 100, 101, 274, 448,
3165 173, 451, 418, -75, 100, 101, 100, 101, 181, 102,
3166 276, 277, 556, 278, 492, 279, 435, 102, 280, 102,
3167 284, 285, 12, 345, 14, 15, 273, 17, 259, 19,
3168 576, 346, -116, 579, 577, 578, 273, 361, 380, 412,
3169 362, 369, 24, 537, 137, 382, 374, 142, 376, 388,
3170 536, 29, 30, 31, 384, 99, 389, 589, 451, 390,
3171 142, 70, 55, 354, 392, 99, 394, 100, 101, 70,
3172 55, 354, 398, 399, 409, 600, -158, 100, 101, -241,
3173 102, 421, -335, 318, 371, -336, 407, 608, 611, 416,
3174 102, 423, 404, 364, 123, 124, 430, 436, 125, 126,
3175 127, 494, 463, 242, 431, 537, 467, 318, 535, 468,
3176 -115, 470, 432, 242, 434, 242, 413, 439, 475, 443,
3177 444, 447, 449, 455, 479, 464, 456, 453, 471, 474,
3178 490, 473, 142, 70, 55, 354, 503, 493, -159, 498,
3179 499, 477, 165, 2, 3, 426, 4, 5, 6, 523,
3180 242, 525, 528, 527, 478, 533, 542, 13, 544, 548,
3181 549, 554, 18, 567, 20, 568, 21, 22, 370, 569,
3182 144, 573, 242, 580, 23, 596, 582, 583, 465, 592,
3183 587, 27, 181, 28, 166, 597, 604, 211, 212, 213,
3184 590, 33, 591, 34, 35, 603, 12, 602, 14, 15,
3185 605, 17, 37, 19, 606, 543, 163, 275, 422, 39,
3186 538, 226, 227, 228, 547, 609, 24, 610, 237, 229,
3187 581, 230, 242, 501, 231, 29, 30, 31, 167, 266,
3188 40, 41, 441, 529, 550, 551, 182, 530, 584, 595,
3189 502, 570, 524, 403, 561, 559, 560, 565, 566, 43,
3190 538, 585, 44, 115, 497, 136, 142, 45, 46, 378,
3191 480, 0, 47, 0, 48, 0, 0, 0, 50, 0,
3192 0, 0, 0, 561, 559, 560, 565, 566, 0, 594,
3193 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3194 0, 0, 561, 559, 560, 565, 566, -4, 0, 0,
3195 1, 2, 3, 0, 4, 5, 6, 7, 8, 9,
3196 10, 0, 0, 11, 12, 13, 14, 15, 16, 17,
3197 18, 19, 0, 0, 21, 22, 0, 0, 188, 0,
3198 0, 0, 23, 0, 24, 25, 0, 26, 0, 27,
3199 0, 28, 0, 29, 30, 31, 0, 0, 32, 33,
3200 0, 34, 35, 0, 0, 0, -337, -337, -337, 36,
3201 37, 38, 0, 0, 196, 197, 0, 39, 0, 0,
3202 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3203 211, 212, 213, 0, 214, 215, 216, 0, 40, 41,
3204 0, 0, 0, 0, 0, 0, 0, 42, 0, 222,
3205 223, 0, 224, 225, 226, 227, 228, 43, 0, 0,
3206 44, 0, 229, 0, 230, 45, 46, 231, 0, 0,
3207 47, 0, 48, 0, 49, 0, 50, 1, 2, 3,
3208 -4, 4, 5, 6, 7, 8, 9, 10, 0, 0,
3209 0, 12, 13, 14, 15, 16, 17, 18, 19, 20,
3210 0, 21, 22, 143, 0, 144, 0, 0, 0, 23,
3211 145, 24, 25, 0, 26, 146, 27, 0, 28, 147,
3212 29, 30, 31, 0, 0, 32, 33, 0, 34, 35,
3213 211, 212, 213, 0, 0, 0, 36, 37, 38, 0,
3214 148, 0, 0, 0, 39, 0, 0, 0, 0, 0,
3215 0, 0, 224, 225, 226, 227, 228, 0, 0, 0,
3216 0, 0, 229, 0, 230, 40, 41, 231, 0, 0,
3217 0, 0, 0, 0, 149, 0, 0, 0, 0, 0,
3218 0, 0, 0, 0, 43, 0, 0, 44, 0, 0,
3219 0, 0, 45, 46, 0, 0, 0, 47, 0, 48,
3220 0, 49, 0, 50, 1, 2, 3, 150, 4, 5,
3221 6, 7, 8, 9, 10, 0, 0, 0, 12, 13,
3222 14, 15, 16, 17, 18, 19, 20, 0, 21, 22,
3223 143, 0, 144, 0, 0, 0, 23, 145, 24, 25,
3224 0, 26, 146, 27, 0, 28, 147, 29, 30, 31,
3225 0, 0, 32, 33, 0, 34, 35, 0, 0, 0,
3226 0, 0, 0, 36, 37, 38, 0, 148, 0, 0,
3227 0, 39, 0, 0, 0, 0, 0, 0, 0, 0,
3228 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3229 0, 0, 40, 41, 0, 0, 0, 0, 0, 0,
3230 0, 149, 0, 0, 0, 0, 0, 0, 0, 0,
3231 0, 43, 0, 0, 44, 0, 0, 0, 0, 45,
3232 46, 0, 0, 0, 47, 0, 48, 0, 49, 0,
3233 50, 1, 2, 3, 272, 4, 5, 6, 7, 8,
3234 9, 10, 0, 0, 0, 12, 13, 14, 15, 16,
3235 17, 18, 19, 20, 0, 21, 22, 143, 0, 144,
3236 0, 0, 0, 23, 145, 24, 25, 0, 26, 146,
3237 27, 0, 28, 147, 29, 30, 31, 0, 0, 32,
3238 33, 0, 34, 35, 0, 0, 0, 0, 0, 0,
3239 36, 37, 38, 0, 148, 0, 0, 0, 39, 0,
3240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3241 0, 0, 0, 0, 0, 0, 0, 0, 0, 40,
3242 41, 0, 0, 0, 0, 0, 0, 0, 149, 0,
3243 0, 0, 0, 0, 0, 0, 0, 0, 43, 0,
3244 0, 44, 0, 0, 0, 0, 45, 46, 0, 0,
3245 0, 47, 0, 48, 0, 49, 0, 50, 1, 2,
3246 3, 442, 4, 5, 6, 7, 8, 9, 10, 0,
3247 0, 11, 12, 13, 14, 15, 16, 17, 18, 19,
3248 0, 0, 21, 22, 0, 0, -337, 0, 0, 0,
3249 23, 0, 24, 25, 0, 26, 0, 27, 0, 28,
3250 0, 29, 30, 31, 0, 0, 32, 33, 0, 34,
3251 35, 0, 0, 0, 0, 0, 0, 36, 37, 38,
3252 0, 0, -337, -337, 0, 39, 0, 0, 0, 0,
3253 0, 0, 0, 0, 0, 0, 0, 0, 211, 212,
3254 213, 0, 214, 215, 216, 0, 40, 41, 0, 0,
3255 0, 0, 0, 0, 0, 42, 0, -337, -337, 0,
3256 224, 225, 226, 227, 228, 43, 0, 0, 44, 0,
3257 229, 0, 230, 45, 46, 231, 0, 0, 47, 0,
3258 48, 0, 49, 0, 50, 1, 2, 3, -3, 4,
3259 5, 6, 7, 8, 9, 10, 0, 0, 0, 12,
3260 13, 14, 15, 16, 17, 18, 19, 0, 0, 21,
3261 22, 0, 0, 0, 0, 0, 0, 23, 0, 24,
3262 25, 0, 26, 0, 27, 0, 28, 0, 29, 30,
3263 31, 0, 0, 32, 33, 0, 34, 35, 0, 0,
3264 0, 0, 0, 0, 36, 37, 38, 0, 0, 0,
3265 0, 0, 39, 0, 0, 0, 0, 0, 0, 0,
3266 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3267 0, 0, 0, 40, 41, 0, 0, 0, 0, 0,
3268 0, 0, 348, 0, 0, 0, 0, 0, 0, 0,
3269 0, 0, 43, 0, 0, 44, 0, 0, 0, 0,
3270 45, 46, 0, 0, 0, 47, 0, 349, 0, 49,
3271 0, 50, 1, 2, 3, -15, 4, 5, 6, 7,
3272 8, 9, 10, 0, 0, 0, 12, 13, 14, 15,
3273 16, 17, 18, 19, 0, 0, 21, 22, 0, 0,
3274 0, 0, 0, 0, 23, 0, 24, 25, 0, 26,
3275 0, 27, 0, 28, 0, 29, 30, 31, 0, 0,
3276 32, 33, 0, 34, 35, 0, 0, 0, 0, 0,
3277 0, 36, 37, 38, 0, 0, 0, 0, 0, 39,
3278 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3279 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3280 40, 41, 0, 0, 0, 0, 0, 0, 0, 348,
3281 0, 0, 0, 0, 0, 0, 0, 0, 0, 43,
3282 0, 0, 44, 0, 0, 0, 0, 45, 46, 0,
3283 0, 0, 47, 0, 349, 0, 49, 0, 50, 1,
3284 2, 3, -16, 4, 5, 6, 7, 8, 9, 10,
3285 0, 0, 0, 12, 13, 14, 15, 16, 17, 18,
3286 19, 0, 0, 21, 22, 0, 0, 0, 0, 0,
3287 0, 23, 0, 24, 25, 0, 26, 0, 27, 0,
3288 28, 0, 29, 30, 31, 0, 0, 32, 33, 0,
3289 34, 35, 0, 0, 0, 0, 0, 0, 36, 37,
3290 38, 0, 0, 0, 0, 0, 39, 0, 0, 0,
3291 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3292 0, 0, 0, 0, 0, 0, 0, 40, 41, 0,
3293 0, 0, 0, 0, 0, 0, 557, 0, 0, 0,
3294 0, 0, 0, 0, 0, 0, 43, 0, 0, 44,
3295 0, 0, 0, 0, 45, 46, 0, 0, 0, 47,
3296 0, 558, 0, 49, 0, 50, 1, 2, 3, -148,
3297 4, 5, 6, 7, 8, 9, 10, 0, 0, 0,
3298 12, 13, 14, 15, 16, 17, 18, 19, 0, 0,
3299 21, 22, 0, 0, 0, 0, 0, 0, 23, 0,
3300 24, 25, 0, 26, 0, 27, 0, 28, 0, 29,
3301 30, 31, 0, 0, 32, 33, 0, 34, 35, 0,
3302 0, 0, -137, 0, 0, 36, 37, 38, 0, 0,
3303 0, 0, 0, 39, -137, 0, -137, 0, -137, -137,
3304 0, -137, 0, -137, -137, 0, 0, 0, 0, -137,
3305 -137, 0, 0, 0, 40, 41, -137, 0, 0, 0,
3306 0, 0, -137, 557, -137, -137, -137, -137, 0, 0,
3307 0, 0, 0, 43, 0, 0, 44, 0, 0, 0,
3308 0, 45, 46, 0, 0, 0, 47, 0, 558, 0,
3309 49, 0, 50, 0, -3, 0, -149, 1, 2, 3,
3310 0, 4, 5, 6, 7, 8, 9, 10, 0, 92,
3311 11, 12, 13, 14, 15, 16, 17, 18, 19, 0,
3312 0, 21, 22, 0, 0, 0, 0, 0, 0, 23,
3313 0, 24, 25, 0, 26, 0, 27, 0, 28, 0,
3314 29, 30, 31, 0, 0, 32, 33, 0, 34, 35,
3315 0, 0, 0, 0, 0, 0, 36, 37, 38, 0,
3316 0, 0, 0, 0, 39, 0, 0, 0, 0, 0,
3317 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3318 0, 0, 0, 0, 0, 40, 41, 0, 0, 0,
3319 0, 0, 0, 0, 42, 0, 0, 0, 0, 0,
3320 0, 0, 0, 0, 43, 0, 0, 44, 0, 0,
3321 0, 0, 45, 46, 0, 0, 0, 47, 0, 48,
3322 0, 49, 0, 50, 1, 2, 3, 0, 4, 5,
3323 6, 7, 8, 9, 10, 0, -124, 0, 12, 13,
3324 14, 15, 16, 17, 18, 19, 20, 0, 21, 22,
3325 143, 0, 144, 0, 0, 0, 23, 145, 24, 25,
3326 0, 26, 146, 27, 0, 28, 147, 29, 30, 31,
3327 0, 0, 32, 33, 0, 34, 35, 0, 0, 0,
3328 0, 0, 0, 36, 37, 38, 0, 148, 0, 0,
3329 0, 39, 0, 0, 0, 0, 0, 0, 0, 0,
3330 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3331 0, 0, 40, 41, 0, 0, 0, 0, 0, 0,
3332 0, 149, 0, 0, 0, 0, 0, 0, 0, 0,
3333 0, 43, 0, 0, 44, 0, 0, 0, 0, 45,
3334 46, 0, 0, 0, 47, 0, 48, 0, 49, 0,
3335 50, 1, 2, 3, 0, 4, 5, 6, 7, 8,
3336 9, 10, 0, 0, 0, 12, 13, 14, 15, 16,
3337 17, 18, 19, 20, 0, 21, 22, 143, 0, 144,
3338 0, 0, 0, 23, 145, 24, 25, 0, 26, 146,
3339 27, 0, 28, 147, 29, 30, 31, 0, 0, 32,
3340 33, 0, 34, 35, 0, 0, 0, 0, 0, 0,
3341 36, 37, 38, 0, 148, 0, 0, 0, 39, 0,
3342 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3343 0, 107, 2, 3, 0, 4, 5, 6, 0, 40,
3344 41, 0, 0, 0, 0, 0, 13, 0, 149, 0,
3345 0, 18, 0, 20, 0, 21, 22, 0, 43, 0,
3346 0, 44, 0, 23, 0, 0, 45, 46, 0, 0,
3347 27, 47, 28, 48, 0, 49, 0, 50, 0, 0,
3348 33, 0, 34, 35, 0, 0, 0, 0, 107, 2,
3349 3, 37, 4, 5, 6, 0, 0, 0, 39, 0,
3350 0, 0, 0, 13, 0, 0, 0, 0, 18, 0,
3351 20, 0, 21, 22, 0, 0, 0, 0, 0, 40,
3352 41, 0, 0, 0, 0, 0, 0, 0, 0, 28,
3353 0, 0, 0, 0, 0, 0, 0, 33, 43, 34,
3354 35, 44, 0, 0, 0, 0, 45, 46, 0, 0,
3355 0, 47, 0, 48, 0, 39, 0, 50, 0, 0,
3356 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3357 0, 0, 0, 0, 0, 0, 40, 41, 0, 0,
3358 0, 0, 0, 188, 0, 0, 0, 0, 0, 0,
3359 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3360 0, 0, 0, 0, 0, 0, 0, 0, 47, 0,
3361 48, 189, 190, 191, 50, 192, 193, 194, 195, 196,
3362 197, 198, 199, 200, 201, 202, 203, 204, 205, 206,
3363 207, 208, 209, 210, 0, 211, 212, 213, 0, 214,
3364 215, 216, 0, 0, 0, 0, 0, 217, 218, 0,
3365 219, 220, 221, 188, 222, 223, 0, 224, 225, 226,
3366 227, 228, 0, 0, 0, 0, 0, 229, 0, 230,
3367 0, 0, 231, 0, 0, 0, 0, 0, 419, 0,
3368 0, 189, 190, 191, 0, 192, 193, 194, 195, 196,
3369 197, 198, 199, 200, 201, 202, 203, 204, 205, 206,
3370 207, 208, 209, 210, 0, 211, 212, 213, 0, 214,
3371 215, 216, 0, 0, 0, 0, 0, 217, 218, 0,
3372 219, 220, 221, 188, 222, 223, 0, 224, 225, 226,
3373 227, 228, 0, 0, 0, 0, 0, 229, 0, 230,
3374 0, 0, 231, 0, 0, 0, 0, 0, 513, 0,
3375 0, 189, 190, 191, 0, 192, 193, 194, 195, 196,
3376 197, 198, 199, 200, 201, 202, 203, 204, 205, 206,
3377 207, 208, 209, 210, 0, 211, 212, 213, 0, 214,
3378 215, 216, 0, 0, 0, 188, 0, 217, 218, 408,
3379 219, 220, 221, 0, 222, 223, 0, 224, 225, 226,
3380 227, 228, 0, 0, 0, 0, 0, 229, 0, 230,
3381 0, 0, 231, 189, 190, 191, 0, 192, 193, 194,
3382 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
3383 205, 206, 207, 208, 209, 210, 0, 211, 212, 213,
3384 0, 214, 215, 216, 0, 0, 0, 188, 0, 217,
3385 218, 0, 219, 220, 221, 0, 222, 223, 0, 224,
3386 225, 226, 227, 228, 0, 0, 0, 0, 0, 229,
3387 0, 230, 410, 0, 231, 189, 190, 191, 0, 192,
3388 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
3389 203, 204, 205, 206, 207, 208, 209, 210, 0, 211,
3390 212, 213, 0, 214, 215, 216, 0, 0, 0, 188,
3391 0, 217, 218, 0, 219, 220, 221, 0, 222, 223,
3392 0, 224, 225, 226, 227, 228, 0, 0, 0, 0,
3393 0, 229, 0, 230, 469, 0, 231, 189, 190, 191,
3394 0, 192, 193, 194, 195, 196, 197, 198, 199, 200,
3395 201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
3396 0, 211, 212, 213, 0, 214, 215, 216, 0, 0,
3397 0, 188, 0, 217, 218, 0, 219, 220, 221, 0,
3398 222, 223, 0, 224, 225, 226, 227, 228, 0, 0,
3399 0, 0, 0, 229, 0, 230, 511, 0, 231, 189,
3400 190, 191, 0, 192, 193, 194, 195, 196, 197, 198,
3401 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
3402 209, 210, 0, 211, 212, 213, 0, 214, 215, 216,
3403 0, 0, 0, 188, 0, 217, 218, 0, 219, 220,
3404 221, 0, 222, 223, 0, 224, 225, 226, 227, 228,
3405 0, 0, 0, 0, 0, 229, 0, 230, 514, 0,
3406 231, 189, 190, 191, 0, 192, 193, 194, 195, 196,
3407 197, 198, 199, 200, 201, 202, 203, 204, 205, 206,
3408 207, 208, 209, 210, 0, 211, 212, 213, 0, 214,
3409 215, 216, 0, 0, 0, 188, 0, 217, 218, 0,
3410 219, 220, 221, 0, 222, 223, 0, 224, 225, 226,
3411 227, 228, 0, 0, 0, 0, 0, 229, 0, 230,
3412 522, 0, 231, 189, 190, 191, 0, 192, 193, 194,
3413 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
3414 205, 206, 207, 208, 209, 210, 0, 211, 212, 213,
3415 0, 214, 215, 216, 0, 0, 0, 188, 0, 217,
3416 218, 575, 219, 220, 221, 0, 222, 223, 0, 224,
3417 225, 226, 227, 228, 0, 0, 0, 0, 0, 229,
3418 0, 230, 0, 0, 231, 189, 190, 191, 0, 192,
3419 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
3420 203, 204, 205, 206, 207, 208, 209, 210, 0, 211,
3421 212, 213, 0, 214, 215, 216, 0, 0, 0, 188,
3422 0, 217, 218, 0, 219, 220, 221, 0, 222, 223,
3423 0, 224, 225, 226, 227, 228, 0, 0, 0, 0,
3424 0, 229, 0, 230, 601, 0, 231, 189, 190, 191,
3425 0, 192, 193, 194, 195, 196, 197, 198, 199, 200,
3426 201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
3427 0, 211, 212, 213, 0, 214, 215, 216, 0, 0,
3428 0, 188, 0, 217, 218, 0, 219, 220, 221, 0,
3429 222, 223, 0, 224, 225, 226, 227, 228, 0, 0,
3430 0, 0, 0, 229, 0, 230, 0, 0, 231, 189,
3431 190, 191, 0, 192, 193, 194, 195, 196, 197, 198,
3432 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
3433 209, 210, 0, 211, 212, 213, 0, 214, 215, 216,
3434 0, 0, 0, 188, 0, 217, 218, 0, 219, 220,
3435 221, 0, 0, 223, 0, 224, 225, 226, 227, 228,
3436 0, 0, 0, 0, 0, 229, 0, 230, 0, 0,
3437 231, 189, 190, 191, 0, 192, 193, 194, 195, 196,
3438 197, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3439 0, 0, 0, 210, 0, 211, 212, 213, 0, 214,
3440 215, 216, 0, 0, 0, 188, 0, 0, 0, 0,
3441 219, 220, 221, 0, 222, 223, 0, 224, 225, 226,
3442 227, 228, 0, 0, 0, 0, 0, 229, 0, 230,
3443 0, 0, 231, 189, 190, 191, 0, 192, 193, 194,
3444 195, 196, 197, 0, 0, 0, 0, 0, 0, 0,
3445 0, 0, 0, 0, 0, 0, 0, 211, 212, 213,
3446 0, 214, 215, 216, 0, 0, 0, 188, 0, 0,
3447 0, 0, 219, 220, 221, 0, 222, 223, 0, 224,
3448 225, 226, 227, 228, 0, 0, 0, 0, 0, 229,
3449 0, 230, 0, 0, 231, 189, 190, 191, 0, 192,
3450 193, 194, 195, 196, 197, 0, 0, 0, 0, 0,
3451 0, 0, 0, 0, 0, 0, 0, 0, 0, 211,
3452 212, 213, 0, 214, 215, 216, 0, 0, 0, 188,
3453 0, 0, 0, 0, 0, 220, 221, 0, 222, 223,
3454 0, 224, 225, 226, 227, 228, 0, 0, 0, 0,
3455 0, 229, 0, 230, 0, 0, 231, 189, 190, 191,
3456 0, 192, 193, 194, 195, 196, 197, 0, 0, 0,
3457 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3458 0, 211, 212, 213, 0, 214, 215, 216, 0, 0,
3459 0, 188, 0, 0, 0, 0, 0, 0, 221, 0,
3460 222, 223, 0, 224, 225, 226, 227, 228, 0, 0,
3461 0, 0, 0, 229, 0, 230, 0, 0, 231, 189,
3462 190, 191, 0, 192, 193, 194, 195, 196, 197, 0,
3463 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3464 0, 0, 0, 211, 212, 213, 0, 214, 215, 216,
3465 0, 0, 0, 188, 0, 0, 0, 0, 0, 0,
3466 -337, 0, 222, 223, 0, 224, 225, 226, 227, 228,
3467 0, 0, 0, 0, 0, 229, 0, 230, 0, 0,
3468 231, 189, 190, 191, 0, -337, -337, -337, -337, 196,
3469 197, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3470 0, 0, 0, 0, 0, 211, 212, 213, 0, 214,
3471 215, 216, 0, 0, 0, 0, 0, 0, 0, 0,
3472 0, 0, 0, 0, 222, 223, 0, 224, 225, 226,
3473 227, 228, 0, 0, 0, 0, 0, 229, 0, 230,
3477 static const yytype_int16 yycheck[] =
3479 0, 0, 0, 0, 0, 106, 18, 59, 49, 66,
3480 140, 23, 118, 345, 447, 27, 4, 186, 3, 3,
3481 359, 4, 462, 4, 11, 37, 3, 231, 40, 41,
3482 4, 365, 44, 45, 46, 47, 48, 0, 93, 26,
3483 97, 3, 68, 231, 376, 276, 49, 3, 91, 92,
3484 93, 510, 11, 53, 53, 53, 53, 53, 112, 15,
3485 16, 0, 101, 0, 571, 101, 15, 26, 122, 509,
3486 125, 542, 28, 128, 123, 33, 3, 103, 123, 128,
3487 123, 588, 125, 95, 423, 128, 545, 3, 15, 16,
3488 53, 145, 146, 26, 151, 134, 3, 431, 134, 32,
3489 112, 28, 573, 61, 127, 128, 118, 111, 15, 16,
3490 122, 115, 444, 123, 53, 319, 53, 94, 123, 106,
3491 123, 28, 291, 229, 34, 3, 4, 257, 140, 110,
3492 111, 319, 94, 145, 146, 127, 15, 111, 342, 127,
3493 50, 15, 127, 127, 127, 123, 127, 3, 482, 3,
3494 103, 25, 105, 127, 342, 0, 30, 31, 490, 127,
3495 116, 15, 16, 394, 164, 164, 164, 164, 164, 43,
3496 603, 45, 184, 129, 28, 187, 188, 189, 190, 191,
3497 192, 193, 194, 195, 196, 197, 198, 199, 200, 201,
3498 202, 203, 204, 205, 206, 207, 208, 209, 210, 430,
3499 532, 164, 214, 215, 216, 217, 218, 219, 220, 221,
3500 222, 223, 224, 225, 226, 227, 228, 229, 230, 407,
3501 127, 15, 3, 277, 278, 164, 238, 164, 416, 398,
3502 399, 25, 101, 274, 123, 11, 3, 31, 123, 239,
3503 239, 239, 254, 3, 128, 257, 128, 259, 103, 101,
3504 17, 45, 19, 20, 241, 22, 362, 24, 133, 105,
3505 3, 126, 116, 250, 101, 277, 278, 3, 3, 123,
3506 37, 125, 15, 16, 3, 129, 464, 3, 45, 46,
3507 47, 48, 3, 471, 3, 28, 15, 16, 127, 390,
3508 15, 392, 346, 68, 15, 16, 15, 16, 3, 28,
3509 3, 100, 533, 68, 434, 100, 35, 28, 3, 28,
3510 3, 3, 17, 134, 19, 20, 373, 22, 101, 24,
3511 548, 123, 128, 554, 552, 553, 383, 128, 105, 341,
3512 123, 134, 37, 100, 346, 101, 134, 349, 134, 103,
3513 45, 46, 47, 48, 133, 3, 3, 575, 449, 53,
3514 362, 351, 351, 351, 53, 3, 3, 15, 16, 359,
3515 359, 359, 103, 103, 134, 593, 133, 15, 16, 126,
3516 28, 133, 90, 116, 361, 90, 90, 605, 609, 90,
3517 28, 127, 125, 3, 3, 4, 134, 116, 7, 8,
3518 9, 443, 404, 380, 101, 100, 408, 116, 499, 411,
3519 128, 413, 133, 390, 105, 392, 125, 103, 420, 100,
3520 134, 123, 14, 101, 426, 90, 133, 127, 90, 127,
3521 65, 134, 434, 423, 423, 423, 111, 439, 133, 127,
3522 101, 133, 3, 4, 5, 103, 7, 8, 9, 133,
3523 427, 127, 123, 127, 134, 134, 115, 18, 110, 105,
3524 133, 3, 23, 3, 25, 25, 27, 28, 116, 133,
3525 31, 115, 449, 127, 35, 3, 127, 133, 116, 134,
3526 133, 42, 3, 44, 45, 111, 111, 91, 92, 93,
3527 133, 52, 133, 54, 55, 123, 17, 133, 19, 20,
3528 127, 22, 63, 24, 133, 507, 53, 164, 351, 70,
3529 500, 115, 116, 117, 516, 134, 37, 133, 97, 123,
3530 558, 125, 499, 454, 128, 46, 47, 48, 59, 144,
3531 91, 92, 382, 488, 519, 519, 71, 488, 563, 582,
3532 455, 540, 480, 291, 534, 534, 534, 534, 534, 110,
3533 540, 568, 113, 26, 449, 47, 558, 118, 119, 258,
3534 427, -1, 123, -1, 125, -1, -1, -1, 129, -1,
3535 -1, -1, -1, 563, 563, 563, 563, 563, -1, 581,
3536 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3537 -1, -1, 582, 582, 582, 582, 582, 0, -1, -1,
3538 3, 4, 5, -1, 7, 8, 9, 10, 11, 12,
3539 13, -1, -1, 16, 17, 18, 19, 20, 21, 22,
3540 23, 24, -1, -1, 27, 28, -1, -1, 39, -1,
3541 -1, -1, 35, -1, 37, 38, -1, 40, -1, 42,
3542 -1, 44, -1, 46, 47, 48, -1, -1, 51, 52,
3543 -1, 54, 55, -1, -1, -1, 67, 68, 69, 62,
3544 63, 64, -1, -1, 75, 76, -1, 70, -1, -1,
3545 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3546 91, 92, 93, -1, 95, 96, 97, -1, 91, 92,
3547 -1, -1, -1, -1, -1, -1, -1, 100, -1, 110,
3548 111, -1, 113, 114, 115, 116, 117, 110, -1, -1,
3549 113, -1, 123, -1, 125, 118, 119, 128, -1, -1,
3550 123, -1, 125, -1, 127, -1, 129, 3, 4, 5,
3551 133, 7, 8, 9, 10, 11, 12, 13, -1, -1,
3552 -1, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3553 -1, 27, 28, 29, -1, 31, -1, -1, -1, 35,
3554 36, 37, 38, -1, 40, 41, 42, -1, 44, 45,
3555 46, 47, 48, -1, -1, 51, 52, -1, 54, 55,
3556 91, 92, 93, -1, -1, -1, 62, 63, 64, -1,
3557 66, -1, -1, -1, 70, -1, -1, -1, -1, -1,
3558 -1, -1, 113, 114, 115, 116, 117, -1, -1, -1,
3559 -1, -1, 123, -1, 125, 91, 92, 128, -1, -1,
3560 -1, -1, -1, -1, 100, -1, -1, -1, -1, -1,
3561 -1, -1, -1, -1, 110, -1, -1, 113, -1, -1,
3562 -1, -1, 118, 119, -1, -1, -1, 123, -1, 125,
3563 -1, 127, -1, 129, 3, 4, 5, 133, 7, 8,
3564 9, 10, 11, 12, 13, -1, -1, -1, 17, 18,
3565 19, 20, 21, 22, 23, 24, 25, -1, 27, 28,
3566 29, -1, 31, -1, -1, -1, 35, 36, 37, 38,
3567 -1, 40, 41, 42, -1, 44, 45, 46, 47, 48,
3568 -1, -1, 51, 52, -1, 54, 55, -1, -1, -1,
3569 -1, -1, -1, 62, 63, 64, -1, 66, -1, -1,
3570 -1, 70, -1, -1, -1, -1, -1, -1, -1, -1,
3571 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3572 -1, -1, 91, 92, -1, -1, -1, -1, -1, -1,
3573 -1, 100, -1, -1, -1, -1, -1, -1, -1, -1,
3574 -1, 110, -1, -1, 113, -1, -1, -1, -1, 118,
3575 119, -1, -1, -1, 123, -1, 125, -1, 127, -1,
3576 129, 3, 4, 5, 133, 7, 8, 9, 10, 11,
3577 12, 13, -1, -1, -1, 17, 18, 19, 20, 21,
3578 22, 23, 24, 25, -1, 27, 28, 29, -1, 31,
3579 -1, -1, -1, 35, 36, 37, 38, -1, 40, 41,
3580 42, -1, 44, 45, 46, 47, 48, -1, -1, 51,
3581 52, -1, 54, 55, -1, -1, -1, -1, -1, -1,
3582 62, 63, 64, -1, 66, -1, -1, -1, 70, -1,
3583 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3584 -1, -1, -1, -1, -1, -1, -1, -1, -1, 91,
3585 92, -1, -1, -1, -1, -1, -1, -1, 100, -1,
3586 -1, -1, -1, -1, -1, -1, -1, -1, 110, -1,
3587 -1, 113, -1, -1, -1, -1, 118, 119, -1, -1,
3588 -1, 123, -1, 125, -1, 127, -1, 129, 3, 4,
3589 5, 133, 7, 8, 9, 10, 11, 12, 13, -1,
3590 -1, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3591 -1, -1, 27, 28, -1, -1, 39, -1, -1, -1,
3592 35, -1, 37, 38, -1, 40, -1, 42, -1, 44,
3593 -1, 46, 47, 48, -1, -1, 51, 52, -1, 54,
3594 55, -1, -1, -1, -1, -1, -1, 62, 63, 64,
3595 -1, -1, 75, 76, -1, 70, -1, -1, -1, -1,
3596 -1, -1, -1, -1, -1, -1, -1, -1, 91, 92,
3597 93, -1, 95, 96, 97, -1, 91, 92, -1, -1,
3598 -1, -1, -1, -1, -1, 100, -1, 110, 111, -1,
3599 113, 114, 115, 116, 117, 110, -1, -1, 113, -1,
3600 123, -1, 125, 118, 119, 128, -1, -1, 123, -1,
3601 125, -1, 127, -1, 129, 3, 4, 5, 133, 7,
3602 8, 9, 10, 11, 12, 13, -1, -1, -1, 17,
3603 18, 19, 20, 21, 22, 23, 24, -1, -1, 27,
3604 28, -1, -1, -1, -1, -1, -1, 35, -1, 37,
3605 38, -1, 40, -1, 42, -1, 44, -1, 46, 47,
3606 48, -1, -1, 51, 52, -1, 54, 55, -1, -1,
3607 -1, -1, -1, -1, 62, 63, 64, -1, -1, -1,
3608 -1, -1, 70, -1, -1, -1, -1, -1, -1, -1,
3609 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3610 -1, -1, -1, 91, 92, -1, -1, -1, -1, -1,
3611 -1, -1, 100, -1, -1, -1, -1, -1, -1, -1,
3612 -1, -1, 110, -1, -1, 113, -1, -1, -1, -1,
3613 118, 119, -1, -1, -1, 123, -1, 125, -1, 127,
3614 -1, 129, 3, 4, 5, 133, 7, 8, 9, 10,
3615 11, 12, 13, -1, -1, -1, 17, 18, 19, 20,
3616 21, 22, 23, 24, -1, -1, 27, 28, -1, -1,
3617 -1, -1, -1, -1, 35, -1, 37, 38, -1, 40,
3618 -1, 42, -1, 44, -1, 46, 47, 48, -1, -1,
3619 51, 52, -1, 54, 55, -1, -1, -1, -1, -1,
3620 -1, 62, 63, 64, -1, -1, -1, -1, -1, 70,
3621 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3622 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3623 91, 92, -1, -1, -1, -1, -1, -1, -1, 100,
3624 -1, -1, -1, -1, -1, -1, -1, -1, -1, 110,
3625 -1, -1, 113, -1, -1, -1, -1, 118, 119, -1,
3626 -1, -1, 123, -1, 125, -1, 127, -1, 129, 3,
3627 4, 5, 133, 7, 8, 9, 10, 11, 12, 13,
3628 -1, -1, -1, 17, 18, 19, 20, 21, 22, 23,
3629 24, -1, -1, 27, 28, -1, -1, -1, -1, -1,
3630 -1, 35, -1, 37, 38, -1, 40, -1, 42, -1,
3631 44, -1, 46, 47, 48, -1, -1, 51, 52, -1,
3632 54, 55, -1, -1, -1, -1, -1, -1, 62, 63,
3633 64, -1, -1, -1, -1, -1, 70, -1, -1, -1,
3634 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3635 -1, -1, -1, -1, -1, -1, -1, 91, 92, -1,
3636 -1, -1, -1, -1, -1, -1, 100, -1, -1, -1,
3637 -1, -1, -1, -1, -1, -1, 110, -1, -1, 113,
3638 -1, -1, -1, -1, 118, 119, -1, -1, -1, 123,
3639 -1, 125, -1, 127, -1, 129, 3, 4, 5, 133,
3640 7, 8, 9, 10, 11, 12, 13, -1, -1, -1,
3641 17, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3642 27, 28, -1, -1, -1, -1, -1, -1, 35, -1,
3643 37, 38, -1, 40, -1, 42, -1, 44, -1, 46,
3644 47, 48, -1, -1, 51, 52, -1, 54, 55, -1,
3645 -1, -1, 3, -1, -1, 62, 63, 64, -1, -1,
3646 -1, -1, -1, 70, 15, -1, 17, -1, 19, 20,
3647 -1, 22, -1, 24, 25, -1, -1, -1, -1, 30,
3648 31, -1, -1, -1, 91, 92, 37, -1, -1, -1,
3649 -1, -1, 43, 100, 45, 46, 47, 48, -1, -1,
3650 -1, -1, -1, 110, -1, -1, 113, -1, -1, -1,
3651 -1, 118, 119, -1, -1, -1, 123, -1, 125, -1,
3652 127, -1, 129, -1, 0, -1, 133, 3, 4, 5,
3653 -1, 7, 8, 9, 10, 11, 12, 13, -1, 90,
3654 16, 17, 18, 19, 20, 21, 22, 23, 24, -1,
3655 -1, 27, 28, -1, -1, -1, -1, -1, -1, 35,
3656 -1, 37, 38, -1, 40, -1, 42, -1, 44, -1,
3657 46, 47, 48, -1, -1, 51, 52, -1, 54, 55,
3658 -1, -1, -1, -1, -1, -1, 62, 63, 64, -1,
3659 -1, -1, -1, -1, 70, -1, -1, -1, -1, -1,
3660 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3661 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
3662 -1, -1, -1, -1, 100, -1, -1, -1, -1, -1,
3663 -1, -1, -1, -1, 110, -1, -1, 113, -1, -1,
3664 -1, -1, 118, 119, -1, -1, -1, 123, -1, 125,
3665 -1, 127, -1, 129, 3, 4, 5, -1, 7, 8,
3666 9, 10, 11, 12, 13, -1, 15, -1, 17, 18,
3667 19, 20, 21, 22, 23, 24, 25, -1, 27, 28,
3668 29, -1, 31, -1, -1, -1, 35, 36, 37, 38,
3669 -1, 40, 41, 42, -1, 44, 45, 46, 47, 48,
3670 -1, -1, 51, 52, -1, 54, 55, -1, -1, -1,
3671 -1, -1, -1, 62, 63, 64, -1, 66, -1, -1,
3672 -1, 70, -1, -1, -1, -1, -1, -1, -1, -1,
3673 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3674 -1, -1, 91, 92, -1, -1, -1, -1, -1, -1,
3675 -1, 100, -1, -1, -1, -1, -1, -1, -1, -1,
3676 -1, 110, -1, -1, 113, -1, -1, -1, -1, 118,
3677 119, -1, -1, -1, 123, -1, 125, -1, 127, -1,
3678 129, 3, 4, 5, -1, 7, 8, 9, 10, 11,
3679 12, 13, -1, -1, -1, 17, 18, 19, 20, 21,
3680 22, 23, 24, 25, -1, 27, 28, 29, -1, 31,
3681 -1, -1, -1, 35, 36, 37, 38, -1, 40, 41,
3682 42, -1, 44, 45, 46, 47, 48, -1, -1, 51,
3683 52, -1, 54, 55, -1, -1, -1, -1, -1, -1,
3684 62, 63, 64, -1, 66, -1, -1, -1, 70, -1,
3685 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3686 -1, 3, 4, 5, -1, 7, 8, 9, -1, 91,
3687 92, -1, -1, -1, -1, -1, 18, -1, 100, -1,
3688 -1, 23, -1, 25, -1, 27, 28, -1, 110, -1,
3689 -1, 113, -1, 35, -1, -1, 118, 119, -1, -1,
3690 42, 123, 44, 125, -1, 127, -1, 129, -1, -1,
3691 52, -1, 54, 55, -1, -1, -1, -1, 3, 4,
3692 5, 63, 7, 8, 9, -1, -1, -1, 70, -1,
3693 -1, -1, -1, 18, -1, -1, -1, -1, 23, -1,
3694 25, -1, 27, 28, -1, -1, -1, -1, -1, 91,
3695 92, -1, -1, -1, -1, -1, -1, -1, -1, 44,
3696 -1, -1, -1, -1, -1, -1, -1, 52, 110, 54,
3697 55, 113, -1, -1, -1, -1, 118, 119, -1, -1,
3698 -1, 123, -1, 125, -1, 70, -1, 129, -1, -1,
3699 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3700 -1, -1, -1, -1, -1, -1, 91, 92, -1, -1,
3701 -1, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3702 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3703 -1, -1, -1, -1, -1, -1, -1, -1, 123, -1,
3704 125, 67, 68, 69, 129, 71, 72, 73, 74, 75,
3705 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
3706 86, 87, 88, 89, -1, 91, 92, 93, -1, 95,
3707 96, 97, -1, -1, -1, -1, -1, 103, 104, -1,
3708 106, 107, 108, 39, 110, 111, -1, 113, 114, 115,
3709 116, 117, -1, -1, -1, -1, -1, 123, -1, 125,
3710 -1, -1, 128, -1, -1, -1, -1, -1, 134, -1,
3711 -1, 67, 68, 69, -1, 71, 72, 73, 74, 75,
3712 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
3713 86, 87, 88, 89, -1, 91, 92, 93, -1, 95,
3714 96, 97, -1, -1, -1, -1, -1, 103, 104, -1,
3715 106, 107, 108, 39, 110, 111, -1, 113, 114, 115,
3716 116, 117, -1, -1, -1, -1, -1, 123, -1, 125,
3717 -1, -1, 128, -1, -1, -1, -1, -1, 134, -1,
3718 -1, 67, 68, 69, -1, 71, 72, 73, 74, 75,
3719 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
3720 86, 87, 88, 89, -1, 91, 92, 93, -1, 95,
3721 96, 97, -1, -1, -1, 39, -1, 103, 104, 105,
3722 106, 107, 108, -1, 110, 111, -1, 113, 114, 115,
3723 116, 117, -1, -1, -1, -1, -1, 123, -1, 125,
3724 -1, -1, 128, 67, 68, 69, -1, 71, 72, 73,
3725 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
3726 84, 85, 86, 87, 88, 89, -1, 91, 92, 93,
3727 -1, 95, 96, 97, -1, -1, -1, 39, -1, 103,
3728 104, -1, 106, 107, 108, -1, 110, 111, -1, 113,
3729 114, 115, 116, 117, -1, -1, -1, -1, -1, 123,
3730 -1, 125, 126, -1, 128, 67, 68, 69, -1, 71,
3731 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
3732 82, 83, 84, 85, 86, 87, 88, 89, -1, 91,
3733 92, 93, -1, 95, 96, 97, -1, -1, -1, 39,
3734 -1, 103, 104, -1, 106, 107, 108, -1, 110, 111,
3735 -1, 113, 114, 115, 116, 117, -1, -1, -1, -1,
3736 -1, 123, -1, 125, 126, -1, 128, 67, 68, 69,
3737 -1, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3738 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
3739 -1, 91, 92, 93, -1, 95, 96, 97, -1, -1,
3740 -1, 39, -1, 103, 104, -1, 106, 107, 108, -1,
3741 110, 111, -1, 113, 114, 115, 116, 117, -1, -1,
3742 -1, -1, -1, 123, -1, 125, 126, -1, 128, 67,
3743 68, 69, -1, 71, 72, 73, 74, 75, 76, 77,
3744 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
3745 88, 89, -1, 91, 92, 93, -1, 95, 96, 97,
3746 -1, -1, -1, 39, -1, 103, 104, -1, 106, 107,
3747 108, -1, 110, 111, -1, 113, 114, 115, 116, 117,
3748 -1, -1, -1, -1, -1, 123, -1, 125, 126, -1,
3749 128, 67, 68, 69, -1, 71, 72, 73, 74, 75,
3750 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
3751 86, 87, 88, 89, -1, 91, 92, 93, -1, 95,
3752 96, 97, -1, -1, -1, 39, -1, 103, 104, -1,
3753 106, 107, 108, -1, 110, 111, -1, 113, 114, 115,
3754 116, 117, -1, -1, -1, -1, -1, 123, -1, 125,
3755 126, -1, 128, 67, 68, 69, -1, 71, 72, 73,
3756 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
3757 84, 85, 86, 87, 88, 89, -1, 91, 92, 93,
3758 -1, 95, 96, 97, -1, -1, -1, 39, -1, 103,
3759 104, 105, 106, 107, 108, -1, 110, 111, -1, 113,
3760 114, 115, 116, 117, -1, -1, -1, -1, -1, 123,
3761 -1, 125, -1, -1, 128, 67, 68, 69, -1, 71,
3762 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
3763 82, 83, 84, 85, 86, 87, 88, 89, -1, 91,
3764 92, 93, -1, 95, 96, 97, -1, -1, -1, 39,
3765 -1, 103, 104, -1, 106, 107, 108, -1, 110, 111,
3766 -1, 113, 114, 115, 116, 117, -1, -1, -1, -1,
3767 -1, 123, -1, 125, 126, -1, 128, 67, 68, 69,
3768 -1, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3769 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
3770 -1, 91, 92, 93, -1, 95, 96, 97, -1, -1,
3771 -1, 39, -1, 103, 104, -1, 106, 107, 108, -1,
3772 110, 111, -1, 113, 114, 115, 116, 117, -1, -1,
3773 -1, -1, -1, 123, -1, 125, -1, -1, 128, 67,
3774 68, 69, -1, 71, 72, 73, 74, 75, 76, 77,
3775 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
3776 88, 89, -1, 91, 92, 93, -1, 95, 96, 97,
3777 -1, -1, -1, 39, -1, 103, 104, -1, 106, 107,
3778 108, -1, -1, 111, -1, 113, 114, 115, 116, 117,
3779 -1, -1, -1, -1, -1, 123, -1, 125, -1, -1,
3780 128, 67, 68, 69, -1, 71, 72, 73, 74, 75,
3781 76, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3782 -1, -1, -1, 89, -1, 91, 92, 93, -1, 95,
3783 96, 97, -1, -1, -1, 39, -1, -1, -1, -1,
3784 106, 107, 108, -1, 110, 111, -1, 113, 114, 115,
3785 116, 117, -1, -1, -1, -1, -1, 123, -1, 125,
3786 -1, -1, 128, 67, 68, 69, -1, 71, 72, 73,
3787 74, 75, 76, -1, -1, -1, -1, -1, -1, -1,
3788 -1, -1, -1, -1, -1, -1, -1, 91, 92, 93,
3789 -1, 95, 96, 97, -1, -1, -1, 39, -1, -1,
3790 -1, -1, 106, 107, 108, -1, 110, 111, -1, 113,
3791 114, 115, 116, 117, -1, -1, -1, -1, -1, 123,
3792 -1, 125, -1, -1, 128, 67, 68, 69, -1, 71,
3793 72, 73, 74, 75, 76, -1, -1, -1, -1, -1,
3794 -1, -1, -1, -1, -1, -1, -1, -1, -1, 91,
3795 92, 93, -1, 95, 96, 97, -1, -1, -1, 39,
3796 -1, -1, -1, -1, -1, 107, 108, -1, 110, 111,
3797 -1, 113, 114, 115, 116, 117, -1, -1, -1, -1,
3798 -1, 123, -1, 125, -1, -1, 128, 67, 68, 69,
3799 -1, 71, 72, 73, 74, 75, 76, -1, -1, -1,
3800 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3801 -1, 91, 92, 93, -1, 95, 96, 97, -1, -1,
3802 -1, 39, -1, -1, -1, -1, -1, -1, 108, -1,
3803 110, 111, -1, 113, 114, 115, 116, 117, -1, -1,
3804 -1, -1, -1, 123, -1, 125, -1, -1, 128, 67,
3805 68, 69, -1, 71, 72, 73, 74, 75, 76, -1,
3806 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3807 -1, -1, -1, 91, 92, 93, -1, 95, 96, 97,
3808 -1, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3809 108, -1, 110, 111, -1, 113, 114, 115, 116, 117,
3810 -1, -1, -1, -1, -1, 123, -1, 125, -1, -1,
3811 128, 67, 68, 69, -1, 71, 72, 73, 74, 75,
3812 76, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3813 -1, -1, -1, -1, -1, 91, 92, 93, -1, 95,
3814 96, 97, -1, -1, -1, -1, -1, -1, -1, -1,
3815 -1, -1, -1, -1, 110, 111, -1, 113, 114, 115,
3816 116, 117, -1, -1, -1, -1, -1, 123, -1, 125,
3820 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
3821 symbol of state STATE-NUM. */
3822 static const yytype_uint16 yystos[] =
3824 0, 3, 4, 5, 7, 8, 9, 10, 11, 12,
3825 13, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3826 25, 27, 28, 35, 37, 38, 40, 42, 44, 46,
3827 47, 48, 51, 52, 54, 55, 62, 63, 64, 70,
3828 91, 92, 100, 110, 113, 118, 119, 123, 125, 127,
3829 129, 136, 137, 138, 139, 145, 148, 150, 158, 161,
3830 162, 163, 164, 165, 172, 180, 183, 184, 187, 190,
3831 191, 192, 193, 197, 199, 208, 213, 214, 215, 226,
3832 233, 236, 249, 250, 251, 256, 260, 264, 265, 267,
3833 268, 269, 90, 49, 123, 123, 155, 156, 123, 3,
3834 15, 16, 28, 127, 185, 186, 15, 3, 260, 3,
3835 235, 260, 123, 3, 186, 239, 260, 127, 123, 128,
3836 15, 260, 123, 3, 4, 7, 8, 9, 257, 258,
3837 259, 260, 260, 260, 260, 260, 255, 260, 245, 246,
3838 247, 253, 260, 29, 31, 36, 41, 45, 66, 100,
3839 133, 144, 145, 146, 150, 152, 166, 167, 182, 191,
3840 252, 3, 0, 139, 127, 3, 45, 152, 159, 160,
3841 256, 146, 147, 15, 25, 30, 31, 43, 45, 207,
3842 266, 3, 193, 3, 127, 220, 224, 101, 39, 67,
3843 68, 69, 71, 72, 73, 74, 75, 76, 77, 78,
3844 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
3845 89, 91, 92, 93, 95, 96, 97, 103, 104, 106,
3846 107, 108, 110, 111, 113, 114, 115, 116, 117, 123,
3847 125, 128, 3, 123, 254, 255, 11, 147, 173, 189,
3848 127, 128, 185, 186, 238, 239, 240, 248, 123, 254,
3849 128, 181, 245, 3, 103, 254, 133, 105, 101, 101,
3850 134, 126, 101, 253, 3, 3, 153, 154, 254, 254,
3851 153, 3, 133, 146, 127, 137, 3, 100, 68, 100,
3852 3, 34, 50, 232, 3, 3, 209, 260, 3, 220,
3853 225, 227, 228, 260, 260, 260, 260, 260, 260, 260,
3854 260, 260, 260, 260, 260, 260, 260, 260, 260, 260,
3855 260, 260, 260, 260, 260, 260, 260, 3, 116, 129,
3856 185, 262, 263, 260, 260, 260, 260, 260, 260, 260,
3857 260, 260, 260, 260, 260, 260, 260, 260, 245, 260,
3858 123, 125, 129, 262, 263, 134, 123, 260, 100, 125,
3859 140, 141, 142, 148, 150, 197, 199, 208, 233, 188,
3860 185, 128, 123, 244, 3, 94, 229, 230, 231, 134,
3861 116, 185, 143, 144, 134, 260, 134, 253, 258, 260,
3862 105, 243, 101, 144, 133, 243, 254, 254, 103, 3,
3863 53, 194, 53, 195, 3, 210, 211, 221, 103, 103,
3864 111, 115, 216, 228, 125, 262, 263, 90, 105, 134,
3865 126, 261, 260, 125, 262, 263, 90, 155, 254, 134,
3866 149, 133, 142, 127, 140, 245, 103, 105, 212, 231,
3867 134, 101, 133, 155, 105, 35, 116, 240, 242, 103,
3868 151, 154, 133, 100, 134, 3, 4, 123, 240, 14,
3869 196, 240, 241, 127, 243, 101, 133, 4, 220, 4,
3870 220, 217, 222, 260, 90, 116, 263, 260, 260, 126,
3871 260, 90, 263, 134, 127, 260, 140, 133, 134, 260,
3872 242, 243, 94, 231, 26, 32, 174, 176, 178, 179,
3873 65, 157, 253, 260, 256, 155, 229, 241, 127, 101,
3874 200, 151, 211, 111, 4, 110, 111, 127, 218, 223,
3875 226, 126, 263, 134, 126, 263, 33, 61, 168, 169,
3876 170, 171, 126, 133, 212, 127, 231, 127, 123, 174,
3877 176, 155, 134, 134, 198, 240, 45, 100, 191, 204,
3878 205, 206, 115, 260, 110, 226, 222, 260, 105, 133,
3879 170, 171, 237, 177, 3, 155, 243, 100, 125, 145,
3880 150, 191, 201, 202, 203, 208, 233, 3, 25, 133,
3881 206, 224, 219, 115, 222, 105, 143, 143, 143, 243,
3882 127, 149, 127, 133, 203, 232, 217, 133, 224, 143,
3883 133, 133, 134, 234, 260, 201, 3, 111, 217, 175,
3884 143, 126, 133, 123, 111, 127, 133, 229, 143, 134,
3888 #define yyerrok (yyerrstatus = 0)
3889 #define yyclearin (yychar = YYEMPTY)
3890 #define YYEMPTY (-2)
3893 #define YYACCEPT goto yyacceptlab
3894 #define YYABORT goto yyabortlab
3895 #define YYERROR goto yyerrorlab
3898 /* Like YYERROR except do call yyerror. This remains here temporarily
3899 to ease the transition to the new meaning of YYERROR, for GCC.
3900 Once GCC version 2 has supplanted version 1, this can go. */
3902 #define YYFAIL goto yyerrlab
3904 #define YYRECOVERING() (!!yyerrstatus)
3906 #define YYBACKUP(Token, Value) \
3908 if (yychar == YYEMPTY && yylen == 1) \
3912 yytoken = YYTRANSLATE (yychar); \
3918 yyerror (YY_("syntax error: cannot back up")); \
3925 #define YYERRCODE 256
3928 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
3929 If N is 0, then set CURRENT to the empty location which ends
3930 the previous symbol: RHS[0] (always defined). */
3932 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
3933 #ifndef YYLLOC_DEFAULT
3934 # define YYLLOC_DEFAULT(Current, Rhs, N) \
3938 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
3939 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
3940 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
3941 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
3945 (Current).first_line = (Current).last_line = \
3946 YYRHSLOC (Rhs, 0).last_line; \
3947 (Current).first_column = (Current).last_column = \
3948 YYRHSLOC (Rhs, 0).last_column; \
3954 /* YY_LOCATION_PRINT -- Print the location on the stream.
3955 This macro was not mandated originally: define only if we know
3956 we won't break user code: when these are the locations we know. */
3958 #ifndef YY_LOCATION_PRINT
3959 # if YYLTYPE_IS_TRIVIAL
3960 # define YY_LOCATION_PRINT(File, Loc) \
3961 fprintf (File, "%d.%d-%d.%d", \
3962 (Loc).first_line, (Loc).first_column, \
3963 (Loc).last_line, (Loc).last_column)
3965 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
3970 /* YYLEX -- calling `yylex' with the right arguments. */
3973 # define YYLEX yylex (YYLEX_PARAM)
3975 # define YYLEX yylex ()
3978 /* Enable debugging if requested. */
3982 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
3983 # define YYFPRINTF fprintf
3986 # define YYDPRINTF(Args) \
3992 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
3996 YYFPRINTF (stderr, "%s ", Title); \
3997 yy_symbol_print (stderr, \
3999 YYFPRINTF (stderr, "\n"); \
4004 /*--------------------------------.
4005 | Print this symbol on YYOUTPUT. |
4006 `--------------------------------*/
4009 #if (defined __STDC__ || defined __C99__FUNC__ \
4010 || defined __cplusplus || defined _MSC_VER)
4012 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
4015 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
4018 YYSTYPE const * const yyvaluep;
4024 if (yytype < YYNTOKENS)
4025 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4037 /*--------------------------------.
4038 | Print this symbol on YYOUTPUT. |
4039 `--------------------------------*/
4041 #if (defined __STDC__ || defined __C99__FUNC__ \
4042 || defined __cplusplus || defined _MSC_VER)
4044 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
4047 yy_symbol_print (yyoutput, yytype, yyvaluep)
4050 YYSTYPE const * const yyvaluep;
4053 if (yytype < YYNTOKENS)
4054 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4056 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4058 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
4059 YYFPRINTF (yyoutput, ")");
4062 /*------------------------------------------------------------------.
4063 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4065 `------------------------------------------------------------------*/
4067 #if (defined __STDC__ || defined __C99__FUNC__ \
4068 || defined __cplusplus || defined _MSC_VER)
4070 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4073 yy_stack_print (yybottom, yytop)
4074 yytype_int16 *yybottom;
4075 yytype_int16 *yytop;
4078 YYFPRINTF (stderr, "Stack now");
4079 for (; yybottom <= yytop; yybottom++)
4081 int yybot = *yybottom;
4082 YYFPRINTF (stderr, " %d", yybot);
4084 YYFPRINTF (stderr, "\n");
4087 # define YY_STACK_PRINT(Bottom, Top) \
4090 yy_stack_print ((Bottom), (Top)); \
4094 /*------------------------------------------------.
4095 | Report that the YYRULE is going to be reduced. |
4096 `------------------------------------------------*/
4098 #if (defined __STDC__ || defined __C99__FUNC__ \
4099 || defined __cplusplus || defined _MSC_VER)
4101 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
4104 yy_reduce_print (yyvsp, yyrule)
4109 int yynrhs = yyr2[yyrule];
4111 unsigned long int yylno = yyrline[yyrule];
4112 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4114 /* The symbols being reduced. */
4115 for (yyi = 0; yyi < yynrhs; yyi++)
4117 YYFPRINTF (stderr, " $%d = ", yyi + 1);
4118 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4119 &(yyvsp[(yyi + 1) - (yynrhs)])
4121 YYFPRINTF (stderr, "\n");
4125 # define YY_REDUCE_PRINT(Rule) \
4128 yy_reduce_print (yyvsp, Rule); \
4131 /* Nonzero means print parse trace. It is left uninitialized so that
4132 multiple parsers can coexist. */
4134 #else /* !YYDEBUG */
4135 # define YYDPRINTF(Args)
4136 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4137 # define YY_STACK_PRINT(Bottom, Top)
4138 # define YY_REDUCE_PRINT(Rule)
4139 #endif /* !YYDEBUG */
4142 /* YYINITDEPTH -- initial size of the parser's stacks. */
4144 # define YYINITDEPTH 200
4147 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4148 if the built-in stack extension method is used).
4150 Do not make this value too large; the results are undefined if
4151 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4152 evaluated with infinite-precision integer arithmetic. */
4155 # define YYMAXDEPTH 10000
4163 # if defined __GLIBC__ && defined _STRING_H
4164 # define yystrlen strlen
4166 /* Return the length of YYSTR. */
4167 #if (defined __STDC__ || defined __C99__FUNC__ \
4168 || defined __cplusplus || defined _MSC_VER)
4170 yystrlen (const char *yystr)
4178 for (yylen = 0; yystr[yylen]; yylen++)
4186 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4187 # define yystpcpy stpcpy
4189 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4191 #if (defined __STDC__ || defined __C99__FUNC__ \
4192 || defined __cplusplus || defined _MSC_VER)
4194 yystpcpy (char *yydest, const char *yysrc)
4197 yystpcpy (yydest, yysrc)
4203 const char *yys = yysrc;
4205 while ((*yyd++ = *yys++) != '\0')
4214 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4215 quotes and backslashes, so that it's suitable for yyerror. The
4216 heuristic is that double-quoting is unnecessary unless the string
4217 contains an apostrophe, a comma, or backslash (other than
4218 backslash-backslash). YYSTR is taken from yytname. If YYRES is
4219 null, do not copy; instead, return the length of what the result
4222 yytnamerr (char *yyres, const char *yystr)
4227 char const *yyp = yystr;
4234 goto do_not_strip_quotes;
4238 goto do_not_strip_quotes;
4251 do_not_strip_quotes: ;
4255 return yystrlen (yystr);
4257 return yystpcpy (yyres, yystr) - yyres;
4261 /* Copy into YYRESULT an error message about the unexpected token
4262 YYCHAR while in state YYSTATE. Return the number of bytes copied,
4263 including the terminating null byte. If YYRESULT is null, do not
4264 copy anything; just return the number of bytes that would be
4265 copied. As a special case, return 0 if an ordinary "syntax error"
4266 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
4267 size calculation. */
4269 yysyntax_error (char *yyresult, int yystate, int yychar)
4271 int yyn = yypact[yystate];
4273 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
4277 int yytype = YYTRANSLATE (yychar);
4278 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
4279 YYSIZE_T yysize = yysize0;
4281 int yysize_overflow = 0;
4282 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4283 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4287 /* This is so xgettext sees the translatable formats that are
4288 constructed on the fly. */
4289 YY_("syntax error, unexpected %s");
4290 YY_("syntax error, unexpected %s, expecting %s");
4291 YY_("syntax error, unexpected %s, expecting %s or %s");
4292 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
4293 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
4297 static char const yyunexpected[] = "syntax error, unexpected %s";
4298 static char const yyexpecting[] = ", expecting %s";
4299 static char const yyor[] = " or %s";
4300 char yyformat[sizeof yyunexpected
4301 + sizeof yyexpecting - 1
4302 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
4303 * (sizeof yyor - 1))];
4304 char const *yyprefix = yyexpecting;
4306 /* Start YYX at -YYN if negative to avoid negative indexes in
4308 int yyxbegin = yyn < 0 ? -yyn : 0;
4310 /* Stay within bounds of both yycheck and yytname. */
4311 int yychecklim = YYLAST - yyn + 1;
4312 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4315 yyarg[0] = yytname[yytype];
4316 yyfmt = yystpcpy (yyformat, yyunexpected);
4318 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4319 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
4321 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4325 yyformat[sizeof yyunexpected - 1] = '\0';
4328 yyarg[yycount++] = yytname[yyx];
4329 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4330 yysize_overflow |= (yysize1 < yysize);
4332 yyfmt = yystpcpy (yyfmt, yyprefix);
4336 yyf = YY_(yyformat);
4337 yysize1 = yysize + yystrlen (yyf);
4338 yysize_overflow |= (yysize1 < yysize);
4341 if (yysize_overflow)
4342 return YYSIZE_MAXIMUM;
4346 /* Avoid sprintf, as that infringes on the user's name space.
4347 Don't have undefined behavior even if the translation
4348 produced a string with the wrong number of "%s"s. */
4349 char *yyp = yyresult;
4351 while ((*yyp = *yyf) != '\0')
4353 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
4355 yyp += yytnamerr (yyp, yyarg[yyi++]);
4368 #endif /* YYERROR_VERBOSE */
4371 /*-----------------------------------------------.
4372 | Release the memory associated to this symbol. |
4373 `-----------------------------------------------*/
4376 #if (defined __STDC__ || defined __C99__FUNC__ \
4377 || defined __cplusplus || defined _MSC_VER)
4379 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
4382 yydestruct (yymsg, yytype, yyvaluep)
4392 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4402 /* Prevent warnings from -Wmissing-prototypes. */
4403 #ifdef YYPARSE_PARAM
4404 #if defined __STDC__ || defined __cplusplus
4405 int yyparse (void *YYPARSE_PARAM);
4409 #else /* ! YYPARSE_PARAM */
4410 #if defined __STDC__ || defined __cplusplus
4415 #endif /* ! YYPARSE_PARAM */
4418 /* The lookahead symbol. */
4421 /* The semantic value of the lookahead symbol. */
4424 /* Number of syntax errors so far. */
4429 /*-------------------------.
4430 | yyparse or yypush_parse. |
4431 `-------------------------*/
4433 #ifdef YYPARSE_PARAM
4434 #if (defined __STDC__ || defined __C99__FUNC__ \
4435 || defined __cplusplus || defined _MSC_VER)
4437 yyparse (void *YYPARSE_PARAM)
4440 yyparse (YYPARSE_PARAM)
4441 void *YYPARSE_PARAM;
4443 #else /* ! YYPARSE_PARAM */
4444 #if (defined __STDC__ || defined __C99__FUNC__ \
4445 || defined __cplusplus || defined _MSC_VER)
4458 /* Number of tokens to shift before error messages enabled. */
4461 /* The stacks and their tools:
4462 `yyss': related to states.
4463 `yyvs': related to semantic values.
4465 Refer to the stacks thru separate pointers, to allow yyoverflow
4466 to reallocate them elsewhere. */
4468 /* The state stack. */
4469 yytype_int16 yyssa[YYINITDEPTH];
4471 yytype_int16 *yyssp;
4473 /* The semantic value stack. */
4474 YYSTYPE yyvsa[YYINITDEPTH];
4478 YYSIZE_T yystacksize;
4482 /* Lookahead token as an internal (translated) token number. */
4484 /* The variables used to return semantic value and location from the
4489 /* Buffer for error messages, and its allocated size. */
4491 char *yymsg = yymsgbuf;
4492 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
4495 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
4497 /* The number of symbols on the RHS of the reduced rule.
4498 Keep to zero when no symbol should be popped. */
4504 yystacksize = YYINITDEPTH;
4506 YYDPRINTF ((stderr, "Starting parse\n"));
4511 yychar = YYEMPTY; /* Cause a token to be read. */
4513 /* Initialize stack pointers.
4514 Waste one element of value and location stack
4515 so that they stay on the same level as the state stack.
4516 The wasted elements are never initialized. */
4522 /*------------------------------------------------------------.
4523 | yynewstate -- Push a new state, which is found in yystate. |
4524 `------------------------------------------------------------*/
4526 /* In all cases, when you get here, the value and location stacks
4527 have just been pushed. So pushing a state here evens the stacks. */
4533 if (yyss + yystacksize - 1 <= yyssp)
4535 /* Get the current used size of the three stacks, in elements. */
4536 YYSIZE_T yysize = yyssp - yyss + 1;
4540 /* Give user a chance to reallocate the stack. Use copies of
4541 these so that the &'s don't force the real ones into
4543 YYSTYPE *yyvs1 = yyvs;
4544 yytype_int16 *yyss1 = yyss;
4546 /* Each stack pointer address is followed by the size of the
4547 data in use in that stack, in bytes. This used to be a
4548 conditional around just the two extra args, but that might
4549 be undefined if yyoverflow is a macro. */
4550 yyoverflow (YY_("memory exhausted"),
4551 &yyss1, yysize * sizeof (*yyssp),
4552 &yyvs1, yysize * sizeof (*yyvsp),
4558 #else /* no yyoverflow */
4559 # ifndef YYSTACK_RELOCATE
4560 goto yyexhaustedlab;
4562 /* Extend the stack our own way. */
4563 if (YYMAXDEPTH <= yystacksize)
4564 goto yyexhaustedlab;
4566 if (YYMAXDEPTH < yystacksize)
4567 yystacksize = YYMAXDEPTH;
4570 yytype_int16 *yyss1 = yyss;
4571 union yyalloc *yyptr =
4572 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
4574 goto yyexhaustedlab;
4575 YYSTACK_RELOCATE (yyss_alloc, yyss);
4576 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
4577 # undef YYSTACK_RELOCATE
4579 YYSTACK_FREE (yyss1);
4582 #endif /* no yyoverflow */
4584 yyssp = yyss + yysize - 1;
4585 yyvsp = yyvs + yysize - 1;
4587 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
4588 (unsigned long int) yystacksize));
4590 if (yyss + yystacksize - 1 <= yyssp)
4594 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
4596 if (yystate == YYFINAL)
4606 /* Do appropriate processing given the current state. Read a
4607 lookahead token if we need one and don't already have one. */
4609 /* First try to decide what to do without reference to lookahead token. */
4610 yyn = yypact[yystate];
4611 if (yyn == YYPACT_NINF)
4614 /* Not known => get a lookahead token if don't already have one. */
4616 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
4617 if (yychar == YYEMPTY)
4619 YYDPRINTF ((stderr, "Reading a token: "));
4623 if (yychar <= YYEOF)
4625 yychar = yytoken = YYEOF;
4626 YYDPRINTF ((stderr, "Now at end of input.\n"));
4630 yytoken = YYTRANSLATE (yychar);
4631 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
4634 /* If the proper action on seeing token YYTOKEN is to reduce or to
4635 detect an error, take that action. */
4637 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
4642 if (yyn == 0 || yyn == YYTABLE_NINF)
4648 /* Count tokens shifted since error; after three, turn off error
4653 /* Shift the lookahead token. */
4654 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
4656 /* Discard the shifted token. */
4665 /*-----------------------------------------------------------.
4666 | yydefault -- do the default action for the current state. |
4667 `-----------------------------------------------------------*/
4669 yyn = yydefact[yystate];
4675 /*-----------------------------.
4676 | yyreduce -- Do a reduction. |
4677 `-----------------------------*/
4679 /* yyn is the number of a rule to reduce with. */
4682 /* If YYLEN is nonzero, implement the default value of the action:
4685 Otherwise, the following line sets YYVAL to garbage.
4686 This behavior is undocumented and Bison
4687 users should not rely upon it. Assigning to YYVAL
4688 unconditionally makes the parser a bit smaller, and it avoids a
4689 GCC warning that YYVAL may be used uninitialized. */
4690 yyval = yyvsp[1-yylen];
4693 YY_REDUCE_PRINT (yyn);
4700 /* Line 1464 of skeleton.m4 */
4701 #line 2010 "parser.y"
4702 {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
4711 /* Line 1464 of skeleton.m4 */
4712 #line 2022 "parser.y"
4713 {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
4722 /* Line 1464 of skeleton.m4 */
4723 #line 2023 "parser.y"
4724 {PASS_ALWAYS as3_pass=(yyvsp[(2) - (4)].number_int);PASS1 as3_warning("embed command ignored");}
4733 /* Line 1464 of skeleton.m4 */
4734 #line 2026 "parser.y"
4735 {(yyval.code)=(yyvsp[(1) - (1)].code);}
4744 /* Line 1464 of skeleton.m4 */
4745 #line 2027 "parser.y"
4746 {(yyval.code)=code_new();}
4755 /* Line 1464 of skeleton.m4 */
4756 #line 2029 "parser.y"
4758 (yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));
4768 /* Line 1464 of skeleton.m4 */
4769 #line 2032 "parser.y"
4770 {(yyval.code)=(yyvsp[(1) - (1)].code);}
4779 /* Line 1464 of skeleton.m4 */
4780 #line 2048 "parser.y"
4781 {(yyval.code)=(yyvsp[(2) - (3)].code);}
4790 /* Line 1464 of skeleton.m4 */
4791 #line 2049 "parser.y"
4801 /* Line 1464 of skeleton.m4 */
4802 #line 2052 "parser.y"
4812 /* Line 1464 of skeleton.m4 */
4813 #line 2059 "parser.y"
4817 (yyval.code) = (yyvsp[(3) - (4)].code);
4821 as3_pass=(yyvsp[(1) - (4)].number_int);
4831 /* Line 1464 of skeleton.m4 */
4832 #line 2071 "parser.y"
4833 {(yyval.code)=(yyvsp[(1) - (2)].code);}
4842 /* Line 1464 of skeleton.m4 */
4843 #line 2072 "parser.y"
4844 {(yyval.code)=(yyvsp[(1) - (1)].code);}
4853 /* Line 1464 of skeleton.m4 */
4854 #line 2076 "parser.y"
4856 if((yyvsp[(1) - (1)].code)) {
4858 global->init = abc_initscript(global->file);
4859 code_t**cc = &global->init->method->body->code;
4860 *cc = code_append(*cc, (yyvsp[(1) - (1)].code));
4871 /* Line 1464 of skeleton.m4 */
4872 #line 2087 "parser.y"
4875 (yyval.number_int) = as3_pass;
4886 /* Line 1464 of skeleton.m4 */
4887 #line 2095 "parser.y"
4890 (yyval.number_int)=as3_pass;
4891 char*key = concat3((yyvsp[(1) - (3)].id),"::",(yyvsp[(3) - (3)].id));
4892 if(!definitions || !dict_contains(definitions, key)) {
4905 /* Line 1464 of skeleton.m4 */
4906 #line 2122 "parser.y"
4907 {(yyval.node)=(yyvsp[(2) - (2)].node);}
4916 /* Line 1464 of skeleton.m4 */
4917 #line 2123 "parser.y"
4918 {(yyval.node)=mkdummynode();}
4927 /* Line 1464 of skeleton.m4 */
4928 #line 2125 "parser.y"
4929 {(yyval.code)=(yyvsp[(2) - (2)].code);}
4938 /* Line 1464 of skeleton.m4 */
4939 #line 2126 "parser.y"
4940 {(yyval.code)=(yyvsp[(2) - (2)].code);}
4949 /* Line 1464 of skeleton.m4 */
4950 #line 2128 "parser.y"
4951 {(yyval.code) = (yyvsp[(1) - (1)].code);}
4960 /* Line 1464 of skeleton.m4 */
4961 #line 2129 "parser.y"
4962 {(yyval.code) = code_append((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
4971 /* Line 1464 of skeleton.m4 */
4972 #line 2132 "parser.y"
4975 if(variable_exists((yyvsp[(1) - (3)].id)))
4976 syntaxerror("Variable %s already defined", (yyvsp[(1) - (3)].id));
4978 new_variable(state->method, (yyvsp[(1) - (3)].id), (yyvsp[(2) - (3)].classinfo), 1, 0);
4984 if(state->method->uses_slots) {
4985 v = find_slot(state->method, (yyvsp[(1) - (3)].id));
4987 // this variable is stored in a slot
4989 v->type = (yyvsp[(2) - (3)].classinfo);
4994 v = new_variable2(state->method, (yyvsp[(1) - (3)].id), (yyvsp[(2) - (3)].classinfo), 1, 0);
4997 (yyval.code) = slot?abc_getscopeobject(0, 1):0;
4999 typedcode_t val = node_read((yyvsp[(3) - (3)].node));
5000 if(!is_subtype_of(val.t, (yyvsp[(2) - (3)].classinfo))) {
5001 syntaxerror("Can't convert %s to %s", val.t->name, (yyvsp[(2) - (3)].classinfo)->name);
5003 if((yyvsp[(2) - (3)].classinfo)) {
5004 if(val.c->prev || val.c->opcode != OPCODE_PUSHUNDEFINED) {
5005 (yyval.code) = code_append((yyval.code), val.c);
5006 (yyval.code) = converttype((yyval.code), val.t, (yyvsp[(2) - (3)].classinfo));
5009 (yyval.code) = defaultvalue((yyval.code), (yyvsp[(2) - (3)].classinfo));
5012 if(val.c->prev || val.c->opcode != OPCODE_PUSHUNDEFINED) {
5013 (yyval.code) = code_append((yyval.code), val.c);
5014 (yyval.code) = abc_coerce_a((yyval.code));
5016 // don't do anything
5018 code_free((yyval.code));
5024 (yyval.code) = abc_setslot((yyval.code), v->index);
5026 (yyval.code) = abc_setlocal((yyval.code), v->index);
5027 v->init = do_init_variable((yyvsp[(1) - (3)].id));
5038 /* Line 1464 of skeleton.m4 */
5039 #line 2192 "parser.y"
5040 {PASS12 new_state();}
5049 /* Line 1464 of skeleton.m4 */
5050 #line 2192 "parser.y"
5052 (yyval.code) = var_block((yyvsp[(2) - (2)].code), state->vars);
5063 /* Line 1464 of skeleton.m4 */
5064 #line 2196 "parser.y"
5065 {(yyval.code) = code_new();}
5074 /* Line 1464 of skeleton.m4 */
5075 #line 2197 "parser.y"
5076 {(yyval.code)=(yyvsp[(2) - (2)].code);}
5085 /* Line 1464 of skeleton.m4 */
5086 #line 2200 "parser.y"
5088 (yyval.code) = code_new();
5089 (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (6)].value).c);
5090 code_t*myjmp,*myif = (yyval.code) = abc_iffalse((yyval.code), 0);
5092 (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (6)].code));
5093 if((yyvsp[(6) - (6)].code)) {
5094 myjmp = (yyval.code) = abc_jump((yyval.code), 0);
5096 myif->branch = (yyval.code) = abc_nop((yyval.code));
5097 if((yyvsp[(6) - (6)].code)) {
5098 (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (6)].code));
5099 myjmp->branch = (yyval.code) = abc_nop((yyval.code));
5110 /* Line 1464 of skeleton.m4 */
5111 #line 2216 "parser.y"
5112 {(yyval.code)=code_new();}
5121 /* Line 1464 of skeleton.m4 */
5122 #line 2223 "parser.y"
5124 PASS1 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable(state->method, (yyvsp[(2) - (3)].id),0,1,0);
5125 PASS2 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable(state->method, (yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].classinfo),1,0);
5135 /* Line 1464 of skeleton.m4 */
5136 #line 2227 "parser.y"
5139 (yyval.id)=(yyvsp[(1) - (1)].id);
5149 /* Line 1464 of skeleton.m4 */
5150 #line 2232 "parser.y"
5151 {PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (2)].id);(yyval.for_start).each=0;}
5160 /* Line 1464 of skeleton.m4 */
5161 #line 2233 "parser.y"
5162 {PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (3)].id);(yyval.for_start).each=1;}
5171 /* Line 1464 of skeleton.m4 */
5172 #line 2235 "parser.y"
5174 if((yyvsp[(1) - (8)].for_start).each) syntaxerror("invalid syntax: ; not allowed in for each statement");
5175 (yyval.code) = code_new();
5176 (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (8)].code));
5177 code_t*loopstart = (yyval.code) = abc_label((yyval.code));
5178 (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (8)].value).c);
5179 code_t*myif = (yyval.code) = abc_iffalse((yyval.code), 0);
5180 (yyval.code) = code_append((yyval.code), (yyvsp[(8) - (8)].code));
5181 code_t*cont = (yyval.code) = abc_nop((yyval.code));
5182 (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (8)].code));
5183 (yyval.code) = abc_jump((yyval.code), loopstart);
5184 code_t*out = (yyval.code) = abc_nop((yyval.code));
5185 breakjumpsto((yyval.code), (yyvsp[(1) - (8)].for_start).name, out);
5186 continuejumpsto((yyval.code), (yyvsp[(1) - (8)].for_start).name, cont);
5189 (yyval.code) = var_block((yyval.code), state->vars);
5200 /* Line 1464 of skeleton.m4 */
5201 #line 2255 "parser.y"
5203 node_t*n = resolve_identifier((yyvsp[(2) - (6)].id));
5204 typedcode_t w = node_write(n);
5206 int it = alloc_local();
5207 int array = alloc_local();
5209 (yyval.code) = code_new();
5210 (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (6)].value).c);
5211 (yyval.code) = abc_coerce_a((yyval.code));
5212 (yyval.code) = abc_setlocal((yyval.code), array);
5213 (yyval.code) = abc_pushbyte((yyval.code), 0);
5214 (yyval.code) = abc_setlocal((yyval.code), it);
5216 code_t*loopstart = (yyval.code) = abc_label((yyval.code));
5218 (yyval.code) = abc_hasnext2((yyval.code), array, it);
5219 code_t*myif = (yyval.code) = abc_iffalse((yyval.code), 0);
5220 (yyval.code) = abc_getlocal((yyval.code), array);
5221 (yyval.code) = abc_getlocal((yyval.code), it);
5222 if(!(yyvsp[(1) - (6)].for_start).each)
5223 (yyval.code) = abc_nextname((yyval.code));
5225 (yyval.code) = abc_nextvalue((yyval.code));
5227 (yyval.code) = converttype((yyval.code), 0, w.t);
5228 (yyval.code) = code_append((yyval.code), w.c);
5230 (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (6)].code));
5231 (yyval.code) = abc_jump((yyval.code), loopstart);
5233 code_t*out = (yyval.code) = abc_nop((yyval.code));
5234 breakjumpsto((yyval.code), (yyvsp[(1) - (6)].for_start).name, out);
5235 continuejumpsto((yyval.code), (yyvsp[(1) - (6)].for_start).name, loopstart);
5239 (yyval.code) = abc_kill((yyval.code), it);
5240 (yyval.code) = abc_kill((yyval.code), array);
5242 (yyval.code) = var_block((yyval.code), state->vars);
5253 /* Line 1464 of skeleton.m4 */
5254 #line 2299 "parser.y"
5257 (yyval.code) = code_new();
5259 code_t*myjmp = (yyval.code) = abc_jump((yyval.code), 0);
5260 code_t*loopstart = (yyval.code) = abc_label((yyval.code));
5261 (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (5)].code));
5262 code_t*cont = (yyval.code) = abc_nop((yyval.code));
5263 myjmp->branch = cont;
5264 (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (5)].value).c);
5265 (yyval.code) = abc_iftrue((yyval.code), loopstart);
5266 code_t*out = (yyval.code) = abc_nop((yyval.code));
5267 breakjumpsto((yyval.code), (yyvsp[(1) - (5)].id), out);
5268 continuejumpsto((yyval.code), (yyvsp[(1) - (5)].id), cont);
5278 /* Line 1464 of skeleton.m4 */
5279 #line 2315 "parser.y"
5281 (yyval.code) = code_new();
5282 code_t*loopstart = (yyval.code) = abc_label((yyval.code));
5283 (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (6)].code));
5284 code_t*cont = (yyval.code) = abc_nop((yyval.code));
5285 (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (6)].value).c);
5286 (yyval.code) = abc_iftrue((yyval.code), loopstart);
5287 code_t*out = (yyval.code) = abc_nop((yyval.code));
5288 breakjumpsto((yyval.code), (yyvsp[(1) - (6)].id), out);
5289 continuejumpsto((yyval.code), (yyvsp[(1) - (6)].id), cont);
5299 /* Line 1464 of skeleton.m4 */
5300 #line 2327 "parser.y"
5302 (yyval.code) = abc___break__(0, "");
5312 /* Line 1464 of skeleton.m4 */
5313 #line 2330 "parser.y"
5315 (yyval.code) = abc___break__(0, (yyvsp[(2) - (2)].id));
5325 /* Line 1464 of skeleton.m4 */
5326 #line 2333 "parser.y"
5328 (yyval.code) = abc___continue__(0, "");
5338 /* Line 1464 of skeleton.m4 */
5339 #line 2336 "parser.y"
5341 (yyval.code) = abc___continue__(0, (yyvsp[(2) - (2)].id));
5351 /* Line 1464 of skeleton.m4 */
5352 #line 2340 "parser.y"
5362 /* Line 1464 of skeleton.m4 */
5363 #line 2341 "parser.y"
5364 {(yyval.code)=(yyvsp[(1) - (1)].code);}
5373 /* Line 1464 of skeleton.m4 */
5374 #line 2342 "parser.y"
5375 {(yyval.code)=(yyvsp[(1) - (1)].code);}
5384 /* Line 1464 of skeleton.m4 */
5385 #line 2343 "parser.y"
5386 {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));}
5395 /* Line 1464 of skeleton.m4 */
5396 #line 2344 "parser.y"
5397 {(yyval.code)=(yyvsp[(1) - (1)].code);}
5406 /* Line 1464 of skeleton.m4 */
5407 #line 2345 "parser.y"
5408 {(yyval.code)=code_append((yyval.code),(yyvsp[(2) - (2)].code));}
5417 /* Line 1464 of skeleton.m4 */
5418 #line 2347 "parser.y"
5420 (yyval.code) = abc_getlocal(0, state->switch_var);
5421 (yyval.code) = code_append((yyval.code), node_read((yyvsp[(2) - (4)].node)).c);
5422 code_t*j = (yyval.code) = abc_ifne((yyval.code), 0);
5423 (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (4)].code));
5424 if((yyval.code)->opcode != OPCODE___BREAK__) {
5425 (yyval.code) = abc___fallthrough__((yyval.code), "");
5427 code_t*e = (yyval.code) = abc_nop((yyval.code));
5438 /* Line 1464 of skeleton.m4 */
5439 #line 2358 "parser.y"
5441 (yyval.code) = (yyvsp[(3) - (3)].code);
5451 /* Line 1464 of skeleton.m4 */
5452 #line 2361 "parser.y"
5453 {PASS12 new_state();state->switch_var=alloc_local();}
5462 /* Line 1464 of skeleton.m4 */
5463 #line 2361 "parser.y"
5465 (yyval.code) = node_read((yyvsp[(4) - (8)].node)).c;
5466 (yyval.code) = abc_setlocal((yyval.code), state->switch_var);
5467 (yyval.code) = code_append((yyval.code), (yyvsp[(7) - (8)].code));
5469 code_t*out = (yyval.code) = abc_kill((yyval.code), state->switch_var);
5470 breakjumpsto((yyval.code), (yyvsp[(1) - (8)].id), out);
5472 code_t*c = (yyval.code),*lastblock=0;
5474 if(c->opcode == OPCODE_IFNE) {
5475 if(!c->next) syntaxerror("internal error in fallthrough handling");
5477 } else if(c->opcode == OPCODE___FALLTHROUGH__) {
5479 c->opcode = OPCODE_JUMP;
5480 c->branch = lastblock;
5482 /* fall through end of switch */
5483 c->opcode = OPCODE_NOP;
5489 (yyval.code) = var_block((yyval.code), state->vars);
5500 /* Line 1464 of skeleton.m4 */
5501 #line 2392 "parser.y"
5502 {PASS12 new_state();
5503 state->exception_name=(yyvsp[(3) - (5)].id);
5504 PASS1 new_variable(state->method, (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].classinfo), 0, 0);
5505 PASS2 new_variable(state->method, (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].classinfo), 0, 0);
5515 /* Line 1464 of skeleton.m4 */
5516 #line 2397 "parser.y"
5518 namespace_t name_ns = {ACCESS_PACKAGE, ""};
5519 multiname_t name = {QNAME, &name_ns, 0, (yyvsp[(3) - (9)].id)};
5521 NEW(abc_exception_t, e)
5522 e->exc_type = sig2mname((yyvsp[(4) - (9)].classinfo));
5523 e->var_name = multiname_clone(&name);
5524 (yyval.exception) = e;
5527 int i = find_variable_safe(state, (yyvsp[(3) - (9)].id))->index;
5528 e->target = c = abc_nop(0);
5529 c = abc_setlocal(c, i);
5530 c = code_append(c, code_dup(state->method->scope_code));
5531 c = code_append(c, (yyvsp[(8) - (9)].code));
5534 c = var_block(c, state->vars);
5545 /* Line 1464 of skeleton.m4 */
5546 #line 2417 "parser.y"
5547 {PASS12 new_state();state->exception_name=0;}
5556 /* Line 1464 of skeleton.m4 */
5557 #line 2417 "parser.y"
5559 (yyvsp[(4) - (5)].code) = var_block((yyvsp[(4) - (5)].code), state->vars);
5560 if(!(yyvsp[(4) - (5)].code)) {
5561 (yyval.exception)=0;
5563 NEW(abc_exception_t, e)
5564 e->exc_type = 0; //all exceptions
5565 e->var_name = 0; //no name
5568 e->to = code_append(e->to, (yyvsp[(4) - (5)].code));
5569 (yyval.exception) = e;
5581 /* Line 1464 of skeleton.m4 */
5582 #line 2433 "parser.y"
5583 {(yyval.catch_list).l=list_new();(yyval.catch_list).finally=0;list_append((yyval.catch_list).l,(yyvsp[(1) - (1)].exception));}
5592 /* Line 1464 of skeleton.m4 */
5593 #line 2434 "parser.y"
5594 {(yyval.catch_list)=(yyvsp[(1) - (2)].catch_list);list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));}
5603 /* Line 1464 of skeleton.m4 */
5604 #line 2435 "parser.y"
5605 {(yyval.catch_list)=(yyvsp[(1) - (1)].catch_list);}
5614 /* Line 1464 of skeleton.m4 */
5615 #line 2436 "parser.y"
5617 (yyval.catch_list) = (yyvsp[(1) - (2)].catch_list);
5618 (yyval.catch_list).finally = 0;
5619 if((yyvsp[(2) - (2)].exception)) {
5620 list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));
5621 (yyval.catch_list).finally = (yyvsp[(2) - (2)].exception)->to;(yyvsp[(2) - (2)].exception)->to=0;
5632 /* Line 1464 of skeleton.m4 */
5633 #line 2444 "parser.y"
5635 (yyval.catch_list).l=list_new();
5636 (yyval.catch_list).finally = 0;
5637 if((yyvsp[(1) - (1)].exception)) {
5638 list_append((yyval.catch_list).l,(yyvsp[(1) - (1)].exception));
5639 (yyval.catch_list).finally = (yyvsp[(1) - (1)].exception)->to;(yyvsp[(1) - (1)].exception)->to=0;
5650 /* Line 1464 of skeleton.m4 */
5651 #line 2453 "parser.y"
5652 {PASS12 new_state();
5653 state->method->has_exceptions=1;
5654 state->method->late_binding=1;//for invariant scope_code
5664 /* Line 1464 of skeleton.m4 */
5665 #line 2456 "parser.y"
5667 code_t*out = abc_nop(0);
5669 code_t*start = abc_nop(0);
5670 (yyval.code) = code_append(start, (yyvsp[(4) - (6)].code));
5671 if(!is_break_or_jump((yyvsp[(4) - (6)].code))) {
5672 (yyval.code) = abc_jump((yyval.code), out);
5674 code_t*end = (yyval.code) = abc_nop((yyval.code));
5677 if((yyvsp[(6) - (6)].catch_list).finally)
5678 tmp = alloc_local();
5680 abc_exception_list_t*l = (yyvsp[(6) - (6)].catch_list).l;
5683 abc_exception_t*e = l->abc_exception;
5685 (yyval.code) = code_append((yyval.code), e->target);
5686 (yyval.code) = abc_jump((yyval.code), out);
5688 parserassert((ptroff_t)(yyvsp[(6) - (6)].catch_list).finally);
5690 e->target = (yyval.code) = abc_nop((yyval.code));
5691 (yyval.code) = code_append((yyval.code), code_dup(state->method->scope_code));
5692 (yyval.code) = abc___rethrow__((yyval.code));
5700 (yyval.code) = code_append((yyval.code), out);
5702 (yyval.code) = insert_finally((yyval.code), (yyvsp[(6) - (6)].catch_list).finally, tmp);
5704 list_concat(state->method->exceptions, (yyvsp[(6) - (6)].catch_list).l);
5706 (yyval.code) = var_block((yyval.code), state->vars);
5717 /* Line 1464 of skeleton.m4 */
5718 #line 2502 "parser.y"
5720 (yyval.code)=(yyvsp[(2) - (2)].value).c;
5721 (yyval.code)=abc_throw((yyval.code));
5731 /* Line 1464 of skeleton.m4 */
5732 #line 2506 "parser.y"
5734 if(!state->exception_name)
5735 syntaxerror("re-throw only possible within a catch block");
5736 variable_t*v = find_variable(state, state->exception_name);
5737 (yyval.code)=code_new();
5738 (yyval.code)=abc_getlocal((yyval.code), v->index);
5739 (yyval.code)=abc_throw((yyval.code));
5749 /* Line 1464 of skeleton.m4 */
5750 #line 2517 "parser.y"
5753 if(state->method->has_exceptions) {
5754 int v = alloc_local();
5755 state->method->scope_code = abc_getlocal(state->method->scope_code, v);
5756 state->method->scope_code = abc_pushwith(state->method->scope_code);
5757 (yyval.value_list).number = v;
5759 (yyval.value_list).cc = (yyvsp[(3) - (4)].value).c;
5769 /* Line 1464 of skeleton.m4 */
5770 #line 2527 "parser.y"
5772 /* remove getlocal;pushwith from scope code again */
5773 state->method->scope_code = code_cutlast(code_cutlast(state->method->scope_code));
5775 (yyval.code) = (yyvsp[(1) - (2)].value_list).cc;
5776 if(state->method->has_exceptions) {
5777 (yyval.code) = abc_dup((yyval.code));
5778 (yyval.code) = abc_setlocal((yyval.code), (yyvsp[(1) - (2)].value_list).number);
5780 (yyval.code) = abc_pushwith((yyval.code));
5781 (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (2)].code));
5782 (yyval.code) = abc_popscope((yyval.code));
5793 /* Line 1464 of skeleton.m4 */
5794 #line 2545 "parser.y"
5795 {PASS12 (yyval.id)="package";}
5804 /* Line 1464 of skeleton.m4 */
5805 #line 2546 "parser.y"
5806 {PASS12 (yyval.id)="namespace";}
5815 /* Line 1464 of skeleton.m4 */
5816 #line 2547 "parser.y"
5817 {PASS12 (yyval.id)="NaN";}
5826 /* Line 1464 of skeleton.m4 */
5827 #line 2549 "parser.y"
5828 {PASS12 (yyval.id) = concat3((yyvsp[(1) - (3)].id),".",(yyvsp[(3) - (3)].id));free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;}
5837 /* Line 1464 of skeleton.m4 */
5838 #line 2550 "parser.y"
5839 {PASS12 (yyval.id)=strdup((yyvsp[(1) - (1)].id));}
5848 /* Line 1464 of skeleton.m4 */
5849 #line 2552 "parser.y"
5850 {PASS12 startpackage((yyvsp[(2) - (3)].id));free((yyvsp[(2) - (3)].id));(yyvsp[(2) - (3)].id)=0;}
5859 /* Line 1464 of skeleton.m4 */
5860 #line 2553 "parser.y"
5861 {PASS12 endpackage();(yyval.code)=0;}
5870 /* Line 1464 of skeleton.m4 */
5871 #line 2554 "parser.y"
5872 {PASS12 startpackage("");}
5881 /* Line 1464 of skeleton.m4 */
5882 #line 2555 "parser.y"
5883 {PASS12 endpackage();(yyval.code)=0;}
5892 /* Line 1464 of skeleton.m4 */
5893 #line 2578 "parser.y"
5896 slotinfo_t*s = registry_find(state->package, (yyvsp[(2) - (2)].id));
5897 if(!s && as3_pass==1) {as3_schedule_class(state->package, (yyvsp[(2) - (2)].id));}
5898 state_has_imports();
5899 dict_put(state->imports, state->package, (yyvsp[(2) - (2)].id));
5910 /* Line 1464 of skeleton.m4 */
5911 #line 2586 "parser.y"
5914 slotinfo_t*s = registry_find((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);
5915 if(!s && as3_pass==1) {
5916 as3_schedule_class((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);
5918 /*if(s && s->kind == INFOTYPE_VAR && TYPE_IS_NAMESPACE(s->type)) {
5919 trie_put(active_namespaces, (unsigned char*)$2->name, 0);
5921 state_has_imports();
5922 dict_put(state->imports, (yyvsp[(2) - (2)].classinfo)->name, (yyvsp[(2) - (2)].classinfo));
5923 import_toplevel((yyvsp[(2) - (2)].classinfo)->package);
5934 /* Line 1464 of skeleton.m4 */
5935 #line 2600 "parser.y"
5938 if(strncmp("flash.", (yyvsp[(2) - (4)].id), 6) && as3_pass==1) {
5939 as3_schedule_package((yyvsp[(2) - (4)].id));
5943 i->package = (yyvsp[(2) - (4)].id);
5944 state_has_imports();
5945 list_append(state->wildcard_imports, i);
5946 import_toplevel(i->package);
5957 /* Line 1464 of skeleton.m4 */
5958 #line 2616 "parser.y"
5959 {PASS12 (yyval.flags).flags=0;(yyval.flags).ns=0;}
5968 /* Line 1464 of skeleton.m4 */
5969 #line 2617 "parser.y"
5970 {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}
5979 /* Line 1464 of skeleton.m4 */
5980 #line 2618 "parser.y"
5981 {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}
5990 /* Line 1464 of skeleton.m4 */
5991 #line 2619 "parser.y"
5994 (yyval.flags).flags=(yyvsp[(1) - (2)].flags).flags|(yyvsp[(2) - (2)].flags).flags;
5995 if((yyvsp[(1) - (2)].flags).ns && (yyvsp[(2) - (2)].flags).ns) syntaxerror("only one namespace allowed in one declaration");
5996 (yyval.flags).ns=(yyvsp[(1) - (2)].flags).ns?(yyvsp[(1) - (2)].flags).ns:(yyvsp[(2) - (2)].flags).ns;
6007 /* Line 1464 of skeleton.m4 */
6008 #line 2626 "parser.y"
6009 {PASS12 (yyval.flags).flags=FLAG_PUBLIC;(yyval.flags).ns=0;}
6018 /* Line 1464 of skeleton.m4 */
6019 #line 2627 "parser.y"
6020 {PASS12 (yyval.flags).flags=FLAG_PRIVATE;(yyval.flags).ns=0;}
6029 /* Line 1464 of skeleton.m4 */
6030 #line 2628 "parser.y"
6031 {PASS12 (yyval.flags).flags=FLAG_PROTECTED;(yyval.flags).ns=0;}
6040 /* Line 1464 of skeleton.m4 */
6041 #line 2629 "parser.y"
6042 {PASS12 (yyval.flags).flags=FLAG_STATIC;(yyval.flags).ns=0;}
6051 /* Line 1464 of skeleton.m4 */
6052 #line 2630 "parser.y"
6053 {PASS12 (yyval.flags).flags=FLAG_DYNAMIC;(yyval.flags).ns=0;}
6062 /* Line 1464 of skeleton.m4 */
6063 #line 2631 "parser.y"
6064 {PASS12 (yyval.flags).flags=FLAG_FINAL;(yyval.flags).ns=0;}
6073 /* Line 1464 of skeleton.m4 */
6074 #line 2632 "parser.y"
6075 {PASS12 (yyval.flags).flags=FLAG_OVERRIDE;(yyval.flags).ns=0;}
6084 /* Line 1464 of skeleton.m4 */
6085 #line 2633 "parser.y"
6086 {PASS12 (yyval.flags).flags=FLAG_NATIVE;(yyval.flags).ns=0;}
6095 /* Line 1464 of skeleton.m4 */
6096 #line 2634 "parser.y"
6097 {PASS12 (yyval.flags).flags=FLAG_PACKAGEINTERNAL;(yyval.flags).ns=0;}
6106 /* Line 1464 of skeleton.m4 */
6107 #line 2635 "parser.y"
6108 {PASS12 (yyval.flags).flags=FLAG_NAMESPACE;
6109 (yyval.flags).ns=(yyvsp[(1) - (1)].id);
6119 /* Line 1464 of skeleton.m4 */
6120 #line 2639 "parser.y"
6121 {PASS12 (yyval.classinfo)=0;}
6130 /* Line 1464 of skeleton.m4 */
6131 #line 2640 "parser.y"
6132 {PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
6141 /* Line 1464 of skeleton.m4 */
6142 #line 2642 "parser.y"
6143 {PASS12 (yyval.classinfo_list)=list_new();}
6152 /* Line 1464 of skeleton.m4 */
6153 #line 2643 "parser.y"
6154 {PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
6163 /* Line 1464 of skeleton.m4 */
6164 #line 2645 "parser.y"
6165 {PASS12 (yyval.classinfo_list)=list_new();}
6174 /* Line 1464 of skeleton.m4 */
6175 #line 2646 "parser.y"
6176 {PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
6185 /* Line 1464 of skeleton.m4 */
6186 #line 2650 "parser.y"
6187 {PASS12 startclass(&(yyvsp[(1) - (6)].flags),(yyvsp[(3) - (6)].id),(yyvsp[(4) - (6)].classinfo),(yyvsp[(5) - (6)].classinfo_list));}
6196 /* Line 1464 of skeleton.m4 */
6197 #line 2652 "parser.y"
6198 {PASS12 endclass();(yyval.code)=0;}
6207 /* Line 1464 of skeleton.m4 */
6208 #line 2656 "parser.y"
6209 {PASS12 (yyvsp[(1) - (5)].flags).flags|=FLAG_INTERFACE;
6210 startclass(&(yyvsp[(1) - (5)].flags),(yyvsp[(3) - (5)].id),0,(yyvsp[(4) - (5)].classinfo_list));}
6219 /* Line 1464 of skeleton.m4 */
6220 #line 2659 "parser.y"
6221 {PASS12 endclass();(yyval.code)=0;}
6230 /* Line 1464 of skeleton.m4 */
6231 #line 2668 "parser.y"
6232 {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
6241 /* Line 1464 of skeleton.m4 */
6242 #line 2671 "parser.y"
6243 {PASS_ALWAYS as3_pass=(yyvsp[(2) - (4)].number_int);PASS1 as3_warning("embed command ignored");}
6252 /* Line 1464 of skeleton.m4 */
6253 #line 2673 "parser.y"
6255 code_t*c = state->cls->static_init->header;
6256 c = code_append(c, (yyvsp[(1) - (1)].code));
6257 state->cls->static_init->header = c;
6267 /* Line 1464 of skeleton.m4 */
6268 #line 2684 "parser.y"
6270 syntaxerror("variable declarations not allowed in interfaces");
6280 /* Line 1464 of skeleton.m4 */
6281 #line 2687 "parser.y"
6284 (yyvsp[(1) - (8)].flags).flags |= FLAG_PUBLIC;
6285 if((yyvsp[(1) - (8)].flags).flags&(FLAG_PRIVATE|FLAG_PACKAGEINTERNAL|FLAG_PROTECTED)) {
6286 syntaxerror("invalid method modifiers: interface methods always need to be public");
6288 startfunction(&(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo));
6289 endfunction(&(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo), 0);
6290 list_deep_free((yyvsp[(6) - (8)].params).list);
6300 /* Line 1464 of skeleton.m4 */
6301 #line 2762 "parser.y"
6302 {PASS12 setslotstate(&(yyvsp[(1) - (2)].flags),(yyvsp[(2) - (2)].token));}
6311 /* Line 1464 of skeleton.m4 */
6312 #line 2762 "parser.y"
6313 {PASS12 (yyval.code)=(yyvsp[(4) - (4)].code);setslotstate(0, 0);}
6322 /* Line 1464 of skeleton.m4 */
6323 #line 2764 "parser.y"
6324 {PASS12 (yyval.code)=0;}
6333 /* Line 1464 of skeleton.m4 */
6334 #line 2765 "parser.y"
6335 {PASS12 (yyval.code)=0;}
6344 /* Line 1464 of skeleton.m4 */
6345 #line 2768 "parser.y"
6348 int flags = slotstate_flags->flags;
6349 namespace_t ns = modifiers2access(slotstate_flags);
6353 varinfo_t* info = 0;
6355 memberinfo_t*i = registry_findmember(state->cls->info, ns.name, (yyvsp[(1) - (3)].id), 1, slotstate_flags->flags&FLAG_STATIC);
6357 check_override(i, flags);
6359 info = varinfo_register_onclass(state->cls->info, ns.access, ns.name, (yyvsp[(1) - (3)].id), slotstate_flags->flags&FLAG_STATIC);
6361 slotinfo_t*i = registry_find(state->package, (yyvsp[(1) - (3)].id));
6363 syntaxerror("package %s already contains '%s'", state->package, (yyvsp[(1) - (3)].id));
6365 if(ns.name && ns.name[0]) {
6366 syntaxerror("namespaces not allowed on package-level variables");
6368 info = varinfo_register_global(ns.access, state->package, (yyvsp[(1) - (3)].id));
6371 info->type = (yyvsp[(2) - (3)].classinfo);
6372 info->flags = flags;
6374 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, info);
6378 varinfo_t*info = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
6382 trait_t*t = add_abc_slot(slotstate_flags, (yyvsp[(1) - (3)].id), &mname, &code);
6384 if((yyvsp[(2) - (3)].classinfo)) {
6385 MULTINAME(m, (yyvsp[(2) - (3)].classinfo));
6386 t->type_name = multiname_clone(&m);
6388 info->slot = t->slot_id;
6390 /* workaround for "VerifyError: Error #1053: Illegal override of ::test2 in C1"
6391 FIXME: is there a way to use slots and still don't have conflicting overrides?
6393 info->slot = t->slot_id = 0;
6395 constant_t cval = (yyvsp[(3) - (3)].node)->type->eval((yyvsp[(3) - (3)].node));
6396 if(cval.type!=CONSTANT_UNKNOWN) {
6397 /* compile time constant */
6398 t->value = malloc(sizeof(constant_t));
6399 memcpy(t->value, &cval, sizeof(constant_t));
6400 info->value = constant_clone(t->value);
6402 typedcode_t v = node_read((yyvsp[(3) - (3)].node));
6403 /* initalization code (if needed) */
6405 if(v.c && !is_pushundefined(v.c)) {
6406 c = abc_getlocal_0(c);
6407 c = code_append(c, v.c);
6408 c = converttype(c, v.t, (yyvsp[(2) - (3)].classinfo));
6410 c = abc_initproperty2(c, &mname);
6412 c = abc_setslot(c, t->slot_id);
6415 *code = code_append(*code, c);
6418 if(slotstate_varconst==KW_CONST) {
6419 t->kind= TRAIT_CONST;
6420 info->flags |= FLAG_CONST;
6434 /* Line 1464 of skeleton.m4 */
6435 #line 2851 "parser.y"
6436 {(yyval.constant)=0;}
6445 /* Line 1464 of skeleton.m4 */
6446 #line 2852 "parser.y"
6448 (yyval.constant) = malloc(sizeof(constant_t));
6449 *(yyval.constant) = node_eval((yyvsp[(2) - (2)].node));
6450 if((yyval.constant)->type == CONSTANT_UNKNOWN) {
6451 syntaxerror("can't evaluate default parameter value (needs to be a compile-time constant)");
6462 /* Line 1464 of skeleton.m4 */
6463 #line 2860 "parser.y"
6464 {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_int));}
6473 /* Line 1464 of skeleton.m4 */
6474 #line 2861 "parser.y"
6476 (yyval.constant) = constant_new_uint((yyvsp[(1) - (1)].number_uint));
6486 /* Line 1464 of skeleton.m4 */
6487 #line 2864 "parser.y"
6488 {(yyval.constant) = constant_new_float((yyvsp[(1) - (1)].number_float));}
6497 /* Line 1464 of skeleton.m4 */
6498 #line 2865 "parser.y"
6499 {(yyval.constant) = constant_new_string2((yyvsp[(1) - (1)].str).str,(yyvsp[(1) - (1)].str).len);free((char*)(yyvsp[(1) - (1)].str).str);}
6508 /* Line 1464 of skeleton.m4 */
6509 #line 2866 "parser.y"
6510 {(yyval.constant) = constant_new_true((yyvsp[(1) - (1)].token));}
6519 /* Line 1464 of skeleton.m4 */
6520 #line 2867 "parser.y"
6521 {(yyval.constant) = constant_new_false((yyvsp[(1) - (1)].token));}
6530 /* Line 1464 of skeleton.m4 */
6531 #line 2868 "parser.y"
6532 {(yyval.constant) = constant_new_null((yyvsp[(1) - (1)].token));}
6541 /* Line 1464 of skeleton.m4 */
6542 #line 2869 "parser.y"
6543 {(yyval.constant) = constant_new_undefined((yyvsp[(1) - (1)].token));}
6552 /* Line 1464 of skeleton.m4 */
6553 #line 2870 "parser.y"
6554 {(yyval.constant) = constant_new_float(__builtin_nan(""));}
6563 /* Line 1464 of skeleton.m4 */
6564 #line 2878 "parser.y"
6566 multiname_t m = {QNAME, &stdns, 0, "XML"};
6569 v.c = abc_getlex2(v.c, &m);
6570 v.c = code_append(v.c, node_read((yyvsp[(1) - (1)].node)).c);
6571 v.c = abc_construct(v.c, 1);
6573 (yyval.node) = mkcodenode(v);
6583 /* Line 1464 of skeleton.m4 */
6584 #line 2889 "parser.y"
6585 {PASS_ALWAYS if(!xml_level++) tokenizer_begin_xml();}
6594 /* Line 1464 of skeleton.m4 */
6595 #line 2890 "parser.y"
6596 {PASS_ALWAYS tokenizer_begin_xmltext();}
6605 /* Line 1464 of skeleton.m4 */
6606 #line 2891 "parser.y"
6607 {PASS_ALWAYS if(!--xml_level) tokenizer_end_xml(); else tokenizer_begin_xmltext();}
6616 /* Line 1464 of skeleton.m4 */
6617 #line 2893 "parser.y"
6618 {PASS_ALWAYS tokenizer_begin_xmltext();}
6627 /* Line 1464 of skeleton.m4 */
6628 #line 2893 "parser.y"
6630 (yyval.node) = (yyvsp[(2) - (4)].node);
6640 /* Line 1464 of skeleton.m4 */
6641 #line 2896 "parser.y"
6642 {PASS_ALWAYS tokenizer_begin_xml();}
6651 /* Line 1464 of skeleton.m4 */
6652 #line 2896 "parser.y"
6654 (yyval.node) = (yyvsp[(2) - (4)].node);
6664 /* Line 1464 of skeleton.m4 */
6665 #line 2899 "parser.y"
6666 {(yyval.node)=mkstringnode("");}
6675 /* Line 1464 of skeleton.m4 */
6676 #line 2900 "parser.y"
6678 (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node));
6688 /* Line 1464 of skeleton.m4 */
6689 #line 2903 "parser.y"
6691 char* str = string_cstr(&(yyvsp[(2) - (2)].str));
6692 (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),mkstringnode(str));
6703 /* Line 1464 of skeleton.m4 */
6704 #line 2908 "parser.y"
6706 (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node), mkstringnode(">"));
6716 /* Line 1464 of skeleton.m4 */
6717 #line 2911 "parser.y"
6719 (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node));
6729 /* Line 1464 of skeleton.m4 */
6730 #line 2914 "parser.y"
6732 (yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkaddnode((yyvsp[(2) - (3)].node),(yyvsp[(3) - (3)].node)));
6742 /* Line 1464 of skeleton.m4 */
6743 #line 2917 "parser.y"
6745 (yyval.node) = mkstringnode((yyvsp[(1) - (1)].id));
6755 /* Line 1464 of skeleton.m4 */
6756 #line 2920 "parser.y"
6758 (yyval.node) = (yyvsp[(1) - (1)].node);
6768 /* Line 1464 of skeleton.m4 */
6769 #line 2924 "parser.y"
6771 (yyval.node) = mkstringnode("");
6781 /* Line 1464 of skeleton.m4 */
6782 #line 2927 "parser.y"
6784 (yyval.node) = mkaddnode(mkstringnode(" "),(yyvsp[(1) - (1)].node));
6794 /* Line 1464 of skeleton.m4 */
6795 #line 2931 "parser.y"
6797 //$$ = allocprintf("<%s%s/>", $2, $3, $5, $8);
6798 (yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkstringnode("<"),(yyvsp[(2) - (6)].node)),(yyvsp[(3) - (6)].node)),mkstringnode("/>"));
6808 /* Line 1464 of skeleton.m4 */
6809 #line 2935 "parser.y"
6811 //$$ = allocprintf("<%s%s>%s</%s>", $2, $3, $5, $8);
6812 (yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(
6813 mkstringnode("<"),(yyvsp[(2) - (10)].node)),(yyvsp[(3) - (10)].node)),mkstringnode(">")),(yyvsp[(5) - (10)].node)),mkstringnode("</")),(yyvsp[(8) - (10)].node)),mkstringnode(">"));
6823 /* Line 1464 of skeleton.m4 */
6824 #line 2940 "parser.y"
6826 //$$ = allocprintf("<%s%s>%s%s</%s>", $2, $3, $5, $6, $9);
6827 (yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(
6828 mkstringnode("<"),(yyvsp[(2) - (11)].node)),(yyvsp[(3) - (11)].node)),mkstringnode(">")),(yyvsp[(5) - (11)].node)),(yyvsp[(6) - (11)].node)),mkstringnode("</")),(yyvsp[(9) - (11)].node)),mkstringnode(">"));
6838 /* Line 1464 of skeleton.m4 */
6839 #line 2946 "parser.y"
6841 (yyval.node) = (yyvsp[(1) - (1)].node);
6851 /* Line 1464 of skeleton.m4 */
6852 #line 2949 "parser.y"
6854 (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node), mkaddnode(mkstringnode(" "),(yyvsp[(2) - (2)].node)));
6864 /* Line 1464 of skeleton.m4 */
6865 #line 2952 "parser.y"
6867 (yyval.node) = (yyvsp[(1) - (1)].node);
6877 /* Line 1464 of skeleton.m4 */
6878 #line 2955 "parser.y"
6880 char* str = string_cstr(&(yyvsp[(3) - (3)].str));
6881 (yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkstringnode(concat2("=",str)));
6892 /* Line 1464 of skeleton.m4 */
6893 #line 2960 "parser.y"
6895 (yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkaddnode(mkstringnode("=\""), mkaddnode((yyvsp[(3) - (3)].node), mkstringnode("\""))));
6905 /* Line 1464 of skeleton.m4 */
6906 #line 2963 "parser.y"
6908 (yyval.node) = mkaddnode(mkaddnode(mkstringnode(concat2((yyvsp[(1) - (3)].id),"=\"")), (yyvsp[(3) - (3)].node)), mkstringnode("\""));
6918 /* Line 1464 of skeleton.m4 */
6919 #line 2966 "parser.y"
6921 char* str = string_cstr(&(yyvsp[(3) - (3)].str));
6922 (yyval.node)=mkstringnode(allocprintf("%s=%s", (yyvsp[(1) - (3)].id),str));
6924 free((yyvsp[(1) - (3)].id));free((char*)(yyvsp[(3) - (3)].str).str);
6934 /* Line 1464 of skeleton.m4 */
6935 #line 2976 "parser.y"
6938 memset(&(yyval.params),0,sizeof((yyval.params)));
6948 /* Line 1464 of skeleton.m4 */
6949 #line 2980 "parser.y"
6952 (yyval.params)=(yyvsp[(1) - (1)].params);
6962 /* Line 1464 of skeleton.m4 */
6963 #line 2986 "parser.y"
6966 memset(&(yyval.params),0,sizeof((yyval.params)));
6967 (yyval.params).varargs=1;
6968 list_append((yyval.params).list, (yyvsp[(2) - (2)].param));
6978 /* Line 1464 of skeleton.m4 */
6979 #line 2992 "parser.y"
6982 (yyval.params) =(yyvsp[(1) - (4)].params);
6983 (yyval.params).varargs=1;
6984 list_append((yyval.params).list, (yyvsp[(4) - (4)].param));
6994 /* Line 1464 of skeleton.m4 */
6995 #line 3000 "parser.y"
6998 (yyval.params) = (yyvsp[(1) - (3)].params);
6999 list_append((yyval.params).list, (yyvsp[(3) - (3)].param));
7009 /* Line 1464 of skeleton.m4 */
7010 #line 3005 "parser.y"
7013 memset(&(yyval.params),0,sizeof((yyval.params)));
7014 list_append((yyval.params).list, (yyvsp[(1) - (1)].param));
7024 /* Line 1464 of skeleton.m4 */
7025 #line 3011 "parser.y"
7028 (yyval.param) = rfx_calloc(sizeof(param_t));
7029 (yyval.param)->name=(yyvsp[(1) - (4)].id);
7030 (yyval.param)->type = (yyvsp[(3) - (4)].classinfo);
7032 (yyval.param)->value = (yyvsp[(4) - (4)].constant);
7042 /* Line 1464 of skeleton.m4 */
7043 #line 3019 "parser.y"
7046 (yyval.param) = rfx_calloc(sizeof(param_t));
7047 (yyval.param)->name=(yyvsp[(1) - (2)].id);
7048 (yyval.param)->type = TYPE_ANY;
7050 (yyval.param)->value = (yyvsp[(2) - (2)].constant);
7060 /* Line 1464 of skeleton.m4 */
7061 #line 3029 "parser.y"
7062 {PASS12 (yyval.token)=0;}
7071 /* Line 1464 of skeleton.m4 */
7072 #line 3032 "parser.y"
7073 {PASS12 startfunction(&(yyvsp[(1) - (9)].flags),(yyvsp[(3) - (9)].token),(yyvsp[(4) - (9)].id),&(yyvsp[(6) - (9)].params),(yyvsp[(8) - (9)].classinfo));}
7082 /* Line 1464 of skeleton.m4 */
7083 #line 3033 "parser.y"
7086 endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),0,0);
7088 if(!state->method->info) syntaxerror("internal error");
7090 code_t*c = method_header(state->method);
7091 c = wrap_function(c, 0, (yyvsp[(11) - (12)].code));
7093 endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),(yyvsp[(8) - (12)].classinfo),c);
7095 list_deep_free((yyvsp[(6) - (12)].params).list);
7106 /* Line 1464 of skeleton.m4 */
7107 #line 3049 "parser.y"
7108 {PASS12 (yyval.id)=0;}
7117 /* Line 1464 of skeleton.m4 */
7118 #line 3051 "parser.y"
7119 {PASS12 innerfunction((yyvsp[(2) - (7)].id),&(yyvsp[(4) - (7)].params),(yyvsp[(6) - (7)].classinfo));}
7128 /* Line 1464 of skeleton.m4 */
7129 #line 3052 "parser.y"
7132 endfunction(0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),0,0);
7134 methodinfo_t*f = state->method->info;
7135 if(!f || !f->kind) syntaxerror("internal error");
7137 code_t*c = method_header(state->method);
7138 c = wrap_function(c, 0, (yyvsp[(9) - (10)].code));
7140 int index = state->method->var_index;
7141 endfunction(0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),(yyvsp[(6) - (10)].classinfo),c);
7143 (yyval.value).c = abc_getlocal(0, index);
7144 (yyval.value).t = TYPE_FUNCTION(f);
7146 PASS12 list_deep_free((yyvsp[(4) - (10)].params).list);
7156 /* Line 1464 of skeleton.m4 */
7157 #line 3074 "parser.y"
7159 PASS1 NEW(unresolvedinfo_t,c);
7160 memset(c, 0, sizeof(*c));
7161 c->kind = INFOTYPE_UNRESOLVED;
7162 c->name = (yyvsp[(1) - (1)].id);
7163 c->package = get_package_from_name((yyvsp[(1) - (1)].id));
7165 c->nsset = get_current_imports();
7166 /* make the compiler look for this class in the current directory,
7168 as3_schedule_class_noerror(state->package, (yyvsp[(1) - (1)].id));
7170 (yyval.classinfo) = (classinfo_t*)c;
7172 slotinfo_t*s = find_class((yyvsp[(1) - (1)].id));
7173 if(!s) syntaxerror("Could not find class/method %s (current package: %s)\n", (yyvsp[(1) - (1)].id), state->package);
7174 (yyval.classinfo) = (classinfo_t*)s;
7185 /* Line 1464 of skeleton.m4 */
7186 #line 3094 "parser.y"
7188 PASS1 NEW(unresolvedinfo_t,c);
7189 memset(c, 0, sizeof(*c));
7190 c->kind = INFOTYPE_UNRESOLVED;
7191 c->package = (yyvsp[(1) - (3)].id);
7192 c->name = (yyvsp[(3) - (3)].id);
7193 (yyval.classinfo) = (classinfo_t*)c;
7195 slotinfo_t*s = registry_find((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
7196 if(!s) syntaxerror("Couldn't find class/method %s.%s\n", (yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
7197 free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;
7198 (yyval.classinfo) = (classinfo_t*)s;
7209 /* Line 1464 of skeleton.m4 */
7210 #line 3112 "parser.y"
7211 {PASS12 (yyval.classinfo_list)=list_new();list_append((yyval.classinfo_list), (yyvsp[(1) - (1)].classinfo));}
7220 /* Line 1464 of skeleton.m4 */
7221 #line 3113 "parser.y"
7222 {PASS12 (yyval.classinfo_list)=(yyvsp[(1) - (3)].classinfo_list);list_append((yyval.classinfo_list),(yyvsp[(3) - (3)].classinfo));}
7231 /* Line 1464 of skeleton.m4 */
7232 #line 3115 "parser.y"
7233 {PASS12 (yyval.classinfo)=(yyvsp[(1) - (1)].classinfo);}
7242 /* Line 1464 of skeleton.m4 */
7243 #line 3116 "parser.y"
7244 {PASS12 (yyval.classinfo)=TYPE_ANY;}
7253 /* Line 1464 of skeleton.m4 */
7254 #line 3117 "parser.y"
7255 {PASS12 (yyval.classinfo)=TYPE_VOID;}
7264 /* Line 1464 of skeleton.m4 */
7265 #line 3126 "parser.y"
7266 {PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
7275 /* Line 1464 of skeleton.m4 */
7276 #line 3127 "parser.y"
7277 {PASS12 (yyval.classinfo)=0;}
7286 /* Line 1464 of skeleton.m4 */
7287 #line 3131 "parser.y"
7288 {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
7297 /* Line 1464 of skeleton.m4 */
7298 #line 3132 "parser.y"
7299 {(yyval.value_list)=(yyvsp[(2) - (3)].value_list);}
7308 /* Line 1464 of skeleton.m4 */
7309 #line 3134 "parser.y"
7310 {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
7319 /* Line 1464 of skeleton.m4 */
7320 #line 3138 "parser.y"
7321 {(yyval.value_list).number=1;
7322 (yyval.value_list).cc = (yyvsp[(1) - (1)].value).c;
7332 /* Line 1464 of skeleton.m4 */
7333 #line 3142 "parser.y"
7334 {(yyval.value_list) = (yyvsp[(1) - (2)].value_list);}
7343 /* Line 1464 of skeleton.m4 */
7344 #line 3143 "parser.y"
7346 (yyval.value_list).number= (yyvsp[(1) - (2)].value_list).number+1;
7347 (yyval.value_list).cc = code_append((yyvsp[(1) - (2)].value_list).cc, (yyvsp[(2) - (2)].value).c);
7357 /* Line 1464 of skeleton.m4 */
7358 #line 3149 "parser.y"
7360 typedcode_t v = node_read((yyvsp[(2) - (4)].node));
7361 (yyval.value).c = v.c;
7362 if((yyval.value).c->opcode == OPCODE_COERCE_A) (yyval.value).c = code_cutlast((yyval.value).c);
7364 code_t*paramcode = (yyvsp[(4) - (4)].value_list).cc;
7365 if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
7366 multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
7367 (yyval.value).c = code_cutlast((yyval.value).c);
7368 (yyval.value).c = code_append((yyval.value).c, paramcode);
7369 (yyval.value).c = abc_constructprop2((yyval.value).c, name, (yyvsp[(4) - (4)].value_list).number);
7370 multiname_destroy(name);
7371 } else if(is_getlocal((yyval.value).c)) {
7372 (yyval.value).c = code_append((yyval.value).c, paramcode);
7373 (yyval.value).c = abc_construct((yyval.value).c, (yyvsp[(4) - (4)].value_list).number);
7374 } else if(TYPE_IS_CLASS(v.t) && v.t->data) {
7375 code_free((yyval.value).c);
7376 classinfo_t*c = v.t->data;
7378 (yyval.value).c = abc_findpropstrict2(0, &m);
7379 (yyval.value).c = code_append((yyval.value).c, paramcode);
7380 (yyval.value).c = abc_constructprop2((yyval.value).c, &m, (yyvsp[(4) - (4)].value_list).number);
7381 /*} else if($$.c->opcode == OPCODE_GETSLOT) {
7382 int slot = (int)(ptroff_t)$$.c->data[0];
7383 trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);//FIXME
7384 multiname_t*name = t->name;
7385 $$.c = code_cutlast($$.c);
7386 $$.c = code_append($$.c, paramcode);
7387 $$.c = abc_constructprop2($$.c, name, $4.number);*/
7389 (yyval.value).c = code_append((yyval.value).c, paramcode);
7390 (yyval.value).c = abc_construct((yyval.value).c, (yyvsp[(4) - (4)].value_list).number);
7393 (yyval.value).t = TYPE_ANY;
7394 if(TYPE_IS_CLASS(v.t) && v.t->data) {
7395 (yyval.value).t = v.t->data;
7397 (yyval.value).c = abc_coerce_a((yyval.value).c);
7398 (yyval.value).t = TYPE_ANY;
7409 /* Line 1464 of skeleton.m4 */
7410 #line 3196 "parser.y"
7413 typedcode_t v = node_read((yyvsp[(1) - (4)].node));
7414 (yyval.value).c = v.c;
7415 if((yyval.value).c->opcode == OPCODE_COERCE_A) {
7416 (yyval.value).c = code_cutlast((yyval.value).c);
7418 code_t*paramcode = (yyvsp[(3) - (4)].value_list).cc;
7420 (yyval.value).t = TYPE_ANY;
7421 if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
7422 multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
7423 (yyval.value).c = code_cutlast((yyval.value).c);
7424 (yyval.value).c = code_append((yyval.value).c, paramcode);
7425 (yyval.value).c = abc_callproperty2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);
7426 multiname_destroy(name);
7427 /* } else if($$.c->opcode == OPCODE_GETSLOT && $$.c->prev->opcode != OPCODE_GETSCOPEOBJECT) {
7428 int slot = (int)(ptroff_t)$$.c->data[0];
7429 trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);
7430 if(t->kind!=TRAIT_METHOD) {
7431 //ok: flash allows to assign closures to members.
7433 multiname_t*name = t->name;
7434 $$.c = code_cutlast($$.c);
7435 $$.c = code_append($$.c, paramcode);
7436 //$$.c = abc_callmethod($$.c, t->method, len); //#1051 illegal early access binding
7437 $$.c = abc_callproperty2($$.c, name, $3.number);*/
7438 } else if((yyval.value).c->opcode == OPCODE_GETSUPER) {
7439 multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
7440 (yyval.value).c = code_cutlast((yyval.value).c);
7441 (yyval.value).c = code_append((yyval.value).c, paramcode);
7442 (yyval.value).c = abc_callsuper2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);
7443 multiname_destroy(name);
7445 (yyval.value).c = abc_getglobalscope((yyval.value).c);
7446 (yyval.value).c = code_append((yyval.value).c, paramcode);
7447 (yyval.value).c = abc_call((yyval.value).c, (yyvsp[(3) - (4)].value_list).number);
7450 if(TYPE_IS_FUNCTION(v.t) && v.t->data) {
7451 (yyval.value).t = ((methodinfo_t*)(v.t->data))->return_type;
7452 } else if(TYPE_IS_CLASS(v.t) && v.t->data) {
7453 // calling a class is like a typecast
7454 (yyval.value).t = (classinfo_t*)v.t->data;
7456 (yyval.value).t = TYPE_ANY;
7457 (yyval.value).c = abc_coerce_a((yyval.value).c);
7468 /* Line 1464 of skeleton.m4 */
7469 #line 3246 "parser.y"
7471 if(!state->cls) syntaxerror("super() not allowed outside of a class");
7472 if(!state->method) syntaxerror("super() not allowed outside of a function");
7473 if(!state->method->is_constructor) syntaxerror("super() not allowed outside of a constructor");
7475 (yyval.value).c = code_new();
7476 (yyval.value).c = abc_getlocal_0((yyval.value).c);
7478 (yyval.value).c = code_append((yyval.value).c, (yyvsp[(3) - (4)].value_list).cc);
7480 this is dependent on the control path, check this somewhere else
7481 if(state->method->has_super)
7482 syntaxerror("constructor may call super() only once");
7484 state->method->has_super = 1;
7486 (yyval.value).c = abc_constructsuper((yyval.value).c, (yyvsp[(3) - (4)].value_list).number);
7487 (yyval.value).c = abc_pushundefined((yyval.value).c);
7488 (yyval.value).t = TYPE_ANY;
7498 /* Line 1464 of skeleton.m4 */
7499 #line 3267 "parser.y"
7501 typedcode_t v = node_read((yyvsp[(2) - (2)].node));
7502 (yyval.value).c = v.c;
7503 if((yyval.value).c->opcode == OPCODE_COERCE_A) {
7504 (yyval.value).c = code_cutlast((yyval.value).c);
7506 multiname_t*name = 0;
7507 if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
7508 (yyval.value).c->opcode = OPCODE_DELETEPROPERTY;
7509 } else if((yyval.value).c->opcode == OPCODE_GETSLOT) {
7510 int slot = (int)(ptroff_t)(yyval.value).c->data[0];
7511 multiname_t*name = traits_find_slotid(state->cls->abc->traits,slot)->name;
7512 (yyval.value).c = code_cutlast((yyval.value).c);
7513 (yyval.value).c = abc_deleteproperty2((yyval.value).c, name);
7515 (yyval.value).c = abc_getlocal_0((yyval.value).c);
7516 MULTINAME_LATE(m, v.t?v.t->access:ACCESS_PACKAGE, "");
7517 (yyval.value).c = abc_deleteproperty2((yyval.value).c, &m);
7519 (yyval.value).t = TYPE_BOOLEAN;
7529 /* Line 1464 of skeleton.m4 */
7530 #line 3289 "parser.y"
7532 (yyval.code) = abc_returnvoid(0);
7542 /* Line 1464 of skeleton.m4 */
7543 #line 3292 "parser.y"
7545 (yyval.code) = (yyvsp[(2) - (2)].value).c;
7546 (yyval.code) = abc_returnvalue((yyval.code));
7556 /* Line 1464 of skeleton.m4 */
7557 #line 3299 "parser.y"
7559 (yyval.value) = node_read((yyvsp[(1) - (1)].node));
7569 /* Line 1464 of skeleton.m4 */
7570 #line 3302 "parser.y"
7572 (yyval.value) = node_read((yyvsp[(1) - (1)].node));
7582 /* Line 1464 of skeleton.m4 */
7583 #line 3305 "parser.y"
7585 (yyval.node) = mkmultinode(&node_comma, (yyvsp[(1) - (1)].node));
7595 /* Line 1464 of skeleton.m4 */
7596 #line 3308 "parser.y"
7598 (yyval.node) = multinode_extend((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7608 /* Line 1464 of skeleton.m4 */
7609 #line 3311 "parser.y"
7611 (yyval.code) = node_exec((yyvsp[(1) - (1)].node));
7621 /* Line 1464 of skeleton.m4 */
7622 #line 3314 "parser.y"
7624 (yyval.code) = (yyvsp[(1) - (3)].code);
7625 (yyval.code) = code_append((yyval.code), node_exec((yyvsp[(3) - (3)].node)));
7635 /* Line 1464 of skeleton.m4 */
7636 #line 3319 "parser.y"
7637 {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
7646 /* Line 1464 of skeleton.m4 */
7647 #line 3320 "parser.y"
7648 {(yyval.value_list)=(yyvsp[(1) - (1)].value_list);}
7657 /* Line 1464 of skeleton.m4 */
7658 #line 3322 "parser.y"
7659 {(yyval.code)=abc_pushstring(0,(yyvsp[(1) - (1)].id));}
7668 /* Line 1464 of skeleton.m4 */
7669 #line 3323 "parser.y"
7670 {(yyval.code)=abc_pushstring2(0,&(yyvsp[(1) - (1)].str));}
7679 /* Line 1464 of skeleton.m4 */
7680 #line 3324 "parser.y"
7681 {syntaxerror("dictionary keys must be strings");}
7690 /* Line 1464 of skeleton.m4 */
7691 #line 3325 "parser.y"
7692 {syntaxerror("dictionary keys must be strings");}
7701 /* Line 1464 of skeleton.m4 */
7702 #line 3326 "parser.y"
7703 {syntaxerror("dictionary keys must be strings");}
7712 /* Line 1464 of skeleton.m4 */
7713 #line 3328 "parser.y"
7715 (yyval.value_list).cc = 0;
7716 (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(1) - (3)].code));
7717 (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (3)].value).c);
7718 (yyval.value_list).number = 2;
7728 /* Line 1464 of skeleton.m4 */
7729 #line 3334 "parser.y"
7731 (yyval.value_list).cc = (yyvsp[(1) - (5)].value_list).cc;
7732 (yyval.value_list).number = (yyvsp[(1) - (5)].value_list).number+2;
7733 (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (5)].code));
7734 (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(5) - (5)].value).c);
7744 /* Line 1464 of skeleton.m4 */
7745 #line 3343 "parser.y"
7746 {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
7755 /* Line 1464 of skeleton.m4 */
7756 #line 3344 "parser.y"
7757 {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
7766 /* Line 1464 of skeleton.m4 */
7767 #line 3345 "parser.y"
7768 {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
7777 /* Line 1464 of skeleton.m4 */
7778 #line 3346 "parser.y"
7779 {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
7788 /* Line 1464 of skeleton.m4 */
7789 #line 3347 "parser.y"
7790 {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
7799 /* Line 1464 of skeleton.m4 */
7800 #line 3348 "parser.y"
7801 {(yyval.node) = (yyvsp[(1) - (1)].node);}
7810 /* Line 1464 of skeleton.m4 */
7811 #line 3350 "parser.y"
7813 (yyval.node) = mkconstnode((yyvsp[(1) - (1)].constant));
7823 /* Line 1464 of skeleton.m4 */
7824 #line 3354 "parser.y"
7826 (yyval.node) = (yyvsp[(1) - (1)].node);
7836 /* Line 1464 of skeleton.m4 */
7837 #line 3359 "parser.y"
7841 multiname_t m = {QNAME, &stdns, 0, "RegExp"};
7842 if(!(yyvsp[(1) - (1)].regexp).options) {
7843 v.c = abc_getlex2(v.c, &m);
7844 v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).pattern);
7845 v.c = abc_construct(v.c, 1);
7847 v.c = abc_getlex2(v.c, &m);
7848 v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).pattern);
7849 v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).options);
7850 v.c = abc_construct(v.c, 2);
7853 (yyval.node) = mkcodenode(v);
7863 /* Line 1464 of skeleton.m4 */
7864 #line 3377 "parser.y"
7867 state->method->need_arguments = 1;
7870 v.c = abc_getlocal(0, state->method->need_arguments);
7872 (yyval.node) = mkcodenode(v);
7882 /* Line 1464 of skeleton.m4 */
7883 #line 3388 "parser.y"
7887 v.c = code_append(v.c, (yyvsp[(2) - (3)].value_list).cc);
7888 v.c = abc_newarray(v.c, (yyvsp[(2) - (3)].value_list).number);
7889 v.t = registry_getarrayclass();
7890 (yyval.node) = mkcodenode(v);
7900 /* Line 1464 of skeleton.m4 */
7901 #line 3398 "parser.y"
7905 v.c = code_append(v.c, (yyvsp[(2) - (3)].value_list).cc);
7906 v.c = abc_newobject(v.c, (yyvsp[(2) - (3)].value_list).number/2);
7907 v.t = registry_getobjectclass();
7908 (yyval.node) = mkcodenode(v);
7918 /* Line 1464 of skeleton.m4 */
7919 #line 3407 "parser.y"
7920 {(yyval.node) = mknode2(&node_lt,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7929 /* Line 1464 of skeleton.m4 */
7930 #line 3408 "parser.y"
7931 {(yyval.node) = mknode2(&node_gt,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7940 /* Line 1464 of skeleton.m4 */
7941 #line 3409 "parser.y"
7942 {(yyval.node) = mknode2(&node_le,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7951 /* Line 1464 of skeleton.m4 */
7952 #line 3410 "parser.y"
7953 {(yyval.node) = mknode2(&node_ge,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7962 /* Line 1464 of skeleton.m4 */
7963 #line 3411 "parser.y"
7964 {(yyval.node) = mknode2(&node_eqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7973 /* Line 1464 of skeleton.m4 */
7974 #line 3412 "parser.y"
7975 {(yyval.node) = mknode2(&node_eqeqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7984 /* Line 1464 of skeleton.m4 */
7985 #line 3413 "parser.y"
7986 {(yyval.node) = mknode2(&node_noteqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7995 /* Line 1464 of skeleton.m4 */
7996 #line 3414 "parser.y"
7997 {(yyval.node) = mknode2(&node_noteq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
8006 /* Line 1464 of skeleton.m4 */
8007 #line 3415 "parser.y"
8008 {(yyval.node) = mknode2(&node_oror,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
8017 /* Line 1464 of skeleton.m4 */
8018 #line 3416 "parser.y"
8019 {(yyval.node) = mknode2(&node_andand,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
8028 /* Line 1464 of skeleton.m4 */
8029 #line 3417 "parser.y"
8030 {(yyval.node) = mknode1(&node_not, (yyvsp[(2) - (2)].node));}
8039 /* Line 1464 of skeleton.m4 */
8040 #line 3418 "parser.y"
8041 {(yyval.node) = mknode1(&node_bitnot, (yyvsp[(2) - (2)].node));}
8050 /* Line 1464 of skeleton.m4 */
8051 #line 3419 "parser.y"
8052 {(yyval.node) = mknode2(&node_bitand, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8061 /* Line 1464 of skeleton.m4 */
8062 #line 3420 "parser.y"
8063 {(yyval.node) = mknode2(&node_bitxor, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8072 /* Line 1464 of skeleton.m4 */
8073 #line 3421 "parser.y"
8074 {(yyval.node) = mknode2(&node_bitor, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8083 /* Line 1464 of skeleton.m4 */
8084 #line 3422 "parser.y"
8085 {(yyval.node) = mknode2(&node_shr, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8094 /* Line 1464 of skeleton.m4 */
8095 #line 3423 "parser.y"
8096 {(yyval.node) = mknode2(&node_ushr, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8105 /* Line 1464 of skeleton.m4 */
8106 #line 3424 "parser.y"
8107 {(yyval.node) = mknode2(&node_shl, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8116 /* Line 1464 of skeleton.m4 */
8117 #line 3425 "parser.y"
8118 {(yyval.node) = mknode2(&node_div, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8127 /* Line 1464 of skeleton.m4 */
8128 #line 3426 "parser.y"
8129 {(yyval.node) = mknode2(&node_mod, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8138 /* Line 1464 of skeleton.m4 */
8139 #line 3427 "parser.y"
8140 {(yyval.node) = mknode2(&node_plus, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8149 /* Line 1464 of skeleton.m4 */
8150 #line 3428 "parser.y"
8151 {(yyval.node) = mknode2(&node_minus, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8160 /* Line 1464 of skeleton.m4 */
8161 #line 3429 "parser.y"
8162 {(yyval.node) = mknode2(&node_multiply, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8171 /* Line 1464 of skeleton.m4 */
8172 #line 3430 "parser.y"
8173 {(yyval.node) = mknode2(&node_in, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8182 /* Line 1464 of skeleton.m4 */
8183 #line 3431 "parser.y"
8184 {(yyval.node) = mknode2(&node_as, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8193 /* Line 1464 of skeleton.m4 */
8194 #line 3432 "parser.y"
8195 {(yyval.node) = mknode2(&node_instanceof, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8204 /* Line 1464 of skeleton.m4 */
8205 #line 3433 "parser.y"
8206 {(yyval.node) = mknode2(&node_is, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8215 /* Line 1464 of skeleton.m4 */
8216 #line 3434 "parser.y"
8217 {(yyval.node) = mknode1(&node_typeof, (yyvsp[(2) - (2)].node));}
8226 /* Line 1464 of skeleton.m4 */
8227 #line 3435 "parser.y"
8228 {(yyval.node) = mknode1(&node_void, (yyvsp[(2) - (2)].node));}
8237 /* Line 1464 of skeleton.m4 */
8238 #line 3436 "parser.y"
8239 { (yyval.node) = mkconstnode(constant_new_undefined());}
8248 /* Line 1464 of skeleton.m4 */
8249 #line 3437 "parser.y"
8250 { (yyval.node)=(yyvsp[(2) - (3)].node);}
8259 /* Line 1464 of skeleton.m4 */
8260 #line 3438 "parser.y"
8261 {(yyval.node) = mknode1(&node_neg, (yyvsp[(2) - (2)].node));}
8270 /* Line 1464 of skeleton.m4 */
8271 #line 3439 "parser.y"
8272 {(yyval.node) = mknode2(&node_arraylookup, (yyvsp[(1) - (4)].node),(yyvsp[(3) - (4)].node));}
8281 /* Line 1464 of skeleton.m4 */
8282 #line 3440 "parser.y"
8283 {(yyval.node) = mknode2(&node_muleq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8292 /* Line 1464 of skeleton.m4 */
8293 #line 3441 "parser.y"
8294 {(yyval.node) = mknode2(&node_modeq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8303 /* Line 1464 of skeleton.m4 */
8304 #line 3442 "parser.y"
8305 {(yyval.node) = mknode2(&node_shleq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8314 /* Line 1464 of skeleton.m4 */
8315 #line 3443 "parser.y"
8316 {(yyval.node) = mknode2(&node_shreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8325 /* Line 1464 of skeleton.m4 */
8326 #line 3444 "parser.y"
8327 {(yyval.node) = mknode2(&node_ushreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8336 /* Line 1464 of skeleton.m4 */
8337 #line 3445 "parser.y"
8338 { (yyval.node) = mknode2(&node_diveq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8347 /* Line 1464 of skeleton.m4 */
8348 #line 3446 "parser.y"
8349 { (yyval.node) = mknode2(&node_bitoreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8358 /* Line 1464 of skeleton.m4 */
8359 #line 3447 "parser.y"
8360 { (yyval.node) = mknode2(&node_bitxoreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8369 /* Line 1464 of skeleton.m4 */
8370 #line 3448 "parser.y"
8371 { (yyval.node) = mknode2(&node_bitandeq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8380 /* Line 1464 of skeleton.m4 */
8381 #line 3449 "parser.y"
8382 { (yyval.node) = mknode2(&node_pluseq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8391 /* Line 1464 of skeleton.m4 */
8392 #line 3450 "parser.y"
8393 { (yyval.node) = mknode2(&node_minuseq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8402 /* Line 1464 of skeleton.m4 */
8403 #line 3451 "parser.y"
8404 { (yyval.node) = mknode2(&node_assign, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8413 /* Line 1464 of skeleton.m4 */
8414 #line 3452 "parser.y"
8415 { (yyval.node) = mknode3(&node_tenary, (yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));}
8424 /* Line 1464 of skeleton.m4 */
8425 #line 3454 "parser.y"
8426 { (yyval.node) = mknode1(&node_rplusplus, (yyvsp[(1) - (2)].node));}
8435 /* Line 1464 of skeleton.m4 */
8436 #line 3455 "parser.y"
8437 { (yyval.node) = mknode1(&node_rminusminus, (yyvsp[(1) - (2)].node));}
8446 /* Line 1464 of skeleton.m4 */
8447 #line 3456 "parser.y"
8448 {(yyval.node) = mknode1(&node_lplusplus, (yyvsp[(2) - (2)].node)); }
8457 /* Line 1464 of skeleton.m4 */
8458 #line 3457 "parser.y"
8459 {(yyval.node) = mknode1(&node_lminusminus, (yyvsp[(2) - (2)].node)); }
8468 /* Line 1464 of skeleton.m4 */
8469 #line 3460 "parser.y"
8470 { if(!state->cls->info)
8471 syntaxerror("super keyword not allowed outside a class");
8472 classinfo_t*t = state->cls->info->superclass;
8473 if(!t) t = TYPE_OBJECT;
8474 memberinfo_t*f = findmember_nsset(t, (yyvsp[(3) - (3)].id), 1, 0);
8475 MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
8478 v.c = abc_getlocal_0(v.c);
8479 v.c = abc_getsuper2(v.c, &m);
8480 v.t = slotinfo_gettype((slotinfo_t*)f);
8481 (yyval.node) = mkcodenode(v);
8491 /* Line 1464 of skeleton.m4 */
8492 #line 3474 "parser.y"
8495 multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(2) - (2)].id)};
8496 v.c = abc_getlex2(0, &m);
8498 (yyval.node) = mkcodenode(v);
8508 /* Line 1464 of skeleton.m4 */
8509 #line 3482 "parser.y"
8510 {PASS12 new_state();state->xmlfilter=1;}
8519 /* Line 1464 of skeleton.m4 */
8520 #line 3482 "parser.y"
8524 typedcode_t v = node_read((yyvsp[(1) - (6)].node));
8525 typedcode_t w = node_read((yyvsp[(5) - (6)].node));
8527 int index = alloc_local();
8528 int result = alloc_local();
8529 int tmp = alloc_local();
8530 int xml = alloc_local();
8532 c = code_append(c, v.c);
8533 c = abc_checkfilter(c);
8534 c = abc_coerce_a(c); //hasnext2 converts to *
8535 c = abc_setlocal(c, xml);
8536 multiname_t m = {QNAME, &stdns, 0, "XMLList"};
8537 c = abc_getlex2(c, &m);
8538 c = abc_construct(c, 0);
8539 c = abc_setlocal(c, result);
8540 c = abc_pushbyte(c, 0);
8541 c = abc_setlocal(c, index);
8542 code_t*jmp = c = abc_jump(c, 0);
8543 code_t*loop = c = abc_label(c);
8544 c = abc_getlocal(c, xml);
8545 c = abc_getlocal(c, index);
8546 c = abc_nextvalue(c);
8548 c = abc_setlocal(c, tmp);
8549 c = abc_pushwith(c);
8550 c = code_append(c, w.c);
8551 c = abc_popscope(c);
8552 code_t*b = c = abc_iffalse(c, 0);
8553 c = abc_getlocal(c, result);
8554 c = abc_getlocal(c, index);
8555 c = abc_getlocal(c, tmp);
8556 multiname_t m2 = {MULTINAMEL, 0, &nopackage_namespace_set, 0};
8557 c = abc_setproperty2(c, &m2);
8558 c = b->branch = jmp->branch = abc_nop(c);
8559 c = abc_kill(c, tmp);
8560 c = abc_hasnext2(c, xml, index);
8561 c = abc_iftrue(c, loop);
8562 c = abc_getlocal(c, result);
8563 c = abc_kill(c, xml);
8564 c = abc_kill(c, result);
8565 c = abc_kill(c, index);
8567 c = var_block(c, state->vars);
8572 (yyval.node) = mkcodenode(r);
8582 /* Line 1464 of skeleton.m4 */
8583 #line 3536 "parser.y"
8584 {(yyval.id)=(yyvsp[(1) - (1)].id);}
8593 /* Line 1464 of skeleton.m4 */
8594 #line 3537 "parser.y"
8604 /* Line 1464 of skeleton.m4 */
8605 #line 3539 "parser.y"
8615 /* Line 1464 of skeleton.m4 */
8616 #line 3579 "parser.y"
8618 (yyval.node) = get_descendants((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].id), 0, 0);
8628 /* Line 1464 of skeleton.m4 */
8629 #line 3582 "parser.y"
8631 typedcode_t v = node_read((yyvsp[(1) - (3)].node));
8632 multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
8633 v.c = abc_getdescendants2(v.c, &m);
8635 (yyval.node) = mkcodenode(v);
8645 /* Line 1464 of skeleton.m4 */
8646 #line 3589 "parser.y"
8648 (yyval.node) = get_descendants((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].id), 1, 0);
8658 /* Line 1464 of skeleton.m4 */
8659 #line 3592 "parser.y"
8661 typedcode_t v = node_read((yyvsp[(1) - (5)].node));
8662 typedcode_t w = node_read((yyvsp[(4) - (5)].node));
8663 multiname_t m = {MULTINAMEL, 0, &nopackage_namespace_set, 0};
8664 v.c = code_append(v.c, w.c);
8665 v.c = converttype(w.c, w.t, TYPE_STRING);
8666 v.c = abc_getproperty2(v.c, &m);
8668 (yyval.node) = mkcodenode(v);
8678 /* Line 1464 of skeleton.m4 */
8679 #line 3603 "parser.y"
8681 typedcode_t v = node_read((yyvsp[(1) - (4)].node));
8682 multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(4) - (4)].id)};
8683 v.c = abc_getproperty2(v.c, &m);
8685 (yyval.node) = mkcodenode(v);
8695 /* Line 1464 of skeleton.m4 */
8696 #line 3611 "parser.y"
8698 (yyval.node) = get_descendants((yyvsp[(1) - (6)].node), (yyvsp[(4) - (6)].id), (yyvsp[(6) - (6)].id), 0, 1);
8708 /* Line 1464 of skeleton.m4 */
8709 #line 3615 "parser.y"
8711 typedcode_t v = node_read((yyvsp[(1) - (4)].node));
8712 multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(4) - (4)].id)};
8713 v.c = abc_getdescendants2(v.c, &m);
8715 (yyval.node) = mkcodenode(v);
8725 /* Line 1464 of skeleton.m4 */
8726 #line 3622 "parser.y"
8728 (yyval.node) = get_descendants((yyvsp[(1) - (6)].node), (yyvsp[(4) - (6)].id), (yyvsp[(6) - (6)].id), 1, 1);
8738 /* Line 1464 of skeleton.m4 */
8739 #line 3626 "parser.y"
8741 typedcode_t v = node_read((yyvsp[(1) - (6)].node));
8742 typedcode_t w = node_read((yyvsp[(5) - (6)].node));
8743 multiname_t m = {MULTINAMELA, 0, &nopackage_namespace_set, 0};
8744 v.c = code_append(v.c, w.c);
8745 v.c = converttype(w.c, w.t, TYPE_STRING);
8746 v.c = abc_getproperty2(v.c, &m);
8748 (yyval.node) = mkcodenode(v);
8758 /* Line 1464 of skeleton.m4 */
8759 #line 3636 "parser.y"
8761 typedcode_t v = node_read((yyvsp[(1) - (6)].node));
8762 typedcode_t w = node_read((yyvsp[(5) - (6)].node));
8763 multiname_t m = {MULTINAMELA, 0, &nopackage_namespace_set, 0};
8764 v.c = code_append(v.c, w.c);
8765 v.c = converttype(w.c, w.t, TYPE_STRING);
8766 v.c = abc_getdescendants2(v.c, &m);
8768 (yyval.node) = mkcodenode(v);
8778 /* Line 1464 of skeleton.m4 */
8779 #line 3647 "parser.y"
8781 typedcode_t v1 = node_read((yyvsp[(1) - (3)].node));
8782 (yyval.value).c = v1.c;
8783 classinfo_t*t = v1.t;
8785 if(TYPE_IS_CLASS(t) && t->data) {
8789 if(TYPE_IS_XML(t) && !findmember_nsset(t, (yyvsp[(3) - (3)].id), 1, is_static)) {
8790 multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
8791 (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
8792 (yyval.value).c = abc_coerce_a((yyval.value).c);
8793 (yyval.value).t = TYPE_XMLLIST;
8795 if(t->subtype==INFOTYPE_UNRESOLVED) {
8796 syntaxerror("syntaxerror: trying to resolve property '%s' on incomplete object '%s'", (yyvsp[(3) - (3)].id), t->name);
8798 memberinfo_t*f = findmember_nsset(t, (yyvsp[(3) - (3)].id), 1, is_static);
8800 if(f && !is_static != !(f->flags&FLAG_STATIC))
8802 if(f && f->slot && !noslot) {
8803 (yyval.value).c = abc_getslot((yyval.value).c, f->slot);
8806 if(!TYPE_IS_XMLLIST(t)) {
8807 as3_softwarning("Access of undefined property '%s' in %s", (yyvsp[(3) - (3)].id), t->name);
8810 MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
8811 (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
8813 /* determine type */
8814 (yyval.value).t = slotinfo_gettype((slotinfo_t*)f);
8815 if(!(yyval.value).t)
8816 (yyval.value).c = abc_coerce_a((yyval.value).c);
8818 } else if(v1.c && v1.c->opcode == OPCODE___PUSHPACKAGE__) {
8819 string_t*package = v1.c->data[0];
8820 char*package2 = concat3(package->str, ".", (yyvsp[(3) - (3)].id));
8822 slotinfo_t*a = registry_find(package->str, (yyvsp[(3) - (3)].id));
8824 (yyval.value) = push_class(a);
8825 } else if(dict_contains(state->import_toplevel_packages, package2) ||
8826 registry_ispackage(package2)) {
8827 (yyval.value).c = v1.c;
8828 (yyval.value).c->data[0] = string_new4(package2);
8829 (yyval.value).t = 0;
8831 syntaxerror("couldn't resolve %s", package2);
8834 /* when resolving a property on an unknown type, we do know the
8835 name of the property (and don't seem to need the package), but
8836 we need to make avm2 try out all access modes */
8837 as3_softwarning("Resolving %s on unknown type", (yyvsp[(3) - (3)].id));
8838 multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
8839 (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
8840 (yyval.value).c = abc_coerce_a((yyval.value).c);
8841 (yyval.value).t = TYPE_ANY;
8852 /* Line 1464 of skeleton.m4 */
8853 #line 3844 "parser.y"
8856 /* Queue unresolved identifiers for checking against the parent
8857 function's variables.
8858 We consider everything which is not a local variable "unresolved".
8859 This encompasses class names, members of the surrounding class
8860 etc. which is *correct* because local variables of the parent function
8864 if(!find_variable(state, (yyvsp[(1) - (1)].id))) {
8865 unknown_variable((yyvsp[(1) - (1)].id));
8866 /* let the compiler know that it might want to check the current directory/package
8867 for this identifier- maybe there's a file $1.as defining $1. */
8868 as3_schedule_class_noerror(state->package, (yyvsp[(1) - (1)].id));
8874 (yyval.node) = resolve_identifier((yyvsp[(1) - (1)].id));
8884 /* Line 1464 of skeleton.m4 */
8885 #line 3878 "parser.y"
8888 NEW(namespace_decl_t,n);
8889 n->name = (yyvsp[(2) - (2)].id);
8890 n->url = (yyvsp[(2) - (2)].id);
8891 (yyval.namespace_decl)=n;
8901 /* Line 1464 of skeleton.m4 */
8902 #line 3885 "parser.y"
8905 NEW(namespace_decl_t,n);
8906 n->name = (yyvsp[(2) - (4)].id);
8907 n->url = (yyvsp[(4) - (4)].id);
8908 (yyval.namespace_decl)=n;
8918 /* Line 1464 of skeleton.m4 */
8919 #line 3892 "parser.y"
8922 NEW(namespace_decl_t,n);
8923 n->name = (yyvsp[(2) - (4)].id);
8924 n->url = (yyvsp[(4) - (4)].str).str;
8925 (yyval.namespace_decl)=n;
8935 /* Line 1464 of skeleton.m4 */
8936 #line 3899 "parser.y"
8939 dict_put(state->namespaces, (unsigned char*)(yyvsp[(2) - (2)].namespace_decl)->name, (void*)(yyvsp[(2) - (2)].namespace_decl)->url);
8941 namespace_t access = modifiers2access(&(yyvsp[(1) - (2)].flags));
8942 varinfo_t* var = varinfo_register_global(access.access, state->package, (yyvsp[(2) - (2)].namespace_decl)->name);
8943 var->type = TYPE_NAMESPACE;
8945 ns.access = ACCESS_NAMESPACE;
8946 ns.name = (yyvsp[(2) - (2)].namespace_decl)->url;
8947 var->value = constant_new_namespace(&ns);
8950 MULTINAME(m, TYPE_NAMESPACE);
8951 trait_t*t = add_abc_slot(&(yyvsp[(1) - (2)].flags), (yyvsp[(2) - (2)].namespace_decl)->name, 0, 0);
8952 t->value = var->value;
8953 t->type_name = multiname_clone(&m);
8966 /* Line 1464 of skeleton.m4 */
8967 #line 3922 "parser.y"
8970 (yyval.code) = code_append((yyval.code), node_read((yyvsp[(4) - (4)].node)).c);
8971 (yyval.code) = abc_dxnslate((yyval.code));
8981 /* Line 1464 of skeleton.m4 */
8982 #line 3928 "parser.y"
8986 varinfo_t*s = (varinfo_t*)(yyvsp[(3) - (3)].classinfo);
8987 if(s->kind == INFOTYPE_UNRESOLVED) {
8988 s = (varinfo_t*)registry_resolve((slotinfo_t*)s);
8990 syntaxerror("Couldn't resolve namespace %s", (yyvsp[(3) - (3)].classinfo)->name);
8993 if(!s || s->kind != INFOTYPE_VAR)
8994 syntaxerror("%s.%s is not a public namespace (%d)", (yyvsp[(3) - (3)].classinfo)->package, (yyvsp[(3) - (3)].classinfo)->name, s?s->kind:-1);
8995 if(!s->value || !NS_TYPE(s->value->type))
8996 syntaxerror("%s.%s is not a namespace", (yyvsp[(3) - (3)].classinfo)->package, (yyvsp[(3) - (3)].classinfo)->name);
8998 const char*url = s->value->ns->name;
8999 dict_put(state->namespaces, (unsigned char*)(yyvsp[(3) - (3)].classinfo)->name, (void*)url);
9000 add_active_url(url);
9009 /* Line 1464 of skeleton.m4 */
9010 #line 9011 "parser.tab.c"
9013 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
9017 YY_STACK_PRINT (yyss, yyssp);
9021 /* Now `shift' the result of the reduction. Determine what state
9022 that goes to, based on the state we popped back to and the rule
9023 number reduced by. */
9027 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
9028 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
9029 yystate = yytable[yystate];
9031 yystate = yydefgoto[yyn - YYNTOKENS];
9036 /*------------------------------------.
9037 | yyerrlab -- here on detecting error |
9038 `------------------------------------*/
9040 /* If not already recovering from an error, report this error. */
9044 #if ! YYERROR_VERBOSE
9045 yyerror (YY_("syntax error"));
9048 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
9049 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
9051 YYSIZE_T yyalloc = 2 * yysize;
9052 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
9053 yyalloc = YYSTACK_ALLOC_MAXIMUM;
9054 if (yymsg != yymsgbuf)
9055 YYSTACK_FREE (yymsg);
9056 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
9058 yymsg_alloc = yyalloc;
9062 yymsg_alloc = sizeof yymsgbuf;
9066 if (0 < yysize && yysize <= yymsg_alloc)
9068 (void) yysyntax_error (yymsg, yystate, yychar);
9073 yyerror (YY_("syntax error"));
9075 goto yyexhaustedlab;
9083 if (yyerrstatus == 3)
9085 /* If just tried and failed to reuse lookahead token after an
9086 error, discard it. */
9088 if (yychar <= YYEOF)
9090 /* Return failure if at end of input. */
9091 if (yychar == YYEOF)
9096 yydestruct ("Error: discarding",
9102 /* Else will try to reuse lookahead token after shifting the error
9107 /*---------------------------------------------------.
9108 | yyerrorlab -- error raised explicitly by YYERROR. |
9109 `---------------------------------------------------*/
9112 /* Pacify compilers like GCC when the user code never invokes
9113 YYERROR and the label yyerrorlab therefore never appears in user
9115 if (/*CONSTCOND*/ 0)
9118 /* Do not reclaim the symbols of the rule which action triggered
9122 YY_STACK_PRINT (yyss, yyssp);
9127 /*-------------------------------------------------------------.
9128 | yyerrlab1 -- common code for both syntax error and YYERROR. |
9129 `-------------------------------------------------------------*/
9131 yyerrstatus = 3; /* Each real token shifted decrements this. */
9135 yyn = yypact[yystate];
9136 if (yyn != YYPACT_NINF)
9139 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
9147 /* Pop the current state because it cannot handle the error token. */
9152 yydestruct ("Error: popping",
9153 yystos[yystate], yyvsp);
9156 YY_STACK_PRINT (yyss, yyssp);
9162 /* Shift the error token. */
9163 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
9169 /*-------------------------------------.
9170 | yyacceptlab -- YYACCEPT comes here. |
9171 `-------------------------------------*/
9176 /*-----------------------------------.
9177 | yyabortlab -- YYABORT comes here. |
9178 `-----------------------------------*/
9183 #if !defined(yyoverflow) || YYERROR_VERBOSE
9184 /*-------------------------------------------------.
9185 | yyexhaustedlab -- memory exhaustion comes here. |
9186 `-------------------------------------------------*/
9188 yyerror (YY_("memory exhausted"));
9194 if (yychar != YYEMPTY)
9195 yydestruct ("Cleanup: discarding lookahead",
9197 /* Do not reclaim the symbols of the rule which action triggered
9198 this YYABORT or YYACCEPT. */
9200 YY_STACK_PRINT (yyss, yyssp);
9201 while (yyssp != yyss)
9203 yydestruct ("Cleanup: popping",
9204 yystos[*yyssp], yyvsp);
9209 YYSTACK_FREE (yyss);
9212 if (yymsg != yymsgbuf)
9213 YYSTACK_FREE (yymsg);
9215 /* Make sure YYID is used. */
9216 return YYID (yyresult);