diff options
| author | Jari Vetoniemi <jari.vetoniemi@indooratlas.com> | 2020-03-16 18:49:26 +0900 |
|---|---|---|
| committer | Jari Vetoniemi <jari.vetoniemi@indooratlas.com> | 2020-03-30 00:39:06 +0900 |
| commit | fcbf63e62c627deae76c1b8cb8c0876c536ed811 (patch) | |
| tree | 64cb17de3f41a2b6fef2368028fbd00349946994 /jni/ruby/parse.c | |
Fresh start
Diffstat (limited to 'jni/ruby/parse.c')
| -rw-r--r-- | jni/ruby/parse.c | 17889 |
1 files changed, 17889 insertions, 0 deletions
diff --git a/jni/ruby/parse.c b/jni/ruby/parse.c new file mode 100644 index 0000000..9693aad --- /dev/null +++ b/jni/ruby/parse.c @@ -0,0 +1,17889 @@ +/* A Bison parser, made by GNU Bison 2.5. */ + +/* Bison implementation for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2011 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 <http://www.gnu.org/licenses/>. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + 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. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "2.5" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 1 + +/* Push parsers. */ +#define YYPUSH 0 + +/* Pull parsers. */ +#define YYPULL 1 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + + + +/* Copy the first part of user declarations. */ + +/* Line 268 of yacc.c */ +#line 12 "parse.y" + + +#ifndef PARSER_DEBUG +#define PARSER_DEBUG 0 +#endif +#define YYDEBUG 1 +#define YYERROR_VERBOSE 1 +#define YYSTACK_USE_ALLOCA 0 + +#include "ruby/ruby.h" +#include "ruby/st.h" +#include "ruby/encoding.h" +#include "internal.h" +#include "node.h" +#include "parse.h" +#include "symbol.h" +#include "regenc.h" +#include <stdio.h> +#include <errno.h> +#include <ctype.h> +#include "probes.h" + +#ifndef WARN_PAST_SCOPE +# define WARN_PAST_SCOPE 0 +#endif + +#define YYMALLOC(size) rb_parser_malloc(parser, (size)) +#define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size)) +#define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size)) +#define YYFREE(ptr) rb_parser_free(parser, (ptr)) +#undef malloc +#undef realloc +#undef calloc +#undef free +#define malloc YYMALLOC +#define realloc YYREALLOC +#define calloc YYCALLOC +#define free YYFREE + +enum lex_state_bits { + EXPR_BEG_bit, /* ignore newline, +/- is a sign. */ + EXPR_END_bit, /* newline significant, +/- is an operator. */ + EXPR_ENDARG_bit, /* ditto, and unbound braces. */ + EXPR_ENDFN_bit, /* ditto, and unbound braces. */ + EXPR_ARG_bit, /* newline significant, +/- is an operator. */ + EXPR_CMDARG_bit, /* newline significant, +/- is an operator. */ + EXPR_MID_bit, /* newline significant, +/- is an operator. */ + EXPR_FNAME_bit, /* ignore newline, no reserved words. */ + EXPR_DOT_bit, /* right after `.' or `::', no reserved words. */ + EXPR_CLASS_bit, /* immediate after `class', no here document. */ + EXPR_VALUE_bit, /* alike EXPR_BEG but label is disallowed. */ + EXPR_LABELARG_bit, /* ignore significant, +/- is a sign. */ + EXPR_MAX_STATE +}; +/* examine combinations */ +enum lex_state_e { +#define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit) + DEF_EXPR(BEG), + DEF_EXPR(END), + DEF_EXPR(ENDARG), + DEF_EXPR(ENDFN), + DEF_EXPR(ARG), + DEF_EXPR(CMDARG), + DEF_EXPR(MID), + DEF_EXPR(FNAME), + DEF_EXPR(DOT), + DEF_EXPR(CLASS), + DEF_EXPR(VALUE), + DEF_EXPR(LABELARG), + EXPR_BEG_ANY = (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS | EXPR_LABELARG), + EXPR_ARG_ANY = (EXPR_ARG | EXPR_CMDARG), + EXPR_END_ANY = (EXPR_END | EXPR_ENDARG | EXPR_ENDFN) +}; +#define IS_lex_state_for(x, ls) ((x) & (ls)) +#define IS_lex_state(ls) IS_lex_state_for(lex_state, (ls)) + +#if PARSER_DEBUG +static const char *lex_state_name(enum lex_state_e state); +#endif + +typedef VALUE stack_type; + +# define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1)) +# define BITSTACK_POP(stack) ((stack) = (stack) >> 1) +# define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1)) +# define BITSTACK_SET_P(stack) ((stack)&1) + +#define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n)) +#define COND_POP() BITSTACK_POP(cond_stack) +#define COND_LEXPOP() BITSTACK_LEXPOP(cond_stack) +#define COND_P() BITSTACK_SET_P(cond_stack) + +#define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n)) +#define CMDARG_POP() BITSTACK_POP(cmdarg_stack) +#define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack) +#define CMDARG_P() BITSTACK_SET_P(cmdarg_stack) + +struct vtable { + ID *tbl; + int pos; + int capa; + struct vtable *prev; +}; + +struct local_vars { + struct vtable *args; + struct vtable *vars; + struct vtable *used; +# if WARN_PAST_SCOPE + struct vtable *past; +# endif + struct local_vars *prev; + stack_type cmdargs; +}; + +#define DVARS_INHERIT ((void*)1) +#define DVARS_TOPSCOPE NULL +#define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl)) +#define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3) + +static int +vtable_size(const struct vtable *tbl) +{ + if (POINTER_P(tbl)) { + return tbl->pos; + } + else { + return 0; + } +} + +#define VTBL_DEBUG 0 + +static struct vtable * +vtable_alloc(struct vtable *prev) +{ + struct vtable *tbl = ALLOC(struct vtable); + tbl->pos = 0; + tbl->capa = 8; + tbl->tbl = ALLOC_N(ID, tbl->capa); + tbl->prev = prev; + if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl); + return tbl; +} + +static void +vtable_free(struct vtable *tbl) +{ + if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl); + if (POINTER_P(tbl)) { + if (tbl->tbl) { + xfree(tbl->tbl); + } + xfree(tbl); + } +} + +static void +vtable_add(struct vtable *tbl, ID id) +{ + if (!POINTER_P(tbl)) { + rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl); + } + if (VTBL_DEBUG) printf("vtable_add: %p, %"PRIsVALUE"\n", (void *)tbl, rb_id2str(id)); + + if (tbl->pos == tbl->capa) { + tbl->capa = tbl->capa * 2; + REALLOC_N(tbl->tbl, ID, tbl->capa); + } + tbl->tbl[tbl->pos++] = id; +} + +#ifndef RIPPER +static void +vtable_pop(struct vtable *tbl, int n) +{ + if (tbl->pos < n) rb_bug("vtable_pop: unreachable"); + tbl->pos -= n; +} +#endif + +static int +vtable_included(const struct vtable * tbl, ID id) +{ + int i; + + if (POINTER_P(tbl)) { + for (i = 0; i < tbl->pos; i++) { + if (tbl->tbl[i] == id) { + return i+1; + } + } + } + return 0; +} + + +#ifndef RIPPER +typedef struct token_info { + const char *token; + int linenum; + int column; + int nonspc; + struct token_info *next; +} token_info; +#endif + +/* + Structure of Lexer Buffer: + + lex_pbeg tokp lex_p lex_pend + | | | | + |-----------+--------------+------------| + |<------------>| + token +*/ +struct parser_params { + NODE *heap; + + YYSTYPE *parser_yylval; + VALUE eofp; + + NODE *parser_lex_strterm; + stack_type parser_cond_stack; + stack_type parser_cmdarg_stack; + enum lex_state_e parser_lex_state; + int parser_paren_nest; + int parser_lpar_beg; + int parser_in_single; + int parser_in_def; + int parser_brace_nest; + int parser_compile_for_eval; + int parser_in_kwarg; + int parser_in_defined; + int parser_tokidx; + int parser_toksiz; + int parser_tokline; + char *parser_tokenbuf; + VALUE parser_lex_input; + VALUE parser_lex_lastline; + VALUE parser_lex_nextline; + const char *parser_lex_pbeg; + const char *parser_lex_p; + const char *parser_lex_pend; + int parser_heredoc_end; + int parser_command_start; + NODE *parser_deferred_nodes; + long parser_lex_gets_ptr; + VALUE (*parser_lex_gets)(struct parser_params*,VALUE); + struct local_vars *parser_lvtbl; + int line_count; + int parser_ruby_sourceline; /* current line no. */ + char *parser_ruby_sourcefile; /* current source file */ + VALUE parser_ruby_sourcefile_string; + rb_encoding *enc; + + ID cur_arg; + + int last_cr_line; + + unsigned int parser_ruby__end__seen: 1; + unsigned int parser_yydebug: 1; + unsigned int has_shebang: 1; + +#ifndef RIPPER + /* Ruby core only */ + unsigned int parser_token_info_enabled: 1; +# if WARN_PAST_SCOPE + unsigned int parser_past_scope_enabled: 1; +# endif + int nerr; + + NODE *parser_eval_tree_begin; + NODE *parser_eval_tree; + VALUE debug_lines; + VALUE coverage; + + token_info *parser_token_info; +#else + /* Ripper only */ + unsigned int toplevel_p: 1; + unsigned int error_p: 1; + + const char *tokp; + VALUE delayed; + int delayed_line; + int delayed_col; + + VALUE value; + VALUE result; + VALUE parsing_thread; +#endif +}; + +#ifdef RIPPER +#define intern_cstr(n,l,en) rb_intern3(n,l,en) +#else +#define intern_cstr(n,l,en) rb_intern3(n,l,en) +#endif + +#define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc) +#define STR_NEW0() rb_enc_str_new(0,0,current_enc) +#define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc) +#define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc) +#define TOK_INTERN() intern_cstr(tok(), toklen(), current_enc) + +static int parser_yyerror(struct parser_params*, const char*); +#define yyerror(msg) parser_yyerror(parser, (msg)) + +#define lex_strterm (parser->parser_lex_strterm) +#define lex_state (parser->parser_lex_state) +#define cond_stack (parser->parser_cond_stack) +#define cmdarg_stack (parser->parser_cmdarg_stack) +#define paren_nest (parser->parser_paren_nest) +#define lpar_beg (parser->parser_lpar_beg) +#define brace_nest (parser->parser_brace_nest) +#define in_single (parser->parser_in_single) +#define in_def (parser->parser_in_def) +#define compile_for_eval (parser->parser_compile_for_eval) +#define in_defined (parser->parser_in_defined) +#define tokenbuf (parser->parser_tokenbuf) +#define tokidx (parser->parser_tokidx) +#define toksiz (parser->parser_toksiz) +#define tokline (parser->parser_tokline) +#define lex_input (parser->parser_lex_input) +#define lex_lastline (parser->parser_lex_lastline) +#define lex_nextline (parser->parser_lex_nextline) +#define lex_pbeg (parser->parser_lex_pbeg) +#define lex_p (parser->parser_lex_p) +#define lex_pend (parser->parser_lex_pend) +#define heredoc_end (parser->parser_heredoc_end) +#define command_start (parser->parser_command_start) +#define deferred_nodes (parser->parser_deferred_nodes) +#define lex_gets_ptr (parser->parser_lex_gets_ptr) +#define lex_gets (parser->parser_lex_gets) +#define lvtbl (parser->parser_lvtbl) +#define ruby__end__seen (parser->parser_ruby__end__seen) +#define ruby_sourceline (parser->parser_ruby_sourceline) +#define ruby_sourcefile (parser->parser_ruby_sourcefile) +#define ruby_sourcefile_string (parser->parser_ruby_sourcefile_string) +#define current_enc (parser->enc) +#define current_arg (parser->cur_arg) +#define yydebug (parser->parser_yydebug) +#ifdef RIPPER +#else +#define ruby_eval_tree (parser->parser_eval_tree) +#define ruby_eval_tree_begin (parser->parser_eval_tree_begin) +#define ruby_debug_lines (parser->debug_lines) +#define ruby_coverage (parser->coverage) +#endif + +#if YYPURE +static int yylex(void*, void*); +#else +static int yylex(void*); +#endif + +#ifndef RIPPER +#define yyparse ruby_yyparse + +static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE); +#define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3)) + +static NODE *cond_gen(struct parser_params*,NODE*); +#define cond(node) cond_gen(parser, (node)) +static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*); +#define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2)) + +static NODE *newline_node(NODE*); +static void fixpos(NODE*,NODE*); + +static int value_expr_gen(struct parser_params*,NODE*); +static void void_expr_gen(struct parser_params*,NODE*); +static NODE *remove_begin(NODE*); +static NODE *remove_begin_all(NODE*); +#define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node)) +#define void_expr0(node) void_expr_gen(parser, (node)) +#define void_expr(node) void_expr0((node) = remove_begin(node)) +static void void_stmts_gen(struct parser_params*,NODE*); +#define void_stmts(node) void_stmts_gen(parser, (node)) +static void reduce_nodes_gen(struct parser_params*,NODE**); +#define reduce_nodes(n) reduce_nodes_gen(parser,(n)) +static void block_dup_check_gen(struct parser_params*,NODE*,NODE*); +#define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2)) + +static NODE *block_append_gen(struct parser_params*,NODE*,NODE*); +#define block_append(h,t) block_append_gen(parser,(h),(t)) +static NODE *list_append_gen(struct parser_params*,NODE*,NODE*); +#define list_append(l,i) list_append_gen(parser,(l),(i)) +static NODE *list_concat(NODE*,NODE*); +static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*); +#define arg_append(h,t) arg_append_gen(parser,(h),(t)) +static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*); +#define arg_concat(h,t) arg_concat_gen(parser,(h),(t)) +static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*); +#define literal_concat(h,t) literal_concat_gen(parser,(h),(t)) +static int literal_concat0(struct parser_params *, VALUE, VALUE); +static NODE *new_evstr_gen(struct parser_params*,NODE*); +#define new_evstr(n) new_evstr_gen(parser,(n)) +static NODE *evstr2dstr_gen(struct parser_params*,NODE*); +#define evstr2dstr(n) evstr2dstr_gen(parser,(n)) +static NODE *splat_array(NODE*); + +static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*); +#define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1)) +static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID); +#define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id)) + +static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*); +#define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t)) +static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID); +#define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b)) +#define new_kw_arg(k) ((k) ? NEW_KW_ARG(0, (k)) : 0) + +static VALUE negate_lit(VALUE); +static NODE *ret_args_gen(struct parser_params*,NODE*); +#define ret_args(node) ret_args_gen(parser, (node)) +static NODE *arg_blk_pass(NODE*,NODE*); +static NODE *new_yield_gen(struct parser_params*,NODE*); +#define new_yield(node) new_yield_gen(parser, (node)) +static NODE *dsym_node_gen(struct parser_params*,NODE*); +#define dsym_node(node) dsym_node_gen(parser, (node)) + +static NODE *gettable_gen(struct parser_params*,ID); +#define gettable(id) gettable_gen(parser,(id)) +static NODE *assignable_gen(struct parser_params*,ID,NODE*); +#define assignable(id,node) assignable_gen(parser, (id), (node)) + +static NODE *aryset_gen(struct parser_params*,NODE*,NODE*); +#define aryset(node1,node2) aryset_gen(parser, (node1), (node2)) +static NODE *attrset_gen(struct parser_params*,NODE*,ID); +#define attrset(node,id) attrset_gen(parser, (node), (id)) + +static void rb_backref_error_gen(struct parser_params*,NODE*); +#define rb_backref_error(n) rb_backref_error_gen(parser,(n)) +static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*); +#define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2)) + +static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs); +static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs); +#define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs)) +static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs); +#define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs)) + +static NODE *new_hash_gen(struct parser_params *parser, NODE *hash); +#define new_hash(hash) new_hash_gen(parser, (hash)) + +#define new_defined(expr) NEW_DEFINED(remove_begin_all(expr)) + +static NODE *match_op_gen(struct parser_params*,NODE*,NODE*); +#define match_op(node1,node2) match_op_gen(parser, (node1), (node2)) + +static ID *local_tbl_gen(struct parser_params*); +#define local_tbl() local_tbl_gen(parser) + +static void fixup_nodes(NODE **); + +static VALUE reg_compile_gen(struct parser_params*, VALUE, int); +#define reg_compile(str,options) reg_compile_gen(parser, (str), (options)) +static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int); +#define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options)) +static int reg_fragment_check_gen(struct parser_params*, VALUE, int); +#define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options)) +static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match); +#define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match)) + +#define get_id(id) (id) +#define get_value(val) (val) +#else +#define NODE_RIPPER NODE_CDECL + +static inline VALUE +ripper_new_yylval(ID a, VALUE b, VALUE c) +{ + return (VALUE)NEW_CDECL(a, b, c); +} + +static inline int +ripper_is_node_yylval(VALUE n) +{ + return RB_TYPE_P(n, T_NODE) && nd_type(RNODE(n)) == NODE_RIPPER; +} + +#define value_expr(node) ((void)(node)) +#define remove_begin(node) (node) +#define rb_dvar_defined(id) 0 +#define rb_local_defined(id) 0 +static ID ripper_get_id(VALUE); +#define get_id(id) ripper_get_id(id) +static VALUE ripper_get_value(VALUE); +#define get_value(val) ripper_get_value(val) +static VALUE assignable_gen(struct parser_params*,VALUE); +#define assignable(lhs,node) assignable_gen(parser, (lhs)) +static int id_is_var_gen(struct parser_params *parser, ID id); +#define id_is_var(id) id_is_var_gen(parser, (id)) + +#define node_assign(node1, node2) dispatch2(assign, (node1), (node2)) + +static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs); +static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs); +#define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs)) + +#endif /* !RIPPER */ + +#define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs)) + +RUBY_FUNC_EXPORTED VALUE rb_parser_reg_compile(struct parser_params* parser, VALUE str, int options, VALUE *errmsg); + +static ID formal_argument_gen(struct parser_params*, ID); +#define formal_argument(id) formal_argument_gen(parser, (id)) +static ID shadowing_lvar_gen(struct parser_params*,ID); +#define shadowing_lvar(name) shadowing_lvar_gen(parser, (name)) +static void new_bv_gen(struct parser_params*,ID); +#define new_bv(id) new_bv_gen(parser, (id)) + +static void local_push_gen(struct parser_params*,int); +#define local_push(top) local_push_gen(parser,(top)) +static void local_pop_gen(struct parser_params*); +#define local_pop() local_pop_gen(parser) +static void local_var_gen(struct parser_params*, ID); +#define local_var(id) local_var_gen(parser, (id)) +static void arg_var_gen(struct parser_params*, ID); +#define arg_var(id) arg_var_gen(parser, (id)) +static int local_id_gen(struct parser_params*, ID); +#define local_id(id) local_id_gen(parser, (id)) +static ID internal_id_gen(struct parser_params*); +#define internal_id() internal_id_gen(parser) + +static const struct vtable *dyna_push_gen(struct parser_params *); +#define dyna_push() dyna_push_gen(parser) +static void dyna_pop_gen(struct parser_params*, const struct vtable *); +#define dyna_pop(node) dyna_pop_gen(parser, (node)) +static int dyna_in_block_gen(struct parser_params*); +#define dyna_in_block() dyna_in_block_gen(parser) +#define dyna_var(id) local_var(id) +static int dvar_defined_gen(struct parser_params*,ID,int); +#define dvar_defined(id) dvar_defined_gen(parser, (id), 0) +#define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1) +static int dvar_curr_gen(struct parser_params*,ID); +#define dvar_curr(id) dvar_curr_gen(parser, (id)) + +static int lvar_defined_gen(struct parser_params*, ID); +#define lvar_defined(id) lvar_defined_gen(parser, (id)) + +#define RE_OPTION_ONCE (1<<16) +#define RE_OPTION_ENCODING_SHIFT 8 +#define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT) +#define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff) +#define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE) +#define RE_OPTION_MASK 0xff +#define RE_OPTION_ARG_ENCODING_NONE 32 + +#define NODE_STRTERM NODE_ZARRAY /* nothing to gc */ +#define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */ +#define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1)) +#define nd_func u1.id +#if SIZEOF_SHORT == 2 +#define nd_term(node) ((signed short)(node)->u2.id) +#else +#define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2) +#endif +#define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2) +#define nd_nest u3.cnt + +/****** Ripper *******/ + +#ifdef RIPPER +#define RIPPER_VERSION "0.1.0" + +static inline VALUE intern_sym(const char *name); + +#include "eventids1.c" +#include "eventids2.c" + +static VALUE ripper_dispatch0(struct parser_params*,ID); +static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE); +static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE); +static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE); +static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE); +static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE); +static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE); +static void ripper_error_gen(struct parser_params *parser); +#define ripper_error() ripper_error_gen(parser) + +#define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n)) +#define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a)) +#define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b)) +#define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c)) +#define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d)) +#define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e)) +#define dispatch7(n,a,b,c,d,e,f,g) ripper_dispatch7(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e), (f), (g)) + +#define yyparse ripper_yyparse + +#define ripper_intern(s) ID2SYM(rb_intern(s)) +static VALUE ripper_id2sym(ID); +#ifdef __GNUC__ +#define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \ + ID2SYM(id) : ripper_id2sym(id)) +#endif + +#define arg_new() dispatch0(args_new) +#define arg_add(l,a) dispatch2(args_add, (l), (a)) +#define arg_add_star(l,a) dispatch2(args_add_star, (l), (a)) +#define arg_add_block(l,b) dispatch2(args_add_block, (l), (b)) +#define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b))) +#define bare_assoc(v) dispatch1(bare_assoc_hash, (v)) +#define arg_add_assocs(l,b) arg_add((l), bare_assoc(b)) + +#define args2mrhs(a) dispatch1(mrhs_new_from_args, (a)) +#define mrhs_new() dispatch0(mrhs_new) +#define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a)) +#define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a)) + +#define mlhs_new() dispatch0(mlhs_new) +#define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a)) +#define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a)) + +#define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \ + dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk)) + +#define blockvar_new(p,v) dispatch2(block_var, (p), (v)) +#define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a)) +#define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a)) + +#define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a))) +#define method_arg(m,a) dispatch2(method_add_arg,(m),(a)) +#define method_add_block(m,b) dispatch2(method_add_block, (m), (b)) + +#define escape_Qundef(x) ((x)==Qundef ? Qnil : (x)) + +static inline VALUE +new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail) +{ + NODE *t = (NODE *)tail; + VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value; + return params_new(f, o, r, p, k, kr, escape_Qundef(b)); +} +#define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t)) + +static inline VALUE +new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b) +{ + return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b); +} +#define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b)) + +#define new_defined(expr) dispatch1(defined, (expr)) + +#define FIXME 0 + +#endif /* RIPPER */ + +#ifndef RIPPER +# define Qnone 0 +# define ifndef_ripper(x) (x) +#else +# define Qnone Qnil +# define ifndef_ripper(x) +#endif + +#ifndef RIPPER +# define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt)) +# define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a)) +# define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a)) +# define rb_warnV(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a)) +# define rb_warn4S(file,line,fmt,a) rb_compile_warn((file), (line), (fmt), (a)) +# define rb_warn4V(file,line,fmt,a) rb_compile_warn((file), (line), (fmt), (a)) +# define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt)) +# define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a)) +# define rb_warningV(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a)) +#else +# define rb_warn0(fmt) ripper_warn0(parser, (fmt)) +# define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a)) +# define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a)) +# define rb_warnV(fmt,a) ripper_warnV(parser, (fmt), (a)) +# define rb_warn4S(file,line,fmt,a) ripper_warnS(parser, (fmt), (a)) +# define rb_warn4V(file,line,fmt,a) ripper_warnV(parser, (fmt), (a)) +# define rb_warning0(fmt) ripper_warning0(parser, (fmt)) +# define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a)) +# define rb_warningV(fmt,a) ripper_warningV(parser, (fmt), (a)) +static void ripper_warn0(struct parser_params*, const char*); +static void ripper_warnI(struct parser_params*, const char*, int); +static void ripper_warnS(struct parser_params*, const char*, const char*); +static void ripper_warnV(struct parser_params*, const char*, VALUE); +static void ripper_warning0(struct parser_params*, const char*); +static void ripper_warningS(struct parser_params*, const char*, const char*); +static void ripper_warningV(struct parser_params*, const char*, VALUE); +#endif + +#ifdef RIPPER +static void ripper_compile_error(struct parser_params*, const char *fmt, ...); +# define rb_compile_error ripper_compile_error +# define compile_error ripper_compile_error +# define PARSER_ARG parser, +#else +# define rb_compile_error rb_compile_error_with_enc +# define compile_error parser->nerr++,rb_compile_error_with_enc +# define PARSER_ARG ruby_sourcefile, ruby_sourceline, (void *)current_enc, +#endif + +/* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150, + for instance). This is too low for Ruby to parse some files, such as + date/format.rb, therefore bump the value up to at least Bison's default. */ +#ifdef OLD_YACC +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif +#endif + +#ifndef RIPPER +static void token_info_push(struct parser_params*, const char *token); +static void token_info_pop(struct parser_params*, const char *token); +#define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0) +#define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0) +#else +#define token_info_push(token) /* nothing */ +#define token_info_pop(token) /* nothing */ +#endif + + +/* Line 268 of yacc.c */ +#line 793 "parse.c" + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +# define YYTOKEN_TABLE 0 +#endif + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + END_OF_INPUT = 0, + keyword_class = 258, + keyword_module = 259, + keyword_def = 260, + keyword_undef = 261, + keyword_begin = 262, + keyword_rescue = 263, + keyword_ensure = 264, + keyword_end = 265, + keyword_if = 266, + keyword_unless = 267, + keyword_then = 268, + keyword_elsif = 269, + keyword_else = 270, + keyword_case = 271, + keyword_when = 272, + keyword_while = 273, + keyword_until = 274, + keyword_for = 275, + keyword_break = 276, + keyword_next = 277, + keyword_redo = 278, + keyword_retry = 279, + keyword_in = 280, + keyword_do = 281, + keyword_do_cond = 282, + keyword_do_block = 283, + keyword_do_LAMBDA = 284, + keyword_return = 285, + keyword_yield = 286, + keyword_super = 287, + keyword_self = 288, + keyword_nil = 289, + keyword_true = 290, + keyword_false = 291, + keyword_and = 292, + keyword_or = 293, + keyword_not = 294, + modifier_if = 295, + modifier_unless = 296, + modifier_while = 297, + modifier_until = 298, + modifier_rescue = 299, + keyword_alias = 300, + keyword_defined = 301, + keyword_BEGIN = 302, + keyword_END = 303, + keyword__LINE__ = 304, + keyword__FILE__ = 305, + keyword__ENCODING__ = 306, + tIDENTIFIER = 307, + tFID = 308, + tGVAR = 309, + tIVAR = 310, + tCONSTANT = 311, + tCVAR = 312, + tLABEL = 313, + tINTEGER = 314, + tFLOAT = 315, + tRATIONAL = 316, + tIMAGINARY = 317, + tSTRING_CONTENT = 318, + tCHAR = 319, + tNTH_REF = 320, + tBACK_REF = 321, + tREGEXP_END = 322, + tUPLUS = 130, + tUMINUS = 131, + tPOW = 132, + tCMP = 134, + tEQ = 139, + tEQQ = 140, + tNEQ = 141, + tGEQ = 138, + tLEQ = 137, + tANDOP = 148, + tOROP = 149, + tMATCH = 142, + tNMATCH = 143, + tDOT2 = 128, + tDOT3 = 129, + tAREF = 144, + tASET = 145, + tLSHFT = 135, + tRSHFT = 136, + tCOLON2 = 323, + tCOLON3 = 324, + tOP_ASGN = 325, + tASSOC = 326, + tLPAREN = 327, + tLPAREN_ARG = 328, + tRPAREN = 329, + tLBRACK = 330, + tLBRACE = 331, + tLBRACE_ARG = 332, + tSTAR = 333, + tDSTAR = 334, + tAMPER = 335, + tLAMBDA = 336, + tSYMBEG = 337, + tSTRING_BEG = 338, + tXSTRING_BEG = 339, + tREGEXP_BEG = 340, + tWORDS_BEG = 341, + tQWORDS_BEG = 342, + tSYMBOLS_BEG = 343, + tQSYMBOLS_BEG = 344, + tSTRING_DBEG = 345, + tSTRING_DEND = 346, + tSTRING_DVAR = 347, + tSTRING_END = 348, + tLAMBEG = 349, + tLABEL_END = 350, + tLOWEST = 351, + tUMINUS_NUM = 352, + tLAST_TOKEN = 353 + }; +#endif + + + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +{ + +/* Line 293 of yacc.c */ +#line 737 "parse.y" + + VALUE val; + NODE *node; + ID id; + int num; + const struct vtable *vars; + + + +/* Line 293 of yacc.c */ +#line 957 "parse.c" +} YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +#endif + + +/* Copy the second part of user declarations. */ + + +/* Line 343 of yacc.c */ +#line 969 "parse.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__ \ + || defined __cplusplus || defined _MSC_VER) +# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned int +# endif +#endif + +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(e) ((void) (e)) +#else +# define YYUSE(e) /* empty */ +#endif + +/* Identity function, used to suppress warnings about constant conditions. */ +#ifndef lint +# define YYID(n) (n) +#else +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static int +YYID (int yyi) +#else +static int +YYID (yyi) + int yyi; +#endif +{ + return yyi; +} +#endif + +#if ! defined yyoverflow || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined EXIT_SUCCESS \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yytype_int16 yyss_alloc; + YYSTYPE yyvs_alloc; +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (YYID (0)) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (YYID (0)) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 3 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 11005 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 145 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 208 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 632 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 1068 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 353 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const yytype_uint8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 144, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 143, 130, 2, 2, 2, 128, 123, 2, + 139, 140, 126, 124, 137, 125, 136, 127, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 118, 142, + 120, 116, 119, 117, 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, 135, 2, 141, 122, 2, 138, 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, 133, 121, 134, 131, 2, 81, 82, + 68, 69, 70, 2, 71, 85, 86, 76, 75, 72, + 73, 74, 79, 80, 83, 84, 2, 2, 77, 78, + 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, 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, 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, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 129, 132 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const yytype_uint16 yyprhs[] = +{ + 0, 0, 3, 4, 7, 10, 12, 14, 18, 21, + 23, 24, 30, 35, 38, 40, 42, 46, 49, 51, + 52, 58, 59, 64, 68, 72, 76, 79, 83, 87, + 91, 95, 99, 104, 106, 110, 114, 121, 127, 133, + 139, 145, 149, 153, 157, 159, 163, 167, 169, 173, + 177, 181, 184, 186, 188, 190, 192, 194, 199, 200, + 206, 208, 211, 215, 220, 226, 231, 237, 240, 243, + 246, 249, 252, 254, 258, 260, 264, 266, 269, 273, + 279, 282, 287, 290, 295, 297, 301, 303, 307, 310, + 314, 316, 320, 322, 324, 329, 333, 337, 341, 345, + 348, 350, 352, 354, 359, 363, 367, 371, 375, 378, + 380, 382, 384, 387, 389, 393, 395, 397, 399, 401, + 403, 405, 407, 409, 411, 413, 414, 419, 421, 423, + 425, 427, 429, 431, 433, 435, 437, 439, 441, 443, + 445, 447, 449, 451, 453, 455, 457, 459, 461, 463, + 465, 467, 469, 471, 473, 475, 477, 479, 481, 483, + 485, 487, 489, 491, 493, 495, 497, 499, 501, 503, + 505, 507, 509, 511, 513, 515, 517, 519, 521, 523, + 525, 527, 529, 531, 533, 535, 537, 539, 541, 543, + 545, 547, 549, 551, 553, 555, 557, 559, 561, 565, + 571, 575, 581, 588, 594, 600, 606, 612, 617, 621, + 625, 629, 633, 637, 641, 645, 649, 653, 658, 661, + 664, 668, 672, 676, 680, 684, 688, 692, 696, 700, + 704, 708, 712, 716, 719, 722, 726, 730, 734, 738, + 739, 744, 745, 746, 755, 757, 759, 761, 764, 769, + 772, 776, 778, 780, 782, 784, 787, 792, 795, 797, + 800, 803, 808, 810, 811, 814, 817, 820, 822, 824, + 827, 831, 836, 838, 840, 844, 849, 852, 854, 856, + 858, 860, 862, 864, 866, 868, 870, 872, 874, 875, + 880, 881, 885, 886, 887, 893, 897, 901, 904, 908, + 912, 914, 919, 923, 925, 926, 933, 938, 942, 945, + 947, 950, 953, 960, 967, 968, 969, 977, 978, 979, + 987, 993, 998, 999, 1000, 1010, 1011, 1018, 1019, 1020, + 1029, 1030, 1036, 1037, 1044, 1045, 1046, 1056, 1058, 1060, + 1062, 1064, 1066, 1068, 1070, 1072, 1074, 1076, 1078, 1080, + 1082, 1084, 1086, 1088, 1090, 1092, 1095, 1097, 1099, 1101, + 1107, 1109, 1112, 1114, 1116, 1118, 1122, 1124, 1128, 1130, + 1135, 1142, 1146, 1152, 1155, 1160, 1162, 1166, 1171, 1174, + 1177, 1179, 1182, 1183, 1190, 1199, 1204, 1211, 1216, 1219, + 1226, 1229, 1234, 1241, 1244, 1249, 1252, 1257, 1259, 1261, + 1263, 1267, 1269, 1274, 1276, 1281, 1283, 1287, 1289, 1291, + 1292, 1293, 1294, 1295, 1302, 1307, 1309, 1313, 1317, 1318, + 1324, 1327, 1332, 1338, 1344, 1347, 1348, 1354, 1355, 1361, + 1365, 1366, 1371, 1372, 1377, 1380, 1382, 1387, 1388, 1394, + 1395, 1401, 1407, 1409, 1411, 1418, 1420, 1422, 1424, 1426, + 1429, 1431, 1434, 1436, 1438, 1440, 1442, 1444, 1446, 1448, + 1451, 1455, 1459, 1463, 1467, 1471, 1472, 1476, 1478, 1481, + 1485, 1489, 1490, 1494, 1498, 1502, 1506, 1510, 1511, 1515, + 1516, 1520, 1521, 1524, 1525, 1528, 1529, 1532, 1534, 1535, + 1539, 1540, 1541, 1542, 1543, 1551, 1553, 1555, 1557, 1559, + 1562, 1564, 1566, 1568, 1570, 1574, 1576, 1579, 1581, 1583, + 1585, 1587, 1589, 1591, 1593, 1595, 1597, 1599, 1601, 1603, + 1605, 1607, 1609, 1611, 1613, 1615, 1617, 1619, 1621, 1623, + 1625, 1626, 1631, 1634, 1638, 1639, 1643, 1648, 1651, 1654, + 1656, 1659, 1660, 1667, 1676, 1681, 1688, 1693, 1700, 1703, + 1708, 1715, 1718, 1723, 1726, 1731, 1733, 1734, 1736, 1738, + 1740, 1742, 1744, 1746, 1748, 1750, 1754, 1756, 1760, 1762, + 1765, 1767, 1770, 1772, 1774, 1778, 1780, 1784, 1786, 1788, + 1791, 1793, 1797, 1801, 1803, 1807, 1809, 1813, 1815, 1817, + 1820, 1822, 1824, 1826, 1829, 1832, 1834, 1836, 1837, 1842, + 1844, 1847, 1849, 1853, 1857, 1860, 1865, 1868, 1870, 1872, + 1874, 1876, 1878, 1880, 1882, 1884, 1886, 1888, 1890, 1892, + 1893, 1895, 1896, 1898, 1901, 1904, 1905, 1907, 1909, 1911, + 1913, 1915, 1918 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yytype_int16 yyrhs[] = +{ + 146, 0, -1, -1, 147, 148, -1, 149, 345, -1, + 352, -1, 150, -1, 149, 351, 150, -1, 1, 150, + -1, 157, -1, -1, 47, 151, 133, 148, 134, -1, + 153, 269, 236, 272, -1, 154, 345, -1, 352, -1, + 155, -1, 154, 351, 155, -1, 1, 157, -1, 157, + -1, -1, 47, 156, 133, 148, 134, -1, -1, 45, + 180, 158, 180, -1, 45, 54, 54, -1, 45, 54, + 66, -1, 45, 54, 65, -1, 6, 181, -1, 157, + 40, 161, -1, 157, 41, 161, -1, 157, 42, 161, + -1, 157, 43, 161, -1, 157, 44, 157, -1, 48, + 133, 153, 134, -1, 159, -1, 168, 116, 162, -1, + 306, 89, 162, -1, 221, 135, 193, 348, 89, 162, + -1, 221, 136, 52, 89, 162, -1, 221, 136, 56, + 89, 162, -1, 221, 87, 56, 89, 162, -1, 221, + 87, 52, 89, 162, -1, 307, 89, 162, -1, 175, + 116, 201, -1, 168, 116, 200, -1, 160, -1, 175, + 116, 162, -1, 175, 116, 159, -1, 162, -1, 160, + 37, 160, -1, 160, 38, 160, -1, 39, 346, 160, + -1, 130, 162, -1, 185, -1, 160, -1, 167, -1, + 163, -1, 258, -1, 258, 344, 342, 195, -1, -1, + 96, 165, 244, 153, 134, -1, 341, -1, 166, 195, + -1, 166, 195, 164, -1, 221, 136, 342, 195, -1, + 221, 136, 342, 195, 164, -1, 221, 87, 342, 195, + -1, 221, 87, 342, 195, 164, -1, 32, 195, -1, + 31, 195, -1, 30, 194, -1, 21, 194, -1, 22, + 194, -1, 170, -1, 91, 169, 347, -1, 170, -1, + 91, 169, 347, -1, 172, -1, 172, 171, -1, 172, + 97, 174, -1, 172, 97, 174, 137, 173, -1, 172, + 97, -1, 172, 97, 137, 173, -1, 97, 174, -1, + 97, 174, 137, 173, -1, 97, -1, 97, 137, 173, + -1, 174, -1, 91, 169, 347, -1, 171, 137, -1, + 172, 171, 137, -1, 171, -1, 173, 137, 171, -1, + 303, -1, 304, -1, 221, 135, 193, 348, -1, 221, + 136, 52, -1, 221, 87, 52, -1, 221, 136, 56, + -1, 221, 87, 56, -1, 88, 56, -1, 307, -1, + 303, -1, 304, -1, 221, 135, 193, 348, -1, 221, + 136, 52, -1, 221, 87, 52, -1, 221, 136, 56, + -1, 221, 87, 56, -1, 88, 56, -1, 307, -1, + 52, -1, 56, -1, 88, 176, -1, 176, -1, 221, + 87, 176, -1, 52, -1, 56, -1, 53, -1, 183, + -1, 184, -1, 178, -1, 298, -1, 179, -1, 300, + -1, 180, -1, -1, 181, 137, 182, 180, -1, 121, + -1, 122, -1, 123, -1, 71, -1, 72, -1, 73, + -1, 79, -1, 80, -1, 119, -1, 75, -1, 120, + -1, 76, -1, 74, -1, 85, -1, 86, -1, 124, + -1, 125, -1, 126, -1, 97, -1, 127, -1, 128, + -1, 70, -1, 98, -1, 130, -1, 131, -1, 68, + -1, 69, -1, 83, -1, 84, -1, 138, -1, 49, + -1, 50, -1, 51, -1, 47, -1, 48, -1, 45, + -1, 37, -1, 7, -1, 21, -1, 16, -1, 3, + -1, 5, -1, 46, -1, 26, -1, 15, -1, 14, + -1, 10, -1, 9, -1, 36, -1, 20, -1, 25, + -1, 4, -1, 22, -1, 34, -1, 39, -1, 38, + -1, 23, -1, 8, -1, 24, -1, 30, -1, 33, + -1, 32, -1, 13, -1, 35, -1, 6, -1, 17, + -1, 31, -1, 11, -1, 12, -1, 18, -1, 19, + -1, 175, 116, 185, -1, 175, 116, 185, 44, 185, + -1, 306, 89, 185, -1, 306, 89, 185, 44, 185, + -1, 221, 135, 193, 348, 89, 185, -1, 221, 136, + 52, 89, 185, -1, 221, 136, 56, 89, 185, -1, + 221, 87, 52, 89, 185, -1, 221, 87, 56, 89, + 185, -1, 88, 56, 89, 185, -1, 307, 89, 185, + -1, 185, 81, 185, -1, 185, 82, 185, -1, 185, + 124, 185, -1, 185, 125, 185, -1, 185, 126, 185, + -1, 185, 127, 185, -1, 185, 128, 185, -1, 185, + 70, 185, -1, 129, 302, 70, 185, -1, 68, 185, + -1, 69, 185, -1, 185, 121, 185, -1, 185, 122, + 185, -1, 185, 123, 185, -1, 185, 71, 185, -1, + 185, 119, 185, -1, 185, 75, 185, -1, 185, 120, + 185, -1, 185, 76, 185, -1, 185, 72, 185, -1, + 185, 73, 185, -1, 185, 74, 185, -1, 185, 79, + 185, -1, 185, 80, 185, -1, 130, 185, -1, 131, + 185, -1, 185, 85, 185, -1, 185, 86, 185, -1, + 185, 77, 185, -1, 185, 78, 185, -1, -1, 46, + 346, 186, 185, -1, -1, -1, 185, 117, 187, 185, + 346, 118, 188, 185, -1, 202, -1, 185, -1, 352, + -1, 199, 349, -1, 199, 137, 339, 349, -1, 339, + 349, -1, 139, 193, 347, -1, 352, -1, 191, -1, + 352, -1, 194, -1, 199, 137, -1, 199, 137, 339, + 137, -1, 339, 137, -1, 167, -1, 199, 198, -1, + 339, 198, -1, 199, 137, 339, 198, -1, 197, -1, + -1, 196, 194, -1, 99, 189, -1, 137, 197, -1, + 352, -1, 189, -1, 97, 189, -1, 199, 137, 189, + -1, 199, 137, 97, 189, -1, 201, -1, 189, -1, + 199, 137, 189, -1, 199, 137, 97, 189, -1, 97, + 189, -1, 273, -1, 274, -1, 277, -1, 278, -1, + 279, -1, 284, -1, 282, -1, 285, -1, 305, -1, + 307, -1, 53, -1, -1, 222, 203, 152, 232, -1, + -1, 92, 204, 347, -1, -1, -1, 92, 205, 160, + 206, 347, -1, 91, 153, 140, -1, 221, 87, 56, + -1, 88, 56, -1, 94, 190, 141, -1, 95, 338, + 134, -1, 30, -1, 31, 139, 194, 347, -1, 31, + 139, 347, -1, 31, -1, -1, 46, 346, 139, 207, + 160, 347, -1, 39, 139, 160, 347, -1, 39, 139, + 347, -1, 166, 264, -1, 259, -1, 259, 264, -1, + 100, 249, -1, 223, 161, 233, 153, 235, 232, -1, + 224, 161, 233, 153, 236, 232, -1, -1, -1, 225, + 208, 161, 234, 209, 153, 232, -1, -1, -1, 226, + 210, 161, 234, 211, 153, 232, -1, 227, 161, 345, + 267, 232, -1, 227, 345, 267, 232, -1, -1, -1, + 228, 237, 25, 212, 161, 234, 213, 153, 232, -1, + -1, 229, 177, 308, 214, 152, 232, -1, -1, -1, + 229, 85, 160, 215, 350, 216, 152, 232, -1, -1, + 230, 177, 217, 152, 232, -1, -1, 231, 178, 218, + 310, 152, 232, -1, -1, -1, 231, 336, 344, 219, + 178, 220, 310, 152, 232, -1, 21, -1, 22, -1, + 23, -1, 24, -1, 202, -1, 7, -1, 11, -1, + 12, -1, 18, -1, 19, -1, 16, -1, 20, -1, + 3, -1, 4, -1, 5, -1, 10, -1, 350, -1, + 13, -1, 350, 13, -1, 350, -1, 27, -1, 236, + -1, 14, 161, 233, 153, 235, -1, 352, -1, 15, + 153, -1, 175, -1, 168, -1, 316, -1, 91, 240, + 347, -1, 238, -1, 239, 137, 238, -1, 239, -1, + 239, 137, 97, 316, -1, 239, 137, 97, 316, 137, + 239, -1, 239, 137, 97, -1, 239, 137, 97, 137, + 239, -1, 97, 316, -1, 97, 316, 137, 239, -1, + 97, -1, 97, 137, 239, -1, 323, 137, 326, 335, + -1, 323, 335, -1, 326, 335, -1, 334, -1, 137, + 241, -1, -1, 319, 137, 329, 137, 332, 242, -1, + 319, 137, 329, 137, 332, 137, 319, 242, -1, 319, + 137, 329, 242, -1, 319, 137, 329, 137, 319, 242, + -1, 319, 137, 332, 242, -1, 319, 137, -1, 319, + 137, 332, 137, 319, 242, -1, 319, 242, -1, 329, + 137, 332, 242, -1, 329, 137, 332, 137, 319, 242, + -1, 329, 242, -1, 329, 137, 319, 242, -1, 332, + 242, -1, 332, 137, 319, 242, -1, 241, -1, 352, + -1, 245, -1, 121, 246, 121, -1, 78, -1, 121, + 243, 246, 121, -1, 346, -1, 346, 142, 247, 346, + -1, 248, -1, 247, 137, 248, -1, 52, -1, 315, + -1, -1, -1, -1, -1, 250, 251, 254, 252, 253, + 255, -1, 139, 314, 246, 140, -1, 314, -1, 113, + 153, 134, -1, 29, 153, 10, -1, -1, 28, 257, + 244, 153, 10, -1, 167, 256, -1, 258, 344, 342, + 192, -1, 258, 344, 342, 192, 264, -1, 258, 344, + 342, 195, 256, -1, 166, 191, -1, -1, 221, 136, + 342, 260, 192, -1, -1, 221, 87, 342, 261, 191, + -1, 221, 87, 343, -1, -1, 221, 136, 262, 191, + -1, -1, 221, 87, 263, 191, -1, 32, 191, -1, + 32, -1, 221, 135, 193, 348, -1, -1, 133, 265, + 244, 153, 134, -1, -1, 26, 266, 244, 153, 10, + -1, 17, 199, 233, 153, 268, -1, 236, -1, 267, + -1, 8, 270, 271, 233, 153, 269, -1, 352, -1, + 189, -1, 201, -1, 352, -1, 90, 175, -1, 352, + -1, 9, 153, -1, 352, -1, 301, -1, 298, -1, + 300, -1, 275, -1, 64, -1, 276, -1, 275, 276, + -1, 102, 288, 112, -1, 103, 289, 112, -1, 104, + 290, 67, -1, 105, 143, 112, -1, 105, 280, 112, + -1, -1, 280, 281, 143, -1, 291, -1, 281, 291, + -1, 107, 143, 112, -1, 107, 283, 112, -1, -1, + 283, 281, 143, -1, 106, 143, 112, -1, 106, 286, + 112, -1, 108, 143, 112, -1, 108, 287, 112, -1, + -1, 286, 63, 143, -1, -1, 287, 63, 143, -1, + -1, 288, 291, -1, -1, 289, 291, -1, -1, 290, + 291, -1, 63, -1, -1, 111, 292, 297, -1, -1, + -1, -1, -1, 109, 293, 294, 295, 296, 153, 110, + -1, 54, -1, 55, -1, 57, -1, 307, -1, 101, + 299, -1, 178, -1, 55, -1, 54, -1, 57, -1, + 101, 289, 112, -1, 302, -1, 129, 302, -1, 59, + -1, 60, -1, 61, -1, 62, -1, 52, -1, 55, + -1, 54, -1, 56, -1, 57, -1, 34, -1, 33, + -1, 35, -1, 36, -1, 50, -1, 49, -1, 51, + -1, 303, -1, 304, -1, 303, -1, 304, -1, 65, + -1, 66, -1, 350, -1, -1, 120, 309, 161, 350, + -1, 1, 350, -1, 139, 314, 347, -1, -1, 311, + 314, 350, -1, 324, 137, 326, 335, -1, 324, 335, + -1, 326, 335, -1, 334, -1, 137, 312, -1, -1, + 319, 137, 330, 137, 332, 313, -1, 319, 137, 330, + 137, 332, 137, 319, 313, -1, 319, 137, 330, 313, + -1, 319, 137, 330, 137, 319, 313, -1, 319, 137, + 332, 313, -1, 319, 137, 332, 137, 319, 313, -1, + 319, 313, -1, 330, 137, 332, 313, -1, 330, 137, + 332, 137, 319, 313, -1, 330, 313, -1, 330, 137, + 319, 313, -1, 332, 313, -1, 332, 137, 319, 313, + -1, 312, -1, -1, 56, -1, 55, -1, 54, -1, + 57, -1, 315, -1, 52, -1, 316, -1, 317, -1, + 91, 240, 347, -1, 318, -1, 319, 137, 318, -1, + 58, -1, 320, 189, -1, 320, -1, 320, 221, -1, + 320, -1, 322, -1, 323, 137, 322, -1, 321, -1, + 324, 137, 321, -1, 70, -1, 98, -1, 325, 52, + -1, 325, -1, 317, 116, 189, -1, 317, 116, 221, + -1, 328, -1, 329, 137, 328, -1, 327, -1, 330, + 137, 327, -1, 126, -1, 97, -1, 331, 52, -1, + 331, -1, 123, -1, 99, -1, 333, 52, -1, 137, + 334, -1, 352, -1, 305, -1, -1, 139, 337, 160, + 347, -1, 352, -1, 339, 349, -1, 340, -1, 339, + 137, 340, -1, 189, 90, 189, -1, 58, 189, -1, + 102, 288, 114, 189, -1, 98, 189, -1, 52, -1, + 56, -1, 53, -1, 52, -1, 56, -1, 53, -1, + 183, -1, 52, -1, 53, -1, 183, -1, 136, -1, + 87, -1, -1, 351, -1, -1, 144, -1, 346, 140, + -1, 346, 141, -1, -1, 144, -1, 137, -1, 142, + -1, 144, -1, 350, -1, 351, 142, -1, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const yytype_uint16 yyrline[] = +{ + 0, 901, 901, 901, 932, 943, 952, 960, 968, 974, + 976, 975, 996, 1029, 1040, 1049, 1057, 1065, 1071, 1076, + 1075, 1096, 1096, 1104, 1112, 1123, 1134, 1142, 1151, 1160, + 1173, 1186, 1195, 1207, 1208, 1218, 1223, 1244, 1249, 1254, + 1264, 1269, 1280, 1289, 1298, 1301, 1310, 1322, 1323, 1331, + 1339, 1347, 1355, 1358, 1370, 1371, 1374, 1375, 1387, 1386, + 1408, 1418, 1427, 1440, 1449, 1461, 1470, 1482, 1491, 1500, + 1508, 1516, 1526, 1527, 1537, 1538, 1548, 1556, 1564, 1572, + 1581, 1589, 1598, 1606, 1615, 1623, 1634, 1635, 1645, 1653, + 1663, 1671, 1681, 1685, 1689, 1697, 1705, 1713, 1721, 1735, + 1749, 1762, 1771, 1780, 1788, 1796, 1804, 1812, 1826, 1840, + 1852, 1861, 1864, 1872, 1880, 1890, 1891, 1892, 1893, 1898, + 1909, 1910, 1913, 1921, 1924, 1932, 1932, 1942, 1943, 1944, + 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, 1954, + 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, + 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1974, 1974, 1974, + 1975, 1975, 1976, 1976, 1976, 1977, 1977, 1977, 1977, 1978, + 1978, 1978, 1978, 1979, 1979, 1979, 1980, 1980, 1980, 1980, + 1981, 1981, 1981, 1981, 1982, 1982, 1982, 1982, 1983, 1983, + 1983, 1983, 1984, 1984, 1984, 1984, 1985, 1985, 1988, 1997, + 2007, 2012, 2022, 2048, 2053, 2058, 2063, 2073, 2083, 2095, + 2109, 2123, 2131, 2139, 2147, 2155, 2163, 2171, 2180, 2188, + 2196, 2204, 2212, 2220, 2228, 2236, 2244, 2252, 2260, 2268, + 2276, 2284, 2295, 2303, 2311, 2319, 2327, 2335, 2343, 2351, + 2351, 2361, 2367, 2360, 2380, 2386, 2398, 2399, 2403, 2411, + 2421, 2431, 2432, 2435, 2436, 2437, 2441, 2449, 2459, 2468, + 2476, 2486, 2495, 2504, 2504, 2516, 2526, 2530, 2536, 2544, + 2552, 2566, 2582, 2583, 2586, 2600, 2615, 2625, 2626, 2627, + 2628, 2629, 2630, 2631, 2632, 2633, 2634, 2635, 2644, 2643, + 2671, 2671, 2680, 2684, 2679, 2693, 2701, 2709, 2717, 2730, + 2738, 2746, 2754, 2762, 2770, 2770, 2779, 2787, 2795, 2805, + 2806, 2816, 2820, 2832, 2844, 2844, 2844, 2855, 2855, 2855, + 2866, 2877, 2886, 2888, 2885, 2952, 2951, 2973, 2978, 2972, + 2997, 2996, 3018, 3017, 3040, 3041, 3040, 3064, 3072, 3080, + 3088, 3098, 3110, 3116, 3122, 3128, 3134, 3140, 3146, 3152, + 3158, 3164, 3174, 3180, 3185, 3186, 3193, 3198, 3201, 3202, + 3215, 3216, 3226, 3227, 3230, 3238, 3248, 3256, 3266, 3274, + 3283, 3292, 3300, 3308, 3317, 3329, 3337, 3348, 3352, 3356, + 3360, 3366, 3371, 3376, 3380, 3384, 3388, 3392, 3396, 3404, + 3408, 3412, 3416, 3420, 3424, 3428, 3432, 3436, 3442, 3443, + 3449, 3459, 3468, 3480, 3484, 3494, 3501, 3510, 3518, 3524, + 3527, 3532, 3535, 3524, 3554, 3562, 3568, 3572, 3579, 3578, + 3599, 3615, 3624, 3636, 3650, 3660, 3659, 3676, 3675, 3691, + 3700, 3699, 3717, 3716, 3733, 3741, 3749, 3764, 3763, 3783, + 3782, 3803, 3815, 3816, 3819, 3838, 3841, 3849, 3857, 3860, + 3864, 3867, 3875, 3878, 3879, 3887, 3890, 3907, 3908, 3909, + 3919, 3929, 3956, 4034, 4043, 4054, 4061, 4071, 4079, 4089, + 4098, 4109, 4116, 4134, 4143, 4153, 4162, 4173, 4180, 4191, + 4198, 4213, 4220, 4231, 4238, 4249, 4256, 4297, 4299, 4298, + 4314, 4320, 4324, 4328, 4313, 4348, 4356, 4364, 4372, 4375, + 4386, 4387, 4388, 4389, 4392, 4403, 4404, 4415, 4416, 4417, + 4418, 4421, 4422, 4423, 4424, 4425, 4428, 4429, 4430, 4431, + 4432, 4433, 4434, 4437, 4450, 4460, 4468, 4478, 4479, 4482, + 4491, 4490, 4499, 4511, 4521, 4521, 4534, 4538, 4542, 4546, + 4552, 4557, 4562, 4566, 4570, 4574, 4578, 4582, 4586, 4590, + 4594, 4598, 4602, 4606, 4610, 4614, 4619, 4625, 4635, 4645, + 4655, 4667, 4668, 4675, 4684, 4693, 4712, 4719, 4733, 4742, + 4752, 4764, 4773, 4784, 4792, 4809, 4817, 4833, 4834, 4837, + 4842, 4849, 4861, 4873, 4881, 4897, 4905, 4921, 4922, 4925, + 4938, 4949, 4950, 4953, 4970, 4974, 4984, 4994, 4994, 5023, + 5024, 5034, 5041, 5065, 5077, 5085, 5093, 5107, 5108, 5109, + 5112, 5113, 5114, 5115, 5118, 5119, 5120, 5123, 5128, 5135, + 5136, 5139, 5140, 5143, 5146, 5149, 5150, 5151, 5154, 5155, + 5158, 5159, 5163 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "\"end-of-input\"", "error", "$undefined", "keyword_class", + "keyword_module", "keyword_def", "keyword_undef", "keyword_begin", + "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if", + "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else", + "keyword_case", "keyword_when", "keyword_while", "keyword_until", + "keyword_for", "keyword_break", "keyword_next", "keyword_redo", + "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond", + "keyword_do_block", "keyword_do_LAMBDA", "keyword_return", + "keyword_yield", "keyword_super", "keyword_self", "keyword_nil", + "keyword_true", "keyword_false", "keyword_and", "keyword_or", + "keyword_not", "modifier_if", "modifier_unless", "modifier_while", + "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined", + "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__", + "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR", + "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tRATIONAL", + "tIMAGINARY", "tSTRING_CONTENT", "tCHAR", "tNTH_REF", "tBACK_REF", + "tREGEXP_END", "\"unary+\"", "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"", + "\"===\"", "\"!=\"", "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"", + "\"!~\"", "\"..\"", "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"", + "\"::\"", "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"", + "\"( arg\"", "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"", + "\"**arg\"", "\"&\"", "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", + "tREGEXP_BEG", "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG", + "tQSYMBOLS_BEG", "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR", + "tSTRING_END", "tLAMBEG", "tLABEL_END", "tLOWEST", "'='", "'?'", "':'", + "'>'", "'<'", "'|'", "'^'", "'&'", "'+'", "'-'", "'*'", "'/'", "'%'", + "tUMINUS_NUM", "'!'", "'~'", "tLAST_TOKEN", "'{'", "'}'", "'['", "'.'", + "','", "'`'", "'('", "')'", "']'", "';'", "' '", "'\\n'", "$accept", + "program", "$@1", "top_compstmt", "top_stmts", "top_stmt", "$@2", + "bodystmt", "compstmt", "stmts", "stmt_or_begin", "$@3", "stmt", "$@4", + "command_asgn", "expr", "expr_value", "command_call", "block_command", + "cmd_brace_block", "@5", "fcall", "command", "mlhs", "mlhs_inner", + "mlhs_basic", "mlhs_item", "mlhs_head", "mlhs_post", "mlhs_node", "lhs", + "cname", "cpath", "fname", "fsym", "fitem", "undef_list", "$@6", "op", + "reswords", "arg", "$@7", "@8", "$@9", "arg_value", "aref_args", + "paren_args", "opt_paren_args", "opt_call_args", "call_args", + "command_args", "@10", "block_arg", "opt_block_arg", "args", "mrhs_arg", + "mrhs", "primary", "@11", "$@12", "$@13", "$@14", "$@15", "$@16", "$@17", + "$@18", "$@19", "$@20", "$@21", "@22", "@23", "@24", "@25", "@26", + "$@27", "@28", "primary_value", "k_begin", "k_if", "k_unless", "k_while", + "k_until", "k_case", "k_for", "k_class", "k_module", "k_def", "k_end", + "then", "do", "if_tail", "opt_else", "for_var", "f_marg", "f_marg_list", + "f_margs", "block_args_tail", "opt_block_args_tail", "block_param", + "opt_block_param", "block_param_def", "opt_bv_decl", "bv_decls", "bvar", + "lambda", "@29", "@30", "@31", "@32", "f_larglist", "lambda_body", + "do_block", "@33", "block_call", "method_call", "@34", "@35", "@36", + "@37", "brace_block", "@38", "@39", "case_body", "cases", "opt_rescue", + "exc_list", "exc_var", "opt_ensure", "literal", "strings", "string", + "string1", "xstring", "regexp", "words", "word_list", "word", "symbols", + "symbol_list", "qwords", "qsymbols", "qword_list", "qsym_list", + "string_contents", "xstring_contents", "regexp_contents", + "string_content", "@40", "@41", "@42", "@43", "@44", "string_dvar", + "symbol", "sym", "dsym", "numeric", "simple_numeric", "user_variable", + "keyword_variable", "var_ref", "var_lhs", "backref", "superclass", + "$@45", "f_arglist", "@46", "args_tail", "opt_args_tail", "f_args", + "f_bad_arg", "f_norm_arg", "f_arg_asgn", "f_arg_item", "f_arg", + "f_label", "f_kw", "f_block_kw", "f_block_kwarg", "f_kwarg", + "kwrest_mark", "f_kwrest", "f_opt", "f_block_opt", "f_block_optarg", + "f_optarg", "restarg_mark", "f_rest_arg", "blkarg_mark", "f_block_arg", + "opt_f_block_arg", "singleton", "$@47", "assoc_list", "assocs", "assoc", + "operation", "operation2", "operation3", "dot_or_colon", "opt_terms", + "opt_nl", "rparen", "rbracket", "trailer", "term", "terms", "none", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const yytype_uint16 yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 130, 131, + 132, 134, 139, 140, 141, 138, 137, 148, 149, 142, + 143, 128, 129, 144, 145, 135, 136, 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, 351, 61, 63, 58, 62, + 60, 124, 94, 38, 43, 45, 42, 47, 37, 352, + 33, 126, 353, 123, 125, 91, 46, 44, 96, 40, + 41, 93, 59, 32, 10 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint16 yyr1[] = +{ + 0, 145, 147, 146, 148, 149, 149, 149, 149, 150, + 151, 150, 152, 153, 154, 154, 154, 154, 155, 156, + 155, 158, 157, 157, 157, 157, 157, 157, 157, 157, + 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, + 157, 157, 157, 157, 157, 159, 159, 160, 160, 160, + 160, 160, 160, 161, 162, 162, 163, 163, 165, 164, + 166, 167, 167, 167, 167, 167, 167, 167, 167, 167, + 167, 167, 168, 168, 169, 169, 170, 170, 170, 170, + 170, 170, 170, 170, 170, 170, 171, 171, 172, 172, + 173, 173, 174, 174, 174, 174, 174, 174, 174, 174, + 174, 175, 175, 175, 175, 175, 175, 175, 175, 175, + 176, 176, 177, 177, 177, 178, 178, 178, 178, 178, + 179, 179, 180, 180, 181, 182, 181, 183, 183, 183, + 183, 183, 183, 183, 183, 183, 183, 183, 183, 183, + 183, 183, 183, 183, 183, 183, 183, 183, 183, 183, + 183, 183, 183, 183, 183, 183, 183, 184, 184, 184, + 184, 184, 184, 184, 184, 184, 184, 184, 184, 184, + 184, 184, 184, 184, 184, 184, 184, 184, 184, 184, + 184, 184, 184, 184, 184, 184, 184, 184, 184, 184, + 184, 184, 184, 184, 184, 184, 184, 184, 185, 185, + 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, + 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, + 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, + 185, 185, 185, 185, 185, 185, 185, 185, 185, 186, + 185, 187, 188, 185, 185, 189, 190, 190, 190, 190, + 191, 192, 192, 193, 193, 193, 193, 193, 194, 194, + 194, 194, 194, 196, 195, 197, 198, 198, 199, 199, + 199, 199, 200, 200, 201, 201, 201, 202, 202, 202, + 202, 202, 202, 202, 202, 202, 202, 202, 203, 202, + 204, 202, 205, 206, 202, 202, 202, 202, 202, 202, + 202, 202, 202, 202, 207, 202, 202, 202, 202, 202, + 202, 202, 202, 202, 208, 209, 202, 210, 211, 202, + 202, 202, 212, 213, 202, 214, 202, 215, 216, 202, + 217, 202, 218, 202, 219, 220, 202, 202, 202, 202, + 202, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 233, 233, 234, 234, 235, 235, + 236, 236, 237, 237, 238, 238, 239, 239, 240, 240, + 240, 240, 240, 240, 240, 240, 240, 241, 241, 241, + 241, 242, 242, 243, 243, 243, 243, 243, 243, 243, + 243, 243, 243, 243, 243, 243, 243, 243, 244, 244, + 245, 245, 245, 246, 246, 247, 247, 248, 248, 250, + 251, 252, 253, 249, 254, 254, 255, 255, 257, 256, + 258, 258, 258, 258, 259, 260, 259, 261, 259, 259, + 262, 259, 263, 259, 259, 259, 259, 265, 264, 266, + 264, 267, 268, 268, 269, 269, 270, 270, 270, 271, + 271, 272, 272, 273, 273, 273, 274, 275, 275, 275, + 276, 277, 278, 279, 279, 280, 280, 281, 281, 282, + 282, 283, 283, 284, 284, 285, 285, 286, 286, 287, + 287, 288, 288, 289, 289, 290, 290, 291, 292, 291, + 293, 294, 295, 296, 291, 297, 297, 297, 297, 298, + 299, 299, 299, 299, 300, 301, 301, 302, 302, 302, + 302, 303, 303, 303, 303, 303, 304, 304, 304, 304, + 304, 304, 304, 305, 305, 306, 306, 307, 307, 308, + 309, 308, 308, 310, 311, 310, 312, 312, 312, 312, + 313, 313, 314, 314, 314, 314, 314, 314, 314, 314, + 314, 314, 314, 314, 314, 314, 314, 315, 315, 315, + 315, 316, 316, 317, 318, 318, 319, 319, 320, 321, + 321, 322, 322, 323, 323, 324, 324, 325, 325, 326, + 326, 327, 328, 329, 329, 330, 330, 331, 331, 332, + 332, 333, 333, 334, 335, 335, 336, 337, 336, 338, + 338, 339, 339, 340, 340, 340, 340, 341, 341, 341, + 342, 342, 342, 342, 343, 343, 343, 344, 344, 345, + 345, 346, 346, 347, 348, 349, 349, 349, 350, 350, + 351, 351, 352 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = +{ + 0, 2, 0, 2, 2, 1, 1, 3, 2, 1, + 0, 5, 4, 2, 1, 1, 3, 2, 1, 0, + 5, 0, 4, 3, 3, 3, 2, 3, 3, 3, + 3, 3, 4, 1, 3, 3, 6, 5, 5, 5, + 5, 3, 3, 3, 1, 3, 3, 1, 3, 3, + 3, 2, 1, 1, 1, 1, 1, 4, 0, 5, + 1, 2, 3, 4, 5, 4, 5, 2, 2, 2, + 2, 2, 1, 3, 1, 3, 1, 2, 3, 5, + 2, 4, 2, 4, 1, 3, 1, 3, 2, 3, + 1, 3, 1, 1, 4, 3, 3, 3, 3, 2, + 1, 1, 1, 4, 3, 3, 3, 3, 2, 1, + 1, 1, 2, 1, 3, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 0, 4, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 3, 5, + 3, 5, 6, 5, 5, 5, 5, 4, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 4, 2, 2, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 2, 2, 3, 3, 3, 3, 0, + 4, 0, 0, 8, 1, 1, 1, 2, 4, 2, + 3, 1, 1, 1, 1, 2, 4, 2, 1, 2, + 2, 4, 1, 0, 2, 2, 2, 1, 1, 2, + 3, 4, 1, 1, 3, 4, 2, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 0, 4, + 0, 3, 0, 0, 5, 3, 3, 2, 3, 3, + 1, 4, 3, 1, 0, 6, 4, 3, 2, 1, + 2, 2, 6, 6, 0, 0, 7, 0, 0, 7, + 5, 4, 0, 0, 9, 0, 6, 0, 0, 8, + 0, 5, 0, 6, 0, 0, 9, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 2, 1, 1, 1, 5, + 1, 2, 1, 1, 1, 3, 1, 3, 1, 4, + 6, 3, 5, 2, 4, 1, 3, 4, 2, 2, + 1, 2, 0, 6, 8, 4, 6, 4, 2, 6, + 2, 4, 6, 2, 4, 2, 4, 1, 1, 1, + 3, 1, 4, 1, 4, 1, 3, 1, 1, 0, + 0, 0, 0, 6, 4, 1, 3, 3, 0, 5, + 2, 4, 5, 5, 2, 0, 5, 0, 5, 3, + 0, 4, 0, 4, 2, 1, 4, 0, 5, 0, + 5, 5, 1, 1, 6, 1, 1, 1, 1, 2, + 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, + 3, 3, 3, 3, 3, 0, 3, 1, 2, 3, + 3, 0, 3, 3, 3, 3, 3, 0, 3, 0, + 3, 0, 2, 0, 2, 0, 2, 1, 0, 3, + 0, 0, 0, 0, 7, 1, 1, 1, 1, 2, + 1, 1, 1, 1, 3, 1, 2, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 4, 2, 3, 0, 3, 4, 2, 2, 1, + 2, 0, 6, 8, 4, 6, 4, 6, 2, 4, + 6, 2, 4, 2, 4, 1, 0, 1, 1, 1, + 1, 1, 1, 1, 1, 3, 1, 3, 1, 2, + 1, 2, 1, 1, 3, 1, 3, 1, 1, 2, + 1, 3, 3, 1, 3, 1, 3, 1, 1, 2, + 1, 1, 1, 2, 2, 1, 1, 0, 4, 1, + 2, 1, 3, 3, 2, 4, 2, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 0, 1, 2, 2, 0, 1, 1, 1, 1, + 1, 2, 0 +}; + +/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const yytype_uint16 yydefact[] = +{ + 2, 0, 0, 1, 0, 349, 350, 351, 0, 342, + 343, 344, 347, 345, 346, 348, 337, 338, 339, 340, + 300, 263, 263, 517, 516, 518, 519, 621, 0, 621, + 10, 0, 521, 520, 522, 607, 609, 513, 512, 608, + 515, 507, 508, 509, 510, 457, 527, 528, 0, 0, + 0, 0, 292, 632, 632, 84, 409, 483, 481, 483, + 485, 465, 477, 471, 479, 0, 0, 0, 3, 619, + 6, 9, 33, 44, 47, 55, 263, 54, 0, 72, + 0, 76, 86, 0, 52, 244, 0, 288, 0, 0, + 314, 317, 619, 0, 0, 0, 0, 56, 309, 277, + 278, 456, 458, 279, 280, 281, 283, 282, 284, 454, + 455, 453, 505, 523, 524, 285, 0, 286, 60, 5, + 8, 167, 178, 168, 191, 164, 184, 174, 173, 194, + 195, 189, 172, 171, 166, 192, 196, 197, 176, 165, + 179, 183, 185, 177, 170, 186, 193, 188, 187, 180, + 190, 175, 163, 182, 181, 162, 169, 160, 161, 157, + 158, 159, 115, 117, 116, 152, 153, 148, 130, 131, + 132, 139, 136, 138, 133, 134, 154, 155, 140, 141, + 145, 149, 135, 137, 127, 128, 129, 142, 143, 144, + 146, 147, 150, 151, 156, 120, 122, 124, 26, 118, + 119, 121, 123, 0, 0, 0, 0, 0, 0, 0, + 481, 0, 258, 0, 245, 268, 70, 262, 632, 0, + 523, 524, 0, 286, 632, 601, 71, 69, 621, 68, + 0, 632, 434, 67, 621, 622, 0, 0, 21, 239, + 0, 0, 337, 338, 300, 303, 435, 0, 218, 0, + 219, 297, 0, 19, 0, 0, 619, 15, 18, 621, + 74, 14, 621, 0, 0, 625, 625, 246, 0, 0, + 625, 599, 621, 0, 0, 0, 82, 341, 0, 92, + 93, 100, 311, 410, 502, 501, 503, 500, 0, 499, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 506, 51, 233, 234, 628, 629, 4, 630, 620, + 0, 0, 0, 0, 0, 0, 0, 439, 437, 424, + 61, 308, 418, 420, 0, 88, 0, 80, 77, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 241, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 432, 632, 430, 0, + 53, 0, 0, 0, 0, 619, 0, 620, 0, 363, + 362, 0, 0, 523, 524, 286, 110, 111, 0, 0, + 113, 0, 0, 523, 524, 286, 330, 187, 180, 190, + 175, 157, 158, 159, 115, 116, 597, 332, 596, 0, + 618, 617, 0, 310, 459, 0, 0, 125, 604, 297, + 269, 606, 265, 0, 0, 0, 0, 259, 267, 432, + 632, 430, 0, 0, 0, 260, 621, 0, 302, 264, + 621, 254, 632, 632, 253, 621, 307, 50, 23, 25, + 24, 0, 304, 0, 0, 0, 432, 430, 0, 17, + 0, 621, 295, 13, 620, 73, 291, 293, 298, 627, + 626, 247, 627, 249, 299, 600, 0, 99, 506, 90, + 85, 0, 432, 632, 430, 556, 487, 490, 488, 504, + 484, 460, 482, 461, 462, 486, 463, 464, 0, 467, + 473, 0, 474, 469, 470, 0, 475, 0, 476, 0, + 631, 7, 27, 28, 29, 30, 31, 48, 49, 632, + 632, 58, 62, 632, 0, 34, 273, 0, 43, 272, + 621, 0, 78, 89, 46, 45, 0, 198, 268, 42, + 216, 223, 228, 229, 230, 225, 227, 237, 238, 231, + 232, 209, 210, 235, 236, 0, 224, 226, 220, 221, + 222, 211, 212, 213, 214, 215, 610, 612, 611, 613, + 0, 263, 429, 621, 610, 612, 611, 613, 0, 263, + 0, 632, 354, 0, 353, 0, 0, 0, 0, 0, + 0, 297, 432, 632, 430, 322, 327, 110, 111, 112, + 0, 530, 325, 529, 432, 632, 430, 0, 0, 534, + 334, 610, 611, 263, 35, 200, 41, 208, 0, 0, + 198, 603, 0, 270, 266, 632, 610, 611, 621, 610, + 611, 602, 301, 623, 250, 255, 257, 306, 22, 0, + 240, 0, 32, 427, 425, 207, 0, 75, 16, 621, + 625, 0, 83, 96, 98, 621, 610, 611, 562, 559, + 558, 557, 560, 568, 577, 0, 588, 578, 592, 591, + 587, 556, 411, 555, 415, 561, 563, 564, 566, 541, + 570, 575, 632, 580, 632, 585, 541, 590, 541, 0, + 539, 491, 0, 466, 468, 478, 472, 480, 217, 401, + 621, 0, 399, 398, 0, 632, 0, 276, 0, 87, + 81, 0, 0, 0, 621, 0, 0, 433, 65, 0, + 0, 436, 0, 0, 431, 63, 632, 352, 289, 632, + 632, 445, 632, 355, 632, 357, 315, 356, 318, 0, + 0, 321, 614, 296, 621, 610, 611, 0, 0, 532, + 0, 0, 110, 111, 114, 621, 0, 621, 556, 0, + 556, 0, 252, 421, 57, 251, 0, 126, 605, 271, + 261, 0, 0, 436, 0, 0, 632, 621, 11, 0, + 294, 248, 91, 94, 0, 375, 366, 368, 621, 364, + 621, 412, 0, 0, 548, 569, 0, 537, 595, 579, + 0, 538, 0, 551, 589, 0, 553, 593, 492, 495, + 496, 497, 489, 498, 397, 621, 0, 564, 382, 572, + 573, 632, 632, 583, 382, 382, 380, 403, 0, 0, + 0, 0, 0, 274, 79, 199, 0, 40, 205, 39, + 206, 66, 428, 624, 0, 37, 203, 38, 204, 64, + 426, 446, 447, 632, 448, 0, 632, 360, 0, 0, + 358, 0, 0, 0, 320, 0, 0, 436, 0, 328, + 0, 0, 436, 331, 598, 621, 0, 0, 335, 422, + 423, 201, 0, 256, 305, 20, 621, 0, 373, 0, + 565, 0, 0, 581, 540, 567, 541, 541, 576, 632, + 594, 541, 586, 541, 564, 541, 493, 0, 400, 0, + 388, 390, 0, 571, 0, 378, 379, 0, 393, 0, + 395, 0, 440, 438, 0, 419, 275, 242, 36, 202, + 0, 0, 450, 361, 0, 12, 452, 0, 312, 313, + 0, 0, 270, 632, 323, 0, 531, 326, 533, 333, + 535, 534, 365, 376, 0, 371, 367, 414, 0, 0, + 413, 0, 544, 0, 546, 536, 0, 552, 0, 549, + 554, 0, 402, 582, 381, 382, 382, 297, 432, 574, + 632, 382, 584, 382, 382, 407, 621, 405, 408, 59, + 0, 0, 449, 0, 101, 102, 109, 0, 451, 0, + 316, 319, 442, 443, 441, 0, 0, 0, 0, 374, + 0, 369, 0, 0, 541, 541, 541, 541, 0, 0, + 385, 0, 387, 614, 296, 377, 0, 394, 0, 391, + 396, 0, 404, 243, 108, 432, 632, 430, 632, 632, + 0, 329, 0, 372, 0, 417, 416, 545, 0, 542, + 547, 550, 494, 382, 382, 382, 382, 406, 614, 107, + 621, 610, 611, 444, 359, 324, 336, 370, 541, 386, + 0, 383, 389, 392, 436, 543, 382, 384 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int16 yydefgoto[] = +{ + -1, 1, 2, 68, 69, 70, 240, 570, 571, 256, + 257, 450, 258, 441, 72, 73, 361, 74, 75, 512, + 695, 247, 77, 78, 259, 79, 80, 81, 470, 82, + 213, 380, 381, 195, 196, 197, 198, 608, 559, 200, + 84, 443, 545, 980, 215, 264, 232, 753, 430, 431, + 229, 230, 217, 417, 432, 518, 519, 85, 359, 262, + 263, 639, 629, 363, 852, 364, 853, 737, 995, 741, + 738, 935, 597, 599, 751, 941, 249, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 718, 573, 726, + 849, 850, 372, 776, 777, 778, 964, 901, 805, 691, + 692, 806, 976, 977, 282, 283, 475, 781, 882, 662, + 950, 323, 513, 97, 98, 716, 709, 568, 560, 321, + 510, 509, 580, 994, 720, 843, 921, 925, 99, 100, + 101, 102, 103, 104, 105, 294, 488, 106, 298, 107, + 108, 296, 300, 290, 288, 292, 480, 682, 681, 798, + 896, 961, 802, 109, 289, 110, 111, 112, 220, 221, + 115, 222, 223, 592, 740, 749, 750, 884, 784, 664, + 665, 666, 894, 668, 669, 670, 671, 810, 811, 672, + 673, 674, 675, 813, 814, 676, 677, 678, 679, 680, + 787, 399, 598, 269, 433, 225, 118, 633, 562, 402, + 307, 427, 428, 711, 461, 574, 367, 261 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -817 +static const yytype_int16 yypact[] = +{ + -817, 102, 2542, -817, 7282, -817, -817, -817, 6793, -817, + -817, -817, -817, -817, -817, -817, 7398, 7398, -817, -817, + 7398, 3893, 3479, -817, -817, -817, -817, 201, 6657, -27, + -817, 117, -817, -817, -817, 2789, 3617, -817, -817, 2927, + -817, -817, -817, -817, -817, -817, -817, -817, 8790, 8790, + 80, 4988, -36, 7746, 8094, 7058, -817, 6521, -817, -817, + -817, 21, 41, 63, 92, 813, 8906, 8790, -817, 362, + -817, 944, -817, 528, -817, -817, 174, 230, 148, -817, + 165, 9138, -817, 210, 2905, 276, 304, -817, 9022, 9022, + -817, -817, 5896, 9250, 9362, 9474, 6384, 3, 98, -817, + -817, 242, -817, -817, -817, -817, -817, -817, -817, -817, + -817, -817, -817, 483, 486, -817, 292, 498, -817, -817, + -817, -817, -817, -817, -817, -817, -817, -817, -817, -817, + -817, -817, -817, -817, -817, -817, -817, -817, -817, -817, + -817, -817, -817, -817, -817, -817, -817, -817, -817, -817, + -817, -817, -817, -817, -817, -817, -817, -817, -817, -817, + -817, -817, -817, -817, -817, -817, -817, -817, -817, -817, + -817, -817, -817, -817, -817, -817, -817, -817, -817, -817, + -817, -817, -817, -817, -817, -817, -817, -817, -817, -817, + -817, -817, -817, -817, -817, -817, -817, -817, 277, -817, + -817, -817, -817, 257, 8790, 361, 5130, 8790, 8790, 8790, + -817, 8790, -817, 311, 2905, 342, -817, -817, 329, 448, + 45, 220, 386, 245, 343, -817, -817, -817, 5780, -817, + 7398, 7398, -817, -817, 6012, -817, 9022, 624, -817, 346, + 370, 5272, -817, -817, -817, 379, 395, 174, -817, 456, + 455, 567, 7514, -817, 4988, 400, 362, -817, 944, -27, + 441, -817, -27, 9022, 429, 28, 312, -817, 342, 446, + 312, -817, -27, 523, 813, 9586, 458, -817, 472, 511, + 538, 565, -817, -817, -817, -817, -817, -817, 436, -817, + 515, 601, 731, 485, 619, 494, 35, 518, 671, 521, + 47, 570, -817, -817, -817, -817, -817, -817, -817, 6128, + 9022, 9022, 9022, 9022, 7514, 9022, 9022, -817, -817, -817, + 547, -817, -817, -817, 8210, -817, 4988, 7170, 524, 8210, + 8790, 8790, 8790, 8790, 8790, 8790, 8790, 8790, 8790, 8790, + 8790, 8790, 8790, 8790, 8790, -817, 8790, 8790, 8790, 8790, + 8790, 8790, 8790, 8790, 8790, 8790, 9872, 7398, 9952, 4330, + 528, 81, 81, 9022, 9022, 362, 648, 534, 610, -817, + -817, 600, 659, 58, 87, 95, 302, 381, 9022, 445, + -817, 69, 638, -817, -817, -817, -817, 31, 44, 55, + 149, 194, 259, 272, 300, 316, -817, -817, -817, 3, + -817, -817, 10032, -817, -817, 8906, 8906, -817, -817, 263, + -817, -817, -817, 548, 8790, 8790, 7630, -817, -817, 10112, + 7398, 10192, 8790, 8790, 7862, -817, -27, 546, -817, -817, + -27, -817, 582, 589, -817, 119, -817, -817, -817, -817, + -817, 6793, -817, 8790, 5406, 573, 10112, 10192, 8790, 944, + 607, -27, -817, -817, 6244, 604, -817, 528, -817, 7978, + -817, -817, 8094, -817, -817, -817, 346, 667, -817, -817, + 605, 9586, 10272, 7398, 10352, 1430, -817, -817, -817, -817, + -817, -817, -817, -817, -817, -817, -817, -817, 51, -817, + -817, 602, -817, -817, -817, 419, -817, 606, -817, 8790, + -817, -817, -817, -817, -817, -817, -817, -817, -817, 50, + 50, -817, -817, 50, 8790, -817, 611, 614, -817, -817, + -27, 9586, 616, -817, -817, -817, 628, 1893, -817, -817, + 455, 2287, 2287, 2287, 2287, 998, 998, 2361, 2097, 2287, + 2287, 3043, 3043, 491, 491, 8790, 998, 998, 847, 847, + 799, 428, 428, 455, 455, 455, 4031, 3065, 4169, 3203, + 395, 621, -817, -27, 586, -817, 711, -817, 395, 3755, + 753, 757, -817, 4472, 764, 4756, 170, 170, 648, 8326, + 753, 151, 10432, 7398, 10512, -817, 528, -817, 667, -817, + 362, -817, -817, -817, 10592, 7398, 10032, 4330, 9022, 627, + -817, -817, -817, 4188, -817, 2631, -817, 2905, 6793, 8790, + 2767, -817, 8790, 342, -817, 343, 2651, 3341, -27, 308, + 358, -817, -817, -817, -817, 7630, 7862, -817, -817, 9022, + 2905, 678, -817, -817, -817, 2905, 5406, 219, -817, -27, + 312, 9586, 605, 403, 46, -27, 349, 365, -817, -817, + -817, -817, -817, -817, -817, 1148, -817, -817, -817, -817, + -817, 1521, -817, -817, -817, -817, -817, 690, -817, 680, + 8790, -817, 694, 763, 699, -817, 700, 774, 706, 793, + -817, -817, 837, -817, -817, -817, -817, -817, 455, -817, + 1008, 5548, -817, -817, 5272, 50, 5548, 709, 8442, -817, + 605, 9586, 8906, 8790, 10861, 8906, 8906, -817, 547, 395, + 710, 733, 8906, 8906, -817, 547, 395, -817, -817, 8558, + 832, -817, 595, -817, 832, -817, -817, -817, -817, 753, + 73, -817, 64, 130, -27, 154, 161, 9022, 362, -817, + 9022, 4330, 403, 46, -817, -27, 753, 119, 1521, 4330, + 1521, 6929, -817, 98, 230, -817, 8790, -817, -817, -817, + -817, 8790, 8790, 371, 8790, 8790, 713, 119, -817, 718, + -817, -817, -817, 334, 1148, 321, -817, 717, -27, -817, + -27, -817, 8790, 1521, -817, -817, 414, -817, -817, -817, + 2, -817, 1521, -817, -817, 1668, -817, -817, -817, -817, + -817, -817, -817, -817, -817, -27, 735, 742, 722, 9698, + -817, 723, 699, -817, 729, 730, -817, 726, 867, 744, + 5272, 869, 8790, 746, 605, 2905, 770, -817, 2905, -817, + 2905, -817, -817, -817, 8906, -817, 2905, -817, 2905, -817, + -817, 611, -817, 803, -817, 4872, 888, -817, 9022, 753, + -817, 753, 5548, 5548, -817, 8674, 4614, 162, 170, -817, + 362, 753, -817, -817, -817, -27, 753, 362, -817, -817, + -817, 2905, 8790, 7862, -817, -817, -27, 902, 761, 1194, + -817, 765, 70, -817, -817, -817, 769, 773, -817, 699, + -817, 777, -817, 779, -817, 777, -817, 786, -817, 9698, + 1521, -817, 855, 672, 414, -817, -817, 1521, -817, 1668, + -817, 882, -817, -817, 784, -817, 783, -817, -817, 2905, + 9810, 81, -817, -817, 5548, -817, -817, 81, -817, -817, + 753, 753, -817, 559, -817, 4330, -817, -817, -817, -817, + -817, 627, -817, 791, 902, 467, -817, -817, 5548, 5272, + -817, 1521, -817, 1668, -817, -817, 1668, -817, 1668, -817, + -817, 5664, -817, 672, -817, 798, 804, -817, 10672, -817, + 699, 807, -817, 814, 807, -817, 313, -817, -817, -817, + 8790, 865, -817, 689, 511, 538, 565, 4330, -817, 4472, + -817, -817, -817, -817, -817, 5548, 753, 4330, 902, 791, + 902, 816, 920, 826, 777, 824, 777, 777, 852, 1521, + -817, 1668, -817, 827, 830, -817, 1668, -817, 1668, -817, + -817, 882, -817, 2905, 667, 10752, 7398, 10832, 757, 595, + 753, -817, 753, 791, 902, -817, -817, -817, 1668, -817, + -817, -817, -817, 807, 842, 807, 807, -817, 65, 46, + -27, 96, 110, -817, -817, -817, -817, 791, 777, -817, + 1668, -817, -817, -817, 133, -817, 807, -817 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int16 yypgoto[] = +{ + -817, -817, -817, -370, -817, 24, -817, -571, 502, -817, + 527, -817, 9, -817, -314, 38, -69, -64, -817, -602, + -817, 475, -10, 896, -149, -1, -73, -817, -418, 16, + 1355, -312, 895, -56, -817, -19, -817, -817, 4, -817, + 929, -817, -817, -817, 1617, -817, -72, 278, -338, 48, + -17, -817, -379, -206, 76, -817, -296, -38, -817, -817, + -817, -817, -817, -817, -817, -817, -817, -817, -817, -817, + -817, -817, -817, -817, -817, -817, 56, -817, -817, -817, + -817, -817, -817, -817, -817, -817, -817, -31, -331, -542, + -37, -640, -817, -800, -786, 223, 310, 49, -817, -425, + -817, -500, -817, -18, -817, -817, -817, -817, -817, -817, + -817, 248, -817, -817, -817, -817, -817, -817, -817, -95, + -817, -817, -549, -817, -22, -817, -817, -817, -817, -817, + -817, 906, -817, -817, -817, -817, 712, -817, -817, -817, + -817, -817, -817, 801, 949, -817, -102, -817, -817, -817, + -817, -817, -817, 13, -817, 14, -817, 22, 1140, 1346, + 913, 1544, 1456, -817, -817, 71, -817, -428, 143, -304, + -816, -606, -11, -737, -96, 396, 227, 114, -817, -817, + -817, 181, -723, -810, 121, 236, -817, -651, -817, 43, + -638, -817, -817, -817, 99, -400, -817, -281, -817, 626, + -48, -13, -196, -591, -236, -44, 12, -2 +}; + +/* 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 YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -633 +static const yytype_int16 yytable[] = +{ + 119, 287, 302, 403, 319, 233, 212, 212, 328, 238, + 212, 71, 199, 71, 236, 524, 239, 277, 425, 563, + 362, 201, 202, 365, 621, 308, 746, 763, 120, 729, + 463, 575, 199, 529, 465, 728, 791, 614, 436, 815, + 397, 201, 202, 277, 366, 614, 885, 663, 308, 779, + 260, 267, 271, 642, 773, 277, 277, 277, 86, 320, + 86, 199, 621, 455, 216, 226, 456, 589, 227, 892, + 590, 276, 219, 219, 631, 561, 219, 569, -105, 946, + 846, 309, 618, -101, 851, 694, 572, 301, 696, -105, + 400, 943, 218, 218, 572, 978, 218, 972, 491, 948, + 199, 658, 3, 700, -290, 451, 831, 86, -290, -104, + 497, 278, -102, 839, 476, 224, 224, 235, -517, 224, + -109, 603, 219, -106, 317, 659, 360, 360, 689, 265, + 360, -516, 887, -296, -525, 645, 251, 278, 561, 401, + 569, 893, -518, 857, 219, 219, -103, 492, 219, 371, + 382, 382, 266, 270, 862, -107, 315, 316, 999, 498, + 477, -101, 478, 885, 293, 459, 634, -517, 779, 878, + 861, 690, 460, 905, 906, 319, -108, 520, 866, -104, + -516, -296, -296, 949, 295, -611, -106, -103, 482, 591, + 485, -518, 489, 634, 683, -92, 489, 725, 946, 972, + 317, -96, 469, -610, -610, 978, 297, -105, 453, -105, + 855, 305, 308, 306, 1033, 305, 418, 306, 212, 885, + 212, 212, 418, 305, -93, 306, 621, 425, 892, 434, + 622, 318, -100, 663, 624, 299, -519, 277, -104, 627, + -104, 502, 503, 504, 505, 734, 614, 614, 1057, 966, + 241, 955, -106, 260, -106, 637, 973, 745, 322, 466, + 515, 449, 86, 235, 324, 525, 769, -98, 454, -611, + 820, 779, 435, 779, 437, -103, 426, -103, 429, 885, + 881, -521, 744, 824, 219, -519, 219, 219, -99, 277, + 219, -95, 219, 992, 576, 577, 468, 86, -97, -94, + 1005, 457, 325, 634, 218, 897, 218, 318, 86, -526, + 86, 482, 305, 231, 306, 634, 934, 578, 71, 219, + 663, 308, 663, 506, 699, 260, 329, 224, -607, 224, + -521, 278, 1015, 501, 423, -73, -102, 593, 779, 1001, + 234, 604, 606, 522, 58, 235, -520, 212, 360, 360, + 360, 360, 448, 507, 508, 434, -87, 780, 1044, -522, + -436, -109, 567, -341, 996, 86, 219, 219, 219, 219, + 86, 219, 219, 648, -95, 649, 650, 651, 652, -108, + 219, 405, 86, 278, 993, 219, 684, -511, 524, -511, + -97, 356, 779, 684, 779, -520, 234, 764, 469, 856, + 517, 360, 360, -514, 771, 517, 567, -608, -522, 760, + 212, -341, -341, 219, 407, 86, 586, 409, 434, 219, + 219, -436, 628, 842, -104, 567, 1032, 414, 779, -614, + 418, 418, 415, 277, 219, -607, -511, -511, -511, 357, + 358, -607, 119, 770, 865, 199, 867, 765, 469, 462, + 1021, 567, -514, 71, 201, 202, 460, 235, 877, 1064, + 872, 219, 219, 212, 667, -95, 416, -436, -514, -436, + -436, 434, 653, 621, -106, 422, 219, 76, 567, 76, + 424, -97, 476, 277, 654, 442, -95, -103, 707, -95, + -614, 76, 76, -95, 614, 76, 714, 587, 330, 476, + 86, 588, -97, 444, 305, -97, 306, 693, 693, -97, + 86, 693, 657, 658, -608, 615, -514, -514, 228, 648, + -608, 649, 650, 651, 652, 330, 76, 278, 477, 219, + 478, 752, 727, 727, 231, 419, -614, 659, -614, -614, + 452, 76, -610, 446, 708, 477, 739, 478, 479, 731, + 710, 864, 715, 255, 353, 354, 355, -72, 640, 472, + 760, 330, 686, 76, 76, 315, 316, 76, 772, 721, + 458, 874, -525, 212, 845, -526, 579, 278, 476, 467, + 464, 434, 880, 420, 421, 212, 754, 406, 567, 757, + 987, 420, 447, 434, 808, 471, 989, 486, -523, -101, + 567, 755, -102, 277, 1000, 710, 490, 473, 474, 848, + 845, 476, 199, 418, -109, 351, 352, 353, 354, 355, + -92, 201, 202, -93, 477, -524, 478, 481, 469, 86, + 493, 86, 710, 496, 119, -100, 747, 832, 525, 219, + 499, 827, 829, 511, 752, 71, -523, -523, 835, 837, + 667, 219, -286, 86, 219, 730, 448, 477, 869, 478, + 481, 523, 609, 277, 476, 579, 581, 767, 858, 938, + 788, 860, 788, -524, -524, 712, 500, 817, 438, 807, + 942, 76, 476, -108, 585, 219, 623, 582, 1050, 439, + 440, 826, 86, 693, 859, 868, 891, 278, 854, 895, + -286, -286, -104, 76, -99, 76, 76, 632, 255, 76, + 477, 76, 478, 483, 755, 863, 76, 844, 847, 625, + 847, 710, 847, -95, 766, 594, 626, 76, 477, 76, + 478, 487, 710, 816, 476, 583, 584, 667, 76, 667, + 636, -87, 641, 445, 702, 685, 634, 86, -268, 687, + 86, 698, 86, 701, -297, 199, 255, 278, 219, 968, + -427, 219, 219, 717, 418, 719, 748, 817, 219, 219, + 918, 277, 667, 595, 596, 360, 1025, 723, 360, 927, + 477, 667, 478, 494, 76, 76, 76, 76, 76, 76, + 76, 76, 817, 219, 476, 517, 219, 86, 484, 76, + 713, 76, -297, -297, 76, 86, 782, 595, 596, 788, + 788, 971, 768, 974, 727, 789, 936, 783, 928, 793, + 929, 796, 834, 940, 1026, 1027, 794, -106, 255, 890, + 937, 786, 76, 890, 76, 939, 790, 792, 76, 76, + 477, 922, 478, 795, 926, 797, -269, 845, -97, -103, + 873, 833, 875, 76, 879, 1004, 898, 1006, 899, 900, + 904, 277, 1007, 908, 910, 903, 907, 909, 911, 330, + -94, 812, 41, 42, 43, 44, 86, 912, 913, 915, + 76, 76, 277, -270, 343, 344, 360, 788, 917, 807, + 219, 799, 800, 920, 801, 76, 807, 924, 944, 990, + 991, 86, 46, 47, 219, 947, 951, 962, 86, 86, + 953, 967, 86, 1043, 956, 1045, 958, 330, 979, 76, + -271, 1024, 1046, 351, 352, 353, 354, 355, 998, 76, + 1035, 847, 343, 344, 975, 1009, 649, 650, 651, 652, + 667, 1011, 1058, 816, 1016, 214, 214, 890, 76, 214, + 816, 1018, 816, 1034, 648, 963, 649, 650, 651, 652, + 1036, 1038, 1042, 1022, 1066, 1031, -610, 889, 788, -611, + 350, 351, 352, 353, 354, 355, 983, 248, 250, 1060, + 86, 638, 214, 214, 310, 311, 312, 313, 314, 369, + 386, 86, 1054, 774, 840, 303, 304, 876, 807, 1055, + 804, 1056, 870, 1047, 86, 86, 1053, 404, 291, 398, + 495, 413, 997, 888, 1010, 1012, 212, 86, 969, 886, + 1017, 965, 1019, 1020, 434, 600, 721, 847, 0, 952, + 954, 567, 0, 0, 957, 0, 959, 710, 960, 0, + 0, 0, 0, 86, 0, 86, 0, 0, 76, 0, + 76, 86, 816, 86, 816, 0, 0, 0, 76, 816, + 648, 816, 649, 650, 651, 652, 653, 0, 330, 0, + 76, 0, 76, 76, 0, 722, 0, 724, 654, 0, + 0, 812, 219, 343, 344, 970, 809, 0, 812, 0, + 812, 0, 1059, 1061, 1062, 1063, 0, 0, 0, 655, + 0, 0, 0, 816, 76, 656, 657, 658, 0, 0, + 0, 76, 0, 0, 0, 1067, 0, 0, 0, 348, + 349, 350, 351, 352, 353, 354, 355, 0, 0, 0, + 0, 659, 0, 214, 660, 0, 214, 214, 214, 0, + 303, 0, 113, 0, 113, 0, 0, 1037, 1039, 1040, + 1041, 0, 235, 0, 0, 0, 0, 214, 0, 214, + 214, 0, 0, 0, 0, 0, 76, 0, 0, 76, + 0, 76, 0, 0, 0, 0, 0, 76, 0, 0, + 76, 76, 0, 0, 0, 0, 0, 76, 76, 0, + 812, 113, 812, 818, 0, 279, 819, 812, 821, 812, + 648, 1065, 649, 650, 651, 652, 0, 0, 0, 0, + 0, 0, 76, 0, 0, 76, 76, 0, 0, 0, + 0, 279, 0, 0, 76, 0, 0, 0, 0, 0, + 0, 0, 0, 373, 383, 383, 383, 0, 0, 774, + 0, 812, 0, 0, 0, 775, 648, 0, 649, 650, + 651, 652, 0, 214, 0, 0, 0, 0, 527, 530, + 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, + 541, 542, 543, 544, 0, 546, 547, 548, 549, 550, + 551, 552, 553, 554, 555, 774, 214, 0, 0, 0, + 0, 945, 0, 0, 0, 76, 809, 0, 0, 0, + 809, 0, 0, 809, 0, 809, 0, 0, 0, 76, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 76, 0, 914, 76, 0, 0, 0, 76, 76, 0, + 0, 76, 0, 0, 605, 607, 0, 0, 0, 0, + 0, 0, 0, 610, 214, 214, 113, 923, 114, 214, + 114, 605, 607, 214, 930, 931, 0, 83, 933, 83, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 630, 0, 0, 0, 0, 635, 0, 0, + 0, 113, 0, 0, 0, 0, 0, 0, 214, 0, + 0, 214, 113, 0, 113, 0, 0, 114, 0, 76, + 0, 280, 214, 0, 0, 809, 83, 809, 0, 0, + 76, 0, 809, 0, 809, 279, 0, 0, 0, 0, + 0, 0, 0, 76, 76, 0, 988, 280, 688, 0, + 0, 0, 0, 0, 0, 0, 76, 0, 0, 374, + 384, 384, 384, 214, 0, 0, 0, 0, 370, 113, + 1002, 1003, 0, 0, 113, 0, 809, 0, 117, 0, + 117, 0, 76, 1008, 76, 0, 113, 279, 0, 0, + 76, 0, 76, 0, 704, 0, 0, 0, 0, 0, + 0, 0, 648, 0, 649, 650, 651, 652, 653, 1028, + 0, 1029, 0, 0, 0, 0, 0, 1030, 0, 113, + 654, 76, 0, 0, 0, 0, 0, 117, 214, 0, + 0, 281, 214, 0, 0, 0, 0, 0, 0, 0, + 0, 655, 0, 0, 214, 0, 0, 656, 657, 658, + 0, 0, 0, 0, 0, 0, 0, 281, 214, 0, + 0, 214, 0, 0, 0, 0, 116, 0, 116, 375, + 385, 385, 114, 659, 214, 214, 660, 0, 0, 0, + 0, 83, 0, 0, 0, 0, 0, 0, 0, 661, + 0, 0, 0, 648, 0, 649, 650, 651, 652, 653, + 0, 0, 0, 0, 113, 0, 0, 114, 0, 0, + 0, 654, 0, 0, 113, 116, 83, 0, 114, 214, + 114, 0, 0, 0, 0, 0, 0, 83, 0, 83, + 0, 279, 655, 0, 0, 0, 0, 0, 656, 657, + 658, 280, 0, 0, 0, 0, 0, 214, 0, 0, + 0, 610, 825, 0, 828, 830, 0, 0, 0, 0, + 0, 836, 838, 0, 659, 0, 0, 660, 214, 0, + 0, 0, 0, 0, 0, 114, 0, 0, 0, 0, + 114, 279, 117, 0, 83, 0, 0, 0, 0, 83, + 0, 268, 114, 280, 0, 0, 0, 0, 0, 0, + 0, 83, 0, 0, 526, 871, 0, 0, 0, 0, + 828, 830, 0, 836, 838, 0, 0, 117, 0, 0, + 0, 0, 0, 0, 0, 114, 0, 0, 117, 0, + 117, 214, 0, 113, 83, 113, 0, 0, 0, 0, + 648, 0, 649, 650, 651, 652, 653, 0, 0, 0, + 0, 281, 0, 0, 0, 0, 0, 113, 654, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 116, 214, 0, 0, 0, 0, 0, 0, 0, 655, + 0, 0, 0, 919, 0, 117, 657, 658, 0, 0, + 117, 0, 0, 0, 0, 0, 113, 0, 0, 0, + 0, 279, 117, 281, 214, 116, 0, 0, 0, 0, + 114, 659, 0, 0, 0, 0, 116, 0, 116, 83, + 114, 919, 214, 0, 0, 0, 0, 0, 0, 83, + 0, 0, 0, 0, 0, 117, 0, 280, 0, 0, + 0, 408, 0, 0, 410, 411, 412, 0, 0, 0, + 0, 113, 0, 0, 113, 0, 113, 0, 0, 0, + 0, 279, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 116, 0, 0, 0, 0, 116, 0, + 0, 0, 0, 0, 0, 0, 0, 280, 0, 0, + 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 113, 0, 0, 0, 0, 0, 0, 0, 113, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 117, 0, 0, 116, 0, 0, 0, 0, 0, 1023, + 117, 0, 0, 0, 0, 0, 0, 0, 0, 114, + 0, 114, 0, 0, 0, 0, 0, 281, 83, 0, + 83, 0, 0, 0, 0, 0, 0, 703, 0, 0, + 0, 516, 0, 114, 0, 0, 528, 0, 0, 383, + 0, 0, 83, 0, 0, 214, 0, 0, 0, 0, + 113, 0, 0, 330, 331, 332, 333, 334, 335, 336, + 337, 338, 339, 340, 341, 342, 0, 281, 343, 344, + 0, 0, 114, 0, 0, 113, 0, 280, 116, 0, + 0, 83, 113, 113, 0, 0, 113, 0, 116, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 345, 0, 346, 347, 348, 349, 350, 351, 352, 353, + 354, 355, 0, 0, 0, 0, 0, 0, 0, 117, + -245, 117, 611, 613, 0, 0, 0, 114, 0, 383, + 114, 268, 114, 0, 0, 0, 83, 280, 0, 83, + 0, 83, 0, 117, 0, 0, 0, 526, 0, 0, + 984, 0, 0, 0, 113, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 113, 613, 0, 0, 268, + 0, 0, 0, 0, 0, 0, 0, 114, 113, 113, + 0, 0, 117, 0, 0, 114, 83, 281, 0, 0, + 0, 113, 0, 0, 83, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 116, 0, 116, + 0, 0, 0, 0, 0, 0, 0, 113, 0, 113, + 0, 697, 0, 0, 0, 113, 0, 113, 803, 0, + 0, 116, 0, 0, 0, 0, 0, 117, 0, 0, + 117, 0, 117, 0, 0, 384, 0, 281, 0, 0, + 0, 0, 0, 0, 0, 0, 114, 330, 331, 332, + 333, 334, 335, 336, 337, 83, 339, 340, 0, 0, + 116, 0, 343, 344, 0, 0, 0, 0, 0, 0, + 0, 114, 0, 0, 0, 0, 528, 117, 114, 114, + 83, 0, 114, 0, 0, 117, 0, 83, 83, 0, + 0, 83, 0, 0, 0, 0, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 355, 758, 0, 0, 759, + 0, 0, 0, 0, 0, 116, 0, 0, 116, 0, + 116, 0, 613, 268, 0, 384, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 385, 985, 0, 0, 0, + 114, 0, 0, 0, 0, 982, 117, 0, 0, 83, + 0, 114, 0, 0, 0, 116, 0, 785, 0, 0, + 83, 0, 0, 116, 114, 114, 0, 0, 0, 0, + 0, 117, 0, 83, 83, 0, 0, 114, 117, 117, + 0, 0, 117, 0, 0, 823, 83, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 114, 0, 114, 841, 0, 0, 0, + 0, 114, 83, 114, 83, 0, 0, 0, 0, 0, + 83, 0, 83, 0, 0, 385, 0, 330, -633, -633, + -633, -633, 335, 336, 116, 0, -633, -633, 0, 0, + 0, 0, 343, 344, 0, 0, 986, 0, 0, 0, + 117, 0, 0, 0, 0, 0, 0, 0, 0, 116, + 0, 117, 0, 0, 0, 0, 116, 116, 0, 883, + 116, 0, 0, 0, 117, 117, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 355, 0, 117, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 330, 331, 332, 333, 334, 335, 336, 0, 916, + 339, 340, 0, 117, 0, 117, 343, 344, 0, 0, + 0, 117, 0, 117, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 116, 0, + 0, 0, 932, 0, 0, 0, 0, 0, 0, 116, + 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, + 268, 0, 116, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 116, 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, 116, 0, 116, 0, 0, 0, 0, 0, 116, + 0, 116, -632, 4, 0, 5, 6, 7, 8, 9, + 0, 0, 0, 10, 11, 0, 0, 0, 12, 0, + 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, + 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, + 0, 27, 0, 0, 0, 0, 0, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 0, 41, 42, 43, 44, 0, 45, 46, 47, 0, + 48, 49, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 50, 0, 0, 51, 52, 0, 53, 54, 0, 55, + 0, 0, 56, 57, 58, 59, 60, 61, 62, 63, + 64, -614, 0, 0, 0, 0, 0, 0, 0, -614, + -614, -614, 0, 0, -614, -614, -614, 0, -614, 0, + 0, 65, 66, 67, 0, 756, 0, -614, -614, -614, + -614, 0, 0, 0, -632, 0, -632, 0, -614, -614, + 0, -614, -614, -614, -614, -614, 0, 0, 0, 0, + 0, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 0, 0, 343, 344, 0, 0, + 0, -614, -614, -614, -614, -614, -614, -614, -614, -614, + -614, -614, -614, -614, 0, 0, -614, -614, -614, 0, + 761, -614, 0, 0, 0, 0, 0, -614, 345, 0, + 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, + 0, -614, 0, 0, -614, 0, 0, -105, -614, -614, + -614, -614, -614, -614, -614, -614, -614, -614, -614, -614, + 0, 0, 0, 0, -614, -614, -614, -614, -614, -511, + 0, -614, -614, -614, 0, -614, 0, -511, -511, -511, + 0, 0, -511, -511, -511, 0, -511, 0, 0, 0, + 0, 703, 0, 0, -511, 0, -511, -511, -511, 0, + 0, 0, 0, 0, 0, 0, -511, -511, 0, -511, + -511, -511, -511, -511, 0, 0, 0, 330, 331, 332, + 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, + 0, 0, 343, 344, 0, 0, 0, 0, 0, -511, + -511, -511, -511, -511, -511, -511, -511, -511, -511, -511, + -511, -511, 0, 0, -511, -511, -511, 0, -511, -511, + 0, 0, 0, 0, 345, -511, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 355, 0, 0, 0, -511, + 0, 0, -511, 0, 0, -511, -511, -511, -511, -511, + -511, -511, -511, -511, -511, -511, -511, -511, 0, 0, + 0, 0, 0, -511, -511, -511, -511, -514, 0, -511, + -511, -511, 0, -511, 0, -514, -514, -514, 0, 0, + -514, -514, -514, 0, -514, 0, 0, 0, 0, 0, + 0, 0, -514, 0, -514, -514, -514, 0, 0, 0, + 0, 0, 0, 0, -514, -514, 0, -514, -514, -514, + -514, -514, 0, 0, 0, 330, 331, 332, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 0, 0, + 343, 344, 0, 0, 0, 0, 0, -514, -514, -514, + -514, -514, -514, -514, -514, -514, -514, -514, -514, -514, + 0, 0, -514, -514, -514, 0, -514, -514, 0, 0, + 0, 0, 345, -514, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 0, 0, 0, -514, 0, 0, + -514, 0, 0, -514, -514, -514, -514, -514, -514, -514, + -514, -514, -514, -514, -514, -514, 0, 0, 0, 0, + 0, -514, -514, -514, -514, -615, 0, -514, -514, -514, + 0, -514, 0, -615, -615, -615, 0, 0, -615, -615, + -615, 0, -615, 0, 0, 0, 0, 0, 0, 0, + 0, -615, -615, -615, -615, 0, 0, 0, 0, 0, + 0, 0, -615, -615, 0, -615, -615, -615, -615, -615, + 0, 0, 0, 330, 331, 332, 333, 334, 335, 336, + 337, 338, 339, 340, -633, -633, 0, 0, 343, 344, + 0, 0, 0, 0, 0, -615, -615, -615, -615, -615, + -615, -615, -615, -615, -615, -615, -615, -615, 0, 0, + -615, -615, -615, 0, 0, -615, 0, 0, 0, 0, + 0, -615, 346, 347, 348, 349, 350, 351, 352, 353, + 354, 355, 0, 0, 0, -615, 0, 0, -615, 0, + 0, 0, -615, -615, -615, -615, -615, -615, -615, -615, + -615, -615, -615, -615, 0, 0, 0, 0, -615, -615, + -615, -615, -615, -616, 0, -615, -615, -615, 0, -615, + 0, -616, -616, -616, 0, 0, -616, -616, -616, 0, + -616, 0, 0, 0, 0, 0, 0, 0, 0, -616, + -616, -616, -616, 0, 0, 0, 0, 0, 0, 0, + -616, -616, 0, -616, -616, -616, -616, -616, 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, -616, -616, -616, -616, -616, -616, -616, + -616, -616, -616, -616, -616, -616, 0, 0, -616, -616, + -616, 0, 0, -616, 0, 0, 0, 0, 0, -616, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, -616, 0, 0, -616, 0, 0, 0, + -616, -616, -616, -616, -616, -616, -616, -616, -616, -616, + -616, -616, 0, 0, 0, 0, -616, -616, -616, -616, + -616, -296, 0, -616, -616, -616, 0, -616, 0, -296, + -296, -296, 0, 0, -296, -296, -296, 0, -296, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -296, -296, + -296, 0, 0, 0, 0, 0, 0, 0, -296, -296, + 0, -296, -296, -296, -296, -296, 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, -296, -296, -296, -296, -296, -296, -296, -296, -296, + -296, -296, -296, -296, 0, 0, -296, -296, -296, 0, + 762, -296, 0, 0, 0, 0, 0, -296, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, -296, 0, 0, -296, 0, 0, -107, -296, -296, + -296, -296, -296, -296, -296, -296, -296, -296, -296, -296, + 0, 0, 0, 0, 0, -296, -296, -296, -296, -435, + 0, -296, -296, -296, 0, -296, 0, -435, -435, -435, + 0, 0, -435, -435, -435, 0, -435, 0, 0, 0, + 0, 0, 0, 0, 0, -435, -435, -435, 0, 0, + 0, 0, 0, 0, 0, 0, -435, -435, 0, -435, + -435, -435, -435, -435, 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, -435, + -435, -435, -435, -435, -435, -435, -435, -435, -435, -435, + -435, -435, 0, 0, -435, -435, -435, 0, 0, -435, + 0, 0, 0, 0, 0, -435, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, -435, + 0, 0, 0, 0, 0, 0, -435, 0, -435, -435, + -435, -435, -435, -435, -435, -435, -435, -435, 0, 0, + 0, 0, -435, -435, -435, -435, -435, -287, 231, -435, + -435, -435, 0, -435, 0, -287, -287, -287, 0, 0, + -287, -287, -287, 0, -287, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -287, -287, -287, 0, 0, 0, + 0, 0, 0, 0, -287, -287, 0, -287, -287, -287, + -287, -287, 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, -287, -287, -287, + -287, -287, -287, -287, -287, -287, -287, -287, -287, -287, + 0, 0, -287, -287, -287, 0, 0, -287, 0, 0, + 0, 0, 0, -287, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, -287, 0, 0, + -287, 0, 0, 0, -287, -287, -287, -287, -287, -287, + -287, -287, -287, -287, -287, -287, 0, 0, 0, 0, + 0, -287, -287, -287, -287, -425, 0, -287, -287, -287, + 0, -287, 0, -425, -425, -425, 0, 0, -425, -425, + -425, 0, -425, 0, 0, 0, 0, 0, 0, 0, + 0, -425, -425, -425, 0, 0, 0, 0, 0, 0, + 0, 0, -425, -425, 0, -425, -425, -425, -425, -425, + 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, -425, -425, -425, -425, -425, + -425, -425, -425, -425, -425, -425, -425, -425, 0, 0, + -425, -425, -425, 0, 0, -425, 0, 0, 0, 0, + 0, -425, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -425, 0, 0, 0, 0, + 0, 0, -425, 0, -425, -425, -425, -425, -425, -425, + -425, -425, -425, -425, 0, 0, 0, 0, -425, -425, + -425, -425, -425, -303, -425, -425, -425, -425, 0, -425, + 0, -303, -303, -303, 0, 0, -303, -303, -303, 0, + -303, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -303, -303, 0, 0, 0, 0, 0, 0, 0, 0, + -303, -303, 0, -303, -303, -303, -303, -303, 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, -303, -303, -303, -303, -303, -303, -303, + -303, -303, -303, -303, -303, -303, 0, 0, -303, -303, + -303, 0, 0, -303, 0, 0, 0, 0, 0, -303, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, -303, 0, 0, 0, 0, 0, 0, + -303, 0, -303, -303, -303, -303, -303, -303, -303, -303, + -303, -303, 0, 0, 0, 0, 0, -303, -303, -303, + -303, -614, 228, -303, -303, -303, 0, -303, 0, -614, + -614, -614, 0, 0, 0, -614, -614, 0, -614, 0, + 0, 0, 0, 0, 0, 0, 0, -614, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -614, -614, + 0, -614, -614, -614, -614, -614, 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, -614, -614, -614, -614, -614, -614, -614, -614, -614, + -614, -614, -614, -614, 0, 0, -614, -614, -614, 0, + 705, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, -614, 0, 0, 0, 0, 0, -105, -614, 0, + -614, -614, -614, -614, -614, -614, -614, -614, -614, -614, + 0, 0, 0, 0, -614, -614, -614, -614, -96, -296, + 0, -614, 0, -614, 0, -614, 0, -296, -296, -296, + 0, 0, 0, -296, -296, 0, -296, 0, -632, 0, + 0, 0, 0, 0, 0, 0, -632, -632, -632, 0, + 0, -632, -632, -632, 0, -632, -296, -296, 0, -296, + -296, -296, -296, -296, -632, -632, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -632, -632, 0, -632, -632, + -632, -632, -632, 0, 0, 0, 0, 0, 0, -296, + -296, -296, -296, -296, -296, -296, -296, -296, -296, -296, + -296, -296, 0, 0, -296, -296, -296, 0, 706, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -632, 0, 0, 0, -296, + 0, 0, 0, 0, 0, -107, -296, 0, -296, -296, + -296, -296, -296, -296, -296, -296, -296, -296, -632, 0, + 0, 0, 0, -296, -296, -296, -98, 0, 0, -296, + 0, -296, 0, -296, 0, 0, 0, 0, 0, 0, + 0, -632, -632, 0, -632, 0, 0, 231, -632, 0, + -632, 252, -632, 5, 6, 7, 8, 9, -632, -632, + -632, 10, 11, 0, 0, -632, 12, 0, 13, 14, + 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, + 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, + 0, 0, 0, 0, 0, 28, 29, 253, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 0, 41, + 42, 43, 44, 0, 45, 46, 47, 0, 48, 49, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 50, 0, + 0, 51, 52, 0, 53, 54, 0, 55, 0, 0, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, + 66, 67, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, -632, 252, -632, 5, 6, 7, 8, 9, + 0, 0, -632, 10, 11, 0, -632, -632, 12, 0, + 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, + 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, + 0, 27, 0, 0, 0, 0, 0, 28, 29, 253, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 0, 41, 42, 43, 44, 0, 45, 46, 47, 0, + 48, 49, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 50, 0, 0, 51, 52, 0, 53, 54, 0, 55, + 0, 0, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 65, 66, 67, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -632, 252, -632, 5, 6, 7, + 8, 9, 0, 0, -632, 10, 11, 0, 0, -632, + 12, -632, 13, 14, 15, 16, 17, 18, 19, 0, + 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, + 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, + 29, 253, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 0, 41, 42, 43, 44, 0, 45, 46, + 47, 0, 48, 49, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 0, 0, 51, 52, 0, 53, 54, + 0, 55, 0, 0, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 65, 66, 67, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, -632, 252, -632, 5, + 6, 7, 8, 9, 0, 0, -632, 10, 11, 0, + 0, -632, 12, 0, 13, 14, 15, 16, 17, 18, + 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, + 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, + 0, 28, 29, 253, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 0, 41, 42, 43, 44, 0, + 45, 46, 47, 0, 48, 49, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 0, 0, 51, 52, 0, + 53, 54, 0, 55, 0, 0, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 0, 0, 0, 0, 0, + 0, 0, 0, 252, 0, 5, 6, 7, 8, 9, + 0, -632, -632, 10, 11, 65, 66, 67, 12, 0, + 13, 14, 15, 16, 17, 18, 19, 0, -632, 0, + -632, 0, 20, 21, 22, 23, 24, 25, 26, 0, + 0, 27, 0, 0, 0, 0, 0, 28, 29, 253, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 0, 41, 42, 43, 44, 0, 45, 46, 47, 0, + 48, 49, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 50, 0, 0, 51, 52, 0, 53, 54, 0, 55, + 0, 0, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 0, 0, 0, 0, 0, 0, 0, 0, 252, + 0, 5, 6, 7, 8, 9, 0, 0, 0, 10, + 11, 65, 66, 67, 12, 0, 13, 14, 15, 16, + 17, 18, 19, 0, -632, 0, -632, 0, 20, 21, + 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, + 0, 0, 0, 28, 29, 253, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 0, 41, 42, 43, + 44, 0, 45, 46, 47, 0, 48, 49, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 0, 0, 254, + 52, 0, 53, 54, 0, 55, 0, 0, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 65, 66, 67, + 0, 0, 0, 0, 0, 0, 0, 0, -632, 0, + -632, 252, -632, 5, 6, 7, 8, 9, 0, 0, + 0, 10, 11, 0, 0, 0, 12, 0, 13, 14, + 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, + 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, + 0, 0, 0, 0, 0, 28, 29, 253, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 0, 41, + 42, 43, 44, 0, 45, 46, 47, 0, 48, 49, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 50, 0, + 0, 51, 52, 0, 53, 54, 0, 55, 0, 0, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, + 66, 67, 0, 0, 0, 0, 0, 0, 0, 0, + -632, 0, -632, 252, -632, 5, 6, 7, 8, 9, + 0, 0, 0, 10, 11, 0, 0, 0, 12, 0, + 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, + 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, + 0, 27, 0, 0, 0, 0, 0, 28, 29, 253, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 0, 41, 42, 43, 44, 0, 45, 46, 47, 0, + 48, 49, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 50, 0, 0, 51, 52, 0, 53, 54, 0, 55, + 0, 0, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 65, 66, 67, 0, 0, -632, 4, 0, 5, + 6, 7, 8, 9, -632, 0, -632, 10, 11, 0, + 0, 0, 12, 0, 13, 14, 15, 16, 17, 18, + 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, + 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, + 0, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 0, 41, 42, 43, 44, 0, + 45, 46, 47, 0, 48, 49, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 0, 0, 51, 52, 0, + 53, 54, 0, 55, 0, 0, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 65, 66, 67, 0, 0, + -632, 0, 0, 0, 0, 0, 0, 0, -632, 252, + -632, 5, 6, 7, 8, 9, 0, 0, -632, 10, + 11, 0, 0, 0, 12, 0, 13, 14, 15, 16, + 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, + 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, + 0, 0, 0, 28, 29, 253, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 0, 41, 42, 43, + 44, 0, 45, 46, 47, 0, 48, 49, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 0, 0, 51, + 52, 0, 53, 54, 0, 55, 0, 0, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 0, 0, 0, + 0, 0, 0, 0, 0, 252, 0, 5, 6, 7, + 8, 9, 0, 0, 0, 10, 11, 65, 66, 67, + 12, 0, 13, 14, 15, 16, 17, 18, 19, 0, + -632, 0, -632, 0, 20, 21, 22, 23, 24, 25, + 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, + 29, 253, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 0, 41, 42, 43, 44, 0, 45, 46, + 47, 0, 48, 49, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 0, 0, 51, 52, 0, 53, 54, + 0, 55, 0, 0, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 0, -632, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 6, 7, 0, 9, 0, 0, + 0, 10, 11, 65, 66, 67, 12, 0, 13, 14, + 15, 16, 17, 18, 19, 0, -632, 0, -632, 0, + 20, 21, 22, 23, 24, 25, 26, 0, 0, 203, + 0, 0, 0, 0, 0, 0, 29, 0, 0, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 204, 41, + 42, 43, 44, 0, 45, 46, 47, 0, 48, 49, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 205, 0, + 0, 206, 52, 0, 53, 54, 0, 207, 208, 209, + 56, 57, 210, 59, 60, 61, 62, 63, 64, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 6, 7, 0, 9, 0, 0, 0, 10, 11, 65, + 211, 67, 12, 0, 13, 14, 15, 16, 17, 18, + 19, 0, 0, 0, 235, 0, 20, 21, 22, 23, + 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, + 0, 0, 29, 0, 0, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 0, 41, 42, 43, 44, 0, + 45, 46, 47, 0, 48, 49, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 205, 0, 0, 206, 52, 0, + 53, 54, 0, 0, 0, 0, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 5, 6, 7, 0, 9, + 0, 0, 0, 10, 11, 65, 66, 67, 12, 0, + 13, 14, 15, 16, 17, 18, 19, 0, 305, 0, + 306, 0, 20, 21, 22, 23, 24, 25, 26, 0, + 0, 27, 0, 0, 0, 0, 0, 0, 29, 0, + 0, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 0, 41, 42, 43, 44, 0, 45, 46, 47, 0, + 48, 49, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 205, 0, 0, 206, 52, 0, 53, 54, 0, 0, + 0, 0, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 6, 7, 8, 9, 0, 0, 0, 10, + 11, 65, 66, 67, 12, 0, 13, 14, 15, 16, + 17, 18, 19, 0, 0, 0, 235, 0, 20, 21, + 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, + 0, 0, 0, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 0, 41, 42, 43, + 44, 0, 45, 46, 47, 0, 48, 49, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 0, 0, 51, + 52, 0, 53, 54, 0, 55, 0, 0, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 5, 6, 7, + 8, 9, 0, 0, 0, 10, 11, 65, 66, 67, + 12, 0, 13, 14, 15, 16, 17, 18, 19, 0, + 500, 0, 0, 0, 20, 21, 22, 23, 24, 25, + 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, + 29, 253, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 0, 41, 42, 43, 44, 0, 45, 46, + 47, 0, 48, 49, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 0, 0, 51, 52, 0, 53, 54, + 0, 55, 0, 0, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 65, 66, 67, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 500, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 0, 0, 0, 145, 146, 147, 387, 388, 389, + 390, 152, 153, 154, 0, 0, 0, 0, 0, 155, + 156, 157, 158, 391, 392, 393, 394, 163, 37, 38, + 395, 40, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 0, 0, 174, 175, 0, 0, 176, 177, 178, + 179, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 180, 181, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 0, 192, 193, 0, 0, 0, 0, + 0, 0, 194, 396, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 0, 0, + 0, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 0, 0, 0, 0, 0, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 284, 285, 164, 286, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 0, 0, + 174, 175, 0, 0, 176, 177, 178, 179, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 180, 181, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 0, 192, 193, 0, 0, 0, 0, 0, 0, 194, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 0, 0, 0, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 0, 0, 0, + 0, 0, 155, 156, 157, 158, 159, 160, 161, 162, + 163, 237, 0, 164, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 0, 0, 174, 175, 0, 0, + 176, 177, 178, 179, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 180, 181, 0, 0, 57, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 0, 192, 193, 0, + 0, 0, 0, 0, 0, 194, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 0, 0, 0, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 0, 0, 0, 0, 0, 155, 156, + 157, 158, 159, 160, 161, 162, 163, 0, 0, 164, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 0, 0, 174, 175, 0, 0, 176, 177, 178, 179, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 180, 181, 0, 0, 57, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 0, 192, 193, 0, 0, 0, 0, 0, + 0, 194, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 0, 0, 0, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 0, + 0, 0, 0, 0, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 0, 0, 164, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 0, 0, 174, 175, + 0, 0, 176, 177, 178, 179, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 180, 181, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 0, 192, + 193, 5, 6, 7, 0, 9, 0, 194, 0, 10, + 11, 0, 0, 0, 12, 0, 13, 14, 15, 242, + 243, 18, 19, 0, 0, 0, 0, 0, 244, 245, + 246, 23, 24, 25, 26, 0, 0, 203, 0, 0, + 0, 0, 0, 0, 272, 0, 0, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 0, 41, 42, 43, + 44, 0, 45, 46, 47, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 273, 0, 0, 206, + 52, 0, 53, 54, 0, 0, 0, 0, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 0, 0, 0, + 0, 0, 0, 5, 6, 7, 0, 9, 0, 0, + 0, 10, 11, 0, 0, 0, 12, 274, 13, 14, + 15, 242, 243, 18, 19, 275, 0, 0, 0, 0, + 244, 245, 246, 23, 24, 25, 26, 0, 0, 203, + 0, 0, 0, 0, 0, 0, 272, 0, 0, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 0, 41, + 42, 43, 44, 0, 45, 46, 47, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 273, 0, + 0, 206, 52, 0, 53, 54, 0, 0, 0, 0, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 0, + 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, + 0, 0, 0, 10, 11, 0, 0, 0, 12, 274, + 13, 14, 15, 16, 17, 18, 19, 521, 0, 0, + 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, + 0, 27, 0, 0, 0, 0, 0, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 0, 41, 42, 43, 44, 0, 45, 46, 47, 0, + 48, 49, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 50, 0, 0, 51, 52, 0, 53, 54, 0, 55, + 0, 0, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 6, 7, 0, 9, 0, 0, 0, 10, + 11, 65, 66, 67, 12, 0, 13, 14, 15, 16, + 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, + 22, 23, 24, 25, 26, 0, 0, 203, 0, 0, + 0, 0, 0, 0, 29, 0, 0, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 204, 41, 42, 43, + 44, 0, 45, 46, 47, 0, 48, 49, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 205, 0, 0, 206, + 52, 0, 53, 54, 0, 207, 208, 209, 56, 57, + 210, 59, 60, 61, 62, 63, 64, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 5, 6, 7, + 8, 9, 0, 0, 0, 10, 11, 65, 211, 67, + 12, 0, 13, 14, 15, 16, 17, 18, 19, 0, + 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, + 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, + 29, 0, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 0, 41, 42, 43, 44, 0, 45, 46, + 47, 0, 48, 49, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 0, 0, 51, 52, 0, 53, 54, + 0, 55, 0, 0, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 6, 7, 0, 9, 0, 0, + 0, 10, 11, 65, 66, 67, 12, 0, 13, 14, + 15, 242, 243, 18, 19, 0, 0, 0, 0, 0, + 244, 245, 246, 23, 24, 25, 26, 0, 0, 203, + 0, 0, 0, 0, 0, 0, 29, 0, 0, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 204, 41, + 42, 43, 44, 0, 45, 46, 47, 0, 48, 49, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 205, 0, + 0, 206, 52, 0, 53, 54, 0, 612, 208, 209, + 56, 57, 210, 59, 60, 61, 62, 63, 64, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 6, 7, 0, 9, 0, 0, 0, 10, 11, 65, + 211, 67, 12, 0, 13, 14, 15, 242, 243, 18, + 19, 0, 0, 0, 0, 0, 244, 245, 246, 23, + 24, 25, 26, 0, 0, 203, 0, 0, 0, 0, + 0, 0, 29, 0, 0, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 204, 41, 42, 43, 44, 0, + 45, 46, 47, 0, 48, 49, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 205, 0, 0, 206, 52, 0, + 53, 54, 0, 207, 208, 0, 56, 57, 210, 59, + 60, 61, 62, 63, 64, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 5, 6, 7, 0, 9, + 0, 0, 0, 10, 11, 65, 211, 67, 12, 0, + 13, 14, 15, 242, 243, 18, 19, 0, 0, 0, + 0, 0, 244, 245, 246, 23, 24, 25, 26, 0, + 0, 203, 0, 0, 0, 0, 0, 0, 29, 0, + 0, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 204, 41, 42, 43, 44, 0, 45, 46, 47, 0, + 48, 49, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 205, 0, 0, 206, 52, 0, 53, 54, 0, 0, + 208, 209, 56, 57, 210, 59, 60, 61, 62, 63, + 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 6, 7, 0, 9, 0, 0, 0, 10, + 11, 65, 211, 67, 12, 0, 13, 14, 15, 242, + 243, 18, 19, 0, 0, 0, 0, 0, 244, 245, + 246, 23, 24, 25, 26, 0, 0, 203, 0, 0, + 0, 0, 0, 0, 29, 0, 0, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 204, 41, 42, 43, + 44, 0, 45, 46, 47, 0, 48, 49, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 205, 0, 0, 206, + 52, 0, 53, 54, 0, 612, 208, 0, 56, 57, + 210, 59, 60, 61, 62, 63, 64, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 5, 6, 7, + 0, 9, 0, 0, 0, 10, 11, 65, 211, 67, + 12, 0, 13, 14, 15, 242, 243, 18, 19, 0, + 0, 0, 0, 0, 244, 245, 246, 23, 24, 25, + 26, 0, 0, 203, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 204, 41, 42, 43, 44, 0, 45, 46, + 47, 0, 48, 49, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 205, 0, 0, 206, 52, 0, 53, 54, + 0, 0, 208, 0, 56, 57, 210, 59, 60, 61, + 62, 63, 64, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 6, 7, 0, 9, 0, 0, + 0, 10, 11, 65, 211, 67, 12, 0, 13, 14, + 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, + 20, 21, 22, 23, 24, 25, 26, 0, 0, 203, + 0, 0, 0, 0, 0, 0, 29, 0, 0, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 0, 41, + 42, 43, 44, 0, 45, 46, 47, 0, 48, 49, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 205, 0, + 0, 206, 52, 0, 53, 54, 0, 514, 0, 0, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 6, 7, 0, 9, 0, 0, 0, 10, 11, 65, + 211, 67, 12, 0, 13, 14, 15, 242, 243, 18, + 19, 0, 0, 0, 0, 0, 244, 245, 246, 23, + 24, 25, 26, 0, 0, 203, 0, 0, 0, 0, + 0, 0, 29, 0, 0, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 0, 41, 42, 43, 44, 0, + 45, 46, 47, 0, 48, 49, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 205, 0, 0, 206, 52, 0, + 53, 54, 0, 207, 0, 0, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 5, 6, 7, 0, 9, + 0, 0, 0, 10, 11, 65, 211, 67, 12, 0, + 13, 14, 15, 242, 243, 18, 19, 0, 0, 0, + 0, 0, 244, 245, 246, 23, 24, 25, 26, 0, + 0, 203, 0, 0, 0, 0, 0, 0, 29, 0, + 0, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 0, 41, 42, 43, 44, 0, 45, 46, 47, 0, + 48, 49, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 205, 0, 0, 206, 52, 0, 53, 54, 0, 822, + 0, 0, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 6, 7, 0, 9, 0, 0, 0, 10, + 11, 65, 211, 67, 12, 0, 13, 14, 15, 242, + 243, 18, 19, 0, 0, 0, 0, 0, 244, 245, + 246, 23, 24, 25, 26, 0, 0, 203, 0, 0, + 0, 0, 0, 0, 29, 0, 0, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 0, 41, 42, 43, + 44, 0, 45, 46, 47, 0, 48, 49, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 205, 0, 0, 206, + 52, 0, 53, 54, 0, 514, 0, 0, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 5, 6, 7, + 0, 9, 0, 0, 0, 10, 11, 65, 211, 67, + 12, 0, 13, 14, 15, 242, 243, 18, 19, 0, + 0, 0, 0, 0, 244, 245, 246, 23, 24, 25, + 26, 0, 0, 203, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 0, 41, 42, 43, 44, 0, 45, 46, + 47, 0, 48, 49, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 205, 0, 0, 206, 52, 0, 53, 54, + 0, 612, 0, 0, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 6, 7, 0, 9, 0, 0, + 0, 10, 11, 65, 211, 67, 12, 0, 13, 14, + 15, 242, 243, 18, 19, 0, 0, 0, 0, 0, + 244, 245, 246, 23, 24, 25, 26, 0, 0, 203, + 0, 0, 0, 0, 0, 0, 29, 0, 0, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 0, 41, + 42, 43, 44, 0, 45, 46, 47, 0, 48, 49, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 205, 0, + 0, 206, 52, 0, 53, 54, 0, 0, 0, 0, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 6, 7, 0, 9, 0, 0, 0, 10, 11, 65, + 211, 67, 12, 0, 13, 14, 15, 16, 17, 18, + 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, + 24, 25, 26, 0, 0, 203, 0, 0, 0, 0, + 0, 0, 29, 0, 0, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 0, 41, 42, 43, 44, 0, + 45, 46, 47, 0, 48, 49, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 205, 0, 0, 206, 52, 0, + 53, 54, 0, 0, 0, 0, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 5, 6, 7, 0, 9, + 0, 0, 0, 10, 11, 65, 211, 67, 12, 0, + 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, + 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, + 0, 27, 0, 0, 0, 0, 0, 0, 29, 0, + 0, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 0, 41, 42, 43, 44, 0, 45, 46, 47, 0, + 48, 49, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 205, 0, 0, 206, 52, 0, 53, 54, 0, 0, + 0, 0, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 6, 7, 0, 9, 0, 0, 0, 10, + 11, 65, 66, 67, 12, 0, 13, 14, 15, 242, + 243, 18, 19, 0, 0, 0, 0, 0, 244, 245, + 246, 23, 24, 25, 26, 0, 0, 203, 0, 0, + 0, 0, 0, 0, 272, 0, 0, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 0, 41, 42, 43, + 44, 0, 45, 46, 47, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 273, 0, 0, 326, + 52, 0, 53, 54, 0, 327, 0, 0, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 0, 0, 0, + 0, 0, 0, 5, 6, 7, 0, 9, 0, 0, + 0, 10, 11, 0, 0, 0, 12, 274, 13, 14, + 15, 242, 243, 18, 19, 0, 0, 0, 0, 0, + 244, 245, 246, 23, 24, 25, 26, 0, 0, 203, + 0, 0, 0, 0, 0, 0, 272, 0, 0, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 0, 41, + 42, 43, 44, 0, 45, 46, 47, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 368, 0, + 0, 51, 52, 0, 53, 54, 0, 55, 0, 0, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 0, + 0, 0, 0, 0, 0, 5, 6, 7, 0, 9, + 0, 0, 0, 10, 11, 0, 0, 0, 12, 274, + 13, 14, 15, 242, 243, 18, 19, 0, 0, 0, + 0, 0, 244, 245, 246, 23, 24, 25, 26, 0, + 0, 203, 0, 0, 0, 0, 0, 0, 272, 0, + 0, 32, 33, 34, 376, 36, 37, 38, 377, 40, + 0, 41, 42, 43, 44, 0, 45, 46, 47, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 378, 0, 0, + 379, 0, 0, 206, 52, 0, 53, 54, 0, 0, + 0, 0, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, + 0, 9, 0, 0, 0, 10, 11, 0, 0, 0, + 12, 274, 13, 14, 15, 242, 243, 18, 19, 0, + 0, 0, 0, 0, 244, 245, 246, 23, 24, 25, + 26, 0, 0, 203, 0, 0, 0, 0, 0, 0, + 272, 0, 0, 32, 33, 34, 376, 36, 37, 38, + 377, 40, 0, 41, 42, 43, 44, 0, 45, 46, + 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 379, 0, 0, 206, 52, 0, 53, 54, + 0, 0, 0, 0, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 0, 0, 0, 0, 0, 0, 5, + 6, 7, 0, 9, 0, 0, 0, 10, 11, 0, + 0, 0, 12, 274, 13, 14, 15, 242, 243, 18, + 19, 0, 0, 0, 0, 0, 244, 245, 246, 23, + 24, 25, 26, 0, 0, 203, 0, 0, 0, 0, + 0, 0, 272, 0, 0, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 0, 41, 42, 43, 44, 0, + 45, 46, 47, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 273, 0, 0, 326, 52, 0, + 53, 54, 0, 0, 0, 0, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 0, 0, 0, 0, 0, + 0, 5, 6, 7, 0, 9, 0, 0, 0, 10, + 11, 0, 0, 0, 12, 274, 13, 14, 15, 242, + 243, 18, 19, 0, 0, 0, 0, 0, 244, 245, + 246, 23, 24, 25, 26, 0, 0, 203, 0, 0, + 0, 0, 0, 0, 272, 0, 0, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 0, 41, 42, 43, + 44, 0, 45, 46, 47, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 902, 0, 0, 206, + 52, 0, 53, 54, 0, 0, 0, 0, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 0, 0, 0, + 0, 0, 0, 5, 6, 7, 0, 9, 0, 0, + 0, 10, 11, 0, 0, 0, 12, 274, 13, 14, + 15, 242, 243, 18, 19, 0, 0, 0, 0, 0, + 244, 245, 246, 23, 24, 25, 26, 0, 0, 203, + 0, 0, 0, 0, 0, 0, 272, 0, 0, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 0, 41, + 42, 43, 44, 0, 45, 46, 47, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 981, 0, + 0, 206, 52, 0, 53, 54, 0, 0, 0, 0, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 0, + 0, 0, 0, 0, 556, 557, 0, 0, 558, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 174, 175, 0, 0, 176, 177, 178, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 0, 192, 193, 564, 565, 0, 0, 566, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 174, 175, 0, 0, 176, 177, 178, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 0, 192, 193, 601, 565, 0, 0, 602, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 174, 175, 0, 0, 176, 177, 178, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 0, 192, 193, 616, 557, 0, 0, 617, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 174, 175, 0, 0, 176, 177, 178, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 0, 192, 193, 619, 565, 0, 0, 620, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 174, 175, 0, 0, 176, 177, 178, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 0, 192, 193, 643, 557, 0, 0, 644, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 174, 175, 0, 0, 176, 177, 178, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 0, 192, 193, 646, 565, 0, 0, 647, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 174, 175, 0, 0, 176, 177, 178, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 0, 192, 193, 732, 557, 0, 0, 733, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 174, 175, 0, 0, 176, 177, 178, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 0, 192, 193, 735, 565, 0, 0, 736, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 174, 175, 0, 0, 176, 177, 178, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 0, 192, 193, 742, 557, 0, 0, 743, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 174, 175, 0, 0, 176, 177, 178, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 0, 192, 193, 1013, 557, 0, 0, 1014, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 174, 175, 0, 0, 176, 177, 178, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 0, 192, 193, 1048, 557, 0, 0, 1049, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 174, 175, 0, 0, 176, 177, 178, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 0, 192, 193, 1051, 565, 0, 0, 1052, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 174, 175, 0, 0, 176, 177, 178, 179, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, + 181, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 0, 0, 343, 344, 0, 0, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 0, 192, 193, 0, 0, 0, 0, 0, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 345, 0, + 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 235 +}; + +#define yypact_value_is_default(yystate) \ + ((yystate) == (-817)) + +#define yytable_value_is_error(yytable_value) \ + ((yytable_value) == (-633)) + +static const yytype_int16 yycheck[] = +{ + 2, 57, 66, 98, 76, 22, 16, 17, 81, 28, + 20, 2, 8, 4, 27, 329, 29, 55, 224, 357, + 89, 8, 8, 92, 424, 69, 597, 618, 4, 578, + 266, 362, 28, 329, 270, 577, 674, 416, 234, 690, + 96, 28, 28, 81, 92, 424, 783, 475, 92, 655, + 51, 53, 54, 471, 645, 93, 94, 95, 2, 76, + 4, 57, 462, 259, 16, 17, 262, 379, 20, 792, + 1, 55, 16, 17, 444, 356, 20, 358, 13, 879, + 720, 69, 420, 25, 724, 510, 13, 65, 513, 25, + 87, 877, 16, 17, 13, 911, 20, 907, 63, 29, + 96, 99, 0, 521, 140, 254, 708, 51, 144, 13, + 63, 55, 25, 715, 63, 16, 17, 144, 87, 20, + 25, 402, 66, 13, 26, 123, 88, 89, 78, 53, + 92, 87, 783, 87, 89, 473, 56, 81, 419, 136, + 421, 792, 87, 734, 88, 89, 13, 112, 92, 93, + 94, 95, 53, 54, 745, 25, 37, 38, 944, 112, + 109, 116, 111, 900, 143, 137, 447, 136, 774, 775, + 741, 121, 144, 811, 812, 247, 25, 326, 749, 25, + 136, 135, 136, 113, 143, 139, 25, 25, 290, 120, + 292, 136, 294, 474, 143, 137, 298, 27, 998, 1009, + 26, 137, 275, 139, 139, 1021, 143, 142, 256, 144, + 137, 142, 256, 144, 1000, 142, 218, 144, 228, 956, + 230, 231, 224, 142, 137, 144, 626, 433, 951, 231, + 426, 133, 137, 661, 430, 143, 87, 275, 142, 435, + 144, 310, 311, 312, 313, 583, 625, 626, 1034, 900, + 133, 889, 142, 254, 144, 451, 907, 595, 28, 272, + 324, 252, 206, 144, 116, 329, 636, 137, 256, 139, + 695, 877, 234, 879, 236, 142, 228, 144, 230, 1016, + 780, 87, 594, 701, 228, 136, 230, 231, 137, 327, + 234, 137, 236, 933, 363, 364, 274, 241, 137, 137, + 951, 263, 137, 584, 228, 805, 230, 133, 252, 89, + 254, 413, 142, 139, 144, 596, 858, 365, 309, 263, + 748, 365, 750, 314, 520, 326, 116, 228, 26, 230, + 136, 275, 970, 309, 89, 116, 116, 381, 944, 945, + 139, 405, 406, 327, 102, 144, 87, 357, 310, 311, + 312, 313, 89, 315, 316, 357, 137, 661, 1009, 87, + 26, 116, 358, 87, 935, 309, 310, 311, 312, 313, + 314, 315, 316, 52, 25, 54, 55, 56, 57, 116, + 324, 89, 326, 327, 933, 329, 488, 87, 702, 87, + 25, 87, 998, 495, 1000, 136, 139, 89, 471, 730, + 324, 363, 364, 87, 640, 329, 402, 26, 136, 615, + 420, 135, 136, 357, 137, 359, 378, 56, 420, 363, + 364, 87, 441, 719, 116, 421, 997, 116, 1034, 26, + 432, 433, 90, 471, 378, 133, 136, 135, 136, 135, + 136, 139, 444, 639, 748, 441, 750, 89, 521, 137, + 137, 447, 136, 444, 441, 441, 144, 144, 137, 1050, + 89, 405, 406, 473, 475, 116, 137, 133, 87, 135, + 136, 473, 58, 873, 116, 89, 420, 2, 474, 4, + 137, 116, 63, 521, 70, 139, 137, 116, 560, 140, + 87, 16, 17, 144, 873, 20, 568, 52, 70, 63, + 444, 56, 137, 133, 142, 140, 144, 509, 510, 144, + 454, 513, 98, 99, 133, 416, 135, 136, 139, 52, + 139, 54, 55, 56, 57, 70, 51, 471, 109, 473, + 111, 603, 576, 577, 139, 87, 133, 123, 135, 136, + 140, 66, 139, 87, 561, 109, 590, 111, 112, 580, + 563, 747, 569, 51, 126, 127, 128, 116, 459, 87, + 766, 70, 143, 88, 89, 37, 38, 92, 641, 571, + 141, 767, 89, 583, 15, 89, 17, 521, 63, 56, + 134, 583, 778, 135, 136, 595, 603, 89, 584, 608, + 921, 135, 136, 595, 690, 137, 927, 112, 87, 116, + 596, 603, 116, 641, 137, 618, 112, 135, 136, 14, + 15, 63, 608, 615, 116, 124, 125, 126, 127, 128, + 137, 608, 608, 137, 109, 87, 111, 112, 701, 573, + 112, 575, 645, 112, 636, 137, 598, 709, 702, 583, + 70, 705, 706, 96, 716, 636, 135, 136, 712, 713, + 661, 595, 87, 597, 598, 579, 89, 109, 753, 111, + 112, 137, 114, 701, 63, 17, 56, 629, 737, 865, + 672, 740, 674, 135, 136, 89, 142, 690, 54, 690, + 876, 206, 63, 116, 25, 629, 140, 87, 1026, 65, + 66, 704, 636, 695, 738, 751, 792, 641, 729, 795, + 135, 136, 116, 228, 137, 230, 231, 134, 206, 234, + 109, 236, 111, 112, 716, 746, 241, 719, 720, 137, + 722, 734, 724, 137, 625, 87, 137, 252, 109, 254, + 111, 112, 745, 690, 63, 135, 136, 748, 263, 750, + 133, 137, 137, 241, 116, 143, 1027, 691, 137, 143, + 694, 137, 696, 137, 87, 751, 254, 701, 702, 87, + 139, 705, 706, 10, 766, 8, 139, 780, 712, 713, + 834, 809, 783, 135, 136, 737, 87, 13, 740, 848, + 109, 792, 111, 112, 309, 310, 311, 312, 313, 314, + 315, 316, 805, 737, 63, 719, 740, 741, 67, 324, + 89, 326, 135, 136, 329, 749, 116, 135, 136, 811, + 812, 907, 134, 909, 858, 52, 860, 137, 849, 676, + 851, 678, 89, 867, 135, 136, 52, 116, 326, 786, + 861, 137, 357, 790, 359, 866, 137, 137, 363, 364, + 109, 843, 111, 137, 846, 52, 137, 15, 137, 116, + 137, 141, 134, 378, 137, 951, 121, 953, 116, 137, + 137, 899, 958, 814, 815, 809, 137, 137, 142, 70, + 137, 690, 59, 60, 61, 62, 820, 10, 134, 10, + 405, 406, 920, 137, 85, 86, 848, 889, 118, 900, + 834, 54, 55, 90, 57, 420, 907, 9, 137, 930, + 931, 845, 65, 66, 848, 140, 137, 121, 852, 853, + 137, 56, 856, 1009, 137, 1011, 137, 70, 134, 444, + 137, 56, 1018, 124, 125, 126, 127, 128, 137, 454, + 10, 933, 85, 86, 52, 137, 54, 55, 56, 57, + 951, 137, 1038, 900, 137, 16, 17, 904, 473, 20, + 907, 137, 909, 137, 52, 899, 54, 55, 56, 57, + 134, 137, 110, 976, 1060, 996, 139, 786, 970, 139, + 123, 124, 125, 126, 127, 128, 920, 48, 49, 137, + 924, 454, 53, 54, 40, 41, 42, 43, 44, 93, + 95, 935, 1029, 91, 716, 66, 67, 774, 1009, 1030, + 690, 1032, 754, 1021, 948, 949, 1028, 101, 59, 96, + 298, 210, 941, 786, 965, 966, 1026, 961, 904, 783, + 971, 900, 973, 974, 1026, 399, 1028, 1029, -1, 886, + 887, 1027, -1, -1, 891, -1, 893, 1050, 895, -1, + -1, -1, -1, 987, -1, 989, -1, -1, 573, -1, + 575, 995, 1009, 997, 1011, -1, -1, -1, 583, 1016, + 52, 1018, 54, 55, 56, 57, 58, -1, 70, -1, + 595, -1, 597, 598, -1, 573, -1, 575, 70, -1, + -1, 900, 1026, 85, 86, 904, 690, -1, 907, -1, + 909, -1, 1043, 1044, 1045, 1046, -1, -1, -1, 91, + -1, -1, -1, 1060, 629, 97, 98, 99, -1, -1, + -1, 636, -1, -1, -1, 1066, -1, -1, -1, 121, + 122, 123, 124, 125, 126, 127, 128, -1, -1, -1, + -1, 123, -1, 204, 126, -1, 207, 208, 209, -1, + 211, -1, 2, -1, 4, -1, -1, 1004, 1005, 1006, + 1007, -1, 144, -1, -1, -1, -1, 228, -1, 230, + 231, -1, -1, -1, -1, -1, 691, -1, -1, 694, + -1, 696, -1, -1, -1, -1, -1, 702, -1, -1, + 705, 706, -1, -1, -1, -1, -1, 712, 713, -1, + 1009, 51, 1011, 691, -1, 55, 694, 1016, 696, 1018, + 52, 1058, 54, 55, 56, 57, -1, -1, -1, -1, + -1, -1, 737, -1, -1, 740, 741, -1, -1, -1, + -1, 81, -1, -1, 749, -1, -1, -1, -1, -1, + -1, -1, -1, 93, 94, 95, 96, -1, -1, 91, + -1, 1060, -1, -1, -1, 97, 52, -1, 54, 55, + 56, 57, -1, 324, -1, -1, -1, -1, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, -1, 346, 347, 348, 349, 350, + 351, 352, 353, 354, 355, 91, 357, -1, -1, -1, + -1, 97, -1, -1, -1, 820, 900, -1, -1, -1, + 904, -1, -1, 907, -1, 909, -1, -1, -1, 834, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 845, -1, 820, 848, -1, -1, -1, 852, 853, -1, + -1, 856, -1, -1, 405, 406, -1, -1, -1, -1, + -1, -1, -1, 414, 415, 416, 206, 845, 2, 420, + 4, 422, 423, 424, 852, 853, -1, 2, 856, 4, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 443, -1, -1, -1, -1, 448, -1, -1, + -1, 241, -1, -1, -1, -1, -1, -1, 459, -1, + -1, 462, 252, -1, 254, -1, -1, 51, -1, 924, + -1, 55, 473, -1, -1, 1009, 51, 1011, -1, -1, + 935, -1, 1016, -1, 1018, 275, -1, -1, -1, -1, + -1, -1, -1, 948, 949, -1, 924, 81, 499, -1, + -1, -1, -1, -1, -1, -1, 961, -1, -1, 93, + 94, 95, 96, 514, -1, -1, -1, -1, 93, 309, + 948, 949, -1, -1, 314, -1, 1060, -1, 2, -1, + 4, -1, 987, 961, 989, -1, 326, 327, -1, -1, + 995, -1, 997, -1, 545, -1, -1, -1, -1, -1, + -1, -1, 52, -1, 54, 55, 56, 57, 58, 987, + -1, 989, -1, -1, -1, -1, -1, 995, -1, 359, + 70, 1026, -1, -1, -1, -1, -1, 51, 579, -1, + -1, 55, 583, -1, -1, -1, -1, -1, -1, -1, + -1, 91, -1, -1, 595, -1, -1, 97, 98, 99, + -1, -1, -1, -1, -1, -1, -1, 81, 609, -1, + -1, 612, -1, -1, -1, -1, 2, -1, 4, 93, + 94, 95, 206, 123, 625, 626, 126, -1, -1, -1, + -1, 206, -1, -1, -1, -1, -1, -1, -1, 139, + -1, -1, -1, 52, -1, 54, 55, 56, 57, 58, + -1, -1, -1, -1, 444, -1, -1, 241, -1, -1, + -1, 70, -1, -1, 454, 51, 241, -1, 252, 670, + 254, -1, -1, -1, -1, -1, -1, 252, -1, 254, + -1, 471, 91, -1, -1, -1, -1, -1, 97, 98, + 99, 275, -1, -1, -1, -1, -1, 698, -1, -1, + -1, 702, 703, -1, 705, 706, -1, -1, -1, -1, + -1, 712, 713, -1, 123, -1, -1, 126, 719, -1, + -1, -1, -1, -1, -1, 309, -1, -1, -1, -1, + 314, 521, 206, -1, 309, -1, -1, -1, -1, 314, + -1, 54, 326, 327, -1, -1, -1, -1, -1, -1, + -1, 326, -1, -1, 329, 756, -1, -1, -1, -1, + 761, 762, -1, 764, 765, -1, -1, 241, -1, -1, + -1, -1, -1, -1, -1, 359, -1, -1, 252, -1, + 254, 782, -1, 573, 359, 575, -1, -1, -1, -1, + 52, -1, 54, 55, 56, 57, 58, -1, -1, -1, + -1, 275, -1, -1, -1, -1, -1, 597, 70, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 206, 822, -1, -1, -1, -1, -1, -1, -1, 91, + -1, -1, -1, 834, -1, 309, 98, 99, -1, -1, + 314, -1, -1, -1, -1, -1, 636, -1, -1, -1, + -1, 641, 326, 327, 855, 241, -1, -1, -1, -1, + 444, 123, -1, -1, -1, -1, 252, -1, 254, 444, + 454, 872, 873, -1, -1, -1, -1, -1, -1, 454, + -1, -1, -1, -1, -1, 359, -1, 471, -1, -1, + -1, 204, -1, -1, 207, 208, 209, -1, -1, -1, + -1, 691, -1, -1, 694, -1, 696, -1, -1, -1, + -1, 701, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 309, -1, -1, -1, -1, 314, -1, + -1, -1, -1, -1, -1, -1, -1, 521, -1, -1, + 326, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 741, -1, -1, -1, -1, -1, -1, -1, 749, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 444, -1, -1, 359, -1, -1, -1, -1, -1, 980, + 454, -1, -1, -1, -1, -1, -1, -1, -1, 573, + -1, 575, -1, -1, -1, -1, -1, 471, 573, -1, + 575, -1, -1, -1, -1, -1, -1, 44, -1, -1, + -1, 324, -1, 597, -1, -1, 329, -1, -1, 809, + -1, -1, 597, -1, -1, 1026, -1, -1, -1, -1, + 820, -1, -1, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, -1, 521, 85, 86, + -1, -1, 636, -1, -1, 845, -1, 641, 444, -1, + -1, 636, 852, 853, -1, -1, 856, -1, 454, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 117, -1, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, -1, -1, -1, -1, -1, -1, -1, 573, + 137, 575, 415, 416, -1, -1, -1, 691, -1, 899, + 694, 424, 696, -1, -1, -1, 691, 701, -1, 694, + -1, 696, -1, 597, -1, -1, -1, 702, -1, -1, + 920, -1, -1, -1, 924, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 935, 459, -1, -1, 462, + -1, -1, -1, -1, -1, -1, -1, 741, 948, 949, + -1, -1, 636, -1, -1, 749, 741, 641, -1, -1, + -1, 961, -1, -1, 749, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 573, -1, 575, + -1, -1, -1, -1, -1, -1, -1, 987, -1, 989, + -1, 514, -1, -1, -1, 995, -1, 997, 682, -1, + -1, 597, -1, -1, -1, -1, -1, 691, -1, -1, + 694, -1, 696, -1, -1, 809, -1, 701, -1, -1, + -1, -1, -1, -1, -1, -1, 820, 70, 71, 72, + 73, 74, 75, 76, 77, 820, 79, 80, -1, -1, + 636, -1, 85, 86, -1, -1, -1, -1, -1, -1, + -1, 845, -1, -1, -1, -1, 579, 741, 852, 853, + 845, -1, 856, -1, -1, 749, -1, 852, 853, -1, + -1, 856, -1, -1, -1, -1, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, 609, -1, -1, 612, + -1, -1, -1, -1, -1, 691, -1, -1, 694, -1, + 696, -1, 625, 626, -1, 899, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 809, 920, -1, -1, -1, + 924, -1, -1, -1, -1, 920, 820, -1, -1, 924, + -1, 935, -1, -1, -1, 741, -1, 670, -1, -1, + 935, -1, -1, 749, 948, 949, -1, -1, -1, -1, + -1, 845, -1, 948, 949, -1, -1, 961, 852, 853, + -1, -1, 856, -1, -1, 698, 961, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 987, -1, 989, 719, -1, -1, -1, + -1, 995, 987, 997, 989, -1, -1, -1, -1, -1, + 995, -1, 997, -1, -1, 899, -1, 70, 71, 72, + 73, 74, 75, 76, 820, -1, 79, 80, -1, -1, + -1, -1, 85, 86, -1, -1, 920, -1, -1, -1, + 924, -1, -1, -1, -1, -1, -1, -1, -1, 845, + -1, 935, -1, -1, -1, -1, 852, 853, -1, 782, + 856, -1, -1, -1, 948, 949, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, -1, 961, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 70, 71, 72, 73, 74, 75, 76, -1, 822, + 79, 80, -1, 987, -1, 989, 85, 86, -1, -1, + -1, 995, -1, 997, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 924, -1, + -1, -1, 855, -1, -1, -1, -1, -1, -1, 935, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 873, -1, 948, 949, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 961, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 987, -1, 989, -1, -1, -1, -1, -1, 995, + -1, 997, 0, 1, -1, 3, 4, 5, 6, 7, + -1, -1, -1, 11, 12, -1, -1, -1, 16, -1, + 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, + -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, -1, 64, 65, 66, -1, + 68, 69, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 88, -1, -1, 91, 92, -1, 94, 95, -1, 97, + -1, -1, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 0, -1, -1, -1, -1, -1, -1, -1, 8, + 9, 10, -1, -1, 13, 14, 15, -1, 17, -1, + -1, 129, 130, 131, -1, 44, -1, 26, 27, 28, + 29, -1, -1, -1, 142, -1, 144, -1, 37, 38, + -1, 40, 41, 42, 43, 44, -1, -1, -1, -1, + -1, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, -1, -1, 85, 86, -1, -1, + -1, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, -1, -1, 85, 86, 87, -1, + 89, 90, -1, -1, -1, -1, -1, 96, 117, -1, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + -1, 110, -1, -1, 113, -1, -1, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + -1, -1, -1, -1, 133, 134, 135, 136, 137, 0, + -1, 140, 141, 142, -1, 144, -1, 8, 9, 10, + -1, -1, 13, 14, 15, -1, 17, -1, -1, -1, + -1, 44, -1, -1, 25, -1, 27, 28, 29, -1, + -1, -1, -1, -1, -1, -1, 37, 38, -1, 40, + 41, 42, 43, 44, -1, -1, -1, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + -1, -1, 85, 86, -1, -1, -1, -1, -1, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, -1, -1, 85, 86, 87, -1, 89, 90, + -1, -1, -1, -1, 117, 96, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, -1, -1, -1, 110, + -1, -1, 113, -1, -1, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, -1, -1, + -1, -1, -1, 134, 135, 136, 137, 0, -1, 140, + 141, 142, -1, 144, -1, 8, 9, 10, -1, -1, + 13, 14, 15, -1, 17, -1, -1, -1, -1, -1, + -1, -1, 25, -1, 27, 28, 29, -1, -1, -1, + -1, -1, -1, -1, 37, 38, -1, 40, 41, 42, + 43, 44, -1, -1, -1, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, -1, -1, + 85, 86, -1, -1, -1, -1, -1, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + -1, -1, 85, 86, 87, -1, 89, 90, -1, -1, + -1, -1, 117, 96, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, -1, -1, -1, 110, -1, -1, + 113, -1, -1, 116, 117, 118, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, -1, -1, -1, -1, + -1, 134, 135, 136, 137, 0, -1, 140, 141, 142, + -1, 144, -1, 8, 9, 10, -1, -1, 13, 14, + 15, -1, 17, -1, -1, -1, -1, -1, -1, -1, + -1, 26, 27, 28, 29, -1, -1, -1, -1, -1, + -1, -1, 37, 38, -1, 40, 41, 42, 43, 44, + -1, -1, -1, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, -1, -1, 85, 86, + -1, -1, -1, -1, -1, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, -1, -1, + 85, 86, 87, -1, -1, 90, -1, -1, -1, -1, + -1, 96, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, -1, -1, -1, 110, -1, -1, 113, -1, + -1, -1, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, -1, -1, -1, -1, 133, 134, + 135, 136, 137, 0, -1, 140, 141, 142, -1, 144, + -1, 8, 9, 10, -1, -1, 13, 14, 15, -1, + 17, -1, -1, -1, -1, -1, -1, -1, -1, 26, + 27, 28, 29, -1, -1, -1, -1, -1, -1, -1, + 37, 38, -1, 40, 41, 42, 43, 44, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, -1, -1, 85, 86, + 87, -1, -1, 90, -1, -1, -1, -1, -1, 96, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 110, -1, -1, 113, -1, -1, -1, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, -1, -1, -1, -1, 133, 134, 135, 136, + 137, 0, -1, 140, 141, 142, -1, 144, -1, 8, + 9, 10, -1, -1, 13, 14, 15, -1, 17, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, + 29, -1, -1, -1, -1, -1, -1, -1, 37, 38, + -1, 40, 41, 42, 43, 44, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, -1, -1, 85, 86, 87, -1, + 89, 90, -1, -1, -1, -1, -1, 96, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 110, -1, -1, 113, -1, -1, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + -1, -1, -1, -1, -1, 134, 135, 136, 137, 0, + -1, 140, 141, 142, -1, 144, -1, 8, 9, 10, + -1, -1, 13, 14, 15, -1, 17, -1, -1, -1, + -1, -1, -1, -1, -1, 26, 27, 28, -1, -1, + -1, -1, -1, -1, -1, -1, 37, 38, -1, 40, + 41, 42, 43, 44, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, -1, -1, 85, 86, 87, -1, -1, 90, + -1, -1, -1, -1, -1, 96, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 110, + -1, -1, -1, -1, -1, -1, 117, -1, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, -1, -1, + -1, -1, 133, 134, 135, 136, 137, 0, 139, 140, + 141, 142, -1, 144, -1, 8, 9, 10, -1, -1, + 13, 14, 15, -1, 17, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 27, 28, 29, -1, -1, -1, + -1, -1, -1, -1, 37, 38, -1, 40, 41, 42, + 43, 44, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + -1, -1, 85, 86, 87, -1, -1, 90, -1, -1, + -1, -1, -1, 96, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 110, -1, -1, + 113, -1, -1, -1, 117, 118, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, -1, -1, -1, -1, + -1, 134, 135, 136, 137, 0, -1, 140, 141, 142, + -1, 144, -1, 8, 9, 10, -1, -1, 13, 14, + 15, -1, 17, -1, -1, -1, -1, -1, -1, -1, + -1, 26, 27, 28, -1, -1, -1, -1, -1, -1, + -1, -1, 37, 38, -1, 40, 41, 42, 43, 44, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, -1, -1, + 85, 86, 87, -1, -1, 90, -1, -1, -1, -1, + -1, 96, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 110, -1, -1, -1, -1, + -1, -1, 117, -1, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, -1, -1, -1, -1, 133, 134, + 135, 136, 137, 0, 139, 140, 141, 142, -1, 144, + -1, 8, 9, 10, -1, -1, 13, 14, 15, -1, + 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 27, 28, -1, -1, -1, -1, -1, -1, -1, -1, + 37, 38, -1, 40, 41, 42, 43, 44, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, -1, -1, 85, 86, + 87, -1, -1, 90, -1, -1, -1, -1, -1, 96, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 110, -1, -1, -1, -1, -1, -1, + 117, -1, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, -1, -1, -1, -1, -1, 134, 135, 136, + 137, 0, 139, 140, 141, 142, -1, 144, -1, 8, + 9, 10, -1, -1, -1, 14, 15, -1, 17, -1, + -1, -1, -1, -1, -1, -1, -1, 26, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 37, 38, + -1, 40, 41, 42, 43, 44, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, -1, -1, 85, 86, 87, -1, + 89, -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, -1, 116, 117, -1, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + -1, -1, -1, -1, 133, 134, 135, 136, 137, 0, + -1, 140, -1, 142, -1, 144, -1, 8, 9, 10, + -1, -1, -1, 14, 15, -1, 17, -1, 0, -1, + -1, -1, -1, -1, -1, -1, 8, 9, 10, -1, + -1, 13, 14, 15, -1, 17, 37, 38, -1, 40, + 41, 42, 43, 44, 26, 27, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 37, 38, -1, 40, 41, + 42, 43, 44, -1, -1, -1, -1, -1, -1, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, -1, -1, 85, 86, 87, -1, 89, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 87, -1, -1, -1, 110, + -1, -1, -1, -1, -1, 116, 117, -1, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 110, -1, + -1, -1, -1, 134, 135, 136, 137, -1, -1, 140, + -1, 142, -1, 144, -1, -1, -1, -1, -1, -1, + -1, 133, 134, -1, 136, -1, -1, 139, 140, -1, + 142, 1, 144, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, -1, -1, 15, 16, -1, 18, 19, + 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, + 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, + -1, -1, -1, -1, -1, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, -1, 64, 65, 66, -1, 68, 69, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 88, -1, + -1, 91, 92, -1, 94, 95, -1, 97, -1, -1, + 100, 101, 102, 103, 104, 105, 106, 107, 108, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 129, + 130, 131, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 142, 1, 144, 3, 4, 5, 6, 7, + -1, -1, 10, 11, 12, -1, 14, 15, 16, -1, + 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, + -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, -1, 64, 65, 66, -1, + 68, 69, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 88, -1, -1, 91, 92, -1, 94, 95, -1, 97, + -1, -1, 100, 101, 102, 103, 104, 105, 106, 107, + 108, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 129, 130, 131, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 142, 1, 144, 3, 4, 5, + 6, 7, -1, -1, 10, 11, 12, -1, -1, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, -1, + -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, + 36, -1, -1, 39, -1, -1, -1, -1, -1, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, -1, 64, 65, + 66, -1, 68, 69, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 88, -1, -1, 91, 92, -1, 94, 95, + -1, 97, -1, -1, 100, 101, 102, 103, 104, 105, + 106, 107, 108, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 129, 130, 131, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 142, 1, 144, 3, + 4, 5, 6, 7, -1, -1, 10, 11, 12, -1, + -1, 15, 16, -1, 18, 19, 20, 21, 22, 23, + 24, -1, -1, -1, -1, -1, 30, 31, 32, 33, + 34, 35, 36, -1, -1, 39, -1, -1, -1, -1, + -1, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, -1, + 64, 65, 66, -1, 68, 69, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 88, -1, -1, 91, 92, -1, + 94, 95, -1, 97, -1, -1, 100, 101, 102, 103, + 104, 105, 106, 107, 108, -1, -1, -1, -1, -1, + -1, -1, -1, 1, -1, 3, 4, 5, 6, 7, + -1, 9, 10, 11, 12, 129, 130, 131, 16, -1, + 18, 19, 20, 21, 22, 23, 24, -1, 142, -1, + 144, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, -1, 64, 65, 66, -1, + 68, 69, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 88, -1, -1, 91, 92, -1, 94, 95, -1, 97, + -1, -1, 100, 101, 102, 103, 104, 105, 106, 107, + 108, -1, -1, -1, -1, -1, -1, -1, -1, 1, + -1, 3, 4, 5, 6, 7, -1, -1, -1, 11, + 12, 129, 130, 131, 16, -1, 18, 19, 20, 21, + 22, 23, 24, -1, 142, -1, 144, -1, 30, 31, + 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, + -1, -1, -1, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, -1, 64, 65, 66, -1, 68, 69, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 88, -1, -1, 91, + 92, -1, 94, 95, -1, 97, -1, -1, 100, 101, + 102, 103, 104, 105, 106, 107, 108, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 129, 130, 131, + -1, -1, -1, -1, -1, -1, -1, -1, 140, -1, + 142, 1, 144, 3, 4, 5, 6, 7, -1, -1, + -1, 11, 12, -1, -1, -1, 16, -1, 18, 19, + 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, + 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, + -1, -1, -1, -1, -1, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, -1, 64, 65, 66, -1, 68, 69, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 88, -1, + -1, 91, 92, -1, 94, 95, -1, 97, -1, -1, + 100, 101, 102, 103, 104, 105, 106, 107, 108, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 129, + 130, 131, -1, -1, -1, -1, -1, -1, -1, -1, + 140, -1, 142, 1, 144, 3, 4, 5, 6, 7, + -1, -1, -1, 11, 12, -1, -1, -1, 16, -1, + 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, + -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, -1, 64, 65, 66, -1, + 68, 69, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 88, -1, -1, 91, 92, -1, 94, 95, -1, 97, + -1, -1, 100, 101, 102, 103, 104, 105, 106, 107, + 108, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 129, 130, 131, -1, -1, 134, 1, -1, 3, + 4, 5, 6, 7, 142, -1, 144, 11, 12, -1, + -1, -1, 16, -1, 18, 19, 20, 21, 22, 23, + 24, -1, -1, -1, -1, -1, 30, 31, 32, 33, + 34, 35, 36, -1, -1, 39, -1, -1, -1, -1, + -1, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, -1, + 64, 65, 66, -1, 68, 69, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 88, -1, -1, 91, 92, -1, + 94, 95, -1, 97, -1, -1, 100, 101, 102, 103, + 104, 105, 106, 107, 108, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 129, 130, 131, -1, -1, + 134, -1, -1, -1, -1, -1, -1, -1, 142, 1, + 144, 3, 4, 5, 6, 7, -1, -1, 10, 11, + 12, -1, -1, -1, 16, -1, 18, 19, 20, 21, + 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, + 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, + -1, -1, -1, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, -1, 64, 65, 66, -1, 68, 69, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 88, -1, -1, 91, + 92, -1, 94, 95, -1, 97, -1, -1, 100, 101, + 102, 103, 104, 105, 106, 107, 108, -1, -1, -1, + -1, -1, -1, -1, -1, 1, -1, 3, 4, 5, + 6, 7, -1, -1, -1, 11, 12, 129, 130, 131, + 16, -1, 18, 19, 20, 21, 22, 23, 24, -1, + 142, -1, 144, -1, 30, 31, 32, 33, 34, 35, + 36, -1, -1, 39, -1, -1, -1, -1, -1, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, -1, 64, 65, + 66, -1, 68, 69, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 88, -1, -1, 91, 92, -1, 94, 95, + -1, 97, -1, -1, 100, 101, 102, 103, 104, 105, + 106, 107, 108, -1, 110, -1, -1, -1, -1, -1, + -1, -1, -1, 3, 4, 5, -1, 7, -1, -1, + -1, 11, 12, 129, 130, 131, 16, -1, 18, 19, + 20, 21, 22, 23, 24, -1, 142, -1, 144, -1, + 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, + -1, -1, -1, -1, -1, -1, 46, -1, -1, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, -1, 64, 65, 66, -1, 68, 69, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 88, -1, + -1, 91, 92, -1, 94, 95, -1, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, + 4, 5, -1, 7, -1, -1, -1, 11, 12, 129, + 130, 131, 16, -1, 18, 19, 20, 21, 22, 23, + 24, -1, -1, -1, 144, -1, 30, 31, 32, 33, + 34, 35, 36, -1, -1, 39, -1, -1, -1, -1, + -1, -1, 46, -1, -1, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, -1, + 64, 65, 66, -1, 68, 69, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 88, -1, -1, 91, 92, -1, + 94, 95, -1, -1, -1, -1, 100, 101, 102, 103, + 104, 105, 106, 107, 108, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 3, 4, 5, -1, 7, + -1, -1, -1, 11, 12, 129, 130, 131, 16, -1, + 18, 19, 20, 21, 22, 23, 24, -1, 142, -1, + 144, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, -1, 46, -1, + -1, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, -1, 64, 65, 66, -1, + 68, 69, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 88, -1, -1, 91, 92, -1, 94, 95, -1, -1, + -1, -1, 100, 101, 102, 103, 104, 105, 106, 107, + 108, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 3, 4, 5, 6, 7, -1, -1, -1, 11, + 12, 129, 130, 131, 16, -1, 18, 19, 20, 21, + 22, 23, 24, -1, -1, -1, 144, -1, 30, 31, + 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, + -1, -1, -1, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, -1, 64, 65, 66, -1, 68, 69, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 88, -1, -1, 91, + 92, -1, 94, 95, -1, 97, -1, -1, 100, 101, + 102, 103, 104, 105, 106, 107, 108, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3, 4, 5, + 6, 7, -1, -1, -1, 11, 12, 129, 130, 131, + 16, -1, 18, 19, 20, 21, 22, 23, 24, -1, + 142, -1, -1, -1, 30, 31, 32, 33, 34, 35, + 36, -1, -1, 39, -1, -1, -1, -1, -1, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, -1, 64, 65, + 66, -1, 68, 69, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 88, -1, -1, 91, 92, -1, 94, 95, + -1, 97, -1, -1, 100, 101, 102, 103, 104, 105, + 106, 107, 108, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 129, 130, 131, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 142, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, -1, -1, -1, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, -1, -1, -1, -1, -1, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 68, 69, 70, 71, 72, 73, 74, 75, + 76, -1, -1, 79, 80, -1, -1, 83, 84, 85, + 86, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 97, 98, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, -1, 130, 131, -1, -1, -1, -1, + -1, -1, 138, 139, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, -1, -1, + -1, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, -1, -1, -1, -1, -1, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 68, + 69, 70, 71, 72, 73, 74, 75, 76, -1, -1, + 79, 80, -1, -1, 83, 84, 85, 86, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 97, 98, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + -1, 130, 131, -1, -1, -1, -1, -1, -1, 138, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, -1, -1, -1, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, -1, -1, -1, + -1, -1, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, -1, 56, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 68, 69, 70, 71, 72, + 73, 74, 75, 76, -1, -1, 79, 80, -1, -1, + 83, 84, 85, 86, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 97, 98, -1, -1, 101, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, -1, 130, 131, -1, + -1, -1, -1, -1, -1, 138, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + -1, -1, -1, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, -1, -1, -1, -1, -1, 45, 46, + 47, 48, 49, 50, 51, 52, 53, -1, -1, 56, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 68, 69, 70, 71, 72, 73, 74, 75, 76, + -1, -1, 79, 80, -1, -1, 83, 84, 85, 86, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 97, 98, -1, -1, 101, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, -1, 130, 131, -1, -1, -1, -1, -1, + -1, 138, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, -1, -1, -1, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, + -1, -1, -1, -1, 45, 46, 47, 48, 49, 50, + 51, 52, 53, -1, -1, 56, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 68, 69, 70, + 71, 72, 73, 74, 75, 76, -1, -1, 79, 80, + -1, -1, 83, 84, 85, 86, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 97, 98, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, -1, 130, + 131, 3, 4, 5, -1, 7, -1, 138, -1, 11, + 12, -1, -1, -1, 16, -1, 18, 19, 20, 21, + 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, + 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, + -1, -1, -1, -1, 46, -1, -1, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, -1, 64, 65, 66, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 88, -1, -1, 91, + 92, -1, 94, 95, -1, -1, -1, -1, 100, 101, + 102, 103, 104, 105, 106, 107, 108, -1, -1, -1, + -1, -1, -1, 3, 4, 5, -1, 7, -1, -1, + -1, 11, 12, -1, -1, -1, 16, 129, 18, 19, + 20, 21, 22, 23, 24, 137, -1, -1, -1, -1, + 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, + -1, -1, -1, -1, -1, -1, 46, -1, -1, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, -1, 64, 65, 66, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 88, -1, + -1, 91, 92, -1, 94, 95, -1, -1, -1, -1, + 100, 101, 102, 103, 104, 105, 106, 107, 108, -1, + -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, + -1, -1, -1, 11, 12, -1, -1, -1, 16, 129, + 18, 19, 20, 21, 22, 23, 24, 137, -1, -1, + -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, -1, 64, 65, 66, -1, + 68, 69, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 88, -1, -1, 91, 92, -1, 94, 95, -1, 97, + -1, -1, 100, 101, 102, 103, 104, 105, 106, 107, + 108, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 3, 4, 5, -1, 7, -1, -1, -1, 11, + 12, 129, 130, 131, 16, -1, 18, 19, 20, 21, + 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, + 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, + -1, -1, -1, -1, 46, -1, -1, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, -1, 64, 65, 66, -1, 68, 69, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 88, -1, -1, 91, + 92, -1, 94, 95, -1, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3, 4, 5, + 6, 7, -1, -1, -1, 11, 12, 129, 130, 131, + 16, -1, 18, 19, 20, 21, 22, 23, 24, -1, + -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, + 36, -1, -1, 39, -1, -1, -1, -1, -1, 45, + 46, -1, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, -1, 64, 65, + 66, -1, 68, 69, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 88, -1, -1, 91, 92, -1, 94, 95, + -1, 97, -1, -1, 100, 101, 102, 103, 104, 105, + 106, 107, 108, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3, 4, 5, -1, 7, -1, -1, + -1, 11, 12, 129, 130, 131, 16, -1, 18, 19, + 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, + 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, + -1, -1, -1, -1, -1, -1, 46, -1, -1, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, -1, 64, 65, 66, -1, 68, 69, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 88, -1, + -1, 91, 92, -1, 94, 95, -1, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, + 4, 5, -1, 7, -1, -1, -1, 11, 12, 129, + 130, 131, 16, -1, 18, 19, 20, 21, 22, 23, + 24, -1, -1, -1, -1, -1, 30, 31, 32, 33, + 34, 35, 36, -1, -1, 39, -1, -1, -1, -1, + -1, -1, 46, -1, -1, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, -1, + 64, 65, 66, -1, 68, 69, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 88, -1, -1, 91, 92, -1, + 94, 95, -1, 97, 98, -1, 100, 101, 102, 103, + 104, 105, 106, 107, 108, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 3, 4, 5, -1, 7, + -1, -1, -1, 11, 12, 129, 130, 131, 16, -1, + 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, + -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, -1, 46, -1, + -1, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, -1, 64, 65, 66, -1, + 68, 69, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 88, -1, -1, 91, 92, -1, 94, 95, -1, -1, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 3, 4, 5, -1, 7, -1, -1, -1, 11, + 12, 129, 130, 131, 16, -1, 18, 19, 20, 21, + 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, + 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, + -1, -1, -1, -1, 46, -1, -1, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, -1, 64, 65, 66, -1, 68, 69, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 88, -1, -1, 91, + 92, -1, 94, 95, -1, 97, 98, -1, 100, 101, + 102, 103, 104, 105, 106, 107, 108, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3, 4, 5, + -1, 7, -1, -1, -1, 11, 12, 129, 130, 131, + 16, -1, 18, 19, 20, 21, 22, 23, 24, -1, + -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, + 36, -1, -1, 39, -1, -1, -1, -1, -1, -1, + 46, -1, -1, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, -1, 64, 65, + 66, -1, 68, 69, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 88, -1, -1, 91, 92, -1, 94, 95, + -1, -1, 98, -1, 100, 101, 102, 103, 104, 105, + 106, 107, 108, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3, 4, 5, -1, 7, -1, -1, + -1, 11, 12, 129, 130, 131, 16, -1, 18, 19, + 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, + 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, + -1, -1, -1, -1, -1, -1, 46, -1, -1, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, -1, 64, 65, 66, -1, 68, 69, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 88, -1, + -1, 91, 92, -1, 94, 95, -1, 97, -1, -1, + 100, 101, 102, 103, 104, 105, 106, 107, 108, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, + 4, 5, -1, 7, -1, -1, -1, 11, 12, 129, + 130, 131, 16, -1, 18, 19, 20, 21, 22, 23, + 24, -1, -1, -1, -1, -1, 30, 31, 32, 33, + 34, 35, 36, -1, -1, 39, -1, -1, -1, -1, + -1, -1, 46, -1, -1, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, -1, + 64, 65, 66, -1, 68, 69, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 88, -1, -1, 91, 92, -1, + 94, 95, -1, 97, -1, -1, 100, 101, 102, 103, + 104, 105, 106, 107, 108, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 3, 4, 5, -1, 7, + -1, -1, -1, 11, 12, 129, 130, 131, 16, -1, + 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, + -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, -1, 46, -1, + -1, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, -1, 64, 65, 66, -1, + 68, 69, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 88, -1, -1, 91, 92, -1, 94, 95, -1, 97, + -1, -1, 100, 101, 102, 103, 104, 105, 106, 107, + 108, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 3, 4, 5, -1, 7, -1, -1, -1, 11, + 12, 129, 130, 131, 16, -1, 18, 19, 20, 21, + 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, + 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, + -1, -1, -1, -1, 46, -1, -1, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, -1, 64, 65, 66, -1, 68, 69, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 88, -1, -1, 91, + 92, -1, 94, 95, -1, 97, -1, -1, 100, 101, + 102, 103, 104, 105, 106, 107, 108, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3, 4, 5, + -1, 7, -1, -1, -1, 11, 12, 129, 130, 131, + 16, -1, 18, 19, 20, 21, 22, 23, 24, -1, + -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, + 36, -1, -1, 39, -1, -1, -1, -1, -1, -1, + 46, -1, -1, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, -1, 64, 65, + 66, -1, 68, 69, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 88, -1, -1, 91, 92, -1, 94, 95, + -1, 97, -1, -1, 100, 101, 102, 103, 104, 105, + 106, 107, 108, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3, 4, 5, -1, 7, -1, -1, + -1, 11, 12, 129, 130, 131, 16, -1, 18, 19, + 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, + 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, + -1, -1, -1, -1, -1, -1, 46, -1, -1, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, -1, 64, 65, 66, -1, 68, 69, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 88, -1, + -1, 91, 92, -1, 94, 95, -1, -1, -1, -1, + 100, 101, 102, 103, 104, 105, 106, 107, 108, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, + 4, 5, -1, 7, -1, -1, -1, 11, 12, 129, + 130, 131, 16, -1, 18, 19, 20, 21, 22, 23, + 24, -1, -1, -1, -1, -1, 30, 31, 32, 33, + 34, 35, 36, -1, -1, 39, -1, -1, -1, -1, + -1, -1, 46, -1, -1, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, -1, + 64, 65, 66, -1, 68, 69, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 88, -1, -1, 91, 92, -1, + 94, 95, -1, -1, -1, -1, 100, 101, 102, 103, + 104, 105, 106, 107, 108, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 3, 4, 5, -1, 7, + -1, -1, -1, 11, 12, 129, 130, 131, 16, -1, + 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, + -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, -1, 46, -1, + -1, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, -1, 64, 65, 66, -1, + 68, 69, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 88, -1, -1, 91, 92, -1, 94, 95, -1, -1, + -1, -1, 100, 101, 102, 103, 104, 105, 106, 107, + 108, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 3, 4, 5, -1, 7, -1, -1, -1, 11, + 12, 129, 130, 131, 16, -1, 18, 19, 20, 21, + 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, + 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, + -1, -1, -1, -1, 46, -1, -1, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, -1, 64, 65, 66, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 88, -1, -1, 91, + 92, -1, 94, 95, -1, 97, -1, -1, 100, 101, + 102, 103, 104, 105, 106, 107, 108, -1, -1, -1, + -1, -1, -1, 3, 4, 5, -1, 7, -1, -1, + -1, 11, 12, -1, -1, -1, 16, 129, 18, 19, + 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, + 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, + -1, -1, -1, -1, -1, -1, 46, -1, -1, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, -1, 64, 65, 66, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 88, -1, + -1, 91, 92, -1, 94, 95, -1, 97, -1, -1, + 100, 101, 102, 103, 104, 105, 106, 107, 108, -1, + -1, -1, -1, -1, -1, 3, 4, 5, -1, 7, + -1, -1, -1, 11, 12, -1, -1, -1, 16, 129, + 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, + -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, + -1, 39, -1, -1, -1, -1, -1, -1, 46, -1, + -1, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, 61, 62, -1, 64, 65, 66, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 85, -1, -1, + 88, -1, -1, 91, 92, -1, 94, 95, -1, -1, + -1, -1, 100, 101, 102, 103, 104, 105, 106, 107, + 108, -1, -1, -1, -1, -1, -1, 3, 4, 5, + -1, 7, -1, -1, -1, 11, 12, -1, -1, -1, + 16, 129, 18, 19, 20, 21, 22, 23, 24, -1, + -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, + 36, -1, -1, 39, -1, -1, -1, -1, -1, -1, + 46, -1, -1, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, -1, 64, 65, + 66, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 88, -1, -1, 91, 92, -1, 94, 95, + -1, -1, -1, -1, 100, 101, 102, 103, 104, 105, + 106, 107, 108, -1, -1, -1, -1, -1, -1, 3, + 4, 5, -1, 7, -1, -1, -1, 11, 12, -1, + -1, -1, 16, 129, 18, 19, 20, 21, 22, 23, + 24, -1, -1, -1, -1, -1, 30, 31, 32, 33, + 34, 35, 36, -1, -1, 39, -1, -1, -1, -1, + -1, -1, 46, -1, -1, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, -1, + 64, 65, 66, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 88, -1, -1, 91, 92, -1, + 94, 95, -1, -1, -1, -1, 100, 101, 102, 103, + 104, 105, 106, 107, 108, -1, -1, -1, -1, -1, + -1, 3, 4, 5, -1, 7, -1, -1, -1, 11, + 12, -1, -1, -1, 16, 129, 18, 19, 20, 21, + 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, + 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, + -1, -1, -1, -1, 46, -1, -1, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, -1, 64, 65, 66, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 88, -1, -1, 91, + 92, -1, 94, 95, -1, -1, -1, -1, 100, 101, + 102, 103, 104, 105, 106, 107, 108, -1, -1, -1, + -1, -1, -1, 3, 4, 5, -1, 7, -1, -1, + -1, 11, 12, -1, -1, -1, 16, 129, 18, 19, + 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, + 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, + -1, -1, -1, -1, -1, -1, 46, -1, -1, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, -1, 64, 65, 66, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 88, -1, + -1, 91, 92, -1, 94, 95, -1, -1, -1, -1, + 100, 101, 102, 103, 104, 105, 106, 107, 108, -1, + -1, -1, -1, -1, 52, 53, -1, -1, 56, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 129, + 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, + -1, 79, 80, -1, -1, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 52, 53, -1, -1, 56, -1, + 138, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, + -1, 79, 80, -1, -1, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 52, 53, -1, -1, 56, -1, + 138, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, + -1, 79, 80, -1, -1, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 52, 53, -1, -1, 56, -1, + 138, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, + -1, 79, 80, -1, -1, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 52, 53, -1, -1, 56, -1, + 138, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, + -1, 79, 80, -1, -1, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 52, 53, -1, -1, 56, -1, + 138, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, + -1, 79, 80, -1, -1, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 52, 53, -1, -1, 56, -1, + 138, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, + -1, 79, 80, -1, -1, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 52, 53, -1, -1, 56, -1, + 138, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, + -1, 79, 80, -1, -1, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 52, 53, -1, -1, 56, -1, + 138, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, + -1, 79, 80, -1, -1, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 52, 53, -1, -1, 56, -1, + 138, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, + -1, 79, 80, -1, -1, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 52, 53, -1, -1, 56, -1, + 138, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, + -1, 79, 80, -1, -1, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 52, 53, -1, -1, 56, -1, + 138, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, + -1, 79, 80, -1, -1, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, + 98, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, 52, 53, -1, -1, 56, -1, + 138, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 68, 69, 70, 71, 72, 73, 74, 75, 76, -1, + -1, 79, 80, -1, -1, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, + 98, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, -1, -1, 85, 86, -1, -1, + -1, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, -1, 130, 131, -1, -1, -1, -1, -1, -1, + 138, -1, -1, -1, -1, -1, -1, -1, 117, -1, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 144 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint16 yystos[] = +{ + 0, 146, 147, 0, 1, 3, 4, 5, 6, 7, + 11, 12, 16, 18, 19, 20, 21, 22, 23, 24, + 30, 31, 32, 33, 34, 35, 36, 39, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 59, 60, 61, 62, 64, 65, 66, 68, 69, + 88, 91, 92, 94, 95, 97, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 129, 130, 131, 148, 149, + 150, 157, 159, 160, 162, 163, 166, 167, 168, 170, + 171, 172, 174, 175, 185, 202, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 258, 259, 273, + 274, 275, 276, 277, 278, 279, 282, 284, 285, 298, + 300, 301, 302, 303, 304, 305, 306, 307, 341, 352, + 150, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 56, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 79, 80, 83, 84, 85, 86, + 97, 98, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 130, 131, 138, 178, 179, 180, 181, 183, + 184, 298, 300, 39, 58, 88, 91, 97, 98, 99, + 102, 130, 167, 175, 185, 189, 194, 197, 199, 221, + 303, 304, 306, 307, 339, 340, 194, 194, 139, 195, + 196, 139, 191, 195, 139, 144, 346, 54, 180, 346, + 151, 133, 21, 22, 30, 31, 32, 166, 185, 221, + 185, 56, 1, 47, 91, 153, 154, 155, 157, 169, + 170, 352, 204, 205, 190, 199, 339, 352, 189, 338, + 339, 352, 46, 88, 129, 137, 174, 202, 221, 303, + 304, 307, 249, 250, 54, 55, 57, 178, 289, 299, + 288, 289, 290, 143, 280, 143, 286, 143, 283, 143, + 287, 302, 162, 185, 185, 142, 144, 345, 350, 351, + 40, 41, 42, 43, 44, 37, 38, 26, 133, 191, + 195, 264, 28, 256, 116, 137, 91, 97, 171, 116, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 85, 86, 117, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, 87, 135, 136, 203, + 160, 161, 161, 208, 210, 161, 345, 351, 88, 168, + 175, 221, 237, 303, 304, 307, 52, 56, 85, 88, + 176, 177, 221, 303, 304, 307, 177, 33, 34, 35, + 36, 49, 50, 51, 52, 56, 139, 178, 305, 336, + 87, 136, 344, 264, 276, 89, 89, 137, 189, 56, + 189, 189, 189, 288, 116, 90, 137, 198, 352, 87, + 135, 136, 89, 89, 137, 198, 194, 346, 347, 194, + 193, 194, 199, 339, 352, 160, 347, 160, 54, 65, + 66, 158, 139, 186, 133, 153, 87, 136, 89, 157, + 156, 169, 140, 345, 351, 347, 347, 160, 141, 137, + 144, 349, 137, 349, 134, 349, 346, 56, 302, 171, + 173, 137, 87, 135, 136, 251, 63, 109, 111, 112, + 291, 112, 291, 112, 67, 291, 112, 112, 281, 291, + 112, 63, 112, 112, 112, 281, 112, 63, 112, 70, + 142, 150, 161, 161, 161, 161, 157, 160, 160, 266, + 265, 96, 164, 257, 97, 162, 189, 199, 200, 201, + 169, 137, 174, 137, 159, 162, 175, 185, 189, 201, + 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, + 185, 185, 185, 185, 185, 187, 185, 185, 185, 185, + 185, 185, 185, 185, 185, 185, 52, 53, 56, 183, + 263, 342, 343, 193, 52, 53, 56, 183, 262, 342, + 152, 153, 13, 233, 350, 233, 161, 161, 345, 17, + 267, 56, 87, 135, 136, 25, 160, 52, 56, 176, + 1, 120, 308, 350, 87, 135, 136, 217, 337, 218, + 344, 52, 56, 342, 162, 185, 162, 185, 182, 114, + 185, 189, 97, 189, 197, 339, 52, 56, 193, 52, + 56, 340, 347, 140, 347, 137, 137, 347, 180, 207, + 185, 148, 134, 342, 342, 185, 133, 347, 155, 206, + 339, 137, 173, 52, 56, 193, 52, 56, 52, 54, + 55, 56, 57, 58, 70, 91, 97, 98, 99, 123, + 126, 139, 254, 312, 314, 315, 316, 317, 318, 319, + 320, 321, 324, 325, 326, 327, 330, 331, 332, 333, + 334, 293, 292, 143, 291, 143, 143, 143, 185, 78, + 121, 244, 245, 352, 244, 165, 244, 189, 137, 347, + 173, 137, 116, 44, 185, 89, 89, 191, 195, 261, + 346, 348, 89, 89, 191, 195, 260, 10, 232, 8, + 269, 352, 153, 13, 153, 27, 234, 350, 234, 267, + 199, 232, 52, 56, 193, 52, 56, 212, 215, 350, + 309, 214, 52, 56, 176, 193, 152, 160, 139, 310, + 311, 219, 191, 192, 195, 352, 44, 180, 189, 189, + 198, 89, 89, 348, 89, 89, 339, 160, 134, 148, + 347, 349, 171, 348, 91, 97, 238, 239, 240, 316, + 314, 252, 116, 137, 313, 189, 137, 335, 352, 52, + 137, 335, 137, 313, 52, 137, 313, 52, 294, 54, + 55, 57, 297, 307, 241, 243, 246, 317, 319, 320, + 322, 323, 326, 328, 329, 332, 334, 346, 153, 153, + 244, 153, 97, 189, 173, 185, 346, 162, 185, 162, + 185, 164, 191, 141, 89, 162, 185, 162, 185, 164, + 192, 189, 201, 270, 352, 15, 236, 352, 14, 235, + 236, 236, 209, 211, 232, 137, 233, 348, 161, 350, + 161, 152, 348, 232, 347, 314, 152, 314, 178, 264, + 256, 185, 89, 137, 347, 134, 240, 137, 316, 137, + 347, 246, 253, 189, 312, 318, 330, 332, 321, 326, + 334, 319, 327, 332, 317, 319, 295, 246, 121, 116, + 137, 242, 88, 221, 137, 335, 335, 137, 242, 137, + 242, 142, 10, 134, 153, 10, 189, 118, 162, 185, + 90, 271, 352, 153, 9, 272, 352, 161, 232, 232, + 153, 153, 189, 153, 234, 216, 350, 232, 347, 232, + 350, 220, 347, 239, 137, 97, 238, 140, 29, 113, + 255, 137, 313, 137, 313, 335, 137, 313, 137, 313, + 313, 296, 121, 221, 241, 329, 332, 56, 87, 322, + 326, 319, 328, 332, 319, 52, 247, 248, 315, 134, + 188, 88, 175, 221, 303, 304, 307, 233, 153, 233, + 232, 232, 236, 267, 268, 213, 152, 310, 137, 239, + 137, 316, 153, 153, 319, 332, 319, 319, 153, 137, + 242, 137, 242, 52, 56, 335, 137, 242, 137, 242, + 242, 137, 346, 185, 56, 87, 135, 136, 153, 153, + 153, 232, 152, 239, 137, 10, 134, 313, 137, 313, + 313, 313, 110, 319, 332, 319, 319, 248, 52, 56, + 193, 52, 56, 269, 235, 232, 232, 239, 319, 242, + 137, 242, 242, 242, 348, 313, 319, 242 +}; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. However, + YYFAIL appears to be in use. Nevertheless, it is formally deprecated + in Bison 2.4.2's NEWS entry, where a plan to phase it out is + discussed. */ + +#define YYFAIL goto yyerrlab +#if defined YYFAIL + /* This is here to suppress warnings from the GCC cpp's + -Wunused-macros. Normally we don't worry about that warning, but + some users do, and we want to make it easy for users to remove + YYFAIL uses, which will produce warnings from Bison 2.5. */ +#endif + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (1); \ + goto yybackup; \ + } \ + else \ + { \ + parser_yyerror (parser, YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (YYID (0)) + + +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (YYID (N)) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (YYID (0)) +#endif + + +/* This macro is provided for backward compatibility. */ + +#ifndef YY_LOCATION_PRINT +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, YYLEX_PARAM) +#else +# define YYLEX yylex (&yylval, parser) +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (YYID (0)) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value, parser); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (YYID (0)) + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser) +#else +static void +yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; + struct parser_params *parser; +#endif +{ + if (!yyvaluep) + return; + YYUSE (parser); +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# else + YYUSE (yyoutput); +# endif + switch (yytype) + { + default: + break; + } +} + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser) +#else +static void +yy_symbol_print (yyoutput, yytype, yyvaluep, parser) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; + struct parser_params *parser; +#endif +{ + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser); + YYFPRINTF (yyoutput, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) +#else +static void +yy_stack_print (yybottom, yytop) + yytype_int16 *yybottom; + yytype_int16 *yytop; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (YYID (0)) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser) +#else +static void +yy_reduce_print (yyvsp, yyrule, parser) + YYSTYPE *yyvsp; + int yyrule; + struct parser_params *parser; +#endif +{ + int yynrhs = yyr2[yyrule]; + int yyi; + unsigned long int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + &(yyvsp[(yyi + 1) - (yynrhs)]) + , parser); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyvsp, Rule, parser); \ +} while (YYID (0)) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +#ifndef yydebug +int yydebug; +#endif +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static YYSIZE_T +yystrlen (const char *yystr) +#else +static YYSIZE_T +yystrlen (yystr) + const char *yystr; +#endif +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static char * +yystpcpy (char *yydest, const char *yysrc) +#else +static char * +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +#endif +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP. + + Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return 2 if the + required number of bytes is too large to store. */ +static int +yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, + yytype_int16 *yyssp, int yytoken) +{ + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); + YYSIZE_T yysize = yysize0; + YYSIZE_T yysize1; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + /* Internationalized format string. */ + const char *yyformat = 0; + /* Arguments of yyformat. */ + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + /* Number of reported tokens (one for the "unexpected", one per + "expected"). */ + int yycount = 0; + + /* There are many possibilities here to consider: + - Assume YYFAIL is not used. It's too flawed to consider. See + <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> + for details. YYERROR is fine as it does not invoke this + function. + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + if (yytoken != YYEMPTY) + { + int yyn = yypact[*yyssp]; + yyarg[yycount++] = yytname[yytoken]; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + break; + } + yyarg[yycount++] = yytname[yyx]; + yysize1 = yysize + yytnamerr (0, yytname[yyx]); + if (! (yysize <= yysize1 + && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + } + } + } + + switch (yycount) + { +# define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +# undef YYCASE_ + } + + yysize1 = yysize + yystrlen (yyformat); + if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return 1; + } + + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyformat += 2; + } + else + { + yyp++; + yyformat++; + } + } + return 0; +} +#endif /* YYERROR_VERBOSE */ + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser) +#else +static void +yydestruct (yymsg, yytype, yyvaluep, parser) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; + struct parser_params *parser; +#endif +{ + YYUSE (yyvaluep); + YYUSE (parser); + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + + +/* Prevent warnings from -Wmissing-prototypes. */ +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (struct parser_params *parser); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void *YYPARSE_PARAM) +#else +int +yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +#endif +#else /* ! YYPARSE_PARAM */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (struct parser_params *parser) +#else +int +yyparse (parser) + struct parser_params *parser; +#endif +#endif +{ +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + + /* Number of syntax errors so far. */ + int yynerrs; + + int yystate; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + + /* The stacks and their tools: + `yyss': related to states. + `yyvs': related to semantic values. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs; + YYSTYPE *yyvsp; + + YYSIZE_T yystacksize; + + int yyn; + int yyresult; + /* Lookahead token as an internal (translated) token number. */ + int yytoken; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + yytoken = 0; + yyss = yyssa; + yyvs = yyvsa; + yystacksize = YYINITDEPTH; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token. */ + yychar = YYEMPTY; + + yystate = yyn; + *++yyvsp = yylval; + + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: + +/* Line 1806 of yacc.c */ +#line 901 "parse.y" + { + lex_state = EXPR_BEG; + /*%%%*/ + local_push(compile_for_eval || rb_parse_in_main()); + /*% + local_push(0); + %*/ + } + break; + + case 3: + +/* Line 1806 of yacc.c */ +#line 910 "parse.y" + { + /*%%%*/ + if ((yyvsp[(2) - (2)].node) && !compile_for_eval) { + /* last expression should not be void */ + if (nd_type((yyvsp[(2) - (2)].node)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].node)); + else { + NODE *node = (yyvsp[(2) - (2)].node); + while (node->nd_next) { + node = node->nd_next; + } + void_expr(node->nd_head); + } + } + ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].node))); + /*% + $$ = $2; + parser->result = dispatch1(program, $$); + %*/ + local_pop(); + } + break; + + case 4: + +/* Line 1806 of yacc.c */ +#line 933 "parse.y" + { + /*%%%*/ + void_stmts((yyvsp[(1) - (2)].node)); + fixup_nodes(&deferred_nodes); + /*% + %*/ + (yyval.node) = (yyvsp[(1) - (2)].node); + } + break; + + case 5: + +/* Line 1806 of yacc.c */ +#line 944 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_BEGIN(0); + /*% + $$ = dispatch2(stmts_add, dispatch0(stmts_new), + dispatch0(void_stmt)); + %*/ + } + break; + + case 6: + +/* Line 1806 of yacc.c */ +#line 953 "parse.y" + { + /*%%%*/ + (yyval.node) = newline_node((yyvsp[(1) - (1)].node)); + /*% + $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1); + %*/ + } + break; + + case 7: + +/* Line 1806 of yacc.c */ +#line 961 "parse.y" + { + /*%%%*/ + (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node))); + /*% + $$ = dispatch2(stmts_add, $1, $3); + %*/ + } + break; + + case 8: + +/* Line 1806 of yacc.c */ +#line 969 "parse.y" + { + (yyval.node) = remove_begin((yyvsp[(2) - (2)].node)); + } + break; + + case 10: + +/* Line 1806 of yacc.c */ +#line 976 "parse.y" + { + /*%%%*/ + /* local_push(0); */ + /*% + %*/ + } + break; + + case 11: + +/* Line 1806 of yacc.c */ +#line 983 "parse.y" + { + /*%%%*/ + ruby_eval_tree_begin = block_append(ruby_eval_tree_begin, + (yyvsp[(4) - (5)].node)); + /* NEW_PREEXE($4)); */ + /* local_pop(); */ + (yyval.node) = NEW_BEGIN(0); + /*% + $$ = dispatch1(BEGIN, $4); + %*/ + } + break; + + case 12: + +/* Line 1806 of yacc.c */ +#line 1000 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(1) - (4)].node); + if ((yyvsp[(2) - (4)].node)) { + (yyval.node) = NEW_RESCUE((yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].node), (yyvsp[(3) - (4)].node)); + } + else if ((yyvsp[(3) - (4)].node)) { + rb_warn0("else without rescue is useless"); + (yyval.node) = block_append((yyval.node), (yyvsp[(3) - (4)].node)); + } + if ((yyvsp[(4) - (4)].node)) { + if ((yyval.node)) { + (yyval.node) = NEW_ENSURE((yyval.node), (yyvsp[(4) - (4)].node)); + } + else { + (yyval.node) = block_append((yyvsp[(4) - (4)].node), NEW_NIL()); + } + } + fixpos((yyval.node), (yyvsp[(1) - (4)].node)); + /*% + $$ = dispatch4(bodystmt, + escape_Qundef($1), + escape_Qundef($2), + escape_Qundef($3), + escape_Qundef($4)); + %*/ + } + break; + + case 13: + +/* Line 1806 of yacc.c */ +#line 1030 "parse.y" + { + /*%%%*/ + void_stmts((yyvsp[(1) - (2)].node)); + fixup_nodes(&deferred_nodes); + /*% + %*/ + (yyval.node) = (yyvsp[(1) - (2)].node); + } + break; + + case 14: + +/* Line 1806 of yacc.c */ +#line 1041 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_BEGIN(0); + /*% + $$ = dispatch2(stmts_add, dispatch0(stmts_new), + dispatch0(void_stmt)); + %*/ + } + break; + + case 15: + +/* Line 1806 of yacc.c */ +#line 1050 "parse.y" + { + /*%%%*/ + (yyval.node) = newline_node((yyvsp[(1) - (1)].node)); + /*% + $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1); + %*/ + } + break; + + case 16: + +/* Line 1806 of yacc.c */ +#line 1058 "parse.y" + { + /*%%%*/ + (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node))); + /*% + $$ = dispatch2(stmts_add, $1, $3); + %*/ + } + break; + + case 17: + +/* Line 1806 of yacc.c */ +#line 1066 "parse.y" + { + (yyval.node) = remove_begin((yyvsp[(2) - (2)].node)); + } + break; + + case 18: + +/* Line 1806 of yacc.c */ +#line 1072 "parse.y" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + } + break; + + case 19: + +/* Line 1806 of yacc.c */ +#line 1076 "parse.y" + { + yyerror("BEGIN is permitted only at toplevel"); + /*%%%*/ + /* local_push(0); */ + /*% + %*/ + } + break; + + case 20: + +/* Line 1806 of yacc.c */ +#line 1084 "parse.y" + { + /*%%%*/ + ruby_eval_tree_begin = block_append(ruby_eval_tree_begin, + (yyvsp[(4) - (5)].node)); + /* NEW_PREEXE($4)); */ + /* local_pop(); */ + (yyval.node) = NEW_BEGIN(0); + /*% + $$ = dispatch1(BEGIN, $4); + %*/ + } + break; + + case 21: + +/* Line 1806 of yacc.c */ +#line 1096 "parse.y" + {lex_state = EXPR_FNAME;} + break; + + case 22: + +/* Line 1806 of yacc.c */ +#line 1097 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_ALIAS((yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].node)); + /*% + $$ = dispatch2(alias, $2, $4); + %*/ + } + break; + + case 23: + +/* Line 1806 of yacc.c */ +#line 1105 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].id)); + /*% + $$ = dispatch2(var_alias, $2, $3); + %*/ + } + break; + + case 24: + +/* Line 1806 of yacc.c */ +#line 1113 "parse.y" + { + /*%%%*/ + char buf[2]; + buf[0] = '$'; + buf[1] = (char)(yyvsp[(3) - (3)].node)->nd_nth; + (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), rb_intern2(buf, 2)); + /*% + $$ = dispatch2(var_alias, $2, $3); + %*/ + } + break; + + case 25: + +/* Line 1806 of yacc.c */ +#line 1124 "parse.y" + { + /*%%%*/ + yyerror("can't make alias for the number variables"); + (yyval.node) = NEW_BEGIN(0); + /*% + $$ = dispatch2(var_alias, $2, $3); + $$ = dispatch1(alias_error, $$); + ripper_error(); + %*/ + } + break; + + case 26: + +/* Line 1806 of yacc.c */ +#line 1135 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (2)].node); + /*% + $$ = dispatch1(undef, $2); + %*/ + } + break; + + case 27: + +/* Line 1806 of yacc.c */ +#line 1143 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_IF(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0); + fixpos((yyval.node), (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch2(if_mod, $3, $1); + %*/ + } + break; + + case 28: + +/* Line 1806 of yacc.c */ +#line 1152 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_UNLESS(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0); + fixpos((yyval.node), (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch2(unless_mod, $3, $1); + %*/ + } + break; + + case 29: + +/* Line 1806 of yacc.c */ +#line 1161 "parse.y" + { + /*%%%*/ + if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) { + (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0); + } + else { + (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1); + } + /*% + $$ = dispatch2(while_mod, $3, $1); + %*/ + } + break; + + case 30: + +/* Line 1806 of yacc.c */ +#line 1174 "parse.y" + { + /*%%%*/ + if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) { + (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0); + } + else { + (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1); + } + /*% + $$ = dispatch2(until_mod, $3, $1); + %*/ + } + break; + + case 31: + +/* Line 1806 of yacc.c */ +#line 1187 "parse.y" + { + /*%%%*/ + NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].node)), 0); + (yyval.node) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].node)), resq, 0); + /*% + $$ = dispatch2(rescue_mod, $1, $3); + %*/ + } + break; + + case 32: + +/* Line 1806 of yacc.c */ +#line 1196 "parse.y" + { + if (in_def || in_single) { + rb_warn0("END in method; use at_exit"); + } + /*%%%*/ + (yyval.node) = NEW_POSTEXE(NEW_NODE( + NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].node) /* body */, 0 /* args */)); + /*% + $$ = dispatch1(END, $3); + %*/ + } + break; + + case 34: + +/* Line 1806 of yacc.c */ +#line 1209 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(3) - (3)].node)); + (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node); + (yyval.node) = (yyvsp[(1) - (3)].node); + /*% + $$ = dispatch2(massign, $1, $3); + %*/ + } + break; + + case 35: + +/* Line 1806 of yacc.c */ +#line 1219 "parse.y" + { + value_expr((yyvsp[(3) - (3)].node)); + (yyval.node) = new_op_assign((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].node)); + } + break; + + case 36: + +/* Line 1806 of yacc.c */ +#line 1224 "parse.y" + { + /*%%%*/ + NODE *args; + + value_expr((yyvsp[(6) - (6)].node)); + if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY(); + args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node)); + if ((yyvsp[(5) - (6)].id) == tOROP) { + (yyvsp[(5) - (6)].id) = 0; + } + else if ((yyvsp[(5) - (6)].id) == tANDOP) { + (yyvsp[(5) - (6)].id) = 1; + } + (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args); + fixpos((yyval.node), (yyvsp[(1) - (6)].node)); + /*% + $$ = dispatch2(aref_field, $1, escape_Qundef($3)); + $$ = dispatch3(opassign, $$, $5, $6); + %*/ + } + break; + + case 37: + +/* Line 1806 of yacc.c */ +#line 1245 "parse.y" + { + value_expr((yyvsp[(5) - (5)].node)); + (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node)); + } + break; + + case 38: + +/* Line 1806 of yacc.c */ +#line 1250 "parse.y" + { + value_expr((yyvsp[(5) - (5)].node)); + (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node)); + } + break; + + case 39: + +/* Line 1806 of yacc.c */ +#line 1255 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_COLON2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id)); + (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node)); + /*% + $$ = dispatch2(const_path_field, $1, $3); + $$ = dispatch3(opassign, $$, $4, $5); + %*/ + } + break; + + case 40: + +/* Line 1806 of yacc.c */ +#line 1265 "parse.y" + { + value_expr((yyvsp[(5) - (5)].node)); + (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ID2SYM(idCOLON2), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node)); + } + break; + + case 41: + +/* Line 1806 of yacc.c */ +#line 1270 "parse.y" + { + /*%%%*/ + rb_backref_error((yyvsp[(1) - (3)].node)); + (yyval.node) = NEW_BEGIN(0); + /*% + $$ = dispatch2(assign, dispatch1(var_field, $1), $3); + $$ = dispatch1(assign_error, $$); + ripper_error(); + %*/ + } + break; + + case 42: + +/* Line 1806 of yacc.c */ +#line 1281 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(3) - (3)].node)); + (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch2(assign, $1, $3); + %*/ + } + break; + + case 43: + +/* Line 1806 of yacc.c */ +#line 1290 "parse.y" + { + /*%%%*/ + (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node); + (yyval.node) = (yyvsp[(1) - (3)].node); + /*% + $$ = dispatch2(massign, $1, $3); + %*/ + } + break; + + case 45: + +/* Line 1806 of yacc.c */ +#line 1302 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(3) - (3)].node)); + (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch2(assign, $1, $3); + %*/ + } + break; + + case 46: + +/* Line 1806 of yacc.c */ +#line 1311 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(3) - (3)].node)); + (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch2(assign, $1, $3); + %*/ + } + break; + + case 48: + +/* Line 1806 of yacc.c */ +#line 1324 "parse.y" + { + /*%%%*/ + (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ripper_intern("and"), $3); + %*/ + } + break; + + case 49: + +/* Line 1806 of yacc.c */ +#line 1332 "parse.y" + { + /*%%%*/ + (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ripper_intern("or"), $3); + %*/ + } + break; + + case 50: + +/* Line 1806 of yacc.c */ +#line 1340 "parse.y" + { + /*%%%*/ + (yyval.node) = call_uni_op(cond((yyvsp[(3) - (3)].node)), '!'); + /*% + $$ = dispatch2(unary, ripper_intern("not"), $3); + %*/ + } + break; + + case 51: + +/* Line 1806 of yacc.c */ +#line 1348 "parse.y" + { + /*%%%*/ + (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!'); + /*% + $$ = dispatch2(unary, ripper_id2sym('!'), $2); + %*/ + } + break; + + case 53: + +/* Line 1806 of yacc.c */ +#line 1359 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(1) - (1)].node)); + (yyval.node) = (yyvsp[(1) - (1)].node); + if (!(yyval.node)) (yyval.node) = NEW_NIL(); + /*% + $$ = $1; + %*/ + } + break; + + case 57: + +/* Line 1806 of yacc.c */ +#line 1376 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node)); + /*% + $$ = dispatch3(call, $1, $2, $3); + $$ = method_arg($$, $4); + %*/ + } + break; + + case 58: + +/* Line 1806 of yacc.c */ +#line 1387 "parse.y" + { + (yyvsp[(1) - (1)].vars) = dyna_push(); + /*%%%*/ + (yyval.num) = ruby_sourceline; + /*% + %*/ + } + break; + + case 59: + +/* Line 1806 of yacc.c */ +#line 1397 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node)); + nd_set_line((yyval.node), (yyvsp[(2) - (5)].num)); + /*% + $$ = dispatch2(brace_block, escape_Qundef($3), $4); + %*/ + dyna_pop((yyvsp[(1) - (5)].vars)); + } + break; + + case 60: + +/* Line 1806 of yacc.c */ +#line 1409 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_FCALL((yyvsp[(1) - (1)].id), 0); + nd_set_line((yyval.node), tokline); + /*% + %*/ + } + break; + + case 61: + +/* Line 1806 of yacc.c */ +#line 1419 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(1) - (2)].node); + (yyval.node)->nd_args = (yyvsp[(2) - (2)].node); + /*% + $$ = dispatch2(command, $1, $2); + %*/ + } + break; + + case 62: + +/* Line 1806 of yacc.c */ +#line 1428 "parse.y" + { + /*%%%*/ + block_dup_check((yyvsp[(2) - (3)].node),(yyvsp[(3) - (3)].node)); + (yyvsp[(1) - (3)].node)->nd_args = (yyvsp[(2) - (3)].node); + (yyvsp[(3) - (3)].node)->nd_iter = (yyvsp[(1) - (3)].node); + (yyval.node) = (yyvsp[(3) - (3)].node); + fixpos((yyval.node), (yyvsp[(1) - (3)].node)); + /*% + $$ = dispatch2(command, $1, $2); + $$ = method_add_block($$, $3); + %*/ + } + break; + + case 63: + +/* Line 1806 of yacc.c */ +#line 1441 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node)); + fixpos((yyval.node), (yyvsp[(1) - (4)].node)); + /*% + $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4); + %*/ + } + break; + + case 64: + +/* Line 1806 of yacc.c */ +#line 1450 "parse.y" + { + /*%%%*/ + block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node)); + (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node)); + (yyval.node) = (yyvsp[(5) - (5)].node); + fixpos((yyval.node), (yyvsp[(1) - (5)].node)); + /*% + $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4); + $$ = method_add_block($$, $5); + %*/ + } + break; + + case 65: + +/* Line 1806 of yacc.c */ +#line 1462 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node)); + fixpos((yyval.node), (yyvsp[(1) - (4)].node)); + /*% + $$ = dispatch4(command_call, $1, ID2SYM(idCOLON2), $3, $4); + %*/ + } + break; + + case 66: + +/* Line 1806 of yacc.c */ +#line 1471 "parse.y" + { + /*%%%*/ + block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node)); + (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node)); + (yyval.node) = (yyvsp[(5) - (5)].node); + fixpos((yyval.node), (yyvsp[(1) - (5)].node)); + /*% + $$ = dispatch4(command_call, $1, ID2SYM(idCOLON2), $3, $4); + $$ = method_add_block($$, $5); + %*/ + } + break; + + case 67: + +/* Line 1806 of yacc.c */ +#line 1483 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node)); + fixpos((yyval.node), (yyvsp[(2) - (2)].node)); + /*% + $$ = dispatch1(super, $2); + %*/ + } + break; + + case 68: + +/* Line 1806 of yacc.c */ +#line 1492 "parse.y" + { + /*%%%*/ + (yyval.node) = new_yield((yyvsp[(2) - (2)].node)); + fixpos((yyval.node), (yyvsp[(2) - (2)].node)); + /*% + $$ = dispatch1(yield, $2); + %*/ + } + break; + + case 69: + +/* Line 1806 of yacc.c */ +#line 1501 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].node))); + /*% + $$ = dispatch1(return, $2); + %*/ + } + break; + + case 70: + +/* Line 1806 of yacc.c */ +#line 1509 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].node))); + /*% + $$ = dispatch1(break, $2); + %*/ + } + break; + + case 71: + +/* Line 1806 of yacc.c */ +#line 1517 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].node))); + /*% + $$ = dispatch1(next, $2); + %*/ + } + break; + + case 73: + +/* Line 1806 of yacc.c */ +#line 1528 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (3)].node); + /*% + $$ = dispatch1(mlhs_paren, $2); + %*/ + } + break; + + case 75: + +/* Line 1806 of yacc.c */ +#line 1539 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].node)), 0); + /*% + $$ = dispatch1(mlhs_paren, $2); + %*/ + } + break; + + case 76: + +/* Line 1806 of yacc.c */ +#line 1549 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0); + /*% + $$ = $1; + %*/ + } + break; + + case 77: + +/* Line 1806 of yacc.c */ +#line 1557 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN(list_append((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node)), 0); + /*% + $$ = mlhs_add($1, $2); + %*/ + } + break; + + case 78: + +/* Line 1806 of yacc.c */ +#line 1565 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + /*% + $$ = mlhs_add_star($1, $3); + %*/ + } + break; + + case 79: + +/* Line 1806 of yacc.c */ +#line 1573 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG((yyvsp[(3) - (5)].node),(yyvsp[(5) - (5)].node))); + /*% + $1 = mlhs_add_star($1, $3); + $$ = mlhs_add($1, $5); + %*/ + } + break; + + case 80: + +/* Line 1806 of yacc.c */ +#line 1582 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN((yyvsp[(1) - (2)].node), -1); + /*% + $$ = mlhs_add_star($1, Qnil); + %*/ + } + break; + + case 81: + +/* Line 1806 of yacc.c */ +#line 1590 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), NEW_POSTARG(-1, (yyvsp[(4) - (4)].node))); + /*% + $1 = mlhs_add_star($1, Qnil); + $$ = mlhs_add($1, $4); + %*/ + } + break; + + case 82: + +/* Line 1806 of yacc.c */ +#line 1599 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN(0, (yyvsp[(2) - (2)].node)); + /*% + $$ = mlhs_add_star(mlhs_new(), $2); + %*/ + } + break; + + case 83: + +/* Line 1806 of yacc.c */ +#line 1607 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].node),(yyvsp[(4) - (4)].node))); + /*% + $2 = mlhs_add_star(mlhs_new(), $2); + $$ = mlhs_add($2, $4); + %*/ + } + break; + + case 84: + +/* Line 1806 of yacc.c */ +#line 1616 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN(0, -1); + /*% + $$ = mlhs_add_star(mlhs_new(), Qnil); + %*/ + } + break; + + case 85: + +/* Line 1806 of yacc.c */ +#line 1624 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node))); + /*% + $$ = mlhs_add_star(mlhs_new(), Qnil); + $$ = mlhs_add($$, $3); + %*/ + } + break; + + case 87: + +/* Line 1806 of yacc.c */ +#line 1636 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (3)].node); + /*% + $$ = dispatch1(mlhs_paren, $2); + %*/ + } + break; + + case 88: + +/* Line 1806 of yacc.c */ +#line 1646 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_LIST((yyvsp[(1) - (2)].node)); + /*% + $$ = mlhs_add(mlhs_new(), $1); + %*/ + } + break; + + case 89: + +/* Line 1806 of yacc.c */ +#line 1654 "parse.y" + { + /*%%%*/ + (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node)); + /*% + $$ = mlhs_add($1, $2); + %*/ + } + break; + + case 90: + +/* Line 1806 of yacc.c */ +#line 1664 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node)); + /*% + $$ = mlhs_add(mlhs_new(), $1); + %*/ + } + break; + + case 91: + +/* Line 1806 of yacc.c */ +#line 1672 "parse.y" + { + /*%%%*/ + (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + /*% + $$ = mlhs_add($1, $3); + %*/ + } + break; + + case 92: + +/* Line 1806 of yacc.c */ +#line 1682 "parse.y" + { + (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0); + } + break; + + case 93: + +/* Line 1806 of yacc.c */ +#line 1686 "parse.y" + { + (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0); + } + break; + + case 94: + +/* Line 1806 of yacc.c */ +#line 1690 "parse.y" + { + /*%%%*/ + (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); + /*% + $$ = dispatch2(aref_field, $1, escape_Qundef($3)); + %*/ + } + break; + + case 95: + +/* Line 1806 of yacc.c */ +#line 1698 "parse.y" + { + /*%%%*/ + (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)); + /*% + $$ = dispatch3(field, $1, ripper_id2sym('.'), $3); + %*/ + } + break; + + case 96: + +/* Line 1806 of yacc.c */ +#line 1706 "parse.y" + { + /*%%%*/ + (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)); + /*% + $$ = dispatch2(const_path_field, $1, $3); + %*/ + } + break; + + case 97: + +/* Line 1806 of yacc.c */ +#line 1714 "parse.y" + { + /*%%%*/ + (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)); + /*% + $$ = dispatch3(field, $1, ripper_id2sym('.'), $3); + %*/ + } + break; + + case 98: + +/* Line 1806 of yacc.c */ +#line 1722 "parse.y" + { + /*%%%*/ + if (in_def || in_single) + yyerror("dynamic constant assignment"); + (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id))); + /*% + $$ = dispatch2(const_path_field, $1, $3); + if (in_def || in_single) { + $$ = dispatch1(assign_error, $$); + ripper_error(); + } + %*/ + } + break; + + case 99: + +/* Line 1806 of yacc.c */ +#line 1736 "parse.y" + { + /*%%%*/ + if (in_def || in_single) + yyerror("dynamic constant assignment"); + (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id))); + /*% + $$ = dispatch1(top_const_field, $2); + if (in_def || in_single) { + $$ = dispatch1(assign_error, $$); + ripper_error(); + } + %*/ + } + break; + + case 100: + +/* Line 1806 of yacc.c */ +#line 1750 "parse.y" + { + /*%%%*/ + rb_backref_error((yyvsp[(1) - (1)].node)); + (yyval.node) = NEW_BEGIN(0); + /*% + $$ = dispatch1(var_field, $1); + $$ = dispatch1(assign_error, $$); + ripper_error(); + %*/ + } + break; + + case 101: + +/* Line 1806 of yacc.c */ +#line 1763 "parse.y" + { + (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0); + /*%%%*/ + if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0); + /*% + $$ = dispatch1(var_field, $$); + %*/ + } + break; + + case 102: + +/* Line 1806 of yacc.c */ +#line 1772 "parse.y" + { + (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0); + /*%%%*/ + if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0); + /*% + $$ = dispatch1(var_field, $$); + %*/ + } + break; + + case 103: + +/* Line 1806 of yacc.c */ +#line 1781 "parse.y" + { + /*%%%*/ + (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); + /*% + $$ = dispatch2(aref_field, $1, escape_Qundef($3)); + %*/ + } + break; + + case 104: + +/* Line 1806 of yacc.c */ +#line 1789 "parse.y" + { + /*%%%*/ + (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)); + /*% + $$ = dispatch3(field, $1, ripper_id2sym('.'), $3); + %*/ + } + break; + + case 105: + +/* Line 1806 of yacc.c */ +#line 1797 "parse.y" + { + /*%%%*/ + (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)); + /*% + $$ = dispatch3(field, $1, ID2SYM(idCOLON2), $3); + %*/ + } + break; + + case 106: + +/* Line 1806 of yacc.c */ +#line 1805 "parse.y" + { + /*%%%*/ + (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)); + /*% + $$ = dispatch3(field, $1, ripper_id2sym('.'), $3); + %*/ + } + break; + + case 107: + +/* Line 1806 of yacc.c */ +#line 1813 "parse.y" + { + /*%%%*/ + if (in_def || in_single) + yyerror("dynamic constant assignment"); + (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id))); + /*% + $$ = dispatch2(const_path_field, $1, $3); + if (in_def || in_single) { + $$ = dispatch1(assign_error, $$); + ripper_error(); + } + %*/ + } + break; + + case 108: + +/* Line 1806 of yacc.c */ +#line 1827 "parse.y" + { + /*%%%*/ + if (in_def || in_single) + yyerror("dynamic constant assignment"); + (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id))); + /*% + $$ = dispatch1(top_const_field, $2); + if (in_def || in_single) { + $$ = dispatch1(assign_error, $$); + ripper_error(); + } + %*/ + } + break; + + case 109: + +/* Line 1806 of yacc.c */ +#line 1841 "parse.y" + { + /*%%%*/ + rb_backref_error((yyvsp[(1) - (1)].node)); + (yyval.node) = NEW_BEGIN(0); + /*% + $$ = dispatch1(assign_error, $1); + ripper_error(); + %*/ + } + break; + + case 110: + +/* Line 1806 of yacc.c */ +#line 1853 "parse.y" + { + /*%%%*/ + yyerror("class/module name must be CONSTANT"); + /*% + $$ = dispatch1(class_name_error, $1); + ripper_error(); + %*/ + } + break; + + case 112: + +/* Line 1806 of yacc.c */ +#line 1865 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id)); + /*% + $$ = dispatch1(top_const_ref, $2); + %*/ + } + break; + + case 113: + +/* Line 1806 of yacc.c */ +#line 1873 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_COLON2(0, (yyval.node)); + /*% + $$ = dispatch1(const_ref, $1); + %*/ + } + break; + + case 114: + +/* Line 1806 of yacc.c */ +#line 1881 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)); + /*% + $$ = dispatch2(const_path_ref, $1, $3); + %*/ + } + break; + + case 118: + +/* Line 1806 of yacc.c */ +#line 1894 "parse.y" + { + lex_state = EXPR_ENDFN; + (yyval.id) = (yyvsp[(1) - (1)].id); + } + break; + + case 119: + +/* Line 1806 of yacc.c */ +#line 1899 "parse.y" + { + lex_state = EXPR_ENDFN; + /*%%%*/ + (yyval.id) = (yyvsp[(1) - (1)].id); + /*% + $$ = $1; + %*/ + } + break; + + case 122: + +/* Line 1806 of yacc.c */ +#line 1914 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id))); + /*% + $$ = dispatch1(symbol_literal, $1); + %*/ + } + break; + + case 124: + +/* Line 1806 of yacc.c */ +#line 1925 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_UNDEF((yyvsp[(1) - (1)].node)); + /*% + $$ = rb_ary_new3(1, $1); + %*/ + } + break; + + case 125: + +/* Line 1806 of yacc.c */ +#line 1932 "parse.y" + {lex_state = EXPR_FNAME;} + break; + + case 126: + +/* Line 1806 of yacc.c */ +#line 1933 "parse.y" + { + /*%%%*/ + (yyval.node) = block_append((yyvsp[(1) - (4)].node), NEW_UNDEF((yyvsp[(4) - (4)].node))); + /*% + rb_ary_push($1, $4); + %*/ + } + break; + + case 127: + +/* Line 1806 of yacc.c */ +#line 1942 "parse.y" + { ifndef_ripper((yyval.id) = '|'); } + break; + + case 128: + +/* Line 1806 of yacc.c */ +#line 1943 "parse.y" + { ifndef_ripper((yyval.id) = '^'); } + break; + + case 129: + +/* Line 1806 of yacc.c */ +#line 1944 "parse.y" + { ifndef_ripper((yyval.id) = '&'); } + break; + + case 130: + +/* Line 1806 of yacc.c */ +#line 1945 "parse.y" + { ifndef_ripper((yyval.id) = tCMP); } + break; + + case 131: + +/* Line 1806 of yacc.c */ +#line 1946 "parse.y" + { ifndef_ripper((yyval.id) = tEQ); } + break; + + case 132: + +/* Line 1806 of yacc.c */ +#line 1947 "parse.y" + { ifndef_ripper((yyval.id) = tEQQ); } + break; + + case 133: + +/* Line 1806 of yacc.c */ +#line 1948 "parse.y" + { ifndef_ripper((yyval.id) = tMATCH); } + break; + + case 134: + +/* Line 1806 of yacc.c */ +#line 1949 "parse.y" + { ifndef_ripper((yyval.id) = tNMATCH); } + break; + + case 135: + +/* Line 1806 of yacc.c */ +#line 1950 "parse.y" + { ifndef_ripper((yyval.id) = '>'); } + break; + + case 136: + +/* Line 1806 of yacc.c */ +#line 1951 "parse.y" + { ifndef_ripper((yyval.id) = tGEQ); } + break; + + case 137: + +/* Line 1806 of yacc.c */ +#line 1952 "parse.y" + { ifndef_ripper((yyval.id) = '<'); } + break; + + case 138: + +/* Line 1806 of yacc.c */ +#line 1953 "parse.y" + { ifndef_ripper((yyval.id) = tLEQ); } + break; + + case 139: + +/* Line 1806 of yacc.c */ +#line 1954 "parse.y" + { ifndef_ripper((yyval.id) = tNEQ); } + break; + + case 140: + +/* Line 1806 of yacc.c */ +#line 1955 "parse.y" + { ifndef_ripper((yyval.id) = tLSHFT); } + break; + + case 141: + +/* Line 1806 of yacc.c */ +#line 1956 "parse.y" + { ifndef_ripper((yyval.id) = tRSHFT); } + break; + + case 142: + +/* Line 1806 of yacc.c */ +#line 1957 "parse.y" + { ifndef_ripper((yyval.id) = '+'); } + break; + + case 143: + +/* Line 1806 of yacc.c */ +#line 1958 "parse.y" + { ifndef_ripper((yyval.id) = '-'); } + break; + + case 144: + +/* Line 1806 of yacc.c */ +#line 1959 "parse.y" + { ifndef_ripper((yyval.id) = '*'); } + break; + + case 145: + +/* Line 1806 of yacc.c */ +#line 1960 "parse.y" + { ifndef_ripper((yyval.id) = '*'); } + break; + + case 146: + +/* Line 1806 of yacc.c */ +#line 1961 "parse.y" + { ifndef_ripper((yyval.id) = '/'); } + break; + + case 147: + +/* Line 1806 of yacc.c */ +#line 1962 "parse.y" + { ifndef_ripper((yyval.id) = '%'); } + break; + + case 148: + +/* Line 1806 of yacc.c */ +#line 1963 "parse.y" + { ifndef_ripper((yyval.id) = tPOW); } + break; + + case 149: + +/* Line 1806 of yacc.c */ +#line 1964 "parse.y" + { ifndef_ripper((yyval.id) = tDSTAR); } + break; + + case 150: + +/* Line 1806 of yacc.c */ +#line 1965 "parse.y" + { ifndef_ripper((yyval.id) = '!'); } + break; + + case 151: + +/* Line 1806 of yacc.c */ +#line 1966 "parse.y" + { ifndef_ripper((yyval.id) = '~'); } + break; + + case 152: + +/* Line 1806 of yacc.c */ +#line 1967 "parse.y" + { ifndef_ripper((yyval.id) = tUPLUS); } + break; + + case 153: + +/* Line 1806 of yacc.c */ +#line 1968 "parse.y" + { ifndef_ripper((yyval.id) = tUMINUS); } + break; + + case 154: + +/* Line 1806 of yacc.c */ +#line 1969 "parse.y" + { ifndef_ripper((yyval.id) = tAREF); } + break; + + case 155: + +/* Line 1806 of yacc.c */ +#line 1970 "parse.y" + { ifndef_ripper((yyval.id) = tASET); } + break; + + case 156: + +/* Line 1806 of yacc.c */ +#line 1971 "parse.y" + { ifndef_ripper((yyval.id) = '`'); } + break; + + case 198: + +/* Line 1806 of yacc.c */ +#line 1989 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(3) - (3)].node)); + (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch2(assign, $1, $3); + %*/ + } + break; + + case 199: + +/* Line 1806 of yacc.c */ +#line 1998 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(3) - (5)].node)); + (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0); + (yyval.node) = node_assign((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node)); + /*% + $$ = dispatch2(assign, $1, dispatch2(rescue_mod, $3, $5)); + %*/ + } + break; + + case 200: + +/* Line 1806 of yacc.c */ +#line 2008 "parse.y" + { + value_expr((yyvsp[(3) - (3)].node)); + (yyval.node) = new_op_assign((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].node)); + } + break; + + case 201: + +/* Line 1806 of yacc.c */ +#line 2013 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(3) - (5)].node)); + (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0); + /*% + $3 = dispatch2(rescue_mod, $3, $5); + %*/ + (yyval.node) = new_op_assign((yyvsp[(1) - (5)].node), (yyvsp[(2) - (5)].id), (yyvsp[(3) - (5)].node)); + } + break; + + case 202: + +/* Line 1806 of yacc.c */ +#line 2023 "parse.y" + { + /*%%%*/ + NODE *args; + + value_expr((yyvsp[(6) - (6)].node)); + if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY(); + if (nd_type((yyvsp[(3) - (6)].node)) == NODE_BLOCK_PASS) { + args = NEW_ARGSCAT((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node)); + } + else { + args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node)); + } + if ((yyvsp[(5) - (6)].id) == tOROP) { + (yyvsp[(5) - (6)].id) = 0; + } + else if ((yyvsp[(5) - (6)].id) == tANDOP) { + (yyvsp[(5) - (6)].id) = 1; + } + (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args); + fixpos((yyval.node), (yyvsp[(1) - (6)].node)); + /*% + $1 = dispatch2(aref_field, $1, escape_Qundef($3)); + $$ = dispatch3(opassign, $1, $5, $6); + %*/ + } + break; + + case 203: + +/* Line 1806 of yacc.c */ +#line 2049 "parse.y" + { + value_expr((yyvsp[(5) - (5)].node)); + (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node)); + } + break; + + case 204: + +/* Line 1806 of yacc.c */ +#line 2054 "parse.y" + { + value_expr((yyvsp[(5) - (5)].node)); + (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node)); + } + break; + + case 205: + +/* Line 1806 of yacc.c */ +#line 2059 "parse.y" + { + value_expr((yyvsp[(5) - (5)].node)); + (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ID2SYM(idCOLON2), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node)); + } + break; + + case 206: + +/* Line 1806 of yacc.c */ +#line 2064 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_COLON2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id)); + (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node)); + /*% + $$ = dispatch2(const_path_field, $1, $3); + $$ = dispatch3(opassign, $$, $4, $5); + %*/ + } + break; + + case 207: + +/* Line 1806 of yacc.c */ +#line 2074 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_COLON3((yyvsp[(2) - (4)].id)); + (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node)); + /*% + $$ = dispatch1(top_const_field, $2); + $$ = dispatch3(opassign, $$, $3, $4); + %*/ + } + break; + + case 208: + +/* Line 1806 of yacc.c */ +#line 2084 "parse.y" + { + /*%%%*/ + rb_backref_error((yyvsp[(1) - (3)].node)); + (yyval.node) = NEW_BEGIN(0); + /*% + $$ = dispatch1(var_field, $1); + $$ = dispatch3(opassign, $$, $2, $3); + $$ = dispatch1(assign_error, $$); + ripper_error(); + %*/ + } + break; + + case 209: + +/* Line 1806 of yacc.c */ +#line 2096 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(1) - (3)].node)); + value_expr((yyvsp[(3) - (3)].node)); + (yyval.node) = NEW_DOT2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) && + (yyvsp[(3) - (3)].node) && nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) { + deferred_nodes = list_append(deferred_nodes, (yyval.node)); + } + /*% + $$ = dispatch2(dot2, $1, $3); + %*/ + } + break; + + case 210: + +/* Line 1806 of yacc.c */ +#line 2110 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(1) - (3)].node)); + value_expr((yyvsp[(3) - (3)].node)); + (yyval.node) = NEW_DOT3((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) && + (yyvsp[(3) - (3)].node) && nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) { + deferred_nodes = list_append(deferred_nodes, (yyval.node)); + } + /*% + $$ = dispatch2(dot3, $1, $3); + %*/ + } + break; + + case 211: + +/* Line 1806 of yacc.c */ +#line 2124 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '+', (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM('+'), $3); + %*/ + } + break; + + case 212: + +/* Line 1806 of yacc.c */ +#line 2132 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '-', (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM('-'), $3); + %*/ + } + break; + + case 213: + +/* Line 1806 of yacc.c */ +#line 2140 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '*', (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM('*'), $3); + %*/ + } + break; + + case 214: + +/* Line 1806 of yacc.c */ +#line 2148 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '/', (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM('/'), $3); + %*/ + } + break; + + case 215: + +/* Line 1806 of yacc.c */ +#line 2156 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '%', (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM('%'), $3); + %*/ + } + break; + + case 216: + +/* Line 1806 of yacc.c */ +#line 2164 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tPOW, (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM(idPow), $3); + %*/ + } + break; + + case 217: + +/* Line 1806 of yacc.c */ +#line 2172 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].node), tPOW, (yyvsp[(4) - (4)].node)), tUMINUS, 0); + /*% + $$ = dispatch3(binary, $2, ID2SYM(idPow), $4); + $$ = dispatch2(unary, ID2SYM(idUMinus), $$); + %*/ + } + break; + + case 218: + +/* Line 1806 of yacc.c */ +#line 2181 "parse.y" + { + /*%%%*/ + (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUPLUS); + /*% + $$ = dispatch2(unary, ID2SYM(idUPlus), $2); + %*/ + } + break; + + case 219: + +/* Line 1806 of yacc.c */ +#line 2189 "parse.y" + { + /*%%%*/ + (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUMINUS); + /*% + $$ = dispatch2(unary, ID2SYM(idUMinus), $2); + %*/ + } + break; + + case 220: + +/* Line 1806 of yacc.c */ +#line 2197 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '|', (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM('|'), $3); + %*/ + } + break; + + case 221: + +/* Line 1806 of yacc.c */ +#line 2205 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '^', (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM('^'), $3); + %*/ + } + break; + + case 222: + +/* Line 1806 of yacc.c */ +#line 2213 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '&', (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM('&'), $3); + %*/ + } + break; + + case 223: + +/* Line 1806 of yacc.c */ +#line 2221 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tCMP, (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM(idCmp), $3); + %*/ + } + break; + + case 224: + +/* Line 1806 of yacc.c */ +#line 2229 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '>', (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM('>'), $3); + %*/ + } + break; + + case 225: + +/* Line 1806 of yacc.c */ +#line 2237 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tGEQ, (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM(idGE), $3); + %*/ + } + break; + + case 226: + +/* Line 1806 of yacc.c */ +#line 2245 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '<', (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM('<'), $3); + %*/ + } + break; + + case 227: + +/* Line 1806 of yacc.c */ +#line 2253 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLEQ, (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM(idLE), $3); + %*/ + } + break; + + case 228: + +/* Line 1806 of yacc.c */ +#line 2261 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQ, (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM(idEq), $3); + %*/ + } + break; + + case 229: + +/* Line 1806 of yacc.c */ +#line 2269 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQQ, (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM(idEqq), $3); + %*/ + } + break; + + case 230: + +/* Line 1806 of yacc.c */ +#line 2277 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNEQ, (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM(idNeq), $3); + %*/ + } + break; + + case 231: + +/* Line 1806 of yacc.c */ +#line 2285 "parse.y" + { + /*%%%*/ + (yyval.node) = match_op((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].node)->nd_lit, T_REGEXP)) { + (yyval.node) = reg_named_capture_assign((yyvsp[(1) - (3)].node)->nd_lit, (yyval.node)); + } + /*% + $$ = dispatch3(binary, $1, ID2SYM(idEqTilde), $3); + %*/ + } + break; + + case 232: + +/* Line 1806 of yacc.c */ +#line 2296 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNMATCH, (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM(idNeqTilde), $3); + %*/ + } + break; + + case 233: + +/* Line 1806 of yacc.c */ +#line 2304 "parse.y" + { + /*%%%*/ + (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!'); + /*% + $$ = dispatch2(unary, ID2SYM('!'), $2); + %*/ + } + break; + + case 234: + +/* Line 1806 of yacc.c */ +#line 2312 "parse.y" + { + /*%%%*/ + (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), '~'); + /*% + $$ = dispatch2(unary, ID2SYM('~'), $2); + %*/ + } + break; + + case 235: + +/* Line 1806 of yacc.c */ +#line 2320 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLSHFT, (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM(idLTLT), $3); + %*/ + } + break; + + case 236: + +/* Line 1806 of yacc.c */ +#line 2328 "parse.y" + { + /*%%%*/ + (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tRSHFT, (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM(idGTGT), $3); + %*/ + } + break; + + case 237: + +/* Line 1806 of yacc.c */ +#line 2336 "parse.y" + { + /*%%%*/ + (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM(idANDOP), $3); + %*/ + } + break; + + case 238: + +/* Line 1806 of yacc.c */ +#line 2344 "parse.y" + { + /*%%%*/ + (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch3(binary, $1, ID2SYM(idOROP), $3); + %*/ + } + break; + + case 239: + +/* Line 1806 of yacc.c */ +#line 2351 "parse.y" + {in_defined = 1;} + break; + + case 240: + +/* Line 1806 of yacc.c */ +#line 2352 "parse.y" + { + in_defined = 0; + /*%%%*/ + (yyval.node) = new_defined((yyvsp[(4) - (4)].node)); + /*% + $$ = dispatch1(defined, $4); + %*/ + } + break; + + case 241: + +/* Line 1806 of yacc.c */ +#line 2361 "parse.y" + { + (yyval.val) = cond_stack; + cond_stack = 0; + COND_PUSH(1); + } + break; + + case 242: + +/* Line 1806 of yacc.c */ +#line 2367 "parse.y" + { + cond_stack = (yyvsp[(3) - (6)].val); + } + break; + + case 243: + +/* Line 1806 of yacc.c */ +#line 2371 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(1) - (8)].node)); + (yyval.node) = NEW_IF(cond((yyvsp[(1) - (8)].node)), (yyvsp[(4) - (8)].node), (yyvsp[(8) - (8)].node)); + fixpos((yyval.node), (yyvsp[(1) - (8)].node)); + /*% + $$ = dispatch3(ifop, $1, $4, $8); + %*/ + } + break; + + case 244: + +/* Line 1806 of yacc.c */ +#line 2381 "parse.y" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + } + break; + + case 245: + +/* Line 1806 of yacc.c */ +#line 2387 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(1) - (1)].node)); + (yyval.node) = (yyvsp[(1) - (1)].node); + if (!(yyval.node)) (yyval.node) = NEW_NIL(); + /*% + $$ = $1; + %*/ + } + break; + + case 247: + +/* Line 1806 of yacc.c */ +#line 2400 "parse.y" + { + (yyval.node) = (yyvsp[(1) - (2)].node); + } + break; + + case 248: + +/* Line 1806 of yacc.c */ +#line 2404 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(3) - (4)].node) ? arg_append((yyvsp[(1) - (4)].node), new_hash((yyvsp[(3) - (4)].node))) : (yyvsp[(1) - (4)].node); + /*% + $$ = arg_add_assocs($1, $3); + %*/ + } + break; + + case 249: + +/* Line 1806 of yacc.c */ +#line 2412 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(1) - (2)].node) ? NEW_LIST(new_hash((yyvsp[(1) - (2)].node))) : 0; + /*% + $$ = arg_add_assocs(arg_new(), $1); + %*/ + } + break; + + case 250: + +/* Line 1806 of yacc.c */ +#line 2422 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (3)].node); + /*% + $$ = dispatch1(arg_paren, escape_Qundef($2)); + %*/ + } + break; + + case 255: + +/* Line 1806 of yacc.c */ +#line 2438 "parse.y" + { + (yyval.node) = (yyvsp[(1) - (2)].node); + } + break; + + case 256: + +/* Line 1806 of yacc.c */ +#line 2442 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(3) - (4)].node) ? arg_append((yyvsp[(1) - (4)].node), new_hash((yyvsp[(3) - (4)].node))) : (yyvsp[(1) - (4)].node); + /*% + $$ = arg_add_assocs($1, $3); + %*/ + } + break; + + case 257: + +/* Line 1806 of yacc.c */ +#line 2450 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(1) - (2)].node) ? NEW_LIST(new_hash((yyvsp[(1) - (2)].node))) : 0; + /*% + $$ = arg_add_assocs(arg_new(), $1); + %*/ + } + break; + + case 258: + +/* Line 1806 of yacc.c */ +#line 2460 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(1) - (1)].node)); + (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node)); + /*% + $$ = arg_add(arg_new(), $1); + %*/ + } + break; + + case 259: + +/* Line 1806 of yacc.c */ +#line 2469 "parse.y" + { + /*%%%*/ + (yyval.node) = arg_blk_pass((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); + /*% + $$ = arg_add_optblock($1, $2); + %*/ + } + break; + + case 260: + +/* Line 1806 of yacc.c */ +#line 2477 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_LIST((yyvsp[(1) - (2)].node) ? new_hash((yyvsp[(1) - (2)].node)) : 0); + (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(2) - (2)].node)); + /*% + $$ = arg_add_assocs(arg_new(), $1); + $$ = arg_add_optblock($$, $2); + %*/ + } + break; + + case 261: + +/* Line 1806 of yacc.c */ +#line 2487 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(3) - (4)].node) ? arg_append((yyvsp[(1) - (4)].node), new_hash((yyvsp[(3) - (4)].node))) : (yyvsp[(1) - (4)].node); + (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(4) - (4)].node)); + /*% + $$ = arg_add_optblock(arg_add_assocs($1, $3), $4); + %*/ + } + break; + + case 263: + +/* Line 1806 of yacc.c */ +#line 2504 "parse.y" + { + (yyval.val) = cmdarg_stack; + CMDARG_PUSH(1); + } + break; + + case 264: + +/* Line 1806 of yacc.c */ +#line 2509 "parse.y" + { + /* CMDARG_POP() */ + cmdarg_stack = (yyvsp[(1) - (2)].val); + (yyval.node) = (yyvsp[(2) - (2)].node); + } + break; + + case 265: + +/* Line 1806 of yacc.c */ +#line 2517 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].node)); + /*% + $$ = $2; + %*/ + } + break; + + case 266: + +/* Line 1806 of yacc.c */ +#line 2527 "parse.y" + { + (yyval.node) = (yyvsp[(2) - (2)].node); + } + break; + + case 267: + +/* Line 1806 of yacc.c */ +#line 2531 "parse.y" + { + (yyval.node) = 0; + } + break; + + case 268: + +/* Line 1806 of yacc.c */ +#line 2537 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node)); + /*% + $$ = arg_add(arg_new(), $1); + %*/ + } + break; + + case 269: + +/* Line 1806 of yacc.c */ +#line 2545 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node)); + /*% + $$ = arg_add_star(arg_new(), $2); + %*/ + } + break; + + case 270: + +/* Line 1806 of yacc.c */ +#line 2553 "parse.y" + { + /*%%%*/ + NODE *n1; + if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) { + (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node)); + } + else { + (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + } + /*% + $$ = arg_add($1, $3); + %*/ + } + break; + + case 271: + +/* Line 1806 of yacc.c */ +#line 2567 "parse.y" + { + /*%%%*/ + NODE *n1; + if ((nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) { + (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node)); + } + else { + (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node)); + } + /*% + $$ = arg_add_star($1, $4); + %*/ + } + break; + + case 274: + +/* Line 1806 of yacc.c */ +#line 2587 "parse.y" + { + /*%%%*/ + NODE *n1; + if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) { + (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node)); + } + else { + (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + } + /*% + $$ = mrhs_add(args2mrhs($1), $3); + %*/ + } + break; + + case 275: + +/* Line 1806 of yacc.c */ +#line 2601 "parse.y" + { + /*%%%*/ + NODE *n1; + if (nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY && + (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) { + (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node)); + } + else { + (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node)); + } + /*% + $$ = mrhs_add_star(args2mrhs($1), $4); + %*/ + } + break; + + case 276: + +/* Line 1806 of yacc.c */ +#line 2616 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node)); + /*% + $$ = mrhs_add_star(mrhs_new(), $2); + %*/ + } + break; + + case 287: + +/* Line 1806 of yacc.c */ +#line 2636 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_FCALL((yyvsp[(1) - (1)].id), 0); + /*% + $$ = method_arg(dispatch1(fcall, $1), arg_new()); + %*/ + } + break; + + case 288: + +/* Line 1806 of yacc.c */ +#line 2644 "parse.y" + { + (yyvsp[(1) - (1)].val) = cmdarg_stack; + cmdarg_stack = 0; + /*%%%*/ + (yyval.num) = ruby_sourceline; + /*% + %*/ + } + break; + + case 289: + +/* Line 1806 of yacc.c */ +#line 2654 "parse.y" + { + cmdarg_stack = (yyvsp[(1) - (4)].val); + /*%%%*/ + if ((yyvsp[(3) - (4)].node) == NULL) { + (yyval.node) = NEW_NIL(); + } + else { + if (nd_type((yyvsp[(3) - (4)].node)) == NODE_RESCUE || + nd_type((yyvsp[(3) - (4)].node)) == NODE_ENSURE) + nd_set_line((yyvsp[(3) - (4)].node), (yyvsp[(2) - (4)].num)); + (yyval.node) = NEW_BEGIN((yyvsp[(3) - (4)].node)); + } + nd_set_line((yyval.node), (yyvsp[(2) - (4)].num)); + /*% + $$ = dispatch1(begin, $3); + %*/ + } + break; + + case 290: + +/* Line 1806 of yacc.c */ +#line 2671 "parse.y" + {lex_state = EXPR_ENDARG;} + break; + + case 291: + +/* Line 1806 of yacc.c */ +#line 2672 "parse.y" + { + /*%%%*/ + (yyval.node) = 0; + /*% + $$ = dispatch1(paren, 0); + %*/ + } + break; + + case 292: + +/* Line 1806 of yacc.c */ +#line 2680 "parse.y" + { + (yyvsp[(1) - (1)].val) = cmdarg_stack; + cmdarg_stack = 0; + } + break; + + case 293: + +/* Line 1806 of yacc.c */ +#line 2684 "parse.y" + {lex_state = EXPR_ENDARG;} + break; + + case 294: + +/* Line 1806 of yacc.c */ +#line 2685 "parse.y" + { + cmdarg_stack = (yyvsp[(1) - (5)].val); + /*%%%*/ + (yyval.node) = (yyvsp[(3) - (5)].node); + /*% + $$ = dispatch1(paren, $3); + %*/ + } + break; + + case 295: + +/* Line 1806 of yacc.c */ +#line 2694 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (3)].node); + /*% + $$ = dispatch1(paren, $2); + %*/ + } + break; + + case 296: + +/* Line 1806 of yacc.c */ +#line 2702 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)); + /*% + $$ = dispatch2(const_path_ref, $1, $3); + %*/ + } + break; + + case 297: + +/* Line 1806 of yacc.c */ +#line 2710 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id)); + /*% + $$ = dispatch1(top_const_ref, $2); + %*/ + } + break; + + case 298: + +/* Line 1806 of yacc.c */ +#line 2718 "parse.y" + { + /*%%%*/ + if ((yyvsp[(2) - (3)].node) == 0) { + (yyval.node) = NEW_ZARRAY(); /* zero length array*/ + } + else { + (yyval.node) = (yyvsp[(2) - (3)].node); + } + /*% + $$ = dispatch1(array, escape_Qundef($2)); + %*/ + } + break; + + case 299: + +/* Line 1806 of yacc.c */ +#line 2731 "parse.y" + { + /*%%%*/ + (yyval.node) = new_hash((yyvsp[(2) - (3)].node)); + /*% + $$ = dispatch1(hash, escape_Qundef($2)); + %*/ + } + break; + + case 300: + +/* Line 1806 of yacc.c */ +#line 2739 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_RETURN(0); + /*% + $$ = dispatch0(return0); + %*/ + } + break; + + case 301: + +/* Line 1806 of yacc.c */ +#line 2747 "parse.y" + { + /*%%%*/ + (yyval.node) = new_yield((yyvsp[(3) - (4)].node)); + /*% + $$ = dispatch1(yield, dispatch1(paren, $3)); + %*/ + } + break; + + case 302: + +/* Line 1806 of yacc.c */ +#line 2755 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_YIELD(0); + /*% + $$ = dispatch1(yield, dispatch1(paren, arg_new())); + %*/ + } + break; + + case 303: + +/* Line 1806 of yacc.c */ +#line 2763 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_YIELD(0); + /*% + $$ = dispatch0(yield0); + %*/ + } + break; + + case 304: + +/* Line 1806 of yacc.c */ +#line 2770 "parse.y" + {in_defined = 1;} + break; + + case 305: + +/* Line 1806 of yacc.c */ +#line 2771 "parse.y" + { + in_defined = 0; + /*%%%*/ + (yyval.node) = new_defined((yyvsp[(5) - (6)].node)); + /*% + $$ = dispatch1(defined, $5); + %*/ + } + break; + + case 306: + +/* Line 1806 of yacc.c */ +#line 2780 "parse.y" + { + /*%%%*/ + (yyval.node) = call_uni_op(cond((yyvsp[(3) - (4)].node)), '!'); + /*% + $$ = dispatch2(unary, ripper_intern("not"), $3); + %*/ + } + break; + + case 307: + +/* Line 1806 of yacc.c */ +#line 2788 "parse.y" + { + /*%%%*/ + (yyval.node) = call_uni_op(cond(NEW_NIL()), '!'); + /*% + $$ = dispatch2(unary, ripper_intern("not"), Qnil); + %*/ + } + break; + + case 308: + +/* Line 1806 of yacc.c */ +#line 2796 "parse.y" + { + /*%%%*/ + (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node); + (yyval.node) = (yyvsp[(2) - (2)].node); + /*% + $$ = method_arg(dispatch1(fcall, $1), arg_new()); + $$ = method_add_block($$, $2); + %*/ + } + break; + + case 310: + +/* Line 1806 of yacc.c */ +#line 2807 "parse.y" + { + /*%%%*/ + block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node)); + (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node); + (yyval.node) = (yyvsp[(2) - (2)].node); + /*% + $$ = method_add_block($1, $2); + %*/ + } + break; + + case 311: + +/* Line 1806 of yacc.c */ +#line 2817 "parse.y" + { + (yyval.node) = (yyvsp[(2) - (2)].node); + } + break; + + case 312: + +/* Line 1806 of yacc.c */ +#line 2824 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_IF(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node)); + fixpos((yyval.node), (yyvsp[(2) - (6)].node)); + /*% + $$ = dispatch3(if, $2, $4, escape_Qundef($5)); + %*/ + } + break; + + case 313: + +/* Line 1806 of yacc.c */ +#line 2836 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_UNLESS(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node)); + fixpos((yyval.node), (yyvsp[(2) - (6)].node)); + /*% + $$ = dispatch3(unless, $2, $4, escape_Qundef($5)); + %*/ + } + break; + + case 314: + +/* Line 1806 of yacc.c */ +#line 2844 "parse.y" + {COND_PUSH(1);} + break; + + case 315: + +/* Line 1806 of yacc.c */ +#line 2844 "parse.y" + {COND_POP();} + break; + + case 316: + +/* Line 1806 of yacc.c */ +#line 2847 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1); + fixpos((yyval.node), (yyvsp[(3) - (7)].node)); + /*% + $$ = dispatch2(while, $3, $6); + %*/ + } + break; + + case 317: + +/* Line 1806 of yacc.c */ +#line 2855 "parse.y" + {COND_PUSH(1);} + break; + + case 318: + +/* Line 1806 of yacc.c */ +#line 2855 "parse.y" + {COND_POP();} + break; + + case 319: + +/* Line 1806 of yacc.c */ +#line 2858 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1); + fixpos((yyval.node), (yyvsp[(3) - (7)].node)); + /*% + $$ = dispatch2(until, $3, $6); + %*/ + } + break; + + case 320: + +/* Line 1806 of yacc.c */ +#line 2869 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CASE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node)); + fixpos((yyval.node), (yyvsp[(2) - (5)].node)); + /*% + $$ = dispatch2(case, $2, $4); + %*/ + } + break; + + case 321: + +/* Line 1806 of yacc.c */ +#line 2878 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CASE(0, (yyvsp[(3) - (4)].node)); + /*% + $$ = dispatch2(case, Qnil, $3); + %*/ + } + break; + + case 322: + +/* Line 1806 of yacc.c */ +#line 2886 "parse.y" + {COND_PUSH(1);} + break; + + case 323: + +/* Line 1806 of yacc.c */ +#line 2888 "parse.y" + {COND_POP();} + break; + + case 324: + +/* Line 1806 of yacc.c */ +#line 2891 "parse.y" + { + /*%%%*/ + /* + * for a, b, c in e + * #=> + * e.each{|*x| a, b, c = x + * + * for a in e + * #=> + * e.each{|x| a, = x} + */ + ID id = internal_id(); + ID *tbl = ALLOC_N(ID, 2); + NODE *m = NEW_ARGS_AUX(0, 0); + NODE *args, *scope; + + if (nd_type((yyvsp[(2) - (9)].node)) == NODE_MASGN) { + /* if args.length == 1 && args[0].kind_of?(Array) + * args = args[0] + * end + */ + NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1))); + NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0))); + m->nd_next = block_append( + NEW_IF( + NEW_NODE(NODE_AND, + NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0), + idEq, one), + NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero), + rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))), + 0), + NEW_DASGN_CURR(id, + NEW_CALL(NEW_DVAR(id), idAREF, zero)), + 0), + node_assign((yyvsp[(2) - (9)].node), NEW_DVAR(id))); + + args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0)); + } + else { + if (nd_type((yyvsp[(2) - (9)].node)) == NODE_LASGN || + nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN || + nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN_CURR) { + (yyvsp[(2) - (9)].node)->nd_value = NEW_DVAR(id); + m->nd_plen = 1; + m->nd_next = (yyvsp[(2) - (9)].node); + args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0)); + } + else { + m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].node)), 0), NEW_DVAR(id)); + args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0)); + } + } + scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].node), args); + tbl[0] = 1; tbl[1] = id; + (yyval.node) = NEW_FOR(0, (yyvsp[(5) - (9)].node), scope); + fixpos((yyval.node), (yyvsp[(2) - (9)].node)); + /*% + $$ = dispatch3(for, $2, $5, $8); + %*/ + } + break; + + case 325: + +/* Line 1806 of yacc.c */ +#line 2952 "parse.y" + { + if (in_def || in_single) + yyerror("class definition in method body"); + local_push(0); + /*%%%*/ + (yyval.num) = ruby_sourceline; + /*% + %*/ + } + break; + + case 326: + +/* Line 1806 of yacc.c */ +#line 2963 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CLASS((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(3) - (6)].node)); + nd_set_line((yyval.node), (yyvsp[(4) - (6)].num)); + /*% + $$ = dispatch3(class, $2, $3, $5); + %*/ + local_pop(); + } + break; + + case 327: + +/* Line 1806 of yacc.c */ +#line 2973 "parse.y" + { + (yyval.num) = in_def; + in_def = 0; + } + break; + + case 328: + +/* Line 1806 of yacc.c */ +#line 2978 "parse.y" + { + (yyval.num) = in_single; + in_single = 0; + local_push(0); + } + break; + + case 329: + +/* Line 1806 of yacc.c */ +#line 2985 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_SCLASS((yyvsp[(3) - (8)].node), (yyvsp[(7) - (8)].node)); + fixpos((yyval.node), (yyvsp[(3) - (8)].node)); + /*% + $$ = dispatch2(sclass, $3, $7); + %*/ + local_pop(); + in_def = (yyvsp[(4) - (8)].num); + in_single = (yyvsp[(6) - (8)].num); + } + break; + + case 330: + +/* Line 1806 of yacc.c */ +#line 2997 "parse.y" + { + if (in_def || in_single) + yyerror("module definition in method body"); + local_push(0); + /*%%%*/ + (yyval.num) = ruby_sourceline; + /*% + %*/ + } + break; + + case 331: + +/* Line 1806 of yacc.c */ +#line 3008 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MODULE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node)); + nd_set_line((yyval.node), (yyvsp[(3) - (5)].num)); + /*% + $$ = dispatch2(module, $2, $4); + %*/ + local_pop(); + } + break; + + case 332: + +/* Line 1806 of yacc.c */ +#line 3018 "parse.y" + { + in_def++; + local_push(0); + (yyval.id) = current_arg; + current_arg = 0; + } + break; + + case 333: + +/* Line 1806 of yacc.c */ +#line 3027 "parse.y" + { + /*%%%*/ + NODE *body = remove_begin((yyvsp[(5) - (6)].node)); + reduce_nodes(&body); + (yyval.node) = NEW_DEFN((yyvsp[(2) - (6)].id), (yyvsp[(4) - (6)].node), body, NOEX_PRIVATE); + nd_set_line((yyval.node), (yyvsp[(1) - (6)].num)); + /*% + $$ = dispatch3(def, $2, $4, $5); + %*/ + local_pop(); + in_def--; + current_arg = (yyvsp[(3) - (6)].id); + } + break; + + case 334: + +/* Line 1806 of yacc.c */ +#line 3040 "parse.y" + {lex_state = EXPR_FNAME;} + break; + + case 335: + +/* Line 1806 of yacc.c */ +#line 3041 "parse.y" + { + in_single++; + lex_state = EXPR_ENDFN; /* force for args */ + local_push(0); + (yyval.id) = current_arg; + current_arg = 0; + } + break; + + case 336: + +/* Line 1806 of yacc.c */ +#line 3051 "parse.y" + { + /*%%%*/ + NODE *body = remove_begin((yyvsp[(8) - (9)].node)); + reduce_nodes(&body); + (yyval.node) = NEW_DEFS((yyvsp[(2) - (9)].node), (yyvsp[(5) - (9)].id), (yyvsp[(7) - (9)].node), body); + nd_set_line((yyval.node), (yyvsp[(1) - (9)].num)); + /*% + $$ = dispatch5(defs, $2, $3, $5, $7, $8); + %*/ + local_pop(); + in_single--; + current_arg = (yyvsp[(6) - (9)].id); + } + break; + + case 337: + +/* Line 1806 of yacc.c */ +#line 3065 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_BREAK(0); + /*% + $$ = dispatch1(break, arg_new()); + %*/ + } + break; + + case 338: + +/* Line 1806 of yacc.c */ +#line 3073 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_NEXT(0); + /*% + $$ = dispatch1(next, arg_new()); + %*/ + } + break; + + case 339: + +/* Line 1806 of yacc.c */ +#line 3081 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_REDO(); + /*% + $$ = dispatch0(redo); + %*/ + } + break; + + case 340: + +/* Line 1806 of yacc.c */ +#line 3089 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_RETRY(); + /*% + $$ = dispatch0(retry); + %*/ + } + break; + + case 341: + +/* Line 1806 of yacc.c */ +#line 3099 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(1) - (1)].node)); + (yyval.node) = (yyvsp[(1) - (1)].node); + if (!(yyval.node)) (yyval.node) = NEW_NIL(); + /*% + $$ = $1; + %*/ + } + break; + + case 342: + +/* Line 1806 of yacc.c */ +#line 3111 "parse.y" + { + token_info_push("begin"); + } + break; + + case 343: + +/* Line 1806 of yacc.c */ +#line 3117 "parse.y" + { + token_info_push("if"); + } + break; + + case 344: + +/* Line 1806 of yacc.c */ +#line 3123 "parse.y" + { + token_info_push("unless"); + } + break; + + case 345: + +/* Line 1806 of yacc.c */ +#line 3129 "parse.y" + { + token_info_push("while"); + } + break; + + case 346: + +/* Line 1806 of yacc.c */ +#line 3135 "parse.y" + { + token_info_push("until"); + } + break; + + case 347: + +/* Line 1806 of yacc.c */ +#line 3141 "parse.y" + { + token_info_push("case"); + } + break; + + case 348: + +/* Line 1806 of yacc.c */ +#line 3147 "parse.y" + { + token_info_push("for"); + } + break; + + case 349: + +/* Line 1806 of yacc.c */ +#line 3153 "parse.y" + { + token_info_push("class"); + } + break; + + case 350: + +/* Line 1806 of yacc.c */ +#line 3159 "parse.y" + { + token_info_push("module"); + } + break; + + case 351: + +/* Line 1806 of yacc.c */ +#line 3165 "parse.y" + { + token_info_push("def"); + /*%%%*/ + (yyval.num) = ruby_sourceline; + /*% + %*/ + } + break; + + case 352: + +/* Line 1806 of yacc.c */ +#line 3175 "parse.y" + { + token_info_pop("end"); + } + break; + + case 359: + +/* Line 1806 of yacc.c */ +#line 3205 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_IF(cond((yyvsp[(2) - (5)].node)), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node)); + fixpos((yyval.node), (yyvsp[(2) - (5)].node)); + /*% + $$ = dispatch3(elsif, $2, $4, escape_Qundef($5)); + %*/ + } + break; + + case 361: + +/* Line 1806 of yacc.c */ +#line 3217 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (2)].node); + /*% + $$ = dispatch1(else, $2); + %*/ + } + break; + + case 364: + +/* Line 1806 of yacc.c */ +#line 3231 "parse.y" + { + (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0); + /*%%%*/ + /*% + $$ = dispatch1(mlhs_paren, $$); + %*/ + } + break; + + case 365: + +/* Line 1806 of yacc.c */ +#line 3239 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (3)].node); + /*% + $$ = dispatch1(mlhs_paren, $2); + %*/ + } + break; + + case 366: + +/* Line 1806 of yacc.c */ +#line 3249 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node)); + /*% + $$ = mlhs_add(mlhs_new(), $1); + %*/ + } + break; + + case 367: + +/* Line 1806 of yacc.c */ +#line 3257 "parse.y" + { + /*%%%*/ + (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); + /*% + $$ = mlhs_add($1, $3); + %*/ + } + break; + + case 368: + +/* Line 1806 of yacc.c */ +#line 3267 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0); + /*% + $$ = $1; + %*/ + } + break; + + case 369: + +/* Line 1806 of yacc.c */ +#line 3275 "parse.y" + { + (yyval.node) = assignable((yyvsp[(4) - (4)].id), 0); + /*%%%*/ + (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), (yyval.node)); + /*% + $$ = mlhs_add_star($1, $$); + %*/ + } + break; + + case 370: + +/* Line 1806 of yacc.c */ +#line 3284 "parse.y" + { + (yyval.node) = assignable((yyvsp[(4) - (6)].id), 0); + /*%%%*/ + (yyval.node) = NEW_MASGN((yyvsp[(1) - (6)].node), NEW_POSTARG((yyval.node), (yyvsp[(6) - (6)].node))); + /*% + $$ = mlhs_add_star($1, $$); + %*/ + } + break; + + case 371: + +/* Line 1806 of yacc.c */ +#line 3293 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), -1); + /*% + $$ = mlhs_add_star($1, Qnil); + %*/ + } + break; + + case 372: + +/* Line 1806 of yacc.c */ +#line 3301 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG(-1, (yyvsp[(5) - (5)].node))); + /*% + $$ = mlhs_add_star($1, $5); + %*/ + } + break; + + case 373: + +/* Line 1806 of yacc.c */ +#line 3309 "parse.y" + { + (yyval.node) = assignable((yyvsp[(2) - (2)].id), 0); + /*%%%*/ + (yyval.node) = NEW_MASGN(0, (yyval.node)); + /*% + $$ = mlhs_add_star(mlhs_new(), $$); + %*/ + } + break; + + case 374: + +/* Line 1806 of yacc.c */ +#line 3318 "parse.y" + { + (yyval.node) = assignable((yyvsp[(2) - (4)].id), 0); + /*%%%*/ + (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyval.node), (yyvsp[(4) - (4)].node))); + /*% + #if 0 + TODO: Check me + #endif + $$ = mlhs_add_star($$, $4); + %*/ + } + break; + + case 375: + +/* Line 1806 of yacc.c */ +#line 3330 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN(0, -1); + /*% + $$ = mlhs_add_star(mlhs_new(), Qnil); + %*/ + } + break; + + case 376: + +/* Line 1806 of yacc.c */ +#line 3338 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node))); + /*% + $$ = mlhs_add_star(mlhs_new(), Qnil); + %*/ + } + break; + + case 377: + +/* Line 1806 of yacc.c */ +#line 3349 "parse.y" + { + (yyval.node) = new_args_tail((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id)); + } + break; + + case 378: + +/* Line 1806 of yacc.c */ +#line 3353 "parse.y" + { + (yyval.node) = new_args_tail((yyvsp[(1) - (2)].node), Qnone, (yyvsp[(2) - (2)].id)); + } + break; + + case 379: + +/* Line 1806 of yacc.c */ +#line 3357 "parse.y" + { + (yyval.node) = new_args_tail(Qnone, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id)); + } + break; + + case 380: + +/* Line 1806 of yacc.c */ +#line 3361 "parse.y" + { + (yyval.node) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].id)); + } + break; + + case 381: + +/* Line 1806 of yacc.c */ +#line 3367 "parse.y" + { + (yyval.node) = (yyvsp[(2) - (2)].node); + } + break; + + case 382: + +/* Line 1806 of yacc.c */ +#line 3371 "parse.y" + { + (yyval.node) = new_args_tail(Qnone, Qnone, Qnone); + } + break; + + case 383: + +/* Line 1806 of yacc.c */ +#line 3377 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), Qnone, (yyvsp[(6) - (6)].node)); + } + break; + + case 384: + +/* Line 1806 of yacc.c */ +#line 3381 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].node)); + } + break; + + case 385: + +/* Line 1806 of yacc.c */ +#line 3385 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), Qnone, Qnone, (yyvsp[(4) - (4)].node)); + } + break; + + case 386: + +/* Line 1806 of yacc.c */ +#line 3389 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), Qnone, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node)); + } + break; + + case 387: + +/* Line 1806 of yacc.c */ +#line 3393 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node)); + } + break; + + case 388: + +/* Line 1806 of yacc.c */ +#line 3397 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone)); + /*%%%*/ + /*% + dispatch1(excessed_comma, $$); + %*/ + } + break; + + case 389: + +/* Line 1806 of yacc.c */ +#line 3405 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (6)].node), Qnone, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node)); + } + break; + + case 390: + +/* Line 1806 of yacc.c */ +#line 3409 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].node)); + } + break; + + case 391: + +/* Line 1806 of yacc.c */ +#line 3413 "parse.y" + { + (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node)); + } + break; + + case 392: + +/* Line 1806 of yacc.c */ +#line 3417 "parse.y" + { + (yyval.node) = new_args(Qnone, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node)); + } + break; + + case 393: + +/* Line 1806 of yacc.c */ +#line 3421 "parse.y" + { + (yyval.node) = new_args(Qnone, (yyvsp[(1) - (2)].node), Qnone, Qnone, (yyvsp[(2) - (2)].node)); + } + break; + + case 394: + +/* Line 1806 of yacc.c */ +#line 3425 "parse.y" + { + (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node)); + } + break; + + case 395: + +/* Line 1806 of yacc.c */ +#line 3429 "parse.y" + { + (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].id), Qnone, (yyvsp[(2) - (2)].node)); + } + break; + + case 396: + +/* Line 1806 of yacc.c */ +#line 3433 "parse.y" + { + (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node)); + } + break; + + case 397: + +/* Line 1806 of yacc.c */ +#line 3437 "parse.y" + { + (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].node)); + } + break; + + case 399: + +/* Line 1806 of yacc.c */ +#line 3444 "parse.y" + { + command_start = TRUE; + } + break; + + case 400: + +/* Line 1806 of yacc.c */ +#line 3450 "parse.y" + { + current_arg = 0; + /*%%%*/ + (yyval.node) = 0; + /*% + $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil), + escape_Qundef($2)); + %*/ + } + break; + + case 401: + +/* Line 1806 of yacc.c */ +#line 3460 "parse.y" + { + /*%%%*/ + (yyval.node) = 0; + /*% + $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil), + Qnil); + %*/ + } + break; + + case 402: + +/* Line 1806 of yacc.c */ +#line 3469 "parse.y" + { + current_arg = 0; + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (4)].node); + /*% + $$ = blockvar_new(escape_Qundef($2), escape_Qundef($3)); + %*/ + } + break; + + case 403: + +/* Line 1806 of yacc.c */ +#line 3481 "parse.y" + { + (yyval.node) = 0; + } + break; + + case 404: + +/* Line 1806 of yacc.c */ +#line 3485 "parse.y" + { + /*%%%*/ + (yyval.node) = 0; + /*% + $$ = $3; + %*/ + } + break; + + case 407: + +/* Line 1806 of yacc.c */ +#line 3511 "parse.y" + { + new_bv(get_id((yyvsp[(1) - (1)].id))); + /*%%%*/ + /*% + $$ = get_value($1); + %*/ + } + break; + + case 408: + +/* Line 1806 of yacc.c */ +#line 3519 "parse.y" + { + (yyval.node) = 0; + } + break; + + case 409: + +/* Line 1806 of yacc.c */ +#line 3524 "parse.y" + { + (yyval.vars) = dyna_push(); + } + break; + + case 410: + +/* Line 1806 of yacc.c */ +#line 3527 "parse.y" + { + (yyval.num) = lpar_beg; + lpar_beg = ++paren_nest; + } + break; + + case 411: + +/* Line 1806 of yacc.c */ +#line 3532 "parse.y" + { + (yyval.num) = ruby_sourceline; + } + break; + + case 412: + +/* Line 1806 of yacc.c */ +#line 3535 "parse.y" + { + (yyval.val) = cmdarg_stack; + cmdarg_stack = 0; + } + break; + + case 413: + +/* Line 1806 of yacc.c */ +#line 3540 "parse.y" + { + lpar_beg = (yyvsp[(2) - (6)].num); + cmdarg_stack = (yyvsp[(5) - (6)].val); + CMDARG_LEXPOP(); + /*%%%*/ + (yyval.node) = NEW_LAMBDA((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node)); + nd_set_line((yyval.node), (yyvsp[(4) - (6)].num)); + /*% + $$ = dispatch2(lambda, $3, $6); + %*/ + dyna_pop((yyvsp[(1) - (6)].vars)); + } + break; + + case 414: + +/* Line 1806 of yacc.c */ +#line 3555 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (4)].node); + /*% + $$ = dispatch1(paren, $2); + %*/ + } + break; + + case 415: + +/* Line 1806 of yacc.c */ +#line 3563 "parse.y" + { + (yyval.node) = (yyvsp[(1) - (1)].node); + } + break; + + case 416: + +/* Line 1806 of yacc.c */ +#line 3569 "parse.y" + { + (yyval.node) = (yyvsp[(2) - (3)].node); + } + break; + + case 417: + +/* Line 1806 of yacc.c */ +#line 3573 "parse.y" + { + (yyval.node) = (yyvsp[(2) - (3)].node); + } + break; + + case 418: + +/* Line 1806 of yacc.c */ +#line 3579 "parse.y" + { + (yyvsp[(1) - (1)].vars) = dyna_push(); + /*%%%*/ + (yyval.num) = ruby_sourceline; + /*% %*/ + } + break; + + case 419: + +/* Line 1806 of yacc.c */ +#line 3588 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node)); + nd_set_line((yyval.node), (yyvsp[(2) - (5)].num)); + /*% + $$ = dispatch2(do_block, escape_Qundef($3), $4); + %*/ + dyna_pop((yyvsp[(1) - (5)].vars)); + } + break; + + case 420: + +/* Line 1806 of yacc.c */ +#line 3600 "parse.y" + { + /*%%%*/ + if (nd_type((yyvsp[(1) - (2)].node)) == NODE_YIELD) { + compile_error(PARSER_ARG "block given to yield"); + } + else { + block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node)); + } + (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node); + (yyval.node) = (yyvsp[(2) - (2)].node); + fixpos((yyval.node), (yyvsp[(1) - (2)].node)); + /*% + $$ = method_add_block($1, $2); + %*/ + } + break; + + case 421: + +/* Line 1806 of yacc.c */ +#line 3616 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node)); + /*% + $$ = dispatch3(call, $1, $2, $3); + $$ = method_optarg($$, $4); + %*/ + } + break; + + case 422: + +/* Line 1806 of yacc.c */ +#line 3625 "parse.y" + { + /*%%%*/ + block_dup_check((yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node)); + (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node)); + (yyval.node) = (yyvsp[(5) - (5)].node); + fixpos((yyval.node), (yyvsp[(1) - (5)].node)); + /*% + $$ = dispatch4(command_call, $1, $2, $3, $4); + $$ = method_add_block($$, $5); + %*/ + } + break; + + case 423: + +/* Line 1806 of yacc.c */ +#line 3637 "parse.y" + { + /*%%%*/ + block_dup_check((yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node)); + (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node)); + (yyval.node) = (yyvsp[(5) - (5)].node); + fixpos((yyval.node), (yyvsp[(1) - (5)].node)); + /*% + $$ = dispatch4(command_call, $1, $2, $3, $4); + $$ = method_add_block($$, $5); + %*/ + } + break; + + case 424: + +/* Line 1806 of yacc.c */ +#line 3651 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(1) - (2)].node); + (yyval.node)->nd_args = (yyvsp[(2) - (2)].node); + /*% + $$ = method_arg(dispatch1(fcall, $1), $2); + %*/ + } + break; + + case 425: + +/* Line 1806 of yacc.c */ +#line 3660 "parse.y" + { + /*%%%*/ + (yyval.num) = ruby_sourceline; + /*% %*/ + } + break; + + case 426: + +/* Line 1806 of yacc.c */ +#line 3666 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].node)); + nd_set_line((yyval.node), (yyvsp[(4) - (5)].num)); + /*% + $$ = dispatch3(call, $1, ripper_id2sym('.'), $3); + $$ = method_optarg($$, $5); + %*/ + } + break; + + case 427: + +/* Line 1806 of yacc.c */ +#line 3676 "parse.y" + { + /*%%%*/ + (yyval.num) = ruby_sourceline; + /*% %*/ + } + break; + + case 428: + +/* Line 1806 of yacc.c */ +#line 3682 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].node)); + nd_set_line((yyval.node), (yyvsp[(4) - (5)].num)); + /*% + $$ = dispatch3(call, $1, ripper_id2sym('.'), $3); + $$ = method_optarg($$, $5); + %*/ + } + break; + + case 429: + +/* Line 1806 of yacc.c */ +#line 3692 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CALL((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id), 0); + /*% + $$ = dispatch3(call, $1, ID2SYM(idCOLON2), $3); + %*/ + } + break; + + case 430: + +/* Line 1806 of yacc.c */ +#line 3700 "parse.y" + { + /*%%%*/ + (yyval.num) = ruby_sourceline; + /*% %*/ + } + break; + + case 431: + +/* Line 1806 of yacc.c */ +#line 3706 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), idCall, (yyvsp[(4) - (4)].node)); + nd_set_line((yyval.node), (yyvsp[(3) - (4)].num)); + /*% + $$ = dispatch3(call, $1, ripper_id2sym('.'), + ID2SYM(idCall)); + $$ = method_optarg($$, $4); + %*/ + } + break; + + case 432: + +/* Line 1806 of yacc.c */ +#line 3717 "parse.y" + { + /*%%%*/ + (yyval.num) = ruby_sourceline; + /*% %*/ + } + break; + + case 433: + +/* Line 1806 of yacc.c */ +#line 3723 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), idCall, (yyvsp[(4) - (4)].node)); + nd_set_line((yyval.node), (yyvsp[(3) - (4)].num)); + /*% + $$ = dispatch3(call, $1, ID2SYM(idCOLON2), + ID2SYM(idCall)); + $$ = method_optarg($$, $4); + %*/ + } + break; + + case 434: + +/* Line 1806 of yacc.c */ +#line 3734 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node)); + /*% + $$ = dispatch1(super, $2); + %*/ + } + break; + + case 435: + +/* Line 1806 of yacc.c */ +#line 3742 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_ZSUPER(); + /*% + $$ = dispatch0(zsuper); + %*/ + } + break; + + case 436: + +/* Line 1806 of yacc.c */ +#line 3750 "parse.y" + { + /*%%%*/ + if ((yyvsp[(1) - (4)].node) && nd_type((yyvsp[(1) - (4)].node)) == NODE_SELF) + (yyval.node) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].node)); + else + (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), tAREF, (yyvsp[(3) - (4)].node)); + fixpos((yyval.node), (yyvsp[(1) - (4)].node)); + /*% + $$ = dispatch2(aref, $1, escape_Qundef($3)); + %*/ + } + break; + + case 437: + +/* Line 1806 of yacc.c */ +#line 3764 "parse.y" + { + (yyvsp[(1) - (1)].vars) = dyna_push(); + /*%%%*/ + (yyval.num) = ruby_sourceline; + /*% + %*/ + } + break; + + case 438: + +/* Line 1806 of yacc.c */ +#line 3773 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node)); + nd_set_line((yyval.node), (yyvsp[(2) - (5)].num)); + /*% + $$ = dispatch2(brace_block, escape_Qundef($3), $4); + %*/ + dyna_pop((yyvsp[(1) - (5)].vars)); + } + break; + + case 439: + +/* Line 1806 of yacc.c */ +#line 3783 "parse.y" + { + (yyvsp[(1) - (1)].vars) = dyna_push(); + /*%%%*/ + (yyval.num) = ruby_sourceline; + /*% + %*/ + } + break; + + case 440: + +/* Line 1806 of yacc.c */ +#line 3792 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node)); + nd_set_line((yyval.node), (yyvsp[(2) - (5)].num)); + /*% + $$ = dispatch2(do_block, escape_Qundef($3), $4); + %*/ + dyna_pop((yyvsp[(1) - (5)].vars)); + } + break; + + case 441: + +/* Line 1806 of yacc.c */ +#line 3806 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_WHEN((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node)); + /*% + $$ = dispatch3(when, $2, $4, escape_Qundef($5)); + %*/ + } + break; + + case 444: + +/* Line 1806 of yacc.c */ +#line 3822 "parse.y" + { + /*%%%*/ + if ((yyvsp[(3) - (6)].node)) { + (yyvsp[(3) - (6)].node) = node_assign((yyvsp[(3) - (6)].node), NEW_ERRINFO()); + (yyvsp[(5) - (6)].node) = block_append((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node)); + } + (yyval.node) = NEW_RESBODY((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node)); + fixpos((yyval.node), (yyvsp[(2) - (6)].node)?(yyvsp[(2) - (6)].node):(yyvsp[(5) - (6)].node)); + /*% + $$ = dispatch4(rescue, + escape_Qundef($2), + escape_Qundef($3), + escape_Qundef($5), + escape_Qundef($6)); + %*/ + } + break; + + case 446: + +/* Line 1806 of yacc.c */ +#line 3842 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node)); + /*% + $$ = rb_ary_new3(1, $1); + %*/ + } + break; + + case 447: + +/* Line 1806 of yacc.c */ +#line 3850 "parse.y" + { + /*%%%*/ + if (!((yyval.node) = splat_array((yyvsp[(1) - (1)].node)))) (yyval.node) = (yyvsp[(1) - (1)].node); + /*% + $$ = $1; + %*/ + } + break; + + case 449: + +/* Line 1806 of yacc.c */ +#line 3861 "parse.y" + { + (yyval.node) = (yyvsp[(2) - (2)].node); + } + break; + + case 451: + +/* Line 1806 of yacc.c */ +#line 3868 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (2)].node); + /*% + $$ = dispatch1(ensure, $2); + %*/ + } + break; + + case 454: + +/* Line 1806 of yacc.c */ +#line 3880 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id))); + /*% + $$ = dispatch1(symbol_literal, $1); + %*/ + } + break; + + case 456: + +/* Line 1806 of yacc.c */ +#line 3891 "parse.y" + { + /*%%%*/ + NODE *node = (yyvsp[(1) - (1)].node); + if (!node) { + node = NEW_STR(STR_NEW0()); + } + else { + node = evstr2dstr(node); + } + (yyval.node) = node; + /*% + $$ = $1; + %*/ + } + break; + + case 459: + +/* Line 1806 of yacc.c */ +#line 3910 "parse.y" + { + /*%%%*/ + (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); + /*% + $$ = dispatch2(string_concat, $1, $2); + %*/ + } + break; + + case 460: + +/* Line 1806 of yacc.c */ +#line 3920 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (3)].node); + /*% + $$ = dispatch1(string_literal, $2); + %*/ + } + break; + + case 461: + +/* Line 1806 of yacc.c */ +#line 3930 "parse.y" + { + /*%%%*/ + NODE *node = (yyvsp[(2) - (3)].node); + if (!node) { + node = NEW_XSTR(STR_NEW0()); + } + else { + switch (nd_type(node)) { + case NODE_STR: + nd_set_type(node, NODE_XSTR); + break; + case NODE_DSTR: + nd_set_type(node, NODE_DXSTR); + break; + default: + node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node)); + break; + } + } + (yyval.node) = node; + /*% + $$ = dispatch1(xstring_literal, $2); + %*/ + } + break; + + case 462: + +/* Line 1806 of yacc.c */ +#line 3957 "parse.y" + { + /*%%%*/ + int options = (yyvsp[(3) - (3)].num); + NODE *node = (yyvsp[(2) - (3)].node); + NODE *list, *prev; + if (!node) { + node = NEW_LIT(reg_compile(STR_NEW0(), options)); + } + else switch (nd_type(node)) { + case NODE_STR: + { + VALUE src = node->nd_lit; + nd_set_type(node, NODE_LIT); + node->nd_lit = reg_compile(src, options); + } + break; + default: + node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node)); + case NODE_DSTR: + if (options & RE_OPTION_ONCE) { + nd_set_type(node, NODE_DREGX_ONCE); + } + else { + nd_set_type(node, NODE_DREGX); + } + node->nd_cflag = options & RE_OPTION_MASK; + if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options); + for (list = (prev = node)->nd_next; list; list = list->nd_next) { + if (nd_type(list->nd_head) == NODE_STR) { + VALUE tail = list->nd_head->nd_lit; + if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) { + VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit; + if (!literal_concat0(parser, lit, tail)) { + node = 0; + break; + } + rb_str_resize(tail, 0); + prev->nd_next = list->nd_next; + rb_gc_force_recycle((VALUE)list->nd_head); + rb_gc_force_recycle((VALUE)list); + list = prev; + } + else { + prev = list; + } + } + else { + prev = 0; + } + } + if (!node->nd_next) { + VALUE src = node->nd_lit; + nd_set_type(node, NODE_LIT); + node->nd_lit = reg_compile(src, options); + } + break; + } + (yyval.node) = node; + /*% + VALUE re = $2, opt = $3, src = 0, err; + int options = 0; + if (ripper_is_node_yylval(re)) { + $2 = RNODE(re)->nd_rval; + src = RNODE(re)->nd_cval; + } + if (ripper_is_node_yylval(opt)) { + $3 = RNODE(opt)->nd_rval; + options = (int)RNODE(opt)->nd_state; + } + if (src && NIL_P(rb_parser_reg_compile(parser, src, options, &err))) { + compile_error(PARSER_ARG "%"PRIsVALUE, err); + } + $$ = dispatch2(regexp_literal, $2, $3); + %*/ + } + break; + + case 463: + +/* Line 1806 of yacc.c */ +#line 4035 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_ZARRAY(); + /*% + $$ = dispatch0(words_new); + $$ = dispatch1(array, $$); + %*/ + } + break; + + case 464: + +/* Line 1806 of yacc.c */ +#line 4044 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (3)].node); + /*% + $$ = dispatch1(array, $2); + %*/ + } + break; + + case 465: + +/* Line 1806 of yacc.c */ +#line 4054 "parse.y" + { + /*%%%*/ + (yyval.node) = 0; + /*% + $$ = dispatch0(words_new); + %*/ + } + break; + + case 466: + +/* Line 1806 of yacc.c */ +#line 4062 "parse.y" + { + /*%%%*/ + (yyval.node) = list_append((yyvsp[(1) - (3)].node), evstr2dstr((yyvsp[(2) - (3)].node))); + /*% + $$ = dispatch2(words_add, $1, $2); + %*/ + } + break; + + case 468: + +/* Line 1806 of yacc.c */ +#line 4080 "parse.y" + { + /*%%%*/ + (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); + /*% + $$ = dispatch2(word_add, $1, $2); + %*/ + } + break; + + case 469: + +/* Line 1806 of yacc.c */ +#line 4090 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_ZARRAY(); + /*% + $$ = dispatch0(symbols_new); + $$ = dispatch1(array, $$); + %*/ + } + break; + + case 470: + +/* Line 1806 of yacc.c */ +#line 4099 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (3)].node); + /*% + $$ = dispatch1(array, $2); + %*/ + } + break; + + case 471: + +/* Line 1806 of yacc.c */ +#line 4109 "parse.y" + { + /*%%%*/ + (yyval.node) = 0; + /*% + $$ = dispatch0(symbols_new); + %*/ + } + break; + + case 472: + +/* Line 1806 of yacc.c */ +#line 4117 "parse.y" + { + /*%%%*/ + (yyvsp[(2) - (3)].node) = evstr2dstr((yyvsp[(2) - (3)].node)); + if (nd_type((yyvsp[(2) - (3)].node)) == NODE_DSTR) { + nd_set_type((yyvsp[(2) - (3)].node), NODE_DSYM); + } + else { + nd_set_type((yyvsp[(2) - (3)].node), NODE_LIT); + (yyvsp[(2) - (3)].node)->nd_lit = rb_str_intern((yyvsp[(2) - (3)].node)->nd_lit); + } + (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node)); + /*% + $$ = dispatch2(symbols_add, $1, $2); + %*/ + } + break; + + case 473: + +/* Line 1806 of yacc.c */ +#line 4135 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_ZARRAY(); + /*% + $$ = dispatch0(qwords_new); + $$ = dispatch1(array, $$); + %*/ + } + break; + + case 474: + +/* Line 1806 of yacc.c */ +#line 4144 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (3)].node); + /*% + $$ = dispatch1(array, $2); + %*/ + } + break; + + case 475: + +/* Line 1806 of yacc.c */ +#line 4154 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_ZARRAY(); + /*% + $$ = dispatch0(qsymbols_new); + $$ = dispatch1(array, $$); + %*/ + } + break; + + case 476: + +/* Line 1806 of yacc.c */ +#line 4163 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (3)].node); + /*% + $$ = dispatch1(array, $2); + %*/ + } + break; + + case 477: + +/* Line 1806 of yacc.c */ +#line 4173 "parse.y" + { + /*%%%*/ + (yyval.node) = 0; + /*% + $$ = dispatch0(qwords_new); + %*/ + } + break; + + case 478: + +/* Line 1806 of yacc.c */ +#line 4181 "parse.y" + { + /*%%%*/ + (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node)); + /*% + $$ = dispatch2(qwords_add, $1, $2); + %*/ + } + break; + + case 479: + +/* Line 1806 of yacc.c */ +#line 4191 "parse.y" + { + /*%%%*/ + (yyval.node) = 0; + /*% + $$ = dispatch0(qsymbols_new); + %*/ + } + break; + + case 480: + +/* Line 1806 of yacc.c */ +#line 4199 "parse.y" + { + /*%%%*/ + VALUE lit; + lit = (yyvsp[(2) - (3)].node)->nd_lit; + (yyvsp[(2) - (3)].node)->nd_lit = ID2SYM(rb_intern_str(lit)); + nd_set_type((yyvsp[(2) - (3)].node), NODE_LIT); + (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node)); + /*% + $$ = dispatch2(qsymbols_add, $1, $2); + %*/ + } + break; + + case 481: + +/* Line 1806 of yacc.c */ +#line 4213 "parse.y" + { + /*%%%*/ + (yyval.node) = 0; + /*% + $$ = dispatch0(string_content); + %*/ + } + break; + + case 482: + +/* Line 1806 of yacc.c */ +#line 4221 "parse.y" + { + /*%%%*/ + (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); + /*% + $$ = dispatch2(string_add, $1, $2); + %*/ + } + break; + + case 483: + +/* Line 1806 of yacc.c */ +#line 4231 "parse.y" + { + /*%%%*/ + (yyval.node) = 0; + /*% + $$ = dispatch0(xstring_new); + %*/ + } + break; + + case 484: + +/* Line 1806 of yacc.c */ +#line 4239 "parse.y" + { + /*%%%*/ + (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); + /*% + $$ = dispatch2(xstring_add, $1, $2); + %*/ + } + break; + + case 485: + +/* Line 1806 of yacc.c */ +#line 4249 "parse.y" + { + /*%%%*/ + (yyval.node) = 0; + /*% + $$ = ripper_new_yylval(0, dispatch0(regexp_new), 0); + %*/ + } + break; + + case 486: + +/* Line 1806 of yacc.c */ +#line 4257 "parse.y" + { + /*%%%*/ + NODE *head = (yyvsp[(1) - (2)].node), *tail = (yyvsp[(2) - (2)].node); + if (!head) { + (yyval.node) = tail; + } + else if (!tail) { + (yyval.node) = head; + } + else { + switch (nd_type(head)) { + case NODE_STR: + nd_set_type(head, NODE_DSTR); + break; + case NODE_DSTR: + break; + default: + head = list_append(NEW_DSTR(Qnil), head); + break; + } + (yyval.node) = list_append(head, tail); + } + /*% + VALUE s1 = 1, s2 = 0, n1 = $1, n2 = $2; + if (ripper_is_node_yylval(n1)) { + s1 = RNODE(n1)->nd_cval; + n1 = RNODE(n1)->nd_rval; + } + if (ripper_is_node_yylval(n2)) { + s2 = RNODE(n2)->nd_cval; + n2 = RNODE(n2)->nd_rval; + } + $$ = dispatch2(regexp_add, n1, n2); + if (!s1 && s2) { + $$ = ripper_new_yylval(0, $$, s2); + } + %*/ + } + break; + + case 488: + +/* Line 1806 of yacc.c */ +#line 4299 "parse.y" + { + (yyval.node) = lex_strterm; + lex_strterm = 0; + lex_state = EXPR_BEG; + } + break; + + case 489: + +/* Line 1806 of yacc.c */ +#line 4305 "parse.y" + { + lex_strterm = (yyvsp[(2) - (3)].node); + /*%%%*/ + (yyval.node) = NEW_EVSTR((yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch1(string_dvar, $3); + %*/ + } + break; + + case 490: + +/* Line 1806 of yacc.c */ +#line 4314 "parse.y" + { + (yyvsp[(1) - (1)].val) = cond_stack; + (yyval.val) = cmdarg_stack; + cond_stack = 0; + cmdarg_stack = 0; + } + break; + + case 491: + +/* Line 1806 of yacc.c */ +#line 4320 "parse.y" + { + (yyval.node) = lex_strterm; + lex_strterm = 0; + } + break; + + case 492: + +/* Line 1806 of yacc.c */ +#line 4324 "parse.y" + { + (yyval.num) = lex_state; + lex_state = EXPR_BEG; + } + break; + + case 493: + +/* Line 1806 of yacc.c */ +#line 4328 "parse.y" + { + (yyval.num) = brace_nest; + brace_nest = 0; + } + break; + + case 494: + +/* Line 1806 of yacc.c */ +#line 4333 "parse.y" + { + cond_stack = (yyvsp[(1) - (7)].val); + cmdarg_stack = (yyvsp[(2) - (7)].val); + lex_strterm = (yyvsp[(3) - (7)].node); + lex_state = (yyvsp[(4) - (7)].num); + brace_nest = (yyvsp[(5) - (7)].num); + /*%%%*/ + if ((yyvsp[(6) - (7)].node)) (yyvsp[(6) - (7)].node)->flags &= ~NODE_FL_NEWLINE; + (yyval.node) = new_evstr((yyvsp[(6) - (7)].node)); + /*% + $$ = dispatch1(string_embexpr, $6); + %*/ + } + break; + + case 495: + +/* Line 1806 of yacc.c */ +#line 4349 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_GVAR((yyvsp[(1) - (1)].id)); + /*% + $$ = dispatch1(var_ref, $1); + %*/ + } + break; + + case 496: + +/* Line 1806 of yacc.c */ +#line 4357 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_IVAR((yyvsp[(1) - (1)].id)); + /*% + $$ = dispatch1(var_ref, $1); + %*/ + } + break; + + case 497: + +/* Line 1806 of yacc.c */ +#line 4365 "parse.y" + { + /*%%%*/ + (yyval.node) = NEW_CVAR((yyvsp[(1) - (1)].id)); + /*% + $$ = dispatch1(var_ref, $1); + %*/ + } + break; + + case 499: + +/* Line 1806 of yacc.c */ +#line 4376 "parse.y" + { + lex_state = EXPR_END; + /*%%%*/ + (yyval.id) = (yyvsp[(2) - (2)].id); + /*% + $$ = dispatch1(symbol, $2); + %*/ + } + break; + + case 504: + +/* Line 1806 of yacc.c */ +#line 4393 "parse.y" + { + lex_state = EXPR_END; + /*%%%*/ + (yyval.node) = dsym_node((yyvsp[(2) - (3)].node)); + /*% + $$ = dispatch1(dyna_symbol, $2); + %*/ + } + break; + + case 506: + +/* Line 1806 of yacc.c */ +#line 4405 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (2)].node); + (yyval.node)->nd_lit = negate_lit((yyval.node)->nd_lit); + /*% + $$ = dispatch2(unary, ID2SYM(idUMinus), $2); + %*/ + } + break; + + case 516: + +/* Line 1806 of yacc.c */ +#line 4428 "parse.y" + {ifndef_ripper((yyval.id) = keyword_nil);} + break; + + case 517: + +/* Line 1806 of yacc.c */ +#line 4429 "parse.y" + {ifndef_ripper((yyval.id) = keyword_self);} + break; + + case 518: + +/* Line 1806 of yacc.c */ +#line 4430 "parse.y" + {ifndef_ripper((yyval.id) = keyword_true);} + break; + + case 519: + +/* Line 1806 of yacc.c */ +#line 4431 "parse.y" + {ifndef_ripper((yyval.id) = keyword_false);} + break; + + case 520: + +/* Line 1806 of yacc.c */ +#line 4432 "parse.y" + {ifndef_ripper((yyval.id) = keyword__FILE__);} + break; + + case 521: + +/* Line 1806 of yacc.c */ +#line 4433 "parse.y" + {ifndef_ripper((yyval.id) = keyword__LINE__);} + break; + + case 522: + +/* Line 1806 of yacc.c */ +#line 4434 "parse.y" + {ifndef_ripper((yyval.id) = keyword__ENCODING__);} + break; + + case 523: + +/* Line 1806 of yacc.c */ +#line 4438 "parse.y" + { + /*%%%*/ + if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0); + /*% + if (id_is_var(get_id($1))) { + $$ = dispatch1(var_ref, $1); + } + else { + $$ = dispatch1(vcall, $1); + } + %*/ + } + break; + + case 524: + +/* Line 1806 of yacc.c */ +#line 4451 "parse.y" + { + /*%%%*/ + if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0); + /*% + $$ = dispatch1(var_ref, $1); + %*/ + } + break; + + case 525: + +/* Line 1806 of yacc.c */ +#line 4461 "parse.y" + { + (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0); + /*%%%*/ + /*% + $$ = dispatch1(var_field, $$); + %*/ + } + break; + + case 526: + +/* Line 1806 of yacc.c */ +#line 4469 "parse.y" + { + (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0); + /*%%%*/ + /*% + $$ = dispatch1(var_field, $$); + %*/ + } + break; + + case 529: + +/* Line 1806 of yacc.c */ +#line 4483 "parse.y" + { + /*%%%*/ + (yyval.node) = 0; + /*% + $$ = Qnil; + %*/ + } + break; + + case 530: + +/* Line 1806 of yacc.c */ +#line 4491 "parse.y" + { + lex_state = EXPR_BEG; + command_start = TRUE; + } + break; + + case 531: + +/* Line 1806 of yacc.c */ +#line 4496 "parse.y" + { + (yyval.node) = (yyvsp[(3) - (4)].node); + } + break; + + case 532: + +/* Line 1806 of yacc.c */ +#line 4500 "parse.y" + { + /*%%%*/ + yyerrok; + (yyval.node) = 0; + /*% + yyerrok; + $$ = Qnil; + %*/ + } + break; + + case 533: + +/* Line 1806 of yacc.c */ +#line 4512 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(2) - (3)].node); + /*% + $$ = dispatch1(paren, $2); + %*/ + lex_state = EXPR_BEG; + command_start = TRUE; + } + break; + + case 534: + +/* Line 1806 of yacc.c */ +#line 4521 "parse.y" + { + (yyval.num) = parser->parser_in_kwarg; + parser->parser_in_kwarg = 1; + } + break; + + case 535: + +/* Line 1806 of yacc.c */ +#line 4526 "parse.y" + { + parser->parser_in_kwarg = (yyvsp[(1) - (3)].num); + (yyval.node) = (yyvsp[(2) - (3)].node); + lex_state = EXPR_BEG; + command_start = TRUE; + } + break; + + case 536: + +/* Line 1806 of yacc.c */ +#line 4535 "parse.y" + { + (yyval.node) = new_args_tail((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id)); + } + break; + + case 537: + +/* Line 1806 of yacc.c */ +#line 4539 "parse.y" + { + (yyval.node) = new_args_tail((yyvsp[(1) - (2)].node), Qnone, (yyvsp[(2) - (2)].id)); + } + break; + + case 538: + +/* Line 1806 of yacc.c */ +#line 4543 "parse.y" + { + (yyval.node) = new_args_tail(Qnone, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id)); + } + break; + + case 539: + +/* Line 1806 of yacc.c */ +#line 4547 "parse.y" + { + (yyval.node) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].id)); + } + break; + + case 540: + +/* Line 1806 of yacc.c */ +#line 4553 "parse.y" + { + (yyval.node) = (yyvsp[(2) - (2)].node); + } + break; + + case 541: + +/* Line 1806 of yacc.c */ +#line 4557 "parse.y" + { + (yyval.node) = new_args_tail(Qnone, Qnone, Qnone); + } + break; + + case 542: + +/* Line 1806 of yacc.c */ +#line 4563 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), Qnone, (yyvsp[(6) - (6)].node)); + } + break; + + case 543: + +/* Line 1806 of yacc.c */ +#line 4567 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].node)); + } + break; + + case 544: + +/* Line 1806 of yacc.c */ +#line 4571 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), Qnone, Qnone, (yyvsp[(4) - (4)].node)); + } + break; + + case 545: + +/* Line 1806 of yacc.c */ +#line 4575 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), Qnone, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node)); + } + break; + + case 546: + +/* Line 1806 of yacc.c */ +#line 4579 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node)); + } + break; + + case 547: + +/* Line 1806 of yacc.c */ +#line 4583 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (6)].node), Qnone, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node)); + } + break; + + case 548: + +/* Line 1806 of yacc.c */ +#line 4587 "parse.y" + { + (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].node)); + } + break; + + case 549: + +/* Line 1806 of yacc.c */ +#line 4591 "parse.y" + { + (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node)); + } + break; + + case 550: + +/* Line 1806 of yacc.c */ +#line 4595 "parse.y" + { + (yyval.node) = new_args(Qnone, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node)); + } + break; + + case 551: + +/* Line 1806 of yacc.c */ +#line 4599 "parse.y" + { + (yyval.node) = new_args(Qnone, (yyvsp[(1) - (2)].node), Qnone, Qnone, (yyvsp[(2) - (2)].node)); + } + break; + + case 552: + +/* Line 1806 of yacc.c */ +#line 4603 "parse.y" + { + (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node)); + } + break; + + case 553: + +/* Line 1806 of yacc.c */ +#line 4607 "parse.y" + { + (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].id), Qnone, (yyvsp[(2) - (2)].node)); + } + break; + + case 554: + +/* Line 1806 of yacc.c */ +#line 4611 "parse.y" + { + (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node)); + } + break; + + case 555: + +/* Line 1806 of yacc.c */ +#line 4615 "parse.y" + { + (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].node)); + } + break; + + case 556: + +/* Line 1806 of yacc.c */ +#line 4619 "parse.y" + { + (yyval.node) = new_args_tail(Qnone, Qnone, Qnone); + (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.node)); + } + break; + + case 557: + +/* Line 1806 of yacc.c */ +#line 4626 "parse.y" + { + /*%%%*/ + yyerror("formal argument cannot be a constant"); + (yyval.id) = 0; + /*% + $$ = dispatch1(param_error, $1); + ripper_error(); + %*/ + } + break; + + case 558: + +/* Line 1806 of yacc.c */ +#line 4636 "parse.y" + { + /*%%%*/ + yyerror("formal argument cannot be an instance variable"); + (yyval.id) = 0; + /*% + $$ = dispatch1(param_error, $1); + ripper_error(); + %*/ + } + break; + + case 559: + +/* Line 1806 of yacc.c */ +#line 4646 "parse.y" + { + /*%%%*/ + yyerror("formal argument cannot be a global variable"); + (yyval.id) = 0; + /*% + $$ = dispatch1(param_error, $1); + ripper_error(); + %*/ + } + break; + + case 560: + +/* Line 1806 of yacc.c */ +#line 4656 "parse.y" + { + /*%%%*/ + yyerror("formal argument cannot be a class variable"); + (yyval.id) = 0; + /*% + $$ = dispatch1(param_error, $1); + ripper_error(); + %*/ + } + break; + + case 562: + +/* Line 1806 of yacc.c */ +#line 4669 "parse.y" + { + formal_argument(get_id((yyvsp[(1) - (1)].id))); + (yyval.id) = (yyvsp[(1) - (1)].id); + } + break; + + case 563: + +/* Line 1806 of yacc.c */ +#line 4676 "parse.y" + { + ID id = get_id((yyvsp[(1) - (1)].id)); + arg_var(id); + current_arg = id; + (yyval.id) = (yyvsp[(1) - (1)].id); + } + break; + + case 564: + +/* Line 1806 of yacc.c */ +#line 4685 "parse.y" + { + current_arg = 0; + /*%%%*/ + (yyval.node) = NEW_ARGS_AUX((yyvsp[(1) - (1)].id), 1); + /*% + $$ = get_value($1); + %*/ + } + break; + + case 565: + +/* Line 1806 of yacc.c */ +#line 4694 "parse.y" + { + ID tid = internal_id(); + arg_var(tid); + /*%%%*/ + if (dyna_in_block()) { + (yyvsp[(2) - (3)].node)->nd_value = NEW_DVAR(tid); + } + else { + (yyvsp[(2) - (3)].node)->nd_value = NEW_LVAR(tid); + } + (yyval.node) = NEW_ARGS_AUX(tid, 1); + (yyval.node)->nd_next = (yyvsp[(2) - (3)].node); + /*% + $$ = dispatch1(mlhs_paren, $2); + %*/ + } + break; + + case 567: + +/* Line 1806 of yacc.c */ +#line 4720 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(1) - (3)].node); + (yyval.node)->nd_plen++; + (yyval.node)->nd_next = block_append((yyval.node)->nd_next, (yyvsp[(3) - (3)].node)->nd_next); + rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].node)); + /*% + $$ = rb_ary_push($1, $3); + %*/ + } + break; + + case 568: + +/* Line 1806 of yacc.c */ +#line 4734 "parse.y" + { + ID id = get_id((yyvsp[(1) - (1)].id)); + arg_var(formal_argument(id)); + current_arg = id; + (yyval.id) = (yyvsp[(1) - (1)].id); + } + break; + + case 569: + +/* Line 1806 of yacc.c */ +#line 4743 "parse.y" + { + current_arg = 0; + (yyval.node) = assignable((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node)); + /*%%%*/ + (yyval.node) = new_kw_arg((yyval.node)); + /*% + $$ = rb_assoc_new($$, $2); + %*/ + } + break; + + case 570: + +/* Line 1806 of yacc.c */ +#line 4753 "parse.y" + { + current_arg = 0; + (yyval.node) = assignable((yyvsp[(1) - (1)].id), (NODE *)-1); + /*%%%*/ + (yyval.node) = new_kw_arg((yyval.node)); + /*% + $$ = rb_assoc_new($$, 0); + %*/ + } + break; + + case 571: + +/* Line 1806 of yacc.c */ +#line 4765 "parse.y" + { + (yyval.node) = assignable((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node)); + /*%%%*/ + (yyval.node) = new_kw_arg((yyval.node)); + /*% + $$ = rb_assoc_new($$, $2); + %*/ + } + break; + + case 572: + +/* Line 1806 of yacc.c */ +#line 4774 "parse.y" + { + (yyval.node) = assignable((yyvsp[(1) - (1)].id), (NODE *)-1); + /*%%%*/ + (yyval.node) = new_kw_arg((yyval.node)); + /*% + $$ = rb_assoc_new($$, 0); + %*/ + } + break; + + case 573: + +/* Line 1806 of yacc.c */ +#line 4785 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(1) - (1)].node); + /*% + $$ = rb_ary_new3(1, $1); + %*/ + } + break; + + case 574: + +/* Line 1806 of yacc.c */ +#line 4793 "parse.y" + { + /*%%%*/ + NODE *kws = (yyvsp[(1) - (3)].node); + + while (kws->nd_next) { + kws = kws->nd_next; + } + kws->nd_next = (yyvsp[(3) - (3)].node); + (yyval.node) = (yyvsp[(1) - (3)].node); + /*% + $$ = rb_ary_push($1, $3); + %*/ + } + break; + + case 575: + +/* Line 1806 of yacc.c */ +#line 4810 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(1) - (1)].node); + /*% + $$ = rb_ary_new3(1, $1); + %*/ + } + break; + + case 576: + +/* Line 1806 of yacc.c */ +#line 4818 "parse.y" + { + /*%%%*/ + NODE *kws = (yyvsp[(1) - (3)].node); + + while (kws->nd_next) { + kws = kws->nd_next; + } + kws->nd_next = (yyvsp[(3) - (3)].node); + (yyval.node) = (yyvsp[(1) - (3)].node); + /*% + $$ = rb_ary_push($1, $3); + %*/ + } + break; + + case 579: + +/* Line 1806 of yacc.c */ +#line 4838 "parse.y" + { + shadowing_lvar(get_id((yyvsp[(2) - (2)].id))); + (yyval.id) = (yyvsp[(2) - (2)].id); + } + break; + + case 580: + +/* Line 1806 of yacc.c */ +#line 4843 "parse.y" + { + (yyval.id) = internal_id(); + arg_var((yyval.id)); + } + break; + + case 581: + +/* Line 1806 of yacc.c */ +#line 4850 "parse.y" + { + current_arg = 0; + (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node)); + /*%%%*/ + (yyval.node) = NEW_OPT_ARG(0, (yyval.node)); + /*% + $$ = rb_assoc_new($$, $3); + %*/ + } + break; + + case 582: + +/* Line 1806 of yacc.c */ +#line 4862 "parse.y" + { + current_arg = 0; + (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node)); + /*%%%*/ + (yyval.node) = NEW_OPT_ARG(0, (yyval.node)); + /*% + $$ = rb_assoc_new($$, $3); + %*/ + } + break; + + case 583: + +/* Line 1806 of yacc.c */ +#line 4874 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(1) - (1)].node); + /*% + $$ = rb_ary_new3(1, $1); + %*/ + } + break; + + case 584: + +/* Line 1806 of yacc.c */ +#line 4882 "parse.y" + { + /*%%%*/ + NODE *opts = (yyvsp[(1) - (3)].node); + + while (opts->nd_next) { + opts = opts->nd_next; + } + opts->nd_next = (yyvsp[(3) - (3)].node); + (yyval.node) = (yyvsp[(1) - (3)].node); + /*% + $$ = rb_ary_push($1, $3); + %*/ + } + break; + + case 585: + +/* Line 1806 of yacc.c */ +#line 4898 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(1) - (1)].node); + /*% + $$ = rb_ary_new3(1, $1); + %*/ + } + break; + + case 586: + +/* Line 1806 of yacc.c */ +#line 4906 "parse.y" + { + /*%%%*/ + NODE *opts = (yyvsp[(1) - (3)].node); + + while (opts->nd_next) { + opts = opts->nd_next; + } + opts->nd_next = (yyvsp[(3) - (3)].node); + (yyval.node) = (yyvsp[(1) - (3)].node); + /*% + $$ = rb_ary_push($1, $3); + %*/ + } + break; + + case 589: + +/* Line 1806 of yacc.c */ +#line 4926 "parse.y" + { + /*%%%*/ + if (!is_local_id((yyvsp[(2) - (2)].id))) + yyerror("rest argument must be local variable"); + /*% %*/ + arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id)))); + /*%%%*/ + (yyval.id) = (yyvsp[(2) - (2)].id); + /*% + $$ = dispatch1(rest_param, $2); + %*/ + } + break; + + case 590: + +/* Line 1806 of yacc.c */ +#line 4939 "parse.y" + { + /*%%%*/ + (yyval.id) = internal_id(); + arg_var((yyval.id)); + /*% + $$ = dispatch1(rest_param, Qnil); + %*/ + } + break; + + case 593: + +/* Line 1806 of yacc.c */ +#line 4954 "parse.y" + { + /*%%%*/ + if (!is_local_id((yyvsp[(2) - (2)].id))) + yyerror("block argument must be local variable"); + else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].id))) + yyerror("duplicated block argument name"); + /*% %*/ + arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id)))); + /*%%%*/ + (yyval.id) = (yyvsp[(2) - (2)].id); + /*% + $$ = dispatch1(blockarg, $2); + %*/ + } + break; + + case 594: + +/* Line 1806 of yacc.c */ +#line 4971 "parse.y" + { + (yyval.id) = (yyvsp[(2) - (2)].id); + } + break; + + case 595: + +/* Line 1806 of yacc.c */ +#line 4975 "parse.y" + { + /*%%%*/ + (yyval.id) = 0; + /*% + $$ = Qundef; + %*/ + } + break; + + case 596: + +/* Line 1806 of yacc.c */ +#line 4985 "parse.y" + { + /*%%%*/ + value_expr((yyvsp[(1) - (1)].node)); + (yyval.node) = (yyvsp[(1) - (1)].node); + if (!(yyval.node)) (yyval.node) = NEW_NIL(); + /*% + $$ = $1; + %*/ + } + break; + + case 597: + +/* Line 1806 of yacc.c */ +#line 4994 "parse.y" + {lex_state = EXPR_BEG;} + break; + + case 598: + +/* Line 1806 of yacc.c */ +#line 4995 "parse.y" + { + /*%%%*/ + if ((yyvsp[(3) - (4)].node) == 0) { + yyerror("can't define singleton method for ()."); + } + else { + switch (nd_type((yyvsp[(3) - (4)].node))) { + case NODE_STR: + case NODE_DSTR: + case NODE_XSTR: + case NODE_DXSTR: + case NODE_DREGX: + case NODE_LIT: + case NODE_ARRAY: + case NODE_ZARRAY: + yyerror("can't define singleton method for literals"); + default: + value_expr((yyvsp[(3) - (4)].node)); + break; + } + } + (yyval.node) = (yyvsp[(3) - (4)].node); + /*% + $$ = dispatch1(paren, $3); + %*/ + } + break; + + case 600: + +/* Line 1806 of yacc.c */ +#line 5025 "parse.y" + { + /*%%%*/ + (yyval.node) = (yyvsp[(1) - (2)].node); + /*% + $$ = dispatch1(assoclist_from_args, $1); + %*/ + } + break; + + case 602: + +/* Line 1806 of yacc.c */ +#line 5042 "parse.y" + { + /*%%%*/ + NODE *assocs = (yyvsp[(1) - (3)].node); + NODE *tail = (yyvsp[(3) - (3)].node); + if (!assocs) { + assocs = tail; + } + else if (tail) { + if (assocs->nd_head && + !tail->nd_head && nd_type(tail->nd_next) == NODE_ARRAY && + nd_type(tail->nd_next->nd_head) == NODE_HASH) { + /* DSTAR */ + tail = tail->nd_next->nd_head->nd_head; + } + assocs = list_concat(assocs, tail); + } + (yyval.node) = assocs; + /*% + $$ = rb_ary_push($1, $3); + %*/ + } + break; + + case 603: + +/* Line 1806 of yacc.c */ +#line 5066 "parse.y" + { + /*%%%*/ + if (nd_type((yyvsp[(1) - (3)].node)) == NODE_STR) { + nd_set_type((yyvsp[(1) - (3)].node), NODE_LIT); + (yyvsp[(1) - (3)].node)->nd_lit = rb_fstring((yyvsp[(1) - (3)].node)->nd_lit); + } + (yyval.node) = list_append(NEW_LIST((yyvsp[(1) - (3)].node)), (yyvsp[(3) - (3)].node)); + /*% + $$ = dispatch2(assoc_new, $1, $3); + %*/ + } + break; + + case 604: + +/* Line 1806 of yacc.c */ +#line 5078 "parse.y" + { + /*%%%*/ + (yyval.node) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].id)))), (yyvsp[(2) - (2)].node)); + /*% + $$ = dispatch2(assoc_new, $1, $2); + %*/ + } + break; + + case 605: + +/* Line 1806 of yacc.c */ +#line 5086 "parse.y" + { + /*%%%*/ + (yyval.node) = list_append(NEW_LIST(dsym_node((yyvsp[(2) - (4)].node))), (yyvsp[(4) - (4)].node)); + /*% + $$ = dispatch2(assoc_new, dispatch1(dyna_symbol, $2), $4); + %*/ + } + break; + + case 606: + +/* Line 1806 of yacc.c */ +#line 5094 "parse.y" + { + /*%%%*/ + if (nd_type((yyvsp[(2) - (2)].node)) == NODE_HASH && + !((yyvsp[(2) - (2)].node)->nd_head && (yyvsp[(2) - (2)].node)->nd_head->nd_alen)) + (yyval.node) = 0; + else + (yyval.node) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].node)); + /*% + $$ = dispatch1(assoc_splat, $2); + %*/ + } + break; + + case 628: + +/* Line 1806 of yacc.c */ +#line 5154 "parse.y" + {yyerrok;} + break; + + case 631: + +/* Line 1806 of yacc.c */ +#line 5159 "parse.y" + {yyerrok;} + break; + + case 632: + +/* Line 1806 of yacc.c */ +#line 5163 "parse.y" + { + /*%%%*/ + (yyval.node) = 0; + /*% + $$ = Qundef; + %*/ + } + break; + + + +/* Line 1806 of yacc.c */ +#line 11466 "parse.c" + default: break; + } + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); + + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if ! YYERROR_VERBOSE + parser_yyerror (parser, YY_("syntax error")); +#else +# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ + yyssp, yytoken) + { + char const *yymsgp = YY_("syntax error"); + int yysyntax_error_status; + yysyntax_error_status = YYSYNTAX_ERROR; + if (yysyntax_error_status == 0) + yymsgp = yymsg; + else if (yysyntax_error_status == 1) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); + if (!yymsg) + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = 2; + } + else + { + yysyntax_error_status = YYSYNTAX_ERROR; + yymsgp = yymsg; + } + } + parser_yyerror (parser, yymsgp); + if (yysyntax_error_status == 2) + goto yyexhaustedlab; + } +# undef YYSYNTAX_ERROR +#endif + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval, parser); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + yystos[yystate], yyvsp, parser); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + *++yyvsp = yylval; + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#if !defined(yyoverflow) || YYERROR_VERBOSE +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + parser_yyerror (parser, YY_("memory exhausted")); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEMPTY) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval, parser); + } + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + yystos[*yyssp], yyvsp, parser); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); +#endif + /* Make sure YYID is used. */ + return YYID (yyresult); +} + + + +/* Line 2067 of yacc.c */ +#line 5171 "parse.y" + +# undef parser +# undef yylex +# undef yylval +# define yylval (*((YYSTYPE*)(parser->parser_yylval))) + +static int parser_regx_options(struct parser_params*); +static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**); +static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc); +static int parser_parse_string(struct parser_params*,NODE*); +static int parser_here_document(struct parser_params*,NODE*); + + +# define nextc() parser_nextc(parser) +# define pushback(c) parser_pushback(parser, (c)) +# define newtok() parser_newtok(parser) +# define tokspace(n) parser_tokspace(parser, (n)) +# define tokadd(c) parser_tokadd(parser, (c)) +# define tok_hex(numlen) parser_tok_hex(parser, (numlen)) +# define read_escape(flags,e) parser_read_escape(parser, (flags), (e)) +# define tokadd_escape(e) parser_tokadd_escape(parser, (e)) +# define regx_options() parser_regx_options(parser) +# define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e)) +# define parse_string(n) parser_parse_string(parser,(n)) +# define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc)) +# define here_document(n) parser_here_document(parser,(n)) +# define heredoc_identifier() parser_heredoc_identifier(parser) +# define heredoc_restore(n) parser_heredoc_restore(parser,(n)) +# define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i)) +# define number_literal_suffix(f) parser_number_literal_suffix(parser, (f)) +# define set_number_literal(v, t, f) parser_set_number_literal(parser, (v), (t), (f)) +# define set_integer_literal(v, f) parser_set_integer_literal(parser, (v), (f)) + +#ifndef RIPPER +# define set_yylval_str(x) (yylval.node = NEW_STR(x)) +# define set_yylval_num(x) (yylval.num = (x)) +# define set_yylval_id(x) (yylval.id = (x)) +# define set_yylval_name(x) (yylval.id = (x)) +# define set_yylval_literal(x) (yylval.node = NEW_LIT(x)) +# define set_yylval_node(x) (yylval.node = (x)) +# define yylval_id() (yylval.id) +#else +static inline VALUE +ripper_yylval_id(ID x) +{ + return ripper_new_yylval(x, ID2SYM(x), 0); +} +# define set_yylval_str(x) (yylval.val = (x)) +# define set_yylval_num(x) (yylval.val = ripper_new_yylval((x), 0, 0)) +# define set_yylval_id(x) (void)(x) +# define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x)) +# define set_yylval_literal(x) (void)(x) +# define set_yylval_node(x) (void)(x) +# define yylval_id() yylval.id +#endif + +#ifndef RIPPER +#define ripper_flush(p) (void)(p) +#else +#define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p) + +#define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val)) + +static inline VALUE +intern_sym(const char *name) +{ + ID id = rb_intern_const(name); + return ID2SYM(id); +} + +static int +ripper_has_scan_event(struct parser_params *parser) +{ + + if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp"); + return lex_p > parser->tokp; +} + +static VALUE +ripper_scan_event_val(struct parser_params *parser, int t) +{ + VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp); + VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str); + ripper_flush(parser); + return rval; +} + +static void +ripper_dispatch_scan_event(struct parser_params *parser, int t) +{ + if (!ripper_has_scan_event(parser)) return; + yylval_rval = ripper_scan_event_val(parser, t); +} + +static void +ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t) +{ + if (!ripper_has_scan_event(parser)) return; + (void)ripper_scan_event_val(parser, t); +} + +static void +ripper_dispatch_delayed_token(struct parser_params *parser, int t) +{ + int saved_line = ruby_sourceline; + const char *saved_tokp = parser->tokp; + + ruby_sourceline = parser->delayed_line; + parser->tokp = lex_pbeg + parser->delayed_col; + yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed); + parser->delayed = Qnil; + ruby_sourceline = saved_line; + parser->tokp = saved_tokp; +} +#endif /* RIPPER */ + +#include "ruby/regex.h" +#include "ruby/util.h" + +/* We remove any previous definition of `SIGN_EXTEND_CHAR', + since ours (we hope) works properly with all combinations of + machines, compilers, `char' and `unsigned char' argument types. + (Per Bothner suggested the basic approach.) */ +#undef SIGN_EXTEND_CHAR +#if __STDC__ +# define SIGN_EXTEND_CHAR(c) ((signed char)(c)) +#else /* not __STDC__ */ +/* As in Harbison and Steele. */ +# define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128) +#endif + +#define parser_encoding_name() (current_enc->name) +#define parser_mbclen() mbclen((lex_p-1),lex_pend,current_enc) +#define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc) +#define is_identchar(p,e,enc) (rb_enc_isalnum((unsigned char)(*(p)),(enc)) || (*(p)) == '_' || !ISASCII(*(p))) +#define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc)) + +#define parser_isascii() ISASCII(*(lex_p-1)) + +#ifndef RIPPER +static int +token_info_get_column(struct parser_params *parser, const char *token) +{ + int column = 1; + const char *p, *pend = lex_p - strlen(token); + for (p = lex_pbeg; p < pend; p++) { + if (*p == '\t') { + column = (((column - 1) / 8) + 1) * 8; + } + column++; + } + return column; +} + +static int +token_info_has_nonspaces(struct parser_params *parser, const char *token) +{ + const char *p, *pend = lex_p - strlen(token); + for (p = lex_pbeg; p < pend; p++) { + if (*p != ' ' && *p != '\t') { + return 1; + } + } + return 0; +} + +#undef token_info_push +static void +token_info_push(struct parser_params *parser, const char *token) +{ + token_info *ptinfo; + + if (!parser->parser_token_info_enabled) return; + ptinfo = ALLOC(token_info); + ptinfo->token = token; + ptinfo->linenum = ruby_sourceline; + ptinfo->column = token_info_get_column(parser, token); + ptinfo->nonspc = token_info_has_nonspaces(parser, token); + ptinfo->next = parser->parser_token_info; + + parser->parser_token_info = ptinfo; +} + +#undef token_info_pop +static void +token_info_pop(struct parser_params *parser, const char *token) +{ + int linenum; + token_info *ptinfo = parser->parser_token_info; + + if (!ptinfo) return; + parser->parser_token_info = ptinfo->next; + if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */ + goto finish; + } + linenum = ruby_sourceline; + if (linenum == ptinfo->linenum) { /* SKIP */ + goto finish; + } + if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */ + goto finish; + } + if (parser->parser_token_info_enabled) { + rb_compile_warn(ruby_sourcefile, linenum, + "mismatched indentations at '%s' with '%s' at %d", + token, ptinfo->token, ptinfo->linenum); + } + + finish: + xfree(ptinfo); +} +#endif /* RIPPER */ + +static int +parser_yyerror(struct parser_params *parser, const char *msg) +{ +#ifndef RIPPER + const int max_line_margin = 30; + const char *p, *pe; + char *buf; + long len; + int i; + + compile_error(PARSER_ARG "%s", msg); + p = lex_p; + while (lex_pbeg <= p) { + if (*p == '\n') break; + p--; + } + p++; + + pe = lex_p; + while (pe < lex_pend) { + if (*pe == '\n') break; + pe++; + } + + len = pe - p; + if (len > 4) { + char *p2; + const char *pre = "", *post = ""; + + if (len > max_line_margin * 2 + 10) { + if (lex_p - p > max_line_margin) { + p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline)); + pre = "..."; + } + if (pe - lex_p > max_line_margin) { + pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline)); + post = "..."; + } + len = pe - p; + } + buf = ALLOCA_N(char, len+2); + MEMCPY(buf, p, char, len); + buf[len] = '\0'; + rb_compile_error_with_enc(NULL, 0, (void *)current_enc, "%s%s%s", pre, buf, post); + + i = (int)(lex_p - p); + p2 = buf; pe = buf + len; + + while (p2 < pe) { + if (*p2 != '\t') *p2 = ' '; + p2++; + } + buf[i] = '^'; + buf[i+1] = '\0'; + rb_compile_error_append("%s%s", pre, buf); + } +#else + dispatch1(parse_error, STR_NEW2(msg)); + ripper_error(); +#endif /* !RIPPER */ + return 0; +} + +static void parser_prepare(struct parser_params *parser); + +#ifndef RIPPER +static VALUE +debug_lines(VALUE fname) +{ + ID script_lines; + CONST_ID(script_lines, "SCRIPT_LINES__"); + if (rb_const_defined_at(rb_cObject, script_lines)) { + VALUE hash = rb_const_get_at(rb_cObject, script_lines); + if (RB_TYPE_P(hash, T_HASH)) { + VALUE lines = rb_ary_new(); + rb_hash_aset(hash, fname, lines); + return lines; + } + } + return 0; +} + +static VALUE +coverage(VALUE fname, int n) +{ + VALUE coverages = rb_get_coverages(); + if (RTEST(coverages) && RBASIC(coverages)->klass == 0) { + VALUE lines = rb_ary_tmp_new_fill(n); + rb_hash_aset(coverages, fname, lines); + return lines; + } + return 0; +} + +static int +e_option_supplied(struct parser_params *parser) +{ + return strcmp(ruby_sourcefile, "-e") == 0; +} + +static VALUE +yycompile0(VALUE arg) +{ + int n; + NODE *tree; + struct parser_params *parser = (struct parser_params *)arg; + + if (!compile_for_eval && rb_safe_level() == 0) { + ruby_debug_lines = debug_lines(ruby_sourcefile_string); + if (ruby_debug_lines && ruby_sourceline > 0) { + VALUE str = STR_NEW0(); + n = ruby_sourceline; + do { + rb_ary_push(ruby_debug_lines, str); + } while (--n); + } + + if (!e_option_supplied(parser)) { + ruby_coverage = coverage(ruby_sourcefile_string, ruby_sourceline); + } + } + parser->last_cr_line = ruby_sourceline - 1; + + parser_prepare(parser); + deferred_nodes = 0; +#ifndef RIPPER + parser->parser_token_info_enabled = !compile_for_eval && RTEST(ruby_verbose); +#endif +#ifndef RIPPER + if (RUBY_DTRACE_PARSE_BEGIN_ENABLED()) { + RUBY_DTRACE_PARSE_BEGIN(parser->parser_ruby_sourcefile, + parser->parser_ruby_sourceline); + } +#endif + n = yyparse((void*)parser); +#ifndef RIPPER + if (RUBY_DTRACE_PARSE_END_ENABLED()) { + RUBY_DTRACE_PARSE_END(parser->parser_ruby_sourcefile, + parser->parser_ruby_sourceline); + } +#endif + ruby_debug_lines = 0; + ruby_coverage = 0; + compile_for_eval = 0; + + lex_strterm = 0; + lex_p = lex_pbeg = lex_pend = 0; + lex_lastline = lex_nextline = 0; + if (parser->nerr) { + return 0; + } + tree = ruby_eval_tree; + if (!tree) { + tree = NEW_NIL(); + } + else if (ruby_eval_tree_begin) { + tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body); + } + return (VALUE)tree; +} + +static NODE* +yycompile(struct parser_params *parser, VALUE fname, int line) +{ + ruby_sourcefile_string = rb_str_new_frozen(fname); + ruby_sourcefile = RSTRING_PTR(fname); + ruby_sourceline = line - 1; + return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser); +} +#endif /* !RIPPER */ + +static rb_encoding * +must_be_ascii_compatible(VALUE s) +{ + rb_encoding *enc = rb_enc_get(s); + if (!rb_enc_asciicompat(enc)) { + rb_raise(rb_eArgError, "invalid source encoding"); + } + return enc; +} + +static VALUE +lex_get_str(struct parser_params *parser, VALUE s) +{ + char *beg, *end, *start; + long len; + + beg = RSTRING_PTR(s); + len = RSTRING_LEN(s); + start = beg; + if (lex_gets_ptr) { + if (len == lex_gets_ptr) return Qnil; + beg += lex_gets_ptr; + len -= lex_gets_ptr; + } + end = memchr(beg, '\n', len); + if (end) len = ++end - beg; + lex_gets_ptr += len; + return rb_str_subseq(s, beg - start, len); +} + +static VALUE +lex_getline(struct parser_params *parser) +{ + VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input); + if (NIL_P(line)) return line; + must_be_ascii_compatible(line); +#ifndef RIPPER + if (ruby_debug_lines) { + rb_enc_associate(line, current_enc); + rb_ary_push(ruby_debug_lines, line); + } + if (ruby_coverage) { + rb_ary_push(ruby_coverage, Qnil); + } +#endif + return line; +} + +static const rb_data_type_t parser_data_type; + +#ifndef RIPPER +static NODE* +parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line) +{ + struct parser_params *parser; + NODE *node; + + TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser); + lex_gets = lex_get_str; + lex_gets_ptr = 0; + lex_input = rb_str_new_frozen(s); + lex_pbeg = lex_p = lex_pend = 0; + compile_for_eval = rb_parse_in_eval(); + + node = yycompile(parser, fname, line); + RB_GC_GUARD(vparser); /* prohibit tail call optimization */ + + return node; +} + +NODE* +rb_compile_string(const char *f, VALUE s, int line) +{ + must_be_ascii_compatible(s); + return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), s, line); +} + +NODE* +rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line) +{ + return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line); +} + +NODE* +rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line) +{ + must_be_ascii_compatible(s); + return parser_compile_string(vparser, f, s, line); +} + +NODE* +rb_compile_cstr(const char *f, const char *s, int len, int line) +{ + VALUE str = rb_str_new(s, len); + return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), str, line); +} + +NODE* +rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line) +{ + VALUE str = rb_str_new(s, len); + return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line); +} + +static VALUE +lex_io_gets(struct parser_params *parser, VALUE io) +{ + return rb_io_gets(io); +} + +NODE* +rb_compile_file(const char *f, VALUE file, int start) +{ + VALUE volatile vparser = rb_parser_new(); + + return rb_parser_compile_file(vparser, f, file, start); +} + +NODE* +rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start) +{ + return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start); +} + +NODE* +rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start) +{ + struct parser_params *parser; + NODE *node; + + TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser); + lex_gets = lex_io_gets; + lex_input = file; + lex_pbeg = lex_p = lex_pend = 0; + compile_for_eval = rb_parse_in_eval(); + + node = yycompile(parser, fname, start); + RB_GC_GUARD(vparser); /* prohibit tail call optimization */ + + return node; +} +#endif /* !RIPPER */ + +#define STR_FUNC_ESCAPE 0x01 +#define STR_FUNC_EXPAND 0x02 +#define STR_FUNC_REGEXP 0x04 +#define STR_FUNC_QWORDS 0x08 +#define STR_FUNC_SYMBOL 0x10 +#define STR_FUNC_INDENT 0x20 + +enum string_type { + str_squote = (0), + str_dquote = (STR_FUNC_EXPAND), + str_xquote = (STR_FUNC_EXPAND), + str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND), + str_sword = (STR_FUNC_QWORDS), + str_dword = (STR_FUNC_QWORDS|STR_FUNC_EXPAND), + str_ssym = (STR_FUNC_SYMBOL), + str_dsym = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND) +}; + +static VALUE +parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0) +{ + VALUE str; + + str = rb_enc_str_new(p, n, enc); + if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) { + if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) { + } + else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) { + rb_enc_associate(str, rb_ascii8bit_encoding()); + } + } + + return str; +} + +#define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend) +#define lex_eol_p() (lex_p >= lex_pend) +#define peek(c) peek_n((c), 0) +#define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n]) +#define peekc() peekc_n(0) +#define peekc_n(n) (lex_p+(n) < lex_pend ? (unsigned char)lex_p[n] : -1) + +static inline int +parser_nextc(struct parser_params *parser) +{ + int c; + + if (lex_p == lex_pend) { + VALUE v = lex_nextline; + lex_nextline = 0; + if (!v) { + if (parser->eofp) + return -1; + + if (!lex_input || NIL_P(v = lex_getline(parser))) { + parser->eofp = Qtrue; + lex_goto_eol(parser); + return -1; + } + } + { +#ifdef RIPPER + if (parser->tokp < lex_pend) { + if (NIL_P(parser->delayed)) { + parser->delayed = rb_str_buf_new(1024); + rb_enc_associate(parser->delayed, current_enc); + rb_str_buf_cat(parser->delayed, + parser->tokp, lex_pend - parser->tokp); + parser->delayed_line = ruby_sourceline; + parser->delayed_col = (int)(parser->tokp - lex_pbeg); + } + else { + rb_str_buf_cat(parser->delayed, + parser->tokp, lex_pend - parser->tokp); + } + } +#endif + if (heredoc_end > 0) { + ruby_sourceline = heredoc_end; + heredoc_end = 0; + } + ruby_sourceline++; + parser->line_count++; + lex_pbeg = lex_p = RSTRING_PTR(v); + lex_pend = lex_p + RSTRING_LEN(v); + ripper_flush(parser); + lex_lastline = v; + } + } + c = (unsigned char)*lex_p++; + if (c == '\r') { + if (peek('\n')) { + lex_p++; + c = '\n'; + } + else if (ruby_sourceline > parser->last_cr_line) { + parser->last_cr_line = ruby_sourceline; + rb_compile_warn(ruby_sourcefile, ruby_sourceline, "encountered \\r in middle of line, treated as a mere space"); + } + } + + return c; +} + +static void +parser_pushback(struct parser_params *parser, int c) +{ + if (c == -1) return; + lex_p--; + if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') { + lex_p--; + } +} + +#define was_bol() (lex_p == lex_pbeg + 1) + +#define tokfix() (tokenbuf[tokidx]='\0') +#define tok() tokenbuf +#define toklen() tokidx +#define toklast() (tokidx>0?tokenbuf[tokidx-1]:0) + +static char* +parser_newtok(struct parser_params *parser) +{ + tokidx = 0; + tokline = ruby_sourceline; + if (!tokenbuf) { + toksiz = 60; + tokenbuf = ALLOC_N(char, 60); + } + if (toksiz > 4096) { + toksiz = 60; + REALLOC_N(tokenbuf, char, 60); + } + return tokenbuf; +} + +static char * +parser_tokspace(struct parser_params *parser, int n) +{ + tokidx += n; + + if (tokidx >= toksiz) { + do {toksiz *= 2;} while (toksiz < tokidx); + REALLOC_N(tokenbuf, char, toksiz); + } + return &tokenbuf[tokidx-n]; +} + +static void +parser_tokadd(struct parser_params *parser, int c) +{ + tokenbuf[tokidx++] = (char)c; + if (tokidx >= toksiz) { + toksiz *= 2; + REALLOC_N(tokenbuf, char, toksiz); + } +} + +static int +parser_tok_hex(struct parser_params *parser, size_t *numlen) +{ + int c; + + c = scan_hex(lex_p, 2, numlen); + if (!*numlen) { + yyerror("invalid hex escape"); + return 0; + } + lex_p += *numlen; + return c; +} + +#define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n)) + +/* return value is for ?\u3042 */ +static int +parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp, + int string_literal, int symbol_literal, int regexp_literal) +{ + /* + * If string_literal is true, then we allow multiple codepoints + * in \u{}, and add the codepoints to the current token. + * Otherwise we're parsing a character literal and return a single + * codepoint without adding it + */ + + int codepoint; + size_t numlen; + + if (regexp_literal) { tokadd('\\'); tokadd('u'); } + + if (peek('{')) { /* handle \u{...} form */ + do { + if (regexp_literal) { tokadd(*lex_p); } + nextc(); + codepoint = scan_hex(lex_p, 6, &numlen); + if (numlen == 0) { + yyerror("invalid Unicode escape"); + return 0; + } + if (codepoint > 0x10ffff) { + yyerror("invalid Unicode codepoint (too large)"); + return 0; + } + lex_p += numlen; + if (regexp_literal) { + tokcopy((int)numlen); + } + else if (codepoint >= 0x80) { + *encp = rb_utf8_encoding(); + if (string_literal) tokaddmbc(codepoint, *encp); + } + else if (string_literal) { + tokadd(codepoint); + } + } while (string_literal && (peek(' ') || peek('\t'))); + + if (!peek('}')) { + yyerror("unterminated Unicode escape"); + return 0; + } + + if (regexp_literal) { tokadd('}'); } + nextc(); + } + else { /* handle \uxxxx form */ + codepoint = scan_hex(lex_p, 4, &numlen); + if (numlen < 4) { + yyerror("invalid Unicode escape"); + return 0; + } + lex_p += 4; + if (regexp_literal) { + tokcopy(4); + } + else if (codepoint >= 0x80) { + *encp = rb_utf8_encoding(); + if (string_literal) tokaddmbc(codepoint, *encp); + } + else if (string_literal) { + tokadd(codepoint); + } + } + + return codepoint; +} + +#define ESCAPE_CONTROL 1 +#define ESCAPE_META 2 + +static int +parser_read_escape(struct parser_params *parser, int flags, + rb_encoding **encp) +{ + int c; + size_t numlen; + + switch (c = nextc()) { + case '\\': /* Backslash */ + return c; + + case 'n': /* newline */ + return '\n'; + + case 't': /* horizontal tab */ + return '\t'; + + case 'r': /* carriage-return */ + return '\r'; + + case 'f': /* form-feed */ + return '\f'; + + case 'v': /* vertical tab */ + return '\13'; + + case 'a': /* alarm(bell) */ + return '\007'; + + case 'e': /* escape */ + return 033; + + case '0': case '1': case '2': case '3': /* octal constant */ + case '4': case '5': case '6': case '7': + pushback(c); + c = scan_oct(lex_p, 3, &numlen); + lex_p += numlen; + return c; + + case 'x': /* hex constant */ + c = tok_hex(&numlen); + if (numlen == 0) return 0; + return c; + + case 'b': /* backspace */ + return '\010'; + + case 's': /* space */ + return ' '; + + case 'M': + if (flags & ESCAPE_META) goto eof; + if ((c = nextc()) != '-') { + pushback(c); + goto eof; + } + if ((c = nextc()) == '\\') { + if (peek('u')) goto eof; + return read_escape(flags|ESCAPE_META, encp) | 0x80; + } + else if (c == -1 || !ISASCII(c)) goto eof; + else { + return ((c & 0xff) | 0x80); + } + + case 'C': + if ((c = nextc()) != '-') { + pushback(c); + goto eof; + } + case 'c': + if (flags & ESCAPE_CONTROL) goto eof; + if ((c = nextc())== '\\') { + if (peek('u')) goto eof; + c = read_escape(flags|ESCAPE_CONTROL, encp); + } + else if (c == '?') + return 0177; + else if (c == -1 || !ISASCII(c)) goto eof; + return c & 0x9f; + + eof: + case -1: + yyerror("Invalid escape character syntax"); + return '\0'; + + default: + return c; + } +} + +static void +parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc) +{ + int len = rb_enc_codelen(c, enc); + rb_enc_mbcput(c, tokspace(len), enc); +} + +static int +parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp) +{ + int c; + int flags = 0; + size_t numlen; + + first: + switch (c = nextc()) { + case '\n': + return 0; /* just ignore */ + + case '0': case '1': case '2': case '3': /* octal constant */ + case '4': case '5': case '6': case '7': + { + ruby_scan_oct(--lex_p, 3, &numlen); + if (numlen == 0) goto eof; + lex_p += numlen; + tokcopy((int)numlen + 1); + } + return 0; + + case 'x': /* hex constant */ + { + tok_hex(&numlen); + if (numlen == 0) return -1; + tokcopy((int)numlen + 2); + } + return 0; + + case 'M': + if (flags & ESCAPE_META) goto eof; + if ((c = nextc()) != '-') { + pushback(c); + goto eof; + } + tokcopy(3); + flags |= ESCAPE_META; + goto escaped; + + case 'C': + if (flags & ESCAPE_CONTROL) goto eof; + if ((c = nextc()) != '-') { + pushback(c); + goto eof; + } + tokcopy(3); + goto escaped; + + case 'c': + if (flags & ESCAPE_CONTROL) goto eof; + tokcopy(2); + flags |= ESCAPE_CONTROL; + escaped: + if ((c = nextc()) == '\\') { + goto first; + } + else if (c == -1) goto eof; + tokadd(c); + return 0; + + eof: + case -1: + yyerror("Invalid escape character syntax"); + return -1; + + default: + tokadd('\\'); + tokadd(c); + } + return 0; +} + +static int +parser_regx_options(struct parser_params *parser) +{ + int kcode = 0; + int kopt = 0; + int options = 0; + int c, opt, kc; + + newtok(); + while (c = nextc(), ISALPHA(c)) { + if (c == 'o') { + options |= RE_OPTION_ONCE; + } + else if (rb_char_to_option_kcode(c, &opt, &kc)) { + if (kc >= 0) { + if (kc != rb_ascii8bit_encindex()) kcode = c; + kopt = opt; + } + else { + options |= opt; + } + } + else { + tokadd(c); + } + } + options |= kopt; + pushback(c); + if (toklen()) { + tokfix(); + compile_error(PARSER_ARG "unknown regexp option%s - %s", + toklen() > 1 ? "s" : "", tok()); + } + return options | RE_OPTION_ENCODING(kcode); +} + +static void +dispose_string(VALUE str) +{ + rb_str_free(str); + rb_gc_force_recycle(str); +} + +static int +parser_tokadd_mbchar(struct parser_params *parser, int c) +{ + int len = parser_precise_mbclen(); + if (!MBCLEN_CHARFOUND_P(len)) { + compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name()); + return -1; + } + tokadd(c); + lex_p += --len; + if (len > 0) tokcopy(len); + return c; +} + +#define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c)) + +static inline int +simple_re_meta(int c) +{ + switch (c) { + case '$': case '*': case '+': case '.': + case '?': case '^': case '|': + case ')': case ']': case '}': case '>': + return TRUE; + default: + return FALSE; + } +} + +static int +parser_tokadd_string(struct parser_params *parser, + int func, int term, int paren, long *nest, + rb_encoding **encp) +{ + int c; + int has_nonascii = 0; + rb_encoding *enc = *encp; + char *errbuf = 0; + static const char mixed_msg[] = "%s mixed within %s source"; + +#define mixed_error(enc1, enc2) if (!errbuf) { \ + size_t len = sizeof(mixed_msg) - 4; \ + len += strlen(rb_enc_name(enc1)); \ + len += strlen(rb_enc_name(enc2)); \ + errbuf = ALLOCA_N(char, len); \ + snprintf(errbuf, len, mixed_msg, \ + rb_enc_name(enc1), \ + rb_enc_name(enc2)); \ + yyerror(errbuf); \ + } +#define mixed_escape(beg, enc1, enc2) do { \ + const char *pos = lex_p; \ + lex_p = (beg); \ + mixed_error((enc1), (enc2)); \ + lex_p = pos; \ + } while (0) + + while ((c = nextc()) != -1) { + if (paren && c == paren) { + ++*nest; + } + else if (c == term) { + if (!nest || !*nest) { + pushback(c); + break; + } + --*nest; + } + else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) { + int c2 = *lex_p; + if (c2 == '$' || c2 == '@' || c2 == '{') { + pushback(c); + break; + } + } + else if (c == '\\') { + const char *beg = lex_p - 1; + c = nextc(); + switch (c) { + case '\n': + if (func & STR_FUNC_QWORDS) break; + if (func & STR_FUNC_EXPAND) continue; + tokadd('\\'); + break; + + case '\\': + if (func & STR_FUNC_ESCAPE) tokadd(c); + break; + + case 'u': + if ((func & STR_FUNC_EXPAND) == 0) { + tokadd('\\'); + break; + } + parser_tokadd_utf8(parser, &enc, 1, + func & STR_FUNC_SYMBOL, + func & STR_FUNC_REGEXP); + if (has_nonascii && enc != *encp) { + mixed_escape(beg, enc, *encp); + } + continue; + + default: + if (c == -1) return -1; + if (!ISASCII(c)) { + if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\'); + goto non_ascii; + } + if (func & STR_FUNC_REGEXP) { + if (c == term && !simple_re_meta(c)) { + tokadd(c); + continue; + } + pushback(c); + if ((c = tokadd_escape(&enc)) < 0) + return -1; + if (has_nonascii && enc != *encp) { + mixed_escape(beg, enc, *encp); + } + continue; + } + else if (func & STR_FUNC_EXPAND) { + pushback(c); + if (func & STR_FUNC_ESCAPE) tokadd('\\'); + c = read_escape(0, &enc); + } + else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) { + /* ignore backslashed spaces in %w */ + } + else if (c != term && !(paren && c == paren)) { + tokadd('\\'); + pushback(c); + continue; + } + } + } + else if (!parser_isascii()) { + non_ascii: + has_nonascii = 1; + if (enc != *encp) { + mixed_error(enc, *encp); + continue; + } + if (tokadd_mbchar(c) == -1) return -1; + continue; + } + else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) { + pushback(c); + break; + } + if (c & 0x80) { + has_nonascii = 1; + if (enc != *encp) { + mixed_error(enc, *encp); + continue; + } + } + tokadd(c); + } + *encp = enc; + return c; +} + +#define NEW_STRTERM(func, term, paren) \ + rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0) + +#ifdef RIPPER +static void +ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc) +{ + VALUE content = yylval.val; + if (!ripper_is_node_yylval(content)) + content = ripper_new_yylval(0, 0, content); + if (!NIL_P(parser->delayed)) { + ptrdiff_t len = lex_p - parser->tokp; + if (len > 0) { + rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc); + } + ripper_dispatch_delayed_token(parser, tSTRING_CONTENT); + parser->tokp = lex_p; + RNODE(content)->nd_rval = yylval.val; + } + ripper_dispatch_scan_event(parser, tSTRING_CONTENT); + if (yylval.val != content) + RNODE(content)->nd_rval = yylval.val; + yylval.val = content; +} + +#define flush_string_content(enc) ripper_flush_string_content(parser, (enc)) +#else +#define flush_string_content(enc) ((void)(enc)) +#endif + +RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32]; +/* this can be shared with ripper, since it's independent from struct + * parser_params. */ +#ifndef RIPPER +#define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0) +#define SPECIAL_PUNCT(idx) ( \ + BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \ + BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \ + BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \ + BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \ + BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \ + BIT('0', idx)) +const unsigned int ruby_global_name_punct_bits[] = { + SPECIAL_PUNCT(0), + SPECIAL_PUNCT(1), + SPECIAL_PUNCT(2), +}; +#undef BIT +#undef SPECIAL_PUNCT +#endif + +static int +parser_peek_variable_name(struct parser_params *parser) +{ + int c; + const char *p = lex_p; + + if (p + 1 >= lex_pend) return 0; + c = *p++; + switch (c) { + case '$': + if ((c = *p) == '-') { + if (++p >= lex_pend) return 0; + c = *p; + } + else if (is_global_name_punct(c) || ISDIGIT(c)) { + return tSTRING_DVAR; + } + break; + case '@': + if ((c = *p) == '@') { + if (++p >= lex_pend) return 0; + c = *p; + } + break; + case '{': + lex_p = p; + command_start = TRUE; + return tSTRING_DBEG; + default: + return 0; + } + if (!ISASCII(c) || c == '_' || ISALPHA(c)) + return tSTRING_DVAR; + return 0; +} + +static int +parser_parse_string(struct parser_params *parser, NODE *quote) +{ + int func = (int)quote->nd_func; + int term = nd_term(quote); + int paren = nd_paren(quote); + int c, space = 0; + rb_encoding *enc = current_enc; + + if (func == -1) return tSTRING_END; + c = nextc(); + if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) { + do {c = nextc();} while (ISSPACE(c)); + space = 1; + } + if (c == term && !quote->nd_nest) { + if (func & STR_FUNC_QWORDS) { + quote->nd_func = -1; + return ' '; + } + if (!(func & STR_FUNC_REGEXP)) return tSTRING_END; + set_yylval_num(regx_options()); +#ifdef RIPPER + ripper_dispatch_scan_event(parser, tREGEXP_END); +#endif + return tREGEXP_END; + } + if (space) { + pushback(c); + return ' '; + } + newtok(); + if ((func & STR_FUNC_EXPAND) && c == '#') { + int t = parser_peek_variable_name(parser); + if (t) return t; + tokadd('#'); + c = nextc(); + } + pushback(c); + if (tokadd_string(func, term, paren, "e->nd_nest, + &enc) == -1) { + ruby_sourceline = nd_line(quote); + if (func & STR_FUNC_REGEXP) { + if (parser->eofp) + compile_error(PARSER_ARG "unterminated regexp meets end of file"); + return tREGEXP_END; + } + else { + if (parser->eofp) + compile_error(PARSER_ARG "unterminated string meets end of file"); + return tSTRING_END; + } + } + + tokfix(); + set_yylval_str(STR_NEW3(tok(), toklen(), enc, func)); + flush_string_content(enc); + + return tSTRING_CONTENT; +} + +static int +parser_heredoc_identifier(struct parser_params *parser) +{ + int c = nextc(), term, func = 0; + long len; + + if (c == '-') { + c = nextc(); + func = STR_FUNC_INDENT; + } + switch (c) { + case '\'': + func |= str_squote; goto quoted; + case '"': + func |= str_dquote; goto quoted; + case '`': + func |= str_xquote; + quoted: + newtok(); + tokadd(func); + term = c; + while ((c = nextc()) != -1 && c != term) { + if (tokadd_mbchar(c) == -1) return 0; + } + if (c == -1) { + compile_error(PARSER_ARG "unterminated here document identifier"); + return 0; + } + break; + + default: + if (!parser_is_identchar()) { + pushback(c); + if (func & STR_FUNC_INDENT) { + pushback('-'); + } + return 0; + } + newtok(); + term = '"'; + tokadd(func |= str_dquote); + do { + if (tokadd_mbchar(c) == -1) return 0; + } while ((c = nextc()) != -1 && parser_is_identchar()); + pushback(c); + break; + } + + tokfix(); +#ifdef RIPPER + ripper_dispatch_scan_event(parser, tHEREDOC_BEG); +#endif + len = lex_p - lex_pbeg; + lex_goto_eol(parser); + lex_strterm = rb_node_newnode(NODE_HEREDOC, + STR_NEW(tok(), toklen()), /* nd_lit */ + len, /* nd_nth */ + lex_lastline); /* nd_orig */ + nd_set_line(lex_strterm, ruby_sourceline); + ripper_flush(parser); + return term == '`' ? tXSTRING_BEG : tSTRING_BEG; +} + +static void +parser_heredoc_restore(struct parser_params *parser, NODE *here) +{ + VALUE line; + + lex_strterm = 0; + line = here->nd_orig; + lex_lastline = line; + lex_pbeg = RSTRING_PTR(line); + lex_pend = lex_pbeg + RSTRING_LEN(line); + lex_p = lex_pbeg + here->nd_nth; + heredoc_end = ruby_sourceline; + ruby_sourceline = nd_line(here); + dispose_string(here->nd_lit); + rb_gc_force_recycle((VALUE)here); + ripper_flush(parser); +} + +static int +parser_whole_match_p(struct parser_params *parser, + const char *eos, long len, int indent) +{ + const char *p = lex_pbeg; + long n; + + if (indent) { + while (*p && ISSPACE(*p)) p++; + } + n = lex_pend - (p + len); + if (n < 0) return FALSE; + if (n > 0 && p[len] != '\n') { + if (p[len] != '\r') return FALSE; + if (n <= 1 || p[len+1] != '\n') return FALSE; + } + return strncmp(eos, p, len) == 0; +} + +#define NUM_SUFFIX_R (1<<0) +#define NUM_SUFFIX_I (1<<1) +#define NUM_SUFFIX_ALL 3 + +static int +parser_number_literal_suffix(struct parser_params *parser, int mask) +{ + int c, result = 0; + const char *lastp = lex_p; + + while ((c = nextc()) != -1) { + if ((mask & NUM_SUFFIX_I) && c == 'i') { + result |= (mask & NUM_SUFFIX_I); + mask &= ~NUM_SUFFIX_I; + /* r after i, rational of complex is disallowed */ + mask &= ~NUM_SUFFIX_R; + continue; + } + if ((mask & NUM_SUFFIX_R) && c == 'r') { + result |= (mask & NUM_SUFFIX_R); + mask &= ~NUM_SUFFIX_R; + continue; + } + if (!ISASCII(c) || ISALPHA(c) || c == '_') { + lex_p = lastp; + return 0; + } + pushback(c); + if (c == '.') { + c = peekc_n(1); + if (ISDIGIT(c)) { + yyerror("unexpected fraction part after numeric literal"); + lex_p += 2; + while (parser_is_identchar()) nextc(); + } + } + break; + } + return result; +} + +static int +parser_set_number_literal(struct parser_params *parser, VALUE v, int type, int suffix) +{ + if (suffix & NUM_SUFFIX_I) { + v = rb_complex_raw(INT2FIX(0), v); + type = tIMAGINARY; + } + set_yylval_literal(v); + return type; +} + +static int +parser_set_integer_literal(struct parser_params *parser, VALUE v, int suffix) +{ + int type = tINTEGER; + if (suffix & NUM_SUFFIX_R) { + v = rb_rational_raw1(v); + type = tRATIONAL; + } + return set_number_literal(v, type, suffix); +} + +#ifdef RIPPER +static void +ripper_dispatch_heredoc_end(struct parser_params *parser) +{ + if (!NIL_P(parser->delayed)) + ripper_dispatch_delayed_token(parser, tSTRING_CONTENT); + lex_goto_eol(parser); + ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END); +} + +#define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser) +#else +#define dispatch_heredoc_end() ((void)0) +#endif + +static int +parser_here_document(struct parser_params *parser, NODE *here) +{ + int c, func, indent = 0; + const char *eos, *p, *pend; + long len; + VALUE str = 0; + rb_encoding *enc = current_enc; + + eos = RSTRING_PTR(here->nd_lit); + len = RSTRING_LEN(here->nd_lit) - 1; + indent = (func = *eos++) & STR_FUNC_INDENT; + + if ((c = nextc()) == -1) { + error: + compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos); +#ifdef RIPPER + if (NIL_P(parser->delayed)) { + ripper_dispatch_scan_event(parser, tSTRING_CONTENT); + } + else { + if (str) { + rb_str_append(parser->delayed, str); + } + else if ((len = lex_p - parser->tokp) > 0) { + if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) { + int cr = ENC_CODERANGE_UNKNOWN; + rb_str_coderange_scan_restartable(parser->tokp, lex_p, enc, &cr); + if (cr != ENC_CODERANGE_7BIT && + current_enc == rb_usascii_encoding() && + enc != rb_utf8_encoding()) { + enc = rb_ascii8bit_encoding(); + } + } + rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc); + } + ripper_dispatch_delayed_token(parser, tSTRING_CONTENT); + } + lex_goto_eol(parser); +#endif + restore: + heredoc_restore(lex_strterm); + return 0; + } + if (was_bol() && whole_match_p(eos, len, indent)) { + dispatch_heredoc_end(); + heredoc_restore(lex_strterm); + return tSTRING_END; + } + + if (!(func & STR_FUNC_EXPAND)) { + do { + p = RSTRING_PTR(lex_lastline); + pend = lex_pend; + if (pend > p) { + switch (pend[-1]) { + case '\n': + if (--pend == p || pend[-1] != '\r') { + pend++; + break; + } + case '\r': + --pend; + } + } + if (str) + rb_str_cat(str, p, pend - p); + else + str = STR_NEW(p, pend - p); + if (pend < lex_pend) rb_str_cat(str, "\n", 1); + lex_goto_eol(parser); + if (nextc() == -1) { + if (str) { + dispose_string(str); + str = 0; + } + goto error; + } + } while (!whole_match_p(eos, len, indent)); + } + else { + /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/ + newtok(); + if (c == '#') { + int t = parser_peek_variable_name(parser); + if (t) return t; + tokadd('#'); + c = nextc(); + } + do { + pushback(c); + if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) { + if (parser->eofp) goto error; + goto restore; + } + if (c != '\n') { + set_yylval_str(STR_NEW3(tok(), toklen(), enc, func)); + flush_string_content(enc); + return tSTRING_CONTENT; + } + tokadd(nextc()); + /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/ + if ((c = nextc()) == -1) goto error; + } while (!whole_match_p(eos, len, indent)); + str = STR_NEW3(tok(), toklen(), enc, func); + } + dispatch_heredoc_end(); + heredoc_restore(lex_strterm); + lex_strterm = NEW_STRTERM(-1, 0, 0); + set_yylval_str(str); + return tSTRING_CONTENT; +} + +#include "lex.c" + +static void +arg_ambiguous_gen(struct parser_params *parser, char c) +{ +#ifndef RIPPER + rb_warningS("ambiguous first argument; put parentheses or a space even after `%c' operator", c); +#else + dispatch1(arg_ambiguous, rb_usascii_str_new(&c, 1)); +#endif +} +#define arg_ambiguous(c) (arg_ambiguous_gen(parser, (c)), 1) + +static ID +formal_argument_gen(struct parser_params *parser, ID lhs) +{ + switch (id_type(lhs)) { + case ID_LOCAL: + break; +#ifndef RIPPER + case ID_CONST: + yyerror("formal argument cannot be a constant"); + return 0; + case ID_INSTANCE: + yyerror("formal argument cannot be an instance variable"); + return 0; + case ID_GLOBAL: + yyerror("formal argument cannot be a global variable"); + return 0; + case ID_CLASS: + yyerror("formal argument cannot be a class variable"); + return 0; +#else + default: + lhs = dispatch1(param_error, lhs); + ripper_error(); + return 0; +#endif + } + shadowing_lvar(lhs); + return lhs; +} + +static int +lvar_defined_gen(struct parser_params *parser, ID id) +{ + return (dyna_in_block() && dvar_defined_get(id)) || local_id(id); +} + +/* emacsen -*- hack */ +static long +parser_encode_length(struct parser_params *parser, const char *name, long len) +{ + long nlen; + + if (len > 5 && name[nlen = len - 5] == '-') { + if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0) + return nlen; + } + if (len > 4 && name[nlen = len - 4] == '-') { + if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0) + return nlen; + if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 && + !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0)) + /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */ + return nlen; + } + return len; +} + +static void +parser_set_encode(struct parser_params *parser, const char *name) +{ + int idx = rb_enc_find_index(name); + rb_encoding *enc; + VALUE excargs[3]; + + if (idx < 0) { + excargs[1] = rb_sprintf("unknown encoding name: %s", name); + error: + excargs[0] = rb_eArgError; + excargs[2] = rb_make_backtrace(); + rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline)); + rb_exc_raise(rb_make_exception(3, excargs)); + } + enc = rb_enc_from_index(idx); + if (!rb_enc_asciicompat(enc)) { + excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc)); + goto error; + } + parser->enc = enc; +#ifndef RIPPER + if (ruby_debug_lines) { + VALUE lines = ruby_debug_lines; + long i, n = RARRAY_LEN(lines); + for (i = 0; i < n; ++i) { + rb_enc_associate_index(RARRAY_AREF(lines, i), idx); + } + } +#endif +} + +static int +comment_at_top(struct parser_params *parser) +{ + const char *p = lex_pbeg, *pend = lex_p - 1; + if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0; + while (p < pend) { + if (!ISSPACE(*p)) return 0; + p++; + } + return 1; +} + +typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len); +typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val); + +static void +magic_comment_encoding(struct parser_params *parser, const char *name, const char *val) +{ + if (!comment_at_top(parser)) { + return; + } + parser_set_encode(parser, val); +} + +#ifndef RIPPER +static int +parser_get_bool(struct parser_params *parser, const char *name, const char *val) +{ + switch (*val) { + case 't': case 'T': + if (strcasecmp(val, "true") == 0) { + return TRUE; + } + break; + case 'f': case 'F': + if (strcasecmp(val, "false") == 0) { + return FALSE; + } + break; + } + rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val); + return -1; +} + +static void +parser_set_token_info(struct parser_params *parser, const char *name, const char *val) +{ + int b = parser_get_bool(parser, name, val); + if (b >= 0) parser->parser_token_info_enabled = b; +} + +# if WARN_PAST_SCOPE +static void +parser_set_past_scope(struct parser_params *parser, const char *name, const char *val) +{ + int b = parser_get_bool(parser, name, val); + if (b >= 0) parser->parser_past_scope_enabled = b; +} +# endif +#endif + +struct magic_comment { + const char *name; + rb_magic_comment_setter_t func; + rb_magic_comment_length_t length; +}; + +static const struct magic_comment magic_comments[] = { + {"coding", magic_comment_encoding, parser_encode_length}, + {"encoding", magic_comment_encoding, parser_encode_length}, +#ifndef RIPPER + {"warn_indent", parser_set_token_info}, +# if WARN_PAST_SCOPE + {"warn_past_scope", parser_set_past_scope}, +# endif +#endif +}; + +static const char * +magic_comment_marker(const char *str, long len) +{ + long i = 2; + + while (i < len) { + switch (str[i]) { + case '-': + if (str[i-1] == '*' && str[i-2] == '-') { + return str + i + 1; + } + i += 2; + break; + case '*': + if (i + 1 >= len) return 0; + if (str[i+1] != '-') { + i += 4; + } + else if (str[i-1] != '-') { + i += 2; + } + else { + return str + i + 2; + } + break; + default: + i += 3; + break; + } + } + return 0; +} + +static int +parser_magic_comment(struct parser_params *parser, const char *str, long len) +{ + VALUE name = 0, val = 0; + const char *beg, *end, *vbeg, *vend; +#define str_copy(_s, _p, _n) ((_s) \ + ? (void)(rb_str_resize((_s), (_n)), \ + MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \ + : (void)((_s) = STR_NEW((_p), (_n)))) + + if (len <= 7) return FALSE; + if (!(beg = magic_comment_marker(str, len))) return FALSE; + if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE; + str = beg; + len = end - beg - 3; + + /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */ + while (len > 0) { + const struct magic_comment *p = magic_comments; + char *s; + int i; + long n = 0; + + for (; len > 0 && *str; str++, --len) { + switch (*str) { + case '\'': case '"': case ':': case ';': + continue; + } + if (!ISSPACE(*str)) break; + } + for (beg = str; len > 0; str++, --len) { + switch (*str) { + case '\'': case '"': case ':': case ';': + break; + default: + if (ISSPACE(*str)) break; + continue; + } + break; + } + for (end = str; len > 0 && ISSPACE(*str); str++, --len); + if (!len) break; + if (*str != ':') continue; + + do str++; while (--len > 0 && ISSPACE(*str)); + if (!len) break; + if (*str == '"') { + for (vbeg = ++str; --len > 0 && *str != '"'; str++) { + if (*str == '\\') { + --len; + ++str; + } + } + vend = str; + if (len) { + --len; + ++str; + } + } + else { + for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++); + vend = str; + } + while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++; + + n = end - beg; + str_copy(name, beg, n); + s = RSTRING_PTR(name); + for (i = 0; i < n; ++i) { + if (s[i] == '-') s[i] = '_'; + } + do { + if (STRNCASECMP(p->name, s, n) == 0) { + n = vend - vbeg; + if (p->length) { + n = (*p->length)(parser, vbeg, n); + } + str_copy(val, vbeg, n); + (*p->func)(parser, s, RSTRING_PTR(val)); + break; + } + } while (++p < magic_comments + numberof(magic_comments)); +#ifdef RIPPER + str_copy(val, vbeg, vend - vbeg); + dispatch2(magic_comment, name, val); +#endif + } + + return TRUE; +} + +static void +set_file_encoding(struct parser_params *parser, const char *str, const char *send) +{ + int sep = 0; + const char *beg = str; + VALUE s; + + for (;;) { + if (send - str <= 6) return; + switch (str[6]) { + case 'C': case 'c': str += 6; continue; + case 'O': case 'o': str += 5; continue; + case 'D': case 'd': str += 4; continue; + case 'I': case 'i': str += 3; continue; + case 'N': case 'n': str += 2; continue; + case 'G': case 'g': str += 1; continue; + case '=': case ':': + sep = 1; + str += 6; + break; + default: + str += 6; + if (ISSPACE(*str)) break; + continue; + } + if (STRNCASECMP(str-6, "coding", 6) == 0) break; + } + for (;;) { + do { + if (++str >= send) return; + } while (ISSPACE(*str)); + if (sep) break; + if (*str != '=' && *str != ':') return; + sep = 1; + str++; + } + beg = str; + while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send); + s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg)); + parser_set_encode(parser, RSTRING_PTR(s)); + rb_str_resize(s, 0); +} + +static void +parser_prepare(struct parser_params *parser) +{ + int c = nextc(); + switch (c) { + case '#': + if (peek('!')) parser->has_shebang = 1; + break; + case 0xef: /* UTF-8 BOM marker */ + if (lex_pend - lex_p >= 2 && + (unsigned char)lex_p[0] == 0xbb && + (unsigned char)lex_p[1] == 0xbf) { + parser->enc = rb_utf8_encoding(); + lex_p += 2; + lex_pbeg = lex_p; + return; + } + break; + case EOF: + return; + } + pushback(c); + parser->enc = rb_enc_get(lex_lastline); +} + +#define IS_ARG() IS_lex_state(EXPR_ARG_ANY) +#define IS_END() IS_lex_state(EXPR_END_ANY) +#define IS_BEG() IS_lex_state(EXPR_BEG_ANY) +#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c)) +#define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG()) +#define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1)) +#define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT) + +#ifndef RIPPER +#define ambiguous_operator(op, syn) ( \ + rb_warning0("`"op"' after local variable or literal is interpreted as binary operator"), \ + rb_warning0("even though it seems like "syn"")) +#else +#define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn)) +#endif +#define warn_balanced(op, syn) ((void) \ + (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \ + space_seen && !ISSPACE(c) && \ + (ambiguous_operator(op, syn), 0))) + +static VALUE +parse_rational(struct parser_params *parser, char *str, int len, int seen_point) +{ + VALUE v; + char *point = &str[seen_point]; + size_t fraclen = len-seen_point-1; + memmove(point, point+1, fraclen+1); + v = rb_cstr_to_inum(str, 10, FALSE); + return rb_rational_new(v, rb_int_positive_pow(10, fraclen)); +} + +static int +parse_numeric(struct parser_params *parser, int c) +{ + int is_float, seen_point, seen_e, nondigit; + int suffix; + + is_float = seen_point = seen_e = nondigit = 0; + lex_state = EXPR_END; + newtok(); + if (c == '-' || c == '+') { + tokadd(c); + c = nextc(); + } + if (c == '0') { +#define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0) + int start = toklen(); + c = nextc(); + if (c == 'x' || c == 'X') { + /* hexadecimal */ + c = nextc(); + if (c != -1 && ISXDIGIT(c)) { + do { + if (c == '_') { + if (nondigit) break; + nondigit = c; + continue; + } + if (!ISXDIGIT(c)) break; + nondigit = 0; + tokadd(c); + } while ((c = nextc()) != -1); + } + pushback(c); + tokfix(); + if (toklen() == start) { + no_digits(); + } + else if (nondigit) goto trailing_uc; + suffix = number_literal_suffix(NUM_SUFFIX_ALL); + return set_integer_literal(rb_cstr_to_inum(tok(), 16, FALSE), suffix); + } + if (c == 'b' || c == 'B') { + /* binary */ + c = nextc(); + if (c == '0' || c == '1') { + do { + if (c == '_') { + if (nondigit) break; + nondigit = c; + continue; + } + if (c != '0' && c != '1') break; + nondigit = 0; + tokadd(c); + } while ((c = nextc()) != -1); + } + pushback(c); + tokfix(); + if (toklen() == start) { + no_digits(); + } + else if (nondigit) goto trailing_uc; + suffix = number_literal_suffix(NUM_SUFFIX_ALL); + return set_integer_literal(rb_cstr_to_inum(tok(), 2, FALSE), suffix); + } + if (c == 'd' || c == 'D') { + /* decimal */ + c = nextc(); + if (c != -1 && ISDIGIT(c)) { + do { + if (c == '_') { + if (nondigit) break; + nondigit = c; + continue; + } + if (!ISDIGIT(c)) break; + nondigit = 0; + tokadd(c); + } while ((c = nextc()) != -1); + } + pushback(c); + tokfix(); + if (toklen() == start) { + no_digits(); + } + else if (nondigit) goto trailing_uc; + suffix = number_literal_suffix(NUM_SUFFIX_ALL); + return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix); + } + if (c == '_') { + /* 0_0 */ + goto octal_number; + } + if (c == 'o' || c == 'O') { + /* prefixed octal */ + c = nextc(); + if (c == -1 || c == '_' || !ISDIGIT(c)) { + no_digits(); + } + } + if (c >= '0' && c <= '7') { + /* octal */ + octal_number: + do { + if (c == '_') { + if (nondigit) break; + nondigit = c; + continue; + } + if (c < '0' || c > '9') break; + if (c > '7') goto invalid_octal; + nondigit = 0; + tokadd(c); + } while ((c = nextc()) != -1); + if (toklen() > start) { + pushback(c); + tokfix(); + if (nondigit) goto trailing_uc; + suffix = number_literal_suffix(NUM_SUFFIX_ALL); + return set_integer_literal(rb_cstr_to_inum(tok(), 8, FALSE), suffix); + } + if (nondigit) { + pushback(c); + goto trailing_uc; + } + } + if (c > '7' && c <= '9') { + invalid_octal: + yyerror("Invalid octal digit"); + } + else if (c == '.' || c == 'e' || c == 'E') { + tokadd('0'); + } + else { + pushback(c); + suffix = number_literal_suffix(NUM_SUFFIX_ALL); + return set_integer_literal(INT2FIX(0), suffix); + } + } + + for (;;) { + switch (c) { + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + nondigit = 0; + tokadd(c); + break; + + case '.': + if (nondigit) goto trailing_uc; + if (seen_point || seen_e) { + goto decode_num; + } + else { + int c0 = nextc(); + if (c0 == -1 || !ISDIGIT(c0)) { + pushback(c0); + goto decode_num; + } + c = c0; + } + seen_point = toklen(); + tokadd('.'); + tokadd(c); + is_float++; + nondigit = 0; + break; + + case 'e': + case 'E': + if (nondigit) { + pushback(c); + c = nondigit; + goto decode_num; + } + if (seen_e) { + goto decode_num; + } + nondigit = c; + c = nextc(); + if (c != '-' && c != '+' && !ISDIGIT(c)) { + pushback(c); + nondigit = 0; + goto decode_num; + } + tokadd(nondigit); + seen_e++; + is_float++; + tokadd(c); + nondigit = (c == '-' || c == '+') ? c : 0; + break; + + case '_': /* `_' in number just ignored */ + if (nondigit) goto decode_num; + nondigit = c; + break; + + default: + goto decode_num; + } + c = nextc(); + } + + decode_num: + pushback(c); + if (nondigit) { + char tmp[30]; + trailing_uc: + snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit); + yyerror(tmp); + } + tokfix(); + if (is_float) { + int type = tFLOAT; + VALUE v; + + suffix = number_literal_suffix(seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL); + if (suffix & NUM_SUFFIX_R) { + type = tRATIONAL; + v = parse_rational(parser, tok(), toklen(), seen_point); + } + else { + double d = strtod(tok(), 0); + if (errno == ERANGE) { + rb_warningS("Float %s out of range", tok()); + errno = 0; + } + v = DBL2NUM(d); + } + return set_number_literal(v, type, suffix); + } + suffix = number_literal_suffix(NUM_SUFFIX_ALL); + return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix); +} + +static int +parse_qmark(struct parser_params *parser) +{ + rb_encoding *enc; + register int c; + + if (IS_END()) { + lex_state = EXPR_VALUE; + return '?'; + } + c = nextc(); + if (c == -1) { + compile_error(PARSER_ARG "incomplete character syntax"); + return 0; + } + if (rb_enc_isspace(c, current_enc)) { + if (!IS_ARG()) { + int c2 = 0; + switch (c) { + case ' ': + c2 = 's'; + break; + case '\n': + c2 = 'n'; + break; + case '\t': + c2 = 't'; + break; + case '\v': + c2 = 'v'; + break; + case '\r': + c2 = 'r'; + break; + case '\f': + c2 = 'f'; + break; + } + if (c2) { + rb_warnI("invalid character syntax; use ?\\%c", c2); + } + } + ternary: + pushback(c); + lex_state = EXPR_VALUE; + return '?'; + } + newtok(); + enc = current_enc; + if (!parser_isascii()) { + if (tokadd_mbchar(c) == -1) return 0; + } + else if ((rb_enc_isalnum(c, current_enc) || c == '_') && + lex_p < lex_pend && is_identchar(lex_p, lex_pend, current_enc)) { + goto ternary; + } + else if (c == '\\') { + if (peek('u')) { + nextc(); + c = parser_tokadd_utf8(parser, &enc, 0, 0, 0); + if (0x80 <= c) { + tokaddmbc(c, enc); + } + else { + tokadd(c); + } + } + else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) { + nextc(); + if (tokadd_mbchar(c) == -1) return 0; + } + else { + c = read_escape(0, &enc); + tokadd(c); + } + } + else { + tokadd(c); + } + tokfix(); + set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0)); + lex_state = EXPR_END; + return tCHAR; +} + +static int +parse_percent(struct parser_params *parser, const int space_seen, const enum lex_state_e last_state) +{ + register int c; + + if (IS_lex_state(EXPR_BEG_ANY)) { + int term; + int paren; + + c = nextc(); + quotation: + if (c == -1 || !ISALNUM(c)) { + term = c; + c = 'Q'; + } + else { + term = nextc(); + if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) { + yyerror("unknown type of %string"); + return 0; + } + } + if (c == -1 || term == -1) { + compile_error(PARSER_ARG "unterminated quoted string meets end of file"); + return 0; + } + paren = term; + if (term == '(') term = ')'; + else if (term == '[') term = ']'; + else if (term == '{') term = '}'; + else if (term == '<') term = '>'; + else paren = 0; + + switch (c) { + case 'Q': + lex_strterm = NEW_STRTERM(str_dquote, term, paren); + return tSTRING_BEG; + + case 'q': + lex_strterm = NEW_STRTERM(str_squote, term, paren); + return tSTRING_BEG; + + case 'W': + lex_strterm = NEW_STRTERM(str_dword, term, paren); + do {c = nextc();} while (ISSPACE(c)); + pushback(c); + return tWORDS_BEG; + + case 'w': + lex_strterm = NEW_STRTERM(str_sword, term, paren); + do {c = nextc();} while (ISSPACE(c)); + pushback(c); + return tQWORDS_BEG; + + case 'I': + lex_strterm = NEW_STRTERM(str_dword, term, paren); + do {c = nextc();} while (ISSPACE(c)); + pushback(c); + return tSYMBOLS_BEG; + + case 'i': + lex_strterm = NEW_STRTERM(str_sword, term, paren); + do {c = nextc();} while (ISSPACE(c)); + pushback(c); + return tQSYMBOLS_BEG; + + case 'x': + lex_strterm = NEW_STRTERM(str_xquote, term, paren); + return tXSTRING_BEG; + + case 'r': + lex_strterm = NEW_STRTERM(str_regexp, term, paren); + return tREGEXP_BEG; + + case 's': + lex_strterm = NEW_STRTERM(str_ssym, term, paren); + lex_state = EXPR_FNAME; + return tSYMBEG; + + default: + yyerror("unknown type of %string"); + return 0; + } + } + if ((c = nextc()) == '=') { + set_yylval_id('%'); + lex_state = EXPR_BEG; + return tOP_ASGN; + } + if (IS_SPCARG(c)) { + goto quotation; + } + lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; + pushback(c); + warn_balanced("%%", "string literal"); + return '%'; +} + +static int +tokadd_ident(struct parser_params *parser, int c) +{ + do { + if (tokadd_mbchar(c) == -1) return -1; + c = nextc(); + } while (parser_is_identchar()); + pushback(c); + return 0; +} + +static void +tokenize_ident(struct parser_params *parser, const enum lex_state_e last_state) +{ + ID ident = TOK_INTERN(); + + set_yylval_name(ident); + if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) && + is_local_id(ident) && lvar_defined(ident)) { + lex_state = EXPR_END; + } +} + +static int +parse_numvar(struct parser_params *parser) +{ + size_t len; + int overflow; + unsigned long n = ruby_scan_digits(tok()+1, toklen()-1, 10, &len, &overflow); + const unsigned long nth_ref_max = + (FIXNUM_MAX / 2 < INT_MAX) ? FIXNUM_MAX / 2 : INT_MAX; + /* NTH_REF is left-shifted to be ORed with back-ref flag and + * turned into a Fixnum, in compile.c */ + + if (overflow || n > nth_ref_max) { + /* compile_error()? */ + rb_warnS("`%s' is too big for a number variable, always nil", tok()); + return 0; /* $0 is $PROGRAM_NAME, not NTH_REF */ + } + else { + return (int)n; + } +} + +static int +parse_gvar(struct parser_params *parser, const enum lex_state_e last_state) +{ + register int c; + + lex_state = EXPR_END; + newtok(); + c = nextc(); + switch (c) { + case '_': /* $_: last read line string */ + c = nextc(); + if (parser_is_identchar()) { + tokadd('$'); + tokadd('_'); + break; + } + pushback(c); + c = '_'; + /* fall through */ + case '~': /* $~: match-data */ + case '*': /* $*: argv */ + case '$': /* $$: pid */ + case '?': /* $?: last status */ + case '!': /* $!: error string */ + case '@': /* $@: error position */ + case '/': /* $/: input record separator */ + case '\\': /* $\: output record separator */ + case ';': /* $;: field separator */ + case ',': /* $,: output field separator */ + case '.': /* $.: last read line number */ + case '=': /* $=: ignorecase */ + case ':': /* $:: load path */ + case '<': /* $<: reading filename */ + case '>': /* $>: default output handle */ + case '\"': /* $": already loaded files */ + tokadd('$'); + tokadd(c); + goto gvar; + + case '-': + tokadd('$'); + tokadd(c); + c = nextc(); + if (parser_is_identchar()) { + if (tokadd_mbchar(c) == -1) return 0; + } + else { + pushback(c); + pushback('-'); + return '$'; + } + gvar: + set_yylval_name(TOK_INTERN()); + return tGVAR; + + case '&': /* $&: last match */ + case '`': /* $`: string before last match */ + case '\'': /* $': string after last match */ + case '+': /* $+: string matches last paren. */ + if (IS_lex_state_for(last_state, EXPR_FNAME)) { + tokadd('$'); + tokadd(c); + goto gvar; + } + set_yylval_node(NEW_BACK_REF(c)); + return tBACK_REF; + + case '1': case '2': case '3': + case '4': case '5': case '6': + case '7': case '8': case '9': + tokadd('$'); + do { + tokadd(c); + c = nextc(); + } while (c != -1 && ISDIGIT(c)); + pushback(c); + if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar; + tokfix(); + set_yylval_node(NEW_NTH_REF(parse_numvar(parser))); + return tNTH_REF; + + default: + if (!parser_is_identchar()) { + pushback(c); + compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c); + return 0; + } + case '0': + tokadd('$'); + } + + if (tokadd_ident(parser, c)) return 0; + lex_state = EXPR_END; + tokenize_ident(parser, last_state); + return tGVAR; +} + +static int +parse_atmark(struct parser_params *parser, const enum lex_state_e last_state) +{ + int result = tIVAR; + register int c = nextc(); + + newtok(); + tokadd('@'); + if (c == '@') { + result = tCVAR; + tokadd('@'); + c = nextc(); + } + if (c == -1 || ISSPACE(c)) { + if (result == tIVAR) { + compile_error(PARSER_ARG "`@' without identifiers is not allowed as an instance variable name"); + } + else { + compile_error(PARSER_ARG "`@@' without identifiers is not allowed as a class variable name"); + } + return 0; + } + else if (ISDIGIT(c) || !parser_is_identchar()) { + pushback(c); + if (result == tIVAR) { + compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c); + } + else { + compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c); + } + return 0; + } + + if (tokadd_ident(parser, c)) return 0; + lex_state = EXPR_END; + tokenize_ident(parser, last_state); + return result; +} + +static int +parse_ident(struct parser_params *parser, int c, int cmd_state) +{ + int result = 0; + int mb = ENC_CODERANGE_7BIT; + const enum lex_state_e last_state = lex_state; + + do { + if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN; + if (tokadd_mbchar(c) == -1) return 0; + c = nextc(); + } while (parser_is_identchar()); + if ((c == '!' || c == '?') && !peek('=')) { + tokadd(c); + } + else { + pushback(c); + } + tokfix(); + + if (toklast() == '!' || toklast() == '?') { + result = tFID; + } + else { + if (IS_lex_state(EXPR_FNAME)) { + register int c = nextc(); + if (c == '=' && !peek('~') && !peek('>') && + (!peek('=') || (peek_n('>', 1)))) { + result = tIDENTIFIER; + tokadd(c); + tokfix(); + } + else { + pushback(c); + } + } + if (result == 0 && ISUPPER(tok()[0])) { + result = tCONSTANT; + } + else { + result = tIDENTIFIER; + } + } + + if (IS_LABEL_POSSIBLE()) { + if (IS_LABEL_SUFFIX(0)) { + lex_state = EXPR_LABELARG; + nextc(); + set_yylval_name(TOK_INTERN()); + return tLABEL; + } + } + if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) { + const struct kwtable *kw; + + /* See if it is a reserved word. */ + kw = rb_reserved_word(tok(), toklen()); + if (kw) { + enum lex_state_e state = lex_state; + lex_state = kw->state; + if (IS_lex_state_for(state, EXPR_FNAME)) { + set_yylval_name(rb_intern(kw->name)); + return kw->id[0]; + } + if (IS_lex_state(EXPR_BEG)) { + command_start = TRUE; + } + if (kw->id[0] == keyword_do) { + if (lpar_beg && lpar_beg == paren_nest) { + lpar_beg = 0; + --paren_nest; + return keyword_do_LAMBDA; + } + if (COND_P()) return keyword_do_cond; + if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG)) + return keyword_do_block; + if (IS_lex_state_for(state, (EXPR_BEG | EXPR_ENDARG))) + return keyword_do_block; + return keyword_do; + } + if (IS_lex_state_for(state, (EXPR_BEG | EXPR_VALUE | EXPR_LABELARG))) + return kw->id[0]; + else { + if (kw->id[0] != kw->id[1]) + lex_state = EXPR_BEG; + return kw->id[1]; + } + } + } + + if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) { + if (cmd_state) { + lex_state = EXPR_CMDARG; + } + else { + lex_state = EXPR_ARG; + } + } + else if (lex_state == EXPR_FNAME) { + lex_state = EXPR_ENDFN; + } + else { + lex_state = EXPR_END; + } + + tokenize_ident(parser, last_state); + return result; +} + +static int +parser_yylex(struct parser_params *parser) +{ + register int c; + int space_seen = 0; + int cmd_state; + enum lex_state_e last_state; +#ifdef RIPPER + int fallthru = FALSE; +#endif + + if (lex_strterm) { + int token; + if (nd_type(lex_strterm) == NODE_HEREDOC) { + token = here_document(lex_strterm); + if (token == tSTRING_END) { + lex_strterm = 0; + lex_state = EXPR_END; + } + } + else { + token = parse_string(lex_strterm); + if (token == tSTRING_END && (peek_n('\'', -1) || peek_n('"', -1))) { + if (((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !COND_P()) || IS_ARG()) && + IS_LABEL_SUFFIX(0)) { + nextc(); + token = tLABEL_END; + } + } + if (token == tSTRING_END || token == tREGEXP_END || token == tLABEL_END) { + rb_gc_force_recycle((VALUE)lex_strterm); + lex_strterm = 0; + lex_state = token == tLABEL_END ? EXPR_LABELARG : EXPR_END; + } + } + return token; + } + cmd_state = command_start; + command_start = FALSE; + retry: + last_state = lex_state; + switch (c = nextc()) { + case '\0': /* NUL */ + case '\004': /* ^D */ + case '\032': /* ^Z */ + case -1: /* end of script. */ + return 0; + + /* white spaces */ + case ' ': case '\t': case '\f': case '\r': + case '\13': /* '\v' */ + space_seen = 1; +#ifdef RIPPER + while ((c = nextc())) { + switch (c) { + case ' ': case '\t': case '\f': case '\r': + case '\13': /* '\v' */ + break; + default: + goto outofloop; + } + } + outofloop: + pushback(c); + ripper_dispatch_scan_event(parser, tSP); +#endif + goto retry; + + case '#': /* it's a comment */ + /* no magic_comment in shebang line */ + if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) { + if (comment_at_top(parser)) { + set_file_encoding(parser, lex_p, lex_pend); + } + } + lex_p = lex_pend; +#ifdef RIPPER + ripper_dispatch_scan_event(parser, tCOMMENT); + fallthru = TRUE; +#endif + /* fall through */ + case '\n': + if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT | EXPR_LABELARG)) { +#ifdef RIPPER + if (!fallthru) { + ripper_dispatch_scan_event(parser, tIGNORED_NL); + } + fallthru = FALSE; +#endif + if (IS_lex_state(EXPR_LABELARG) && parser->parser_in_kwarg) { + goto normal_newline; + } + goto retry; + } + while ((c = nextc())) { + switch (c) { + case ' ': case '\t': case '\f': case '\r': + case '\13': /* '\v' */ + space_seen = 1; + break; + case '.': { +#ifdef RIPPER + ripper_dispatch_delayed_token(parser, tIGNORED_NL); +#endif + if ((c = nextc()) != '.') { + pushback(c); + pushback('.'); +#ifdef RIPPER + ripper_dispatch_scan_event(parser, tSP); +#endif + goto retry; + } + } + default: + --ruby_sourceline; + lex_nextline = lex_lastline; + case -1: /* EOF no decrement*/ + lex_goto_eol(parser); +#ifdef RIPPER + if (c != -1) { + parser->tokp = lex_p; + } +#endif + goto normal_newline; + } + } + normal_newline: + command_start = TRUE; + lex_state = EXPR_BEG; + return '\n'; + + case '*': + if ((c = nextc()) == '*') { + if ((c = nextc()) == '=') { + set_yylval_id(tPOW); + lex_state = EXPR_BEG; + return tOP_ASGN; + } + pushback(c); + if (IS_SPCARG(c)) { + rb_warning0("`**' interpreted as argument prefix"); + c = tDSTAR; + } + else if (IS_BEG()) { + c = tDSTAR; + } + else { + warn_balanced("**", "argument prefix"); + c = tPOW; + } + } + else { + if (c == '=') { + set_yylval_id('*'); + lex_state = EXPR_BEG; + return tOP_ASGN; + } + pushback(c); + if (IS_SPCARG(c)) { + rb_warning0("`*' interpreted as argument prefix"); + c = tSTAR; + } + else if (IS_BEG()) { + c = tSTAR; + } + else { + warn_balanced("*", "argument prefix"); + c = '*'; + } + } + lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; + return c; + + case '!': + c = nextc(); + if (IS_AFTER_OPERATOR()) { + lex_state = EXPR_ARG; + if (c == '@') { + return '!'; + } + } + else { + lex_state = EXPR_BEG; + } + if (c == '=') { + return tNEQ; + } + if (c == '~') { + return tNMATCH; + } + pushback(c); + return '!'; + + case '=': + if (was_bol()) { + /* skip embedded rd document */ + if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) { +#ifdef RIPPER + int first_p = TRUE; + + lex_goto_eol(parser); + ripper_dispatch_scan_event(parser, tEMBDOC_BEG); +#endif + for (;;) { + lex_goto_eol(parser); +#ifdef RIPPER + if (!first_p) { + ripper_dispatch_scan_event(parser, tEMBDOC); + } + first_p = FALSE; +#endif + c = nextc(); + if (c == -1) { + compile_error(PARSER_ARG "embedded document meets end of file"); + return 0; + } + if (c != '=') continue; + if (strncmp(lex_p, "end", 3) == 0 && + (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) { + break; + } + } + lex_goto_eol(parser); +#ifdef RIPPER + ripper_dispatch_scan_event(parser, tEMBDOC_END); +#endif + goto retry; + } + } + + lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; + if ((c = nextc()) == '=') { + if ((c = nextc()) == '=') { + return tEQQ; + } + pushback(c); + return tEQ; + } + if (c == '~') { + return tMATCH; + } + else if (c == '>') { + return tASSOC; + } + pushback(c); + return '='; + + case '<': + last_state = lex_state; + c = nextc(); + if (c == '<' && + !IS_lex_state(EXPR_DOT | EXPR_CLASS) && + !IS_END() && + (!IS_ARG() || space_seen)) { + int token = heredoc_identifier(); + if (token) return token; + } + if (IS_AFTER_OPERATOR()) { + lex_state = EXPR_ARG; + } + else { + if (IS_lex_state(EXPR_CLASS)) + command_start = TRUE; + lex_state = EXPR_BEG; + } + if (c == '=') { + if ((c = nextc()) == '>') { + return tCMP; + } + pushback(c); + return tLEQ; + } + if (c == '<') { + if ((c = nextc()) == '=') { + set_yylval_id(tLSHFT); + lex_state = EXPR_BEG; + return tOP_ASGN; + } + pushback(c); + warn_balanced("<<", "here document"); + return tLSHFT; + } + pushback(c); + return '<'; + + case '>': + lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; + if ((c = nextc()) == '=') { + return tGEQ; + } + if (c == '>') { + if ((c = nextc()) == '=') { + set_yylval_id(tRSHFT); + lex_state = EXPR_BEG; + return tOP_ASGN; + } + pushback(c); + return tRSHFT; + } + pushback(c); + return '>'; + + case '"': + lex_strterm = NEW_STRTERM(str_dquote, '"', 0); + return tSTRING_BEG; + + case '`': + if (IS_lex_state(EXPR_FNAME)) { + lex_state = EXPR_ENDFN; + return c; + } + if (IS_lex_state(EXPR_DOT)) { + if (cmd_state) + lex_state = EXPR_CMDARG; + else + lex_state = EXPR_ARG; + return c; + } + lex_strterm = NEW_STRTERM(str_xquote, '`', 0); + return tXSTRING_BEG; + + case '\'': + lex_strterm = NEW_STRTERM(str_squote, '\'', 0); + return tSTRING_BEG; + + case '?': + return parse_qmark(parser); + + case '&': + if ((c = nextc()) == '&') { + lex_state = EXPR_BEG; + if ((c = nextc()) == '=') { + set_yylval_id(tANDOP); + lex_state = EXPR_BEG; + return tOP_ASGN; + } + pushback(c); + return tANDOP; + } + else if (c == '=') { + set_yylval_id('&'); + lex_state = EXPR_BEG; + return tOP_ASGN; + } + pushback(c); + if (IS_SPCARG(c)) { + rb_warning0("`&' interpreted as argument prefix"); + c = tAMPER; + } + else if (IS_BEG()) { + c = tAMPER; + } + else { + warn_balanced("&", "argument prefix"); + c = '&'; + } + lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; + return c; + + case '|': + if ((c = nextc()) == '|') { + lex_state = EXPR_BEG; + if ((c = nextc()) == '=') { + set_yylval_id(tOROP); + lex_state = EXPR_BEG; + return tOP_ASGN; + } + pushback(c); + return tOROP; + } + if (c == '=') { + set_yylval_id('|'); + lex_state = EXPR_BEG; + return tOP_ASGN; + } + lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; + pushback(c); + return '|'; + + case '+': + c = nextc(); + if (IS_AFTER_OPERATOR()) { + lex_state = EXPR_ARG; + if (c == '@') { + return tUPLUS; + } + pushback(c); + return '+'; + } + if (c == '=') { + set_yylval_id('+'); + lex_state = EXPR_BEG; + return tOP_ASGN; + } + if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous('+'))) { + lex_state = EXPR_BEG; + pushback(c); + if (c != -1 && ISDIGIT(c)) { + return parse_numeric(parser, '+'); + } + return tUPLUS; + } + lex_state = EXPR_BEG; + pushback(c); + warn_balanced("+", "unary operator"); + return '+'; + + case '-': + c = nextc(); + if (IS_AFTER_OPERATOR()) { + lex_state = EXPR_ARG; + if (c == '@') { + return tUMINUS; + } + pushback(c); + return '-'; + } + if (c == '=') { + set_yylval_id('-'); + lex_state = EXPR_BEG; + return tOP_ASGN; + } + if (c == '>') { + lex_state = EXPR_ENDFN; + return tLAMBDA; + } + if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous('-'))) { + lex_state = EXPR_BEG; + pushback(c); + if (c != -1 && ISDIGIT(c)) { + return tUMINUS_NUM; + } + return tUMINUS; + } + lex_state = EXPR_BEG; + pushback(c); + warn_balanced("-", "unary operator"); + return '-'; + + case '.': + lex_state = EXPR_BEG; + if ((c = nextc()) == '.') { + if ((c = nextc()) == '.') { + return tDOT3; + } + pushback(c); + return tDOT2; + } + pushback(c); + if (c != -1 && ISDIGIT(c)) { + yyerror("no .<digit> floating literal anymore; put 0 before dot"); + } + lex_state = EXPR_DOT; + return '.'; + + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + return parse_numeric(parser, c); + + case ')': + case ']': + paren_nest--; + case '}': + COND_LEXPOP(); + CMDARG_LEXPOP(); + if (c == ')') + lex_state = EXPR_ENDFN; + else + lex_state = EXPR_ENDARG; + if (c == '}') { + if (!brace_nest--) c = tSTRING_DEND; + } + return c; + + case ':': + c = nextc(); + if (c == ':') { + if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) { + lex_state = EXPR_BEG; + return tCOLON3; + } + lex_state = EXPR_DOT; + return tCOLON2; + } + if (IS_END() || ISSPACE(c)) { + pushback(c); + warn_balanced(":", "symbol literal"); + lex_state = EXPR_BEG; + return ':'; + } + switch (c) { + case '\'': + lex_strterm = NEW_STRTERM(str_ssym, c, 0); + break; + case '"': + lex_strterm = NEW_STRTERM(str_dsym, c, 0); + break; + default: + pushback(c); + break; + } + lex_state = EXPR_FNAME; + return tSYMBEG; + + case '/': + if (IS_lex_state(EXPR_BEG_ANY)) { + lex_strterm = NEW_STRTERM(str_regexp, '/', 0); + return tREGEXP_BEG; + } + if ((c = nextc()) == '=') { + set_yylval_id('/'); + lex_state = EXPR_BEG; + return tOP_ASGN; + } + pushback(c); + if (IS_SPCARG(c)) { + (void)arg_ambiguous('/'); + lex_strterm = NEW_STRTERM(str_regexp, '/', 0); + return tREGEXP_BEG; + } + lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; + warn_balanced("/", "regexp literal"); + return '/'; + + case '^': + if ((c = nextc()) == '=') { + set_yylval_id('^'); + lex_state = EXPR_BEG; + return tOP_ASGN; + } + lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; + pushback(c); + return '^'; + + case ';': + lex_state = EXPR_BEG; + command_start = TRUE; + return ';'; + + case ',': + lex_state = EXPR_BEG; + return ','; + + case '~': + if (IS_AFTER_OPERATOR()) { + if ((c = nextc()) != '@') { + pushback(c); + } + lex_state = EXPR_ARG; + } + else { + lex_state = EXPR_BEG; + } + return '~'; + + case '(': + if (IS_BEG()) { + c = tLPAREN; + } + else if (IS_SPCARG(-1)) { + c = tLPAREN_ARG; + } + paren_nest++; + COND_PUSH(0); + CMDARG_PUSH(0); + lex_state = EXPR_BEG; + return c; + + case '[': + paren_nest++; + if (IS_AFTER_OPERATOR()) { + lex_state = EXPR_ARG; + if ((c = nextc()) == ']') { + if ((c = nextc()) == '=') { + return tASET; + } + pushback(c); + return tAREF; + } + pushback(c); + return '['; + } + else if (IS_BEG()) { + c = tLBRACK; + } + else if (IS_ARG() && space_seen) { + c = tLBRACK; + } + lex_state = EXPR_BEG; + COND_PUSH(0); + CMDARG_PUSH(0); + return c; + + case '{': + ++brace_nest; + if (lpar_beg && lpar_beg == paren_nest) { + lex_state = EXPR_BEG; + lpar_beg = 0; + --paren_nest; + COND_PUSH(0); + CMDARG_PUSH(0); + return tLAMBEG; + } + if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN)) + c = '{'; /* block (primary) */ + else if (IS_lex_state(EXPR_ENDARG)) + c = tLBRACE_ARG; /* block (expr) */ + else + c = tLBRACE; /* hash */ + COND_PUSH(0); + CMDARG_PUSH(0); + lex_state = EXPR_BEG; + if (c != tLBRACE) command_start = TRUE; + return c; + + case '\\': + c = nextc(); + if (c == '\n') { + space_seen = 1; +#ifdef RIPPER + ripper_dispatch_scan_event(parser, tSP); +#endif + goto retry; /* skip \\n */ + } + pushback(c); + return '\\'; + + case '%': + return parse_percent(parser, space_seen, last_state); + + case '$': + return parse_gvar(parser, last_state); + + case '@': + return parse_atmark(parser, last_state); + + case '_': + if (was_bol() && whole_match_p("__END__", 7, 0)) { + ruby__end__seen = 1; + parser->eofp = Qtrue; +#ifndef RIPPER + return -1; +#else + lex_goto_eol(parser); + ripper_dispatch_scan_event(parser, k__END__); + return 0; +#endif + } + newtok(); + break; + + default: + if (!parser_is_identchar()) { + compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c); + goto retry; + } + + newtok(); + break; + } + + return parse_ident(parser, c, cmd_state); +} + +#if YYPURE +static int +yylex(void *lval, void *p) +#else +yylex(void *p) +#endif +{ + struct parser_params *parser = (struct parser_params*)p; + int t; + +#if YYPURE + parser->parser_yylval = lval; + parser->parser_yylval->val = Qundef; +#endif + t = parser_yylex(parser); +#ifdef RIPPER + if (!NIL_P(parser->delayed)) { + ripper_dispatch_delayed_token(parser, t); + return t; + } + if (t != 0) + ripper_dispatch_scan_event(parser, t); +#endif + + return t; +} + +#ifndef RIPPER +static NODE* +node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2) +{ + NODE *n = (rb_node_newnode)(type, a0, a1, a2); + nd_set_line(n, ruby_sourceline); + return n; +} + +static enum node_type +nodetype(NODE *node) /* for debug */ +{ + return (enum node_type)nd_type(node); +} + +static int +nodeline(NODE *node) +{ + return nd_line(node); +} + +static NODE* +newline_node(NODE *node) +{ + if (node) { + node = remove_begin(node); + node->flags |= NODE_FL_NEWLINE; + } + return node; +} + +static void +fixpos(NODE *node, NODE *orig) +{ + if (!node) return; + if (!orig) return; + if (orig == (NODE*)1) return; + nd_set_line(node, nd_line(orig)); +} + +static void +parser_warning(struct parser_params *parser, NODE *node, const char *mesg) +{ + rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg); +} +#define parser_warning(node, mesg) parser_warning(parser, (node), (mesg)) + +static void +parser_warn(struct parser_params *parser, NODE *node, const char *mesg) +{ + rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg); +} +#define parser_warn(node, mesg) parser_warn(parser, (node), (mesg)) + +static NODE* +block_append_gen(struct parser_params *parser, NODE *head, NODE *tail) +{ + NODE *end, *h = head, *nd; + + if (tail == 0) return head; + + if (h == 0) return tail; + switch (nd_type(h)) { + case NODE_LIT: + case NODE_STR: + case NODE_SELF: + case NODE_TRUE: + case NODE_FALSE: + case NODE_NIL: + parser_warning(h, "unused literal ignored"); + return tail; + default: + h = end = NEW_BLOCK(head); + end->nd_end = end; + fixpos(end, head); + head = end; + break; + case NODE_BLOCK: + end = h->nd_end; + break; + } + + nd = end->nd_head; + switch (nd_type(nd)) { + case NODE_RETURN: + case NODE_BREAK: + case NODE_NEXT: + case NODE_REDO: + case NODE_RETRY: + if (RTEST(ruby_verbose)) { + parser_warning(tail, "statement not reached"); + } + break; + + default: + break; + } + + if (nd_type(tail) != NODE_BLOCK) { + tail = NEW_BLOCK(tail); + tail->nd_end = tail; + } + end->nd_next = tail; + h->nd_end = tail->nd_end; + return head; +} + +/* append item to the list */ +static NODE* +list_append_gen(struct parser_params *parser, NODE *list, NODE *item) +{ + NODE *last; + + if (list == 0) return NEW_LIST(item); + if (list->nd_next) { + last = list->nd_next->nd_end; + } + else { + last = list; + } + + list->nd_alen += 1; + last->nd_next = NEW_LIST(item); + list->nd_next->nd_end = last->nd_next; + return list; +} + +/* concat two lists */ +static NODE* +list_concat(NODE *head, NODE *tail) +{ + NODE *last; + + if (head->nd_next) { + last = head->nd_next->nd_end; + } + else { + last = head; + } + + head->nd_alen += tail->nd_alen; + last->nd_next = tail; + if (tail->nd_next) { + head->nd_next->nd_end = tail->nd_next->nd_end; + } + else { + head->nd_next->nd_end = tail; + } + + return head; +} + +static int +literal_concat0(struct parser_params *parser, VALUE head, VALUE tail) +{ + if (NIL_P(tail)) return 1; + if (!rb_enc_compatible(head, tail)) { + compile_error(PARSER_ARG "string literal encodings differ (%s / %s)", + rb_enc_name(rb_enc_get(head)), + rb_enc_name(rb_enc_get(tail))); + rb_str_resize(head, 0); + rb_str_resize(tail, 0); + return 0; + } + rb_str_buf_append(head, tail); + return 1; +} + +/* concat two string literals */ +static NODE * +literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail) +{ + enum node_type htype; + NODE *headlast; + VALUE lit; + + if (!head) return tail; + if (!tail) return head; + + htype = nd_type(head); + if (htype == NODE_EVSTR) { + NODE *node = NEW_DSTR(Qnil); + head = list_append(node, head); + htype = NODE_DSTR; + } + switch (nd_type(tail)) { + case NODE_STR: + if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) && + nd_type(headlast) == NODE_STR) { + htype = NODE_STR; + lit = headlast->nd_lit; + } + else { + lit = head->nd_lit; + } + if (htype == NODE_STR) { + if (!literal_concat0(parser, lit, tail->nd_lit)) { + error: + rb_gc_force_recycle((VALUE)head); + rb_gc_force_recycle((VALUE)tail); + return 0; + } + rb_gc_force_recycle((VALUE)tail); + } + else { + list_append(head, tail); + } + break; + + case NODE_DSTR: + if (htype == NODE_STR) { + if (!literal_concat0(parser, head->nd_lit, tail->nd_lit)) + goto error; + tail->nd_lit = head->nd_lit; + rb_gc_force_recycle((VALUE)head); + head = tail; + } + else if (NIL_P(tail->nd_lit)) { + append: + head->nd_alen += tail->nd_alen - 1; + head->nd_next->nd_end->nd_next = tail->nd_next; + head->nd_next->nd_end = tail->nd_next->nd_end; + rb_gc_force_recycle((VALUE)tail); + } + else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) && + nd_type(headlast) == NODE_STR) { + lit = headlast->nd_lit; + if (!literal_concat0(parser, lit, tail->nd_lit)) + goto error; + tail->nd_lit = Qnil; + goto append; + } + else { + nd_set_type(tail, NODE_ARRAY); + tail->nd_head = NEW_STR(tail->nd_lit); + list_concat(head, tail); + } + break; + + case NODE_EVSTR: + if (htype == NODE_STR) { + nd_set_type(head, NODE_DSTR); + head->nd_alen = 1; + } + list_append(head, tail); + break; + } + return head; +} + +static NODE * +evstr2dstr_gen(struct parser_params *parser, NODE *node) +{ + if (nd_type(node) == NODE_EVSTR) { + node = list_append(NEW_DSTR(Qnil), node); + } + return node; +} + +static NODE * +new_evstr_gen(struct parser_params *parser, NODE *node) +{ + NODE *head = node; + + if (node) { + switch (nd_type(node)) { + case NODE_STR: case NODE_DSTR: case NODE_EVSTR: + return node; + } + } + return NEW_EVSTR(head); +} + +static NODE * +call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1) +{ + value_expr(recv); + value_expr(arg1); + return NEW_CALL(recv, id, NEW_LIST(arg1)); +} + +static NODE * +call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id) +{ + value_expr(recv); + return NEW_CALL(recv, id, 0); +} + +static NODE* +match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2) +{ + value_expr(node1); + value_expr(node2); + if (node1) { + switch (nd_type(node1)) { + case NODE_DREGX: + case NODE_DREGX_ONCE: + return NEW_MATCH2(node1, node2); + + case NODE_LIT: + if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) { + return NEW_MATCH2(node1, node2); + } + } + } + + if (node2) { + switch (nd_type(node2)) { + case NODE_DREGX: + case NODE_DREGX_ONCE: + return NEW_MATCH3(node2, node1); + + case NODE_LIT: + if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) { + return NEW_MATCH3(node2, node1); + } + } + } + + return NEW_CALL(node1, tMATCH, NEW_LIST(node2)); +} + +# if WARN_PAST_SCOPE +static int +past_dvar_p(struct parser_params *parser, ID id) +{ + struct vtable *past = lvtbl->past; + while (past) { + if (vtable_included(past, id)) return 1; + past = past->prev; + } + return 0; +} +# endif + +static NODE* +gettable_gen(struct parser_params *parser, ID id) +{ + switch (id) { + case keyword_self: + return NEW_SELF(); + case keyword_nil: + return NEW_NIL(); + case keyword_true: + return NEW_TRUE(); + case keyword_false: + return NEW_FALSE(); + case keyword__FILE__: + return NEW_STR(rb_str_dup(ruby_sourcefile_string)); + case keyword__LINE__: + return NEW_LIT(INT2FIX(tokline)); + case keyword__ENCODING__: + return NEW_LIT(rb_enc_from_encoding(current_enc)); + } + switch (id_type(id)) { + case ID_LOCAL: + if (dyna_in_block() && dvar_defined(id)) { + if (id == current_arg) { + rb_warnV("circular argument reference - %"PRIsVALUE, rb_id2str(id)); + } + return NEW_DVAR(id); + } + if (local_id(id)) { + if (id == current_arg) { + rb_warnV("circular argument reference - %"PRIsVALUE, rb_id2str(id)); + } + return NEW_LVAR(id); + } +# if WARN_PAST_SCOPE + if (!in_defined && RTEST(ruby_verbose) && past_dvar_p(parser, id)) { + rb_warningV("possible reference to past scope - %"PRIsVALUE, rb_id2str(id)); + } +# endif + /* method call without arguments */ + return NEW_VCALL(id); + case ID_GLOBAL: + return NEW_GVAR(id); + case ID_INSTANCE: + return NEW_IVAR(id); + case ID_CONST: + return NEW_CONST(id); + case ID_CLASS: + return NEW_CVAR(id); + } + compile_error(PARSER_ARG "identifier %"PRIsVALUE" is not valid to get", rb_id2str(id)); + return 0; +} +#else /* !RIPPER */ +static int +id_is_var_gen(struct parser_params *parser, ID id) +{ + if (is_notop_id(id)) { + switch (id & ID_SCOPE_MASK) { + case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS: + return 1; + case ID_LOCAL: + if (dyna_in_block() && dvar_defined(id)) return 1; + if (local_id(id)) return 1; + /* method call without arguments */ + return 0; + } + } + compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2str(id)); + return 0; +} +#endif /* !RIPPER */ + +#if PARSER_DEBUG +static const char * +lex_state_name(enum lex_state_e state) +{ + static const char names[][12] = { + "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG", + "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS", + "EXPR_VALUE", + }; + + if ((unsigned)state & ~(~0u << EXPR_MAX_STATE)) + return names[ffs(state)]; + return NULL; +} +#endif + +#ifdef RIPPER +static VALUE +assignable_gen(struct parser_params *parser, VALUE lhs) +#else +static NODE* +assignable_gen(struct parser_params *parser, ID id, NODE *val) +#endif +{ +#ifdef RIPPER + ID id = get_id(lhs); +# define assignable_result(x) get_value(lhs) +# define parser_yyerror(parser, x) (dispatch1(assign_error, lhs), ripper_error()) +#else +# define assignable_result(x) (x) +#endif + if (!id) return assignable_result(0); + switch (id) { + case keyword_self: + yyerror("Can't change the value of self"); + goto error; + case keyword_nil: + yyerror("Can't assign to nil"); + goto error; + case keyword_true: + yyerror("Can't assign to true"); + goto error; + case keyword_false: + yyerror("Can't assign to false"); + goto error; + case keyword__FILE__: + yyerror("Can't assign to __FILE__"); + goto error; + case keyword__LINE__: + yyerror("Can't assign to __LINE__"); + goto error; + case keyword__ENCODING__: + yyerror("Can't assign to __ENCODING__"); + goto error; + } + switch (id_type(id)) { + case ID_LOCAL: + if (dyna_in_block()) { + if (dvar_curr(id)) { + return assignable_result(NEW_DASGN_CURR(id, val)); + } + else if (dvar_defined(id)) { + return assignable_result(NEW_DASGN(id, val)); + } + else if (local_id(id)) { + return assignable_result(NEW_LASGN(id, val)); + } + else { + dyna_var(id); + return assignable_result(NEW_DASGN_CURR(id, val)); + } + } + else { + if (!local_id(id)) { + local_var(id); + } + return assignable_result(NEW_LASGN(id, val)); + } + break; + case ID_GLOBAL: + return assignable_result(NEW_GASGN(id, val)); + case ID_INSTANCE: + return assignable_result(NEW_IASGN(id, val)); + case ID_CONST: + if (!in_def && !in_single) + return assignable_result(NEW_CDECL(id, val, 0)); + yyerror("dynamic constant assignment"); + break; + case ID_CLASS: + return assignable_result(NEW_CVASGN(id, val)); + default: + compile_error(PARSER_ARG "identifier %"PRIsVALUE" is not valid to set", rb_id2str(id)); + } + error: + return assignable_result(0); +#undef assignable_result +#undef parser_yyerror +} + +static int +is_private_local_id(ID name) +{ + VALUE s; + if (name == idUScore) return 1; + if (!is_local_id(name)) return 0; + s = rb_id2str(name); + if (!s) return 0; + return RSTRING_PTR(s)[0] == '_'; +} + +#define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1)) + +static int +shadowing_lvar_0(struct parser_params *parser, ID name) +{ + if (is_private_local_id(name)) return 1; + if (dyna_in_block()) { + if (dvar_curr(name)) { + yyerror("duplicated argument name"); + } + else if (dvar_defined_get(name) || local_id(name)) { + rb_warningV("shadowing outer local variable - %"PRIsVALUE, rb_id2str(name)); + vtable_add(lvtbl->vars, name); + if (lvtbl->used) { + vtable_add(lvtbl->used, (ID)ruby_sourceline | LVAR_USED); + } + return 0; + } + } + else { + if (local_id(name)) { + yyerror("duplicated argument name"); + } + } + return 1; +} + +static ID +shadowing_lvar_gen(struct parser_params *parser, ID name) +{ + shadowing_lvar_0(parser, name); + return name; +} + +static void +new_bv_gen(struct parser_params *parser, ID name) +{ + if (!name) return; + if (!is_local_id(name)) { + compile_error(PARSER_ARG "invalid local variable - %"PRIsVALUE, + rb_id2str(name)); + return; + } + if (!shadowing_lvar_0(parser, name)) return; + dyna_var(name); +} + +#ifndef RIPPER +static NODE * +aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx) +{ + return NEW_ATTRASGN(recv, tASET, idx); +} + +static void +block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2) +{ + if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) { + compile_error(PARSER_ARG "both block arg and actual block given"); + } +} + +static NODE * +attrset_gen(struct parser_params *parser, NODE *recv, ID id) +{ + return NEW_ATTRASGN(recv, rb_id_attrset(id), 0); +} + +static void +rb_backref_error_gen(struct parser_params *parser, NODE *node) +{ + switch (nd_type(node)) { + case NODE_NTH_REF: + compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth); + break; + case NODE_BACK_REF: + compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth); + break; + } +} + +static NODE * +arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2) +{ + if (!node2) return node1; + switch (nd_type(node1)) { + case NODE_BLOCK_PASS: + if (node1->nd_head) + node1->nd_head = arg_concat(node1->nd_head, node2); + else + node1->nd_head = NEW_LIST(node2); + return node1; + case NODE_ARGSPUSH: + if (nd_type(node2) != NODE_ARRAY) break; + node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2); + nd_set_type(node1, NODE_ARGSCAT); + return node1; + case NODE_ARGSCAT: + if (nd_type(node2) != NODE_ARRAY || + nd_type(node1->nd_body) != NODE_ARRAY) break; + node1->nd_body = list_concat(node1->nd_body, node2); + return node1; + } + return NEW_ARGSCAT(node1, node2); +} + +static NODE * +arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2) +{ + if (!node1) return NEW_LIST(node2); + switch (nd_type(node1)) { + case NODE_ARRAY: + return list_append(node1, node2); + case NODE_BLOCK_PASS: + node1->nd_head = arg_append(node1->nd_head, node2); + return node1; + case NODE_ARGSPUSH: + node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2); + nd_set_type(node1, NODE_ARGSCAT); + return node1; + } + return NEW_ARGSPUSH(node1, node2); +} + +static NODE * +splat_array(NODE* node) +{ + if (nd_type(node) == NODE_SPLAT) node = node->nd_head; + if (nd_type(node) == NODE_ARRAY) return node; + return 0; +} + +static NODE * +node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs) +{ + if (!lhs) return 0; + + switch (nd_type(lhs)) { + case NODE_GASGN: + case NODE_IASGN: + case NODE_IASGN2: + case NODE_LASGN: + case NODE_DASGN: + case NODE_DASGN_CURR: + case NODE_MASGN: + case NODE_CDECL: + case NODE_CVASGN: + lhs->nd_value = rhs; + break; + + case NODE_ATTRASGN: + case NODE_CALL: + lhs->nd_args = arg_append(lhs->nd_args, rhs); + break; + + default: + /* should not happen */ + break; + } + + return lhs; +} + +static int +value_expr_gen(struct parser_params *parser, NODE *node) +{ + int cond = 0; + + if (!node) { + rb_warning0("empty expression"); + } + while (node) { + switch (nd_type(node)) { + case NODE_RETURN: + case NODE_BREAK: + case NODE_NEXT: + case NODE_REDO: + case NODE_RETRY: + if (!cond) yyerror("void value expression"); + /* or "control never reach"? */ + return FALSE; + + case NODE_BLOCK: + while (node->nd_next) { + node = node->nd_next; + } + node = node->nd_head; + break; + + case NODE_BEGIN: + node = node->nd_body; + break; + + case NODE_IF: + if (!node->nd_body) { + node = node->nd_else; + break; + } + else if (!node->nd_else) { + node = node->nd_body; + break; + } + if (!value_expr(node->nd_body)) return FALSE; + node = node->nd_else; + break; + + case NODE_AND: + case NODE_OR: + cond = 1; + node = node->nd_2nd; + break; + + default: + return TRUE; + } + } + + return TRUE; +} + +static void +void_expr_gen(struct parser_params *parser, NODE *node) +{ + const char *useless = 0; + + if (!RTEST(ruby_verbose)) return; + + if (!node) return; + switch (nd_type(node)) { + case NODE_CALL: + switch (node->nd_mid) { + case '+': + case '-': + case '*': + case '/': + case '%': + case tPOW: + case tUPLUS: + case tUMINUS: + case '|': + case '^': + case '&': + case tCMP: + case '>': + case tGEQ: + case '<': + case tLEQ: + case tEQ: + case tNEQ: + useless = rb_id2name(node->nd_mid); + break; + } + break; + + case NODE_LVAR: + case NODE_DVAR: + case NODE_GVAR: + case NODE_IVAR: + case NODE_CVAR: + case NODE_NTH_REF: + case NODE_BACK_REF: + useless = "a variable"; + break; + case NODE_CONST: + useless = "a constant"; + break; + case NODE_LIT: + case NODE_STR: + case NODE_DSTR: + case NODE_DREGX: + case NODE_DREGX_ONCE: + useless = "a literal"; + break; + case NODE_COLON2: + case NODE_COLON3: + useless = "::"; + break; + case NODE_DOT2: + useless = ".."; + break; + case NODE_DOT3: + useless = "..."; + break; + case NODE_SELF: + useless = "self"; + break; + case NODE_NIL: + useless = "nil"; + break; + case NODE_TRUE: + useless = "true"; + break; + case NODE_FALSE: + useless = "false"; + break; + case NODE_DEFINED: + useless = "defined?"; + break; + } + + if (useless) { + int line = ruby_sourceline; + + ruby_sourceline = nd_line(node); + rb_warnS("possibly useless use of %s in void context", useless); + ruby_sourceline = line; + } +} + +static void +void_stmts_gen(struct parser_params *parser, NODE *node) +{ + if (!RTEST(ruby_verbose)) return; + if (!node) return; + if (nd_type(node) != NODE_BLOCK) return; + + for (;;) { + if (!node->nd_next) return; + void_expr0(node->nd_head); + node = node->nd_next; + } +} + +static NODE * +remove_begin(NODE *node) +{ + NODE **n = &node, *n1 = node; + while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) { + *n = n1 = n1->nd_body; + } + return node; +} + +static NODE * +remove_begin_all(NODE *node) +{ + NODE **n = &node, *n1 = node; + while (n1 && nd_type(n1) == NODE_BEGIN) { + *n = n1 = n1->nd_body; + } + return node; +} + +static void +reduce_nodes_gen(struct parser_params *parser, NODE **body) +{ + NODE *node = *body; + + if (!node) { + *body = NEW_NIL(); + return; + } +#define subnodes(n1, n2) \ + ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \ + (!node->n2) ? (body = &node->n1, 1) : \ + (reduce_nodes(&node->n1), body = &node->n2, 1)) + + while (node) { + int newline = (int)(node->flags & NODE_FL_NEWLINE); + switch (nd_type(node)) { + end: + case NODE_NIL: + *body = 0; + return; + case NODE_RETURN: + *body = node = node->nd_stts; + if (newline && node) node->flags |= NODE_FL_NEWLINE; + continue; + case NODE_BEGIN: + *body = node = node->nd_body; + if (newline && node) node->flags |= NODE_FL_NEWLINE; + continue; + case NODE_BLOCK: + body = &node->nd_end->nd_head; + break; + case NODE_IF: + if (subnodes(nd_body, nd_else)) break; + return; + case NODE_CASE: + body = &node->nd_body; + break; + case NODE_WHEN: + if (!subnodes(nd_body, nd_next)) goto end; + break; + case NODE_ENSURE: + if (!subnodes(nd_head, nd_resq)) goto end; + break; + case NODE_RESCUE: + if (node->nd_else) { + body = &node->nd_resq; + break; + } + if (!subnodes(nd_head, nd_resq)) goto end; + break; + default: + return; + } + node = *body; + if (newline && node) node->flags |= NODE_FL_NEWLINE; + } + +#undef subnodes +} + +static int +is_static_content(NODE *node) +{ + if (!node) return 1; + switch (nd_type(node)) { + case NODE_HASH: + if (!(node = node->nd_head)) break; + case NODE_ARRAY: + do { + if (!is_static_content(node->nd_head)) return 0; + } while ((node = node->nd_next) != 0); + case NODE_LIT: + case NODE_STR: + case NODE_NIL: + case NODE_TRUE: + case NODE_FALSE: + case NODE_ZARRAY: + break; + default: + return 0; + } + return 1; +} + +static int +assign_in_cond(struct parser_params *parser, NODE *node) +{ + switch (nd_type(node)) { + case NODE_MASGN: + yyerror("multiple assignment in conditional"); + return 1; + + case NODE_LASGN: + case NODE_DASGN: + case NODE_DASGN_CURR: + case NODE_GASGN: + case NODE_IASGN: + break; + + default: + return 0; + } + + if (!node->nd_value) return 1; + if (is_static_content(node->nd_value)) { + /* reports always */ + parser_warn(node->nd_value, "found = in conditional, should be =="); + } + return 1; +} + +static void +warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str) +{ + if (!e_option_supplied(parser)) parser_warn(node, str); +} + +static void +warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str) +{ + if (!e_option_supplied(parser)) parser_warning(node, str); +} + +static void +fixup_nodes(NODE **rootnode) +{ + NODE *node, *next, *head; + + for (node = *rootnode; node; node = next) { + enum node_type type; + VALUE val; + + next = node->nd_next; + head = node->nd_head; + rb_gc_force_recycle((VALUE)node); + *rootnode = next; + switch (type = nd_type(head)) { + case NODE_DOT2: + case NODE_DOT3: + val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit, + type == NODE_DOT3); + rb_gc_force_recycle((VALUE)head->nd_beg); + rb_gc_force_recycle((VALUE)head->nd_end); + nd_set_type(head, NODE_LIT); + head->nd_lit = val; + break; + default: + break; + } + } +} + +static NODE *cond0(struct parser_params*,NODE*); + +static NODE* +range_op(struct parser_params *parser, NODE *node) +{ + enum node_type type; + + if (node == 0) return 0; + + type = nd_type(node); + value_expr(node); + if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) { + warn_unless_e_option(parser, node, "integer literal in conditional range"); + return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$.")))); + } + return cond0(parser, node); +} + +static int +literal_node(NODE *node) +{ + if (!node) return 1; /* same as NODE_NIL */ + switch (nd_type(node)) { + case NODE_LIT: + case NODE_STR: + case NODE_DSTR: + case NODE_EVSTR: + case NODE_DREGX: + case NODE_DREGX_ONCE: + case NODE_DSYM: + return 2; + case NODE_TRUE: + case NODE_FALSE: + case NODE_NIL: + return 1; + } + return 0; +} + +static NODE* +cond0(struct parser_params *parser, NODE *node) +{ + if (node == 0) return 0; + assign_in_cond(parser, node); + + switch (nd_type(node)) { + case NODE_DSTR: + case NODE_EVSTR: + case NODE_STR: + rb_warn0("string literal in condition"); + break; + + case NODE_DREGX: + case NODE_DREGX_ONCE: + warning_unless_e_option(parser, node, "regex literal in condition"); + return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_"))); + + case NODE_AND: + case NODE_OR: + node->nd_1st = cond0(parser, node->nd_1st); + node->nd_2nd = cond0(parser, node->nd_2nd); + break; + + case NODE_DOT2: + case NODE_DOT3: + node->nd_beg = range_op(parser, node->nd_beg); + node->nd_end = range_op(parser, node->nd_end); + if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2); + else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3); + if (!e_option_supplied(parser)) { + int b = literal_node(node->nd_beg); + int e = literal_node(node->nd_end); + if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) { + parser_warn(node, "range literal in condition"); + } + } + break; + + case NODE_DSYM: + parser_warning(node, "literal in condition"); + break; + + case NODE_LIT: + if (RB_TYPE_P(node->nd_lit, T_REGEXP)) { + warn_unless_e_option(parser, node, "regex literal in condition"); + nd_set_type(node, NODE_MATCH); + } + else { + parser_warning(node, "literal in condition"); + } + default: + break; + } + return node; +} + +static NODE* +cond_gen(struct parser_params *parser, NODE *node) +{ + if (node == 0) return 0; + return cond0(parser, node); +} + +static NODE* +logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right) +{ + value_expr(left); + if (left && (enum node_type)nd_type(left) == type) { + NODE *node = left, *second; + while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) { + node = second; + } + node->nd_2nd = NEW_NODE(type, second, right, 0); + return left; + } + return NEW_NODE(type, left, right, 0); +} + +static void +no_blockarg(struct parser_params *parser, NODE *node) +{ + if (node && nd_type(node) == NODE_BLOCK_PASS) { + compile_error(PARSER_ARG "block argument should not be given"); + } +} + +static NODE * +ret_args_gen(struct parser_params *parser, NODE *node) +{ + if (node) { + no_blockarg(parser, node); + if (nd_type(node) == NODE_ARRAY) { + if (node->nd_next == 0) { + node = node->nd_head; + } + else { + nd_set_type(node, NODE_VALUES); + } + } + } + return node; +} + +static NODE * +new_yield_gen(struct parser_params *parser, NODE *node) +{ + if (node) no_blockarg(parser, node); + + return NEW_YIELD(node); +} + +static VALUE +negate_lit(VALUE lit) +{ + int type = TYPE(lit); + switch (type) { + case T_FIXNUM: + lit = LONG2FIX(-FIX2LONG(lit)); + break; + case T_BIGNUM: + case T_RATIONAL: + case T_COMPLEX: + lit = rb_funcall(lit,tUMINUS,0,0); + break; + case T_FLOAT: +#if USE_FLONUM + if (FLONUM_P(lit)) { + lit = DBL2NUM(-RFLOAT_VALUE(lit)); + break; + } +#endif + RFLOAT(lit)->float_value = -RFLOAT_VALUE(lit); + break; + default: + rb_bug("unknown literal type (%d) passed to negate_lit", type); + break; + } + return lit; +} + +static NODE * +arg_blk_pass(NODE *node1, NODE *node2) +{ + if (node2) { + node2->nd_head = node1; + return node2; + } + return node1; +} + + +static NODE* +new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail) +{ + int saved_line = ruby_sourceline; + struct rb_args_info *args = tail->nd_ainfo; + + args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0; + args->pre_init = m ? m->nd_next : 0; + + args->post_args_num = p ? rb_long2int(p->nd_plen) : 0; + args->post_init = p ? p->nd_next : 0; + args->first_post_arg = p ? p->nd_pid : 0; + + args->rest_arg = r; + + args->opt_args = o; + + ruby_sourceline = saved_line; + + return tail; +} + +static NODE* +new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b) +{ + int saved_line = ruby_sourceline; + struct rb_args_info *args; + NODE *node; + + args = ZALLOC(struct rb_args_info); + node = NEW_NODE(NODE_ARGS, 0, 0, args); + + args->block_arg = b; + args->kw_args = k; + + if (k) { + /* + * def foo(k1: 1, kr1:, k2: 2, **krest, &b) + * variable order: k1, kr1, k2, &b, internal_id, krest + * #=> <reorder> + * variable order: kr1, k1, k2, internal_id, krest, &b + */ + ID kw_bits; + NODE *kwn = k; + struct vtable *required_kw_vars = vtable_alloc(NULL); + struct vtable *kw_vars = vtable_alloc(NULL); + int i; + + while (kwn) { + NODE *val_node = kwn->nd_body->nd_value; + ID vid = kwn->nd_body->nd_vid; + + if (val_node == (NODE *)-1) { + vtable_add(required_kw_vars, vid); + } + else { + vtable_add(kw_vars, vid); + } + + kwn = kwn->nd_next; + } + + kw_bits = internal_id(); + if (kr && is_junk_id(kr)) vtable_pop(lvtbl->args, 1); + vtable_pop(lvtbl->args, vtable_size(required_kw_vars) + vtable_size(kw_vars) + (b != 0)); + + for (i=0; i<vtable_size(required_kw_vars); i++) arg_var(required_kw_vars->tbl[i]); + for (i=0; i<vtable_size(kw_vars); i++) arg_var(kw_vars->tbl[i]); + vtable_free(required_kw_vars); + vtable_free(kw_vars); + + arg_var(kw_bits); + if (kr) arg_var(kr); + if (b) arg_var(b); + + args->kw_rest_arg = NEW_DVAR(kw_bits); + args->kw_rest_arg->nd_cflag = kr; + } + else if (kr) { + if (b) vtable_pop(lvtbl->args, 1); /* reorder */ + arg_var(kr); + if (b) arg_var(b); + args->kw_rest_arg = NEW_DVAR(kr); + } + + ruby_sourceline = saved_line; + return node; +} + +static NODE* +dsym_node_gen(struct parser_params *parser, NODE *node) +{ + VALUE lit; + + if (!node) { + return NEW_LIT(ID2SYM(idNULL)); + } + + switch (nd_type(node)) { + case NODE_DSTR: + nd_set_type(node, NODE_DSYM); + break; + case NODE_STR: + lit = node->nd_lit; + node->nd_lit = ID2SYM(rb_intern_str(lit)); + nd_set_type(node, NODE_LIT); + break; + default: + node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node)); + break; + } + return node; +} + +static int +append_literal_keys(st_data_t k, st_data_t v, st_data_t h) +{ + NODE *node = (NODE *)v; + NODE **result = (NODE **)h; + node->nd_alen = 2; + node->nd_next->nd_end = node->nd_next; + node->nd_next->nd_next = 0; + if (*result) + list_concat(*result, node); + else + *result = node; + return ST_CONTINUE; +} + +static NODE * +remove_duplicate_keys(struct parser_params *parser, NODE *hash) +{ + st_table *literal_keys = st_init_numtable_with_size(hash->nd_alen / 2); + NODE *result = 0; + while (hash && hash->nd_head && hash->nd_next) { + NODE *head = hash->nd_head; + NODE *value = hash->nd_next; + NODE *next = value->nd_next; + VALUE key = (VALUE)head; + st_data_t data; + if (nd_type(head) == NODE_LIT && + st_lookup(literal_keys, (key = head->nd_lit), &data)) { + rb_compile_warn(ruby_sourcefile, nd_line((NODE *)data), + "duplicated key at line %d ignored: %+"PRIsVALUE, + nd_line(head), head->nd_lit); + head = ((NODE *)data)->nd_next; + head->nd_head = block_append(head->nd_head, value->nd_head); + } + else { + st_insert(literal_keys, (st_data_t)key, (st_data_t)hash); + } + hash = next; + } + st_foreach(literal_keys, append_literal_keys, (st_data_t)&result); + st_free_table(literal_keys); + if (hash) { + if (!result) result = hash; + else list_concat(result, hash); + } + return result; +} + +static NODE * +new_hash_gen(struct parser_params *parser, NODE *hash) +{ + if (hash) hash = remove_duplicate_keys(parser, hash); + return NEW_HASH(hash); +} +#endif /* !RIPPER */ + +#ifndef RIPPER +static NODE * +new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs) +{ + NODE *asgn; + + if (lhs) { + ID vid = lhs->nd_vid; + if (op == tOROP) { + lhs->nd_value = rhs; + asgn = NEW_OP_ASGN_OR(gettable(vid), lhs); + if (is_notop_id(vid)) { + switch (id_type(vid)) { + case ID_GLOBAL: + case ID_INSTANCE: + case ID_CLASS: + asgn->nd_aid = vid; + } + } + } + else if (op == tANDOP) { + lhs->nd_value = rhs; + asgn = NEW_OP_ASGN_AND(gettable(vid), lhs); + } + else { + asgn = lhs; + asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs)); + } + } + else { + asgn = NEW_BEGIN(0); + } + return asgn; +} + +static NODE * +new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs) +{ + NODE *asgn; + + if (op == tOROP) { + op = 0; + } + else if (op == tANDOP) { + op = 1; + } + asgn = NEW_OP_ASGN2(lhs, attr, op, rhs); + fixpos(asgn, lhs); + return asgn; +} + +static NODE * +new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs) +{ + NODE *asgn; + + if (op == tOROP) { + op = 0; + } + else if (op == tANDOP) { + op = 1; + } + if (lhs) { + asgn = NEW_OP_CDECL(lhs, op, rhs); + } + else { + asgn = NEW_BEGIN(0); + } + fixpos(asgn, lhs); + return asgn; +} +#else +static VALUE +new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs) +{ + return dispatch3(opassign, lhs, op, rhs); +} + +static VALUE +new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs) +{ + VALUE recv = dispatch3(field, lhs, type, attr); + return dispatch3(opassign, recv, op, rhs); +} +#endif + +static void +warn_unused_var(struct parser_params *parser, struct local_vars *local) +{ + int i, cnt; + ID *v, *u; + + if (!local->used) return; + v = local->vars->tbl; + u = local->used->tbl; + cnt = local->used->pos; + if (cnt != local->vars->pos) { + rb_bug("local->used->pos != local->vars->pos"); + } + for (i = 0; i < cnt; ++i) { + if (!v[i] || (u[i] & LVAR_USED)) continue; + if (is_private_local_id(v[i])) continue; + rb_warn4V(ruby_sourcefile, (int)u[i], "assigned but unused variable - %"PRIsVALUE, rb_id2str(v[i])); + } +} + +static void +local_push_gen(struct parser_params *parser, int inherit_dvars) +{ + struct local_vars *local; + + local = ALLOC(struct local_vars); + local->prev = lvtbl; + local->args = vtable_alloc(0); + local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE); + local->used = !(inherit_dvars && + (ifndef_ripper(compile_for_eval || e_option_supplied(parser))+0)) && + RTEST(ruby_verbose) ? vtable_alloc(0) : 0; +# if WARN_PAST_SCOPE + local->past = 0; +# endif + local->cmdargs = cmdarg_stack; + cmdarg_stack = 0; + lvtbl = local; +} + +static void +local_pop_gen(struct parser_params *parser) +{ + struct local_vars *local = lvtbl->prev; + if (lvtbl->used) { + warn_unused_var(parser, lvtbl); + vtable_free(lvtbl->used); + } +# if WARN_PAST_SCOPE + while (lvtbl->past) { + struct vtable *past = lvtbl->past; + lvtbl->past = past->prev; + vtable_free(past); + } +# endif + vtable_free(lvtbl->args); + vtable_free(lvtbl->vars); + cmdarg_stack = lvtbl->cmdargs; + xfree(lvtbl); + lvtbl = local; +} + +#ifndef RIPPER +static ID* +local_tbl_gen(struct parser_params *parser) +{ + int cnt_args = vtable_size(lvtbl->args); + int cnt_vars = vtable_size(lvtbl->vars); + int cnt = cnt_args + cnt_vars; + int i, j; + ID *buf; + + if (cnt <= 0) return 0; + buf = ALLOC_N(ID, cnt + 1); + MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args); + /* remove IDs duplicated to warn shadowing */ + for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) { + ID id = lvtbl->vars->tbl[i]; + if (!vtable_included(lvtbl->args, id)) { + buf[j++] = id; + } + } + if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1); + buf[0] = cnt; + return buf; +} +#endif + +static void +arg_var_gen(struct parser_params *parser, ID id) +{ + vtable_add(lvtbl->args, id); +} + +static void +local_var_gen(struct parser_params *parser, ID id) +{ + vtable_add(lvtbl->vars, id); + if (lvtbl->used) { + vtable_add(lvtbl->used, (ID)ruby_sourceline); + } +} + +static int +local_id_gen(struct parser_params *parser, ID id) +{ + struct vtable *vars, *args, *used; + + vars = lvtbl->vars; + args = lvtbl->args; + used = lvtbl->used; + + while (vars && POINTER_P(vars->prev)) { + vars = vars->prev; + args = args->prev; + if (used) used = used->prev; + } + + if (vars && vars->prev == DVARS_INHERIT) { + return rb_local_defined(id); + } + else if (vtable_included(args, id)) { + return 1; + } + else { + int i = vtable_included(vars, id); + if (i && used) used->tbl[i-1] |= LVAR_USED; + return i != 0; + } +} + +static const struct vtable * +dyna_push_gen(struct parser_params *parser) +{ + lvtbl->args = vtable_alloc(lvtbl->args); + lvtbl->vars = vtable_alloc(lvtbl->vars); + if (lvtbl->used) { + lvtbl->used = vtable_alloc(lvtbl->used); + } + return lvtbl->args; +} + +static void +dyna_pop_vtable(struct parser_params *parser, struct vtable **vtblp) +{ + struct vtable *tmp = *vtblp; + *vtblp = tmp->prev; +# if WARN_PAST_SCOPE + if (parser->parser_past_scope_enabled) { + tmp->prev = lvtbl->past; + lvtbl->past = tmp; + return; + } +# endif + vtable_free(tmp); +} + +static void +dyna_pop_1(struct parser_params *parser) +{ + struct vtable *tmp; + + if ((tmp = lvtbl->used) != 0) { + warn_unused_var(parser, lvtbl); + lvtbl->used = lvtbl->used->prev; + vtable_free(tmp); + } + dyna_pop_vtable(parser, &lvtbl->args); + dyna_pop_vtable(parser, &lvtbl->vars); +} + +static void +dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs) +{ + while (lvtbl->args != lvargs) { + dyna_pop_1(parser); + if (!lvtbl->args) { + struct local_vars *local = lvtbl->prev; + xfree(lvtbl); + lvtbl = local; + } + } + dyna_pop_1(parser); +} + +static int +dyna_in_block_gen(struct parser_params *parser) +{ + return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE; +} + +static int +dvar_defined_gen(struct parser_params *parser, ID id, int get) +{ + struct vtable *vars, *args, *used; + int i; + + args = lvtbl->args; + vars = lvtbl->vars; + used = lvtbl->used; + + while (POINTER_P(vars)) { + if (vtable_included(args, id)) { + return 1; + } + if ((i = vtable_included(vars, id)) != 0) { + if (used) used->tbl[i-1] |= LVAR_USED; + return 1; + } + args = args->prev; + vars = vars->prev; + if (get) used = 0; + if (used) used = used->prev; + } + + if (vars == DVARS_INHERIT) { + return rb_dvar_defined(id); + } + + return 0; +} + +static int +dvar_curr_gen(struct parser_params *parser, ID id) +{ + return (vtable_included(lvtbl->args, id) || + vtable_included(lvtbl->vars, id)); +} + +#ifndef RIPPER +static void +reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options) +{ + int c = RE_OPTION_ENCODING_IDX(options); + + if (c) { + int opt, idx; + rb_char_to_option_kcode(c, &opt, &idx); + if (idx != ENCODING_GET(str) && + rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) { + goto error; + } + ENCODING_SET(str, idx); + } + else if (RE_OPTION_ENCODING_NONE(options)) { + if (!ENCODING_IS_ASCII8BIT(str) && + rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) { + c = 'n'; + goto error; + } + rb_enc_associate(str, rb_ascii8bit_encoding()); + } + else if (current_enc == rb_usascii_encoding()) { + if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) { + /* raise in re.c */ + rb_enc_associate(str, rb_usascii_encoding()); + } + else { + rb_enc_associate(str, rb_ascii8bit_encoding()); + } + } + return; + + error: + compile_error(PARSER_ARG + "regexp encoding option '%c' differs from source encoding '%s'", + c, rb_enc_name(rb_enc_get(str))); +} + +static int +reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options) +{ + VALUE err; + reg_fragment_setenc(str, options); + err = rb_reg_check_preprocess(str); + if (err != Qnil) { + err = rb_obj_as_string(err); + compile_error(PARSER_ARG "%"PRIsVALUE, err); + return 0; + } + return 1; +} + +typedef struct { + struct parser_params* parser; + rb_encoding *enc; + NODE *succ_block; + NODE *fail_block; + int num; +} reg_named_capture_assign_t; + +static int +reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end, + int back_num, int *back_refs, OnigRegex regex, void *arg0) +{ + reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0; + struct parser_params* parser = arg->parser; + rb_encoding *enc = arg->enc; + long len = name_end - name; + const char *s = (const char *)name; + ID var; + + arg->num++; + + if (arg->succ_block == 0) { + arg->succ_block = NEW_BEGIN(0); + arg->fail_block = NEW_BEGIN(0); + } + + if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) || + (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) || + !rb_enc_symname2_p(s, len, enc)) { + return ST_CONTINUE; + } + var = intern_cstr(s, len, enc); + if (dvar_defined(var) || local_id(var)) { + rb_warningV("named capture conflicts a local variable - %"PRIsVALUE, + rb_id2str(var)); + } + arg->succ_block = block_append(arg->succ_block, + newline_node(node_assign(assignable(var,0), + NEW_CALL( + gettable(rb_intern("$~")), + idAREF, + NEW_LIST(NEW_LIT(ID2SYM(var)))) + ))); + arg->fail_block = block_append(arg->fail_block, + newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil)))); + return ST_CONTINUE; +} + +static NODE * +reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match) +{ + reg_named_capture_assign_t arg; + + arg.parser = parser; + arg.enc = rb_enc_get(regexp); + arg.succ_block = 0; + arg.fail_block = 0; + arg.num = 0; + onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, &arg); + + if (arg.num == 0) + return match; + + return + block_append( + newline_node(match), + NEW_IF(gettable(rb_intern("$~")), + block_append( + newline_node(arg.succ_block), + newline_node( + NEW_CALL( + gettable(rb_intern("$~")), + rb_intern("begin"), + NEW_LIST(NEW_LIT(INT2FIX(0)))))), + block_append( + newline_node(arg.fail_block), + newline_node( + NEW_LIT(Qnil))))); +} + +static VALUE +parser_reg_compile(struct parser_params* parser, VALUE str, int options) +{ + reg_fragment_setenc(str, options); + return rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline); +} + +static VALUE +reg_compile_gen(struct parser_params* parser, VALUE str, int options) +{ + VALUE re; + VALUE err; + + err = rb_errinfo(); + re = parser_reg_compile(parser, str, options); + if (NIL_P(re)) { + VALUE m = rb_attr_get(rb_errinfo(), idMesg); + rb_set_errinfo(err); + if (!NIL_P(err)) { + rb_str_append(rb_str_cat(rb_attr_get(err, idMesg), "\n", 1), m); + } + else { + compile_error(PARSER_ARG "%"PRIsVALUE, m); + } + return Qnil; + } + return re; +} + +VALUE +rb_parser_reg_compile(struct parser_params* parser, VALUE str, int options, VALUE *errmsg) +{ + VALUE err = rb_errinfo(); + VALUE re = parser_reg_compile(parser, str, options); + if (NIL_P(re)) { + *errmsg = rb_attr_get(rb_errinfo(), idMesg); + rb_set_errinfo(err); + } + return re; +} + +NODE* +rb_parser_append_print(VALUE vparser, NODE *node) +{ + NODE *prelude = 0; + NODE *scope = node; + struct parser_params *parser; + + if (!node) return node; + + TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser); + + node = node->nd_body; + + if (nd_type(node) == NODE_PRELUDE) { + prelude = node; + node = node->nd_body; + } + + node = block_append(node, + NEW_FCALL(rb_intern("print"), + NEW_ARRAY(NEW_GVAR(rb_intern("$_"))))); + if (prelude) { + prelude->nd_body = node; + scope->nd_body = prelude; + } + else { + scope->nd_body = node; + } + + return scope; +} + +NODE * +rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split) +{ + NODE *prelude = 0; + NODE *scope = node; + struct parser_params *parser; + + if (!node) return node; + + TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser); + + node = node->nd_body; + + if (nd_type(node) == NODE_PRELUDE) { + prelude = node; + node = node->nd_body; + } + if (split) { + node = block_append(NEW_GASGN(rb_intern("$F"), + NEW_CALL(NEW_GVAR(rb_intern("$_")), + rb_intern("split"), 0)), + node); + } + if (chop) { + node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")), + rb_intern("chop!"), 0), node); + } + + node = NEW_OPT_N(node); + + if (prelude) { + prelude->nd_body = node; + scope->nd_body = prelude; + } + else { + scope->nd_body = node; + } + + return scope; +} + +void +rb_init_parse(void) +{ + /* just to suppress unused-function warnings */ + (void)nodetype; + (void)nodeline; +#if PARSER_DEBUG + (void)lex_state_name(-1); +#endif +} +#endif /* !RIPPER */ + +static ID +internal_id_gen(struct parser_params *parser) +{ + ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars); + id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1; + return ID_STATIC_SYM | ID_INTERNAL | (id << ID_SCOPE_SHIFT); +} + +static void +parser_initialize(struct parser_params *parser) +{ + parser->eofp = Qfalse; + + parser->parser_lex_strterm = 0; + parser->parser_cond_stack = 0; + parser->parser_cmdarg_stack = 0; + parser->parser_paren_nest = 0; + parser->parser_lpar_beg = 0; + parser->parser_brace_nest = 0; + parser->parser_in_single = 0; + parser->parser_in_def = 0; + parser->parser_in_defined = 0; + parser->parser_in_kwarg = 0; + parser->parser_compile_for_eval = 0; + parser->parser_tokenbuf = NULL; + parser->parser_tokidx = 0; + parser->parser_toksiz = 0; + parser->parser_heredoc_end = 0; + parser->parser_command_start = TRUE; + parser->parser_deferred_nodes = 0; + parser->parser_lex_pbeg = 0; + parser->parser_lex_p = 0; + parser->parser_lex_pend = 0; + parser->parser_lvtbl = 0; + parser->parser_ruby__end__seen = 0; + parser->parser_ruby_sourcefile = 0; + parser->parser_ruby_sourcefile_string = Qnil; + parser->cur_arg = 0; +#ifndef RIPPER + parser->parser_eval_tree_begin = 0; + parser->parser_eval_tree = 0; +#else + parser->delayed = Qnil; + + parser->result = Qnil; + parser->parsing_thread = Qnil; + parser->toplevel_p = TRUE; + parser->error_p = FALSE; +#endif +#ifdef YYMALLOC + parser->heap = NULL; +#endif + parser->enc = rb_utf8_encoding(); +} + +#ifdef RIPPER +#define parser_mark ripper_parser_mark +#define parser_free ripper_parser_free +#endif + +static void +parser_mark(void *ptr) +{ + struct parser_params *p = (struct parser_params*)ptr; + + rb_gc_mark((VALUE)p->parser_lex_strterm); + rb_gc_mark((VALUE)p->parser_deferred_nodes); + rb_gc_mark(p->parser_lex_input); + rb_gc_mark(p->parser_lex_lastline); + rb_gc_mark(p->parser_lex_nextline); + rb_gc_mark(p->parser_ruby_sourcefile_string); +#ifndef RIPPER + rb_gc_mark((VALUE)p->parser_eval_tree_begin) ; + rb_gc_mark((VALUE)p->parser_eval_tree) ; + rb_gc_mark(p->debug_lines); +#else + rb_gc_mark(p->delayed); + rb_gc_mark(p->value); + rb_gc_mark(p->result); + rb_gc_mark(p->parsing_thread); +#endif +#ifdef YYMALLOC + rb_gc_mark((VALUE)p->heap); +#endif +} + +static void +parser_free(void *ptr) +{ + struct parser_params *p = (struct parser_params*)ptr; + struct local_vars *local, *prev; + + if (p->parser_tokenbuf) { + xfree(p->parser_tokenbuf); + } + for (local = p->parser_lvtbl; local; local = prev) { + if (local->vars) xfree(local->vars); + prev = local->prev; + xfree(local); + } + xfree(p); +} + +static size_t +parser_memsize(const void *ptr) +{ + struct parser_params *p = (struct parser_params*)ptr; + struct local_vars *local; + size_t size = sizeof(*p); + + if (!ptr) return 0; + size += p->parser_toksiz; + for (local = p->parser_lvtbl; local; local = local->prev) { + size += sizeof(*local); + if (local->vars) size += local->vars->capa * sizeof(ID); + } + return size; +} + +static const rb_data_type_t parser_data_type = { +#ifndef RIPPER + "parser", +#else + "ripper", +#endif + { + parser_mark, + parser_free, + parser_memsize, + }, + 0, 0, RUBY_TYPED_FREE_IMMEDIATELY +}; + +#ifndef RIPPER +#undef rb_reserved_word + +const struct kwtable * +rb_reserved_word(const char *str, unsigned int len) +{ + return reserved_word(str, len); +} + +static struct parser_params * +parser_new(void) +{ + struct parser_params *p; + + p = ZALLOC(struct parser_params); + parser_initialize(p); + return p; +} + +VALUE +rb_parser_new(void) +{ + struct parser_params *p = parser_new(); + + return TypedData_Wrap_Struct(0, &parser_data_type, p); +} +#endif + +#ifdef RIPPER +#define rb_parser_end_seen_p ripper_parser_end_seen_p +#define rb_parser_encoding ripper_parser_encoding +#define rb_parser_get_yydebug ripper_parser_get_yydebug +#define rb_parser_set_yydebug ripper_parser_set_yydebug +static VALUE ripper_parser_end_seen_p(VALUE vparser); +static VALUE ripper_parser_encoding(VALUE vparser); +static VALUE ripper_parser_get_yydebug(VALUE self); +static VALUE ripper_parser_set_yydebug(VALUE self, VALUE flag); + +/* + * call-seq: + * ripper#error? -> Boolean + * + * Return true if parsed source has errors. + */ +static VALUE +ripper_error_p(VALUE vparser) +{ + struct parser_params *parser; + + TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser); + return parser->error_p ? Qtrue : Qfalse; +} +#endif + +/* + * call-seq: + * ripper#end_seen? -> Boolean + * + * Return true if parsed source ended by +\_\_END\_\_+. + */ +VALUE +rb_parser_end_seen_p(VALUE vparser) +{ + struct parser_params *parser; + + TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser); + return ruby__end__seen ? Qtrue : Qfalse; +} + +/* + * call-seq: + * ripper#encoding -> encoding + * + * Return encoding of the source. + */ +VALUE +rb_parser_encoding(VALUE vparser) +{ + struct parser_params *parser; + + TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser); + return rb_enc_from_encoding(current_enc); +} + +/* + * call-seq: + * ripper.yydebug -> true or false + * + * Get yydebug. + */ +VALUE +rb_parser_get_yydebug(VALUE self) +{ + struct parser_params *parser; + + TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); + return yydebug ? Qtrue : Qfalse; +} + +/* + * call-seq: + * ripper.yydebug = flag + * + * Set yydebug. + */ +VALUE +rb_parser_set_yydebug(VALUE self, VALUE flag) +{ + struct parser_params *parser; + + TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); + yydebug = RTEST(flag); + return flag; +} + +#ifndef RIPPER +#ifdef YYMALLOC +#define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE)) +#define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0) +#define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \ + (n)->u3.cnt = (c), (p)) + +void * +rb_parser_malloc(struct parser_params *parser, size_t size) +{ + size_t cnt = HEAPCNT(1, size); + NODE *n = NEWHEAP(); + void *ptr = xmalloc(size); + + return ADD2HEAP(n, cnt, ptr); +} + +void * +rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size) +{ + size_t cnt = HEAPCNT(nelem, size); + NODE *n = NEWHEAP(); + void *ptr = xcalloc(nelem, size); + + return ADD2HEAP(n, cnt, ptr); +} + +void * +rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size) +{ + NODE *n; + size_t cnt = HEAPCNT(1, size); + + if (ptr && (n = parser->heap) != NULL) { + do { + if (n->u1.node == ptr) { + n->u1.node = ptr = xrealloc(ptr, size); + if (n->u3.cnt) n->u3.cnt = cnt; + return ptr; + } + } while ((n = n->u2.node) != NULL); + } + n = NEWHEAP(); + ptr = xrealloc(ptr, size); + return ADD2HEAP(n, cnt, ptr); +} + +void +rb_parser_free(struct parser_params *parser, void *ptr) +{ + NODE **prev = &parser->heap, *n; + + while ((n = *prev) != NULL) { + if (n->u1.node == ptr) { + *prev = n->u2.node; + rb_gc_force_recycle((VALUE)n); + break; + } + prev = &n->u2.node; + } + xfree(ptr); +} +#endif +#endif + +#ifdef RIPPER +#ifdef RIPPER_DEBUG +extern int rb_is_pointer_to_heap(VALUE); + +/* :nodoc: */ +static VALUE +ripper_validate_object(VALUE self, VALUE x) +{ + if (x == Qfalse) return x; + if (x == Qtrue) return x; + if (x == Qnil) return x; + if (x == Qundef) + rb_raise(rb_eArgError, "Qundef given"); + if (FIXNUM_P(x)) return x; + if (SYMBOL_P(x)) return x; + if (!rb_is_pointer_to_heap(x)) + rb_raise(rb_eArgError, "invalid pointer: %p", x); + switch (BUILTIN_TYPE(x)) { + case T_STRING: + case T_OBJECT: + case T_ARRAY: + case T_BIGNUM: + case T_FLOAT: + case T_COMPLEX: + case T_RATIONAL: + return x; + case T_NODE: + if (nd_type(x) != NODE_RIPPER) { + rb_raise(rb_eArgError, "NODE given: %p", x); + } + return ((NODE *)x)->nd_rval; + default: + rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)", + x, rb_obj_classname(x)); + } + return x; +} +#endif + +#define validate(x) ((x) = get_value(x)) + +static VALUE +ripper_dispatch0(struct parser_params *parser, ID mid) +{ + return rb_funcall(parser->value, mid, 0); +} + +static VALUE +ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a) +{ + validate(a); + return rb_funcall(parser->value, mid, 1, a); +} + +static VALUE +ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b) +{ + validate(a); + validate(b); + return rb_funcall(parser->value, mid, 2, a, b); +} + +static VALUE +ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c) +{ + validate(a); + validate(b); + validate(c); + return rb_funcall(parser->value, mid, 3, a, b, c); +} + +static VALUE +ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d) +{ + validate(a); + validate(b); + validate(c); + validate(d); + return rb_funcall(parser->value, mid, 4, a, b, c, d); +} + +static VALUE +ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e) +{ + validate(a); + validate(b); + validate(c); + validate(d); + validate(e); + return rb_funcall(parser->value, mid, 5, a, b, c, d, e); +} + +static VALUE +ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g) +{ + validate(a); + validate(b); + validate(c); + validate(d); + validate(e); + validate(f); + validate(g); + return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g); +} + +static const struct kw_assoc { + ID id; + const char *name; +} keyword_to_name[] = { + {keyword_class, "class"}, + {keyword_module, "module"}, + {keyword_def, "def"}, + {keyword_undef, "undef"}, + {keyword_begin, "begin"}, + {keyword_rescue, "rescue"}, + {keyword_ensure, "ensure"}, + {keyword_end, "end"}, + {keyword_if, "if"}, + {keyword_unless, "unless"}, + {keyword_then, "then"}, + {keyword_elsif, "elsif"}, + {keyword_else, "else"}, + {keyword_case, "case"}, + {keyword_when, "when"}, + {keyword_while, "while"}, + {keyword_until, "until"}, + {keyword_for, "for"}, + {keyword_break, "break"}, + {keyword_next, "next"}, + {keyword_redo, "redo"}, + {keyword_retry, "retry"}, + {keyword_in, "in"}, + {keyword_do, "do"}, + {keyword_do_cond, "do"}, + {keyword_do_block, "do"}, + {keyword_return, "return"}, + {keyword_yield, "yield"}, + {keyword_super, "super"}, + {keyword_self, "self"}, + {keyword_nil, "nil"}, + {keyword_true, "true"}, + {keyword_false, "false"}, + {keyword_and, "and"}, + {keyword_or, "or"}, + {keyword_not, "not"}, + {modifier_if, "if"}, + {modifier_unless, "unless"}, + {modifier_while, "while"}, + {modifier_until, "until"}, + {modifier_rescue, "rescue"}, + {keyword_alias, "alias"}, + {keyword_defined, "defined?"}, + {keyword_BEGIN, "BEGIN"}, + {keyword_END, "END"}, + {keyword__LINE__, "__LINE__"}, + {keyword__FILE__, "__FILE__"}, + {keyword__ENCODING__, "__ENCODING__"}, + {0, NULL} +}; + +static const char* +keyword_id_to_str(ID id) +{ + const struct kw_assoc *a; + + for (a = keyword_to_name; a->id; a++) { + if (a->id == id) + return a->name; + } + return NULL; +} + +#undef ripper_id2sym +static VALUE +ripper_id2sym(ID id) +{ + const char *name; + char buf[8]; + + if (id <= 256) { + buf[0] = (char)id; + buf[1] = '\0'; + return ID2SYM(rb_intern2(buf, 1)); + } + if ((name = keyword_id_to_str(id))) { + return ID2SYM(rb_intern(name)); + } + if (!rb_id2str(id)) { + rb_bug("cannot convert ID to string: %ld", (unsigned long)id); + } + return ID2SYM(id); +} + +static ID +ripper_get_id(VALUE v) +{ + NODE *nd; + if (!RB_TYPE_P(v, T_NODE)) return 0; + nd = (NODE *)v; + if (nd_type(nd) != NODE_RIPPER) return 0; + return nd->nd_vid; +} + +static VALUE +ripper_get_value(VALUE v) +{ + NODE *nd; + if (v == Qundef) return Qnil; + if (!RB_TYPE_P(v, T_NODE)) return v; + nd = (NODE *)v; + if (nd_type(nd) != NODE_RIPPER) return Qnil; + return nd->nd_rval; +} + +static void +ripper_error_gen(struct parser_params *parser) +{ + parser->error_p = TRUE; +} + +static void +ripper_compile_error(struct parser_params *parser, const char *fmt, ...) +{ + VALUE str; + va_list args; + + va_start(args, fmt); + str = rb_vsprintf(fmt, args); + va_end(args); + rb_funcall(parser->value, rb_intern("compile_error"), 1, str); + ripper_error_gen(parser); +} + +static ID id_warn, id_warning; + +static void +ripper_warn0(struct parser_params *parser, const char *fmt) +{ + rb_funcall(parser->value, id_warn, 1, STR_NEW2(fmt)); +} + +static void +ripper_warnI(struct parser_params *parser, const char *fmt, int a) +{ + rb_funcall(parser->value, id_warn, 2, + STR_NEW2(fmt), INT2NUM(a)); +} + +static void +ripper_warnS(struct parser_params *parser, const char *fmt, const char *str) +{ + rb_funcall(parser->value, id_warn, 2, + STR_NEW2(fmt), STR_NEW2(str)); +} + +static void +ripper_warnV(struct parser_params *parser, const char *fmt, VALUE v) +{ + rb_funcall(parser->value, id_warn, 2, + STR_NEW2(fmt), v); +} + +static void +ripper_warning0(struct parser_params *parser, const char *fmt) +{ + rb_funcall(parser->value, id_warning, 1, STR_NEW2(fmt)); +} + +static void +ripper_warningS(struct parser_params *parser, const char *fmt, const char *str) +{ + rb_funcall(parser->value, id_warning, 2, + STR_NEW2(fmt), STR_NEW2(str)); +} + +static void +ripper_warningV(struct parser_params *parser, const char *fmt, VALUE v) +{ + rb_funcall(parser->value, id_warning, 2, + STR_NEW2(fmt), v); +} + +static VALUE +ripper_lex_get_generic(struct parser_params *parser, VALUE src) +{ + return rb_io_gets(src); +} + +static VALUE +ripper_s_allocate(VALUE klass) +{ + struct parser_params *p; + VALUE self; + + p = ZALLOC(struct parser_params); + self = TypedData_Wrap_Struct(klass, &parser_data_type, p); + p->value = self; + return self; +} + +#define ripper_initialized_p(r) ((r)->parser_lex_input != 0) + +/* + * call-seq: + * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper + * + * Create a new Ripper object. + * _src_ must be a String, an IO, or an Object which has #gets method. + * + * This method does not starts parsing. + * See also Ripper#parse and Ripper.parse. + */ +static VALUE +ripper_initialize(int argc, VALUE *argv, VALUE self) +{ + struct parser_params *parser; + VALUE src, fname, lineno; + + TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); + rb_scan_args(argc, argv, "12", &src, &fname, &lineno); + if (RB_TYPE_P(src, T_FILE)) { + parser->parser_lex_gets = ripper_lex_get_generic; + } + else { + StringValue(src); + parser->parser_lex_gets = lex_get_str; + } + parser->parser_lex_input = src; + parser->eofp = Qfalse; + if (NIL_P(fname)) { + fname = STR_NEW2("(ripper)"); + OBJ_FREEZE(fname); + } + else { + StringValue(fname); + fname = rb_str_new_frozen(fname); + } + parser_initialize(parser); + + parser->parser_ruby_sourcefile_string = fname; + parser->parser_ruby_sourcefile = RSTRING_PTR(fname); + parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1; + + return Qnil; +} + +struct ripper_args { + struct parser_params *parser; + int argc; + VALUE *argv; +}; + +static VALUE +ripper_parse0(VALUE parser_v) +{ + struct parser_params *parser; + + TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser); + parser_prepare(parser); + ripper_yyparse((void*)parser); + return parser->result; +} + +static VALUE +ripper_ensure(VALUE parser_v) +{ + struct parser_params *parser; + + TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser); + parser->parsing_thread = Qnil; + return Qnil; +} + +/* + * call-seq: + * ripper#parse + * + * Start parsing and returns the value of the root action. + */ +static VALUE +ripper_parse(VALUE self) +{ + struct parser_params *parser; + + TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); + if (!ripper_initialized_p(parser)) { + rb_raise(rb_eArgError, "method called for uninitialized object"); + } + if (!NIL_P(parser->parsing_thread)) { + if (parser->parsing_thread == rb_thread_current()) + rb_raise(rb_eArgError, "Ripper#parse is not reentrant"); + else + rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe"); + } + parser->parsing_thread = rb_thread_current(); + rb_ensure(ripper_parse0, self, ripper_ensure, self); + + return parser->result; +} + +/* + * call-seq: + * ripper#column -> Integer + * + * Return column number of current parsing line. + * This number starts from 0. + */ +static VALUE +ripper_column(VALUE self) +{ + struct parser_params *parser; + long col; + + TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); + if (!ripper_initialized_p(parser)) { + rb_raise(rb_eArgError, "method called for uninitialized object"); + } + if (NIL_P(parser->parsing_thread)) return Qnil; + col = parser->tokp - parser->parser_lex_pbeg; + return LONG2NUM(col); +} + +/* + * call-seq: + * ripper#filename -> String + * + * Return current parsing filename. + */ +static VALUE +ripper_filename(VALUE self) +{ + struct parser_params *parser; + + TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); + if (!ripper_initialized_p(parser)) { + rb_raise(rb_eArgError, "method called for uninitialized object"); + } + return parser->parser_ruby_sourcefile_string; +} + +/* + * call-seq: + * ripper#lineno -> Integer + * + * Return line number of current parsing line. + * This number starts from 1. + */ +static VALUE +ripper_lineno(VALUE self) +{ + struct parser_params *parser; + + TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); + if (!ripper_initialized_p(parser)) { + rb_raise(rb_eArgError, "method called for uninitialized object"); + } + if (NIL_P(parser->parsing_thread)) return Qnil; + return INT2NUM(parser->parser_ruby_sourceline); +} + +#ifdef RIPPER_DEBUG +/* :nodoc: */ +static VALUE +ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg) +{ + StringValue(msg); + if (obj == Qundef) { + rb_raise(rb_eArgError, "%"PRIsVALUE, msg); + } + return Qnil; +} + +/* :nodoc: */ +static VALUE +ripper_value(VALUE self, VALUE obj) +{ + return ULONG2NUM(obj); +} +#endif + + +void +Init_ripper(void) +{ + ripper_init_eventids1(); + ripper_init_eventids2(); + id_warn = rb_intern_const("warn"); + id_warning = rb_intern_const("warning"); + + InitVM(ripper); +} + +void +InitVM_ripper(void) +{ + VALUE Ripper; + + Ripper = rb_define_class("Ripper", rb_cObject); + /* version of Ripper */ + rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION)); + rb_define_alloc_func(Ripper, ripper_s_allocate); + rb_define_method(Ripper, "initialize", ripper_initialize, -1); + rb_define_method(Ripper, "parse", ripper_parse, 0); + rb_define_method(Ripper, "column", ripper_column, 0); + rb_define_method(Ripper, "filename", ripper_filename, 0); + rb_define_method(Ripper, "lineno", ripper_lineno, 0); + rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0); + rb_define_method(Ripper, "encoding", rb_parser_encoding, 0); + rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0); + rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1); + rb_define_method(Ripper, "error?", ripper_error_p, 0); +#ifdef RIPPER_DEBUG + rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2); + rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1); + rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1); +#endif + + ripper_init_eventids1_table(Ripper); + ripper_init_eventids2_table(Ripper); + +# if 0 + /* Hack to let RDoc document SCRIPT_LINES__ */ + + /* + * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded + * after the assignment will be added as an Array of lines with the file + * name as the key. + */ + rb_define_global_const("SCRIPT_LINES__", Qnil); +#endif + +} +#endif /* RIPPER */ + |