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
188 KW_DEFAULT_XML = 318,
225 below_semicolon = 355,
226 below_assignment = 356,
229 minusminus_prefix = 359,
230 plusplus_prefix = 360,
233 above_identifier = 363,
241 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
243 /* Line 223 of skeleton.m4 */
248 /* Line 223 of skeleton.m4 */
251 enum yytokentype token;
253 classinfo_t*classinfo;
254 classinfo_list_t*classinfo_list;
256 slotinfo_list_t*slotinfo_list;
259 unsigned int number_uint;
263 //typedcode_list_t*value_list;
264 codeandnumber_t value_list;
270 for_start_t for_start;
271 abc_exception_t *exception;
274 namespace_decl_t* namespace_decl;
277 abc_exception_list_t *l;
283 /* Line 223 of skeleton.m4 */
284 #line 285 "parser.tab.c"
286 # define YYSTYPE_IS_TRIVIAL 1
287 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
288 # define YYSTYPE_IS_DECLARED 1
292 /* Copy the second part of user declarations. */
294 /* Line 273 of skeleton.m4 */
298 static int a3_error(char*s)
300 syntaxerror("%s", s);
301 return 0; //make gcc happy
304 static void parsererror(const char*file, int line, const char*f)
306 syntaxerror("internal error in %s, %s:%d", f, file, line);
309 #define parserassert(b) {if(!(b)) parsererror(__FILE__, __LINE__,__func__);}
312 static char* concat2(const char* t1, const char* t2)
316 char*text = malloc(l1+l2+1);
317 memcpy(text , t1, l1);
318 memcpy(text+l1, t2, l2);
322 static char* concat3(const char* t1, const char* t2, const char* t3)
327 char*text = malloc(l1+l2+l3+1);
328 memcpy(text , t1, l1);
329 memcpy(text+l1, t2, l2);
330 memcpy(text+l1+l2, t3, l3);
335 typedef struct _import {
338 DECLARE_LIST(import);
340 DECLARE(methodstate);
341 DECLARE_LIST(methodstate);
343 typedef struct _classstate {
349 methodstate_t*static_init;
351 //code_t*static_init;
352 parsedclass_t*dependencies;
354 char has_constructor;
357 struct _methodstate {
368 dict_t*unresolved_variables;
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 void methodstate_destroy(methodstate_t*m)
394 dict_destroy(m->unresolved_variables);
395 m->unresolved_variables = 0;
396 list_free(m->innerfunctions);m->innerfunctions=0;
399 typedef struct _state {
404 import_list_t*wildcard_imports;
405 dict_t*import_toplevel_packages;
408 namespace_list_t*active_namespace_urls;
410 char has_own_imports;
411 char new_vars; // e.g. transition between two functions
412 char xmlfilter; // are we inside a xmlobj..() filter?
415 methodstate_t*method;
422 dict_t*allvars; // also contains variables from sublevels
425 typedef struct _global {
428 parsedclass_list_t*classes;
429 abc_script_t*classinit;
431 abc_script_t*init; //package-level code
434 dict_t*file2token2info;
437 static global_t*global = 0;
438 static state_t* state = 0;
442 /* protected handling here is a big hack: we just assume the protectedns
443 is package:class. the correct approach would be to add the proper
444 namespace to all protected members in the registry, even though that
445 would slow down searching */
446 #define MEMBER_MULTINAME(m,f,n) \
450 m##_ns.access = ((slotinfo_t*)(f))->access; \
451 if(m##_ns.access == ACCESS_NAMESPACE) \
452 m##_ns.name = ((slotinfo_t*)(f))->package; \
453 else if(m##_ns.access == ACCESS_PROTECTED && (f)->parent) \
454 m##_ns.name = concat3((f)->parent->package,":",(f)->parent->name); \
459 m.namespace_set = 0; \
460 m.name = ((slotinfo_t*)(f))->name; \
462 m.type = MULTINAME; \
464 m.namespace_set = &nopackage_namespace_set; \
468 /* warning: list length of namespace set is undefined */
469 #define MULTINAME_LATE(m, access, package) \
470 namespace_t m##_ns = {access, package}; \
471 namespace_set_t m##_nsset; \
472 namespace_list_t m##_l;m##_l.next = 0; \
473 m##_nsset.namespaces = &m##_l; \
474 m##_nsset = m##_nsset; \
475 m##_l.namespace = &m##_ns; \
476 multiname_t m = {MULTINAMEL, 0, &m##_nsset, 0};
478 static namespace_t ns1 = {ACCESS_PRIVATE, ""};
479 static namespace_t ns2 = {ACCESS_PROTECTED, ""};
480 static namespace_t ns3 = {ACCESS_PACKAGEINTERNAL, ""};
481 static namespace_t stdns = {ACCESS_PACKAGE, ""};
482 static namespace_list_t nl4 = {&stdns,0};
483 static namespace_list_t nl3 = {&ns3,&nl4};
484 static namespace_list_t nl2 = {&ns2,&nl3};
485 static namespace_list_t nl1 = {&ns1,&nl2};
486 static namespace_set_t nopackage_namespace_set = {&nl1};
488 static dict_t*definitions=0;
489 void as3_set_define(const char*c)
492 definitions = dict_new();
493 if(!dict_contains(definitions,c))
494 dict_put(definitions,c,0);
497 static void new_state()
500 state_t*oldstate = state;
502 memcpy(s, state, sizeof(state_t)); //shallow copy
504 s->imports = dict_new();
506 if(!s->import_toplevel_packages) {
507 s->import_toplevel_packages = dict_new();
511 state->has_own_imports = 0;
512 state->vars = dict_new();
513 state->old = oldstate;
516 trie_remember(active_namespaces);
519 state->active_namespace_urls = list_clone(oldstate->active_namespace_urls);
522 static void state_destroy(state_t*state)
524 if(state->has_own_imports) {
525 list_free(state->wildcard_imports);
526 dict_destroy(state->imports);state->imports=0;
528 if(state->imports && (!state->old || state->old->imports!=state->imports)) {
529 dict_destroy(state->imports);state->imports=0;
532 dict_destroy(state->vars);state->vars=0;
534 if(state->new_vars && state->allvars) {
535 parserassert(!state->old || state->old->allvars != state->allvars);
536 DICT_ITERATE_DATA(state->allvars, void*, data) {
539 dict_destroy(state->allvars);
542 list_free(state->active_namespace_urls)
543 state->active_namespace_urls = 0;
548 static void old_state()
550 trie_rollback(active_namespaces);
552 if(!state || !state->old)
553 syntaxerror("invalid nesting");
554 state_t*leaving = state;
558 if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) {
559 methodstate_destroy(leaving->method);leaving->method=0;
561 if(as3_pass>1 && leaving->cls && leaving->cls != state->cls) {
566 state_destroy(leaving);
569 static code_t* method_header(methodstate_t*m);
570 static code_t* wrap_function(code_t*c,code_t*header, code_t*body);
571 static void function_initvars(methodstate_t*m, char has_params, params_t*params, int flags, char var0);
574 static char* internal_filename_package = 0;
575 void initialize_file(char*filename)
578 syntaxerror("invalid call to initialize_file during parsing of another file");
581 active_namespaces = trie_new();
584 state->package = internal_filename_package = strdup(filename);
585 state->allvars = dict_new();
587 global->token2info = dict_lookup(global->file2token2info,
588 current_filename // use long version
590 if(!global->token2info) {
591 global->token2info = dict_new2(&ptr_type);
592 dict_put(global->file2token2info, current_filename, global->token2info);
596 state->method = rfx_calloc(sizeof(methodstate_t));
597 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
598 state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope
600 state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
601 state->method->variable_count = 0;
603 syntaxerror("internal error: skewed tokencount");
604 function_initvars(state->method, 0, 0, 0, 1);
611 if(!state || state->level!=1) {
612 syntaxerror("unexpected end of file in pass %d", as3_pass);
616 dict_del(global->file2token2info, current_filename);
617 code_t*header = method_header(state->method);
618 //if(global->init->method->body->code || global->init->traits) {
620 code_t*c = wrap_function(header, 0, global->init->method->body->code);
621 global->init->method->body->code = abc_returnvoid(c);
622 free(state->method);state->method=0;
626 //free(state->package);state->package=0; // used in registry
627 state_destroy(state);state=0;
630 void initialize_parser()
632 global = rfx_calloc(sizeof(global_t));
633 global->file = abc_file_new();
634 global->file->flags &= ~ABCFILE_LAZY;
635 global->file2token2info = dict_new();
636 global->token2info = 0;
637 global->classinit = abc_initscript(global->file);
640 void* finish_parser()
642 dict_free_all(global->file2token2info, 1, (void*)dict_destroy);
643 global->token2info=0;
645 initcode_add_classlist(global->classinit, global->classes);
650 typedef struct _variable {
656 methodstate_t*is_inner_method;
659 static variable_t* find_variable(state_t*s, const char*name)
661 if(s->method->no_variable_scoping) {
662 return dict_lookup(s->allvars, name);
667 v = dict_lookup(s->vars, name);
669 if(s->new_vars) break;
675 static variable_t* find_slot(methodstate_t*m, const char*name)
678 return dict_lookup(m->slots, name);
682 static variable_t* find_variable_safe(state_t*s, char*name)
684 variable_t* v = find_variable(s, name);
686 syntaxerror("undefined variable: %s", name);
690 static char variable_exists(char*name)
692 return dict_contains(state->vars, name);
695 static code_t*defaultvalue(code_t*c, classinfo_t*type)
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)) {
744 syntaxerror("variable %s already defined", name);
746 dict_put(state->vars, name, v);
748 if(method->no_variable_scoping &&
750 dict_contains(state->allvars, name))
752 variable_t*v = dict_lookup(state->allvars, name);
754 syntaxerror("variable %s already defined.", name);
757 dict_put(state->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->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 namespace_t modifiers2access(modifiers_t*mod)
937 if(mod->flags&FLAG_NAMESPACE) {
938 if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
939 syntaxerror("invalid combination of access levels and namespaces");
940 ns.access = ACCESS_NAMESPACE;
942 const char*url = (const char*)trie_lookup(active_namespaces, (unsigned char*)mod->ns);
944 /* shouldn't happen- the tokenizer only reports something as a namespace
945 if it was already registered */
946 trie_dump(active_namespaces);
947 syntaxerror("unknown namespace: %s", mod->ns);
950 } else if(mod->flags&FLAG_PUBLIC) {
951 if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
952 syntaxerror("invalid combination of access levels");
953 ns.access = ACCESS_PACKAGE;
954 } else if(mod->flags&FLAG_PRIVATE) {
955 if(mod->flags&(FLAG_PUBLIC|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
956 syntaxerror("invalid combination of access levels");
957 ns.access = ACCESS_PRIVATE;
958 } else if(mod->flags&FLAG_PROTECTED) {
959 if(mod->flags&(FLAG_PUBLIC|FLAG_PRIVATE|FLAG_PACKAGEINTERNAL))
960 syntaxerror("invalid combination of access levels");
961 ns.access = ACCESS_PROTECTED;
963 ns.access = ACCESS_PACKAGEINTERNAL;
967 static slotinfo_t* find_class(const char*name);
969 static memberinfo_t* findmember_nsset(classinfo_t*cls, const char*name, char recurse, char is_static)
971 return registry_findmember_nsset(cls, state->active_namespace_urls, name, recurse, is_static);
974 static void innerfunctions2vars(methodstate_t*m)
976 methodstate_list_t*l = m->innerfunctions;
978 methodstate_t*m = l->methodstate;
980 variable_t* v = new_variable2(state->method, m->info->name, TYPE_FUNCTION(m->info), 0, 0);
981 m->var_index = v->index;
983 m->slot_index = m->is_a_slot;
984 v->is_inner_method = m;
989 static void function_initvars(methodstate_t*m, char has_params, params_t*params, int flags, char var0)
994 index = new_variable(m, "this", 0, 0, 0);
995 else if(!m->is_global)
996 index = new_variable(m, (flags&FLAG_STATIC)?"class":"this", state->cls?state->cls->info:0, 0, 0);
998 index = new_variable(m, "globalscope", 0, 0, 0);
1000 DICT_ITERATE_ITEMS(state->vars, char*, name, variable_t*, v) {
1001 printf("%s %d\n", name, v->index);
1004 parserassert(!index);
1009 for(p=params->list;p;p=p->next) {
1010 variable_t*v = new_variable2(m, p->param->name, p->param->type, 0, 1);
1011 v->is_parameter = 1;
1013 if(as3_pass==2 && m->need_arguments) {
1014 /* arguments can never be used by an innerfunction (the inner functions
1015 have their own arguments var), so it's ok to not initialize this until
1016 pass 2. (We don't know whether we need it before, anyway) */
1017 variable_t*v = new_variable2(m, "arguments", TYPE_ARRAY, 0, 0);
1018 m->need_arguments = v->index;
1022 innerfunctions2vars(m);
1025 m->scope_code = add_scope_code(m->scope_code, m, 0);
1027 /* exchange unresolved identifiers with the actual objects */
1028 DICT_ITERATE_ITEMS(m->slots, char*, name, variable_t*, v) {
1029 if(v->type && v->type->kind == INFOTYPE_UNRESOLVED) {
1030 classinfo_t*type = (classinfo_t*)registry_resolve((slotinfo_t*)v->type);
1031 if(!type || type->kind != INFOTYPE_CLASS) {
1032 syntaxerror("Couldn't find class %s::%s (%s)", v->type->package, v->type->name, name);
1042 char*as3_globalclass=0;
1043 static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, classinfo_list_t*implements)
1046 syntaxerror("inner classes now allowed");
1051 classinfo_list_t*mlist=0;
1053 if(mod->flags&~(FLAG_PACKAGEINTERNAL|FLAG_PUBLIC|FLAG_FINAL|FLAG_DYNAMIC|FLAG_INTERFACE))
1054 syntaxerror("invalid modifier(s)");
1056 if((mod->flags&(FLAG_PUBLIC|FLAG_PACKAGEINTERNAL)) == (FLAG_PUBLIC|FLAG_PACKAGEINTERNAL))
1057 syntaxerror("public and internal not supported at the same time.");
1059 if((mod->flags&(FLAG_PROTECTED|FLAG_STATIC)) == (FLAG_PROTECTED|FLAG_STATIC))
1060 syntaxerror("protected and static not supported at the same time.");
1062 //if(!(mod->flags&FLAG_INTERFACE) && !extends) {
1063 if(!(mod->flags&FLAG_INTERFACE) && !extends) {
1064 // all classes extend object
1065 extends = registry_getobjectclass();
1068 /* create the class name, together with the proper attributes */
1072 if(!(mod->flags&FLAG_PUBLIC) && state->package==internal_filename_package) {
1073 access = ACCESS_PRIVATE; package = internal_filename_package;
1074 } else if(!(mod->flags&FLAG_PUBLIC) && state->package!=internal_filename_package) {
1075 access = ACCESS_PACKAGEINTERNAL; package = state->package;
1076 } else if(state->package!=internal_filename_package) {
1077 access = ACCESS_PACKAGE; package = state->package;
1079 syntaxerror("public classes only allowed inside a package");
1083 state->cls = rfx_calloc(sizeof(classstate_t));
1084 state->cls->init = rfx_calloc(sizeof(methodstate_t));
1085 state->cls->static_init = rfx_calloc(sizeof(methodstate_t));
1086 state->cls->static_init->is_static=FLAG_STATIC;
1087 /* notice: we make no effort to initialize the top variable (local0) here,
1088 even though it has special meaning. We just rely on the fact
1089 that pass 1 won't do anything with variables */
1091 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->cls);
1093 /* set current method to constructor- all code within the class-level (except
1094 static variable initializations) will be executed during construction time */
1095 state->method = state->cls->init;
1097 if(registry_find(package, classname)) {
1098 syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, classname);
1100 /* build info struct */
1101 int num_interfaces = (list_length(implements));
1102 state->cls->info = classinfo_register(access, package, classname, num_interfaces);
1103 state->cls->info->flags |= mod->flags & (FLAG_DYNAMIC|FLAG_INTERFACE|FLAG_FINAL);
1104 state->cls->info->superclass = extends;
1107 classinfo_list_t*l = implements;
1108 for(l=implements;l;l=l->next) {
1109 state->cls->info->interfaces[pos++] = l->classinfo;
1114 state->cls = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1116 parserassert(state->cls && state->cls->info);
1118 state->method = state->cls->static_init;
1120 function_initvars(state->cls->init, 0, 0, 0, 1);
1121 state->cls->static_init->variable_count=1;
1122 function_initvars(state->cls->static_init, 0, 0, 0, 0);
1124 if(extends && (extends->flags & FLAG_FINAL))
1125 syntaxerror("Can't extend final class '%s'", extends->name);
1128 while(state->cls->info->interfaces[pos]) {
1129 if(!(state->cls->info->interfaces[pos]->flags & FLAG_INTERFACE))
1130 syntaxerror("'%s' is not an interface",
1131 state->cls->info->interfaces[pos]->name);
1135 /* generate the abc code for this class */
1136 MULTINAME(classname2,state->cls->info);
1137 multiname_t*extends2 = sig2mname(extends);
1139 /* don't add the class to the class index just yet- that will be done later
1141 state->cls->abc = abc_class_new(0, &classname2, extends2);
1142 state->cls->abc->file = global->file;
1144 multiname_destroy(extends2);
1145 if(state->cls->info->flags&FLAG_FINAL) abc_class_final(state->cls->abc);
1146 if(!(state->cls->info->flags&FLAG_DYNAMIC)) abc_class_sealed(state->cls->abc);
1147 if(state->cls->info->flags&FLAG_INTERFACE) {
1148 abc_class_interface(state->cls->abc);
1151 for(mlist=implements;mlist;mlist=mlist->next) {
1152 MULTINAME(m, mlist->classinfo);
1153 abc_class_add_interface(state->cls->abc, &m);
1156 state->cls->dependencies = parsedclass_new(state->cls->info, state->cls->abc);
1157 list_append(global->classes, state->cls->dependencies);
1159 /* flash.display.MovieClip handling */
1160 if(!as3_globalclass && (mod->flags&FLAG_PUBLIC) && slotinfo_equals((slotinfo_t*)registry_getMovieClip(),(slotinfo_t*)extends)) {
1161 if(state->package && state->package[0]) {
1162 as3_globalclass = concat3(state->package, ".", classname);
1164 as3_globalclass = strdup(classname);
1170 static void endclass()
1173 if(!state->cls->has_constructor && !(state->cls->info->flags&FLAG_INTERFACE)) {
1175 c = abc_getlocal_0(c);
1176 c = abc_constructsuper(c, 0);
1177 state->cls->init->header = code_append(state->cls->init->header, c);
1178 state->cls->has_constructor=1;
1180 if(state->cls->init) {
1181 if(state->cls->info->flags&FLAG_INTERFACE) {
1182 if(state->cls->init->header)
1183 syntaxerror("interface can not have class-level code");
1185 abc_method_t*m = abc_class_getconstructor(state->cls->abc, 0);
1186 code_t*c = method_header(state->cls->init);
1187 m->body->code = wrap_function(c, 0, m->body->code);
1190 if(state->cls->static_init) {
1191 abc_method_t*m = abc_class_getstaticconstructor(state->cls->abc, 0);
1192 code_t*c = method_header(state->cls->static_init);
1193 m->body->code = wrap_function(c, 0, m->body->code);
1196 trait_list_t*trait = state->cls->abc->traits;
1197 /* switch all protected members to the protected ns of this class */
1199 trait_t*t = trait->trait;
1200 if(t->name->ns->access == ACCESS_PROTECTED) {
1201 if(!state->cls->abc->protectedNS) {
1202 char*n = concat3(state->cls->info->package, ":", state->cls->info->name);
1203 state->cls->abc->protectedNS = namespace_new_protected(n);
1204 state->cls->abc->flags |= CLASS_PROTECTED_NS;
1206 t->name->ns->name = strdup(state->cls->abc->protectedNS->name);
1208 trait = trait->next;
1215 void check_code_for_break(code_t*c)
1218 if(c->opcode == OPCODE___BREAK__) {
1219 char*name = string_cstr(c->data[0]);
1220 syntaxerror("Unresolved \"break %s\"", name);
1222 if(c->opcode == OPCODE___CONTINUE__) {
1223 char*name = string_cstr(c->data[0]);
1224 syntaxerror("Unresolved \"continue %s\"", name);
1226 if(c->opcode == OPCODE___RETHROW__) {
1227 syntaxerror("Unresolved \"rethrow\"");
1229 if(c->opcode == OPCODE___FALLTHROUGH__) {
1230 syntaxerror("Unresolved \"fallthrough\"");
1232 if(c->opcode == OPCODE___PUSHPACKAGE__) {
1233 char*name = string_cstr(c->data[0]);
1234 syntaxerror("Can't reference a package (%s) as such", name);
1240 static void check_constant_against_type(classinfo_t*t, constant_t*c)
1242 #define xassert(b) if(!(b)) syntaxerror("Invalid default value %s for type '%s'", constant_tostring(c), t->name)
1243 if(TYPE_IS_NUMBER(t)) {
1244 xassert(c->type == CONSTANT_FLOAT
1245 || c->type == CONSTANT_INT
1246 || c->type == CONSTANT_UINT);
1247 } else if(TYPE_IS_UINT(t)) {
1248 xassert(c->type == CONSTANT_UINT ||
1249 (c->type == CONSTANT_INT && c->i>=0));
1250 } else if(TYPE_IS_INT(t)) {
1251 xassert(c->type == CONSTANT_INT);
1252 } else if(TYPE_IS_BOOLEAN(t)) {
1253 xassert(c->type == CONSTANT_TRUE
1254 || c->type == CONSTANT_FALSE);
1258 static void check_override(memberinfo_t*m, int flags)
1262 if(m->parent == state->cls->info && !((flags^m->flags)&FLAG_STATIC))
1263 syntaxerror("class '%s' already contains a method/slot '%s'", m->parent->name, m->name);
1265 syntaxerror("internal error: overriding method %s, which doesn't have parent", m->name);
1266 if(m->access==ACCESS_PRIVATE)
1268 if(m->flags & FLAG_FINAL)
1269 syntaxerror("can't override final member %s", m->name);
1271 /* allow this. it's no issue.
1272 if((m->flags & FLAG_STATIC) && !(flags&FLAG_STATIC))
1273 syntaxerror("can't override static member %s", m->name);*/
1275 if(!(m->flags & FLAG_STATIC) && (flags&FLAG_STATIC))
1276 syntaxerror("can't override non-static member %s with static declaration", m->name);
1278 if(!(flags&FLAG_OVERRIDE) && !(flags&FLAG_STATIC) && !(m->flags&FLAG_STATIC)) {
1279 if(m->parent && !(m->parent->flags&FLAG_INTERFACE)) {
1280 if(m->kind == INFOTYPE_METHOD)
1281 syntaxerror("can't override without explicit 'override' declaration");
1283 syntaxerror("can't override '%s'", m->name);
1288 static methodinfo_t*registerfunction(enum yytokentype getset, modifiers_t*mod, char*name, params_t*params, classinfo_t*return_type, int slot)
1290 methodinfo_t*minfo = 0;
1291 namespace_t ns = modifiers2access(mod);
1294 minfo = methodinfo_register_global(ns.access, state->package, name);
1295 minfo->return_type = return_type;
1296 } else if(getset != KW_GET && getset != KW_SET) {
1298 memberinfo_t* m = registry_findmember(state->cls->info, ns.name, name, 0, mod->flags&FLAG_STATIC);
1300 syntaxerror("class already contains a %s '%s'", infotypename((slotinfo_t*)m), m->name);
1302 minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name, mod->flags&FLAG_STATIC);
1303 minfo->return_type = return_type;
1304 // getslot on a member slot only returns "undefined", so no need
1305 // to actually store these
1306 //state->minfo->slot = state->method->abc->method->trait->slot_id;
1308 //class getter/setter
1309 int gs = getset==KW_GET?SUBTYPE_GET:SUBTYPE_SET;
1311 if(getset == KW_GET) {
1313 } else if(params->list && params->list->param && !params->list->next) {
1314 type = params->list->param->type;
1316 syntaxerror("setter function needs to take exactly one argument");
1317 // not sure wether to look into superclasses here, too
1318 minfo = (methodinfo_t*)registry_findmember(state->cls->info, ns.name, name, 1, mod->flags&FLAG_STATIC);
1320 if(minfo->kind!=INFOTYPE_VAR)
1321 syntaxerror("class already contains a method called '%s'", name);
1322 if(!(minfo->subtype & (SUBTYPE_GETSET)))
1323 syntaxerror("class already contains a field called '%s'", name);
1324 if(minfo->subtype & gs)
1325 syntaxerror("getter/setter for '%s' already defined", name);
1326 /* make a setter or getter into a getset */
1327 minfo->subtype |= gs;
1330 FIXME: this check needs to be done in pass 2
1332 if((!minfo->return_type != !type) ||
1333 (minfo->return_type && type &&
1334 !strcmp(minfo->return_type->name, type->name))) {
1335 syntaxerror("different type in getter and setter: %s and %s",
1336 minfo->return_type?minfo->return_type->name:"*",
1337 type?type->name:"*");
1340 minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name, mod->flags&FLAG_STATIC);
1341 minfo->kind = INFOTYPE_VAR; //hack
1342 minfo->subtype = gs;
1343 minfo->return_type = type;
1346 /* can't assign a slot as getter and setter might have different slots */
1347 //minfo->slot = slot;
1349 if(mod->flags&FLAG_FINAL) minfo->flags |= FLAG_FINAL;
1350 if(mod->flags&FLAG_STATIC) minfo->flags |= FLAG_STATIC;
1351 if(mod->flags&FLAG_OVERRIDE) minfo->flags |= FLAG_OVERRIDE;
1356 static void innerfunction(char*name, params_t*params, classinfo_t*return_type)
1358 //parserassert(state->method && state->method->info);
1360 methodstate_t*parent_method = state->method;
1364 return_type = 0; // not valid in pass 1
1366 v = new_variable2(parent_method, name, 0, 0, 0);
1371 state->new_vars = 1;
1372 state->allvars = dict_new();
1375 state->method = rfx_calloc(sizeof(methodstate_t));
1376 state->method->inner = 1;
1377 state->method->is_static = parent_method->is_static;
1378 state->method->variable_count = 0;
1379 state->method->abc = rfx_calloc(sizeof(abc_method_t));
1381 v->is_inner_method = state->method;
1384 NEW(methodinfo_t,minfo);
1385 minfo->kind = INFOTYPE_METHOD;
1386 minfo->access = ACCESS_PACKAGEINTERNAL;
1388 state->method->info = minfo;
1391 list_append(parent_method->innerfunctions, state->method);
1393 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
1395 function_initvars(state->method, 1, params, 0, 1);
1399 state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1400 state->method->variable_count = 0;
1401 parserassert(state->method);
1403 state->method->info->return_type = return_type;
1404 function_initvars(state->method, 1, params, 0, 1);
1408 static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,
1409 params_t*params, classinfo_t*return_type)
1411 if(state->method && state->method->info) {
1412 syntaxerror("not able to start another method scope");
1415 state->new_vars = 1;
1416 state->allvars = dict_new();
1419 state->method = rfx_calloc(sizeof(methodstate_t));
1420 state->method->has_super = 0;
1421 state->method->is_static = mod->flags&FLAG_STATIC;
1424 state->method->is_constructor = !strcmp(state->cls->info->name,name);
1426 state->method->is_global = 1;
1427 state->method->late_binding = 1; // for global methods, always push local_0 on the scope stack
1429 if(state->method->is_constructor)
1430 name = "__as3_constructor__";
1432 state->method->info = registerfunction(getset, mod, name, params, return_type, 0);
1434 function_initvars(state->method, 1, params, mod->flags, 1);
1436 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
1440 state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
1441 state->method->variable_count = 0;
1442 parserassert(state->method);
1445 memberinfo_t*m = registry_findmember(state->cls->info, mod->ns, name, 2, mod->flags&FLAG_STATIC);
1446 check_override(m, mod->flags);
1450 state->cls->has_constructor |= state->method->is_constructor;
1453 function_initvars(state->method, 1, params, mod->flags, 1);
1457 static void insert_unresolved(methodstate_t*m, dict_t*xvars, dict_t*allvars)
1459 parserassert(m->inner);
1460 if(m->unresolved_variables) {
1461 dict_t*d = m->unresolved_variables;
1463 DICT_ITERATE_KEY(d, char*, id) {
1464 /* check parent method's variables */
1466 if(dict_contains(allvars, id)) {
1467 m->uses_parent_function = 1;
1468 state->method->uses_slots = 1;
1469 dict_put(xvars, id, 0);
1473 methodstate_list_t*ml = m->innerfunctions;
1475 insert_unresolved(ml->methodstate, xvars, allvars);
1480 static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*name,
1481 params_t*params, classinfo_t*return_type, code_t*body)
1484 dict_t*xvars = dict_new();
1486 if(state->method->unresolved_variables) {
1487 DICT_ITERATE_KEY(state->method->unresolved_variables, char*, vname) {
1488 if(!state->method->no_variable_scoping && dict_contains(state->allvars, vname)) {
1489 variable_t*v = dict_lookup(state->allvars, vname);
1490 if(!v->is_inner_method) {
1491 state->method->no_variable_scoping = 1;
1492 as3_warning("function %s uses forward or outer block variable references (%s): switching into compatiblity mode", name, vname);
1498 methodstate_list_t*ml = state->method->innerfunctions;
1500 insert_unresolved(ml->methodstate, xvars, state->allvars);
1504 if(state->method->uses_slots) {
1505 state->method->slots = dict_new();
1507 DICT_ITERATE_ITEMS(state->allvars, char*, name, variable_t*, v) {
1508 if(!name) syntaxerror("internal error");
1509 if(v->index && dict_contains(xvars, name)) {
1510 v->init = v->kill = 0;
1512 if(v->is_inner_method) {
1513 v->is_inner_method->is_a_slot = i;
1516 dict_put(state->method->slots, name, v);
1519 state->method->uses_slots = i;
1520 dict_destroy(state->vars);state->vars = 0;
1521 parserassert(state->new_vars);
1522 dict_destroy(state->allvars);state->allvars = 0;
1529 /*if(state->method->uses_parent_function){
1530 syntaxerror("accessing variables of parent function from inner functions not supported yet");
1535 multiname_t*type2 = sig2mname(return_type);
1537 if(state->method->inner) {
1538 f = state->method->abc;
1539 abc_method_init(f, global->file, type2, 1);
1540 } else if(state->method->is_constructor) {
1541 f = abc_class_getconstructor(state->cls->abc, type2);
1542 } else if(!state->method->is_global) {
1543 namespace_t ns = modifiers2access(mod);
1544 multiname_t mname = {QNAME, &ns, 0, name};
1545 if(mod->flags&FLAG_STATIC)
1546 f = abc_class_staticmethod(state->cls->abc, type2, &mname);
1548 f = abc_class_method(state->cls->abc, type2, &mname);
1549 slot = f->trait->slot_id;
1551 namespace_t mname_ns = {state->method->info->access, state->package};
1552 multiname_t mname = {QNAME, &mname_ns, 0, name};
1554 f = abc_method_new(global->file, type2, 1);
1555 if(!global->init) global->init = abc_initscript(global->file);
1556 trait_t*t = trait_new_method(&global->init->traits, multiname_clone(&mname), f);
1557 //abc_code_t*c = global->init->method->body->code;
1559 //flash doesn't seem to allow us to access function slots
1560 //state->method->info->slot = slot;
1562 if(mod && mod->flags&FLAG_OVERRIDE) f->trait->attributes |= TRAIT_ATTR_OVERRIDE;
1563 if(getset == KW_GET) f->trait->kind = TRAIT_GETTER;
1564 if(getset == KW_SET) f->trait->kind = TRAIT_SETTER;
1565 if(params->varargs) f->flags |= METHOD_NEED_REST;
1566 if(state->method->need_arguments) f->flags |= METHOD_NEED_ARGUMENTS;
1570 for(p=params->list;p;p=p->next) {
1571 if(params->varargs && !p->next) {
1572 break; //varargs: omit last parameter in function signature
1574 multiname_t*m = sig2mname(p->param->type);
1575 list_append(f->parameters, m);
1576 if(p->param->value) {
1577 check_constant_against_type(p->param->type, p->param->value);
1578 opt=1;list_append(f->optional_parameters, p->param->value);
1580 syntaxerror("function %s: non-optional parameter not allowed after optional parameters", name);
1583 if(state->method->slots) {
1584 DICT_ITERATE_ITEMS(state->method->slots, char*, name, variable_t*, v) {
1586 multiname_t*mname = multiname_new(namespace_new(ACCESS_PACKAGE, ""), name);
1587 multiname_t*type = sig2mname(v->type);
1588 trait_t*t = trait_new_member(&f->body->traits, type, mname, 0);
1589 t->slot_id = v->index;
1594 check_code_for_break(body);
1596 /* Seems this works now.
1597 if(state->method->exceptions && state->method->uses_slots) {
1598 as3_warning("try/catch and activation not supported yet within the same method");
1602 f->body->code = body;
1603 f->body->exceptions = state->method->exceptions;
1604 } else { //interface
1606 syntaxerror("interface methods can't have a method body");
1616 void breakjumpsto(code_t*c, char*name, code_t*jump)
1619 if(c->opcode == OPCODE___BREAK__) {
1620 string_t*name2 = c->data[0];
1621 if(!name2->len || !strncmp(name2->str, name, name2->len)) {
1622 c->opcode = OPCODE_JUMP;
1629 void continuejumpsto(code_t*c, char*name, code_t*jump)
1632 if(c->opcode == OPCODE___CONTINUE__) {
1633 string_t*name2 = c->data[0];
1634 if(!name2->len || !strncmp(name2->str, name, name2->len)) {
1635 c->opcode = OPCODE_JUMP;
1643 code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
1648 return abc_coerce_a(c);
1652 // cast an "any" type to a specific type. subject to
1653 // runtime exceptions
1654 return abc_coerce2(c, &m);
1657 if((TYPE_IS_NUMBER(from) || TYPE_IS_UINT(from) || TYPE_IS_INT(from)) &&
1658 (TYPE_IS_NUMBER(to) || TYPE_IS_UINT(to) || TYPE_IS_INT(to))) {
1659 // allow conversion between number types
1660 if(TYPE_IS_UINT(to))
1661 return abc_convert_u(c);
1662 else if(TYPE_IS_INT(to))
1663 return abc_convert_i(c);
1664 else if(TYPE_IS_NUMBER(to))
1665 return abc_convert_d(c);
1666 return abc_coerce2(c, &m);
1669 if(TYPE_IS_XMLLIST(to) && TYPE_IS_XML(from))
1672 if(TYPE_IS_BOOLEAN(to))
1673 return abc_convert_b(c);
1674 if(TYPE_IS_STRING(to))
1675 return abc_convert_s(c);
1676 if(TYPE_IS_OBJECT(to))
1677 return abc_coerce2(c, &m);
1678 if(TYPE_IS_OBJECT(from) && TYPE_IS_XMLLIST(to))
1679 return abc_coerce2(c, &m);
1680 if(TYPE_IS_OBJECT(from) && TYPE_IS_ARRAY(to))
1681 return abc_coerce2(c, &m);
1683 classinfo_t*supertype = from;
1685 if(supertype == to) {
1686 /* target type is one of from's superclasses.
1687 (not sure we need this coerce - as far as the verifier
1688 is concerned, object==object (i think) */
1689 return abc_coerce2(c, &m);
1692 while(supertype->interfaces[t]) {
1693 if(supertype->interfaces[t]==to) {
1694 // target type is one of from's interfaces
1695 return abc_coerce2(c, &m);
1699 supertype = supertype->superclass;
1701 if(TYPE_IS_FUNCTION(from) && TYPE_IS_FUNCTION(to))
1703 if(TYPE_IS_CLASS(from) && TYPE_IS_CLASS(to))
1705 if(TYPE_IS_NULL(from) && !IS_NUMBER_OR_INT(to))
1709 as3_error("can't convert type %s%s%s to %s%s%s",
1710 from->package, from->package[0]?".":"", from->name,
1711 to->package, to->package[0]?".":"", to->name);
1715 code_t* coerce_to_type(code_t*c, classinfo_t*t)
1718 return abc_coerce_a(c);
1719 } else if(TYPE_IS_STRING(t)) {
1720 return abc_coerce_s(c);
1723 return abc_coerce2(c, &m);
1727 char is_pushundefined(code_t*c)
1729 return (c && !c->prev && !c->next && c->opcode == OPCODE_PUSHUNDEFINED);
1732 static const char* get_package_from_name(const char*name)
1734 /* try explicit imports */
1735 dictentry_t* e = dict_get_slot(state->imports, name);
1737 if(!strcmp(e->key, name)) {
1738 slotinfo_t*c = (slotinfo_t*)e->data;
1739 if(c) return c->package;
1745 static namespace_list_t*get_current_imports()
1747 namespace_list_t*searchlist = 0;
1749 list_append(searchlist, namespace_new_package(state->package));
1751 import_list_t*l = state->wildcard_imports;
1753 namespace_t*ns = namespace_new_package(l->import->package);
1754 list_append(searchlist, ns);
1757 list_append(searchlist, namespace_new_package(""));
1758 list_append(searchlist, namespace_new_package(internal_filename_package));
1762 static slotinfo_t* find_class(const char*name)
1766 c = registry_find(state->package, name);
1769 /* try explicit imports */
1770 dictentry_t* e = dict_get_slot(state->imports, name);
1773 if(!strcmp(e->key, name)) {
1774 c = (slotinfo_t*)e->data;
1780 /* try package.* imports */
1781 import_list_t*l = state->wildcard_imports;
1783 //printf("does package %s contain a class %s?\n", l->import->package, name);
1784 c = registry_find(l->import->package, name);
1789 /* try global package */
1790 c = registry_find("", name);
1793 /* try local "filename" package */
1794 c = registry_find(internal_filename_package, name);
1799 typedcode_t push_class(slotinfo_t*a)
1804 if(a->access == ACCESS_PACKAGEINTERNAL &&
1805 strcmp(a->package, state->package) &&
1806 strcmp(a->package, internal_filename_package)
1808 syntaxerror("Can't access internal %s %s in package '%s' from package '%s'",
1809 infotypename(a), a->name, a->package, state->package);
1813 if(a->kind != INFOTYPE_CLASS) {
1815 x.c = abc_findpropstrict2(x.c, &m);
1816 x.c = abc_getproperty2(x.c, &m);
1817 if(a->kind == INFOTYPE_METHOD) {
1818 methodinfo_t*f = (methodinfo_t*)a;
1819 x.t = TYPE_FUNCTION(f);
1821 varinfo_t*v = (varinfo_t*)a;
1826 if(state->cls && state->method == state->cls->static_init) {
1827 /* we're in the static initializer.
1828 record the fact that we're using this class here */
1829 parsedclass_add_dependency(state->cls->dependencies, (classinfo_t*)a);
1831 classinfo_t*c = (classinfo_t*)a;
1833 if(0) { //Error #1026: Slot 1 exceeds slotCount=0 of global
1834 x.c = abc_getglobalscope(x.c);
1835 x.c = abc_getslot(x.c, c->slot);
1838 x.c = abc_getlex2(x.c, &m);
1840 x.t = TYPE_CLASS(c);
1846 char is_break_or_jump(code_t*c)
1850 if(c->opcode == OPCODE_JUMP ||
1851 c->opcode == OPCODE___BREAK__ ||
1852 c->opcode == OPCODE___CONTINUE__ ||
1853 c->opcode == OPCODE_THROW ||
1854 c->opcode == OPCODE_RETURNVOID ||
1855 c->opcode == OPCODE_RETURNVALUE) {
1861 #define IS_FINALLY_TARGET(op) \
1862 ((op) == OPCODE___CONTINUE__ || \
1863 (op) == OPCODE___BREAK__ || \
1864 (op) == OPCODE_RETURNVOID || \
1865 (op) == OPCODE_RETURNVALUE || \
1866 (op) == OPCODE___RETHROW__)
1868 static code_t* insert_finally_lookup(code_t*c, code_t*finally, int tempvar)
1870 #define NEED_EXTRA_STACK_ARG
1871 code_t*finally_label = abc_nop(0);
1872 NEW(lookupswitch_t, l);
1878 code_t*prev = i->prev;
1879 if(IS_FINALLY_TARGET(i->opcode)) {
1882 if(i->opcode == OPCODE___RETHROW__ ||
1883 i->opcode == OPCODE_RETURNVALUE) {
1884 if(i->opcode == OPCODE___RETHROW__)
1885 i->opcode = OPCODE_THROW;
1887 p = abc_coerce_a(p);
1888 p = abc_setlocal(p, tempvar);
1890 p = abc_pushbyte(p, count++);
1891 p = abc_jump(p, finally_label);
1892 code_t*target = p = abc_label(p);
1893 #ifdef NEED_EXTRA_STACK_ARG
1897 p = abc_getlocal(p, tempvar);
1900 p->next = i;i->prev = p;
1901 list_append(l->targets, target);
1907 c = abc_pushbyte(c, -1);
1908 c = code_append(c, finally_label);
1909 c = code_append(c, finally);
1911 #ifdef NEED_EXTRA_STACK_ARG
1914 c = abc_lookupswitch(c, l);
1915 c = l->def = abc_label(c);
1916 #ifdef NEED_EXTRA_STACK_ARG
1923 static code_t* insert_finally_simple(code_t*c, code_t*finally, int tempvar)
1927 code_t*prev = i->prev;
1928 if(IS_FINALLY_TARGET(i->opcode)) {
1929 if(i->opcode == OPCODE___RETHROW__)
1930 i->opcode = OPCODE_THROW;
1931 code_t*end = code_dup(finally);
1932 code_t*start = code_start(end);
1933 if(prev) prev->next = start;
1940 return code_append(c, finally);
1943 code_t* insert_finally(code_t*c, code_t*finally, int tempvar)
1949 int num_insertion_points=0;
1951 if(IS_FINALLY_TARGET(i->opcode))
1952 num_insertion_points++;
1959 if(i->branch || i->opcode == OPCODE_LOOKUPSWITCH) {
1964 int simple_version_cost = (1+num_insertion_points)*code_size;
1965 int lookup_version_cost = 4*num_insertion_points + 5;
1967 if(cantdup || simple_version_cost > lookup_version_cost) {
1968 //printf("(use lookup) simple=%d > lookup=%d\n", simple_version_cost, lookup_version_cost);
1969 return insert_finally_lookup(c, finally, tempvar);
1971 //printf("(use simple) simple=%d < lookup=%d\n", simple_version_cost, lookup_version_cost);
1972 return insert_finally_simple(c, finally, tempvar);
1976 #define PASS1 }} if(as3_pass == 1) {{
1977 #define PASS1END }} if(as3_pass == 2) {{
1978 #define PASS2 }} if(as3_pass == 2) {{
1979 #define PASS12 }} if(as3_pass == 1 || as3_pass == 2) {{
1980 #define PASS12END }} if(as3_pass == 2) {{
1981 #define PASS_ALWAYS }} {{
1985 /* Line 273 of skeleton.m4 */
1986 #line 1987 "parser.tab.c"
1987 /* Unqualified %code blocks. */
1989 /* Line 274 of skeleton.m4 */
1990 #line 2077 "parser.y"
1992 char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
1996 char do_init_variable(char*name)
1998 if(!state->method->no_variable_scoping)
2000 if(!state->new_vars)
2006 /* Line 274 of skeleton.m4 */
2007 #line 2528 "parser.y"
2009 static void state_has_imports()
2011 state->wildcard_imports = list_clone(state->wildcard_imports);
2012 state->imports = dict_clone(state->imports);
2013 state->has_own_imports = 1;
2015 static void import_toplevel(const char*package)
2017 char* s = strdup(package);
2019 dict_put(state->import_toplevel_packages, s, 0);
2020 char*x = strrchr(s, '.');
2029 /* Line 274 of skeleton.m4 */
2030 #line 2667 "parser.y"
2032 static int slotstate_varconst = 0;
2033 static modifiers_t*slotstate_flags = 0;
2034 static void setslotstate(modifiers_t* flags, int varconst)
2036 slotstate_varconst = varconst;
2037 slotstate_flags = flags;
2040 if(flags->flags&FLAG_STATIC) {
2041 state->method = state->cls->static_init;
2043 state->method = state->cls->init;
2046 // reset to "default" state (all in class code is static by default) */
2047 state->method = state->cls->static_init;
2050 parserassert(state->method);
2053 static trait_t* add_abc_slot(modifiers_t* modifiers, const char*name, multiname_t*m, code_t***c)
2055 int flags = modifiers->flags;
2056 namespace_t ns = modifiers2access(modifiers);
2059 multiname_t mname = {QNAME, &ns, 0, name};
2061 trait_list_t**traits;
2065 if(!global->init) global->init = abc_initscript(global->file);
2066 ns.name = state->package;
2067 traits = &global->init->traits;
2068 code = &global->init->method->body->code;
2069 } else if(flags&FLAG_STATIC) {
2071 traits = &state->cls->abc->static_traits;
2072 code = &state->cls->static_init->header;
2074 // instance variable
2075 traits = &state->cls->abc->traits;
2076 code = &state->cls->init->header;
2078 if(ns.access == ACCESS_PROTECTED) {
2079 ns.name = concat3(state->cls->info->package,":",state->cls->info->name);
2085 *m = *multiname_clone(&mname);
2087 return trait_new_member(traits, 0, multiname_clone(&mname), 0);
2091 /* Line 274 of skeleton.m4 */
2092 #line 2847 "parser.y"
2094 static int xml_level = 0;
2097 /* Line 274 of skeleton.m4 */
2098 #line 3513 "parser.y"
2100 node_t* resolve_identifier(const char*name);
2101 node_t* get_descendants(node_t*e,const char*ns,const char*subnode,char multi, char attr)
2103 typedcode_t v = node_read(e);
2106 multiname_t m = {0,0,0,subnode};
2107 namespace_t zero = {ZERONAMESPACE,"*"};
2108 if(!strcmp(ns,"*")) {
2110 m.type = attr?QNAMEA:QNAME;
2112 typedcode_t w = node_read(resolve_identifier(ns));
2113 if(!TYPE_IS_NAMESPACE(w.t)) {
2114 as3_softwarning("%s might not be a namespace", ns);
2116 v.c = code_append(v.c, w.c);
2117 v.c = converttype(v.c, w.t, TYPE_NAMESPACE);
2118 m.type = attr?RTQNAMEA:RTQNAME;
2122 v.c = abc_getproperty2(v.c, &m);
2124 v.c = abc_getdescendants2(v.c, &m);
2127 if(TYPE_IS_XML(v.t)) {
2130 v.c = abc_coerce_a(v.c);
2133 return mkcodenode(v);
2137 /* Line 274 of skeleton.m4 */
2138 #line 3684 "parser.y"
2140 node_t* var_read(variable_t*v)
2143 o.c = abc_getlocal(0, v->index);
2145 return mkcodenode(o);
2148 node_t* resolve_identifier(const char*name)
2158 /* look at variables */
2159 if((v = find_variable(state, name))) {
2160 // name is a local variable
2163 if((v = find_slot(state->method, name))) {
2164 o.c = abc_getscopeobject(o.c, 1);
2165 o.c = abc_getslot(o.c, v->index);
2167 return mkcodenode(o);
2170 int i_am_static = state->method->is_static;
2172 /* look at current class' members */
2173 if(!state->method->inner &&
2174 !state->xmlfilter &&
2176 (f = findmember_nsset(state->cls->info, name, 1, i_am_static)))
2178 // name is a member or attribute in this class
2179 int var_is_static = (f->flags&FLAG_STATIC);
2181 if(f->kind == INFOTYPE_VAR && (f->flags&FLAG_CONST)) {
2182 /* if the variable is a constant (and we know what is evaluates to), we
2183 can just use the value itself */
2184 varinfo_t*v = (varinfo_t*)f;
2186 return mkconstnode(v->value);
2190 if(var_is_static >= i_am_static) {
2191 if(f->kind == INFOTYPE_METHOD) {
2192 o.t = TYPE_FUNCTION(f);
2197 if(var_is_static && !i_am_static) {
2198 /* access to a static member from a non-static location.
2199 do this via findpropstrict:
2200 there doesn't seem to be any non-lookup way to access
2201 static properties of a class */
2202 state->method->late_binding = 1;
2204 namespace_t ns = {f->access, f->package};
2205 multiname_t m = {QNAME, &ns, 0, name};
2206 o.c = abc_findpropstrict2(o.c, &m);
2207 o.c = abc_getproperty2(o.c, &m);
2208 return mkcodenode(o);
2209 } else if(f->slot>0) {
2210 o.c = abc_getlocal_0(o.c);
2211 o.c = abc_getslot(o.c, f->slot);
2212 return mkcodenode(o);
2214 MEMBER_MULTINAME(m, f, name);
2215 o.c = abc_getlocal_0(o.c);
2216 o.c = abc_getproperty2(o.c, &m);
2217 return mkcodenode(o);
2222 /* look at actual classes, in the current package and imported */
2223 if(!state->xmlfilter && (a = find_class(name))) {
2224 if(state->cls && state->cls->info == (classinfo_t*)a && i_am_static) {
2225 o.c = abc_getlocal_0(0);
2226 o.t = TYPE_CLASS((classinfo_t*)a);
2230 return mkcodenode(o);
2233 /* look through package prefixes */
2234 if(!state->xmlfilter &&
2235 (dict_contains(state->import_toplevel_packages, name) ||
2236 registry_ispackage(name))) {
2237 o.c = abc___pushpackage__(o.c, (char*)name);
2239 return mkcodenode(o); //?
2242 /* unknown object, let the avm2 resolve it */
2244 if(!state->method->inner && !state->xmlfilter) {
2245 /* we really should make inner functions aware of the class context */
2246 as3_warning("Couldn't resolve '%s', doing late binding", name);
2248 state->method->late_binding = 1;
2250 multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, name};
2253 o.c = abc_findpropstrict2(o.c, &m);
2254 o.c = abc_getproperty2(o.c, &m);
2255 return mkcodenode(o);
2260 /* Line 274 of skeleton.m4 */
2261 #line 3835 "parser.y"
2263 void add_active_url(const char*url)
2267 list_append(state->active_namespace_urls, n);
2272 /* Line 274 of skeleton.m4 */
2273 #line 2274 "parser.tab.c"
2280 typedef YYTYPE_UINT8 yytype_uint8;
2282 typedef unsigned char yytype_uint8;
2286 typedef YYTYPE_INT8 yytype_int8;
2287 #elif (defined __STDC__ || defined __C99__FUNC__ \
2288 || defined __cplusplus || defined _MSC_VER)
2289 typedef signed char yytype_int8;
2291 typedef short int yytype_int8;
2294 #ifdef YYTYPE_UINT16
2295 typedef YYTYPE_UINT16 yytype_uint16;
2297 typedef unsigned short int yytype_uint16;
2301 typedef YYTYPE_INT16 yytype_int16;
2303 typedef short int yytype_int16;
2307 # ifdef __SIZE_TYPE__
2308 # define YYSIZE_T __SIZE_TYPE__
2309 # elif defined size_t
2310 # define YYSIZE_T size_t
2311 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
2312 || defined __cplusplus || defined _MSC_VER)
2313 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
2314 # define YYSIZE_T size_t
2316 # define YYSIZE_T unsigned int
2320 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
2325 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
2326 # define YY_(msgid) dgettext ("bison-runtime", msgid)
2330 # define YY_(msgid) msgid
2334 /* Suppress unused-variable warnings by "using" E. */
2335 #if ! defined lint || defined __GNUC__
2336 # define YYUSE(e) ((void) (e))
2338 # define YYUSE(e) /* empty */
2341 /* Identity function, used to suppress warnings about constant conditions. */
2343 # define YYID(n) (n)
2345 #if (defined __STDC__ || defined __C99__FUNC__ \
2346 || defined __cplusplus || defined _MSC_VER)
2359 #if ! defined yyoverflow || YYERROR_VERBOSE
2361 /* The parser invokes alloca or malloc; define the necessary symbols. */
2363 # ifdef YYSTACK_USE_ALLOCA
2364 # if YYSTACK_USE_ALLOCA
2366 # define YYSTACK_ALLOC __builtin_alloca
2367 # elif defined __BUILTIN_VA_ARG_INCR
2368 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
2370 # define YYSTACK_ALLOC __alloca
2371 # elif defined _MSC_VER
2372 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
2373 # define alloca _alloca
2375 # define YYSTACK_ALLOC alloca
2376 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
2377 || defined __cplusplus || defined _MSC_VER)
2378 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
2380 # define _STDLIB_H 1
2387 # ifdef YYSTACK_ALLOC
2388 /* Pacify GCC's `empty if-body' warning. */
2389 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
2390 # ifndef YYSTACK_ALLOC_MAXIMUM
2391 /* The OS might guarantee only one guard page at the bottom of the stack,
2392 and a page size can be as small as 4096 bytes. So we cannot safely
2393 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
2394 to allow for a few compiler-allocated temporary stack slots. */
2395 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
2398 # define YYSTACK_ALLOC YYMALLOC
2399 # define YYSTACK_FREE YYFREE
2400 # ifndef YYSTACK_ALLOC_MAXIMUM
2401 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
2403 # if (defined __cplusplus && ! defined _STDLIB_H \
2404 && ! ((defined YYMALLOC || defined malloc) \
2405 && (defined YYFREE || defined free)))
2406 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
2408 # define _STDLIB_H 1
2412 # define YYMALLOC malloc
2413 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
2414 || defined __cplusplus || defined _MSC_VER)
2415 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
2419 # define YYFREE free
2420 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
2421 || defined __cplusplus || defined _MSC_VER)
2422 void free (void *); /* INFRINGES ON USER NAME SPACE */
2426 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
2429 #if (! defined yyoverflow \
2430 && (! defined __cplusplus \
2431 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
2433 /* A type that is properly aligned for any stack member. */
2436 yytype_int16 yyss_alloc;
2440 /* The size of the maximum gap between one aligned stack and the next. */
2441 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
2443 /* The size of an array large to enough to hold all stacks, each with
2445 # define YYSTACK_BYTES(N) \
2446 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
2447 + YYSTACK_GAP_MAXIMUM)
2449 /* Copy COUNT objects from FROM to TO. The source and destination do
2452 # if defined __GNUC__ && 1 < __GNUC__
2453 # define YYCOPY(To, From, Count) \
2454 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
2456 # define YYCOPY(To, From, Count) \
2460 for (yyi = 0; yyi < (Count); yyi++) \
2461 (To)[yyi] = (From)[yyi]; \
2467 /* Relocate STACK from its old location to the new one. The
2468 local variables YYSIZE and YYSTACKSIZE give the old and new number of
2469 elements in the stack, and YYPTR gives the new location of the
2470 stack. Advance YYPTR to a properly aligned location for the next
2472 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
2475 YYSIZE_T yynewbytes; \
2476 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
2477 Stack = &yyptr->Stack_alloc; \
2478 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
2479 yyptr += yynewbytes / sizeof (*yyptr); \
2485 /* YYFINAL -- State number of the termination state. */
2487 /* YYLAST -- Last index in YYTABLE. */
2490 /* YYNTOKENS -- Number of terminals. */
2491 #define YYNTOKENS 136
2492 /* YYNNTS -- Number of nonterminals. */
2494 /* YYNRULES -- Number of rules. */
2495 #define YYNRULES 358
2496 /* YYNRULES -- Number of states. */
2497 #define YYNSTATES 612
2499 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
2500 #define YYUNDEFTOK 2
2501 #define YYMAXUTOK 365
2503 #define YYTRANSLATE(YYX) \
2504 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
2506 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
2507 static const yytype_uint8 yytranslate[] =
2509 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2510 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2511 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2512 2, 2, 2, 120, 2, 2, 2, 118, 109, 2,
2513 124, 135, 117, 115, 102, 114, 129, 116, 2, 2,
2514 2, 2, 2, 2, 2, 2, 2, 2, 106, 101,
2515 111, 104, 112, 105, 130, 2, 2, 2, 2, 2,
2516 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2517 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2518 2, 126, 2, 127, 108, 2, 2, 2, 2, 2,
2519 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2520 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2521 2, 2, 2, 128, 107, 134, 119, 2, 2, 2,
2522 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2523 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2524 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2525 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2526 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2527 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2528 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2529 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2530 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2531 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2532 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2533 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2534 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
2535 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2536 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2537 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2538 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
2539 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
2540 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2541 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
2542 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
2543 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
2544 95, 96, 97, 98, 99, 100, 103, 110, 113, 121,
2545 122, 123, 125, 131, 132, 133
2549 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
2551 static const yytype_uint16 yyprhs[] =
2553 0, 0, 3, 5, 6, 8, 10, 13, 15, 17,
2554 19, 21, 23, 25, 30, 32, 33, 35, 37, 40,
2555 42, 44, 46, 48, 50, 55, 60, 62, 64, 65,
2556 68, 70, 72, 74, 76, 78, 80, 82, 84, 86,
2557 88, 90, 92, 94, 96, 100, 103, 105, 107, 109,
2558 111, 113, 115, 117, 122, 125, 127, 129, 130, 134,
2559 137, 138, 141, 144, 146, 150, 154, 155, 158, 159,
2560 162, 169, 170, 172, 174, 178, 180, 183, 187, 196,
2561 203, 209, 216, 218, 221, 223, 226, 227, 229, 231,
2562 234, 236, 239, 244, 248, 249, 258, 259, 269, 270,
2563 276, 278, 281, 283, 286, 288, 289, 296, 299, 301,
2564 306, 309, 311, 313, 315, 317, 319, 323, 325, 326,
2565 333, 334, 340, 343, 346, 351, 352, 354, 356, 359,
2566 361, 363, 365, 367, 369, 371, 373, 375, 377, 379,
2567 380, 383, 384, 387, 388, 391, 392, 402, 403, 412,
2568 413, 415, 417, 420, 422, 427, 429, 431, 433, 434,
2569 436, 438, 441, 443, 446, 455, 457, 459, 460, 465,
2570 467, 471, 475, 476, 479, 481, 483, 485, 487, 489,
2571 491, 493, 495, 497, 499, 501, 503, 504, 505, 510,
2572 511, 516, 517, 520, 523, 526, 529, 533, 535, 537,
2573 538, 540, 547, 558, 570, 572, 575, 577, 581, 585,
2574 589, 593, 594, 596, 599, 604, 608, 610, 615, 618,
2575 620, 622, 623, 624, 637, 639, 640, 641, 652, 654,
2576 658, 660, 662, 664, 668, 670, 672, 674, 677, 678,
2577 679, 683, 684, 686, 688, 690, 693, 696, 697, 702,
2578 707, 712, 715, 717, 720, 722, 724, 726, 730, 732,
2579 736, 737, 739, 741, 743, 745, 747, 749, 753, 759,
2580 761, 763, 765, 767, 769, 771, 773, 775, 777, 779,
2581 783, 787, 791, 795, 799, 803, 807, 811, 815, 819,
2582 823, 827, 830, 833, 837, 841, 845, 849, 853, 857,
2583 861, 865, 869, 873, 877, 881, 885, 889, 893, 896,
2584 899, 901, 905, 908, 913, 917, 921, 925, 929, 933,
2585 937, 941, 945, 949, 953, 957, 961, 967, 970, 973,
2586 976, 979, 983, 986, 987, 994, 996, 998, 1000, 1002,
2587 1004, 1010, 1014, 1020, 1026, 1031, 1038, 1043, 1050, 1057,
2588 1064, 1068, 1070, 1072, 1075, 1080, 1085, 1088, 1093
2591 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
2592 static const yytype_int16 yyrhs[] =
2594 137, 0, -1, 138, -1, -1, 139, -1, 140, -1,
2595 139, 140, -1, 188, -1, 200, -1, 198, -1, 234,
2596 -1, 209, -1, 149, -1, 151, 128, 138, 134, -1,
2597 101, -1, -1, 142, -1, 143, -1, 142, 143, -1,
2598 200, -1, 198, -1, 234, -1, 209, -1, 149, -1,
2599 151, 128, 141, 134, -1, 126, 150, 261, 127, -1,
2600 101, -1, 145, -1, -1, 145, 147, -1, 147, -1,
2601 269, -1, 191, -1, 163, -1, 164, -1, 165, -1,
2602 166, -1, 173, -1, 159, -1, 185, -1, 181, -1,
2603 257, -1, 270, -1, 268, -1, 128, 145, 134, -1,
2604 128, 134, -1, 101, -1, 146, -1, 153, -1, 167,
2605 -1, 168, -1, 253, -1, 183, -1, 151, 128, 145,
2606 134, -1, 147, 101, -1, 147, -1, 146, -1, -1,
2607 3, 91, 3, -1, 104, 261, -1, -1, 46, 154,
2608 -1, 32, 154, -1, 155, -1, 154, 102, 155, -1,
2609 3, 244, 152, -1, -1, 157, 148, -1, -1, 66,
2610 156, -1, 65, 124, 255, 135, 156, 158, -1, -1,
2611 153, -1, 257, -1, 46, 3, 244, -1, 3, -1,
2612 11, 124, -1, 11, 50, 124, -1, 162, 160, 101,
2613 255, 101, 257, 135, 156, -1, 162, 161, 69, 255,
2614 135, 156, -1, 12, 124, 255, 135, 156, -1, 13,
2615 156, 12, 124, 255, 135, -1, 67, -1, 67, 3,
2616 -1, 30, -1, 30, 3, -1, -1, 170, -1, 172,
2617 -1, 170, 172, -1, 171, -1, 170, 171, -1, 34,
2618 261, 106, 144, -1, 62, 106, 144, -1, -1, 14,
2619 124, 174, 261, 135, 128, 169, 134, -1, -1, 33,
2620 124, 3, 244, 135, 176, 128, 144, 134, -1, -1,
2621 27, 128, 178, 144, 134, -1, 175, -1, 179, 175,
2622 -1, 179, -1, 179, 177, -1, 177, -1, -1, 52,
2623 128, 182, 144, 134, 180, -1, 37, 255, -1, 37,
2624 -1, 39, 124, 255, 135, -1, 184, 148, -1, 3,
2625 -1, 17, -1, 16, -1, 29, -1, 4, -1, 187,
2626 129, 186, -1, 186, -1, -1, 17, 187, 128, 189,
2627 141, 134, -1, -1, 17, 128, 190, 141, 134, -1,
2628 41, 3, -1, 41, 240, -1, 41, 187, 129, 117,
2629 -1, -1, 193, -1, 194, -1, 193, 194, -1, 20,
2630 -1, 21, -1, 18, -1, 38, -1, 47, -1, 49,
2631 -1, 48, -1, 25, -1, 23, -1, 4, -1, -1,
2632 54, 241, -1, -1, 54, 242, -1, -1, 15, 242,
2633 -1, -1, 192, 31, 3, 195, 197, 128, 199, 202,
2634 134, -1, -1, 192, 44, 3, 196, 128, 201, 205,
2635 134, -1, -1, 203, -1, 204, -1, 203, 204, -1,
2636 101, -1, 151, 128, 202, 134, -1, 209, -1, 234,
2637 -1, 146, -1, -1, 206, -1, 207, -1, 206, 207,
2638 -1, 101, -1, 46, 3, -1, 192, 26, 233, 3,
2639 124, 230, 135, 244, -1, 46, -1, 32, -1, -1,
2640 192, 208, 210, 211, -1, 212, -1, 211, 102, 212,
2641 -1, 3, 244, 152, -1, -1, 104, 261, -1, 8,
2642 -1, 9, -1, 10, -1, 5, -1, 56, -1, 55,
2643 -1, 45, -1, 28, -1, 29, -1, 227, -1, 111,
2644 -1, 112, -1, -1, -1, 128, 261, 220, 134, -1,
2645 -1, 128, 261, 222, 134, -1, -1, 223, 219, -1,
2646 223, 5, -1, 223, 112, -1, 227, 223, -1, 224,
2647 227, 223, -1, 3, -1, 221, -1, -1, 228, -1,
2648 216, 225, 226, 116, 218, 112, -1, 216, 225, 226,
2649 217, 223, 111, 116, 225, 218, 112, -1, 216, 225,
2650 226, 217, 223, 224, 111, 116, 225, 218, 112, -1,
2651 229, -1, 228, 229, -1, 221, -1, 221, 104, 5,
2652 -1, 221, 104, 221, -1, 3, 104, 221, -1, 3,
2653 104, 5, -1, -1, 231, -1, 95, 232, -1, 231,
2654 102, 95, 232, -1, 231, 102, 232, -1, 232, -1,
2655 3, 106, 243, 213, -1, 3, 213, -1, 51, -1,
2656 35, -1, -1, -1, 192, 26, 233, 3, 124, 230,
2657 135, 244, 128, 235, 144, 134, -1, 3, -1, -1,
2658 -1, 26, 236, 124, 230, 135, 244, 128, 238, 144,
2659 134, -1, 186, -1, 187, 129, 186, -1, 240, -1,
2660 239, -1, 241, -1, 242, 102, 241, -1, 241, -1,
2661 117, -1, 36, -1, 106, 243, -1, -1, -1, 124,
2662 246, 135, -1, -1, 247, -1, 248, -1, 254, -1,
2663 247, 102, -1, 248, 254, -1, -1, 24, 261, 249,
2664 245, -1, 261, 124, 246, 135, -1, 53, 124, 246,
2665 135, -1, 64, 261, -1, 42, -1, 42, 255, -1,
2666 261, -1, 256, -1, 261, -1, 256, 102, 261, -1,
2667 261, -1, 257, 102, 261, -1, -1, 260, -1, 3,
2668 -1, 5, -1, 8, -1, 9, -1, 10, -1, 259,
2669 106, 254, -1, 260, 102, 259, 106, 254, -1, 237,
2670 -1, 265, -1, 250, -1, 252, -1, 251, -1, 266,
2671 -1, 214, -1, 215, -1, 6, -1, 19, -1, 126,
2672 246, 127, -1, 71, 258, 134, -1, 261, 111, 261,
2673 -1, 261, 112, 261, -1, 261, 76, 261, -1, 261,
2674 77, 261, -1, 261, 72, 261, -1, 261, 73, 261,
2675 -1, 261, 75, 261, -1, 261, 74, 261, -1, 261,
2676 89, 261, -1, 261, 90, 261, -1, 120, 261, -1,
2677 119, 261, -1, 261, 109, 261, -1, 261, 108, 261,
2678 -1, 261, 107, 261, -1, 261, 98, 261, -1, 261,
2679 97, 261, -1, 261, 96, 261, -1, 261, 116, 261,
2680 -1, 261, 118, 261, -1, 261, 115, 261, -1, 261,
2681 114, 261, -1, 261, 117, 261, -1, 261, 69, 261,
2682 -1, 261, 70, 261, -1, 261, 40, 261, -1, 261,
2683 68, 261, -1, 43, 261, -1, 36, 261, -1, 36,
2684 -1, 124, 256, 135, -1, 114, 261, -1, 261, 126,
2685 261, 127, -1, 261, 81, 261, -1, 261, 80, 261,
2686 -1, 261, 87, 261, -1, 261, 86, 261, -1, 261,
2687 88, 261, -1, 261, 79, 261, -1, 261, 78, 261,
2688 -1, 261, 85, 261, -1, 261, 82, 261, -1, 261,
2689 83, 261, -1, 261, 84, 261, -1, 261, 104, 261,
2690 -1, 261, 105, 261, 106, 261, -1, 261, 93, -1,
2691 261, 92, -1, 93, 261, -1, 92, 261, -1, 53,
2692 129, 3, -1, 130, 3, -1, -1, 261, 129, 124,
2693 262, 261, 135, -1, 3, -1, 117, -1, 4, -1,
2694 186, -1, 117, -1, 261, 129, 263, 91, 264, -1,
2695 261, 94, 264, -1, 261, 94, 263, 91, 264, -1,
2696 261, 129, 126, 261, 127, -1, 261, 129, 130, 264,
2697 -1, 261, 129, 130, 263, 91, 264, -1, 261, 94,
2698 130, 264, -1, 261, 94, 130, 263, 91, 264, -1,
2699 261, 129, 130, 126, 261, 127, -1, 261, 94, 130,
2700 126, 261, 127, -1, 261, 129, 264, -1, 4, -1,
2701 3, -1, 16, 3, -1, 16, 3, 104, 3, -1,
2702 16, 3, 104, 5, -1, 192, 267, -1, 63, 16,
2703 104, 261, -1, 22, 16, 241, -1
2706 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
2707 static const yytype_uint16 yyrline[] =
2709 0, 1968, 1968, 1970, 1970, 1971, 1972, 1974, 1975, 1976,
2710 1977, 1978, 1979, 1980, 1981, 1983, 1983, 1984, 1985, 1987,
2711 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1999,
2712 2002, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013,
2713 2014, 2015, 2016, 2017, 2018, 2019, 2022, 2023, 2024, 2025,
2714 2026, 2027, 2028, 2029, 2041, 2042, 2046, 2057, 2065, 2092,
2715 2093, 2095, 2096, 2098, 2099, 2101, 2162, 2162, 2166, 2167,
2716 2170, 2186, 2187, 2188, 2193, 2197, 2202, 2203, 2205, 2225,
2717 2269, 2285, 2297, 2300, 2303, 2306, 2310, 2311, 2312, 2313,
2718 2314, 2315, 2317, 2328, 2331, 2331, 2362, 2362, 2387, 2387,
2719 2403, 2404, 2405, 2406, 2414, 2423, 2423, 2472, 2476, 2487,
2720 2497, 2514, 2515, 2516, 2517, 2518, 2520, 2521, 2523, 2523,
2721 2525, 2525, 2549, 2557, 2568, 2584, 2585, 2586, 2587, 2594,
2722 2595, 2596, 2597, 2598, 2599, 2600, 2601, 2602, 2603, 2607,
2723 2608, 2610, 2611, 2613, 2614, 2618, 2616, 2624, 2622, 2631,
2724 2632, 2633, 2634, 2635, 2636, 2637, 2638, 2640, 2646, 2647,
2725 2648, 2649, 2650, 2651, 2654, 2727, 2727, 2729, 2729, 2731,
2726 2732, 2734, 2818, 2819, 2828, 2829, 2832, 2833, 2834, 2835,
2727 2836, 2837, 2838, 2851, 2862, 2863, 2864, 2866, 2866, 2869,
2728 2869, 2872, 2873, 2876, 2881, 2884, 2887, 2890, 2893, 2897,
2729 2900, 2904, 2908, 2913, 2919, 2922, 2925, 2928, 2933, 2936,
2730 2939, 2949, 2953, 2959, 2965, 2973, 2978, 2984, 2992, 3000,
2731 3001, 3002, 3005, 3004, 3021, 3022, 3024, 3023, 3047, 3066,
2732 3080, 3081, 3083, 3084, 3086, 3087, 3088, 3097, 3098, 3102,
2733 3103, 3105, 3106, 3107, 3109, 3113, 3114, 3119, 3120, 3167,
2734 3217, 3238, 3260, 3263, 3270, 3273, 3276, 3279, 3282, 3285,
2735 3290, 3291, 3293, 3294, 3295, 3296, 3297, 3299, 3305, 3314,
2736 3315, 3316, 3317, 3318, 3319, 3321, 3325, 3330, 3348, 3359,
2737 3369, 3378, 3379, 3380, 3381, 3382, 3383, 3384, 3385, 3386,
2738 3387, 3388, 3389, 3390, 3391, 3392, 3393, 3394, 3395, 3396,
2739 3397, 3398, 3399, 3400, 3401, 3402, 3403, 3404, 3405, 3406,
2740 3407, 3408, 3409, 3410, 3411, 3412, 3413, 3414, 3415, 3416,
2741 3417, 3418, 3419, 3420, 3421, 3422, 3423, 3425, 3426, 3427,
2742 3428, 3430, 3445, 3453, 3453, 3507, 3508, 3509, 3510, 3511,
2743 3551, 3554, 3561, 3564, 3575, 3583, 3587, 3594, 3598, 3608,
2744 3619, 3806, 3810, 3844, 3851, 3858, 3865, 3887, 3894
2748 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
2749 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2750 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
2751 static const char *const yytname[] =
2753 "$end", "error", "$undefined", "T_IDENTIFIER", "T_NAMESPACE",
2754 "T_STRING", "T_REGEXP", "T_EMPTY", "T_INT", "T_UINT", "T_FLOAT",
2755 "\"for\"", "\"while\"", "\"do\"", "\"switch\"", "\"implements\"",
2756 "\"namespace\"", "\"package\"", "\"protected\"", "\"arguments\"",
2757 "\"public\"", "\"private\"", "\"use\"", "\"internal\"", "\"new\"",
2758 "\"native\"", "\"function\"", "\"finally\"", "\"undefined\"", "\"NaN\"",
2759 "\"continue\"", "\"class\"", "\"const\"", "\"catch\"", "\"case\"",
2760 "\"set\"", "\"void\"", "\"throw\"", "\"static\"", "\"with\"",
2761 "\"instanceof\"", "\"import\"", "\"return\"", "\"typeof\"",
2762 "\"interface\"", "\"null\"", "\"var\"", "\"dynamic\"", "\"override\"",
2763 "\"final\"", "\"each\"", "\"get\"", "\"try\"", "\"super\"",
2764 "\"extends\"", "\"false\"", "\"true\"", "\"Boolean\"", "\"uint\"",
2765 "\"int\"", "\"Number\"", "\"String\"", "\"default\"", "\"default xml\"",
2766 "\"delete\"", "\"if\"", "\"else\"", "\"break\"", "\"is\"", "\"in\"",
2767 "\"as\"", "\"{ (dictionary)\"", "\"==\"", "\"===\"", "\"!=\"", "\"!==\"",
2768 "\"<=\"", "\">=\"", "\"|=\"", "\"/=\"", "\"%=\"", "\"*=\"", "\"&=\"",
2769 "\"+=\"", "\"-=\"", "\"^=\"", "\">>=\"", "\"<<=\"", "\">>>=\"", "\"||\"",
2770 "\"&&\"", "\"::\"", "\"--\"", "\"++\"", "\"..\"", "\"...\"", "\"<<\"",
2771 "\">>>\"", "\">>\"", "prec_none", "below_semicolon", "';'", "','",
2772 "below_assignment", "'='", "'?'", "':'", "'|'", "'^'", "'&'", "below_lt",
2773 "'<'", "'>'", "below_minus", "'-'", "'+'", "'/'", "'*'", "'%'", "'~'",
2774 "'!'", "minusminus_prefix", "plusplus_prefix", "below_curly", "'('",
2775 "new2", "'['", "']'", "'{'", "'.'", "'@'", "above_identifier",
2776 "below_else", "above_function", "'}'", "')'", "$accept", "PROGRAM",
2777 "MAYBE_PROGRAM_CODE_LIST", "PROGRAM_CODE_LIST", "PROGRAM_CODE",
2778 "MAYBE_INPACKAGE_CODE_LIST", "INPACKAGE_CODE_LIST", "INPACKAGE_CODE",
2779 "MAYBECODE", "CODE", "CODE_STATEMENT", "CODEPIECE", "CODEBLOCK",
2780 "PACKAGE_INITCODE", "EMBED_START", "CONDITIONAL_COMPILATION",
2781 "MAYBEEXPRESSION", "VARIABLE_DECLARATION", "VARIABLE_LIST",
2782 "ONE_VARIABLE", "IF_CODEBLOCK", "$@1", "MAYBEELSE", "IF", "FOR_INIT",
2783 "FOR_IN_INIT", "FOR_START", "FOR", "FOR_IN", "WHILE", "DO_WHILE",
2784 "BREAK", "CONTINUE", "MAYBE_CASE_LIST", "CASE_LIST", "CASE", "DEFAULT",
2785 "SWITCH", "$@2", "CATCH", "$@3", "FINALLY", "$@4", "CATCH_LIST",
2786 "CATCH_FINALLY_LIST", "TRY", "$@5", "THROW", "WITH_HEAD", "WITH",
2787 "X_IDENTIFIER", "PACKAGE", "PACKAGE_DECLARATION", "$@6", "$@7", "IMPORT",
2788 "MAYBE_MODIFIERS", "MODIFIER_LIST", "MODIFIER", "EXTENDS",
2789 "EXTENDS_LIST", "IMPLEMENTS_LIST", "CLASS_DECLARATION", "$@8",
2790 "INTERFACE_DECLARATION", "$@9", "MAYBE_CLASS_BODY", "CLASS_BODY",
2791 "CLASS_BODY_ITEM", "MAYBE_INTERFACE_BODY", "INTERFACE_BODY",
2792 "IDECLARATION", "VARCONST", "SLOT_DECLARATION", "$@10", "SLOT_LIST",
2793 "ONE_SLOT", "MAYBECONSTANT", "CONSTANT", "XML", "OPEN", "CLOSE",
2794 "CLOSE2", "XMLEXPR1", "$@11", "XMLEXPR2", "$@12", "XMLTEXT", "XML2",
2795 "XML_ID_OR_EXPR", "MAYBE_XMLATTRIBUTES", "XMLNODE", "XMLATTRIBUTES",
2796 "XMLATTRIBUTE", "MAYBE_PARAM_LIST", "PARAM_LIST", "PARAM", "GETSET",
2797 "FUNCTION_DECLARATION", "$@13", "MAYBE_IDENTIFIER", "INNERFUNCTION",
2798 "$@14", "CLASS", "PACKAGEANDCLASS", "CLASS_SPEC", "CLASS_SPEC_LIST",
2799 "TYPE", "MAYBETYPE", "MAYBE_PARAM_VALUES", "MAYBE_EXPRESSION_LIST",
2800 "EXPRESSION_LIST", "EXPRESSION_LIST_AND_COMMA", "XX", "NEW",
2801 "FUNCTIONCALL", "DELETE", "RETURN", "NONCOMMAEXPRESSION", "EXPRESSION",
2802 "COMMA_EXPRESSION", "VOIDEXPRESSION", "MAYBE_DICT_EXPRPAIR_LIST",
2803 "DICTLH", "DICT_EXPRPAIR_LIST", "E", "$@15", "ID_OR_NS", "SUBNODE",
2804 "MEMBER", "VAR_READ", "NAMESPACE_ID", "NAMESPACE_DECLARATION",
2805 "DEFAULT_NAMESPACE", "USE_NAMESPACE", 0
2810 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
2812 static const yytype_uint16 yytoknum[] =
2814 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
2815 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
2816 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
2817 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
2818 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
2819 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
2820 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
2821 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
2822 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
2823 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
2824 355, 59, 44, 356, 61, 63, 58, 124, 94, 38,
2825 357, 60, 62, 358, 45, 43, 47, 42, 37, 126,
2826 33, 359, 360, 361, 40, 362, 91, 93, 123, 46,
2827 64, 363, 364, 365, 125, 41
2831 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
2832 static const yytype_uint16 yyr1[] =
2834 0, 136, 137, 138, 138, 139, 139, 140, 140, 140,
2835 140, 140, 140, 140, 140, 141, 141, 142, 142, 143,
2836 143, 143, 143, 143, 143, 143, 143, 144, 144, 145,
2837 145, 146, 146, 146, 146, 146, 146, 146, 146, 146,
2838 146, 146, 146, 146, 146, 146, 147, 147, 147, 147,
2839 147, 147, 147, 147, 148, 148, 149, 150, 151, 152,
2840 152, 153, 153, 154, 154, 155, 157, 156, 158, 158,
2841 159, 160, 160, 160, 161, 161, 162, 162, 163, 164,
2842 165, 166, 167, 167, 168, 168, 169, 169, 169, 169,
2843 170, 170, 171, 172, 174, 173, 176, 175, 178, 177,
2844 179, 179, 180, 180, 180, 182, 181, 183, 183, 184,
2845 185, 186, 186, 186, 186, 186, 187, 187, 189, 188,
2846 190, 188, 191, 191, 191, 192, 192, 193, 193, 194,
2847 194, 194, 194, 194, 194, 194, 194, 194, 194, 195,
2848 195, 196, 196, 197, 197, 199, 198, 201, 200, 202,
2849 202, 203, 203, 204, 204, 204, 204, 204, 205, 205,
2850 206, 206, 207, 207, 207, 208, 208, 210, 209, 211,
2851 211, 212, 213, 213, 214, 214, 214, 214, 214, 214,
2852 214, 214, 214, 215, 216, 217, 218, 220, 219, 222,
2853 221, 223, 223, 223, 223, 224, 224, 225, 225, 226,
2854 226, 227, 227, 227, 228, 228, 229, 229, 229, 229,
2855 229, 230, 230, 230, 230, 231, 231, 232, 232, 233,
2856 233, 233, 235, 234, 236, 236, 238, 237, 239, 240,
2857 241, 241, 242, 242, 243, 243, 243, 244, 244, 245,
2858 245, 246, 246, 246, 247, 248, 247, 249, 250, 251,
2859 251, 252, 253, 253, 254, 255, 256, 256, 257, 257,
2860 258, 258, 259, 259, 259, 259, 259, 260, 260, 261,
2861 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
2862 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
2863 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
2864 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
2865 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
2866 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
2867 261, 261, 261, 262, 261, 263, 263, 263, 264, 264,
2868 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
2869 265, 266, 266, 267, 267, 267, 268, 269, 270
2872 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
2873 static const yytype_uint8 yyr2[] =
2875 0, 2, 1, 0, 1, 1, 2, 1, 1, 1,
2876 1, 1, 1, 4, 1, 0, 1, 1, 2, 1,
2877 1, 1, 1, 1, 4, 4, 1, 1, 0, 2,
2878 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2879 1, 1, 1, 1, 3, 2, 1, 1, 1, 1,
2880 1, 1, 1, 4, 2, 1, 1, 0, 3, 2,
2881 0, 2, 2, 1, 3, 3, 0, 2, 0, 2,
2882 6, 0, 1, 1, 3, 1, 2, 3, 8, 6,
2883 5, 6, 1, 2, 1, 2, 0, 1, 1, 2,
2884 1, 2, 4, 3, 0, 8, 0, 9, 0, 5,
2885 1, 2, 1, 2, 1, 0, 6, 2, 1, 4,
2886 2, 1, 1, 1, 1, 1, 3, 1, 0, 6,
2887 0, 5, 2, 2, 4, 0, 1, 1, 2, 1,
2888 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
2889 2, 0, 2, 0, 2, 0, 9, 0, 8, 0,
2890 1, 1, 2, 1, 4, 1, 1, 1, 0, 1,
2891 1, 2, 1, 2, 8, 1, 1, 0, 4, 1,
2892 3, 3, 0, 2, 1, 1, 1, 1, 1, 1,
2893 1, 1, 1, 1, 1, 1, 0, 0, 4, 0,
2894 4, 0, 2, 2, 2, 2, 3, 1, 1, 0,
2895 1, 6, 10, 11, 1, 2, 1, 3, 3, 3,
2896 3, 0, 1, 2, 4, 3, 1, 4, 2, 1,
2897 1, 0, 0, 12, 1, 0, 0, 10, 1, 3,
2898 1, 1, 1, 3, 1, 1, 1, 2, 0, 0,
2899 3, 0, 1, 1, 1, 2, 2, 0, 4, 4,
2900 4, 2, 1, 2, 1, 1, 1, 3, 1, 3,
2901 0, 1, 1, 1, 1, 1, 1, 3, 5, 1,
2902 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
2903 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
2904 3, 2, 2, 3, 3, 3, 3, 3, 3, 3,
2905 3, 3, 3, 3, 3, 3, 3, 3, 2, 2,
2906 1, 3, 2, 4, 3, 3, 3, 3, 3, 3,
2907 3, 3, 3, 3, 3, 3, 5, 2, 2, 2,
2908 2, 3, 2, 0, 6, 1, 1, 1, 1, 1,
2909 5, 3, 5, 5, 4, 6, 4, 6, 6, 6,
2910 3, 1, 1, 2, 4, 4, 2, 4, 3
2913 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
2914 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
2915 means the default is an error. */
2916 static const yytype_uint16 yydefact[] =
2918 125, 352, 351, 177, 277, 174, 175, 176, 0, 0,
2919 66, 0, 0, 131, 278, 129, 130, 0, 137, 0,
2920 136, 225, 181, 182, 310, 132, 0, 0, 0, 180,
2921 133, 135, 134, 0, 0, 179, 178, 0, 0, 0,
2922 260, 0, 0, 14, 184, 0, 0, 0, 0, 241,
2923 125, 0, 0, 2, 125, 5, 56, 12, 0, 38,
2924 71, 33, 34, 35, 36, 37, 40, 125, 39, 7,
2925 32, 0, 126, 127, 9, 8, 11, 275, 276, 0,
2926 183, 10, 269, 271, 273, 272, 41, 258, 270, 274,
2927 43, 31, 42, 0, 0, 76, 0, 0, 125, 94,
2928 111, 115, 113, 112, 114, 120, 117, 0, 0, 352,
2929 351, 247, 224, 0, 309, 0, 122, 0, 123, 308,
2930 105, 241, 0, 0, 251, 0, 262, 263, 264, 265,
2931 266, 0, 0, 261, 330, 329, 312, 292, 291, 0,
2932 256, 0, 242, 243, 244, 254, 84, 0, 108, 252,
2933 0, 82, 46, 45, 125, 47, 30, 0, 48, 49,
2934 50, 52, 0, 51, 332, 1, 6, 125, 352, 0,
2935 72, 0, 0, 73, 55, 110, 0, 221, 0, 166,
2936 0, 165, 167, 356, 138, 128, 197, 0, 198, 199,
2937 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2938 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2939 0, 0, 0, 0, 328, 327, 0, 0, 0, 0,
2940 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2941 0, 0, 241, 0, 0, 58, 77, 0, 255, 0,
2942 67, 0, 125, 118, 0, 228, 0, 231, 230, 358,
2943 239, 211, 0, 0, 28, 0, 331, 0, 0, 280,
2944 0, 0, 0, 311, 279, 245, 246, 85, 238, 62,
2945 63, 107, 253, 61, 83, 44, 29, 125, 0, 238,
2946 0, 0, 54, 353, 220, 219, 0, 139, 141, 0,
2947 189, 0, 206, 0, 200, 204, 259, 306, 307, 304,
2948 305, 285, 286, 288, 287, 283, 284, 320, 319, 315,
2949 314, 322, 323, 324, 321, 317, 316, 318, 289, 290,
2950 111, 115, 339, 0, 338, 0, 341, 298, 297, 296,
2951 325, 0, 295, 294, 293, 281, 282, 302, 301, 299,
2952 303, 300, 0, 0, 333, 0, 0, 0, 350, 66,
2953 0, 0, 26, 57, 0, 125, 17, 23, 0, 20,
2954 19, 22, 21, 125, 116, 0, 241, 248, 172, 0,
2955 0, 212, 216, 109, 124, 229, 0, 27, 250, 357,
2956 66, 267, 0, 257, 0, 60, 0, 125, 13, 60,
2957 0, 0, 0, 0, 0, 143, 0, 0, 238, 168,
2958 169, 0, 0, 0, 185, 186, 191, 205, 0, 0,
2959 346, 0, 0, 249, 313, 0, 0, 0, 0, 344,
2960 0, 80, 0, 0, 0, 121, 18, 125, 0, 0,
2961 0, 0, 218, 213, 238, 0, 0, 68, 0, 236,
2962 235, 234, 237, 0, 65, 64, 53, 0, 66, 354,
2963 355, 211, 140, 0, 0, 232, 142, 147, 60, 0,
2964 190, 210, 209, 207, 208, 0, 0, 0, 0, 339,
2965 342, 326, 0, 343, 0, 0, 340, 81, 86, 0,
2966 0, 119, 240, 173, 172, 0, 0, 215, 0, 0,
2967 100, 104, 102, 106, 66, 70, 268, 59, 0, 79,
2968 0, 144, 145, 0, 125, 171, 170, 201, 193, 184,
2969 194, 0, 192, 0, 191, 349, 347, 334, 348, 345,
2970 0, 0, 0, 87, 90, 88, 25, 24, 217, 226,
2971 214, 98, 0, 101, 103, 69, 66, 238, 125, 233,
2972 0, 162, 0, 0, 125, 160, 0, 187, 184, 191,
2973 195, 0, 28, 95, 91, 89, 28, 28, 238, 78,
2974 0, 153, 157, 0, 0, 0, 125, 151, 155, 156,
2975 163, 221, 148, 161, 186, 0, 0, 196, 28, 93,
2976 0, 0, 0, 222, 125, 146, 152, 0, 0, 188,
2977 186, 92, 227, 99, 96, 28, 0, 0, 202, 0,
2978 0, 0, 154, 211, 203, 28, 223, 0, 0, 238,
2982 /* YYDEFGOTO[NTERM-NUM]. */
2983 static const yytype_int16 yydefgoto[] =
2985 -1, 52, 53, 54, 55, 354, 355, 356, 376, 377,
2986 155, 156, 175, 357, 424, 157, 444, 158, 273, 270,
2987 97, 98, 495, 59, 171, 172, 60, 61, 62, 63,
2988 64, 159, 160, 522, 523, 524, 525, 65, 241, 490,
2989 600, 491, 557, 492, 493, 66, 254, 161, 67, 68,
2990 324, 246, 69, 363, 242, 70, 162, 72, 73, 395,
2991 397, 454, 359, 538, 360, 504, 565, 566, 567, 543,
2992 544, 545, 182, 361, 289, 399, 400, 432, 77, 78,
2993 79, 406, 465, 512, 575, 188, 401, 466, 513, 189,
2994 293, 80, 294, 295, 370, 371, 372, 286, 362, 595,
2995 113, 82, 556, 247, 248, 441, 456, 442, 385, 367,
2996 141, 142, 143, 250, 83, 84, 85, 163, 144, 237,
2997 238, 86, 131, 132, 133, 87, 415, 325, 326, 88,
3001 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
3003 #define YYPACT_NINF -501
3004 static const yytype_int16 yypact[] =
3006 1777, -27, 777, -501, -501, -501, -501, -501, -25, -48,
3007 -501, -47, 258, -501, -501, -501, -501, 73, -501, 2113,
3008 -501, 107, -501, -501, 2170, -501, -8, 363, 2113, -501,
3009 -501, -501, -501, -9, -17, -501, -501, 117, 2113, 35,
3010 153, 2113, 2113, -501, -501, 2113, 2113, 2113, 2113, 2113,
3011 721, 135, 141, -501, 589, -501, -501, -501, 23, -501,
3012 434, -501, -501, -501, -501, -501, -501, 2033, -501, -501,
3013 -501, 362, 453, -501, -501, -501, -501, -501, -501, 14,
3014 -501, -501, -501, -501, -501, -501, 74, 2865, -501, -501,
3015 -501, -501, -501, 174, 100, -501, 2113, 223, 2033, -501,
3016 -501, -501, -501, -501, -501, -501, -501, 98, 418, -501,
3017 -501, -34, -501, 112, -24, 2113, 110, 122, -501, -24,
3018 -501, 2113, 255, 156, -24, 2113, -501, -501, -501, -501,
3019 -501, 129, 158, 163, -24, -24, 818, -24, -24, -55,
3020 2803, 139, 168, 2113, -501, 2803, 268, 275, 2113, 2113,
3021 275, 282, -501, -501, 853, -501, -501, 165, -501, -501,
3022 -501, -501, 279, -501, -501, -501, -501, 1117, 222, 296,
3023 -501, 203, 237, 74, 206, -501, 310, 27, 311, -501,
3024 312, -501, -501, -501, -501, -501, -501, 2113, -501, 15,
3025 2113, 2113, 2113, 2113, 2113, 2113, 2113, 2113, 2113, 2113,
3026 2113, 2113, 2113, 2113, 2113, 2113, 2113, 2113, 2113, 2113,
3027 2113, 2113, 2113, 2113, -501, -501, 36, 2113, 2113, 2113,
3028 2113, 2113, 2113, 2113, 2113, 2113, 2113, 2113, 2113, 2113,
3029 2113, 2113, 2113, 2113, 123, -501, -501, 181, 215, 195,
3030 -501, 2113, 1249, -501, 418, 192, 194, -501, -501, -501,
3031 207, 25, 197, 344, 1905, 199, -501, 2113, 201, -501,
3032 2113, 153, 2113, -501, -501, -501, -501, -501, 236, 238,
3033 -501, -501, -501, 238, -501, -501, -501, 2033, 209, 236,
3034 2113, 2113, -501, 241, -501, -501, 343, 295, 298, 347,
3035 2803, 249, 265, 38, 15, -501, 2803, 1109, 581, 581,
3036 581, 3237, 3237, 3237, 3237, 1109, 1109, 2803, 2803, 2803,
3037 2803, 2803, 2803, 2803, 2803, 2803, 2803, 2803, 2927, 2989,
3038 271, 283, 284, 273, -501, 285, -501, 713, 713, 713,
3039 2803, 2369, 3051, 3113, 3175, 1109, 1109, 818, 818, -24,
3040 -24, -24, 224, 2431, -501, 2113, 293, 291, -501, -501,
3041 2113, 2229, -501, 243, 257, 1381, -501, -501, 270, -501,
3042 -501, -501, -501, 1249, -501, 418, 2113, -501, 68, 380,
3043 267, 302, -501, -501, -501, 278, 277, 1905, -501, 2803,
3044 -501, -501, 303, 2803, 308, 309, 275, 985, -501, -19,
3045 314, 281, 220, 299, 418, 402, 418, 292, 236, 328,
3046 -501, 307, 18, 19, -501, -501, -501, -501, 2113, 341,
3047 -501, 368, 2113, -501, -501, 2113, 2493, 2113, 342, -501,
3048 368, -501, 301, 317, 2113, -501, -501, 1249, 315, 313,
3049 2113, 308, -501, -501, 236, 28, 48, 384, 2113, -501,
3050 -501, -501, -501, 2113, -501, -501, -501, 2113, -501, -501,
3051 -501, 25, -501, 418, 323, -501, 350, -501, 309, 347,
3052 -501, -501, -501, -501, -501, 352, 37, 2555, 368, -501,
3053 -501, 2803, 2299, -501, 2617, 368, -501, -501, 49, 2679,
3054 320, -501, -501, 2803, 351, 331, 380, -501, 337, 332,
3055 -501, -501, 48, -501, -501, -501, -501, 2803, -29, -501,
3056 333, 350, -501, 418, 234, -501, -501, -501, -501, 353,
3057 -501, 2113, -501, 356, -501, -501, -501, -501, -501, -501,
3058 2113, 366, 348, 49, -501, -501, -501, -501, -501, -501,
3059 -501, -501, 472, -501, -501, -501, -501, 236, 1513, -501,
3060 478, -501, 457, 354, 280, -501, 14, 2803, 370, -501,
3061 17, 2741, 1905, -501, -501, -501, 1905, 1905, 236, -501,
3062 364, -501, -501, 365, 72, 360, 1645, -501, -501, -501,
3063 -501, 27, -501, -501, -501, 361, 14, 17, 1905, -501,
3064 369, 372, 349, -501, 1513, -501, -501, 494, 395, -501,
3065 -501, -501, -501, -501, -501, 1905, 375, 386, -501, 399,
3066 385, 378, -501, 25, -501, 1905, -501, 379, 381, 236,
3070 /* YYPGOTO[NTERM-NUM]. */
3071 static const yytype_int16 yypgoto[] =
3073 -501, -501, 355, -501, 462, -331, -501, 162, -470, -36,
3074 1, -57, 420, 61, -501, 2, 62, 459, 374, 137,
3075 -334, -501, -501, -501, -501, -501, -501, -501, -501, -501,
3076 -501, -501, -501, -501, -501, 5, 6, -501, -501, 32,
3077 -501, 33, -501, -501, -501, -501, -501, -501, -501, -501,
3078 -7, 39, -501, -501, -501, -501, 0, -501, 458, -501,
3079 -501, -501, 63, -501, 67, -501, -53, -501, -33, -501,
3080 -501, -10, -501, 3, -501, -501, 76, 52, -501, -501,
3081 -501, -501, -500, -501, -501, -170, -501, -455, -501, -497,
3082 -501, -422, -501, 252, -430, -501, -342, -39, 4, -501,
3083 -501, -501, -501, -501, 510, -102, 90, 116, -270, -501,
3084 -110, -501, -501, -501, -501, -501, -501, -501, -130, -77,
3085 501, -52, -501, 289, -501, -12, -501, -191, -189, -501,
3086 -501, -501, -501, -501, -501
3089 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
3090 positive, shift that token. If negative, reduce the rule which
3091 number is the opposite. If zero, do what YYDEFACT says.
3092 If YYTABLE_NINF, syntax error. */
3093 #define YYTABLE_NINF -338
3094 static const yytype_int16 yytable[] =
3096 71, 56, 58, 76, 81, 106, 249, 111, 173, 389,
3097 174, 255, 114, 266, 154, 421, 119, 186, 291, 292,
3098 106, 500, 508, 461, 463, 94, 124, 433, 368, 134,
3099 135, 368, 428, 136, 137, 138, 140, 145, 252, 320,
3100 321, 174, 508, 347, 514, 348, 437, 262, 258, 574,
3101 -74, 107, 102, 103, 71, 56, 58, 76, 81, 550,
3102 216, 57, 284, 74, 93, 104, 117, 75, 214, 215,
3103 216, 271, 272, 190, 588, 488, 96, 99, 285, 590,
3104 263, 489, 579, 520, 140, 443, 580, 581, 176, 108,
3105 599, 549, 233, 487, 577, 234, 480, 276, 177, 95,
3106 232, 245, 233, 140, 179, 234, 536, 121, 591, 145,
3107 112, 521, 122, 140, 499, 57, 115, 74, 181, 120,
3108 369, 75, 342, 486, 292, 601, 320, 321, 458, 510,
3109 381, 145, 409, 123, 410, 608, 140, 140, 164, 102,
3110 103, 165, 187, 187, 530, 511, 187, 187, 509, 510,
3111 404, 167, 104, 322, 405, 418, 126, 419, 127, 125,
3112 535, 128, 129, 130, 485, 511, 323, 71, 56, 58,
3113 76, 81, 430, 607, 431, 290, 190, 235, 296, 297,
3114 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
3115 308, 309, 310, 311, 312, 313, 314, 315, 316, 317,
3116 318, 319, 559, 390, 391, 327, 328, 329, 330, 331,
3117 332, 333, 334, 335, 336, 337, 338, 339, 340, 341,
3118 145, 343, 470, 449, 236, 450, 243, 244, 57, 351,
3119 74, 476, 462, 464, 75, 239, 251, 364, 184, -111,
3120 322, 387, 71, 56, 358, 379, 375, 344, 145, 345,
3121 383, 253, 13, 346, 15, 16, 429, 18, 256, 20,
3122 257, 100, 101, 259, 260, 261, 264, 560, 140, 140,
3123 265, 267, 25, 422, 102, 103, 320, 321, 268, 516,
3124 540, 30, 31, 32, 184, 274, 519, 104, 582, 102,
3125 103, -75, 452, 277, 455, 176, 320, 321, 13, 279,
3126 15, 16, 104, 18, 280, 20, 281, 282, 496, 102,
3127 103, 100, 101, 283, 287, 288, 349, 262, 25, 350,
3128 276, -117, 104, 365, 102, 103, 540, 30, 31, 32,
3129 276, 366, 373, 416, 378, 541, 380, 104, 140, 611,
3130 386, 145, 384, 388, 439, 392, 393, 100, 101, 394,
3131 398, 455, 396, 402, 145, 71, 56, 358, 375, 413,
3132 102, 103, -335, 71, 56, 358, 116, 101, -158, 403,
3133 -241, 100, 101, 104, -337, -336, 411, 245, 176, 102,
3134 103, 541, 420, 368, 102, 103, 105, 245, 177, 245,
3135 322, 425, 104, 178, 179, 498, 467, 104, 427, 408,
3136 471, 539, 434, 472, 435, 474, 180, -116, 181, 438,
3137 322, 436, 479, 443, -159, 447, 448, 453, 483, 417,
3138 457, 100, 101, 451, 245, 440, 145, 71, 56, 358,
3139 459, 497, 468, 475, 102, 103, 477, 168, 110, 3,
3140 4, 460, 5, 6, 7, 478, 245, 104, 482, 481,
3141 494, 502, 503, 14, 527, 430, 532, 184, 19, 529,
3142 21, 374, 22, 23, 507, 531, 147, 548, 537, 546,
3143 24, 13, 552, 15, 16, 558, 18, 28, 20, 29,
3144 169, 570, 553, 571, 594, 469, 576, 34, 572, 35,
3145 36, 25, 583, 584, 585, 589, 245, 597, 38, 547,
3146 30, 31, 32, 592, 542, 40, 593, 598, 551, 602,
3147 603, 604, 606, 605, 609, 610, 166, 426, 240, 170,
3148 505, 269, 278, 445, 533, 534, 41, 42, 554, 555,
3149 185, 596, 587, 586, 573, 506, 528, 118, 564, 562,
3150 563, 568, 569, 501, 542, 44, 407, 484, 45, 139,
3151 382, 0, 0, 46, 47, 0, 0, 0, 48, 0,
3152 49, 0, 0, 0, 51, 0, 564, 562, 563, 568,
3153 569, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3154 0, 0, 0, 0, 564, 562, 563, 568, 569, -4,
3155 0, 0, 1, 2, 3, 4, 0, 5, 6, 7,
3156 8, 9, 10, 11, 0, 0, 12, 13, 14, 15,
3157 16, 17, 18, 19, 20, 0, 0, 22, 23, 0,
3158 0, 191, 0, 0, 0, 24, 0, 25, 26, 0,
3159 27, 0, 28, 0, 29, 0, 30, 31, 32, 0,
3160 0, 33, 34, 0, 35, 36, 0, 0, 0, -338,
3161 -338, -338, 37, 38, 39, 0, 0, 199, 200, 0,
3162 40, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3163 0, 0, 0, 214, 215, 216, 0, 217, 218, 219,
3164 0, 41, 42, 0, 0, 0, 0, 0, 0, 0,
3165 43, 0, 225, 226, 0, 227, 228, 229, 230, 231,
3166 44, 0, 0, 45, 0, 232, 0, 233, 46, 47,
3167 234, 0, 0, 48, 0, 49, 0, 50, 0, 51,
3168 0, 0, 0, -4, 1, 2, 3, 4, 0, 5,
3169 6, 7, 8, 9, 10, 11, 0, 0, 0, 13,
3170 14, 15, 16, 17, 18, 19, 20, 21, 0, 22,
3171 23, 146, 0, 147, 0, 0, 0, 24, 148, 25,
3172 26, 0, 27, 149, 28, 0, 29, 150, 30, 31,
3173 32, 0, 0, 33, 34, 0, 35, 36, 0, 0,
3174 0, -138, 0, 0, 37, 38, 39, 0, 151, 0,
3175 0, 0, 40, -138, 0, -138, 0, -138, -138, 0,
3176 -138, 0, -138, -138, 0, 214, 215, 216, -138, -138,
3177 0, 0, 0, 41, 42, -138, 0, 0, 0, 0,
3178 0, -138, 152, -138, -138, -138, -138, 227, 228, 229,
3179 230, 231, 44, 0, 0, 45, 0, 232, 0, 233,
3180 46, 47, 234, 0, 0, 48, 0, 49, 0, 50,
3181 0, 51, 0, 0, 0, 153, 1, 2, 3, 4,
3182 0, 5, 6, 7, 8, 9, 10, 11, 0, 0,
3183 0, 13, 14, 15, 16, 17, 18, 19, 20, 21,
3184 0, 22, 23, 146, 0, 147, 0, 0, 0, 24,
3185 148, 25, 26, 0, 27, 149, 28, 0, 29, 150,
3186 30, 31, 32, 0, 0, 33, 34, 0, 35, 36,
3187 214, 215, 216, 0, 0, 0, 37, 38, 39, 0,
3188 151, 0, 0, 0, 40, 0, 0, 0, 0, 0,
3189 0, 0, 0, 0, 229, 230, 231, 0, 0, 0,
3190 0, 0, 232, 0, 233, 41, 42, 234, 0, 0,
3191 0, 0, 0, 0, 152, 0, 0, 0, 0, 0,
3192 0, 0, 0, 0, 44, 0, 0, 45, 0, 0,
3193 0, 0, 46, 47, 0, 0, 0, 48, 0, 49,
3194 0, 50, 0, 51, 0, 0, 0, 275, 1, 2,
3195 3, 4, 0, 5, 6, 7, 8, 9, 10, 11,
3196 0, 0, 0, 13, 14, 15, 16, 17, 18, 19,
3197 20, 21, 0, 22, 23, 146, 0, 147, 0, 0,
3198 0, 24, 148, 25, 26, 0, 27, 149, 28, 0,
3199 29, 150, 30, 31, 32, 0, 0, 33, 34, 0,
3200 35, 36, 0, 0, 0, 0, 0, 0, 37, 38,
3201 39, 0, 151, 0, 0, 0, 40, 0, 0, 0,
3202 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3203 0, 0, 0, 0, 0, 0, 0, 41, 42, 0,
3204 0, 0, 0, 0, 0, 0, 152, 0, 0, 0,
3205 0, 0, 0, 0, 0, 0, 44, 0, 0, 45,
3206 0, 0, 0, 0, 46, 47, 0, 0, 0, 48,
3207 0, 49, 0, 50, 0, 51, 0, 0, 0, 446,
3208 1, 2, 3, 4, 0, 5, 6, 7, 8, 9,
3209 10, 11, 0, 0, 12, 13, 14, 15, 16, 17,
3210 18, 19, 20, 0, 0, 22, 23, 0, 0, -338,
3211 0, 0, 0, 24, 0, 25, 26, 0, 27, 0,
3212 28, 0, 29, 0, 30, 31, 32, 0, 0, 33,
3213 34, 0, 35, 36, 0, 0, 0, 0, 0, 0,
3214 37, 38, 39, 0, 0, -338, -338, 0, 40, 0,
3215 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3216 0, 214, 215, 216, 0, 217, 218, 219, 0, 41,
3217 42, 0, 0, 0, 0, 0, 0, 0, 43, 0,
3218 -338, -338, 0, 227, 228, 229, 230, 231, 44, 0,
3219 0, 45, 0, 232, 0, 233, 46, 47, 234, 0,
3220 0, 48, 0, 49, 0, 50, 0, 51, 0, 0,
3221 0, -3, 1, 2, 3, 4, 0, 5, 6, 7,
3222 8, 9, 10, 11, 0, 0, 0, 13, 14, 15,
3223 16, 17, 18, 19, 20, 0, 0, 22, 23, 0,
3224 0, 0, 0, 0, 0, 24, 0, 25, 26, 0,
3225 27, 0, 28, 0, 29, 0, 30, 31, 32, 0,
3226 0, 33, 34, 0, 35, 36, 0, 0, 0, 0,
3227 0, 0, 37, 38, 39, 0, 0, 0, 0, 0,
3228 40, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3229 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3230 0, 41, 42, 0, 0, 0, 0, 0, 0, 0,
3231 352, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3232 44, 0, 0, 45, 0, 0, 0, 0, 46, 47,
3233 0, 0, 0, 48, 0, 353, 0, 50, 0, 51,
3234 0, 0, 0, -15, 1, 2, 3, 4, 0, 5,
3235 6, 7, 8, 9, 10, 11, 0, 0, 0, 13,
3236 14, 15, 16, 17, 18, 19, 20, 0, 0, 22,
3237 23, 0, 0, 0, 0, 0, 0, 24, 0, 25,
3238 26, 0, 27, 0, 28, 0, 29, 0, 30, 31,
3239 32, 0, 0, 33, 34, 0, 35, 36, 0, 0,
3240 0, 0, 0, 0, 37, 38, 39, 0, 0, 0,
3241 0, 0, 40, 0, 0, 0, 0, 0, 0, 0,
3242 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3243 0, 0, 0, 41, 42, 0, 0, 0, 0, 0,
3244 0, 0, 352, 0, 0, 0, 0, 0, 0, 0,
3245 0, 0, 44, 0, 0, 45, 0, 0, 0, 0,
3246 46, 47, 0, 0, 0, 48, 0, 353, 0, 50,
3247 0, 51, 0, 0, 0, -16, 1, 2, 3, 4,
3248 0, 5, 6, 7, 8, 9, 10, 11, 0, 0,
3249 0, 13, 14, 15, 16, 17, 18, 19, 20, 0,
3250 0, 22, 23, 0, 0, 0, 0, 0, 0, 24,
3251 0, 25, 26, 0, 27, 0, 28, 0, 29, 0,
3252 30, 31, 32, 0, 0, 33, 34, 0, 35, 36,
3253 0, 0, 0, 0, 0, 0, 37, 38, 39, 0,
3254 0, 0, 0, 0, 40, 0, 0, 0, 0, 0,
3255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3256 0, 0, 0, 0, 0, 41, 42, 0, 0, 0,
3257 0, 0, 0, 0, 561, 0, 0, 0, 0, 0,
3258 0, 0, 0, 0, 44, 0, 0, 45, 0, 0,
3259 0, 0, 46, 47, 0, 0, 0, 48, 0, 49,
3260 0, 50, 0, 51, 0, 0, 0, -149, 1, 2,
3261 3, 4, 0, 5, 6, 7, 8, 9, 10, 11,
3262 0, 0, 0, 13, 14, 15, 16, 17, 18, 19,
3263 20, 0, 0, 22, 23, 0, 0, 0, 0, 0,
3264 0, 24, 0, 25, 26, 0, 27, 0, 28, 0,
3265 29, 0, 30, 31, 32, 0, 0, 33, 34, 0,
3266 35, 36, 0, 0, 0, 0, 0, 0, 37, 38,
3267 39, 0, 0, 0, 0, 0, 40, 0, 0, 0,
3268 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3269 0, 0, 0, 0, 0, 0, 0, 41, 42, 0,
3270 0, 0, 0, 0, 0, 0, 561, 0, 0, 0,
3271 0, 0, 0, 0, 0, 0, 44, 0, 0, 45,
3272 0, 0, 0, 0, 46, 47, 0, 0, 0, 48,
3273 0, 49, 0, 50, 0, 51, 0, -3, 0, -150,
3274 1, 2, 3, 4, 0, 5, 6, 7, 8, 9,
3275 10, 11, 0, 0, 12, 13, 14, 15, 16, 17,
3276 18, 19, 20, 0, 0, 22, 23, 0, 0, 0,
3277 0, 0, 0, 24, 0, 25, 26, 0, 27, 0,
3278 28, 0, 29, 0, 30, 31, 32, 0, 0, 33,
3279 34, 0, 35, 36, 0, 0, 0, 0, 0, 0,
3280 37, 38, 39, 0, 0, 0, 0, 0, 40, 0,
3281 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3282 0, 0, 0, 0, 0, 0, 0, 0, 0, 41,
3283 42, 0, 0, 0, 0, 0, 0, 0, 43, 0,
3284 0, 0, 0, 0, 0, 0, 0, 0, 44, 0,
3285 0, 45, 0, 0, 0, 0, 46, 47, 0, 0,
3286 0, 48, 0, 49, 0, 50, 0, 51, 1, 2,
3287 3, 4, 0, 5, 6, 7, 8, 9, 10, 11,
3288 0, -125, 0, 13, 14, 15, 16, 17, 18, 19,
3289 20, 21, 0, 22, 23, 146, 0, 147, 0, 0,
3290 0, 24, 148, 25, 26, 0, 27, 149, 28, 0,
3291 29, 150, 30, 31, 32, 0, 0, 33, 34, 0,
3292 35, 36, 0, 0, 0, 0, 0, 0, 37, 38,
3293 39, 0, 151, 0, 0, 0, 40, 0, 0, 0,
3294 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3295 0, 0, 0, 0, 0, 0, 0, 41, 42, 0,
3296 0, 0, 0, 0, 0, 0, 152, 0, 0, 0,
3297 0, 0, 0, 0, 0, 0, 44, 0, 0, 45,
3298 0, 0, 0, 0, 46, 47, 0, 0, 0, 48,
3299 0, 49, 0, 50, 0, 51, 1, 2, 3, 4,
3300 0, 5, 6, 7, 8, 9, 10, 11, 0, 0,
3301 0, 13, 14, 15, 16, 17, 18, 19, 20, 21,
3302 0, 22, 23, 146, 0, 147, 0, 0, 0, 24,
3303 148, 25, 26, 0, 27, 149, 28, 0, 29, 150,
3304 30, 31, 32, 0, 0, 33, 34, 0, 35, 36,
3305 0, 0, 0, 0, 0, 0, 37, 38, 39, 0,
3306 151, 0, 0, 0, 40, 0, 0, 0, 0, 0,
3307 0, 0, 0, 0, 0, 0, 109, 110, 3, 4,
3308 0, 5, 6, 7, 0, 41, 42, 0, 0, 0,
3309 0, 0, 14, 0, 152, 0, 0, 19, 0, 21,
3310 0, 22, 23, 0, 44, 0, 0, 45, 0, 24,
3311 0, 0, 46, 47, 0, 0, 28, 48, 29, 49,
3312 0, 50, 0, 51, 0, 0, 34, 0, 35, 36,
3313 0, 0, 0, 109, 110, 3, 4, 38, 5, 6,
3314 7, 0, 0, 0, 40, 0, 0, 0, 0, 14,
3315 0, 0, 0, 0, 19, 0, 21, 0, 22, 23,
3316 0, 0, 0, 0, 0, 41, 42, 0, 0, 0,
3317 0, 0, 0, 0, 0, 29, 0, 0, 0, 0,
3318 0, 0, 0, 34, 44, 35, 36, 45, 0, 0,
3319 0, 0, 46, 47, 0, 0, 0, 48, 0, 49,
3320 0, 40, 0, 51, 0, 0, 0, 0, 0, 0,
3321 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3322 0, 0, 41, 42, 0, 0, 0, 0, 0, 191,
3323 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3324 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3325 0, 0, 0, 0, 48, 0, 49, 192, 193, 194,
3326 51, 195, 196, 197, 198, 199, 200, 201, 202, 203,
3327 204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
3328 0, 214, 215, 216, 0, 217, 218, 219, 0, 0,
3329 0, 0, 0, 220, 221, 0, 222, 223, 224, 191,
3330 225, 226, 0, 227, 228, 229, 230, 231, 0, 0,
3331 0, 0, 0, 232, 0, 233, 0, 0, 234, 0,
3332 0, 0, 0, 0, 423, 0, 0, 192, 193, 194,
3333 0, 195, 196, 197, 198, 199, 200, 201, 202, 203,
3334 204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
3335 0, 214, 215, 216, 0, 217, 218, 219, 0, 0,
3336 0, 0, 0, 220, 221, 0, 222, 223, 224, 191,
3337 225, 226, 0, 227, 228, 229, 230, 231, 0, 0,
3338 0, 0, 0, 232, 0, 233, 0, 0, 234, 0,
3339 0, 0, 0, 0, 517, 0, 0, 192, 193, 194,
3340 0, 195, 196, 197, 198, 199, 200, 201, 202, 203,
3341 204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
3342 0, 214, 215, 216, 0, 217, 218, 219, 0, 0,
3343 0, 191, 0, 220, 221, 412, 222, 223, 224, 0,
3344 225, 226, 0, 227, 228, 229, 230, 231, 0, 0,
3345 0, 0, 0, 232, 0, 233, 0, 0, 234, 192,
3346 193, 194, 0, 195, 196, 197, 198, 199, 200, 201,
3347 202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
3348 212, 213, 0, 214, 215, 216, 0, 217, 218, 219,
3349 0, 0, 0, 191, 0, 220, 221, 0, 222, 223,
3350 224, 0, 225, 226, 0, 227, 228, 229, 230, 231,
3351 0, 0, 0, 0, 0, 232, 0, 233, 414, 0,
3352 234, 192, 193, 194, 0, 195, 196, 197, 198, 199,
3353 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
3354 210, 211, 212, 213, 0, 214, 215, 216, 0, 217,
3355 218, 219, 0, 0, 0, 191, 0, 220, 221, 0,
3356 222, 223, 224, 0, 225, 226, 0, 227, 228, 229,
3357 230, 231, 0, 0, 0, 0, 0, 232, 0, 233,
3358 473, 0, 234, 192, 193, 194, 0, 195, 196, 197,
3359 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
3360 208, 209, 210, 211, 212, 213, 0, 214, 215, 216,
3361 0, 217, 218, 219, 0, 0, 0, 191, 0, 220,
3362 221, 0, 222, 223, 224, 0, 225, 226, 0, 227,
3363 228, 229, 230, 231, 0, 0, 0, 0, 0, 232,
3364 0, 233, 515, 0, 234, 192, 193, 194, 0, 195,
3365 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
3366 206, 207, 208, 209, 210, 211, 212, 213, 0, 214,
3367 215, 216, 0, 217, 218, 219, 0, 0, 0, 191,
3368 0, 220, 221, 0, 222, 223, 224, 0, 225, 226,
3369 0, 227, 228, 229, 230, 231, 0, 0, 0, 0,
3370 0, 232, 0, 233, 518, 0, 234, 192, 193, 194,
3371 0, 195, 196, 197, 198, 199, 200, 201, 202, 203,
3372 204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
3373 0, 214, 215, 216, 0, 217, 218, 219, 0, 0,
3374 0, 191, 0, 220, 221, 0, 222, 223, 224, 0,
3375 225, 226, 0, 227, 228, 229, 230, 231, 0, 0,
3376 0, 0, 0, 232, 0, 233, 526, 0, 234, 192,
3377 193, 194, 0, 195, 196, 197, 198, 199, 200, 201,
3378 202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
3379 212, 213, 0, 214, 215, 216, 0, 217, 218, 219,
3380 0, 0, 0, 191, 0, 220, 221, 578, 222, 223,
3381 224, 0, 225, 226, 0, 227, 228, 229, 230, 231,
3382 0, 0, 0, 0, 0, 232, 0, 233, 0, 0,
3383 234, 192, 193, 194, 0, 195, 196, 197, 198, 199,
3384 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
3385 210, 211, 212, 213, 0, 214, 215, 216, 0, 217,
3386 218, 219, 0, 0, 0, 191, 0, 220, 221, 0,
3387 222, 223, 224, 0, 225, 226, 0, 227, 228, 229,
3388 230, 231, 0, 0, 0, 0, 0, 232, 0, 233,
3389 0, 0, 234, 192, 193, 194, 0, 195, 196, 197,
3390 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
3391 208, 209, 210, 211, 212, 213, 0, 214, 215, 216,
3392 0, 217, 218, 219, 0, 0, 0, 191, 0, 220,
3393 221, 0, 222, 223, 224, 0, 0, 226, 0, 227,
3394 228, 229, 230, 231, 0, 0, 0, 0, 0, 232,
3395 0, 233, 0, 0, 234, 192, 193, 194, 0, 195,
3396 196, 197, 198, 199, 200, 0, 0, 0, 0, 0,
3397 0, 0, 0, 0, 0, 0, 0, 213, 0, 214,
3398 215, 216, 0, 217, 218, 219, 0, 0, 0, 191,
3399 0, 0, 0, 0, 222, 223, 224, 0, 225, 226,
3400 0, 227, 228, 229, 230, 231, 0, 0, 0, 0,
3401 0, 232, 0, 233, 0, 0, 234, 192, 193, 194,
3402 0, 195, 196, 197, 198, 199, 200, 0, 0, 0,
3403 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3404 0, 214, 215, 216, 0, 217, 218, 219, 0, 0,
3405 0, 191, 0, 0, 0, 0, 222, 223, 224, 0,
3406 225, 226, 0, 227, 228, 229, 230, 231, 0, 0,
3407 0, 0, 0, 232, 0, 233, 0, 0, 234, 192,
3408 193, 194, 0, 195, 196, 197, 198, 199, 200, 0,
3409 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3410 0, 0, 0, 214, 215, 216, 0, 217, 218, 219,
3411 0, 0, 0, 191, 0, 0, 0, 0, 0, 223,
3412 224, 0, 225, 226, 0, 227, 228, 229, 230, 231,
3413 0, 0, 0, 0, 0, 232, 0, 233, 0, 0,
3414 234, 192, 193, 194, 0, 195, 196, 197, 198, 199,
3415 200, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3416 0, 0, 0, 0, 0, 214, 215, 216, 0, 217,
3417 218, 219, 0, 0, 0, 191, 0, 0, 0, 0,
3418 0, 0, 224, 0, 225, 226, 0, 227, 228, 229,
3419 230, 231, 0, 0, 0, 0, 0, 232, 0, 233,
3420 0, 0, 234, 192, 193, 194, 0, 195, 196, 197,
3421 198, 199, 200, 0, 0, 0, 0, 0, 0, 0,
3422 0, 0, 0, 0, 0, 0, 0, 214, 215, 216,
3423 0, 217, 218, 219, 0, 0, 0, 191, 0, 0,
3424 0, 0, 0, 0, -338, 0, 225, 226, 0, 227,
3425 228, 229, 230, 231, 0, 0, 0, 0, 0, 232,
3426 0, 233, 0, 0, 234, 192, 193, 194, 0, -338,
3427 -338, -338, -338, 199, 200, 0, 0, 0, 0, 0,
3428 0, 0, 0, 0, 0, 0, 0, 0, 0, 214,
3429 215, 216, 0, 217, 218, 219, 0, 0, 0, 0,
3430 0, 0, 0, 0, 0, 0, 0, 0, 225, 226,
3431 0, 227, 228, 229, 230, 231, 0, 0, 0, 0,
3432 0, 232, 0, 233, 0, 0, 234
3435 static const yytype_int16 yycheck[] =
3437 0, 0, 0, 0, 0, 12, 108, 19, 60, 279,
3438 67, 121, 24, 143, 50, 349, 28, 3, 3, 189,
3439 27, 451, 5, 5, 5, 50, 38, 369, 3, 41,
3440 42, 3, 363, 45, 46, 47, 48, 49, 115, 3,
3441 4, 98, 5, 234, 466, 234, 380, 102, 125, 546,
3442 69, 12, 16, 17, 54, 54, 54, 54, 54, 514,
3443 94, 0, 35, 0, 91, 29, 27, 0, 92, 93,
3444 94, 148, 149, 102, 574, 27, 124, 124, 51, 576,
3445 135, 33, 552, 34, 96, 104, 556, 557, 16, 16,
3446 590, 513, 126, 435, 549, 129, 427, 154, 26, 124,
3447 124, 108, 126, 115, 32, 129, 135, 124, 578, 121,
3448 3, 62, 129, 125, 448, 54, 124, 54, 46, 128,
3449 95, 54, 232, 95, 294, 595, 3, 4, 398, 112,
3450 260, 143, 323, 16, 323, 605, 148, 149, 3, 16,
3451 17, 0, 128, 128, 486, 128, 128, 128, 111, 112,
3452 112, 128, 29, 117, 116, 346, 3, 346, 5, 124,
3453 494, 8, 9, 10, 434, 128, 130, 167, 167, 167,
3454 167, 167, 104, 603, 106, 187, 102, 3, 190, 191,
3455 192, 193, 194, 195, 196, 197, 198, 199, 200, 201,
3456 202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
3457 212, 213, 536, 280, 281, 217, 218, 219, 220, 221,
3458 222, 223, 224, 225, 226, 227, 228, 229, 230, 231,
3459 232, 233, 411, 3, 124, 5, 128, 129, 167, 241,
3460 167, 420, 402, 403, 167, 12, 124, 244, 4, 129,
3461 117, 277, 242, 242, 242, 257, 253, 124, 260, 126,
3462 262, 129, 18, 130, 20, 21, 366, 23, 3, 25,
3463 104, 3, 4, 134, 106, 102, 127, 537, 280, 281,
3464 102, 3, 38, 350, 16, 17, 3, 4, 3, 468,
3465 46, 47, 48, 49, 4, 3, 475, 29, 558, 16,
3466 17, 69, 394, 128, 396, 16, 3, 4, 18, 3,
3467 20, 21, 29, 23, 101, 25, 69, 101, 438, 16,
3468 17, 3, 4, 3, 3, 3, 135, 102, 38, 124,
3469 377, 129, 29, 129, 16, 17, 46, 47, 48, 49,
3470 387, 124, 135, 345, 135, 101, 135, 29, 350, 609,
3471 102, 353, 106, 134, 36, 104, 3, 3, 4, 54,
3472 3, 453, 54, 104, 366, 355, 355, 355, 365, 135,
3473 16, 17, 91, 363, 363, 363, 3, 4, 134, 104,
3474 127, 3, 4, 29, 91, 91, 91, 384, 16, 16,
3475 17, 101, 91, 3, 16, 17, 128, 394, 26, 396,
3476 117, 134, 29, 31, 32, 447, 408, 29, 128, 126,
3477 412, 503, 135, 415, 102, 417, 44, 129, 46, 106,
3478 117, 134, 424, 104, 134, 101, 135, 15, 430, 126,
3479 128, 3, 4, 124, 431, 117, 438, 427, 427, 427,
3480 102, 443, 91, 91, 16, 17, 135, 3, 4, 5,
3481 6, 134, 8, 9, 10, 128, 453, 29, 135, 134,
3482 66, 128, 102, 19, 134, 104, 124, 4, 24, 128,
3483 26, 117, 28, 29, 112, 128, 32, 111, 135, 116,
3484 36, 18, 106, 20, 21, 3, 23, 43, 25, 45,
3485 46, 3, 134, 26, 135, 117, 116, 53, 134, 55,
3486 56, 38, 128, 128, 134, 134, 503, 3, 64, 511,
3487 47, 48, 49, 134, 504, 71, 134, 112, 520, 134,
3488 124, 112, 134, 128, 135, 134, 54, 355, 98, 60,
3489 458, 147, 167, 386, 492, 492, 92, 93, 523, 523,
3490 72, 584, 571, 566, 544, 459, 484, 27, 538, 538,
3491 538, 538, 538, 453, 544, 111, 294, 431, 114, 48,
3492 261, -1, -1, 119, 120, -1, -1, -1, 124, -1,
3493 126, -1, -1, -1, 130, -1, 566, 566, 566, 566,
3494 566, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3495 -1, -1, -1, -1, 584, 584, 584, 584, 584, 0,
3496 -1, -1, 3, 4, 5, 6, -1, 8, 9, 10,
3497 11, 12, 13, 14, -1, -1, 17, 18, 19, 20,
3498 21, 22, 23, 24, 25, -1, -1, 28, 29, -1,
3499 -1, 40, -1, -1, -1, 36, -1, 38, 39, -1,
3500 41, -1, 43, -1, 45, -1, 47, 48, 49, -1,
3501 -1, 52, 53, -1, 55, 56, -1, -1, -1, 68,
3502 69, 70, 63, 64, 65, -1, -1, 76, 77, -1,
3503 71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3504 -1, -1, -1, 92, 93, 94, -1, 96, 97, 98,
3505 -1, 92, 93, -1, -1, -1, -1, -1, -1, -1,
3506 101, -1, 111, 112, -1, 114, 115, 116, 117, 118,
3507 111, -1, -1, 114, -1, 124, -1, 126, 119, 120,
3508 129, -1, -1, 124, -1, 126, -1, 128, -1, 130,
3509 -1, -1, -1, 134, 3, 4, 5, 6, -1, 8,
3510 9, 10, 11, 12, 13, 14, -1, -1, -1, 18,
3511 19, 20, 21, 22, 23, 24, 25, 26, -1, 28,
3512 29, 30, -1, 32, -1, -1, -1, 36, 37, 38,
3513 39, -1, 41, 42, 43, -1, 45, 46, 47, 48,
3514 49, -1, -1, 52, 53, -1, 55, 56, -1, -1,
3515 -1, 4, -1, -1, 63, 64, 65, -1, 67, -1,
3516 -1, -1, 71, 16, -1, 18, -1, 20, 21, -1,
3517 23, -1, 25, 26, -1, 92, 93, 94, 31, 32,
3518 -1, -1, -1, 92, 93, 38, -1, -1, -1, -1,
3519 -1, 44, 101, 46, 47, 48, 49, 114, 115, 116,
3520 117, 118, 111, -1, -1, 114, -1, 124, -1, 126,
3521 119, 120, 129, -1, -1, 124, -1, 126, -1, 128,
3522 -1, 130, -1, -1, -1, 134, 3, 4, 5, 6,
3523 -1, 8, 9, 10, 11, 12, 13, 14, -1, -1,
3524 -1, 18, 19, 20, 21, 22, 23, 24, 25, 26,
3525 -1, 28, 29, 30, -1, 32, -1, -1, -1, 36,
3526 37, 38, 39, -1, 41, 42, 43, -1, 45, 46,
3527 47, 48, 49, -1, -1, 52, 53, -1, 55, 56,
3528 92, 93, 94, -1, -1, -1, 63, 64, 65, -1,
3529 67, -1, -1, -1, 71, -1, -1, -1, -1, -1,
3530 -1, -1, -1, -1, 116, 117, 118, -1, -1, -1,
3531 -1, -1, 124, -1, 126, 92, 93, 129, -1, -1,
3532 -1, -1, -1, -1, 101, -1, -1, -1, -1, -1,
3533 -1, -1, -1, -1, 111, -1, -1, 114, -1, -1,
3534 -1, -1, 119, 120, -1, -1, -1, 124, -1, 126,
3535 -1, 128, -1, 130, -1, -1, -1, 134, 3, 4,
3536 5, 6, -1, 8, 9, 10, 11, 12, 13, 14,
3537 -1, -1, -1, 18, 19, 20, 21, 22, 23, 24,
3538 25, 26, -1, 28, 29, 30, -1, 32, -1, -1,
3539 -1, 36, 37, 38, 39, -1, 41, 42, 43, -1,
3540 45, 46, 47, 48, 49, -1, -1, 52, 53, -1,
3541 55, 56, -1, -1, -1, -1, -1, -1, 63, 64,
3542 65, -1, 67, -1, -1, -1, 71, -1, -1, -1,
3543 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3544 -1, -1, -1, -1, -1, -1, -1, 92, 93, -1,
3545 -1, -1, -1, -1, -1, -1, 101, -1, -1, -1,
3546 -1, -1, -1, -1, -1, -1, 111, -1, -1, 114,
3547 -1, -1, -1, -1, 119, 120, -1, -1, -1, 124,
3548 -1, 126, -1, 128, -1, 130, -1, -1, -1, 134,
3549 3, 4, 5, 6, -1, 8, 9, 10, 11, 12,
3550 13, 14, -1, -1, 17, 18, 19, 20, 21, 22,
3551 23, 24, 25, -1, -1, 28, 29, -1, -1, 40,
3552 -1, -1, -1, 36, -1, 38, 39, -1, 41, -1,
3553 43, -1, 45, -1, 47, 48, 49, -1, -1, 52,
3554 53, -1, 55, 56, -1, -1, -1, -1, -1, -1,
3555 63, 64, 65, -1, -1, 76, 77, -1, 71, -1,
3556 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3557 -1, 92, 93, 94, -1, 96, 97, 98, -1, 92,
3558 93, -1, -1, -1, -1, -1, -1, -1, 101, -1,
3559 111, 112, -1, 114, 115, 116, 117, 118, 111, -1,
3560 -1, 114, -1, 124, -1, 126, 119, 120, 129, -1,
3561 -1, 124, -1, 126, -1, 128, -1, 130, -1, -1,
3562 -1, 134, 3, 4, 5, 6, -1, 8, 9, 10,
3563 11, 12, 13, 14, -1, -1, -1, 18, 19, 20,
3564 21, 22, 23, 24, 25, -1, -1, 28, 29, -1,
3565 -1, -1, -1, -1, -1, 36, -1, 38, 39, -1,
3566 41, -1, 43, -1, 45, -1, 47, 48, 49, -1,
3567 -1, 52, 53, -1, 55, 56, -1, -1, -1, -1,
3568 -1, -1, 63, 64, 65, -1, -1, -1, -1, -1,
3569 71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3570 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3571 -1, 92, 93, -1, -1, -1, -1, -1, -1, -1,
3572 101, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3573 111, -1, -1, 114, -1, -1, -1, -1, 119, 120,
3574 -1, -1, -1, 124, -1, 126, -1, 128, -1, 130,
3575 -1, -1, -1, 134, 3, 4, 5, 6, -1, 8,
3576 9, 10, 11, 12, 13, 14, -1, -1, -1, 18,
3577 19, 20, 21, 22, 23, 24, 25, -1, -1, 28,
3578 29, -1, -1, -1, -1, -1, -1, 36, -1, 38,
3579 39, -1, 41, -1, 43, -1, 45, -1, 47, 48,
3580 49, -1, -1, 52, 53, -1, 55, 56, -1, -1,
3581 -1, -1, -1, -1, 63, 64, 65, -1, -1, -1,
3582 -1, -1, 71, -1, -1, -1, -1, -1, -1, -1,
3583 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3584 -1, -1, -1, 92, 93, -1, -1, -1, -1, -1,
3585 -1, -1, 101, -1, -1, -1, -1, -1, -1, -1,
3586 -1, -1, 111, -1, -1, 114, -1, -1, -1, -1,
3587 119, 120, -1, -1, -1, 124, -1, 126, -1, 128,
3588 -1, 130, -1, -1, -1, 134, 3, 4, 5, 6,
3589 -1, 8, 9, 10, 11, 12, 13, 14, -1, -1,
3590 -1, 18, 19, 20, 21, 22, 23, 24, 25, -1,
3591 -1, 28, 29, -1, -1, -1, -1, -1, -1, 36,
3592 -1, 38, 39, -1, 41, -1, 43, -1, 45, -1,
3593 47, 48, 49, -1, -1, 52, 53, -1, 55, 56,
3594 -1, -1, -1, -1, -1, -1, 63, 64, 65, -1,
3595 -1, -1, -1, -1, 71, -1, -1, -1, -1, -1,
3596 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3597 -1, -1, -1, -1, -1, 92, 93, -1, -1, -1,
3598 -1, -1, -1, -1, 101, -1, -1, -1, -1, -1,
3599 -1, -1, -1, -1, 111, -1, -1, 114, -1, -1,
3600 -1, -1, 119, 120, -1, -1, -1, 124, -1, 126,
3601 -1, 128, -1, 130, -1, -1, -1, 134, 3, 4,
3602 5, 6, -1, 8, 9, 10, 11, 12, 13, 14,
3603 -1, -1, -1, 18, 19, 20, 21, 22, 23, 24,
3604 25, -1, -1, 28, 29, -1, -1, -1, -1, -1,
3605 -1, 36, -1, 38, 39, -1, 41, -1, 43, -1,
3606 45, -1, 47, 48, 49, -1, -1, 52, 53, -1,
3607 55, 56, -1, -1, -1, -1, -1, -1, 63, 64,
3608 65, -1, -1, -1, -1, -1, 71, -1, -1, -1,
3609 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3610 -1, -1, -1, -1, -1, -1, -1, 92, 93, -1,
3611 -1, -1, -1, -1, -1, -1, 101, -1, -1, -1,
3612 -1, -1, -1, -1, -1, -1, 111, -1, -1, 114,
3613 -1, -1, -1, -1, 119, 120, -1, -1, -1, 124,
3614 -1, 126, -1, 128, -1, 130, -1, 0, -1, 134,
3615 3, 4, 5, 6, -1, 8, 9, 10, 11, 12,
3616 13, 14, -1, -1, 17, 18, 19, 20, 21, 22,
3617 23, 24, 25, -1, -1, 28, 29, -1, -1, -1,
3618 -1, -1, -1, 36, -1, 38, 39, -1, 41, -1,
3619 43, -1, 45, -1, 47, 48, 49, -1, -1, 52,
3620 53, -1, 55, 56, -1, -1, -1, -1, -1, -1,
3621 63, 64, 65, -1, -1, -1, -1, -1, 71, -1,
3622 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3623 -1, -1, -1, -1, -1, -1, -1, -1, -1, 92,
3624 93, -1, -1, -1, -1, -1, -1, -1, 101, -1,
3625 -1, -1, -1, -1, -1, -1, -1, -1, 111, -1,
3626 -1, 114, -1, -1, -1, -1, 119, 120, -1, -1,
3627 -1, 124, -1, 126, -1, 128, -1, 130, 3, 4,
3628 5, 6, -1, 8, 9, 10, 11, 12, 13, 14,
3629 -1, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3630 25, 26, -1, 28, 29, 30, -1, 32, -1, -1,
3631 -1, 36, 37, 38, 39, -1, 41, 42, 43, -1,
3632 45, 46, 47, 48, 49, -1, -1, 52, 53, -1,
3633 55, 56, -1, -1, -1, -1, -1, -1, 63, 64,
3634 65, -1, 67, -1, -1, -1, 71, -1, -1, -1,
3635 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3636 -1, -1, -1, -1, -1, -1, -1, 92, 93, -1,
3637 -1, -1, -1, -1, -1, -1, 101, -1, -1, -1,
3638 -1, -1, -1, -1, -1, -1, 111, -1, -1, 114,
3639 -1, -1, -1, -1, 119, 120, -1, -1, -1, 124,
3640 -1, 126, -1, 128, -1, 130, 3, 4, 5, 6,
3641 -1, 8, 9, 10, 11, 12, 13, 14, -1, -1,
3642 -1, 18, 19, 20, 21, 22, 23, 24, 25, 26,
3643 -1, 28, 29, 30, -1, 32, -1, -1, -1, 36,
3644 37, 38, 39, -1, 41, 42, 43, -1, 45, 46,
3645 47, 48, 49, -1, -1, 52, 53, -1, 55, 56,
3646 -1, -1, -1, -1, -1, -1, 63, 64, 65, -1,
3647 67, -1, -1, -1, 71, -1, -1, -1, -1, -1,
3648 -1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
3649 -1, 8, 9, 10, -1, 92, 93, -1, -1, -1,
3650 -1, -1, 19, -1, 101, -1, -1, 24, -1, 26,
3651 -1, 28, 29, -1, 111, -1, -1, 114, -1, 36,
3652 -1, -1, 119, 120, -1, -1, 43, 124, 45, 126,
3653 -1, 128, -1, 130, -1, -1, 53, -1, 55, 56,
3654 -1, -1, -1, 3, 4, 5, 6, 64, 8, 9,
3655 10, -1, -1, -1, 71, -1, -1, -1, -1, 19,
3656 -1, -1, -1, -1, 24, -1, 26, -1, 28, 29,
3657 -1, -1, -1, -1, -1, 92, 93, -1, -1, -1,
3658 -1, -1, -1, -1, -1, 45, -1, -1, -1, -1,
3659 -1, -1, -1, 53, 111, 55, 56, 114, -1, -1,
3660 -1, -1, 119, 120, -1, -1, -1, 124, -1, 126,
3661 -1, 71, -1, 130, -1, -1, -1, -1, -1, -1,
3662 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3663 -1, -1, 92, 93, -1, -1, -1, -1, -1, 40,
3664 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3665 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3666 -1, -1, -1, -1, 124, -1, 126, 68, 69, 70,
3667 130, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3668 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
3669 -1, 92, 93, 94, -1, 96, 97, 98, -1, -1,
3670 -1, -1, -1, 104, 105, -1, 107, 108, 109, 40,
3671 111, 112, -1, 114, 115, 116, 117, 118, -1, -1,
3672 -1, -1, -1, 124, -1, 126, -1, -1, 129, -1,
3673 -1, -1, -1, -1, 135, -1, -1, 68, 69, 70,
3674 -1, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3675 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
3676 -1, 92, 93, 94, -1, 96, 97, 98, -1, -1,
3677 -1, -1, -1, 104, 105, -1, 107, 108, 109, 40,
3678 111, 112, -1, 114, 115, 116, 117, 118, -1, -1,
3679 -1, -1, -1, 124, -1, 126, -1, -1, 129, -1,
3680 -1, -1, -1, -1, 135, -1, -1, 68, 69, 70,
3681 -1, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3682 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
3683 -1, 92, 93, 94, -1, 96, 97, 98, -1, -1,
3684 -1, 40, -1, 104, 105, 106, 107, 108, 109, -1,
3685 111, 112, -1, 114, 115, 116, 117, 118, -1, -1,
3686 -1, -1, -1, 124, -1, 126, -1, -1, 129, 68,
3687 69, 70, -1, 72, 73, 74, 75, 76, 77, 78,
3688 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
3689 89, 90, -1, 92, 93, 94, -1, 96, 97, 98,
3690 -1, -1, -1, 40, -1, 104, 105, -1, 107, 108,
3691 109, -1, 111, 112, -1, 114, 115, 116, 117, 118,
3692 -1, -1, -1, -1, -1, 124, -1, 126, 127, -1,
3693 129, 68, 69, 70, -1, 72, 73, 74, 75, 76,
3694 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
3695 87, 88, 89, 90, -1, 92, 93, 94, -1, 96,
3696 97, 98, -1, -1, -1, 40, -1, 104, 105, -1,
3697 107, 108, 109, -1, 111, 112, -1, 114, 115, 116,
3698 117, 118, -1, -1, -1, -1, -1, 124, -1, 126,
3699 127, -1, 129, 68, 69, 70, -1, 72, 73, 74,
3700 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
3701 85, 86, 87, 88, 89, 90, -1, 92, 93, 94,
3702 -1, 96, 97, 98, -1, -1, -1, 40, -1, 104,
3703 105, -1, 107, 108, 109, -1, 111, 112, -1, 114,
3704 115, 116, 117, 118, -1, -1, -1, -1, -1, 124,
3705 -1, 126, 127, -1, 129, 68, 69, 70, -1, 72,
3706 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
3707 83, 84, 85, 86, 87, 88, 89, 90, -1, 92,
3708 93, 94, -1, 96, 97, 98, -1, -1, -1, 40,
3709 -1, 104, 105, -1, 107, 108, 109, -1, 111, 112,
3710 -1, 114, 115, 116, 117, 118, -1, -1, -1, -1,
3711 -1, 124, -1, 126, 127, -1, 129, 68, 69, 70,
3712 -1, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3713 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
3714 -1, 92, 93, 94, -1, 96, 97, 98, -1, -1,
3715 -1, 40, -1, 104, 105, -1, 107, 108, 109, -1,
3716 111, 112, -1, 114, 115, 116, 117, 118, -1, -1,
3717 -1, -1, -1, 124, -1, 126, 127, -1, 129, 68,
3718 69, 70, -1, 72, 73, 74, 75, 76, 77, 78,
3719 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
3720 89, 90, -1, 92, 93, 94, -1, 96, 97, 98,
3721 -1, -1, -1, 40, -1, 104, 105, 106, 107, 108,
3722 109, -1, 111, 112, -1, 114, 115, 116, 117, 118,
3723 -1, -1, -1, -1, -1, 124, -1, 126, -1, -1,
3724 129, 68, 69, 70, -1, 72, 73, 74, 75, 76,
3725 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
3726 87, 88, 89, 90, -1, 92, 93, 94, -1, 96,
3727 97, 98, -1, -1, -1, 40, -1, 104, 105, -1,
3728 107, 108, 109, -1, 111, 112, -1, 114, 115, 116,
3729 117, 118, -1, -1, -1, -1, -1, 124, -1, 126,
3730 -1, -1, 129, 68, 69, 70, -1, 72, 73, 74,
3731 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
3732 85, 86, 87, 88, 89, 90, -1, 92, 93, 94,
3733 -1, 96, 97, 98, -1, -1, -1, 40, -1, 104,
3734 105, -1, 107, 108, 109, -1, -1, 112, -1, 114,
3735 115, 116, 117, 118, -1, -1, -1, -1, -1, 124,
3736 -1, 126, -1, -1, 129, 68, 69, 70, -1, 72,
3737 73, 74, 75, 76, 77, -1, -1, -1, -1, -1,
3738 -1, -1, -1, -1, -1, -1, -1, 90, -1, 92,
3739 93, 94, -1, 96, 97, 98, -1, -1, -1, 40,
3740 -1, -1, -1, -1, 107, 108, 109, -1, 111, 112,
3741 -1, 114, 115, 116, 117, 118, -1, -1, -1, -1,
3742 -1, 124, -1, 126, -1, -1, 129, 68, 69, 70,
3743 -1, 72, 73, 74, 75, 76, 77, -1, -1, -1,
3744 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3745 -1, 92, 93, 94, -1, 96, 97, 98, -1, -1,
3746 -1, 40, -1, -1, -1, -1, 107, 108, 109, -1,
3747 111, 112, -1, 114, 115, 116, 117, 118, -1, -1,
3748 -1, -1, -1, 124, -1, 126, -1, -1, 129, 68,
3749 69, 70, -1, 72, 73, 74, 75, 76, 77, -1,
3750 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3751 -1, -1, -1, 92, 93, 94, -1, 96, 97, 98,
3752 -1, -1, -1, 40, -1, -1, -1, -1, -1, 108,
3753 109, -1, 111, 112, -1, 114, 115, 116, 117, 118,
3754 -1, -1, -1, -1, -1, 124, -1, 126, -1, -1,
3755 129, 68, 69, 70, -1, 72, 73, 74, 75, 76,
3756 77, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3757 -1, -1, -1, -1, -1, 92, 93, 94, -1, 96,
3758 97, 98, -1, -1, -1, 40, -1, -1, -1, -1,
3759 -1, -1, 109, -1, 111, 112, -1, 114, 115, 116,
3760 117, 118, -1, -1, -1, -1, -1, 124, -1, 126,
3761 -1, -1, 129, 68, 69, 70, -1, 72, 73, 74,
3762 75, 76, 77, -1, -1, -1, -1, -1, -1, -1,
3763 -1, -1, -1, -1, -1, -1, -1, 92, 93, 94,
3764 -1, 96, 97, 98, -1, -1, -1, 40, -1, -1,
3765 -1, -1, -1, -1, 109, -1, 111, 112, -1, 114,
3766 115, 116, 117, 118, -1, -1, -1, -1, -1, 124,
3767 -1, 126, -1, -1, 129, 68, 69, 70, -1, 72,
3768 73, 74, 75, 76, 77, -1, -1, -1, -1, -1,
3769 -1, -1, -1, -1, -1, -1, -1, -1, -1, 92,
3770 93, 94, -1, 96, 97, 98, -1, -1, -1, -1,
3771 -1, -1, -1, -1, -1, -1, -1, -1, 111, 112,
3772 -1, 114, 115, 116, 117, 118, -1, -1, -1, -1,
3773 -1, 124, -1, 126, -1, -1, 129
3776 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
3777 symbol of state STATE-NUM. */
3778 static const yytype_uint16 yystos[] =
3780 0, 3, 4, 5, 6, 8, 9, 10, 11, 12,
3781 13, 14, 17, 18, 19, 20, 21, 22, 23, 24,
3782 25, 26, 28, 29, 36, 38, 39, 41, 43, 45,
3783 47, 48, 49, 52, 53, 55, 56, 63, 64, 65,
3784 71, 92, 93, 101, 111, 114, 119, 120, 124, 126,
3785 128, 130, 137, 138, 139, 140, 146, 149, 151, 159,
3786 162, 163, 164, 165, 166, 173, 181, 184, 185, 188,
3787 191, 192, 193, 194, 198, 200, 209, 214, 215, 216,
3788 227, 234, 237, 250, 251, 252, 257, 261, 265, 266,
3789 268, 269, 270, 91, 50, 124, 124, 156, 157, 124,
3790 3, 4, 16, 17, 29, 128, 186, 187, 16, 3,
3791 4, 261, 3, 236, 261, 124, 3, 187, 240, 261,
3792 128, 124, 129, 16, 261, 124, 3, 5, 8, 9,
3793 10, 258, 259, 260, 261, 261, 261, 261, 261, 256,
3794 261, 246, 247, 248, 254, 261, 30, 32, 37, 42,
3795 46, 67, 101, 134, 145, 146, 147, 151, 153, 167,
3796 168, 183, 192, 253, 3, 0, 140, 128, 3, 46,
3797 153, 160, 161, 257, 147, 148, 16, 26, 31, 32,
3798 44, 46, 208, 267, 4, 194, 3, 128, 221, 225,
3799 102, 40, 68, 69, 70, 72, 73, 74, 75, 76,
3800 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
3801 87, 88, 89, 90, 92, 93, 94, 96, 97, 98,
3802 104, 105, 107, 108, 109, 111, 112, 114, 115, 116,
3803 117, 118, 124, 126, 129, 3, 124, 255, 256, 12,
3804 148, 174, 190, 128, 129, 186, 187, 239, 240, 241,
3805 249, 124, 255, 129, 182, 246, 3, 104, 255, 134,
3806 106, 102, 102, 135, 127, 102, 254, 3, 3, 154,
3807 155, 255, 255, 154, 3, 134, 147, 128, 138, 3,
3808 101, 69, 101, 3, 35, 51, 233, 3, 3, 210,
3809 261, 3, 221, 226, 228, 229, 261, 261, 261, 261,
3810 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
3811 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
3812 3, 4, 117, 130, 186, 263, 264, 261, 261, 261,
3813 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
3814 261, 261, 246, 261, 124, 126, 130, 263, 264, 135,
3815 124, 261, 101, 126, 141, 142, 143, 149, 151, 198,
3816 200, 209, 234, 189, 186, 129, 124, 245, 3, 95,
3817 230, 231, 232, 135, 117, 186, 144, 145, 135, 261,
3818 135, 254, 259, 261, 106, 244, 102, 145, 134, 244,
3819 255, 255, 104, 3, 54, 195, 54, 196, 3, 211,
3820 212, 222, 104, 104, 112, 116, 217, 229, 126, 263,
3821 264, 91, 106, 135, 127, 262, 261, 126, 263, 264,
3822 91, 156, 255, 135, 150, 134, 143, 128, 141, 246,
3823 104, 106, 213, 232, 135, 102, 134, 156, 106, 36,
3824 117, 241, 243, 104, 152, 155, 134, 101, 135, 3,
3825 5, 124, 241, 15, 197, 241, 242, 128, 244, 102,
3826 134, 5, 221, 5, 221, 218, 223, 261, 91, 117,
3827 264, 261, 261, 127, 261, 91, 264, 135, 128, 261,
3828 141, 134, 135, 261, 243, 244, 95, 232, 27, 33,
3829 175, 177, 179, 180, 66, 158, 254, 261, 257, 156,
3830 230, 242, 128, 102, 201, 152, 212, 112, 5, 111,
3831 112, 128, 219, 224, 227, 127, 264, 135, 127, 264,
3832 34, 62, 169, 170, 171, 172, 127, 134, 213, 128,
3833 232, 128, 124, 175, 177, 156, 135, 135, 199, 241,
3834 46, 101, 192, 205, 206, 207, 116, 261, 111, 227,
3835 223, 261, 106, 134, 171, 172, 238, 178, 3, 156,
3836 244, 101, 146, 151, 192, 202, 203, 204, 209, 234,
3837 3, 26, 134, 207, 225, 220, 116, 223, 106, 144,
3838 144, 144, 244, 128, 128, 134, 204, 233, 218, 134,
3839 225, 144, 134, 134, 135, 235, 202, 3, 112, 218,
3840 176, 144, 134, 124, 112, 128, 134, 230, 144, 135,
3844 #define yyerrok (yyerrstatus = 0)
3845 #define yyclearin (yychar = YYEMPTY)
3846 #define YYEMPTY (-2)
3849 #define YYACCEPT goto yyacceptlab
3850 #define YYABORT goto yyabortlab
3851 #define YYERROR goto yyerrorlab
3854 /* Like YYERROR except do call yyerror. This remains here temporarily
3855 to ease the transition to the new meaning of YYERROR, for GCC.
3856 Once GCC version 2 has supplanted version 1, this can go. */
3858 #define YYFAIL goto yyerrlab
3860 #define YYRECOVERING() (!!yyerrstatus)
3862 #define YYBACKUP(Token, Value) \
3864 if (yychar == YYEMPTY && yylen == 1) \
3868 yytoken = YYTRANSLATE (yychar); \
3874 yyerror (YY_("syntax error: cannot back up")); \
3881 #define YYERRCODE 256
3884 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
3885 If N is 0, then set CURRENT to the empty location which ends
3886 the previous symbol: RHS[0] (always defined). */
3888 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
3889 #ifndef YYLLOC_DEFAULT
3890 # define YYLLOC_DEFAULT(Current, Rhs, N) \
3894 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
3895 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
3896 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
3897 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
3901 (Current).first_line = (Current).last_line = \
3902 YYRHSLOC (Rhs, 0).last_line; \
3903 (Current).first_column = (Current).last_column = \
3904 YYRHSLOC (Rhs, 0).last_column; \
3910 /* YY_LOCATION_PRINT -- Print the location on the stream.
3911 This macro was not mandated originally: define only if we know
3912 we won't break user code: when these are the locations we know. */
3914 #ifndef YY_LOCATION_PRINT
3915 # if YYLTYPE_IS_TRIVIAL
3916 # define YY_LOCATION_PRINT(File, Loc) \
3917 fprintf (File, "%d.%d-%d.%d", \
3918 (Loc).first_line, (Loc).first_column, \
3919 (Loc).last_line, (Loc).last_column)
3921 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
3926 /* YYLEX -- calling `yylex' with the right arguments. */
3929 # define YYLEX yylex (YYLEX_PARAM)
3931 # define YYLEX yylex ()
3934 /* Enable debugging if requested. */
3938 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
3939 # define YYFPRINTF fprintf
3942 # define YYDPRINTF(Args) \
3948 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
3952 YYFPRINTF (stderr, "%s ", Title); \
3953 yy_symbol_print (stderr, \
3955 YYFPRINTF (stderr, "\n"); \
3960 /*--------------------------------.
3961 | Print this symbol on YYOUTPUT. |
3962 `--------------------------------*/
3965 #if (defined __STDC__ || defined __C99__FUNC__ \
3966 || defined __cplusplus || defined _MSC_VER)
3968 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
3971 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
3974 YYSTYPE const * const yyvaluep;
3980 if (yytype < YYNTOKENS)
3981 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
3993 /*--------------------------------.
3994 | Print this symbol on YYOUTPUT. |
3995 `--------------------------------*/
3997 #if (defined __STDC__ || defined __C99__FUNC__ \
3998 || defined __cplusplus || defined _MSC_VER)
4000 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
4003 yy_symbol_print (yyoutput, yytype, yyvaluep)
4006 YYSTYPE const * const yyvaluep;
4009 if (yytype < YYNTOKENS)
4010 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4012 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4014 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
4015 YYFPRINTF (yyoutput, ")");
4018 /*------------------------------------------------------------------.
4019 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4021 `------------------------------------------------------------------*/
4023 #if (defined __STDC__ || defined __C99__FUNC__ \
4024 || defined __cplusplus || defined _MSC_VER)
4026 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4029 yy_stack_print (yybottom, yytop)
4030 yytype_int16 *yybottom;
4031 yytype_int16 *yytop;
4034 YYFPRINTF (stderr, "Stack now");
4035 for (; yybottom <= yytop; yybottom++)
4037 int yybot = *yybottom;
4038 YYFPRINTF (stderr, " %d", yybot);
4040 YYFPRINTF (stderr, "\n");
4043 # define YY_STACK_PRINT(Bottom, Top) \
4046 yy_stack_print ((Bottom), (Top)); \
4050 /*------------------------------------------------.
4051 | Report that the YYRULE is going to be reduced. |
4052 `------------------------------------------------*/
4054 #if (defined __STDC__ || defined __C99__FUNC__ \
4055 || defined __cplusplus || defined _MSC_VER)
4057 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
4060 yy_reduce_print (yyvsp, yyrule)
4065 int yynrhs = yyr2[yyrule];
4067 unsigned long int yylno = yyrline[yyrule];
4068 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4070 /* The symbols being reduced. */
4071 for (yyi = 0; yyi < yynrhs; yyi++)
4073 YYFPRINTF (stderr, " $%d = ", yyi + 1);
4074 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4075 &(yyvsp[(yyi + 1) - (yynrhs)])
4077 YYFPRINTF (stderr, "\n");
4081 # define YY_REDUCE_PRINT(Rule) \
4084 yy_reduce_print (yyvsp, Rule); \
4087 /* Nonzero means print parse trace. It is left uninitialized so that
4088 multiple parsers can coexist. */
4090 #else /* !YYDEBUG */
4091 # define YYDPRINTF(Args)
4092 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4093 # define YY_STACK_PRINT(Bottom, Top)
4094 # define YY_REDUCE_PRINT(Rule)
4095 #endif /* !YYDEBUG */
4098 /* YYINITDEPTH -- initial size of the parser's stacks. */
4100 # define YYINITDEPTH 200
4103 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4104 if the built-in stack extension method is used).
4106 Do not make this value too large; the results are undefined if
4107 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4108 evaluated with infinite-precision integer arithmetic. */
4111 # define YYMAXDEPTH 10000
4119 # if defined __GLIBC__ && defined _STRING_H
4120 # define yystrlen strlen
4122 /* Return the length of YYSTR. */
4123 #if (defined __STDC__ || defined __C99__FUNC__ \
4124 || defined __cplusplus || defined _MSC_VER)
4126 yystrlen (const char *yystr)
4134 for (yylen = 0; yystr[yylen]; yylen++)
4142 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4143 # define yystpcpy stpcpy
4145 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4147 #if (defined __STDC__ || defined __C99__FUNC__ \
4148 || defined __cplusplus || defined _MSC_VER)
4150 yystpcpy (char *yydest, const char *yysrc)
4153 yystpcpy (yydest, yysrc)
4159 const char *yys = yysrc;
4161 while ((*yyd++ = *yys++) != '\0')
4170 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4171 quotes and backslashes, so that it's suitable for yyerror. The
4172 heuristic is that double-quoting is unnecessary unless the string
4173 contains an apostrophe, a comma, or backslash (other than
4174 backslash-backslash). YYSTR is taken from yytname. If YYRES is
4175 null, do not copy; instead, return the length of what the result
4178 yytnamerr (char *yyres, const char *yystr)
4183 char const *yyp = yystr;
4190 goto do_not_strip_quotes;
4194 goto do_not_strip_quotes;
4207 do_not_strip_quotes: ;
4211 return yystrlen (yystr);
4213 return yystpcpy (yyres, yystr) - yyres;
4217 /* Copy into YYRESULT an error message about the unexpected token
4218 YYCHAR while in state YYSTATE. Return the number of bytes copied,
4219 including the terminating null byte. If YYRESULT is null, do not
4220 copy anything; just return the number of bytes that would be
4221 copied. As a special case, return 0 if an ordinary "syntax error"
4222 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
4223 size calculation. */
4225 yysyntax_error (char *yyresult, int yystate, int yychar)
4227 int yyn = yypact[yystate];
4229 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
4233 int yytype = YYTRANSLATE (yychar);
4234 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
4235 YYSIZE_T yysize = yysize0;
4237 int yysize_overflow = 0;
4238 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4239 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4243 /* This is so xgettext sees the translatable formats that are
4244 constructed on the fly. */
4245 YY_("syntax error, unexpected %s");
4246 YY_("syntax error, unexpected %s, expecting %s");
4247 YY_("syntax error, unexpected %s, expecting %s or %s");
4248 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
4249 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
4253 static char const yyunexpected[] = "syntax error, unexpected %s";
4254 static char const yyexpecting[] = ", expecting %s";
4255 static char const yyor[] = " or %s";
4256 char yyformat[sizeof yyunexpected
4257 + sizeof yyexpecting - 1
4258 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
4259 * (sizeof yyor - 1))];
4260 char const *yyprefix = yyexpecting;
4262 /* Start YYX at -YYN if negative to avoid negative indexes in
4264 int yyxbegin = yyn < 0 ? -yyn : 0;
4266 /* Stay within bounds of both yycheck and yytname. */
4267 int yychecklim = YYLAST - yyn + 1;
4268 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4271 yyarg[0] = yytname[yytype];
4272 yyfmt = yystpcpy (yyformat, yyunexpected);
4274 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4275 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
4277 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4281 yyformat[sizeof yyunexpected - 1] = '\0';
4284 yyarg[yycount++] = yytname[yyx];
4285 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4286 yysize_overflow |= (yysize1 < yysize);
4288 yyfmt = yystpcpy (yyfmt, yyprefix);
4292 yyf = YY_(yyformat);
4293 yysize1 = yysize + yystrlen (yyf);
4294 yysize_overflow |= (yysize1 < yysize);
4297 if (yysize_overflow)
4298 return YYSIZE_MAXIMUM;
4302 /* Avoid sprintf, as that infringes on the user's name space.
4303 Don't have undefined behavior even if the translation
4304 produced a string with the wrong number of "%s"s. */
4305 char *yyp = yyresult;
4307 while ((*yyp = *yyf) != '\0')
4309 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
4311 yyp += yytnamerr (yyp, yyarg[yyi++]);
4324 #endif /* YYERROR_VERBOSE */
4327 /*-----------------------------------------------.
4328 | Release the memory associated to this symbol. |
4329 `-----------------------------------------------*/
4332 #if (defined __STDC__ || defined __C99__FUNC__ \
4333 || defined __cplusplus || defined _MSC_VER)
4335 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
4338 yydestruct (yymsg, yytype, yyvaluep)
4348 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4358 /* Prevent warnings from -Wmissing-prototypes. */
4359 #ifdef YYPARSE_PARAM
4360 #if defined __STDC__ || defined __cplusplus
4361 int yyparse (void *YYPARSE_PARAM);
4365 #else /* ! YYPARSE_PARAM */
4366 #if defined __STDC__ || defined __cplusplus
4371 #endif /* ! YYPARSE_PARAM */
4374 /* The lookahead symbol. */
4377 /* The semantic value of the lookahead symbol. */
4380 /* Number of syntax errors so far. */
4385 /*-------------------------.
4386 | yyparse or yypush_parse. |
4387 `-------------------------*/
4389 #ifdef YYPARSE_PARAM
4390 #if (defined __STDC__ || defined __C99__FUNC__ \
4391 || defined __cplusplus || defined _MSC_VER)
4393 yyparse (void *YYPARSE_PARAM)
4396 yyparse (YYPARSE_PARAM)
4397 void *YYPARSE_PARAM;
4399 #else /* ! YYPARSE_PARAM */
4400 #if (defined __STDC__ || defined __C99__FUNC__ \
4401 || defined __cplusplus || defined _MSC_VER)
4414 /* Number of tokens to shift before error messages enabled. */
4417 /* The stacks and their tools:
4418 `yyss': related to states.
4419 `yyvs': related to semantic values.
4421 Refer to the stacks thru separate pointers, to allow yyoverflow
4422 to reallocate them elsewhere. */
4424 /* The state stack. */
4425 yytype_int16 yyssa[YYINITDEPTH];
4427 yytype_int16 *yyssp;
4429 /* The semantic value stack. */
4430 YYSTYPE yyvsa[YYINITDEPTH];
4434 YYSIZE_T yystacksize;
4438 /* Lookahead token as an internal (translated) token number. */
4440 /* The variables used to return semantic value and location from the
4445 /* Buffer for error messages, and its allocated size. */
4447 char *yymsg = yymsgbuf;
4448 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
4451 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
4453 /* The number of symbols on the RHS of the reduced rule.
4454 Keep to zero when no symbol should be popped. */
4460 yystacksize = YYINITDEPTH;
4462 YYDPRINTF ((stderr, "Starting parse\n"));
4467 yychar = YYEMPTY; /* Cause a token to be read. */
4469 /* Initialize stack pointers.
4470 Waste one element of value and location stack
4471 so that they stay on the same level as the state stack.
4472 The wasted elements are never initialized. */
4478 /*------------------------------------------------------------.
4479 | yynewstate -- Push a new state, which is found in yystate. |
4480 `------------------------------------------------------------*/
4482 /* In all cases, when you get here, the value and location stacks
4483 have just been pushed. So pushing a state here evens the stacks. */
4489 if (yyss + yystacksize - 1 <= yyssp)
4491 /* Get the current used size of the three stacks, in elements. */
4492 YYSIZE_T yysize = yyssp - yyss + 1;
4496 /* Give user a chance to reallocate the stack. Use copies of
4497 these so that the &'s don't force the real ones into
4499 YYSTYPE *yyvs1 = yyvs;
4500 yytype_int16 *yyss1 = yyss;
4502 /* Each stack pointer address is followed by the size of the
4503 data in use in that stack, in bytes. This used to be a
4504 conditional around just the two extra args, but that might
4505 be undefined if yyoverflow is a macro. */
4506 yyoverflow (YY_("memory exhausted"),
4507 &yyss1, yysize * sizeof (*yyssp),
4508 &yyvs1, yysize * sizeof (*yyvsp),
4514 #else /* no yyoverflow */
4515 # ifndef YYSTACK_RELOCATE
4516 goto yyexhaustedlab;
4518 /* Extend the stack our own way. */
4519 if (YYMAXDEPTH <= yystacksize)
4520 goto yyexhaustedlab;
4522 if (YYMAXDEPTH < yystacksize)
4523 yystacksize = YYMAXDEPTH;
4526 yytype_int16 *yyss1 = yyss;
4527 union yyalloc *yyptr =
4528 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
4530 goto yyexhaustedlab;
4531 YYSTACK_RELOCATE (yyss_alloc, yyss);
4532 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
4533 # undef YYSTACK_RELOCATE
4535 YYSTACK_FREE (yyss1);
4538 #endif /* no yyoverflow */
4540 yyssp = yyss + yysize - 1;
4541 yyvsp = yyvs + yysize - 1;
4543 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
4544 (unsigned long int) yystacksize));
4546 if (yyss + yystacksize - 1 <= yyssp)
4550 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
4552 if (yystate == YYFINAL)
4562 /* Do appropriate processing given the current state. Read a
4563 lookahead token if we need one and don't already have one. */
4565 /* First try to decide what to do without reference to lookahead token. */
4566 yyn = yypact[yystate];
4567 if (yyn == YYPACT_NINF)
4570 /* Not known => get a lookahead token if don't already have one. */
4572 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
4573 if (yychar == YYEMPTY)
4575 YYDPRINTF ((stderr, "Reading a token: "));
4579 if (yychar <= YYEOF)
4581 yychar = yytoken = YYEOF;
4582 YYDPRINTF ((stderr, "Now at end of input.\n"));
4586 yytoken = YYTRANSLATE (yychar);
4587 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
4590 /* If the proper action on seeing token YYTOKEN is to reduce or to
4591 detect an error, take that action. */
4593 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
4598 if (yyn == 0 || yyn == YYTABLE_NINF)
4604 /* Count tokens shifted since error; after three, turn off error
4609 /* Shift the lookahead token. */
4610 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
4612 /* Discard the shifted token. */
4621 /*-----------------------------------------------------------.
4622 | yydefault -- do the default action for the current state. |
4623 `-----------------------------------------------------------*/
4625 yyn = yydefact[yystate];
4631 /*-----------------------------.
4632 | yyreduce -- Do a reduction. |
4633 `-----------------------------*/
4635 /* yyn is the number of a rule to reduce with. */
4638 /* If YYLEN is nonzero, implement the default value of the action:
4641 Otherwise, the following line sets YYVAL to garbage.
4642 This behavior is undocumented and Bison
4643 users should not rely upon it. Assigning to YYVAL
4644 unconditionally makes the parser a bit smaller, and it avoids a
4645 GCC warning that YYVAL may be used uninitialized. */
4646 yyval = yyvsp[1-yylen];
4649 YY_REDUCE_PRINT (yyn);
4656 /* Line 1464 of skeleton.m4 */
4657 #line 1980 "parser.y"
4658 {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
4667 /* Line 1464 of skeleton.m4 */
4668 #line 1992 "parser.y"
4669 {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
4678 /* Line 1464 of skeleton.m4 */
4679 #line 1993 "parser.y"
4680 {PASS_ALWAYS as3_pass=(yyvsp[(2) - (4)].number_int);PASS1 as3_warning("embed command ignored");}
4689 /* Line 1464 of skeleton.m4 */
4690 #line 1996 "parser.y"
4691 {(yyval.code)=(yyvsp[(1) - (1)].code);}
4700 /* Line 1464 of skeleton.m4 */
4701 #line 1997 "parser.y"
4702 {(yyval.code)=code_new();}
4711 /* Line 1464 of skeleton.m4 */
4712 #line 1999 "parser.y"
4714 (yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));
4724 /* Line 1464 of skeleton.m4 */
4725 #line 2002 "parser.y"
4726 {(yyval.code)=(yyvsp[(1) - (1)].code);}
4735 /* Line 1464 of skeleton.m4 */
4736 #line 2018 "parser.y"
4737 {(yyval.code)=(yyvsp[(2) - (3)].code);}
4746 /* Line 1464 of skeleton.m4 */
4747 #line 2019 "parser.y"
4757 /* Line 1464 of skeleton.m4 */
4758 #line 2022 "parser.y"
4768 /* Line 1464 of skeleton.m4 */
4769 #line 2029 "parser.y"
4773 (yyval.code) = (yyvsp[(3) - (4)].code);
4777 as3_pass=(yyvsp[(1) - (4)].number_int);
4787 /* Line 1464 of skeleton.m4 */
4788 #line 2041 "parser.y"
4789 {(yyval.code)=(yyvsp[(1) - (2)].code);}
4798 /* Line 1464 of skeleton.m4 */
4799 #line 2042 "parser.y"
4800 {(yyval.code)=(yyvsp[(1) - (1)].code);}
4809 /* Line 1464 of skeleton.m4 */
4810 #line 2046 "parser.y"
4812 if((yyvsp[(1) - (1)].code)) {
4814 global->init = abc_initscript(global->file);
4815 code_t**cc = &global->init->method->body->code;
4816 *cc = code_append(*cc, (yyvsp[(1) - (1)].code));
4827 /* Line 1464 of skeleton.m4 */
4828 #line 2057 "parser.y"
4831 (yyval.number_int) = as3_pass;
4842 /* Line 1464 of skeleton.m4 */
4843 #line 2065 "parser.y"
4846 (yyval.number_int)=as3_pass;
4847 char*key = concat3((yyvsp[(1) - (3)].id),"::",(yyvsp[(3) - (3)].id));
4848 if(!definitions || !dict_contains(definitions, key)) {
4861 /* Line 1464 of skeleton.m4 */
4862 #line 2092 "parser.y"
4863 {(yyval.node)=(yyvsp[(2) - (2)].node);}
4872 /* Line 1464 of skeleton.m4 */
4873 #line 2093 "parser.y"
4874 {(yyval.node)=mkdummynode();}
4883 /* Line 1464 of skeleton.m4 */
4884 #line 2095 "parser.y"
4885 {(yyval.code)=(yyvsp[(2) - (2)].code);}
4894 /* Line 1464 of skeleton.m4 */
4895 #line 2096 "parser.y"
4896 {(yyval.code)=(yyvsp[(2) - (2)].code);}
4905 /* Line 1464 of skeleton.m4 */
4906 #line 2098 "parser.y"
4907 {(yyval.code) = (yyvsp[(1) - (1)].code);}
4916 /* Line 1464 of skeleton.m4 */
4917 #line 2099 "parser.y"
4918 {(yyval.code) = code_append((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
4927 /* Line 1464 of skeleton.m4 */
4928 #line 2102 "parser.y"
4931 if(variable_exists((yyvsp[(1) - (3)].id)))
4932 syntaxerror("Variable %s already defined", (yyvsp[(1) - (3)].id));
4934 new_variable(state->method, (yyvsp[(1) - (3)].id), 0, 1, 0);
4940 if(state->method->uses_slots) {
4941 v = find_slot(state->method, (yyvsp[(1) - (3)].id));
4943 // this variable is stored in a slot
4945 v->type = (yyvsp[(2) - (3)].classinfo);
4950 v = new_variable2(state->method, (yyvsp[(1) - (3)].id), (yyvsp[(2) - (3)].classinfo), 1, 0);
4953 (yyval.code) = slot?abc_getscopeobject(0, 1):0;
4955 typedcode_t val = node_read((yyvsp[(3) - (3)].node));
4956 if(!is_subtype_of(val.t, (yyvsp[(2) - (3)].classinfo))) {
4957 syntaxerror("Can't convert %s to %s", val.t->name, (yyvsp[(2) - (3)].classinfo)->name);
4959 if((yyvsp[(2) - (3)].classinfo)) {
4960 if(val.c->prev || val.c->opcode != OPCODE_PUSHUNDEFINED) {
4961 (yyval.code) = code_append((yyval.code), val.c);
4962 (yyval.code) = converttype((yyval.code), val.t, (yyvsp[(2) - (3)].classinfo));
4965 (yyval.code) = defaultvalue((yyval.code), (yyvsp[(2) - (3)].classinfo));
4968 if(val.c->prev || val.c->opcode != OPCODE_PUSHUNDEFINED) {
4969 (yyval.code) = code_append((yyval.code), val.c);
4970 (yyval.code) = abc_coerce_a((yyval.code));
4972 // don't do anything
4974 code_free((yyval.code));
4980 (yyval.code) = abc_setslot((yyval.code), v->index);
4982 (yyval.code) = abc_setlocal((yyval.code), v->index);
4983 v->init = do_init_variable((yyvsp[(1) - (3)].id));
4994 /* Line 1464 of skeleton.m4 */
4995 #line 2162 "parser.y"
4996 {PASS12 new_state();}
5005 /* Line 1464 of skeleton.m4 */
5006 #line 2162 "parser.y"
5008 (yyval.code) = var_block((yyvsp[(2) - (2)].code), state->vars);
5019 /* Line 1464 of skeleton.m4 */
5020 #line 2166 "parser.y"
5021 {(yyval.code) = code_new();}
5030 /* Line 1464 of skeleton.m4 */
5031 #line 2167 "parser.y"
5032 {(yyval.code)=(yyvsp[(2) - (2)].code);}
5041 /* Line 1464 of skeleton.m4 */
5042 #line 2170 "parser.y"
5044 (yyval.code) = code_new();
5045 (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (6)].value).c);
5046 code_t*myjmp,*myif = (yyval.code) = abc_iffalse((yyval.code), 0);
5048 (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (6)].code));
5049 if((yyvsp[(6) - (6)].code)) {
5050 myjmp = (yyval.code) = abc_jump((yyval.code), 0);
5052 myif->branch = (yyval.code) = abc_nop((yyval.code));
5053 if((yyvsp[(6) - (6)].code)) {
5054 (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (6)].code));
5055 myjmp->branch = (yyval.code) = abc_nop((yyval.code));
5066 /* Line 1464 of skeleton.m4 */
5067 #line 2186 "parser.y"
5068 {(yyval.code)=code_new();}
5077 /* Line 1464 of skeleton.m4 */
5078 #line 2193 "parser.y"
5080 PASS1 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable(state->method, (yyvsp[(2) - (3)].id),0,1,0);
5081 PASS2 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable(state->method, (yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].classinfo),1,0);
5091 /* Line 1464 of skeleton.m4 */
5092 #line 2197 "parser.y"
5095 (yyval.id)=(yyvsp[(1) - (1)].id);
5105 /* Line 1464 of skeleton.m4 */
5106 #line 2202 "parser.y"
5107 {PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (2)].id);(yyval.for_start).each=0;}
5116 /* Line 1464 of skeleton.m4 */
5117 #line 2203 "parser.y"
5118 {PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (3)].id);(yyval.for_start).each=1;}
5127 /* Line 1464 of skeleton.m4 */
5128 #line 2205 "parser.y"
5130 if((yyvsp[(1) - (8)].for_start).each) syntaxerror("invalid syntax: ; not allowed in for each statement");
5131 (yyval.code) = code_new();
5132 (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (8)].code));
5133 code_t*loopstart = (yyval.code) = abc_label((yyval.code));
5134 (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (8)].value).c);
5135 code_t*myif = (yyval.code) = abc_iffalse((yyval.code), 0);
5136 (yyval.code) = code_append((yyval.code), (yyvsp[(8) - (8)].code));
5137 code_t*cont = (yyval.code) = abc_nop((yyval.code));
5138 (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (8)].code));
5139 (yyval.code) = abc_jump((yyval.code), loopstart);
5140 code_t*out = (yyval.code) = abc_nop((yyval.code));
5141 breakjumpsto((yyval.code), (yyvsp[(1) - (8)].for_start).name, out);
5142 continuejumpsto((yyval.code), (yyvsp[(1) - (8)].for_start).name, cont);
5145 (yyval.code) = var_block((yyval.code), state->vars);
5156 /* Line 1464 of skeleton.m4 */
5157 #line 2225 "parser.y"
5159 node_t*n = resolve_identifier((yyvsp[(2) - (6)].id));
5160 typedcode_t w = node_write(n);
5162 int it = alloc_local();
5163 int array = alloc_local();
5165 (yyval.code) = code_new();
5166 (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (6)].value).c);
5167 (yyval.code) = abc_coerce_a((yyval.code));
5168 (yyval.code) = abc_setlocal((yyval.code), array);
5169 (yyval.code) = abc_pushbyte((yyval.code), 0);
5170 (yyval.code) = abc_setlocal((yyval.code), it);
5172 code_t*loopstart = (yyval.code) = abc_label((yyval.code));
5174 (yyval.code) = abc_hasnext2((yyval.code), array, it);
5175 code_t*myif = (yyval.code) = abc_iffalse((yyval.code), 0);
5176 (yyval.code) = abc_getlocal((yyval.code), array);
5177 (yyval.code) = abc_getlocal((yyval.code), it);
5178 if(!(yyvsp[(1) - (6)].for_start).each)
5179 (yyval.code) = abc_nextname((yyval.code));
5181 (yyval.code) = abc_nextvalue((yyval.code));
5183 (yyval.code) = converttype((yyval.code), 0, w.t);
5184 (yyval.code) = code_append((yyval.code), w.c);
5186 (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (6)].code));
5187 (yyval.code) = abc_jump((yyval.code), loopstart);
5189 code_t*out = (yyval.code) = abc_nop((yyval.code));
5190 breakjumpsto((yyval.code), (yyvsp[(1) - (6)].for_start).name, out);
5191 continuejumpsto((yyval.code), (yyvsp[(1) - (6)].for_start).name, loopstart);
5195 (yyval.code) = abc_kill((yyval.code), it);
5196 (yyval.code) = abc_kill((yyval.code), array);
5198 (yyval.code) = var_block((yyval.code), state->vars);
5209 /* Line 1464 of skeleton.m4 */
5210 #line 2269 "parser.y"
5213 (yyval.code) = code_new();
5215 code_t*myjmp = (yyval.code) = abc_jump((yyval.code), 0);
5216 code_t*loopstart = (yyval.code) = abc_label((yyval.code));
5217 (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (5)].code));
5218 code_t*cont = (yyval.code) = abc_nop((yyval.code));
5219 myjmp->branch = cont;
5220 (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (5)].value).c);
5221 (yyval.code) = abc_iftrue((yyval.code), loopstart);
5222 code_t*out = (yyval.code) = abc_nop((yyval.code));
5223 breakjumpsto((yyval.code), (yyvsp[(1) - (5)].id), out);
5224 continuejumpsto((yyval.code), (yyvsp[(1) - (5)].id), cont);
5234 /* Line 1464 of skeleton.m4 */
5235 #line 2285 "parser.y"
5237 (yyval.code) = code_new();
5238 code_t*loopstart = (yyval.code) = abc_label((yyval.code));
5239 (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (6)].code));
5240 code_t*cont = (yyval.code) = abc_nop((yyval.code));
5241 (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (6)].value).c);
5242 (yyval.code) = abc_iftrue((yyval.code), loopstart);
5243 code_t*out = (yyval.code) = abc_nop((yyval.code));
5244 breakjumpsto((yyval.code), (yyvsp[(1) - (6)].id), out);
5245 continuejumpsto((yyval.code), (yyvsp[(1) - (6)].id), cont);
5255 /* Line 1464 of skeleton.m4 */
5256 #line 2297 "parser.y"
5258 (yyval.code) = abc___break__(0, "");
5268 /* Line 1464 of skeleton.m4 */
5269 #line 2300 "parser.y"
5271 (yyval.code) = abc___break__(0, (yyvsp[(2) - (2)].id));
5281 /* Line 1464 of skeleton.m4 */
5282 #line 2303 "parser.y"
5284 (yyval.code) = abc___continue__(0, "");
5294 /* Line 1464 of skeleton.m4 */
5295 #line 2306 "parser.y"
5297 (yyval.code) = abc___continue__(0, (yyvsp[(2) - (2)].id));
5307 /* Line 1464 of skeleton.m4 */
5308 #line 2310 "parser.y"
5318 /* Line 1464 of skeleton.m4 */
5319 #line 2311 "parser.y"
5320 {(yyval.code)=(yyvsp[(1) - (1)].code);}
5329 /* Line 1464 of skeleton.m4 */
5330 #line 2312 "parser.y"
5331 {(yyval.code)=(yyvsp[(1) - (1)].code);}
5340 /* Line 1464 of skeleton.m4 */
5341 #line 2313 "parser.y"
5342 {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));}
5351 /* Line 1464 of skeleton.m4 */
5352 #line 2314 "parser.y"
5353 {(yyval.code)=(yyvsp[(1) - (1)].code);}
5362 /* Line 1464 of skeleton.m4 */
5363 #line 2315 "parser.y"
5364 {(yyval.code)=code_append((yyval.code),(yyvsp[(2) - (2)].code));}
5373 /* Line 1464 of skeleton.m4 */
5374 #line 2317 "parser.y"
5376 (yyval.code) = abc_getlocal(0, state->switch_var);
5377 (yyval.code) = code_append((yyval.code), node_read((yyvsp[(2) - (4)].node)).c);
5378 code_t*j = (yyval.code) = abc_ifne((yyval.code), 0);
5379 (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (4)].code));
5380 if((yyval.code)->opcode != OPCODE___BREAK__) {
5381 (yyval.code) = abc___fallthrough__((yyval.code), "");
5383 code_t*e = (yyval.code) = abc_nop((yyval.code));
5394 /* Line 1464 of skeleton.m4 */
5395 #line 2328 "parser.y"
5397 (yyval.code) = (yyvsp[(3) - (3)].code);
5407 /* Line 1464 of skeleton.m4 */
5408 #line 2331 "parser.y"
5409 {PASS12 new_state();state->switch_var=alloc_local();}
5418 /* Line 1464 of skeleton.m4 */
5419 #line 2331 "parser.y"
5421 (yyval.code) = node_read((yyvsp[(4) - (8)].node)).c;
5422 (yyval.code) = abc_setlocal((yyval.code), state->switch_var);
5423 (yyval.code) = code_append((yyval.code), (yyvsp[(7) - (8)].code));
5425 code_t*out = (yyval.code) = abc_kill((yyval.code), state->switch_var);
5426 breakjumpsto((yyval.code), (yyvsp[(1) - (8)].id), out);
5428 code_t*c = (yyval.code),*lastblock=0;
5430 if(c->opcode == OPCODE_IFNE) {
5431 if(!c->next) syntaxerror("internal error in fallthrough handling");
5433 } else if(c->opcode == OPCODE___FALLTHROUGH__) {
5435 c->opcode = OPCODE_JUMP;
5436 c->branch = lastblock;
5438 /* fall through end of switch */
5439 c->opcode = OPCODE_NOP;
5445 (yyval.code) = var_block((yyval.code), state->vars);
5456 /* Line 1464 of skeleton.m4 */
5457 #line 2362 "parser.y"
5458 {PASS12 new_state();
5459 state->exception_name=(yyvsp[(3) - (5)].id);
5460 PASS1 new_variable(state->method, (yyvsp[(3) - (5)].id), 0, 0, 0);
5461 PASS2 new_variable(state->method, (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].classinfo), 0, 0);
5471 /* Line 1464 of skeleton.m4 */
5472 #line 2367 "parser.y"
5474 namespace_t name_ns = {ACCESS_PACKAGE, ""};
5475 multiname_t name = {QNAME, &name_ns, 0, (yyvsp[(3) - (9)].id)};
5477 NEW(abc_exception_t, e)
5478 e->exc_type = sig2mname((yyvsp[(4) - (9)].classinfo));
5479 e->var_name = multiname_clone(&name);
5480 (yyval.exception) = e;
5483 int i = find_variable_safe(state, (yyvsp[(3) - (9)].id))->index;
5484 e->target = c = abc_nop(0);
5485 c = abc_setlocal(c, i);
5486 c = code_append(c, code_dup(state->method->scope_code));
5487 c = code_append(c, (yyvsp[(8) - (9)].code));
5490 c = var_block(c, state->vars);
5501 /* Line 1464 of skeleton.m4 */
5502 #line 2387 "parser.y"
5503 {PASS12 new_state();state->exception_name=0;}
5512 /* Line 1464 of skeleton.m4 */
5513 #line 2387 "parser.y"
5515 (yyvsp[(4) - (5)].code) = var_block((yyvsp[(4) - (5)].code), state->vars);
5516 if(!(yyvsp[(4) - (5)].code)) {
5517 (yyval.exception)=0;
5519 NEW(abc_exception_t, e)
5520 e->exc_type = 0; //all exceptions
5521 e->var_name = 0; //no name
5524 e->to = code_append(e->to, (yyvsp[(4) - (5)].code));
5525 (yyval.exception) = e;
5537 /* Line 1464 of skeleton.m4 */
5538 #line 2403 "parser.y"
5539 {(yyval.catch_list).l=list_new();(yyval.catch_list).finally=0;list_append((yyval.catch_list).l,(yyvsp[(1) - (1)].exception));}
5548 /* Line 1464 of skeleton.m4 */
5549 #line 2404 "parser.y"
5550 {(yyval.catch_list)=(yyvsp[(1) - (2)].catch_list);list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));}
5559 /* Line 1464 of skeleton.m4 */
5560 #line 2405 "parser.y"
5561 {(yyval.catch_list)=(yyvsp[(1) - (1)].catch_list);}
5570 /* Line 1464 of skeleton.m4 */
5571 #line 2406 "parser.y"
5573 (yyval.catch_list) = (yyvsp[(1) - (2)].catch_list);
5574 (yyval.catch_list).finally = 0;
5575 if((yyvsp[(2) - (2)].exception)) {
5576 list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));
5577 (yyval.catch_list).finally = (yyvsp[(2) - (2)].exception)->to;(yyvsp[(2) - (2)].exception)->to=0;
5588 /* Line 1464 of skeleton.m4 */
5589 #line 2414 "parser.y"
5591 (yyval.catch_list).l=list_new();
5592 (yyval.catch_list).finally = 0;
5593 if((yyvsp[(1) - (1)].exception)) {
5594 list_append((yyval.catch_list).l,(yyvsp[(1) - (1)].exception));
5595 (yyval.catch_list).finally = (yyvsp[(1) - (1)].exception)->to;(yyvsp[(1) - (1)].exception)->to=0;
5606 /* Line 1464 of skeleton.m4 */
5607 #line 2423 "parser.y"
5608 {PASS12 new_state();
5609 state->method->has_exceptions=1;
5610 state->method->late_binding=1;//for invariant scope_code
5620 /* Line 1464 of skeleton.m4 */
5621 #line 2426 "parser.y"
5623 code_t*out = abc_nop(0);
5625 code_t*start = abc_nop(0);
5626 (yyval.code) = code_append(start, (yyvsp[(4) - (6)].code));
5627 if(!is_break_or_jump((yyvsp[(4) - (6)].code))) {
5628 (yyval.code) = abc_jump((yyval.code), out);
5630 code_t*end = (yyval.code) = abc_nop((yyval.code));
5633 if((yyvsp[(6) - (6)].catch_list).finally)
5634 tmp = alloc_local();
5636 abc_exception_list_t*l = (yyvsp[(6) - (6)].catch_list).l;
5639 abc_exception_t*e = l->abc_exception;
5641 (yyval.code) = code_append((yyval.code), e->target);
5642 (yyval.code) = abc_jump((yyval.code), out);
5644 parserassert((ptroff_t)(yyvsp[(6) - (6)].catch_list).finally);
5646 e->target = (yyval.code) = abc_nop((yyval.code));
5647 (yyval.code) = code_append((yyval.code), code_dup(state->method->scope_code));
5648 (yyval.code) = abc___rethrow__((yyval.code));
5656 (yyval.code) = code_append((yyval.code), out);
5658 (yyval.code) = insert_finally((yyval.code), (yyvsp[(6) - (6)].catch_list).finally, tmp);
5660 list_concat(state->method->exceptions, (yyvsp[(6) - (6)].catch_list).l);
5662 (yyval.code) = var_block((yyval.code), state->vars);
5673 /* Line 1464 of skeleton.m4 */
5674 #line 2472 "parser.y"
5676 (yyval.code)=(yyvsp[(2) - (2)].value).c;
5677 (yyval.code)=abc_throw((yyval.code));
5687 /* Line 1464 of skeleton.m4 */
5688 #line 2476 "parser.y"
5690 if(!state->exception_name)
5691 syntaxerror("re-throw only possible within a catch block");
5692 variable_t*v = find_variable(state, state->exception_name);
5693 (yyval.code)=code_new();
5694 (yyval.code)=abc_getlocal((yyval.code), v->index);
5695 (yyval.code)=abc_throw((yyval.code));
5705 /* Line 1464 of skeleton.m4 */
5706 #line 2487 "parser.y"
5709 if(state->method->has_exceptions) {
5710 int v = alloc_local();
5711 state->method->scope_code = abc_getlocal(state->method->scope_code, v);
5712 state->method->scope_code = abc_pushwith(state->method->scope_code);
5713 (yyval.value_list).number = v;
5715 (yyval.value_list).cc = (yyvsp[(3) - (4)].value).c;
5725 /* Line 1464 of skeleton.m4 */
5726 #line 2497 "parser.y"
5728 /* remove getlocal;pushwith from scope code again */
5729 state->method->scope_code = code_cutlast(code_cutlast(state->method->scope_code));
5731 (yyval.code) = (yyvsp[(1) - (2)].value_list).cc;
5732 if(state->method->has_exceptions) {
5733 (yyval.code) = abc_dup((yyval.code));
5734 (yyval.code) = abc_setlocal((yyval.code), (yyvsp[(1) - (2)].value_list).number);
5736 (yyval.code) = abc_pushwith((yyval.code));
5737 (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (2)].code));
5738 (yyval.code) = abc_popscope((yyval.code));
5749 /* Line 1464 of skeleton.m4 */
5750 #line 2515 "parser.y"
5751 {PASS12 (yyval.id)="package";}
5760 /* Line 1464 of skeleton.m4 */
5761 #line 2516 "parser.y"
5762 {PASS12 (yyval.id)="namespace";}
5771 /* Line 1464 of skeleton.m4 */
5772 #line 2517 "parser.y"
5773 {PASS12 (yyval.id)="NaN";}
5782 /* Line 1464 of skeleton.m4 */
5783 #line 2518 "parser.y"
5784 {PASS12 (yyval.id)=(yyvsp[(1) - (1)].id);}
5793 /* Line 1464 of skeleton.m4 */
5794 #line 2520 "parser.y"
5795 {PASS12 (yyval.id) = concat3((yyvsp[(1) - (3)].id),".",(yyvsp[(3) - (3)].id));free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;}
5804 /* Line 1464 of skeleton.m4 */
5805 #line 2521 "parser.y"
5806 {PASS12 (yyval.id)=strdup((yyvsp[(1) - (1)].id));}
5815 /* Line 1464 of skeleton.m4 */
5816 #line 2523 "parser.y"
5817 {PASS12 startpackage((yyvsp[(2) - (3)].id));free((yyvsp[(2) - (3)].id));(yyvsp[(2) - (3)].id)=0;}
5826 /* Line 1464 of skeleton.m4 */
5827 #line 2524 "parser.y"
5828 {PASS12 endpackage();(yyval.code)=0;}
5837 /* Line 1464 of skeleton.m4 */
5838 #line 2525 "parser.y"
5839 {PASS12 startpackage("");}
5848 /* Line 1464 of skeleton.m4 */
5849 #line 2526 "parser.y"
5850 {PASS12 endpackage();(yyval.code)=0;}
5859 /* Line 1464 of skeleton.m4 */
5860 #line 2549 "parser.y"
5863 slotinfo_t*s = registry_find(state->package, (yyvsp[(2) - (2)].id));
5864 if(!s && as3_pass==1) {as3_schedule_class(state->package, (yyvsp[(2) - (2)].id));}
5865 state_has_imports();
5866 dict_put(state->imports, state->package, (yyvsp[(2) - (2)].id));
5877 /* Line 1464 of skeleton.m4 */
5878 #line 2557 "parser.y"
5881 slotinfo_t*s = registry_find((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);
5882 if(!s && as3_pass==1) {// || !(s->flags&FLAG_BUILTIN)) {
5883 as3_schedule_class((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);
5885 state_has_imports();
5886 dict_put(state->imports, (yyvsp[(2) - (2)].classinfo)->name, (yyvsp[(2) - (2)].classinfo));
5887 import_toplevel((yyvsp[(2) - (2)].classinfo)->package);
5898 /* Line 1464 of skeleton.m4 */
5899 #line 2568 "parser.y"
5902 if(strncmp("flash.", (yyvsp[(2) - (4)].id), 6) && as3_pass==1) {
5903 as3_schedule_package((yyvsp[(2) - (4)].id));
5907 i->package = (yyvsp[(2) - (4)].id);
5908 state_has_imports();
5909 list_append(state->wildcard_imports, i);
5910 import_toplevel(i->package);
5921 /* Line 1464 of skeleton.m4 */
5922 #line 2584 "parser.y"
5923 {PASS12 (yyval.flags).flags=0;(yyval.flags).ns=0;}
5932 /* Line 1464 of skeleton.m4 */
5933 #line 2585 "parser.y"
5934 {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}
5943 /* Line 1464 of skeleton.m4 */
5944 #line 2586 "parser.y"
5945 {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}
5954 /* Line 1464 of skeleton.m4 */
5955 #line 2587 "parser.y"
5958 (yyval.flags).flags=(yyvsp[(1) - (2)].flags).flags|(yyvsp[(2) - (2)].flags).flags;
5959 if((yyvsp[(1) - (2)].flags).ns && (yyvsp[(2) - (2)].flags).ns) syntaxerror("only one namespace allowed in one declaration");
5960 (yyval.flags).ns=(yyvsp[(1) - (2)].flags).ns?(yyvsp[(1) - (2)].flags).ns:(yyvsp[(2) - (2)].flags).ns;
5971 /* Line 1464 of skeleton.m4 */
5972 #line 2594 "parser.y"
5973 {PASS12 (yyval.flags).flags=FLAG_PUBLIC;(yyval.flags).ns=0;}
5982 /* Line 1464 of skeleton.m4 */
5983 #line 2595 "parser.y"
5984 {PASS12 (yyval.flags).flags=FLAG_PRIVATE;(yyval.flags).ns=0;}
5993 /* Line 1464 of skeleton.m4 */
5994 #line 2596 "parser.y"
5995 {PASS12 (yyval.flags).flags=FLAG_PROTECTED;(yyval.flags).ns=0;}
6004 /* Line 1464 of skeleton.m4 */
6005 #line 2597 "parser.y"
6006 {PASS12 (yyval.flags).flags=FLAG_STATIC;(yyval.flags).ns=0;}
6015 /* Line 1464 of skeleton.m4 */
6016 #line 2598 "parser.y"
6017 {PASS12 (yyval.flags).flags=FLAG_DYNAMIC;(yyval.flags).ns=0;}
6026 /* Line 1464 of skeleton.m4 */
6027 #line 2599 "parser.y"
6028 {PASS12 (yyval.flags).flags=FLAG_FINAL;(yyval.flags).ns=0;}
6037 /* Line 1464 of skeleton.m4 */
6038 #line 2600 "parser.y"
6039 {PASS12 (yyval.flags).flags=FLAG_OVERRIDE;(yyval.flags).ns=0;}
6048 /* Line 1464 of skeleton.m4 */
6049 #line 2601 "parser.y"
6050 {PASS12 (yyval.flags).flags=FLAG_NATIVE;(yyval.flags).ns=0;}
6059 /* Line 1464 of skeleton.m4 */
6060 #line 2602 "parser.y"
6061 {PASS12 (yyval.flags).flags=FLAG_PACKAGEINTERNAL;(yyval.flags).ns=0;}
6070 /* Line 1464 of skeleton.m4 */
6071 #line 2603 "parser.y"
6072 {PASS12 (yyval.flags).flags=FLAG_NAMESPACE;
6073 (yyval.flags).ns=(yyvsp[(1) - (1)].id);
6083 /* Line 1464 of skeleton.m4 */
6084 #line 2607 "parser.y"
6085 {PASS12 (yyval.classinfo)=0;}
6094 /* Line 1464 of skeleton.m4 */
6095 #line 2608 "parser.y"
6096 {PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
6105 /* Line 1464 of skeleton.m4 */
6106 #line 2610 "parser.y"
6107 {PASS12 (yyval.classinfo_list)=list_new();}
6116 /* Line 1464 of skeleton.m4 */
6117 #line 2611 "parser.y"
6118 {PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
6127 /* Line 1464 of skeleton.m4 */
6128 #line 2613 "parser.y"
6129 {PASS12 (yyval.classinfo_list)=list_new();}
6138 /* Line 1464 of skeleton.m4 */
6139 #line 2614 "parser.y"
6140 {PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
6149 /* Line 1464 of skeleton.m4 */
6150 #line 2618 "parser.y"
6151 {PASS12 startclass(&(yyvsp[(1) - (6)].flags),(yyvsp[(3) - (6)].id),(yyvsp[(4) - (6)].classinfo),(yyvsp[(5) - (6)].classinfo_list));}
6160 /* Line 1464 of skeleton.m4 */
6161 #line 2620 "parser.y"
6162 {PASS12 endclass();(yyval.code)=0;}
6171 /* Line 1464 of skeleton.m4 */
6172 #line 2624 "parser.y"
6173 {PASS12 (yyvsp[(1) - (5)].flags).flags|=FLAG_INTERFACE;
6174 startclass(&(yyvsp[(1) - (5)].flags),(yyvsp[(3) - (5)].id),0,(yyvsp[(4) - (5)].classinfo_list));}
6183 /* Line 1464 of skeleton.m4 */
6184 #line 2627 "parser.y"
6185 {PASS12 endclass();(yyval.code)=0;}
6194 /* Line 1464 of skeleton.m4 */
6195 #line 2636 "parser.y"
6196 {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
6205 /* Line 1464 of skeleton.m4 */
6206 #line 2640 "parser.y"
6208 code_t*c = state->cls->static_init->header;
6209 c = code_append(c, (yyvsp[(1) - (1)].code));
6210 state->cls->static_init->header = c;
6220 /* Line 1464 of skeleton.m4 */
6221 #line 2651 "parser.y"
6223 syntaxerror("variable declarations not allowed in interfaces");
6233 /* Line 1464 of skeleton.m4 */
6234 #line 2654 "parser.y"
6237 (yyvsp[(1) - (8)].flags).flags |= FLAG_PUBLIC;
6238 if((yyvsp[(1) - (8)].flags).flags&(FLAG_PRIVATE|FLAG_PACKAGEINTERNAL|FLAG_PROTECTED)) {
6239 syntaxerror("invalid method modifiers: interface methods always need to be public");
6241 startfunction(&(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo));
6242 endfunction(&(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo), 0);
6243 list_deep_free((yyvsp[(6) - (8)].params).list);
6253 /* Line 1464 of skeleton.m4 */
6254 #line 2729 "parser.y"
6255 {PASS12 setslotstate(&(yyvsp[(1) - (2)].flags),(yyvsp[(2) - (2)].token));}
6264 /* Line 1464 of skeleton.m4 */
6265 #line 2729 "parser.y"
6266 {PASS12 (yyval.code)=(yyvsp[(4) - (4)].code);setslotstate(0, 0);}
6275 /* Line 1464 of skeleton.m4 */
6276 #line 2731 "parser.y"
6277 {PASS12 (yyval.code)=0;}
6286 /* Line 1464 of skeleton.m4 */
6287 #line 2732 "parser.y"
6288 {PASS12 (yyval.code)=0;}
6297 /* Line 1464 of skeleton.m4 */
6298 #line 2735 "parser.y"
6301 int flags = slotstate_flags->flags;
6302 namespace_t ns = modifiers2access(slotstate_flags);
6306 varinfo_t* info = 0;
6308 memberinfo_t*i = registry_findmember(state->cls->info, ns.name, (yyvsp[(1) - (3)].id), 1, slotstate_flags->flags&FLAG_STATIC);
6310 check_override(i, flags);
6312 info = varinfo_register_onclass(state->cls->info, ns.access, ns.name, (yyvsp[(1) - (3)].id), slotstate_flags->flags&FLAG_STATIC);
6314 slotinfo_t*i = registry_find(state->package, (yyvsp[(1) - (3)].id));
6316 syntaxerror("package %s already contains '%s'", state->package, (yyvsp[(1) - (3)].id));
6318 if(ns.name && ns.name[0]) {
6319 syntaxerror("namespaces not allowed on package-level variables");
6321 info = varinfo_register_global(ns.access, state->package, (yyvsp[(1) - (3)].id));
6324 info->type = (yyvsp[(2) - (3)].classinfo);
6325 info->flags = flags;
6327 dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, info);
6331 varinfo_t*info = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
6335 trait_t*t = add_abc_slot(slotstate_flags, (yyvsp[(1) - (3)].id), &mname, &code);
6337 if((yyvsp[(2) - (3)].classinfo)) {
6338 MULTINAME(m, (yyvsp[(2) - (3)].classinfo));
6339 t->type_name = multiname_clone(&m);
6341 info->slot = t->slot_id;
6343 /* workaround for "VerifyError: Error #1053: Illegal override of ::test2 in C1"
6344 FIXME: is there a way to use slots and still don't have conflicting overrides?
6346 info->slot = t->slot_id = 0;
6348 constant_t cval = (yyvsp[(3) - (3)].node)->type->eval((yyvsp[(3) - (3)].node));
6349 if(cval.type!=CONSTANT_UNKNOWN) {
6350 /* compile time constant */
6351 t->value = malloc(sizeof(constant_t));
6352 memcpy(t->value, &cval, sizeof(constant_t));
6353 info->value = constant_clone(t->value);
6355 typedcode_t v = node_read((yyvsp[(3) - (3)].node));
6356 /* initalization code (if needed) */
6358 if(v.c && !is_pushundefined(v.c)) {
6359 c = abc_getlocal_0(c);
6360 c = code_append(c, v.c);
6361 c = converttype(c, v.t, (yyvsp[(2) - (3)].classinfo));
6363 c = abc_initproperty2(c, &mname);
6365 c = abc_setslot(c, t->slot_id);
6368 *code = code_append(*code, c);
6371 if(slotstate_varconst==KW_CONST) {
6372 t->kind= TRAIT_CONST;
6373 info->flags |= FLAG_CONST;
6387 /* Line 1464 of skeleton.m4 */
6388 #line 2818 "parser.y"
6389 {(yyval.constant)=0;}
6398 /* Line 1464 of skeleton.m4 */
6399 #line 2819 "parser.y"
6401 (yyval.constant) = malloc(sizeof(constant_t));
6402 *(yyval.constant) = node_eval((yyvsp[(2) - (2)].node));
6403 if((yyval.constant)->type == CONSTANT_UNKNOWN) {
6404 syntaxerror("can't evaluate default parameter value (needs to be a compile-time constant)");
6415 /* Line 1464 of skeleton.m4 */
6416 #line 2828 "parser.y"
6417 {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_int));}
6426 /* Line 1464 of skeleton.m4 */
6427 #line 2829 "parser.y"
6429 (yyval.constant) = constant_new_uint((yyvsp[(1) - (1)].number_uint));
6439 /* Line 1464 of skeleton.m4 */
6440 #line 2832 "parser.y"
6441 {(yyval.constant) = constant_new_float((yyvsp[(1) - (1)].number_float));}
6450 /* Line 1464 of skeleton.m4 */
6451 #line 2833 "parser.y"
6452 {(yyval.constant) = constant_new_string2((yyvsp[(1) - (1)].str).str,(yyvsp[(1) - (1)].str).len);free((char*)(yyvsp[(1) - (1)].str).str);}
6461 /* Line 1464 of skeleton.m4 */
6462 #line 2834 "parser.y"
6463 {(yyval.constant) = constant_new_true((yyvsp[(1) - (1)].token));}
6472 /* Line 1464 of skeleton.m4 */
6473 #line 2835 "parser.y"
6474 {(yyval.constant) = constant_new_false((yyvsp[(1) - (1)].token));}
6483 /* Line 1464 of skeleton.m4 */
6484 #line 2836 "parser.y"
6485 {(yyval.constant) = constant_new_null((yyvsp[(1) - (1)].token));}
6494 /* Line 1464 of skeleton.m4 */
6495 #line 2837 "parser.y"
6496 {(yyval.constant) = constant_new_undefined((yyvsp[(1) - (1)].token));}
6505 /* Line 1464 of skeleton.m4 */
6506 #line 2838 "parser.y"
6507 {(yyval.constant) = constant_new_float(__builtin_nan(""));}
6516 /* Line 1464 of skeleton.m4 */
6517 #line 2851 "parser.y"
6519 multiname_t m = {QNAME, &stdns, 0, "XML"};
6522 v.c = abc_getlex2(v.c, &m);
6523 v.c = code_append(v.c, node_read((yyvsp[(1) - (1)].node)).c);
6524 v.c = abc_construct(v.c, 1);
6526 (yyval.node) = mkcodenode(v);
6536 /* Line 1464 of skeleton.m4 */
6537 #line 2862 "parser.y"
6538 {PASS_ALWAYS if(!xml_level++) tokenizer_begin_xml();}
6547 /* Line 1464 of skeleton.m4 */
6548 #line 2863 "parser.y"
6549 {PASS_ALWAYS tokenizer_begin_xmltext();}
6558 /* Line 1464 of skeleton.m4 */
6559 #line 2864 "parser.y"
6560 {PASS_ALWAYS if(!--xml_level) tokenizer_end_xml(); else tokenizer_begin_xmltext();}
6569 /* Line 1464 of skeleton.m4 */
6570 #line 2866 "parser.y"
6571 {PASS_ALWAYS tokenizer_begin_xmltext();}
6580 /* Line 1464 of skeleton.m4 */
6581 #line 2866 "parser.y"
6583 (yyval.node) = (yyvsp[(2) - (4)].node);
6593 /* Line 1464 of skeleton.m4 */
6594 #line 2869 "parser.y"
6595 {PASS_ALWAYS tokenizer_begin_xml();}
6604 /* Line 1464 of skeleton.m4 */
6605 #line 2869 "parser.y"
6607 (yyval.node) = (yyvsp[(2) - (4)].node);
6617 /* Line 1464 of skeleton.m4 */
6618 #line 2872 "parser.y"
6619 {(yyval.node)=mkstringnode("");}
6628 /* Line 1464 of skeleton.m4 */
6629 #line 2873 "parser.y"
6631 (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node));
6641 /* Line 1464 of skeleton.m4 */
6642 #line 2876 "parser.y"
6644 char* str = string_cstr(&(yyvsp[(2) - (2)].str));
6645 (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),mkstringnode(str));
6656 /* Line 1464 of skeleton.m4 */
6657 #line 2881 "parser.y"
6659 (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node), mkstringnode(">"));
6669 /* Line 1464 of skeleton.m4 */
6670 #line 2884 "parser.y"
6672 (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node));
6682 /* Line 1464 of skeleton.m4 */
6683 #line 2887 "parser.y"
6685 (yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkaddnode((yyvsp[(2) - (3)].node),(yyvsp[(3) - (3)].node)));
6695 /* Line 1464 of skeleton.m4 */
6696 #line 2890 "parser.y"
6698 (yyval.node) = mkstringnode((yyvsp[(1) - (1)].id));
6708 /* Line 1464 of skeleton.m4 */
6709 #line 2893 "parser.y"
6711 (yyval.node) = (yyvsp[(1) - (1)].node);
6721 /* Line 1464 of skeleton.m4 */
6722 #line 2897 "parser.y"
6724 (yyval.node) = mkstringnode("");
6734 /* Line 1464 of skeleton.m4 */
6735 #line 2900 "parser.y"
6737 (yyval.node) = mkaddnode(mkstringnode(" "),(yyvsp[(1) - (1)].node));
6747 /* Line 1464 of skeleton.m4 */
6748 #line 2904 "parser.y"
6750 //$$ = allocprintf("<%s%s/>", $2, $3, $5, $8);
6751 (yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkstringnode("<"),(yyvsp[(2) - (6)].node)),(yyvsp[(3) - (6)].node)),mkstringnode("/>"));
6761 /* Line 1464 of skeleton.m4 */
6762 #line 2908 "parser.y"
6764 //$$ = allocprintf("<%s%s>%s</%s>", $2, $3, $5, $8);
6765 (yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(
6766 mkstringnode("<"),(yyvsp[(2) - (10)].node)),(yyvsp[(3) - (10)].node)),mkstringnode(">")),(yyvsp[(5) - (10)].node)),mkstringnode("</")),(yyvsp[(8) - (10)].node)),mkstringnode(">"));
6776 /* Line 1464 of skeleton.m4 */
6777 #line 2913 "parser.y"
6779 //$$ = allocprintf("<%s%s>%s%s</%s>", $2, $3, $5, $6, $9);
6780 (yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(
6781 mkstringnode("<"),(yyvsp[(2) - (11)].node)),(yyvsp[(3) - (11)].node)),mkstringnode(">")),(yyvsp[(5) - (11)].node)),(yyvsp[(6) - (11)].node)),mkstringnode("</")),(yyvsp[(9) - (11)].node)),mkstringnode(">"));
6791 /* Line 1464 of skeleton.m4 */
6792 #line 2919 "parser.y"
6794 (yyval.node) = (yyvsp[(1) - (1)].node);
6804 /* Line 1464 of skeleton.m4 */
6805 #line 2922 "parser.y"
6807 (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node), mkaddnode(mkstringnode(" "),(yyvsp[(2) - (2)].node)));
6817 /* Line 1464 of skeleton.m4 */
6818 #line 2925 "parser.y"
6820 (yyval.node) = (yyvsp[(1) - (1)].node);
6830 /* Line 1464 of skeleton.m4 */
6831 #line 2928 "parser.y"
6833 char* str = string_cstr(&(yyvsp[(3) - (3)].str));
6834 (yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkstringnode(concat2("=",str)));
6845 /* Line 1464 of skeleton.m4 */
6846 #line 2933 "parser.y"
6848 (yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkaddnode(mkstringnode("=\""), mkaddnode((yyvsp[(3) - (3)].node), mkstringnode("\""))));
6858 /* Line 1464 of skeleton.m4 */
6859 #line 2936 "parser.y"
6861 (yyval.node) = mkaddnode(mkaddnode(mkstringnode(concat2((yyvsp[(1) - (3)].id),"=\"")), (yyvsp[(3) - (3)].node)), mkstringnode("\""));
6871 /* Line 1464 of skeleton.m4 */
6872 #line 2939 "parser.y"
6874 char* str = string_cstr(&(yyvsp[(3) - (3)].str));
6875 (yyval.node)=mkstringnode(allocprintf("%s=%s", (yyvsp[(1) - (3)].id),str));
6877 free((yyvsp[(1) - (3)].id));free((char*)(yyvsp[(3) - (3)].str).str);
6887 /* Line 1464 of skeleton.m4 */
6888 #line 2949 "parser.y"
6891 memset(&(yyval.params),0,sizeof((yyval.params)));
6901 /* Line 1464 of skeleton.m4 */
6902 #line 2953 "parser.y"
6905 (yyval.params)=(yyvsp[(1) - (1)].params);
6915 /* Line 1464 of skeleton.m4 */
6916 #line 2959 "parser.y"
6919 memset(&(yyval.params),0,sizeof((yyval.params)));
6920 (yyval.params).varargs=1;
6921 list_append((yyval.params).list, (yyvsp[(2) - (2)].param));
6931 /* Line 1464 of skeleton.m4 */
6932 #line 2965 "parser.y"
6935 (yyval.params) =(yyvsp[(1) - (4)].params);
6936 (yyval.params).varargs=1;
6937 list_append((yyval.params).list, (yyvsp[(4) - (4)].param));
6947 /* Line 1464 of skeleton.m4 */
6948 #line 2973 "parser.y"
6951 (yyval.params) = (yyvsp[(1) - (3)].params);
6952 list_append((yyval.params).list, (yyvsp[(3) - (3)].param));
6962 /* Line 1464 of skeleton.m4 */
6963 #line 2978 "parser.y"
6966 memset(&(yyval.params),0,sizeof((yyval.params)));
6967 list_append((yyval.params).list, (yyvsp[(1) - (1)].param));
6977 /* Line 1464 of skeleton.m4 */
6978 #line 2984 "parser.y"
6981 (yyval.param) = rfx_calloc(sizeof(param_t));
6982 (yyval.param)->name=(yyvsp[(1) - (4)].id);
6983 (yyval.param)->type = (yyvsp[(3) - (4)].classinfo);
6985 (yyval.param)->value = (yyvsp[(4) - (4)].constant);
6995 /* Line 1464 of skeleton.m4 */
6996 #line 2992 "parser.y"
6999 (yyval.param) = rfx_calloc(sizeof(param_t));
7000 (yyval.param)->name=(yyvsp[(1) - (2)].id);
7001 (yyval.param)->type = TYPE_ANY;
7003 (yyval.param)->value = (yyvsp[(2) - (2)].constant);
7013 /* Line 1464 of skeleton.m4 */
7014 #line 3002 "parser.y"
7015 {PASS12 (yyval.token)=0;}
7024 /* Line 1464 of skeleton.m4 */
7025 #line 3005 "parser.y"
7026 {PASS12 startfunction(&(yyvsp[(1) - (9)].flags),(yyvsp[(3) - (9)].token),(yyvsp[(4) - (9)].id),&(yyvsp[(6) - (9)].params),(yyvsp[(8) - (9)].classinfo));}
7035 /* Line 1464 of skeleton.m4 */
7036 #line 3006 "parser.y"
7039 endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),0,0);
7041 if(!state->method->info) syntaxerror("internal error");
7043 code_t*c = method_header(state->method);
7044 c = wrap_function(c, 0, (yyvsp[(11) - (12)].code));
7046 endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),(yyvsp[(8) - (12)].classinfo),c);
7048 list_deep_free((yyvsp[(6) - (12)].params).list);
7059 /* Line 1464 of skeleton.m4 */
7060 #line 3022 "parser.y"
7061 {PASS12 (yyval.id)=0;}
7070 /* Line 1464 of skeleton.m4 */
7071 #line 3024 "parser.y"
7072 {PASS12 innerfunction((yyvsp[(2) - (7)].id),&(yyvsp[(4) - (7)].params),(yyvsp[(6) - (7)].classinfo));}
7081 /* Line 1464 of skeleton.m4 */
7082 #line 3025 "parser.y"
7085 endfunction(0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),0,0);
7087 methodinfo_t*f = state->method->info;
7088 if(!f || !f->kind) syntaxerror("internal error");
7090 code_t*c = method_header(state->method);
7091 c = wrap_function(c, 0, (yyvsp[(9) - (10)].code));
7093 int index = state->method->var_index;
7094 endfunction(0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),(yyvsp[(6) - (10)].classinfo),c);
7096 (yyval.value).c = abc_getlocal(0, index);
7097 (yyval.value).t = TYPE_FUNCTION(f);
7099 PASS12 list_deep_free((yyvsp[(4) - (10)].params).list);
7109 /* Line 1464 of skeleton.m4 */
7110 #line 3047 "parser.y"
7112 PASS1 NEW(unresolvedinfo_t,c);
7113 memset(c, 0, sizeof(*c));
7114 c->kind = INFOTYPE_UNRESOLVED;
7115 c->name = (yyvsp[(1) - (1)].id);
7116 c->package = get_package_from_name((yyvsp[(1) - (1)].id));
7118 c->nsset = get_current_imports();
7119 /* make the compiler look for this class in the current directory,
7121 as3_schedule_class_noerror(state->package, (yyvsp[(1) - (1)].id));
7123 (yyval.classinfo) = (classinfo_t*)c;
7125 slotinfo_t*s = find_class((yyvsp[(1) - (1)].id));
7126 if(!s) syntaxerror("Could not find class/method %s (current package: %s)\n", (yyvsp[(1) - (1)].id), state->package);
7127 (yyval.classinfo) = (classinfo_t*)s;
7137 /* Line 1464 of skeleton.m4 */
7138 #line 3066 "parser.y"
7140 PASS1 NEW(unresolvedinfo_t,c);
7141 memset(c, 0, sizeof(*c));
7142 c->kind = INFOTYPE_UNRESOLVED;
7143 c->package = (yyvsp[(1) - (3)].id);
7144 c->name = (yyvsp[(3) - (3)].id);
7145 (yyval.classinfo) = (classinfo_t*)c;
7147 slotinfo_t*s = registry_find((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
7148 if(!s) syntaxerror("Couldn't find class/method %s.%s\n", (yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
7149 free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;
7150 (yyval.classinfo) = (classinfo_t*)s;
7160 /* Line 1464 of skeleton.m4 */
7161 #line 3083 "parser.y"
7162 {PASS12 (yyval.classinfo_list)=list_new();list_append((yyval.classinfo_list), (yyvsp[(1) - (1)].classinfo));}
7171 /* Line 1464 of skeleton.m4 */
7172 #line 3084 "parser.y"
7173 {PASS12 (yyval.classinfo_list)=(yyvsp[(1) - (3)].classinfo_list);list_append((yyval.classinfo_list),(yyvsp[(3) - (3)].classinfo));}
7182 /* Line 1464 of skeleton.m4 */
7183 #line 3086 "parser.y"
7184 {PASS12 (yyval.classinfo)=(yyvsp[(1) - (1)].classinfo);}
7193 /* Line 1464 of skeleton.m4 */
7194 #line 3087 "parser.y"
7195 {PASS12 (yyval.classinfo)=TYPE_ANY;}
7204 /* Line 1464 of skeleton.m4 */
7205 #line 3088 "parser.y"
7206 {PASS12 (yyval.classinfo)=TYPE_VOID;}
7215 /* Line 1464 of skeleton.m4 */
7216 #line 3097 "parser.y"
7217 {PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
7226 /* Line 1464 of skeleton.m4 */
7227 #line 3098 "parser.y"
7228 {PASS12 (yyval.classinfo)=0;}
7237 /* Line 1464 of skeleton.m4 */
7238 #line 3102 "parser.y"
7239 {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
7248 /* Line 1464 of skeleton.m4 */
7249 #line 3103 "parser.y"
7250 {(yyval.value_list)=(yyvsp[(2) - (3)].value_list);}
7259 /* Line 1464 of skeleton.m4 */
7260 #line 3105 "parser.y"
7261 {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
7270 /* Line 1464 of skeleton.m4 */
7271 #line 3109 "parser.y"
7272 {(yyval.value_list).number=1;
7273 (yyval.value_list).cc = (yyvsp[(1) - (1)].value).c;
7283 /* Line 1464 of skeleton.m4 */
7284 #line 3113 "parser.y"
7285 {(yyval.value_list) = (yyvsp[(1) - (2)].value_list);}
7294 /* Line 1464 of skeleton.m4 */
7295 #line 3114 "parser.y"
7297 (yyval.value_list).number= (yyvsp[(1) - (2)].value_list).number+1;
7298 (yyval.value_list).cc = code_append((yyvsp[(1) - (2)].value_list).cc, (yyvsp[(2) - (2)].value).c);
7308 /* Line 1464 of skeleton.m4 */
7309 #line 3120 "parser.y"
7311 typedcode_t v = node_read((yyvsp[(2) - (4)].node));
7312 (yyval.value).c = v.c;
7313 if((yyval.value).c->opcode == OPCODE_COERCE_A) (yyval.value).c = code_cutlast((yyval.value).c);
7315 code_t*paramcode = (yyvsp[(4) - (4)].value_list).cc;
7316 if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
7317 multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
7318 (yyval.value).c = code_cutlast((yyval.value).c);
7319 (yyval.value).c = code_append((yyval.value).c, paramcode);
7320 (yyval.value).c = abc_constructprop2((yyval.value).c, name, (yyvsp[(4) - (4)].value_list).number);
7321 multiname_destroy(name);
7322 } else if(is_getlocal((yyval.value).c)) {
7323 (yyval.value).c = code_append((yyval.value).c, paramcode);
7324 (yyval.value).c = abc_construct((yyval.value).c, (yyvsp[(4) - (4)].value_list).number);
7325 } else if(TYPE_IS_CLASS(v.t) && v.t->data) {
7326 code_free((yyval.value).c);
7327 classinfo_t*c = v.t->data;
7329 (yyval.value).c = abc_findpropstrict2(0, &m);
7330 (yyval.value).c = code_append((yyval.value).c, paramcode);
7331 (yyval.value).c = abc_constructprop2((yyval.value).c, &m, (yyvsp[(4) - (4)].value_list).number);
7332 /*} else if($$.c->opcode == OPCODE_GETSLOT) {
7333 int slot = (int)(ptroff_t)$$.c->data[0];
7334 trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);//FIXME
7335 multiname_t*name = t->name;
7336 $$.c = code_cutlast($$.c);
7337 $$.c = code_append($$.c, paramcode);
7338 $$.c = abc_constructprop2($$.c, name, $4.number);*/
7340 (yyval.value).c = code_append((yyval.value).c, paramcode);
7341 (yyval.value).c = abc_construct((yyval.value).c, (yyvsp[(4) - (4)].value_list).number);
7344 (yyval.value).t = TYPE_ANY;
7345 if(TYPE_IS_CLASS(v.t) && v.t->data) {
7346 (yyval.value).t = v.t->data;
7348 (yyval.value).c = abc_coerce_a((yyval.value).c);
7349 (yyval.value).t = TYPE_ANY;
7360 /* Line 1464 of skeleton.m4 */
7361 #line 3167 "parser.y"
7364 typedcode_t v = node_read((yyvsp[(1) - (4)].node));
7365 (yyval.value).c = v.c;
7366 if((yyval.value).c->opcode == OPCODE_COERCE_A) {
7367 (yyval.value).c = code_cutlast((yyval.value).c);
7369 code_t*paramcode = (yyvsp[(3) - (4)].value_list).cc;
7371 (yyval.value).t = TYPE_ANY;
7372 if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
7373 multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
7374 (yyval.value).c = code_cutlast((yyval.value).c);
7375 (yyval.value).c = code_append((yyval.value).c, paramcode);
7376 (yyval.value).c = abc_callproperty2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);
7377 multiname_destroy(name);
7378 /* } else if($$.c->opcode == OPCODE_GETSLOT && $$.c->prev->opcode != OPCODE_GETSCOPEOBJECT) {
7379 int slot = (int)(ptroff_t)$$.c->data[0];
7380 trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);
7381 if(t->kind!=TRAIT_METHOD) {
7382 //ok: flash allows to assign closures to members.
7384 multiname_t*name = t->name;
7385 $$.c = code_cutlast($$.c);
7386 $$.c = code_append($$.c, paramcode);
7387 //$$.c = abc_callmethod($$.c, t->method, len); //#1051 illegal early access binding
7388 $$.c = abc_callproperty2($$.c, name, $3.number);*/
7389 } else if((yyval.value).c->opcode == OPCODE_GETSUPER) {
7390 multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
7391 (yyval.value).c = code_cutlast((yyval.value).c);
7392 (yyval.value).c = code_append((yyval.value).c, paramcode);
7393 (yyval.value).c = abc_callsuper2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);
7394 multiname_destroy(name);
7396 (yyval.value).c = abc_getglobalscope((yyval.value).c);
7397 (yyval.value).c = code_append((yyval.value).c, paramcode);
7398 (yyval.value).c = abc_call((yyval.value).c, (yyvsp[(3) - (4)].value_list).number);
7401 if(TYPE_IS_FUNCTION(v.t) && v.t->data) {
7402 (yyval.value).t = ((methodinfo_t*)(v.t->data))->return_type;
7403 } else if(TYPE_IS_CLASS(v.t) && v.t->data) {
7404 // calling a class is like a typecast
7405 (yyval.value).t = (classinfo_t*)v.t->data;
7407 (yyval.value).t = TYPE_ANY;
7408 (yyval.value).c = abc_coerce_a((yyval.value).c);
7419 /* Line 1464 of skeleton.m4 */
7420 #line 3217 "parser.y"
7422 if(!state->cls) syntaxerror("super() not allowed outside of a class");
7423 if(!state->method) syntaxerror("super() not allowed outside of a function");
7424 if(!state->method->is_constructor) syntaxerror("super() not allowed outside of a constructor");
7426 (yyval.value).c = code_new();
7427 (yyval.value).c = abc_getlocal_0((yyval.value).c);
7429 (yyval.value).c = code_append((yyval.value).c, (yyvsp[(3) - (4)].value_list).cc);
7431 this is dependent on the control path, check this somewhere else
7432 if(state->method->has_super)
7433 syntaxerror("constructor may call super() only once");
7435 state->method->has_super = 1;
7437 (yyval.value).c = abc_constructsuper((yyval.value).c, (yyvsp[(3) - (4)].value_list).number);
7438 (yyval.value).c = abc_pushundefined((yyval.value).c);
7439 (yyval.value).t = TYPE_ANY;
7449 /* Line 1464 of skeleton.m4 */
7450 #line 3238 "parser.y"
7452 typedcode_t v = node_read((yyvsp[(2) - (2)].node));
7453 (yyval.value).c = v.c;
7454 if((yyval.value).c->opcode == OPCODE_COERCE_A) {
7455 (yyval.value).c = code_cutlast((yyval.value).c);
7457 multiname_t*name = 0;
7458 if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
7459 (yyval.value).c->opcode = OPCODE_DELETEPROPERTY;
7460 } else if((yyval.value).c->opcode == OPCODE_GETSLOT) {
7461 int slot = (int)(ptroff_t)(yyval.value).c->data[0];
7462 multiname_t*name = traits_find_slotid(state->cls->abc->traits,slot)->name;
7463 (yyval.value).c = code_cutlast((yyval.value).c);
7464 (yyval.value).c = abc_deleteproperty2((yyval.value).c, name);
7466 (yyval.value).c = abc_getlocal_0((yyval.value).c);
7467 MULTINAME_LATE(m, v.t?v.t->access:ACCESS_PACKAGE, "");
7468 (yyval.value).c = abc_deleteproperty2((yyval.value).c, &m);
7470 (yyval.value).t = TYPE_BOOLEAN;
7480 /* Line 1464 of skeleton.m4 */
7481 #line 3260 "parser.y"
7483 (yyval.code) = abc_returnvoid(0);
7493 /* Line 1464 of skeleton.m4 */
7494 #line 3263 "parser.y"
7496 (yyval.code) = (yyvsp[(2) - (2)].value).c;
7497 (yyval.code) = abc_returnvalue((yyval.code));
7507 /* Line 1464 of skeleton.m4 */
7508 #line 3270 "parser.y"
7510 (yyval.value) = node_read((yyvsp[(1) - (1)].node));
7520 /* Line 1464 of skeleton.m4 */
7521 #line 3273 "parser.y"
7523 (yyval.value) = node_read((yyvsp[(1) - (1)].node));
7533 /* Line 1464 of skeleton.m4 */
7534 #line 3276 "parser.y"
7536 (yyval.node) = mkmultinode(&node_comma, (yyvsp[(1) - (1)].node));
7546 /* Line 1464 of skeleton.m4 */
7547 #line 3279 "parser.y"
7549 (yyval.node) = multinode_extend((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7559 /* Line 1464 of skeleton.m4 */
7560 #line 3282 "parser.y"
7562 (yyval.code) = node_exec((yyvsp[(1) - (1)].node));
7572 /* Line 1464 of skeleton.m4 */
7573 #line 3285 "parser.y"
7575 (yyval.code) = (yyvsp[(1) - (3)].code);
7576 (yyval.code) = code_append((yyval.code), node_exec((yyvsp[(3) - (3)].node)));
7586 /* Line 1464 of skeleton.m4 */
7587 #line 3290 "parser.y"
7588 {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
7597 /* Line 1464 of skeleton.m4 */
7598 #line 3291 "parser.y"
7599 {(yyval.value_list)=(yyvsp[(1) - (1)].value_list);}
7608 /* Line 1464 of skeleton.m4 */
7609 #line 3293 "parser.y"
7610 {(yyval.code)=abc_pushstring(0,(yyvsp[(1) - (1)].id));}
7619 /* Line 1464 of skeleton.m4 */
7620 #line 3294 "parser.y"
7621 {(yyval.code)=abc_pushstring2(0,&(yyvsp[(1) - (1)].str));}
7630 /* Line 1464 of skeleton.m4 */
7631 #line 3295 "parser.y"
7632 {syntaxerror("dictionary keys must be strings");}
7641 /* Line 1464 of skeleton.m4 */
7642 #line 3296 "parser.y"
7643 {syntaxerror("dictionary keys must be strings");}
7652 /* Line 1464 of skeleton.m4 */
7653 #line 3297 "parser.y"
7654 {syntaxerror("dictionary keys must be strings");}
7663 /* Line 1464 of skeleton.m4 */
7664 #line 3299 "parser.y"
7666 (yyval.value_list).cc = 0;
7667 (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(1) - (3)].code));
7668 (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (3)].value).c);
7669 (yyval.value_list).number = 2;
7679 /* Line 1464 of skeleton.m4 */
7680 #line 3305 "parser.y"
7682 (yyval.value_list).cc = (yyvsp[(1) - (5)].value_list).cc;
7683 (yyval.value_list).number = (yyvsp[(1) - (5)].value_list).number+2;
7684 (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (5)].code));
7685 (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(5) - (5)].value).c);
7695 /* Line 1464 of skeleton.m4 */
7696 #line 3314 "parser.y"
7697 {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
7706 /* Line 1464 of skeleton.m4 */
7707 #line 3315 "parser.y"
7708 {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
7717 /* Line 1464 of skeleton.m4 */
7718 #line 3316 "parser.y"
7719 {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
7728 /* Line 1464 of skeleton.m4 */
7729 #line 3317 "parser.y"
7730 {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
7739 /* Line 1464 of skeleton.m4 */
7740 #line 3318 "parser.y"
7741 {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
7750 /* Line 1464 of skeleton.m4 */
7751 #line 3319 "parser.y"
7752 {(yyval.node) = (yyvsp[(1) - (1)].node);}
7761 /* Line 1464 of skeleton.m4 */
7762 #line 3321 "parser.y"
7764 (yyval.node) = mkconstnode((yyvsp[(1) - (1)].constant));
7774 /* Line 1464 of skeleton.m4 */
7775 #line 3325 "parser.y"
7777 (yyval.node) = (yyvsp[(1) - (1)].node);
7787 /* Line 1464 of skeleton.m4 */
7788 #line 3330 "parser.y"
7792 multiname_t m = {QNAME, &stdns, 0, "RegExp"};
7793 if(!(yyvsp[(1) - (1)].regexp).options) {
7794 v.c = abc_getlex2(v.c, &m);
7795 v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).pattern);
7796 v.c = abc_construct(v.c, 1);
7798 v.c = abc_getlex2(v.c, &m);
7799 v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).pattern);
7800 v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).options);
7801 v.c = abc_construct(v.c, 2);
7804 (yyval.node) = mkcodenode(v);
7814 /* Line 1464 of skeleton.m4 */
7815 #line 3348 "parser.y"
7818 state->method->need_arguments = 1;
7821 v.c = abc_getlocal(0, state->method->need_arguments);
7823 (yyval.node) = mkcodenode(v);
7833 /* Line 1464 of skeleton.m4 */
7834 #line 3359 "parser.y"
7838 v.c = code_append(v.c, (yyvsp[(2) - (3)].value_list).cc);
7839 v.c = abc_newarray(v.c, (yyvsp[(2) - (3)].value_list).number);
7840 v.t = registry_getarrayclass();
7841 (yyval.node) = mkcodenode(v);
7851 /* Line 1464 of skeleton.m4 */
7852 #line 3369 "parser.y"
7856 v.c = code_append(v.c, (yyvsp[(2) - (3)].value_list).cc);
7857 v.c = abc_newobject(v.c, (yyvsp[(2) - (3)].value_list).number/2);
7858 v.t = registry_getobjectclass();
7859 (yyval.node) = mkcodenode(v);
7869 /* Line 1464 of skeleton.m4 */
7870 #line 3378 "parser.y"
7871 {(yyval.node) = mknode2(&node_lt,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7880 /* Line 1464 of skeleton.m4 */
7881 #line 3379 "parser.y"
7882 {(yyval.node) = mknode2(&node_gt,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7891 /* Line 1464 of skeleton.m4 */
7892 #line 3380 "parser.y"
7893 {(yyval.node) = mknode2(&node_le,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7902 /* Line 1464 of skeleton.m4 */
7903 #line 3381 "parser.y"
7904 {(yyval.node) = mknode2(&node_ge,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7913 /* Line 1464 of skeleton.m4 */
7914 #line 3382 "parser.y"
7915 {(yyval.node) = mknode2(&node_eqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7924 /* Line 1464 of skeleton.m4 */
7925 #line 3383 "parser.y"
7926 {(yyval.node) = mknode2(&node_eqeqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7935 /* Line 1464 of skeleton.m4 */
7936 #line 3384 "parser.y"
7937 {(yyval.node) = mknode2(&node_noteqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7946 /* Line 1464 of skeleton.m4 */
7947 #line 3385 "parser.y"
7948 {(yyval.node) = mknode2(&node_noteq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7957 /* Line 1464 of skeleton.m4 */
7958 #line 3386 "parser.y"
7959 {(yyval.node) = mknode2(&node_oror,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7968 /* Line 1464 of skeleton.m4 */
7969 #line 3387 "parser.y"
7970 {(yyval.node) = mknode2(&node_andand,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
7979 /* Line 1464 of skeleton.m4 */
7980 #line 3388 "parser.y"
7981 {(yyval.node) = mknode1(&node_not, (yyvsp[(2) - (2)].node));}
7990 /* Line 1464 of skeleton.m4 */
7991 #line 3389 "parser.y"
7992 {(yyval.node) = mknode1(&node_bitnot, (yyvsp[(2) - (2)].node));}
8001 /* Line 1464 of skeleton.m4 */
8002 #line 3390 "parser.y"
8003 {(yyval.node) = mknode2(&node_bitand, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8012 /* Line 1464 of skeleton.m4 */
8013 #line 3391 "parser.y"
8014 {(yyval.node) = mknode2(&node_bitxor, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8023 /* Line 1464 of skeleton.m4 */
8024 #line 3392 "parser.y"
8025 {(yyval.node) = mknode2(&node_bitor, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8034 /* Line 1464 of skeleton.m4 */
8035 #line 3393 "parser.y"
8036 {(yyval.node) = mknode2(&node_shr, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8045 /* Line 1464 of skeleton.m4 */
8046 #line 3394 "parser.y"
8047 {(yyval.node) = mknode2(&node_ushr, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8056 /* Line 1464 of skeleton.m4 */
8057 #line 3395 "parser.y"
8058 {(yyval.node) = mknode2(&node_shl, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8067 /* Line 1464 of skeleton.m4 */
8068 #line 3396 "parser.y"
8069 {(yyval.node) = mknode2(&node_div, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8078 /* Line 1464 of skeleton.m4 */
8079 #line 3397 "parser.y"
8080 {(yyval.node) = mknode2(&node_mod, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8089 /* Line 1464 of skeleton.m4 */
8090 #line 3398 "parser.y"
8091 {(yyval.node) = mknode2(&node_plus, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8100 /* Line 1464 of skeleton.m4 */
8101 #line 3399 "parser.y"
8102 {(yyval.node) = mknode2(&node_minus, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8111 /* Line 1464 of skeleton.m4 */
8112 #line 3400 "parser.y"
8113 {(yyval.node) = mknode2(&node_multiply, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8122 /* Line 1464 of skeleton.m4 */
8123 #line 3401 "parser.y"
8124 {(yyval.node) = mknode2(&node_in, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8133 /* Line 1464 of skeleton.m4 */
8134 #line 3402 "parser.y"
8135 {(yyval.node) = mknode2(&node_as, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8144 /* Line 1464 of skeleton.m4 */
8145 #line 3403 "parser.y"
8146 {(yyval.node) = mknode2(&node_instanceof, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8155 /* Line 1464 of skeleton.m4 */
8156 #line 3404 "parser.y"
8157 {(yyval.node) = mknode2(&node_is, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8166 /* Line 1464 of skeleton.m4 */
8167 #line 3405 "parser.y"
8168 {(yyval.node) = mknode1(&node_typeof, (yyvsp[(2) - (2)].node));}
8177 /* Line 1464 of skeleton.m4 */
8178 #line 3406 "parser.y"
8179 {(yyval.node) = mknode1(&node_void, (yyvsp[(2) - (2)].node));}
8188 /* Line 1464 of skeleton.m4 */
8189 #line 3407 "parser.y"
8190 { (yyval.node) = mkconstnode(constant_new_undefined());}
8199 /* Line 1464 of skeleton.m4 */
8200 #line 3408 "parser.y"
8201 { (yyval.node)=(yyvsp[(2) - (3)].node);}
8210 /* Line 1464 of skeleton.m4 */
8211 #line 3409 "parser.y"
8212 {(yyval.node) = mknode1(&node_neg, (yyvsp[(2) - (2)].node));}
8221 /* Line 1464 of skeleton.m4 */
8222 #line 3410 "parser.y"
8223 {(yyval.node) = mknode2(&node_arraylookup, (yyvsp[(1) - (4)].node),(yyvsp[(3) - (4)].node));}
8232 /* Line 1464 of skeleton.m4 */
8233 #line 3411 "parser.y"
8234 {(yyval.node) = mknode2(&node_muleq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8243 /* Line 1464 of skeleton.m4 */
8244 #line 3412 "parser.y"
8245 {(yyval.node) = mknode2(&node_modeq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8254 /* Line 1464 of skeleton.m4 */
8255 #line 3413 "parser.y"
8256 {(yyval.node) = mknode2(&node_shleq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8265 /* Line 1464 of skeleton.m4 */
8266 #line 3414 "parser.y"
8267 {(yyval.node) = mknode2(&node_shreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8276 /* Line 1464 of skeleton.m4 */
8277 #line 3415 "parser.y"
8278 {(yyval.node) = mknode2(&node_ushreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8287 /* Line 1464 of skeleton.m4 */
8288 #line 3416 "parser.y"
8289 { (yyval.node) = mknode2(&node_diveq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8298 /* Line 1464 of skeleton.m4 */
8299 #line 3417 "parser.y"
8300 { (yyval.node) = mknode2(&node_bitoreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8309 /* Line 1464 of skeleton.m4 */
8310 #line 3418 "parser.y"
8311 { (yyval.node) = mknode2(&node_bitxoreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8320 /* Line 1464 of skeleton.m4 */
8321 #line 3419 "parser.y"
8322 { (yyval.node) = mknode2(&node_bitandeq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8331 /* Line 1464 of skeleton.m4 */
8332 #line 3420 "parser.y"
8333 { (yyval.node) = mknode2(&node_pluseq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8342 /* Line 1464 of skeleton.m4 */
8343 #line 3421 "parser.y"
8344 { (yyval.node) = mknode2(&node_minuseq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8353 /* Line 1464 of skeleton.m4 */
8354 #line 3422 "parser.y"
8355 { (yyval.node) = mknode2(&node_assign, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
8364 /* Line 1464 of skeleton.m4 */
8365 #line 3423 "parser.y"
8366 { (yyval.node) = mknode3(&node_tenary, (yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));}
8375 /* Line 1464 of skeleton.m4 */
8376 #line 3425 "parser.y"
8377 { (yyval.node) = mknode1(&node_rplusplus, (yyvsp[(1) - (2)].node));}
8386 /* Line 1464 of skeleton.m4 */
8387 #line 3426 "parser.y"
8388 { (yyval.node) = mknode1(&node_rminusminus, (yyvsp[(1) - (2)].node));}
8397 /* Line 1464 of skeleton.m4 */
8398 #line 3427 "parser.y"
8399 {(yyval.node) = mknode1(&node_lplusplus, (yyvsp[(2) - (2)].node)); }
8408 /* Line 1464 of skeleton.m4 */
8409 #line 3428 "parser.y"
8410 {(yyval.node) = mknode1(&node_lminusminus, (yyvsp[(2) - (2)].node)); }
8419 /* Line 1464 of skeleton.m4 */
8420 #line 3431 "parser.y"
8421 { if(!state->cls->info)
8422 syntaxerror("super keyword not allowed outside a class");
8423 classinfo_t*t = state->cls->info->superclass;
8424 if(!t) t = TYPE_OBJECT;
8425 memberinfo_t*f = findmember_nsset(t, (yyvsp[(3) - (3)].id), 1, 0);
8426 MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
8429 v.c = abc_getlocal_0(v.c);
8430 v.c = abc_getsuper2(v.c, &m);
8431 v.t = slotinfo_gettype((slotinfo_t*)f);
8432 (yyval.node) = mkcodenode(v);
8442 /* Line 1464 of skeleton.m4 */
8443 #line 3445 "parser.y"
8446 multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(2) - (2)].id)};
8447 v.c = abc_getlex2(0, &m);
8449 (yyval.node) = mkcodenode(v);
8459 /* Line 1464 of skeleton.m4 */
8460 #line 3453 "parser.y"
8461 {PASS12 new_state();state->xmlfilter=1;}
8470 /* Line 1464 of skeleton.m4 */
8471 #line 3453 "parser.y"
8475 typedcode_t v = node_read((yyvsp[(1) - (6)].node));
8476 typedcode_t w = node_read((yyvsp[(5) - (6)].node));
8478 int index = alloc_local();
8479 int result = alloc_local();
8480 int tmp = alloc_local();
8481 int xml = alloc_local();
8483 c = code_append(c, v.c);
8484 c = abc_checkfilter(c);
8485 c = abc_coerce_a(c); //hasnext2 converts to *
8486 c = abc_setlocal(c, xml);
8487 multiname_t m = {QNAME, &stdns, 0, "XMLList"};
8488 c = abc_getlex2(c, &m);
8489 c = abc_construct(c, 0);
8490 c = abc_setlocal(c, result);
8491 c = abc_pushbyte(c, 0);
8492 c = abc_setlocal(c, index);
8493 code_t*jmp = c = abc_jump(c, 0);
8494 code_t*loop = c = abc_label(c);
8495 c = abc_getlocal(c, xml);
8496 c = abc_getlocal(c, index);
8497 c = abc_nextvalue(c);
8499 c = abc_setlocal(c, tmp);
8500 c = abc_pushwith(c);
8501 c = code_append(c, w.c);
8502 c = abc_popscope(c);
8503 code_t*b = c = abc_iffalse(c, 0);
8504 c = abc_getlocal(c, result);
8505 c = abc_getlocal(c, index);
8506 c = abc_getlocal(c, tmp);
8507 multiname_t m2 = {MULTINAMEL, 0, &nopackage_namespace_set, 0};
8508 c = abc_setproperty2(c, &m2);
8509 c = b->branch = jmp->branch = abc_nop(c);
8510 c = abc_kill(c, tmp);
8511 c = abc_hasnext2(c, xml, index);
8512 c = abc_iftrue(c, loop);
8513 c = abc_getlocal(c, result);
8514 c = abc_kill(c, xml);
8515 c = abc_kill(c, result);
8516 c = abc_kill(c, index);
8518 c = var_block(c, state->vars);
8523 (yyval.node) = mkcodenode(r);
8533 /* Line 1464 of skeleton.m4 */
8534 #line 3507 "parser.y"
8535 {(yyval.id)=(yyvsp[(1) - (1)].id);}
8544 /* Line 1464 of skeleton.m4 */
8545 #line 3508 "parser.y"
8555 /* Line 1464 of skeleton.m4 */
8556 #line 3509 "parser.y"
8557 {(yyval.id)=(char*)(yyvsp[(1) - (1)].id);}
8566 /* Line 1464 of skeleton.m4 */
8567 #line 3511 "parser.y"
8577 /* Line 1464 of skeleton.m4 */
8578 #line 3551 "parser.y"
8580 (yyval.node) = get_descendants((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].id), 0, 0);
8590 /* Line 1464 of skeleton.m4 */
8591 #line 3554 "parser.y"
8593 typedcode_t v = node_read((yyvsp[(1) - (3)].node));
8594 multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
8595 v.c = abc_getdescendants2(v.c, &m);
8597 (yyval.node) = mkcodenode(v);
8607 /* Line 1464 of skeleton.m4 */
8608 #line 3561 "parser.y"
8610 (yyval.node) = get_descendants((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].id), 1, 0);
8620 /* Line 1464 of skeleton.m4 */
8621 #line 3564 "parser.y"
8623 typedcode_t v = node_read((yyvsp[(1) - (5)].node));
8624 typedcode_t w = node_read((yyvsp[(4) - (5)].node));
8625 multiname_t m = {MULTINAMEL, 0, &nopackage_namespace_set, 0};
8626 v.c = code_append(v.c, w.c);
8627 v.c = converttype(w.c, w.t, TYPE_STRING);
8628 v.c = abc_getproperty2(v.c, &m);
8630 (yyval.node) = mkcodenode(v);
8640 /* Line 1464 of skeleton.m4 */
8641 #line 3575 "parser.y"
8643 typedcode_t v = node_read((yyvsp[(1) - (4)].node));
8644 multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(4) - (4)].id)};
8645 v.c = abc_getproperty2(v.c, &m);
8647 (yyval.node) = mkcodenode(v);
8657 /* Line 1464 of skeleton.m4 */
8658 #line 3583 "parser.y"
8660 (yyval.node) = get_descendants((yyvsp[(1) - (6)].node), (yyvsp[(4) - (6)].id), (yyvsp[(6) - (6)].id), 0, 1);
8670 /* Line 1464 of skeleton.m4 */
8671 #line 3587 "parser.y"
8673 typedcode_t v = node_read((yyvsp[(1) - (4)].node));
8674 multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(4) - (4)].id)};
8675 v.c = abc_getdescendants2(v.c, &m);
8677 (yyval.node) = mkcodenode(v);
8687 /* Line 1464 of skeleton.m4 */
8688 #line 3594 "parser.y"
8690 (yyval.node) = get_descendants((yyvsp[(1) - (6)].node), (yyvsp[(4) - (6)].id), (yyvsp[(6) - (6)].id), 1, 1);
8700 /* Line 1464 of skeleton.m4 */
8701 #line 3598 "parser.y"
8703 typedcode_t v = node_read((yyvsp[(1) - (6)].node));
8704 typedcode_t w = node_read((yyvsp[(5) - (6)].node));
8705 multiname_t m = {MULTINAMELA, 0, &nopackage_namespace_set, 0};
8706 v.c = code_append(v.c, w.c);
8707 v.c = converttype(w.c, w.t, TYPE_STRING);
8708 v.c = abc_getproperty2(v.c, &m);
8710 (yyval.node) = mkcodenode(v);
8720 /* Line 1464 of skeleton.m4 */
8721 #line 3608 "parser.y"
8723 typedcode_t v = node_read((yyvsp[(1) - (6)].node));
8724 typedcode_t w = node_read((yyvsp[(5) - (6)].node));
8725 multiname_t m = {MULTINAMELA, 0, &nopackage_namespace_set, 0};
8726 v.c = code_append(v.c, w.c);
8727 v.c = converttype(w.c, w.t, TYPE_STRING);
8728 v.c = abc_getdescendants2(v.c, &m);
8730 (yyval.node) = mkcodenode(v);
8740 /* Line 1464 of skeleton.m4 */
8741 #line 3619 "parser.y"
8743 typedcode_t v1 = node_read((yyvsp[(1) - (3)].node));
8744 (yyval.value).c = v1.c;
8745 classinfo_t*t = v1.t;
8747 if(TYPE_IS_CLASS(t) && t->data) {
8751 if(TYPE_IS_XML(t) && !findmember_nsset(t, (yyvsp[(3) - (3)].id), 1, is_static)) {
8752 multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
8753 (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
8754 (yyval.value).c = abc_coerce_a((yyval.value).c);
8755 (yyval.value).t = TYPE_XMLLIST;
8757 if(t->subtype==INFOTYPE_UNRESOLVED) {
8758 syntaxerror("syntaxerror: trying to resolve property '%s' on incomplete object '%s'", (yyvsp[(3) - (3)].id), t->name);
8760 memberinfo_t*f = findmember_nsset(t, (yyvsp[(3) - (3)].id), 1, is_static);
8762 if(f && !is_static != !(f->flags&FLAG_STATIC))
8764 if(f && f->slot && !noslot) {
8765 (yyval.value).c = abc_getslot((yyval.value).c, f->slot);
8768 if(!TYPE_IS_XMLLIST(t)) {
8769 as3_softwarning("Access of undefined property '%s' in %s", (yyvsp[(3) - (3)].id), t->name);
8772 MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
8773 (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
8775 /* determine type */
8776 (yyval.value).t = slotinfo_gettype((slotinfo_t*)f);
8777 if(!(yyval.value).t)
8778 (yyval.value).c = abc_coerce_a((yyval.value).c);
8780 } else if(v1.c && v1.c->opcode == OPCODE___PUSHPACKAGE__) {
8781 string_t*package = v1.c->data[0];
8782 char*package2 = concat3(package->str, ".", (yyvsp[(3) - (3)].id));
8784 slotinfo_t*a = registry_find(package->str, (yyvsp[(3) - (3)].id));
8786 (yyval.value) = push_class(a);
8787 } else if(dict_contains(state->import_toplevel_packages, package2) ||
8788 registry_ispackage(package2)) {
8789 (yyval.value).c = v1.c;
8790 (yyval.value).c->data[0] = string_new4(package2);
8791 (yyval.value).t = 0;
8793 syntaxerror("couldn't resolve %s", package2);
8796 /* when resolving a property on an unknown type, we do know the
8797 name of the property (and don't seem to need the package), but
8798 we need to make avm2 try out all access modes */
8799 as3_softwarning("Resolving %s on unknown type", (yyvsp[(3) - (3)].id));
8800 multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
8801 (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
8802 (yyval.value).c = abc_coerce_a((yyval.value).c);
8803 (yyval.value).t = TYPE_ANY;
8814 /* Line 1464 of skeleton.m4 */
8815 #line 3806 "parser.y"
8818 (yyval.node) = resolve_identifier((yyvsp[(1) - (1)].id));
8828 /* Line 1464 of skeleton.m4 */
8829 #line 3810 "parser.y"
8832 /* Queue unresolved identifiers for checking against the parent
8833 function's variables.
8834 We consider everything which is not a local variable "unresolved".
8835 This encompasses class names, members of the surrounding class
8836 etc. which is *correct* because local variables of the parent function
8840 if(!find_variable(state, (yyvsp[(1) - (1)].id))) {
8841 unknown_variable((yyvsp[(1) - (1)].id));
8842 /* let the compiler know that it might want to check the current directory/package
8843 for this identifier- maybe there's a file $1.as defining $1. */
8844 as3_schedule_class_noerror(state->package, (yyvsp[(1) - (1)].id));
8850 (yyval.node) = resolve_identifier((yyvsp[(1) - (1)].id));
8860 /* Line 1464 of skeleton.m4 */
8861 #line 3844 "parser.y"
8864 NEW(namespace_decl_t,n);
8865 n->name = (yyvsp[(2) - (2)].id);
8866 n->url = (yyvsp[(2) - (2)].id);
8867 (yyval.namespace_decl)=n;
8877 /* Line 1464 of skeleton.m4 */
8878 #line 3851 "parser.y"
8881 NEW(namespace_decl_t,n);
8882 n->name = (yyvsp[(2) - (4)].id);
8883 n->url = (yyvsp[(4) - (4)].id);
8884 (yyval.namespace_decl)=n;
8894 /* Line 1464 of skeleton.m4 */
8895 #line 3858 "parser.y"
8898 NEW(namespace_decl_t,n);
8899 n->name = (yyvsp[(2) - (4)].id);
8900 n->url = (yyvsp[(4) - (4)].str).str;
8901 (yyval.namespace_decl)=n;
8911 /* Line 1464 of skeleton.m4 */
8912 #line 3865 "parser.y"
8915 trie_put(active_namespaces, (unsigned char*)(yyvsp[(2) - (2)].namespace_decl)->name, (void*)(yyvsp[(2) - (2)].namespace_decl)->url);
8917 namespace_t access = modifiers2access(&(yyvsp[(1) - (2)].flags));
8918 varinfo_t* var = varinfo_register_global(access.access, state->package, (yyvsp[(2) - (2)].namespace_decl)->name);
8919 var->type = TYPE_NAMESPACE;
8921 ns.access = ACCESS_NAMESPACE;
8922 ns.name = (yyvsp[(2) - (2)].namespace_decl)->url;
8923 var->value = constant_new_namespace(&ns);
8926 MULTINAME(m, TYPE_NAMESPACE);
8927 trait_t*t = add_abc_slot(&(yyvsp[(1) - (2)].flags), (yyvsp[(2) - (2)].namespace_decl)->name, 0, 0);
8928 t->value = var->value;
8929 t->type_name = multiname_clone(&m);
8942 /* Line 1464 of skeleton.m4 */
8943 #line 3888 "parser.y"
8946 (yyval.code) = code_append((yyval.code), node_read((yyvsp[(4) - (4)].node)).c);
8947 (yyval.code) = abc_dxnslate((yyval.code));
8957 /* Line 1464 of skeleton.m4 */
8958 #line 3894 "parser.y"
8961 const char*url = (yyvsp[(3) - (3)].classinfo)->name;
8963 varinfo_t*s = (varinfo_t*)(yyvsp[(3) - (3)].classinfo);
8964 if(s->kind == INFOTYPE_UNRESOLVED) {
8965 s = (varinfo_t*)registry_resolve((slotinfo_t*)s);
8967 syntaxerror("Couldn't resolve namespace %s", (yyvsp[(3) - (3)].classinfo)->name);
8970 if(!s || s->kind != INFOTYPE_VAR)
8971 syntaxerror("%s.%s is not a public namespace (%d)", (yyvsp[(3) - (3)].classinfo)->package, (yyvsp[(3) - (3)].classinfo)->name, s?s->kind:-1);
8972 if(!s->value || !NS_TYPE(s->value->type))
8973 syntaxerror("%s.%s is not a namespace", (yyvsp[(3) - (3)].classinfo)->package, (yyvsp[(3) - (3)].classinfo)->name);
8974 url = s->value->ns->name;
8976 trie_put(active_namespaces, (unsigned char*)(yyvsp[(3) - (3)].classinfo)->name, (void*)url);
8977 add_active_url(url);
8986 /* Line 1464 of skeleton.m4 */
8987 #line 8988 "parser.tab.c"
8990 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
8994 YY_STACK_PRINT (yyss, yyssp);
8998 /* Now `shift' the result of the reduction. Determine what state
8999 that goes to, based on the state we popped back to and the rule
9000 number reduced by. */
9004 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
9005 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
9006 yystate = yytable[yystate];
9008 yystate = yydefgoto[yyn - YYNTOKENS];
9013 /*------------------------------------.
9014 | yyerrlab -- here on detecting error |
9015 `------------------------------------*/
9017 /* If not already recovering from an error, report this error. */
9021 #if ! YYERROR_VERBOSE
9022 yyerror (YY_("syntax error"));
9025 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
9026 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
9028 YYSIZE_T yyalloc = 2 * yysize;
9029 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
9030 yyalloc = YYSTACK_ALLOC_MAXIMUM;
9031 if (yymsg != yymsgbuf)
9032 YYSTACK_FREE (yymsg);
9033 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
9035 yymsg_alloc = yyalloc;
9039 yymsg_alloc = sizeof yymsgbuf;
9043 if (0 < yysize && yysize <= yymsg_alloc)
9045 (void) yysyntax_error (yymsg, yystate, yychar);
9050 yyerror (YY_("syntax error"));
9052 goto yyexhaustedlab;
9060 if (yyerrstatus == 3)
9062 /* If just tried and failed to reuse lookahead token after an
9063 error, discard it. */
9065 if (yychar <= YYEOF)
9067 /* Return failure if at end of input. */
9068 if (yychar == YYEOF)
9073 yydestruct ("Error: discarding",
9079 /* Else will try to reuse lookahead token after shifting the error
9084 /*---------------------------------------------------.
9085 | yyerrorlab -- error raised explicitly by YYERROR. |
9086 `---------------------------------------------------*/
9089 /* Pacify compilers like GCC when the user code never invokes
9090 YYERROR and the label yyerrorlab therefore never appears in user
9092 if (/*CONSTCOND*/ 0)
9095 /* Do not reclaim the symbols of the rule which action triggered
9099 YY_STACK_PRINT (yyss, yyssp);
9104 /*-------------------------------------------------------------.
9105 | yyerrlab1 -- common code for both syntax error and YYERROR. |
9106 `-------------------------------------------------------------*/
9108 yyerrstatus = 3; /* Each real token shifted decrements this. */
9112 yyn = yypact[yystate];
9113 if (yyn != YYPACT_NINF)
9116 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
9124 /* Pop the current state because it cannot handle the error token. */
9129 yydestruct ("Error: popping",
9130 yystos[yystate], yyvsp);
9133 YY_STACK_PRINT (yyss, yyssp);
9139 /* Shift the error token. */
9140 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
9146 /*-------------------------------------.
9147 | yyacceptlab -- YYACCEPT comes here. |
9148 `-------------------------------------*/
9153 /*-----------------------------------.
9154 | yyabortlab -- YYABORT comes here. |
9155 `-----------------------------------*/
9160 #if !defined(yyoverflow) || YYERROR_VERBOSE
9161 /*-------------------------------------------------.
9162 | yyexhaustedlab -- memory exhaustion comes here. |
9163 `-------------------------------------------------*/
9165 yyerror (YY_("memory exhausted"));
9171 if (yychar != YYEMPTY)
9172 yydestruct ("Cleanup: discarding lookahead",
9174 /* Do not reclaim the symbols of the rule which action triggered
9175 this YYABORT or YYACCEPT. */
9177 YY_STACK_PRINT (yyss, yyssp);
9178 while (yyssp != yyss)
9180 yydestruct ("Cleanup: popping",
9181 yystos[*yyssp], yyvsp);
9186 YYSTACK_FREE (yyss);
9189 if (yymsg != yymsgbuf)
9190 YYSTACK_FREE (yymsg);
9192 /* Make sure YYID is used. */
9193 return YYID (yyresult);