X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fas3%2Fparser.tab.c;h=b5ee3753bfd2d2c8e622ad39f2087e735a876a97;hb=1c806da0dba560e9da67b85a3645cd1537742ead;hp=483ebcd2bff81429e467609e3ec383ef29273373;hpb=618a86d162d32d7b64cdf872d3033a56d548b526;p=swftools.git
diff --git a/lib/as3/parser.tab.c b/lib/as3/parser.tab.c
index 483ebcd..b5ee375 100644
--- a/lib/as3/parser.tab.c
+++ b/lib/as3/parser.tab.c
@@ -1,21 +1,21 @@
-/* A Bison parser, made by GNU Bison 2.4. */
+/* A Bison parser, made by GNU Bison 2.4.277-62c99-dirty. */
/* Skeleton implementation for Bison's Yacc-like parsers in C
-
- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
- Free Software Foundation, Inc.
-
+
+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free
+ Software Foundation, Inc.
+
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program. If not, see . */
@@ -28,7 +28,7 @@
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
-
+
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
@@ -46,7 +46,7 @@
#define YYBISON 1
/* Bison version. */
-#define YYBISON_VERSION "2.4"
+#define YYBISON_VERSION "2.4.277-62c99-dirty"
/* Skeleton name. */
#define YYSKELETON_NAME "./skeleton.m4"
@@ -74,7 +74,6 @@
/* Copy the first part of user declarations. */
-
/* Line 198 of skeleton.m4 */
#line 23 "parser.y"
@@ -84,21 +83,24 @@
#include "abc.h"
#include "pool.h"
#include "files.h"
+#include "common.h"
#include "tokenizer.h"
#include "registry.h"
#include "code.h"
#include "opcodes.h"
+#include "compiler.h"
+#include "expr.h"
+#include "initcode.h"
extern int a3_lex();
-
/* Line 198 of skeleton.m4 */
-#line 98 "parser.tab.c"
+#line 100 "parser.tab.c"
/* Enabling traces. */
#ifndef YYDEBUG
-# define YYDEBUG 0
+# define YYDEBUG b4_debug_flag
#endif
/* Enabling verbose error messages. */
@@ -106,7 +108,7 @@ extern int a3_lex();
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
-# define YYERROR_VERBOSE 1
+# define YYERROR_VERBOSE b4_error_verbose_flag
#endif
/* Enabling the token table. */
@@ -122,22 +124,22 @@ extern int a3_lex();
know about them. */
enum yytokentype {
T_IDENTIFIER = 258,
- T_STRING = 259,
- T_REGEXP = 260,
- T_EMPTY = 261,
- T_INT = 262,
- T_UINT = 263,
- T_BYTE = 264,
- T_SHORT = 265,
- T_FLOAT = 266,
- T_FOR = 267,
- T_WHILE = 268,
- T_DO = 269,
- T_SWITCH = 270,
- KW_IMPLEMENTS = 271,
- KW_NAMESPACE = 272,
- KW_PACKAGE = 273,
- KW_PROTECTED = 274,
+ T_NAMESPACE = 259,
+ T_STRING = 260,
+ T_REGEXP = 261,
+ T_EMPTY = 262,
+ T_INT = 263,
+ T_UINT = 264,
+ T_FLOAT = 265,
+ T_FOR = 266,
+ T_WHILE = 267,
+ T_DO = 268,
+ T_SWITCH = 269,
+ KW_IMPLEMENTS = 270,
+ KW_NAMESPACE = 271,
+ KW_PACKAGE = 272,
+ KW_PROTECTED = 273,
+ KW_ARGUMENTS = 274,
KW_PUBLIC = 275,
KW_PRIVATE = 276,
KW_USE = 277,
@@ -147,102 +149,107 @@ extern int a3_lex();
KW_FUNCTION = 281,
KW_FINALLY = 282,
KW_UNDEFINED = 283,
- KW_CONTINUE = 284,
- KW_CLASS = 285,
- KW_CONST = 286,
- KW_CATCH = 287,
- KW_CASE = 288,
- KW_SET = 289,
- KW_VOID = 290,
- KW_THROW = 291,
- KW_STATIC = 292,
- KW_WITH = 293,
- KW_INSTANCEOF = 294,
- KW_IMPORT = 295,
- KW_RETURN = 296,
- KW_TYPEOF = 297,
- KW_INTERFACE = 298,
- KW_NULL = 299,
- KW_VAR = 300,
- KW_DYNAMIC = 301,
- KW_OVERRIDE = 302,
- KW_FINAL = 303,
- KW_EACH = 304,
- KW_GET = 305,
- KW_TRY = 306,
- KW_SUPER = 307,
- KW_EXTENDS = 308,
- KW_FALSE = 309,
- KW_TRUE = 310,
- KW_BOOLEAN = 311,
- KW_UINT = 312,
- KW_INT = 313,
- KW_NUMBER = 314,
- KW_STRING = 315,
- KW_DEFAULT = 316,
- KW_DELETE = 317,
- KW_IF = 318,
- KW_ELSE = 319,
- KW_BREAK = 320,
- KW_IS = 321,
- KW_IN = 322,
- KW_AS = 323,
- T_EQEQ = 324,
- T_EQEQEQ = 325,
- T_NE = 326,
- T_NEE = 327,
- T_LE = 328,
- T_GE = 329,
- T_ORBY = 330,
- T_DIVBY = 331,
- T_MODBY = 332,
- T_MULBY = 333,
- T_PLUSBY = 334,
- T_MINUSBY = 335,
- T_SHRBY = 336,
- T_SHLBY = 337,
- T_USHRBY = 338,
- T_OROR = 339,
- T_ANDAND = 340,
- T_COLONCOLON = 341,
- T_MINUSMINUS = 342,
- T_PLUSPLUS = 343,
- T_DOTDOT = 344,
- T_DOTDOTDOT = 345,
- T_SHL = 346,
- T_USHR = 347,
- T_SHR = 348,
- prec_none = 349,
- below_semicolon = 350,
- below_assignment = 351,
- below_minus = 354,
- minusminus_prefix = 355,
- plusplus_prefix = 356,
- below_curly = 357,
- new2 = 358,
- above_identifier = 359,
- below_else = 360,
- above_function = 361
+ KW_NAN = 284,
+ KW_CONTINUE = 285,
+ KW_CLASS = 286,
+ KW_CONST = 287,
+ KW_CATCH = 288,
+ KW_CASE = 289,
+ KW_SET = 290,
+ KW_VOID = 291,
+ KW_THROW = 292,
+ KW_STATIC = 293,
+ KW_WITH = 294,
+ KW_INSTANCEOF = 295,
+ KW_IMPORT = 296,
+ KW_RETURN = 297,
+ KW_TYPEOF = 298,
+ KW_INTERFACE = 299,
+ KW_NULL = 300,
+ KW_VAR = 301,
+ KW_DYNAMIC = 302,
+ KW_OVERRIDE = 303,
+ KW_FINAL = 304,
+ KW_EACH = 305,
+ KW_GET = 306,
+ KW_TRY = 307,
+ KW_SUPER = 308,
+ KW_EXTENDS = 309,
+ KW_FALSE = 310,
+ KW_TRUE = 311,
+ KW_BOOLEAN = 312,
+ KW_UINT = 313,
+ KW_INT = 314,
+ KW_NUMBER = 315,
+ KW_STRING = 316,
+ KW_DEFAULT = 317,
+ KW_DEFAULT_XML = 318,
+ KW_DELETE = 319,
+ KW_IF = 320,
+ KW_ELSE = 321,
+ KW_BREAK = 322,
+ KW_IS = 323,
+ KW_IN = 324,
+ KW_AS = 325,
+ T_DICTSTART = 326,
+ T_EQEQ = 327,
+ T_EQEQEQ = 328,
+ T_NE = 329,
+ T_NEE = 330,
+ T_LE = 331,
+ T_GE = 332,
+ T_ORBY = 333,
+ T_DIVBY = 334,
+ T_MODBY = 335,
+ T_MULBY = 336,
+ T_ANDBY = 337,
+ T_PLUSBY = 338,
+ T_MINUSBY = 339,
+ T_XORBY = 340,
+ T_SHRBY = 341,
+ T_SHLBY = 342,
+ T_USHRBY = 343,
+ T_OROR = 344,
+ T_ANDAND = 345,
+ T_COLONCOLON = 346,
+ T_MINUSMINUS = 347,
+ T_PLUSPLUS = 348,
+ T_DOTDOT = 349,
+ T_DOTDOTDOT = 350,
+ T_SHL = 351,
+ T_USHR = 352,
+ T_SHR = 353,
+ prec_none = 354,
+ below_semicolon = 355,
+ below_assignment = 356,
+ below_lt = 357,
+ below_minus = 358,
+ minusminus_prefix = 359,
+ plusplus_prefix = 360,
+ below_curly = 361,
+ new2 = 362,
+ above_identifier = 363,
+ below_else = 364,
+ above_function = 365
};
#endif
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union
-/* Line 223 of skeleton.m4 */
-#line 43 "parser.y"
+typedef union /* Line 223 of skeleton.m4 */
+#line 47 "parser.y"
tokenunion
{
-
/* Line 223 of skeleton.m4 */
-#line 43 "parser.y"
+#line 47 "parser.y"
enum yytokentype token;
- int flags;
classinfo_t*classinfo;
classinfo_list_t*classinfo_list;
+ slotinfo_t*slotinfo;
+ slotinfo_list_t*slotinfo_list;
int number_int;
unsigned int number_uint;
@@ -259,15 +266,17 @@ tokenunion
for_start_t for_start;
abc_exception_t *exception;
regexp_t regexp;
+ modifiers_t flags;
+ namespace_decl_t* namespace_decl;
+ node_t*node;
struct {
abc_exception_list_t *l;
code_t*finally;
} catch_list;
-
/* Line 223 of skeleton.m4 */
-#line 271 "parser.tab.c"
+#line 280 "parser.tab.c"
} YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -276,9 +285,8 @@ tokenunion
/* Copy the second part of user declarations. */
-
/* Line 273 of skeleton.m4 */
-#line 256 "parser.y"
+#line 276 "parser.y"
static int a3_error(char*s)
@@ -287,6 +295,13 @@ static int a3_error(char*s)
return 0; //make gcc happy
}
+static void parsererror(const char*file, int line, const char*f)
+{
+ syntaxerror("internal error in %s, %s:%d", f, file, line);
+}
+
+#define parserassert(b) {if(!(b)) parsererror(__FILE__, __LINE__,__func__);}
+
static char* concat2(const char* t1, const char* t2)
{
@@ -314,37 +329,66 @@ static char* concat3(const char* t1, const char* t2, const char* t3)
typedef struct _import {
char*package;
} import_t;
-
DECLARE_LIST(import);
+DECLARE(methodstate);
+DECLARE_LIST(methodstate);
+
typedef struct _classstate {
/* class data */
classinfo_t*info;
abc_class_t*abc;
- code_t*init;
- code_t*static_init;
+
+ methodstate_t*init;
+ methodstate_t*static_init;
+ //code_t*init;
+ //code_t*static_init;
+ parsedclass_t*dependencies;
+
char has_constructor;
} classstate_t;
-DECLARE_LIST(methodstate);
-
-typedef struct _methodstate {
+struct _methodstate {
/* method data */
- memberinfo_t*info;
+ methodinfo_t*info;
+ char has_exceptions;
char late_binding;
char is_constructor;
char has_super;
char is_global;
+ char is_static;
int variable_count;
+ dict_t*unresolved_variables;
+
char inner;
+ char uses_parent_function;
+ char no_variable_scoping;
+ int uses_slots;
+ dict_t*slots;
+ int activation_var;
+
+ int need_arguments;
+
abc_method_t*abc;
int var_index; // for inner methods
+ int slot_index; // for inner methods
+ char is_a_slot; // for inner methods
+ code_t*header;
+
+ code_t*scope_code;
abc_exception_list_t*exceptions;
methodstate_list_t*innerfunctions;
-} methodstate_t;
+};
+
+void methodstate_destroy(methodstate_t*m)
+{
+ dict_destroy(m->unresolved_variables);
+ m->unresolved_variables = 0;
+ list_free(m->innerfunctions);m->innerfunctions=0;
+}
typedef struct _state {
struct _state*old;
@@ -352,22 +396,36 @@ typedef struct _state {
char*package;
import_list_t*wildcard_imports;
+ dict_t*import_toplevel_packages;
dict_t*imports;
+
+ namespace_list_t*active_namespace_urls;
+
char has_own_imports;
char new_vars; // e.g. transition between two functions
+ char xmlfilter; // are we inside a xmlobj..() filter?
classstate_t*cls;
methodstate_t*method;
char*exception_name;
+
+ int switch_var;
dict_t*vars;
+ dict_t*allvars; // also contains variables from sublevels
} state_t;
typedef struct _global {
abc_file_t*file;
- abc_script_t*init;
+
+ parsedclass_list_t*classes;
+ abc_script_t*classinit;
+
+ abc_script_t*init; //package-level code
+
dict_t*token2info;
+ dict_t*file2token2info;
} global_t;
static global_t*global = 0;
@@ -375,20 +433,25 @@ static state_t* state = 0;
DECLARE_LIST(state);
-#define MULTINAME(m,x) \
- multiname_t m;\
- namespace_t m##_ns;\
- registry_fill_multiname(&m, &m##_ns, x);
-
+/* protected handling here is a big hack: we just assume the protectedns
+ is package:class. the correct approach would be to add the proper
+ namespace to all protected members in the registry, even though that
+ would slow down searching */
#define MEMBER_MULTINAME(m,f,n) \
multiname_t m;\
namespace_t m##_ns;\
if(f) { \
- m##_ns = flags2namespace(f->flags, ""); \
+ m##_ns.access = ((slotinfo_t*)(f))->access; \
+ if(m##_ns.access == ACCESS_NAMESPACE) \
+ m##_ns.name = ((slotinfo_t*)(f))->package; \
+ else if(m##_ns.access == ACCESS_PROTECTED && (f)->parent) \
+ m##_ns.name = concat3((f)->parent->package,":",(f)->parent->name); \
+ else \
+ m##_ns.name = ""; \
m.type = QNAME; \
m.ns = &m##_ns; \
m.namespace_set = 0; \
- m.name = f->name; \
+ m.name = ((slotinfo_t*)(f))->name; \
} else { \
m.type = MULTINAME; \
m.ns =0; \
@@ -409,13 +472,22 @@ DECLARE_LIST(state);
static namespace_t ns1 = {ACCESS_PRIVATE, ""};
static namespace_t ns2 = {ACCESS_PROTECTED, ""};
static namespace_t ns3 = {ACCESS_PACKAGEINTERNAL, ""};
-static namespace_t ns4 = {ACCESS_PACKAGE, ""};
-static namespace_list_t nl4 = {&ns4,0};
+static namespace_t stdns = {ACCESS_PACKAGE, ""};
+static namespace_list_t nl4 = {&stdns,0};
static namespace_list_t nl3 = {&ns3,&nl4};
static namespace_list_t nl2 = {&ns2,&nl3};
static namespace_list_t nl1 = {&ns1,&nl2};
static namespace_set_t nopackage_namespace_set = {&nl1};
+static dict_t*definitions=0;
+void as3_set_define(const char*c)
+{
+ if(!definitions)
+ definitions = dict_new();
+ if(!dict_contains(definitions,c))
+ dict_put(definitions,c,0);
+}
+
static void new_state()
{
NEW(state_t, s);
@@ -425,17 +497,20 @@ static void new_state()
if(!s->imports) {
s->imports = dict_new();
}
+ if(!s->import_toplevel_packages) {
+ s->import_toplevel_packages = dict_new();
+ }
state = s;
state->level++;
state->has_own_imports = 0;
state->vars = dict_new();
state->old = oldstate;
-}
-static void state_has_imports()
-{
- state->wildcard_imports = list_clone(state->wildcard_imports);
- state->imports = dict_clone(state->imports);
- state->has_own_imports = 1;
+ state->new_vars = 0;
+
+ trie_remember(active_namespaces);
+
+ if(oldstate)
+ state->active_namespace_urls = list_clone(oldstate->active_namespace_urls);
}
static void state_destroy(state_t*state)
@@ -448,47 +523,81 @@ static void state_destroy(state_t*state)
dict_destroy(state->imports);state->imports=0;
}
if(state->vars) {
- int t;
- for(t=0;tvars->hashsize;t++) {
- dictentry_t*e =state->vars->slots[t];
- while(e) {
- free(e->data);e->data=0;
- e = e->next;
- }
- }
dict_destroy(state->vars);state->vars=0;
}
+ if(state->new_vars && state->allvars) {
+ parserassert(!state->old || state->old->allvars != state->allvars);
+ DICT_ITERATE_DATA(state->allvars, void*, data) {
+ free(data);
+ }
+ dict_destroy(state->allvars);
+ }
+
+ list_free(state->active_namespace_urls)
+ state->active_namespace_urls = 0;
free(state);
}
static void old_state()
{
+ trie_rollback(active_namespaces);
+
if(!state || !state->old)
syntaxerror("invalid nesting");
state_t*leaving = state;
state = state->old;
-
+
if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) {
- free(leaving->method);
- leaving->method=0;
+ methodstate_destroy(leaving->method);leaving->method=0;
}
- if(leaving->cls && leaving->cls != state->cls) {
+ if(as3_pass>1 && leaving->cls && leaving->cls != state->cls) {
free(leaving->cls);
leaving->cls=0;
}
-
+
state_destroy(leaving);
}
+static code_t* method_header(methodstate_t*m);
+static code_t* wrap_function(code_t*c,code_t*header, code_t*body);
+static void function_initvars(methodstate_t*m, char has_params, params_t*params, int flags, char var0);
+
+
+static char* internal_filename_package = 0;
void initialize_file(char*filename)
{
+ if(state) {
+ syntaxerror("invalid call to initialize_file during parsing of another file");
+ }
+
+ active_namespaces = trie_new();
+
new_state();
- state->package = filename;
+ state->package = internal_filename_package = strdup(filename);
+ state->allvars = dict_new();
- state->method = rfx_calloc(sizeof(methodstate_t));
- state->method->variable_count = 1;
+ global->token2info = dict_lookup(global->file2token2info,
+ current_filename // use long version
+ );
+ if(!global->token2info) {
+ global->token2info = dict_new2(&ptr_type);
+ dict_put(global->file2token2info, current_filename, global->token2info);
+ }
+
+ if(as3_pass==1) {
+ state->method = rfx_calloc(sizeof(methodstate_t));
+ dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
+ state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope
+ } else {
+ state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
+ state->method->variable_count = 0;
+ if(!state->method)
+ syntaxerror("internal error: skewed tokencount");
+ function_initvars(state->method, 0, 0, 0, 1);
+ global->init = 0;
+ }
}
void finish_file()
@@ -496,6 +605,19 @@ void finish_file()
if(!state || state->level!=1) {
syntaxerror("unexpected end of file in pass %d", as3_pass);
}
+
+ if(as3_pass==2) {
+ dict_del(global->file2token2info, current_filename);
+ code_t*header = method_header(state->method);
+ //if(global->init->method->body->code || global->init->traits) {
+ if(global->init) {
+ code_t*c = wrap_function(header, 0, global->init->method->body->code);
+ global->init->method->body->code = abc_returnvoid(c);
+ free(state->method);state->method=0;
+ }
+ }
+
+ //free(state->package);state->package=0; // used in registry
state_destroy(state);state=0;
}
@@ -504,129 +626,163 @@ void initialize_parser()
global = rfx_calloc(sizeof(global_t));
global->file = abc_file_new();
global->file->flags &= ~ABCFILE_LAZY;
- global->token2info = dict_new2(&ptr_type);
-
- global->init = abc_initscript(global->file);
- code_t*c = global->init->method->body->code;
- c = abc_getlocal_0(c);
- c = abc_pushscope(c);
- global->init->method->body->code = c;
+ global->file2token2info = dict_new();
+ global->token2info = 0;
+ global->classinit = abc_initscript(global->file);
}
void* finish_parser()
{
- code_t*c = global->init->method->body->code;
- /*c = abc_findpropstrict(c, "[package]::trace");
- c = abc_pushstring(c, "[leaving global init function]");
- c = abc_callpropvoid(c, "[package]::trace", 1);*/
- c = abc_returnvoid(c);
- global->init->method->body->code = c;
- dict_destroy(global->token2info);global->token2info=0;
- return global->file;
-}
-
-
-static void xx_scopetest()
-{
- /* findpropstrict doesn't just return a scope object- it
- also makes it "active" somehow. Push local_0 on the
- scope stack and read it back with findpropstrict, it'll
- contain properties like "trace". Trying to find the same
- property on a "vanilla" local_0 yields only a "undefined" */
- //c = abc_findpropstrict(c, "[package]::trace");
+ dict_free_all(global->file2token2info, 1, (void*)dict_destroy);
+ global->token2info=0;
- /*c = abc_getlocal_0(c);
- c = abc_findpropstrict(c, "[package]::trace");
- c = abc_coerce_a(c);
- c = abc_setlocal_1(c);
+ initcode_add_classlist(global->classinit, global->classes);
- c = abc_pushbyte(c, 0);
- c = abc_setlocal_2(c);
-
- code_t*xx = c = abc_label(c);
- c = abc_findpropstrict(c, "[package]::trace");
- c = abc_pushstring(c, "prop:");
- c = abc_hasnext2(c, 1, 2);
- c = abc_dup(c);
- c = abc_setlocal_3(c);
- c = abc_callpropvoid(c, "[package]::trace", 2);
- c = abc_getlocal_3(c);
- c = abc_kill(c, 3);
- c = abc_iftrue(c,xx);*/
+ return global->file;
}
-
typedef struct _variable {
int index;
classinfo_t*type;
char init;
+ char kill;
+ char is_parameter;
+ methodstate_t*is_inner_method;
} variable_t;
-static variable_t* find_variable(char*name)
+static variable_t* find_variable(state_t*s, char*name)
{
- state_t* s = state;
- while(s) {
- variable_t*v = 0;
- if(s->method)
+ if(s->method->no_variable_scoping) {
+ return dict_lookup(s->allvars, name);
+ } else {
+ state_t*top = s;
+ while(s) {
+ variable_t*v = 0;
v = dict_lookup(s->vars, name);
- if(v) {
- return v;
+ if(v) return v;
+ if(s->new_vars) break;
+ s = s->old;
}
- if(s->new_vars)
- break;
- s = s->old;
+ return 0;
}
+}
+static variable_t* find_slot(methodstate_t*m, const char*name)
+{
+ if(m && m->slots)
+ return dict_lookup(m->slots, name);
return 0;
-}
-static variable_t* find_variable_safe(char*name)
+}
+
+static variable_t* find_variable_safe(state_t*s, char*name)
{
- variable_t* v = find_variable(name);
+ variable_t* v = find_variable(s, name);
if(!v)
syntaxerror("undefined variable: %s", name);
return v;
}
+
static char variable_exists(char*name)
{
- return dict_lookup(state->vars, name)!=0;
+ return dict_contains(state->vars, name);
+}
+
+static code_t*defaultvalue(code_t*c, classinfo_t*type)
+{
+ if(TYPE_IS_INT(type)) {
+ c = abc_pushbyte(c, 0);
+ } else if(TYPE_IS_UINT(type)) {
+ c = abc_pushuint(c, 0);
+ } else if(TYPE_IS_FLOAT(type)) {
+ c = abc_pushnan(c);
+ } else if(TYPE_IS_BOOLEAN(type)) {
+ c = abc_pushfalse(c);
+ } else if(TYPE_IS_STRING(type)) {
+ c = abc_pushnull(c);
+ c = abc_coerce_s(c);
+ } else if(!type) {
+ //c = abc_pushundefined(c);
+ syntaxerror("internal error: can't generate default value for * type");
+ } else {
+ c = abc_pushnull(c);
+ MULTINAME(m, type);
+ c = abc_coerce2(c, &m);
+ }
+ return c;
+}
+
+static int alloc_local()
+{
+ return state->method->variable_count++;
}
-code_t*defaultvalue(code_t*c, classinfo_t*type);
-static int new_variable(const char*name, classinfo_t*type, char init)
+
+static variable_t* new_variable2(methodstate_t*method, const char*name, classinfo_t*type, char init, char maybeslot)
{
+ if(maybeslot) {
+ variable_t*v = find_slot(method, name);
+ if(v) {
+ alloc_local();
+ return v;
+ }
+ }
+
NEW(variable_t, v);
- v->index = state->method->variable_count;
+ v->index = alloc_local();
v->type = type;
- v->init = init;
-
- dict_put(state->vars, name, v);
+ v->init = v->kill = init;
+
+ if(name) {
+ if(!method->no_variable_scoping)
+ {
+ if(dict_contains(state->vars, name)) {
+ *(int*)0=0;
+ syntaxerror("variable %s already defined", name);
+ }
+ dict_put(state->vars, name, v);
+ }
+ if(method->no_variable_scoping &&
+ as3_pass==2 &&
+ dict_contains(state->allvars, name))
+ {
+ variable_t*v = dict_lookup(state->allvars, name);
+ if(v->type != type)
+ syntaxerror("variable %s already defined.", name);
+ return v;
+ }
+ dict_put(state->allvars, name, v);
+ }
- return state->method->variable_count++;
+ return v;
+}
+static int new_variable(methodstate_t*method, const char*name, classinfo_t*type, char init, char maybeslot)
+{
+ return new_variable2(method, name, type, init, maybeslot)->index;
}
+
#define TEMPVARNAME "__as3_temp__"
-static int gettempvar()
+int gettempvar()
{
- variable_t*v = find_variable(TEMPVARNAME);
+ variable_t*v = find_variable(state, TEMPVARNAME);
+ int i;
if(v)
- return v->index;
- return new_variable(TEMPVARNAME, 0, 0);
+ i = v->index;
+ else
+ i = new_variable(state->method, TEMPVARNAME, 0, 0, 0);
+ parserassert(i);
+ return i;
}
-code_t* var_block(code_t*body)
+static code_t* var_block(code_t*body, dict_t*vars)
{
code_t*c = 0;
code_t*k = 0;
int t;
- int num=0;
- for(t=0;tvars->hashsize;t++) {
- dictentry_t*e = state->vars->slots[t];
- while(e) {
- variable_t*v = (variable_t*)e->data;
- if(v->type && v->init) {
- c = defaultvalue(c, v->type);
- c = abc_setlocal(c, v->index);
- k = abc_kill(k, v->index);
- num++;
- }
- e = e->next;
+ DICT_ITERATE_DATA(vars, variable_t*, v) {
+ if(v->type && v->init) {
+ c = defaultvalue(c, v->type);
+ c = abc_setlocal(c, v->index);
+ }
+ if(v->type && v->kill) {
+ k = abc_kill(k, v->index);
}
}
@@ -654,40 +810,85 @@ code_t* var_block(code_t*body)
return c;
}
-#define parserassert(b) {if(!(b)) parsererror(__FILE__, __LINE__,__func__);}
-
-static void parsererror(const char*file, int line, const char*f)
+static void unknown_variable(char*name)
{
- syntaxerror("internal error in %s, %s:%d", f, file, line);
+ if(!state->method->unresolved_variables)
+ state->method->unresolved_variables = dict_new();
+ if(!dict_contains(state->method->unresolved_variables, name))
+ dict_put(state->method->unresolved_variables, name, 0);
}
-
-code_t* method_header()
+static code_t* add_scope_code(code_t*c, methodstate_t*m, char init)
{
- code_t*c = 0;
- if(state->method->late_binding && !state->method->inner) {
+ if(m->uses_slots || m->innerfunctions || (m->late_binding && !m->inner)) {
c = abc_getlocal_0(c);
c = abc_pushscope(c);
}
- /*if(state->method->innerfunctions) {
- c = abc_newactivation(c);
- c = abc_pushscope(c);
- }*/
- if(state->method->is_constructor && !state->method->has_super) {
- // call default constructor
- c = abc_getlocal_0(c);
- c = abc_constructsuper(c, 0);
+ if(m->uses_slots) {
+ /* FIXME: this alloc_local() causes variable indexes to be
+ different in pass2 than in pass1 */
+ if(!m->activation_var) {
+ m->activation_var = alloc_local();
+ }
+ if(init) {
+ c = abc_newactivation(c);
+ c = abc_dup(c);
+ c = abc_pushscope(c);
+ c = abc_setlocal(c, m->activation_var);
+ } else {
+ c = abc_getlocal(c, m->activation_var);
+ c = abc_pushscope(c);
+ }
}
- methodstate_list_t*l = state->method->innerfunctions;
+ return c;
+}
+
+static code_t* method_header(methodstate_t*m)
+{
+ code_t*c = 0;
+
+ c = add_scope_code(c, m, 1);
+
+ methodstate_list_t*l = m->innerfunctions;
while(l) {
parserassert(l->methodstate->abc);
- c = abc_newfunction(c, l->methodstate->abc);
- c = abc_setlocal(c, l->methodstate->var_index);
+ if(m->uses_slots && l->methodstate->is_a_slot) {
+ c = abc_getscopeobject(c, 1);
+ c = abc_newfunction(c, l->methodstate->abc);
+ c = abc_dup(c);
+ c = abc_setlocal(c, l->methodstate->var_index);
+ c = abc_setslot(c, l->methodstate->slot_index);
+ } else {
+ c = abc_newfunction(c, l->methodstate->abc);
+ c = abc_setlocal(c, l->methodstate->var_index);
+ }
free(l->methodstate);l->methodstate=0;
l = l->next;
}
- list_free(state->method->innerfunctions);
- state->method->innerfunctions = 0;
+ if(m->header) {
+ c = code_append(c, m->header);
+ m->header = 0;
+ }
+ if(m->is_constructor && !m->has_super) {
+ // call default constructor
+ c = abc_getlocal_0(c);
+ c = abc_constructsuper(c, 0);
+ }
+
+ if(m->slots) {
+ /* all parameters that are used by inner functions
+ need to be copied from local to slot */
+ parserassert(m->activation_var);
+ DICT_ITERATE_ITEMS(m->slots,char*,name,variable_t*,v) {
+ if(v->is_parameter) {
+ c = abc_getlocal(c, m->activation_var);
+ c = abc_getlocal(c, v->index);
+ c = abc_setslot(c, v->index);
+ }
+ }
+ }
+ list_free(m->innerfunctions);
+ m->innerfunctions = 0;
return c;
}
@@ -695,7 +896,7 @@ code_t* method_header()
static code_t* wrap_function(code_t*c,code_t*header, code_t*body)
{
c = code_append(c, header);
- c = code_append(c, var_block(body));
+ c = code_append(c, var_block(body, state->method->no_variable_scoping?state->allvars:state->vars));
/* append return if necessary */
if(!c || (c->opcode != OPCODE_RETURNVOID &&
c->opcode != OPCODE_RETURNVALUE)) {
@@ -704,151 +905,253 @@ static code_t* wrap_function(code_t*c,code_t*header, code_t*body)
return c;
}
-
static void startpackage(char*name)
{
new_state();
- /*printf("entering package \"%s\"\n", name);*/
state->package = strdup(name);
}
static void endpackage()
{
- /*printf("leaving package \"%s\"\n", state->package);*/
-
//used e.g. in classinfo_register:
//free(state->package);state->package=0;
-
old_state();
}
+#define FLAG_PUBLIC 256
+#define FLAG_PROTECTED 512
+#define FLAG_PRIVATE 1024
+#define FLAG_PACKAGEINTERNAL 2048
+#define FLAG_NAMESPACE 4096
+
+static namespace_t modifiers2access(modifiers_t*mod)
+{
+ namespace_t ns;
+ ns.access = 0;
+ ns.name = "";
+ if(mod->flags&FLAG_NAMESPACE) {
+ if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
+ syntaxerror("invalid combination of access levels and namespaces");
+ ns.access = ACCESS_NAMESPACE;
+ state_t*s = state;
+ const char*url = (const char*)trie_lookup(active_namespaces, mod->ns);
+ if(!url) {
+ /* shouldn't happen- the tokenizer only reports something as a namespace
+ if it was already registered */
+ trie_dump(active_namespaces);
+ syntaxerror("unknown namespace: %s", mod->ns);
+ }
+ ns.name = url;
+ } else if(mod->flags&FLAG_PUBLIC) {
+ if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
+ syntaxerror("invalid combination of access levels");
+ ns.access = ACCESS_PACKAGE;
+ } else if(mod->flags&FLAG_PRIVATE) {
+ if(mod->flags&(FLAG_PUBLIC|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
+ syntaxerror("invalid combination of access levels");
+ ns.access = ACCESS_PRIVATE;
+ } else if(mod->flags&FLAG_PROTECTED) {
+ if(mod->flags&(FLAG_PUBLIC|FLAG_PRIVATE|FLAG_PACKAGEINTERNAL))
+ syntaxerror("invalid combination of access levels");
+ ns.access = ACCESS_PROTECTED;
+ } else {
+ ns.access = ACCESS_PACKAGEINTERNAL;
+ }
+ return ns;
+}
+static slotinfo_t* find_class(const char*name);
+
+static memberinfo_t* findmember_nsset(classinfo_t*cls, const char*name, char recurse)
+{
+ return registry_findmember_nsset(cls, state->active_namespace_urls, name, recurse);
+}
+
+static void innerfunctions2vars(methodstate_t*m)
+{
+ methodstate_list_t*l = m->innerfunctions;
+ while(l) {
+ methodstate_t*m = l->methodstate;
+
+ variable_t* v = new_variable2(state->method, m->info->name, TYPE_FUNCTION(m->info), 0, 0);
+ m->var_index = v->index;
+ if(m->is_a_slot)
+ m->slot_index = m->is_a_slot;
+ v->is_inner_method = m;
+ l = l->next;
+ }
+}
+
+static void function_initvars(methodstate_t*m, char has_params, params_t*params, int flags, char var0)
+{
+ if(var0) {
+ int index = -1;
+ if(m->inner)
+ index = new_variable(m, "this", 0, 0, 0);
+ else if(!m->is_global)
+ index = new_variable(m, (flags&FLAG_STATIC)?"class":"this", state->cls?state->cls->info:0, 0, 0);
+ else
+ index = new_variable(m, "globalscope", 0, 0, 0);
+ if(index) {
+ DICT_ITERATE_ITEMS(state->vars, char*, name, variable_t*, v) {
+ printf("%s %d\n", name, v->index);
+ }
+ }
+ parserassert(!index);
+ }
+
+ if(has_params) {
+ param_list_t*p=0;
+ for(p=params->list;p;p=p->next) {
+ variable_t*v = new_variable2(m, p->param->name, p->param->type, 0, 1);
+ v->is_parameter = 1;
+ }
+ if(as3_pass==2 && m->need_arguments) {
+ /* arguments can never be used by an innerfunction (the inner functions
+ have their own arguments var), so it's ok to not initialize this until
+ pass 2. (We don't know whether we need it before, anyway) */
+ variable_t*v = new_variable2(m, "arguments", TYPE_ARRAY, 0, 0);
+ m->need_arguments = v->index;
+ }
+ }
+
+ innerfunctions2vars(m);
+
+ if(as3_pass==2) {
+ m->scope_code = add_scope_code(m->scope_code, m, 0);
+ if(m->slots) {
+ /* exchange unresolved identifiers with the actual objects */
+ DICT_ITERATE_ITEMS(m->slots, char*, name, variable_t*, v) {
+ if(v->type && v->type->kind == INFOTYPE_UNRESOLVED) {
+ classinfo_t*type = (classinfo_t*)registry_resolve((slotinfo_t*)v->type);
+ if(!type || type->kind != INFOTYPE_CLASS) {
+ syntaxerror("Couldn't find class %s::%s (%s)", v->type->package, v->type->name, name);
+ }
+ v->type = type;
+ }
+ }
+ }
+ }
+}
+
char*as3_globalclass=0;
-static void startclass(int flags, char*classname, classinfo_t*extends, classinfo_list_t*implements, char interface)
+static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, classinfo_list_t*implements)
{
if(state->cls) {
syntaxerror("inner classes now allowed");
}
- new_state();
- state->cls = rfx_calloc(sizeof(classstate_t));
- state->method = rfx_calloc(sizeof(methodstate_t)); // method state, for static constructor
- state->method->variable_count = 1;
+ new_state();
token_list_t*t=0;
classinfo_list_t*mlist=0;
- if(flags&~(FLAG_PACKAGEINTERNAL|FLAG_PUBLIC|FLAG_FINAL|FLAG_DYNAMIC))
+ if(mod->flags&~(FLAG_PACKAGEINTERNAL|FLAG_PUBLIC|FLAG_FINAL|FLAG_DYNAMIC|FLAG_INTERFACE))
syntaxerror("invalid modifier(s)");
- if((flags&(FLAG_PUBLIC|FLAG_PACKAGEINTERNAL)) == (FLAG_PUBLIC|FLAG_PACKAGEINTERNAL))
+ if((mod->flags&(FLAG_PUBLIC|FLAG_PACKAGEINTERNAL)) == (FLAG_PUBLIC|FLAG_PACKAGEINTERNAL))
syntaxerror("public and internal not supported at the same time.");
+
+ if((mod->flags&(FLAG_PROTECTED|FLAG_STATIC)) == (FLAG_PROTECTED|FLAG_STATIC))
+ syntaxerror("protected and static not supported at the same time.");
+
+ //if(!(mod->flags&FLAG_INTERFACE) && !extends) {
+ if(!(mod->flags&FLAG_INTERFACE) && !extends) {
+ // all classes extend object
+ extends = registry_getobjectclass();
+ }
/* create the class name, together with the proper attributes */
int access=0;
char*package=0;
- if(!(flags&FLAG_PUBLIC) && !state->package) {
- access = ACCESS_PRIVATE; package = current_filename;
- } else if(!(flags&FLAG_PUBLIC) && state->package) {
+ if(!(mod->flags&FLAG_PUBLIC) && state->package==internal_filename_package) {
+ access = ACCESS_PRIVATE; package = internal_filename_package;
+ } else if(!(mod->flags&FLAG_PUBLIC) && state->package!=internal_filename_package) {
access = ACCESS_PACKAGEINTERNAL; package = state->package;
- } else if(state->package) {
+ } else if(state->package!=internal_filename_package) {
access = ACCESS_PACKAGE; package = state->package;
} else {
syntaxerror("public classes only allowed inside a package");
}
if(as3_pass==1) {
- if(registry_findclass(package, classname)) {
+ state->cls = rfx_calloc(sizeof(classstate_t));
+ state->cls->init = rfx_calloc(sizeof(methodstate_t));
+ state->cls->static_init = rfx_calloc(sizeof(methodstate_t));
+ state->cls->static_init->is_static=FLAG_STATIC;
+ /* notice: we make no effort to initialize the top variable (local0) here,
+ even though it has special meaning. We just rely on the fact
+ that pass 1 won't do anything with variables */
+
+ dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->cls);
+
+ /* set current method to constructor- all code within the class-level (except
+ static variable initializations) will be executed during construction time */
+ state->method = state->cls->init;
+
+ if(registry_find(package, classname)) {
syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, classname);
}
/* build info struct */
int num_interfaces = (list_length(implements));
state->cls->info = classinfo_register(access, package, classname, num_interfaces);
+ state->cls->info->flags |= mod->flags & (FLAG_DYNAMIC|FLAG_INTERFACE|FLAG_FINAL);
+ state->cls->info->superclass = extends;
+
+ int pos = 0;
+ classinfo_list_t*l = implements;
+ for(l=implements;l;l=l->next) {
+ state->cls->info->interfaces[pos++] = l->classinfo;
+ }
}
if(as3_pass == 2) {
- state->cls->info = registry_findclass(package, classname);
- parserassert((int)state->cls->info);
+ state->cls = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
+
+ parserassert(state->cls && state->cls->info);
+
+ state->method = state->cls->static_init;
- /* fill out interfaces and extends (we couldn't resolve those during the first pass) */
- state->cls->info->superclass = extends?extends:TYPE_OBJECT;
+ function_initvars(state->cls->init, 0, 0, 0, 1);
+ state->cls->static_init->variable_count=1;
+ function_initvars(state->cls->static_init, 0, 0, 0, 0);
+
+ if(extends && (extends->flags & FLAG_FINAL))
+ syntaxerror("Can't extend final class '%s'", extends->name);
+
int pos = 0;
- classinfo_list_t*l = implements;
- for(l=implements;l;l=l->next) {
- state->cls->info->interfaces[pos++] = l->classinfo;
+ while(state->cls->info->interfaces[pos]) {
+ if(!(state->cls->info->interfaces[pos]->flags & FLAG_INTERFACE))
+ syntaxerror("'%s' is not an interface",
+ state->cls->info->interfaces[pos]->name);
+ pos++;
}
/* generate the abc code for this class */
MULTINAME(classname2,state->cls->info);
multiname_t*extends2 = sig2mname(extends);
- state->cls->abc = abc_class_new(global->file, &classname2, extends2);
- if(flags&FLAG_FINAL) abc_class_final(state->cls->abc);
- if(!(flags&FLAG_DYNAMIC)) abc_class_sealed(state->cls->abc);
- if(interface) {
- state->cls->info->flags |= CLASS_INTERFACE;
+ /* don't add the class to the class index just yet- that will be done later
+ by initscript */
+ state->cls->abc = abc_class_new(0, &classname2, extends2);
+ state->cls->abc->file = global->file;
+
+ multiname_destroy(extends2);
+ if(state->cls->info->flags&FLAG_FINAL) abc_class_final(state->cls->abc);
+ if(!(state->cls->info->flags&FLAG_DYNAMIC)) abc_class_sealed(state->cls->abc);
+ if(state->cls->info->flags&FLAG_INTERFACE) {
abc_class_interface(state->cls->abc);
}
- abc_class_protectedNS(state->cls->abc, classname);
-
for(mlist=implements;mlist;mlist=mlist->next) {
MULTINAME(m, mlist->classinfo);
abc_class_add_interface(state->cls->abc, &m);
}
- /* write the construction code for this class to the global init
- function */
- int slotindex = abc_initscript_addClassTrait(global->init, &classname2, state->cls->abc);
-
- abc_method_body_t*m = global->init->method->body;
- __ getglobalscope(m);
- classinfo_t*s = extends;
-
- int count=0;
-
- while(s) {
- //TODO: take a look at the current scope stack, maybe
- // we can re-use something
- s = s->superclass;
- if(!s)
- break;
-
- multiname_t*s2 = sig2mname(s);
- __ getlex2(m, s2);
- multiname_destroy(s2);
-
- __ pushscope(m); count++;
- m->code = m->code->prev->prev; // invert
- }
- /* continue appending after last op end */
- while(m->code && m->code->next) m->code = m->code->next;
-
- /* TODO: if this is one of *our* classes, we can also
- do a getglobalscope/getslot (which references
- the init function's slots) */
- if(extends2) {
- __ getlex2(m, extends2);
- __ dup(m);
- /* notice: we get a Verify Error #1107 if the top elemnt on the scope
- stack is not the superclass */
- __ pushscope(m);count++;
- } else {
- __ pushnull(m);
- /* notice: we get a verify error #1107 if the top element on the scope
- stack is not the global object */
- __ getlocal_0(m);
- __ pushscope(m);count++;
- }
- __ newclass(m,state->cls->abc);
- while(count--) {
- __ popscope(m);
- }
- __ setslot(m, slotindex);
- multiname_destroy(extends2);
+ state->cls->dependencies = parsedclass_new(state->cls->info, state->cls->abc);
+ list_append(global->classes, state->cls->dependencies);
/* flash.display.MovieClip handling */
-
- if(!as3_globalclass && (flags&FLAG_PUBLIC) && classinfo_equals(registry_getMovieClip(),extends)) {
+ if(!as3_globalclass && (mod->flags&FLAG_PUBLIC) && slotinfo_equals((slotinfo_t*)registry_getMovieClip(),(slotinfo_t*)extends)) {
if(state->package && state->package[0]) {
as3_globalclass = concat3(state->package, ".", classname);
} else {
@@ -861,27 +1164,42 @@ static void startclass(int flags, char*classname, classinfo_t*extends, classinfo
static void endclass()
{
if(as3_pass == 2) {
- if(!state->cls->has_constructor && !(state->cls->info->flags&CLASS_INTERFACE)) {
+ if(!state->cls->has_constructor && !(state->cls->info->flags&FLAG_INTERFACE)) {
code_t*c = 0;
c = abc_getlocal_0(c);
c = abc_constructsuper(c, 0);
- state->cls->init = code_append(state->cls->init, c);
- }
- if(!state->method->late_binding) {
- // class initialization code uses late binding
- code_t*c = 0;
- c = abc_getlocal_0(c);
- c = abc_pushscope(c);
- state->cls->static_init = code_append(c, state->cls->static_init);
+ state->cls->init->header = code_append(state->cls->init->header, c);
+ state->cls->has_constructor=1;
}
-
if(state->cls->init) {
- abc_method_t*m = abc_class_getconstructor(state->cls->abc, 0);
- m->body->code = wrap_function(0, state->cls->init, m->body->code);
+ if(state->cls->info->flags&FLAG_INTERFACE) {
+ if(state->cls->init->header)
+ syntaxerror("interface can not have class-level code");
+ } else {
+ abc_method_t*m = abc_class_getconstructor(state->cls->abc, 0);
+ code_t*c = method_header(state->cls->init);
+ m->body->code = wrap_function(c, 0, m->body->code);
+ }
}
if(state->cls->static_init) {
abc_method_t*m = abc_class_getstaticconstructor(state->cls->abc, 0);
- m->body->code = wrap_function(0, state->cls->static_init, m->body->code);
+ code_t*c = method_header(state->cls->static_init);
+ m->body->code = wrap_function(c, 0, m->body->code);
+ }
+
+ trait_list_t*trait = state->cls->abc->traits;
+ /* switch all protected members to the protected ns of this class */
+ while(trait) {
+ trait_t*t = trait->trait;
+ if(t->name->ns->access == ACCESS_PROTECTED) {
+ if(!state->cls->abc->protectedNS) {
+ char*n = concat3(state->cls->info->package, ":", state->cls->info->name);
+ state->cls->abc->protectedNS = namespace_new_protected(n);
+ state->cls->abc->flags |= CLASS_PROTECTED_NS;
+ }
+ t->name->ns->name = strdup(state->cls->abc->protectedNS->name);
+ }
+ trait = trait->next;
}
}
@@ -899,11 +1217,20 @@ void check_code_for_break(code_t*c)
char*name = string_cstr(c->data[0]);
syntaxerror("Unresolved \"continue %s\"", name);
}
+ if(c->opcode == OPCODE___RETHROW__) {
+ syntaxerror("Unresolved \"rethrow\"");
+ }
+ if(c->opcode == OPCODE___FALLTHROUGH__) {
+ syntaxerror("Unresolved \"fallthrough\"");
+ }
+ if(c->opcode == OPCODE___PUSHPACKAGE__) {
+ char*name = string_cstr(c->data[0]);
+ syntaxerror("Can't reference a package (%s) as such", name);
+ }
c=c->prev;
}
}
-
static void check_constant_against_type(classinfo_t*t, constant_t*c)
{
#define xassert(b) if(!(b)) syntaxerror("Invalid default value %s for type '%s'", constant_tostring(c), t->name)
@@ -913,7 +1240,7 @@ static void check_constant_against_type(classinfo_t*t, constant_t*c)
|| c->type == CONSTANT_UINT);
} else if(TYPE_IS_UINT(t)) {
xassert(c->type == CONSTANT_UINT ||
- (c->type == CONSTANT_INT && c->i>0));
+ (c->type == CONSTANT_INT && c->i>=0));
} else if(TYPE_IS_INT(t)) {
xassert(c->type == CONSTANT_INT);
} else if(TYPE_IS_BOOLEAN(t)) {
@@ -922,163 +1249,170 @@ static void check_constant_against_type(classinfo_t*t, constant_t*c)
}
}
-
-static int flags2access(int flags)
+static void check_override(memberinfo_t*m, int flags)
{
- int access = 0;
- if(flags&FLAG_PUBLIC) {
- if(access&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
- syntaxerror("invalid combination of access levels");
- access = ACCESS_PACKAGE;
- } else if(flags&FLAG_PRIVATE) {
- if(access&(FLAG_PUBLIC|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))
- syntaxerror("invalid combination of access levels");
- access = ACCESS_PRIVATE;
- } else if(flags&FLAG_PROTECTED) {
- if(access&(FLAG_PUBLIC|FLAG_PRIVATE|FLAG_PACKAGEINTERNAL))
- syntaxerror("invalid combination of access levels");
- access = ACCESS_PROTECTED;
- } else {
- access = ACCESS_PACKAGEINTERNAL;
+ if(!m)
+ return;
+ if(m->parent == state->cls->info)
+ syntaxerror("class '%s' already contains a method/slot '%s'", m->parent->name, m->name);
+ if(!m->parent)
+ syntaxerror("internal error: overriding method %s, which doesn't have parent", m->name);
+ if(m->access==ACCESS_PRIVATE)
+ return;
+ if(m->flags & FLAG_FINAL)
+ syntaxerror("can't override final member %s", m->name);
+
+ /* allow this. it's no issue.
+ if((m->flags & FLAG_STATIC) && !(flags&FLAG_STATIC))
+ syntaxerror("can't override static member %s", m->name);*/
+
+ if(!(m->flags & FLAG_STATIC) && (flags&FLAG_STATIC))
+ syntaxerror("can't override non-static member %s with static declaration", m->name);
+
+ if(!(flags&FLAG_OVERRIDE) && !(flags&FLAG_STATIC) && !(m->flags&FLAG_STATIC)) {
+ if(m->parent && !(m->parent->flags&FLAG_INTERFACE)) {
+ if(m->kind == INFOTYPE_METHOD)
+ syntaxerror("can't override without explicit 'override' declaration");
+ else
+ syntaxerror("can't override '%s'", m->name);
+ }
}
- return access;
}
-
-static memberinfo_t*registerfunction(enum yytokentype getset, int flags, char*name, params_t*params, classinfo_t*return_type, int slot)
+static methodinfo_t*registerfunction(enum yytokentype getset, modifiers_t*mod, char*name, params_t*params, classinfo_t*return_type, int slot)
{
- memberinfo_t*minfo = 0;
+ methodinfo_t*minfo = 0;
+ namespace_t ns = modifiers2access(mod);
if(!state->cls) {
//package method
- minfo = memberinfo_register_global(flags2access(flags), state->package, name, MEMBER_METHOD);
+ minfo = methodinfo_register_global(ns.access, state->package, name);
minfo->return_type = return_type;
} else if(getset != KW_GET && getset != KW_SET) {
//class method
- if((minfo = registry_findmember(state->cls->info, name, 0))) {
- if(minfo->parent == state->cls->info) {
- syntaxerror("class already contains a member/method called '%s'", name);
- } else if(!minfo->parent) {
- syntaxerror("internal error: overriding method %s, which doesn't have parent", name);
- } else {
- if(!(minfo->flags&(FLAG_STATIC|FLAG_PRIVATE)))
- syntaxerror("function %s already exists in superclass. Did you forget the 'override' keyword?");
- }
+ memberinfo_t* m = registry_findmember(state->cls->info, ns.name, name, 0);
+ if(m) {
+ syntaxerror("class already contains a %s '%s'", infotypename((slotinfo_t*)m), m->name);
}
- minfo = memberinfo_register(state->cls->info, name, MEMBER_METHOD);
+ minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);
minfo->return_type = return_type;
// getslot on a member slot only returns "undefined", so no need
// to actually store these
//state->minfo->slot = state->method->abc->method->trait->slot_id;
} else {
//class getter/setter
- int gs = getset==KW_GET?MEMBER_GET:MEMBER_SET;
+ int gs = getset==KW_GET?SUBTYPE_GET:SUBTYPE_SET;
classinfo_t*type=0;
- if(getset == KW_GET)
+ if(getset == KW_GET) {
type = return_type;
- else if(params->list && params->list->param)
+ } else if(params->list && params->list->param && !params->list->next) {
type = params->list->param->type;
+ } else
+ syntaxerror("setter function needs to take exactly one argument");
// not sure wether to look into superclasses here, too
- if((minfo=registry_findmember(state->cls->info, name, 0))) {
- if(minfo->kind & ~(MEMBER_GET|MEMBER_SET))
- syntaxerror("class already contains a member or method called '%s'", name);
- if(minfo->kind & gs)
+ minfo = (methodinfo_t*)registry_findmember(state->cls->info, ns.name, name, 1);
+ if(minfo) {
+ if(minfo->kind!=INFOTYPE_VAR)
+ syntaxerror("class already contains a method called '%s'", name);
+ if(!(minfo->subtype & (SUBTYPE_GETSET)))
+ syntaxerror("class already contains a field called '%s'", name);
+ if(minfo->subtype & gs)
syntaxerror("getter/setter for '%s' already defined", name);
/* make a setter or getter into a getset */
- minfo->kind |= gs;
- if(!minfo->type)
- minfo->type = type;
- else
- if(type && minfo->type != type)
- syntaxerror("different type in getter and setter");
+ minfo->subtype |= gs;
+
+ /*
+ FIXME: this check needs to be done in pass 2
+
+ if((!minfo->return_type != !type) ||
+ (minfo->return_type && type &&
+ !strcmp(minfo->return_type->name, type->name))) {
+ syntaxerror("different type in getter and setter: %s and %s",
+ minfo->return_type?minfo->return_type->name:"*",
+ type?type->name:"*");
+ }*/
} else {
- minfo = memberinfo_register(state->cls->info, name, gs);
- minfo->type = type;
+ minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);
+ minfo->kind = INFOTYPE_VAR; //hack
+ minfo->subtype = gs;
+ minfo->return_type = type;
}
+
/* can't assign a slot as getter and setter might have different slots */
//minfo->slot = slot;
}
- if(flags&FLAG_STATIC) minfo->flags |= FLAG_STATIC;
- if(flags&FLAG_PUBLIC) minfo->flags |= FLAG_PUBLIC;
- if(flags&FLAG_PRIVATE) minfo->flags |= FLAG_PRIVATE;
- if(flags&FLAG_PROTECTED) minfo->flags |= FLAG_PROTECTED;
- if(flags&FLAG_PACKAGEINTERNAL) minfo->flags |= FLAG_PACKAGEINTERNAL;
- if(flags&FLAG_OVERRIDE) minfo->flags |= FLAG_OVERRIDE;
- return minfo;
-}
-
-static void function_initvars(params_t*params, int flags)
-{
- if(state->method->inner)
- new_variable("this", 0, 0);
- else if(!state->method->is_global)
- new_variable((flags&FLAG_STATIC)?"class":"this", state->cls->info, 0);
- else
- new_variable("globalscope", 0, 0);
+ if(mod->flags&FLAG_FINAL) minfo->flags |= FLAG_FINAL;
+ if(mod->flags&FLAG_STATIC) minfo->flags |= FLAG_STATIC;
+ if(mod->flags&FLAG_OVERRIDE) minfo->flags |= FLAG_OVERRIDE;
- param_list_t*p=0;
- for(p=params->list;p;p=p->next) {
- new_variable(p->param->name, p->param->type, 0);
- }
-
- methodstate_list_t*l = state->method->innerfunctions;
- while(l) {
- methodstate_t*m = l->methodstate;
- m->var_index = new_variable(m->info->name, TYPE_FUNCTION(m->info), 0);
- l = l->next;
- }
+ return minfo;
}
static void innerfunction(char*name, params_t*params, classinfo_t*return_type)
{
- parserassert(state->method && state->method->info);
+ //parserassert(state->method && state->method->info);
methodstate_t*parent_method = state->method;
+ variable_t*v = 0;
if(as3_pass==1) {
- // not valid yet
- params = 0;
- return_type = 0;
+ return_type = 0; // not valid in pass 1
+ if(name) {
+ v = new_variable2(parent_method, name, 0, 0, 0);
+ }
}
new_state();
state->new_vars = 1;
+ state->allvars = dict_new();
if(as3_pass == 1) {
state->method = rfx_calloc(sizeof(methodstate_t));
state->method->inner = 1;
+ state->method->is_static = parent_method->is_static;
state->method->variable_count = 0;
state->method->abc = rfx_calloc(sizeof(abc_method_t));
+ if(v) {
+ v->is_inner_method = state->method;
+ }
- NEW(memberinfo_t,minfo);
+ NEW(methodinfo_t,minfo);
+ minfo->kind = INFOTYPE_METHOD;
+ minfo->access = ACCESS_PACKAGEINTERNAL;
minfo->name = name;
state->method->info = minfo;
- list_append(parent_method->innerfunctions, state->method);
+ if(parent_method)
+ list_append(parent_method->innerfunctions, state->method);
dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
+
+ function_initvars(state->method, 1, params, 0, 1);
}
if(as3_pass == 2) {
state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
+ state->method->variable_count = 0;
parserassert(state->method);
state->method->info->return_type = return_type;
- function_initvars(params, 0);
+ function_initvars(state->method, 1, params, 0, 1);
}
}
-static void startfunction(token_t*ns, int flags, enum yytokentype getset, char*name,
+static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,
params_t*params, classinfo_t*return_type)
{
if(state->method && state->method->info) {
syntaxerror("not able to start another method scope");
}
new_state();
-
+ state->new_vars = 1;
+ state->allvars = dict_new();
+
if(as3_pass == 1) {
state->method = rfx_calloc(sizeof(methodstate_t));
state->method->has_super = 0;
- state->method->variable_count = 0;
+ state->method->is_static = mod->flags&FLAG_STATIC;
if(state->cls) {
state->method->is_constructor = !strcmp(state->cls->info->name,name);
@@ -1089,99 +1423,188 @@ static void startfunction(token_t*ns, int flags, enum yytokentype getset, char*n
if(state->method->is_constructor)
name = "__as3_constructor__";
- return_type = 0;
- state->method->info = registerfunction(getset, flags, name, params, return_type, 0);
+ state->method->info = registerfunction(getset, mod, name, params, return_type, 0);
+
+ function_initvars(state->method, 1, params, mod->flags, 1);
dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
}
if(as3_pass == 2) {
state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
+ state->method->variable_count = 0;
parserassert(state->method);
+
+ if(state->cls) {
+ memberinfo_t*m = registry_findmember(state->cls->info, mod->ns, name, 2);
+ check_override(m, mod->flags);
+ }
if(state->cls) {
state->cls->has_constructor |= state->method->is_constructor;
}
- state->method->info->return_type = return_type;
- function_initvars(params, flags);
+ function_initvars(state->method, 1, params, mod->flags, 1);
}
}
-static abc_method_t* endfunction(token_t*ns, int flags, enum yytokentype getset, char*name,
+static void insert_unresolved(methodstate_t*m, dict_t*xvars, dict_t*allvars)
+{
+ parserassert(m->inner);
+ if(m->unresolved_variables) {
+ dict_t*d = m->unresolved_variables;
+ int t;
+ DICT_ITERATE_KEY(d, char*, id) {
+ /* check parent method's variables */
+ variable_t*v;
+ if(dict_contains(allvars, id)) {
+ m->uses_parent_function = 1;
+ state->method->uses_slots = 1;
+ dict_put(xvars, id, 0);
+ }
+ }
+ }
+ methodstate_list_t*ml = m->innerfunctions;
+ while(ml) {
+ insert_unresolved(ml->methodstate, xvars, allvars);
+ ml = ml->next;
+ }
+}
+
+static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*name,
params_t*params, classinfo_t*return_type, code_t*body)
{
if(as3_pass==1) {
+ dict_t*xvars = dict_new();
+
+ if(state->method->unresolved_variables) {
+ DICT_ITERATE_KEY(state->method->unresolved_variables, char*, vname) {
+ if(!state->method->no_variable_scoping && dict_contains(state->allvars, vname)) {
+ variable_t*v = dict_lookup(state->allvars, vname);
+ if(!v->is_inner_method) {
+ state->method->no_variable_scoping = 1;
+ as3_warning("function %s uses forward or outer block variable references (%s): switching into compatiblity mode", name, vname);
+ }
+ }
+ }
+ }
+
+ methodstate_list_t*ml = state->method->innerfunctions;
+ while(ml) {
+ insert_unresolved(ml->methodstate, xvars, state->allvars);
+ ml = ml->next;
+ }
+
+ if(state->method->uses_slots) {
+ state->method->slots = dict_new();
+ int i = 1;
+ DICT_ITERATE_ITEMS(state->allvars, char*, name, variable_t*, v) {
+ if(!name) syntaxerror("internal error");
+ if(v->index && dict_contains(xvars, name)) {
+ v->init = v->kill = 0;
+ v->index = i;
+ if(v->is_inner_method) {
+ v->is_inner_method->is_a_slot = i;
+ }
+ i++;
+ dict_put(state->method->slots, name, v);
+ }
+ }
+ state->method->uses_slots = i;
+ dict_destroy(state->vars);state->vars = 0;
+ parserassert(state->new_vars);
+ dict_destroy(state->allvars);state->allvars = 0;
+ }
old_state();
return 0;
}
- abc_method_t*f = 0;
+ if(as3_pass==2) {
+ /*if(state->method->uses_parent_function){
+ syntaxerror("accessing variables of parent function from inner functions not supported yet");
+ }*/
- multiname_t*type2 = sig2mname(return_type);
- int slot = 0;
- if(state->method->inner) {
- f = state->method->abc;
- abc_method_init(f, global->file, type2, 1);
- } else if(state->method->is_constructor) {
- f = abc_class_getconstructor(state->cls->abc, type2);
- } else if(!state->method->is_global) {
- namespace_t mname_ns = flags2namespace(flags, "");
- multiname_t mname = {QNAME, &mname_ns, 0, name};
+ abc_method_t*f = 0;
- if(flags&FLAG_STATIC)
- f = abc_class_staticmethod(state->cls->abc, type2, &mname);
- else
- f = abc_class_method(state->cls->abc, type2, &mname);
- slot = f->trait->slot_id;
- } else {
- namespace_t mname_ns = flags2namespace(flags, state->package);
- multiname_t mname = {QNAME, &mname_ns, 0, name};
-
- f = abc_method_new(global->file, type2, 1);
- trait_t*t = trait_new_method(&global->init->traits, multiname_clone(&mname), f);
- //abc_code_t*c = global->init->method->body->code;
- }
- //flash doesn't seem to allow us to access function slots
- //state->method->info->slot = slot;
-
- if(flags&FLAG_OVERRIDE) f->trait->attributes |= TRAIT_ATTR_OVERRIDE;
- if(getset == KW_GET) f->trait->kind = TRAIT_GETTER;
- if(getset == KW_SET) f->trait->kind = TRAIT_SETTER;
- if(params->varargs) f->flags |= METHOD_NEED_REST;
-
- char opt=0;
- param_list_t*p=0;
- for(p=params->list;p;p=p->next) {
- if(params->varargs && !p->next) {
- break; //varargs: omit last parameter in function signature
+ multiname_t*type2 = sig2mname(return_type);
+ int slot = 0;
+ if(state->method->inner) {
+ f = state->method->abc;
+ abc_method_init(f, global->file, type2, 1);
+ } else if(state->method->is_constructor) {
+ f = abc_class_getconstructor(state->cls->abc, type2);
+ } else if(!state->method->is_global) {
+ namespace_t ns = modifiers2access(mod);
+ multiname_t mname = {QNAME, &ns, 0, name};
+ if(mod->flags&FLAG_STATIC)
+ f = abc_class_staticmethod(state->cls->abc, type2, &mname);
+ else
+ f = abc_class_method(state->cls->abc, type2, &mname);
+ slot = f->trait->slot_id;
+ } else {
+ namespace_t mname_ns = {state->method->info->access, state->package};
+ multiname_t mname = {QNAME, &mname_ns, 0, name};
+
+ f = abc_method_new(global->file, type2, 1);
+ if(!global->init) global->init = abc_initscript(global->file);
+ trait_t*t = trait_new_method(&global->init->traits, multiname_clone(&mname), f);
+ //abc_code_t*c = global->init->method->body->code;
}
- multiname_t*m = sig2mname(p->param->type);
- list_append(f->parameters, m);
- if(p->param->value) {
- check_constant_against_type(p->param->type, p->param->value);
- opt=1;list_append(f->optional_parameters, p->param->value);
- } else if(opt) {
- syntaxerror("non-optional parameter not allowed after optional parameters");
+ //flash doesn't seem to allow us to access function slots
+ //state->method->info->slot = slot;
+
+ if(mod && mod->flags&FLAG_OVERRIDE) f->trait->attributes |= TRAIT_ATTR_OVERRIDE;
+ if(getset == KW_GET) f->trait->kind = TRAIT_GETTER;
+ if(getset == KW_SET) f->trait->kind = TRAIT_SETTER;
+ if(params->varargs) f->flags |= METHOD_NEED_REST;
+ if(state->method->need_arguments) f->flags |= METHOD_NEED_ARGUMENTS;
+
+ char opt=0;
+ param_list_t*p=0;
+ for(p=params->list;p;p=p->next) {
+ if(params->varargs && !p->next) {
+ break; //varargs: omit last parameter in function signature
+ }
+ multiname_t*m = sig2mname(p->param->type);
+ list_append(f->parameters, m);
+ if(p->param->value) {
+ check_constant_against_type(p->param->type, p->param->value);
+ opt=1;list_append(f->optional_parameters, p->param->value);
+ } else if(opt) {
+ syntaxerror("function %s: non-optional parameter not allowed after optional parameters", name);
+ }
+ }
+ if(state->method->slots) {
+ DICT_ITERATE_ITEMS(state->method->slots, char*, name, variable_t*, v) {
+ if(v->index) {
+ multiname_t*mname = multiname_new(namespace_new(ACCESS_PACKAGE, ""), name);
+ multiname_t*type = sig2mname(v->type);
+ trait_t*t = trait_new_member(&f->body->traits, type, mname, 0);
+ t->slot_id = v->index;
+ }
+ }
}
- }
- check_code_for_break(body);
- if(f->body) {
- f->body->code = body;
- f->body->exceptions = state->method->exceptions;
- } else { //interface
- if(body)
- syntaxerror("interface methods can't have a method body");
- }
-
- old_state();
- return f;
-}
+ check_code_for_break(body);
-char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
-{
- return 1; // FIXME
+ /* Seems this works now.
+ if(state->method->exceptions && state->method->uses_slots) {
+ as3_warning("try/catch and activation not supported yet within the same method");
+ }*/
+
+ if(f->body) {
+ f->body->code = body;
+ f->body->exceptions = state->method->exceptions;
+ } else { //interface
+ if(body)
+ syntaxerror("interface methods can't have a method body");
+ }
+
+ old_state();
+ return f;
+ }
+
+ return 0;
}
void breakjumpsto(code_t*c, char*name, code_t*jump)
@@ -1211,29 +1634,6 @@ void continuejumpsto(code_t*c, char*name, code_t*jump)
}
}
-#define IS_INT(a) (TYPE_IS_INT((a)) || TYPE_IS_UINT((a)))
-#define IS_NUMBER_OR_INT(a) (TYPE_IS_INT((a)) || TYPE_IS_UINT((a)) || TYPE_IS_NUMBER((a)))
-#define BOTH_INT(a,b) (IS_INT(a) && IS_INT(b))
-
-classinfo_t*join_types(classinfo_t*type1, classinfo_t*type2, char op)
-{
- if(!type1 || !type2)
- return registry_getanytype();
- if(TYPE_IS_ANY(type1) || TYPE_IS_ANY(type2))
- return registry_getanytype();
-
- if(op=='+') {
- if(IS_NUMBER_OR_INT(type1) && IS_NUMBER_OR_INT(type2)) {
- return TYPE_NUMBER;
- } else {
- return TYPE_ANY;
- }
- }
-
- if(type1 == type2)
- return type1;
- return registry_getanytype();
-}
code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
{
if(from==to)
@@ -1251,15 +1651,35 @@ code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
if((TYPE_IS_NUMBER(from) || TYPE_IS_UINT(from) || TYPE_IS_INT(from)) &&
(TYPE_IS_NUMBER(to) || TYPE_IS_UINT(to) || TYPE_IS_INT(to))) {
// allow conversion between number types
+ if(TYPE_IS_UINT(to))
+ return abc_convert_u(c);
+ else if(TYPE_IS_INT(to))
+ return abc_convert_i(c);
+ else if(TYPE_IS_NUMBER(to))
+ return abc_convert_d(c);
return abc_coerce2(c, &m);
}
- //printf("%s.%s\n", from.package, from.name);
- //printf("%s.%s\n", to.package, to.name);
+
+ if(TYPE_IS_XMLLIST(to) && TYPE_IS_XML(from))
+ return c;
+
+ if(TYPE_IS_BOOLEAN(to))
+ return abc_convert_b(c);
+ if(TYPE_IS_STRING(to))
+ return abc_convert_s(c);
+ if(TYPE_IS_OBJECT(to))
+ return abc_coerce2(c, &m);
+ if(TYPE_IS_OBJECT(from) && TYPE_IS_XMLLIST(to))
+ return abc_coerce2(c, &m);
+ if(TYPE_IS_OBJECT(from) && TYPE_IS_ARRAY(to))
+ return abc_coerce2(c, &m);
classinfo_t*supertype = from;
while(supertype) {
if(supertype == to) {
- // target type is one of from's superclasses
+ /* target type is one of from's superclasses.
+ (not sure we need this coerce - as far as the verifier
+ is concerned, object==object (i think) */
return abc_coerce2(c, &m);
}
int t=0;
@@ -1276,28 +1696,25 @@ code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
return c;
if(TYPE_IS_CLASS(from) && TYPE_IS_CLASS(to))
return c;
- syntaxerror("can't convert type %s to %s", from->name, to->name);
- return 0; // make gcc happy
-}
+ if(TYPE_IS_NULL(from) && !IS_NUMBER_OR_INT(to))
+ return c;
+
+ as3_error("can't convert type %s%s%s to %s%s%s",
+ from->package, from->package[0]?".":"", from->name,
+ to->package, to->package[0]?".":"", to->name);
-code_t*defaultvalue(code_t*c, classinfo_t*type)
+ return c;
+}
+code_t* coerce_to_type(code_t*c, classinfo_t*t)
{
- if(TYPE_IS_INT(type)) {
- c = abc_pushbyte(c, 0);
- } else if(TYPE_IS_UINT(type)) {
- c = abc_pushuint(c, 0);
- } else if(TYPE_IS_FLOAT(type)) {
- c = abc_pushnan(c);
- } else if(TYPE_IS_BOOLEAN(type)) {
- c = abc_pushfalse(c);
- } else if(!type) {
- //c = abc_pushundefined(c);
+ if(!t) {
+ return abc_coerce_a(c);
+ } else if(TYPE_IS_STRING(t)) {
+ return abc_coerce_s(c);
} else {
- c = abc_pushnull(c);
- MULTINAME(m, type);
- c = abc_coerce2(c, &m);
+ MULTINAME(m, t);
+ return abc_coerce2(c, &m);
}
- return c;
}
char is_pushundefined(code_t*c)
@@ -1305,11 +1722,41 @@ char is_pushundefined(code_t*c)
return (c && !c->prev && !c->next && c->opcode == OPCODE_PUSHUNDEFINED);
}
-static classinfo_t* find_class(char*name)
+static const char* get_package_from_name(const char*name)
+{
+ /* try explicit imports */
+ dictentry_t* e = dict_get_slot(state->imports, name);
+ while(e) {
+ if(!strcmp(e->key, name)) {
+ slotinfo_t*c = (slotinfo_t*)e->data;
+ if(c) return c->package;
+ }
+ e = e->next;
+ }
+ return 0;
+}
+static namespace_list_t*get_current_imports()
+{
+ namespace_list_t*searchlist = 0;
+
+ list_append(searchlist, namespace_new_package(state->package));
+
+ import_list_t*l = state->wildcard_imports;
+ while(l) {
+ namespace_t*ns = namespace_new_package(l->import->package);
+ list_append(searchlist, ns);
+ l = l->next;
+ }
+ list_append(searchlist, namespace_new_package(""));
+ list_append(searchlist, namespace_new_package(internal_filename_package));
+ return searchlist;
+}
+
+static slotinfo_t* find_class(const char*name)
{
- classinfo_t*c=0;
+ slotinfo_t*c=0;
- c = registry_findclass(state->package, name);
+ c = registry_find(state->package, name);
if(c) return c;
/* try explicit imports */
@@ -1317,7 +1764,7 @@ static classinfo_t* find_class(char*name)
if(c) return c;
while(e) {
if(!strcmp(e->key, name)) {
- c = (classinfo_t*)e->data;
+ c = (slotinfo_t*)e->data;
if(c) return c;
}
e = e->next;
@@ -1327,188 +1774,68 @@ static classinfo_t* find_class(char*name)
import_list_t*l = state->wildcard_imports;
while(l) {
//printf("does package %s contain a class %s?\n", l->import->package, name);
- c = registry_findclass(l->import->package, name);
+ c = registry_find(l->import->package, name);
if(c) return c;
l = l->next;
}
/* try global package */
- c = registry_findclass("", name);
+ c = registry_find("", name);
if(c) return c;
-
+
/* try local "filename" package */
- c = registry_findclass(current_filename_short, name);
+ c = registry_find(internal_filename_package, name);
if(c) return c;
return 0;
}
-
-static char is_getlocal(code_t*c)
-{
- if(!c || c->prev || c->next)
- return 0;
- return(c->opcode == OPCODE_GETLOCAL
- || c->opcode == OPCODE_GETLOCAL_0
- || c->opcode == OPCODE_GETLOCAL_1
- || c->opcode == OPCODE_GETLOCAL_2
- || c->opcode == OPCODE_GETLOCAL_3);
-}
-static int getlocalnr(code_t*c)
-{
- if(c->opcode == OPCODE_GETLOCAL) {return (ptroff_t)c->data[0];}
- else if(c->opcode == OPCODE_GETLOCAL_0) {return 0;}
- else if(c->opcode == OPCODE_GETLOCAL_1) {return 1;}
- else if(c->opcode == OPCODE_GETLOCAL_2) {return 2;}
- else if(c->opcode == OPCODE_GETLOCAL_3) {return 3;}
- else syntaxerror("Internal error: opcode %02x is not a getlocal call", c->opcode);
- return 0;
-}
-
-static code_t* toreadwrite(code_t*in, code_t*middlepart, char justassign, char readbefore)
+typedcode_t push_class(slotinfo_t*a)
{
- /* converts this:
-
- [prefix code] [read instruction]
-
- to this:
-
- [prefix code] ([dup]) [read instruction] [middlepart] [setvar] [write instruction] [getvar]
- */
-
- if(in && in->opcode == OPCODE_COERCE_A) {
- in = code_cutlast(in);
- }
- if(in->next)
- syntaxerror("internal error");
-
- /* chop off read instruction */
- code_t*prefix = in;
- code_t*r = in;
- if(r->prev) {
- prefix = r->prev;r->prev = 0;
- prefix->next=0;
- } else {
- prefix = 0;
- }
-
- char use_temp_var = readbefore;
-
- /* generate the write instruction, and maybe append a dup to the prefix code */
- code_t* write = abc_nop(0);
- if(r->opcode == OPCODE_GETPROPERTY) {
- write->opcode = OPCODE_SETPROPERTY;
- multiname_t*m = (multiname_t*)r->data[0];
- write->data[0] = multiname_clone(m);
- if(m->type == QNAME || m->type == MULTINAME) {
- if(!justassign) {
- prefix = abc_dup(prefix); // we need the object, too
- }
- use_temp_var = 1;
- } else if(m->type == MULTINAMEL) {
- if(!justassign) {
- /* dupping two values on the stack requires 5 operations and one register-
- couldn't adobe just have given us a dup2? */
- int temp = gettempvar();
- prefix = abc_setlocal(prefix, temp);
- prefix = abc_dup(prefix);
- prefix = abc_getlocal(prefix, temp);
- prefix = abc_swap(prefix);
- prefix = abc_getlocal(prefix, temp);
- if(!use_temp_var);
- prefix = abc_kill(prefix, temp);
- }
- use_temp_var = 1;
+ typedcode_t x;
+ x.c = 0;
+ x.t = 0;
+ if(a->access == ACCESS_PACKAGEINTERNAL &&
+ strcmp(a->package, state->package) &&
+ strcmp(a->package, internal_filename_package)
+ ) {
+ syntaxerror("Can't access internal %s %s in package '%s' from package '%s'",
+ infotypename(a), a->name, a->package, state->package);
+ }
+
+
+ if(a->kind != INFOTYPE_CLASS) {
+ MULTINAME(m, a);
+ x.c = abc_findpropstrict2(x.c, &m);
+ x.c = abc_getproperty2(x.c, &m);
+ if(a->kind == INFOTYPE_METHOD) {
+ methodinfo_t*f = (methodinfo_t*)a;
+ x.t = TYPE_FUNCTION(f);
} else {
- syntaxerror("illegal lvalue: can't assign a value to this expression (not a qname/multiname)");
+ varinfo_t*v = (varinfo_t*)a;
+ x.t = v->type;
}
- } else if(r->opcode == OPCODE_GETSLOT) {
- write->opcode = OPCODE_SETSLOT;
- write->data[0] = r->data[0];
- if(!justassign) {
- prefix = abc_dup(prefix); // we need the object, too
- }
- use_temp_var = 1;
- } else if(r->opcode == OPCODE_GETLOCAL) {
- write->opcode = OPCODE_SETLOCAL;
- write->data[0] = r->data[0];
- } else if(r->opcode == OPCODE_GETLOCAL_0) {
- write->opcode = OPCODE_SETLOCAL_0;
- } else if(r->opcode == OPCODE_GETLOCAL_1) {
- write->opcode = OPCODE_SETLOCAL_1;
- } else if(r->opcode == OPCODE_GETLOCAL_2) {
- write->opcode = OPCODE_SETLOCAL_2;
- } else if(r->opcode == OPCODE_GETLOCAL_3) {
- write->opcode = OPCODE_SETLOCAL_3;
+ return x;
} else {
- code_dump(r);
- syntaxerror("illegal lvalue: can't assign a value to this expression");
- }
- code_t* c = 0;
-
- int temp = -1;
- if(!justassign) {
- if(use_temp_var) {
- /* with getproperty/getslot, we have to be extra careful not
- to execute the read code twice, as it might have side-effects
- (e.g. if the property is in fact a setter/getter combination)
-
- So read the value, modify it, and write it again,
- using prefix only once and making sure (by using a temporary
- register) that the return value is what we just wrote */
- temp = gettempvar();
- c = code_append(c, prefix);
- c = code_append(c, r);
- if(readbefore) {
- c = abc_dup(c);
- c = abc_setlocal(c, temp);
- }
- c = code_append(c, middlepart);
- if(!readbefore) {
- c = abc_dup(c);
- c = abc_setlocal(c, temp);
- }
- c = code_append(c, write);
- c = abc_getlocal(c, temp);
- c = abc_kill(c, temp);
- } else {
- /* if we're allowed to execute the read code twice *and*
- the middlepart doesn't modify the code, things are easier.
- */
- code_t* r2 = code_dup(r);
- //c = code_append(c, prefix);
- parserassert(!prefix);
- c = code_append(c, r);
- c = code_append(c, middlepart);
- c = code_append(c, write);
- c = code_append(c, r2);
+ if(state->cls && state->method == state->cls->static_init) {
+ /* we're in the static initializer.
+ record the fact that we're using this class here */
+ parsedclass_add_dependency(state->cls->dependencies, (classinfo_t*)a);
}
- } else {
- /* even smaller version: overwrite the value without reading
- it out first */
- if(!use_temp_var) {
- if(prefix) {
- c = code_append(c, prefix);
- c = abc_dup(c);
- }
- c = code_append(c, middlepart);
- c = code_append(c, write);
- c = code_append(c, r);
+ classinfo_t*c = (classinfo_t*)a;
+ //if(c->slot) {
+ if(0) { //Error #1026: Slot 1 exceeds slotCount=0 of global
+ x.c = abc_getglobalscope(x.c);
+ x.c = abc_getslot(x.c, c->slot);
} else {
- temp = gettempvar();
- if(prefix) {
- c = code_append(c, prefix);
- }
- c = code_append(c, middlepart);
- c = abc_dup(c);
- c = abc_setlocal(c, temp);
- c = code_append(c, write);
- c = abc_getlocal(c, temp);
- c = abc_kill(c, temp);
+ MULTINAME(m, c);
+ x.c = abc_getlex2(x.c, &m);
}
+ x.t = TYPE_CLASS(c);
}
- return c;
+ return x;
}
+
char is_break_or_jump(code_t*c)
{
if(!c)
@@ -1524,7 +1851,6 @@ char is_break_or_jump(code_t*c)
return 0;
}
-
#define IS_FINALLY_TARGET(op) \
((op) == OPCODE___CONTINUE__ || \
(op) == OPCODE___BREAK__ || \
@@ -1632,10 +1958,10 @@ code_t* insert_finally(code_t*c, code_t*finally, int tempvar)
int lookup_version_cost = 4*num_insertion_points + 5;
if(cantdup || simple_version_cost > lookup_version_cost) {
- printf("lookup %d > *%d*\n", simple_version_cost, lookup_version_cost);
+ //printf("(use lookup) simple=%d > lookup=%d\n", simple_version_cost, lookup_version_cost);
return insert_finally_lookup(c, finally, tempvar);
} else {
- printf("simple *%d* < %d\n", simple_version_cost, lookup_version_cost);
+ //printf("(use simple) simple=%d < lookup=%d\n", simple_version_cost, lookup_version_cost);
return insert_finally_simple(c, finally, tempvar);
}
}
@@ -1643,48 +1969,282 @@ code_t* insert_finally(code_t*c, code_t*finally, int tempvar)
#define PASS1 }} if(as3_pass == 1) {{
#define PASS1END }} if(as3_pass == 2) {{
#define PASS2 }} if(as3_pass == 2) {{
-#define PASS12 }} {{
+#define PASS12 }} if(as3_pass == 1 || as3_pass == 2) {{
#define PASS12END }} if(as3_pass == 2) {{
-
+#define PASS_ALWAYS }} {{
/* Line 273 of skeleton.m4 */
-#line 1653 "parser.tab.c"
+#line 1979 "parser.tab.c"
+/* Unqualified %code blocks. */
+/* Line 274 of skeleton.m4 */
+#line 2077 "parser.y"
-#ifdef short
-# undef short
-#endif
+ char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
+ {
+ return 1; // FIXME
+ }
+ char do_init_variable(char*name)
+ {
+ if(!state->method->no_variable_scoping)
+ return 0;
+ if(!state->new_vars)
+ return 1;
+ return 1;
+ }
-#ifdef YYTYPE_UINT8
-typedef YYTYPE_UINT8 yytype_uint8;
-#else
-typedef unsigned char yytype_uint8;
-#endif
+/* Line 274 of skeleton.m4 */
+#line 2528 "parser.y"
-#ifdef YYTYPE_INT8
-typedef YYTYPE_INT8 yytype_int8;
-#elif (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
-typedef signed char yytype_int8;
-#else
-typedef short int yytype_int8;
-#endif
+ static void state_has_imports()
+ {
+ state->wildcard_imports = list_clone(state->wildcard_imports);
+ state->imports = dict_clone(state->imports);
+ state->has_own_imports = 1;
+ }
+ static void import_toplevel(const char*package)
+ {
+ char* s = strdup(package);
+ while(1) {
+ dict_put(state->import_toplevel_packages, s, 0);
+ char*x = strrchr(s, '.');
+ if(!x)
+ break;
+ *x = 0;
+ }
+ free(s);
+ }
-#ifdef YYTYPE_UINT16
-typedef YYTYPE_UINT16 yytype_uint16;
-#else
-typedef unsigned short int yytype_uint16;
-#endif
+/* Line 274 of skeleton.m4 */
+#line 2667 "parser.y"
-#ifdef YYTYPE_INT16
-typedef YYTYPE_INT16 yytype_int16;
-#else
-typedef short int yytype_int16;
-#endif
+ static int slotstate_varconst = 0;
+ static modifiers_t*slotstate_flags = 0;
+ static void setslotstate(modifiers_t* flags, int varconst)
+ {
+ slotstate_varconst = varconst;
+ slotstate_flags = flags;
+ if(state->cls) {
+ if(flags) {
+ if(flags->flags&FLAG_STATIC) {
+ state->method = state->cls->static_init;
+ } else {
+ state->method = state->cls->init;
+ }
+ } else {
+ // reset to "default" state (all in class code is static by default) */
+ state->method = state->cls->static_init;
+ }
+ } else {
+ parserassert(state->method);
+ }
+ }
+ static trait_t* add_abc_slot(modifiers_t* modifiers, const char*name, multiname_t*m, code_t***c)
+ {
+ int flags = modifiers->flags;
+ namespace_t ns = modifiers2access(modifiers);
+
+ /* slot name */
+ multiname_t mname = {QNAME, &ns, 0, name};
+
+ trait_list_t**traits;
+ code_t**code=0;
+ if(!state->cls) {
+ // global variable
+ if(!global->init) global->init = abc_initscript(global->file);
+ ns.name = state->package;
+ traits = &global->init->traits;
+ code = &global->init->method->body->code;
+ } else if(flags&FLAG_STATIC) {
+ // static variable
+ traits = &state->cls->abc->static_traits;
+ code = &state->cls->static_init->header;
+ } else {
+ // instance variable
+ traits = &state->cls->abc->traits;
+ code = &state->cls->init->header;
+
+ if(ns.access == ACCESS_PROTECTED) {
+ ns.name = concat3(state->cls->info->package,":",state->cls->info->name);
+ }
+ }
+ if(c)
+ *c = code;
+ if(m)
+ *m = *multiname_clone(&mname);
+
+ return trait_new_member(traits, 0, multiname_clone(&mname), 0);
+ }
-#ifndef YYSIZE_T
-# ifdef __SIZE_TYPE__
-# define YYSIZE_T __SIZE_TYPE__
+/* Line 274 of skeleton.m4 */
+#line 2847 "parser.y"
+
+ static int xml_level = 0;
+
+/* Line 274 of skeleton.m4 */
+#line 3655 "parser.y"
+
+ node_t* resolve_identifier(char*name)
+ {
+ typedcode_t o;
+ o.t = 0;
+ o.c = 0;
+
+ slotinfo_t*a = 0;
+ memberinfo_t*f = 0;
+
+ variable_t*v;
+ /* look at variables */
+ if((v = find_variable(state, name))) {
+ // name is a local variable
+ o.c = abc_getlocal(o.c, v->index);
+ o.t = v->type;
+ return mkcodenode(o);
+ }
+ if((v = find_slot(state->method, name))) {
+ o.c = abc_getscopeobject(o.c, 1);
+ o.c = abc_getslot(o.c, v->index);
+ o.t = v->type;
+ return mkcodenode(o);
+ }
+
+ int i_am_static = state->method->is_static;
+
+ /* look at current class' members */
+ if(!state->method->inner &&
+ !state->xmlfilter &&
+ state->cls &&
+ (f = findmember_nsset(state->cls->info, name, 1)))
+ {
+ // name is a member or attribute in this class
+ int var_is_static = (f->flags&FLAG_STATIC);
+
+ if(f->kind == INFOTYPE_VAR && (f->flags&FLAG_CONST)) {
+ /* if the variable is a constant (and we know what is evaluates to), we
+ can just use the value itself */
+ varinfo_t*v = (varinfo_t*)f;
+ if(v->value) {
+ return mkconstnode(v->value);
+ }
+ }
+
+ if(var_is_static >= i_am_static) {
+ if(f->kind == INFOTYPE_METHOD) {
+ o.t = TYPE_FUNCTION(f);
+ } else {
+ o.t = f->type;
+ }
+
+ if(var_is_static && !i_am_static) {
+ /* access to a static member from a non-static location.
+ do this via findpropstrict:
+ there doesn't seem to be any non-lookup way to access
+ static properties of a class */
+ state->method->late_binding = 1;
+ o.t = f->type;
+ namespace_t ns = {f->access, f->package};
+ multiname_t m = {QNAME, &ns, 0, name};
+ o.c = abc_findpropstrict2(o.c, &m);
+ o.c = abc_getproperty2(o.c, &m);
+ return mkcodenode(o);
+ } else if(f->slot>0) {
+ o.c = abc_getlocal_0(o.c);
+ o.c = abc_getslot(o.c, f->slot);
+ return mkcodenode(o);
+ } else {
+ MEMBER_MULTINAME(m, f, name);
+ o.c = abc_getlocal_0(o.c);
+ o.c = abc_getproperty2(o.c, &m);
+ return mkcodenode(o);
+ }
+ }
+ }
+
+ /* look at actual classes, in the current package and imported */
+ if(!state->xmlfilter && (a = find_class(name))) {
+ if(state->cls && state->cls->info == (classinfo_t*)a && i_am_static) {
+ o.c = abc_getlocal_0(0);
+ o.t = TYPE_CLASS((classinfo_t*)a);
+ } else {
+ o = push_class(a);
+ }
+ return mkcodenode(o);
+ }
+
+ /* look through package prefixes */
+ if(!state->xmlfilter &&
+ (dict_contains(state->import_toplevel_packages, name) ||
+ registry_ispackage(name))) {
+ o.c = abc___pushpackage__(o.c, name);
+ o.t = 0;
+ return mkcodenode(o); //?
+ }
+
+ /* unknown object, let the avm2 resolve it */
+ if(1) {
+ if(!state->method->inner && !state->xmlfilter) {
+ /* we really should make inner functions aware of the class context */
+ as3_warning("Couldn't resolve '%s', doing late binding", name);
+ }
+ state->method->late_binding = 1;
+
+ multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, name};
+
+ o.t = 0;
+ o.c = abc_findpropstrict2(o.c, &m);
+ o.c = abc_getproperty2(o.c, &m);
+ return mkcodenode(o);
+ }
+ }
+
+/* Line 274 of skeleton.m4 */
+#line 3795 "parser.y"
+
+ void add_active_url(const char*url)
+ {
+ NEW(namespace_t,n);
+ n->name = url;
+ list_append(state->active_namespace_urls, n);
+ }
+
+
+/* Line 274 of skeleton.m4 */
+#line 2213 "parser.tab.c"
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#elif (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+typedef signed char yytype_int8;
+#else
+typedef short int yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+# define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
# define YYSIZE_T size_t
# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
@@ -1862,22 +2422,22 @@ union yyalloc
#endif
/* YYFINAL -- State number of the termination state. */
-#define YYFINAL 118
+#define YYFINAL 164
/* YYLAST -- Last index in YYTABLE. */
-#define YYLAST 2669
+#define YYLAST 3411
/* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS 131
+#define YYNTOKENS 136
/* YYNNTS -- Number of nonterminals. */
-#define YYNNTS 107
+#define YYNNTS 135
/* YYNRULES -- Number of rules. */
-#define YYNRULES 287
+#define YYNRULES 354
/* YYNRULES -- Number of states. */
-#define YYNSTATES 479
+#define YYNSTATES 601
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
#define YYUNDEFTOK 2
-#define YYMAXUTOK 361
+#define YYMAXUTOK 365
#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -1888,16 +2448,16 @@ static const yytype_uint8 yytranslate[] =
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 116, 2, 2, 2, 114, 106, 2,
- 120, 130, 113, 111, 97, 110, 125, 112, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 103, 96,
- 107, 99, 108, 102, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 120, 2, 2, 2, 118, 109, 2,
+ 124, 135, 117, 115, 102, 114, 129, 116, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 106, 101,
+ 111, 104, 112, 105, 130, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 122, 2, 123, 105, 2, 2, 2, 2, 2,
+ 2, 126, 2, 127, 108, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 124, 104, 129, 115, 2, 2, 2,
+ 2, 2, 2, 128, 107, 134, 119, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
@@ -1920,168 +2480,63 @@ static const yytype_uint8 yytranslate[] =
65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
- 95, 98, 100, 101, 109, 117, 118, 119, 121, 126,
- 127, 128
+ 95, 96, 97, 98, 99, 100, 103, 110, 113, 121,
+ 122, 123, 125, 131, 132, 133
};
#if YYDEBUG
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
YYRHS. */
-static const yytype_uint16 yyprhs[] =
+static const int yyprhs[] =
{
- 0, 0, 3, 5, 6, 8, 10, 13, 15, 17,
- 19, 21, 23, 25, 27, 28, 30, 32, 35, 37,
- 39, 41, 43, 45, 47, 49, 50, 53, 55, 57,
- 59, 61, 63, 65, 67, 69, 71, 73, 75, 77,
- 79, 81, 83, 85, 87, 89, 91, 93, 97, 100,
- 103, 105, 107, 110, 111, 114, 117, 119, 123, 127,
- 128, 131, 132, 140, 141, 143, 145, 149, 151, 154,
- 158, 167, 174, 175, 182, 183, 191, 193, 196, 198,
- 201, 202, 204, 206, 209, 211, 214, 219, 223, 224,
- 233, 234, 244, 245, 251, 253, 256, 258, 261, 263,
- 264, 271, 274, 276, 282, 284, 286, 290, 292, 293,
- 300, 301, 307, 310, 315, 316, 318, 320, 323, 325,
- 327, 329, 331, 333, 335, 337, 339, 341, 342, 345,
- 346, 349, 350, 353, 354, 364, 365, 374, 375, 377,
- 379, 382, 384, 386, 388, 390, 391, 393, 395, 398,
- 400, 403, 412, 414, 416, 422, 423, 426, 428, 430,
- 432, 434, 436, 438, 440, 442, 443, 445, 448, 453,
- 457, 459, 464, 467, 469, 471, 472, 473, 486, 488,
- 489, 490, 501, 503, 507, 509, 511, 513, 517, 519,
- 521, 523, 526, 527, 528, 532, 533, 535, 537, 541,
- 542, 547, 552, 557, 560, 562, 565, 567, 569, 573,
- 575, 577, 579, 581, 583, 585, 587, 589, 591, 593,
- 595, 597, 599, 601, 603, 605, 607, 609, 613, 617,
- 621, 625, 629, 633, 637, 641, 645, 649, 652, 655,
- 659, 663, 667, 671, 675, 679, 683, 687, 691, 695,
- 699, 703, 707, 711, 715, 720, 723, 725, 729, 732,
- 737, 741, 742, 744, 748, 754, 758, 762, 766, 770,
- 774, 778, 782, 786, 790, 794, 798, 804, 807, 810,
- 813, 816, 820, 824, 826, 830, 836, 842
+ b4_prhs
};
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
-static const yytype_int16 yyrhs[] =
+static const int yyrhs[] =
{
- 132, 0, -1, 133, -1, -1, 134, -1, 135, -1,
- 134, 135, -1, 181, -1, 193, -1, 191, -1, 209,
- -1, 202, -1, 144, -1, 96, -1, -1, 137, -1,
- 138, -1, 137, 138, -1, 193, -1, 191, -1, 209,
- -1, 202, -1, 144, -1, 96, -1, 140, -1, -1,
- 140, 142, -1, 142, -1, 184, -1, 155, -1, 156,
- -1, 157, -1, 159, -1, 167, -1, 150, -1, 178,
- -1, 175, -1, 230, -1, 96, -1, 141, -1, 146,
- -1, 161, -1, 162, -1, 227, -1, 177, -1, 236,
- -1, 237, -1, 124, 140, 129, -1, 124, 129, -1,
- 142, 96, -1, 142, -1, 141, -1, 99, 228, -1,
- -1, 45, 147, -1, 31, 147, -1, 148, -1, 147,
- 97, 148, -1, 3, 219, 145, -1, -1, 64, 143,
- -1, -1, 63, 120, 151, 229, 130, 143, 149, -1,
- -1, 146, -1, 230, -1, 45, 3, 219, -1, 3,
- -1, 12, 120, -1, 12, 49, 120, -1, 154, 152,
- 96, 229, 96, 230, 130, 143, -1, 154, 153, 67,
- 229, 130, 143, -1, -1, 13, 120, 158, 229, 130,
- 143, -1, -1, 14, 160, 143, 13, 120, 229, 130,
- -1, 65, -1, 65, 3, -1, 29, -1, 29, 3,
- -1, -1, 164, -1, 166, -1, 164, 166, -1, 165,
- -1, 164, 165, -1, 33, 231, 103, 139, -1, 61,
- 103, 139, -1, -1, 15, 120, 168, 231, 130, 124,
- 163, 129, -1, -1, 32, 120, 3, 219, 130, 170,
- 124, 139, 129, -1, -1, 27, 124, 172, 139, 129,
- -1, 169, -1, 173, 169, -1, 173, -1, 173, 171,
- -1, 171, -1, -1, 51, 124, 176, 139, 129, 174,
- -1, 36, 229, -1, 36, -1, 38, 120, 229, 130,
- 143, -1, 3, -1, 18, -1, 180, 125, 179, -1,
- 179, -1, -1, 18, 180, 124, 182, 136, 129, -1,
- -1, 18, 124, 183, 136, 129, -1, 40, 216, -1,
- 40, 180, 125, 113, -1, -1, 186, -1, 187, -1,
- 186, 187, -1, 20, -1, 21, -1, 19, -1, 37,
- -1, 46, -1, 48, -1, 47, -1, 25, -1, 23,
- -1, -1, 53, 216, -1, -1, 53, 217, -1, -1,
- 16, 217, -1, -1, 185, 30, 3, 188, 190, 124,
- 192, 195, 129, -1, -1, 185, 43, 3, 189, 124,
- 194, 198, 129, -1, -1, 196, -1, 197, -1, 196,
- 197, -1, 96, -1, 202, -1, 209, -1, 141, -1,
- -1, 199, -1, 200, -1, 199, 200, -1, 96, -1,
- 45, 3, -1, 185, 26, 208, 3, 120, 205, 130,
- 219, -1, 45, -1, 31, -1, 185, 201, 3, 219,
- 145, -1, -1, 99, 204, -1, 9, -1, 7, -1,
- 8, -1, 11, -1, 4, -1, 55, -1, 54, -1,
- 44, -1, -1, 206, -1, 90, 207, -1, 206, 97,
- 90, 207, -1, 206, 97, 207, -1, 207, -1, 3,
- 103, 218, 203, -1, 3, 203, -1, 50, -1, 34,
- -1, -1, -1, 185, 26, 208, 3, 120, 205, 130,
- 219, 124, 210, 139, 129, -1, 3, -1, -1, -1,
- 26, 211, 120, 205, 130, 219, 124, 213, 139, 129,
- -1, 3, -1, 180, 125, 3, -1, 215, -1, 214,
- -1, 216, -1, 217, 97, 216, -1, 216, -1, 113,
- -1, 35, -1, 103, 218, -1, -1, -1, 120, 221,
- 130, -1, -1, 222, -1, 228, -1, 222, 97, 228,
- -1, -1, 24, 231, 223, 220, -1, 231, 120, 221,
- 130, -1, 52, 120, 221, 130, -1, 62, 231, -1,
- 41, -1, 41, 229, -1, 231, -1, 231, -1, 229,
- 97, 231, -1, 229, -1, 212, -1, 232, -1, 235,
- -1, 224, -1, 226, -1, 225, -1, 5, -1, 9,
- -1, 10, -1, 7, -1, 8, -1, 11, -1, 4,
- -1, 28, -1, 55, -1, 54, -1, 44, -1, 231,
- 107, 231, -1, 231, 108, 231, -1, 231, 73, 231,
- -1, 231, 74, 231, -1, 231, 69, 231, -1, 231,
- 70, 231, -1, 231, 72, 231, -1, 231, 71, 231,
- -1, 231, 84, 231, -1, 231, 85, 231, -1, 116,
- 231, -1, 115, 231, -1, 231, 106, 231, -1, 231,
- 105, 231, -1, 231, 104, 231, -1, 231, 93, 231,
- -1, 231, 92, 231, -1, 231, 91, 231, -1, 231,
- 112, 231, -1, 231, 114, 231, -1, 231, 111, 231,
- -1, 231, 110, 231, -1, 231, 113, 231, -1, 231,
- 67, 231, -1, 231, 68, 231, -1, 231, 39, 231,
- -1, 231, 66, 231, -1, 42, 120, 231, 130, -1,
- 35, 231, -1, 35, -1, 120, 229, 130, -1, 110,
- 231, -1, 231, 122, 231, 123, -1, 122, 221, 123,
- -1, -1, 234, -1, 228, 103, 228, -1, 234, 97,
- 228, 103, 228, -1, 124, 233, 129, -1, 231, 78,
- 231, -1, 231, 77, 231, -1, 231, 82, 231, -1,
- 231, 81, 231, -1, 231, 83, 231, -1, 231, 76,
- 231, -1, 231, 75, 231, -1, 231, 79, 231, -1,
- 231, 80, 231, -1, 231, 99, 231, -1, 231, 102,
- 231, 103, 231, -1, 231, 88, -1, 231, 87, -1,
- 88, 231, -1, 87, 231, -1, 52, 125, 3, -1,
- 231, 125, 3, -1, 3, -1, 185, 17, 3, -1,
- 185, 17, 3, 99, 3, -1, 185, 17, 3, 99,
- 4, -1, 22, 17, 3, -1
+ b4_rhs
};
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const yytype_uint16 yyrline[] =
{
- 0, 1629, 1629, 1631, 1631, 1632, 1633, 1635, 1636, 1637,
- 1638, 1639, 1640, 1641, 1643, 1643, 1644, 1645, 1647, 1648,
- 1649, 1650, 1651, 1652, 1654, 1655, 1657, 1658, 1661, 1662,
- 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1673, 1674,
- 1675, 1676, 1677, 1678, 1679, 1681, 1682, 1684, 1685, 1686,
- 1687, 1691, 1698, 1699, 1703, 1704, 1706, 1707, 1709, 1750,
- 1751, 1754, 1754, 1773, 1774, 1775, 1778, 1781, 1785, 1786,
- 1788, 1808, 1851, 1851, 1870, 1870, 1885, 1888, 1891, 1894,
- 1898, 1899, 1900, 1901, 1902, 1903, 1905, 1916, 1919, 1919,
- 1948, 1948, 1968, 1968, 1985, 1986, 1987, 1988, 1996, 2005,
- 2005, 2050, 2054, 2065, 2074, 2075, 2077, 2078, 2080, 2080,
- 2082, 2082, 2085, 2093, 2103, 2104, 2105, 2106, 2108, 2109,
- 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2118, 2119, 2121,
- 2122, 2124, 2125, 2129, 2127, 2135, 2133, 2141, 2142, 2143,
- 2144, 2145, 2146, 2147, 2149, 2155, 2156, 2157, 2158, 2159,
- 2160, 2163, 2175, 2175, 2177, 2236, 2237, 2239, 2240, 2241,
- 2242, 2243, 2245, 2246, 2247, 2252, 2256, 2262, 2268, 2276,
- 2281, 2287, 2295, 2303, 2304, 2305, 2308, 2307, 2321, 2322,
- 2324, 2323, 2344, 2352, 2360, 2361, 2363, 2364, 2366, 2367,
- 2368, 2377, 2378, 2382, 2383, 2385, 2386, 2387, 2390, 2395,
- 2396, 2432, 2478, 2499, 2520, 2523, 2530, 2531, 2532, 2538,
- 2544, 2546, 2548, 2550, 2552, 2554, 2556, 2573, 2578, 2581,
- 2584, 2587, 2590, 2593, 2596, 2599, 2602, 2606, 2609, 2612,
- 2615, 2618, 2621, 2624, 2627, 2631, 2642, 2660, 2665, 2670,
- 2675, 2680, 2685, 2689, 2693, 2698, 2702, 2706, 2715, 2724,
- 2734, 2739, 2751, 2757, 2762, 2768, 2774, 2778, 2780, 2791,
- 2800, 2807, 2808, 2810, 2816, 2825, 2832, 2844, 2850, 2856,
- 2862, 2868, 2874, 2880, 2893, 2904, 2911, 2924, 2951, 2965,
- 2979, 2993, 3008, 3042, 3139, 3140, 3141, 3143
+ 0, 1968, 1968, 1970, 1970, 1971, 1972, 1974, 1975, 1976,
+ 1977, 1978, 1979, 1980, 1981, 1983, 1983, 1984, 1985, 1987,
+ 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1999,
+ 2002, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013,
+ 2014, 2015, 2016, 2017, 2018, 2019, 2022, 2023, 2024, 2025,
+ 2026, 2027, 2028, 2029, 2041, 2042, 2046, 2057, 2065, 2092,
+ 2093, 2095, 2096, 2098, 2099, 2101, 2162, 2162, 2166, 2167,
+ 2170, 2186, 2187, 2188, 2193, 2197, 2202, 2203, 2205, 2225,
+ 2269, 2285, 2297, 2300, 2303, 2306, 2310, 2311, 2312, 2313,
+ 2314, 2315, 2317, 2328, 2331, 2331, 2362, 2362, 2387, 2387,
+ 2403, 2404, 2405, 2406, 2414, 2423, 2423, 2472, 2476, 2487,
+ 2497, 2514, 2515, 2516, 2517, 2518, 2520, 2521, 2523, 2523,
+ 2525, 2525, 2549, 2557, 2568, 2584, 2585, 2586, 2587, 2594,
+ 2595, 2596, 2597, 2598, 2599, 2600, 2601, 2602, 2603, 2607,
+ 2608, 2610, 2611, 2613, 2614, 2618, 2616, 2624, 2622, 2631,
+ 2632, 2633, 2634, 2635, 2636, 2637, 2638, 2640, 2646, 2647,
+ 2648, 2649, 2650, 2651, 2654, 2727, 2727, 2729, 2729, 2731,
+ 2732, 2734, 2818, 2819, 2828, 2829, 2832, 2833, 2834, 2835,
+ 2836, 2837, 2838, 2851, 2862, 2863, 2864, 2866, 2866, 2869,
+ 2869, 2872, 2873, 2876, 2881, 2884, 2887, 2890, 2893, 2897,
+ 2900, 2904, 2908, 2913, 2919, 2922, 2925, 2928, 2933, 2936,
+ 2939, 2949, 2953, 2959, 2965, 2973, 2978, 2984, 2992, 3000,
+ 3001, 3002, 3005, 3004, 3021, 3022, 3024, 3023, 3047, 3066,
+ 3080, 3081, 3083, 3084, 3086, 3087, 3088, 3097, 3098, 3102,
+ 3103, 3105, 3106, 3107, 3109, 3113, 3114, 3119, 3120, 3167,
+ 3217, 3238, 3260, 3263, 3270, 3273, 3276, 3279, 3282, 3285,
+ 3290, 3291, 3293, 3294, 3295, 3296, 3297, 3299, 3305, 3314,
+ 3315, 3316, 3317, 3318, 3319, 3321, 3325, 3330, 3348, 3359,
+ 3369, 3378, 3379, 3380, 3381, 3382, 3383, 3384, 3385, 3386,
+ 3387, 3388, 3389, 3390, 3391, 3392, 3393, 3394, 3395, 3396,
+ 3397, 3398, 3399, 3400, 3401, 3402, 3403, 3404, 3405, 3406,
+ 3407, 3408, 3409, 3410, 3411, 3412, 3413, 3414, 3415, 3416,
+ 3417, 3418, 3419, 3420, 3421, 3422, 3423, 3425, 3426, 3427,
+ 3428, 3430, 3445, 3453, 3453, 3507, 3508, 3509, 3510, 3511,
+ 3519, 3537, 3544, 3555, 3562, 3569, 3579, 3590, 3770, 3804,
+ 3811, 3818, 3825, 3847, 3853
};
#endif
@@ -2090,52 +2545,59 @@ static const yytype_uint16 yyrline[] =
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const yytname[] =
{
- "$end", "error", "$undefined", "T_IDENTIFIER", "T_STRING", "T_REGEXP",
- "T_EMPTY", "T_INT", "T_UINT", "T_BYTE", "T_SHORT", "T_FLOAT", "\"for\"",
- "\"while\"", "\"do\"", "\"switch\"", "\"implements\"", "\"namespace\"",
- "\"package\"", "\"protected\"", "\"public\"", "\"private\"", "\"use\"",
- "\"internal\"", "\"new\"", "\"native\"", "\"function\"", "\"finally\"",
- "\"undefined\"", "\"continue\"", "\"class\"", "\"const\"", "\"catch\"",
- "\"case\"", "\"set\"", "\"void\"", "\"throw\"", "\"static\"", "\"with\"",
+ "$end", "error", "$undefined", "T_IDENTIFIER", "T_NAMESPACE",
+ "T_STRING", "T_REGEXP", "T_EMPTY", "T_INT", "T_UINT", "T_FLOAT",
+ "\"for\"", "\"while\"", "\"do\"", "\"switch\"", "\"implements\"",
+ "\"namespace\"", "\"package\"", "\"protected\"", "\"arguments\"",
+ "\"public\"", "\"private\"", "\"use\"", "\"internal\"", "\"new\"",
+ "\"native\"", "\"function\"", "\"finally\"", "\"undefined\"", "\"NaN\"",
+ "\"continue\"", "\"class\"", "\"const\"", "\"catch\"", "\"case\"",
+ "\"set\"", "\"void\"", "\"throw\"", "\"static\"", "\"with\"",
"\"instanceof\"", "\"import\"", "\"return\"", "\"typeof\"",
"\"interface\"", "\"null\"", "\"var\"", "\"dynamic\"", "\"override\"",
"\"final\"", "\"each\"", "\"get\"", "\"try\"", "\"super\"",
"\"extends\"", "\"false\"", "\"true\"", "\"Boolean\"", "\"uint\"",
- "\"int\"", "\"Number\"", "\"String\"", "\"default\"", "\"delete\"",
- "\"if\"", "\"else\"", "\"break\"", "\"is\"", "\"in\"", "\"as\"",
- "\"==\"", "\"===\"", "\"!=\"", "\"!==\"", "\"<=\"", "\">=\"", "\"|=\"",
- "\"/=\"", "\"%=\"", "\"*=\"", "\"+=\"", "\"-=\"", "\">>=\"", "\"<<=\"",
- "\">>>=\"", "\"||\"", "\"&&\"", "\"::\"", "\"--\"", "\"++\"", "\"..\"",
- "\"...\"", "\"<<\"", "\">>>\"", "\">>\"", "prec_none", "below_semicolon",
- "';'", "','", "below_assignment", "'='", "\"&=\"", "\"^=\"", "'?'",
- "':'", "'|'", "'^'", "'&'", "'<'", "'>'", "below_minus", "'-'", "'+'",
- "'/'", "'*'", "'%'", "'~'", "'!'", "minusminus_prefix",
- "plusplus_prefix", "below_curly", "'('", "new2", "'['", "']'", "'{'",
- "'.'", "above_identifier", "below_else", "above_function", "'}'", "')'",
- "$accept", "PROGRAM", "MAYBE_PROGRAM_CODE_LIST", "PROGRAM_CODE_LIST",
- "PROGRAM_CODE", "MAYBE_INPACKAGE_CODE_LIST", "INPACKAGE_CODE_LIST",
- "INPACKAGE_CODE", "MAYBECODE", "CODE", "CODE_STATEMENT", "CODEPIECE",
- "CODEBLOCK", "PACKAGE_INITCODE", "MAYBEEXPRESSION",
- "VARIABLE_DECLARATION", "VARIABLE_LIST", "ONE_VARIABLE", "MAYBEELSE",
- "IF", "$@1", "FOR_INIT", "FOR_IN_INIT", "FOR_START", "FOR", "FOR_IN",
- "WHILE", "$@2", "DO_WHILE", "$@3", "BREAK", "CONTINUE",
- "MAYBE_CASE_LIST", "CASE_LIST", "CASE", "DEFAULT", "SWITCH", "$@4",
- "CATCH", "$@5", "FINALLY", "$@6", "CATCH_LIST", "CATCH_FINALLY_LIST",
- "TRY", "$@7", "THROW", "WITH", "X_IDENTIFIER", "PACKAGE",
- "PACKAGE_DECLARATION", "$@8", "$@9", "IMPORT", "MAYBE_MODIFIERS",
- "MODIFIER_LIST", "MODIFIER", "EXTENDS", "EXTENDS_LIST",
- "IMPLEMENTS_LIST", "CLASS_DECLARATION", "$@10", "INTERFACE_DECLARATION",
- "$@11", "MAYBE_CLASS_BODY", "CLASS_BODY", "CLASS_BODY_ITEM",
- "MAYBE_INTERFACE_BODY", "INTERFACE_BODY", "IDECLARATION", "VARCONST",
- "SLOT_DECLARATION", "MAYBESTATICCONSTANT", "STATICCONSTANT",
- "MAYBE_PARAM_LIST", "PARAM_LIST", "PARAM", "GETSET",
- "FUNCTION_DECLARATION", "$@12", "MAYBE_IDENTIFIER", "INNERFUNCTION",
- "$@13", "CLASS", "PACKAGEANDCLASS", "QNAME", "QNAME_LIST", "TYPE",
- "MAYBETYPE", "MAYBE_PARAM_VALUES", "MAYBE_EXPRESSION_LIST",
- "EXPRESSION_LIST", "XX", "NEW", "FUNCTIONCALL", "DELETE", "RETURN",
- "NONCOMMAEXPRESSION", "EXPRESSION", "VOIDEXPRESSION", "E", "CONSTANT",
- "MAYBE_EXPRPAIR_LIST", "EXPRPAIR_LIST", "VAR_READ",
- "NAMESPACE_DECLARATION", "USE_NAMESPACE", 0
+ "\"int\"", "\"Number\"", "\"String\"", "\"default\"", "\"default xml\"",
+ "\"delete\"", "\"if\"", "\"else\"", "\"break\"", "\"is\"", "\"in\"",
+ "\"as\"", "\"{ (dictionary)\"", "\"==\"", "\"===\"", "\"!=\"", "\"!==\"",
+ "\"<=\"", "\">=\"", "\"|=\"", "\"/=\"", "\"%=\"", "\"*=\"", "\"&=\"",
+ "\"+=\"", "\"-=\"", "\"^=\"", "\">>=\"", "\"<<=\"", "\">>>=\"", "\"||\"",
+ "\"&&\"", "\"::\"", "\"--\"", "\"++\"", "\"..\"", "\"...\"", "\"<<\"",
+ "\">>>\"", "\">>\"", "prec_none", "below_semicolon", "';'", "','",
+ "below_assignment", "'='", "'?'", "':'", "'|'", "'^'", "'&'", "below_lt",
+ "'<'", "'>'", "below_minus", "'-'", "'+'", "'/'", "'*'", "'%'", "'~'",
+ "'!'", "minusminus_prefix", "plusplus_prefix", "below_curly", "'('",
+ "new2", "'['", "']'", "'{'", "'.'", "'@'", "above_identifier",
+ "below_else", "above_function", "'}'", "')'", "$accept", "PROGRAM",
+ "MAYBE_PROGRAM_CODE_LIST", "PROGRAM_CODE_LIST", "PROGRAM_CODE",
+ "MAYBE_INPACKAGE_CODE_LIST", "INPACKAGE_CODE_LIST", "INPACKAGE_CODE",
+ "MAYBECODE", "CODE", "CODE_STATEMENT", "CODEPIECE", "CODEBLOCK",
+ "PACKAGE_INITCODE", "EMBED_START", "CONDITIONAL_COMPILATION",
+ "MAYBEEXPRESSION", "VARIABLE_DECLARATION", "VARIABLE_LIST",
+ "ONE_VARIABLE", "IF_CODEBLOCK", "$@1", "MAYBEELSE", "IF", "FOR_INIT",
+ "FOR_IN_INIT", "FOR_START", "FOR", "FOR_IN", "WHILE", "DO_WHILE",
+ "BREAK", "CONTINUE", "MAYBE_CASE_LIST", "CASE_LIST", "CASE", "DEFAULT",
+ "SWITCH", "$@2", "CATCH", "$@3", "FINALLY", "$@4", "CATCH_LIST",
+ "CATCH_FINALLY_LIST", "TRY", "$@5", "THROW", "WITH_HEAD", "WITH",
+ "X_IDENTIFIER", "PACKAGE", "PACKAGE_DECLARATION", "$@6", "$@7", "IMPORT",
+ "MAYBE_MODIFIERS", "MODIFIER_LIST", "MODIFIER", "EXTENDS",
+ "EXTENDS_LIST", "IMPLEMENTS_LIST", "CLASS_DECLARATION", "$@8",
+ "INTERFACE_DECLARATION", "$@9", "MAYBE_CLASS_BODY", "CLASS_BODY",
+ "CLASS_BODY_ITEM", "MAYBE_INTERFACE_BODY", "INTERFACE_BODY",
+ "IDECLARATION", "VARCONST", "SLOT_DECLARATION", "$@10", "SLOT_LIST",
+ "ONE_SLOT", "MAYBECONSTANT", "CONSTANT", "XML", "OPEN", "CLOSE",
+ "CLOSE2", "XMLEXPR1", "$@11", "XMLEXPR2", "$@12", "XMLTEXT", "XML2",
+ "XML_ID_OR_EXPR", "MAYBE_XMLATTRIBUTES", "XMLNODE", "XMLATTRIBUTES",
+ "XMLATTRIBUTE", "MAYBE_PARAM_LIST", "PARAM_LIST", "PARAM", "GETSET",
+ "FUNCTION_DECLARATION", "$@13", "MAYBE_IDENTIFIER", "INNERFUNCTION",
+ "$@14", "CLASS", "PACKAGEANDCLASS", "CLASS_SPEC", "CLASS_SPEC_LIST",
+ "TYPE", "MAYBETYPE", "MAYBE_PARAM_VALUES", "MAYBE_EXPRESSION_LIST",
+ "EXPRESSION_LIST", "EXPRESSION_LIST_AND_COMMA", "XX", "NEW",
+ "FUNCTIONCALL", "DELETE", "RETURN", "NONCOMMAEXPRESSION", "EXPRESSION",
+ "COMMA_EXPRESSION", "VOIDEXPRESSION", "MAYBE_DICT_EXPRPAIR_LIST",
+ "DICTLH", "DICT_EXPRPAIR_LIST", "E", "$@15", "ID_OR_NS", "SUBNODE",
+ "MEMBER", "VAR_READ", "NAMESPACE_ID", "NAMESPACE_DECLARATION",
+ "DEFAULT_NAMESPACE", "USE_NAMESPACE", 0
};
#endif
@@ -2153,80 +2615,94 @@ static const yytype_uint16 yytoknum[] =
315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
- 345, 346, 347, 348, 349, 350, 59, 44, 351, 61,
- 352, 353, 63, 58, 124, 94, 38, 60, 62, 354,
- 45, 43, 47, 42, 37, 126, 33, 355, 356, 357,
- 40, 358, 91, 93, 123, 46, 359, 360, 361, 125,
- 41
+ 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
+ 355, 59, 44, 356, 61, 63, 58, 124, 94, 38,
+ 357, 60, 62, 358, 45, 43, 47, 42, 37, 126,
+ 33, 359, 360, 361, 40, 362, 91, 93, 123, 46,
+ 64, 363, 364, 365, 125, 41
};
# endif
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
-static const yytype_uint8 yyr1[] =
+static const yytype_uint16 yyr1[] =
{
- 0, 131, 132, 133, 133, 134, 134, 135, 135, 135,
- 135, 135, 135, 135, 136, 136, 137, 137, 138, 138,
- 138, 138, 138, 138, 139, 139, 140, 140, 141, 141,
- 141, 141, 141, 141, 141, 141, 141, 141, 142, 142,
- 142, 142, 142, 142, 142, 142, 142, 143, 143, 143,
- 143, 144, 145, 145, 146, 146, 147, 147, 148, 149,
- 149, 151, 150, 152, 152, 152, 153, 153, 154, 154,
- 155, 156, 158, 157, 160, 159, 161, 161, 162, 162,
- 163, 163, 163, 163, 164, 164, 165, 166, 168, 167,
- 170, 169, 172, 171, 173, 173, 174, 174, 174, 176,
- 175, 177, 177, 178, 179, 179, 180, 180, 182, 181,
- 183, 181, 184, 184, 185, 185, 186, 186, 187, 187,
- 187, 187, 187, 187, 187, 187, 187, 188, 188, 189,
- 189, 190, 190, 192, 191, 194, 193, 195, 195, 196,
- 196, 197, 197, 197, 197, 198, 198, 199, 199, 200,
- 200, 200, 201, 201, 202, 203, 203, 204, 204, 204,
- 204, 204, 204, 204, 204, 205, 205, 205, 205, 206,
- 206, 207, 207, 208, 208, 208, 210, 209, 211, 211,
- 213, 212, 214, 215, 216, 216, 217, 217, 218, 218,
- 218, 219, 219, 220, 220, 221, 221, 222, 222, 223,
- 224, 225, 225, 226, 227, 227, 228, 229, 229, 230,
- 231, 231, 231, 231, 231, 231, 231, 232, 232, 232,
- 232, 232, 232, 232, 232, 232, 232, 231, 231, 231,
- 231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
- 231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
- 231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
- 231, 233, 233, 234, 234, 231, 231, 231, 231, 231,
- 231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
- 231, 231, 231, 235, 236, 236, 236, 237
+ 0, 136, 137, 138, 138, 139, 139, 140, 140, 140,
+ 140, 140, 140, 140, 140, 141, 141, 142, 142, 143,
+ 143, 143, 143, 143, 143, 143, 143, 144, 144, 145,
+ 145, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+ 146, 146, 146, 146, 146, 146, 147, 147, 147, 147,
+ 147, 147, 147, 147, 148, 148, 149, 150, 151, 152,
+ 152, 153, 153, 154, 154, 155, 157, 156, 158, 158,
+ 159, 160, 160, 160, 161, 161, 162, 162, 163, 164,
+ 165, 166, 167, 167, 168, 168, 169, 169, 169, 169,
+ 170, 170, 171, 172, 174, 173, 176, 175, 178, 177,
+ 179, 179, 180, 180, 180, 182, 181, 183, 183, 184,
+ 185, 186, 186, 186, 186, 186, 187, 187, 189, 188,
+ 190, 188, 191, 191, 191, 192, 192, 193, 193, 194,
+ 194, 194, 194, 194, 194, 194, 194, 194, 194, 195,
+ 195, 196, 196, 197, 197, 199, 198, 201, 200, 202,
+ 202, 203, 203, 204, 204, 204, 204, 204, 205, 205,
+ 206, 206, 207, 207, 207, 208, 208, 210, 209, 211,
+ 211, 212, 213, 213, 214, 214, 214, 214, 214, 214,
+ 214, 214, 214, 215, 216, 217, 218, 220, 219, 222,
+ 221, 223, 223, 223, 223, 224, 224, 225, 225, 226,
+ 226, 227, 227, 227, 228, 228, 229, 229, 229, 229,
+ 229, 230, 230, 230, 230, 231, 231, 232, 232, 233,
+ 233, 233, 235, 234, 236, 236, 238, 237, 239, 240,
+ 241, 241, 242, 242, 243, 243, 243, 244, 244, 245,
+ 245, 246, 246, 246, 247, 248, 247, 249, 250, 251,
+ 251, 252, 253, 253, 254, 255, 256, 256, 257, 257,
+ 258, 258, 259, 259, 259, 259, 259, 260, 260, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 262, 261, 263, 263, 263, 264, 264,
+ 261, 261, 261, 261, 261, 261, 261, 265, 266, 267,
+ 267, 267, 268, 269, 270
};
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
static const yytype_uint8 yyr2[] =
{
0, 2, 1, 0, 1, 1, 2, 1, 1, 1,
- 1, 1, 1, 1, 0, 1, 1, 2, 1, 1,
- 1, 1, 1, 1, 1, 0, 2, 1, 1, 1,
+ 1, 1, 1, 4, 1, 0, 1, 1, 2, 1,
+ 1, 1, 1, 1, 4, 4, 1, 1, 0, 2,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 3, 2, 2,
- 1, 1, 2, 0, 2, 2, 1, 3, 3, 0,
- 2, 0, 7, 0, 1, 1, 3, 1, 2, 3,
- 8, 6, 0, 6, 0, 7, 1, 2, 1, 2,
- 0, 1, 1, 2, 1, 2, 4, 3, 0, 8,
- 0, 9, 0, 5, 1, 2, 1, 2, 1, 0,
- 6, 2, 1, 5, 1, 1, 3, 1, 0, 6,
- 0, 5, 2, 4, 0, 1, 1, 2, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 0, 2, 0,
- 2, 0, 2, 0, 9, 0, 8, 0, 1, 1,
- 2, 1, 1, 1, 1, 0, 1, 1, 2, 1,
- 2, 8, 1, 1, 5, 0, 2, 1, 1, 1,
- 1, 1, 1, 1, 1, 0, 1, 2, 4, 3,
- 1, 4, 2, 1, 1, 0, 0, 12, 1, 0,
- 0, 10, 1, 3, 1, 1, 1, 3, 1, 1,
- 1, 2, 0, 0, 3, 0, 1, 1, 3, 0,
- 4, 4, 4, 2, 1, 2, 1, 1, 3, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 2, 2, 3,
+ 1, 1, 1, 1, 3, 2, 1, 1, 1, 1,
+ 1, 1, 1, 4, 2, 1, 1, 0, 3, 2,
+ 0, 2, 2, 1, 3, 3, 0, 2, 0, 2,
+ 6, 0, 1, 1, 3, 1, 2, 3, 8, 6,
+ 5, 6, 1, 2, 1, 2, 0, 1, 1, 2,
+ 1, 2, 4, 3, 0, 8, 0, 9, 0, 5,
+ 1, 2, 1, 2, 1, 0, 6, 2, 1, 4,
+ 2, 1, 1, 1, 1, 1, 3, 1, 0, 6,
+ 0, 5, 2, 2, 4, 0, 1, 1, 2, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 2, 0, 2, 0, 2, 0, 9, 0, 8, 0,
+ 1, 1, 2, 1, 4, 1, 1, 1, 0, 1,
+ 1, 2, 1, 2, 8, 1, 1, 0, 4, 1,
+ 3, 3, 0, 2, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 0, 0, 4, 0,
+ 4, 0, 2, 2, 2, 2, 3, 1, 1, 0,
+ 1, 6, 10, 11, 1, 2, 1, 3, 3, 3,
+ 3, 0, 1, 2, 4, 3, 1, 4, 2, 1,
+ 1, 0, 0, 12, 1, 0, 0, 10, 1, 3,
+ 1, 1, 1, 3, 1, 1, 1, 2, 0, 0,
+ 3, 0, 1, 1, 1, 2, 2, 0, 4, 4,
+ 4, 2, 1, 2, 1, 1, 1, 3, 1, 3,
+ 0, 1, 1, 1, 1, 1, 1, 3, 5, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 4, 2, 1, 3, 2, 4,
- 3, 0, 1, 3, 5, 3, 3, 3, 3, 3,
+ 3, 2, 2, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 2, 2,
+ 1, 3, 2, 4, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 5, 2, 2, 2,
- 2, 3, 3, 1, 3, 5, 5, 3
+ 2, 3, 2, 0, 6, 1, 1, 1, 1, 1,
+ 5, 3, 5, 4, 4, 6, 6, 3, 1, 2,
+ 4, 4, 2, 4, 3
};
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
@@ -2234,742 +2710,937 @@ static const yytype_uint8 yyr2[] =
means the default is an error. */
static const yytype_uint16 yydefact[] =
{
- 114, 283, 222, 216, 219, 220, 217, 218, 221, 0,
- 0, 74, 0, 0, 120, 118, 119, 126, 0, 125,
- 179, 223, 256, 121, 0, 0, 0, 226, 122, 124,
- 123, 0, 0, 225, 224, 0, 0, 0, 0, 13,
- 0, 0, 0, 0, 195, 261, 0, 2, 114, 5,
- 51, 12, 34, 63, 29, 30, 31, 32, 33, 36,
- 35, 7, 28, 0, 115, 116, 9, 8, 11, 10,
- 210, 213, 215, 214, 209, 37, 207, 211, 212, 0,
- 68, 72, 114, 88, 104, 105, 110, 107, 0, 199,
- 178, 0, 255, 0, 182, 0, 185, 184, 112, 0,
- 99, 195, 0, 203, 61, 280, 279, 258, 238, 237,
- 0, 0, 196, 197, 206, 0, 0, 262, 1, 6,
- 283, 0, 0, 64, 0, 0, 65, 175, 0, 153,
- 0, 152, 0, 117, 0, 0, 0, 0, 0, 0,
+ 125, 348, 138, 177, 277, 174, 175, 176, 0, 0,
+ 66, 0, 0, 131, 278, 129, 130, 0, 137, 0,
+ 136, 225, 181, 182, 310, 132, 0, 0, 0, 180,
+ 133, 135, 134, 0, 0, 179, 178, 0, 0, 0,
+ 260, 0, 0, 14, 184, 0, 0, 0, 0, 241,
+ 125, 0, 0, 2, 125, 5, 56, 12, 0, 38,
+ 71, 33, 34, 35, 36, 37, 40, 125, 39, 7,
+ 32, 0, 126, 127, 9, 8, 11, 275, 276, 0,
+ 183, 10, 269, 271, 273, 272, 41, 258, 270, 274,
+ 43, 31, 42, 0, 0, 76, 0, 0, 125, 94,
+ 111, 115, 113, 112, 114, 120, 117, 0, 0, 348,
+ 247, 224, 0, 309, 0, 122, 0, 123, 308, 105,
+ 241, 0, 0, 251, 0, 262, 263, 264, 265, 266,
+ 0, 0, 261, 330, 329, 312, 292, 291, 0, 256,
+ 0, 242, 243, 244, 254, 84, 0, 108, 252, 0,
+ 82, 46, 45, 125, 47, 30, 0, 48, 49, 50,
+ 52, 0, 51, 332, 1, 6, 125, 348, 0, 72,
+ 0, 0, 73, 55, 110, 0, 221, 0, 166, 0,
+ 165, 167, 352, 128, 197, 0, 198, 199, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 278, 277, 0, 0,
+ 0, 0, 328, 327, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 195, 0, 0, 69, 0, 0, 78,
- 102, 204, 0, 76, 38, 114, 39, 50, 0, 40,
- 41, 42, 44, 0, 43, 45, 46, 0, 114, 108,
- 0, 193, 165, 0, 0, 0, 25, 0, 281, 0,
- 257, 260, 0, 0, 265, 0, 192, 55, 56, 192,
- 54, 0, 0, 174, 173, 0, 127, 129, 192, 208,
- 252, 253, 250, 251, 231, 232, 234, 233, 229, 230,
- 272, 271, 267, 266, 273, 274, 269, 268, 270, 235,
- 236, 244, 243, 242, 275, 0, 241, 240, 239, 227,
- 228, 248, 247, 245, 249, 246, 0, 0, 282, 0,
- 0, 79, 101, 205, 77, 48, 114, 27, 207, 49,
- 0, 0, 0, 23, 0, 114, 16, 22, 19, 18,
- 21, 20, 114, 106, 195, 200, 155, 0, 0, 166,
- 170, 114, 183, 113, 254, 0, 24, 202, 0, 198,
- 263, 0, 0, 53, 0, 53, 0, 0, 0, 0,
- 131, 0, 0, 53, 0, 201, 259, 114, 287, 47,
- 26, 0, 284, 0, 111, 17, 0, 0, 0, 0,
- 172, 167, 192, 0, 103, 0, 114, 0, 190, 189,
- 0, 188, 191, 0, 58, 57, 0, 114, 165, 128,
- 0, 0, 186, 130, 135, 154, 276, 73, 0, 0,
- 80, 109, 194, 161, 158, 159, 157, 160, 164, 163,
- 162, 156, 155, 0, 0, 169, 0, 0, 94, 98,
- 96, 100, 59, 264, 0, 52, 0, 71, 0, 132,
- 133, 0, 114, 75, 285, 286, 0, 0, 0, 81,
- 84, 82, 171, 180, 168, 92, 0, 95, 97, 114,
- 62, 114, 192, 114, 187, 0, 149, 0, 0, 114,
- 147, 0, 25, 89, 85, 83, 25, 25, 192, 60,
- 70, 0, 141, 144, 0, 0, 114, 139, 142, 143,
- 150, 175, 136, 148, 25, 87, 0, 0, 0, 176,
- 134, 140, 0, 86, 181, 93, 90, 25, 0, 0,
- 0, 165, 25, 177, 0, 0, 192, 91, 151
+ 241, 0, 0, 58, 77, 0, 255, 0, 67, 0,
+ 125, 118, 0, 228, 0, 231, 230, 354, 239, 211,
+ 0, 0, 28, 0, 331, 0, 0, 280, 0, 0,
+ 0, 311, 279, 245, 246, 85, 238, 62, 63, 107,
+ 253, 61, 83, 44, 29, 125, 0, 238, 0, 0,
+ 54, 349, 220, 219, 0, 139, 141, 0, 189, 0,
+ 206, 0, 200, 204, 259, 306, 307, 304, 305, 285,
+ 286, 288, 287, 283, 284, 320, 319, 315, 314, 322,
+ 323, 324, 321, 317, 316, 318, 289, 290, 339, 0,
+ 338, 341, 298, 297, 296, 325, 0, 295, 294, 293,
+ 281, 282, 302, 301, 299, 303, 300, 0, 0, 111,
+ 115, 339, 333, 0, 0, 0, 347, 66, 0, 0,
+ 26, 57, 0, 125, 17, 23, 0, 20, 19, 22,
+ 21, 125, 116, 0, 241, 248, 172, 0, 0, 212,
+ 216, 109, 124, 229, 0, 27, 250, 353, 66, 267,
+ 0, 257, 0, 60, 0, 125, 13, 60, 0, 0,
+ 0, 0, 0, 143, 0, 0, 238, 168, 169, 0,
+ 0, 0, 185, 186, 191, 205, 0, 344, 0, 249,
+ 313, 0, 0, 0, 343, 0, 80, 0, 0, 0,
+ 121, 18, 125, 0, 0, 0, 0, 218, 213, 238,
+ 0, 0, 68, 0, 236, 235, 234, 237, 0, 65,
+ 64, 53, 0, 66, 350, 351, 211, 140, 0, 0,
+ 232, 142, 147, 60, 0, 190, 210, 209, 207, 208,
+ 0, 0, 0, 326, 0, 342, 0, 340, 81, 86,
+ 0, 0, 119, 240, 173, 172, 0, 0, 215, 0,
+ 0, 100, 104, 102, 106, 66, 70, 268, 59, 0,
+ 79, 0, 144, 145, 0, 125, 171, 170, 201, 193,
+ 184, 194, 0, 192, 0, 191, 346, 334, 345, 0,
+ 0, 0, 87, 90, 88, 25, 24, 217, 226, 214,
+ 98, 0, 101, 103, 69, 66, 238, 125, 233, 0,
+ 162, 0, 0, 125, 160, 0, 187, 184, 191, 195,
+ 0, 28, 95, 91, 89, 28, 28, 238, 78, 0,
+ 153, 157, 0, 0, 0, 125, 151, 155, 156, 163,
+ 221, 148, 161, 186, 0, 0, 196, 28, 93, 0,
+ 0, 0, 222, 125, 146, 152, 0, 0, 188, 186,
+ 92, 227, 99, 96, 28, 0, 0, 202, 0, 0,
+ 0, 154, 211, 203, 28, 223, 0, 0, 238, 97,
+ 164
};
/* YYDEFGOTO[NTERM-NUM]. */
static const yytype_int16 yydefgoto[] =
{
- -1, 46, 47, 48, 49, 284, 285, 286, 305, 306,
- 186, 277, 188, 287, 354, 189, 220, 218, 420, 52,
- 209, 124, 125, 53, 54, 55, 56, 177, 57, 82,
- 190, 191, 408, 409, 410, 411, 58, 197, 388, 469,
- 389, 437, 390, 391, 59, 206, 192, 60, 87, 350,
- 61, 292, 198, 62, 193, 64, 65, 320, 322, 361,
- 288, 423, 289, 402, 445, 446, 447, 428, 429, 430,
- 132, 290, 340, 381, 298, 299, 300, 225, 291, 467,
- 91, 70, 436, 96, 97, 351, 363, 352, 313, 295,
- 111, 112, 201, 71, 72, 73, 194, 113, 74, 75,
- 76, 77, 116, 117, 78, 195, 196
+ -1, 52, 53, 54, 55, 352, 353, 354, 374, 375,
+ 154, 155, 174, 355, 419, 156, 439, 157, 271, 268,
+ 97, 98, 486, 59, 170, 171, 60, 61, 62, 63,
+ 64, 158, 159, 511, 512, 513, 514, 65, 239, 481,
+ 589, 482, 546, 483, 484, 66, 252, 160, 67, 68,
+ 243, 244, 69, 361, 240, 70, 161, 72, 73, 393,
+ 395, 449, 357, 527, 358, 495, 554, 555, 556, 532,
+ 533, 534, 181, 359, 287, 397, 398, 427, 77, 78,
+ 79, 404, 460, 503, 564, 186, 399, 461, 504, 187,
+ 291, 80, 292, 293, 368, 369, 370, 284, 360, 584,
+ 112, 82, 545, 245, 246, 436, 451, 437, 383, 365,
+ 140, 141, 142, 248, 83, 84, 85, 162, 143, 235,
+ 236, 86, 130, 131, 132, 87, 411, 345, 321, 88,
+ 89, 182, 90, 91, 92
};
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
-#define YYPACT_NINF -352
+#define YYPACT_NINF -515
static const yytype_int16 yypact[] =
{
- 1185, -352, -352, -352, -352, -352, -352, -352, -352, -34,
- -75, -352, -55, 39, -352, -352, -352, -352, 1740, -352,
- 40, -352, 310, -352, -46, 103, -39, -352, -352, -352,
- -352, -24, -85, -352, -352, 1740, -16, 1740, 1740, -352,
- 1740, 1740, 1740, 1740, 1740, 1740, 114, -352, 1308, -352,
- -352, -352, -352, 1647, -352, -352, -352, -352, -352, -352,
- -352, -352, -352, 258, 305, -352, -352, -352, -352, -352,
- -352, -352, -352, -352, 21, -352, 2183, -352, -352, 59,
- -352, -352, 1552, -352, -352, -352, -352, -352, -61, -86,
- -352, 61, -10, 1740, 62, 63, -352, -352, -352, 1740,
- -352, 1740, 180, -10, -352, -10, -10, 155, -10, -10,
- -78, 67, 87, -352, 2183, 88, 82, 113, -352, -352,
- 150, 215, 219, -352, 127, 157, -352, 10, 223, -352,
- 225, -352, 226, -352, 1740, 1740, 1740, 1740, 1740, 1740,
- 1740, 1740, 1740, 1740, 1740, 1740, 1740, 1740, 1740, 1740,
- 1740, 1740, 1740, 1740, 1740, 1740, -352, -352, 1740, 1740,
- 1740, 1740, 1740, 1740, 1740, 1740, 1740, 1740, 1740, 1740,
- 1740, 1740, 1740, 1740, 1740, 227, -352, 1740, 214, 232,
- 1740, 1740, 215, 233, -352, 447, -352, 144, 231, -352,
- -352, -352, -352, 229, -352, -352, -352, 1740, 693, -352,
- 162, 128, 11, -77, 58, 1799, 1430, 117, -352, 1740,
- -352, -352, 1740, 1740, -352, 1740, 148, 159, -352, 148,
- 159, 1740, 1740, -352, -352, 249, 201, 204, 148, 2183,
- 803, 685, 685, 685, 2544, 2544, 2544, 2544, 803, 803,
- 2183, 2183, 2183, 2183, 2183, 2183, 2183, 2183, 2183, 2244,
- 2304, 151, 151, 151, 2183, 1939, 2364, 2424, 2484, 803,
- 803, 155, 155, -10, -10, -10, 136, 2000, -352, -76,
- 255, -352, 21, 21, -352, -352, 570, -352, 2061, -352,
- 154, 267, 1869, -352, 152, 816, -352, -352, -352, -352,
- -352, -352, 693, -352, 1740, -352, 8, 284, 160, 194,
- -352, 1552, 62, -352, -352, 165, 1430, -352, -60, -352,
- -352, 192, 6, 197, 215, -11, 20, -50, 177, 103,
- 283, 103, 178, 197, 1740, -352, -352, 1552, -352, -352,
- -352, 1740, 206, 182, -352, -352, 175, 179, 205, 6,
- -352, -352, 148, 13, -352, 81, 1552, 1740, -352, -352,
- 185, -352, -352, 1740, -352, -352, 1740, 1552, 11, -352,
- 103, 183, -352, 230, -352, -352, 2183, -352, -38, 172,
- 29, -352, -352, -352, -352, -352, -352, -352, -352, -352,
- -352, -352, 212, 198, 284, -352, 199, 196, -352, -352,
- 81, -352, 265, -352, 164, -352, 202, -352, 203, 230,
- -352, 103, 48, -352, -352, -352, 1740, 228, 208, 29,
- -352, -352, -352, -352, -352, -352, 341, -352, -352, 1552,
- -352, 1552, 148, 939, -352, 345, -352, 323, 221, 149,
- -352, 2122, 1430, -352, -352, -352, 1430, 1430, 148, -352,
- -352, 234, -352, -352, 53, 237, 1062, -352, -352, -352,
- -352, 10, -352, -352, 1430, -352, 238, 239, 240, -352,
- -352, -352, 352, -352, -352, -352, -352, 1430, 236, 235,
- 242, 11, 1430, -352, 243, 245, 148, -352, -352
+ 1766, 12, -515, -515, -515, -515, -515, -515, -28, -6,
+ -515, 16, 94, -515, -515, -515, -515, 108, -515, 2220,
+ -515, 122, -515, -515, 2277, -515, 17, 363, 2220, -515,
+ -515, -515, -515, 24, 27, -515, -515, 112, 2220, 29,
+ 332, 2220, 2220, -515, -515, 2220, 2220, 2220, 2220, 2220,
+ 710, 158, 165, -515, 578, -515, -515, -515, 44, -515,
+ 2148, -515, -515, -515, -515, -515, -515, 2022, -515, -515,
+ -515, 288, 766, -515, -515, -515, -515, -515, -515, 11,
+ -515, -515, -515, -515, -515, -515, 118, 2972, -515, -515,
+ -515, -515, -515, 218, 101, -515, 2220, 221, 2022, -515,
+ -515, -515, -515, -515, -515, -515, -515, -83, 373, -515,
+ -50, -515, 111, -51, 2220, 110, 124, -515, -51, -515,
+ 2220, 253, 155, -51, 2220, -515, -515, -515, -515, -515,
+ 127, 159, 162, -51, -51, 702, -51, -51, -52, 2910,
+ 141, 168, 2220, -515, 2910, 268, 272, 2220, 2220, 272,
+ 273, -515, -515, 842, -515, -515, 149, -515, -515, -515,
+ -515, 266, -515, -515, -515, -515, 1106, 214, 282, -515,
+ 191, 225, 118, 202, -515, 302, 54, 304, -515, 305,
+ -515, -515, -515, -515, -515, 2220, -515, 20, 2220, 2220,
+ 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220,
+ 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220,
+ 2220, 2220, -515, -515, 130, 2220, 2220, 2220, 2220, 2220,
+ 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220,
+ 2220, 2220, 128, -515, -515, 174, 209, 188, -515, 2220,
+ 1238, -515, 373, 184, 187, -515, -515, -515, 194, 21,
+ 186, 84, 1894, 193, -515, 2220, 198, -515, 2220, 332,
+ 2220, -515, -515, -515, -515, -515, 216, 236, -515, -515,
+ -515, 236, -515, -515, -515, 2022, 226, 216, 2220, 2220,
+ -515, 239, -515, -515, 345, 311, 314, 366, 2910, 278,
+ 280, -49, 20, -515, 2910, 408, 570, 570, 570, 3282,
+ 3282, 3282, 3282, 408, 408, 2910, 2910, 2910, 2910, 2910,
+ 2910, 2910, 2910, 2910, 2910, 2910, 365, 3034, -515, 146,
+ -515, -515, 424, 424, 424, 2910, 2476, 3096, 3158, 3220,
+ 408, 408, 702, 702, -51, -51, -51, 250, 2538, 295,
+ 306, 307, -515, 2220, 233, 312, -515, -515, 2220, 2336,
+ -515, 279, 259, 1370, -515, -515, 267, -515, -515, -515,
+ -515, 1238, -515, 373, 2220, -515, 126, 401, 274, 308,
+ -515, -515, -515, 283, 281, 1894, -515, 2910, -515, -515,
+ 310, 2910, 270, 313, 272, 974, -515, -30, 317, 284,
+ 104, 290, 373, 393, 373, 292, 216, 323, -515, 294,
+ 14, 15, -515, -515, -515, -515, 2220, -515, 2220, -515,
+ -515, 2220, 2600, 2220, -515, 354, -515, 296, 301, 2220,
+ -515, -515, 1238, 298, 309, 2220, 270, -515, -515, 216,
+ 22, 39, 364, 2220, -515, -515, -515, -515, 2220, -515,
+ -515, -515, 2220, -515, -515, -515, 21, -515, 373, 315,
+ -515, 334, -515, 313, 366, -515, -515, -515, -515, -515,
+ 333, 43, 2662, 2910, 2406, -515, 2724, -515, -515, 28,
+ 2786, 316, -515, -515, 2910, 342, 319, 401, -515, 321,
+ 327, -515, -515, 39, -515, -515, -515, -515, 2910, -41,
+ -515, 318, 334, -515, 373, 277, -515, -515, -515, -515,
+ 338, -515, 2220, -515, 353, -515, -515, -515, -515, 2220,
+ 350, 331, 28, -515, -515, -515, -515, -515, -515, -515,
+ -515, 463, -515, -515, -515, -515, 216, 1502, -515, 464,
+ -515, 442, 335, 326, -515, 11, 2910, 359, -515, 46,
+ 2848, 1894, -515, -515, -515, 1894, 1894, 216, -515, 358,
+ -515, -515, 360, 264, 336, 1634, -515, -515, -515, -515,
+ 54, -515, -515, -515, 344, 11, 46, 1894, -515, 362,
+ 369, 352, -515, 1502, -515, -515, 489, 381, -515, -515,
+ -515, -515, -515, -515, 1894, 374, 375, -515, 386, 379,
+ 376, -515, 21, -515, 1894, -515, 377, 380, 216, -515,
+ -515
};
/* YYPGOTO[NTERM-NUM]. */
static const yytype_int16 yypgoto[] =
{
- -352, -352, -352, -352, 309, 68, -352, 76, -217, 184,
- 1, -74, -255, 18, 49, 322, 256, 64, -352, -352,
- -352, -352, -352, -352, -352, -352, -352, -352, -352, -352,
- -352, -352, -352, -352, -33, -30, -352, -352, -27, -352,
- -9, -352, -352, -352, -352, -352, -352, -352, -187, 84,
- -352, -352, -352, -352, 0, -352, 318, -352, -352, -352,
- 27, -352, 34, -352, -352, -352, -63, -352, -352, -45,
- -352, 2, 4, -352, -351, -352, -285, -66, 3, -352,
- -352, -352, -352, -352, -352, -21, 28, 50, -197, -352,
- -90, -352, -352, -352, -352, -352, -352, -7, 12, -48,
- -12, -352, -352, -352, -352, -352, -352
+ -515, -515, 343, -515, 457, -340, -515, 160, -514, -37,
+ 1, -58, 417, 60, -515, 2, 82, 461, 390, 161,
+ -241, -515, -515, -515, -515, -515, -515, -515, -515, -515,
+ -515, -515, -515, -515, -515, 31, 32, -515, -515, 63,
+ -515, 64, -515, -515, -515, -515, -515, -515, -515, -515,
+ 37, 59, -515, -515, -515, -515, 0, -515, 477, -515,
+ -515, -515, 65, -515, 68, -515, -22, -515, -3, -515,
+ -515, 30, -515, 3, -515, -515, 100, 85, -515, -515,
+ -515, -515, -464, -515, -515, -172, -515, -453, -515, -488,
+ -515, -423, -515, 269, -428, -515, -339, 5, 4, -515,
+ -515, -515, -515, -515, 535, -103, 116, 140, -269, -515,
+ -109, -515, -515, -515, -515, -515, -515, -515, -132, -55,
+ 519, -54, -515, 320, -515, -12, -515, -515, -215, -515,
+ -515, -515, -515, -515, -515
};
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule which
number is the opposite. If zero, do what YYDEFACT says.
If YYTABLE_NINF, syntax error. */
-#define YYTABLE_NINF -207
+#define YYTABLE_NINF -338
static const yytype_int16 yytable[] =
{
- 63, 50, 68, 69, 98, 126, 89, 398, 187, 94,
- 92, 207, 341, 293, 296, 79, 296, 293, 51, 134,
- 134, 134, 315, 103, 85, 105, 106, 66, 107, 108,
- 109, 323, 114, 114, 67, 101, 174, 134, 115, 175,
- 102, 348, 84, 90, 223, 81, 344, 134, 63, 50,
- 68, 69, 210, 301, 327, 110, -66, 85, 385, 134,
- 224, 302, 406, 199, 200, 83, 51, 14, 15, 16,
- 346, 17, 367, 19, 93, 66, 85, 156, 157, 127,
- 357, 99, 67, 266, 129, 23, 80, 205, 353, 114,
- 407, 392, 403, 425, 28, 29, 30, 88, 131, 414,
- 100, 297, 397, 384, 104, 203, 94, 338, 386, 95,
- 173, 339, 174, 387, 118, 175, 356, 134, 134, 349,
- 474, 85, 229, 230, 231, 232, 233, 234, 235, 236,
- 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,
- 247, 248, 249, 250, 426, 383, 251, 252, 253, 254,
- 255, 256, 257, 258, 259, 260, 261, 262, 263, 264,
- 265, 114, 267, 86, 439, 84, 440, 302, 14, 15,
- 16, 303, 17, 278, 19, 404, 405, -145, 115, 176,
- 85, 202, 85, 208, 212, 282, 23, -104, 204, 269,
- 211, 213, 272, 273, 425, 28, 29, 30, 63, 50,
- 114, 114, 330, 114, 337, 309, 310, 293, 311, 373,
- 215, 214, 374, 375, 376, 455, 377, -67, 216, 456,
- 457, 308, 219, 221, 222, 441, 226, 187, 227, 228,
- 268, 270, 330, 316, 317, 271, 274, 463, 156, 157,
- 279, 458, 156, 157, 280, 426, 281, 307, 294, 378,
- 470, 312, 318, 187, 319, 475, 314, 321, 328, 379,
- 380, 168, 169, 170, 171, 172, 325, 170, 171, 172,
- 332, 173, 187, 174, 331, 173, 175, 174, -146, 478,
- 175, 334, 114, 187, 127, 63, 50, 296, 128, 129,
- 342, 343, 63, 50, 345, 347, 353, 358, 359, 360,
- 362, 130, 364, 131, 371, 369, 370, 400, 396, 372,
- 394, 338, 366, 1, 2, 3, 416, 4, 5, 6,
- 7, 8, 413, 415, 14, 15, 16, 401, 17, 419,
- 19, 432, 421, 422, 18, 114, 20, 433, 21, 362,
- 393, 114, 23, 368, 438, 187, 395, 187, 450, 451,
- 452, 28, 29, 30, 27, 468, 471, 119, 459, 472,
- 336, 335, 32, 417, 33, 34, 460, 464, 465, 276,
- 466, 473, 365, 476, 477, 123, 434, 217, 355, 435,
- 424, 418, 133, 461, 453, 462, 412, 0, 399, 382,
- 0, 0, 0, 0, 431, 0, 0, 37, 38, 0,
- 0, 0, 427, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 444, 443, 448, 449, 0, 0, 427,
- 43, 0, 44, 0, 45, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 444, 443, 448, 449,
- 1, 2, 3, 0, 4, 5, 6, 7, 8, 9,
- 10, 11, 12, 0, 0, 0, 14, 15, 16, 178,
- 17, 18, 19, 20, 0, 21, 179, 0, 121, 0,
- 0, 0, 22, 180, 23, 24, 0, 25, 181, 26,
- 0, 27, 182, 28, 29, 30, 0, 0, 31, 32,
- 0, 33, 34, 0, 0, 0, 0, 0, 0, 35,
- 36, 0, 183, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 37, 38, 0, 0, 0, 0,
- 0, 0, 0, 184, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 40, 0, 0,
- 0, 0, 41, 42, 0, 0, 0, 43, 0, 44,
- 0, 45, 0, 1, 2, 3, 275, 4, 5, 6,
- 7, 8, 9, 10, 11, 12, 0, 0, 0, 14,
- 15, 16, 178, 17, 18, 19, 20, 0, 21, 179,
- 0, 121, 0, 0, 0, 22, 180, 23, 24, 0,
- 25, 181, 26, 0, 27, 182, 28, 29, 30, 0,
- 0, 31, 32, 0, 33, 34, 0, 0, 0, 0,
- 0, 0, 35, 36, 0, 183, 0, 0, 0, 0,
+ 71, 56, 58, 76, 81, 247, 172, 110, 387, 173,
+ 264, 253, 113, 153, 184, 290, 118, 346, 491, 456,
+ 458, 423, 94, 289, 366, 366, 123, 568, 428, 133,
+ 134, 569, 570, 135, 136, 137, 139, 144, 505, -74,
+ 173, 212, 213, 214, 214, 241, 242, 563, 499, 106,
+ 260, 499, 539, 580, 71, 56, 58, 76, 81, 250,
+ 57, 188, 509, 402, 106, 74, 479, 403, 75, 256,
+ 590, 107, 480, 230, 438, 231, 231, 579, 232, 232,
+ 597, 538, 471, 261, 139, 566, 116, 100, 101, 282,
+ 510, 478, 269, 270, 525, 274, 95, 100, 101, 577,
+ 102, 103, 139, 93, 407, 283, 416, 444, 144, 445,
+ 102, 103, 139, 104, 57, 588, 367, 477, 96, 74,
+ 290, 337, 75, 104, 108, 111, 379, 453, 122, 414,
+ 144, 339, 340, 100, 101, 139, 139, 432, 519, 185,
+ 99, 114, 185, 185, 102, 103, 102, 103, 185, 100,
+ 101, 120, 119, 124, 500, 501, 121, 104, 501, 104,
+ 476, 163, 102, 103, 596, 164, 71, 56, 58, 76,
+ 81, 502, 166, 288, 502, 104, 294, 295, 296, 297,
+ 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
+ 308, 309, 310, 311, 312, 313, 314, 315, 316, 317,
+ 467, 372, 490, 322, 323, 324, 325, 326, 327, 328,
+ 329, 330, 331, 332, 333, 334, 335, 336, 144, 338,
+ 188, 233, 105, 388, 389, 234, 57, 349, 457, 459,
+ 425, 74, 426, 237, 75, 249, 100, 101, 385, -111,
+ 71, 56, 356, 377, 524, 341, 144, 318, 381, 102,
+ 103, 320, 342, 251, 343, 424, 254, 549, 344, 255,
+ 319, 257, 104, 318, 259, 258, 139, 139, 262, 320,
+ 263, 265, 406, 100, 101, 266, 272, 275, 571, 362,
+ 175, 2, 175, -75, 548, 277, 102, 103, 373, 447,
+ 176, 450, 278, 417, 279, 13, 178, 15, 16, 104,
+ 18, 487, 20, 280, 175, 281, 434, 285, 286, 347,
+ 180, 260, 348, -117, 176, 25, 363, 274, 364, 177,
+ 178, 371, 382, 529, 30, 31, 32, 274, 376, 600,
+ 2, 412, 179, 378, 180, 125, 139, 126, 384, 144,
+ 127, 128, 129, 390, 13, 450, 15, 16, 391, 18,
+ 318, 20, 144, 71, 56, 356, 320, 100, 101, 413,
+ 386, 71, 56, 356, 25, 392, 115, 101, 394, 396,
+ 102, 103, 529, 30, 31, 32, 100, 101, 530, 102,
+ 103, 320, 400, 104, 401, 409, -335, 435, 489, 102,
+ 103, 528, 104, 420, 462, 422, 463, -337, -336, 464,
+ 373, 466, 104, 415, 366, 189, -241, 470, 448, 429,
+ 430, -158, -116, 474, 446, 431, 433, 438, 442, 443,
+ 452, 144, 71, 56, 356, 454, 488, 530, 455, 469,
+ 485, 468, 472, 190, 191, 192, 494, 193, 194, 195,
+ 196, 197, 198, 493, 473, 498, 425, 518, -338, 520,
+ 516, 521, 320, 526, 535, 211, 541, 212, 213, 214,
+ -159, 215, 216, 217, 537, 542, 547, 559, 560, 561,
+ 574, 318, 220, 221, 222, 565, 223, 224, 578, 225,
+ 226, 227, 228, 229, -338, -338, 572, 583, 573, 230,
+ 536, 231, 586, 587, 232, 531, 581, 540, 593, 592,
+ 212, 213, 214, 582, 215, 216, 217, 594, 591, 276,
+ 595, 165, 598, 421, 599, 238, 212, 213, 214, -338,
+ -338, 169, 225, 226, 227, 228, 229, 553, 551, 552,
+ 557, 558, 230, 531, 231, 496, 267, 232, 225, 226,
+ 227, 228, 229, 543, 544, 440, 522, 523, 230, 183,
+ 231, 585, 575, 232, 497, 553, 551, 552, 557, 558,
+ 517, 405, 117, 562, 492, 576, 475, 138, 0, 0,
+ 0, 0, 0, 553, 551, 552, 557, 558, -4, 380,
+ 0, 1, 2, 3, 4, 0, 5, 6, 7, 8,
+ 9, 10, 11, 0, 0, 12, 13, 14, 15, 16,
+ 17, 18, 19, 20, 0, 0, 22, 23, 0, 0,
+ 189, 0, 0, 0, 24, 0, 25, 26, 0, 27,
+ 0, 28, 0, 29, 0, 30, 31, 32, 0, 0,
+ 33, 34, 0, 35, 36, 0, 0, 0, -338, -338,
+ -338, 37, 38, 39, 0, 0, 197, 198, 0, 40,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 37, 38, 0,
- 0, 0, 0, 0, 0, 0, 184, 0, 0, 0,
+ 0, 0, 212, 213, 214, 0, 215, 216, 217, 0,
+ 41, 42, 0, 0, 0, 0, 0, 0, 0, 43,
+ 0, 223, 224, 0, 225, 226, 227, 228, 229, 44,
+ 0, 0, 45, 0, 230, 0, 231, 46, 47, 232,
+ 0, 0, 48, 0, 49, 0, 50, 0, 51, 0,
+ 0, 0, -4, 1, 2, 3, 4, 0, 5, 6,
+ 7, 8, 9, 10, 11, 0, 0, 0, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 0, 22, 23,
+ 145, 0, 146, 0, 0, 0, 24, 147, 25, 26,
+ 0, 27, 148, 28, 0, 29, 149, 30, 31, 32,
+ 0, 0, 33, 34, 0, 35, 36, 0, 0, 0,
+ 2, 0, 0, 37, 38, 39, 0, 150, 0, 0,
+ 0, 40, 0, 0, 13, 0, 15, 16, 0, 18,
+ 0, 20, 0, 0, 212, 213, 214, 0, 0, 0,
+ 0, 0, 41, 42, 25, 0, 0, 0, 0, 0,
+ 0, 151, 0, 30, 31, 32, 0, 0, 227, 228,
+ 229, 44, 0, 0, 45, 0, 230, 0, 231, 46,
+ 47, 232, 0, 0, 48, 0, 49, 0, 50, 0,
+ 51, 0, 0, 0, 152, 1, 2, 3, 4, 0,
+ 5, 6, 7, 8, 9, 10, 11, 0, 0, 0,
+ 13, 14, 15, 16, 17, 18, 19, 20, 21, 0,
+ 22, 23, 145, 0, 146, 0, 0, 0, 24, 147,
+ 25, 26, 0, 27, 148, 28, 0, 29, 149, 30,
+ 31, 32, 0, 0, 33, 34, 0, 35, 36, 0,
+ 0, 0, 0, 0, 0, 37, 38, 39, 0, 150,
+ 0, 0, 0, 40, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 40, 0, 0, 0, 0, 41, 42, 0, 0, 0,
- 43, 0, 44, 0, 45, 0, 1, 2, 3, 329,
- 4, 5, 6, 7, 8, 9, 10, 11, 12, 0,
- 0, 0, 14, 15, 16, 0, 17, 18, 19, 0,
- 0, 21, 0, 0, 135, 0, 0, 0, 22, 0,
- 23, 24, 0, 25, 0, 26, 0, 27, 0, 28,
- 29, 30, 0, 0, 31, 32, 0, 33, 34, 0,
- 0, -207, -207, -207, 0, 35, 36, 0, 143, 144,
+ 0, 0, 0, 0, 41, 42, 0, 0, 0, 0,
+ 0, 0, 0, 151, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 44, 0, 0, 45, 0, 0, 0,
+ 0, 46, 47, 0, 0, 0, 48, 0, 49, 0,
+ 50, 0, 51, 0, 0, 0, 273, 1, 2, 3,
+ 4, 0, 5, 6, 7, 8, 9, 10, 11, 0,
+ 0, 0, 13, 14, 15, 16, 17, 18, 19, 20,
+ 21, 0, 22, 23, 145, 0, 146, 0, 0, 0,
+ 24, 147, 25, 26, 0, 27, 148, 28, 0, 29,
+ 149, 30, 31, 32, 0, 0, 33, 34, 0, 35,
+ 36, 0, 0, 0, 0, 0, 0, 37, 38, 39,
+ 0, 150, 0, 0, 0, 40, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 156, 157, 0, 0, 158, 159, 160, 0,
- 37, 38, 0, 0, 0, 0, 0, 0, 0, 283,
- 0, 0, 166, 167, 0, 168, 169, 170, 171, 172,
- 0, 0, 0, 40, 0, 173, 0, 174, 41, 42,
- 175, 0, 0, 43, 0, 44, 0, 45, 0, 1,
- 2, 3, -14, 4, 5, 6, 7, 8, 9, 10,
- 11, 12, 0, 0, 0, 14, 15, 16, 0, 17,
- 18, 19, -207, 0, 21, 0, 0, 0, 0, 0,
- 0, 22, 0, 23, 24, 0, 25, 0, 26, 0,
- 27, 0, 28, 29, 30, 0, 0, 31, 32, 0,
- 33, 34, 0, 0, 0, 0, -207, -207, 35, 36,
+ 0, 0, 0, 0, 0, 0, 41, 42, 0, 0,
+ 0, 0, 0, 0, 0, 151, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 44, 0, 0, 45, 0,
+ 0, 0, 0, 46, 47, 0, 0, 0, 48, 0,
+ 49, 0, 50, 0, 51, 0, 0, 0, 441, 1,
+ 2, 3, 4, 0, 5, 6, 7, 8, 9, 10,
+ 11, 0, 0, 12, 13, 14, 15, 16, 17, 18,
+ 19, 20, 0, 0, 22, 23, 0, 0, 0, 0,
+ 0, 0, 24, 0, 25, 26, 0, 27, 0, 28,
+ 0, 29, 0, 30, 31, 32, 0, 0, 33, 34,
+ 0, 35, 36, 0, 0, 0, 0, 0, 0, 37,
+ 38, 39, 0, 0, 0, 0, 0, 40, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 156, 157, 0, 0, 158, 159, 160, 0, 0, 0,
- 0, 0, 0, 37, 38, 0, 0, 0, 0, 0,
- -207, -207, 283, 168, 169, 170, 171, 172, 0, 0,
- 0, 0, 0, 173, 0, 174, 40, 0, 175, 0,
- 0, 41, 42, 0, 0, 0, 43, 0, 44, 0,
- 45, 0, 1, 2, 3, -15, 4, 5, 6, 7,
- 8, 9, 10, 11, 12, 0, 0, 0, 14, 15,
- 16, 0, 17, 18, 19, 0, 0, 21, 0, 0,
- 0, 0, 0, 0, 22, 0, 23, 24, 0, 25,
- 0, 26, 0, 27, 0, 28, 29, 30, 0, 0,
- 31, 32, 0, 33, 34, 0, 0, 0, 0, 0,
- 0, 35, 36, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 41, 42,
+ 0, 0, 0, 0, 0, 0, 0, 43, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 44, 0, 0,
+ 45, 0, 0, 0, 0, 46, 47, 0, 0, 0,
+ 48, 0, 49, 0, 50, 0, 51, 0, 0, 0,
+ -3, 1, 2, 3, 4, 0, 5, 6, 7, 8,
+ 9, 10, 11, 0, 0, 0, 13, 14, 15, 16,
+ 17, 18, 19, 20, 0, 0, 22, 23, 0, 0,
+ 0, 0, 0, 0, 24, 0, 25, 26, 0, 27,
+ 0, 28, 0, 29, 0, 30, 31, 32, 0, 0,
+ 33, 34, 0, 35, 36, 0, 0, 0, 0, 0,
+ 0, 37, 38, 39, 0, 0, 0, 0, 0, 40,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 37, 38, 0, 0,
- 0, 0, 0, 0, 0, 442, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 40,
- 0, 0, 0, 0, 41, 42, 0, 0, 0, 43,
- 0, 44, 0, 45, 0, 1, 2, 3, -137, 4,
- 5, 6, 7, 8, 9, 10, 11, 12, 0, 0,
- 0, 14, 15, 16, 0, 17, 18, 19, 0, 0,
- 21, 0, 0, 0, 0, 0, 0, 22, 0, 23,
- 24, 0, 25, 0, 26, 0, 27, 0, 28, 29,
- 30, 0, 0, 31, 32, 0, 33, 34, 0, 0,
- 0, 0, 0, 0, 35, 36, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 37,
- 38, 0, 0, 0, 0, 0, 0, 0, 442, 0,
+ 41, 42, 0, 0, 0, 0, 0, 0, 0, 350,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 44,
+ 0, 0, 45, 0, 0, 0, 0, 46, 47, 0,
+ 0, 0, 48, 0, 351, 0, 50, 0, 51, 0,
+ 0, 0, -15, 1, 2, 3, 4, 0, 5, 6,
+ 7, 8, 9, 10, 11, 0, 0, 0, 13, 14,
+ 15, 16, 17, 18, 19, 20, 0, 0, 22, 23,
+ 0, 0, 0, 0, 0, 0, 24, 0, 25, 26,
+ 0, 27, 0, 28, 0, 29, 0, 30, 31, 32,
+ 0, 0, 33, 34, 0, 35, 36, 0, 0, 0,
+ 0, 0, 0, 37, 38, 39, 0, 0, 0, 0,
+ 0, 40, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 40, 0, 0, 0, 0, 41, 42, 0,
- 0, 0, 43, 0, 44, -3, 45, 0, 1, 2,
- 3, -138, 4, 5, 6, 7, 8, 9, 10, 11,
- 12, 0, 0, 13, 14, 15, 16, 0, 17, 18,
- 19, 0, 0, 21, 0, 0, 0, 0, 0, 0,
- 22, 0, 23, 24, 0, 25, 0, 26, 0, 27,
- 0, 28, 29, 30, 0, 0, 31, 32, 0, 33,
- 34, 0, 0, 0, 0, 0, 0, 35, 36, 0,
+ 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
+ 0, 350, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 44, 0, 0, 45, 0, 0, 0, 0, 46,
+ 47, 0, 0, 0, 48, 0, 351, 0, 50, 0,
+ 51, 0, 0, 0, -16, 1, 2, 3, 4, 0,
+ 5, 6, 7, 8, 9, 10, 11, 0, 0, 0,
+ 13, 14, 15, 16, 17, 18, 19, 20, 0, 0,
+ 22, 23, 0, 0, 0, 0, 0, 0, 24, 0,
+ 25, 26, 0, 27, 0, 28, 0, 29, 0, 30,
+ 31, 32, 0, 0, 33, 34, 0, 35, 36, 0,
+ 0, 0, 0, 0, 0, 37, 38, 39, 0, 0,
+ 0, 0, 0, 40, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 37, 38, 0, 0, 0, 0, 0, 0,
- 0, 39, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 41, 42, 0, 0, 0, 0,
+ 0, 0, 0, 550, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 44, 0, 0, 45, 0, 0, 0,
+ 0, 46, 47, 0, 0, 0, 48, 0, 49, 0,
+ 50, 0, 51, 0, 0, 0, -149, 1, 2, 3,
+ 4, 0, 5, 6, 7, 8, 9, 10, 11, 0,
+ 0, 0, 13, 14, 15, 16, 17, 18, 19, 20,
+ 0, 0, 22, 23, 0, 0, 0, 0, 0, 0,
+ 24, 0, 25, 26, 0, 27, 0, 28, 0, 29,
+ 0, 30, 31, 32, 0, 0, 33, 34, 0, 35,
+ 36, 0, 0, 0, 0, 0, 0, 37, 38, 39,
0, 0, 0, 0, 0, 40, 0, 0, 0, 0,
- 41, 42, 0, 0, 0, 43, 0, 44, -4, 45,
- 0, 1, 2, 3, 0, 4, 5, 6, 7, 8,
- 9, 10, 11, 12, 0, 0, 13, 14, 15, 16,
- 0, 17, 18, 19, 0, 0, 21, 0, 0, 0,
- 0, 0, 0, 22, 0, 23, 24, 0, 25, 0,
- 26, 0, 27, 0, 28, 29, 30, 0, 0, 31,
- 32, 0, 33, 34, 0, 0, 0, 0, 0, 0,
- 35, 36, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 37, 38, 0, 0, 0,
- 0, 0, 0, 0, 39, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 40, 0,
- 0, 0, 0, 41, 42, 0, 0, 0, 43, 0,
- 44, 0, 45, 1, 2, 3, 0, 4, 5, 6,
- 7, 8, 9, 10, 11, 12, 0, -114, 0, 14,
- 15, 16, 178, 17, 18, 19, 20, 0, 21, 179,
- 0, 121, 0, 0, 0, 22, 180, 23, 24, 0,
- 25, 181, 26, 0, 27, 182, 28, 29, 30, 0,
- 0, 31, 32, 0, 33, 34, 0, 0, 0, 0,
- 0, 0, 35, 36, 0, 183, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 37, 38, 0,
- 0, 0, 0, 0, 0, 0, 184, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 40, 0, 0, 0, 0, 41, 42, 0, 0, 0,
- 43, 0, 44, 0, 45, 1, 2, 3, 0, 4,
- 5, 6, 7, 8, 9, 10, 11, 12, 0, 0,
- 0, 14, 15, 16, 178, 17, 18, 19, 20, 0,
- 21, 179, 0, 121, 0, 0, 0, 22, 180, 23,
- 24, 0, 25, 181, 26, 0, 27, 182, 28, 29,
- 30, 0, 0, 31, 32, 0, 33, 34, 0, 0,
- 0, 0, 0, 0, 35, 36, 0, 183, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 37,
- 38, 0, 0, 0, 0, 0, 0, 0, 184, 0,
- 120, 2, 3, 0, 4, 5, 6, 7, 8, 0,
- 0, 0, 40, 0, 0, 0, 0, 41, 42, 0,
- 0, 18, 43, 20, 44, 21, 185, 0, 121, 0,
- 0, 0, 22, 0, 0, 0, 0, 0, 0, 26,
- 0, 27, 122, 0, 0, 0, 0, 0, 0, 32,
- 0, 33, 34, 0, 0, 0, 0, 0, 0, 35,
+ 0, 0, 0, 0, 0, 0, 41, 42, 0, 0,
+ 0, 0, 0, 0, 0, 550, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 44, 0, 0, 45, 0,
+ 0, 0, 0, 46, 47, 0, 0, 0, 48, 0,
+ 49, 0, 50, 0, 51, 0, -3, 0, -150, 1,
+ 2, 3, 4, 0, 5, 6, 7, 8, 9, 10,
+ 11, 0, 0, 12, 13, 14, 15, 16, 17, 18,
+ 19, 20, 0, 0, 22, 23, 0, 0, 0, 0,
+ 0, 0, 24, 0, 25, 26, 0, 27, 0, 28,
+ 0, 29, 0, 30, 31, 32, 0, 0, 33, 34,
+ 0, 35, 36, 0, 0, 0, 0, 0, 0, 37,
+ 38, 39, 0, 0, 0, 0, 0, 40, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 41, 42,
+ 0, 0, 0, 0, 0, 0, 0, 43, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 44, 0, 0,
+ 45, 0, 0, 0, 0, 46, 47, 0, 0, 0,
+ 48, 0, 49, 0, 50, 0, 51, 1, 2, 3,
+ 4, 0, 5, 6, 7, 8, 9, 10, 11, 0,
+ -125, 0, 13, 14, 15, 16, 17, 18, 19, 20,
+ 21, 0, 22, 23, 145, 0, 146, 0, 0, 0,
+ 24, 147, 25, 26, 0, 27, 148, 28, 0, 29,
+ 149, 30, 31, 32, 0, 0, 33, 34, 0, 35,
+ 36, 0, 0, 0, 0, 0, 0, 37, 38, 39,
+ 0, 150, 0, 0, 0, 40, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 37, 38, 0, 0, 0, 0,
- 0, 0, 0, 1, 2, 3, 0, 4, 5, 6,
- 7, 8, 0, 0, 0, 0, 0, 40, 0, 0,
- 0, 0, 41, 42, 18, 0, 20, 43, 21, 44,
- 0, 45, 0, 0, 0, 22, 0, 0, 0, 0,
- 0, 0, 26, 0, 27, 0, 0, 0, 0, 0,
- 0, 0, 32, 0, 33, 34, 0, 0, 0, 0,
- 0, 0, 35, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 41, 42, 0, 0,
+ 0, 0, 0, 0, 0, 151, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 44, 0, 0, 45, 0,
+ 0, 0, 0, 46, 47, 0, 0, 0, 48, 0,
+ 49, 0, 50, 0, 51, 1, 2, 3, 4, 0,
+ 5, 6, 7, 8, 9, 10, 11, 0, 0, 0,
+ 13, 14, 15, 16, 17, 18, 19, 20, 21, 0,
+ 22, 23, 145, 0, 146, 0, 0, 0, 24, 147,
+ 25, 26, 0, 27, 148, 28, 0, 29, 149, 30,
+ 31, 32, 0, 0, 33, 34, 0, 35, 36, 0,
+ 0, 0, 0, 0, 0, 37, 38, 39, 0, 150,
+ 0, 0, 0, 40, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 37, 38, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 135, 0,
+ 0, 0, 0, 0, 41, 42, 0, 0, 0, 0,
+ 0, 0, 0, 151, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 44, 0, 0, 45, 0, 0, 0,
+ 0, 46, 47, 0, 0, 0, 48, 0, 49, 0,
+ 50, 167, 51, 3, 4, 0, 5, 6, 7, 0,
+ 0, 0, 0, 0, 0, 0, 0, 14, 0, 0,
+ 0, 0, 19, 0, 21, 0, 22, 23, 0, 0,
+ 146, 0, 0, 0, 24, 0, 0, 0, 0, 0,
+ 0, 28, 0, 29, 168, 0, 0, 0, 0, 0,
+ 0, 34, 0, 35, 36, 0, 0, 0, 0, 0,
+ 0, 0, 38, 0, 0, 0, 0, 0, 0, 40,
+ 0, 0, 0, 109, 0, 3, 4, 0, 5, 6,
+ 7, 0, 0, 0, 0, 0, 0, 0, 0, 14,
+ 41, 42, 0, 0, 19, 0, 21, 0, 22, 23,
+ 0, 0, 0, 0, 0, 0, 24, 0, 0, 44,
+ 0, 0, 45, 28, 0, 29, 0, 46, 47, 0,
+ 0, 0, 48, 34, 49, 35, 36, 0, 51, 0,
+ 109, 0, 3, 4, 38, 5, 6, 7, 0, 0,
+ 0, 40, 0, 0, 0, 0, 14, 0, 0, 0,
+ 0, 19, 0, 21, 0, 22, 23, 0, 0, 0,
+ 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
+ 0, 0, 29, 0, 0, 0, 0, 0, 0, 0,
+ 34, 44, 35, 36, 45, 0, 0, 0, 0, 46,
+ 47, 0, 0, 0, 48, 0, 49, 0, 40, 0,
+ 51, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 41,
+ 42, 0, 0, 0, 0, 0, 189, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 40, 0, 0, 0, 0, 41, 42, 0, 0, 0,
- 43, 0, 44, 0, 45, 136, 137, 138, 139, 140,
- 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
- 151, 152, 153, 154, 155, 0, 156, 157, 0, 0,
- 158, 159, 160, 0, 0, 0, 0, 0, 161, 0,
- 0, 162, 0, 163, 164, 165, 166, 167, 135, 168,
- 169, 170, 171, 172, 0, 0, 0, 0, 0, 173,
- 0, 174, 0, 0, 175, 0, 0, 0, 0, 304,
- 0, 0, 0, 0, 0, 136, 137, 138, 139, 140,
- 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
- 151, 152, 153, 154, 155, 0, 156, 157, 0, 0,
- 158, 159, 160, 0, 0, 0, 0, 0, 161, 0,
- 0, 162, 0, 163, 164, 165, 166, 167, 135, 168,
- 169, 170, 171, 172, 0, 0, 0, 0, 0, 173,
- 0, 174, 0, 0, 175, 0, 0, 0, 0, 333,
- 0, 0, 0, 0, 0, 136, 137, 138, 139, 140,
- 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
- 151, 152, 153, 154, 155, 0, 156, 157, 0, 0,
- 158, 159, 160, 0, 0, 0, 0, 0, 161, 135,
- 0, 162, 324, 163, 164, 165, 166, 167, 0, 168,
- 169, 170, 171, 172, 0, 0, 0, 0, 0, 173,
- 0, 174, 0, 0, 175, 0, 136, 137, 138, 139,
- 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
- 150, 151, 152, 153, 154, 155, 0, 156, 157, 0,
- 0, 158, 159, 160, 0, 0, 0, 0, 0, 161,
- 135, 0, 162, 0, 163, 164, 165, 166, 167, 0,
- 168, 169, 170, 171, 172, 0, 0, 0, 0, 0,
- 173, 0, 174, 326, 0, 175, 0, 136, 137, 138,
- 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
- 149, 150, 151, 152, 153, 154, 155, 0, 156, 157,
- 0, 0, 158, 159, 160, 0, 0, 0, 0, 0,
- 161, 135, 0, 162, -206, 163, 164, 165, 166, 167,
- 0, 168, 169, 170, 171, 172, 0, 0, 0, 0,
- 0, 173, 0, 174, 0, 0, 175, 0, 136, 137,
- 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
- 148, 149, 150, 151, 152, 153, 154, 155, 0, 156,
- 157, 0, 0, 158, 159, 160, 0, 0, 0, 0,
- 0, 161, 135, 0, 162, 454, 163, 164, 165, 166,
- 167, 0, 168, 169, 170, 171, 172, 0, 0, 0,
- 0, 0, 173, 0, 174, 0, 0, 175, 0, 136,
- 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
- 147, 148, 149, 150, 151, 152, 153, 154, 155, 0,
- 156, 157, 0, 0, 158, 159, 160, 0, 0, 0,
- 0, 0, 161, 135, 0, 162, 0, 163, 164, 165,
- 166, 167, 0, 168, 169, 170, 171, 172, 0, 0,
- 0, 0, 0, 173, 0, 174, 0, 0, 175, 0,
- 136, 137, 138, 139, 140, 141, 142, 143, 144, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 155,
- 0, 156, 157, 0, 0, 158, 159, 160, 0, 0,
- 0, 0, 0, 135, 0, 0, 0, 0, 163, 164,
- 165, 166, 167, 0, 168, 169, 170, 171, 172, 0,
- 0, 0, 0, 0, 173, 0, 174, 0, 0, 175,
- 136, 137, 138, 139, 140, 141, 142, 143, 144, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 156, 157, 0, 0, 158, 159, 160, 0, 0,
- 0, 0, 0, 135, 0, 0, 0, 0, 163, 164,
- 165, 166, 167, 0, 168, 169, 170, 171, 172, 0,
- 0, 0, 0, 0, 173, 0, 174, 0, 0, 175,
- 136, 137, 138, 139, 140, 141, 142, 143, 144, 0,
+ 0, 48, 0, 49, 190, 191, 192, 51, 193, 194,
+ 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
+ 205, 206, 207, 208, 209, 210, 211, 0, 212, 213,
+ 214, 0, 215, 216, 217, 0, 0, 0, 0, 0,
+ 218, 219, 0, 220, 221, 222, 189, 223, 224, 0,
+ 225, 226, 227, 228, 229, 0, 0, 0, 0, 0,
+ 230, 0, 231, 0, 0, 232, 0, 0, 0, 0,
+ 0, 418, 0, 0, 190, 191, 192, 0, 193, 194,
+ 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
+ 205, 206, 207, 208, 209, 210, 211, 0, 212, 213,
+ 214, 0, 215, 216, 217, 0, 0, 0, 0, 0,
+ 218, 219, 0, 220, 221, 222, 189, 223, 224, 0,
+ 225, 226, 227, 228, 229, 0, 0, 0, 0, 0,
+ 230, 0, 231, 0, 0, 232, 0, 0, 0, 0,
+ 0, 507, 0, 0, 190, 191, 192, 0, 193, 194,
+ 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
+ 205, 206, 207, 208, 209, 210, 211, 0, 212, 213,
+ 214, 0, 215, 216, 217, 0, 0, 0, 189, 0,
+ 218, 219, 408, 220, 221, 222, 0, 223, 224, 0,
+ 225, 226, 227, 228, 229, 0, 0, 0, 0, 0,
+ 230, 0, 231, 0, 0, 232, 190, 191, 192, 0,
+ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
+ 203, 204, 205, 206, 207, 208, 209, 210, 211, 0,
+ 212, 213, 214, 0, 215, 216, 217, 0, 0, 0,
+ 189, 0, 218, 219, 0, 220, 221, 222, 0, 223,
+ 224, 0, 225, 226, 227, 228, 229, 0, 0, 0,
+ 0, 0, 230, 0, 231, 410, 0, 232, 190, 191,
+ 192, 0, 193, 194, 195, 196, 197, 198, 199, 200,
+ 201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
+ 211, 0, 212, 213, 214, 0, 215, 216, 217, 0,
+ 0, 0, 189, 0, 218, 219, 0, 220, 221, 222,
+ 0, 223, 224, 0, 225, 226, 227, 228, 229, 0,
+ 0, 0, 0, 0, 230, 0, 231, 465, 0, 232,
+ 190, 191, 192, 0, 193, 194, 195, 196, 197, 198,
+ 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
+ 209, 210, 211, 0, 212, 213, 214, 0, 215, 216,
+ 217, 0, 0, 0, 189, 0, 218, 219, 0, 220,
+ 221, 222, 0, 223, 224, 0, 225, 226, 227, 228,
+ 229, 0, 0, 0, 0, 0, 230, 0, 231, 506,
+ 0, 232, 190, 191, 192, 0, 193, 194, 195, 196,
+ 197, 198, 199, 200, 201, 202, 203, 204, 205, 206,
+ 207, 208, 209, 210, 211, 0, 212, 213, 214, 0,
+ 215, 216, 217, 0, 0, 0, 189, 0, 218, 219,
+ 0, 220, 221, 222, 0, 223, 224, 0, 225, 226,
+ 227, 228, 229, 0, 0, 0, 0, 0, 230, 0,
+ 231, 508, 0, 232, 190, 191, 192, 0, 193, 194,
+ 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
+ 205, 206, 207, 208, 209, 210, 211, 0, 212, 213,
+ 214, 0, 215, 216, 217, 0, 0, 0, 189, 0,
+ 218, 219, 0, 220, 221, 222, 0, 223, 224, 0,
+ 225, 226, 227, 228, 229, 0, 0, 0, 0, 0,
+ 230, 0, 231, 515, 0, 232, 190, 191, 192, 0,
+ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
+ 203, 204, 205, 206, 207, 208, 209, 210, 211, 0,
+ 212, 213, 214, 0, 215, 216, 217, 0, 0, 0,
+ 189, 0, 218, 219, 567, 220, 221, 222, 0, 223,
+ 224, 0, 225, 226, 227, 228, 229, 0, 0, 0,
+ 0, 0, 230, 0, 231, 0, 0, 232, 190, 191,
+ 192, 0, 193, 194, 195, 196, 197, 198, 199, 200,
+ 201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
+ 211, 0, 212, 213, 214, 0, 215, 216, 217, 0,
+ 0, 0, 189, 0, 218, 219, 0, 220, 221, 222,
+ 0, 223, 224, 0, 225, 226, 227, 228, 229, 0,
+ 0, 0, 0, 0, 230, 0, 231, 0, 0, 232,
+ 190, 191, 192, 0, 193, 194, 195, 196, 197, 198,
+ 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
+ 209, 210, 211, 0, 212, 213, 214, 0, 215, 216,
+ 217, 0, 0, 0, 189, 0, 218, 219, 0, 220,
+ 221, 222, 0, 0, 224, 0, 225, 226, 227, 228,
+ 229, 0, 0, 0, 0, 0, 230, 0, 231, 0,
+ 0, 232, 190, 191, 192, 0, 193, 194, 195, 196,
+ 197, 198, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 212, 213, 214, 0,
+ 215, 216, 217, 0, 0, 0, 189, 0, 0, 0,
+ 0, 220, 221, 222, 0, 223, 224, 0, 225, 226,
+ 227, 228, 229, 0, 0, 0, 0, 0, 230, 0,
+ 231, 0, 0, 232, 190, 191, 192, 0, 193, 194,
+ 195, 196, 197, 198, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 212, 213,
+ 214, 0, 215, 216, 217, 0, 0, 0, 189, 0,
+ 0, 0, 0, 0, 221, 222, 0, 223, 224, 0,
+ 225, 226, 227, 228, 229, 0, 0, 0, 0, 0,
+ 230, 0, 231, 0, 0, 232, 190, 191, 192, 0,
+ 193, 194, 195, 196, 197, 198, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 156, 157, 0, 0, 158, 159, 160, 0, 0,
- 0, 0, 0, 135, 0, 0, 0, 0, 0, 164,
- 165, 166, 167, 0, 168, 169, 170, 171, 172, 0,
- 0, 0, 0, 0, 173, 0, 174, 0, 0, 175,
- 136, 137, 138, 139, 140, 141, 142, 143, 144, 0,
+ 212, 213, 214, 0, 215, 216, 217, 0, 0, 0,
+ 189, 0, 0, 0, 0, 0, 0, 222, 0, 223,
+ 224, 0, 225, 226, 227, 228, 229, 0, 0, 0,
+ 0, 0, 230, 0, 231, 0, 0, 232, 190, 191,
+ 192, 0, 193, 194, 195, 196, 197, 198, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 156, 157, 0, 0, 158, 159, 160, 0, 0,
- 0, 0, 0, 135, 0, 0, 0, 0, 0, 0,
- 165, 166, 167, 0, 168, 169, 170, 171, 172, 0,
- 0, 0, 0, 0, 173, 0, 174, 0, 0, 175,
- 136, 137, 138, 139, 140, 141, 142, 143, 144, 0,
+ 0, 0, 212, 213, 214, 0, 215, 216, 217, 0,
+ 0, 0, 189, 0, 0, 0, 0, 0, 0, -338,
+ 0, 223, 224, 0, 225, 226, 227, 228, 229, 0,
+ 0, 0, 0, 0, 230, 0, 231, 0, 0, 232,
+ 190, 191, 192, 0, -338, -338, -338, -338, 197, 198,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 156, 157, 0, 0, 158, 159, 160, 0, 0,
- 0, 0, 0, 135, 0, 0, 0, 0, 0, 0,
- -207, 166, 167, 0, 168, 169, 170, 171, 172, 0,
- 0, 0, 0, 0, 173, 0, 174, 0, 0, 175,
- 136, 137, 138, -207, -207, -207, -207, 143, 144, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 156, 157, 0, 0, 158, 159, 160, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 166, 167, 0, 168, 169, 170, 171, 172, 0,
- 0, 0, 0, 0, 173, 0, 174, 0, 0, 175
+ 0, 0, 0, 0, 212, 213, 214, 0, 215, 216,
+ 217, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 223, 224, 0, 225, 226, 227, 228,
+ 229, 0, 0, 0, 0, 0, 230, 0, 231, 0,
+ 0, 232
};
static const yytype_int16 yycheck[] =
{
- 0, 0, 0, 0, 25, 53, 18, 358, 82, 3,
- 22, 101, 297, 200, 3, 49, 3, 204, 0, 97,
- 97, 97, 219, 35, 18, 37, 38, 0, 40, 41,
- 42, 228, 44, 45, 0, 120, 122, 97, 45, 125,
- 125, 35, 3, 3, 34, 120, 301, 97, 48, 48,
- 48, 48, 130, 130, 130, 43, 67, 18, 343, 97,
- 50, 3, 33, 124, 125, 120, 48, 19, 20, 21,
- 130, 23, 327, 25, 120, 48, 18, 87, 88, 26,
- 130, 120, 48, 173, 31, 37, 120, 99, 99, 101,
- 61, 346, 130, 45, 46, 47, 48, 13, 45, 384,
- 124, 90, 357, 90, 120, 93, 3, 99, 27, 25,
- 120, 103, 122, 32, 0, 125, 96, 97, 97, 113,
- 471, 18, 134, 135, 136, 137, 138, 139, 140, 141,
- 142, 143, 144, 145, 146, 147, 148, 149, 150, 151,
- 152, 153, 154, 155, 96, 342, 158, 159, 160, 161,
- 162, 163, 164, 165, 166, 167, 168, 169, 170, 171,
- 172, 173, 174, 124, 419, 3, 421, 3, 19, 20,
- 21, 113, 23, 185, 25, 3, 4, 129, 185, 120,
- 18, 120, 18, 3, 97, 197, 37, 125, 125, 177,
- 123, 103, 180, 181, 45, 46, 47, 48, 198, 198,
- 212, 213, 276, 215, 294, 212, 213, 394, 215, 4,
- 97, 129, 7, 8, 9, 432, 11, 67, 3, 436,
- 437, 209, 3, 96, 67, 422, 3, 301, 3, 3,
- 3, 17, 306, 221, 222, 3, 3, 454, 87, 88,
- 96, 438, 87, 88, 13, 96, 17, 130, 120, 44,
- 467, 103, 3, 327, 53, 472, 97, 53, 3, 54,
- 55, 110, 111, 112, 113, 114, 130, 112, 113, 114,
- 3, 120, 346, 122, 120, 120, 125, 122, 129, 476,
- 125, 129, 294, 357, 26, 285, 285, 3, 30, 31,
- 130, 97, 292, 292, 129, 103, 99, 120, 319, 16,
- 321, 43, 124, 45, 129, 99, 124, 124, 356, 130,
- 125, 99, 324, 3, 4, 5, 120, 7, 8, 9,
- 10, 11, 124, 124, 19, 20, 21, 97, 23, 64,
- 25, 103, 130, 130, 24, 347, 26, 129, 28, 360,
- 347, 353, 37, 331, 3, 419, 353, 421, 3, 26,
- 129, 46, 47, 48, 44, 3, 120, 48, 124, 124,
- 292, 285, 52, 390, 54, 55, 129, 129, 129, 185,
- 130, 129, 323, 130, 129, 53, 409, 121, 314, 409,
- 401, 390, 64, 446, 429, 451, 382, -1, 360, 339,
- -1, -1, -1, -1, 406, -1, -1, 87, 88, -1,
- -1, -1, 402, -1, -1, -1, -1, -1, -1, -1,
+ 0, 0, 0, 0, 0, 108, 60, 19, 277, 67,
+ 142, 120, 24, 50, 3, 187, 28, 232, 446, 5,
+ 5, 361, 50, 3, 3, 3, 38, 541, 367, 41,
+ 42, 545, 546, 45, 46, 47, 48, 49, 461, 69,
+ 98, 92, 93, 94, 94, 128, 129, 535, 5, 12,
+ 102, 5, 505, 567, 54, 54, 54, 54, 54, 114,
+ 0, 102, 34, 112, 27, 0, 27, 116, 0, 124,
+ 584, 12, 33, 124, 104, 126, 126, 565, 129, 129,
+ 594, 504, 422, 135, 96, 538, 27, 3, 4, 35,
+ 62, 430, 147, 148, 135, 153, 124, 3, 4, 563,
+ 16, 17, 114, 91, 319, 51, 347, 3, 120, 5,
+ 16, 17, 124, 29, 54, 579, 95, 95, 124, 54,
+ 292, 230, 54, 29, 16, 3, 258, 396, 16, 344,
+ 142, 3, 4, 3, 4, 147, 148, 378, 477, 128,
+ 124, 124, 128, 128, 16, 17, 16, 17, 128, 3,
+ 4, 124, 128, 124, 111, 112, 129, 29, 112, 29,
+ 429, 3, 16, 17, 592, 0, 166, 166, 166, 166,
+ 166, 128, 128, 185, 128, 29, 188, 189, 190, 191,
+ 192, 193, 194, 195, 196, 197, 198, 199, 200, 201,
+ 202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
+ 415, 117, 443, 215, 216, 217, 218, 219, 220, 221,
+ 222, 223, 224, 225, 226, 227, 228, 229, 230, 231,
+ 102, 3, 128, 278, 279, 124, 166, 239, 400, 401,
+ 104, 166, 106, 12, 166, 124, 3, 4, 275, 129,
+ 240, 240, 240, 255, 485, 117, 258, 117, 260, 16,
+ 17, 214, 124, 129, 126, 364, 3, 526, 130, 104,
+ 130, 134, 29, 117, 102, 106, 278, 279, 127, 232,
+ 102, 3, 126, 3, 4, 3, 3, 128, 547, 242,
+ 16, 4, 16, 69, 525, 3, 16, 17, 251, 392,
+ 26, 394, 101, 348, 69, 18, 32, 20, 21, 29,
+ 23, 433, 25, 101, 16, 3, 36, 3, 3, 135,
+ 46, 102, 124, 129, 26, 38, 129, 375, 124, 31,
+ 32, 135, 106, 46, 47, 48, 49, 385, 135, 598,
+ 4, 343, 44, 135, 46, 3, 348, 5, 102, 351,
+ 8, 9, 10, 104, 18, 448, 20, 21, 3, 23,
+ 117, 25, 364, 353, 353, 353, 319, 3, 4, 126,
+ 134, 361, 361, 361, 38, 54, 3, 4, 54, 3,
+ 16, 17, 46, 47, 48, 49, 3, 4, 101, 16,
+ 17, 344, 104, 29, 104, 135, 91, 117, 442, 16,
+ 17, 494, 29, 134, 406, 128, 408, 91, 91, 411,
+ 363, 413, 29, 91, 3, 40, 127, 419, 15, 135,
+ 102, 134, 129, 425, 124, 134, 106, 104, 101, 135,
+ 128, 433, 422, 422, 422, 102, 438, 101, 134, 128,
+ 66, 135, 134, 68, 69, 70, 102, 72, 73, 74,
+ 75, 76, 77, 128, 135, 112, 104, 128, 40, 128,
+ 134, 124, 415, 135, 116, 90, 106, 92, 93, 94,
+ 134, 96, 97, 98, 111, 134, 3, 3, 26, 134,
+ 134, 117, 107, 108, 109, 116, 111, 112, 134, 114,
+ 115, 116, 117, 118, 76, 77, 128, 135, 128, 124,
+ 502, 126, 3, 112, 129, 495, 134, 509, 112, 124,
+ 92, 93, 94, 134, 96, 97, 98, 128, 134, 166,
+ 134, 54, 135, 353, 134, 98, 92, 93, 94, 111,
+ 112, 60, 114, 115, 116, 117, 118, 527, 527, 527,
+ 527, 527, 124, 533, 126, 453, 146, 129, 114, 115,
+ 116, 117, 118, 512, 512, 384, 483, 483, 124, 72,
+ 126, 573, 555, 129, 454, 555, 555, 555, 555, 555,
+ 475, 292, 27, 533, 448, 560, 426, 48, -1, -1,
+ -1, -1, -1, 573, 573, 573, 573, 573, 0, 259,
+ -1, 3, 4, 5, 6, -1, 8, 9, 10, 11,
+ 12, 13, 14, -1, -1, 17, 18, 19, 20, 21,
+ 22, 23, 24, 25, -1, -1, 28, 29, -1, -1,
+ 40, -1, -1, -1, 36, -1, 38, 39, -1, 41,
+ -1, 43, -1, 45, -1, 47, 48, 49, -1, -1,
+ 52, 53, -1, 55, 56, -1, -1, -1, 68, 69,
+ 70, 63, 64, 65, -1, -1, 76, 77, -1, 71,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 423, 423, 423, 423, -1, -1, 429,
- 120, -1, 122, -1, 124, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 446, 446, 446, 446,
- 3, 4, 5, -1, 7, 8, 9, 10, 11, 12,
- 13, 14, 15, -1, -1, -1, 19, 20, 21, 22,
- 23, 24, 25, 26, -1, 28, 29, -1, 31, -1,
- -1, -1, 35, 36, 37, 38, -1, 40, 41, 42,
- -1, 44, 45, 46, 47, 48, -1, -1, 51, 52,
- -1, 54, 55, -1, -1, -1, -1, -1, -1, 62,
- 63, -1, 65, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 87, 88, -1, -1, -1, -1,
- -1, -1, -1, 96, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 110, -1, -1,
- -1, -1, 115, 116, -1, -1, -1, 120, -1, 122,
- -1, 124, -1, 3, 4, 5, 129, 7, 8, 9,
- 10, 11, 12, 13, 14, 15, -1, -1, -1, 19,
+ -1, -1, 92, 93, 94, -1, 96, 97, 98, -1,
+ 92, 93, -1, -1, -1, -1, -1, -1, -1, 101,
+ -1, 111, 112, -1, 114, 115, 116, 117, 118, 111,
+ -1, -1, 114, -1, 124, -1, 126, 119, 120, 129,
+ -1, -1, 124, -1, 126, -1, 128, -1, 130, -1,
+ -1, -1, 134, 3, 4, 5, 6, -1, 8, 9,
+ 10, 11, 12, 13, 14, -1, -1, -1, 18, 19,
20, 21, 22, 23, 24, 25, 26, -1, 28, 29,
- -1, 31, -1, -1, -1, 35, 36, 37, 38, -1,
- 40, 41, 42, -1, 44, 45, 46, 47, 48, -1,
- -1, 51, 52, -1, 54, 55, -1, -1, -1, -1,
- -1, -1, 62, 63, -1, 65, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 87, 88, -1,
- -1, -1, -1, -1, -1, -1, 96, -1, -1, -1,
+ 30, -1, 32, -1, -1, -1, 36, 37, 38, 39,
+ -1, 41, 42, 43, -1, 45, 46, 47, 48, 49,
+ -1, -1, 52, 53, -1, 55, 56, -1, -1, -1,
+ 4, -1, -1, 63, 64, 65, -1, 67, -1, -1,
+ -1, 71, -1, -1, 18, -1, 20, 21, -1, 23,
+ -1, 25, -1, -1, 92, 93, 94, -1, -1, -1,
+ -1, -1, 92, 93, 38, -1, -1, -1, -1, -1,
+ -1, 101, -1, 47, 48, 49, -1, -1, 116, 117,
+ 118, 111, -1, -1, 114, -1, 124, -1, 126, 119,
+ 120, 129, -1, -1, 124, -1, 126, -1, 128, -1,
+ 130, -1, -1, -1, 134, 3, 4, 5, 6, -1,
+ 8, 9, 10, 11, 12, 13, 14, -1, -1, -1,
+ 18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
+ 28, 29, 30, -1, 32, -1, -1, -1, 36, 37,
+ 38, 39, -1, 41, 42, 43, -1, 45, 46, 47,
+ 48, 49, -1, -1, 52, 53, -1, 55, 56, -1,
+ -1, -1, -1, -1, -1, 63, 64, 65, -1, 67,
+ -1, -1, -1, 71, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 110, -1, -1, -1, -1, 115, 116, -1, -1, -1,
- 120, -1, 122, -1, 124, -1, 3, 4, 5, 129,
- 7, 8, 9, 10, 11, 12, 13, 14, 15, -1,
- -1, -1, 19, 20, 21, -1, 23, 24, 25, -1,
- -1, 28, -1, -1, 39, -1, -1, -1, 35, -1,
- 37, 38, -1, 40, -1, 42, -1, 44, -1, 46,
- 47, 48, -1, -1, 51, 52, -1, 54, 55, -1,
- -1, 66, 67, 68, -1, 62, 63, -1, 73, 74,
+ -1, -1, -1, -1, 92, 93, -1, -1, -1, -1,
+ -1, -1, -1, 101, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 111, -1, -1, 114, -1, -1, -1,
+ -1, 119, 120, -1, -1, -1, 124, -1, 126, -1,
+ 128, -1, 130, -1, -1, -1, 134, 3, 4, 5,
+ 6, -1, 8, 9, 10, 11, 12, 13, 14, -1,
+ -1, -1, 18, 19, 20, 21, 22, 23, 24, 25,
+ 26, -1, 28, 29, 30, -1, 32, -1, -1, -1,
+ 36, 37, 38, 39, -1, 41, 42, 43, -1, 45,
+ 46, 47, 48, 49, -1, -1, 52, 53, -1, 55,
+ 56, -1, -1, -1, -1, -1, -1, 63, 64, 65,
+ -1, 67, -1, -1, -1, 71, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 87, 88, -1, -1, 91, 92, 93, -1,
- 87, 88, -1, -1, -1, -1, -1, -1, -1, 96,
- -1, -1, 107, 108, -1, 110, 111, 112, 113, 114,
- -1, -1, -1, 110, -1, 120, -1, 122, 115, 116,
- 125, -1, -1, 120, -1, 122, -1, 124, -1, 3,
- 4, 5, 129, 7, 8, 9, 10, 11, 12, 13,
- 14, 15, -1, -1, -1, 19, 20, 21, -1, 23,
- 24, 25, 39, -1, 28, -1, -1, -1, -1, -1,
- -1, 35, -1, 37, 38, -1, 40, -1, 42, -1,
- 44, -1, 46, 47, 48, -1, -1, 51, 52, -1,
- 54, 55, -1, -1, -1, -1, 73, 74, 62, 63,
+ -1, -1, -1, -1, -1, -1, 92, 93, -1, -1,
+ -1, -1, -1, -1, -1, 101, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 111, -1, -1, 114, -1,
+ -1, -1, -1, 119, 120, -1, -1, -1, 124, -1,
+ 126, -1, 128, -1, 130, -1, -1, -1, 134, 3,
+ 4, 5, 6, -1, 8, 9, 10, 11, 12, 13,
+ 14, -1, -1, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, -1, -1, 28, 29, -1, -1, -1, -1,
+ -1, -1, 36, -1, 38, 39, -1, 41, -1, 43,
+ -1, 45, -1, 47, 48, 49, -1, -1, 52, 53,
+ -1, 55, 56, -1, -1, -1, -1, -1, -1, 63,
+ 64, 65, -1, -1, -1, -1, -1, 71, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 87, 88, -1, -1, 91, 92, 93, -1, -1, -1,
- -1, -1, -1, 87, 88, -1, -1, -1, -1, -1,
- 107, 108, 96, 110, 111, 112, 113, 114, -1, -1,
- -1, -1, -1, 120, -1, 122, 110, -1, 125, -1,
- -1, 115, 116, -1, -1, -1, 120, -1, 122, -1,
- 124, -1, 3, 4, 5, 129, 7, 8, 9, 10,
- 11, 12, 13, 14, 15, -1, -1, -1, 19, 20,
- 21, -1, 23, 24, 25, -1, -1, 28, -1, -1,
- -1, -1, -1, -1, 35, -1, 37, 38, -1, 40,
- -1, 42, -1, 44, -1, 46, 47, 48, -1, -1,
- 51, 52, -1, 54, 55, -1, -1, -1, -1, -1,
- -1, 62, 63, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 92, 93,
+ -1, -1, -1, -1, -1, -1, -1, 101, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 111, -1, -1,
+ 114, -1, -1, -1, -1, 119, 120, -1, -1, -1,
+ 124, -1, 126, -1, 128, -1, 130, -1, -1, -1,
+ 134, 3, 4, 5, 6, -1, 8, 9, 10, 11,
+ 12, 13, 14, -1, -1, -1, 18, 19, 20, 21,
+ 22, 23, 24, 25, -1, -1, 28, 29, -1, -1,
+ -1, -1, -1, -1, 36, -1, 38, 39, -1, 41,
+ -1, 43, -1, 45, -1, 47, 48, 49, -1, -1,
+ 52, 53, -1, 55, 56, -1, -1, -1, -1, -1,
+ -1, 63, 64, 65, -1, -1, -1, -1, -1, 71,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 87, 88, -1, -1,
- -1, -1, -1, -1, -1, 96, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 110,
- -1, -1, -1, -1, 115, 116, -1, -1, -1, 120,
- -1, 122, -1, 124, -1, 3, 4, 5, 129, 7,
- 8, 9, 10, 11, 12, 13, 14, 15, -1, -1,
- -1, 19, 20, 21, -1, 23, 24, 25, -1, -1,
- 28, -1, -1, -1, -1, -1, -1, 35, -1, 37,
- 38, -1, 40, -1, 42, -1, 44, -1, 46, 47,
- 48, -1, -1, 51, 52, -1, 54, 55, -1, -1,
- -1, -1, -1, -1, 62, 63, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 87,
- 88, -1, -1, -1, -1, -1, -1, -1, 96, -1,
+ 92, 93, -1, -1, -1, -1, -1, -1, -1, 101,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 111,
+ -1, -1, 114, -1, -1, -1, -1, 119, 120, -1,
+ -1, -1, 124, -1, 126, -1, 128, -1, 130, -1,
+ -1, -1, 134, 3, 4, 5, 6, -1, 8, 9,
+ 10, 11, 12, 13, 14, -1, -1, -1, 18, 19,
+ 20, 21, 22, 23, 24, 25, -1, -1, 28, 29,
+ -1, -1, -1, -1, -1, -1, 36, -1, 38, 39,
+ -1, 41, -1, 43, -1, 45, -1, 47, 48, 49,
+ -1, -1, 52, 53, -1, 55, 56, -1, -1, -1,
+ -1, -1, -1, 63, 64, 65, -1, -1, -1, -1,
+ -1, 71, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 110, -1, -1, -1, -1, 115, 116, -1,
- -1, -1, 120, -1, 122, 0, 124, -1, 3, 4,
- 5, 129, 7, 8, 9, 10, 11, 12, 13, 14,
- 15, -1, -1, 18, 19, 20, 21, -1, 23, 24,
- 25, -1, -1, 28, -1, -1, -1, -1, -1, -1,
- 35, -1, 37, 38, -1, 40, -1, 42, -1, 44,
- -1, 46, 47, 48, -1, -1, 51, 52, -1, 54,
- 55, -1, -1, -1, -1, -1, -1, 62, 63, -1,
+ -1, -1, 92, 93, -1, -1, -1, -1, -1, -1,
+ -1, 101, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 111, -1, -1, 114, -1, -1, -1, -1, 119,
+ 120, -1, -1, -1, 124, -1, 126, -1, 128, -1,
+ 130, -1, -1, -1, 134, 3, 4, 5, 6, -1,
+ 8, 9, 10, 11, 12, 13, 14, -1, -1, -1,
+ 18, 19, 20, 21, 22, 23, 24, 25, -1, -1,
+ 28, 29, -1, -1, -1, -1, -1, -1, 36, -1,
+ 38, 39, -1, 41, -1, 43, -1, 45, -1, 47,
+ 48, 49, -1, -1, 52, 53, -1, 55, 56, -1,
+ -1, -1, -1, -1, -1, 63, 64, 65, -1, -1,
+ -1, -1, -1, 71, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 92, 93, -1, -1, -1, -1,
+ -1, -1, -1, 101, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 111, -1, -1, 114, -1, -1, -1,
+ -1, 119, 120, -1, -1, -1, 124, -1, 126, -1,
+ 128, -1, 130, -1, -1, -1, 134, 3, 4, 5,
+ 6, -1, 8, 9, 10, 11, 12, 13, 14, -1,
+ -1, -1, 18, 19, 20, 21, 22, 23, 24, 25,
+ -1, -1, 28, 29, -1, -1, -1, -1, -1, -1,
+ 36, -1, 38, 39, -1, 41, -1, 43, -1, 45,
+ -1, 47, 48, 49, -1, -1, 52, 53, -1, 55,
+ 56, -1, -1, -1, -1, -1, -1, 63, 64, 65,
+ -1, -1, -1, -1, -1, 71, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 87, 88, -1, -1, -1, -1, -1, -1,
- -1, 96, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 110, -1, -1, -1, -1,
- 115, 116, -1, -1, -1, 120, -1, 122, 0, 124,
- -1, 3, 4, 5, -1, 7, 8, 9, 10, 11,
- 12, 13, 14, 15, -1, -1, 18, 19, 20, 21,
- -1, 23, 24, 25, -1, -1, 28, -1, -1, -1,
- -1, -1, -1, 35, -1, 37, 38, -1, 40, -1,
- 42, -1, 44, -1, 46, 47, 48, -1, -1, 51,
- 52, -1, 54, 55, -1, -1, -1, -1, -1, -1,
- 62, 63, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 92, 93, -1, -1,
+ -1, -1, -1, -1, -1, 101, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 111, -1, -1, 114, -1,
+ -1, -1, -1, 119, 120, -1, -1, -1, 124, -1,
+ 126, -1, 128, -1, 130, -1, 0, -1, 134, 3,
+ 4, 5, 6, -1, 8, 9, 10, 11, 12, 13,
+ 14, -1, -1, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, -1, -1, 28, 29, -1, -1, -1, -1,
+ -1, -1, 36, -1, 38, 39, -1, 41, -1, 43,
+ -1, 45, -1, 47, 48, 49, -1, -1, 52, 53,
+ -1, 55, 56, -1, -1, -1, -1, -1, -1, 63,
+ 64, 65, -1, -1, -1, -1, -1, 71, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 87, 88, -1, -1, -1,
- -1, -1, -1, -1, 96, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 110, -1,
- -1, -1, -1, 115, 116, -1, -1, -1, 120, -1,
- 122, -1, 124, 3, 4, 5, -1, 7, 8, 9,
- 10, 11, 12, 13, 14, 15, -1, 17, -1, 19,
- 20, 21, 22, 23, 24, 25, 26, -1, 28, 29,
- -1, 31, -1, -1, -1, 35, 36, 37, 38, -1,
- 40, 41, 42, -1, 44, 45, 46, 47, 48, -1,
- -1, 51, 52, -1, 54, 55, -1, -1, -1, -1,
- -1, -1, 62, 63, -1, 65, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 87, 88, -1,
- -1, -1, -1, -1, -1, -1, 96, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 110, -1, -1, -1, -1, 115, 116, -1, -1, -1,
- 120, -1, 122, -1, 124, 3, 4, 5, -1, 7,
- 8, 9, 10, 11, 12, 13, 14, 15, -1, -1,
- -1, 19, 20, 21, 22, 23, 24, 25, 26, -1,
- 28, 29, -1, 31, -1, -1, -1, 35, 36, 37,
- 38, -1, 40, 41, 42, -1, 44, 45, 46, 47,
- 48, -1, -1, 51, 52, -1, 54, 55, -1, -1,
- -1, -1, -1, -1, 62, 63, -1, 65, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 87,
- 88, -1, -1, -1, -1, -1, -1, -1, 96, -1,
- 3, 4, 5, -1, 7, 8, 9, 10, 11, -1,
- -1, -1, 110, -1, -1, -1, -1, 115, 116, -1,
- -1, 24, 120, 26, 122, 28, 124, -1, 31, -1,
- -1, -1, 35, -1, -1, -1, -1, -1, -1, 42,
- -1, 44, 45, -1, -1, -1, -1, -1, -1, 52,
- -1, 54, 55, -1, -1, -1, -1, -1, -1, 62,
+ -1, -1, -1, -1, -1, -1, -1, -1, 92, 93,
+ -1, -1, -1, -1, -1, -1, -1, 101, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 111, -1, -1,
+ 114, -1, -1, -1, -1, 119, 120, -1, -1, -1,
+ 124, -1, 126, -1, 128, -1, 130, 3, 4, 5,
+ 6, -1, 8, 9, 10, 11, 12, 13, 14, -1,
+ 16, -1, 18, 19, 20, 21, 22, 23, 24, 25,
+ 26, -1, 28, 29, 30, -1, 32, -1, -1, -1,
+ 36, 37, 38, 39, -1, 41, 42, 43, -1, 45,
+ 46, 47, 48, 49, -1, -1, 52, 53, -1, 55,
+ 56, -1, -1, -1, -1, -1, -1, 63, 64, 65,
+ -1, 67, -1, -1, -1, 71, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 92, 93, -1, -1,
+ -1, -1, -1, -1, -1, 101, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 111, -1, -1, 114, -1,
+ -1, -1, -1, 119, 120, -1, -1, -1, 124, -1,
+ 126, -1, 128, -1, 130, 3, 4, 5, 6, -1,
+ 8, 9, 10, 11, 12, 13, 14, -1, -1, -1,
+ 18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
+ 28, 29, 30, -1, 32, -1, -1, -1, 36, 37,
+ 38, 39, -1, 41, 42, 43, -1, 45, 46, 47,
+ 48, 49, -1, -1, 52, 53, -1, 55, 56, -1,
+ -1, -1, -1, -1, -1, 63, 64, 65, -1, 67,
+ -1, -1, -1, 71, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 87, 88, -1, -1, -1, -1,
- -1, -1, -1, 3, 4, 5, -1, 7, 8, 9,
- 10, 11, -1, -1, -1, -1, -1, 110, -1, -1,
- -1, -1, 115, 116, 24, -1, 26, 120, 28, 122,
- -1, 124, -1, -1, -1, 35, -1, -1, -1, -1,
- -1, -1, 42, -1, 44, -1, -1, -1, -1, -1,
- -1, -1, 52, -1, 54, 55, -1, -1, -1, -1,
- -1, -1, 62, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 92, 93, -1, -1, -1, -1,
+ -1, -1, -1, 101, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 111, -1, -1, 114, -1, -1, -1,
+ -1, 119, 120, -1, -1, -1, 124, -1, 126, -1,
+ 128, 3, 130, 5, 6, -1, 8, 9, 10, -1,
+ -1, -1, -1, -1, -1, -1, -1, 19, -1, -1,
+ -1, -1, 24, -1, 26, -1, 28, 29, -1, -1,
+ 32, -1, -1, -1, 36, -1, -1, -1, -1, -1,
+ -1, 43, -1, 45, 46, -1, -1, -1, -1, -1,
+ -1, 53, -1, 55, 56, -1, -1, -1, -1, -1,
+ -1, -1, 64, -1, -1, -1, -1, -1, -1, 71,
+ -1, -1, -1, 3, -1, 5, 6, -1, 8, 9,
+ 10, -1, -1, -1, -1, -1, -1, -1, -1, 19,
+ 92, 93, -1, -1, 24, -1, 26, -1, 28, 29,
+ -1, -1, -1, -1, -1, -1, 36, -1, -1, 111,
+ -1, -1, 114, 43, -1, 45, -1, 119, 120, -1,
+ -1, -1, 124, 53, 126, 55, 56, -1, 130, -1,
+ 3, -1, 5, 6, 64, 8, 9, 10, -1, -1,
+ -1, 71, -1, -1, -1, -1, 19, -1, -1, -1,
+ -1, 24, -1, 26, -1, 28, 29, -1, -1, -1,
+ -1, -1, 92, 93, -1, -1, -1, -1, -1, -1,
+ -1, -1, 45, -1, -1, -1, -1, -1, -1, -1,
+ 53, 111, 55, 56, 114, -1, -1, -1, -1, 119,
+ 120, -1, -1, -1, 124, -1, 126, -1, 71, -1,
+ 130, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 92,
+ 93, -1, -1, -1, -1, -1, 40, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 87, 88, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 39, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 110, -1, -1, -1, -1, 115, 116, -1, -1, -1,
- 120, -1, 122, -1, 124, 66, 67, 68, 69, 70,
- 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
- 81, 82, 83, 84, 85, -1, 87, 88, -1, -1,
- 91, 92, 93, -1, -1, -1, -1, -1, 99, -1,
- -1, 102, -1, 104, 105, 106, 107, 108, 39, 110,
- 111, 112, 113, 114, -1, -1, -1, -1, -1, 120,
- -1, 122, -1, -1, 125, -1, -1, -1, -1, 130,
- -1, -1, -1, -1, -1, 66, 67, 68, 69, 70,
- 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
- 81, 82, 83, 84, 85, -1, 87, 88, -1, -1,
- 91, 92, 93, -1, -1, -1, -1, -1, 99, -1,
- -1, 102, -1, 104, 105, 106, 107, 108, 39, 110,
- 111, 112, 113, 114, -1, -1, -1, -1, -1, 120,
- -1, 122, -1, -1, 125, -1, -1, -1, -1, 130,
- -1, -1, -1, -1, -1, 66, 67, 68, 69, 70,
- 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
- 81, 82, 83, 84, 85, -1, 87, 88, -1, -1,
- 91, 92, 93, -1, -1, -1, -1, -1, 99, 39,
- -1, 102, 103, 104, 105, 106, 107, 108, -1, 110,
- 111, 112, 113, 114, -1, -1, -1, -1, -1, 120,
- -1, 122, -1, -1, 125, -1, 66, 67, 68, 69,
- 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
- 80, 81, 82, 83, 84, 85, -1, 87, 88, -1,
- -1, 91, 92, 93, -1, -1, -1, -1, -1, 99,
- 39, -1, 102, -1, 104, 105, 106, 107, 108, -1,
- 110, 111, 112, 113, 114, -1, -1, -1, -1, -1,
- 120, -1, 122, 123, -1, 125, -1, 66, 67, 68,
- 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
- 79, 80, 81, 82, 83, 84, 85, -1, 87, 88,
- -1, -1, 91, 92, 93, -1, -1, -1, -1, -1,
- 99, 39, -1, 102, 103, 104, 105, 106, 107, 108,
- -1, 110, 111, 112, 113, 114, -1, -1, -1, -1,
- -1, 120, -1, 122, -1, -1, 125, -1, 66, 67,
- 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
- 78, 79, 80, 81, 82, 83, 84, 85, -1, 87,
- 88, -1, -1, 91, 92, 93, -1, -1, -1, -1,
- -1, 99, 39, -1, 102, 103, 104, 105, 106, 107,
- 108, -1, 110, 111, 112, 113, 114, -1, -1, -1,
- -1, -1, 120, -1, 122, -1, -1, 125, -1, 66,
- 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
- 77, 78, 79, 80, 81, 82, 83, 84, 85, -1,
- 87, 88, -1, -1, 91, 92, 93, -1, -1, -1,
- -1, -1, 99, 39, -1, 102, -1, 104, 105, 106,
- 107, 108, -1, 110, 111, 112, 113, 114, -1, -1,
- -1, -1, -1, 120, -1, 122, -1, -1, 125, -1,
- 66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 85,
- -1, 87, 88, -1, -1, 91, 92, 93, -1, -1,
- -1, -1, -1, 39, -1, -1, -1, -1, 104, 105,
- 106, 107, 108, -1, 110, 111, 112, 113, 114, -1,
- -1, -1, -1, -1, 120, -1, 122, -1, -1, 125,
- 66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
+ -1, 124, -1, 126, 68, 69, 70, 130, 72, 73,
+ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
+ 84, 85, 86, 87, 88, 89, 90, -1, 92, 93,
+ 94, -1, 96, 97, 98, -1, -1, -1, -1, -1,
+ 104, 105, -1, 107, 108, 109, 40, 111, 112, -1,
+ 114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
+ 124, -1, 126, -1, -1, 129, -1, -1, -1, -1,
+ -1, 135, -1, -1, 68, 69, 70, -1, 72, 73,
+ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
+ 84, 85, 86, 87, 88, 89, 90, -1, 92, 93,
+ 94, -1, 96, 97, 98, -1, -1, -1, -1, -1,
+ 104, 105, -1, 107, 108, 109, 40, 111, 112, -1,
+ 114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
+ 124, -1, 126, -1, -1, 129, -1, -1, -1, -1,
+ -1, 135, -1, -1, 68, 69, 70, -1, 72, 73,
+ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
+ 84, 85, 86, 87, 88, 89, 90, -1, 92, 93,
+ 94, -1, 96, 97, 98, -1, -1, -1, 40, -1,
+ 104, 105, 106, 107, 108, 109, -1, 111, 112, -1,
+ 114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
+ 124, -1, 126, -1, -1, 129, 68, 69, 70, -1,
+ 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
+ 82, 83, 84, 85, 86, 87, 88, 89, 90, -1,
+ 92, 93, 94, -1, 96, 97, 98, -1, -1, -1,
+ 40, -1, 104, 105, -1, 107, 108, 109, -1, 111,
+ 112, -1, 114, 115, 116, 117, 118, -1, -1, -1,
+ -1, -1, 124, -1, 126, 127, -1, 129, 68, 69,
+ 70, -1, 72, 73, 74, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+ 90, -1, 92, 93, 94, -1, 96, 97, 98, -1,
+ -1, -1, 40, -1, 104, 105, -1, 107, 108, 109,
+ -1, 111, 112, -1, 114, 115, 116, 117, 118, -1,
+ -1, -1, -1, -1, 124, -1, 126, 127, -1, 129,
+ 68, 69, 70, -1, 72, 73, 74, 75, 76, 77,
+ 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
+ 88, 89, 90, -1, 92, 93, 94, -1, 96, 97,
+ 98, -1, -1, -1, 40, -1, 104, 105, -1, 107,
+ 108, 109, -1, 111, 112, -1, 114, 115, 116, 117,
+ 118, -1, -1, -1, -1, -1, 124, -1, 126, 127,
+ -1, 129, 68, 69, 70, -1, 72, 73, 74, 75,
+ 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
+ 86, 87, 88, 89, 90, -1, 92, 93, 94, -1,
+ 96, 97, 98, -1, -1, -1, 40, -1, 104, 105,
+ -1, 107, 108, 109, -1, 111, 112, -1, 114, 115,
+ 116, 117, 118, -1, -1, -1, -1, -1, 124, -1,
+ 126, 127, -1, 129, 68, 69, 70, -1, 72, 73,
+ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
+ 84, 85, 86, 87, 88, 89, 90, -1, 92, 93,
+ 94, -1, 96, 97, 98, -1, -1, -1, 40, -1,
+ 104, 105, -1, 107, 108, 109, -1, 111, 112, -1,
+ 114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
+ 124, -1, 126, 127, -1, 129, 68, 69, 70, -1,
+ 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
+ 82, 83, 84, 85, 86, 87, 88, 89, 90, -1,
+ 92, 93, 94, -1, 96, 97, 98, -1, -1, -1,
+ 40, -1, 104, 105, 106, 107, 108, 109, -1, 111,
+ 112, -1, 114, 115, 116, 117, 118, -1, -1, -1,
+ -1, -1, 124, -1, 126, -1, -1, 129, 68, 69,
+ 70, -1, 72, 73, 74, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+ 90, -1, 92, 93, 94, -1, 96, 97, 98, -1,
+ -1, -1, 40, -1, 104, 105, -1, 107, 108, 109,
+ -1, 111, 112, -1, 114, 115, 116, 117, 118, -1,
+ -1, -1, -1, -1, 124, -1, 126, -1, -1, 129,
+ 68, 69, 70, -1, 72, 73, 74, 75, 76, 77,
+ 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
+ 88, 89, 90, -1, 92, 93, 94, -1, 96, 97,
+ 98, -1, -1, -1, 40, -1, 104, 105, -1, 107,
+ 108, 109, -1, -1, 112, -1, 114, 115, 116, 117,
+ 118, -1, -1, -1, -1, -1, 124, -1, 126, -1,
+ -1, 129, 68, 69, 70, -1, 72, 73, 74, 75,
+ 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 92, 93, 94, -1,
+ 96, 97, 98, -1, -1, -1, 40, -1, -1, -1,
+ -1, 107, 108, 109, -1, 111, 112, -1, 114, 115,
+ 116, 117, 118, -1, -1, -1, -1, -1, 124, -1,
+ 126, -1, -1, 129, 68, 69, 70, -1, 72, 73,
+ 74, 75, 76, 77, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 92, 93,
+ 94, -1, 96, 97, 98, -1, -1, -1, 40, -1,
+ -1, -1, -1, -1, 108, 109, -1, 111, 112, -1,
+ 114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
+ 124, -1, 126, -1, -1, 129, 68, 69, 70, -1,
+ 72, 73, 74, 75, 76, 77, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 87, 88, -1, -1, 91, 92, 93, -1, -1,
- -1, -1, -1, 39, -1, -1, -1, -1, 104, 105,
- 106, 107, 108, -1, 110, 111, 112, 113, 114, -1,
- -1, -1, -1, -1, 120, -1, 122, -1, -1, 125,
- 66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
+ 92, 93, 94, -1, 96, 97, 98, -1, -1, -1,
+ 40, -1, -1, -1, -1, -1, -1, 109, -1, 111,
+ 112, -1, 114, 115, 116, 117, 118, -1, -1, -1,
+ -1, -1, 124, -1, 126, -1, -1, 129, 68, 69,
+ 70, -1, 72, 73, 74, 75, 76, 77, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 87, 88, -1, -1, 91, 92, 93, -1, -1,
- -1, -1, -1, 39, -1, -1, -1, -1, -1, 105,
- 106, 107, 108, -1, 110, 111, 112, 113, 114, -1,
- -1, -1, -1, -1, 120, -1, 122, -1, -1, 125,
- 66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
+ -1, -1, 92, 93, 94, -1, 96, 97, 98, -1,
+ -1, -1, 40, -1, -1, -1, -1, -1, -1, 109,
+ -1, 111, 112, -1, 114, 115, 116, 117, 118, -1,
+ -1, -1, -1, -1, 124, -1, 126, -1, -1, 129,
+ 68, 69, 70, -1, 72, 73, 74, 75, 76, 77,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 87, 88, -1, -1, 91, 92, 93, -1, -1,
- -1, -1, -1, 39, -1, -1, -1, -1, -1, -1,
- 106, 107, 108, -1, 110, 111, 112, 113, 114, -1,
- -1, -1, -1, -1, 120, -1, 122, -1, -1, 125,
- 66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 87, 88, -1, -1, 91, 92, 93, -1, -1,
- -1, -1, -1, 39, -1, -1, -1, -1, -1, -1,
- 106, 107, 108, -1, 110, 111, 112, 113, 114, -1,
- -1, -1, -1, -1, 120, -1, 122, -1, -1, 125,
- 66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 87, 88, -1, -1, 91, 92, 93, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 107, 108, -1, 110, 111, 112, 113, 114, -1,
- -1, -1, -1, -1, 120, -1, 122, -1, -1, 125
+ -1, -1, -1, -1, 92, 93, 94, -1, 96, 97,
+ 98, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 111, 112, -1, 114, 115, 116, 117,
+ 118, -1, -1, -1, -1, -1, 124, -1, 126, -1,
+ -1, 129
};
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
-static const yytype_uint8 yystos[] =
+static const yytype_uint16 yystos[] =
{
- 0, 3, 4, 5, 7, 8, 9, 10, 11, 12,
- 13, 14, 15, 18, 19, 20, 21, 23, 24, 25,
- 26, 28, 35, 37, 38, 40, 42, 44, 46, 47,
- 48, 51, 52, 54, 55, 62, 63, 87, 88, 96,
- 110, 115, 116, 120, 122, 124, 132, 133, 134, 135,
- 141, 144, 150, 154, 155, 156, 157, 159, 167, 175,
- 178, 181, 184, 185, 186, 187, 191, 193, 202, 209,
- 212, 224, 225, 226, 229, 230, 231, 232, 235, 49,
- 120, 120, 160, 120, 3, 18, 124, 179, 180, 231,
- 3, 211, 231, 120, 3, 180, 214, 215, 216, 120,
- 124, 120, 125, 231, 120, 231, 231, 231, 231, 231,
- 229, 221, 222, 228, 231, 228, 233, 234, 0, 135,
- 3, 31, 45, 146, 152, 153, 230, 26, 30, 31,
- 43, 45, 201, 187, 97, 39, 66, 67, 68, 69,
- 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
- 80, 81, 82, 83, 84, 85, 87, 88, 91, 92,
- 93, 99, 102, 104, 105, 106, 107, 108, 110, 111,
- 112, 113, 114, 120, 122, 125, 120, 158, 22, 29,
- 36, 41, 45, 65, 96, 124, 141, 142, 143, 146,
- 161, 162, 177, 185, 227, 236, 237, 168, 183, 124,
- 125, 223, 120, 229, 125, 231, 176, 221, 3, 151,
- 130, 123, 97, 103, 129, 97, 3, 147, 148, 3,
- 147, 96, 67, 34, 50, 208, 3, 3, 3, 231,
- 231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
- 231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
- 231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
- 231, 231, 231, 231, 231, 231, 221, 231, 3, 229,
- 17, 3, 229, 229, 3, 129, 140, 142, 231, 96,
- 13, 17, 231, 96, 136, 137, 138, 144, 191, 193,
- 202, 209, 182, 179, 120, 220, 3, 90, 205, 206,
- 207, 130, 3, 113, 130, 139, 140, 130, 229, 228,
- 228, 228, 103, 219, 97, 219, 229, 229, 3, 53,
- 188, 53, 189, 219, 103, 130, 123, 130, 3, 129,
- 142, 120, 3, 130, 129, 138, 136, 221, 99, 103,
- 203, 207, 130, 97, 143, 129, 130, 103, 35, 113,
- 180, 216, 218, 99, 145, 148, 96, 130, 120, 216,
- 16, 190, 216, 217, 124, 145, 231, 143, 229, 99,
- 124, 129, 130, 4, 7, 8, 9, 11, 44, 54,
- 55, 204, 218, 219, 90, 207, 27, 32, 169, 171,
- 173, 174, 143, 228, 125, 228, 230, 143, 205, 217,
- 124, 97, 194, 130, 3, 4, 33, 61, 163, 164,
- 165, 166, 203, 124, 207, 124, 120, 169, 171, 64,
- 149, 130, 130, 192, 216, 45, 96, 185, 198, 199,
- 200, 231, 103, 129, 165, 166, 213, 172, 3, 143,
- 143, 219, 96, 141, 185, 195, 196, 197, 202, 209,
- 3, 26, 129, 200, 103, 139, 139, 139, 219, 124,
- 129, 197, 208, 139, 129, 129, 130, 210, 3, 170,
- 139, 120, 124, 129, 205, 139, 130, 129, 219
+ 0, 3, 4, 5, 6, 8, 9, 10, 11, 12,
+ 13, 14, 17, 18, 19, 20, 21, 22, 23, 24,
+ 25, 26, 28, 29, 36, 38, 39, 41, 43, 45,
+ 47, 48, 49, 52, 53, 55, 56, 63, 64, 65,
+ 71, 92, 93, 101, 111, 114, 119, 120, 124, 126,
+ 128, 130, 137, 138, 139, 140, 146, 149, 151, 159,
+ 162, 163, 164, 165, 166, 173, 181, 184, 185, 188,
+ 191, 192, 193, 194, 198, 200, 209, 214, 215, 216,
+ 227, 234, 237, 250, 251, 252, 257, 261, 265, 266,
+ 268, 269, 270, 91, 50, 124, 124, 156, 157, 124,
+ 3, 4, 16, 17, 29, 128, 186, 187, 16, 3,
+ 261, 3, 236, 261, 124, 3, 187, 240, 261, 128,
+ 124, 129, 16, 261, 124, 3, 5, 8, 9, 10,
+ 258, 259, 260, 261, 261, 261, 261, 261, 256, 261,
+ 246, 247, 248, 254, 261, 30, 32, 37, 42, 46,
+ 67, 101, 134, 145, 146, 147, 151, 153, 167, 168,
+ 183, 192, 253, 3, 0, 140, 128, 3, 46, 153,
+ 160, 161, 257, 147, 148, 16, 26, 31, 32, 44,
+ 46, 208, 267, 194, 3, 128, 221, 225, 102, 40,
+ 68, 69, 70, 72, 73, 74, 75, 76, 77, 78,
+ 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ 89, 90, 92, 93, 94, 96, 97, 98, 104, 105,
+ 107, 108, 109, 111, 112, 114, 115, 116, 117, 118,
+ 124, 126, 129, 3, 124, 255, 256, 12, 148, 174,
+ 190, 128, 129, 186, 187, 239, 240, 241, 249, 124,
+ 255, 129, 182, 246, 3, 104, 255, 134, 106, 102,
+ 102, 135, 127, 102, 254, 3, 3, 154, 155, 255,
+ 255, 154, 3, 134, 147, 128, 138, 3, 101, 69,
+ 101, 3, 35, 51, 233, 3, 3, 210, 261, 3,
+ 221, 226, 228, 229, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 261, 117, 130,
+ 186, 264, 261, 261, 261, 261, 261, 261, 261, 261,
+ 261, 261, 261, 261, 261, 261, 261, 246, 261, 3,
+ 4, 117, 124, 126, 130, 263, 264, 135, 124, 261,
+ 101, 126, 141, 142, 143, 149, 151, 198, 200, 209,
+ 234, 189, 186, 129, 124, 245, 3, 95, 230, 231,
+ 232, 135, 117, 186, 144, 145, 135, 261, 135, 254,
+ 259, 261, 106, 244, 102, 145, 134, 244, 255, 255,
+ 104, 3, 54, 195, 54, 196, 3, 211, 212, 222,
+ 104, 104, 112, 116, 217, 229, 126, 264, 106, 135,
+ 127, 262, 261, 126, 264, 91, 156, 255, 135, 150,
+ 134, 143, 128, 141, 246, 104, 106, 213, 232, 135,
+ 102, 134, 156, 106, 36, 117, 241, 243, 104, 152,
+ 155, 134, 101, 135, 3, 5, 124, 241, 15, 197,
+ 241, 242, 128, 244, 102, 134, 5, 221, 5, 221,
+ 218, 223, 261, 261, 261, 127, 261, 264, 135, 128,
+ 261, 141, 134, 135, 261, 243, 244, 95, 232, 27,
+ 33, 175, 177, 179, 180, 66, 158, 254, 261, 257,
+ 156, 230, 242, 128, 102, 201, 152, 212, 112, 5,
+ 111, 112, 128, 219, 224, 227, 127, 135, 127, 34,
+ 62, 169, 170, 171, 172, 127, 134, 213, 128, 232,
+ 128, 124, 175, 177, 156, 135, 135, 199, 241, 46,
+ 101, 192, 205, 206, 207, 116, 261, 111, 227, 223,
+ 261, 106, 134, 171, 172, 238, 178, 3, 156, 244,
+ 101, 146, 151, 192, 202, 203, 204, 209, 234, 3,
+ 26, 134, 207, 225, 220, 116, 223, 106, 144, 144,
+ 144, 244, 128, 128, 134, 204, 233, 218, 134, 225,
+ 144, 134, 134, 135, 235, 202, 3, 112, 218, 176,
+ 144, 134, 124, 112, 128, 134, 230, 144, 135, 134,
+ 244
};
#define yyerrok (yyerrstatus = 0)
@@ -3480,7 +4151,6 @@ yydestruct (yymsg, yytype, yyvaluep)
switch (yytype)
{
-
default:
break;
}
@@ -3488,13 +4158,15 @@ yydestruct (yymsg, yytype, yyvaluep)
/* Prevent warnings from -Wmissing-prototypes. */
#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
int yyparse (void *YYPARSE_PARAM);
#else
int yyparse ();
#endif
#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
int yyparse (void);
#else
int yyparse ();
@@ -3781,34 +4453,31 @@ yyreduce:
switch (yyn)
{
- case 24:
+ case 13:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1654 "parser.y"
- {(yyval.code)=(yyvsp[(1) - (1)].code);}
+#line 1980 "parser.y"
+ {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
}
break;
- case 25:
+ case 24:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1655 "parser.y"
- {(yyval.code)=code_new();}
+#line 1992 "parser.y"
+ {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
}
break;
- case 26:
+ case 25:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1657 "parser.y"
- {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));}
+#line 1993 "parser.y"
+ {PASS_ALWAYS as3_pass=(yyvsp[(2) - (4)].number_int);PASS1 as3_warning("embed command ignored");}
}
break;
@@ -3816,312 +4485,385 @@ yyreduce:
case 27:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1658 "parser.y"
+#line 1996 "parser.y"
{(yyval.code)=(yyvsp[(1) - (1)].code);}
}
break;
- case 38:
+ case 28:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1673 "parser.y"
- {(yyval.code)=0;}
+#line 1997 "parser.y"
+ {(yyval.code)=code_new();}
}
break;
- case 45:
+ case 29:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1681 "parser.y"
- {/*TODO*/(yyval.code)=0;}
+#line 1999 "parser.y"
+ {
+ (yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));
+}
}
break;
- case 46:
+ case 30:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1682 "parser.y"
- {/*TODO*/(yyval.code)=0;}
+#line 2002 "parser.y"
+ {(yyval.code)=(yyvsp[(1) - (1)].code);}
}
break;
- case 47:
+ case 44:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1684 "parser.y"
+#line 2018 "parser.y"
{(yyval.code)=(yyvsp[(2) - (3)].code);}
}
break;
- case 48:
+ case 45:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2019 "parser.y"
+ {(yyval.code)=0;}
+ }
+ break;
+
+
+ case 46:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 1685 "parser.y"
+#line 2022 "parser.y"
{(yyval.code)=0;}
}
break;
- case 49:
+ case 53:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2029 "parser.y"
+ {
+ PASS_ALWAYS
+ if(as3_pass) {
+ (yyval.code) = (yyvsp[(3) - (4)].code);
+ } else {
+ (yyval.code) = 0;
+ }
+ as3_pass=(yyvsp[(1) - (4)].number_int);
+}
+ }
+ break;
+
+
+ case 54:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 1686 "parser.y"
+#line 2041 "parser.y"
{(yyval.code)=(yyvsp[(1) - (2)].code);}
}
break;
- case 50:
+ case 55:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1687 "parser.y"
+#line 2042 "parser.y"
{(yyval.code)=(yyvsp[(1) - (1)].code);}
}
break;
- case 51:
+ case 56:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1691 "parser.y"
+#line 2046 "parser.y"
{
- code_t**cc = &global->init->method->body->code;
- *cc = code_append(*cc, (yyvsp[(1) - (1)].code));
+ if((yyvsp[(1) - (1)].code)) {
+ if(!global->init)
+ global->init = abc_initscript(global->file);
+ code_t**cc = &global->init->method->body->code;
+ *cc = code_append(*cc, (yyvsp[(1) - (1)].code));
+ }
}
}
break;
- case 52:
+ case 57:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1698 "parser.y"
- {(yyval.value)=(yyvsp[(2) - (2)].value);}
+#line 2057 "parser.y"
+ {
+ PASS_ALWAYS
+ (yyval.number_int) = as3_pass;
+ as3_pass=0;
+}
}
break;
- case 53:
+ case 58:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2065 "parser.y"
+ {
+ PASS12
+ (yyval.number_int)=as3_pass;
+ char*key = concat3((yyvsp[(1) - (3)].id),"::",(yyvsp[(3) - (3)].id));
+ if(!definitions || !dict_contains(definitions, key)) {
+ as3_pass=0;
+ }
+ free(key);
+}
+ }
+ break;
+
+
+ case 59:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 1699 "parser.y"
- {(yyval.value).c=abc_pushundefined(0);
- (yyval.value).t=TYPE_ANY;
- }
+#line 2092 "parser.y"
+ {(yyval.node)=(yyvsp[(2) - (2)].node);}
}
break;
- case 54:
+ case 60:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2093 "parser.y"
+ {(yyval.node)=mkdummynode();}
+ }
+ break;
+
+
+ case 61:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 1703 "parser.y"
+#line 2095 "parser.y"
{(yyval.code)=(yyvsp[(2) - (2)].code);}
}
break;
- case 55:
+ case 62:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1704 "parser.y"
+#line 2096 "parser.y"
{(yyval.code)=(yyvsp[(2) - (2)].code);}
}
break;
- case 56:
+ case 63:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1706 "parser.y"
+#line 2098 "parser.y"
{(yyval.code) = (yyvsp[(1) - (1)].code);}
}
break;
- case 57:
+ case 64:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1707 "parser.y"
+#line 2099 "parser.y"
{(yyval.code) = code_append((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
}
break;
- case 58:
+ case 65:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1710 "parser.y"
+#line 2102 "parser.y"
{
- if(variable_exists((yyvsp[(1) - (3)].id)))
+PASS12
+ if(variable_exists((yyvsp[(1) - (3)].id)))
syntaxerror("Variable %s already defined", (yyvsp[(1) - (3)].id));
+PASS1
+ new_variable(state->method, (yyvsp[(1) - (3)].id), 0, 1, 0);
+PASS2
- if(!is_subtype_of((yyvsp[(3) - (3)].value).t, (yyvsp[(2) - (3)].classinfo))) {
- syntaxerror("Can't convert %s to %s", (yyvsp[(3) - (3)].value).t->name,
- (yyvsp[(2) - (3)].classinfo)->name);
+ char slot = 0;
+ int index = 0;
+ variable_t*v = 0;
+ if(state->method->uses_slots) {
+ v = find_slot(state->method, (yyvsp[(1) - (3)].id));
+ if(v && !v->init) {
+ // this variable is stored in a slot
+ v->init = 1;
+ v->type = (yyvsp[(2) - (3)].classinfo);
+ slot = 1;
+ }
+ }
+ if(!v) {
+ v = new_variable2(state->method, (yyvsp[(1) - (3)].id), (yyvsp[(2) - (3)].classinfo), 1, 0);
}
- int index = new_variable((yyvsp[(1) - (3)].id), (yyvsp[(2) - (3)].classinfo), 1);
+ (yyval.code) = slot?abc_getscopeobject(0, 1):0;
+ typedcode_t val = node_read((yyvsp[(3) - (3)].node));
+ if(!is_subtype_of(val.t, (yyvsp[(2) - (3)].classinfo))) {
+ syntaxerror("Can't convert %s to %s", val.t->name, (yyvsp[(2) - (3)].classinfo)->name);
+ }
if((yyvsp[(2) - (3)].classinfo)) {
- if((yyvsp[(3) - (3)].value).c->prev || (yyvsp[(3) - (3)].value).c->opcode != OPCODE_PUSHUNDEFINED) {
- (yyval.code) = (yyvsp[(3) - (3)].value).c;
- (yyval.code) = converttype((yyval.code), (yyvsp[(3) - (3)].value).t, (yyvsp[(2) - (3)].classinfo));
- (yyval.code) = abc_setlocal((yyval.code), index);
+ if(val.c->prev || val.c->opcode != OPCODE_PUSHUNDEFINED) {
+ (yyval.code) = code_append((yyval.code), val.c);
+ (yyval.code) = converttype((yyval.code), val.t, (yyvsp[(2) - (3)].classinfo));
} else {
- (yyval.code) = defaultvalue(0, (yyvsp[(2) - (3)].classinfo));
- (yyval.code) = abc_setlocal((yyval.code), index);
+ code_free(val.c);
+ (yyval.code) = defaultvalue((yyval.code), (yyvsp[(2) - (3)].classinfo));
}
} else {
- if((yyvsp[(3) - (3)].value).c->prev || (yyvsp[(3) - (3)].value).c->opcode != OPCODE_PUSHUNDEFINED) {
- (yyval.code) = (yyvsp[(3) - (3)].value).c;
+ if(val.c->prev || val.c->opcode != OPCODE_PUSHUNDEFINED) {
+ (yyval.code) = code_append((yyval.code), val.c);
(yyval.code) = abc_coerce_a((yyval.code));
- (yyval.code) = abc_setlocal((yyval.code), index);
} else {
- (yyval.code) = code_new();
+ // don't do anything
+ code_free(val.c);
+ code_free((yyval.code));
+ (yyval.code) = 0;
+ break;
}
}
-
- /* that's the default for a local register, anyway
- else {
- state->method->initcode = abc_pushundefined(state->method->initcode);
- state->method->initcode = abc_setlocal(state->method->initcode, index);
- }*/
- //printf("variable %s -> %d (%s)\n", $2->text, index, $4.t?$4.t->name:"");
+ if(slot) {
+ (yyval.code) = abc_setslot((yyval.code), v->index);
+ } else {
+ (yyval.code) = abc_setlocal((yyval.code), v->index);
+ v->init = do_init_variable((yyvsp[(1) - (3)].id));
+ }
}
}
break;
- case 59:
+ case 66:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1750 "parser.y"
- {(yyval.code) = code_new();}
+#line 2162 "parser.y"
+ {PASS12 new_state();}
}
break;
- case 60:
+ case 67:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1751 "parser.y"
- {(yyval.code)=(yyvsp[(2) - (2)].code);}
+#line 2162 "parser.y"
+ {
+ (yyval.code) = var_block((yyvsp[(2) - (2)].code), state->vars);
+ PASS12 old_state();
+}
}
break;
- case 61:
+ case 68:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1754 "parser.y"
- {new_state();}
+#line 2166 "parser.y"
+ {(yyval.code) = code_new();}
}
break;
- case 62:
+ case 69:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2167 "parser.y"
+ {(yyval.code)=(yyvsp[(2) - (2)].code);}
+ }
+ break;
+
+
+ case 70:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 1754 "parser.y"
+#line 2170 "parser.y"
{
-
(yyval.code) = code_new();
- (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (7)].value).c);
+ (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (6)].value).c);
code_t*myjmp,*myif = (yyval.code) = abc_iffalse((yyval.code), 0);
- (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (7)].code));
- if((yyvsp[(7) - (7)].code)) {
+ (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (6)].code));
+ if((yyvsp[(6) - (6)].code)) {
myjmp = (yyval.code) = abc_jump((yyval.code), 0);
}
myif->branch = (yyval.code) = abc_nop((yyval.code));
- if((yyvsp[(7) - (7)].code)) {
- (yyval.code) = code_append((yyval.code), (yyvsp[(7) - (7)].code));
+ if((yyvsp[(6) - (6)].code)) {
+ (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (6)].code));
myjmp->branch = (yyval.code) = abc_nop((yyval.code));
}
- (yyval.code) = var_block((yyval.code));
- old_state();
}
}
break;
- case 63:
+ case 71:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1773 "parser.y"
+#line 2186 "parser.y"
{(yyval.code)=code_new();}
}
break;
- case 66:
+ case 74:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1778 "parser.y"
+#line 2193 "parser.y"
{
- (yyval.id)=(yyvsp[(2) - (3)].id);new_variable((yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].classinfo),1);
+ PASS1 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable(state->method, (yyvsp[(2) - (3)].id),0,1,0);
+ PASS2 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable(state->method, (yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].classinfo),1,0);
}
}
break;
- case 67:
+ case 75:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1781 "parser.y"
+#line 2197 "parser.y"
{
+ PASS12
(yyval.id)=(yyvsp[(1) - (1)].id);
}
}
@@ -4129,33 +4871,30 @@ yyreduce:
- case 68:
+ case 76:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1785 "parser.y"
- {new_state();(yyval.for_start).name=(yyvsp[(1) - (2)].id);(yyval.for_start).each=0;}
+#line 2202 "parser.y"
+ {PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (2)].id);(yyval.for_start).each=0;}
}
break;
- case 69:
+ case 77:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1786 "parser.y"
- {new_state();(yyval.for_start).name=(yyvsp[(1) - (3)].id);(yyval.for_start).each=1;}
+#line 2203 "parser.y"
+ {PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (3)].id);(yyval.for_start).each=1;}
}
break;
- case 70:
+ case 78:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1788 "parser.y"
+#line 2205 "parser.y"
{
if((yyvsp[(1) - (8)].for_start).each) syntaxerror("invalid syntax: ; not allowed in for each statement");
(yyval.code) = code_new();
@@ -4172,25 +4911,25 @@ yyreduce:
continuejumpsto((yyval.code), (yyvsp[(1) - (8)].for_start).name, cont);
myif->branch = out;
- (yyval.code) = var_block((yyval.code));
- old_state();
+ (yyval.code) = var_block((yyval.code), state->vars);
+ PASS12 old_state();
}
}
break;
- case 71:
+ case 79:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1808 "parser.y"
+#line 2225 "parser.y"
{
- variable_t*var = find_variable((yyvsp[(2) - (6)].id));
- char*tmp1name = concat2((yyvsp[(2) - (6)].id), "__tmp1__");
- int it = new_variable(tmp1name, TYPE_INT, 0);
- char*tmp2name = concat2((yyvsp[(2) - (6)].id), "__array__");
- int array = new_variable(tmp1name, 0, 0);
+ variable_t*var = find_variable(state, (yyvsp[(2) - (6)].id));
+ if(!var) {
+ syntaxerror("variable %s not known in this scope", (yyvsp[(2) - (6)].id));
+ }
+ int it = alloc_local();
+ int array = alloc_local();
(yyval.code) = code_new();
(yyval.code) = code_append((yyval.code), (yyvsp[(4) - (6)].value).c);
@@ -4221,96 +4960,65 @@ yyreduce:
myif->branch = out;
- (yyval.code) = var_block((yyval.code));
- old_state();
+ (yyval.code) = abc_kill((yyval.code), it);
+ (yyval.code) = abc_kill((yyval.code), array);
- free(tmp1name);
- free(tmp2name);
+ (yyval.code) = var_block((yyval.code), state->vars);
+ PASS12 old_state();
}
}
break;
- case 72:
- if(as3_pass==2) {
-
-/* Line 1464 of skeleton.m4 */
-#line 1851 "parser.y"
- {new_state();}
- }
- break;
-
-
-
- case 73:
+ case 80:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1851 "parser.y"
+#line 2269 "parser.y"
{
(yyval.code) = code_new();
code_t*myjmp = (yyval.code) = abc_jump((yyval.code), 0);
code_t*loopstart = (yyval.code) = abc_label((yyval.code));
- (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (6)].code));
+ (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (5)].code));
code_t*cont = (yyval.code) = abc_nop((yyval.code));
myjmp->branch = cont;
- (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (6)].value).c);
+ (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (5)].value).c);
(yyval.code) = abc_iftrue((yyval.code), loopstart);
code_t*out = (yyval.code) = abc_nop((yyval.code));
- breakjumpsto((yyval.code), (yyvsp[(1) - (6)].id), out);
- continuejumpsto((yyval.code), (yyvsp[(1) - (6)].id), cont);
-
- (yyval.code) = var_block((yyval.code));
- old_state();
+ breakjumpsto((yyval.code), (yyvsp[(1) - (5)].id), out);
+ continuejumpsto((yyval.code), (yyvsp[(1) - (5)].id), cont);
}
}
break;
- case 74:
+ case 81:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1870 "parser.y"
- {new_state();}
- }
- break;
-
-
-
- case 75:
- if(as3_pass==2) {
-
-/* Line 1464 of skeleton.m4 */
-#line 1870 "parser.y"
+#line 2285 "parser.y"
{
(yyval.code) = code_new();
code_t*loopstart = (yyval.code) = abc_label((yyval.code));
- (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (7)].code));
+ (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (6)].code));
code_t*cont = (yyval.code) = abc_nop((yyval.code));
- (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (7)].value).c);
+ (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (6)].value).c);
(yyval.code) = abc_iftrue((yyval.code), loopstart);
code_t*out = (yyval.code) = abc_nop((yyval.code));
- breakjumpsto((yyval.code), (yyvsp[(1) - (7)].id), out);
- continuejumpsto((yyval.code), (yyvsp[(1) - (7)].id), cont);
-
- (yyval.code) = var_block((yyval.code));
- old_state();
+ breakjumpsto((yyval.code), (yyvsp[(1) - (6)].id), out);
+ continuejumpsto((yyval.code), (yyvsp[(1) - (6)].id), cont);
}
}
break;
- case 76:
+ case 82:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1885 "parser.y"
+#line 2297 "parser.y"
{
(yyval.code) = abc___break__(0, "");
}
@@ -4319,11 +5027,10 @@ yyreduce:
- case 77:
+ case 83:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1888 "parser.y"
+#line 2300 "parser.y"
{
(yyval.code) = abc___break__(0, (yyvsp[(2) - (2)].id));
}
@@ -4332,11 +5039,10 @@ yyreduce:
- case 78:
+ case 84:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1891 "parser.y"
+#line 2303 "parser.y"
{
(yyval.code) = abc___continue__(0, "");
}
@@ -4345,11 +5051,10 @@ yyreduce:
- case 79:
+ case 85:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1894 "parser.y"
+#line 2306 "parser.y"
{
(yyval.code) = abc___continue__(0, (yyvsp[(2) - (2)].id));
}
@@ -4358,80 +5063,73 @@ yyreduce:
- case 80:
+ case 86:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1898 "parser.y"
+#line 2310 "parser.y"
{(yyval.code)=0;}
}
break;
- case 81:
+ case 87:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1899 "parser.y"
+#line 2311 "parser.y"
{(yyval.code)=(yyvsp[(1) - (1)].code);}
}
break;
- case 82:
+ case 88:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1900 "parser.y"
+#line 2312 "parser.y"
{(yyval.code)=(yyvsp[(1) - (1)].code);}
}
break;
- case 83:
+ case 89:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1901 "parser.y"
+#line 2313 "parser.y"
{(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));}
}
break;
- case 84:
+ case 90:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1902 "parser.y"
+#line 2314 "parser.y"
{(yyval.code)=(yyvsp[(1) - (1)].code);}
}
break;
- case 85:
+ case 91:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1903 "parser.y"
+#line 2315 "parser.y"
{(yyval.code)=code_append((yyval.code),(yyvsp[(2) - (2)].code));}
}
break;
- case 86:
+ case 92:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1905 "parser.y"
+#line 2317 "parser.y"
{
- (yyval.code) = abc_dup(0);
- (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (4)].value).c);
+ (yyval.code) = abc_getlocal(0, state->switch_var);
+ (yyval.code) = code_append((yyval.code), node_read((yyvsp[(2) - (4)].node)).c);
code_t*j = (yyval.code) = abc_ifne((yyval.code), 0);
(yyval.code) = code_append((yyval.code), (yyvsp[(4) - (4)].code));
if((yyval.code)->opcode != OPCODE___BREAK__) {
@@ -4445,11 +5143,10 @@ yyreduce:
- case 87:
+ case 93:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1916 "parser.y"
+#line 2328 "parser.y"
{
(yyval.code) = (yyvsp[(3) - (3)].code);
}
@@ -4458,26 +5155,26 @@ yyreduce:
- case 88:
+ case 94:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1919 "parser.y"
- {new_state();}
+#line 2331 "parser.y"
+ {PASS12 new_state();state->switch_var=alloc_local();}
}
break;
- case 89:
+ case 95:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1919 "parser.y"
+#line 2331 "parser.y"
{
- (yyval.code)=(yyvsp[(4) - (8)].value).c;
+ (yyval.code) = node_read((yyvsp[(4) - (8)].node)).c;
+ (yyval.code) = abc_setlocal((yyval.code), state->switch_var);
(yyval.code) = code_append((yyval.code), (yyvsp[(7) - (8)].code));
- code_t*out = (yyval.code) = abc_pop((yyval.code));
+
+ code_t*out = (yyval.code) = abc_kill((yyval.code), state->switch_var);
breakjumpsto((yyval.code), (yyvsp[(1) - (8)].id), out);
code_t*c = (yyval.code),*lastblock=0;
@@ -4497,30 +5194,32 @@ yyreduce:
c=c->prev;
}
- (yyval.code) = var_block((yyval.code));
- old_state();
+ (yyval.code) = var_block((yyval.code), state->vars);
+ PASS12 old_state();
}
}
break;
- case 90:
+ case 96:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1948 "parser.y"
- {new_state();state->exception_name=(yyvsp[(3) - (5)].id);new_variable((yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].classinfo), 0);}
+#line 2362 "parser.y"
+ {PASS12 new_state();
+ state->exception_name=(yyvsp[(3) - (5)].id);
+ PASS1 new_variable(state->method, (yyvsp[(3) - (5)].id), 0, 0, 0);
+ PASS2 new_variable(state->method, (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].classinfo), 0, 0);
+ }
}
break;
- case 91:
+ case 97:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1949 "parser.y"
+#line 2367 "parser.y"
{
namespace_t name_ns = {ACCESS_PACKAGE, ""};
multiname_t name = {QNAME, &name_ns, 0, (yyvsp[(3) - (9)].id)};
@@ -4531,41 +5230,39 @@ yyreduce:
(yyval.exception) = e;
code_t*c = 0;
- int i = find_variable_safe((yyvsp[(3) - (9)].id))->index;
+ int i = find_variable_safe(state, (yyvsp[(3) - (9)].id))->index;
e->target = c = abc_nop(0);
c = abc_setlocal(c, i);
+ c = code_append(c, code_dup(state->method->scope_code));
c = code_append(c, (yyvsp[(8) - (9)].code));
c = abc_kill(c, i);
- c = var_block(c);
- old_state();
+ c = var_block(c, state->vars);
+ PASS12 old_state();
}
}
break;
- case 92:
+ case 98:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1968 "parser.y"
- {new_state();state->exception_name=0;}
+#line 2387 "parser.y"
+ {PASS12 new_state();state->exception_name=0;}
}
break;
- case 93:
+ case 99:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1968 "parser.y"
+#line 2387 "parser.y"
{
- (yyvsp[(4) - (5)].code) = var_block((yyvsp[(4) - (5)].code));
+ (yyvsp[(4) - (5)].code) = var_block((yyvsp[(4) - (5)].code), state->vars);
if(!(yyvsp[(4) - (5)].code)) {
(yyval.exception)=0;
- old_state();
} else {
NEW(abc_exception_t, e)
e->exc_type = 0; //all exceptions
@@ -4573,53 +5270,49 @@ yyreduce:
e->target = 0;
e->to = abc_nop(0);
e->to = code_append(e->to, (yyvsp[(4) - (5)].code));
- old_state();
(yyval.exception) = e;
}
+ PASS12 old_state();
}
}
break;
- case 94:
+ case 100:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1985 "parser.y"
+#line 2403 "parser.y"
{(yyval.catch_list).l=list_new();(yyval.catch_list).finally=0;list_append((yyval.catch_list).l,(yyvsp[(1) - (1)].exception));}
}
break;
- case 95:
+ case 101:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1986 "parser.y"
+#line 2404 "parser.y"
{(yyval.catch_list)=(yyvsp[(1) - (2)].catch_list);list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));}
}
break;
- case 96:
+ case 102:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1987 "parser.y"
+#line 2405 "parser.y"
{(yyval.catch_list)=(yyvsp[(1) - (1)].catch_list);}
}
break;
- case 97:
+ case 103:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1988 "parser.y"
+#line 2406 "parser.y"
{
(yyval.catch_list) = (yyvsp[(1) - (2)].catch_list);
(yyval.catch_list).finally = 0;
@@ -4633,11 +5326,10 @@ yyreduce:
- case 98:
+ case 104:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 1996 "parser.y"
+#line 2414 "parser.y"
{
(yyval.catch_list).l=list_new();
(yyval.catch_list).finally = 0;
@@ -4651,22 +5343,23 @@ yyreduce:
- case 99:
+ case 105:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2005 "parser.y"
- {new_state();}
+#line 2423 "parser.y"
+ {PASS12 new_state();
+ state->method->has_exceptions=1;
+ state->method->late_binding=1;//for invariant scope_code
+ }
}
break;
- case 100:
+ case 106:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2005 "parser.y"
+#line 2426 "parser.y"
{
code_t*out = abc_nop(0);
@@ -4679,7 +5372,7 @@ yyreduce:
int tmp;
if((yyvsp[(6) - (6)].catch_list).finally)
- tmp = new_variable("__finally__", 0, 0);
+ tmp = alloc_local();
abc_exception_list_t*l = (yyvsp[(6) - (6)].catch_list).l;
int count=0;
@@ -4692,6 +5385,7 @@ yyreduce:
parserassert((ptroff_t)(yyvsp[(6) - (6)].catch_list).finally);
// finally block
e->target = (yyval.code) = abc_nop((yyval.code));
+ (yyval.code) = code_append((yyval.code), code_dup(state->method->scope_code));
(yyval.code) = abc___rethrow__((yyval.code));
}
@@ -4706,19 +5400,18 @@ yyreduce:
list_concat(state->method->exceptions, (yyvsp[(6) - (6)].catch_list).l);
- (yyval.code) = var_block((yyval.code));
- old_state();
+ (yyval.code) = var_block((yyval.code), state->vars);
+ PASS12 old_state();
}
}
break;
- case 101:
+ case 107:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2050 "parser.y"
+#line 2472 "parser.y"
{
(yyval.code)=(yyvsp[(2) - (2)].value).c;
(yyval.code)=abc_throw((yyval.code));
@@ -4728,15 +5421,14 @@ yyreduce:
- case 102:
+ case 108:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2054 "parser.y"
+#line 2476 "parser.y"
{
if(!state->exception_name)
syntaxerror("re-throw only possible within a catch block");
- variable_t*v = find_variable(state->exception_name);
+ variable_t*v = find_variable(state, state->exception_name);
(yyval.code)=code_new();
(yyval.code)=abc_getlocal((yyval.code), v->index);
(yyval.code)=abc_throw((yyval.code));
@@ -4746,110 +5438,158 @@ yyreduce:
- case 103:
+ case 109:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2487 "parser.y"
+ {
+ new_state();
+ if(state->method->has_exceptions) {
+ int v = alloc_local();
+ state->method->scope_code = abc_getlocal(state->method->scope_code, v);
+ state->method->scope_code = abc_pushwith(state->method->scope_code);
+ (yyval.value_list).number = v;
+ }
+ (yyval.value_list).cc = (yyvsp[(3) - (4)].value).c;
+}
+ }
+ break;
+
+
+ case 110:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2065 "parser.y"
+#line 2497 "parser.y"
{
- (yyval.code) = (yyvsp[(3) - (5)].value).c;
- (yyval.code) = abc_pushscope((yyval.code));
- (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (5)].code));
+ /* remove getlocal;pushwith from scope code again */
+ state->method->scope_code = code_cutlast(code_cutlast(state->method->scope_code));
+
+ (yyval.code) = (yyvsp[(1) - (2)].value_list).cc;
+ if(state->method->has_exceptions) {
+ (yyval.code) = abc_dup((yyval.code));
+ (yyval.code) = abc_setlocal((yyval.code), (yyvsp[(1) - (2)].value_list).number);
+ }
+ (yyval.code) = abc_pushwith((yyval.code));
+ (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (2)].code));
(yyval.code) = abc_popscope((yyval.code));
+ old_state();
}
}
break;
- case 105:
+ case 112:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2075 "parser.y"
+#line 2515 "parser.y"
{PASS12 (yyval.id)="package";}
}
break;
- case 106:
+ case 113:
+ if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2516 "parser.y"
+ {PASS12 (yyval.id)="namespace";}
+ }
+ break;
+
+
+
+ case 114:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2517 "parser.y"
+ {PASS12 (yyval.id)="NaN";}
+ }
+ break;
+
+
+ case 115:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2077 "parser.y"
- {PASS12 (yyval.id) = concat3((yyvsp[(1) - (3)].id),".",(yyvsp[(3) - (3)].id));free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;}
+#line 2518 "parser.y"
+ {PASS12 (yyval.id)=(yyvsp[(1) - (1)].id);}
}
break;
- case 107:
+ case 116:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2520 "parser.y"
+ {PASS12 (yyval.id) = concat3((yyvsp[(1) - (3)].id),".",(yyvsp[(3) - (3)].id));free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;}
+ }
+ break;
+
+
+ case 117:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2078 "parser.y"
+#line 2521 "parser.y"
{PASS12 (yyval.id)=strdup((yyvsp[(1) - (1)].id));}
}
break;
- case 108:
+ case 118:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2080 "parser.y"
+#line 2523 "parser.y"
{PASS12 startpackage((yyvsp[(2) - (3)].id));free((yyvsp[(2) - (3)].id));(yyvsp[(2) - (3)].id)=0;}
}
break;
- case 109:
+ case 119:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2081 "parser.y"
+#line 2524 "parser.y"
{PASS12 endpackage();(yyval.code)=0;}
}
break;
- case 110:
+ case 120:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2082 "parser.y"
+#line 2525 "parser.y"
{PASS12 startpackage("");}
}
break;
- case 111:
+ case 121:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2083 "parser.y"
+#line 2526 "parser.y"
{PASS12 endpackage();(yyval.code)=0;}
}
break;
- case 112:
+ case 122:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2085 "parser.y"
+#line 2549 "parser.y"
{
- classinfo_t*c = (yyvsp[(2) - (2)].classinfo);
- if(!c)
- syntaxerror("Couldn't import class\n");
+ PASS12
+ slotinfo_t*s = registry_find(state->package, (yyvsp[(2) - (2)].id));
+ if(!s && as3_pass==1) {as3_schedule_class(state->package, (yyvsp[(2) - (2)].id));}
state_has_imports();
- dict_put(state->imports, c->name, c);
+ dict_put(state->imports, state->package, (yyvsp[(2) - (2)].id));
(yyval.code)=0;
}
}
@@ -4857,16 +5597,41 @@ yyreduce:
- case 113:
+ case 123:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2557 "parser.y"
+ {
+ PASS12
+ slotinfo_t*s = registry_find((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);
+ if(!s && as3_pass==1) {// || !(s->flags&FLAG_BUILTIN)) {
+ as3_schedule_class((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);
+ }
+ state_has_imports();
+ dict_put(state->imports, (yyvsp[(2) - (2)].classinfo)->name, (yyvsp[(2) - (2)].classinfo));
+ import_toplevel((yyvsp[(2) - (2)].classinfo)->package);
+ (yyval.code)=0;
+}
+ }
+ break;
+
+
+ case 124:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2093 "parser.y"
+#line 2568 "parser.y"
{
+ PASS12
+ if(strncmp("flash.", (yyvsp[(2) - (4)].id), 6) && as3_pass==1) {
+ as3_schedule_package((yyvsp[(2) - (4)].id));
+ }
+
NEW(import_t,i);
i->package = (yyvsp[(2) - (4)].id);
state_has_imports();
list_append(state->wildcard_imports, i);
+ import_toplevel(i->package);
(yyval.code)=0;
}
}
@@ -4874,279 +5639,283 @@ yyreduce:
- case 114:
+ case 125:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2103 "parser.y"
- {PASS12 (yyval.flags)=0;}
+#line 2584 "parser.y"
+ {PASS12 (yyval.flags).flags=0;(yyval.flags).ns=0;}
}
break;
- case 115:
+ case 126:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2104 "parser.y"
+#line 2585 "parser.y"
{PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}
}
break;
- case 116:
+ case 127:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2105 "parser.y"
- {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].token);}
+#line 2586 "parser.y"
+ {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}
}
break;
- case 117:
+ case 128:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2106 "parser.y"
- {PASS12 (yyval.flags)=(yyvsp[(1) - (2)].flags)|(yyvsp[(2) - (2)].token);}
+#line 2587 "parser.y"
+ {
+ PASS12
+ (yyval.flags).flags=(yyvsp[(1) - (2)].flags).flags|(yyvsp[(2) - (2)].flags).flags;
+ if((yyvsp[(1) - (2)].flags).ns && (yyvsp[(2) - (2)].flags).ns) syntaxerror("only one namespace allowed in one declaration");
+ (yyval.flags).ns=(yyvsp[(1) - (2)].flags).ns?(yyvsp[(1) - (2)].flags).ns:(yyvsp[(2) - (2)].flags).ns;
+
+}
}
break;
- case 118:
+ case 129:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2108 "parser.y"
- {PASS12 (yyval.token)=FLAG_PUBLIC;}
+#line 2594 "parser.y"
+ {PASS12 (yyval.flags).flags=FLAG_PUBLIC;(yyval.flags).ns=0;}
}
break;
- case 119:
+ case 130:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2109 "parser.y"
- {PASS12 (yyval.token)=FLAG_PRIVATE;}
+#line 2595 "parser.y"
+ {PASS12 (yyval.flags).flags=FLAG_PRIVATE;(yyval.flags).ns=0;}
}
break;
- case 120:
+ case 131:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2110 "parser.y"
- {PASS12 (yyval.token)=FLAG_PROTECTED;}
+#line 2596 "parser.y"
+ {PASS12 (yyval.flags).flags=FLAG_PROTECTED;(yyval.flags).ns=0;}
}
break;
- case 121:
+ case 132:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2111 "parser.y"
- {PASS12 (yyval.token)=FLAG_STATIC;}
+#line 2597 "parser.y"
+ {PASS12 (yyval.flags).flags=FLAG_STATIC;(yyval.flags).ns=0;}
}
break;
- case 122:
+ case 133:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2112 "parser.y"
- {PASS12 (yyval.token)=FLAG_DYNAMIC;}
+#line 2598 "parser.y"
+ {PASS12 (yyval.flags).flags=FLAG_DYNAMIC;(yyval.flags).ns=0;}
}
break;
- case 123:
+ case 134:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2113 "parser.y"
- {PASS12 (yyval.token)=FLAG_FINAL;}
+#line 2599 "parser.y"
+ {PASS12 (yyval.flags).flags=FLAG_FINAL;(yyval.flags).ns=0;}
}
break;
- case 124:
+ case 135:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2114 "parser.y"
- {PASS12 (yyval.token)=FLAG_OVERRIDE;}
+#line 2600 "parser.y"
+ {PASS12 (yyval.flags).flags=FLAG_OVERRIDE;(yyval.flags).ns=0;}
}
break;
- case 125:
+ case 136:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2115 "parser.y"
- {PASS12 (yyval.token)=FLAG_NATIVE;}
+#line 2601 "parser.y"
+ {PASS12 (yyval.flags).flags=FLAG_NATIVE;(yyval.flags).ns=0;}
}
break;
- case 126:
+ case 137:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2116 "parser.y"
- {PASS12 (yyval.token)=FLAG_PACKAGEINTERNAL;}
+#line 2602 "parser.y"
+ {PASS12 (yyval.flags).flags=FLAG_PACKAGEINTERNAL;(yyval.flags).ns=0;}
}
break;
- case 127:
+ case 138:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2118 "parser.y"
- {(yyval.classinfo)=registry_getobjectclass();}
+#line 2603 "parser.y"
+ {PASS12 (yyval.flags).flags=FLAG_NAMESPACE;
+ (yyval.flags).ns=(yyvsp[(1) - (1)].id);
+ }
}
break;
- case 128:
+ case 139:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2119 "parser.y"
- {(yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
+#line 2607 "parser.y"
+ {PASS12 (yyval.classinfo)=0;}
}
break;
- case 129:
+ case 140:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2608 "parser.y"
+ {PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
+ }
+ break;
+
+
+ case 141:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2121 "parser.y"
+#line 2610 "parser.y"
{PASS12 (yyval.classinfo_list)=list_new();}
}
break;
- case 130:
+ case 142:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2122 "parser.y"
+#line 2611 "parser.y"
{PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
}
break;
- case 131:
+ case 143:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2124 "parser.y"
+#line 2613 "parser.y"
{PASS12 (yyval.classinfo_list)=list_new();}
}
break;
- case 132:
+ case 144:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2125 "parser.y"
+#line 2614 "parser.y"
{PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
}
break;
- case 133:
+ case 145:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2129 "parser.y"
- {PASS12 startclass((yyvsp[(1) - (6)].flags),(yyvsp[(3) - (6)].id),(yyvsp[(4) - (6)].classinfo),(yyvsp[(5) - (6)].classinfo_list), 0);}
+#line 2618 "parser.y"
+ {PASS12 startclass(&(yyvsp[(1) - (6)].flags),(yyvsp[(3) - (6)].id),(yyvsp[(4) - (6)].classinfo),(yyvsp[(5) - (6)].classinfo_list));}
}
break;
- case 134:
+ case 146:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2131 "parser.y"
+#line 2620 "parser.y"
{PASS12 endclass();(yyval.code)=0;}
}
break;
- case 135:
+ case 147:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2135 "parser.y"
- {PASS12 startclass((yyvsp[(1) - (5)].flags),(yyvsp[(3) - (5)].id),0,(yyvsp[(4) - (5)].classinfo_list),1);}
+#line 2624 "parser.y"
+ {PASS12 (yyvsp[(1) - (5)].flags).flags|=FLAG_INTERFACE;
+ startclass(&(yyvsp[(1) - (5)].flags),(yyvsp[(3) - (5)].id),0,(yyvsp[(4) - (5)].classinfo_list));}
}
break;
- case 136:
+ case 148:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2137 "parser.y"
+#line 2627 "parser.y"
{PASS12 endclass();(yyval.code)=0;}
}
break;
- case 144:
+ case 154:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2636 "parser.y"
+ {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
+ }
+ break;
+
+
+ case 157:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2149 "parser.y"
+#line 2640 "parser.y"
{
- code_t*c = state->cls->static_init;
+ code_t*c = state->cls->static_init->header;
c = code_append(c, (yyvsp[(1) - (1)].code));
- state->cls->static_init = c;
+ state->cls->static_init->header = c;
}
}
break;
- case 150:
+ case 163:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2160 "parser.y"
+#line 2651 "parser.y"
{
syntaxerror("variable declarations not allowed in interfaces");
}
@@ -5155,82 +5924,145 @@ yyreduce:
- case 151:
+ case 164:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2163 "parser.y"
+#line 2654 "parser.y"
{
PASS12
- (yyvsp[(1) - (8)].flags) |= FLAG_PUBLIC;
- if((yyvsp[(1) - (8)].flags)&(FLAG_PRIVATE|FLAG_PACKAGEINTERNAL|FLAG_PROTECTED)) {
+ (yyvsp[(1) - (8)].flags).flags |= FLAG_PUBLIC;
+ if((yyvsp[(1) - (8)].flags).flags&(FLAG_PRIVATE|FLAG_PACKAGEINTERNAL|FLAG_PROTECTED)) {
syntaxerror("invalid method modifiers: interface methods always need to be public");
}
- startfunction(0,(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo));
- endfunction(0,(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo), 0);
+ startfunction(&(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo));
+ endfunction(&(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo), 0);
+ list_deep_free((yyvsp[(6) - (8)].params).list);
}
}
break;
- case 154:
+ case 167:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2729 "parser.y"
+ {PASS12 setslotstate(&(yyvsp[(1) - (2)].flags),(yyvsp[(2) - (2)].token));}
+ }
+ break;
+
+
+ case 168:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2177 "parser.y"
- {
- int flags = (yyvsp[(1) - (5)].flags);
- memberinfo_t* info = state->cls?
- memberinfo_register(state->cls->info, (yyvsp[(3) - (5)].id), MEMBER_SLOT):
- memberinfo_register_global(flags2access((yyvsp[(1) - (5)].flags)), state->package, (yyvsp[(3) - (5)].id), MEMBER_SLOT);
+#line 2729 "parser.y"
+ {PASS12 (yyval.code)=(yyvsp[(4) - (4)].code);setslotstate(0, 0);}
+ }
+ break;
- info->type = (yyvsp[(4) - (5)].classinfo);
- info->flags = flags;
- /* slot name */
- namespace_t mname_ns = {flags2access(flags), ""};
- multiname_t mname = {QNAME, &mname_ns, 0, (yyvsp[(3) - (5)].id)};
- trait_list_t**traits;
- code_t**code;
- if(!state->cls) {
- // global variable
- mname_ns.name = state->package;
- traits = &global->init->traits;
- code = &global->init->method->body->code;
- } else if(flags&FLAG_STATIC) {
- // static variable
- traits = &state->cls->abc->static_traits;
- code = &state->cls->static_init;
- } else {
- // instance variable
- traits = &state->cls->abc->traits;
- code = &state->cls->init;
+ case 169:
+ if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2731 "parser.y"
+ {PASS12 (yyval.code)=0;}
}
-
- trait_t*t=0;
- if((yyvsp[(4) - (5)].classinfo)) {
- MULTINAME(m, (yyvsp[(4) - (5)].classinfo));
- t = trait_new_member(traits, multiname_clone(&m), multiname_clone(&mname), 0);
- } else {
- t = trait_new_member(traits, 0, multiname_clone(&mname), 0);
+ break;
+
+
+
+ case 170:
+ if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2732 "parser.y"
+ {PASS12 (yyval.code)=0;}
}
- info->slot = t->slot_id;
-
- /* initalization code (if needed) */
- code_t*c = 0;
- if((yyvsp[(5) - (5)].value).c && !is_pushundefined((yyvsp[(5) - (5)].value).c)) {
- c = abc_getlocal_0(c);
- c = code_append(c, (yyvsp[(5) - (5)].value).c);
- c = converttype(c, (yyvsp[(5) - (5)].value).t, (yyvsp[(4) - (5)].classinfo));
- c = abc_setslot(c, t->slot_id);
+ break;
+
+
+
+ case 171:
+ if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2735 "parser.y"
+ {
+PASS12
+ int flags = slotstate_flags->flags;
+ namespace_t ns = modifiers2access(slotstate_flags);
+
+ if(as3_pass == 1) {
+
+ varinfo_t* info = 0;
+ if(state->cls) {
+ memberinfo_t*i = registry_findmember(state->cls->info, ns.name, (yyvsp[(1) - (3)].id), 1);
+ if(i) {
+ check_override(i, flags);
+ }
+ info = varinfo_register_onclass(state->cls->info, ns.access, ns.name, (yyvsp[(1) - (3)].id));
+ } else {
+ slotinfo_t*i = registry_find(state->package, (yyvsp[(1) - (3)].id));
+ if(i) {
+ syntaxerror("package %s already contains '%s'", state->package, (yyvsp[(1) - (3)].id));
+ }
+ if(ns.name && ns.name[0]) {
+ syntaxerror("namespaces not allowed on package-level variables");
+ }
+ info = varinfo_register_global(ns.access, state->package, (yyvsp[(1) - (3)].id));
+ }
+
+ info->type = (yyvsp[(2) - (3)].classinfo);
+ info->flags = flags;
+
+ dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, info);
}
- *code = code_append(*code, c);
+ if(as3_pass == 2) {
+ varinfo_t*info = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
+
+ multiname_t mname;
+ code_t**code;
+ trait_t*t = add_abc_slot(slotstate_flags, (yyvsp[(1) - (3)].id), &mname, &code);
- if((yyvsp[(2) - (5)].token)==KW_CONST) {
- t->kind= TRAIT_CONST;
+ if((yyvsp[(2) - (3)].classinfo)) {
+ MULTINAME(m, (yyvsp[(2) - (3)].classinfo));
+ t->type_name = multiname_clone(&m);
+ }
+ info->slot = t->slot_id;
+
+ /* workaround for "VerifyError: Error #1053: Illegal override of ::test2 in C1"
+ FIXME: is there a way to use slots and still don't have conflicting overrides?
+ */
+ info->slot = t->slot_id = 0;
+
+ constant_t cval = (yyvsp[(3) - (3)].node)->type->eval((yyvsp[(3) - (3)].node));
+ if(cval.type!=CONSTANT_UNKNOWN) {
+ /* compile time constant */
+ t->value = malloc(sizeof(constant_t));
+ memcpy(t->value, &cval, sizeof(constant_t));
+ info->value = constant_clone(t->value);
+ } else {
+ typedcode_t v = node_read((yyvsp[(3) - (3)].node));
+ /* initalization code (if needed) */
+ code_t*c = 0;
+ if(v.c && !is_pushundefined(v.c)) {
+ c = abc_getlocal_0(c);
+ c = code_append(c, v.c);
+ c = converttype(c, v.t, (yyvsp[(2) - (3)].classinfo));
+ if(!t->slot_id) {
+ c = abc_initproperty2(c, &mname);
+ } else {
+ c = abc_setslot(c, t->slot_id);
+ }
+ }
+ *code = code_append(*code, c);
+ }
+
+ if(slotstate_varconst==KW_CONST) {
+ t->kind= TRAIT_CONST;
+ info->flags |= FLAG_CONST;
+ }
}
(yyval.code)=0;
@@ -5240,300 +6072,621 @@ yyreduce:
- case 155:
+ case 172:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2236 "parser.y"
+#line 2818 "parser.y"
{(yyval.constant)=0;}
}
break;
- case 156:
+ case 173:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2819 "parser.y"
+ {
+ (yyval.constant) = malloc(sizeof(constant_t));
+ *(yyval.constant) = node_eval((yyvsp[(2) - (2)].node));
+ if((yyval.constant)->type == CONSTANT_UNKNOWN) {
+ syntaxerror("can't evaluate default parameter value (needs to be a compile-time constant)");
+ }
+}
+ }
+ break;
+
+
+ case 174:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2237 "parser.y"
- {(yyval.constant)=(yyvsp[(2) - (2)].constant);}
+#line 2828 "parser.y"
+ {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_int));}
}
break;
- case 157:
+ case 175:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2829 "parser.y"
+ {
+ (yyval.constant) = constant_new_uint((yyvsp[(1) - (1)].number_uint));
+}
+ }
+ break;
+
+
+ case 176:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2239 "parser.y"
- {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_uint));}
+#line 2832 "parser.y"
+ {(yyval.constant) = constant_new_float((yyvsp[(1) - (1)].number_float));}
}
break;
- case 158:
+ case 177:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2833 "parser.y"
+ {(yyval.constant) = constant_new_string2((yyvsp[(1) - (1)].str).str,(yyvsp[(1) - (1)].str).len);free((char*)(yyvsp[(1) - (1)].str).str);}
+ }
+ break;
+
+
+ case 178:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2240 "parser.y"
- {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_int));}
+#line 2834 "parser.y"
+ {(yyval.constant) = constant_new_true((yyvsp[(1) - (1)].token));}
}
break;
- case 159:
+ case 179:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2835 "parser.y"
+ {(yyval.constant) = constant_new_false((yyvsp[(1) - (1)].token));}
+ }
+ break;
+
+
+ case 180:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2241 "parser.y"
- {(yyval.constant) = constant_new_uint((yyvsp[(1) - (1)].number_uint));}
+#line 2836 "parser.y"
+ {(yyval.constant) = constant_new_null((yyvsp[(1) - (1)].token));}
}
break;
- case 160:
+ case 181:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2837 "parser.y"
+ {(yyval.constant) = constant_new_undefined((yyvsp[(1) - (1)].token));}
+ }
+ break;
+
+
+ case 182:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2242 "parser.y"
- {(yyval.constant) = constant_new_float((yyvsp[(1) - (1)].number_float));}
+#line 2838 "parser.y"
+ {(yyval.constant) = constant_new_float(__builtin_nan(""));}
}
break;
- case 161:
+ case 183:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2851 "parser.y"
+ {
+ multiname_t m = {QNAME, &stdns, 0, "XML"};
+ typedcode_t v;
+ v.c = 0;
+ v.c = abc_getlex2(v.c, &m);
+ v.c = code_append(v.c, node_read((yyvsp[(1) - (1)].node)).c);
+ v.c = abc_construct(v.c, 1);
+ v.t = TYPE_XML;
+ (yyval.node) = mkcodenode(v);
+}
+ }
+ break;
+
+
+ case 184:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2243 "parser.y"
- {(yyval.constant) = constant_new_string2((yyvsp[(1) - (1)].str).str,(yyvsp[(1) - (1)].str).len);}
+#line 2862 "parser.y"
+ {PASS_ALWAYS if(!xml_level++) tokenizer_begin_xml();}
}
break;
- case 162:
+ case 185:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2863 "parser.y"
+ {PASS_ALWAYS tokenizer_begin_xmltext();}
+ }
+ break;
+
+
+ case 186:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2245 "parser.y"
- {(yyval.constant) = constant_new_true((yyvsp[(1) - (1)].token));}
+#line 2864 "parser.y"
+ {PASS_ALWAYS if(!--xml_level) tokenizer_end_xml(); else tokenizer_begin_xmltext();}
}
break;
- case 163:
+ case 187:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2866 "parser.y"
+ {PASS_ALWAYS tokenizer_begin_xmltext();}
+ }
+ break;
+
+
+ case 188:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2246 "parser.y"
- {(yyval.constant) = constant_new_false((yyvsp[(1) - (1)].token));}
+#line 2866 "parser.y"
+ {
+ (yyval.node) = (yyvsp[(2) - (4)].node);
+}
}
break;
- case 164:
+ case 189:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2869 "parser.y"
+ {PASS_ALWAYS tokenizer_begin_xml();}
+ }
+ break;
+
+
+ case 190:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2247 "parser.y"
- {(yyval.constant) = constant_new_null((yyvsp[(1) - (1)].token));}
+#line 2869 "parser.y"
+ {
+ (yyval.node) = (yyvsp[(2) - (4)].node);
+}
}
break;
- case 165:
+ case 191:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2872 "parser.y"
+ {(yyval.node)=mkstringnode("");}
+ }
+ break;
+
+
+ case 192:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2252 "parser.y"
+#line 2873 "parser.y"
{
- PASS12
- memset(&(yyval.params),0,sizeof((yyval.params)));
+ (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node));
}
}
break;
- case 166:
+ case 193:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2876 "parser.y"
+ {
+ char* str = string_cstr(&(yyvsp[(2) - (2)].str));
+ (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),mkstringnode(str));
+ free(str);
+}
+ }
+ break;
+
+
+ case 194:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2256 "parser.y"
+#line 2881 "parser.y"
{
- PASS12
- (yyval.params)=(yyvsp[(1) - (1)].params);
+ (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node), mkstringnode(">"));
}
}
break;
- case 167:
+ case 195:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2884 "parser.y"
+ {
+ (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node));
+}
+ }
+ break;
+
+
+ case 196:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2262 "parser.y"
+#line 2887 "parser.y"
{
- PASS12
- memset(&(yyval.params),0,sizeof((yyval.params)));
- (yyval.params).varargs=1;
- list_append((yyval.params).list, (yyvsp[(2) - (2)].param));
+ (yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkaddnode((yyvsp[(2) - (3)].node),(yyvsp[(3) - (3)].node)));
}
}
break;
- case 168:
+ case 197:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2890 "parser.y"
+ {
+ (yyval.node) = mkstringnode((yyvsp[(1) - (1)].id));
+}
+ }
+ break;
+
+
+ case 198:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2268 "parser.y"
+#line 2893 "parser.y"
{
- PASS12
- (yyval.params) =(yyvsp[(1) - (4)].params);
- (yyval.params).varargs=1;
- list_append((yyval.params).list, (yyvsp[(4) - (4)].param));
+ (yyval.node) = (yyvsp[(1) - (1)].node);
}
}
break;
- case 169:
+ case 199:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2897 "parser.y"
+ {
+ (yyval.node) = mkstringnode("");
+}
+ }
+ break;
+
+
+ case 200:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2276 "parser.y"
+#line 2900 "parser.y"
{
- PASS12
- (yyval.params) = (yyvsp[(1) - (3)].params);
- list_append((yyval.params).list, (yyvsp[(3) - (3)].param));
+ (yyval.node) = mkaddnode(mkstringnode(" "),(yyvsp[(1) - (1)].node));
}
}
break;
- case 170:
+ case 201:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2904 "parser.y"
+ {
+ //$$ = allocprintf("<%s%s/>", $2, $3, $5, $8);
+ (yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkstringnode("<"),(yyvsp[(2) - (6)].node)),(yyvsp[(3) - (6)].node)),mkstringnode("/>"));
+}
+ }
+ break;
+
+
+ case 202:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2281 "parser.y"
+#line 2908 "parser.y"
{
- PASS12
- memset(&(yyval.params),0,sizeof((yyval.params)));
- list_append((yyval.params).list, (yyvsp[(1) - (1)].param));
+ //$$ = allocprintf("<%s%s>%s%s>", $2, $3, $5, $8);
+ (yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(
+ mkstringnode("<"),(yyvsp[(2) - (10)].node)),(yyvsp[(3) - (10)].node)),mkstringnode(">")),(yyvsp[(5) - (10)].node)),mkstringnode("")),(yyvsp[(8) - (10)].node)),mkstringnode(">"));
}
}
break;
- case 171:
+ case 203:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2913 "parser.y"
+ {
+ //$$ = allocprintf("<%s%s>%s%s%s>", $2, $3, $5, $6, $9);
+ (yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(
+ mkstringnode("<"),(yyvsp[(2) - (11)].node)),(yyvsp[(3) - (11)].node)),mkstringnode(">")),(yyvsp[(5) - (11)].node)),(yyvsp[(6) - (11)].node)),mkstringnode("")),(yyvsp[(9) - (11)].node)),mkstringnode(">"));
+}
+ }
+ break;
+
+
+ case 204:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2287 "parser.y"
+#line 2919 "parser.y"
{
- PASS1 (yyval.param)=0;
- PASS2
- (yyval.param) = malloc(sizeof(param_t));
- (yyval.param)->name=(yyvsp[(1) - (4)].id);
- (yyval.param)->type = (yyvsp[(3) - (4)].classinfo);
- (yyval.param)->value = (yyvsp[(4) - (4)].constant);
+ (yyval.node) = (yyvsp[(1) - (1)].node);
}
}
break;
- case 172:
+ case 205:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2922 "parser.y"
+ {
+ (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node), mkaddnode(mkstringnode(" "),(yyvsp[(2) - (2)].node)));
+}
+ }
+ break;
+
+
+ case 206:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2295 "parser.y"
+#line 2925 "parser.y"
{
- PASS1 (yyval.param)=0;
- PASS2
- (yyval.param) = malloc(sizeof(param_t));
- (yyval.param)->name=(yyvsp[(1) - (2)].id);
- (yyval.param)->type = TYPE_ANY;
- (yyval.param)->value = (yyvsp[(2) - (2)].constant);
+ (yyval.node) = (yyvsp[(1) - (1)].node);
}
}
break;
- case 173:
+ case 207:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2928 "parser.y"
+ {
+ char* str = string_cstr(&(yyvsp[(3) - (3)].str));
+ (yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkstringnode(concat2("=",str)));
+ free(str);
+}
+ }
+ break;
+
+
+ case 208:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2303 "parser.y"
- {(yyval.token)=(yyvsp[(1) - (1)].token);}
+#line 2933 "parser.y"
+ {
+ (yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkaddnode(mkstringnode("=\""), mkaddnode((yyvsp[(3) - (3)].node), mkstringnode("\""))));
+}
}
break;
- case 174:
+ case 209:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2936 "parser.y"
+ {
+ (yyval.node) = mkaddnode(mkaddnode(mkstringnode(concat2((yyvsp[(1) - (3)].id),"=\"")), (yyvsp[(3) - (3)].node)), mkstringnode("\""));
+}
+ }
+ break;
+
+
+ case 210:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2304 "parser.y"
- {(yyval.token)=(yyvsp[(1) - (1)].token);}
+#line 2939 "parser.y"
+ {
+ char* str = string_cstr(&(yyvsp[(3) - (3)].str));
+ (yyval.node)=mkstringnode(allocprintf("%s=%s", (yyvsp[(1) - (3)].id),str));
+ free(str);
+ free((yyvsp[(1) - (3)].id));free((char*)(yyvsp[(3) - (3)].str).str);
+}
}
break;
- case 175:
+ case 211:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2949 "parser.y"
+ {
+ PASS12
+ memset(&(yyval.params),0,sizeof((yyval.params)));
+}
+ }
+ break;
+
+
+ case 212:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2305 "parser.y"
- {(yyval.token)=0;}
+#line 2953 "parser.y"
+ {
+ PASS12
+ (yyval.params)=(yyvsp[(1) - (1)].params);
+}
}
break;
- case 176:
+ case 213:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2959 "parser.y"
+ {
+ PASS12
+ memset(&(yyval.params),0,sizeof((yyval.params)));
+ (yyval.params).varargs=1;
+ list_append((yyval.params).list, (yyvsp[(2) - (2)].param));
+}
+ }
+ break;
+
+
+ case 214:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2308 "parser.y"
- {PASS12 startfunction(0,(yyvsp[(1) - (9)].flags),(yyvsp[(3) - (9)].token),(yyvsp[(4) - (9)].id),&(yyvsp[(6) - (9)].params),(yyvsp[(8) - (9)].classinfo));}
+#line 2965 "parser.y"
+ {
+ PASS12
+ (yyval.params) =(yyvsp[(1) - (4)].params);
+ (yyval.params).varargs=1;
+ list_append((yyval.params).list, (yyvsp[(4) - (4)].param));
+}
}
break;
- case 177:
+ case 215:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2973 "parser.y"
+ {
+ PASS12
+ (yyval.params) = (yyvsp[(1) - (3)].params);
+ list_append((yyval.params).list, (yyvsp[(3) - (3)].param));
+}
+ }
+ break;
+
+
+ case 216:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2309 "parser.y"
+#line 2978 "parser.y"
{
- PASS1 old_state();
+ PASS12
+ memset(&(yyval.params),0,sizeof((yyval.params)));
+ list_append((yyval.params).list, (yyvsp[(1) - (1)].param));
+}
+ }
+ break;
+
+
+
+ case 217:
+ if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2984 "parser.y"
+ {
+ PASS12
+ (yyval.param) = rfx_calloc(sizeof(param_t));
+ (yyval.param)->name=(yyvsp[(1) - (4)].id);
+ (yyval.param)->type = (yyvsp[(3) - (4)].classinfo);
+ PASS2
+ (yyval.param)->value = (yyvsp[(4) - (4)].constant);
+}
+ }
+ break;
+
+
+
+ case 218:
+ if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 2992 "parser.y"
+ {
+ PASS12
+ (yyval.param) = rfx_calloc(sizeof(param_t));
+ (yyval.param)->name=(yyvsp[(1) - (2)].id);
+ (yyval.param)->type = TYPE_ANY;
+ PASS2
+ (yyval.param)->value = (yyvsp[(2) - (2)].constant);
+}
+ }
+ break;
+
+
+
+ case 221:
+ if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3002 "parser.y"
+ {PASS12 (yyval.token)=0;}
+ }
+ break;
+
+
+
+ case 222:
+ if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3005 "parser.y"
+ {PASS12 startfunction(&(yyvsp[(1) - (9)].flags),(yyvsp[(3) - (9)].token),(yyvsp[(4) - (9)].id),&(yyvsp[(6) - (9)].params),(yyvsp[(8) - (9)].classinfo));}
+ }
+ break;
+
+
+
+ case 223:
+ if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3006 "parser.y"
+ {
+ PASS1
+ endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),0,0);
PASS2
if(!state->method->info) syntaxerror("internal error");
- code_t*c = method_header();
+ code_t*c = method_header(state->method);
c = wrap_function(c, 0, (yyvsp[(11) - (12)].code));
- endfunction(0,(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),(yyvsp[(8) - (12)].classinfo),c);
+ endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),(yyvsp[(8) - (12)].classinfo),c);
+ PASS12
+ list_deep_free((yyvsp[(6) - (12)].params).list);
(yyval.code)=0;
}
}
@@ -5541,203 +6694,207 @@ yyreduce:
- case 179:
+ case 225:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2322 "parser.y"
+#line 3022 "parser.y"
{PASS12 (yyval.id)=0;}
}
break;
- case 180:
+ case 226:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2324 "parser.y"
+#line 3024 "parser.y"
{PASS12 innerfunction((yyvsp[(2) - (7)].id),&(yyvsp[(4) - (7)].params),(yyvsp[(6) - (7)].classinfo));}
}
break;
- case 181:
+ case 227:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2325 "parser.y"
+#line 3025 "parser.y"
{
- PASS1 old_state();
+ PASS1
+ endfunction(0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),0,0);
PASS2
- memberinfo_t*f = state->method->info;
- if(!f) syntaxerror("internal error");
+ methodinfo_t*f = state->method->info;
+ if(!f || !f->kind) syntaxerror("internal error");
- code_t*c = method_header();
+ code_t*c = method_header(state->method);
c = wrap_function(c, 0, (yyvsp[(9) - (10)].code));
int index = state->method->var_index;
- endfunction(0,0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),(yyvsp[(6) - (10)].classinfo),c);
+ endfunction(0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),(yyvsp[(6) - (10)].classinfo),c);
(yyval.value).c = abc_getlocal(0, index);
(yyval.value).t = TYPE_FUNCTION(f);
+
+ PASS12 list_deep_free((yyvsp[(4) - (10)].params).list);
}
}
break;
- case 182:
+ case 228:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2344 "parser.y"
+#line 3047 "parser.y"
{
- PASS1 (yyval.classinfo)=0;
+ PASS1 NEW(unresolvedinfo_t,c);
+ memset(c, 0, sizeof(*c));
+ c->kind = INFOTYPE_UNRESOLVED;
+ c->name = (yyvsp[(1) - (1)].id);
+ c->package = get_package_from_name((yyvsp[(1) - (1)].id));
+ if(!c->package) {
+ c->nsset = get_current_imports();
+ /* make the compiler look for this class in the current directory,
+ just in case: */
+ as3_schedule_class_noerror(state->package, (yyvsp[(1) - (1)].id));
+ }
+ (yyval.classinfo) = (classinfo_t*)c;
PASS2
- /* try current package */
- (yyval.classinfo) = find_class((yyvsp[(1) - (1)].id));
- if(!(yyval.classinfo)) syntaxerror("Could not find class %s\n", (yyvsp[(1) - (1)].id));
+ slotinfo_t*s = find_class((yyvsp[(1) - (1)].id));
+ if(!s) syntaxerror("Could not find class/method %s (current package: %s)\n", (yyvsp[(1) - (1)].id), state->package);
+ (yyval.classinfo) = (classinfo_t*)s;
}
}
break;
- case 183:
+ case 229:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2352 "parser.y"
+#line 3066 "parser.y"
{
- PASS1 (yyval.classinfo)=0;
+ PASS1 NEW(unresolvedinfo_t,c);
+ memset(c, 0, sizeof(*c));
+ c->kind = INFOTYPE_UNRESOLVED;
+ c->package = (yyvsp[(1) - (3)].id);
+ c->name = (yyvsp[(3) - (3)].id);
+ (yyval.classinfo) = (classinfo_t*)c;
PASS2
- (yyval.classinfo) = registry_findclass((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
- if(!(yyval.classinfo)) syntaxerror("Couldn't find class %s.%s\n", (yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
+ slotinfo_t*s = registry_find((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
+ if(!s) syntaxerror("Couldn't find class/method %s.%s\n", (yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;
+ (yyval.classinfo) = (classinfo_t*)s;
}
}
break;
- case 186:
+ case 232:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2363 "parser.y"
+#line 3083 "parser.y"
{PASS12 (yyval.classinfo_list)=list_new();list_append((yyval.classinfo_list), (yyvsp[(1) - (1)].classinfo));}
}
break;
- case 187:
+ case 233:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2364 "parser.y"
+#line 3084 "parser.y"
{PASS12 (yyval.classinfo_list)=(yyvsp[(1) - (3)].classinfo_list);list_append((yyval.classinfo_list),(yyvsp[(3) - (3)].classinfo));}
}
break;
- case 188:
+ case 234:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2366 "parser.y"
- {(yyval.classinfo)=(yyvsp[(1) - (1)].classinfo);}
+#line 3086 "parser.y"
+ {PASS12 (yyval.classinfo)=(yyvsp[(1) - (1)].classinfo);}
}
break;
- case 189:
+ case 235:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2367 "parser.y"
- {(yyval.classinfo)=registry_getanytype();}
+#line 3087 "parser.y"
+ {PASS12 (yyval.classinfo)=TYPE_ANY;}
}
break;
- case 190:
+ case 236:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2368 "parser.y"
- {(yyval.classinfo)=registry_getanytype();}
+#line 3088 "parser.y"
+ {PASS12 (yyval.classinfo)=TYPE_VOID;}
}
break;
- case 191:
+ case 237:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2377 "parser.y"
- {(yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
+#line 3097 "parser.y"
+ {PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
}
break;
- case 192:
+ case 238:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2378 "parser.y"
- {(yyval.classinfo)=0;}
+#line 3098 "parser.y"
+ {PASS12 (yyval.classinfo)=0;}
}
break;
- case 193:
+ case 239:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2382 "parser.y"
- {(yyval.value_list).cc=0;(yyval.value_list).len=0;}
+#line 3102 "parser.y"
+ {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
}
break;
- case 194:
+ case 240:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2383 "parser.y"
+#line 3103 "parser.y"
{(yyval.value_list)=(yyvsp[(2) - (3)].value_list);}
}
break;
- case 195:
+ case 241:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2385 "parser.y"
- {(yyval.value_list).cc=0;(yyval.value_list).len=0;}
+#line 3105 "parser.y"
+ {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
}
break;
- case 197:
+ case 244:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2387 "parser.y"
- {(yyval.value_list).len=1;
+#line 3109 "parser.y"
+ {(yyval.value_list).number=1;
(yyval.value_list).cc = (yyvsp[(1) - (1)].value).c;
}
}
@@ -5745,27 +6902,36 @@ yyreduce:
- case 198:
+ case 245:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3113 "parser.y"
+ {(yyval.value_list) = (yyvsp[(1) - (2)].value_list);}
+ }
+ break;
+
+
+ case 246:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2390 "parser.y"
+#line 3114 "parser.y"
{
- (yyval.value_list).len= (yyvsp[(1) - (3)].value_list).len+1;
- (yyval.value_list).cc = code_append((yyvsp[(1) - (3)].value_list).cc, (yyvsp[(3) - (3)].value).c);
+ (yyval.value_list).number= (yyvsp[(1) - (2)].value_list).number+1;
+ (yyval.value_list).cc = code_append((yyvsp[(1) - (2)].value_list).cc, (yyvsp[(2) - (2)].value).c);
}
}
break;
- case 200:
+ case 248:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2396 "parser.y"
+#line 3120 "parser.y"
{
- (yyval.value).c = (yyvsp[(2) - (4)].value).c;
+ typedcode_t v = node_read((yyvsp[(2) - (4)].node));
+ (yyval.value).c = v.c;
if((yyval.value).c->opcode == OPCODE_COERCE_A) (yyval.value).c = code_cutlast((yyval.value).c);
code_t*paramcode = (yyvsp[(4) - (4)].value_list).cc;
@@ -5773,23 +6939,33 @@ yyreduce:
multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
(yyval.value).c = code_cutlast((yyval.value).c);
(yyval.value).c = code_append((yyval.value).c, paramcode);
- (yyval.value).c = abc_constructprop2((yyval.value).c, name, (yyvsp[(4) - (4)].value_list).len);
+ (yyval.value).c = abc_constructprop2((yyval.value).c, name, (yyvsp[(4) - (4)].value_list).number);
multiname_destroy(name);
- } else if((yyval.value).c->opcode == OPCODE_GETSLOT) {
- int slot = (int)(ptroff_t)(yyval.value).c->data[0];
- trait_t*t = abc_class_find_slotid(state->cls->abc,slot);//FIXME
- multiname_t*name = t->name;
- (yyval.value).c = code_cutlast((yyval.value).c);
+ } else if(is_getlocal((yyval.value).c)) {
(yyval.value).c = code_append((yyval.value).c, paramcode);
- (yyval.value).c = abc_constructprop2((yyval.value).c, name, (yyvsp[(4) - (4)].value_list).len);
+ (yyval.value).c = abc_construct((yyval.value).c, (yyvsp[(4) - (4)].value_list).number);
+ } else if(TYPE_IS_CLASS(v.t) && v.t->data) {
+ code_free((yyval.value).c);
+ classinfo_t*c = v.t->data;
+ MULTINAME(m, c);
+ (yyval.value).c = abc_findpropstrict2(0, &m);
+ (yyval.value).c = code_append((yyval.value).c, paramcode);
+ (yyval.value).c = abc_constructprop2((yyval.value).c, &m, (yyvsp[(4) - (4)].value_list).number);
+ /*} else if($$.c->opcode == OPCODE_GETSLOT) {
+ int slot = (int)(ptroff_t)$$.c->data[0];
+ trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);//FIXME
+ multiname_t*name = t->name;
+ $$.c = code_cutlast($$.c);
+ $$.c = code_append($$.c, paramcode);
+ $$.c = abc_constructprop2($$.c, name, $4.number);*/
} else {
(yyval.value).c = code_append((yyval.value).c, paramcode);
- (yyval.value).c = abc_construct((yyval.value).c, (yyvsp[(4) - (4)].value_list).len);
+ (yyval.value).c = abc_construct((yyval.value).c, (yyvsp[(4) - (4)].value_list).number);
}
(yyval.value).t = TYPE_ANY;
- if(TYPE_IS_CLASS((yyvsp[(2) - (4)].value).t) && (yyvsp[(2) - (4)].value).t->cls) {
- (yyval.value).t = (yyvsp[(2) - (4)].value).t->cls;
+ if(TYPE_IS_CLASS(v.t) && v.t->data) {
+ (yyval.value).t = v.t->data;
} else {
(yyval.value).c = abc_coerce_a((yyval.value).c);
(yyval.value).t = TYPE_ANY;
@@ -5800,14 +6976,14 @@ yyreduce:
- case 201:
+ case 249:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2432 "parser.y"
+#line 3167 "parser.y"
{
-
- (yyval.value).c = (yyvsp[(1) - (4)].value).c;
+
+ typedcode_t v = node_read((yyvsp[(1) - (4)].node));
+ (yyval.value).c = v.c;
if((yyval.value).c->opcode == OPCODE_COERCE_A) {
(yyval.value).c = code_cutlast((yyval.value).c);
}
@@ -5818,36 +6994,39 @@ yyreduce:
multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
(yyval.value).c = code_cutlast((yyval.value).c);
(yyval.value).c = code_append((yyval.value).c, paramcode);
- (yyval.value).c = abc_callproperty2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).len);
+ (yyval.value).c = abc_callproperty2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);
multiname_destroy(name);
- } else if((yyval.value).c->opcode == OPCODE_GETSLOT) {
- int slot = (int)(ptroff_t)(yyval.value).c->data[0];
- trait_t*t = abc_class_find_slotid(state->cls->abc,slot);//FIXME
+/* } else if($$.c->opcode == OPCODE_GETSLOT && $$.c->prev->opcode != OPCODE_GETSCOPEOBJECT) {
+ int slot = (int)(ptroff_t)$$.c->data[0];
+ trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);
if(t->kind!=TRAIT_METHOD) {
//ok: flash allows to assign closures to members.
}
multiname_t*name = t->name;
- (yyval.value).c = code_cutlast((yyval.value).c);
- (yyval.value).c = code_append((yyval.value).c, paramcode);
+ $$.c = code_cutlast($$.c);
+ $$.c = code_append($$.c, paramcode);
//$$.c = abc_callmethod($$.c, t->method, len); //#1051 illegal early access binding
- (yyval.value).c = abc_callproperty2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).len);
+ $$.c = abc_callproperty2($$.c, name, $3.number);*/
} else if((yyval.value).c->opcode == OPCODE_GETSUPER) {
multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
(yyval.value).c = code_cutlast((yyval.value).c);
(yyval.value).c = code_append((yyval.value).c, paramcode);
- (yyval.value).c = abc_callsuper2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).len);
+ (yyval.value).c = abc_callsuper2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);
multiname_destroy(name);
} else {
(yyval.value).c = abc_getglobalscope((yyval.value).c);
(yyval.value).c = code_append((yyval.value).c, paramcode);
- (yyval.value).c = abc_call((yyval.value).c, (yyvsp[(3) - (4)].value_list).len);
+ (yyval.value).c = abc_call((yyval.value).c, (yyvsp[(3) - (4)].value_list).number);
}
- if(TYPE_IS_FUNCTION((yyvsp[(1) - (4)].value).t) && (yyvsp[(1) - (4)].value).t->function) {
- (yyval.value).t = (yyvsp[(1) - (4)].value).t->function->return_type;
+ if(TYPE_IS_FUNCTION(v.t) && v.t->data) {
+ (yyval.value).t = ((methodinfo_t*)(v.t->data))->return_type;
+ } else if(TYPE_IS_CLASS(v.t) && v.t->data) {
+ // calling a class is like a typecast
+ (yyval.value).t = (classinfo_t*)v.t->data;
} else {
- (yyval.value).c = abc_coerce_a((yyval.value).c);
(yyval.value).t = TYPE_ANY;
+ (yyval.value).c = abc_coerce_a((yyval.value).c);
}
}
}
@@ -5855,11 +7034,10 @@ yyreduce:
- case 202:
+ case 250:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2478 "parser.y"
+#line 3217 "parser.y"
{
if(!state->cls) syntaxerror("super() not allowed outside of a class");
if(!state->method) syntaxerror("super() not allowed outside of a function");
@@ -5876,7 +7054,7 @@ yyreduce:
*/
state->method->has_super = 1;
- (yyval.value).c = abc_constructsuper((yyval.value).c, (yyvsp[(3) - (4)].value_list).len);
+ (yyval.value).c = abc_constructsuper((yyval.value).c, (yyvsp[(3) - (4)].value_list).number);
(yyval.value).c = abc_pushundefined((yyval.value).c);
(yyval.value).t = TYPE_ANY;
}
@@ -5885,13 +7063,13 @@ yyreduce:
- case 203:
+ case 251:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2499 "parser.y"
+#line 3238 "parser.y"
{
- (yyval.value).c = (yyvsp[(2) - (2)].value).c;
+ typedcode_t v = node_read((yyvsp[(2) - (2)].node));
+ (yyval.value).c = v.c;
if((yyval.value).c->opcode == OPCODE_COERCE_A) {
(yyval.value).c = code_cutlast((yyval.value).c);
}
@@ -5900,12 +7078,12 @@ yyreduce:
(yyval.value).c->opcode = OPCODE_DELETEPROPERTY;
} else if((yyval.value).c->opcode == OPCODE_GETSLOT) {
int slot = (int)(ptroff_t)(yyval.value).c->data[0];
- multiname_t*name = abc_class_find_slotid(state->cls->abc,slot)->name;
+ multiname_t*name = traits_find_slotid(state->cls->abc->traits,slot)->name;
(yyval.value).c = code_cutlast((yyval.value).c);
(yyval.value).c = abc_deleteproperty2((yyval.value).c, name);
} else {
(yyval.value).c = abc_getlocal_0((yyval.value).c);
- MULTINAME_LATE(m, (yyvsp[(2) - (2)].value).t?(yyvsp[(2) - (2)].value).t->access:ACCESS_PACKAGE, "");
+ MULTINAME_LATE(m, v.t?v.t->access:ACCESS_PACKAGE, "");
(yyval.value).c = abc_deleteproperty2((yyval.value).c, &m);
}
(yyval.value).t = TYPE_BOOLEAN;
@@ -5915,11 +7093,10 @@ yyreduce:
- case 204:
+ case 252:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2520 "parser.y"
+#line 3260 "parser.y"
{
(yyval.code) = abc_returnvoid(0);
}
@@ -5928,11 +7105,10 @@ yyreduce:
- case 205:
+ case 253:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2523 "parser.y"
+#line 3263 "parser.y"
{
(yyval.code) = (yyvsp[(2) - (2)].value).c;
(yyval.code) = abc_returnvalue((yyval.code));
@@ -5942,1363 +7118,1350 @@ yyreduce:
- case 206:
+ case 254:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2530 "parser.y"
- {(yyval.value)=(yyvsp[(1) - (1)].value);}
+#line 3270 "parser.y"
+ {
+ (yyval.value) = node_read((yyvsp[(1) - (1)].node));
+}
}
break;
- case 207:
+ case 255:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2531 "parser.y"
- {(yyval.value) = (yyvsp[(1) - (1)].value);}
+#line 3273 "parser.y"
+ {
+ (yyval.value) = node_read((yyvsp[(1) - (1)].node));
+}
}
break;
- case 208:
+ case 256:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2532 "parser.y"
+#line 3276 "parser.y"
{
- (yyval.value).c = (yyvsp[(1) - (3)].value).c;
- (yyval.value).c = cut_last_push((yyval.value).c);
- (yyval.value).c = code_append((yyval.value).c,(yyvsp[(3) - (3)].value).c);
- (yyval.value).t = (yyvsp[(3) - (3)].value).t;
+ (yyval.node) = mkmultinode(&node_comma, (yyvsp[(1) - (1)].node));
}
}
break;
- case 209:
+ case 257:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2538 "parser.y"
+#line 3279 "parser.y"
{
- (yyval.code)=cut_last_push((yyvsp[(1) - (1)].value).c);
+ (yyval.node) = multinode_extend((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
}
}
break;
- case 210:
+ case 258:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3282 "parser.y"
+ {
+ (yyval.code) = node_exec((yyvsp[(1) - (1)].node));
+}
+ }
+ break;
+
+
+ case 259:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2544 "parser.y"
- {(yyval.value) = (yyvsp[(1) - (1)].value);}
+#line 3285 "parser.y"
+ {
+ (yyval.code) = (yyvsp[(1) - (3)].code);
+ (yyval.code) = code_append((yyval.code), node_exec((yyvsp[(3) - (3)].node)));
+}
}
break;
- case 212:
+ case 260:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3290 "parser.y"
+ {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
+ }
+ break;
+
+
+ case 261:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2548 "parser.y"
- {(yyval.value) = (yyvsp[(1) - (1)].value);}
+#line 3291 "parser.y"
+ {(yyval.value_list)=(yyvsp[(1) - (1)].value_list);}
}
break;
- case 213:
+ case 262:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3293 "parser.y"
+ {(yyval.code)=abc_pushstring(0,(yyvsp[(1) - (1)].id));}
+ }
+ break;
+
+
+ case 263:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2550 "parser.y"
- {(yyval.value) = (yyvsp[(1) - (1)].value);}
+#line 3294 "parser.y"
+ {(yyval.code)=abc_pushstring2(0,&(yyvsp[(1) - (1)].str));}
}
break;
- case 214:
+ case 264:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3295 "parser.y"
+ {syntaxerror("dictionary keys must be strings");}
+ }
+ break;
+
+
+ case 265:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2552 "parser.y"
- {(yyval.value) = (yyvsp[(1) - (1)].value);}
+#line 3296 "parser.y"
+ {syntaxerror("dictionary keys must be strings");}
}
break;
- case 216:
+ case 266:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3297 "parser.y"
+ {syntaxerror("dictionary keys must be strings");}
+ }
+ break;
+
+
+ case 267:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2556 "parser.y"
+#line 3299 "parser.y"
{
- (yyval.value).c = 0;
- namespace_t ns = {ACCESS_PACKAGE, ""};
- multiname_t m = {QNAME, &ns, 0, "RegExp"};
- if(!(yyvsp[(1) - (1)].regexp).options) {
- (yyval.value).c = abc_getlex2((yyval.value).c, &m);
- (yyval.value).c = abc_pushstring((yyval.value).c, (yyvsp[(1) - (1)].regexp).pattern);
- (yyval.value).c = abc_construct((yyval.value).c, 1);
- } else {
- (yyval.value).c = abc_getlex2((yyval.value).c, &m);
- (yyval.value).c = abc_pushstring((yyval.value).c, (yyvsp[(1) - (1)].regexp).pattern);
- (yyval.value).c = abc_pushstring((yyval.value).c, (yyvsp[(1) - (1)].regexp).options);
- (yyval.value).c = abc_construct((yyval.value).c, 2);
- }
- (yyval.value).t = TYPE_REGEXP;
+ (yyval.value_list).cc = 0;
+ (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(1) - (3)].code));
+ (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (3)].value).c);
+ (yyval.value_list).number = 2;
}
}
break;
- case 217:
+ case 268:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2573 "parser.y"
- {(yyval.value).c = abc_pushbyte(0, (yyvsp[(1) - (1)].number_uint));
- //MULTINAME(m, registry_getintclass());
- //$$.c = abc_coerce2($$.c, &m); // FIXME
- (yyval.value).t = TYPE_INT;
- }
+#line 3305 "parser.y"
+ {
+ (yyval.value_list).cc = (yyvsp[(1) - (5)].value_list).cc;
+ (yyval.value_list).number = (yyvsp[(1) - (5)].value_list).number+2;
+ (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (5)].code));
+ (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(5) - (5)].value).c);
+}
}
break;
- case 218:
+ case 269:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2578 "parser.y"
- {(yyval.value).c = abc_pushshort(0, (yyvsp[(1) - (1)].number_uint));
- (yyval.value).t = TYPE_INT;
- }
+#line 3314 "parser.y"
+ {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
}
break;
- case 219:
+ case 270:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2581 "parser.y"
- {(yyval.value).c = abc_pushint(0, (yyvsp[(1) - (1)].number_int));
- (yyval.value).t = TYPE_INT;
- }
+#line 3315 "parser.y"
+ {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
}
break;
- case 220:
+ case 271:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2584 "parser.y"
- {(yyval.value).c = abc_pushuint(0, (yyvsp[(1) - (1)].number_uint));
- (yyval.value).t = TYPE_UINT;
- }
+#line 3316 "parser.y"
+ {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
}
break;
- case 221:
+ case 272:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2587 "parser.y"
- {(yyval.value).c = abc_pushdouble(0, (yyvsp[(1) - (1)].number_float));
- (yyval.value).t = TYPE_FLOAT;
- }
+#line 3317 "parser.y"
+ {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
}
break;
- case 222:
+ case 273:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2590 "parser.y"
- {(yyval.value).c = abc_pushstring2(0, &(yyvsp[(1) - (1)].str));
- (yyval.value).t = TYPE_STRING;
- }
+#line 3318 "parser.y"
+ {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
}
break;
- case 223:
+ case 274:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2593 "parser.y"
- {(yyval.value).c = abc_pushundefined(0);
- (yyval.value).t = TYPE_ANY;
- }
+#line 3319 "parser.y"
+ {(yyval.node) = (yyvsp[(1) - (1)].node);}
}
break;
- case 224:
+ case 275:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2596 "parser.y"
- {(yyval.value).c = abc_pushtrue(0);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3321 "parser.y"
+ {
+ (yyval.node) = mkconstnode((yyvsp[(1) - (1)].constant));
+}
}
break;
- case 225:
+ case 276:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2599 "parser.y"
- {(yyval.value).c = abc_pushfalse(0);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3325 "parser.y"
+ {
+ (yyval.node) = (yyvsp[(1) - (1)].node);
+}
}
break;
- case 226:
+ case 277:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2602 "parser.y"
- {(yyval.value).c = abc_pushnull(0);
- (yyval.value).t = TYPE_NULL;
- }
+#line 3330 "parser.y"
+ {
+ typedcode_t v;
+ v.c = 0;
+ multiname_t m = {QNAME, &stdns, 0, "RegExp"};
+ if(!(yyvsp[(1) - (1)].regexp).options) {
+ v.c = abc_getlex2(v.c, &m);
+ v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).pattern);
+ v.c = abc_construct(v.c, 1);
+ } else {
+ v.c = abc_getlex2(v.c, &m);
+ v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).pattern);
+ v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).options);
+ v.c = abc_construct(v.c, 2);
+ }
+ v.t = TYPE_REGEXP;
+ (yyval.node) = mkcodenode(v);
+}
}
break;
- case 227:
+ case 278:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2606 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_greaterequals((yyval.value).c);(yyval.value).c=abc_not((yyval.value).c);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3348 "parser.y"
+ {
+ PASS1
+ state->method->need_arguments = 1;
+ PASS2
+ typedcode_t v;
+ v.c = abc_getlocal(0, state->method->need_arguments);
+ v.t = TYPE_ARRAY;
+ (yyval.node) = mkcodenode(v);
+}
}
break;
- case 228:
+ case 279:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2609 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_greaterthan((yyval.value).c);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3359 "parser.y"
+ {
+ typedcode_t v;
+ v.c = code_new();
+ v.c = code_append(v.c, (yyvsp[(2) - (3)].value_list).cc);
+ v.c = abc_newarray(v.c, (yyvsp[(2) - (3)].value_list).number);
+ v.t = registry_getarrayclass();
+ (yyval.node) = mkcodenode(v);
+}
}
break;
- case 229:
+ case 280:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2612 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_greaterthan((yyval.value).c);(yyval.value).c=abc_not((yyval.value).c);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3369 "parser.y"
+ {
+ typedcode_t v;
+ v.c = code_new();
+ v.c = code_append(v.c, (yyvsp[(2) - (3)].value_list).cc);
+ v.c = abc_newobject(v.c, (yyvsp[(2) - (3)].value_list).number/2);
+ v.t = registry_getobjectclass();
+ (yyval.node) = mkcodenode(v);
+}
}
break;
- case 230:
+ case 281:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2615 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_greaterequals((yyval.value).c);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3378 "parser.y"
+ {(yyval.node) = mknode2(&node_lt,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
}
break;
- case 231:
+ case 282:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2618 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_equals((yyval.value).c);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3379 "parser.y"
+ {(yyval.node) = mknode2(&node_gt,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
}
break;
- case 232:
+ case 283:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2621 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_strictequals((yyval.value).c);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3380 "parser.y"
+ {(yyval.node) = mknode2(&node_le,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
}
break;
- case 233:
+ case 284:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2624 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_strictequals((yyval.value).c);(yyval.value).c = abc_not((yyval.value).c);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3381 "parser.y"
+ {(yyval.node) = mknode2(&node_ge,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
}
break;
- case 234:
+ case 285:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2627 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_equals((yyval.value).c);(yyval.value).c = abc_not((yyval.value).c);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3382 "parser.y"
+ {(yyval.node) = mknode2(&node_eqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
}
break;
- case 235:
+ case 286:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3383 "parser.y"
+ {(yyval.node) = mknode2(&node_eqeqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
+ }
+ break;
+
+
+ case 287:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2631 "parser.y"
- {(yyval.value).t = join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, 'O');
- (yyval.value).c = (yyvsp[(1) - (3)].value).c;
- (yyval.value).c = converttype((yyval.value).c, (yyvsp[(1) - (3)].value).t, (yyval.value).t);
- (yyval.value).c = abc_dup((yyval.value).c);
- code_t*jmp = (yyval.value).c = abc_iftrue((yyval.value).c, 0);
- (yyval.value).c = cut_last_push((yyval.value).c);
- (yyval.value).c = code_append((yyval.value).c,(yyvsp[(3) - (3)].value).c);
- (yyval.value).c = converttype((yyval.value).c, (yyvsp[(3) - (3)].value).t, (yyval.value).t);
- code_t*label = (yyval.value).c = abc_label((yyval.value).c);
- jmp->branch = label;
- }
+#line 3384 "parser.y"
+ {(yyval.node) = mknode2(&node_noteqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
}
break;
- case 236:
+ case 288:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3385 "parser.y"
+ {(yyval.node) = mknode2(&node_noteq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
+ }
+ break;
+
+
+ case 289:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2642 "parser.y"
- {
- (yyval.value).t = join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, 'A');
- /*printf("%08x:\n",$1.t);
- code_dump($1.c, 0, 0, "", stdout);
- printf("%08x:\n",$3.t);
- code_dump($3.c, 0, 0, "", stdout);
- printf("joining %08x and %08x to %08x\n", $1.t, $3.t, $$.t);*/
- (yyval.value).c = (yyvsp[(1) - (3)].value).c;
- (yyval.value).c = converttype((yyval.value).c, (yyvsp[(1) - (3)].value).t, (yyval.value).t);
- (yyval.value).c = abc_dup((yyval.value).c);
- code_t*jmp = (yyval.value).c = abc_iffalse((yyval.value).c, 0);
- (yyval.value).c = cut_last_push((yyval.value).c);
- (yyval.value).c = code_append((yyval.value).c,(yyvsp[(3) - (3)].value).c);
- (yyval.value).c = converttype((yyval.value).c, (yyvsp[(3) - (3)].value).t, (yyval.value).t);
- code_t*label = (yyval.value).c = abc_label((yyval.value).c);
- jmp->branch = label;
- }
+#line 3386 "parser.y"
+ {(yyval.node) = mknode2(&node_oror,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
}
break;
- case 237:
+ case 290:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3387 "parser.y"
+ {(yyval.node) = mknode2(&node_andand,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
+ }
+ break;
+
+
+ case 291:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2660 "parser.y"
- {(yyval.value).c=(yyvsp[(2) - (2)].value).c;
- (yyval.value).c = abc_not((yyval.value).c);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3388 "parser.y"
+ {(yyval.node) = mknode1(&node_not, (yyvsp[(2) - (2)].node));}
}
break;
- case 238:
+ case 292:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3389 "parser.y"
+ {(yyval.node) = mknode1(&node_bitnot, (yyvsp[(2) - (2)].node));}
+ }
+ break;
+
+
+ case 293:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2665 "parser.y"
- {(yyval.value).c=(yyvsp[(2) - (2)].value).c;
- (yyval.value).c = abc_bitnot((yyval.value).c);
- (yyval.value).t = TYPE_INT;
- }
+#line 3390 "parser.y"
+ {(yyval.node) = mknode2(&node_bitand, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 239:
+ case 294:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3391 "parser.y"
+ {(yyval.node) = mknode2(&node_bitxor, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+ }
+ break;
+
+
+ case 295:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2670 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
- (yyval.value).c = abc_bitand((yyval.value).c);
- (yyval.value).t = TYPE_INT;
- }
+#line 3392 "parser.y"
+ {(yyval.node) = mknode2(&node_bitor, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 240:
+ case 296:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3393 "parser.y"
+ {(yyval.node) = mknode2(&node_shr, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+ }
+ break;
+
+
+ case 297:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2675 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
- (yyval.value).c = abc_bitxor((yyval.value).c);
- (yyval.value).t = TYPE_INT;
- }
+#line 3394 "parser.y"
+ {(yyval.node) = mknode2(&node_ushr, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 241:
+ case 298:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3395 "parser.y"
+ {(yyval.node) = mknode2(&node_shl, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+ }
+ break;
+
+
+ case 299:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2680 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
- (yyval.value).c = abc_bitor((yyval.value).c);
- (yyval.value).t = TYPE_INT;
- }
+#line 3396 "parser.y"
+ {(yyval.node) = mknode2(&node_div, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 242:
+ case 300:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3397 "parser.y"
+ {(yyval.node) = mknode2(&node_mod, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+ }
+ break;
+
+
+ case 301:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2685 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
- (yyval.value).c = abc_rshift((yyval.value).c);
- (yyval.value).t = TYPE_INT;
- }
+#line 3398 "parser.y"
+ {(yyval.node) = mknode2(&node_plus, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 243:
+ case 302:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3399 "parser.y"
+ {(yyval.node) = mknode2(&node_minus, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+ }
+ break;
+
+
+ case 303:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2689 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
- (yyval.value).c = abc_urshift((yyval.value).c);
- (yyval.value).t = TYPE_INT;
- }
+#line 3400 "parser.y"
+ {(yyval.node) = mknode2(&node_multiply, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 244:
+ case 304:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3401 "parser.y"
+ {(yyval.node) = mknode2(&node_in, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+ }
+ break;
+
+
+ case 305:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2693 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
- (yyval.value).c = abc_lshift((yyval.value).c);
- (yyval.value).t = TYPE_INT;
- }
+#line 3402 "parser.y"
+ {(yyval.node) = mknode2(&node_as, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 245:
+ case 306:
if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3403 "parser.y"
+ {(yyval.node) = mknode2(&node_instanceof, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+ }
+ break;
+
+
+ case 307:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 2698 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
- (yyval.value).c = abc_divide((yyval.value).c);
- (yyval.value).t = TYPE_NUMBER;
- }
+#line 3404 "parser.y"
+ {(yyval.node) = mknode2(&node_is, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 246:
+ case 308:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2702 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
- (yyval.value).c = abc_modulo((yyval.value).c);
- (yyval.value).t = TYPE_NUMBER;
- }
+#line 3405 "parser.y"
+ {(yyval.node) = mknode1(&node_typeof, (yyvsp[(2) - (2)].node));}
}
break;
- case 247:
+ case 309:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2706 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
- if(BOTH_INT((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t)) {
- (yyval.value).c = abc_add_i((yyval.value).c);
- (yyval.value).t = TYPE_INT;
- } else {
- (yyval.value).c = abc_add((yyval.value).c);
- (yyval.value).t = join_types((yyvsp[(1) - (3)].value).t,(yyvsp[(3) - (3)].value).t,'+');
- }
- }
+#line 3406 "parser.y"
+ {(yyval.node) = mknode1(&node_void, (yyvsp[(2) - (2)].node));}
}
break;
- case 248:
+ case 310:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2715 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
- if(BOTH_INT((yyvsp[(1) - (3)].value).t,(yyvsp[(3) - (3)].value).t)) {
- (yyval.value).c = abc_subtract_i((yyval.value).c);
- (yyval.value).t = TYPE_INT;
- } else {
- (yyval.value).c = abc_subtract((yyval.value).c);
- (yyval.value).t = TYPE_NUMBER;
- }
- }
+#line 3407 "parser.y"
+ { (yyval.node) = mkconstnode(constant_new_undefined());}
}
break;
- case 249:
+ case 311:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2724 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
- if(BOTH_INT((yyvsp[(1) - (3)].value).t,(yyvsp[(3) - (3)].value).t)) {
- (yyval.value).c = abc_multiply_i((yyval.value).c);
- (yyval.value).t = TYPE_INT;
- } else {
- (yyval.value).c = abc_multiply((yyval.value).c);
- (yyval.value).t = TYPE_NUMBER;
- }
- }
+#line 3408 "parser.y"
+ { (yyval.node)=(yyvsp[(2) - (3)].node);}
}
break;
- case 250:
+ case 312:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2734 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
- (yyval.value).c = abc_in((yyval.value).c);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3409 "parser.y"
+ {(yyval.node) = mknode1(&node_neg, (yyvsp[(2) - (2)].node));}
}
break;
- case 251:
+ case 313:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2739 "parser.y"
- {char use_astype=0; // flash player's astype works differently than astypelate
- if(use_astype && TYPE_IS_CLASS((yyvsp[(3) - (3)].value).t)) {
- MULTINAME(m,(yyvsp[(3) - (3)].value).t->cls);
- (yyval.value).c = abc_astype2((yyvsp[(1) - (3)].value).c, &m);
- (yyval.value).t = (yyvsp[(3) - (3)].value).t->cls;
- } else {
- (yyval.value).c = code_append((yyvsp[(1) - (3)].value).c, (yyvsp[(3) - (3)].value).c);
- (yyval.value).c = abc_astypelate((yyval.value).c);
- (yyval.value).t = TYPE_ANY;
- }
- }
+#line 3410 "parser.y"
+ {(yyval.node) = mknode2(&node_arraylookup, (yyvsp[(1) - (4)].node),(yyvsp[(3) - (4)].node));}
}
break;
- case 252:
+ case 314:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2752 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c, (yyvsp[(3) - (3)].value).c);
- (yyval.value).c = abc_instanceof((yyval.value).c);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3411 "parser.y"
+ {(yyval.node) = mknode2(&node_muleq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 253:
+ case 315:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2757 "parser.y"
- {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c, (yyvsp[(3) - (3)].value).c);
- (yyval.value).c = abc_istypelate((yyval.value).c);
- (yyval.value).t = TYPE_BOOLEAN;
- }
+#line 3412 "parser.y"
+ {(yyval.node) = mknode2(&node_modeq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 254:
+ case 316:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2762 "parser.y"
- {
- (yyval.value).c = (yyvsp[(3) - (4)].value).c;
- (yyval.value).c = abc_typeof((yyval.value).c);
- (yyval.value).t = TYPE_STRING;
- }
+#line 3413 "parser.y"
+ {(yyval.node) = mknode2(&node_shleq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 255:
+ case 317:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2768 "parser.y"
- {
- (yyval.value).c = cut_last_push((yyvsp[(2) - (2)].value).c);
- (yyval.value).c = abc_pushundefined((yyval.value).c);
- (yyval.value).t = TYPE_ANY;
- }
+#line 3414 "parser.y"
+ {(yyval.node) = mknode2(&node_shreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 256:
+ case 318:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2774 "parser.y"
- { (yyval.value).c = abc_pushundefined(0);
- (yyval.value).t = TYPE_ANY;
- }
+#line 3415 "parser.y"
+ {(yyval.node) = mknode2(&node_ushreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 257:
+ case 319:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2778 "parser.y"
- {(yyval.value)=(yyvsp[(2) - (3)].value);}
+#line 3416 "parser.y"
+ { (yyval.node) = mknode2(&node_diveq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 258:
+ case 320:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2780 "parser.y"
- {
- (yyval.value)=(yyvsp[(2) - (2)].value);
- if(IS_INT((yyvsp[(2) - (2)].value).t)) {
- (yyval.value).c=abc_negate_i((yyval.value).c);
- (yyval.value).t = TYPE_INT;
- } else {
- (yyval.value).c=abc_negate((yyval.value).c);
- (yyval.value).t = TYPE_NUMBER;
- }
-}
+#line 3417 "parser.y"
+ { (yyval.node) = mknode2(&node_bitoreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 259:
+ case 321:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2791 "parser.y"
- {
- (yyval.value).c = (yyvsp[(1) - (4)].value).c;
- (yyval.value).c = code_append((yyval.value).c, (yyvsp[(3) - (4)].value).c);
-
- MULTINAME_LATE(m, (yyvsp[(1) - (4)].value).t?(yyvsp[(1) - (4)].value).t->access:ACCESS_PACKAGE, "");
- (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
- (yyval.value).t = 0; // array elements have unknown type
-}
+#line 3418 "parser.y"
+ { (yyval.node) = mknode2(&node_bitxoreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 260:
+ case 322:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2800 "parser.y"
- {
- (yyval.value).c = code_new();
- (yyval.value).c = code_append((yyval.value).c, (yyvsp[(2) - (3)].value_list).cc);
- (yyval.value).c = abc_newarray((yyval.value).c, (yyvsp[(2) - (3)].value_list).len);
- (yyval.value).t = registry_getarrayclass();
-}
+#line 3419 "parser.y"
+ { (yyval.node) = mknode2(&node_bitandeq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 261:
+ case 323:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2807 "parser.y"
- {(yyval.value_list).cc=0;(yyval.value_list).len=0;}
+#line 3420 "parser.y"
+ { (yyval.node) = mknode2(&node_pluseq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 262:
+ case 324:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2808 "parser.y"
- {(yyval.value_list)=(yyvsp[(1) - (1)].value_list);}
+#line 3421 "parser.y"
+ { (yyval.node) = mknode2(&node_minuseq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 263:
+ case 325:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2810 "parser.y"
- {
- (yyval.value_list).cc = 0;
- (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(1) - (3)].value).c);
- (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (3)].value).c);
- (yyval.value_list).len = 2;
-}
+#line 3422 "parser.y"
+ { (yyval.node) = mknode2(&node_assign, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
}
break;
- case 264:
+ case 326:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2816 "parser.y"
- {
- (yyval.value_list).cc = (yyvsp[(1) - (5)].value_list).cc;
- (yyval.value_list).len = (yyvsp[(1) - (5)].value_list).len+2;
- (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (5)].value).c);
- (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(5) - (5)].value).c);
-}
+#line 3423 "parser.y"
+ { (yyval.node) = mknode3(&node_tenary, (yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));}
}
break;
- case 265:
+ case 327:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2825 "parser.y"
- {
- (yyval.value).c = code_new();
- (yyval.value).c = code_append((yyval.value).c, (yyvsp[(2) - (3)].value_list).cc);
- (yyval.value).c = abc_newobject((yyval.value).c, (yyvsp[(2) - (3)].value_list).len/2);
- (yyval.value).t = registry_getobjectclass();
-}
+#line 3425 "parser.y"
+ { (yyval.node) = mknode1(&node_rplusplus, (yyvsp[(1) - (2)].node));}
}
break;
- case 266:
+ case 328:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2832 "parser.y"
- {
- code_t*c = (yyvsp[(3) - (3)].value).c;
- if(BOTH_INT((yyvsp[(1) - (3)].value).t,(yyvsp[(3) - (3)].value).t)) {
- c=abc_multiply_i(c);
- } else {
- c=abc_multiply(c);
- }
- c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '*'), (yyvsp[(1) - (3)].value).t);
- (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
- (yyval.value).t = (yyvsp[(1) - (3)].value).t;
- }
+#line 3426 "parser.y"
+ { (yyval.node) = mknode1(&node_rminusminus, (yyvsp[(1) - (2)].node));}
}
break;
- case 267:
+ case 329:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2844 "parser.y"
- {
- code_t*c = abc_modulo((yyvsp[(3) - (3)].value).c);
- c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '%'), (yyvsp[(1) - (3)].value).t);
- (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
- (yyval.value).t = (yyvsp[(1) - (3)].value).t;
- }
+#line 3427 "parser.y"
+ {(yyval.node) = mknode1(&node_lplusplus, (yyvsp[(2) - (2)].node)); }
}
break;
- case 268:
+ case 330:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2850 "parser.y"
- {
- code_t*c = abc_lshift((yyvsp[(3) - (3)].value).c);
- c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '<'), (yyvsp[(1) - (3)].value).t);
- (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
- (yyval.value).t = (yyvsp[(1) - (3)].value).t;
- }
+#line 3428 "parser.y"
+ {(yyval.node) = mknode1(&node_lminusminus, (yyvsp[(2) - (2)].node)); }
}
break;
- case 269:
+ case 331:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2856 "parser.y"
- {
- code_t*c = abc_rshift((yyvsp[(3) - (3)].value).c);
- c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '>'), (yyvsp[(1) - (3)].value).t);
- (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
- (yyval.value).t = (yyvsp[(1) - (3)].value).t;
- }
+#line 3431 "parser.y"
+ { if(!state->cls->info)
+ syntaxerror("super keyword not allowed outside a class");
+ classinfo_t*t = state->cls->info->superclass;
+ if(!t) t = TYPE_OBJECT;
+ memberinfo_t*f = findmember_nsset(t, (yyvsp[(3) - (3)].id), 1);
+ MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
+ typedcode_t v;
+ v.c = 0;
+ v.c = abc_getlocal_0(v.c);
+ v.c = abc_getsuper2(v.c, &m);
+ v.t = slotinfo_gettype((slotinfo_t*)f);
+ (yyval.node) = mkcodenode(v);
+ }
}
break;
- case 270:
+ case 332:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2862 "parser.y"
- {
- code_t*c = abc_urshift((yyvsp[(3) - (3)].value).c);
- c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, 'U'), (yyvsp[(1) - (3)].value).t);
- (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
- (yyval.value).t = (yyvsp[(1) - (3)].value).t;
- }
+#line 3445 "parser.y"
+ {
+ typedcode_t v;
+ multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(2) - (2)].id)};
+ v.c = abc_getlex2(0, &m);
+ v.t = TYPE_STRING;
+ (yyval.node) = mkcodenode(v);
+}
}
break;
- case 271:
+ case 333:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2868 "parser.y"
- {
- code_t*c = abc_divide((yyvsp[(3) - (3)].value).c);
- c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '/'), (yyvsp[(1) - (3)].value).t);
- (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
- (yyval.value).t = (yyvsp[(1) - (3)].value).t;
- }
+#line 3453 "parser.y"
+ {PASS12 new_state();state->xmlfilter=1;}
}
break;
- case 272:
+ case 334:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2874 "parser.y"
- {
- code_t*c = abc_bitor((yyvsp[(3) - (3)].value).c);
- c=converttype(c, TYPE_INT, (yyvsp[(1) - (3)].value).t);
- (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
- (yyval.value).t = (yyvsp[(1) - (3)].value).t;
- }
+#line 3453 "parser.y"
+ {
+ PASS1 old_state();
+ PASS2
+ typedcode_t v = node_read((yyvsp[(1) - (6)].node));
+ typedcode_t w = node_read((yyvsp[(5) - (6)].node));
+ code_t*c = 0;
+ int index = alloc_local();
+ int result = alloc_local();
+ int tmp = alloc_local();
+ int xml = alloc_local();
+
+ c = code_append(c, v.c);
+ c = abc_checkfilter(c);
+ c = abc_coerce_a(c); //hasnext2 converts to *
+ c = abc_setlocal(c, xml);
+ multiname_t m = {QNAME, &stdns, 0, "XMLList"};
+ c = abc_getlex2(c, &m);
+ c = abc_construct(c, 0);
+ c = abc_setlocal(c, result);
+ c = abc_pushbyte(c, 0);
+ c = abc_setlocal(c, index);
+ code_t*jmp = c = abc_jump(c, 0);
+ code_t*loop = c = abc_label(c);
+ c = abc_getlocal(c, xml);
+ c = abc_getlocal(c, index);
+ c = abc_nextvalue(c);
+ c = abc_dup(c);
+ c = abc_setlocal(c, tmp);
+ c = abc_pushwith(c);
+ c = code_append(c, w.c);
+ c = abc_popscope(c);
+ code_t*b = c = abc_iffalse(c, 0);
+ c = abc_getlocal(c, result);
+ c = abc_getlocal(c, index);
+ c = abc_getlocal(c, tmp);
+ multiname_t m2 = {MULTINAMEL, 0, &nopackage_namespace_set, 0};
+ c = abc_setproperty2(c, &m2);
+ c = b->branch = jmp->branch = abc_nop(c);
+ c = abc_kill(c, tmp);
+ c = abc_hasnext2(c, xml, index);
+ c = abc_iftrue(c, loop);
+ c = abc_getlocal(c, result);
+ c = abc_kill(c, xml);
+ c = abc_kill(c, result);
+ c = abc_kill(c, index);
+
+ c = var_block(c, state->vars);
+ old_state();
+ typedcode_t r;
+ r.c = c;
+ r.t = TYPE_XMLLIST;
+ (yyval.node) = mkcodenode(r);
+}
}
break;
- case 273:
+ case 335:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2880 "parser.y"
- {
- code_t*c = (yyvsp[(3) - (3)].value).c;
-
- if(TYPE_IS_INT((yyvsp[(1) - (3)].value).t)) {
- c=abc_add_i(c);
- } else {
- c=abc_add(c);
- c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '+'), (yyvsp[(1) - (3)].value).t);
- }
-
- (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
- (yyval.value).t = (yyvsp[(1) - (3)].value).t;
- }
+#line 3507 "parser.y"
+ {(yyval.id)=(yyvsp[(1) - (1)].id);}
}
break;
- case 274:
+ case 336:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2893 "parser.y"
- { code_t*c = (yyvsp[(3) - (3)].value).c;
- if(TYPE_IS_INT((yyvsp[(1) - (3)].value).t)) {
- c=abc_subtract_i(c);
- } else {
- c=abc_subtract(c);
- c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '-'), (yyvsp[(1) - (3)].value).t);
- }
-
- (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
- (yyval.value).t = (yyvsp[(1) - (3)].value).t;
- }
+#line 3508 "parser.y"
+ {(yyval.id)="*";}
}
break;
- case 275:
+ case 337:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2904 "parser.y"
- { code_t*c = 0;
- c = code_append(c, (yyvsp[(3) - (3)].value).c);
- c = converttype(c, (yyvsp[(3) - (3)].value).t, (yyvsp[(1) - (3)].value).t);
- (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 1, 0);
- (yyval.value).t = (yyvsp[(1) - (3)].value).t;
- }
+#line 3509 "parser.y"
+ {(yyval.id)=(char*)(yyvsp[(1) - (1)].id);}
}
break;
- case 276:
+ case 339:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2911 "parser.y"
- {
- (yyval.value).t = join_types((yyvsp[(3) - (5)].value).t,(yyvsp[(5) - (5)].value).t,'?');
- (yyval.value).c = (yyvsp[(1) - (5)].value).c;
- code_t*j1 = (yyval.value).c = abc_iffalse((yyval.value).c, 0);
- (yyval.value).c = code_append((yyval.value).c, (yyvsp[(3) - (5)].value).c);
- (yyval.value).c = converttype((yyval.value).c, (yyvsp[(3) - (5)].value).t, (yyval.value).t);
- code_t*j2 = (yyval.value).c = abc_jump((yyval.value).c, 0);
- (yyval.value).c = j1->branch = abc_label((yyval.value).c);
- (yyval.value).c = code_append((yyval.value).c, (yyvsp[(5) - (5)].value).c);
- (yyval.value).c = converttype((yyval.value).c, (yyvsp[(3) - (5)].value).t, (yyval.value).t);
- (yyval.value).c = j2->branch = abc_label((yyval.value).c);
- }
+#line 3511 "parser.y"
+ {(yyval.id)="*";}
}
break;
- case 277:
+ case 340:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2924 "parser.y"
- { code_t*c = 0;
- classinfo_t*type = (yyvsp[(1) - (2)].value).t;
- if((is_getlocal((yyvsp[(1) - (2)].value).c) && TYPE_IS_INT((yyvsp[(1) - (2)].value).t)) || TYPE_IS_NUMBER((yyvsp[(1) - (2)].value).t)) {
- int nr = getlocalnr((yyvsp[(1) - (2)].value).c);
- code_free((yyvsp[(1) - (2)].value).c);(yyvsp[(1) - (2)].value).c=0;
- if(TYPE_IS_INT((yyvsp[(1) - (2)].value).t)) {
- (yyval.value).c = abc_getlocal(0, nr);
- (yyval.value).c = abc_inclocal_i((yyval.value).c, nr);
- } else if(TYPE_IS_NUMBER((yyvsp[(1) - (2)].value).t)) {
- (yyval.value).c = abc_getlocal(0, nr);
- (yyval.value).c = abc_inclocal((yyval.value).c, nr);
- } else syntaxerror("internal error");
- } else {
- if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
- c=abc_increment_i(c);
- type = TYPE_INT;
- } else {
- c=abc_increment(c);
- type = TYPE_NUMBER;
- }
- c=converttype(c, type, (yyvsp[(1) - (2)].value).t);
- (yyval.value).c = toreadwrite((yyvsp[(1) - (2)].value).c, c, 0, 1);
- (yyval.value).t = (yyvsp[(1) - (2)].value).t;
- }
- }
+#line 3519 "parser.y"
+ {
+ typedcode_t v = node_read((yyvsp[(1) - (5)].node));
+ typedcode_t w = node_read(resolve_identifier((yyvsp[(3) - (5)].id)));
+ v.c = code_append(v.c, w.c);
+ if(!TYPE_IS_NAMESPACE(w.t)) {
+ as3_softwarning("%s might not be a namespace", (yyvsp[(3) - (5)].id));
+ }
+ v.c = converttype(v.c, w.t, TYPE_NAMESPACE);
+ multiname_t m = {RTQNAME, 0, 0, (yyvsp[(5) - (5)].id)};
+ v.c = abc_getproperty2(v.c, &m);
+ if(TYPE_IS_XML(v.t)) {
+ v.t = TYPE_XMLLIST;
+ } else {
+ v.c = abc_coerce_a(v.c);
+ v.t = TYPE_ANY;
+ }
+ (yyval.node) = mkcodenode(v);
+}
}
break;
- case 278:
+ case 341:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2951 "parser.y"
- { code_t*c = 0;
- classinfo_t*type = (yyvsp[(1) - (2)].value).t;
- if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
- c=abc_decrement_i(c);
- type = TYPE_INT;
- } else {
- c=abc_decrement(c);
- type = TYPE_NUMBER;
- }
- c=converttype(c, type, (yyvsp[(1) - (2)].value).t);
- (yyval.value).c = toreadwrite((yyvsp[(1) - (2)].value).c, c, 0, 1);
- (yyval.value).t = (yyvsp[(1) - (2)].value).t;
- }
+#line 3537 "parser.y"
+ {
+ typedcode_t v = node_read((yyvsp[(1) - (3)].node));
+ multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
+ v.c = abc_getdescendants2(v.c, &m);
+ v.t = TYPE_XMLLIST;
+ (yyval.node) = mkcodenode(v);
+}
}
break;
- case 279:
+ case 342:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2965 "parser.y"
- { code_t*c = 0;
- classinfo_t*type = (yyvsp[(2) - (2)].value).t;
- if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
- c=abc_increment_i(c);
- type = TYPE_INT;
- } else {
- c=abc_increment(c);
- type = TYPE_NUMBER;
- }
- c=converttype(c, type, (yyvsp[(2) - (2)].value).t);
- (yyval.value).c = toreadwrite((yyvsp[(2) - (2)].value).c, c, 0, 0);
- (yyval.value).t = (yyvsp[(2) - (2)].value).t;
- }
+#line 3544 "parser.y"
+ {
+ typedcode_t v = node_read((yyvsp[(1) - (5)].node));
+ typedcode_t w = node_read((yyvsp[(4) - (5)].node));
+ multiname_t m = {MULTINAMEL, 0, &nopackage_namespace_set, 0};
+ v.c = code_append(v.c, w.c);
+ v.c = converttype(w.c, w.t, TYPE_STRING);
+ v.c = abc_getproperty2(v.c, &m);
+ v.t = TYPE_XMLLIST;
+ (yyval.node) = mkcodenode(v);
+}
}
break;
- case 280:
+ case 343:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2979 "parser.y"
- { code_t*c = 0;
- classinfo_t*type = (yyvsp[(2) - (2)].value).t;
- if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
- c=abc_decrement_i(c);
- type = TYPE_INT;
- } else {
- c=abc_decrement(c);
- type = TYPE_NUMBER;
- }
- c=converttype(c, type, (yyvsp[(2) - (2)].value).t);
- (yyval.value).c = toreadwrite((yyvsp[(2) - (2)].value).c, c, 0, 0);
- (yyval.value).t = (yyvsp[(2) - (2)].value).t;
- }
+#line 3555 "parser.y"
+ {
+ typedcode_t v = node_read((yyvsp[(1) - (4)].node));
+ multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(4) - (4)].id)};
+ v.c = abc_getproperty2(v.c, &m);
+ v.t = TYPE_STRING;
+ (yyval.node) = mkcodenode(v);
+}
}
break;
- case 281:
+ case 344:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 2994 "parser.y"
- { if(!state->cls->info)
- syntaxerror("super keyword not allowed outside a class");
- classinfo_t*t = state->cls->info->superclass;
- if(!t) t = TYPE_OBJECT;
-
- memberinfo_t*f = registry_findmember(t, (yyvsp[(3) - (3)].id), 1);
- namespace_t ns = flags2namespace(f->flags, "");
- MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
- (yyval.value).c = 0;
- (yyval.value).c = abc_getlocal_0((yyval.value).c);
- (yyval.value).c = abc_getsuper2((yyval.value).c, &m);
- (yyval.value).t = memberinfo_gettype(f);
- }
+#line 3562 "parser.y"
+ {
+ typedcode_t v = node_read((yyvsp[(1) - (4)].node));
+ multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(4) - (4)].id)};
+ v.c = abc_getdescendants2(v.c, &m);
+ v.t = TYPE_STRING;
+ (yyval.node) = mkcodenode(v);
+}
}
break;
- case 282:
+ case 345:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 3009 "parser.y"
- {(yyval.value).c = (yyvsp[(1) - (3)].value).c;
- classinfo_t*t = (yyvsp[(1) - (3)].value).t;
- char is_static = 0;
- if(TYPE_IS_CLASS(t) && t->cls) {
- t = t->cls;
- is_static = 1;
- }
- if(t) {
- memberinfo_t*f = registry_findmember(t, (yyvsp[(3) - (3)].id), 1);
- char noslot = 0;
- if(f && !is_static != !(f->flags&FLAG_STATIC))
- noslot=1;
- if(f && f->slot && !noslot) {
- (yyval.value).c = abc_getslot((yyval.value).c, f->slot);
- } else {
- MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
- (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
- }
- /* determine type */
- (yyval.value).t = memberinfo_gettype(f);
- if(!(yyval.value).t)
- (yyval.value).c = abc_coerce_a((yyval.value).c);
- } else {
- /* when resolving a property on an unknown type, we do know the
- name of the property (and don't seem to need the package), but
- we need to make avm2 try out all access modes */
- multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
- (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
- (yyval.value).c = abc_coerce_a((yyval.value).c);
- (yyval.value).t = registry_getanytype();
- }
- }
+#line 3569 "parser.y"
+ {
+ typedcode_t v = node_read((yyvsp[(1) - (6)].node));
+ typedcode_t w = node_read((yyvsp[(5) - (6)].node));
+ multiname_t m = {MULTINAMELA, 0, &nopackage_namespace_set, 0};
+ v.c = code_append(v.c, w.c);
+ v.c = converttype(w.c, w.t, TYPE_STRING);
+ v.c = abc_getproperty2(v.c, &m);
+ v.t = TYPE_STRING;
+ (yyval.node) = mkcodenode(v);
+}
}
break;
- case 283:
+ case 346:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 3042 "parser.y"
+#line 3579 "parser.y"
{
- (yyval.value).t = 0;
- (yyval.value).c = 0;
- classinfo_t*a = 0;
- memberinfo_t*f = 0;
-
- variable_t*v;
- /* look at variables */
- if((v = find_variable((yyvsp[(1) - (1)].id)))) {
- // $1 is a local variable
- (yyval.value).c = abc_getlocal((yyval.value).c, v->index);
- (yyval.value).t = v->type;
- break;
+ typedcode_t v = node_read((yyvsp[(1) - (6)].node));
+ typedcode_t w = node_read((yyvsp[(5) - (6)].node));
+ multiname_t m = {MULTINAMELA, 0, &nopackage_namespace_set, 0};
+ v.c = code_append(v.c, w.c);
+ v.c = converttype(w.c, w.t, TYPE_STRING);
+ v.c = abc_getdescendants2(v.c, &m);
+ v.t = TYPE_STRING;
+ (yyval.node) = mkcodenode(v);
+}
}
+ break;
- int i_am_static = (state->method && state->method->info)?(state->method->info->flags&FLAG_STATIC):FLAG_STATIC;
-
- /* look at current class' members */
- if(state->cls && (f = registry_findmember(state->cls->info, (yyvsp[(1) - (1)].id), 1)) &&
- (f->flags&FLAG_STATIC) >= i_am_static) {
- // $1 is a function in this class
- int var_is_static = (f->flags&FLAG_STATIC);
- if(f->kind == MEMBER_METHOD) {
- (yyval.value).t = TYPE_FUNCTION(f);
- } else {
- (yyval.value).t = f->type;
+
+ case 347:
+ if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3590 "parser.y"
+ {
+ typedcode_t v1 = node_read((yyvsp[(1) - (3)].node));
+ (yyval.value).c = v1.c;
+ classinfo_t*t = v1.t;
+ char is_static = 0;
+ if(TYPE_IS_CLASS(t) && t->data) {
+ t = t->data;
+ is_static = 1;
+ }
+ if(TYPE_IS_XML(t)) {
+ multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
+ (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
+ (yyval.value).c = abc_coerce_a((yyval.value).c);
+ (yyval.value).t = TYPE_XMLLIST;
+ } else if(t) {
+ if(t->subtype==INFOTYPE_UNRESOLVED) {
+ syntaxerror("syntaxerror: trying to resolve property '%s' on incomplete object '%s'", (yyvsp[(3) - (3)].id), t->name);
}
- if(var_is_static && !i_am_static) {
- /* access to a static member from a non-static location.
- do this via findpropstrict:
- there doesn't seem to be any non-lookup way to access
- static properties of a class */
- state->method->late_binding = 1;
- (yyval.value).t = f->type;
- namespace_t ns = {flags2access(f->flags), ""};
- multiname_t m = {QNAME, &ns, 0, (yyvsp[(1) - (1)].id)};
- (yyval.value).c = abc_findpropstrict2((yyval.value).c, &m);
- (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
- break;
- } else if(f->slot>0) {
- (yyval.value).c = abc_getlocal_0((yyval.value).c);
+ memberinfo_t*f = findmember_nsset(t, (yyvsp[(3) - (3)].id), 1);
+ char noslot = 0;
+ if(f && !is_static != !(f->flags&FLAG_STATIC))
+ noslot=1;
+ if(f && f->slot && !noslot) {
(yyval.value).c = abc_getslot((yyval.value).c, f->slot);
- break;
} else {
- namespace_t ns = {flags2access(f->flags), ""};
- multiname_t m = {QNAME, &ns, 0, (yyvsp[(1) - (1)].id)};
- (yyval.value).c = abc_getlocal_0((yyval.value).c);
+ if(!f) {
+ if(!TYPE_IS_XMLLIST(t)) {
+ as3_softwarning("Access of undefined property '%s' in %s", (yyvsp[(3) - (3)].id), t->name);
+ }
+ }
+ MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
(yyval.value).c = abc_getproperty2((yyval.value).c, &m);
- break;
}
- }
-
- /* look at actual classes, in the current package and imported */
- if((a = find_class((yyvsp[(1) - (1)].id)))) {
- if(a->flags & FLAG_METHOD) {
- MULTINAME(m, a);
- (yyval.value).c = abc_findpropstrict2((yyval.value).c, &m);
- (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
- if(a->function->kind == MEMBER_METHOD) {
- (yyval.value).t = TYPE_FUNCTION(a->function);
- } else {
- (yyval.value).t = a->function->type;
- }
+ /* determine type */
+ (yyval.value).t = slotinfo_gettype((slotinfo_t*)f);
+ if(!(yyval.value).t)
+ (yyval.value).c = abc_coerce_a((yyval.value).c);
+
+ } else if(v1.c && v1.c->opcode == OPCODE___PUSHPACKAGE__) {
+ string_t*package = v1.c->data[0];
+ char*package2 = concat3(package->str, ".", (yyvsp[(3) - (3)].id));
+
+ slotinfo_t*a = registry_find(package->str, (yyvsp[(3) - (3)].id));
+ if(a) {
+ (yyval.value) = push_class(a);
+ } else if(dict_contains(state->import_toplevel_packages, package2) ||
+ registry_ispackage(package2)) {
+ (yyval.value).c = v1.c;
+ (yyval.value).c->data[0] = string_new4(package2);
+ (yyval.value).t = 0;
} else {
- if(a->slot) {
- (yyval.value).c = abc_getglobalscope((yyval.value).c);
- (yyval.value).c = abc_getslot((yyval.value).c, a->slot);
- } else {
- MULTINAME(m, a);
- (yyval.value).c = abc_getlex2((yyval.value).c, &m);
- }
- (yyval.value).t = TYPE_CLASS(a);
+ syntaxerror("couldn't resolve %s", package2);
}
- break;
+ } else {
+ /* when resolving a property on an unknown type, we do know the
+ name of the property (and don't seem to need the package), but
+ we need to make avm2 try out all access modes */
+ as3_softwarning("Resolving %s on unknown type", (yyvsp[(3) - (3)].id));
+ multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
+ (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
+ (yyval.value).c = abc_coerce_a((yyval.value).c);
+ (yyval.value).t = TYPE_ANY;
+ }
+}
}
+ break;
- /* unknown object, let the avm2 resolve it */
- if(1) {
- as3_softwarning("Couldn't resolve '%s', doing late binding", (yyvsp[(1) - (1)].id));
- state->method->late_binding = 1;
-
- multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(1) - (1)].id)};
- (yyval.value).t = 0;
- (yyval.value).c = abc_findpropstrict2((yyval.value).c, &m);
- (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
+
+ case 348:
+ if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3770 "parser.y"
+ {
+ PASS1
+ /* Queue unresolved identifiers for checking against the parent
+ function's variables.
+ We consider everything which is not a local variable "unresolved".
+ This encompasses class names, members of the surrounding class
+ etc. which is *correct* because local variables of the parent function
+ would shadow those.
+ */
+
+ if(!find_variable(state, (yyvsp[(1) - (1)].id))) {
+ unknown_variable((yyvsp[(1) - (1)].id));
+ /* let the compiler know that it might want to check the current directory/package
+ for this identifier- maybe there's a file $1.as defining $1. */
+ as3_schedule_class_noerror(state->package, (yyvsp[(1) - (1)].id));
}
+
+ (yyval.node) = 0;
+ PASS2
+
+ (yyval.node) = resolve_identifier((yyvsp[(1) - (1)].id));
}
}
break;
- case 284:
+ case 349:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 3139 "parser.y"
- {(yyval.code)=0;}
+#line 3804 "parser.y"
+ {
+ PASS12
+ NEW(namespace_decl_t,n);
+ n->name = (yyvsp[(2) - (2)].id);
+ n->url = (yyvsp[(2) - (2)].id);
+ (yyval.namespace_decl)=n;
+}
}
break;
- case 285:
+ case 350:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 3140 "parser.y"
- {(yyval.code)=0;}
+#line 3811 "parser.y"
+ {
+ PASS12
+ NEW(namespace_decl_t,n);
+ n->name = (yyvsp[(2) - (4)].id);
+ n->url = (yyvsp[(4) - (4)].id);
+ (yyval.namespace_decl)=n;
+}
}
break;
- case 286:
+ case 351:
if(as3_pass==2) {
-
/* Line 1464 of skeleton.m4 */
-#line 3141 "parser.y"
- {(yyval.code)=0;}
+#line 3818 "parser.y"
+ {
+ PASS12
+ NEW(namespace_decl_t,n);
+ n->name = (yyvsp[(2) - (4)].id);
+ n->url = (yyvsp[(4) - (4)].str).str;
+ (yyval.namespace_decl)=n;
+}
}
break;
- case 287:
+ case 352:
+ if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3825 "parser.y"
+ {
+ PASS12
+ trie_put(active_namespaces, (yyvsp[(2) - (2)].namespace_decl)->name, (void*)(yyvsp[(2) - (2)].namespace_decl)->url);
+
+ namespace_t access = modifiers2access(&(yyvsp[(1) - (2)].flags));
+ varinfo_t* var = varinfo_register_global(access.access, state->package, (yyvsp[(2) - (2)].namespace_decl)->name);
+ var->type = TYPE_NAMESPACE;
+ namespace_t ns;
+ ns.access = ACCESS_NAMESPACE;
+ ns.name = (yyvsp[(2) - (2)].namespace_decl)->url;
+ var->value = constant_new_namespace(&ns);
+
if(as3_pass==2) {
+ MULTINAME(m, TYPE_NAMESPACE);
+ trait_t*t = add_abc_slot(&(yyvsp[(1) - (2)].flags), (yyvsp[(2) - (2)].namespace_decl)->name, 0, 0);
+ t->value = var->value;
+ t->type_name = multiname_clone(&m);
+ }
+ (yyval.code)=0;
+}
+ }
+ break;
+
+
+
+ case 353:
+ if(as3_pass==2) {
/* Line 1464 of skeleton.m4 */
-#line 3143 "parser.y"
- {(yyval.token)=0;}
+#line 3848 "parser.y"
+ {
+ as3_warning("default xml namespaces not supported yet");
+ (yyval.code) = 0;
+}
}
break;
+
+ case 354:
+ if(as3_pass==2) {
+/* Line 1464 of skeleton.m4 */
+#line 3853 "parser.y"
+ {
+ PASS12
+ const char*url = (yyvsp[(3) - (3)].classinfo)->name;
+
+ varinfo_t*s = (varinfo_t*)(yyvsp[(3) - (3)].classinfo);
+ if(s->kind == INFOTYPE_UNRESOLVED) {
+ s = (varinfo_t*)registry_resolve((slotinfo_t*)s);
+ if(!s)
+ syntaxerror("Couldn't resolve namespace %s", (yyvsp[(3) - (3)].classinfo)->name);
+ }
+
+ if(!s || s->kind != INFOTYPE_VAR)
+ syntaxerror("%s.%s is not a public namespace (%d)", (yyvsp[(3) - (3)].classinfo)->package, (yyvsp[(3) - (3)].classinfo)->name, s?s->kind:-1);
+ if(!s->value || !NS_TYPE(s->value->type))
+ syntaxerror("%s.%s is not a namespace", (yyvsp[(3) - (3)].classinfo)->package, (yyvsp[(3) - (3)].classinfo)->name);
+ url = s->value->ns->name;
+
+ trie_put(active_namespaces, (yyvsp[(3) - (3)].classinfo)->name, (void*)url);
+ add_active_url(url);
+ (yyval.code)=0;
+}
+ }
+ break;
+
/* Line 1464 of skeleton.m4 */
-#line 7302 "parser.tab.c"
+#line 8465 "parser.tab.c"
default: break;
}
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);