|
Ruby
2.0.0p594(2014-10-27revision48167)
|
00001 /* A Bison parser, made by GNU Bison 2.5. */ 00002 00003 /* Bison implementation for Yacc-like parsers in C 00004 00005 Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. 00006 00007 This program is free software: you can redistribute it and/or modify 00008 it under the terms of the GNU General Public License as published by 00009 the Free Software Foundation, either version 3 of the License, or 00010 (at your option) any later version. 00011 00012 This program is distributed in the hope that it will be useful, 00013 but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00015 GNU General Public License for more details. 00016 00017 You should have received a copy of the GNU General Public License 00018 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 00019 00020 /* As a special exception, you may create a larger work that contains 00021 part or all of the Bison parser skeleton and distribute that work 00022 under terms of your choice, so long as that work isn't itself a 00023 parser generator using the skeleton or a modified version thereof 00024 as a parser skeleton. Alternatively, if you modify or redistribute 00025 the parser skeleton itself, you may (at your option) remove this 00026 special exception, which will cause the skeleton and the resulting 00027 Bison output files to be licensed under the GNU General Public 00028 License without this special exception. 00029 00030 This special exception was added by the Free Software Foundation in 00031 version 2.2 of Bison. */ 00032 00033 /* C LALR(1) parser skeleton written by Richard Stallman, by 00034 simplifying the original so-called "semantic" parser. */ 00035 00036 /* All symbols defined below should begin with yy or YY, to avoid 00037 infringing on user name space. This should be done even for local 00038 variables, as they might otherwise be expanded by user macros. 00039 There are some unavoidable exceptions within include files to 00040 define necessary library symbols; they are noted "INFRINGES ON 00041 USER NAME SPACE" below. */ 00042 00043 /* Identify Bison output. */ 00044 #define YYBISON 1 00045 00046 /* Bison version. */ 00047 #define YYBISON_VERSION "2.5" 00048 00049 /* Skeleton name. */ 00050 #define YYSKELETON_NAME "yacc.c" 00051 00052 /* Pure parsers. */ 00053 #define YYPURE 1 00054 00055 /* Push parsers. */ 00056 #define YYPUSH 0 00057 00058 /* Pull parsers. */ 00059 #define YYPULL 1 00060 00061 /* Using locations. */ 00062 #define YYLSP_NEEDED 0 00063 00064 00065 00066 /* Copy the first part of user declarations. */ 00067 00068 /* Line 268 of yacc.c */ 00069 #line 12 "ripper.y" 00070 00071 00072 #ifndef PARSER_DEBUG 00073 #define PARSER_DEBUG 0 00074 #endif 00075 #define YYDEBUG 1 00076 #define YYERROR_VERBOSE 1 00077 #define YYSTACK_USE_ALLOCA 0 00078 00079 #include "ruby/ruby.h" 00080 #include "ruby/st.h" 00081 #include "ruby/encoding.h" 00082 #include "internal.h" 00083 #include "node.h" 00084 #include "parse.h" 00085 #include "id.h" 00086 #include "regenc.h" 00087 #include <stdio.h> 00088 #include <errno.h> 00089 #include <ctype.h> 00090 #include "probes.h" 00091 00092 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0])) 00093 00094 #define YYMALLOC(size) rb_parser_malloc(parser, (size)) 00095 #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size)) 00096 #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size)) 00097 #define YYFREE(ptr) rb_parser_free(parser, (ptr)) 00098 #define malloc YYMALLOC 00099 #define realloc YYREALLOC 00100 #define calloc YYCALLOC 00101 #define free YYFREE 00102 00103 #ifndef RIPPER 00104 static ID register_symid(ID, const char *, long, rb_encoding *); 00105 static ID register_symid_str(ID, VALUE); 00106 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc) 00107 #include "id.c" 00108 #endif 00109 00110 #define is_notop_id(id) ((id)>tLAST_OP_ID) 00111 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL) 00112 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL) 00113 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE) 00114 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET) 00115 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST) 00116 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS) 00117 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK) 00118 #define id_type(id) (is_notop_id(id) ? (int)((id)&ID_SCOPE_MASK) : -1) 00119 00120 #define is_asgn_or_id(id) ((is_notop_id(id)) && \ 00121 (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \ 00122 ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \ 00123 ((id)&ID_SCOPE_MASK) == ID_CLASS)) 00124 00125 enum lex_state_bits { 00126 EXPR_BEG_bit, /* ignore newline, +/- is a sign. */ 00127 EXPR_END_bit, /* newline significant, +/- is an operator. */ 00128 EXPR_ENDARG_bit, /* ditto, and unbound braces. */ 00129 EXPR_ENDFN_bit, /* ditto, and unbound braces. */ 00130 EXPR_ARG_bit, /* newline significant, +/- is an operator. */ 00131 EXPR_CMDARG_bit, /* newline significant, +/- is an operator. */ 00132 EXPR_MID_bit, /* newline significant, +/- is an operator. */ 00133 EXPR_FNAME_bit, /* ignore newline, no reserved words. */ 00134 EXPR_DOT_bit, /* right after `.' or `::', no reserved words. */ 00135 EXPR_CLASS_bit, /* immediate after `class', no here document. */ 00136 EXPR_VALUE_bit, /* alike EXPR_BEG but label is disallowed. */ 00137 EXPR_MAX_STATE 00138 }; 00139 /* examine combinations */ 00140 enum lex_state_e { 00141 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit) 00142 DEF_EXPR(BEG), 00143 DEF_EXPR(END), 00144 DEF_EXPR(ENDARG), 00145 DEF_EXPR(ENDFN), 00146 DEF_EXPR(ARG), 00147 DEF_EXPR(CMDARG), 00148 DEF_EXPR(MID), 00149 DEF_EXPR(FNAME), 00150 DEF_EXPR(DOT), 00151 DEF_EXPR(CLASS), 00152 DEF_EXPR(VALUE), 00153 EXPR_BEG_ANY = (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS), 00154 EXPR_ARG_ANY = (EXPR_ARG | EXPR_CMDARG), 00155 EXPR_END_ANY = (EXPR_END | EXPR_ENDARG | EXPR_ENDFN) 00156 }; 00157 #define IS_lex_state_for(x, ls) ((x) & (ls)) 00158 #define IS_lex_state(ls) IS_lex_state_for(lex_state, (ls)) 00159 00160 #if PARSER_DEBUG 00161 static const char *lex_state_name(enum lex_state_e state); 00162 #endif 00163 00164 typedef VALUE stack_type; 00165 00166 # define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1)) 00167 # define BITSTACK_POP(stack) ((stack) = (stack) >> 1) 00168 # define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1)) 00169 # define BITSTACK_SET_P(stack) ((stack)&1) 00170 00171 #define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n)) 00172 #define COND_POP() BITSTACK_POP(cond_stack) 00173 #define COND_LEXPOP() BITSTACK_LEXPOP(cond_stack) 00174 #define COND_P() BITSTACK_SET_P(cond_stack) 00175 00176 #define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n)) 00177 #define CMDARG_POP() BITSTACK_POP(cmdarg_stack) 00178 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack) 00179 #define CMDARG_P() BITSTACK_SET_P(cmdarg_stack) 00180 00181 struct vtable { 00182 ID *tbl; 00183 int pos; 00184 int capa; 00185 struct vtable *prev; 00186 }; 00187 00188 struct local_vars { 00189 struct vtable *args; 00190 struct vtable *vars; 00191 struct vtable *used; 00192 struct local_vars *prev; 00193 stack_type cmdargs; 00194 }; 00195 00196 #define DVARS_INHERIT ((void*)1) 00197 #define DVARS_TOPSCOPE NULL 00198 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl)) 00199 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3) 00200 00201 static int 00202 vtable_size(const struct vtable *tbl) 00203 { 00204 if (POINTER_P(tbl)) { 00205 return tbl->pos; 00206 } 00207 else { 00208 return 0; 00209 } 00210 } 00211 00212 #define VTBL_DEBUG 0 00213 00214 static struct vtable * 00215 vtable_alloc(struct vtable *prev) 00216 { 00217 struct vtable *tbl = ALLOC(struct vtable); 00218 tbl->pos = 0; 00219 tbl->capa = 8; 00220 tbl->tbl = ALLOC_N(ID, tbl->capa); 00221 tbl->prev = prev; 00222 if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl); 00223 return tbl; 00224 } 00225 00226 static void 00227 vtable_free(struct vtable *tbl) 00228 { 00229 if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl); 00230 if (POINTER_P(tbl)) { 00231 if (tbl->tbl) { 00232 xfree(tbl->tbl); 00233 } 00234 xfree(tbl); 00235 } 00236 } 00237 00238 static void 00239 vtable_add(struct vtable *tbl, ID id) 00240 { 00241 if (!POINTER_P(tbl)) { 00242 rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl); 00243 } 00244 if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id)); 00245 00246 if (tbl->pos == tbl->capa) { 00247 tbl->capa = tbl->capa * 2; 00248 REALLOC_N(tbl->tbl, ID, tbl->capa); 00249 } 00250 tbl->tbl[tbl->pos++] = id; 00251 } 00252 00253 static int 00254 vtable_included(const struct vtable * tbl, ID id) 00255 { 00256 int i; 00257 00258 if (POINTER_P(tbl)) { 00259 for (i = 0; i < tbl->pos; i++) { 00260 if (tbl->tbl[i] == id) { 00261 return i+1; 00262 } 00263 } 00264 } 00265 return 0; 00266 } 00267 00268 00269 #ifndef RIPPER 00270 typedef struct token_info { 00271 const char *token; 00272 int linenum; 00273 int column; 00274 int nonspc; 00275 struct token_info *next; 00276 } token_info; 00277 #endif 00278 00279 /* 00280 Structure of Lexer Buffer: 00281 00282 lex_pbeg tokp lex_p lex_pend 00283 | | | | 00284 |-----------+--------------+------------| 00285 |<------------>| 00286 token 00287 */ 00288 struct parser_params { 00289 int is_ripper; 00290 NODE *heap; 00291 00292 YYSTYPE *parser_yylval; 00293 VALUE eofp; 00294 00295 NODE *parser_lex_strterm; 00296 enum lex_state_e parser_lex_state; 00297 stack_type parser_cond_stack; 00298 stack_type parser_cmdarg_stack; 00299 int parser_class_nest; 00300 int parser_paren_nest; 00301 int parser_lpar_beg; 00302 int parser_in_single; 00303 int parser_in_def; 00304 int parser_brace_nest; 00305 int parser_compile_for_eval; 00306 VALUE parser_cur_mid; 00307 int parser_in_defined; 00308 char *parser_tokenbuf; 00309 int parser_tokidx; 00310 int parser_toksiz; 00311 int parser_tokline; 00312 VALUE parser_lex_input; 00313 VALUE parser_lex_lastline; 00314 VALUE parser_lex_nextline; 00315 const char *parser_lex_pbeg; 00316 const char *parser_lex_p; 00317 const char *parser_lex_pend; 00318 int parser_heredoc_end; 00319 int parser_command_start; 00320 NODE *parser_deferred_nodes; 00321 long parser_lex_gets_ptr; 00322 VALUE (*parser_lex_gets)(struct parser_params*,VALUE); 00323 struct local_vars *parser_lvtbl; 00324 int parser_ruby__end__seen; 00325 int line_count; 00326 int has_shebang; 00327 char *parser_ruby_sourcefile; /* current source file */ 00328 int parser_ruby_sourceline; /* current line no. */ 00329 VALUE parser_ruby_sourcefile_string; 00330 rb_encoding *enc; 00331 00332 int parser_yydebug; 00333 00334 #ifndef RIPPER 00335 /* Ruby core only */ 00336 NODE *parser_eval_tree_begin; 00337 NODE *parser_eval_tree; 00338 VALUE debug_lines; 00339 VALUE coverage; 00340 int nerr; 00341 00342 int parser_token_info_enabled; 00343 token_info *parser_token_info; 00344 #else 00345 /* Ripper only */ 00346 const char *tokp; 00347 VALUE delayed; 00348 int delayed_line; 00349 int delayed_col; 00350 00351 VALUE value; 00352 VALUE result; 00353 VALUE parsing_thread; 00354 int toplevel_p; 00355 #endif 00356 }; 00357 00358 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc) 00359 #define STR_NEW0() rb_enc_str_new(0,0,current_enc) 00360 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc) 00361 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc) 00362 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT) 00363 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc) 00364 00365 static int parser_yyerror(struct parser_params*, const char*); 00366 #define yyerror(msg) parser_yyerror(parser, (msg)) 00367 00368 #define lex_strterm (parser->parser_lex_strterm) 00369 #define lex_state (parser->parser_lex_state) 00370 #define cond_stack (parser->parser_cond_stack) 00371 #define cmdarg_stack (parser->parser_cmdarg_stack) 00372 #define class_nest (parser->parser_class_nest) 00373 #define paren_nest (parser->parser_paren_nest) 00374 #define lpar_beg (parser->parser_lpar_beg) 00375 #define brace_nest (parser->parser_brace_nest) 00376 #define in_single (parser->parser_in_single) 00377 #define in_def (parser->parser_in_def) 00378 #define compile_for_eval (parser->parser_compile_for_eval) 00379 #define cur_mid (parser->parser_cur_mid) 00380 #define in_defined (parser->parser_in_defined) 00381 #define tokenbuf (parser->parser_tokenbuf) 00382 #define tokidx (parser->parser_tokidx) 00383 #define toksiz (parser->parser_toksiz) 00384 #define tokline (parser->parser_tokline) 00385 #define lex_input (parser->parser_lex_input) 00386 #define lex_lastline (parser->parser_lex_lastline) 00387 #define lex_nextline (parser->parser_lex_nextline) 00388 #define lex_pbeg (parser->parser_lex_pbeg) 00389 #define lex_p (parser->parser_lex_p) 00390 #define lex_pend (parser->parser_lex_pend) 00391 #define heredoc_end (parser->parser_heredoc_end) 00392 #define command_start (parser->parser_command_start) 00393 #define deferred_nodes (parser->parser_deferred_nodes) 00394 #define lex_gets_ptr (parser->parser_lex_gets_ptr) 00395 #define lex_gets (parser->parser_lex_gets) 00396 #define lvtbl (parser->parser_lvtbl) 00397 #define ruby__end__seen (parser->parser_ruby__end__seen) 00398 #define ruby_sourceline (parser->parser_ruby_sourceline) 00399 #define ruby_sourcefile (parser->parser_ruby_sourcefile) 00400 #define ruby_sourcefile_string (parser->parser_ruby_sourcefile_string) 00401 #define current_enc (parser->enc) 00402 #define yydebug (parser->parser_yydebug) 00403 #ifdef RIPPER 00404 #else 00405 #define ruby_eval_tree (parser->parser_eval_tree) 00406 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin) 00407 #define ruby_debug_lines (parser->debug_lines) 00408 #define ruby_coverage (parser->coverage) 00409 #endif 00410 00411 #if YYPURE 00412 static int yylex(void*, void*); 00413 #else 00414 static int yylex(void*); 00415 #endif 00416 00417 #ifndef RIPPER 00418 #define yyparse ruby_yyparse 00419 00420 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE); 00421 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3)) 00422 00423 static NODE *cond_gen(struct parser_params*,NODE*); 00424 #define cond(node) cond_gen(parser, (node)) 00425 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*); 00426 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2)) 00427 00428 static NODE *newline_node(NODE*); 00429 static void fixpos(NODE*,NODE*); 00430 00431 static int value_expr_gen(struct parser_params*,NODE*); 00432 static void void_expr_gen(struct parser_params*,NODE*); 00433 static NODE *remove_begin(NODE*); 00434 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node)) 00435 #define void_expr0(node) void_expr_gen(parser, (node)) 00436 #define void_expr(node) void_expr0((node) = remove_begin(node)) 00437 static void void_stmts_gen(struct parser_params*,NODE*); 00438 #define void_stmts(node) void_stmts_gen(parser, (node)) 00439 static void reduce_nodes_gen(struct parser_params*,NODE**); 00440 #define reduce_nodes(n) reduce_nodes_gen(parser,(n)) 00441 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*); 00442 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2)) 00443 00444 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*); 00445 #define block_append(h,t) block_append_gen(parser,(h),(t)) 00446 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*); 00447 #define list_append(l,i) list_append_gen(parser,(l),(i)) 00448 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*); 00449 #define list_concat(h,t) list_concat_gen(parser,(h),(t)) 00450 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*); 00451 #define arg_append(h,t) arg_append_gen(parser,(h),(t)) 00452 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*); 00453 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t)) 00454 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*); 00455 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t)) 00456 static int literal_concat0(struct parser_params *, VALUE, VALUE); 00457 static NODE *new_evstr_gen(struct parser_params*,NODE*); 00458 #define new_evstr(n) new_evstr_gen(parser,(n)) 00459 static NODE *evstr2dstr_gen(struct parser_params*,NODE*); 00460 #define evstr2dstr(n) evstr2dstr_gen(parser,(n)) 00461 static NODE *splat_array(NODE*); 00462 00463 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*); 00464 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1)) 00465 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID); 00466 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id)) 00467 00468 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*); 00469 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t)) 00470 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID); 00471 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b)) 00472 00473 static NODE *negate_lit(NODE*); 00474 static NODE *ret_args_gen(struct parser_params*,NODE*); 00475 #define ret_args(node) ret_args_gen(parser, (node)) 00476 static NODE *arg_blk_pass(NODE*,NODE*); 00477 static NODE *new_yield_gen(struct parser_params*,NODE*); 00478 #define new_yield(node) new_yield_gen(parser, (node)) 00479 static NODE *dsym_node_gen(struct parser_params*,NODE*); 00480 #define dsym_node(node) dsym_node_gen(parser, (node)) 00481 00482 static NODE *gettable_gen(struct parser_params*,ID); 00483 #define gettable(id) gettable_gen(parser,(id)) 00484 static NODE *assignable_gen(struct parser_params*,ID,NODE*); 00485 #define assignable(id,node) assignable_gen(parser, (id), (node)) 00486 00487 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*); 00488 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2)) 00489 static NODE *attrset_gen(struct parser_params*,NODE*,ID); 00490 #define attrset(node,id) attrset_gen(parser, (node), (id)) 00491 00492 static void rb_backref_error_gen(struct parser_params*,NODE*); 00493 #define rb_backref_error(n) rb_backref_error_gen(parser,(n)) 00494 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*); 00495 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2)) 00496 00497 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs); 00498 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs); 00499 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs)) 00500 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs); 00501 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs)) 00502 00503 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*); 00504 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2)) 00505 00506 static ID *local_tbl_gen(struct parser_params*); 00507 #define local_tbl() local_tbl_gen(parser) 00508 00509 static void fixup_nodes(NODE **); 00510 00511 static VALUE reg_compile_gen(struct parser_params*, VALUE, int); 00512 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options)) 00513 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int); 00514 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options)) 00515 static int reg_fragment_check_gen(struct parser_params*, VALUE, int); 00516 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options)) 00517 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match); 00518 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match)) 00519 00520 #define get_id(id) (id) 00521 #define get_value(val) (val) 00522 #else 00523 #define value_expr(node) ((void)(node)) 00524 #define remove_begin(node) (node) 00525 #define rb_dvar_defined(id) 0 00526 #define rb_local_defined(id) 0 00527 static ID ripper_get_id(VALUE); 00528 #define get_id(id) ripper_get_id(id) 00529 static VALUE ripper_get_value(VALUE); 00530 #define get_value(val) ripper_get_value(val) 00531 static VALUE assignable_gen(struct parser_params*,VALUE); 00532 #define assignable(lhs,node) assignable_gen(parser, (lhs)) 00533 static int id_is_var_gen(struct parser_params *parser, ID id); 00534 #define id_is_var(id) id_is_var_gen(parser, (id)) 00535 00536 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2)) 00537 00538 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs); 00539 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs); 00540 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs)) 00541 00542 #endif /* !RIPPER */ 00543 00544 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs)) 00545 00546 static ID formal_argument_gen(struct parser_params*, ID); 00547 #define formal_argument(id) formal_argument_gen(parser, (id)) 00548 static ID shadowing_lvar_gen(struct parser_params*,ID); 00549 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name)) 00550 static void new_bv_gen(struct parser_params*,ID); 00551 #define new_bv(id) new_bv_gen(parser, (id)) 00552 00553 static void local_push_gen(struct parser_params*,int); 00554 #define local_push(top) local_push_gen(parser,(top)) 00555 static void local_pop_gen(struct parser_params*); 00556 #define local_pop() local_pop_gen(parser) 00557 static int local_var_gen(struct parser_params*, ID); 00558 #define local_var(id) local_var_gen(parser, (id)) 00559 static int arg_var_gen(struct parser_params*, ID); 00560 #define arg_var(id) arg_var_gen(parser, (id)) 00561 static int local_id_gen(struct parser_params*, ID); 00562 #define local_id(id) local_id_gen(parser, (id)) 00563 static ID internal_id_gen(struct parser_params*); 00564 #define internal_id() internal_id_gen(parser) 00565 00566 static const struct vtable *dyna_push_gen(struct parser_params *); 00567 #define dyna_push() dyna_push_gen(parser) 00568 static void dyna_pop_gen(struct parser_params*, const struct vtable *); 00569 #define dyna_pop(node) dyna_pop_gen(parser, (node)) 00570 static int dyna_in_block_gen(struct parser_params*); 00571 #define dyna_in_block() dyna_in_block_gen(parser) 00572 #define dyna_var(id) local_var(id) 00573 static int dvar_defined_gen(struct parser_params*,ID,int); 00574 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0) 00575 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1) 00576 static int dvar_curr_gen(struct parser_params*,ID); 00577 #define dvar_curr(id) dvar_curr_gen(parser, (id)) 00578 00579 static int lvar_defined_gen(struct parser_params*, ID); 00580 #define lvar_defined(id) lvar_defined_gen(parser, (id)) 00581 00582 #define RE_OPTION_ONCE (1<<16) 00583 #define RE_OPTION_ENCODING_SHIFT 8 00584 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT) 00585 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff) 00586 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE) 00587 #define RE_OPTION_MASK 0xff 00588 #define RE_OPTION_ARG_ENCODING_NONE 32 00589 00590 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */ 00591 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */ 00592 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1)) 00593 #define nd_func u1.id 00594 #if SIZEOF_SHORT == 2 00595 #define nd_term(node) ((signed short)(node)->u2.id) 00596 #else 00597 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2) 00598 #endif 00599 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2) 00600 #define nd_nest u3.cnt 00601 00602 /****** Ripper *******/ 00603 00604 #ifdef RIPPER 00605 #define RIPPER_VERSION "0.1.0" 00606 00607 #include "eventids1.c" 00608 #include "eventids2.c" 00609 00610 static VALUE ripper_dispatch0(struct parser_params*,ID); 00611 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE); 00612 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE); 00613 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE); 00614 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE); 00615 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE); 00616 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE); 00617 00618 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n)) 00619 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a)) 00620 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b)) 00621 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c)) 00622 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d)) 00623 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e)) 00624 #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)) 00625 00626 #define yyparse ripper_yyparse 00627 00628 #define ripper_intern(s) ID2SYM(rb_intern(s)) 00629 static VALUE ripper_id2sym(ID); 00630 #ifdef __GNUC__ 00631 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \ 00632 ID2SYM(id) : ripper_id2sym(id)) 00633 #endif 00634 00635 #define arg_new() dispatch0(args_new) 00636 #define arg_add(l,a) dispatch2(args_add, (l), (a)) 00637 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a)) 00638 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b)) 00639 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b))) 00640 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v)) 00641 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b)) 00642 00643 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a)) 00644 #define mrhs_new() dispatch0(mrhs_new) 00645 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a)) 00646 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a)) 00647 00648 #define mlhs_new() dispatch0(mlhs_new) 00649 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a)) 00650 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a)) 00651 00652 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \ 00653 dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk)) 00654 00655 #define blockvar_new(p,v) dispatch2(block_var, (p), (v)) 00656 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a)) 00657 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a)) 00658 00659 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a))) 00660 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a)) 00661 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b)) 00662 00663 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x)) 00664 00665 static inline VALUE 00666 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail) 00667 { 00668 NODE *t = (NODE *)tail; 00669 VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value; 00670 return params_new(f, o, r, p, k, kr, escape_Qundef(b)); 00671 } 00672 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t)) 00673 00674 static inline VALUE 00675 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b) 00676 { 00677 return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b); 00678 } 00679 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b)) 00680 00681 #define FIXME 0 00682 00683 #endif /* RIPPER */ 00684 00685 #ifndef RIPPER 00686 # define Qnone 0 00687 # define ifndef_ripper(x) (x) 00688 #else 00689 # define Qnone Qnil 00690 # define ifndef_ripper(x) 00691 #endif 00692 00693 #ifndef RIPPER 00694 # define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt)) 00695 # define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a)) 00696 # define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a)) 00697 # define rb_warn4S(file,line,fmt,a) rb_compile_warn((file), (line), (fmt), (a)) 00698 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt)) 00699 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a)) 00700 #else 00701 # define rb_warn0(fmt) ripper_warn0(parser, (fmt)) 00702 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a)) 00703 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a)) 00704 # define rb_warn4S(file,line,fmt,a) ripper_warnS(parser, (fmt), (a)) 00705 # define rb_warning0(fmt) ripper_warning0(parser, (fmt)) 00706 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a)) 00707 static void ripper_warn0(struct parser_params*, const char*); 00708 static void ripper_warnI(struct parser_params*, const char*, int); 00709 static void ripper_warnS(struct parser_params*, const char*, const char*); 00710 static void ripper_warning0(struct parser_params*, const char*); 00711 static void ripper_warningS(struct parser_params*, const char*, const char*); 00712 #endif 00713 00714 #ifdef RIPPER 00715 static void ripper_compile_error(struct parser_params*, const char *fmt, ...); 00716 # define rb_compile_error ripper_compile_error 00717 # define compile_error ripper_compile_error 00718 # define PARSER_ARG parser, 00719 #else 00720 # define rb_compile_error rb_compile_error_with_enc 00721 # define compile_error parser->nerr++,rb_compile_error_with_enc 00722 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc, 00723 #endif 00724 00725 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150, 00726 for instance). This is too low for Ruby to parse some files, such as 00727 date/format.rb, therefore bump the value up to at least Bison's default. */ 00728 #ifdef OLD_YACC 00729 #ifndef YYMAXDEPTH 00730 #define YYMAXDEPTH 10000 00731 #endif 00732 #endif 00733 00734 #ifndef RIPPER 00735 static void token_info_push(struct parser_params*, const char *token); 00736 static void token_info_pop(struct parser_params*, const char *token); 00737 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0) 00738 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0) 00739 #else 00740 #define token_info_push(token) /* nothing */ 00741 #define token_info_pop(token) /* nothing */ 00742 #endif 00743 00744 00745 /* Line 268 of yacc.c */ 00746 #line 747 "parse.c" 00747 00748 /* Enabling traces. */ 00749 #ifndef YYDEBUG 00750 # define YYDEBUG 1 00751 #endif 00752 00753 /* Enabling verbose error messages. */ 00754 #ifdef YYERROR_VERBOSE 00755 # undef YYERROR_VERBOSE 00756 # define YYERROR_VERBOSE 1 00757 #else 00758 # define YYERROR_VERBOSE 0 00759 #endif 00760 00761 /* Enabling the token table. */ 00762 #ifndef YYTOKEN_TABLE 00763 # define YYTOKEN_TABLE 0 00764 #endif 00765 00766 00767 /* Tokens. */ 00768 #ifndef YYTOKENTYPE 00769 # define YYTOKENTYPE 00770 /* Put the tokens into the symbol table, so that GDB and other debuggers 00771 know about them. */ 00772 enum yytokentype { 00773 END_OF_INPUT = 0, 00774 keyword_class = 258, 00775 keyword_module = 259, 00776 keyword_def = 260, 00777 keyword_undef = 261, 00778 keyword_begin = 262, 00779 keyword_rescue = 263, 00780 keyword_ensure = 264, 00781 keyword_end = 265, 00782 keyword_if = 266, 00783 keyword_unless = 267, 00784 keyword_then = 268, 00785 keyword_elsif = 269, 00786 keyword_else = 270, 00787 keyword_case = 271, 00788 keyword_when = 272, 00789 keyword_while = 273, 00790 keyword_until = 274, 00791 keyword_for = 275, 00792 keyword_break = 276, 00793 keyword_next = 277, 00794 keyword_redo = 278, 00795 keyword_retry = 279, 00796 keyword_in = 280, 00797 keyword_do = 281, 00798 keyword_do_cond = 282, 00799 keyword_do_block = 283, 00800 keyword_do_LAMBDA = 284, 00801 keyword_return = 285, 00802 keyword_yield = 286, 00803 keyword_super = 287, 00804 keyword_self = 288, 00805 keyword_nil = 289, 00806 keyword_true = 290, 00807 keyword_false = 291, 00808 keyword_and = 292, 00809 keyword_or = 293, 00810 keyword_not = 294, 00811 modifier_if = 295, 00812 modifier_unless = 296, 00813 modifier_while = 297, 00814 modifier_until = 298, 00815 modifier_rescue = 299, 00816 keyword_alias = 300, 00817 keyword_defined = 301, 00818 keyword_BEGIN = 302, 00819 keyword_END = 303, 00820 keyword__LINE__ = 304, 00821 keyword__FILE__ = 305, 00822 keyword__ENCODING__ = 306, 00823 tIDENTIFIER = 307, 00824 tFID = 308, 00825 tGVAR = 309, 00826 tIVAR = 310, 00827 tCONSTANT = 311, 00828 tCVAR = 312, 00829 tLABEL = 313, 00830 tINTEGER = 314, 00831 tFLOAT = 315, 00832 tSTRING_CONTENT = 316, 00833 tCHAR = 317, 00834 tNTH_REF = 318, 00835 tBACK_REF = 319, 00836 tREGEXP_END = 320, 00837 tUPLUS = 130, 00838 tUMINUS = 131, 00839 tPOW = 132, 00840 tCMP = 134, 00841 tEQ = 139, 00842 tEQQ = 140, 00843 tNEQ = 141, 00844 tGEQ = 138, 00845 tLEQ = 137, 00846 tANDOP = 321, 00847 tOROP = 322, 00848 tMATCH = 142, 00849 tNMATCH = 143, 00850 tDOT2 = 128, 00851 tDOT3 = 129, 00852 tAREF = 144, 00853 tASET = 145, 00854 tLSHFT = 135, 00855 tRSHFT = 136, 00856 tCOLON2 = 323, 00857 tCOLON3 = 324, 00858 tOP_ASGN = 325, 00859 tASSOC = 326, 00860 tLPAREN = 327, 00861 tLPAREN_ARG = 328, 00862 tRPAREN = 329, 00863 tLBRACK = 330, 00864 tLBRACE = 331, 00865 tLBRACE_ARG = 332, 00866 tSTAR = 333, 00867 tDSTAR = 334, 00868 tAMPER = 335, 00869 tLAMBDA = 336, 00870 tSYMBEG = 337, 00871 tSTRING_BEG = 338, 00872 tXSTRING_BEG = 339, 00873 tREGEXP_BEG = 340, 00874 tWORDS_BEG = 341, 00875 tQWORDS_BEG = 342, 00876 tSYMBOLS_BEG = 343, 00877 tQSYMBOLS_BEG = 344, 00878 tSTRING_DBEG = 345, 00879 tSTRING_DEND = 346, 00880 tSTRING_DVAR = 347, 00881 tSTRING_END = 348, 00882 tLAMBEG = 349, 00883 tLOWEST = 350, 00884 tUMINUS_NUM = 351, 00885 tLAST_TOKEN = 352 00886 }; 00887 #endif 00888 00889 00890 00891 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 00892 typedef union YYSTYPE 00893 { 00894 00895 /* Line 293 of yacc.c */ 00896 #line 691 "ripper.y" 00897 00898 VALUE val; 00899 NODE *node; 00900 ID id; 00901 int num; 00902 const struct vtable *vars; 00903 00904 00905 00906 /* Line 293 of yacc.c */ 00907 #line 908 "parse.c" 00908 } YYSTYPE; 00909 # define YYSTYPE_IS_TRIVIAL 1 00910 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 00911 # define YYSTYPE_IS_DECLARED 1 00912 #endif 00913 00914 00915 /* Copy the second part of user declarations. */ 00916 00917 00918 /* Line 343 of yacc.c */ 00919 #line 920 "parse.c" 00920 00921 #ifdef short 00922 # undef short 00923 #endif 00924 00925 #ifdef YYTYPE_UINT8 00926 typedef YYTYPE_UINT8 yytype_uint8; 00927 #else 00928 typedef unsigned char yytype_uint8; 00929 #endif 00930 00931 #ifdef YYTYPE_INT8 00932 typedef YYTYPE_INT8 yytype_int8; 00933 #elif (defined __STDC__ || defined __C99__FUNC__ \ 00934 || defined __cplusplus || defined _MSC_VER) 00935 typedef signed char yytype_int8; 00936 #else 00937 typedef short int yytype_int8; 00938 #endif 00939 00940 #ifdef YYTYPE_UINT16 00941 typedef YYTYPE_UINT16 yytype_uint16; 00942 #else 00943 typedef unsigned short int yytype_uint16; 00944 #endif 00945 00946 #ifdef YYTYPE_INT16 00947 typedef YYTYPE_INT16 yytype_int16; 00948 #else 00949 typedef short int yytype_int16; 00950 #endif 00951 00952 #ifndef YYSIZE_T 00953 # ifdef __SIZE_TYPE__ 00954 # define YYSIZE_T __SIZE_TYPE__ 00955 # elif defined size_t 00956 # define YYSIZE_T size_t 00957 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 00958 || defined __cplusplus || defined _MSC_VER) 00959 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 00960 # define YYSIZE_T size_t 00961 # else 00962 # define YYSIZE_T unsigned int 00963 # endif 00964 #endif 00965 00966 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 00967 00968 #ifndef YY_ 00969 # if defined YYENABLE_NLS && YYENABLE_NLS 00970 # if ENABLE_NLS 00971 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 00972 # define YY_(msgid) dgettext ("bison-runtime", msgid) 00973 # endif 00974 # endif 00975 # ifndef YY_ 00976 # define YY_(msgid) msgid 00977 # endif 00978 #endif 00979 00980 /* Suppress unused-variable warnings by "using" E. */ 00981 #if ! defined lint || defined __GNUC__ 00982 # define YYUSE(e) ((void) (e)) 00983 #else 00984 # define YYUSE(e) /* empty */ 00985 #endif 00986 00987 /* Identity function, used to suppress warnings about constant conditions. */ 00988 #ifndef lint 00989 # define YYID(n) (n) 00990 #else 00991 #if (defined __STDC__ || defined __C99__FUNC__ \ 00992 || defined __cplusplus || defined _MSC_VER) 00993 static int 00994 YYID (int yyi) 00995 #else 00996 static int 00997 YYID (yyi) 00998 int yyi; 00999 #endif 01000 { 01001 return yyi; 01002 } 01003 #endif 01004 01005 #if ! defined yyoverflow || YYERROR_VERBOSE 01006 01007 /* The parser invokes alloca or malloc; define the necessary symbols. */ 01008 01009 # ifdef YYSTACK_USE_ALLOCA 01010 # if YYSTACK_USE_ALLOCA 01011 # ifdef __GNUC__ 01012 # define YYSTACK_ALLOC __builtin_alloca 01013 # elif defined __BUILTIN_VA_ARG_INCR 01014 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 01015 # elif defined _AIX 01016 # define YYSTACK_ALLOC __alloca 01017 # elif defined _MSC_VER 01018 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 01019 # define alloca _alloca 01020 # else 01021 # define YYSTACK_ALLOC alloca 01022 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 01023 || defined __cplusplus || defined _MSC_VER) 01024 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 01025 # ifndef EXIT_SUCCESS 01026 # define EXIT_SUCCESS 0 01027 # endif 01028 # endif 01029 # endif 01030 # endif 01031 # endif 01032 01033 # ifdef YYSTACK_ALLOC 01034 /* Pacify GCC's `empty if-body' warning. */ 01035 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 01036 # ifndef YYSTACK_ALLOC_MAXIMUM 01037 /* The OS might guarantee only one guard page at the bottom of the stack, 01038 and a page size can be as small as 4096 bytes. So we cannot safely 01039 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 01040 to allow for a few compiler-allocated temporary stack slots. */ 01041 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 01042 # endif 01043 # else 01044 # define YYSTACK_ALLOC YYMALLOC 01045 # define YYSTACK_FREE YYFREE 01046 # ifndef YYSTACK_ALLOC_MAXIMUM 01047 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 01048 # endif 01049 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 01050 && ! ((defined YYMALLOC || defined malloc) \ 01051 && (defined YYFREE || defined free))) 01052 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 01053 # ifndef EXIT_SUCCESS 01054 # define EXIT_SUCCESS 0 01055 # endif 01056 # endif 01057 # ifndef YYMALLOC 01058 # define YYMALLOC malloc 01059 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 01060 || defined __cplusplus || defined _MSC_VER) 01061 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 01062 # endif 01063 # endif 01064 # ifndef YYFREE 01065 # define YYFREE free 01066 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 01067 || defined __cplusplus || defined _MSC_VER) 01068 void free (void *); /* INFRINGES ON USER NAME SPACE */ 01069 # endif 01070 # endif 01071 # endif 01072 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 01073 01074 01075 #if (! defined yyoverflow \ 01076 && (! defined __cplusplus \ 01077 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 01078 01079 /* A type that is properly aligned for any stack member. */ 01080 union yyalloc 01081 { 01082 yytype_int16 yyss_alloc; 01083 YYSTYPE yyvs_alloc; 01084 }; 01085 01086 /* The size of the maximum gap between one aligned stack and the next. */ 01087 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 01088 01089 /* The size of an array large to enough to hold all stacks, each with 01090 N elements. */ 01091 # define YYSTACK_BYTES(N) \ 01092 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 01093 + YYSTACK_GAP_MAXIMUM) 01094 01095 # define YYCOPY_NEEDED 1 01096 01097 /* Relocate STACK from its old location to the new one. The 01098 local variables YYSIZE and YYSTACKSIZE give the old and new number of 01099 elements in the stack, and YYPTR gives the new location of the 01100 stack. Advance YYPTR to a properly aligned location for the next 01101 stack. */ 01102 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 01103 do \ 01104 { \ 01105 YYSIZE_T yynewbytes; \ 01106 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 01107 Stack = &yyptr->Stack_alloc; \ 01108 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 01109 yyptr += yynewbytes / sizeof (*yyptr); \ 01110 } \ 01111 while (YYID (0)) 01112 01113 #endif 01114 01115 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 01116 /* Copy COUNT objects from FROM to TO. The source and destination do 01117 not overlap. */ 01118 # ifndef YYCOPY 01119 # if defined __GNUC__ && 1 < __GNUC__ 01120 # define YYCOPY(To, From, Count) \ 01121 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 01122 # else 01123 # define YYCOPY(To, From, Count) \ 01124 do \ 01125 { \ 01126 YYSIZE_T yyi; \ 01127 for (yyi = 0; yyi < (Count); yyi++) \ 01128 (To)[yyi] = (From)[yyi]; \ 01129 } \ 01130 while (YYID (0)) 01131 # endif 01132 # endif 01133 #endif /* !YYCOPY_NEEDED */ 01134 01135 /* YYFINAL -- State number of the termination state. */ 01136 #define YYFINAL 3 01137 /* YYLAST -- Last index in YYTABLE. */ 01138 #define YYLAST 10700 01139 01140 /* YYNTOKENS -- Number of terminals. */ 01141 #define YYNTOKENS 142 01142 /* YYNNTS -- Number of nonterminals. */ 01143 #define YYNNTS 199 01144 /* YYNRULES -- Number of rules. */ 01145 #define YYNRULES 620 01146 /* YYNRULES -- Number of states. */ 01147 #define YYNSTATES 1057 01148 01149 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 01150 #define YYUNDEFTOK 2 01151 #define YYMAXUTOK 352 01152 01153 #define YYTRANSLATE(YYX) \ 01154 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 01155 01156 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 01157 static const yytype_uint8 yytranslate[] = 01158 { 01159 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01160 141, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01161 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01162 2, 2, 140, 127, 2, 2, 2, 125, 120, 2, 01163 136, 137, 123, 121, 134, 122, 133, 124, 2, 2, 01164 2, 2, 2, 2, 2, 2, 2, 2, 115, 139, 01165 117, 113, 116, 114, 2, 2, 2, 2, 2, 2, 01166 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01167 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01168 2, 132, 2, 138, 119, 2, 135, 2, 2, 2, 01169 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01170 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01171 2, 2, 2, 130, 118, 131, 128, 2, 79, 80, 01172 66, 67, 68, 2, 69, 83, 84, 74, 73, 70, 01173 71, 72, 77, 78, 81, 82, 2, 2, 2, 2, 01174 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01175 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01176 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01177 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01178 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01179 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01180 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01181 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01182 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01183 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 01184 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 01185 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 01186 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 01187 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 01188 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 01189 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 01190 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 01191 65, 75, 76, 85, 86, 87, 88, 89, 90, 91, 01192 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 01193 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 01194 112, 126, 129 01195 }; 01196 01197 #if YYDEBUG 01198 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 01199 YYRHS. */ 01200 static const yytype_uint16 yyprhs[] = 01201 { 01202 0, 0, 3, 4, 7, 10, 12, 14, 18, 21, 01203 23, 24, 30, 35, 38, 40, 42, 46, 49, 51, 01204 52, 58, 59, 64, 68, 72, 76, 79, 83, 87, 01205 91, 95, 99, 104, 106, 110, 114, 121, 127, 133, 01206 139, 145, 149, 153, 157, 161, 163, 167, 171, 173, 01207 177, 181, 185, 188, 190, 192, 194, 196, 198, 203, 01208 204, 210, 212, 215, 219, 224, 230, 235, 241, 244, 01209 247, 250, 253, 256, 258, 262, 264, 268, 270, 273, 01210 277, 283, 286, 291, 294, 299, 301, 305, 307, 311, 01211 314, 318, 320, 324, 326, 328, 333, 337, 341, 345, 01212 349, 352, 354, 356, 358, 363, 367, 371, 375, 379, 01213 382, 384, 386, 388, 391, 393, 397, 399, 401, 403, 01214 405, 407, 409, 411, 413, 415, 417, 418, 423, 425, 01215 427, 429, 431, 433, 435, 437, 439, 441, 443, 445, 01216 447, 449, 451, 453, 455, 457, 459, 461, 463, 465, 01217 467, 469, 471, 473, 475, 477, 479, 481, 483, 485, 01218 487, 489, 491, 493, 495, 497, 499, 501, 503, 505, 01219 507, 509, 511, 513, 515, 517, 519, 521, 523, 525, 01220 527, 529, 531, 533, 535, 537, 539, 541, 543, 545, 01221 547, 549, 551, 553, 555, 557, 559, 561, 563, 565, 01222 569, 575, 579, 585, 592, 598, 604, 610, 616, 621, 01223 625, 629, 633, 637, 641, 645, 649, 653, 657, 662, 01224 667, 670, 673, 677, 681, 685, 689, 693, 697, 701, 01225 705, 709, 713, 717, 721, 725, 728, 731, 735, 739, 01226 743, 747, 748, 753, 760, 762, 764, 766, 769, 774, 01227 777, 781, 783, 785, 787, 789, 792, 797, 800, 802, 01228 805, 808, 813, 815, 816, 819, 822, 825, 827, 829, 01229 832, 836, 841, 845, 850, 853, 855, 857, 859, 861, 01230 863, 865, 867, 869, 871, 873, 875, 876, 881, 882, 01231 886, 887, 888, 894, 898, 902, 905, 909, 913, 915, 01232 920, 924, 926, 927, 934, 939, 943, 946, 948, 951, 01233 954, 961, 968, 969, 970, 978, 979, 980, 988, 994, 01234 999, 1000, 1001, 1011, 1012, 1019, 1020, 1021, 1030, 1031, 01235 1037, 1038, 1045, 1046, 1047, 1057, 1059, 1061, 1063, 1065, 01236 1067, 1069, 1071, 1073, 1075, 1077, 1079, 1081, 1083, 1085, 01237 1087, 1089, 1091, 1093, 1096, 1098, 1100, 1102, 1108, 1110, 01238 1113, 1115, 1117, 1119, 1123, 1125, 1129, 1131, 1136, 1143, 01239 1147, 1153, 1156, 1161, 1163, 1167, 1172, 1175, 1178, 1180, 01240 1183, 1184, 1191, 1200, 1205, 1212, 1217, 1220, 1227, 1230, 01241 1235, 1242, 1245, 1250, 1253, 1258, 1260, 1262, 1264, 1268, 01242 1270, 1275, 1277, 1282, 1284, 1288, 1290, 1292, 1293, 1294, 01243 1295, 1301, 1306, 1308, 1312, 1316, 1317, 1323, 1326, 1331, 01244 1337, 1343, 1346, 1347, 1353, 1354, 1360, 1364, 1365, 1370, 01245 1371, 1376, 1379, 1381, 1386, 1387, 1393, 1394, 1400, 1406, 01246 1408, 1410, 1417, 1419, 1421, 1423, 1425, 1428, 1430, 1433, 01247 1435, 1437, 1439, 1441, 1443, 1445, 1447, 1450, 1454, 1458, 01248 1462, 1466, 1470, 1471, 1475, 1477, 1480, 1484, 1488, 1489, 01249 1493, 1497, 1501, 1505, 1509, 1510, 1514, 1515, 1519, 1520, 01250 1523, 1524, 1527, 1528, 1531, 1533, 1534, 1538, 1539, 1540, 01251 1541, 1548, 1550, 1552, 1554, 1556, 1559, 1561, 1563, 1565, 01252 1567, 1571, 1573, 1575, 1578, 1581, 1583, 1585, 1587, 1589, 01253 1591, 1593, 1595, 1597, 1599, 1601, 1603, 1605, 1607, 1609, 01254 1611, 1613, 1615, 1617, 1619, 1620, 1625, 1628, 1632, 1635, 01255 1640, 1643, 1646, 1648, 1651, 1652, 1659, 1668, 1673, 1680, 01256 1685, 1692, 1695, 1700, 1707, 1710, 1715, 1718, 1723, 1725, 01257 1726, 1728, 1730, 1732, 1734, 1736, 1738, 1740, 1744, 1746, 01258 1750, 1753, 1756, 1758, 1762, 1764, 1768, 1770, 1772, 1775, 01259 1777, 1781, 1785, 1787, 1791, 1793, 1797, 1799, 1801, 1804, 01260 1806, 1808, 1810, 1813, 1816, 1818, 1820, 1821, 1826, 1828, 01261 1831, 1833, 1837, 1841, 1844, 1847, 1849, 1851, 1853, 1855, 01262 1857, 1859, 1861, 1863, 1865, 1867, 1869, 1871, 1872, 1874, 01263 1875, 1877, 1880, 1883, 1884, 1886, 1888, 1890, 1892, 1894, 01264 1897 01265 }; 01266 01267 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 01268 static const yytype_int16 yyrhs[] = 01269 { 01270 143, 0, -1, -1, 144, 145, -1, 146, 333, -1, 01271 340, -1, 147, -1, 146, 339, 147, -1, 1, 147, 01272 -1, 154, -1, -1, 47, 148, 130, 145, 131, -1, 01273 150, 262, 230, 265, -1, 151, 333, -1, 340, -1, 01274 152, -1, 151, 339, 152, -1, 1, 154, -1, 154, 01275 -1, -1, 47, 153, 130, 145, 131, -1, -1, 45, 01276 177, 155, 177, -1, 45, 54, 54, -1, 45, 54, 01277 64, -1, 45, 54, 63, -1, 6, 178, -1, 154, 01278 40, 158, -1, 154, 41, 158, -1, 154, 42, 158, 01279 -1, 154, 43, 158, -1, 154, 44, 154, -1, 48, 01280 130, 150, 131, -1, 156, -1, 165, 113, 159, -1, 01281 297, 87, 159, -1, 215, 132, 188, 336, 87, 159, 01282 -1, 215, 133, 52, 87, 159, -1, 215, 133, 56, 01283 87, 159, -1, 215, 85, 56, 87, 159, -1, 215, 01284 85, 52, 87, 159, -1, 298, 87, 159, -1, 172, 01285 113, 195, -1, 165, 113, 184, -1, 165, 113, 195, 01286 -1, 157, -1, 172, 113, 159, -1, 172, 113, 156, 01287 -1, 159, -1, 157, 37, 157, -1, 157, 38, 157, 01288 -1, 39, 334, 157, -1, 127, 159, -1, 182, -1, 01289 157, -1, 164, -1, 160, -1, 251, -1, 251, 332, 01290 330, 190, -1, -1, 94, 162, 238, 150, 131, -1, 01291 329, -1, 163, 190, -1, 163, 190, 161, -1, 215, 01292 133, 330, 190, -1, 215, 133, 330, 190, 161, -1, 01293 215, 85, 330, 190, -1, 215, 85, 330, 190, 161, 01294 -1, 32, 190, -1, 31, 190, -1, 30, 189, -1, 01295 21, 189, -1, 22, 189, -1, 167, -1, 89, 166, 01296 335, -1, 167, -1, 89, 166, 335, -1, 169, -1, 01297 169, 168, -1, 169, 95, 171, -1, 169, 95, 171, 01298 134, 170, -1, 169, 95, -1, 169, 95, 134, 170, 01299 -1, 95, 171, -1, 95, 171, 134, 170, -1, 95, 01300 -1, 95, 134, 170, -1, 171, -1, 89, 166, 335, 01301 -1, 168, 134, -1, 169, 168, 134, -1, 168, -1, 01302 170, 134, 168, -1, 294, -1, 295, -1, 215, 132, 01303 188, 336, -1, 215, 133, 52, -1, 215, 85, 52, 01304 -1, 215, 133, 56, -1, 215, 85, 56, -1, 86, 01305 56, -1, 298, -1, 294, -1, 295, -1, 215, 132, 01306 188, 336, -1, 215, 133, 52, -1, 215, 85, 52, 01307 -1, 215, 133, 56, -1, 215, 85, 56, -1, 86, 01308 56, -1, 298, -1, 52, -1, 56, -1, 86, 173, 01309 -1, 173, -1, 215, 85, 173, -1, 52, -1, 56, 01310 -1, 53, -1, 180, -1, 181, -1, 175, -1, 290, 01311 -1, 176, -1, 292, -1, 177, -1, -1, 178, 134, 01312 179, 177, -1, 118, -1, 119, -1, 120, -1, 69, 01313 -1, 70, -1, 71, -1, 77, -1, 78, -1, 116, 01314 -1, 73, -1, 117, -1, 74, -1, 72, -1, 83, 01315 -1, 84, -1, 121, -1, 122, -1, 123, -1, 95, 01316 -1, 124, -1, 125, -1, 68, -1, 96, -1, 127, 01317 -1, 128, -1, 66, -1, 67, -1, 81, -1, 82, 01318 -1, 135, -1, 49, -1, 50, -1, 51, -1, 47, 01319 -1, 48, -1, 45, -1, 37, -1, 7, -1, 21, 01320 -1, 16, -1, 3, -1, 5, -1, 46, -1, 26, 01321 -1, 15, -1, 14, -1, 10, -1, 9, -1, 36, 01322 -1, 20, -1, 25, -1, 4, -1, 22, -1, 34, 01323 -1, 39, -1, 38, -1, 23, -1, 8, -1, 24, 01324 -1, 30, -1, 33, -1, 32, -1, 13, -1, 35, 01325 -1, 6, -1, 17, -1, 31, -1, 11, -1, 12, 01326 -1, 18, -1, 19, -1, 172, 113, 182, -1, 172, 01327 113, 182, 44, 182, -1, 297, 87, 182, -1, 297, 01328 87, 182, 44, 182, -1, 215, 132, 188, 336, 87, 01329 182, -1, 215, 133, 52, 87, 182, -1, 215, 133, 01330 56, 87, 182, -1, 215, 85, 52, 87, 182, -1, 01331 215, 85, 56, 87, 182, -1, 86, 56, 87, 182, 01332 -1, 298, 87, 182, -1, 182, 79, 182, -1, 182, 01333 80, 182, -1, 182, 121, 182, -1, 182, 122, 182, 01334 -1, 182, 123, 182, -1, 182, 124, 182, -1, 182, 01335 125, 182, -1, 182, 68, 182, -1, 126, 59, 68, 01336 182, -1, 126, 60, 68, 182, -1, 66, 182, -1, 01337 67, 182, -1, 182, 118, 182, -1, 182, 119, 182, 01338 -1, 182, 120, 182, -1, 182, 69, 182, -1, 182, 01339 116, 182, -1, 182, 73, 182, -1, 182, 117, 182, 01340 -1, 182, 74, 182, -1, 182, 70, 182, -1, 182, 01341 71, 182, -1, 182, 72, 182, -1, 182, 77, 182, 01342 -1, 182, 78, 182, -1, 127, 182, -1, 128, 182, 01343 -1, 182, 83, 182, -1, 182, 84, 182, -1, 182, 01344 75, 182, -1, 182, 76, 182, -1, -1, 46, 334, 01345 183, 182, -1, 182, 114, 182, 334, 115, 182, -1, 01346 196, -1, 182, -1, 340, -1, 194, 337, -1, 194, 01347 134, 327, 337, -1, 327, 337, -1, 136, 188, 335, 01348 -1, 340, -1, 186, -1, 340, -1, 189, -1, 194, 01349 134, -1, 194, 134, 327, 134, -1, 327, 134, -1, 01350 164, -1, 194, 193, -1, 327, 193, -1, 194, 134, 01351 327, 193, -1, 192, -1, -1, 191, 189, -1, 97, 01352 184, -1, 134, 192, -1, 340, -1, 184, -1, 95, 01353 184, -1, 194, 134, 184, -1, 194, 134, 95, 184, 01354 -1, 194, 134, 184, -1, 194, 134, 95, 184, -1, 01355 95, 184, -1, 266, -1, 267, -1, 270, -1, 271, 01356 -1, 272, -1, 277, -1, 275, -1, 278, -1, 296, 01357 -1, 298, -1, 53, -1, -1, 216, 197, 149, 226, 01358 -1, -1, 90, 198, 335, -1, -1, -1, 90, 199, 01359 157, 200, 335, -1, 89, 150, 137, -1, 215, 85, 01360 56, -1, 86, 56, -1, 92, 185, 138, -1, 93, 01361 326, 131, -1, 30, -1, 31, 136, 189, 335, -1, 01362 31, 136, 335, -1, 31, -1, -1, 46, 334, 136, 01363 201, 157, 335, -1, 39, 136, 157, 335, -1, 39, 01364 136, 335, -1, 163, 257, -1, 252, -1, 252, 257, 01365 -1, 98, 243, -1, 217, 158, 227, 150, 229, 226, 01366 -1, 218, 158, 227, 150, 230, 226, -1, -1, -1, 01367 219, 202, 158, 228, 203, 150, 226, -1, -1, -1, 01368 220, 204, 158, 228, 205, 150, 226, -1, 221, 158, 01369 333, 260, 226, -1, 221, 333, 260, 226, -1, -1, 01370 -1, 222, 231, 25, 206, 158, 228, 207, 150, 226, 01371 -1, -1, 223, 174, 299, 208, 149, 226, -1, -1, 01372 -1, 223, 83, 157, 209, 338, 210, 149, 226, -1, 01373 -1, 224, 174, 211, 149, 226, -1, -1, 225, 175, 01374 212, 301, 149, 226, -1, -1, -1, 225, 324, 332, 01375 213, 175, 214, 301, 149, 226, -1, 21, -1, 22, 01376 -1, 23, -1, 24, -1, 196, -1, 7, -1, 11, 01377 -1, 12, -1, 18, -1, 19, -1, 16, -1, 20, 01378 -1, 3, -1, 4, -1, 5, -1, 10, -1, 338, 01379 -1, 13, -1, 338, 13, -1, 338, -1, 27, -1, 01380 230, -1, 14, 158, 227, 150, 229, -1, 340, -1, 01381 15, 150, -1, 172, -1, 165, -1, 306, -1, 89, 01382 234, 335, -1, 232, -1, 233, 134, 232, -1, 233, 01383 -1, 233, 134, 95, 306, -1, 233, 134, 95, 306, 01384 134, 233, -1, 233, 134, 95, -1, 233, 134, 95, 01385 134, 233, -1, 95, 306, -1, 95, 306, 134, 233, 01386 -1, 95, -1, 95, 134, 233, -1, 311, 134, 314, 01387 323, -1, 311, 323, -1, 314, 323, -1, 322, -1, 01388 134, 235, -1, -1, 308, 134, 317, 134, 320, 236, 01389 -1, 308, 134, 317, 134, 320, 134, 308, 236, -1, 01390 308, 134, 317, 236, -1, 308, 134, 317, 134, 308, 01391 236, -1, 308, 134, 320, 236, -1, 308, 134, -1, 01392 308, 134, 320, 134, 308, 236, -1, 308, 236, -1, 01393 317, 134, 320, 236, -1, 317, 134, 320, 134, 308, 01394 236, -1, 317, 236, -1, 317, 134, 308, 236, -1, 01395 320, 236, -1, 320, 134, 308, 236, -1, 235, -1, 01396 340, -1, 239, -1, 118, 240, 118, -1, 76, -1, 01397 118, 237, 240, 118, -1, 334, -1, 334, 139, 241, 01398 334, -1, 242, -1, 241, 134, 242, -1, 52, -1, 01399 305, -1, -1, -1, -1, 244, 245, 247, 246, 248, 01400 -1, 136, 304, 240, 137, -1, 304, -1, 111, 150, 01401 131, -1, 29, 150, 10, -1, -1, 28, 250, 238, 01402 150, 10, -1, 164, 249, -1, 251, 332, 330, 187, 01403 -1, 251, 332, 330, 187, 257, -1, 251, 332, 330, 01404 190, 249, -1, 163, 186, -1, -1, 215, 133, 330, 01405 253, 187, -1, -1, 215, 85, 330, 254, 186, -1, 01406 215, 85, 331, -1, -1, 215, 133, 255, 186, -1, 01407 -1, 215, 85, 256, 186, -1, 32, 186, -1, 32, 01408 -1, 215, 132, 188, 336, -1, -1, 130, 258, 238, 01409 150, 131, -1, -1, 26, 259, 238, 150, 10, -1, 01410 17, 194, 227, 150, 261, -1, 230, -1, 260, -1, 01411 8, 263, 264, 227, 150, 262, -1, 340, -1, 184, 01412 -1, 195, -1, 340, -1, 88, 172, -1, 340, -1, 01413 9, 150, -1, 340, -1, 293, -1, 290, -1, 292, 01414 -1, 268, -1, 62, -1, 269, -1, 268, 269, -1, 01415 100, 281, 110, -1, 101, 282, 110, -1, 102, 283, 01416 65, -1, 103, 140, 110, -1, 103, 273, 110, -1, 01417 -1, 273, 274, 140, -1, 284, -1, 274, 284, -1, 01418 105, 140, 110, -1, 105, 276, 110, -1, -1, 276, 01419 274, 140, -1, 104, 140, 110, -1, 104, 279, 110, 01420 -1, 106, 140, 110, -1, 106, 280, 110, -1, -1, 01421 279, 61, 140, -1, -1, 280, 61, 140, -1, -1, 01422 281, 284, -1, -1, 282, 284, -1, -1, 283, 284, 01423 -1, 61, -1, -1, 109, 285, 289, -1, -1, -1, 01424 -1, 107, 286, 287, 288, 150, 108, -1, 54, -1, 01425 55, -1, 57, -1, 298, -1, 99, 291, -1, 175, 01426 -1, 55, -1, 54, -1, 57, -1, 99, 282, 110, 01427 -1, 59, -1, 60, -1, 126, 59, -1, 126, 60, 01428 -1, 52, -1, 55, -1, 54, -1, 56, -1, 57, 01429 -1, 34, -1, 33, -1, 35, -1, 36, -1, 50, 01430 -1, 49, -1, 51, -1, 294, -1, 295, -1, 294, 01431 -1, 295, -1, 63, -1, 64, -1, 338, -1, -1, 01432 117, 300, 158, 338, -1, 1, 338, -1, 136, 304, 01433 335, -1, 304, 338, -1, 312, 134, 314, 323, -1, 01434 312, 323, -1, 314, 323, -1, 322, -1, 134, 302, 01435 -1, -1, 308, 134, 318, 134, 320, 303, -1, 308, 01436 134, 318, 134, 320, 134, 308, 303, -1, 308, 134, 01437 318, 303, -1, 308, 134, 318, 134, 308, 303, -1, 01438 308, 134, 320, 303, -1, 308, 134, 320, 134, 308, 01439 303, -1, 308, 303, -1, 318, 134, 320, 303, -1, 01440 318, 134, 320, 134, 308, 303, -1, 318, 303, -1, 01441 318, 134, 308, 303, -1, 320, 303, -1, 320, 134, 01442 308, 303, -1, 302, -1, -1, 56, -1, 55, -1, 01443 54, -1, 57, -1, 305, -1, 52, -1, 306, -1, 01444 89, 234, 335, -1, 307, -1, 308, 134, 307, -1, 01445 58, 184, -1, 58, 215, -1, 310, -1, 311, 134, 01446 310, -1, 309, -1, 312, 134, 309, -1, 68, -1, 01447 96, -1, 313, 52, -1, 313, -1, 52, 113, 184, 01448 -1, 52, 113, 215, -1, 316, -1, 317, 134, 316, 01449 -1, 315, -1, 318, 134, 315, -1, 123, -1, 95, 01450 -1, 319, 52, -1, 319, -1, 120, -1, 97, -1, 01451 321, 52, -1, 134, 322, -1, 340, -1, 296, -1, 01452 -1, 136, 325, 157, 335, -1, 340, -1, 327, 337, 01453 -1, 328, -1, 327, 134, 328, -1, 184, 88, 184, 01454 -1, 58, 184, -1, 96, 184, -1, 52, -1, 56, 01455 -1, 53, -1, 52, -1, 56, -1, 53, -1, 180, 01456 -1, 52, -1, 53, -1, 180, -1, 133, -1, 85, 01457 -1, -1, 339, -1, -1, 141, -1, 334, 137, -1, 01458 334, 138, -1, -1, 141, -1, 134, -1, 139, -1, 01459 141, -1, 338, -1, 339, 139, -1, -1 01460 }; 01461 01462 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 01463 static const yytype_uint16 yyrline[] = 01464 { 01465 0, 855, 855, 855, 886, 897, 906, 914, 922, 928, 01466 930, 929, 950, 983, 994, 1003, 1011, 1019, 1025, 1030, 01467 1029, 1050, 1050, 1058, 1066, 1077, 1087, 1095, 1104, 1113, 01468 1126, 1139, 1148, 1160, 1161, 1171, 1176, 1197, 1202, 1207, 01469 1217, 1222, 1232, 1241, 1250, 1259, 1262, 1271, 1283, 1284, 01470 1292, 1300, 1308, 1316, 1319, 1331, 1332, 1335, 1336, 1348, 01471 1347, 1369, 1379, 1388, 1401, 1410, 1422, 1431, 1443, 1452, 01472 1461, 1469, 1477, 1487, 1488, 1498, 1499, 1509, 1517, 1525, 01473 1533, 1542, 1550, 1559, 1567, 1576, 1584, 1595, 1596, 1606, 01474 1614, 1624, 1632, 1642, 1646, 1650, 1658, 1666, 1674, 1682, 01475 1694, 1704, 1716, 1725, 1734, 1742, 1750, 1758, 1766, 1779, 01476 1792, 1803, 1811, 1814, 1822, 1830, 1840, 1841, 1842, 1843, 01477 1848, 1859, 1860, 1863, 1871, 1874, 1882, 1882, 1892, 1893, 01478 1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1903, 01479 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 01480 1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1924, 1924, 01481 1924, 1925, 1925, 1926, 1926, 1926, 1927, 1927, 1927, 1927, 01482 1928, 1928, 1928, 1928, 1929, 1929, 1929, 1930, 1930, 1930, 01483 1930, 1931, 1931, 1931, 1931, 1932, 1932, 1932, 1932, 1933, 01484 1933, 1933, 1933, 1934, 1934, 1934, 1934, 1935, 1935, 1938, 01485 1947, 1957, 1962, 1972, 1998, 2003, 2008, 2013, 2023, 2033, 01486 2044, 2058, 2072, 2080, 2088, 2096, 2104, 2112, 2120, 2129, 01487 2138, 2146, 2154, 2162, 2170, 2178, 2186, 2194, 2202, 2210, 01488 2218, 2226, 2234, 2242, 2253, 2261, 2269, 2277, 2285, 2293, 01489 2301, 2309, 2309, 2319, 2329, 2335, 2347, 2348, 2352, 2360, 01490 2370, 2380, 2381, 2384, 2385, 2386, 2390, 2398, 2408, 2417, 01491 2425, 2435, 2444, 2453, 2453, 2465, 2475, 2479, 2485, 2493, 01492 2501, 2515, 2531, 2545, 2560, 2570, 2571, 2572, 2573, 2574, 01493 2575, 2576, 2577, 2578, 2579, 2580, 2589, 2588, 2616, 2616, 01494 2625, 2629, 2624, 2638, 2646, 2654, 2662, 2675, 2683, 2691, 01495 2699, 2707, 2715, 2715, 2725, 2733, 2741, 2751, 2752, 2762, 01496 2766, 2778, 2790, 2790, 2790, 2801, 2801, 2801, 2812, 2823, 01497 2832, 2834, 2831, 2898, 2897, 2919, 2924, 2918, 2943, 2942, 01498 2964, 2963, 2986, 2987, 2986, 3007, 3015, 3023, 3031, 3041, 01499 3053, 3059, 3065, 3071, 3077, 3083, 3089, 3095, 3101, 3107, 01500 3117, 3123, 3128, 3129, 3136, 3141, 3144, 3145, 3158, 3159, 01501 3169, 3170, 3173, 3181, 3191, 3199, 3209, 3217, 3226, 3235, 01502 3243, 3251, 3260, 3272, 3280, 3291, 3295, 3299, 3303, 3309, 01503 3314, 3319, 3323, 3327, 3331, 3335, 3339, 3347, 3351, 3355, 01504 3359, 3363, 3367, 3371, 3375, 3379, 3385, 3386, 3392, 3401, 01505 3410, 3421, 3425, 3435, 3442, 3451, 3459, 3465, 3468, 3473, 01506 3465, 3489, 3497, 3507, 3511, 3518, 3517, 3538, 3554, 3563, 01507 3575, 3589, 3599, 3598, 3615, 3614, 3630, 3639, 3638, 3656, 01508 3655, 3672, 3680, 3688, 3703, 3702, 3722, 3721, 3742, 3754, 01509 3755, 3758, 3777, 3780, 3788, 3796, 3799, 3803, 3806, 3814, 01510 3817, 3818, 3826, 3829, 3846, 3847, 3848, 3858, 3868, 3895, 01511 3960, 3969, 3980, 3987, 3997, 4005, 4015, 4024, 4035, 4042, 01512 4054, 4063, 4073, 4082, 4093, 4100, 4111, 4118, 4133, 4140, 01513 4151, 4158, 4169, 4176, 4205, 4207, 4206, 4223, 4229, 4234, 01514 4222, 4253, 4261, 4269, 4277, 4280, 4291, 4292, 4293, 4294, 01515 4297, 4308, 4309, 4310, 4318, 4328, 4329, 4330, 4331, 4332, 01516 4335, 4336, 4337, 4338, 4339, 4340, 4341, 4344, 4357, 4367, 01517 4375, 4385, 4386, 4389, 4398, 4397, 4406, 4418, 4428, 4436, 01518 4440, 4444, 4448, 4454, 4459, 4464, 4468, 4472, 4476, 4480, 01519 4484, 4488, 4492, 4496, 4500, 4504, 4508, 4512, 4516, 4521, 01520 4527, 4536, 4545, 4554, 4565, 4566, 4573, 4582, 4601, 4608, 01521 4621, 4633, 4645, 4653, 4670, 4678, 4694, 4695, 4698, 4703, 01522 4709, 4721, 4733, 4741, 4757, 4765, 4781, 4782, 4785, 4798, 01523 4809, 4810, 4813, 4830, 4834, 4844, 4854, 4854, 4883, 4884, 01524 4894, 4901, 4911, 4919, 4927, 4939, 4940, 4941, 4944, 4945, 01525 4946, 4947, 4950, 4951, 4952, 4955, 4960, 4967, 4968, 4971, 01526 4972, 4975, 4978, 4981, 4982, 4983, 4986, 4987, 4990, 4991, 01527 4995 01528 }; 01529 #endif 01530 01531 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 01532 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 01533 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 01534 static const char *const yytname[] = 01535 { 01536 "\"end-of-input\"", "error", "$undefined", "keyword_class", 01537 "keyword_module", "keyword_def", "keyword_undef", "keyword_begin", 01538 "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if", 01539 "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else", 01540 "keyword_case", "keyword_when", "keyword_while", "keyword_until", 01541 "keyword_for", "keyword_break", "keyword_next", "keyword_redo", 01542 "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond", 01543 "keyword_do_block", "keyword_do_LAMBDA", "keyword_return", 01544 "keyword_yield", "keyword_super", "keyword_self", "keyword_nil", 01545 "keyword_true", "keyword_false", "keyword_and", "keyword_or", 01546 "keyword_not", "modifier_if", "modifier_unless", "modifier_while", 01547 "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined", 01548 "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__", 01549 "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR", 01550 "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tSTRING_CONTENT", 01551 "tCHAR", "tNTH_REF", "tBACK_REF", "tREGEXP_END", "\"unary+\"", 01552 "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"", "\"===\"", "\"!=\"", 01553 "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"", "\"!~\"", "\"..\"", 01554 "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"", "\"::\"", 01555 "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"", "\"( arg\"", 01556 "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"", "\"**arg\"", "\"&\"", 01557 "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG", 01558 "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG", "tQSYMBOLS_BEG", 01559 "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG", 01560 "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'", 01561 "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "tLAST_TOKEN", 01562 "'{'", "'}'", "'['", "'.'", "','", "'`'", "'('", "')'", "']'", "';'", 01563 "' '", "'\\n'", "$accept", "program", "$@1", "top_compstmt", "top_stmts", 01564 "top_stmt", "$@2", "bodystmt", "compstmt", "stmts", "stmt_or_begin", 01565 "$@3", "stmt", "$@4", "command_asgn", "expr", "expr_value", 01566 "command_call", "block_command", "cmd_brace_block", "@5", "fcall", 01567 "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head", 01568 "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym", 01569 "fitem", "undef_list", "$@6", "op", "reswords", "arg", "$@7", 01570 "arg_value", "aref_args", "paren_args", "opt_paren_args", 01571 "opt_call_args", "call_args", "command_args", "@8", "block_arg", 01572 "opt_block_arg", "args", "mrhs", "primary", "@9", "$@10", "$@11", "$@12", 01573 "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "$@19", "@20", "@21", 01574 "@22", "@23", "@24", "$@25", "$@26", "primary_value", "k_begin", "k_if", 01575 "k_unless", "k_while", "k_until", "k_case", "k_for", "k_class", 01576 "k_module", "k_def", "k_end", "then", "do", "if_tail", "opt_else", 01577 "for_var", "f_marg", "f_marg_list", "f_margs", "block_args_tail", 01578 "opt_block_args_tail", "block_param", "opt_block_param", 01579 "block_param_def", "opt_bv_decl", "bv_decls", "bvar", "lambda", "@27", 01580 "@28", "@29", "f_larglist", "lambda_body", "do_block", "@30", 01581 "block_call", "method_call", "@31", "@32", "@33", "@34", "brace_block", 01582 "@35", "@36", "case_body", "cases", "opt_rescue", "exc_list", "exc_var", 01583 "opt_ensure", "literal", "strings", "string", "string1", "xstring", 01584 "regexp", "words", "word_list", "word", "symbols", "symbol_list", 01585 "qwords", "qsymbols", "qword_list", "qsym_list", "string_contents", 01586 "xstring_contents", "regexp_contents", "string_content", "@37", "@38", 01587 "@39", "@40", "string_dvar", "symbol", "sym", "dsym", "numeric", 01588 "user_variable", "keyword_variable", "var_ref", "var_lhs", "backref", 01589 "superclass", "$@41", "f_arglist", "args_tail", "opt_args_tail", 01590 "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_kw", 01591 "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest", 01592 "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark", 01593 "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg", 01594 "singleton", "$@42", "assoc_list", "assocs", "assoc", "operation", 01595 "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl", 01596 "rparen", "rbracket", "trailer", "term", "terms", "none", 0 01597 }; 01598 #endif 01599 01600 # ifdef YYPRINT 01601 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 01602 token YYLEX-NUM. */ 01603 static const yytype_uint16 yytoknum[] = 01604 { 01605 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 01606 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 01607 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 01608 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 01609 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 01610 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 01611 315, 316, 317, 318, 319, 320, 130, 131, 132, 134, 01612 139, 140, 141, 138, 137, 321, 322, 142, 143, 128, 01613 129, 144, 145, 135, 136, 323, 324, 325, 326, 327, 01614 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 01615 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 01616 348, 349, 350, 61, 63, 58, 62, 60, 124, 94, 01617 38, 43, 45, 42, 47, 37, 351, 33, 126, 352, 01618 123, 125, 91, 46, 44, 96, 40, 41, 93, 59, 01619 32, 10 01620 }; 01621 # endif 01622 01623 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 01624 static const yytype_uint16 yyr1[] = 01625 { 01626 0, 142, 144, 143, 145, 146, 146, 146, 146, 147, 01627 148, 147, 149, 150, 151, 151, 151, 151, 152, 153, 01628 152, 155, 154, 154, 154, 154, 154, 154, 154, 154, 01629 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, 01630 154, 154, 154, 154, 154, 154, 156, 156, 157, 157, 01631 157, 157, 157, 157, 158, 159, 159, 160, 160, 162, 01632 161, 163, 164, 164, 164, 164, 164, 164, 164, 164, 01633 164, 164, 164, 165, 165, 166, 166, 167, 167, 167, 01634 167, 167, 167, 167, 167, 167, 167, 168, 168, 169, 01635 169, 170, 170, 171, 171, 171, 171, 171, 171, 171, 01636 171, 171, 172, 172, 172, 172, 172, 172, 172, 172, 01637 172, 173, 173, 174, 174, 174, 175, 175, 175, 175, 01638 175, 176, 176, 177, 177, 178, 179, 178, 180, 180, 01639 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 01640 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 01641 180, 180, 180, 180, 180, 180, 180, 180, 181, 181, 01642 181, 181, 181, 181, 181, 181, 181, 181, 181, 181, 01643 181, 181, 181, 181, 181, 181, 181, 181, 181, 181, 01644 181, 181, 181, 181, 181, 181, 181, 181, 181, 181, 01645 181, 181, 181, 181, 181, 181, 181, 181, 181, 182, 01646 182, 182, 182, 182, 182, 182, 182, 182, 182, 182, 01647 182, 182, 182, 182, 182, 182, 182, 182, 182, 182, 01648 182, 182, 182, 182, 182, 182, 182, 182, 182, 182, 01649 182, 182, 182, 182, 182, 182, 182, 182, 182, 182, 01650 182, 183, 182, 182, 182, 184, 185, 185, 185, 185, 01651 186, 187, 187, 188, 188, 188, 188, 188, 189, 189, 01652 189, 189, 189, 191, 190, 192, 193, 193, 194, 194, 01653 194, 194, 195, 195, 195, 196, 196, 196, 196, 196, 01654 196, 196, 196, 196, 196, 196, 197, 196, 198, 196, 01655 199, 200, 196, 196, 196, 196, 196, 196, 196, 196, 01656 196, 196, 201, 196, 196, 196, 196, 196, 196, 196, 01657 196, 196, 202, 203, 196, 204, 205, 196, 196, 196, 01658 206, 207, 196, 208, 196, 209, 210, 196, 211, 196, 01659 212, 196, 213, 214, 196, 196, 196, 196, 196, 215, 01660 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 01661 226, 227, 227, 227, 228, 228, 229, 229, 230, 230, 01662 231, 231, 232, 232, 233, 233, 234, 234, 234, 234, 01663 234, 234, 234, 234, 234, 235, 235, 235, 235, 236, 01664 236, 237, 237, 237, 237, 237, 237, 237, 237, 237, 01665 237, 237, 237, 237, 237, 237, 238, 238, 239, 239, 01666 239, 240, 240, 241, 241, 242, 242, 244, 245, 246, 01667 243, 247, 247, 248, 248, 250, 249, 251, 251, 251, 01668 251, 252, 253, 252, 254, 252, 252, 255, 252, 256, 01669 252, 252, 252, 252, 258, 257, 259, 257, 260, 261, 01670 261, 262, 262, 263, 263, 263, 264, 264, 265, 265, 01671 266, 266, 266, 267, 268, 268, 268, 269, 270, 271, 01672 272, 272, 273, 273, 274, 274, 275, 275, 276, 276, 01673 277, 277, 278, 278, 279, 279, 280, 280, 281, 281, 01674 282, 282, 283, 283, 284, 285, 284, 286, 287, 288, 01675 284, 289, 289, 289, 289, 290, 291, 291, 291, 291, 01676 292, 293, 293, 293, 293, 294, 294, 294, 294, 294, 01677 295, 295, 295, 295, 295, 295, 295, 296, 296, 297, 01678 297, 298, 298, 299, 300, 299, 299, 301, 301, 302, 01679 302, 302, 302, 303, 303, 304, 304, 304, 304, 304, 01680 304, 304, 304, 304, 304, 304, 304, 304, 304, 304, 01681 305, 305, 305, 305, 306, 306, 307, 307, 308, 308, 01682 309, 310, 311, 311, 312, 312, 313, 313, 314, 314, 01683 315, 316, 317, 317, 318, 318, 319, 319, 320, 320, 01684 321, 321, 322, 323, 323, 324, 325, 324, 326, 326, 01685 327, 327, 328, 328, 328, 329, 329, 329, 330, 330, 01686 330, 330, 331, 331, 331, 332, 332, 333, 333, 334, 01687 334, 335, 336, 337, 337, 337, 338, 338, 339, 339, 01688 340 01689 }; 01690 01691 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 01692 static const yytype_uint8 yyr2[] = 01693 { 01694 0, 2, 0, 2, 2, 1, 1, 3, 2, 1, 01695 0, 5, 4, 2, 1, 1, 3, 2, 1, 0, 01696 5, 0, 4, 3, 3, 3, 2, 3, 3, 3, 01697 3, 3, 4, 1, 3, 3, 6, 5, 5, 5, 01698 5, 3, 3, 3, 3, 1, 3, 3, 1, 3, 01699 3, 3, 2, 1, 1, 1, 1, 1, 4, 0, 01700 5, 1, 2, 3, 4, 5, 4, 5, 2, 2, 01701 2, 2, 2, 1, 3, 1, 3, 1, 2, 3, 01702 5, 2, 4, 2, 4, 1, 3, 1, 3, 2, 01703 3, 1, 3, 1, 1, 4, 3, 3, 3, 3, 01704 2, 1, 1, 1, 4, 3, 3, 3, 3, 2, 01705 1, 1, 1, 2, 1, 3, 1, 1, 1, 1, 01706 1, 1, 1, 1, 1, 1, 0, 4, 1, 1, 01707 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 01708 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 01709 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 01710 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 01711 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 01712 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 01713 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 01714 5, 3, 5, 6, 5, 5, 5, 5, 4, 3, 01715 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 01716 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 01717 3, 3, 3, 3, 3, 2, 2, 3, 3, 3, 01718 3, 0, 4, 6, 1, 1, 1, 2, 4, 2, 01719 3, 1, 1, 1, 1, 2, 4, 2, 1, 2, 01720 2, 4, 1, 0, 2, 2, 2, 1, 1, 2, 01721 3, 4, 3, 4, 2, 1, 1, 1, 1, 1, 01722 1, 1, 1, 1, 1, 1, 0, 4, 0, 3, 01723 0, 0, 5, 3, 3, 2, 3, 3, 1, 4, 01724 3, 1, 0, 6, 4, 3, 2, 1, 2, 2, 01725 6, 6, 0, 0, 7, 0, 0, 7, 5, 4, 01726 0, 0, 9, 0, 6, 0, 0, 8, 0, 5, 01727 0, 6, 0, 0, 9, 1, 1, 1, 1, 1, 01728 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 01729 1, 1, 1, 2, 1, 1, 1, 5, 1, 2, 01730 1, 1, 1, 3, 1, 3, 1, 4, 6, 3, 01731 5, 2, 4, 1, 3, 4, 2, 2, 1, 2, 01732 0, 6, 8, 4, 6, 4, 2, 6, 2, 4, 01733 6, 2, 4, 2, 4, 1, 1, 1, 3, 1, 01734 4, 1, 4, 1, 3, 1, 1, 0, 0, 0, 01735 5, 4, 1, 3, 3, 0, 5, 2, 4, 5, 01736 5, 2, 0, 5, 0, 5, 3, 0, 4, 0, 01737 4, 2, 1, 4, 0, 5, 0, 5, 5, 1, 01738 1, 6, 1, 1, 1, 1, 2, 1, 2, 1, 01739 1, 1, 1, 1, 1, 1, 2, 3, 3, 3, 01740 3, 3, 0, 3, 1, 2, 3, 3, 0, 3, 01741 3, 3, 3, 3, 0, 3, 0, 3, 0, 2, 01742 0, 2, 0, 2, 1, 0, 3, 0, 0, 0, 01743 6, 1, 1, 1, 1, 2, 1, 1, 1, 1, 01744 3, 1, 1, 2, 2, 1, 1, 1, 1, 1, 01745 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 01746 1, 1, 1, 1, 0, 4, 2, 3, 2, 4, 01747 2, 2, 1, 2, 0, 6, 8, 4, 6, 4, 01748 6, 2, 4, 6, 2, 4, 2, 4, 1, 0, 01749 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 01750 2, 2, 1, 3, 1, 3, 1, 1, 2, 1, 01751 3, 3, 1, 3, 1, 3, 1, 1, 2, 1, 01752 1, 1, 2, 2, 1, 1, 0, 4, 1, 2, 01753 1, 3, 3, 2, 2, 1, 1, 1, 1, 1, 01754 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 01755 1, 2, 2, 0, 1, 1, 1, 1, 1, 2, 01756 0 01757 }; 01758 01759 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. 01760 Performed when YYTABLE doesn't specify something else to do. Zero 01761 means the default is an error. */ 01762 static const yytype_uint16 yydefact[] = 01763 { 01764 2, 0, 0, 1, 0, 347, 348, 349, 0, 340, 01765 341, 342, 345, 343, 344, 346, 335, 336, 337, 338, 01766 298, 263, 263, 511, 510, 512, 513, 609, 0, 609, 01767 10, 0, 515, 514, 516, 595, 597, 507, 506, 596, 01768 509, 501, 502, 454, 521, 522, 0, 0, 0, 0, 01769 290, 620, 620, 85, 407, 480, 478, 480, 482, 462, 01770 474, 468, 476, 0, 0, 0, 3, 607, 6, 9, 01771 33, 45, 48, 56, 263, 55, 0, 73, 0, 77, 01772 87, 0, 53, 244, 0, 286, 0, 0, 312, 315, 01773 607, 0, 0, 0, 0, 57, 307, 275, 276, 453, 01774 455, 277, 278, 279, 281, 280, 282, 451, 452, 450, 01775 517, 518, 283, 0, 284, 61, 5, 8, 168, 179, 01776 169, 192, 165, 185, 175, 174, 195, 196, 190, 173, 01777 172, 167, 193, 197, 198, 177, 166, 180, 184, 186, 01778 178, 171, 187, 194, 189, 188, 181, 191, 176, 164, 01779 183, 182, 163, 170, 161, 162, 158, 159, 160, 116, 01780 118, 117, 153, 154, 149, 131, 132, 133, 140, 137, 01781 139, 134, 135, 155, 156, 141, 142, 146, 150, 136, 01782 138, 128, 129, 130, 143, 144, 145, 147, 148, 151, 01783 152, 157, 121, 123, 125, 26, 119, 120, 122, 124, 01784 0, 0, 0, 0, 0, 0, 0, 0, 258, 0, 01785 245, 268, 71, 262, 620, 0, 517, 518, 0, 284, 01786 620, 590, 72, 70, 609, 69, 0, 620, 431, 68, 01787 609, 610, 0, 0, 21, 241, 0, 0, 335, 336, 01788 298, 301, 432, 0, 220, 0, 221, 295, 0, 19, 01789 0, 0, 607, 15, 18, 609, 75, 14, 609, 0, 01790 0, 613, 613, 246, 0, 0, 613, 588, 609, 0, 01791 0, 0, 83, 339, 0, 93, 94, 101, 309, 408, 01792 498, 497, 499, 496, 0, 495, 0, 0, 0, 0, 01793 0, 0, 0, 0, 0, 0, 0, 503, 504, 52, 01794 235, 236, 616, 617, 4, 618, 608, 0, 0, 0, 01795 0, 0, 0, 0, 436, 434, 421, 62, 306, 415, 01796 417, 0, 89, 0, 81, 78, 0, 0, 0, 0, 01797 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01798 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01799 0, 0, 0, 429, 620, 427, 0, 54, 0, 0, 01800 0, 0, 607, 0, 608, 0, 361, 360, 0, 0, 01801 517, 518, 284, 111, 112, 0, 0, 114, 0, 0, 01802 517, 518, 284, 328, 188, 181, 191, 176, 158, 159, 01803 160, 116, 117, 586, 330, 585, 0, 606, 605, 0, 01804 308, 456, 0, 0, 126, 593, 295, 269, 594, 265, 01805 0, 0, 0, 259, 267, 429, 620, 427, 0, 0, 01806 0, 260, 609, 0, 300, 264, 609, 254, 620, 620, 01807 253, 609, 305, 51, 23, 25, 24, 0, 302, 0, 01808 0, 0, 429, 427, 0, 17, 0, 609, 293, 13, 01809 608, 74, 289, 291, 296, 615, 614, 247, 615, 249, 01810 297, 589, 0, 100, 503, 504, 91, 86, 0, 429, 01811 620, 427, 549, 484, 487, 485, 500, 481, 457, 479, 01812 458, 459, 483, 460, 461, 0, 464, 470, 0, 471, 01813 466, 467, 0, 472, 0, 473, 0, 0, 619, 7, 01814 27, 28, 29, 30, 31, 49, 50, 620, 620, 59, 01815 63, 620, 0, 34, 43, 0, 44, 609, 0, 79, 01816 90, 47, 46, 0, 199, 268, 42, 217, 225, 230, 01817 231, 232, 227, 229, 239, 240, 233, 234, 210, 211, 01818 237, 238, 609, 226, 228, 222, 223, 224, 212, 213, 01819 214, 215, 216, 598, 600, 599, 601, 0, 263, 426, 01820 609, 598, 600, 599, 601, 0, 263, 0, 620, 352, 01821 0, 351, 0, 0, 0, 0, 0, 0, 295, 429, 01822 620, 427, 320, 325, 111, 112, 113, 0, 524, 323, 01823 523, 429, 620, 427, 0, 0, 549, 332, 598, 599, 01824 263, 35, 201, 41, 209, 0, 199, 592, 0, 270, 01825 266, 620, 598, 599, 609, 598, 599, 591, 299, 611, 01826 250, 255, 257, 304, 22, 0, 242, 0, 32, 424, 01827 422, 208, 0, 76, 16, 609, 613, 0, 84, 97, 01828 99, 609, 598, 599, 555, 552, 551, 550, 553, 0, 01829 566, 0, 577, 567, 581, 580, 576, 549, 409, 548, 01830 412, 554, 556, 558, 534, 564, 620, 569, 620, 574, 01831 534, 579, 534, 0, 532, 488, 0, 463, 465, 475, 01832 469, 477, 218, 219, 399, 609, 0, 397, 396, 0, 01833 620, 0, 274, 0, 88, 82, 0, 0, 0, 0, 01834 0, 0, 430, 66, 0, 0, 433, 0, 0, 428, 01835 64, 620, 350, 287, 620, 620, 442, 620, 353, 620, 01836 355, 313, 354, 316, 0, 0, 319, 602, 294, 609, 01837 598, 599, 0, 0, 526, 0, 0, 111, 112, 115, 01838 609, 0, 609, 549, 0, 0, 0, 252, 418, 58, 01839 251, 0, 127, 271, 261, 0, 0, 433, 0, 0, 01840 620, 609, 11, 0, 292, 248, 92, 95, 0, 560, 01841 555, 0, 373, 364, 366, 609, 362, 609, 0, 0, 01842 541, 0, 530, 584, 568, 0, 531, 0, 544, 578, 01843 0, 546, 582, 489, 491, 492, 493, 486, 494, 555, 01844 0, 395, 609, 0, 380, 562, 620, 620, 572, 380, 01845 380, 378, 401, 0, 0, 0, 0, 0, 272, 80, 01846 200, 0, 40, 206, 39, 207, 67, 425, 612, 0, 01847 37, 204, 38, 205, 65, 423, 443, 444, 620, 445, 01848 0, 620, 358, 0, 0, 356, 0, 0, 0, 318, 01849 0, 0, 433, 0, 326, 0, 0, 433, 329, 587, 01850 609, 0, 528, 333, 419, 420, 202, 0, 256, 303, 01851 20, 570, 609, 0, 371, 0, 557, 0, 0, 0, 01852 410, 533, 559, 534, 534, 565, 620, 583, 534, 575, 01853 534, 534, 0, 0, 0, 561, 0, 398, 386, 388, 01854 0, 376, 377, 0, 391, 0, 393, 0, 437, 435, 01855 0, 416, 273, 243, 36, 203, 0, 0, 447, 359, 01856 0, 12, 449, 0, 310, 311, 0, 0, 270, 620, 01857 321, 0, 525, 324, 527, 331, 549, 363, 374, 0, 01858 369, 365, 411, 0, 0, 0, 537, 0, 539, 529, 01859 0, 545, 0, 542, 547, 0, 571, 295, 429, 400, 01860 379, 380, 380, 563, 620, 380, 573, 380, 380, 405, 01861 609, 403, 406, 60, 0, 446, 0, 102, 103, 110, 01862 0, 448, 0, 314, 317, 439, 440, 438, 0, 0, 01863 0, 0, 372, 0, 367, 414, 413, 534, 534, 534, 01864 534, 490, 602, 294, 0, 383, 0, 385, 375, 0, 01865 392, 0, 389, 394, 0, 402, 109, 429, 620, 427, 01866 620, 620, 0, 327, 0, 370, 0, 538, 0, 535, 01867 540, 543, 380, 380, 380, 380, 404, 602, 108, 609, 01868 598, 599, 441, 357, 322, 334, 368, 534, 384, 0, 01869 381, 387, 390, 433, 536, 380, 382 01870 }; 01871 01872 /* YYDEFGOTO[NTERM-NUM]. */ 01873 static const yytype_int16 yydefgoto[] = 01874 { 01875 -1, 1, 2, 66, 67, 68, 236, 567, 568, 252, 01876 253, 446, 254, 437, 70, 71, 358, 72, 73, 510, 01877 690, 243, 75, 76, 255, 77, 78, 79, 467, 80, 01878 209, 377, 378, 192, 193, 194, 195, 605, 556, 197, 01879 82, 439, 211, 260, 228, 748, 426, 427, 225, 226, 01880 213, 413, 428, 516, 83, 356, 258, 259, 635, 625, 01881 360, 847, 361, 848, 732, 988, 736, 733, 931, 594, 01882 596, 746, 936, 245, 85, 86, 87, 88, 89, 90, 01883 91, 92, 93, 94, 713, 570, 721, 844, 845, 369, 01884 773, 774, 775, 960, 899, 802, 686, 687, 803, 970, 01885 971, 278, 279, 472, 778, 658, 880, 320, 511, 95, 01886 96, 711, 704, 565, 557, 318, 508, 507, 577, 987, 01887 715, 838, 917, 921, 97, 98, 99, 100, 101, 102, 01888 103, 290, 485, 104, 294, 105, 106, 292, 296, 286, 01889 284, 288, 477, 676, 675, 793, 892, 797, 107, 285, 01890 108, 109, 216, 217, 112, 218, 219, 589, 735, 744, 01891 881, 780, 745, 661, 662, 663, 664, 665, 805, 806, 01892 666, 667, 668, 669, 808, 809, 670, 671, 672, 673, 01893 674, 782, 396, 595, 265, 429, 221, 115, 629, 559, 01894 399, 304, 423, 424, 706, 457, 571, 364, 257 01895 }; 01896 01897 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 01898 STATE-NUM. */ 01899 #define YYPACT_NINF -808 01900 static const yytype_int16 yypact[] = 01901 { 01902 -808, 134, 2562, -808, 7195, -808, -808, -808, 6718, -808, 01903 -808, -808, -808, -808, -808, -808, 7308, 7308, -808, -808, 01904 7308, 3884, 3479, -808, -808, -808, -808, 455, 6585, 17, 01905 -808, 60, -808, -808, -808, 2804, 3614, -808, -808, 2939, 01906 -808, -808, -808, -808, -808, -808, 8664, 8664, 140, 4955, 01907 462, 7647, 7986, 6977, -808, 6452, -808, -808, -808, 103, 01908 115, 126, 206, 117, 8777, 8664, -808, -25, -808, 1007, 01909 -808, 322, -808, -808, 141, 372, 352, -808, 337, 9003, 01910 -808, 379, 2918, 247, 278, -808, 8890, 8890, -808, -808, 01911 5842, 9112, 9221, 9330, 6318, 33, 65, -808, -808, 410, 01912 -808, -808, -808, -808, -808, -808, -808, -808, -808, -808, 01913 205, 409, -808, 441, 433, -808, -808, -808, -808, -808, 01914 -808, -808, -808, -808, -808, -808, -808, -808, -808, -808, 01915 -808, -808, -808, -808, -808, -808, -808, -808, -808, -808, 01916 -808, -808, -808, -808, -808, -808, -808, -808, -808, -808, 01917 -808, -808, -808, -808, -808, -808, -808, -808, -808, -808, 01918 -808, -808, -808, -808, -808, -808, -808, -808, -808, -808, 01919 -808, -808, -808, -808, -808, -808, -808, -808, -808, -808, 01920 -808, -808, -808, -808, -808, -808, -808, -808, -808, -808, 01921 -808, -808, -808, -808, -808, 396, -808, -808, -808, -808, 01922 427, 8664, 519, 5094, 8664, 8664, 8664, 8664, -808, 468, 01923 2918, 500, -808, -808, 463, 304, 22, 344, 517, 363, 01924 479, -808, -808, -808, 5729, -808, 7308, 7308, -808, -808, 01925 5955, -808, 8890, 498, -808, 482, 491, 5233, -808, -808, 01926 -808, 497, 499, 141, -808, 361, 570, 458, 7421, -808, 01927 4955, 505, -25, -808, 1007, 17, 538, -808, 17, 8890, 01928 515, 188, 318, -808, 500, 523, 318, -808, 17, 617, 01929 338, 9439, 540, -808, 474, 572, 613, 674, -808, -808, 01930 -808, -808, -808, -808, 522, -808, 601, 669, 284, 576, 01931 752, 577, 58, 582, 759, 584, 68, 609, 612, -808, 01932 -808, -808, -808, -808, -808, -808, 6068, 8890, 8890, 8890, 01933 8890, 7421, 8890, 8890, -808, -808, -808, 588, -808, -808, 01934 -808, 8099, -808, 4955, 7086, 561, 8099, 8664, 8664, 8664, 01935 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 01936 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 01937 8664, 8664, 8664, 2012, 7308, 9718, 4312, 322, 109, 109, 01938 8890, 8890, -25, 689, 563, 651, -808, -808, 685, 691, 01939 53, 57, 100, 328, 393, 8890, 568, -808, 199, 708, 01940 -808, -808, -808, -808, 55, 223, 249, 279, 283, 301, 01941 316, 384, 417, -808, -808, -808, 33, -808, -808, 9795, 01942 -808, -808, 8777, 8777, -808, -808, 414, -808, -808, -808, 01943 8664, 8664, 7534, -808, -808, 9872, 7308, 9949, 8664, 8664, 01944 7760, -808, 17, 595, -808, -808, 17, -808, 580, 599, 01945 -808, 61, -808, -808, -808, -808, -808, 6718, -808, 8664, 01946 5364, 604, 9872, 9949, 8664, 1007, 607, 17, -808, -808, 01947 6181, 618, -808, 322, -808, 7873, -808, -808, 7986, -808, 01948 -808, -808, 482, 769, -808, -808, -808, 622, 9439, 10026, 01949 7308, 10103, 1417, -808, -808, -808, -808, -808, -808, -808, 01950 -808, -808, -808, -808, -808, 244, -808, -808, 611, -808, 01951 -808, -808, 347, -808, 623, -808, 8664, 8664, -808, -808, 01952 -808, -808, -808, -808, -808, -808, -808, 51, 51, -808, 01953 -808, 51, 8664, -808, 628, 634, -808, 17, 9439, 655, 01954 -808, -808, -808, 678, 1866, -808, -808, 570, 2240, 2240, 01955 2240, 2240, 727, 727, 3323, 3188, 2240, 2240, 3053, 3053, 01956 415, 415, 1674, 727, 727, 907, 907, 660, 40, 40, 01957 570, 570, 570, 4019, 3074, 4154, 3209, 499, 661, -808, 01958 17, 535, -808, 688, -808, 499, 3749, 737, 790, -808, 01959 4451, 799, 4729, 66, 66, 689, 8212, 737, 147, 10180, 01960 7308, 10257, -808, 322, -808, 769, -808, -25, -808, -808, 01961 -808, 10334, 7308, 9795, 4312, 8890, 1538, -808, -808, -808, 01962 4173, -808, 2648, -808, 2918, 6718, 2783, -808, 8664, 500, 01963 -808, 479, 2669, 3344, 17, 420, 444, -808, -808, -808, 01964 -808, 7534, 7760, -808, -808, 8890, 2918, 672, -808, -808, 01965 -808, 2918, 5364, 2, -808, 17, 318, 9439, 622, 701, 01966 469, 17, 207, 224, 711, -808, -808, -808, -808, 8664, 01967 -808, 947, -808, -808, -808, -808, -808, 1789, -808, -808, 01968 -808, -808, -808, -808, 680, -808, 687, 773, 694, -808, 01969 698, 783, 704, 791, -808, -808, 834, -808, -808, -808, 01970 -808, -808, 570, 570, -808, 1322, 5503, -808, -808, 5233, 01971 51, 5503, 721, 8325, -808, 622, 9439, 8777, 8664, 741, 01972 8777, 8777, -808, 588, 499, 722, 818, 8777, 8777, -808, 01973 588, 499, -808, -808, 8438, 827, -808, 597, -808, 827, 01974 -808, -808, -808, -808, 737, 70, -808, 67, 136, 17, 01975 148, 149, 8890, -25, -808, 8890, 4312, 701, 469, -808, 01976 17, 737, 61, 1789, 4312, -25, 6851, -808, 65, 372, 01977 -808, 8664, -808, -808, -808, 8664, 8664, 466, 8664, 8664, 01978 731, 61, -808, 736, -808, -808, -808, 567, 8664, -808, 01979 -808, 947, 350, -808, 738, 17, -808, 17, 72, 1789, 01980 -808, 42, -808, -808, -808, 272, -808, 1789, -808, -808, 01981 892, -808, -808, -808, -808, -808, -808, -808, -808, 762, 01982 9548, -808, 17, 764, 746, -808, 751, 694, -808, 758, 01983 760, -808, 761, 893, 775, 5233, 899, 8664, 776, 622, 01984 2918, 8664, -808, 2918, -808, 2918, -808, -808, -808, 8777, 01985 -808, 2918, -808, 2918, -808, -808, 628, -808, 826, -808, 01986 4842, 909, -808, 8890, 737, -808, 737, 5503, 5503, -808, 01987 8551, 4590, 155, 66, -808, -25, 737, -808, -808, -808, 01988 17, 737, -808, -808, -808, -808, 2918, 8664, 7760, -808, 01989 -808, -808, 17, 1011, 789, 1003, -808, 793, 5503, 5233, 01990 -808, -808, -808, 798, 803, -808, 694, -808, 804, -808, 01991 811, 804, 5616, 9548, 877, 792, 808, -808, 1910, -808, 01992 490, -808, -808, 1910, -808, 1368, -808, 1032, -808, -808, 01993 820, -808, 819, 2918, -808, 2918, 9657, 109, -808, -808, 01994 5503, -808, -808, 109, -808, -808, 737, 737, -808, 130, 01995 -808, 4312, -808, -808, -808, -808, 1538, -808, 821, 1011, 01996 434, -808, -808, 944, 832, 1789, -808, 892, -808, -808, 01997 892, -808, 892, -808, -808, 850, 792, -808, 10411, -808, 01998 -808, 830, 831, -808, 694, 835, -808, 837, 835, -808, 01999 443, -808, -808, -808, 910, -808, 796, 572, 613, 674, 02000 4312, -808, 4451, -808, -808, -808, -808, -808, 5503, 737, 02001 4312, 1011, 821, 1011, 838, -808, -808, 804, 839, 804, 02002 804, -808, 840, 841, 1910, -808, 1368, -808, -808, 1368, 02003 -808, 1368, -808, -808, 1032, -808, 769, 10488, 7308, 10565, 02004 790, 597, 737, -808, 737, 821, 1011, -808, 892, -808, 02005 -808, -808, 835, 844, 835, 835, -808, 74, 469, 17, 02006 146, 158, -808, -808, -808, -808, 821, 804, -808, 1368, 02007 -808, -808, -808, 176, -808, 835, -808 02008 }; 02009 02010 /* YYPGOTO[NTERM-NUM]. */ 02011 static const yytype_int16 yypgoto[] = 02012 { 02013 -808, -808, -808, -363, -808, 27, -808, -550, -21, -808, 02014 518, -808, 15, -808, -301, -51, -86, 41, -808, -268, 02015 -808, 413, -7, 888, -153, -4, -73, -808, -416, 7, 02016 1571, -315, 889, -53, -808, -5, -808, -808, 98, -808, 02017 870, -808, 735, -808, -44, 275, -340, 87, -11, -808, 02018 -386, -188, 4, -311, -20, -808, -808, -808, -808, -808, 02019 -808, -808, -808, -808, -808, -808, -808, -808, -808, -808, 02020 -808, -808, -808, 64, -808, -808, -808, -808, -808, -808, 02021 -808, -808, -808, -808, 154, -347, -526, -34, -645, -808, 02022 -785, -779, 221, 309, 374, -808, -446, -808, -665, -808, 02023 -18, -808, -808, -808, -808, -808, -808, 248, -808, -808, 02024 -808, -808, -808, -808, -808, -93, -808, -808, -535, -808, 02025 -6, -808, -808, -808, -808, -808, -808, 918, -808, -808, 02026 -808, -808, 712, -808, -808, -808, -808, -808, -808, -808, 02027 963, -808, -142, -808, -808, -808, -808, -808, 10, -808, 02028 14, -808, 1081, 1361, 928, 1531, 1552, -808, -808, 89, 02029 -464, -372, -415, -783, -518, -723, 234, 242, 133, -808, 02030 -808, -808, 289, -708, -807, 128, 255, -808, -638, -808, 02031 228, -622, -808, -808, -808, 69, -383, -808, -348, -808, 02032 639, -26, 0, 48, -598, -208, 21, -14, -2 02033 }; 02034 02035 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 02036 positive, shift that token. If negative, reduce the rule which 02037 number is the opposite. If YYTABLE_NINF, syntax error. */ 02038 #define YYTABLE_NINF -621 02039 static const yytype_int16 yytable[] = 02040 { 02041 116, 359, 283, 400, 362, 558, 325, 566, 659, 208, 02042 208, 229, 572, 208, 560, 526, 757, 69, 198, 69, 02043 214, 214, 199, 234, 214, 521, 610, 232, 251, 235, 02044 316, 117, 421, 273, 610, 357, 357, 617, 198, 357, 02045 724, 394, 199, 767, 741, 256, 786, 810, 723, 263, 02046 267, 600, 638, 306, 459, 261, 882, 660, 461, 273, 02047 272, 586, 689, 317, 363, 691, 84, 558, 84, 566, 02048 841, 273, 273, 273, 846, 617, 614, 627, -102, 889, 02049 215, 215, -103, 569, 215, 220, 220, -106, 305, 220, 02050 941, 314, -106, 720, 938, 630, 966, 447, 312, 313, 02051 649, 878, 695, 212, 222, 299, 196, 223, 327, -519, 02052 650, 305, 877, 84, 302, -74, 303, 274, 397, 488, 02053 262, 266, 569, 630, 972, -110, 196, 684, 215, 494, 02054 641, 852, 659, 776, 3, -102, -88, 896, 653, 654, 02055 -511, 884, 857, 274, 479, 840, 482, 576, 486, 890, 02056 215, 215, 486, 196, 215, 368, 379, 379, 231, -105, 02057 992, -108, 655, 350, 351, 352, 398, 314, 489, 685, 02058 517, -107, -109, -105, -107, 882, 297, 298, 495, 431, 02059 -104, 433, 251, 879, 901, 902, 856, -93, -511, -104, 02060 237, -94, 196, 659, 861, 315, 247, 966, 466, 316, 02061 587, -97, 231, -598, 850, 302, 941, 303, 453, 302, 02062 -598, 303, 414, -106, 1025, -106, 441, 208, 414, 208, 02063 208, 500, 501, 502, 503, 430, 449, 882, 214, 251, 02064 214, 972, -96, 630, -101, 610, 610, 889, 450, 617, 02065 729, 421, 777, 289, 815, 630, 256, 1046, 302, -98, 02066 303, 273, 740, 776, 874, 291, 357, 357, 357, 357, 02067 962, 505, 506, 445, 949, 967, 293, 84, 462, 763, 02068 -99, 315, -599, 305, 573, 574, 739, 227, 432, 659, 02069 819, -100, -96, -98, 985, -105, 882, -105, 215, -95, 02070 215, 215, -519, 220, 215, 220, 215, -107, 788, -107, 02071 791, 84, 251, 451, 273, 473, 452, 998, -510, 357, 02072 357, 422, 84, 425, 84, -104, 588, -104, -102, 256, 02073 -96, 69, 455, 215, 583, 515, 504, 930, 860, 456, 02074 515, 519, -339, 499, -512, 274, 575, -98, 302, -93, 02075 303, -96, 1008, 678, -96, 473, 295, 208, -96, 481, 02076 678, 474, 430, 475, -595, 776, -510, 776, -98, 312, 02077 313, -98, 513, 353, -513, -98, 1033, 522, -515, 654, 02078 84, 215, 215, 215, 215, 84, 215, 215, 851, -339, 02079 -339, 989, -512, 305, 677, 215, -514, 84, 274, 415, 02080 215, 474, 655, 475, 986, 466, 521, 464, 465, 590, 02081 319, -516, 770, 837, 645, 646, 647, 648, 473, 208, 02082 354, 355, -513, -505, 430, 74, -515, 74, 215, -596, 02083 84, 776, 994, 754, 215, 215, 414, 414, 765, 74, 02084 74, -520, 624, 74, -514, 826, 416, 417, 116, 215, 02085 1024, 1053, 834, 601, 603, 466, 442, 198, 273, -516, 02086 419, 199, 458, 564, 474, 69, 475, -103, -595, 456, 02087 -505, -505, 74, 208, -595, 321, 215, 215, 430, -505, 02088 618, 322, 659, 776, 620, 776, -110, 74, -508, 623, 02089 215, 611, 610, 327, 873, 617, 770, 680, 645, 646, 02090 647, 648, 326, 416, 443, 633, -520, 564, 273, 74, 02091 74, 444, -508, 74, 84, 688, 688, 758, 776, 688, 02092 56, 946, 948, 702, 84, 564, 951, -505, 953, 954, 02093 403, 709, -103, -596, 636, -508, -508, -109, 402, -596, 02094 404, 759, 274, -105, 215, 196, 348, 349, 350, 351, 02095 352, 564, 699, -94, 742, 444, -110, 703, 800, 717, 02096 -508, 719, 434, 867, -294, 710, 747, -107, 650, 469, 02097 705, 435, 436, 230, 766, 694, 716, -101, 993, 564, 02098 980, -109, 754, 208, 761, 406, 982, 1014, 430, -104, 02099 725, 410, 274, 473, 231, 208, 653, 654, 411, 749, 02100 430, 230, -100, -433, 722, 722, 231, 412, 750, -288, 02101 752, -294, -294, -288, 418, -599, 470, 471, 734, 414, 02102 655, 843, 840, 420, 705, 198, 74, 273, 438, 199, 02103 584, 440, 707, 466, 585, 1027, 1029, 1030, 1031, 474, 02104 116, 475, 476, 224, 84, 227, 84, 74, 327, 74, 02105 74, 705, 448, 74, 215, 74, 853, 69, -105, 855, 02106 74, -73, -433, 454, 460, 864, 215, -517, 84, 215, 02107 827, 74, 473, 74, 783, 813, 783, 747, 814, -96, 02108 816, 630, 74, 463, 468, 1054, 273, 496, 1039, 564, 02109 497, 357, 509, 764, 357, 812, 483, 487, 688, 215, 02110 760, 564, 490, 863, 493, 520, 84, -433, -518, -433, 02111 -433, 274, 498, 196, -517, -517, 576, 578, 474, 750, 02112 475, 478, 839, 842, 621, 842, 582, 842, 515, 74, 02113 74, 74, 74, 74, 74, 74, 74, -602, 327, 705, 02114 473, 726, 619, 622, 74, 628, 74, 632, 522, 74, 02115 705, 822, 824, 340, 341, -518, -518, 712, 830, 832, 02116 84, 679, -88, 84, 854, 84, 637, 923, 414, -284, 02117 274, 215, -268, 681, 215, 215, 862, 74, 693, 74, 02118 579, 215, 215, 74, 74, 708, 474, 812, 475, 480, 02119 273, 348, 349, 350, 351, 352, -602, 264, 74, 696, 02120 859, 697, 357, 591, 910, 327, 215, -424, 714, 215, 02121 84, -107, 812, 762, 783, 783, -284, -284, 84, 869, 02122 340, 341, 718, 473, 779, 74, 74, 580, 581, 919, 02123 473, 781, -98, 876, 768, 784, 926, 927, 785, 74, 02124 929, -602, 787, -602, -602, 789, 918, -598, 790, 922, 02125 592, 593, 840, 792, 196, 345, 346, 347, 348, 349, 02126 350, 351, 352, 74, -295, -269, 821, 943, 944, 474, 02127 828, 475, 484, 74, 895, 868, 474, 870, 475, 491, 02128 914, 955, 875, 273, 722, 893, 932, 958, 849, 84, 02129 898, 1017, 897, 74, 783, 900, 210, 210, 794, 795, 02130 210, 796, 903, 215, 905, 858, 273, 44, 45, 981, 02131 907, -295, -295, 908, 84, 829, 909, 215, 934, 911, 02132 -270, 84, 84, 811, 916, 84, 244, 246, 920, 804, 02133 937, 210, 210, 939, 592, 593, 959, 842, 1018, 1019, 02134 942, -104, 945, 957, 300, 301, 405, 947, 950, 407, 02135 408, 409, 84, 84, 770, 952, 645, 646, 647, 648, 02136 649, 973, -95, -271, 995, 991, 84, 956, 1001, 1020, 02137 650, 1021, 783, 996, 1004, 1006, 1016, 1022, 634, 1009, 02138 1015, 1011, 1026, 1028, 807, 327, -598, -599, 1049, 366, 02139 976, 651, 383, 74, 84, 74, 835, 1043, 653, 654, 02140 340, 341, 872, 74, 801, 84, 1036, 865, 924, 770, 02141 925, 645, 646, 647, 648, 74, 492, 74, 74, 887, 02142 933, 208, 655, 887, 1042, 935, 430, 401, 716, 842, 02143 287, 888, 395, 885, 891, 990, 961, 347, 348, 349, 02144 350, 351, 352, 963, 883, 597, 771, 0, 74, 705, 02145 0, 0, 772, 0, 84, 74, 84, 307, 308, 309, 02146 310, 311, 84, 0, 84, 770, 514, 645, 646, 647, 02147 648, 525, 0, 770, 0, 645, 646, 647, 648, 0, 02148 886, 210, 0, 0, 210, 210, 210, 300, 0, 0, 02149 983, 984, 215, 110, 969, 110, 645, 646, 647, 648, 02150 0, 0, 771, 0, 210, 0, 210, 210, 940, 74, 02151 771, 0, 74, 0, 74, 0, 0, 0, 0, 0, 02152 74, 0, 0, 74, 74, 0, 0, 564, 0, 0, 02153 74, 74, 0, 0, 0, 0, 811, 0, 887, 0, 02154 110, 811, 0, 811, 275, 0, 0, 965, 0, 968, 02155 0, 0, 0, 1023, 0, 74, 607, 609, 74, 74, 02156 0, 0, 0, 0, 0, 264, 0, 74, 0, 0, 02157 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02158 0, 0, 370, 380, 380, 380, 1044, 0, 1045, 997, 02159 0, 999, 0, 904, 906, 0, 1000, 807, 0, 964, 02160 609, 210, 807, 264, 807, 0, 524, 527, 528, 529, 02161 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 02162 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 02163 550, 551, 552, 0, 210, 0, 0, 0, 74, 0, 02164 0, 0, 811, 0, 811, 0, 0, 811, 1032, 811, 02165 1034, 0, 74, 0, 0, 1035, 0, 692, 0, 0, 02166 0, 0, 0, 74, 0, 0, 74, 0, 0, 0, 02167 74, 74, 1047, 0, 74, 0, 0, 0, 0, 0, 02168 0, 0, 602, 604, 0, 0, 0, 811, 0, 0, 02169 606, 210, 210, 1055, 110, 0, 210, 0, 602, 604, 02170 210, 74, 74, 807, 0, 807, 0, 0, 807, 0, 02171 807, 0, 0, 0, 0, 74, 0, 0, 0, 626, 02172 0, 525, 0, 0, 631, 0, 0, 0, 110, 0, 02173 0, 0, 0, 0, 0, 210, 0, 0, 210, 110, 02174 0, 110, 0, 74, 0, 1005, 1007, 0, 807, 1010, 02175 210, 1012, 1013, 753, 74, 0, 0, 0, 0, 0, 02176 0, 0, 275, 0, 0, 0, 609, 264, 0, 0, 02177 0, 0, 0, 111, 0, 111, 682, 683, 0, 0, 02178 0, 0, 0, 0, 799, 0, 645, 646, 647, 648, 02179 800, 0, 210, 0, 769, 0, 0, 110, 0, 0, 02180 650, 0, 110, 74, 0, 74, 0, 0, 0, 0, 02181 0, 74, 0, 74, 110, 275, 1048, 1050, 1051, 1052, 02182 111, 651, 0, 0, 276, 0, 0, 652, 653, 654, 02183 770, 0, 645, 646, 647, 648, 800, 0, 818, 1056, 02184 0, 74, 0, 0, 0, 0, 650, 110, 0, 0, 02185 276, 0, 655, 0, 0, 656, 210, 0, 0, 836, 02186 210, 0, 371, 381, 381, 381, 0, 651, 0, 0, 02187 0, 0, 210, 231, 653, 654, 0, 0, 0, 644, 02188 0, 645, 646, 647, 648, 649, 0, 0, 210, 0, 02189 0, 0, 0, 0, 0, 650, 0, 0, 655, 0, 02190 0, 210, 210, 0, 0, 0, 0, 0, 0, 0, 02191 0, 0, 0, 871, 0, 0, 651, 0, 0, 0, 02192 0, 0, 652, 653, 654, 0, 0, 0, 0, 210, 02193 0, 110, 0, 0, 0, 0, 0, 0, 0, 0, 02194 0, 110, 0, 113, 0, 113, 0, 655, 0, 0, 02195 656, 0, 0, 0, 0, 0, 0, 0, 0, 275, 02196 0, 0, 912, 657, 114, 0, 114, 0, 0, 0, 02197 0, 0, 0, 210, 111, 0, 0, 606, 820, 0, 02198 823, 825, 0, 81, 0, 81, 0, 831, 833, 0, 02199 113, 0, 0, 0, 210, 928, 0, 0, 0, 0, 02200 644, 0, 645, 646, 647, 648, 649, 0, 111, 275, 02201 0, 114, 0, 264, 0, 277, 650, 0, 0, 111, 02202 0, 111, 0, 0, 0, 0, 0, 0, 0, 0, 02203 81, 866, 0, 0, 0, 823, 825, 651, 831, 833, 02204 0, 277, 276, 652, 653, 654, 0, 0, 210, 0, 02205 0, 0, 0, 372, 382, 382, 0, 0, 0, 0, 02206 0, 110, 0, 110, 0, 0, 0, 0, 655, 0, 02207 0, 656, 367, 0, 0, 0, 0, 111, 0, 0, 02208 0, 0, 111, 0, 743, 110, 0, 0, 0, 0, 02209 0, 0, 0, 0, 111, 276, 0, 210, 0, 0, 02210 0, 913, 0, 0, 0, 0, 0, 0, 0, 915, 02211 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02212 0, 0, 0, 110, 0, 0, 0, 111, 275, 0, 02213 210, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02214 0, 0, 0, 0, 113, 0, 0, 915, 210, 0, 02215 0, 0, 327, 328, 329, 330, 331, 332, 333, 334, 02216 335, 336, 337, 338, 339, 114, 0, 340, 341, 0, 02217 0, 0, 0, 0, 0, 0, 0, 110, 113, 0, 02218 110, 0, 110, 0, 81, 0, 0, 275, 0, 113, 02219 0, 113, 0, 0, 0, 0, 0, 0, 342, 114, 02220 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 02221 114, 111, 114, 0, 0, 0, 0, 0, 81, 0, 02222 0, 111, 0, 0, 0, 231, 0, 110, 0, 81, 02223 0, 81, 0, 277, 0, 110, 0, 0, 0, 276, 02224 0, 0, 0, 0, 0, 0, 0, 113, 0, 0, 02225 0, 644, 113, 645, 646, 647, 648, 649, 0, 0, 02226 0, 0, 0, 0, 113, 0, 0, 650, 114, 0, 02227 0, 0, 0, 114, 0, 0, 0, 0, 0, 0, 02228 0, 0, 0, 0, 0, 114, 277, 81, 651, 276, 02229 0, 380, 81, 0, 652, 653, 654, 113, 210, 0, 02230 0, 0, 0, 0, 81, 0, 110, 523, 0, 0, 02231 0, 0, 0, 0, 0, 0, 0, 0, 114, 655, 02232 698, 0, 656, 0, 0, 0, 0, 0, 0, 0, 02233 0, 110, 0, 0, 0, 0, 0, 81, 110, 110, 02234 0, 111, 110, 111, 327, 328, 329, 330, 331, 332, 02235 333, 334, 335, 336, 337, 338, 339, 0, 0, 340, 02236 341, 0, 0, 0, 0, 111, 0, 0, 0, 110, 02237 110, 0, 799, 0, 645, 646, 647, 648, 800, 0, 02238 0, 113, 0, 110, 380, 0, 0, 0, 650, 0, 02239 342, 113, 343, 344, 345, 346, 347, 348, 349, 350, 02240 351, 352, 114, 111, 0, 0, 0, 977, 276, 651, 02241 -245, 110, 114, 0, 0, 652, 653, 654, 0, 0, 02242 0, 81, 110, 0, 0, 0, 0, 0, 0, 0, 02243 277, 81, 0, 0, 0, 0, 0, 0, 0, 0, 02244 655, 0, 0, 656, 0, 0, 0, 0, 0, 0, 02245 0, 0, 0, 0, 0, 0, 0, 111, 0, 0, 02246 111, 0, 111, 0, 0, 0, 0, 276, 0, 0, 02247 0, 110, 0, 110, 553, 554, 0, 0, 555, 110, 02248 277, 110, 0, 0, 0, 0, 0, 0, 162, 163, 02249 164, 165, 166, 167, 168, 169, 170, 0, 0, 171, 02250 172, 0, 0, 173, 174, 175, 176, 111, 0, 0, 02251 0, 113, 0, 113, 0, 111, 0, 177, 178, 0, 02252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02253 0, 0, 114, 0, 114, 113, 0, 0, 179, 180, 02254 181, 182, 183, 184, 185, 186, 187, 188, 0, 189, 02255 190, 81, 0, 81, 0, 0, 114, 191, 0, 0, 02256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02257 0, 381, 0, 113, 0, 81, 0, 0, 0, 0, 02258 0, 0, 0, 0, 0, 0, 111, 0, 0, 0, 02259 0, 0, 0, 0, 114, 0, 0, 0, 0, 277, 02260 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02261 0, 111, 0, 81, 0, 0, 0, 0, 111, 111, 02262 0, 0, 111, 0, 0, 0, 0, 113, 0, 0, 02263 113, 0, 113, 0, 0, 0, 0, 0, 798, 0, 02264 0, 0, 0, 0, 0, 0, 0, 0, 114, 111, 02265 111, 114, 0, 114, 0, 0, 0, 0, 277, 0, 02266 0, 0, 0, 111, 381, 0, 0, 81, 0, 0, 02267 81, 0, 81, 0, 0, 0, 0, 113, 523, 0, 02268 0, 0, 0, 0, 0, 113, 0, 978, 0, 0, 02269 0, 111, 0, 0, 0, 0, 0, 0, 114, 0, 02270 0, 0, 111, 0, 0, 0, 114, 0, 0, 0, 02271 0, 0, 0, 0, 0, 0, 0, 81, 327, -621, 02272 -621, -621, -621, 332, 333, 81, 0, -621, -621, 0, 02273 0, 0, 0, 340, 341, 0, 0, 0, 0, 0, 02274 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02275 0, 111, 0, 111, 0, 0, 113, 0, 0, 111, 02276 0, 111, 382, 0, 0, 0, 343, 344, 345, 346, 02277 347, 348, 349, 350, 351, 352, 0, 114, 0, 0, 02278 0, 113, 0, 0, 0, 0, 0, 0, 113, 113, 02279 0, 0, 113, 0, 0, 0, 81, 0, 0, 0, 02280 0, 0, 114, 0, 0, 0, 0, 0, 0, 114, 02281 114, 0, 0, 114, 0, 0, 0, 0, 0, 113, 02282 113, 81, 0, 0, 0, 0, 0, 0, 81, 81, 02283 0, 0, 81, 113, 0, 0, 0, 0, 0, 0, 02284 114, 114, 0, 0, 0, 0, 0, 0, 0, 0, 02285 0, 0, 0, 0, 114, 382, 0, 0, 0, 81, 02286 81, 113, 0, 0, 0, 0, 0, 0, 0, 0, 02287 0, 0, 113, 81, 0, 0, 0, 0, 979, 0, 02288 0, 0, 114, 0, 0, 0, 0, 0, 0, 0, 02289 0, 0, 0, 114, 0, 0, 0, 975, 0, 0, 02290 0, 81, 0, 0, 0, 0, 0, 0, 0, 0, 02291 0, 0, 81, 0, 0, 0, 0, 0, 0, 0, 02292 0, 113, 0, 113, 0, 0, 0, 0, 0, 113, 02293 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 02294 0, 0, 114, 0, 114, 0, 0, 0, 0, 0, 02295 114, 0, 114, 0, 0, 0, 0, 0, 0, 0, 02296 0, 81, 0, 81, 0, 0, 0, 0, 0, 81, 02297 0, 81, -620, 4, 0, 5, 6, 7, 8, 9, 02298 0, 0, 0, 10, 11, 0, 0, 0, 12, 0, 02299 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, 02300 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, 02301 0, 27, 0, 0, 0, 0, 0, 28, 29, 30, 02302 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 02303 0, 41, 42, 0, 43, 44, 45, 0, 46, 47, 02304 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02305 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 02306 0, 49, 50, 0, 51, 52, 0, 53, 0, 0, 02307 54, 55, 56, 57, 58, 59, 60, 61, 62, -602, 02308 0, 0, 0, 0, 0, 0, 0, -602, -602, -602, 02309 0, 0, -602, -602, -602, 0, -602, 0, 63, 64, 02310 65, 0, 751, 0, 0, -602, -602, -602, -602, 0, 02311 0, -620, 0, -620, 0, 0, -602, -602, 0, -602, 02312 -602, -602, -602, -602, 0, 0, 327, 328, 329, 330, 02313 331, 332, 333, 334, 335, 336, 337, 338, 339, 0, 02314 0, 340, 341, 0, 0, 0, 0, -602, -602, -602, 02315 -602, -602, -602, -602, -602, -602, -602, -602, -602, -602, 02316 0, 0, -602, -602, -602, 0, 755, -602, 0, 0, 02317 0, 0, 342, -602, 343, 344, 345, 346, 347, 348, 02318 349, 350, 351, 352, 0, 0, 0, -602, 0, 0, 02319 -602, 0, -106, -602, -602, -602, -602, -602, -602, -602, 02320 -602, -602, -602, -602, -602, 0, 0, 0, 0, -602, 02321 -602, -602, -602, -602, -505, 0, -602, -602, -602, 0, 02322 -602, 0, -505, -505, -505, 0, 0, -505, -505, -505, 02323 0, -505, 0, 0, 0, 0, 0, 698, 0, -505, 02324 0, -505, -505, -505, 0, 0, 0, 0, 0, 0, 02325 0, -505, -505, 0, -505, -505, -505, -505, -505, 0, 02326 0, 327, 328, 329, 330, 331, 332, 333, 334, 335, 02327 336, 337, 338, 339, 0, 0, 340, 341, 0, 0, 02328 0, 0, -505, -505, -505, -505, -505, -505, -505, -505, 02329 -505, -505, -505, -505, -505, 0, 0, -505, -505, -505, 02330 0, -505, -505, 0, 0, 0, 0, 342, -505, 343, 02331 344, 345, 346, 347, 348, 349, 350, 351, 352, 0, 02332 0, 0, -505, 0, 0, -505, 0, -505, -505, -505, 02333 -505, -505, -505, -505, -505, -505, -505, -505, -505, -505, 02334 0, 0, 0, 0, 0, -505, -505, -505, -505, -508, 02335 0, -505, -505, -505, 0, -505, 0, -508, -508, -508, 02336 0, 0, -508, -508, -508, 0, -508, 0, 0, 0, 02337 0, 0, 0, 0, -508, 0, -508, -508, -508, 0, 02338 0, 0, 0, 0, 0, 0, -508, -508, 0, -508, 02339 -508, -508, -508, -508, 0, 0, 327, 328, 329, 330, 02340 331, 332, 333, 334, 335, 336, 337, 338, 339, 0, 02341 0, 340, 341, 0, 0, 0, 0, -508, -508, -508, 02342 -508, -508, -508, -508, -508, -508, -508, -508, -508, -508, 02343 0, 0, -508, -508, -508, 0, -508, -508, 0, 0, 02344 0, 0, 342, -508, 343, 344, 345, 346, 347, 348, 02345 349, 350, 351, 352, 0, 0, 0, -508, 0, 0, 02346 -508, 0, -508, -508, -508, -508, -508, -508, -508, -508, 02347 -508, -508, -508, -508, -508, 0, 0, 0, 0, 0, 02348 -508, -508, -508, -508, -603, 0, -508, -508, -508, 0, 02349 -508, 0, -603, -603, -603, 0, 0, -603, -603, -603, 02350 0, -603, 0, 0, 0, 0, 0, 0, 0, 0, 02351 -603, -603, -603, -603, 0, 0, 0, 0, 0, 0, 02352 0, -603, -603, 0, -603, -603, -603, -603, -603, 0, 02353 0, 327, 328, 329, 330, 331, 332, 333, 334, 335, 02354 336, 337, -621, -621, 0, 0, 340, 341, 0, 0, 02355 0, 0, -603, -603, -603, -603, -603, -603, -603, -603, 02356 -603, -603, -603, -603, -603, 0, 0, -603, -603, -603, 02357 0, 0, -603, 0, 0, 0, 0, 0, -603, 343, 02358 344, 345, 346, 347, 348, 349, 350, 351, 352, 0, 02359 0, 0, -603, 0, 0, -603, 0, 0, -603, -603, 02360 -603, -603, -603, -603, -603, -603, -603, -603, -603, -603, 02361 0, 0, 0, 0, -603, -603, -603, -603, -603, -604, 02362 0, -603, -603, -603, 0, -603, 0, -604, -604, -604, 02363 0, 0, -604, -604, -604, 0, -604, 0, 0, 0, 02364 0, 0, 0, 0, 0, -604, -604, -604, -604, 0, 02365 0, 0, 0, 0, 0, 0, -604, -604, 0, -604, 02366 -604, -604, -604, -604, 0, 0, 327, 328, 329, 330, 02367 331, 332, 333, 334, 0, 336, 337, 0, 0, 0, 02368 0, 340, 341, 0, 0, 0, 0, -604, -604, -604, 02369 -604, -604, -604, -604, -604, -604, -604, -604, -604, -604, 02370 0, 0, -604, -604, -604, 0, 0, -604, 0, 0, 02371 0, 0, 0, -604, 343, 344, 345, 346, 347, 348, 02372 349, 350, 351, 352, 0, 0, 0, -604, 0, 0, 02373 -604, 0, 0, -604, -604, -604, -604, -604, -604, -604, 02374 -604, -604, -604, -604, -604, 0, 0, 0, 0, -604, 02375 -604, -604, -604, -604, -294, 0, -604, -604, -604, 0, 02376 -604, 0, -294, -294, -294, 0, 0, -294, -294, -294, 02377 0, -294, 0, 0, 0, 0, 0, 0, 0, 0, 02378 0, -294, -294, -294, 0, 0, 0, 0, 0, 0, 02379 0, -294, -294, 0, -294, -294, -294, -294, -294, 0, 02380 0, 327, 328, 329, 330, 331, 332, 333, 0, 0, 02381 336, 337, 0, 0, 0, 0, 340, 341, 0, 0, 02382 0, 0, -294, -294, -294, -294, -294, -294, -294, -294, 02383 -294, -294, -294, -294, -294, 0, 0, -294, -294, -294, 02384 0, 756, -294, 0, 0, 0, 0, 0, -294, 343, 02385 344, 345, 346, 347, 348, 349, 350, 351, 352, 0, 02386 0, 0, -294, 0, 0, -294, 0, -108, -294, -294, 02387 -294, -294, -294, -294, -294, -294, -294, -294, -294, -294, 02388 0, 0, 0, 0, 0, -294, -294, -294, -294, -432, 02389 0, -294, -294, -294, 0, -294, 0, -432, -432, -432, 02390 0, 0, -432, -432, -432, 0, -432, 0, 0, 0, 02391 0, 0, 0, 0, 0, -432, -432, -432, 0, 0, 02392 0, 0, 0, 0, 0, 0, -432, -432, 0, -432, 02393 -432, -432, -432, -432, 0, 0, 0, 0, 0, 0, 02394 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02395 0, 0, 0, 0, 0, 0, 0, -432, -432, -432, 02396 -432, -432, -432, -432, -432, -432, -432, -432, -432, -432, 02397 0, 0, -432, -432, -432, 0, 0, -432, 0, 0, 02398 0, 0, 0, -432, 0, 0, 0, 0, 0, 0, 02399 0, 0, 0, 0, 0, 0, 0, -432, 0, 0, 02400 0, 0, 0, -432, 0, -432, -432, -432, -432, -432, 02401 -432, -432, -432, -432, -432, 0, 0, 0, 0, -432, 02402 -432, -432, -432, -432, -285, 227, -432, -432, -432, 0, 02403 -432, 0, -285, -285, -285, 0, 0, -285, -285, -285, 02404 0, -285, 0, 0, 0, 0, 0, 0, 0, 0, 02405 0, -285, -285, -285, 0, 0, 0, 0, 0, 0, 02406 0, -285, -285, 0, -285, -285, -285, -285, -285, 0, 02407 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02408 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02409 0, 0, -285, -285, -285, -285, -285, -285, -285, -285, 02410 -285, -285, -285, -285, -285, 0, 0, -285, -285, -285, 02411 0, 0, -285, 0, 0, 0, 0, 0, -285, 0, 02412 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02413 0, 0, -285, 0, 0, -285, 0, 0, -285, -285, 02414 -285, -285, -285, -285, -285, -285, -285, -285, -285, -285, 02415 0, 0, 0, 0, 0, -285, -285, -285, -285, -422, 02416 0, -285, -285, -285, 0, -285, 0, -422, -422, -422, 02417 0, 0, -422, -422, -422, 0, -422, 0, 0, 0, 02418 0, 0, 0, 0, 0, -422, -422, -422, 0, 0, 02419 0, 0, 0, 0, 0, 0, -422, -422, 0, -422, 02420 -422, -422, -422, -422, 0, 0, 0, 0, 0, 0, 02421 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02422 0, 0, 0, 0, 0, 0, 0, -422, -422, -422, 02423 -422, -422, -422, -422, -422, -422, -422, -422, -422, -422, 02424 0, 0, -422, -422, -422, 0, 0, -422, 0, 0, 02425 0, 0, 0, -422, 0, 0, 0, 0, 0, 0, 02426 0, 0, 0, 0, 0, 0, 0, -422, 0, 0, 02427 0, 0, 0, -422, 0, -422, -422, -422, -422, -422, 02428 -422, -422, -422, -422, -422, 0, 0, 0, 0, -422, 02429 -422, -422, -422, -422, -301, -422, -422, -422, -422, 0, 02430 -422, 0, -301, -301, -301, 0, 0, -301, -301, -301, 02431 0, -301, 0, 0, 0, 0, 0, 0, 0, 0, 02432 0, -301, -301, 0, 0, 0, 0, 0, 0, 0, 02433 0, -301, -301, 0, -301, -301, -301, -301, -301, 0, 02434 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02435 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02436 0, 0, -301, -301, -301, -301, -301, -301, -301, -301, 02437 -301, -301, -301, -301, -301, 0, 0, -301, -301, -301, 02438 0, 0, -301, 0, 0, 0, 0, 0, -301, 0, 02439 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02440 0, 0, -301, 0, 0, 0, 0, 0, -301, 0, 02441 -301, -301, -301, -301, -301, -301, -301, -301, -301, -301, 02442 0, 0, 0, 0, 0, -301, -301, -301, -301, -602, 02443 224, -301, -301, -301, 0, -301, 0, -602, -602, -602, 02444 0, 0, 0, -602, -602, 0, -602, 0, 0, 0, 02445 0, 0, 0, 0, 0, -602, 0, 0, 0, 0, 02446 0, 0, 0, 0, 0, 0, -602, -602, 0, -602, 02447 -602, -602, -602, -602, 0, 0, 0, 0, 0, 0, 02448 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02449 0, 0, 0, 0, 0, 0, 0, -602, -602, -602, 02450 -602, -602, -602, -602, -602, -602, -602, -602, -602, -602, 02451 0, 0, -602, -602, -602, 0, 700, 0, 0, 0, 02452 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02453 0, 0, 0, 0, 0, 0, 0, -602, 0, 0, 02454 0, 0, -106, -602, 0, -602, -602, -602, -602, -602, 02455 -602, -602, -602, -602, -602, 0, 0, 0, 0, -602, 02456 -602, -602, -602, -97, -294, 0, -602, 0, -602, 0, 02457 -602, 0, -294, -294, -294, 0, 0, 0, -294, -294, 02458 0, -294, 0, -620, 0, 0, 0, 0, 0, 0, 02459 0, -620, -620, -620, 0, 0, -620, -620, -620, 0, 02460 -620, -294, -294, 0, -294, -294, -294, -294, -294, -620, 02461 -620, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02462 -620, -620, 0, -620, -620, -620, -620, -620, 0, 0, 02463 0, 0, -294, -294, -294, -294, -294, -294, -294, -294, 02464 -294, -294, -294, -294, -294, 0, 0, -294, -294, -294, 02465 0, 701, 0, 0, 0, 0, 0, 0, 0, 0, 02466 0, 0, 0, 0, 0, 0, 0, 0, -620, 0, 02467 0, 0, -294, 0, 0, 0, 0, -108, -294, 0, 02468 -294, -294, -294, -294, -294, -294, -294, -294, -294, -294, 02469 0, -620, 0, 0, 0, -294, -294, -294, -99, 0, 02470 0, -294, 0, -294, 0, -294, 0, 0, 0, 0, 02471 0, 0, 0, -620, -620, 0, -620, 0, 0, 227, 02472 -620, 0, -620, 248, -620, 5, 6, 7, 8, 9, 02473 -620, -620, -620, 10, 11, 0, 0, -620, 12, 0, 02474 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, 02475 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, 02476 0, 27, 0, 0, 0, 0, 0, 28, 29, 249, 02477 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 02478 0, 41, 42, 0, 43, 44, 45, 0, 46, 47, 02479 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02480 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 02481 0, 49, 50, 0, 51, 52, 0, 53, 0, 0, 02482 54, 55, 56, 57, 58, 59, 60, 61, 62, 0, 02483 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02484 0, 0, 0, 0, 0, 0, 0, 0, 63, 64, 02485 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02486 0, -620, 248, -620, 5, 6, 7, 8, 9, 0, 02487 0, -620, 10, 11, 0, -620, -620, 12, 0, 13, 02488 14, 15, 16, 17, 18, 19, 0, 0, 0, 0, 02489 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, 02490 27, 0, 0, 0, 0, 0, 28, 29, 249, 31, 02491 32, 33, 34, 35, 36, 37, 38, 39, 40, 0, 02492 41, 42, 0, 43, 44, 45, 0, 46, 47, 0, 02493 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02494 0, 0, 0, 0, 0, 0, 0, 48, 0, 0, 02495 49, 50, 0, 51, 52, 0, 53, 0, 0, 54, 02496 55, 56, 57, 58, 59, 60, 61, 62, 0, 0, 02497 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02498 0, 0, 0, 0, 0, 0, 0, 63, 64, 65, 02499 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02500 -620, 248, -620, 5, 6, 7, 8, 9, 0, 0, 02501 -620, 10, 11, 0, 0, -620, 12, -620, 13, 14, 02502 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, 02503 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 02504 0, 0, 0, 0, 0, 28, 29, 249, 31, 32, 02505 33, 34, 35, 36, 37, 38, 39, 40, 0, 41, 02506 42, 0, 43, 44, 45, 0, 46, 47, 0, 0, 02507 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02508 0, 0, 0, 0, 0, 0, 48, 0, 0, 49, 02509 50, 0, 51, 52, 0, 53, 0, 0, 54, 55, 02510 56, 57, 58, 59, 60, 61, 62, 0, 0, 0, 02511 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02512 0, 0, 0, 0, 0, 0, 63, 64, 65, 0, 02513 0, 0, 0, 0, 0, 0, 0, 0, 0, -620, 02514 248, -620, 5, 6, 7, 8, 9, 0, 0, -620, 02515 10, 11, 0, 0, -620, 12, 0, 13, 14, 15, 02516 16, 17, 18, 19, 0, 0, 0, 0, 0, 20, 02517 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, 02518 0, 0, 0, 0, 28, 29, 249, 31, 32, 33, 02519 34, 35, 36, 37, 38, 39, 40, 0, 41, 42, 02520 0, 43, 44, 45, 0, 46, 47, 0, 0, 0, 02521 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02522 0, 0, 0, 0, 0, 48, 0, 0, 49, 50, 02523 0, 51, 52, 0, 53, 0, 0, 54, 55, 56, 02524 57, 58, 59, 60, 61, 62, 0, 0, 0, 0, 02525 0, 0, 0, 248, 0, 5, 6, 7, 8, 9, 02526 0, -620, -620, 10, 11, 63, 64, 65, 12, 0, 02527 13, 14, 15, 16, 17, 18, 19, 0, -620, 0, 02528 -620, 0, 20, 21, 22, 23, 24, 25, 26, 0, 02529 0, 27, 0, 0, 0, 0, 0, 28, 29, 249, 02530 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 02531 0, 41, 42, 0, 43, 44, 45, 0, 46, 47, 02532 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02533 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 02534 0, 49, 50, 0, 51, 52, 0, 53, 0, 0, 02535 54, 55, 56, 57, 58, 59, 60, 61, 62, 0, 02536 0, 0, 0, 0, 0, 0, 248, 0, 5, 6, 02537 7, 8, 9, 0, 0, 0, 10, 11, 63, 64, 02538 65, 12, 0, 13, 14, 15, 16, 17, 18, 19, 02539 0, -620, 0, -620, 0, 20, 21, 22, 23, 24, 02540 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 02541 28, 29, 249, 31, 32, 33, 34, 35, 36, 37, 02542 38, 39, 40, 0, 41, 42, 0, 43, 44, 45, 02543 0, 46, 47, 0, 0, 0, 0, 0, 0, 0, 02544 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02545 0, 48, 0, 0, 250, 50, 0, 51, 52, 0, 02546 53, 0, 0, 54, 55, 56, 57, 58, 59, 60, 02547 61, 62, 0, 0, 0, 0, 0, 0, 0, 0, 02548 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02549 0, 63, 64, 65, 0, 0, 0, 0, 0, 0, 02550 0, 0, -620, 0, -620, 248, -620, 5, 6, 7, 02551 8, 9, 0, 0, 0, 10, 11, 0, 0, 0, 02552 12, 0, 13, 14, 15, 16, 17, 18, 19, 0, 02553 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 02554 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, 02555 29, 249, 31, 32, 33, 34, 35, 36, 37, 38, 02556 39, 40, 0, 41, 42, 0, 43, 44, 45, 0, 02557 46, 47, 0, 0, 0, 0, 0, 0, 0, 0, 02558 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02559 48, 0, 0, 49, 50, 0, 51, 52, 0, 53, 02560 0, 0, 54, 55, 56, 57, 58, 59, 60, 61, 02561 62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02562 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02563 63, 64, 65, 0, 0, 0, 0, 0, 0, 0, 02564 0, -620, 0, -620, 248, -620, 5, 6, 7, 8, 02565 9, 0, 0, 0, 10, 11, 0, 0, 0, 12, 02566 0, 13, 14, 15, 16, 17, 18, 19, 0, 0, 02567 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 02568 0, 0, 27, 0, 0, 0, 0, 0, 28, 29, 02569 249, 31, 32, 33, 34, 35, 36, 37, 38, 39, 02570 40, 0, 41, 42, 0, 43, 44, 45, 0, 46, 02571 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02572 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 02573 0, 0, 49, 50, 0, 51, 52, 0, 53, 0, 02574 0, 54, 55, 56, 57, 58, 59, 60, 61, 62, 02575 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02576 0, 0, 0, 0, 0, 0, 0, 0, 0, 63, 02577 64, 65, 0, 0, -620, 4, 0, 5, 6, 7, 02578 8, 9, -620, 0, -620, 10, 11, 0, 0, 0, 02579 12, 0, 13, 14, 15, 16, 17, 18, 19, 0, 02580 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 02581 26, 0, 0, 27, 0, 0, 0, 0, 0, 28, 02582 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 02583 39, 40, 0, 41, 42, 0, 43, 44, 45, 0, 02584 46, 47, 0, 0, 0, 0, 0, 0, 0, 0, 02585 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02586 48, 0, 0, 49, 50, 0, 51, 52, 0, 53, 02587 0, 0, 54, 55, 56, 57, 58, 59, 60, 61, 02588 62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02589 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02590 63, 64, 65, 0, 0, -620, 0, 0, 0, 0, 02591 0, 0, 0, -620, 248, -620, 5, 6, 7, 8, 02592 9, 0, 0, -620, 10, 11, 0, 0, 0, 12, 02593 0, 13, 14, 15, 16, 17, 18, 19, 0, 0, 02594 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 02595 0, 0, 27, 0, 0, 0, 0, 0, 28, 29, 02596 249, 31, 32, 33, 34, 35, 36, 37, 38, 39, 02597 40, 0, 41, 42, 0, 43, 44, 45, 0, 46, 02598 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02599 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 02600 0, 0, 49, 50, 0, 51, 52, 0, 53, 0, 02601 0, 54, 55, 56, 57, 58, 59, 60, 61, 62, 02602 0, 0, 0, 0, 0, 0, 0, 248, 0, 5, 02603 6, 7, 8, 9, 0, 0, 0, 10, 11, 63, 02604 64, 65, 12, 0, 13, 14, 15, 16, 17, 18, 02605 19, 0, -620, 0, -620, 0, 20, 21, 22, 23, 02606 24, 25, 26, 0, 0, 27, 0, 0, 0, 0, 02607 0, 28, 29, 249, 31, 32, 33, 34, 35, 36, 02608 37, 38, 39, 40, 0, 41, 42, 0, 43, 44, 02609 45, 0, 46, 47, 0, 0, 0, 0, 0, 0, 02610 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02611 0, 0, 48, 0, 0, 49, 50, 0, 51, 52, 02612 0, 53, 0, 0, 54, 55, 56, 57, 58, 59, 02613 60, 61, 62, 0, -620, 0, 0, 0, 0, 0, 02614 0, 0, 5, 6, 7, 0, 9, 0, 0, 0, 02615 10, 11, 63, 64, 65, 12, 0, 13, 14, 15, 02616 16, 17, 18, 19, 0, -620, 0, -620, 0, 20, 02617 21, 22, 23, 24, 25, 26, 0, 0, 200, 0, 02618 0, 0, 0, 0, 0, 29, 0, 0, 32, 33, 02619 34, 35, 36, 37, 38, 39, 40, 201, 41, 42, 02620 0, 43, 44, 45, 0, 46, 47, 0, 0, 0, 02621 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02622 0, 0, 0, 0, 0, 202, 0, 0, 203, 50, 02623 0, 51, 52, 0, 204, 205, 206, 54, 55, 56, 02624 57, 58, 59, 60, 61, 62, 0, 0, 0, 0, 02625 0, 0, 0, 0, 0, 5, 6, 7, 0, 9, 02626 0, 0, 0, 10, 11, 63, 207, 65, 12, 0, 02627 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, 02628 231, 0, 20, 21, 22, 23, 24, 25, 26, 0, 02629 0, 27, 0, 0, 0, 0, 0, 0, 29, 0, 02630 0, 32, 33, 34, 35, 36, 37, 38, 39, 40, 02631 0, 41, 42, 0, 43, 44, 45, 0, 46, 47, 02632 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02633 0, 0, 0, 0, 0, 0, 0, 0, 202, 0, 02634 0, 203, 50, 0, 51, 52, 0, 0, 0, 0, 02635 54, 55, 56, 57, 58, 59, 60, 61, 62, 0, 02636 0, 0, 0, 0, 0, 0, 0, 0, 5, 6, 02637 7, 0, 9, 0, 0, 0, 10, 11, 63, 64, 02638 65, 12, 0, 13, 14, 15, 16, 17, 18, 19, 02639 0, 302, 0, 303, 0, 20, 21, 22, 23, 24, 02640 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 02641 0, 29, 0, 0, 32, 33, 34, 35, 36, 37, 02642 38, 39, 40, 0, 41, 42, 0, 43, 44, 45, 02643 0, 46, 47, 0, 0, 0, 0, 0, 0, 0, 02644 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02645 0, 202, 0, 0, 203, 50, 0, 51, 52, 0, 02646 0, 0, 0, 54, 55, 56, 57, 58, 59, 60, 02647 61, 62, 0, 0, 0, 0, 0, 0, 0, 0, 02648 0, 5, 6, 7, 8, 9, 0, 0, 0, 10, 02649 11, 63, 64, 65, 12, 0, 13, 14, 15, 16, 02650 17, 18, 19, 0, 0, 0, 231, 0, 20, 21, 02651 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, 02652 0, 0, 0, 28, 29, 30, 31, 32, 33, 34, 02653 35, 36, 37, 38, 39, 40, 0, 41, 42, 0, 02654 43, 44, 45, 0, 46, 47, 0, 0, 0, 0, 02655 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02656 0, 0, 0, 0, 48, 0, 0, 49, 50, 0, 02657 51, 52, 0, 53, 0, 0, 54, 55, 56, 57, 02658 58, 59, 60, 61, 62, 0, 0, 0, 0, 0, 02659 0, 0, 0, 0, 5, 6, 7, 8, 9, 0, 02660 0, 0, 10, 11, 63, 64, 65, 12, 0, 13, 02661 14, 15, 16, 17, 18, 19, 0, 498, 0, 0, 02662 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, 02663 27, 0, 0, 0, 0, 0, 28, 29, 249, 31, 02664 32, 33, 34, 35, 36, 37, 38, 39, 40, 0, 02665 41, 42, 0, 43, 44, 45, 0, 46, 47, 0, 02666 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02667 0, 0, 0, 0, 0, 0, 0, 48, 0, 0, 02668 49, 50, 0, 51, 52, 0, 53, 0, 0, 54, 02669 55, 56, 57, 58, 59, 60, 61, 62, 0, 0, 02670 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02671 0, 0, 0, 0, 0, 0, 0, 63, 64, 65, 02672 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02673 498, 118, 119, 120, 121, 122, 123, 124, 125, 126, 02674 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 02675 137, 138, 139, 140, 141, 0, 0, 0, 142, 143, 02676 144, 384, 385, 386, 387, 149, 150, 151, 0, 0, 02677 0, 0, 0, 152, 153, 154, 155, 388, 389, 390, 02678 391, 160, 37, 38, 392, 40, 0, 0, 0, 0, 02679 0, 0, 0, 0, 162, 163, 164, 165, 166, 167, 02680 168, 169, 170, 0, 0, 171, 172, 0, 0, 173, 02681 174, 175, 176, 0, 0, 0, 0, 0, 0, 0, 02682 0, 0, 0, 177, 178, 0, 0, 0, 0, 0, 02683 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02684 0, 0, 0, 0, 179, 180, 181, 182, 183, 184, 02685 185, 186, 187, 188, 0, 189, 190, 0, 0, 0, 02686 0, 0, 0, 191, 393, 118, 119, 120, 121, 122, 02687 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 02688 133, 134, 135, 136, 137, 138, 139, 140, 141, 0, 02689 0, 0, 142, 143, 144, 145, 146, 147, 148, 149, 02690 150, 151, 0, 0, 0, 0, 0, 152, 153, 154, 02691 155, 156, 157, 158, 159, 160, 280, 281, 161, 282, 02692 0, 0, 0, 0, 0, 0, 0, 0, 162, 163, 02693 164, 165, 166, 167, 168, 169, 170, 0, 0, 171, 02694 172, 0, 0, 173, 174, 175, 176, 0, 0, 0, 02695 0, 0, 0, 0, 0, 0, 0, 177, 178, 0, 02696 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02697 0, 0, 0, 0, 0, 0, 0, 0, 179, 180, 02698 181, 182, 183, 184, 185, 186, 187, 188, 0, 189, 02699 190, 0, 0, 0, 0, 0, 0, 191, 118, 119, 02700 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 02701 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 02702 140, 141, 0, 0, 0, 142, 143, 144, 145, 146, 02703 147, 148, 149, 150, 151, 0, 0, 0, 0, 0, 02704 152, 153, 154, 155, 156, 157, 158, 159, 160, 233, 02705 0, 161, 0, 0, 0, 0, 0, 0, 0, 0, 02706 0, 162, 163, 164, 165, 166, 167, 168, 169, 170, 02707 0, 0, 171, 172, 0, 0, 173, 174, 175, 176, 02708 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02709 177, 178, 0, 0, 55, 0, 0, 0, 0, 0, 02710 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02711 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, 02712 188, 0, 189, 190, 0, 0, 0, 0, 0, 0, 02713 191, 118, 119, 120, 121, 122, 123, 124, 125, 126, 02714 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 02715 137, 138, 139, 140, 141, 0, 0, 0, 142, 143, 02716 144, 145, 146, 147, 148, 149, 150, 151, 0, 0, 02717 0, 0, 0, 152, 153, 154, 155, 156, 157, 158, 02718 159, 160, 0, 0, 161, 0, 0, 0, 0, 0, 02719 0, 0, 0, 0, 162, 163, 164, 165, 166, 167, 02720 168, 169, 170, 0, 0, 171, 172, 0, 0, 173, 02721 174, 175, 176, 0, 0, 0, 0, 0, 0, 0, 02722 0, 0, 0, 177, 178, 0, 0, 55, 0, 0, 02723 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02724 0, 0, 0, 0, 179, 180, 181, 182, 183, 184, 02725 185, 186, 187, 188, 0, 189, 190, 0, 0, 0, 02726 0, 0, 0, 191, 118, 119, 120, 121, 122, 123, 02727 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 02728 134, 135, 136, 137, 138, 139, 140, 141, 0, 0, 02729 0, 142, 143, 144, 145, 146, 147, 148, 149, 150, 02730 151, 0, 0, 0, 0, 0, 152, 153, 154, 155, 02731 156, 157, 158, 159, 160, 0, 0, 161, 0, 0, 02732 0, 0, 0, 0, 0, 0, 0, 162, 163, 164, 02733 165, 166, 167, 168, 169, 170, 0, 0, 171, 172, 02734 0, 0, 173, 174, 175, 176, 0, 0, 0, 0, 02735 0, 0, 0, 0, 0, 0, 177, 178, 0, 0, 02736 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02737 0, 0, 0, 0, 0, 0, 0, 179, 180, 181, 02738 182, 183, 184, 185, 186, 187, 188, 0, 189, 190, 02739 5, 6, 7, 0, 9, 0, 191, 0, 10, 11, 02740 0, 0, 0, 12, 0, 13, 14, 15, 238, 239, 02741 18, 19, 0, 0, 0, 0, 0, 240, 241, 242, 02742 23, 24, 25, 26, 0, 0, 200, 0, 0, 0, 02743 0, 0, 0, 268, 0, 0, 32, 33, 34, 35, 02744 36, 37, 38, 39, 40, 0, 41, 42, 0, 43, 02745 44, 45, 0, 0, 0, 0, 0, 0, 0, 0, 02746 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02747 0, 0, 0, 269, 0, 0, 203, 50, 0, 51, 02748 52, 0, 0, 0, 0, 54, 55, 56, 57, 58, 02749 59, 60, 61, 62, 0, 0, 0, 0, 0, 5, 02750 6, 7, 0, 9, 0, 0, 0, 10, 11, 0, 02751 0, 0, 12, 270, 13, 14, 15, 238, 239, 18, 02752 19, 271, 0, 0, 0, 0, 240, 241, 242, 23, 02753 24, 25, 26, 0, 0, 200, 0, 0, 0, 0, 02754 0, 0, 268, 0, 0, 32, 33, 34, 35, 36, 02755 37, 38, 39, 40, 0, 41, 42, 0, 43, 44, 02756 45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02757 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02758 0, 0, 269, 0, 0, 203, 50, 0, 51, 52, 02759 0, 0, 0, 0, 54, 55, 56, 57, 58, 59, 02760 60, 61, 62, 0, 0, 0, 0, 0, 5, 6, 02761 7, 8, 9, 0, 0, 0, 10, 11, 0, 0, 02762 0, 12, 270, 13, 14, 15, 16, 17, 18, 19, 02763 518, 0, 0, 0, 0, 20, 21, 22, 23, 24, 02764 25, 26, 0, 0, 27, 0, 0, 0, 0, 0, 02765 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 02766 38, 39, 40, 0, 41, 42, 0, 43, 44, 45, 02767 0, 46, 47, 0, 0, 0, 0, 0, 0, 0, 02768 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02769 0, 48, 0, 0, 49, 50, 0, 51, 52, 0, 02770 53, 0, 0, 54, 55, 56, 57, 58, 59, 60, 02771 61, 62, 0, 0, 0, 0, 0, 0, 0, 0, 02772 0, 5, 6, 7, 0, 9, 0, 0, 0, 10, 02773 11, 63, 64, 65, 12, 0, 13, 14, 15, 16, 02774 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, 02775 22, 23, 24, 25, 26, 0, 0, 200, 0, 0, 02776 0, 0, 0, 0, 29, 0, 0, 32, 33, 34, 02777 35, 36, 37, 38, 39, 40, 201, 41, 42, 0, 02778 43, 44, 45, 0, 46, 47, 0, 0, 0, 0, 02779 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02780 0, 0, 0, 0, 202, 0, 0, 203, 50, 0, 02781 51, 52, 0, 204, 205, 206, 54, 55, 56, 57, 02782 58, 59, 60, 61, 62, 0, 0, 0, 0, 0, 02783 0, 0, 0, 0, 5, 6, 7, 8, 9, 0, 02784 0, 0, 10, 11, 63, 207, 65, 12, 0, 13, 02785 14, 15, 16, 17, 18, 19, 0, 0, 0, 0, 02786 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, 02787 27, 0, 0, 0, 0, 0, 28, 29, 0, 31, 02788 32, 33, 34, 35, 36, 37, 38, 39, 40, 0, 02789 41, 42, 0, 43, 44, 45, 0, 46, 47, 0, 02790 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02791 0, 0, 0, 0, 0, 0, 0, 48, 0, 0, 02792 49, 50, 0, 51, 52, 0, 53, 0, 0, 54, 02793 55, 56, 57, 58, 59, 60, 61, 62, 0, 0, 02794 0, 0, 0, 0, 0, 0, 0, 5, 6, 7, 02795 0, 9, 0, 0, 0, 10, 11, 63, 64, 65, 02796 12, 0, 13, 14, 15, 238, 239, 18, 19, 0, 02797 0, 0, 0, 0, 240, 241, 242, 23, 24, 25, 02798 26, 0, 0, 200, 0, 0, 0, 0, 0, 0, 02799 29, 0, 0, 32, 33, 34, 35, 36, 37, 38, 02800 39, 40, 201, 41, 42, 0, 43, 44, 45, 0, 02801 46, 47, 0, 0, 0, 0, 0, 0, 0, 0, 02802 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02803 202, 0, 0, 203, 50, 0, 51, 52, 0, 608, 02804 205, 206, 54, 55, 56, 57, 58, 59, 60, 61, 02805 62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02806 5, 6, 7, 0, 9, 0, 0, 0, 10, 11, 02807 63, 207, 65, 12, 0, 13, 14, 15, 238, 239, 02808 18, 19, 0, 0, 0, 0, 0, 240, 241, 242, 02809 23, 24, 25, 26, 0, 0, 200, 0, 0, 0, 02810 0, 0, 0, 29, 0, 0, 32, 33, 34, 35, 02811 36, 37, 38, 39, 40, 201, 41, 42, 0, 43, 02812 44, 45, 0, 46, 47, 0, 0, 0, 0, 0, 02813 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02814 0, 0, 0, 202, 0, 0, 203, 50, 0, 51, 02815 52, 0, 204, 205, 0, 54, 55, 56, 57, 58, 02816 59, 60, 61, 62, 0, 0, 0, 0, 0, 0, 02817 0, 0, 0, 5, 6, 7, 0, 9, 0, 0, 02818 0, 10, 11, 63, 207, 65, 12, 0, 13, 14, 02819 15, 238, 239, 18, 19, 0, 0, 0, 0, 0, 02820 240, 241, 242, 23, 24, 25, 26, 0, 0, 200, 02821 0, 0, 0, 0, 0, 0, 29, 0, 0, 32, 02822 33, 34, 35, 36, 37, 38, 39, 40, 201, 41, 02823 42, 0, 43, 44, 45, 0, 46, 47, 0, 0, 02824 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02825 0, 0, 0, 0, 0, 0, 202, 0, 0, 203, 02826 50, 0, 51, 52, 0, 0, 205, 206, 54, 55, 02827 56, 57, 58, 59, 60, 61, 62, 0, 0, 0, 02828 0, 0, 0, 0, 0, 0, 5, 6, 7, 0, 02829 9, 0, 0, 0, 10, 11, 63, 207, 65, 12, 02830 0, 13, 14, 15, 238, 239, 18, 19, 0, 0, 02831 0, 0, 0, 240, 241, 242, 23, 24, 25, 26, 02832 0, 0, 200, 0, 0, 0, 0, 0, 0, 29, 02833 0, 0, 32, 33, 34, 35, 36, 37, 38, 39, 02834 40, 201, 41, 42, 0, 43, 44, 45, 0, 46, 02835 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02836 0, 0, 0, 0, 0, 0, 0, 0, 0, 202, 02837 0, 0, 203, 50, 0, 51, 52, 0, 608, 205, 02838 0, 54, 55, 56, 57, 58, 59, 60, 61, 62, 02839 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 02840 6, 7, 0, 9, 0, 0, 0, 10, 11, 63, 02841 207, 65, 12, 0, 13, 14, 15, 238, 239, 18, 02842 19, 0, 0, 0, 0, 0, 240, 241, 242, 23, 02843 24, 25, 26, 0, 0, 200, 0, 0, 0, 0, 02844 0, 0, 29, 0, 0, 32, 33, 34, 35, 36, 02845 37, 38, 39, 40, 201, 41, 42, 0, 43, 44, 02846 45, 0, 46, 47, 0, 0, 0, 0, 0, 0, 02847 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02848 0, 0, 202, 0, 0, 203, 50, 0, 51, 52, 02849 0, 0, 205, 0, 54, 55, 56, 57, 58, 59, 02850 60, 61, 62, 0, 0, 0, 0, 0, 0, 0, 02851 0, 0, 5, 6, 7, 0, 9, 0, 0, 0, 02852 10, 11, 63, 207, 65, 12, 0, 13, 14, 15, 02853 16, 17, 18, 19, 0, 0, 0, 0, 0, 20, 02854 21, 22, 23, 24, 25, 26, 0, 0, 200, 0, 02855 0, 0, 0, 0, 0, 29, 0, 0, 32, 33, 02856 34, 35, 36, 37, 38, 39, 40, 0, 41, 42, 02857 0, 43, 44, 45, 0, 46, 47, 0, 0, 0, 02858 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02859 0, 0, 0, 0, 0, 202, 0, 0, 203, 50, 02860 0, 51, 52, 0, 512, 0, 0, 54, 55, 56, 02861 57, 58, 59, 60, 61, 62, 0, 0, 0, 0, 02862 0, 0, 0, 0, 0, 5, 6, 7, 0, 9, 02863 0, 0, 0, 10, 11, 63, 207, 65, 12, 0, 02864 13, 14, 15, 238, 239, 18, 19, 0, 0, 0, 02865 0, 0, 240, 241, 242, 23, 24, 25, 26, 0, 02866 0, 200, 0, 0, 0, 0, 0, 0, 29, 0, 02867 0, 32, 33, 34, 35, 36, 37, 38, 39, 40, 02868 0, 41, 42, 0, 43, 44, 45, 0, 46, 47, 02869 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02870 0, 0, 0, 0, 0, 0, 0, 0, 202, 0, 02871 0, 203, 50, 0, 51, 52, 0, 204, 0, 0, 02872 54, 55, 56, 57, 58, 59, 60, 61, 62, 0, 02873 0, 0, 0, 0, 0, 0, 0, 0, 5, 6, 02874 7, 0, 9, 0, 0, 0, 10, 11, 63, 207, 02875 65, 12, 0, 13, 14, 15, 238, 239, 18, 19, 02876 0, 0, 0, 0, 0, 240, 241, 242, 23, 24, 02877 25, 26, 0, 0, 200, 0, 0, 0, 0, 0, 02878 0, 29, 0, 0, 32, 33, 34, 35, 36, 37, 02879 38, 39, 40, 0, 41, 42, 0, 43, 44, 45, 02880 0, 46, 47, 0, 0, 0, 0, 0, 0, 0, 02881 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02882 0, 202, 0, 0, 203, 50, 0, 51, 52, 0, 02883 817, 0, 0, 54, 55, 56, 57, 58, 59, 60, 02884 61, 62, 0, 0, 0, 0, 0, 0, 0, 0, 02885 0, 5, 6, 7, 0, 9, 0, 0, 0, 10, 02886 11, 63, 207, 65, 12, 0, 13, 14, 15, 238, 02887 239, 18, 19, 0, 0, 0, 0, 0, 240, 241, 02888 242, 23, 24, 25, 26, 0, 0, 200, 0, 0, 02889 0, 0, 0, 0, 29, 0, 0, 32, 33, 34, 02890 35, 36, 37, 38, 39, 40, 0, 41, 42, 0, 02891 43, 44, 45, 0, 46, 47, 0, 0, 0, 0, 02892 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02893 0, 0, 0, 0, 202, 0, 0, 203, 50, 0, 02894 51, 52, 0, 512, 0, 0, 54, 55, 56, 57, 02895 58, 59, 60, 61, 62, 0, 0, 0, 0, 0, 02896 0, 0, 0, 0, 5, 6, 7, 0, 9, 0, 02897 0, 0, 10, 11, 63, 207, 65, 12, 0, 13, 02898 14, 15, 238, 239, 18, 19, 0, 0, 0, 0, 02899 0, 240, 241, 242, 23, 24, 25, 26, 0, 0, 02900 200, 0, 0, 0, 0, 0, 0, 29, 0, 0, 02901 32, 33, 34, 35, 36, 37, 38, 39, 40, 0, 02902 41, 42, 0, 43, 44, 45, 0, 46, 47, 0, 02903 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02904 0, 0, 0, 0, 0, 0, 0, 202, 0, 0, 02905 203, 50, 0, 51, 52, 0, 608, 0, 0, 54, 02906 55, 56, 57, 58, 59, 60, 61, 62, 0, 0, 02907 0, 0, 0, 0, 0, 0, 0, 5, 6, 7, 02908 0, 9, 0, 0, 0, 10, 11, 63, 207, 65, 02909 12, 0, 13, 14, 15, 238, 239, 18, 19, 0, 02910 0, 0, 0, 0, 240, 241, 242, 23, 24, 25, 02911 26, 0, 0, 200, 0, 0, 0, 0, 0, 0, 02912 29, 0, 0, 32, 33, 34, 35, 36, 37, 38, 02913 39, 40, 0, 41, 42, 0, 43, 44, 45, 0, 02914 46, 47, 0, 0, 0, 0, 0, 0, 0, 0, 02915 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02916 202, 0, 0, 203, 50, 0, 51, 52, 0, 0, 02917 0, 0, 54, 55, 56, 57, 58, 59, 60, 61, 02918 62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02919 5, 6, 7, 0, 9, 0, 0, 0, 10, 11, 02920 63, 207, 65, 12, 0, 13, 14, 15, 16, 17, 02921 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, 02922 23, 24, 25, 26, 0, 0, 200, 0, 0, 0, 02923 0, 0, 0, 29, 0, 0, 32, 33, 34, 35, 02924 36, 37, 38, 39, 40, 0, 41, 42, 0, 43, 02925 44, 45, 0, 46, 47, 0, 0, 0, 0, 0, 02926 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02927 0, 0, 0, 202, 0, 0, 203, 50, 0, 51, 02928 52, 0, 0, 0, 0, 54, 55, 56, 57, 58, 02929 59, 60, 61, 62, 0, 0, 0, 0, 0, 0, 02930 0, 0, 0, 5, 6, 7, 0, 9, 0, 0, 02931 0, 10, 11, 63, 207, 65, 12, 0, 13, 14, 02932 15, 16, 17, 18, 19, 0, 0, 0, 0, 0, 02933 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 02934 0, 0, 0, 0, 0, 0, 29, 0, 0, 32, 02935 33, 34, 35, 36, 37, 38, 39, 40, 0, 41, 02936 42, 0, 43, 44, 45, 0, 46, 47, 0, 0, 02937 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02938 0, 0, 0, 0, 0, 0, 202, 0, 0, 203, 02939 50, 0, 51, 52, 0, 0, 0, 0, 54, 55, 02940 56, 57, 58, 59, 60, 61, 62, 0, 0, 0, 02941 0, 0, 0, 0, 0, 0, 5, 6, 7, 0, 02942 9, 0, 0, 0, 10, 11, 63, 64, 65, 12, 02943 0, 13, 14, 15, 238, 239, 18, 19, 0, 0, 02944 0, 0, 0, 240, 241, 242, 23, 24, 25, 26, 02945 0, 0, 200, 0, 0, 0, 0, 0, 0, 268, 02946 0, 0, 32, 33, 34, 35, 36, 37, 38, 39, 02947 40, 0, 41, 42, 0, 43, 44, 45, 0, 0, 02948 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02949 0, 0, 0, 0, 0, 0, 0, 0, 0, 269, 02950 0, 0, 323, 50, 0, 51, 52, 0, 324, 0, 02951 0, 54, 55, 56, 57, 58, 59, 60, 61, 62, 02952 0, 0, 0, 0, 0, 5, 6, 7, 0, 9, 02953 0, 0, 0, 10, 11, 0, 0, 0, 12, 270, 02954 13, 14, 15, 238, 239, 18, 19, 0, 0, 0, 02955 0, 0, 240, 241, 242, 23, 24, 25, 26, 0, 02956 0, 200, 0, 0, 0, 0, 0, 0, 268, 0, 02957 0, 32, 33, 34, 35, 36, 37, 38, 39, 40, 02958 0, 41, 42, 0, 43, 44, 45, 0, 0, 0, 02959 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02960 0, 0, 0, 0, 0, 0, 0, 0, 365, 0, 02961 0, 49, 50, 0, 51, 52, 0, 53, 0, 0, 02962 54, 55, 56, 57, 58, 59, 60, 61, 62, 0, 02963 0, 0, 0, 0, 5, 6, 7, 0, 9, 0, 02964 0, 0, 10, 11, 0, 0, 0, 12, 270, 13, 02965 14, 15, 238, 239, 18, 19, 0, 0, 0, 0, 02966 0, 240, 241, 242, 23, 24, 25, 26, 0, 0, 02967 200, 0, 0, 0, 0, 0, 0, 268, 0, 0, 02968 32, 33, 34, 373, 36, 37, 38, 374, 40, 0, 02969 41, 42, 0, 43, 44, 45, 0, 0, 0, 0, 02970 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02971 0, 0, 0, 0, 375, 0, 0, 376, 0, 0, 02972 203, 50, 0, 51, 52, 0, 0, 0, 0, 54, 02973 55, 56, 57, 58, 59, 60, 61, 62, 0, 0, 02974 0, 0, 0, 5, 6, 7, 0, 9, 0, 0, 02975 0, 10, 11, 0, 0, 0, 12, 270, 13, 14, 02976 15, 238, 239, 18, 19, 0, 0, 0, 0, 0, 02977 240, 241, 242, 23, 24, 25, 26, 0, 0, 200, 02978 0, 0, 0, 0, 0, 0, 268, 0, 0, 32, 02979 33, 34, 373, 36, 37, 38, 374, 40, 0, 41, 02980 42, 0, 43, 44, 45, 0, 0, 0, 0, 0, 02981 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02982 0, 0, 0, 0, 0, 0, 376, 0, 0, 203, 02983 50, 0, 51, 52, 0, 0, 0, 0, 54, 55, 02984 56, 57, 58, 59, 60, 61, 62, 0, 0, 0, 02985 0, 0, 5, 6, 7, 0, 9, 0, 0, 0, 02986 10, 11, 0, 0, 0, 12, 270, 13, 14, 15, 02987 238, 239, 18, 19, 0, 0, 0, 0, 0, 240, 02988 241, 242, 23, 24, 25, 26, 0, 0, 200, 0, 02989 0, 0, 0, 0, 0, 268, 0, 0, 32, 33, 02990 34, 35, 36, 37, 38, 39, 40, 0, 41, 42, 02991 0, 43, 44, 45, 0, 0, 0, 0, 0, 0, 02992 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 02993 0, 0, 0, 0, 0, 269, 0, 0, 323, 50, 02994 0, 51, 52, 0, 0, 0, 0, 54, 55, 56, 02995 57, 58, 59, 60, 61, 62, 0, 0, 0, 0, 02996 0, 5, 6, 7, 0, 9, 0, 0, 0, 10, 02997 11, 0, 0, 0, 12, 270, 13, 14, 15, 238, 02998 239, 18, 19, 0, 0, 0, 0, 0, 240, 241, 02999 242, 23, 24, 25, 26, 0, 0, 200, 0, 0, 03000 0, 0, 0, 0, 268, 0, 0, 32, 33, 34, 03001 35, 36, 37, 38, 39, 40, 0, 41, 42, 0, 03002 43, 44, 45, 0, 0, 0, 0, 0, 0, 0, 03003 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03004 0, 0, 0, 0, 894, 0, 0, 203, 50, 0, 03005 51, 52, 0, 0, 0, 0, 54, 55, 56, 57, 03006 58, 59, 60, 61, 62, 0, 0, 0, 0, 0, 03007 5, 6, 7, 0, 9, 0, 0, 0, 10, 11, 03008 0, 0, 0, 12, 270, 13, 14, 15, 238, 239, 03009 18, 19, 0, 0, 0, 0, 0, 240, 241, 242, 03010 23, 24, 25, 26, 0, 0, 200, 0, 0, 0, 03011 0, 0, 0, 268, 0, 0, 32, 33, 34, 35, 03012 36, 37, 38, 39, 40, 0, 41, 42, 0, 43, 03013 44, 45, 0, 0, 0, 0, 0, 0, 0, 0, 03014 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03015 0, 0, 0, 974, 0, 0, 203, 50, 0, 51, 03016 52, 0, 0, 0, 0, 54, 55, 56, 57, 58, 03017 59, 60, 61, 62, 0, 0, 0, 0, 0, 0, 03018 561, 562, 0, 0, 563, 0, 0, 0, 0, 0, 03019 0, 0, 0, 270, 162, 163, 164, 165, 166, 167, 03020 168, 169, 170, 0, 0, 171, 172, 0, 0, 173, 03021 174, 175, 176, 0, 0, 0, 0, 0, 0, 0, 03022 0, 0, 0, 177, 178, 0, 0, 0, 0, 0, 03023 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03024 0, 0, 0, 0, 179, 180, 181, 182, 183, 184, 03025 185, 186, 187, 188, 0, 189, 190, 598, 562, 0, 03026 0, 599, 0, 191, 0, 0, 0, 0, 0, 0, 03027 0, 162, 163, 164, 165, 166, 167, 168, 169, 170, 03028 0, 0, 171, 172, 0, 0, 173, 174, 175, 176, 03029 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03030 177, 178, 0, 0, 0, 0, 0, 0, 0, 0, 03031 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03032 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, 03033 188, 0, 189, 190, 612, 554, 0, 0, 613, 0, 03034 191, 0, 0, 0, 0, 0, 0, 0, 162, 163, 03035 164, 165, 166, 167, 168, 169, 170, 0, 0, 171, 03036 172, 0, 0, 173, 174, 175, 176, 0, 0, 0, 03037 0, 0, 0, 0, 0, 0, 0, 177, 178, 0, 03038 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03039 0, 0, 0, 0, 0, 0, 0, 0, 179, 180, 03040 181, 182, 183, 184, 185, 186, 187, 188, 0, 189, 03041 190, 615, 562, 0, 0, 616, 0, 191, 0, 0, 03042 0, 0, 0, 0, 0, 162, 163, 164, 165, 166, 03043 167, 168, 169, 170, 0, 0, 171, 172, 0, 0, 03044 173, 174, 175, 176, 0, 0, 0, 0, 0, 0, 03045 0, 0, 0, 0, 177, 178, 0, 0, 0, 0, 03046 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03047 0, 0, 0, 0, 0, 179, 180, 181, 182, 183, 03048 184, 185, 186, 187, 188, 0, 189, 190, 639, 554, 03049 0, 0, 640, 0, 191, 0, 0, 0, 0, 0, 03050 0, 0, 162, 163, 164, 165, 166, 167, 168, 169, 03051 170, 0, 0, 171, 172, 0, 0, 173, 174, 175, 03052 176, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03053 0, 177, 178, 0, 0, 0, 0, 0, 0, 0, 03054 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03055 0, 0, 179, 180, 181, 182, 183, 184, 185, 186, 03056 187, 188, 0, 189, 190, 642, 562, 0, 0, 643, 03057 0, 191, 0, 0, 0, 0, 0, 0, 0, 162, 03058 163, 164, 165, 166, 167, 168, 169, 170, 0, 0, 03059 171, 172, 0, 0, 173, 174, 175, 176, 0, 0, 03060 0, 0, 0, 0, 0, 0, 0, 0, 177, 178, 03061 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03062 0, 0, 0, 0, 0, 0, 0, 0, 0, 179, 03063 180, 181, 182, 183, 184, 185, 186, 187, 188, 0, 03064 189, 190, 727, 554, 0, 0, 728, 0, 191, 0, 03065 0, 0, 0, 0, 0, 0, 162, 163, 164, 165, 03066 166, 167, 168, 169, 170, 0, 0, 171, 172, 0, 03067 0, 173, 174, 175, 176, 0, 0, 0, 0, 0, 03068 0, 0, 0, 0, 0, 177, 178, 0, 0, 0, 03069 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03070 0, 0, 0, 0, 0, 0, 179, 180, 181, 182, 03071 183, 184, 185, 186, 187, 188, 0, 189, 190, 730, 03072 562, 0, 0, 731, 0, 191, 0, 0, 0, 0, 03073 0, 0, 0, 162, 163, 164, 165, 166, 167, 168, 03074 169, 170, 0, 0, 171, 172, 0, 0, 173, 174, 03075 175, 176, 0, 0, 0, 0, 0, 0, 0, 0, 03076 0, 0, 177, 178, 0, 0, 0, 0, 0, 0, 03077 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03078 0, 0, 0, 179, 180, 181, 182, 183, 184, 185, 03079 186, 187, 188, 0, 189, 190, 737, 554, 0, 0, 03080 738, 0, 191, 0, 0, 0, 0, 0, 0, 0, 03081 162, 163, 164, 165, 166, 167, 168, 169, 170, 0, 03082 0, 171, 172, 0, 0, 173, 174, 175, 176, 0, 03083 0, 0, 0, 0, 0, 0, 0, 0, 0, 177, 03084 178, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03085 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03086 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 03087 0, 189, 190, 1002, 554, 0, 0, 1003, 0, 191, 03088 0, 0, 0, 0, 0, 0, 0, 162, 163, 164, 03089 165, 166, 167, 168, 169, 170, 0, 0, 171, 172, 03090 0, 0, 173, 174, 175, 176, 0, 0, 0, 0, 03091 0, 0, 0, 0, 0, 0, 177, 178, 0, 0, 03092 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03093 0, 0, 0, 0, 0, 0, 0, 179, 180, 181, 03094 182, 183, 184, 185, 186, 187, 188, 0, 189, 190, 03095 1037, 554, 0, 0, 1038, 0, 191, 0, 0, 0, 03096 0, 0, 0, 0, 162, 163, 164, 165, 166, 167, 03097 168, 169, 170, 0, 0, 171, 172, 0, 0, 173, 03098 174, 175, 176, 0, 0, 0, 0, 0, 0, 0, 03099 0, 0, 0, 177, 178, 0, 0, 0, 0, 0, 03100 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03101 0, 0, 0, 0, 179, 180, 181, 182, 183, 184, 03102 185, 186, 187, 188, 0, 189, 190, 1040, 562, 0, 03103 0, 1041, 0, 191, 0, 0, 0, 0, 0, 0, 03104 0, 162, 163, 164, 165, 166, 167, 168, 169, 170, 03105 0, 0, 171, 172, 0, 0, 173, 174, 175, 176, 03106 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03107 177, 178, 0, 0, 0, 0, 0, 0, 0, 0, 03108 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 03109 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, 03110 188, 0, 189, 190, 0, 0, 0, 0, 0, 0, 03111 191 03112 }; 03113 03114 #define yypact_value_is_default(yystate) \ 03115 ((yystate) == (-808)) 03116 03117 #define yytable_value_is_error(yytable_value) \ 03118 ((yytable_value) == (-621)) 03119 03120 static const yytype_int16 yycheck[] = 03121 { 03122 2, 87, 55, 96, 90, 353, 79, 355, 472, 16, 03123 17, 22, 359, 20, 354, 326, 614, 2, 8, 4, 03124 16, 17, 8, 28, 20, 326, 412, 27, 49, 29, 03125 74, 4, 220, 53, 420, 86, 87, 420, 28, 90, 03126 575, 94, 28, 641, 594, 49, 668, 685, 574, 51, 03127 52, 399, 468, 67, 262, 51, 779, 472, 266, 79, 03128 53, 376, 508, 74, 90, 511, 2, 415, 4, 417, 03129 715, 91, 92, 93, 719, 458, 416, 440, 25, 787, 03130 16, 17, 25, 13, 20, 16, 17, 13, 67, 20, 03131 875, 26, 25, 27, 873, 443, 903, 250, 37, 38, 03132 58, 29, 518, 16, 17, 64, 8, 20, 68, 87, 03133 68, 90, 777, 49, 139, 113, 141, 53, 85, 61, 03134 51, 52, 13, 471, 907, 25, 28, 76, 64, 61, 03135 470, 729, 596, 651, 0, 113, 134, 802, 96, 97, 03136 85, 779, 740, 79, 286, 15, 288, 17, 290, 787, 03137 86, 87, 294, 55, 90, 91, 92, 93, 141, 13, 03138 939, 25, 120, 123, 124, 125, 133, 26, 110, 118, 03139 323, 13, 25, 25, 25, 898, 59, 60, 110, 230, 03140 25, 232, 203, 111, 806, 807, 736, 134, 133, 13, 03141 130, 134, 94, 657, 744, 130, 56, 1004, 271, 243, 03142 1, 134, 141, 136, 134, 139, 991, 141, 259, 139, 03143 136, 141, 214, 139, 993, 141, 237, 224, 220, 226, 03144 227, 307, 308, 309, 310, 227, 252, 950, 224, 250, 03145 226, 1014, 25, 581, 134, 621, 622, 945, 252, 622, 03146 580, 429, 657, 140, 690, 593, 250, 1026, 139, 25, 03147 141, 271, 592, 771, 772, 140, 307, 308, 309, 310, 03148 898, 312, 313, 248, 886, 903, 140, 203, 268, 632, 03149 134, 130, 136, 252, 360, 361, 591, 136, 230, 743, 03150 696, 134, 134, 134, 929, 139, 1009, 141, 224, 134, 03151 226, 227, 87, 224, 230, 226, 232, 139, 670, 141, 03152 672, 237, 323, 255, 324, 61, 258, 945, 85, 360, 03153 361, 224, 248, 226, 250, 139, 117, 141, 113, 323, 03154 113, 306, 134, 259, 375, 321, 311, 853, 743, 141, 03155 326, 324, 85, 306, 85, 271, 362, 113, 139, 134, 03156 141, 134, 964, 485, 137, 61, 140, 354, 141, 65, 03157 492, 107, 354, 109, 26, 873, 133, 875, 134, 37, 03158 38, 137, 321, 85, 85, 141, 1004, 326, 85, 97, 03159 306, 307, 308, 309, 310, 311, 312, 313, 725, 132, 03160 133, 931, 133, 362, 140, 321, 85, 323, 324, 85, 03161 326, 107, 120, 109, 929, 468, 697, 59, 60, 378, 03162 28, 85, 52, 714, 54, 55, 56, 57, 61, 416, 03163 132, 133, 133, 85, 416, 2, 133, 4, 354, 26, 03164 356, 939, 940, 611, 360, 361, 428, 429, 636, 16, 03165 17, 87, 437, 20, 133, 703, 132, 133, 440, 375, 03166 990, 1039, 710, 402, 403, 518, 85, 437, 468, 133, 03167 87, 437, 134, 355, 107, 440, 109, 113, 130, 141, 03168 132, 133, 49, 470, 136, 113, 402, 403, 470, 85, 03169 422, 134, 936, 991, 426, 993, 113, 64, 85, 431, 03170 416, 412, 868, 68, 134, 868, 52, 140, 54, 55, 03171 56, 57, 113, 132, 133, 447, 87, 399, 518, 86, 03172 87, 87, 85, 90, 440, 507, 508, 87, 1026, 511, 03173 100, 883, 884, 557, 450, 417, 888, 133, 890, 891, 03174 87, 565, 113, 130, 455, 132, 133, 113, 87, 136, 03175 134, 87, 468, 113, 470, 437, 121, 122, 123, 124, 03176 125, 443, 542, 134, 595, 87, 113, 558, 58, 570, 03177 133, 572, 54, 87, 85, 566, 600, 113, 68, 85, 03178 560, 63, 64, 136, 637, 517, 568, 134, 134, 471, 03179 917, 113, 760, 580, 625, 56, 923, 134, 580, 113, 03180 576, 113, 518, 61, 141, 592, 96, 97, 88, 600, 03181 592, 136, 134, 26, 573, 574, 141, 134, 600, 137, 03182 605, 132, 133, 141, 87, 136, 132, 133, 587, 611, 03183 120, 14, 15, 134, 614, 605, 203, 637, 136, 605, 03184 52, 130, 87, 696, 56, 997, 998, 999, 1000, 107, 03185 632, 109, 110, 136, 570, 136, 572, 224, 68, 226, 03186 227, 641, 137, 230, 580, 232, 732, 632, 113, 735, 03187 237, 113, 85, 138, 131, 748, 592, 85, 594, 595, 03188 704, 248, 61, 250, 666, 686, 668, 711, 689, 134, 03189 691, 1019, 259, 56, 134, 1047, 696, 68, 1018, 581, 03190 68, 732, 94, 635, 735, 685, 110, 110, 690, 625, 03191 621, 593, 110, 746, 110, 134, 632, 130, 85, 132, 03192 133, 637, 139, 605, 132, 133, 17, 56, 107, 711, 03193 109, 110, 714, 715, 134, 717, 25, 719, 714, 306, 03194 307, 308, 309, 310, 311, 312, 313, 26, 68, 729, 03195 61, 577, 137, 134, 321, 131, 323, 130, 697, 326, 03196 740, 700, 701, 83, 84, 132, 133, 10, 707, 708, 03197 686, 140, 134, 689, 733, 691, 134, 843, 760, 85, 03198 696, 697, 134, 140, 700, 701, 745, 354, 134, 356, 03199 85, 707, 708, 360, 361, 87, 107, 777, 109, 110, 03200 800, 121, 122, 123, 124, 125, 85, 52, 375, 134, 03201 742, 113, 843, 85, 815, 68, 732, 136, 8, 735, 03202 736, 113, 802, 131, 806, 807, 132, 133, 744, 761, 03203 83, 84, 13, 61, 134, 402, 403, 132, 133, 840, 03204 61, 134, 134, 775, 113, 52, 847, 848, 134, 416, 03205 851, 130, 134, 132, 133, 52, 838, 136, 134, 841, 03206 132, 133, 15, 52, 746, 118, 119, 120, 121, 122, 03207 123, 124, 125, 440, 85, 134, 115, 878, 879, 107, 03208 138, 109, 110, 450, 800, 134, 107, 131, 109, 110, 03209 829, 892, 134, 893, 853, 113, 855, 85, 724, 815, 03210 134, 85, 118, 470, 886, 134, 16, 17, 54, 55, 03211 20, 57, 134, 829, 134, 741, 916, 63, 64, 920, 03212 139, 132, 133, 10, 840, 87, 131, 843, 860, 10, 03213 134, 847, 848, 685, 88, 851, 46, 47, 9, 685, 03214 872, 51, 52, 134, 132, 133, 118, 929, 132, 133, 03215 137, 113, 134, 56, 64, 65, 201, 134, 134, 204, 03216 205, 206, 878, 879, 52, 134, 54, 55, 56, 57, 03217 58, 131, 134, 134, 10, 134, 892, 893, 108, 980, 03218 68, 982, 964, 131, 134, 134, 56, 988, 450, 134, 03219 970, 134, 134, 134, 685, 68, 136, 136, 134, 91, 03220 916, 89, 93, 570, 920, 572, 711, 1021, 96, 97, 03221 83, 84, 771, 580, 685, 931, 1014, 749, 844, 52, 03222 846, 54, 55, 56, 57, 592, 294, 594, 595, 781, 03223 856, 1018, 120, 785, 1020, 861, 1018, 99, 1020, 1021, 03224 57, 787, 94, 781, 790, 936, 898, 120, 121, 122, 03225 123, 124, 125, 900, 779, 396, 89, -1, 625, 1039, 03226 -1, -1, 95, -1, 980, 632, 982, 40, 41, 42, 03227 43, 44, 988, -1, 990, 52, 321, 54, 55, 56, 03228 57, 326, -1, 52, -1, 54, 55, 56, 57, -1, 03229 781, 201, -1, -1, 204, 205, 206, 207, -1, -1, 03230 926, 927, 1018, 2, 52, 4, 54, 55, 56, 57, 03231 -1, -1, 89, -1, 224, -1, 226, 227, 95, 686, 03232 89, -1, 689, -1, 691, -1, -1, -1, -1, -1, 03233 697, -1, -1, 700, 701, -1, -1, 1019, -1, -1, 03234 707, 708, -1, -1, -1, -1, 898, -1, 900, -1, 03235 49, 903, -1, 905, 53, -1, -1, 903, -1, 905, 03236 -1, -1, -1, 989, -1, 732, 411, 412, 735, 736, 03237 -1, -1, -1, -1, -1, 420, -1, 744, -1, -1, 03238 79, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03239 -1, -1, 91, 92, 93, 94, 1022, -1, 1024, 945, 03240 -1, 947, -1, 809, 810, -1, 952, 898, -1, 900, 03241 455, 321, 903, 458, 905, -1, 326, 327, 328, 329, 03242 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 03243 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 03244 350, 351, 352, -1, 354, -1, -1, -1, 815, -1, 03245 -1, -1, 1004, -1, 1006, -1, -1, 1009, 1004, 1011, 03246 1006, -1, 829, -1, -1, 1011, -1, 512, -1, -1, 03247 -1, -1, -1, 840, -1, -1, 843, -1, -1, -1, 03248 847, 848, 1028, -1, 851, -1, -1, -1, -1, -1, 03249 -1, -1, 402, 403, -1, -1, -1, 1049, -1, -1, 03250 410, 411, 412, 1049, 203, -1, 416, -1, 418, 419, 03251 420, 878, 879, 1004, -1, 1006, -1, -1, 1009, -1, 03252 1011, -1, -1, -1, -1, 892, -1, -1, -1, 439, 03253 -1, 576, -1, -1, 444, -1, -1, -1, 237, -1, 03254 -1, -1, -1, -1, -1, 455, -1, -1, 458, 248, 03255 -1, 250, -1, 920, -1, 961, 962, -1, 1049, 965, 03256 470, 967, 968, 608, 931, -1, -1, -1, -1, -1, 03257 -1, -1, 271, -1, -1, -1, 621, 622, -1, -1, 03258 -1, -1, -1, 2, -1, 4, 496, 497, -1, -1, 03259 -1, -1, -1, -1, 52, -1, 54, 55, 56, 57, 03260 58, -1, 512, -1, 649, -1, -1, 306, -1, -1, 03261 68, -1, 311, 980, -1, 982, -1, -1, -1, -1, 03262 -1, 988, -1, 990, 323, 324, 1032, 1033, 1034, 1035, 03263 49, 89, -1, -1, 53, -1, -1, 95, 96, 97, 03264 52, -1, 54, 55, 56, 57, 58, -1, 693, 1055, 03265 -1, 1018, -1, -1, -1, -1, 68, 356, -1, -1, 03266 79, -1, 120, -1, -1, 123, 576, -1, -1, 714, 03267 580, -1, 91, 92, 93, 94, -1, 89, -1, -1, 03268 -1, -1, 592, 141, 96, 97, -1, -1, -1, 52, 03269 -1, 54, 55, 56, 57, 58, -1, -1, 608, -1, 03270 -1, -1, -1, -1, -1, 68, -1, -1, 120, -1, 03271 -1, 621, 622, -1, -1, -1, -1, -1, -1, -1, 03272 -1, -1, -1, 768, -1, -1, 89, -1, -1, -1, 03273 -1, -1, 95, 96, 97, -1, -1, -1, -1, 649, 03274 -1, 440, -1, -1, -1, -1, -1, -1, -1, -1, 03275 -1, 450, -1, 2, -1, 4, -1, 120, -1, -1, 03276 123, -1, -1, -1, -1, -1, -1, -1, -1, 468, 03277 -1, -1, 817, 136, 2, -1, 4, -1, -1, -1, 03278 -1, -1, -1, 693, 203, -1, -1, 697, 698, -1, 03279 700, 701, -1, 2, -1, 4, -1, 707, 708, -1, 03280 49, -1, -1, -1, 714, 850, -1, -1, -1, -1, 03281 52, -1, 54, 55, 56, 57, 58, -1, 237, 518, 03282 -1, 49, -1, 868, -1, 53, 68, -1, -1, 248, 03283 -1, 250, -1, -1, -1, -1, -1, -1, -1, -1, 03284 49, 751, -1, -1, -1, 755, 756, 89, 758, 759, 03285 -1, 79, 271, 95, 96, 97, -1, -1, 768, -1, 03286 -1, -1, -1, 91, 92, 93, -1, -1, -1, -1, 03287 -1, 570, -1, 572, -1, -1, -1, -1, 120, -1, 03288 -1, 123, 91, -1, -1, -1, -1, 306, -1, -1, 03289 -1, -1, 311, -1, 136, 594, -1, -1, -1, -1, 03290 -1, -1, -1, -1, 323, 324, -1, 817, -1, -1, 03291 -1, 821, -1, -1, -1, -1, -1, -1, -1, 829, 03292 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03293 -1, -1, -1, 632, -1, -1, -1, 356, 637, -1, 03294 850, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03295 -1, -1, -1, -1, 203, -1, -1, 867, 868, -1, 03296 -1, -1, 68, 69, 70, 71, 72, 73, 74, 75, 03297 76, 77, 78, 79, 80, 203, -1, 83, 84, -1, 03298 -1, -1, -1, -1, -1, -1, -1, 686, 237, -1, 03299 689, -1, 691, -1, 203, -1, -1, 696, -1, 248, 03300 -1, 250, -1, -1, -1, -1, -1, -1, 114, 237, 03301 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 03302 248, 440, 250, -1, -1, -1, -1, -1, 237, -1, 03303 -1, 450, -1, -1, -1, 141, -1, 736, -1, 248, 03304 -1, 250, -1, 271, -1, 744, -1, -1, -1, 468, 03305 -1, -1, -1, -1, -1, -1, -1, 306, -1, -1, 03306 -1, 52, 311, 54, 55, 56, 57, 58, -1, -1, 03307 -1, -1, -1, -1, 323, -1, -1, 68, 306, -1, 03308 -1, -1, -1, 311, -1, -1, -1, -1, -1, -1, 03309 -1, -1, -1, -1, -1, 323, 324, 306, 89, 518, 03310 -1, 800, 311, -1, 95, 96, 97, 356, 1018, -1, 03311 -1, -1, -1, -1, 323, -1, 815, 326, -1, -1, 03312 -1, -1, -1, -1, -1, -1, -1, -1, 356, 120, 03313 44, -1, 123, -1, -1, -1, -1, -1, -1, -1, 03314 -1, 840, -1, -1, -1, -1, -1, 356, 847, 848, 03315 -1, 570, 851, 572, 68, 69, 70, 71, 72, 73, 03316 74, 75, 76, 77, 78, 79, 80, -1, -1, 83, 03317 84, -1, -1, -1, -1, 594, -1, -1, -1, 878, 03318 879, -1, 52, -1, 54, 55, 56, 57, 58, -1, 03319 -1, 440, -1, 892, 893, -1, -1, -1, 68, -1, 03320 114, 450, 116, 117, 118, 119, 120, 121, 122, 123, 03321 124, 125, 440, 632, -1, -1, -1, 916, 637, 89, 03322 134, 920, 450, -1, -1, 95, 96, 97, -1, -1, 03323 -1, 440, 931, -1, -1, -1, -1, -1, -1, -1, 03324 468, 450, -1, -1, -1, -1, -1, -1, -1, -1, 03325 120, -1, -1, 123, -1, -1, -1, -1, -1, -1, 03326 -1, -1, -1, -1, -1, -1, -1, 686, -1, -1, 03327 689, -1, 691, -1, -1, -1, -1, 696, -1, -1, 03328 -1, 980, -1, 982, 52, 53, -1, -1, 56, 988, 03329 518, 990, -1, -1, -1, -1, -1, -1, 66, 67, 03330 68, 69, 70, 71, 72, 73, 74, -1, -1, 77, 03331 78, -1, -1, 81, 82, 83, 84, 736, -1, -1, 03332 -1, 570, -1, 572, -1, 744, -1, 95, 96, -1, 03333 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03334 -1, -1, 570, -1, 572, 594, -1, -1, 116, 117, 03335 118, 119, 120, 121, 122, 123, 124, 125, -1, 127, 03336 128, 570, -1, 572, -1, -1, 594, 135, -1, -1, 03337 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03338 -1, 800, -1, 632, -1, 594, -1, -1, -1, -1, 03339 -1, -1, -1, -1, -1, -1, 815, -1, -1, -1, 03340 -1, -1, -1, -1, 632, -1, -1, -1, -1, 637, 03341 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03342 -1, 840, -1, 632, -1, -1, -1, -1, 847, 848, 03343 -1, -1, 851, -1, -1, -1, -1, 686, -1, -1, 03344 689, -1, 691, -1, -1, -1, -1, -1, 676, -1, 03345 -1, -1, -1, -1, -1, -1, -1, -1, 686, 878, 03346 879, 689, -1, 691, -1, -1, -1, -1, 696, -1, 03347 -1, -1, -1, 892, 893, -1, -1, 686, -1, -1, 03348 689, -1, 691, -1, -1, -1, -1, 736, 697, -1, 03349 -1, -1, -1, -1, -1, 744, -1, 916, -1, -1, 03350 -1, 920, -1, -1, -1, -1, -1, -1, 736, -1, 03351 -1, -1, 931, -1, -1, -1, 744, -1, -1, -1, 03352 -1, -1, -1, -1, -1, -1, -1, 736, 68, 69, 03353 70, 71, 72, 73, 74, 744, -1, 77, 78, -1, 03354 -1, -1, -1, 83, 84, -1, -1, -1, -1, -1, 03355 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03356 -1, 980, -1, 982, -1, -1, 815, -1, -1, 988, 03357 -1, 990, 800, -1, -1, -1, 116, 117, 118, 119, 03358 120, 121, 122, 123, 124, 125, -1, 815, -1, -1, 03359 -1, 840, -1, -1, -1, -1, -1, -1, 847, 848, 03360 -1, -1, 851, -1, -1, -1, 815, -1, -1, -1, 03361 -1, -1, 840, -1, -1, -1, -1, -1, -1, 847, 03362 848, -1, -1, 851, -1, -1, -1, -1, -1, 878, 03363 879, 840, -1, -1, -1, -1, -1, -1, 847, 848, 03364 -1, -1, 851, 892, -1, -1, -1, -1, -1, -1, 03365 878, 879, -1, -1, -1, -1, -1, -1, -1, -1, 03366 -1, -1, -1, -1, 892, 893, -1, -1, -1, 878, 03367 879, 920, -1, -1, -1, -1, -1, -1, -1, -1, 03368 -1, -1, 931, 892, -1, -1, -1, -1, 916, -1, 03369 -1, -1, 920, -1, -1, -1, -1, -1, -1, -1, 03370 -1, -1, -1, 931, -1, -1, -1, 916, -1, -1, 03371 -1, 920, -1, -1, -1, -1, -1, -1, -1, -1, 03372 -1, -1, 931, -1, -1, -1, -1, -1, -1, -1, 03373 -1, 980, -1, 982, -1, -1, -1, -1, -1, 988, 03374 -1, 990, -1, -1, -1, -1, -1, -1, -1, -1, 03375 -1, -1, 980, -1, 982, -1, -1, -1, -1, -1, 03376 988, -1, 990, -1, -1, -1, -1, -1, -1, -1, 03377 -1, 980, -1, 982, -1, -1, -1, -1, -1, 988, 03378 -1, 990, 0, 1, -1, 3, 4, 5, 6, 7, 03379 -1, -1, -1, 11, 12, -1, -1, -1, 16, -1, 03380 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, 03381 -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, 03382 -1, 39, -1, -1, -1, -1, -1, 45, 46, 47, 03383 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 03384 -1, 59, 60, -1, 62, 63, 64, -1, 66, 67, 03385 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03386 -1, -1, -1, -1, -1, -1, -1, -1, 86, -1, 03387 -1, 89, 90, -1, 92, 93, -1, 95, -1, -1, 03388 98, 99, 100, 101, 102, 103, 104, 105, 106, 0, 03389 -1, -1, -1, -1, -1, -1, -1, 8, 9, 10, 03390 -1, -1, 13, 14, 15, -1, 17, -1, 126, 127, 03391 128, -1, 44, -1, -1, 26, 27, 28, 29, -1, 03392 -1, 139, -1, 141, -1, -1, 37, 38, -1, 40, 03393 41, 42, 43, 44, -1, -1, 68, 69, 70, 71, 03394 72, 73, 74, 75, 76, 77, 78, 79, 80, -1, 03395 -1, 83, 84, -1, -1, -1, -1, 68, 69, 70, 03396 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 03397 -1, -1, 83, 84, 85, -1, 87, 88, -1, -1, 03398 -1, -1, 114, 94, 116, 117, 118, 119, 120, 121, 03399 122, 123, 124, 125, -1, -1, -1, 108, -1, -1, 03400 111, -1, 113, 114, 115, 116, 117, 118, 119, 120, 03401 121, 122, 123, 124, 125, -1, -1, -1, -1, 130, 03402 131, 132, 133, 134, 0, -1, 137, 138, 139, -1, 03403 141, -1, 8, 9, 10, -1, -1, 13, 14, 15, 03404 -1, 17, -1, -1, -1, -1, -1, 44, -1, 25, 03405 -1, 27, 28, 29, -1, -1, -1, -1, -1, -1, 03406 -1, 37, 38, -1, 40, 41, 42, 43, 44, -1, 03407 -1, 68, 69, 70, 71, 72, 73, 74, 75, 76, 03408 77, 78, 79, 80, -1, -1, 83, 84, -1, -1, 03409 -1, -1, 68, 69, 70, 71, 72, 73, 74, 75, 03410 76, 77, 78, 79, 80, -1, -1, 83, 84, 85, 03411 -1, 87, 88, -1, -1, -1, -1, 114, 94, 116, 03412 117, 118, 119, 120, 121, 122, 123, 124, 125, -1, 03413 -1, -1, 108, -1, -1, 111, -1, 113, 114, 115, 03414 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 03415 -1, -1, -1, -1, -1, 131, 132, 133, 134, 0, 03416 -1, 137, 138, 139, -1, 141, -1, 8, 9, 10, 03417 -1, -1, 13, 14, 15, -1, 17, -1, -1, -1, 03418 -1, -1, -1, -1, 25, -1, 27, 28, 29, -1, 03419 -1, -1, -1, -1, -1, -1, 37, 38, -1, 40, 03420 41, 42, 43, 44, -1, -1, 68, 69, 70, 71, 03421 72, 73, 74, 75, 76, 77, 78, 79, 80, -1, 03422 -1, 83, 84, -1, -1, -1, -1, 68, 69, 70, 03423 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 03424 -1, -1, 83, 84, 85, -1, 87, 88, -1, -1, 03425 -1, -1, 114, 94, 116, 117, 118, 119, 120, 121, 03426 122, 123, 124, 125, -1, -1, -1, 108, -1, -1, 03427 111, -1, 113, 114, 115, 116, 117, 118, 119, 120, 03428 121, 122, 123, 124, 125, -1, -1, -1, -1, -1, 03429 131, 132, 133, 134, 0, -1, 137, 138, 139, -1, 03430 141, -1, 8, 9, 10, -1, -1, 13, 14, 15, 03431 -1, 17, -1, -1, -1, -1, -1, -1, -1, -1, 03432 26, 27, 28, 29, -1, -1, -1, -1, -1, -1, 03433 -1, 37, 38, -1, 40, 41, 42, 43, 44, -1, 03434 -1, 68, 69, 70, 71, 72, 73, 74, 75, 76, 03435 77, 78, 79, 80, -1, -1, 83, 84, -1, -1, 03436 -1, -1, 68, 69, 70, 71, 72, 73, 74, 75, 03437 76, 77, 78, 79, 80, -1, -1, 83, 84, 85, 03438 -1, -1, 88, -1, -1, -1, -1, -1, 94, 116, 03439 117, 118, 119, 120, 121, 122, 123, 124, 125, -1, 03440 -1, -1, 108, -1, -1, 111, -1, -1, 114, 115, 03441 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 03442 -1, -1, -1, -1, 130, 131, 132, 133, 134, 0, 03443 -1, 137, 138, 139, -1, 141, -1, 8, 9, 10, 03444 -1, -1, 13, 14, 15, -1, 17, -1, -1, -1, 03445 -1, -1, -1, -1, -1, 26, 27, 28, 29, -1, 03446 -1, -1, -1, -1, -1, -1, 37, 38, -1, 40, 03447 41, 42, 43, 44, -1, -1, 68, 69, 70, 71, 03448 72, 73, 74, 75, -1, 77, 78, -1, -1, -1, 03449 -1, 83, 84, -1, -1, -1, -1, 68, 69, 70, 03450 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 03451 -1, -1, 83, 84, 85, -1, -1, 88, -1, -1, 03452 -1, -1, -1, 94, 116, 117, 118, 119, 120, 121, 03453 122, 123, 124, 125, -1, -1, -1, 108, -1, -1, 03454 111, -1, -1, 114, 115, 116, 117, 118, 119, 120, 03455 121, 122, 123, 124, 125, -1, -1, -1, -1, 130, 03456 131, 132, 133, 134, 0, -1, 137, 138, 139, -1, 03457 141, -1, 8, 9, 10, -1, -1, 13, 14, 15, 03458 -1, 17, -1, -1, -1, -1, -1, -1, -1, -1, 03459 -1, 27, 28, 29, -1, -1, -1, -1, -1, -1, 03460 -1, 37, 38, -1, 40, 41, 42, 43, 44, -1, 03461 -1, 68, 69, 70, 71, 72, 73, 74, -1, -1, 03462 77, 78, -1, -1, -1, -1, 83, 84, -1, -1, 03463 -1, -1, 68, 69, 70, 71, 72, 73, 74, 75, 03464 76, 77, 78, 79, 80, -1, -1, 83, 84, 85, 03465 -1, 87, 88, -1, -1, -1, -1, -1, 94, 116, 03466 117, 118, 119, 120, 121, 122, 123, 124, 125, -1, 03467 -1, -1, 108, -1, -1, 111, -1, 113, 114, 115, 03468 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 03469 -1, -1, -1, -1, -1, 131, 132, 133, 134, 0, 03470 -1, 137, 138, 139, -1, 141, -1, 8, 9, 10, 03471 -1, -1, 13, 14, 15, -1, 17, -1, -1, -1, 03472 -1, -1, -1, -1, -1, 26, 27, 28, -1, -1, 03473 -1, -1, -1, -1, -1, -1, 37, 38, -1, 40, 03474 41, 42, 43, 44, -1, -1, -1, -1, -1, -1, 03475 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03476 -1, -1, -1, -1, -1, -1, -1, 68, 69, 70, 03477 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 03478 -1, -1, 83, 84, 85, -1, -1, 88, -1, -1, 03479 -1, -1, -1, 94, -1, -1, -1, -1, -1, -1, 03480 -1, -1, -1, -1, -1, -1, -1, 108, -1, -1, 03481 -1, -1, -1, 114, -1, 116, 117, 118, 119, 120, 03482 121, 122, 123, 124, 125, -1, -1, -1, -1, 130, 03483 131, 132, 133, 134, 0, 136, 137, 138, 139, -1, 03484 141, -1, 8, 9, 10, -1, -1, 13, 14, 15, 03485 -1, 17, -1, -1, -1, -1, -1, -1, -1, -1, 03486 -1, 27, 28, 29, -1, -1, -1, -1, -1, -1, 03487 -1, 37, 38, -1, 40, 41, 42, 43, 44, -1, 03488 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03489 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03490 -1, -1, 68, 69, 70, 71, 72, 73, 74, 75, 03491 76, 77, 78, 79, 80, -1, -1, 83, 84, 85, 03492 -1, -1, 88, -1, -1, -1, -1, -1, 94, -1, 03493 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03494 -1, -1, 108, -1, -1, 111, -1, -1, 114, 115, 03495 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 03496 -1, -1, -1, -1, -1, 131, 132, 133, 134, 0, 03497 -1, 137, 138, 139, -1, 141, -1, 8, 9, 10, 03498 -1, -1, 13, 14, 15, -1, 17, -1, -1, -1, 03499 -1, -1, -1, -1, -1, 26, 27, 28, -1, -1, 03500 -1, -1, -1, -1, -1, -1, 37, 38, -1, 40, 03501 41, 42, 43, 44, -1, -1, -1, -1, -1, -1, 03502 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03503 -1, -1, -1, -1, -1, -1, -1, 68, 69, 70, 03504 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 03505 -1, -1, 83, 84, 85, -1, -1, 88, -1, -1, 03506 -1, -1, -1, 94, -1, -1, -1, -1, -1, -1, 03507 -1, -1, -1, -1, -1, -1, -1, 108, -1, -1, 03508 -1, -1, -1, 114, -1, 116, 117, 118, 119, 120, 03509 121, 122, 123, 124, 125, -1, -1, -1, -1, 130, 03510 131, 132, 133, 134, 0, 136, 137, 138, 139, -1, 03511 141, -1, 8, 9, 10, -1, -1, 13, 14, 15, 03512 -1, 17, -1, -1, -1, -1, -1, -1, -1, -1, 03513 -1, 27, 28, -1, -1, -1, -1, -1, -1, -1, 03514 -1, 37, 38, -1, 40, 41, 42, 43, 44, -1, 03515 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03516 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03517 -1, -1, 68, 69, 70, 71, 72, 73, 74, 75, 03518 76, 77, 78, 79, 80, -1, -1, 83, 84, 85, 03519 -1, -1, 88, -1, -1, -1, -1, -1, 94, -1, 03520 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03521 -1, -1, 108, -1, -1, -1, -1, -1, 114, -1, 03522 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 03523 -1, -1, -1, -1, -1, 131, 132, 133, 134, 0, 03524 136, 137, 138, 139, -1, 141, -1, 8, 9, 10, 03525 -1, -1, -1, 14, 15, -1, 17, -1, -1, -1, 03526 -1, -1, -1, -1, -1, 26, -1, -1, -1, -1, 03527 -1, -1, -1, -1, -1, -1, 37, 38, -1, 40, 03528 41, 42, 43, 44, -1, -1, -1, -1, -1, -1, 03529 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03530 -1, -1, -1, -1, -1, -1, -1, 68, 69, 70, 03531 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 03532 -1, -1, 83, 84, 85, -1, 87, -1, -1, -1, 03533 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03534 -1, -1, -1, -1, -1, -1, -1, 108, -1, -1, 03535 -1, -1, 113, 114, -1, 116, 117, 118, 119, 120, 03536 121, 122, 123, 124, 125, -1, -1, -1, -1, 130, 03537 131, 132, 133, 134, 0, -1, 137, -1, 139, -1, 03538 141, -1, 8, 9, 10, -1, -1, -1, 14, 15, 03539 -1, 17, -1, 0, -1, -1, -1, -1, -1, -1, 03540 -1, 8, 9, 10, -1, -1, 13, 14, 15, -1, 03541 17, 37, 38, -1, 40, 41, 42, 43, 44, 26, 03542 27, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03543 37, 38, -1, 40, 41, 42, 43, 44, -1, -1, 03544 -1, -1, 68, 69, 70, 71, 72, 73, 74, 75, 03545 76, 77, 78, 79, 80, -1, -1, 83, 84, 85, 03546 -1, 87, -1, -1, -1, -1, -1, -1, -1, -1, 03547 -1, -1, -1, -1, -1, -1, -1, -1, 85, -1, 03548 -1, -1, 108, -1, -1, -1, -1, 113, 114, -1, 03549 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 03550 -1, 108, -1, -1, -1, 131, 132, 133, 134, -1, 03551 -1, 137, -1, 139, -1, 141, -1, -1, -1, -1, 03552 -1, -1, -1, 130, 131, -1, 133, -1, -1, 136, 03553 137, -1, 139, 1, 141, 3, 4, 5, 6, 7, 03554 8, 9, 10, 11, 12, -1, -1, 15, 16, -1, 03555 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, 03556 -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, 03557 -1, 39, -1, -1, -1, -1, -1, 45, 46, 47, 03558 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 03559 -1, 59, 60, -1, 62, 63, 64, -1, 66, 67, 03560 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03561 -1, -1, -1, -1, -1, -1, -1, -1, 86, -1, 03562 -1, 89, 90, -1, 92, 93, -1, 95, -1, -1, 03563 98, 99, 100, 101, 102, 103, 104, 105, 106, -1, 03564 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03565 -1, -1, -1, -1, -1, -1, -1, -1, 126, 127, 03566 128, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03567 -1, 139, 1, 141, 3, 4, 5, 6, 7, -1, 03568 -1, 10, 11, 12, -1, 14, 15, 16, -1, 18, 03569 19, 20, 21, 22, 23, 24, -1, -1, -1, -1, 03570 -1, 30, 31, 32, 33, 34, 35, 36, -1, -1, 03571 39, -1, -1, -1, -1, -1, 45, 46, 47, 48, 03572 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, 03573 59, 60, -1, 62, 63, 64, -1, 66, 67, -1, 03574 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03575 -1, -1, -1, -1, -1, -1, -1, 86, -1, -1, 03576 89, 90, -1, 92, 93, -1, 95, -1, -1, 98, 03577 99, 100, 101, 102, 103, 104, 105, 106, -1, -1, 03578 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03579 -1, -1, -1, -1, -1, -1, -1, 126, 127, 128, 03580 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03581 139, 1, 141, 3, 4, 5, 6, 7, -1, -1, 03582 10, 11, 12, -1, -1, 15, 16, 17, 18, 19, 03583 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, 03584 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, 03585 -1, -1, -1, -1, -1, 45, 46, 47, 48, 49, 03586 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, 03587 60, -1, 62, 63, 64, -1, 66, 67, -1, -1, 03588 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03589 -1, -1, -1, -1, -1, -1, 86, -1, -1, 89, 03590 90, -1, 92, 93, -1, 95, -1, -1, 98, 99, 03591 100, 101, 102, 103, 104, 105, 106, -1, -1, -1, 03592 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03593 -1, -1, -1, -1, -1, -1, 126, 127, 128, -1, 03594 -1, -1, -1, -1, -1, -1, -1, -1, -1, 139, 03595 1, 141, 3, 4, 5, 6, 7, -1, -1, 10, 03596 11, 12, -1, -1, 15, 16, -1, 18, 19, 20, 03597 21, 22, 23, 24, -1, -1, -1, -1, -1, 30, 03598 31, 32, 33, 34, 35, 36, -1, -1, 39, -1, 03599 -1, -1, -1, -1, 45, 46, 47, 48, 49, 50, 03600 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, 03601 -1, 62, 63, 64, -1, 66, 67, -1, -1, -1, 03602 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03603 -1, -1, -1, -1, -1, 86, -1, -1, 89, 90, 03604 -1, 92, 93, -1, 95, -1, -1, 98, 99, 100, 03605 101, 102, 103, 104, 105, 106, -1, -1, -1, -1, 03606 -1, -1, -1, 1, -1, 3, 4, 5, 6, 7, 03607 -1, 9, 10, 11, 12, 126, 127, 128, 16, -1, 03608 18, 19, 20, 21, 22, 23, 24, -1, 139, -1, 03609 141, -1, 30, 31, 32, 33, 34, 35, 36, -1, 03610 -1, 39, -1, -1, -1, -1, -1, 45, 46, 47, 03611 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 03612 -1, 59, 60, -1, 62, 63, 64, -1, 66, 67, 03613 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03614 -1, -1, -1, -1, -1, -1, -1, -1, 86, -1, 03615 -1, 89, 90, -1, 92, 93, -1, 95, -1, -1, 03616 98, 99, 100, 101, 102, 103, 104, 105, 106, -1, 03617 -1, -1, -1, -1, -1, -1, 1, -1, 3, 4, 03618 5, 6, 7, -1, -1, -1, 11, 12, 126, 127, 03619 128, 16, -1, 18, 19, 20, 21, 22, 23, 24, 03620 -1, 139, -1, 141, -1, 30, 31, 32, 33, 34, 03621 35, 36, -1, -1, 39, -1, -1, -1, -1, -1, 03622 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 03623 55, 56, 57, -1, 59, 60, -1, 62, 63, 64, 03624 -1, 66, 67, -1, -1, -1, -1, -1, -1, -1, 03625 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03626 -1, 86, -1, -1, 89, 90, -1, 92, 93, -1, 03627 95, -1, -1, 98, 99, 100, 101, 102, 103, 104, 03628 105, 106, -1, -1, -1, -1, -1, -1, -1, -1, 03629 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03630 -1, 126, 127, 128, -1, -1, -1, -1, -1, -1, 03631 -1, -1, 137, -1, 139, 1, 141, 3, 4, 5, 03632 6, 7, -1, -1, -1, 11, 12, -1, -1, -1, 03633 16, -1, 18, 19, 20, 21, 22, 23, 24, -1, 03634 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, 03635 36, -1, -1, 39, -1, -1, -1, -1, -1, 45, 03636 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 03637 56, 57, -1, 59, 60, -1, 62, 63, 64, -1, 03638 66, 67, -1, -1, -1, -1, -1, -1, -1, -1, 03639 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03640 86, -1, -1, 89, 90, -1, 92, 93, -1, 95, 03641 -1, -1, 98, 99, 100, 101, 102, 103, 104, 105, 03642 106, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03643 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03644 126, 127, 128, -1, -1, -1, -1, -1, -1, -1, 03645 -1, 137, -1, 139, 1, 141, 3, 4, 5, 6, 03646 7, -1, -1, -1, 11, 12, -1, -1, -1, 16, 03647 -1, 18, 19, 20, 21, 22, 23, 24, -1, -1, 03648 -1, -1, -1, 30, 31, 32, 33, 34, 35, 36, 03649 -1, -1, 39, -1, -1, -1, -1, -1, 45, 46, 03650 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 03651 57, -1, 59, 60, -1, 62, 63, 64, -1, 66, 03652 67, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03653 -1, -1, -1, -1, -1, -1, -1, -1, -1, 86, 03654 -1, -1, 89, 90, -1, 92, 93, -1, 95, -1, 03655 -1, 98, 99, 100, 101, 102, 103, 104, 105, 106, 03656 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03657 -1, -1, -1, -1, -1, -1, -1, -1, -1, 126, 03658 127, 128, -1, -1, 131, 1, -1, 3, 4, 5, 03659 6, 7, 139, -1, 141, 11, 12, -1, -1, -1, 03660 16, -1, 18, 19, 20, 21, 22, 23, 24, -1, 03661 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, 03662 36, -1, -1, 39, -1, -1, -1, -1, -1, 45, 03663 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 03664 56, 57, -1, 59, 60, -1, 62, 63, 64, -1, 03665 66, 67, -1, -1, -1, -1, -1, -1, -1, -1, 03666 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03667 86, -1, -1, 89, 90, -1, 92, 93, -1, 95, 03668 -1, -1, 98, 99, 100, 101, 102, 103, 104, 105, 03669 106, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03670 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03671 126, 127, 128, -1, -1, 131, -1, -1, -1, -1, 03672 -1, -1, -1, 139, 1, 141, 3, 4, 5, 6, 03673 7, -1, -1, 10, 11, 12, -1, -1, -1, 16, 03674 -1, 18, 19, 20, 21, 22, 23, 24, -1, -1, 03675 -1, -1, -1, 30, 31, 32, 33, 34, 35, 36, 03676 -1, -1, 39, -1, -1, -1, -1, -1, 45, 46, 03677 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 03678 57, -1, 59, 60, -1, 62, 63, 64, -1, 66, 03679 67, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03680 -1, -1, -1, -1, -1, -1, -1, -1, -1, 86, 03681 -1, -1, 89, 90, -1, 92, 93, -1, 95, -1, 03682 -1, 98, 99, 100, 101, 102, 103, 104, 105, 106, 03683 -1, -1, -1, -1, -1, -1, -1, 1, -1, 3, 03684 4, 5, 6, 7, -1, -1, -1, 11, 12, 126, 03685 127, 128, 16, -1, 18, 19, 20, 21, 22, 23, 03686 24, -1, 139, -1, 141, -1, 30, 31, 32, 33, 03687 34, 35, 36, -1, -1, 39, -1, -1, -1, -1, 03688 -1, 45, 46, 47, 48, 49, 50, 51, 52, 53, 03689 54, 55, 56, 57, -1, 59, 60, -1, 62, 63, 03690 64, -1, 66, 67, -1, -1, -1, -1, -1, -1, 03691 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03692 -1, -1, 86, -1, -1, 89, 90, -1, 92, 93, 03693 -1, 95, -1, -1, 98, 99, 100, 101, 102, 103, 03694 104, 105, 106, -1, 108, -1, -1, -1, -1, -1, 03695 -1, -1, 3, 4, 5, -1, 7, -1, -1, -1, 03696 11, 12, 126, 127, 128, 16, -1, 18, 19, 20, 03697 21, 22, 23, 24, -1, 139, -1, 141, -1, 30, 03698 31, 32, 33, 34, 35, 36, -1, -1, 39, -1, 03699 -1, -1, -1, -1, -1, 46, -1, -1, 49, 50, 03700 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 03701 -1, 62, 63, 64, -1, 66, 67, -1, -1, -1, 03702 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03703 -1, -1, -1, -1, -1, 86, -1, -1, 89, 90, 03704 -1, 92, 93, -1, 95, 96, 97, 98, 99, 100, 03705 101, 102, 103, 104, 105, 106, -1, -1, -1, -1, 03706 -1, -1, -1, -1, -1, 3, 4, 5, -1, 7, 03707 -1, -1, -1, 11, 12, 126, 127, 128, 16, -1, 03708 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, 03709 141, -1, 30, 31, 32, 33, 34, 35, 36, -1, 03710 -1, 39, -1, -1, -1, -1, -1, -1, 46, -1, 03711 -1, 49, 50, 51, 52, 53, 54, 55, 56, 57, 03712 -1, 59, 60, -1, 62, 63, 64, -1, 66, 67, 03713 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03714 -1, -1, -1, -1, -1, -1, -1, -1, 86, -1, 03715 -1, 89, 90, -1, 92, 93, -1, -1, -1, -1, 03716 98, 99, 100, 101, 102, 103, 104, 105, 106, -1, 03717 -1, -1, -1, -1, -1, -1, -1, -1, 3, 4, 03718 5, -1, 7, -1, -1, -1, 11, 12, 126, 127, 03719 128, 16, -1, 18, 19, 20, 21, 22, 23, 24, 03720 -1, 139, -1, 141, -1, 30, 31, 32, 33, 34, 03721 35, 36, -1, -1, 39, -1, -1, -1, -1, -1, 03722 -1, 46, -1, -1, 49, 50, 51, 52, 53, 54, 03723 55, 56, 57, -1, 59, 60, -1, 62, 63, 64, 03724 -1, 66, 67, -1, -1, -1, -1, -1, -1, -1, 03725 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03726 -1, 86, -1, -1, 89, 90, -1, 92, 93, -1, 03727 -1, -1, -1, 98, 99, 100, 101, 102, 103, 104, 03728 105, 106, -1, -1, -1, -1, -1, -1, -1, -1, 03729 -1, 3, 4, 5, 6, 7, -1, -1, -1, 11, 03730 12, 126, 127, 128, 16, -1, 18, 19, 20, 21, 03731 22, 23, 24, -1, -1, -1, 141, -1, 30, 31, 03732 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, 03733 -1, -1, -1, 45, 46, 47, 48, 49, 50, 51, 03734 52, 53, 54, 55, 56, 57, -1, 59, 60, -1, 03735 62, 63, 64, -1, 66, 67, -1, -1, -1, -1, 03736 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03737 -1, -1, -1, -1, 86, -1, -1, 89, 90, -1, 03738 92, 93, -1, 95, -1, -1, 98, 99, 100, 101, 03739 102, 103, 104, 105, 106, -1, -1, -1, -1, -1, 03740 -1, -1, -1, -1, 3, 4, 5, 6, 7, -1, 03741 -1, -1, 11, 12, 126, 127, 128, 16, -1, 18, 03742 19, 20, 21, 22, 23, 24, -1, 139, -1, -1, 03743 -1, 30, 31, 32, 33, 34, 35, 36, -1, -1, 03744 39, -1, -1, -1, -1, -1, 45, 46, 47, 48, 03745 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, 03746 59, 60, -1, 62, 63, 64, -1, 66, 67, -1, 03747 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03748 -1, -1, -1, -1, -1, -1, -1, 86, -1, -1, 03749 89, 90, -1, 92, 93, -1, 95, -1, -1, 98, 03750 99, 100, 101, 102, 103, 104, 105, 106, -1, -1, 03751 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03752 -1, -1, -1, -1, -1, -1, -1, 126, 127, 128, 03753 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03754 139, 3, 4, 5, 6, 7, 8, 9, 10, 11, 03755 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 03756 22, 23, 24, 25, 26, -1, -1, -1, 30, 31, 03757 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 03758 -1, -1, -1, 45, 46, 47, 48, 49, 50, 51, 03759 52, 53, 54, 55, 56, 57, -1, -1, -1, -1, 03760 -1, -1, -1, -1, 66, 67, 68, 69, 70, 71, 03761 72, 73, 74, -1, -1, 77, 78, -1, -1, 81, 03762 82, 83, 84, -1, -1, -1, -1, -1, -1, -1, 03763 -1, -1, -1, 95, 96, -1, -1, -1, -1, -1, 03764 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03765 -1, -1, -1, -1, 116, 117, 118, 119, 120, 121, 03766 122, 123, 124, 125, -1, 127, 128, -1, -1, -1, 03767 -1, -1, -1, 135, 136, 3, 4, 5, 6, 7, 03768 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 03769 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, 03770 -1, -1, 30, 31, 32, 33, 34, 35, 36, 37, 03771 38, 39, -1, -1, -1, -1, -1, 45, 46, 47, 03772 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 03773 -1, -1, -1, -1, -1, -1, -1, -1, 66, 67, 03774 68, 69, 70, 71, 72, 73, 74, -1, -1, 77, 03775 78, -1, -1, 81, 82, 83, 84, -1, -1, -1, 03776 -1, -1, -1, -1, -1, -1, -1, 95, 96, -1, 03777 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03778 -1, -1, -1, -1, -1, -1, -1, -1, 116, 117, 03779 118, 119, 120, 121, 122, 123, 124, 125, -1, 127, 03780 128, -1, -1, -1, -1, -1, -1, 135, 3, 4, 03781 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 03782 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 03783 25, 26, -1, -1, -1, 30, 31, 32, 33, 34, 03784 35, 36, 37, 38, 39, -1, -1, -1, -1, -1, 03785 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 03786 -1, 56, -1, -1, -1, -1, -1, -1, -1, -1, 03787 -1, 66, 67, 68, 69, 70, 71, 72, 73, 74, 03788 -1, -1, 77, 78, -1, -1, 81, 82, 83, 84, 03789 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03790 95, 96, -1, -1, 99, -1, -1, -1, -1, -1, 03791 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03792 -1, 116, 117, 118, 119, 120, 121, 122, 123, 124, 03793 125, -1, 127, 128, -1, -1, -1, -1, -1, -1, 03794 135, 3, 4, 5, 6, 7, 8, 9, 10, 11, 03795 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 03796 22, 23, 24, 25, 26, -1, -1, -1, 30, 31, 03797 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 03798 -1, -1, -1, 45, 46, 47, 48, 49, 50, 51, 03799 52, 53, -1, -1, 56, -1, -1, -1, -1, -1, 03800 -1, -1, -1, -1, 66, 67, 68, 69, 70, 71, 03801 72, 73, 74, -1, -1, 77, 78, -1, -1, 81, 03802 82, 83, 84, -1, -1, -1, -1, -1, -1, -1, 03803 -1, -1, -1, 95, 96, -1, -1, 99, -1, -1, 03804 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03805 -1, -1, -1, -1, 116, 117, 118, 119, 120, 121, 03806 122, 123, 124, 125, -1, 127, 128, -1, -1, -1, 03807 -1, -1, -1, 135, 3, 4, 5, 6, 7, 8, 03808 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 03809 19, 20, 21, 22, 23, 24, 25, 26, -1, -1, 03810 -1, 30, 31, 32, 33, 34, 35, 36, 37, 38, 03811 39, -1, -1, -1, -1, -1, 45, 46, 47, 48, 03812 49, 50, 51, 52, 53, -1, -1, 56, -1, -1, 03813 -1, -1, -1, -1, -1, -1, -1, 66, 67, 68, 03814 69, 70, 71, 72, 73, 74, -1, -1, 77, 78, 03815 -1, -1, 81, 82, 83, 84, -1, -1, -1, -1, 03816 -1, -1, -1, -1, -1, -1, 95, 96, -1, -1, 03817 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03818 -1, -1, -1, -1, -1, -1, -1, 116, 117, 118, 03819 119, 120, 121, 122, 123, 124, 125, -1, 127, 128, 03820 3, 4, 5, -1, 7, -1, 135, -1, 11, 12, 03821 -1, -1, -1, 16, -1, 18, 19, 20, 21, 22, 03822 23, 24, -1, -1, -1, -1, -1, 30, 31, 32, 03823 33, 34, 35, 36, -1, -1, 39, -1, -1, -1, 03824 -1, -1, -1, 46, -1, -1, 49, 50, 51, 52, 03825 53, 54, 55, 56, 57, -1, 59, 60, -1, 62, 03826 63, 64, -1, -1, -1, -1, -1, -1, -1, -1, 03827 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03828 -1, -1, -1, 86, -1, -1, 89, 90, -1, 92, 03829 93, -1, -1, -1, -1, 98, 99, 100, 101, 102, 03830 103, 104, 105, 106, -1, -1, -1, -1, -1, 3, 03831 4, 5, -1, 7, -1, -1, -1, 11, 12, -1, 03832 -1, -1, 16, 126, 18, 19, 20, 21, 22, 23, 03833 24, 134, -1, -1, -1, -1, 30, 31, 32, 33, 03834 34, 35, 36, -1, -1, 39, -1, -1, -1, -1, 03835 -1, -1, 46, -1, -1, 49, 50, 51, 52, 53, 03836 54, 55, 56, 57, -1, 59, 60, -1, 62, 63, 03837 64, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03838 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03839 -1, -1, 86, -1, -1, 89, 90, -1, 92, 93, 03840 -1, -1, -1, -1, 98, 99, 100, 101, 102, 103, 03841 104, 105, 106, -1, -1, -1, -1, -1, 3, 4, 03842 5, 6, 7, -1, -1, -1, 11, 12, -1, -1, 03843 -1, 16, 126, 18, 19, 20, 21, 22, 23, 24, 03844 134, -1, -1, -1, -1, 30, 31, 32, 33, 34, 03845 35, 36, -1, -1, 39, -1, -1, -1, -1, -1, 03846 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 03847 55, 56, 57, -1, 59, 60, -1, 62, 63, 64, 03848 -1, 66, 67, -1, -1, -1, -1, -1, -1, -1, 03849 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03850 -1, 86, -1, -1, 89, 90, -1, 92, 93, -1, 03851 95, -1, -1, 98, 99, 100, 101, 102, 103, 104, 03852 105, 106, -1, -1, -1, -1, -1, -1, -1, -1, 03853 -1, 3, 4, 5, -1, 7, -1, -1, -1, 11, 03854 12, 126, 127, 128, 16, -1, 18, 19, 20, 21, 03855 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, 03856 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, 03857 -1, -1, -1, -1, 46, -1, -1, 49, 50, 51, 03858 52, 53, 54, 55, 56, 57, 58, 59, 60, -1, 03859 62, 63, 64, -1, 66, 67, -1, -1, -1, -1, 03860 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03861 -1, -1, -1, -1, 86, -1, -1, 89, 90, -1, 03862 92, 93, -1, 95, 96, 97, 98, 99, 100, 101, 03863 102, 103, 104, 105, 106, -1, -1, -1, -1, -1, 03864 -1, -1, -1, -1, 3, 4, 5, 6, 7, -1, 03865 -1, -1, 11, 12, 126, 127, 128, 16, -1, 18, 03866 19, 20, 21, 22, 23, 24, -1, -1, -1, -1, 03867 -1, 30, 31, 32, 33, 34, 35, 36, -1, -1, 03868 39, -1, -1, -1, -1, -1, 45, 46, -1, 48, 03869 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, 03870 59, 60, -1, 62, 63, 64, -1, 66, 67, -1, 03871 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03872 -1, -1, -1, -1, -1, -1, -1, 86, -1, -1, 03873 89, 90, -1, 92, 93, -1, 95, -1, -1, 98, 03874 99, 100, 101, 102, 103, 104, 105, 106, -1, -1, 03875 -1, -1, -1, -1, -1, -1, -1, 3, 4, 5, 03876 -1, 7, -1, -1, -1, 11, 12, 126, 127, 128, 03877 16, -1, 18, 19, 20, 21, 22, 23, 24, -1, 03878 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, 03879 36, -1, -1, 39, -1, -1, -1, -1, -1, -1, 03880 46, -1, -1, 49, 50, 51, 52, 53, 54, 55, 03881 56, 57, 58, 59, 60, -1, 62, 63, 64, -1, 03882 66, 67, -1, -1, -1, -1, -1, -1, -1, -1, 03883 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03884 86, -1, -1, 89, 90, -1, 92, 93, -1, 95, 03885 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 03886 106, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03887 3, 4, 5, -1, 7, -1, -1, -1, 11, 12, 03888 126, 127, 128, 16, -1, 18, 19, 20, 21, 22, 03889 23, 24, -1, -1, -1, -1, -1, 30, 31, 32, 03890 33, 34, 35, 36, -1, -1, 39, -1, -1, -1, 03891 -1, -1, -1, 46, -1, -1, 49, 50, 51, 52, 03892 53, 54, 55, 56, 57, 58, 59, 60, -1, 62, 03893 63, 64, -1, 66, 67, -1, -1, -1, -1, -1, 03894 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03895 -1, -1, -1, 86, -1, -1, 89, 90, -1, 92, 03896 93, -1, 95, 96, -1, 98, 99, 100, 101, 102, 03897 103, 104, 105, 106, -1, -1, -1, -1, -1, -1, 03898 -1, -1, -1, 3, 4, 5, -1, 7, -1, -1, 03899 -1, 11, 12, 126, 127, 128, 16, -1, 18, 19, 03900 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, 03901 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, 03902 -1, -1, -1, -1, -1, -1, 46, -1, -1, 49, 03903 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 03904 60, -1, 62, 63, 64, -1, 66, 67, -1, -1, 03905 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03906 -1, -1, -1, -1, -1, -1, 86, -1, -1, 89, 03907 90, -1, 92, 93, -1, -1, 96, 97, 98, 99, 03908 100, 101, 102, 103, 104, 105, 106, -1, -1, -1, 03909 -1, -1, -1, -1, -1, -1, 3, 4, 5, -1, 03910 7, -1, -1, -1, 11, 12, 126, 127, 128, 16, 03911 -1, 18, 19, 20, 21, 22, 23, 24, -1, -1, 03912 -1, -1, -1, 30, 31, 32, 33, 34, 35, 36, 03913 -1, -1, 39, -1, -1, -1, -1, -1, -1, 46, 03914 -1, -1, 49, 50, 51, 52, 53, 54, 55, 56, 03915 57, 58, 59, 60, -1, 62, 63, 64, -1, 66, 03916 67, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03917 -1, -1, -1, -1, -1, -1, -1, -1, -1, 86, 03918 -1, -1, 89, 90, -1, 92, 93, -1, 95, 96, 03919 -1, 98, 99, 100, 101, 102, 103, 104, 105, 106, 03920 -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 03921 4, 5, -1, 7, -1, -1, -1, 11, 12, 126, 03922 127, 128, 16, -1, 18, 19, 20, 21, 22, 23, 03923 24, -1, -1, -1, -1, -1, 30, 31, 32, 33, 03924 34, 35, 36, -1, -1, 39, -1, -1, -1, -1, 03925 -1, -1, 46, -1, -1, 49, 50, 51, 52, 53, 03926 54, 55, 56, 57, 58, 59, 60, -1, 62, 63, 03927 64, -1, 66, 67, -1, -1, -1, -1, -1, -1, 03928 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03929 -1, -1, 86, -1, -1, 89, 90, -1, 92, 93, 03930 -1, -1, 96, -1, 98, 99, 100, 101, 102, 103, 03931 104, 105, 106, -1, -1, -1, -1, -1, -1, -1, 03932 -1, -1, 3, 4, 5, -1, 7, -1, -1, -1, 03933 11, 12, 126, 127, 128, 16, -1, 18, 19, 20, 03934 21, 22, 23, 24, -1, -1, -1, -1, -1, 30, 03935 31, 32, 33, 34, 35, 36, -1, -1, 39, -1, 03936 -1, -1, -1, -1, -1, 46, -1, -1, 49, 50, 03937 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, 03938 -1, 62, 63, 64, -1, 66, 67, -1, -1, -1, 03939 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03940 -1, -1, -1, -1, -1, 86, -1, -1, 89, 90, 03941 -1, 92, 93, -1, 95, -1, -1, 98, 99, 100, 03942 101, 102, 103, 104, 105, 106, -1, -1, -1, -1, 03943 -1, -1, -1, -1, -1, 3, 4, 5, -1, 7, 03944 -1, -1, -1, 11, 12, 126, 127, 128, 16, -1, 03945 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, 03946 -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, 03947 -1, 39, -1, -1, -1, -1, -1, -1, 46, -1, 03948 -1, 49, 50, 51, 52, 53, 54, 55, 56, 57, 03949 -1, 59, 60, -1, 62, 63, 64, -1, 66, 67, 03950 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03951 -1, -1, -1, -1, -1, -1, -1, -1, 86, -1, 03952 -1, 89, 90, -1, 92, 93, -1, 95, -1, -1, 03953 98, 99, 100, 101, 102, 103, 104, 105, 106, -1, 03954 -1, -1, -1, -1, -1, -1, -1, -1, 3, 4, 03955 5, -1, 7, -1, -1, -1, 11, 12, 126, 127, 03956 128, 16, -1, 18, 19, 20, 21, 22, 23, 24, 03957 -1, -1, -1, -1, -1, 30, 31, 32, 33, 34, 03958 35, 36, -1, -1, 39, -1, -1, -1, -1, -1, 03959 -1, 46, -1, -1, 49, 50, 51, 52, 53, 54, 03960 55, 56, 57, -1, 59, 60, -1, 62, 63, 64, 03961 -1, 66, 67, -1, -1, -1, -1, -1, -1, -1, 03962 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03963 -1, 86, -1, -1, 89, 90, -1, 92, 93, -1, 03964 95, -1, -1, 98, 99, 100, 101, 102, 103, 104, 03965 105, 106, -1, -1, -1, -1, -1, -1, -1, -1, 03966 -1, 3, 4, 5, -1, 7, -1, -1, -1, 11, 03967 12, 126, 127, 128, 16, -1, 18, 19, 20, 21, 03968 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, 03969 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, 03970 -1, -1, -1, -1, 46, -1, -1, 49, 50, 51, 03971 52, 53, 54, 55, 56, 57, -1, 59, 60, -1, 03972 62, 63, 64, -1, 66, 67, -1, -1, -1, -1, 03973 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03974 -1, -1, -1, -1, 86, -1, -1, 89, 90, -1, 03975 92, 93, -1, 95, -1, -1, 98, 99, 100, 101, 03976 102, 103, 104, 105, 106, -1, -1, -1, -1, -1, 03977 -1, -1, -1, -1, 3, 4, 5, -1, 7, -1, 03978 -1, -1, 11, 12, 126, 127, 128, 16, -1, 18, 03979 19, 20, 21, 22, 23, 24, -1, -1, -1, -1, 03980 -1, 30, 31, 32, 33, 34, 35, 36, -1, -1, 03981 39, -1, -1, -1, -1, -1, -1, 46, -1, -1, 03982 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, 03983 59, 60, -1, 62, 63, 64, -1, 66, 67, -1, 03984 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03985 -1, -1, -1, -1, -1, -1, -1, 86, -1, -1, 03986 89, 90, -1, 92, 93, -1, 95, -1, -1, 98, 03987 99, 100, 101, 102, 103, 104, 105, 106, -1, -1, 03988 -1, -1, -1, -1, -1, -1, -1, 3, 4, 5, 03989 -1, 7, -1, -1, -1, 11, 12, 126, 127, 128, 03990 16, -1, 18, 19, 20, 21, 22, 23, 24, -1, 03991 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35, 03992 36, -1, -1, 39, -1, -1, -1, -1, -1, -1, 03993 46, -1, -1, 49, 50, 51, 52, 53, 54, 55, 03994 56, 57, -1, 59, 60, -1, 62, 63, 64, -1, 03995 66, 67, -1, -1, -1, -1, -1, -1, -1, -1, 03996 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 03997 86, -1, -1, 89, 90, -1, 92, 93, -1, -1, 03998 -1, -1, 98, 99, 100, 101, 102, 103, 104, 105, 03999 106, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04000 3, 4, 5, -1, 7, -1, -1, -1, 11, 12, 04001 126, 127, 128, 16, -1, 18, 19, 20, 21, 22, 04002 23, 24, -1, -1, -1, -1, -1, 30, 31, 32, 04003 33, 34, 35, 36, -1, -1, 39, -1, -1, -1, 04004 -1, -1, -1, 46, -1, -1, 49, 50, 51, 52, 04005 53, 54, 55, 56, 57, -1, 59, 60, -1, 62, 04006 63, 64, -1, 66, 67, -1, -1, -1, -1, -1, 04007 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04008 -1, -1, -1, 86, -1, -1, 89, 90, -1, 92, 04009 93, -1, -1, -1, -1, 98, 99, 100, 101, 102, 04010 103, 104, 105, 106, -1, -1, -1, -1, -1, -1, 04011 -1, -1, -1, 3, 4, 5, -1, 7, -1, -1, 04012 -1, 11, 12, 126, 127, 128, 16, -1, 18, 19, 04013 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, 04014 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, 04015 -1, -1, -1, -1, -1, -1, 46, -1, -1, 49, 04016 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, 04017 60, -1, 62, 63, 64, -1, 66, 67, -1, -1, 04018 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04019 -1, -1, -1, -1, -1, -1, 86, -1, -1, 89, 04020 90, -1, 92, 93, -1, -1, -1, -1, 98, 99, 04021 100, 101, 102, 103, 104, 105, 106, -1, -1, -1, 04022 -1, -1, -1, -1, -1, -1, 3, 4, 5, -1, 04023 7, -1, -1, -1, 11, 12, 126, 127, 128, 16, 04024 -1, 18, 19, 20, 21, 22, 23, 24, -1, -1, 04025 -1, -1, -1, 30, 31, 32, 33, 34, 35, 36, 04026 -1, -1, 39, -1, -1, -1, -1, -1, -1, 46, 04027 -1, -1, 49, 50, 51, 52, 53, 54, 55, 56, 04028 57, -1, 59, 60, -1, 62, 63, 64, -1, -1, 04029 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04030 -1, -1, -1, -1, -1, -1, -1, -1, -1, 86, 04031 -1, -1, 89, 90, -1, 92, 93, -1, 95, -1, 04032 -1, 98, 99, 100, 101, 102, 103, 104, 105, 106, 04033 -1, -1, -1, -1, -1, 3, 4, 5, -1, 7, 04034 -1, -1, -1, 11, 12, -1, -1, -1, 16, 126, 04035 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, 04036 -1, -1, 30, 31, 32, 33, 34, 35, 36, -1, 04037 -1, 39, -1, -1, -1, -1, -1, -1, 46, -1, 04038 -1, 49, 50, 51, 52, 53, 54, 55, 56, 57, 04039 -1, 59, 60, -1, 62, 63, 64, -1, -1, -1, 04040 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04041 -1, -1, -1, -1, -1, -1, -1, -1, 86, -1, 04042 -1, 89, 90, -1, 92, 93, -1, 95, -1, -1, 04043 98, 99, 100, 101, 102, 103, 104, 105, 106, -1, 04044 -1, -1, -1, -1, 3, 4, 5, -1, 7, -1, 04045 -1, -1, 11, 12, -1, -1, -1, 16, 126, 18, 04046 19, 20, 21, 22, 23, 24, -1, -1, -1, -1, 04047 -1, 30, 31, 32, 33, 34, 35, 36, -1, -1, 04048 39, -1, -1, -1, -1, -1, -1, 46, -1, -1, 04049 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, 04050 59, 60, -1, 62, 63, 64, -1, -1, -1, -1, 04051 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04052 -1, -1, -1, -1, 83, -1, -1, 86, -1, -1, 04053 89, 90, -1, 92, 93, -1, -1, -1, -1, 98, 04054 99, 100, 101, 102, 103, 104, 105, 106, -1, -1, 04055 -1, -1, -1, 3, 4, 5, -1, 7, -1, -1, 04056 -1, 11, 12, -1, -1, -1, 16, 126, 18, 19, 04057 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, 04058 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, 04059 -1, -1, -1, -1, -1, -1, 46, -1, -1, 49, 04060 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, 04061 60, -1, 62, 63, 64, -1, -1, -1, -1, -1, 04062 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04063 -1, -1, -1, -1, -1, -1, 86, -1, -1, 89, 04064 90, -1, 92, 93, -1, -1, -1, -1, 98, 99, 04065 100, 101, 102, 103, 104, 105, 106, -1, -1, -1, 04066 -1, -1, 3, 4, 5, -1, 7, -1, -1, -1, 04067 11, 12, -1, -1, -1, 16, 126, 18, 19, 20, 04068 21, 22, 23, 24, -1, -1, -1, -1, -1, 30, 04069 31, 32, 33, 34, 35, 36, -1, -1, 39, -1, 04070 -1, -1, -1, -1, -1, 46, -1, -1, 49, 50, 04071 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, 04072 -1, 62, 63, 64, -1, -1, -1, -1, -1, -1, 04073 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04074 -1, -1, -1, -1, -1, 86, -1, -1, 89, 90, 04075 -1, 92, 93, -1, -1, -1, -1, 98, 99, 100, 04076 101, 102, 103, 104, 105, 106, -1, -1, -1, -1, 04077 -1, 3, 4, 5, -1, 7, -1, -1, -1, 11, 04078 12, -1, -1, -1, 16, 126, 18, 19, 20, 21, 04079 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, 04080 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, 04081 -1, -1, -1, -1, 46, -1, -1, 49, 50, 51, 04082 52, 53, 54, 55, 56, 57, -1, 59, 60, -1, 04083 62, 63, 64, -1, -1, -1, -1, -1, -1, -1, 04084 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04085 -1, -1, -1, -1, 86, -1, -1, 89, 90, -1, 04086 92, 93, -1, -1, -1, -1, 98, 99, 100, 101, 04087 102, 103, 104, 105, 106, -1, -1, -1, -1, -1, 04088 3, 4, 5, -1, 7, -1, -1, -1, 11, 12, 04089 -1, -1, -1, 16, 126, 18, 19, 20, 21, 22, 04090 23, 24, -1, -1, -1, -1, -1, 30, 31, 32, 04091 33, 34, 35, 36, -1, -1, 39, -1, -1, -1, 04092 -1, -1, -1, 46, -1, -1, 49, 50, 51, 52, 04093 53, 54, 55, 56, 57, -1, 59, 60, -1, 62, 04094 63, 64, -1, -1, -1, -1, -1, -1, -1, -1, 04095 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04096 -1, -1, -1, 86, -1, -1, 89, 90, -1, 92, 04097 93, -1, -1, -1, -1, 98, 99, 100, 101, 102, 04098 103, 104, 105, 106, -1, -1, -1, -1, -1, -1, 04099 52, 53, -1, -1, 56, -1, -1, -1, -1, -1, 04100 -1, -1, -1, 126, 66, 67, 68, 69, 70, 71, 04101 72, 73, 74, -1, -1, 77, 78, -1, -1, 81, 04102 82, 83, 84, -1, -1, -1, -1, -1, -1, -1, 04103 -1, -1, -1, 95, 96, -1, -1, -1, -1, -1, 04104 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04105 -1, -1, -1, -1, 116, 117, 118, 119, 120, 121, 04106 122, 123, 124, 125, -1, 127, 128, 52, 53, -1, 04107 -1, 56, -1, 135, -1, -1, -1, -1, -1, -1, 04108 -1, 66, 67, 68, 69, 70, 71, 72, 73, 74, 04109 -1, -1, 77, 78, -1, -1, 81, 82, 83, 84, 04110 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04111 95, 96, -1, -1, -1, -1, -1, -1, -1, -1, 04112 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04113 -1, 116, 117, 118, 119, 120, 121, 122, 123, 124, 04114 125, -1, 127, 128, 52, 53, -1, -1, 56, -1, 04115 135, -1, -1, -1, -1, -1, -1, -1, 66, 67, 04116 68, 69, 70, 71, 72, 73, 74, -1, -1, 77, 04117 78, -1, -1, 81, 82, 83, 84, -1, -1, -1, 04118 -1, -1, -1, -1, -1, -1, -1, 95, 96, -1, 04119 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04120 -1, -1, -1, -1, -1, -1, -1, -1, 116, 117, 04121 118, 119, 120, 121, 122, 123, 124, 125, -1, 127, 04122 128, 52, 53, -1, -1, 56, -1, 135, -1, -1, 04123 -1, -1, -1, -1, -1, 66, 67, 68, 69, 70, 04124 71, 72, 73, 74, -1, -1, 77, 78, -1, -1, 04125 81, 82, 83, 84, -1, -1, -1, -1, -1, -1, 04126 -1, -1, -1, -1, 95, 96, -1, -1, -1, -1, 04127 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04128 -1, -1, -1, -1, -1, 116, 117, 118, 119, 120, 04129 121, 122, 123, 124, 125, -1, 127, 128, 52, 53, 04130 -1, -1, 56, -1, 135, -1, -1, -1, -1, -1, 04131 -1, -1, 66, 67, 68, 69, 70, 71, 72, 73, 04132 74, -1, -1, 77, 78, -1, -1, 81, 82, 83, 04133 84, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04134 -1, 95, 96, -1, -1, -1, -1, -1, -1, -1, 04135 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04136 -1, -1, 116, 117, 118, 119, 120, 121, 122, 123, 04137 124, 125, -1, 127, 128, 52, 53, -1, -1, 56, 04138 -1, 135, -1, -1, -1, -1, -1, -1, -1, 66, 04139 67, 68, 69, 70, 71, 72, 73, 74, -1, -1, 04140 77, 78, -1, -1, 81, 82, 83, 84, -1, -1, 04141 -1, -1, -1, -1, -1, -1, -1, -1, 95, 96, 04142 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04143 -1, -1, -1, -1, -1, -1, -1, -1, -1, 116, 04144 117, 118, 119, 120, 121, 122, 123, 124, 125, -1, 04145 127, 128, 52, 53, -1, -1, 56, -1, 135, -1, 04146 -1, -1, -1, -1, -1, -1, 66, 67, 68, 69, 04147 70, 71, 72, 73, 74, -1, -1, 77, 78, -1, 04148 -1, 81, 82, 83, 84, -1, -1, -1, -1, -1, 04149 -1, -1, -1, -1, -1, 95, 96, -1, -1, -1, 04150 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04151 -1, -1, -1, -1, -1, -1, 116, 117, 118, 119, 04152 120, 121, 122, 123, 124, 125, -1, 127, 128, 52, 04153 53, -1, -1, 56, -1, 135, -1, -1, -1, -1, 04154 -1, -1, -1, 66, 67, 68, 69, 70, 71, 72, 04155 73, 74, -1, -1, 77, 78, -1, -1, 81, 82, 04156 83, 84, -1, -1, -1, -1, -1, -1, -1, -1, 04157 -1, -1, 95, 96, -1, -1, -1, -1, -1, -1, 04158 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04159 -1, -1, -1, 116, 117, 118, 119, 120, 121, 122, 04160 123, 124, 125, -1, 127, 128, 52, 53, -1, -1, 04161 56, -1, 135, -1, -1, -1, -1, -1, -1, -1, 04162 66, 67, 68, 69, 70, 71, 72, 73, 74, -1, 04163 -1, 77, 78, -1, -1, 81, 82, 83, 84, -1, 04164 -1, -1, -1, -1, -1, -1, -1, -1, -1, 95, 04165 96, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04166 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04167 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 04168 -1, 127, 128, 52, 53, -1, -1, 56, -1, 135, 04169 -1, -1, -1, -1, -1, -1, -1, 66, 67, 68, 04170 69, 70, 71, 72, 73, 74, -1, -1, 77, 78, 04171 -1, -1, 81, 82, 83, 84, -1, -1, -1, -1, 04172 -1, -1, -1, -1, -1, -1, 95, 96, -1, -1, 04173 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04174 -1, -1, -1, -1, -1, -1, -1, 116, 117, 118, 04175 119, 120, 121, 122, 123, 124, 125, -1, 127, 128, 04176 52, 53, -1, -1, 56, -1, 135, -1, -1, -1, 04177 -1, -1, -1, -1, 66, 67, 68, 69, 70, 71, 04178 72, 73, 74, -1, -1, 77, 78, -1, -1, 81, 04179 82, 83, 84, -1, -1, -1, -1, -1, -1, -1, 04180 -1, -1, -1, 95, 96, -1, -1, -1, -1, -1, 04181 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04182 -1, -1, -1, -1, 116, 117, 118, 119, 120, 121, 04183 122, 123, 124, 125, -1, 127, 128, 52, 53, -1, 04184 -1, 56, -1, 135, -1, -1, -1, -1, -1, -1, 04185 -1, 66, 67, 68, 69, 70, 71, 72, 73, 74, 04186 -1, -1, 77, 78, -1, -1, 81, 82, 83, 84, 04187 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04188 95, 96, -1, -1, -1, -1, -1, -1, -1, -1, 04189 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 04190 -1, 116, 117, 118, 119, 120, 121, 122, 123, 124, 04191 125, -1, 127, 128, -1, -1, -1, -1, -1, -1, 04192 135 04193 }; 04194 04195 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 04196 symbol of state STATE-NUM. */ 04197 static const yytype_uint16 yystos[] = 04198 { 04199 0, 143, 144, 0, 1, 3, 4, 5, 6, 7, 04200 11, 12, 16, 18, 19, 20, 21, 22, 23, 24, 04201 30, 31, 32, 33, 34, 35, 36, 39, 45, 46, 04202 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 04203 57, 59, 60, 62, 63, 64, 66, 67, 86, 89, 04204 90, 92, 93, 95, 98, 99, 100, 101, 102, 103, 04205 104, 105, 106, 126, 127, 128, 145, 146, 147, 154, 04206 156, 157, 159, 160, 163, 164, 165, 167, 168, 169, 04207 171, 172, 182, 196, 215, 216, 217, 218, 219, 220, 04208 221, 222, 223, 224, 225, 251, 252, 266, 267, 268, 04209 269, 270, 271, 272, 275, 277, 278, 290, 292, 293, 04210 294, 295, 296, 297, 298, 329, 340, 147, 3, 4, 04211 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 04212 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 04213 25, 26, 30, 31, 32, 33, 34, 35, 36, 37, 04214 38, 39, 45, 46, 47, 48, 49, 50, 51, 52, 04215 53, 56, 66, 67, 68, 69, 70, 71, 72, 73, 04216 74, 77, 78, 81, 82, 83, 84, 95, 96, 116, 04217 117, 118, 119, 120, 121, 122, 123, 124, 125, 127, 04218 128, 135, 175, 176, 177, 178, 180, 181, 290, 292, 04219 39, 58, 86, 89, 95, 96, 97, 127, 164, 172, 04220 182, 184, 189, 192, 194, 215, 294, 295, 297, 298, 04221 327, 328, 189, 189, 136, 190, 191, 136, 186, 190, 04222 136, 141, 334, 54, 177, 334, 148, 130, 21, 22, 04223 30, 31, 32, 163, 182, 215, 182, 56, 1, 47, 04224 89, 150, 151, 152, 154, 166, 167, 340, 198, 199, 04225 185, 194, 327, 340, 184, 326, 327, 340, 46, 86, 04226 126, 134, 171, 196, 215, 294, 295, 298, 243, 244, 04227 54, 55, 57, 175, 282, 291, 281, 282, 283, 140, 04228 273, 140, 279, 140, 276, 140, 280, 59, 60, 159, 04229 182, 182, 139, 141, 333, 338, 339, 40, 41, 42, 04230 43, 44, 37, 38, 26, 130, 186, 190, 257, 28, 04231 249, 113, 134, 89, 95, 168, 113, 68, 69, 70, 04232 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 04233 83, 84, 114, 116, 117, 118, 119, 120, 121, 122, 04234 123, 124, 125, 85, 132, 133, 197, 157, 158, 158, 04235 202, 204, 158, 333, 339, 86, 165, 172, 215, 231, 04236 294, 295, 298, 52, 56, 83, 86, 173, 174, 215, 04237 294, 295, 298, 174, 33, 34, 35, 36, 49, 50, 04238 51, 52, 56, 136, 175, 296, 324, 85, 133, 332, 04239 257, 269, 87, 87, 134, 184, 56, 184, 184, 184, 04240 113, 88, 134, 193, 340, 85, 132, 133, 87, 87, 04241 134, 193, 189, 334, 335, 189, 188, 189, 194, 327, 04242 340, 157, 335, 157, 54, 63, 64, 155, 136, 183, 04243 130, 150, 85, 133, 87, 154, 153, 166, 137, 333, 04244 339, 335, 335, 157, 138, 134, 141, 337, 134, 337, 04245 131, 337, 334, 56, 59, 60, 168, 170, 134, 85, 04246 132, 133, 245, 61, 107, 109, 110, 284, 110, 284, 04247 110, 65, 284, 110, 110, 274, 284, 110, 61, 110, 04248 110, 110, 274, 110, 61, 110, 68, 68, 139, 147, 04249 158, 158, 158, 158, 154, 157, 157, 259, 258, 94, 04250 161, 250, 95, 159, 184, 194, 195, 166, 134, 171, 04251 134, 156, 159, 172, 182, 184, 195, 182, 182, 182, 04252 182, 182, 182, 182, 182, 182, 182, 182, 182, 182, 04253 182, 182, 182, 182, 182, 182, 182, 182, 182, 182, 04254 182, 182, 182, 52, 53, 56, 180, 256, 330, 331, 04255 188, 52, 53, 56, 180, 255, 330, 149, 150, 13, 04256 227, 338, 227, 158, 158, 333, 17, 260, 56, 85, 04257 132, 133, 25, 157, 52, 56, 173, 1, 117, 299, 04258 338, 85, 132, 133, 211, 325, 212, 332, 52, 56, 04259 330, 159, 182, 159, 182, 179, 182, 184, 95, 184, 04260 192, 327, 52, 56, 188, 52, 56, 328, 335, 137, 04261 335, 134, 134, 335, 177, 201, 182, 145, 131, 330, 04262 330, 182, 130, 335, 152, 200, 327, 134, 170, 52, 04263 56, 188, 52, 56, 52, 54, 55, 56, 57, 58, 04264 68, 89, 95, 96, 97, 120, 123, 136, 247, 302, 04265 304, 305, 306, 307, 308, 309, 312, 313, 314, 315, 04266 318, 319, 320, 321, 322, 286, 285, 140, 284, 140, 04267 140, 140, 182, 182, 76, 118, 238, 239, 340, 238, 04268 162, 238, 184, 134, 335, 170, 134, 113, 44, 334, 04269 87, 87, 186, 190, 254, 334, 336, 87, 87, 186, 04270 190, 253, 10, 226, 8, 262, 340, 150, 13, 150, 04271 27, 228, 338, 228, 260, 194, 226, 52, 56, 188, 04272 52, 56, 206, 209, 338, 300, 208, 52, 56, 173, 04273 188, 149, 157, 136, 301, 304, 213, 186, 187, 190, 04274 340, 44, 177, 184, 193, 87, 87, 336, 87, 87, 04275 327, 157, 131, 145, 335, 337, 168, 336, 113, 184, 04276 52, 89, 95, 232, 233, 234, 306, 304, 246, 134, 04277 303, 134, 323, 340, 52, 134, 323, 134, 303, 52, 04278 134, 303, 52, 287, 54, 55, 57, 289, 298, 52, 04279 58, 235, 237, 240, 308, 310, 311, 314, 316, 317, 04280 320, 322, 334, 150, 150, 238, 150, 95, 184, 170, 04281 182, 115, 159, 182, 159, 182, 161, 186, 138, 87, 04282 159, 182, 159, 182, 161, 187, 184, 195, 263, 340, 04283 15, 230, 340, 14, 229, 230, 230, 203, 205, 226, 04284 134, 227, 336, 158, 338, 158, 149, 336, 226, 335, 04285 304, 149, 338, 175, 257, 249, 182, 87, 134, 335, 04286 131, 184, 234, 134, 306, 134, 335, 240, 29, 111, 04287 248, 302, 307, 318, 320, 309, 314, 322, 308, 315, 04288 320, 308, 288, 113, 86, 215, 240, 118, 134, 236, 04289 134, 323, 323, 134, 236, 134, 236, 139, 10, 131, 04290 150, 10, 184, 182, 159, 182, 88, 264, 340, 150, 04291 9, 265, 340, 158, 226, 226, 150, 150, 184, 150, 04292 228, 210, 338, 226, 335, 226, 214, 335, 233, 134, 04293 95, 232, 137, 150, 150, 134, 303, 134, 303, 323, 04294 134, 303, 134, 303, 303, 150, 215, 56, 85, 118, 04295 235, 317, 320, 310, 314, 308, 316, 320, 308, 52, 04296 241, 242, 305, 131, 86, 172, 215, 294, 295, 298, 04297 227, 150, 227, 226, 226, 230, 260, 261, 207, 149, 04298 301, 134, 233, 134, 306, 10, 131, 308, 320, 308, 04299 308, 108, 52, 56, 134, 236, 134, 236, 323, 134, 04300 236, 134, 236, 236, 134, 334, 56, 85, 132, 133, 04301 150, 150, 150, 226, 149, 233, 134, 303, 134, 303, 04302 303, 303, 308, 320, 308, 308, 242, 52, 56, 188, 04303 52, 56, 262, 229, 226, 226, 233, 308, 236, 134, 04304 236, 236, 236, 336, 303, 308, 236 04305 }; 04306 04307 #define yyerrok (yyerrstatus = 0) 04308 #define yyclearin (yychar = YYEMPTY) 04309 #define YYEMPTY (-2) 04310 #define YYEOF 0 04311 04312 #define YYACCEPT goto yyacceptlab 04313 #define YYABORT goto yyabortlab 04314 #define YYERROR goto yyerrorlab 04315 04316 04317 /* Like YYERROR except do call yyerror. This remains here temporarily 04318 to ease the transition to the new meaning of YYERROR, for GCC. 04319 Once GCC version 2 has supplanted version 1, this can go. However, 04320 YYFAIL appears to be in use. Nevertheless, it is formally deprecated 04321 in Bison 2.4.2's NEWS entry, where a plan to phase it out is 04322 discussed. */ 04323 04324 #define YYFAIL goto yyerrlab 04325 #if defined YYFAIL 04326 /* This is here to suppress warnings from the GCC cpp's 04327 -Wunused-macros. Normally we don't worry about that warning, but 04328 some users do, and we want to make it easy for users to remove 04329 YYFAIL uses, which will produce warnings from Bison 2.5. */ 04330 #endif 04331 04332 #define YYRECOVERING() (!!yyerrstatus) 04333 04334 #define YYBACKUP(Token, Value) \ 04335 do \ 04336 if (yychar == YYEMPTY && yylen == 1) \ 04337 { \ 04338 yychar = (Token); \ 04339 yylval = (Value); \ 04340 YYPOPSTACK (1); \ 04341 goto yybackup; \ 04342 } \ 04343 else \ 04344 { \ 04345 parser_yyerror (parser, YY_("syntax error: cannot back up")); \ 04346 YYERROR; \ 04347 } \ 04348 while (YYID (0)) 04349 04350 04351 #define YYTERROR 1 04352 #define YYERRCODE 256 04353 04354 04355 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 04356 If N is 0, then set CURRENT to the empty location which ends 04357 the previous symbol: RHS[0] (always defined). */ 04358 04359 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 04360 #ifndef YYLLOC_DEFAULT 04361 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 04362 do \ 04363 if (YYID (N)) \ 04364 { \ 04365 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 04366 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 04367 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 04368 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 04369 } \ 04370 else \ 04371 { \ 04372 (Current).first_line = (Current).last_line = \ 04373 YYRHSLOC (Rhs, 0).last_line; \ 04374 (Current).first_column = (Current).last_column = \ 04375 YYRHSLOC (Rhs, 0).last_column; \ 04376 } \ 04377 while (YYID (0)) 04378 #endif 04379 04380 04381 /* This macro is provided for backward compatibility. */ 04382 04383 #ifndef YY_LOCATION_PRINT 04384 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 04385 #endif 04386 04387 04388 /* YYLEX -- calling `yylex' with the right arguments. */ 04389 04390 #ifdef YYLEX_PARAM 04391 # define YYLEX yylex (&yylval, YYLEX_PARAM) 04392 #else 04393 # define YYLEX yylex (&yylval, parser) 04394 #endif 04395 04396 /* Enable debugging if requested. */ 04397 #if YYDEBUG 04398 04399 # ifndef YYFPRINTF 04400 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 04401 # define YYFPRINTF fprintf 04402 # endif 04403 04404 # define YYDPRINTF(Args) \ 04405 do { \ 04406 if (yydebug) \ 04407 YYFPRINTF Args; \ 04408 } while (YYID (0)) 04409 04410 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 04411 do { \ 04412 if (yydebug) \ 04413 { \ 04414 YYFPRINTF (stderr, "%s ", Title); \ 04415 yy_symbol_print (stderr, \ 04416 Type, Value, parser); \ 04417 YYFPRINTF (stderr, "\n"); \ 04418 } \ 04419 } while (YYID (0)) 04420 04421 04422 /*--------------------------------. 04423 | Print this symbol on YYOUTPUT. | 04424 `--------------------------------*/ 04425 04426 /*ARGSUSED*/ 04427 #if (defined __STDC__ || defined __C99__FUNC__ \ 04428 || defined __cplusplus || defined _MSC_VER) 04429 static void 04430 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser) 04431 #else 04432 static void 04433 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser) 04434 FILE *yyoutput; 04435 int yytype; 04436 YYSTYPE const * const yyvaluep; 04437 struct parser_params *parser; 04438 #endif 04439 { 04440 if (!yyvaluep) 04441 return; 04442 YYUSE (parser); 04443 # ifdef YYPRINT 04444 if (yytype < YYNTOKENS) 04445 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 04446 # else 04447 YYUSE (yyoutput); 04448 # endif 04449 switch (yytype) 04450 { 04451 default: 04452 break; 04453 } 04454 } 04455 04456 04457 /*--------------------------------. 04458 | Print this symbol on YYOUTPUT. | 04459 `--------------------------------*/ 04460 04461 #if (defined __STDC__ || defined __C99__FUNC__ \ 04462 || defined __cplusplus || defined _MSC_VER) 04463 static void 04464 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser) 04465 #else 04466 static void 04467 yy_symbol_print (yyoutput, yytype, yyvaluep, parser) 04468 FILE *yyoutput; 04469 int yytype; 04470 YYSTYPE const * const yyvaluep; 04471 struct parser_params *parser; 04472 #endif 04473 { 04474 if (yytype < YYNTOKENS) 04475 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 04476 else 04477 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 04478 04479 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser); 04480 YYFPRINTF (yyoutput, ")"); 04481 } 04482 04483 /*------------------------------------------------------------------. 04484 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 04485 | TOP (included). | 04486 `------------------------------------------------------------------*/ 04487 04488 #if (defined __STDC__ || defined __C99__FUNC__ \ 04489 || defined __cplusplus || defined _MSC_VER) 04490 static void 04491 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 04492 #else 04493 static void 04494 yy_stack_print (yybottom, yytop) 04495 yytype_int16 *yybottom; 04496 yytype_int16 *yytop; 04497 #endif 04498 { 04499 YYFPRINTF (stderr, "Stack now"); 04500 for (; yybottom <= yytop; yybottom++) 04501 { 04502 int yybot = *yybottom; 04503 YYFPRINTF (stderr, " %d", yybot); 04504 } 04505 YYFPRINTF (stderr, "\n"); 04506 } 04507 04508 # define YY_STACK_PRINT(Bottom, Top) \ 04509 do { \ 04510 if (yydebug) \ 04511 yy_stack_print ((Bottom), (Top)); \ 04512 } while (YYID (0)) 04513 04514 04515 /*------------------------------------------------. 04516 | Report that the YYRULE is going to be reduced. | 04517 `------------------------------------------------*/ 04518 04519 #if (defined __STDC__ || defined __C99__FUNC__ \ 04520 || defined __cplusplus || defined _MSC_VER) 04521 static void 04522 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser) 04523 #else 04524 static void 04525 yy_reduce_print (yyvsp, yyrule, parser) 04526 YYSTYPE *yyvsp; 04527 int yyrule; 04528 struct parser_params *parser; 04529 #endif 04530 { 04531 int yynrhs = yyr2[yyrule]; 04532 int yyi; 04533 unsigned long int yylno = yyrline[yyrule]; 04534 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 04535 yyrule - 1, yylno); 04536 /* The symbols being reduced. */ 04537 for (yyi = 0; yyi < yynrhs; yyi++) 04538 { 04539 YYFPRINTF (stderr, " $%d = ", yyi + 1); 04540 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 04541 &(yyvsp[(yyi + 1) - (yynrhs)]) 04542 , parser); 04543 YYFPRINTF (stderr, "\n"); 04544 } 04545 } 04546 04547 # define YY_REDUCE_PRINT(Rule) \ 04548 do { \ 04549 if (yydebug) \ 04550 yy_reduce_print (yyvsp, Rule, parser); \ 04551 } while (YYID (0)) 04552 04553 /* Nonzero means print parse trace. It is left uninitialized so that 04554 multiple parsers can coexist. */ 04555 #ifndef yydebug 04556 int yydebug; 04557 #endif 04558 #else /* !YYDEBUG */ 04559 # define YYDPRINTF(Args) 04560 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 04561 # define YY_STACK_PRINT(Bottom, Top) 04562 # define YY_REDUCE_PRINT(Rule) 04563 #endif /* !YYDEBUG */ 04564 04565 04566 /* YYINITDEPTH -- initial size of the parser's stacks. */ 04567 #ifndef YYINITDEPTH 04568 # define YYINITDEPTH 200 04569 #endif 04570 04571 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 04572 if the built-in stack extension method is used). 04573 04574 Do not make this value too large; the results are undefined if 04575 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 04576 evaluated with infinite-precision integer arithmetic. */ 04577 04578 #ifndef YYMAXDEPTH 04579 # define YYMAXDEPTH 10000 04580 #endif 04581 04582 04583 #if YYERROR_VERBOSE 04584 04585 # ifndef yystrlen 04586 # if defined __GLIBC__ && defined _STRING_H 04587 # define yystrlen strlen 04588 # else 04589 /* Return the length of YYSTR. */ 04590 #if (defined __STDC__ || defined __C99__FUNC__ \ 04591 || defined __cplusplus || defined _MSC_VER) 04592 static YYSIZE_T 04593 yystrlen (const char *yystr) 04594 #else 04595 static YYSIZE_T 04596 yystrlen (yystr) 04597 const char *yystr; 04598 #endif 04599 { 04600 YYSIZE_T yylen; 04601 for (yylen = 0; yystr[yylen]; yylen++) 04602 continue; 04603 return yylen; 04604 } 04605 # endif 04606 # endif 04607 04608 # ifndef yystpcpy 04609 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 04610 # define yystpcpy stpcpy 04611 # else 04612 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 04613 YYDEST. */ 04614 #if (defined __STDC__ || defined __C99__FUNC__ \ 04615 || defined __cplusplus || defined _MSC_VER) 04616 static char * 04617 yystpcpy (char *yydest, const char *yysrc) 04618 #else 04619 static char * 04620 yystpcpy (yydest, yysrc) 04621 char *yydest; 04622 const char *yysrc; 04623 #endif 04624 { 04625 char *yyd = yydest; 04626 const char *yys = yysrc; 04627 04628 while ((*yyd++ = *yys++) != '\0') 04629 continue; 04630 04631 return yyd - 1; 04632 } 04633 # endif 04634 # endif 04635 04636 # ifndef yytnamerr 04637 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 04638 quotes and backslashes, so that it's suitable for yyerror. The 04639 heuristic is that double-quoting is unnecessary unless the string 04640 contains an apostrophe, a comma, or backslash (other than 04641 backslash-backslash). YYSTR is taken from yytname. If YYRES is 04642 null, do not copy; instead, return the length of what the result 04643 would have been. */ 04644 static YYSIZE_T 04645 yytnamerr (char *yyres, const char *yystr) 04646 { 04647 if (*yystr == '"') 04648 { 04649 YYSIZE_T yyn = 0; 04650 char const *yyp = yystr; 04651 04652 for (;;) 04653 switch (*++yyp) 04654 { 04655 case '\'': 04656 case ',': 04657 goto do_not_strip_quotes; 04658 04659 case '\\': 04660 if (*++yyp != '\\') 04661 goto do_not_strip_quotes; 04662 /* Fall through. */ 04663 default: 04664 if (yyres) 04665 yyres[yyn] = *yyp; 04666 yyn++; 04667 break; 04668 04669 case '"': 04670 if (yyres) 04671 yyres[yyn] = '\0'; 04672 return yyn; 04673 } 04674 do_not_strip_quotes: ; 04675 } 04676 04677 if (! yyres) 04678 return yystrlen (yystr); 04679 04680 return yystpcpy (yyres, yystr) - yyres; 04681 } 04682 # endif 04683 04684 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 04685 about the unexpected token YYTOKEN for the state stack whose top is 04686 YYSSP. 04687 04688 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 04689 not large enough to hold the message. In that case, also set 04690 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 04691 required number of bytes is too large to store. */ 04692 static int 04693 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 04694 yytype_int16 *yyssp, int yytoken) 04695 { 04696 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); 04697 YYSIZE_T yysize = yysize0; 04698 YYSIZE_T yysize1; 04699 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 04700 /* Internationalized format string. */ 04701 const char *yyformat = 0; 04702 /* Arguments of yyformat. */ 04703 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 04704 /* Number of reported tokens (one for the "unexpected", one per 04705 "expected"). */ 04706 int yycount = 0; 04707 04708 /* There are many possibilities here to consider: 04709 - Assume YYFAIL is not used. It's too flawed to consider. See 04710 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> 04711 for details. YYERROR is fine as it does not invoke this 04712 function. 04713 - If this state is a consistent state with a default action, then 04714 the only way this function was invoked is if the default action 04715 is an error action. In that case, don't check for expected 04716 tokens because there are none. 04717 - The only way there can be no lookahead present (in yychar) is if 04718 this state is a consistent state with a default action. Thus, 04719 detecting the absence of a lookahead is sufficient to determine 04720 that there is no unexpected or expected token to report. In that 04721 case, just report a simple "syntax error". 04722 - Don't assume there isn't a lookahead just because this state is a 04723 consistent state with a default action. There might have been a 04724 previous inconsistent state, consistent state with a non-default 04725 action, or user semantic action that manipulated yychar. 04726 - Of course, the expected token list depends on states to have 04727 correct lookahead information, and it depends on the parser not 04728 to perform extra reductions after fetching a lookahead from the 04729 scanner and before detecting a syntax error. Thus, state merging 04730 (from LALR or IELR) and default reductions corrupt the expected 04731 token list. However, the list is correct for canonical LR with 04732 one exception: it will still contain any token that will not be 04733 accepted due to an error action in a later state. 04734 */ 04735 if (yytoken != YYEMPTY) 04736 { 04737 int yyn = yypact[*yyssp]; 04738 yyarg[yycount++] = yytname[yytoken]; 04739 if (!yypact_value_is_default (yyn)) 04740 { 04741 /* Start YYX at -YYN if negative to avoid negative indexes in 04742 YYCHECK. In other words, skip the first -YYN actions for 04743 this state because they are default actions. */ 04744 int yyxbegin = yyn < 0 ? -yyn : 0; 04745 /* Stay within bounds of both yycheck and yytname. */ 04746 int yychecklim = YYLAST - yyn + 1; 04747 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 04748 int yyx; 04749 04750 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 04751 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 04752 && !yytable_value_is_error (yytable[yyx + yyn])) 04753 { 04754 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 04755 { 04756 yycount = 1; 04757 yysize = yysize0; 04758 break; 04759 } 04760 yyarg[yycount++] = yytname[yyx]; 04761 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 04762 if (! (yysize <= yysize1 04763 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 04764 return 2; 04765 yysize = yysize1; 04766 } 04767 } 04768 } 04769 04770 switch (yycount) 04771 { 04772 # define YYCASE_(N, S) \ 04773 case N: \ 04774 yyformat = S; \ 04775 break 04776 YYCASE_(0, YY_("syntax error")); 04777 YYCASE_(1, YY_("syntax error, unexpected %s")); 04778 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 04779 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 04780 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 04781 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 04782 # undef YYCASE_ 04783 } 04784 04785 yysize1 = yysize + yystrlen (yyformat); 04786 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 04787 return 2; 04788 yysize = yysize1; 04789 04790 if (*yymsg_alloc < yysize) 04791 { 04792 *yymsg_alloc = 2 * yysize; 04793 if (! (yysize <= *yymsg_alloc 04794 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 04795 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 04796 return 1; 04797 } 04798 04799 /* Avoid sprintf, as that infringes on the user's name space. 04800 Don't have undefined behavior even if the translation 04801 produced a string with the wrong number of "%s"s. */ 04802 { 04803 char *yyp = *yymsg; 04804 int yyi = 0; 04805 while ((*yyp = *yyformat) != '\0') 04806 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 04807 { 04808 yyp += yytnamerr (yyp, yyarg[yyi++]); 04809 yyformat += 2; 04810 } 04811 else 04812 { 04813 yyp++; 04814 yyformat++; 04815 } 04816 } 04817 return 0; 04818 } 04819 #endif /* YYERROR_VERBOSE */ 04820 04821 /*-----------------------------------------------. 04822 | Release the memory associated to this symbol. | 04823 `-----------------------------------------------*/ 04824 04825 /*ARGSUSED*/ 04826 #if (defined __STDC__ || defined __C99__FUNC__ \ 04827 || defined __cplusplus || defined _MSC_VER) 04828 static void 04829 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser) 04830 #else 04831 static void 04832 yydestruct (yymsg, yytype, yyvaluep, parser) 04833 const char *yymsg; 04834 int yytype; 04835 YYSTYPE *yyvaluep; 04836 struct parser_params *parser; 04837 #endif 04838 { 04839 YYUSE (yyvaluep); 04840 YYUSE (parser); 04841 04842 if (!yymsg) 04843 yymsg = "Deleting"; 04844 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 04845 04846 switch (yytype) 04847 { 04848 04849 default: 04850 break; 04851 } 04852 } 04853 04854 04855 /* Prevent warnings from -Wmissing-prototypes. */ 04856 #ifdef YYPARSE_PARAM 04857 #if defined __STDC__ || defined __cplusplus 04858 int yyparse (void *YYPARSE_PARAM); 04859 #else 04860 int yyparse (); 04861 #endif 04862 #else /* ! YYPARSE_PARAM */ 04863 #if defined __STDC__ || defined __cplusplus 04864 int yyparse (struct parser_params *parser); 04865 #else 04866 int yyparse (); 04867 #endif 04868 #endif /* ! YYPARSE_PARAM */ 04869 04870 04871 /*----------. 04872 | yyparse. | 04873 `----------*/ 04874 04875 #ifdef YYPARSE_PARAM 04876 #if (defined __STDC__ || defined __C99__FUNC__ \ 04877 || defined __cplusplus || defined _MSC_VER) 04878 int 04879 yyparse (void *YYPARSE_PARAM) 04880 #else 04881 int 04882 yyparse (YYPARSE_PARAM) 04883 void *YYPARSE_PARAM; 04884 #endif 04885 #else /* ! YYPARSE_PARAM */ 04886 #if (defined __STDC__ || defined __C99__FUNC__ \ 04887 || defined __cplusplus || defined _MSC_VER) 04888 int 04889 yyparse (struct parser_params *parser) 04890 #else 04891 int 04892 yyparse (parser) 04893 struct parser_params *parser; 04894 #endif 04895 #endif 04896 { 04897 /* The lookahead symbol. */ 04898 int yychar; 04899 04900 /* The semantic value of the lookahead symbol. */ 04901 YYSTYPE yylval; 04902 04903 /* Number of syntax errors so far. */ 04904 int yynerrs; 04905 04906 int yystate; 04907 /* Number of tokens to shift before error messages enabled. */ 04908 int yyerrstatus; 04909 04910 /* The stacks and their tools: 04911 `yyss': related to states. 04912 `yyvs': related to semantic values. 04913 04914 Refer to the stacks thru separate pointers, to allow yyoverflow 04915 to reallocate them elsewhere. */ 04916 04917 /* The state stack. */ 04918 yytype_int16 yyssa[YYINITDEPTH]; 04919 yytype_int16 *yyss; 04920 yytype_int16 *yyssp; 04921 04922 /* The semantic value stack. */ 04923 YYSTYPE yyvsa[YYINITDEPTH]; 04924 YYSTYPE *yyvs; 04925 YYSTYPE *yyvsp; 04926 04927 YYSIZE_T yystacksize; 04928 04929 int yyn; 04930 int yyresult; 04931 /* Lookahead token as an internal (translated) token number. */ 04932 int yytoken; 04933 /* The variables used to return semantic value and location from the 04934 action routines. */ 04935 YYSTYPE yyval; 04936 04937 #if YYERROR_VERBOSE 04938 /* Buffer for error messages, and its allocated size. */ 04939 char yymsgbuf[128]; 04940 char *yymsg = yymsgbuf; 04941 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 04942 #endif 04943 04944 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 04945 04946 /* The number of symbols on the RHS of the reduced rule. 04947 Keep to zero when no symbol should be popped. */ 04948 int yylen = 0; 04949 04950 yytoken = 0; 04951 yyss = yyssa; 04952 yyvs = yyvsa; 04953 yystacksize = YYINITDEPTH; 04954 04955 YYDPRINTF ((stderr, "Starting parse\n")); 04956 04957 yystate = 0; 04958 yyerrstatus = 0; 04959 yynerrs = 0; 04960 yychar = YYEMPTY; /* Cause a token to be read. */ 04961 04962 /* Initialize stack pointers. 04963 Waste one element of value and location stack 04964 so that they stay on the same level as the state stack. 04965 The wasted elements are never initialized. */ 04966 yyssp = yyss; 04967 yyvsp = yyvs; 04968 04969 goto yysetstate; 04970 04971 /*------------------------------------------------------------. 04972 | yynewstate -- Push a new state, which is found in yystate. | 04973 `------------------------------------------------------------*/ 04974 yynewstate: 04975 /* In all cases, when you get here, the value and location stacks 04976 have just been pushed. So pushing a state here evens the stacks. */ 04977 yyssp++; 04978 04979 yysetstate: 04980 *yyssp = yystate; 04981 04982 if (yyss + yystacksize - 1 <= yyssp) 04983 { 04984 /* Get the current used size of the three stacks, in elements. */ 04985 YYSIZE_T yysize = yyssp - yyss + 1; 04986 04987 #ifdef yyoverflow 04988 { 04989 /* Give user a chance to reallocate the stack. Use copies of 04990 these so that the &'s don't force the real ones into 04991 memory. */ 04992 YYSTYPE *yyvs1 = yyvs; 04993 yytype_int16 *yyss1 = yyss; 04994 04995 /* Each stack pointer address is followed by the size of the 04996 data in use in that stack, in bytes. This used to be a 04997 conditional around just the two extra args, but that might 04998 be undefined if yyoverflow is a macro. */ 04999 yyoverflow (YY_("memory exhausted"), 05000 &yyss1, yysize * sizeof (*yyssp), 05001 &yyvs1, yysize * sizeof (*yyvsp), 05002 &yystacksize); 05003 05004 yyss = yyss1; 05005 yyvs = yyvs1; 05006 } 05007 #else /* no yyoverflow */ 05008 # ifndef YYSTACK_RELOCATE 05009 goto yyexhaustedlab; 05010 # else 05011 /* Extend the stack our own way. */ 05012 if (YYMAXDEPTH <= yystacksize) 05013 goto yyexhaustedlab; 05014 yystacksize *= 2; 05015 if (YYMAXDEPTH < yystacksize) 05016 yystacksize = YYMAXDEPTH; 05017 05018 { 05019 yytype_int16 *yyss1 = yyss; 05020 union yyalloc *yyptr = 05021 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 05022 if (! yyptr) 05023 goto yyexhaustedlab; 05024 YYSTACK_RELOCATE (yyss_alloc, yyss); 05025 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 05026 # undef YYSTACK_RELOCATE 05027 if (yyss1 != yyssa) 05028 YYSTACK_FREE (yyss1); 05029 } 05030 # endif 05031 #endif /* no yyoverflow */ 05032 05033 yyssp = yyss + yysize - 1; 05034 yyvsp = yyvs + yysize - 1; 05035 05036 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 05037 (unsigned long int) yystacksize)); 05038 05039 if (yyss + yystacksize - 1 <= yyssp) 05040 YYABORT; 05041 } 05042 05043 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 05044 05045 if (yystate == YYFINAL) 05046 YYACCEPT; 05047 05048 goto yybackup; 05049 05050 /*-----------. 05051 | yybackup. | 05052 `-----------*/ 05053 yybackup: 05054 05055 /* Do appropriate processing given the current state. Read a 05056 lookahead token if we need one and don't already have one. */ 05057 05058 /* First try to decide what to do without reference to lookahead token. */ 05059 yyn = yypact[yystate]; 05060 if (yypact_value_is_default (yyn)) 05061 goto yydefault; 05062 05063 /* Not known => get a lookahead token if don't already have one. */ 05064 05065 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 05066 if (yychar == YYEMPTY) 05067 { 05068 YYDPRINTF ((stderr, "Reading a token: ")); 05069 yychar = YYLEX; 05070 } 05071 05072 if (yychar <= YYEOF) 05073 { 05074 yychar = yytoken = YYEOF; 05075 YYDPRINTF ((stderr, "Now at end of input.\n")); 05076 } 05077 else 05078 { 05079 yytoken = YYTRANSLATE (yychar); 05080 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 05081 } 05082 05083 /* If the proper action on seeing token YYTOKEN is to reduce or to 05084 detect an error, take that action. */ 05085 yyn += yytoken; 05086 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 05087 goto yydefault; 05088 yyn = yytable[yyn]; 05089 if (yyn <= 0) 05090 { 05091 if (yytable_value_is_error (yyn)) 05092 goto yyerrlab; 05093 yyn = -yyn; 05094 goto yyreduce; 05095 } 05096 05097 /* Count tokens shifted since error; after three, turn off error 05098 status. */ 05099 if (yyerrstatus) 05100 yyerrstatus--; 05101 05102 /* Shift the lookahead token. */ 05103 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 05104 05105 /* Discard the shifted token. */ 05106 yychar = YYEMPTY; 05107 05108 yystate = yyn; 05109 *++yyvsp = yylval; 05110 05111 goto yynewstate; 05112 05113 05114 /*-----------------------------------------------------------. 05115 | yydefault -- do the default action for the current state. | 05116 `-----------------------------------------------------------*/ 05117 yydefault: 05118 yyn = yydefact[yystate]; 05119 if (yyn == 0) 05120 goto yyerrlab; 05121 goto yyreduce; 05122 05123 05124 /*-----------------------------. 05125 | yyreduce -- Do a reduction. | 05126 `-----------------------------*/ 05127 yyreduce: 05128 /* yyn is the number of a rule to reduce with. */ 05129 yylen = yyr2[yyn]; 05130 05131 /* If YYLEN is nonzero, implement the default value of the action: 05132 `$$ = $1'. 05133 05134 Otherwise, the following line sets YYVAL to garbage. 05135 This behavior is undocumented and Bison 05136 users should not rely upon it. Assigning to YYVAL 05137 unconditionally makes the parser a bit smaller, and it avoids a 05138 GCC warning that YYVAL may be used uninitialized. */ 05139 yyval = yyvsp[1-yylen]; 05140 05141 05142 YY_REDUCE_PRINT (yyn); 05143 switch (yyn) 05144 { 05145 case 2: 05146 05147 /* Line 1806 of yacc.c */ 05148 #line 855 "ripper.y" 05149 { 05150 lex_state = EXPR_BEG; 05151 #if 0 05152 local_push(compile_for_eval || rb_parse_in_main()); 05153 #endif 05154 local_push(0); 05155 05156 } 05157 break; 05158 05159 case 3: 05160 05161 /* Line 1806 of yacc.c */ 05162 #line 864 "ripper.y" 05163 { 05164 #if 0 05165 if ((yyvsp[(2) - (2)].val) && !compile_for_eval) { 05166 /* last expression should not be void */ 05167 if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val)); 05168 else { 05169 NODE *node = (yyvsp[(2) - (2)].val); 05170 while (node->nd_next) { 05171 node = node->nd_next; 05172 } 05173 void_expr(node->nd_head); 05174 } 05175 } 05176 ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val))); 05177 #endif 05178 (yyval.val) = (yyvsp[(2) - (2)].val); 05179 parser->result = dispatch1(program, (yyval.val)); 05180 05181 local_pop(); 05182 } 05183 break; 05184 05185 case 4: 05186 05187 /* Line 1806 of yacc.c */ 05188 #line 887 "ripper.y" 05189 { 05190 #if 0 05191 void_stmts((yyvsp[(1) - (2)].val)); 05192 fixup_nodes(&deferred_nodes); 05193 #endif 05194 05195 (yyval.val) = (yyvsp[(1) - (2)].val); 05196 } 05197 break; 05198 05199 case 5: 05200 05201 /* Line 1806 of yacc.c */ 05202 #line 898 "ripper.y" 05203 { 05204 #if 0 05205 (yyval.val) = NEW_BEGIN(0); 05206 #endif 05207 (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), 05208 dispatch0(void_stmt)); 05209 05210 } 05211 break; 05212 05213 case 6: 05214 05215 /* Line 1806 of yacc.c */ 05216 #line 907 "ripper.y" 05217 { 05218 #if 0 05219 (yyval.val) = newline_node((yyvsp[(1) - (1)].val)); 05220 #endif 05221 (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val)); 05222 05223 } 05224 break; 05225 05226 case 7: 05227 05228 /* Line 1806 of yacc.c */ 05229 #line 915 "ripper.y" 05230 { 05231 #if 0 05232 (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val))); 05233 #endif 05234 (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05235 05236 } 05237 break; 05238 05239 case 8: 05240 05241 /* Line 1806 of yacc.c */ 05242 #line 923 "ripper.y" 05243 { 05244 (yyval.val) = remove_begin((yyvsp[(2) - (2)].val)); 05245 } 05246 break; 05247 05248 case 10: 05249 05250 /* Line 1806 of yacc.c */ 05251 #line 930 "ripper.y" 05252 { 05253 #if 0 05254 /* local_push(0); */ 05255 #endif 05256 05257 } 05258 break; 05259 05260 case 11: 05261 05262 /* Line 1806 of yacc.c */ 05263 #line 937 "ripper.y" 05264 { 05265 #if 0 05266 ruby_eval_tree_begin = block_append(ruby_eval_tree_begin, 05267 (yyvsp[(4) - (5)].val)); 05268 /* NEW_PREEXE($4)); */ 05269 /* local_pop(); */ 05270 (yyval.val) = NEW_BEGIN(0); 05271 #endif 05272 (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val)); 05273 05274 } 05275 break; 05276 05277 case 12: 05278 05279 /* Line 1806 of yacc.c */ 05280 #line 954 "ripper.y" 05281 { 05282 #if 0 05283 (yyval.val) = (yyvsp[(1) - (4)].val); 05284 if ((yyvsp[(2) - (4)].val)) { 05285 (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val)); 05286 } 05287 else if ((yyvsp[(3) - (4)].val)) { 05288 rb_warn0("else without rescue is useless"); 05289 (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val)); 05290 } 05291 if ((yyvsp[(4) - (4)].val)) { 05292 if ((yyval.val)) { 05293 (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val)); 05294 } 05295 else { 05296 (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL()); 05297 } 05298 } 05299 fixpos((yyval.val), (yyvsp[(1) - (4)].val)); 05300 #endif 05301 (yyval.val) = dispatch4(bodystmt, 05302 escape_Qundef((yyvsp[(1) - (4)].val)), 05303 escape_Qundef((yyvsp[(2) - (4)].val)), 05304 escape_Qundef((yyvsp[(3) - (4)].val)), 05305 escape_Qundef((yyvsp[(4) - (4)].val))); 05306 05307 } 05308 break; 05309 05310 case 13: 05311 05312 /* Line 1806 of yacc.c */ 05313 #line 984 "ripper.y" 05314 { 05315 #if 0 05316 void_stmts((yyvsp[(1) - (2)].val)); 05317 fixup_nodes(&deferred_nodes); 05318 #endif 05319 05320 (yyval.val) = (yyvsp[(1) - (2)].val); 05321 } 05322 break; 05323 05324 case 14: 05325 05326 /* Line 1806 of yacc.c */ 05327 #line 995 "ripper.y" 05328 { 05329 #if 0 05330 (yyval.val) = NEW_BEGIN(0); 05331 #endif 05332 (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), 05333 dispatch0(void_stmt)); 05334 05335 } 05336 break; 05337 05338 case 15: 05339 05340 /* Line 1806 of yacc.c */ 05341 #line 1004 "ripper.y" 05342 { 05343 #if 0 05344 (yyval.val) = newline_node((yyvsp[(1) - (1)].val)); 05345 #endif 05346 (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val)); 05347 05348 } 05349 break; 05350 05351 case 16: 05352 05353 /* Line 1806 of yacc.c */ 05354 #line 1012 "ripper.y" 05355 { 05356 #if 0 05357 (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val))); 05358 #endif 05359 (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05360 05361 } 05362 break; 05363 05364 case 17: 05365 05366 /* Line 1806 of yacc.c */ 05367 #line 1020 "ripper.y" 05368 { 05369 (yyval.val) = remove_begin((yyvsp[(2) - (2)].val)); 05370 } 05371 break; 05372 05373 case 18: 05374 05375 /* Line 1806 of yacc.c */ 05376 #line 1026 "ripper.y" 05377 { 05378 (yyval.val) = (yyvsp[(1) - (1)].val); 05379 } 05380 break; 05381 05382 case 19: 05383 05384 /* Line 1806 of yacc.c */ 05385 #line 1030 "ripper.y" 05386 { 05387 yyerror("BEGIN is permitted only at toplevel"); 05388 #if 0 05389 /* local_push(0); */ 05390 #endif 05391 05392 } 05393 break; 05394 05395 case 20: 05396 05397 /* Line 1806 of yacc.c */ 05398 #line 1038 "ripper.y" 05399 { 05400 #if 0 05401 ruby_eval_tree_begin = block_append(ruby_eval_tree_begin, 05402 (yyvsp[(4) - (5)].val)); 05403 /* NEW_PREEXE($4)); */ 05404 /* local_pop(); */ 05405 (yyval.val) = NEW_BEGIN(0); 05406 #endif 05407 (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val)); 05408 05409 } 05410 break; 05411 05412 case 21: 05413 05414 /* Line 1806 of yacc.c */ 05415 #line 1050 "ripper.y" 05416 {lex_state = EXPR_FNAME;} 05417 break; 05418 05419 case 22: 05420 05421 /* Line 1806 of yacc.c */ 05422 #line 1051 "ripper.y" 05423 { 05424 #if 0 05425 (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val)); 05426 #endif 05427 (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val)); 05428 05429 } 05430 break; 05431 05432 case 23: 05433 05434 /* Line 1806 of yacc.c */ 05435 #line 1059 "ripper.y" 05436 { 05437 #if 0 05438 (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val)); 05439 #endif 05440 (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val)); 05441 05442 } 05443 break; 05444 05445 case 24: 05446 05447 /* Line 1806 of yacc.c */ 05448 #line 1067 "ripper.y" 05449 { 05450 #if 0 05451 char buf[2]; 05452 buf[0] = '$'; 05453 buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth; 05454 (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2)); 05455 #endif 05456 (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val)); 05457 05458 } 05459 break; 05460 05461 case 25: 05462 05463 /* Line 1806 of yacc.c */ 05464 #line 1078 "ripper.y" 05465 { 05466 #if 0 05467 yyerror("can't make alias for the number variables"); 05468 (yyval.val) = NEW_BEGIN(0); 05469 #endif 05470 (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val)); 05471 (yyval.val) = dispatch1(alias_error, (yyval.val)); 05472 05473 } 05474 break; 05475 05476 case 26: 05477 05478 /* Line 1806 of yacc.c */ 05479 #line 1088 "ripper.y" 05480 { 05481 #if 0 05482 (yyval.val) = (yyvsp[(2) - (2)].val); 05483 #endif 05484 (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val)); 05485 05486 } 05487 break; 05488 05489 case 27: 05490 05491 /* Line 1806 of yacc.c */ 05492 #line 1096 "ripper.y" 05493 { 05494 #if 0 05495 (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0); 05496 fixpos((yyval.val), (yyvsp[(3) - (3)].val)); 05497 #endif 05498 (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val)); 05499 05500 } 05501 break; 05502 05503 case 28: 05504 05505 /* Line 1806 of yacc.c */ 05506 #line 1105 "ripper.y" 05507 { 05508 #if 0 05509 (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0); 05510 fixpos((yyval.val), (yyvsp[(3) - (3)].val)); 05511 #endif 05512 (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val)); 05513 05514 } 05515 break; 05516 05517 case 29: 05518 05519 /* Line 1806 of yacc.c */ 05520 #line 1114 "ripper.y" 05521 { 05522 #if 0 05523 if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) { 05524 (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0); 05525 } 05526 else { 05527 (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1); 05528 } 05529 #endif 05530 (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val)); 05531 05532 } 05533 break; 05534 05535 case 30: 05536 05537 /* Line 1806 of yacc.c */ 05538 #line 1127 "ripper.y" 05539 { 05540 #if 0 05541 if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) { 05542 (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0); 05543 } 05544 else { 05545 (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1); 05546 } 05547 #endif 05548 (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val)); 05549 05550 } 05551 break; 05552 05553 case 31: 05554 05555 /* Line 1806 of yacc.c */ 05556 #line 1140 "ripper.y" 05557 { 05558 #if 0 05559 NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0); 05560 (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0); 05561 #endif 05562 (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05563 05564 } 05565 break; 05566 05567 case 32: 05568 05569 /* Line 1806 of yacc.c */ 05570 #line 1149 "ripper.y" 05571 { 05572 if (in_def || in_single) { 05573 rb_warn0("END in method; use at_exit"); 05574 } 05575 #if 0 05576 (yyval.val) = NEW_POSTEXE(NEW_NODE( 05577 NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */)); 05578 #endif 05579 (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val)); 05580 05581 } 05582 break; 05583 05584 case 34: 05585 05586 /* Line 1806 of yacc.c */ 05587 #line 1162 "ripper.y" 05588 { 05589 #if 0 05590 value_expr((yyvsp[(3) - (3)].val)); 05591 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val); 05592 (yyval.val) = (yyvsp[(1) - (3)].val); 05593 #endif 05594 (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05595 05596 } 05597 break; 05598 05599 case 35: 05600 05601 /* Line 1806 of yacc.c */ 05602 #line 1172 "ripper.y" 05603 { 05604 value_expr((yyvsp[(3) - (3)].val)); 05605 (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val)); 05606 } 05607 break; 05608 05609 case 36: 05610 05611 /* Line 1806 of yacc.c */ 05612 #line 1177 "ripper.y" 05613 { 05614 #if 0 05615 NODE *args; 05616 05617 value_expr((yyvsp[(6) - (6)].val)); 05618 if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY(); 05619 args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val)); 05620 if ((yyvsp[(5) - (6)].val) == tOROP) { 05621 (yyvsp[(5) - (6)].val) = 0; 05622 } 05623 else if ((yyvsp[(5) - (6)].val) == tANDOP) { 05624 (yyvsp[(5) - (6)].val) = 1; 05625 } 05626 (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args); 05627 fixpos((yyval.val), (yyvsp[(1) - (6)].val)); 05628 #endif 05629 (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val))); 05630 (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val)); 05631 05632 } 05633 break; 05634 05635 case 37: 05636 05637 /* Line 1806 of yacc.c */ 05638 #line 1198 "ripper.y" 05639 { 05640 value_expr((yyvsp[(5) - (5)].val)); 05641 (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 05642 } 05643 break; 05644 05645 case 38: 05646 05647 /* Line 1806 of yacc.c */ 05648 #line 1203 "ripper.y" 05649 { 05650 value_expr((yyvsp[(5) - (5)].val)); 05651 (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 05652 } 05653 break; 05654 05655 case 39: 05656 05657 /* Line 1806 of yacc.c */ 05658 #line 1208 "ripper.y" 05659 { 05660 #if 0 05661 (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val)); 05662 (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 05663 #endif 05664 (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val)); 05665 (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 05666 05667 } 05668 break; 05669 05670 case 40: 05671 05672 /* Line 1806 of yacc.c */ 05673 #line 1218 "ripper.y" 05674 { 05675 value_expr((yyvsp[(5) - (5)].val)); 05676 (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 05677 } 05678 break; 05679 05680 case 41: 05681 05682 /* Line 1806 of yacc.c */ 05683 #line 1223 "ripper.y" 05684 { 05685 #if 0 05686 rb_backref_error((yyvsp[(1) - (3)].val)); 05687 (yyval.val) = NEW_BEGIN(0); 05688 #endif 05689 (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val)); 05690 (yyval.val) = dispatch1(assign_error, (yyval.val)); 05691 05692 } 05693 break; 05694 05695 case 42: 05696 05697 /* Line 1806 of yacc.c */ 05698 #line 1233 "ripper.y" 05699 { 05700 #if 0 05701 value_expr((yyvsp[(3) - (3)].val)); 05702 (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05703 #endif 05704 (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05705 05706 } 05707 break; 05708 05709 case 43: 05710 05711 /* Line 1806 of yacc.c */ 05712 #line 1242 "ripper.y" 05713 { 05714 #if 0 05715 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val); 05716 (yyval.val) = (yyvsp[(1) - (3)].val); 05717 #endif 05718 (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05719 05720 } 05721 break; 05722 05723 case 44: 05724 05725 /* Line 1806 of yacc.c */ 05726 #line 1251 "ripper.y" 05727 { 05728 #if 0 05729 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val); 05730 (yyval.val) = (yyvsp[(1) - (3)].val); 05731 #endif 05732 (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05733 05734 } 05735 break; 05736 05737 case 46: 05738 05739 /* Line 1806 of yacc.c */ 05740 #line 1263 "ripper.y" 05741 { 05742 #if 0 05743 value_expr((yyvsp[(3) - (3)].val)); 05744 (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05745 #endif 05746 (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05747 05748 } 05749 break; 05750 05751 case 47: 05752 05753 /* Line 1806 of yacc.c */ 05754 #line 1272 "ripper.y" 05755 { 05756 #if 0 05757 value_expr((yyvsp[(3) - (3)].val)); 05758 (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05759 #endif 05760 (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05761 05762 } 05763 break; 05764 05765 case 49: 05766 05767 /* Line 1806 of yacc.c */ 05768 #line 1285 "ripper.y" 05769 { 05770 #if 0 05771 (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05772 #endif 05773 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val)); 05774 05775 } 05776 break; 05777 05778 case 50: 05779 05780 /* Line 1806 of yacc.c */ 05781 #line 1293 "ripper.y" 05782 { 05783 #if 0 05784 (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 05785 #endif 05786 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val)); 05787 05788 } 05789 break; 05790 05791 case 51: 05792 05793 /* Line 1806 of yacc.c */ 05794 #line 1301 "ripper.y" 05795 { 05796 #if 0 05797 (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!'); 05798 #endif 05799 (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val)); 05800 05801 } 05802 break; 05803 05804 case 52: 05805 05806 /* Line 1806 of yacc.c */ 05807 #line 1309 "ripper.y" 05808 { 05809 #if 0 05810 (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!'); 05811 #endif 05812 (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val)); 05813 05814 } 05815 break; 05816 05817 case 54: 05818 05819 /* Line 1806 of yacc.c */ 05820 #line 1320 "ripper.y" 05821 { 05822 #if 0 05823 value_expr((yyvsp[(1) - (1)].val)); 05824 (yyval.val) = (yyvsp[(1) - (1)].val); 05825 if (!(yyval.val)) (yyval.val) = NEW_NIL(); 05826 #endif 05827 (yyval.val) = (yyvsp[(1) - (1)].val); 05828 05829 } 05830 break; 05831 05832 case 58: 05833 05834 /* Line 1806 of yacc.c */ 05835 #line 1337 "ripper.y" 05836 { 05837 #if 0 05838 (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 05839 #endif 05840 (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val)); 05841 (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val)); 05842 05843 } 05844 break; 05845 05846 case 59: 05847 05848 /* Line 1806 of yacc.c */ 05849 #line 1348 "ripper.y" 05850 { 05851 (yyvsp[(1) - (1)].vars) = dyna_push(); 05852 #if 0 05853 (yyval.num) = ruby_sourceline; 05854 #endif 05855 05856 } 05857 break; 05858 05859 case 60: 05860 05861 /* Line 1806 of yacc.c */ 05862 #line 1358 "ripper.y" 05863 { 05864 #if 0 05865 (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val)); 05866 nd_set_line((yyval.val), (yyvsp[(2) - (5)].num)); 05867 #endif 05868 (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val)); 05869 05870 dyna_pop((yyvsp[(1) - (5)].vars)); 05871 } 05872 break; 05873 05874 case 61: 05875 05876 /* Line 1806 of yacc.c */ 05877 #line 1370 "ripper.y" 05878 { 05879 #if 0 05880 (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0); 05881 nd_set_line((yyval.val), tokline); 05882 #endif 05883 05884 } 05885 break; 05886 05887 case 62: 05888 05889 /* Line 1806 of yacc.c */ 05890 #line 1380 "ripper.y" 05891 { 05892 #if 0 05893 (yyval.val) = (yyvsp[(1) - (2)].val); 05894 (yyval.val)->nd_args = (yyvsp[(2) - (2)].val); 05895 #endif 05896 (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 05897 05898 } 05899 break; 05900 05901 case 63: 05902 05903 /* Line 1806 of yacc.c */ 05904 #line 1389 "ripper.y" 05905 { 05906 #if 0 05907 block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val)); 05908 (yyvsp[(1) - (3)].val)->nd_args = (yyvsp[(2) - (3)].val); 05909 (yyvsp[(3) - (3)].val)->nd_iter = (yyvsp[(1) - (3)].val); 05910 (yyval.val) = (yyvsp[(3) - (3)].val); 05911 fixpos((yyval.val), (yyvsp[(1) - (3)].val)); 05912 #endif 05913 (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val)); 05914 (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val)); 05915 05916 } 05917 break; 05918 05919 case 64: 05920 05921 /* Line 1806 of yacc.c */ 05922 #line 1402 "ripper.y" 05923 { 05924 #if 0 05925 (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 05926 fixpos((yyval.val), (yyvsp[(1) - (4)].val)); 05927 #endif 05928 (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 05929 05930 } 05931 break; 05932 05933 case 65: 05934 05935 /* Line 1806 of yacc.c */ 05936 #line 1411 "ripper.y" 05937 { 05938 #if 0 05939 block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val)); 05940 (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val)); 05941 (yyval.val) = (yyvsp[(5) - (5)].val); 05942 fixpos((yyval.val), (yyvsp[(1) - (5)].val)); 05943 #endif 05944 (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val)); 05945 (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val)); 05946 05947 } 05948 break; 05949 05950 case 66: 05951 05952 /* Line 1806 of yacc.c */ 05953 #line 1423 "ripper.y" 05954 { 05955 #if 0 05956 (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 05957 fixpos((yyval.val), (yyvsp[(1) - (4)].val)); 05958 #endif 05959 (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 05960 05961 } 05962 break; 05963 05964 case 67: 05965 05966 /* Line 1806 of yacc.c */ 05967 #line 1432 "ripper.y" 05968 { 05969 #if 0 05970 block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val)); 05971 (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val)); 05972 (yyval.val) = (yyvsp[(5) - (5)].val); 05973 fixpos((yyval.val), (yyvsp[(1) - (5)].val)); 05974 #endif 05975 (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val)); 05976 (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val)); 05977 05978 } 05979 break; 05980 05981 case 68: 05982 05983 /* Line 1806 of yacc.c */ 05984 #line 1444 "ripper.y" 05985 { 05986 #if 0 05987 (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val)); 05988 fixpos((yyval.val), (yyvsp[(2) - (2)].val)); 05989 #endif 05990 (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val)); 05991 05992 } 05993 break; 05994 05995 case 69: 05996 05997 /* Line 1806 of yacc.c */ 05998 #line 1453 "ripper.y" 05999 { 06000 #if 0 06001 (yyval.val) = new_yield((yyvsp[(2) - (2)].val)); 06002 fixpos((yyval.val), (yyvsp[(2) - (2)].val)); 06003 #endif 06004 (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val)); 06005 06006 } 06007 break; 06008 06009 case 70: 06010 06011 /* Line 1806 of yacc.c */ 06012 #line 1462 "ripper.y" 06013 { 06014 #if 0 06015 (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val))); 06016 #endif 06017 (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val)); 06018 06019 } 06020 break; 06021 06022 case 71: 06023 06024 /* Line 1806 of yacc.c */ 06025 #line 1470 "ripper.y" 06026 { 06027 #if 0 06028 (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val))); 06029 #endif 06030 (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val)); 06031 06032 } 06033 break; 06034 06035 case 72: 06036 06037 /* Line 1806 of yacc.c */ 06038 #line 1478 "ripper.y" 06039 { 06040 #if 0 06041 (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val))); 06042 #endif 06043 (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val)); 06044 06045 } 06046 break; 06047 06048 case 74: 06049 06050 /* Line 1806 of yacc.c */ 06051 #line 1489 "ripper.y" 06052 { 06053 #if 0 06054 (yyval.val) = (yyvsp[(2) - (3)].val); 06055 #endif 06056 (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val)); 06057 06058 } 06059 break; 06060 06061 case 76: 06062 06063 /* Line 1806 of yacc.c */ 06064 #line 1500 "ripper.y" 06065 { 06066 #if 0 06067 (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0); 06068 #endif 06069 (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val)); 06070 06071 } 06072 break; 06073 06074 case 77: 06075 06076 /* Line 1806 of yacc.c */ 06077 #line 1510 "ripper.y" 06078 { 06079 #if 0 06080 (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0); 06081 #endif 06082 (yyval.val) = (yyvsp[(1) - (1)].val); 06083 06084 } 06085 break; 06086 06087 case 78: 06088 06089 /* Line 1806 of yacc.c */ 06090 #line 1518 "ripper.y" 06091 { 06092 #if 0 06093 (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0); 06094 #endif 06095 (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 06096 06097 } 06098 break; 06099 06100 case 79: 06101 06102 /* Line 1806 of yacc.c */ 06103 #line 1526 "ripper.y" 06104 { 06105 #if 0 06106 (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06107 #endif 06108 (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06109 06110 } 06111 break; 06112 06113 case 80: 06114 06115 /* Line 1806 of yacc.c */ 06116 #line 1534 "ripper.y" 06117 { 06118 #if 0 06119 (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val))); 06120 #endif 06121 (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val)); 06122 (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val)); 06123 06124 } 06125 break; 06126 06127 case 81: 06128 06129 /* Line 1806 of yacc.c */ 06130 #line 1543 "ripper.y" 06131 { 06132 #if 0 06133 (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1); 06134 #endif 06135 (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil); 06136 06137 } 06138 break; 06139 06140 case 82: 06141 06142 /* Line 1806 of yacc.c */ 06143 #line 1551 "ripper.y" 06144 { 06145 #if 0 06146 (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val))); 06147 #endif 06148 (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil); 06149 (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val)); 06150 06151 } 06152 break; 06153 06154 case 83: 06155 06156 /* Line 1806 of yacc.c */ 06157 #line 1560 "ripper.y" 06158 { 06159 #if 0 06160 (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val)); 06161 #endif 06162 (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val)); 06163 06164 } 06165 break; 06166 06167 case 84: 06168 06169 /* Line 1806 of yacc.c */ 06170 #line 1568 "ripper.y" 06171 { 06172 #if 0 06173 (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val))); 06174 #endif 06175 (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val)); 06176 (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val)); 06177 06178 } 06179 break; 06180 06181 case 85: 06182 06183 /* Line 1806 of yacc.c */ 06184 #line 1577 "ripper.y" 06185 { 06186 #if 0 06187 (yyval.val) = NEW_MASGN(0, -1); 06188 #endif 06189 (yyval.val) = mlhs_add_star(mlhs_new(), Qnil); 06190 06191 } 06192 break; 06193 06194 case 86: 06195 06196 /* Line 1806 of yacc.c */ 06197 #line 1585 "ripper.y" 06198 { 06199 #if 0 06200 (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val))); 06201 #endif 06202 (yyval.val) = mlhs_add_star(mlhs_new(), Qnil); 06203 (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val)); 06204 06205 } 06206 break; 06207 06208 case 88: 06209 06210 /* Line 1806 of yacc.c */ 06211 #line 1597 "ripper.y" 06212 { 06213 #if 0 06214 (yyval.val) = (yyvsp[(2) - (3)].val); 06215 #endif 06216 (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val)); 06217 06218 } 06219 break; 06220 06221 case 89: 06222 06223 /* Line 1806 of yacc.c */ 06224 #line 1607 "ripper.y" 06225 { 06226 #if 0 06227 (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val)); 06228 #endif 06229 (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val)); 06230 06231 } 06232 break; 06233 06234 case 90: 06235 06236 /* Line 1806 of yacc.c */ 06237 #line 1615 "ripper.y" 06238 { 06239 #if 0 06240 (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val)); 06241 #endif 06242 (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val)); 06243 06244 } 06245 break; 06246 06247 case 91: 06248 06249 /* Line 1806 of yacc.c */ 06250 #line 1625 "ripper.y" 06251 { 06252 #if 0 06253 (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val)); 06254 #endif 06255 (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val)); 06256 06257 } 06258 break; 06259 06260 case 92: 06261 06262 /* Line 1806 of yacc.c */ 06263 #line 1633 "ripper.y" 06264 { 06265 #if 0 06266 (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06267 #endif 06268 (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06269 06270 } 06271 break; 06272 06273 case 93: 06274 06275 /* Line 1806 of yacc.c */ 06276 #line 1643 "ripper.y" 06277 { 06278 (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0); 06279 } 06280 break; 06281 06282 case 94: 06283 06284 /* Line 1806 of yacc.c */ 06285 #line 1647 "ripper.y" 06286 { 06287 (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0); 06288 } 06289 break; 06290 06291 case 95: 06292 06293 /* Line 1806 of yacc.c */ 06294 #line 1651 "ripper.y" 06295 { 06296 #if 0 06297 (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)); 06298 #endif 06299 (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val))); 06300 06301 } 06302 break; 06303 06304 case 96: 06305 06306 /* Line 1806 of yacc.c */ 06307 #line 1659 "ripper.y" 06308 { 06309 #if 0 06310 (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06311 #endif 06312 (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val)); 06313 06314 } 06315 break; 06316 06317 case 97: 06318 06319 /* Line 1806 of yacc.c */ 06320 #line 1667 "ripper.y" 06321 { 06322 #if 0 06323 (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06324 #endif 06325 (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06326 06327 } 06328 break; 06329 06330 case 98: 06331 06332 /* Line 1806 of yacc.c */ 06333 #line 1675 "ripper.y" 06334 { 06335 #if 0 06336 (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06337 #endif 06338 (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val)); 06339 06340 } 06341 break; 06342 06343 case 99: 06344 06345 /* Line 1806 of yacc.c */ 06346 #line 1683 "ripper.y" 06347 { 06348 #if 0 06349 if (in_def || in_single) 06350 yyerror("dynamic constant assignment"); 06351 (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val))); 06352 #endif 06353 if (in_def || in_single) 06354 yyerror("dynamic constant assignment"); 06355 (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06356 06357 } 06358 break; 06359 06360 case 100: 06361 06362 /* Line 1806 of yacc.c */ 06363 #line 1695 "ripper.y" 06364 { 06365 #if 0 06366 if (in_def || in_single) 06367 yyerror("dynamic constant assignment"); 06368 (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val))); 06369 #endif 06370 (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val)); 06371 06372 } 06373 break; 06374 06375 case 101: 06376 06377 /* Line 1806 of yacc.c */ 06378 #line 1705 "ripper.y" 06379 { 06380 #if 0 06381 rb_backref_error((yyvsp[(1) - (1)].val)); 06382 (yyval.val) = NEW_BEGIN(0); 06383 #endif 06384 (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val)); 06385 (yyval.val) = dispatch1(assign_error, (yyval.val)); 06386 06387 } 06388 break; 06389 06390 case 102: 06391 06392 /* Line 1806 of yacc.c */ 06393 #line 1717 "ripper.y" 06394 { 06395 (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0); 06396 #if 0 06397 if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0); 06398 #endif 06399 (yyval.val) = dispatch1(var_field, (yyval.val)); 06400 06401 } 06402 break; 06403 06404 case 103: 06405 06406 /* Line 1806 of yacc.c */ 06407 #line 1726 "ripper.y" 06408 { 06409 (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0); 06410 #if 0 06411 if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0); 06412 #endif 06413 (yyval.val) = dispatch1(var_field, (yyval.val)); 06414 06415 } 06416 break; 06417 06418 case 104: 06419 06420 /* Line 1806 of yacc.c */ 06421 #line 1735 "ripper.y" 06422 { 06423 #if 0 06424 (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)); 06425 #endif 06426 (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val))); 06427 06428 } 06429 break; 06430 06431 case 105: 06432 06433 /* Line 1806 of yacc.c */ 06434 #line 1743 "ripper.y" 06435 { 06436 #if 0 06437 (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06438 #endif 06439 (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val)); 06440 06441 } 06442 break; 06443 06444 case 106: 06445 06446 /* Line 1806 of yacc.c */ 06447 #line 1751 "ripper.y" 06448 { 06449 #if 0 06450 (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06451 #endif 06452 (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val)); 06453 06454 } 06455 break; 06456 06457 case 107: 06458 06459 /* Line 1806 of yacc.c */ 06460 #line 1759 "ripper.y" 06461 { 06462 #if 0 06463 (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06464 #endif 06465 (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val)); 06466 06467 } 06468 break; 06469 06470 case 108: 06471 06472 /* Line 1806 of yacc.c */ 06473 #line 1767 "ripper.y" 06474 { 06475 #if 0 06476 if (in_def || in_single) 06477 yyerror("dynamic constant assignment"); 06478 (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val))); 06479 #endif 06480 (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06481 if (in_def || in_single) { 06482 (yyval.val) = dispatch1(assign_error, (yyval.val)); 06483 } 06484 06485 } 06486 break; 06487 06488 case 109: 06489 06490 /* Line 1806 of yacc.c */ 06491 #line 1780 "ripper.y" 06492 { 06493 #if 0 06494 if (in_def || in_single) 06495 yyerror("dynamic constant assignment"); 06496 (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val))); 06497 #endif 06498 (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val)); 06499 if (in_def || in_single) { 06500 (yyval.val) = dispatch1(assign_error, (yyval.val)); 06501 } 06502 06503 } 06504 break; 06505 06506 case 110: 06507 06508 /* Line 1806 of yacc.c */ 06509 #line 1793 "ripper.y" 06510 { 06511 #if 0 06512 rb_backref_error((yyvsp[(1) - (1)].val)); 06513 (yyval.val) = NEW_BEGIN(0); 06514 #endif 06515 (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val)); 06516 06517 } 06518 break; 06519 06520 case 111: 06521 06522 /* Line 1806 of yacc.c */ 06523 #line 1804 "ripper.y" 06524 { 06525 #if 0 06526 yyerror("class/module name must be CONSTANT"); 06527 #endif 06528 (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val)); 06529 06530 } 06531 break; 06532 06533 case 113: 06534 06535 /* Line 1806 of yacc.c */ 06536 #line 1815 "ripper.y" 06537 { 06538 #if 0 06539 (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val)); 06540 #endif 06541 (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val)); 06542 06543 } 06544 break; 06545 06546 case 114: 06547 06548 /* Line 1806 of yacc.c */ 06549 #line 1823 "ripper.y" 06550 { 06551 #if 0 06552 (yyval.val) = NEW_COLON2(0, (yyval.val)); 06553 #endif 06554 (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val)); 06555 06556 } 06557 break; 06558 06559 case 115: 06560 06561 /* Line 1806 of yacc.c */ 06562 #line 1831 "ripper.y" 06563 { 06564 #if 0 06565 (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06566 #endif 06567 (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06568 06569 } 06570 break; 06571 06572 case 119: 06573 06574 /* Line 1806 of yacc.c */ 06575 #line 1844 "ripper.y" 06576 { 06577 lex_state = EXPR_ENDFN; 06578 (yyval.val) = (yyvsp[(1) - (1)].val); 06579 } 06580 break; 06581 06582 case 120: 06583 06584 /* Line 1806 of yacc.c */ 06585 #line 1849 "ripper.y" 06586 { 06587 lex_state = EXPR_ENDFN; 06588 #if 0 06589 (yyval.val) = (yyvsp[(1) - (1)].id); 06590 #endif 06591 (yyval.val) = (yyvsp[(1) - (1)].val); 06592 06593 } 06594 break; 06595 06596 case 123: 06597 06598 /* Line 1806 of yacc.c */ 06599 #line 1864 "ripper.y" 06600 { 06601 #if 0 06602 (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val))); 06603 #endif 06604 (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val)); 06605 06606 } 06607 break; 06608 06609 case 125: 06610 06611 /* Line 1806 of yacc.c */ 06612 #line 1875 "ripper.y" 06613 { 06614 #if 0 06615 (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val)); 06616 #endif 06617 (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val)); 06618 06619 } 06620 break; 06621 06622 case 126: 06623 06624 /* Line 1806 of yacc.c */ 06625 #line 1882 "ripper.y" 06626 {lex_state = EXPR_FNAME;} 06627 break; 06628 06629 case 127: 06630 06631 /* Line 1806 of yacc.c */ 06632 #line 1883 "ripper.y" 06633 { 06634 #if 0 06635 (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val))); 06636 #endif 06637 rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val)); 06638 06639 } 06640 break; 06641 06642 case 128: 06643 06644 /* Line 1806 of yacc.c */ 06645 #line 1892 "ripper.y" 06646 { ifndef_ripper((yyval.val) = '|'); } 06647 break; 06648 06649 case 129: 06650 06651 /* Line 1806 of yacc.c */ 06652 #line 1893 "ripper.y" 06653 { ifndef_ripper((yyval.val) = '^'); } 06654 break; 06655 06656 case 130: 06657 06658 /* Line 1806 of yacc.c */ 06659 #line 1894 "ripper.y" 06660 { ifndef_ripper((yyval.val) = '&'); } 06661 break; 06662 06663 case 131: 06664 06665 /* Line 1806 of yacc.c */ 06666 #line 1895 "ripper.y" 06667 { ifndef_ripper((yyval.val) = tCMP); } 06668 break; 06669 06670 case 132: 06671 06672 /* Line 1806 of yacc.c */ 06673 #line 1896 "ripper.y" 06674 { ifndef_ripper((yyval.val) = tEQ); } 06675 break; 06676 06677 case 133: 06678 06679 /* Line 1806 of yacc.c */ 06680 #line 1897 "ripper.y" 06681 { ifndef_ripper((yyval.val) = tEQQ); } 06682 break; 06683 06684 case 134: 06685 06686 /* Line 1806 of yacc.c */ 06687 #line 1898 "ripper.y" 06688 { ifndef_ripper((yyval.val) = tMATCH); } 06689 break; 06690 06691 case 135: 06692 06693 /* Line 1806 of yacc.c */ 06694 #line 1899 "ripper.y" 06695 { ifndef_ripper((yyval.val) = tNMATCH); } 06696 break; 06697 06698 case 136: 06699 06700 /* Line 1806 of yacc.c */ 06701 #line 1900 "ripper.y" 06702 { ifndef_ripper((yyval.val) = '>'); } 06703 break; 06704 06705 case 137: 06706 06707 /* Line 1806 of yacc.c */ 06708 #line 1901 "ripper.y" 06709 { ifndef_ripper((yyval.val) = tGEQ); } 06710 break; 06711 06712 case 138: 06713 06714 /* Line 1806 of yacc.c */ 06715 #line 1902 "ripper.y" 06716 { ifndef_ripper((yyval.val) = '<'); } 06717 break; 06718 06719 case 139: 06720 06721 /* Line 1806 of yacc.c */ 06722 #line 1903 "ripper.y" 06723 { ifndef_ripper((yyval.val) = tLEQ); } 06724 break; 06725 06726 case 140: 06727 06728 /* Line 1806 of yacc.c */ 06729 #line 1904 "ripper.y" 06730 { ifndef_ripper((yyval.val) = tNEQ); } 06731 break; 06732 06733 case 141: 06734 06735 /* Line 1806 of yacc.c */ 06736 #line 1905 "ripper.y" 06737 { ifndef_ripper((yyval.val) = tLSHFT); } 06738 break; 06739 06740 case 142: 06741 06742 /* Line 1806 of yacc.c */ 06743 #line 1906 "ripper.y" 06744 { ifndef_ripper((yyval.val) = tRSHFT); } 06745 break; 06746 06747 case 143: 06748 06749 /* Line 1806 of yacc.c */ 06750 #line 1907 "ripper.y" 06751 { ifndef_ripper((yyval.val) = '+'); } 06752 break; 06753 06754 case 144: 06755 06756 /* Line 1806 of yacc.c */ 06757 #line 1908 "ripper.y" 06758 { ifndef_ripper((yyval.val) = '-'); } 06759 break; 06760 06761 case 145: 06762 06763 /* Line 1806 of yacc.c */ 06764 #line 1909 "ripper.y" 06765 { ifndef_ripper((yyval.val) = '*'); } 06766 break; 06767 06768 case 146: 06769 06770 /* Line 1806 of yacc.c */ 06771 #line 1910 "ripper.y" 06772 { ifndef_ripper((yyval.val) = '*'); } 06773 break; 06774 06775 case 147: 06776 06777 /* Line 1806 of yacc.c */ 06778 #line 1911 "ripper.y" 06779 { ifndef_ripper((yyval.val) = '/'); } 06780 break; 06781 06782 case 148: 06783 06784 /* Line 1806 of yacc.c */ 06785 #line 1912 "ripper.y" 06786 { ifndef_ripper((yyval.val) = '%'); } 06787 break; 06788 06789 case 149: 06790 06791 /* Line 1806 of yacc.c */ 06792 #line 1913 "ripper.y" 06793 { ifndef_ripper((yyval.val) = tPOW); } 06794 break; 06795 06796 case 150: 06797 06798 /* Line 1806 of yacc.c */ 06799 #line 1914 "ripper.y" 06800 { ifndef_ripper((yyval.val) = tDSTAR); } 06801 break; 06802 06803 case 151: 06804 06805 /* Line 1806 of yacc.c */ 06806 #line 1915 "ripper.y" 06807 { ifndef_ripper((yyval.val) = '!'); } 06808 break; 06809 06810 case 152: 06811 06812 /* Line 1806 of yacc.c */ 06813 #line 1916 "ripper.y" 06814 { ifndef_ripper((yyval.val) = '~'); } 06815 break; 06816 06817 case 153: 06818 06819 /* Line 1806 of yacc.c */ 06820 #line 1917 "ripper.y" 06821 { ifndef_ripper((yyval.val) = tUPLUS); } 06822 break; 06823 06824 case 154: 06825 06826 /* Line 1806 of yacc.c */ 06827 #line 1918 "ripper.y" 06828 { ifndef_ripper((yyval.val) = tUMINUS); } 06829 break; 06830 06831 case 155: 06832 06833 /* Line 1806 of yacc.c */ 06834 #line 1919 "ripper.y" 06835 { ifndef_ripper((yyval.val) = tAREF); } 06836 break; 06837 06838 case 156: 06839 06840 /* Line 1806 of yacc.c */ 06841 #line 1920 "ripper.y" 06842 { ifndef_ripper((yyval.val) = tASET); } 06843 break; 06844 06845 case 157: 06846 06847 /* Line 1806 of yacc.c */ 06848 #line 1921 "ripper.y" 06849 { ifndef_ripper((yyval.val) = '`'); } 06850 break; 06851 06852 case 199: 06853 06854 /* Line 1806 of yacc.c */ 06855 #line 1939 "ripper.y" 06856 { 06857 #if 0 06858 value_expr((yyvsp[(3) - (3)].val)); 06859 (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06860 #endif 06861 (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 06862 06863 } 06864 break; 06865 06866 case 200: 06867 06868 /* Line 1806 of yacc.c */ 06869 #line 1948 "ripper.y" 06870 { 06871 #if 0 06872 value_expr((yyvsp[(3) - (5)].val)); 06873 (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0); 06874 (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val)); 06875 #endif 06876 (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val))); 06877 06878 } 06879 break; 06880 06881 case 201: 06882 06883 /* Line 1806 of yacc.c */ 06884 #line 1958 "ripper.y" 06885 { 06886 value_expr((yyvsp[(3) - (3)].val)); 06887 (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val)); 06888 } 06889 break; 06890 06891 case 202: 06892 06893 /* Line 1806 of yacc.c */ 06894 #line 1963 "ripper.y" 06895 { 06896 #if 0 06897 value_expr((yyvsp[(3) - (5)].val)); 06898 (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0); 06899 #endif 06900 (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)); 06901 06902 (yyval.val) = new_op_assign((yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val)); 06903 } 06904 break; 06905 06906 case 203: 06907 06908 /* Line 1806 of yacc.c */ 06909 #line 1973 "ripper.y" 06910 { 06911 #if 0 06912 NODE *args; 06913 06914 value_expr((yyvsp[(6) - (6)].val)); 06915 if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY(); 06916 if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) { 06917 args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val)); 06918 } 06919 else { 06920 args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val)); 06921 } 06922 if ((yyvsp[(5) - (6)].val) == tOROP) { 06923 (yyvsp[(5) - (6)].val) = 0; 06924 } 06925 else if ((yyvsp[(5) - (6)].val) == tANDOP) { 06926 (yyvsp[(5) - (6)].val) = 1; 06927 } 06928 (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args); 06929 fixpos((yyval.val), (yyvsp[(1) - (6)].val)); 06930 #endif 06931 (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val))); 06932 (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val)); 06933 06934 } 06935 break; 06936 06937 case 204: 06938 06939 /* Line 1806 of yacc.c */ 06940 #line 1999 "ripper.y" 06941 { 06942 value_expr((yyvsp[(5) - (5)].val)); 06943 (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 06944 } 06945 break; 06946 06947 case 205: 06948 06949 /* Line 1806 of yacc.c */ 06950 #line 2004 "ripper.y" 06951 { 06952 value_expr((yyvsp[(5) - (5)].val)); 06953 (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 06954 } 06955 break; 06956 06957 case 206: 06958 06959 /* Line 1806 of yacc.c */ 06960 #line 2009 "ripper.y" 06961 { 06962 value_expr((yyvsp[(5) - (5)].val)); 06963 (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 06964 } 06965 break; 06966 06967 case 207: 06968 06969 /* Line 1806 of yacc.c */ 06970 #line 2014 "ripper.y" 06971 { 06972 #if 0 06973 (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val)); 06974 (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 06975 #endif 06976 (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val)); 06977 (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 06978 06979 } 06980 break; 06981 06982 case 208: 06983 06984 /* Line 1806 of yacc.c */ 06985 #line 2024 "ripper.y" 06986 { 06987 #if 0 06988 (yyval.val) = NEW_COLON3((yyvsp[(2) - (4)].val)); 06989 (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 06990 #endif 06991 (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val)); 06992 (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 06993 06994 } 06995 break; 06996 06997 case 209: 06998 06999 /* Line 1806 of yacc.c */ 07000 #line 2034 "ripper.y" 07001 { 07002 #if 0 07003 rb_backref_error((yyvsp[(1) - (3)].val)); 07004 (yyval.val) = NEW_BEGIN(0); 07005 #endif 07006 (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val)); 07007 (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val)); 07008 (yyval.val) = dispatch1(assign_error, (yyval.val)); 07009 07010 } 07011 break; 07012 07013 case 210: 07014 07015 /* Line 1806 of yacc.c */ 07016 #line 2045 "ripper.y" 07017 { 07018 #if 0 07019 value_expr((yyvsp[(1) - (3)].val)); 07020 value_expr((yyvsp[(3) - (3)].val)); 07021 (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 07022 if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) && 07023 nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) { 07024 deferred_nodes = list_append(deferred_nodes, (yyval.val)); 07025 } 07026 #endif 07027 (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 07028 07029 } 07030 break; 07031 07032 case 211: 07033 07034 /* Line 1806 of yacc.c */ 07035 #line 2059 "ripper.y" 07036 { 07037 #if 0 07038 value_expr((yyvsp[(1) - (3)].val)); 07039 value_expr((yyvsp[(3) - (3)].val)); 07040 (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 07041 if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) && 07042 nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) { 07043 deferred_nodes = list_append(deferred_nodes, (yyval.val)); 07044 } 07045 #endif 07046 (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 07047 07048 } 07049 break; 07050 07051 case 212: 07052 07053 /* Line 1806 of yacc.c */ 07054 #line 2073 "ripper.y" 07055 { 07056 #if 0 07057 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val)); 07058 #endif 07059 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val)); 07060 07061 } 07062 break; 07063 07064 case 213: 07065 07066 /* Line 1806 of yacc.c */ 07067 #line 2081 "ripper.y" 07068 { 07069 #if 0 07070 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val)); 07071 #endif 07072 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val)); 07073 07074 } 07075 break; 07076 07077 case 214: 07078 07079 /* Line 1806 of yacc.c */ 07080 #line 2089 "ripper.y" 07081 { 07082 #if 0 07083 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val)); 07084 #endif 07085 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val)); 07086 07087 } 07088 break; 07089 07090 case 215: 07091 07092 /* Line 1806 of yacc.c */ 07093 #line 2097 "ripper.y" 07094 { 07095 #if 0 07096 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val)); 07097 #endif 07098 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val)); 07099 07100 } 07101 break; 07102 07103 case 216: 07104 07105 /* Line 1806 of yacc.c */ 07106 #line 2105 "ripper.y" 07107 { 07108 #if 0 07109 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val)); 07110 #endif 07111 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val)); 07112 07113 } 07114 break; 07115 07116 case 217: 07117 07118 /* Line 1806 of yacc.c */ 07119 #line 2113 "ripper.y" 07120 { 07121 #if 0 07122 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val)); 07123 #endif 07124 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val)); 07125 07126 } 07127 break; 07128 07129 case 218: 07130 07131 /* Line 1806 of yacc.c */ 07132 #line 2121 "ripper.y" 07133 { 07134 #if 0 07135 (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0); 07136 #endif 07137 (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val)); 07138 (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val)); 07139 07140 } 07141 break; 07142 07143 case 219: 07144 07145 /* Line 1806 of yacc.c */ 07146 #line 2130 "ripper.y" 07147 { 07148 #if 0 07149 (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0); 07150 #endif 07151 (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val)); 07152 (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val)); 07153 07154 } 07155 break; 07156 07157 case 220: 07158 07159 /* Line 1806 of yacc.c */ 07160 #line 2139 "ripper.y" 07161 { 07162 #if 0 07163 (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS); 07164 #endif 07165 (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val)); 07166 07167 } 07168 break; 07169 07170 case 221: 07171 07172 /* Line 1806 of yacc.c */ 07173 #line 2147 "ripper.y" 07174 { 07175 #if 0 07176 (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS); 07177 #endif 07178 (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val)); 07179 07180 } 07181 break; 07182 07183 case 222: 07184 07185 /* Line 1806 of yacc.c */ 07186 #line 2155 "ripper.y" 07187 { 07188 #if 0 07189 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val)); 07190 #endif 07191 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('|'), (yyvsp[(3) - (3)].val)); 07192 07193 } 07194 break; 07195 07196 case 223: 07197 07198 /* Line 1806 of yacc.c */ 07199 #line 2163 "ripper.y" 07200 { 07201 #if 0 07202 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val)); 07203 #endif 07204 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val)); 07205 07206 } 07207 break; 07208 07209 case 224: 07210 07211 /* Line 1806 of yacc.c */ 07212 #line 2171 "ripper.y" 07213 { 07214 #if 0 07215 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val)); 07216 #endif 07217 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val)); 07218 07219 } 07220 break; 07221 07222 case 225: 07223 07224 /* Line 1806 of yacc.c */ 07225 #line 2179 "ripper.y" 07226 { 07227 #if 0 07228 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val)); 07229 #endif 07230 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val)); 07231 07232 } 07233 break; 07234 07235 case 226: 07236 07237 /* Line 1806 of yacc.c */ 07238 #line 2187 "ripper.y" 07239 { 07240 #if 0 07241 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val)); 07242 #endif 07243 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val)); 07244 07245 } 07246 break; 07247 07248 case 227: 07249 07250 /* Line 1806 of yacc.c */ 07251 #line 2195 "ripper.y" 07252 { 07253 #if 0 07254 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val)); 07255 #endif 07256 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val)); 07257 07258 } 07259 break; 07260 07261 case 228: 07262 07263 /* Line 1806 of yacc.c */ 07264 #line 2203 "ripper.y" 07265 { 07266 #if 0 07267 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val)); 07268 #endif 07269 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val)); 07270 07271 } 07272 break; 07273 07274 case 229: 07275 07276 /* Line 1806 of yacc.c */ 07277 #line 2211 "ripper.y" 07278 { 07279 #if 0 07280 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val)); 07281 #endif 07282 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val)); 07283 07284 } 07285 break; 07286 07287 case 230: 07288 07289 /* Line 1806 of yacc.c */ 07290 #line 2219 "ripper.y" 07291 { 07292 #if 0 07293 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val)); 07294 #endif 07295 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val)); 07296 07297 } 07298 break; 07299 07300 case 231: 07301 07302 /* Line 1806 of yacc.c */ 07303 #line 2227 "ripper.y" 07304 { 07305 #if 0 07306 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val)); 07307 #endif 07308 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val)); 07309 07310 } 07311 break; 07312 07313 case 232: 07314 07315 /* Line 1806 of yacc.c */ 07316 #line 2235 "ripper.y" 07317 { 07318 #if 0 07319 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val)); 07320 #endif 07321 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val)); 07322 07323 } 07324 break; 07325 07326 case 233: 07327 07328 /* Line 1806 of yacc.c */ 07329 #line 2243 "ripper.y" 07330 { 07331 #if 0 07332 (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 07333 if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].val)->nd_lit, T_REGEXP)) { 07334 (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val)); 07335 } 07336 #endif 07337 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val)); 07338 07339 } 07340 break; 07341 07342 case 234: 07343 07344 /* Line 1806 of yacc.c */ 07345 #line 2254 "ripper.y" 07346 { 07347 #if 0 07348 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val)); 07349 #endif 07350 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!~"), (yyvsp[(3) - (3)].val)); 07351 07352 } 07353 break; 07354 07355 case 235: 07356 07357 /* Line 1806 of yacc.c */ 07358 #line 2262 "ripper.y" 07359 { 07360 #if 0 07361 (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!'); 07362 #endif 07363 (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val)); 07364 07365 } 07366 break; 07367 07368 case 236: 07369 07370 /* Line 1806 of yacc.c */ 07371 #line 2270 "ripper.y" 07372 { 07373 #if 0 07374 (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~'); 07375 #endif 07376 (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val)); 07377 07378 } 07379 break; 07380 07381 case 237: 07382 07383 /* Line 1806 of yacc.c */ 07384 #line 2278 "ripper.y" 07385 { 07386 #if 0 07387 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val)); 07388 #endif 07389 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<<"), (yyvsp[(3) - (3)].val)); 07390 07391 } 07392 break; 07393 07394 case 238: 07395 07396 /* Line 1806 of yacc.c */ 07397 #line 2286 "ripper.y" 07398 { 07399 #if 0 07400 (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val)); 07401 #endif 07402 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">>"), (yyvsp[(3) - (3)].val)); 07403 07404 } 07405 break; 07406 07407 case 239: 07408 07409 /* Line 1806 of yacc.c */ 07410 #line 2294 "ripper.y" 07411 { 07412 #if 0 07413 (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 07414 #endif 07415 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val)); 07416 07417 } 07418 break; 07419 07420 case 240: 07421 07422 /* Line 1806 of yacc.c */ 07423 #line 2302 "ripper.y" 07424 { 07425 #if 0 07426 (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 07427 #endif 07428 (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val)); 07429 07430 } 07431 break; 07432 07433 case 241: 07434 07435 /* Line 1806 of yacc.c */ 07436 #line 2309 "ripper.y" 07437 {in_defined = 1;} 07438 break; 07439 07440 case 242: 07441 07442 /* Line 1806 of yacc.c */ 07443 #line 2310 "ripper.y" 07444 { 07445 #if 0 07446 in_defined = 0; 07447 (yyval.val) = NEW_DEFINED((yyvsp[(4) - (4)].val)); 07448 #endif 07449 in_defined = 0; 07450 (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val)); 07451 07452 } 07453 break; 07454 07455 case 243: 07456 07457 /* Line 1806 of yacc.c */ 07458 #line 2320 "ripper.y" 07459 { 07460 #if 0 07461 value_expr((yyvsp[(1) - (6)].val)); 07462 (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val)); 07463 fixpos((yyval.val), (yyvsp[(1) - (6)].val)); 07464 #endif 07465 (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val)); 07466 07467 } 07468 break; 07469 07470 case 244: 07471 07472 /* Line 1806 of yacc.c */ 07473 #line 2330 "ripper.y" 07474 { 07475 (yyval.val) = (yyvsp[(1) - (1)].val); 07476 } 07477 break; 07478 07479 case 245: 07480 07481 /* Line 1806 of yacc.c */ 07482 #line 2336 "ripper.y" 07483 { 07484 #if 0 07485 value_expr((yyvsp[(1) - (1)].val)); 07486 (yyval.val) = (yyvsp[(1) - (1)].val); 07487 if (!(yyval.val)) (yyval.val) = NEW_NIL(); 07488 #endif 07489 (yyval.val) = (yyvsp[(1) - (1)].val); 07490 07491 } 07492 break; 07493 07494 case 247: 07495 07496 /* Line 1806 of yacc.c */ 07497 #line 2349 "ripper.y" 07498 { 07499 (yyval.val) = (yyvsp[(1) - (2)].val); 07500 } 07501 break; 07502 07503 case 248: 07504 07505 /* Line 1806 of yacc.c */ 07506 #line 2353 "ripper.y" 07507 { 07508 #if 0 07509 (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val))); 07510 #endif 07511 (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)); 07512 07513 } 07514 break; 07515 07516 case 249: 07517 07518 /* Line 1806 of yacc.c */ 07519 #line 2361 "ripper.y" 07520 { 07521 #if 0 07522 (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val))); 07523 #endif 07524 (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val)); 07525 07526 } 07527 break; 07528 07529 case 250: 07530 07531 /* Line 1806 of yacc.c */ 07532 #line 2371 "ripper.y" 07533 { 07534 #if 0 07535 (yyval.val) = (yyvsp[(2) - (3)].val); 07536 #endif 07537 (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val))); 07538 07539 } 07540 break; 07541 07542 case 255: 07543 07544 /* Line 1806 of yacc.c */ 07545 #line 2387 "ripper.y" 07546 { 07547 (yyval.val) = (yyvsp[(1) - (2)].val); 07548 } 07549 break; 07550 07551 case 256: 07552 07553 /* Line 1806 of yacc.c */ 07554 #line 2391 "ripper.y" 07555 { 07556 #if 0 07557 (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val))); 07558 #endif 07559 (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)); 07560 07561 } 07562 break; 07563 07564 case 257: 07565 07566 /* Line 1806 of yacc.c */ 07567 #line 2399 "ripper.y" 07568 { 07569 #if 0 07570 (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val))); 07571 #endif 07572 (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val)); 07573 07574 } 07575 break; 07576 07577 case 258: 07578 07579 /* Line 1806 of yacc.c */ 07580 #line 2409 "ripper.y" 07581 { 07582 #if 0 07583 value_expr((yyvsp[(1) - (1)].val)); 07584 (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val)); 07585 #endif 07586 (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val)); 07587 07588 } 07589 break; 07590 07591 case 259: 07592 07593 /* Line 1806 of yacc.c */ 07594 #line 2418 "ripper.y" 07595 { 07596 #if 0 07597 (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 07598 #endif 07599 (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 07600 07601 } 07602 break; 07603 07604 case 260: 07605 07606 /* Line 1806 of yacc.c */ 07607 #line 2426 "ripper.y" 07608 { 07609 #if 0 07610 (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val))); 07611 (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val)); 07612 #endif 07613 (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val)); 07614 (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val)); 07615 07616 } 07617 break; 07618 07619 case 261: 07620 07621 /* Line 1806 of yacc.c */ 07622 #line 2436 "ripper.y" 07623 { 07624 #if 0 07625 (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val))); 07626 (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val)); 07627 #endif 07628 (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val)); 07629 07630 } 07631 break; 07632 07633 case 262: 07634 07635 /* Line 1806 of yacc.c */ 07636 #line 2447 "ripper.y" 07637 { 07638 (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val)); 07639 } 07640 break; 07641 07642 case 263: 07643 07644 /* Line 1806 of yacc.c */ 07645 #line 2453 "ripper.y" 07646 { 07647 (yyval.val) = cmdarg_stack; 07648 CMDARG_PUSH(1); 07649 } 07650 break; 07651 07652 case 264: 07653 07654 /* Line 1806 of yacc.c */ 07655 #line 2458 "ripper.y" 07656 { 07657 /* CMDARG_POP() */ 07658 cmdarg_stack = (yyvsp[(1) - (2)].val); 07659 (yyval.val) = (yyvsp[(2) - (2)].val); 07660 } 07661 break; 07662 07663 case 265: 07664 07665 /* Line 1806 of yacc.c */ 07666 #line 2466 "ripper.y" 07667 { 07668 #if 0 07669 (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val)); 07670 #endif 07671 (yyval.val) = (yyvsp[(2) - (2)].val); 07672 07673 } 07674 break; 07675 07676 case 266: 07677 07678 /* Line 1806 of yacc.c */ 07679 #line 2476 "ripper.y" 07680 { 07681 (yyval.val) = (yyvsp[(2) - (2)].val); 07682 } 07683 break; 07684 07685 case 267: 07686 07687 /* Line 1806 of yacc.c */ 07688 #line 2480 "ripper.y" 07689 { 07690 (yyval.val) = 0; 07691 } 07692 break; 07693 07694 case 268: 07695 07696 /* Line 1806 of yacc.c */ 07697 #line 2486 "ripper.y" 07698 { 07699 #if 0 07700 (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val)); 07701 #endif 07702 (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val)); 07703 07704 } 07705 break; 07706 07707 case 269: 07708 07709 /* Line 1806 of yacc.c */ 07710 #line 2494 "ripper.y" 07711 { 07712 #if 0 07713 (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val)); 07714 #endif 07715 (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val)); 07716 07717 } 07718 break; 07719 07720 case 270: 07721 07722 /* Line 1806 of yacc.c */ 07723 #line 2502 "ripper.y" 07724 { 07725 #if 0 07726 NODE *n1; 07727 if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) { 07728 (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val)); 07729 } 07730 else { 07731 (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 07732 } 07733 #endif 07734 (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 07735 07736 } 07737 break; 07738 07739 case 271: 07740 07741 /* Line 1806 of yacc.c */ 07742 #line 2516 "ripper.y" 07743 { 07744 #if 0 07745 NODE *n1; 07746 if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) { 07747 (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val)); 07748 } 07749 else { 07750 (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val)); 07751 } 07752 #endif 07753 (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val)); 07754 07755 } 07756 break; 07757 07758 case 272: 07759 07760 /* Line 1806 of yacc.c */ 07761 #line 2532 "ripper.y" 07762 { 07763 #if 0 07764 NODE *n1; 07765 if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) { 07766 (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val)); 07767 } 07768 else { 07769 (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 07770 } 07771 #endif 07772 (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val)); 07773 07774 } 07775 break; 07776 07777 case 273: 07778 07779 /* Line 1806 of yacc.c */ 07780 #line 2546 "ripper.y" 07781 { 07782 #if 0 07783 NODE *n1; 07784 if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY && 07785 (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) { 07786 (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val)); 07787 } 07788 else { 07789 (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val)); 07790 } 07791 #endif 07792 (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val)); 07793 07794 } 07795 break; 07796 07797 case 274: 07798 07799 /* Line 1806 of yacc.c */ 07800 #line 2561 "ripper.y" 07801 { 07802 #if 0 07803 (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val)); 07804 #endif 07805 (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val)); 07806 07807 } 07808 break; 07809 07810 case 285: 07811 07812 /* Line 1806 of yacc.c */ 07813 #line 2581 "ripper.y" 07814 { 07815 #if 0 07816 (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0); 07817 #endif 07818 (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new()); 07819 07820 } 07821 break; 07822 07823 case 286: 07824 07825 /* Line 1806 of yacc.c */ 07826 #line 2589 "ripper.y" 07827 { 07828 (yyvsp[(1) - (1)].val) = cmdarg_stack; 07829 cmdarg_stack = 0; 07830 #if 0 07831 (yyval.num) = ruby_sourceline; 07832 #endif 07833 07834 } 07835 break; 07836 07837 case 287: 07838 07839 /* Line 1806 of yacc.c */ 07840 #line 2599 "ripper.y" 07841 { 07842 cmdarg_stack = (yyvsp[(1) - (4)].val); 07843 #if 0 07844 if ((yyvsp[(3) - (4)].val) == NULL) { 07845 (yyval.val) = NEW_NIL(); 07846 } 07847 else { 07848 if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE || 07849 nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE) 07850 nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num)); 07851 (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val)); 07852 } 07853 nd_set_line((yyval.val), (yyvsp[(2) - (4)].num)); 07854 #endif 07855 (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val)); 07856 07857 } 07858 break; 07859 07860 case 288: 07861 07862 /* Line 1806 of yacc.c */ 07863 #line 2616 "ripper.y" 07864 {lex_state = EXPR_ENDARG;} 07865 break; 07866 07867 case 289: 07868 07869 /* Line 1806 of yacc.c */ 07870 #line 2617 "ripper.y" 07871 { 07872 #if 0 07873 (yyval.val) = 0; 07874 #endif 07875 (yyval.val) = dispatch1(paren, 0); 07876 07877 } 07878 break; 07879 07880 case 290: 07881 07882 /* Line 1806 of yacc.c */ 07883 #line 2625 "ripper.y" 07884 { 07885 (yyvsp[(1) - (1)].val) = cmdarg_stack; 07886 cmdarg_stack = 0; 07887 } 07888 break; 07889 07890 case 291: 07891 07892 /* Line 1806 of yacc.c */ 07893 #line 2629 "ripper.y" 07894 {lex_state = EXPR_ENDARG;} 07895 break; 07896 07897 case 292: 07898 07899 /* Line 1806 of yacc.c */ 07900 #line 2630 "ripper.y" 07901 { 07902 cmdarg_stack = (yyvsp[(1) - (5)].val); 07903 #if 0 07904 (yyval.val) = (yyvsp[(3) - (5)].val); 07905 #endif 07906 (yyval.val) = dispatch1(paren, (yyvsp[(3) - (5)].val)); 07907 07908 } 07909 break; 07910 07911 case 293: 07912 07913 /* Line 1806 of yacc.c */ 07914 #line 2639 "ripper.y" 07915 { 07916 #if 0 07917 (yyval.val) = (yyvsp[(2) - (3)].val); 07918 #endif 07919 (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val)); 07920 07921 } 07922 break; 07923 07924 case 294: 07925 07926 /* Line 1806 of yacc.c */ 07927 #line 2647 "ripper.y" 07928 { 07929 #if 0 07930 (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 07931 #endif 07932 (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 07933 07934 } 07935 break; 07936 07937 case 295: 07938 07939 /* Line 1806 of yacc.c */ 07940 #line 2655 "ripper.y" 07941 { 07942 #if 0 07943 (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val)); 07944 #endif 07945 (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val)); 07946 07947 } 07948 break; 07949 07950 case 296: 07951 07952 /* Line 1806 of yacc.c */ 07953 #line 2663 "ripper.y" 07954 { 07955 #if 0 07956 if ((yyvsp[(2) - (3)].val) == 0) { 07957 (yyval.val) = NEW_ZARRAY(); /* zero length array*/ 07958 } 07959 else { 07960 (yyval.val) = (yyvsp[(2) - (3)].val); 07961 } 07962 #endif 07963 (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val))); 07964 07965 } 07966 break; 07967 07968 case 297: 07969 07970 /* Line 1806 of yacc.c */ 07971 #line 2676 "ripper.y" 07972 { 07973 #if 0 07974 (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val)); 07975 #endif 07976 (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val))); 07977 07978 } 07979 break; 07980 07981 case 298: 07982 07983 /* Line 1806 of yacc.c */ 07984 #line 2684 "ripper.y" 07985 { 07986 #if 0 07987 (yyval.val) = NEW_RETURN(0); 07988 #endif 07989 (yyval.val) = dispatch0(return0); 07990 07991 } 07992 break; 07993 07994 case 299: 07995 07996 /* Line 1806 of yacc.c */ 07997 #line 2692 "ripper.y" 07998 { 07999 #if 0 08000 (yyval.val) = new_yield((yyvsp[(3) - (4)].val)); 08001 #endif 08002 (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val))); 08003 08004 } 08005 break; 08006 08007 case 300: 08008 08009 /* Line 1806 of yacc.c */ 08010 #line 2700 "ripper.y" 08011 { 08012 #if 0 08013 (yyval.val) = NEW_YIELD(0); 08014 #endif 08015 (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new())); 08016 08017 } 08018 break; 08019 08020 case 301: 08021 08022 /* Line 1806 of yacc.c */ 08023 #line 2708 "ripper.y" 08024 { 08025 #if 0 08026 (yyval.val) = NEW_YIELD(0); 08027 #endif 08028 (yyval.val) = dispatch0(yield0); 08029 08030 } 08031 break; 08032 08033 case 302: 08034 08035 /* Line 1806 of yacc.c */ 08036 #line 2715 "ripper.y" 08037 {in_defined = 1;} 08038 break; 08039 08040 case 303: 08041 08042 /* Line 1806 of yacc.c */ 08043 #line 2716 "ripper.y" 08044 { 08045 #if 0 08046 in_defined = 0; 08047 (yyval.val) = NEW_DEFINED((yyvsp[(5) - (6)].val)); 08048 #endif 08049 in_defined = 0; 08050 (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val)); 08051 08052 } 08053 break; 08054 08055 case 304: 08056 08057 /* Line 1806 of yacc.c */ 08058 #line 2726 "ripper.y" 08059 { 08060 #if 0 08061 (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!'); 08062 #endif 08063 (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val)); 08064 08065 } 08066 break; 08067 08068 case 305: 08069 08070 /* Line 1806 of yacc.c */ 08071 #line 2734 "ripper.y" 08072 { 08073 #if 0 08074 (yyval.val) = call_uni_op(cond(NEW_NIL()), '!'); 08075 #endif 08076 (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil); 08077 08078 } 08079 break; 08080 08081 case 306: 08082 08083 /* Line 1806 of yacc.c */ 08084 #line 2742 "ripper.y" 08085 { 08086 #if 0 08087 (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val); 08088 (yyval.val) = (yyvsp[(2) - (2)].val); 08089 #endif 08090 (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new()); 08091 (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val)); 08092 08093 } 08094 break; 08095 08096 case 308: 08097 08098 /* Line 1806 of yacc.c */ 08099 #line 2753 "ripper.y" 08100 { 08101 #if 0 08102 block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val)); 08103 (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val); 08104 (yyval.val) = (yyvsp[(2) - (2)].val); 08105 #endif 08106 (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 08107 08108 } 08109 break; 08110 08111 case 309: 08112 08113 /* Line 1806 of yacc.c */ 08114 #line 2763 "ripper.y" 08115 { 08116 (yyval.val) = (yyvsp[(2) - (2)].val); 08117 } 08118 break; 08119 08120 case 310: 08121 08122 /* Line 1806 of yacc.c */ 08123 #line 2770 "ripper.y" 08124 { 08125 #if 0 08126 (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val)); 08127 fixpos((yyval.val), (yyvsp[(2) - (6)].val)); 08128 #endif 08129 (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val))); 08130 08131 } 08132 break; 08133 08134 case 311: 08135 08136 /* Line 1806 of yacc.c */ 08137 #line 2782 "ripper.y" 08138 { 08139 #if 0 08140 (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val)); 08141 fixpos((yyval.val), (yyvsp[(2) - (6)].val)); 08142 #endif 08143 (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val))); 08144 08145 } 08146 break; 08147 08148 case 312: 08149 08150 /* Line 1806 of yacc.c */ 08151 #line 2790 "ripper.y" 08152 {COND_PUSH(1);} 08153 break; 08154 08155 case 313: 08156 08157 /* Line 1806 of yacc.c */ 08158 #line 2790 "ripper.y" 08159 {COND_POP();} 08160 break; 08161 08162 case 314: 08163 08164 /* Line 1806 of yacc.c */ 08165 #line 2793 "ripper.y" 08166 { 08167 #if 0 08168 (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1); 08169 fixpos((yyval.val), (yyvsp[(3) - (7)].val)); 08170 #endif 08171 (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val)); 08172 08173 } 08174 break; 08175 08176 case 315: 08177 08178 /* Line 1806 of yacc.c */ 08179 #line 2801 "ripper.y" 08180 {COND_PUSH(1);} 08181 break; 08182 08183 case 316: 08184 08185 /* Line 1806 of yacc.c */ 08186 #line 2801 "ripper.y" 08187 {COND_POP();} 08188 break; 08189 08190 case 317: 08191 08192 /* Line 1806 of yacc.c */ 08193 #line 2804 "ripper.y" 08194 { 08195 #if 0 08196 (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1); 08197 fixpos((yyval.val), (yyvsp[(3) - (7)].val)); 08198 #endif 08199 (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val)); 08200 08201 } 08202 break; 08203 08204 case 318: 08205 08206 /* Line 1806 of yacc.c */ 08207 #line 2815 "ripper.y" 08208 { 08209 #if 0 08210 (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val)); 08211 fixpos((yyval.val), (yyvsp[(2) - (5)].val)); 08212 #endif 08213 (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val)); 08214 08215 } 08216 break; 08217 08218 case 319: 08219 08220 /* Line 1806 of yacc.c */ 08221 #line 2824 "ripper.y" 08222 { 08223 #if 0 08224 (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val)); 08225 #endif 08226 (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val)); 08227 08228 } 08229 break; 08230 08231 case 320: 08232 08233 /* Line 1806 of yacc.c */ 08234 #line 2832 "ripper.y" 08235 {COND_PUSH(1);} 08236 break; 08237 08238 case 321: 08239 08240 /* Line 1806 of yacc.c */ 08241 #line 2834 "ripper.y" 08242 {COND_POP();} 08243 break; 08244 08245 case 322: 08246 08247 /* Line 1806 of yacc.c */ 08248 #line 2837 "ripper.y" 08249 { 08250 #if 0 08251 /* 08252 * for a, b, c in e 08253 * #=> 08254 * e.each{|*x| a, b, c = x 08255 * 08256 * for a in e 08257 * #=> 08258 * e.each{|x| a, = x} 08259 */ 08260 ID id = internal_id(); 08261 ID *tbl = ALLOC_N(ID, 2); 08262 NODE *m = NEW_ARGS_AUX(0, 0); 08263 NODE *args, *scope; 08264 08265 if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) { 08266 /* if args.length == 1 && args[0].kind_of?(Array) 08267 * args = args[0] 08268 * end 08269 */ 08270 NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1))); 08271 NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0))); 08272 m->nd_next = block_append( 08273 NEW_IF( 08274 NEW_NODE(NODE_AND, 08275 NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0), 08276 idEq, one), 08277 NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero), 08278 rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))), 08279 0), 08280 NEW_DASGN_CURR(id, 08281 NEW_CALL(NEW_DVAR(id), idAREF, zero)), 08282 0), 08283 node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id))); 08284 08285 args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0)); 08286 } 08287 else { 08288 if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN || 08289 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN || 08290 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) { 08291 (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id); 08292 m->nd_plen = 1; 08293 m->nd_next = (yyvsp[(2) - (9)].val); 08294 args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0)); 08295 } 08296 else { 08297 m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id)); 08298 args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0)); 08299 } 08300 } 08301 scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args); 08302 tbl[0] = 1; tbl[1] = id; 08303 (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope); 08304 fixpos((yyval.val), (yyvsp[(2) - (9)].val)); 08305 #endif 08306 (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val)); 08307 08308 } 08309 break; 08310 08311 case 323: 08312 08313 /* Line 1806 of yacc.c */ 08314 #line 2898 "ripper.y" 08315 { 08316 if (in_def || in_single) 08317 yyerror("class definition in method body"); 08318 local_push(0); 08319 #if 0 08320 (yyval.num) = ruby_sourceline; 08321 #endif 08322 08323 } 08324 break; 08325 08326 case 324: 08327 08328 /* Line 1806 of yacc.c */ 08329 #line 2909 "ripper.y" 08330 { 08331 #if 0 08332 (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val)); 08333 nd_set_line((yyval.val), (yyvsp[(4) - (6)].num)); 08334 #endif 08335 (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val)); 08336 08337 local_pop(); 08338 } 08339 break; 08340 08341 case 325: 08342 08343 /* Line 1806 of yacc.c */ 08344 #line 2919 "ripper.y" 08345 { 08346 (yyval.num) = in_def; 08347 in_def = 0; 08348 } 08349 break; 08350 08351 case 326: 08352 08353 /* Line 1806 of yacc.c */ 08354 #line 2924 "ripper.y" 08355 { 08356 (yyval.num) = in_single; 08357 in_single = 0; 08358 local_push(0); 08359 } 08360 break; 08361 08362 case 327: 08363 08364 /* Line 1806 of yacc.c */ 08365 #line 2931 "ripper.y" 08366 { 08367 #if 0 08368 (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val)); 08369 fixpos((yyval.val), (yyvsp[(3) - (8)].val)); 08370 #endif 08371 (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val)); 08372 08373 local_pop(); 08374 in_def = (yyvsp[(4) - (8)].num); 08375 in_single = (yyvsp[(6) - (8)].num); 08376 } 08377 break; 08378 08379 case 328: 08380 08381 /* Line 1806 of yacc.c */ 08382 #line 2943 "ripper.y" 08383 { 08384 if (in_def || in_single) 08385 yyerror("module definition in method body"); 08386 local_push(0); 08387 #if 0 08388 (yyval.num) = ruby_sourceline; 08389 #endif 08390 08391 } 08392 break; 08393 08394 case 329: 08395 08396 /* Line 1806 of yacc.c */ 08397 #line 2954 "ripper.y" 08398 { 08399 #if 0 08400 (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val)); 08401 nd_set_line((yyval.val), (yyvsp[(3) - (5)].num)); 08402 #endif 08403 (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val)); 08404 08405 local_pop(); 08406 } 08407 break; 08408 08409 case 330: 08410 08411 /* Line 1806 of yacc.c */ 08412 #line 2964 "ripper.y" 08413 { 08414 (yyval.id) = cur_mid; 08415 cur_mid = (yyvsp[(2) - (2)].val); 08416 in_def++; 08417 local_push(0); 08418 } 08419 break; 08420 08421 case 331: 08422 08423 /* Line 1806 of yacc.c */ 08424 #line 2973 "ripper.y" 08425 { 08426 #if 0 08427 NODE *body = remove_begin((yyvsp[(5) - (6)].val)); 08428 reduce_nodes(&body); 08429 (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE); 08430 nd_set_line((yyval.val), (yyvsp[(1) - (6)].num)); 08431 #endif 08432 (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val)); 08433 08434 local_pop(); 08435 in_def--; 08436 cur_mid = (yyvsp[(3) - (6)].id); 08437 } 08438 break; 08439 08440 case 332: 08441 08442 /* Line 1806 of yacc.c */ 08443 #line 2986 "ripper.y" 08444 {lex_state = EXPR_FNAME;} 08445 break; 08446 08447 case 333: 08448 08449 /* Line 1806 of yacc.c */ 08450 #line 2987 "ripper.y" 08451 { 08452 in_single++; 08453 lex_state = EXPR_ENDFN; /* force for args */ 08454 local_push(0); 08455 } 08456 break; 08457 08458 case 334: 08459 08460 /* Line 1806 of yacc.c */ 08461 #line 2995 "ripper.y" 08462 { 08463 #if 0 08464 NODE *body = remove_begin((yyvsp[(8) - (9)].val)); 08465 reduce_nodes(&body); 08466 (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body); 08467 nd_set_line((yyval.val), (yyvsp[(1) - (9)].num)); 08468 #endif 08469 (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val)); 08470 08471 local_pop(); 08472 in_single--; 08473 } 08474 break; 08475 08476 case 335: 08477 08478 /* Line 1806 of yacc.c */ 08479 #line 3008 "ripper.y" 08480 { 08481 #if 0 08482 (yyval.val) = NEW_BREAK(0); 08483 #endif 08484 (yyval.val) = dispatch1(break, arg_new()); 08485 08486 } 08487 break; 08488 08489 case 336: 08490 08491 /* Line 1806 of yacc.c */ 08492 #line 3016 "ripper.y" 08493 { 08494 #if 0 08495 (yyval.val) = NEW_NEXT(0); 08496 #endif 08497 (yyval.val) = dispatch1(next, arg_new()); 08498 08499 } 08500 break; 08501 08502 case 337: 08503 08504 /* Line 1806 of yacc.c */ 08505 #line 3024 "ripper.y" 08506 { 08507 #if 0 08508 (yyval.val) = NEW_REDO(); 08509 #endif 08510 (yyval.val) = dispatch0(redo); 08511 08512 } 08513 break; 08514 08515 case 338: 08516 08517 /* Line 1806 of yacc.c */ 08518 #line 3032 "ripper.y" 08519 { 08520 #if 0 08521 (yyval.val) = NEW_RETRY(); 08522 #endif 08523 (yyval.val) = dispatch0(retry); 08524 08525 } 08526 break; 08527 08528 case 339: 08529 08530 /* Line 1806 of yacc.c */ 08531 #line 3042 "ripper.y" 08532 { 08533 #if 0 08534 value_expr((yyvsp[(1) - (1)].val)); 08535 (yyval.val) = (yyvsp[(1) - (1)].val); 08536 if (!(yyval.val)) (yyval.val) = NEW_NIL(); 08537 #endif 08538 (yyval.val) = (yyvsp[(1) - (1)].val); 08539 08540 } 08541 break; 08542 08543 case 340: 08544 08545 /* Line 1806 of yacc.c */ 08546 #line 3054 "ripper.y" 08547 { 08548 token_info_push("begin"); 08549 } 08550 break; 08551 08552 case 341: 08553 08554 /* Line 1806 of yacc.c */ 08555 #line 3060 "ripper.y" 08556 { 08557 token_info_push("if"); 08558 } 08559 break; 08560 08561 case 342: 08562 08563 /* Line 1806 of yacc.c */ 08564 #line 3066 "ripper.y" 08565 { 08566 token_info_push("unless"); 08567 } 08568 break; 08569 08570 case 343: 08571 08572 /* Line 1806 of yacc.c */ 08573 #line 3072 "ripper.y" 08574 { 08575 token_info_push("while"); 08576 } 08577 break; 08578 08579 case 344: 08580 08581 /* Line 1806 of yacc.c */ 08582 #line 3078 "ripper.y" 08583 { 08584 token_info_push("until"); 08585 } 08586 break; 08587 08588 case 345: 08589 08590 /* Line 1806 of yacc.c */ 08591 #line 3084 "ripper.y" 08592 { 08593 token_info_push("case"); 08594 } 08595 break; 08596 08597 case 346: 08598 08599 /* Line 1806 of yacc.c */ 08600 #line 3090 "ripper.y" 08601 { 08602 token_info_push("for"); 08603 } 08604 break; 08605 08606 case 347: 08607 08608 /* Line 1806 of yacc.c */ 08609 #line 3096 "ripper.y" 08610 { 08611 token_info_push("class"); 08612 } 08613 break; 08614 08615 case 348: 08616 08617 /* Line 1806 of yacc.c */ 08618 #line 3102 "ripper.y" 08619 { 08620 token_info_push("module"); 08621 } 08622 break; 08623 08624 case 349: 08625 08626 /* Line 1806 of yacc.c */ 08627 #line 3108 "ripper.y" 08628 { 08629 token_info_push("def"); 08630 #if 0 08631 (yyval.num) = ruby_sourceline; 08632 #endif 08633 08634 } 08635 break; 08636 08637 case 350: 08638 08639 /* Line 1806 of yacc.c */ 08640 #line 3118 "ripper.y" 08641 { 08642 token_info_pop("end"); 08643 } 08644 break; 08645 08646 case 351: 08647 08648 /* Line 1806 of yacc.c */ 08649 #line 3126 "ripper.y" 08650 { (yyval.val) = Qnil; } 08651 break; 08652 08653 case 353: 08654 08655 /* Line 1806 of yacc.c */ 08656 #line 3132 "ripper.y" 08657 { (yyval.val) = (yyvsp[(2) - (2)].val); } 08658 break; 08659 08660 case 354: 08661 08662 /* Line 1806 of yacc.c */ 08663 #line 3139 "ripper.y" 08664 { (yyval.val) = Qnil; } 08665 break; 08666 08667 case 357: 08668 08669 /* Line 1806 of yacc.c */ 08670 #line 3148 "ripper.y" 08671 { 08672 #if 0 08673 (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 08674 fixpos((yyval.val), (yyvsp[(2) - (5)].val)); 08675 #endif 08676 (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val))); 08677 08678 } 08679 break; 08680 08681 case 359: 08682 08683 /* Line 1806 of yacc.c */ 08684 #line 3160 "ripper.y" 08685 { 08686 #if 0 08687 (yyval.val) = (yyvsp[(2) - (2)].val); 08688 #endif 08689 (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val)); 08690 08691 } 08692 break; 08693 08694 case 362: 08695 08696 /* Line 1806 of yacc.c */ 08697 #line 3174 "ripper.y" 08698 { 08699 (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0); 08700 #if 0 08701 #endif 08702 (yyval.val) = dispatch1(mlhs_paren, (yyval.val)); 08703 08704 } 08705 break; 08706 08707 case 363: 08708 08709 /* Line 1806 of yacc.c */ 08710 #line 3182 "ripper.y" 08711 { 08712 #if 0 08713 (yyval.val) = (yyvsp[(2) - (3)].val); 08714 #endif 08715 (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val)); 08716 08717 } 08718 break; 08719 08720 case 364: 08721 08722 /* Line 1806 of yacc.c */ 08723 #line 3192 "ripper.y" 08724 { 08725 #if 0 08726 (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val)); 08727 #endif 08728 (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val)); 08729 08730 } 08731 break; 08732 08733 case 365: 08734 08735 /* Line 1806 of yacc.c */ 08736 #line 3200 "ripper.y" 08737 { 08738 #if 0 08739 (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 08740 #endif 08741 (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 08742 08743 } 08744 break; 08745 08746 case 366: 08747 08748 /* Line 1806 of yacc.c */ 08749 #line 3210 "ripper.y" 08750 { 08751 #if 0 08752 (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0); 08753 #endif 08754 (yyval.val) = (yyvsp[(1) - (1)].val); 08755 08756 } 08757 break; 08758 08759 case 367: 08760 08761 /* Line 1806 of yacc.c */ 08762 #line 3218 "ripper.y" 08763 { 08764 (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0); 08765 #if 0 08766 (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val)); 08767 #endif 08768 (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val)); 08769 08770 } 08771 break; 08772 08773 case 368: 08774 08775 /* Line 1806 of yacc.c */ 08776 #line 3227 "ripper.y" 08777 { 08778 (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0); 08779 #if 0 08780 (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val))); 08781 #endif 08782 (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val)); 08783 08784 } 08785 break; 08786 08787 case 369: 08788 08789 /* Line 1806 of yacc.c */ 08790 #line 3236 "ripper.y" 08791 { 08792 #if 0 08793 (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1); 08794 #endif 08795 (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil); 08796 08797 } 08798 break; 08799 08800 case 370: 08801 08802 /* Line 1806 of yacc.c */ 08803 #line 3244 "ripper.y" 08804 { 08805 #if 0 08806 (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val))); 08807 #endif 08808 (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val)); 08809 08810 } 08811 break; 08812 08813 case 371: 08814 08815 /* Line 1806 of yacc.c */ 08816 #line 3252 "ripper.y" 08817 { 08818 (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0); 08819 #if 0 08820 (yyval.val) = NEW_MASGN(0, (yyval.val)); 08821 #endif 08822 (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val)); 08823 08824 } 08825 break; 08826 08827 case 372: 08828 08829 /* Line 1806 of yacc.c */ 08830 #line 3261 "ripper.y" 08831 { 08832 (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0); 08833 #if 0 08834 (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val))); 08835 #endif 08836 #if 0 08837 TODO: Check me 08838 #endif 08839 (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val)); 08840 08841 } 08842 break; 08843 08844 case 373: 08845 08846 /* Line 1806 of yacc.c */ 08847 #line 3273 "ripper.y" 08848 { 08849 #if 0 08850 (yyval.val) = NEW_MASGN(0, -1); 08851 #endif 08852 (yyval.val) = mlhs_add_star(mlhs_new(), Qnil); 08853 08854 } 08855 break; 08856 08857 case 374: 08858 08859 /* Line 1806 of yacc.c */ 08860 #line 3281 "ripper.y" 08861 { 08862 #if 0 08863 (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val))); 08864 #endif 08865 (yyval.val) = mlhs_add_star(mlhs_new(), Qnil); 08866 08867 } 08868 break; 08869 08870 case 375: 08871 08872 /* Line 1806 of yacc.c */ 08873 #line 3292 "ripper.y" 08874 { 08875 (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 08876 } 08877 break; 08878 08879 case 376: 08880 08881 /* Line 1806 of yacc.c */ 08882 #line 3296 "ripper.y" 08883 { 08884 (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val)); 08885 } 08886 break; 08887 08888 case 377: 08889 08890 /* Line 1806 of yacc.c */ 08891 #line 3300 "ripper.y" 08892 { 08893 (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 08894 } 08895 break; 08896 08897 case 378: 08898 08899 /* Line 1806 of yacc.c */ 08900 #line 3304 "ripper.y" 08901 { 08902 (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val)); 08903 } 08904 break; 08905 08906 case 379: 08907 08908 /* Line 1806 of yacc.c */ 08909 #line 3310 "ripper.y" 08910 { 08911 (yyval.val) = (yyvsp[(2) - (2)].val); 08912 } 08913 break; 08914 08915 case 380: 08916 08917 /* Line 1806 of yacc.c */ 08918 #line 3314 "ripper.y" 08919 { 08920 (yyval.val) = new_args_tail(Qnone, Qnone, Qnone); 08921 } 08922 break; 08923 08924 case 381: 08925 08926 /* Line 1806 of yacc.c */ 08927 #line 3320 "ripper.y" 08928 { 08929 (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val)); 08930 } 08931 break; 08932 08933 case 382: 08934 08935 /* Line 1806 of yacc.c */ 08936 #line 3324 "ripper.y" 08937 { 08938 (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val)); 08939 } 08940 break; 08941 08942 case 383: 08943 08944 /* Line 1806 of yacc.c */ 08945 #line 3328 "ripper.y" 08946 { 08947 (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val)); 08948 } 08949 break; 08950 08951 case 384: 08952 08953 /* Line 1806 of yacc.c */ 08954 #line 3332 "ripper.y" 08955 { 08956 (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val)); 08957 } 08958 break; 08959 08960 case 385: 08961 08962 /* Line 1806 of yacc.c */ 08963 #line 3336 "ripper.y" 08964 { 08965 (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val)); 08966 } 08967 break; 08968 08969 case 386: 08970 08971 /* Line 1806 of yacc.c */ 08972 #line 3340 "ripper.y" 08973 { 08974 (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone)); 08975 #if 0 08976 #endif 08977 dispatch1(excessed_comma, (yyval.val)); 08978 08979 } 08980 break; 08981 08982 case 387: 08983 08984 /* Line 1806 of yacc.c */ 08985 #line 3348 "ripper.y" 08986 { 08987 (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val)); 08988 } 08989 break; 08990 08991 case 388: 08992 08993 /* Line 1806 of yacc.c */ 08994 #line 3352 "ripper.y" 08995 { 08996 (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val)); 08997 } 08998 break; 08999 09000 case 389: 09001 09002 /* Line 1806 of yacc.c */ 09003 #line 3356 "ripper.y" 09004 { 09005 (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val)); 09006 } 09007 break; 09008 09009 case 390: 09010 09011 /* Line 1806 of yacc.c */ 09012 #line 3360 "ripper.y" 09013 { 09014 (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val)); 09015 } 09016 break; 09017 09018 case 391: 09019 09020 /* Line 1806 of yacc.c */ 09021 #line 3364 "ripper.y" 09022 { 09023 (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val)); 09024 } 09025 break; 09026 09027 case 392: 09028 09029 /* Line 1806 of yacc.c */ 09030 #line 3368 "ripper.y" 09031 { 09032 (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 09033 } 09034 break; 09035 09036 case 393: 09037 09038 /* Line 1806 of yacc.c */ 09039 #line 3372 "ripper.y" 09040 { 09041 (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val)); 09042 } 09043 break; 09044 09045 case 394: 09046 09047 /* Line 1806 of yacc.c */ 09048 #line 3376 "ripper.y" 09049 { 09050 (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 09051 } 09052 break; 09053 09054 case 395: 09055 09056 /* Line 1806 of yacc.c */ 09057 #line 3380 "ripper.y" 09058 { 09059 (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val)); 09060 } 09061 break; 09062 09063 case 397: 09064 09065 /* Line 1806 of yacc.c */ 09066 #line 3387 "ripper.y" 09067 { 09068 command_start = TRUE; 09069 } 09070 break; 09071 09072 case 398: 09073 09074 /* Line 1806 of yacc.c */ 09075 #line 3393 "ripper.y" 09076 { 09077 #if 0 09078 (yyval.val) = 0; 09079 #endif 09080 (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil), 09081 escape_Qundef((yyvsp[(2) - (3)].val))); 09082 09083 } 09084 break; 09085 09086 case 399: 09087 09088 /* Line 1806 of yacc.c */ 09089 #line 3402 "ripper.y" 09090 { 09091 #if 0 09092 (yyval.val) = 0; 09093 #endif 09094 (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil), 09095 Qnil); 09096 09097 } 09098 break; 09099 09100 case 400: 09101 09102 /* Line 1806 of yacc.c */ 09103 #line 3411 "ripper.y" 09104 { 09105 #if 0 09106 (yyval.val) = (yyvsp[(2) - (4)].val); 09107 #endif 09108 (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val))); 09109 09110 } 09111 break; 09112 09113 case 401: 09114 09115 /* Line 1806 of yacc.c */ 09116 #line 3422 "ripper.y" 09117 { 09118 (yyval.val) = 0; 09119 } 09120 break; 09121 09122 case 402: 09123 09124 /* Line 1806 of yacc.c */ 09125 #line 3426 "ripper.y" 09126 { 09127 #if 0 09128 (yyval.val) = 0; 09129 #endif 09130 (yyval.val) = (yyvsp[(3) - (4)].val); 09131 09132 } 09133 break; 09134 09135 case 403: 09136 09137 /* Line 1806 of yacc.c */ 09138 #line 3438 "ripper.y" 09139 { 09140 (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val)); 09141 } 09142 break; 09143 09144 case 404: 09145 09146 /* Line 1806 of yacc.c */ 09147 #line 3445 "ripper.y" 09148 { 09149 rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 09150 } 09151 break; 09152 09153 case 405: 09154 09155 /* Line 1806 of yacc.c */ 09156 #line 3452 "ripper.y" 09157 { 09158 new_bv(get_id((yyvsp[(1) - (1)].val))); 09159 #if 0 09160 #endif 09161 (yyval.val) = get_value((yyvsp[(1) - (1)].val)); 09162 09163 } 09164 break; 09165 09166 case 406: 09167 09168 /* Line 1806 of yacc.c */ 09169 #line 3460 "ripper.y" 09170 { 09171 (yyval.val) = 0; 09172 } 09173 break; 09174 09175 case 407: 09176 09177 /* Line 1806 of yacc.c */ 09178 #line 3465 "ripper.y" 09179 { 09180 (yyval.vars) = dyna_push(); 09181 } 09182 break; 09183 09184 case 408: 09185 09186 /* Line 1806 of yacc.c */ 09187 #line 3468 "ripper.y" 09188 { 09189 (yyval.num) = lpar_beg; 09190 lpar_beg = ++paren_nest; 09191 } 09192 break; 09193 09194 case 409: 09195 09196 /* Line 1806 of yacc.c */ 09197 #line 3473 "ripper.y" 09198 { 09199 (yyval.num) = ruby_sourceline; 09200 } 09201 break; 09202 09203 case 410: 09204 09205 /* Line 1806 of yacc.c */ 09206 #line 3477 "ripper.y" 09207 { 09208 lpar_beg = (yyvsp[(2) - (5)].num); 09209 #if 0 09210 (yyval.val) = NEW_LAMBDA((yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)); 09211 nd_set_line((yyval.val), (yyvsp[(4) - (5)].num)); 09212 #endif 09213 (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)); 09214 09215 dyna_pop((yyvsp[(1) - (5)].vars)); 09216 } 09217 break; 09218 09219 case 411: 09220 09221 /* Line 1806 of yacc.c */ 09222 #line 3490 "ripper.y" 09223 { 09224 #if 0 09225 (yyval.val) = (yyvsp[(2) - (4)].val); 09226 #endif 09227 (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val)); 09228 09229 } 09230 break; 09231 09232 case 412: 09233 09234 /* Line 1806 of yacc.c */ 09235 #line 3498 "ripper.y" 09236 { 09237 #if 0 09238 (yyval.val) = (yyvsp[(1) - (1)].val); 09239 #endif 09240 (yyval.val) = (yyvsp[(1) - (1)].val); 09241 09242 } 09243 break; 09244 09245 case 413: 09246 09247 /* Line 1806 of yacc.c */ 09248 #line 3508 "ripper.y" 09249 { 09250 (yyval.val) = (yyvsp[(2) - (3)].val); 09251 } 09252 break; 09253 09254 case 414: 09255 09256 /* Line 1806 of yacc.c */ 09257 #line 3512 "ripper.y" 09258 { 09259 (yyval.val) = (yyvsp[(2) - (3)].val); 09260 } 09261 break; 09262 09263 case 415: 09264 09265 /* Line 1806 of yacc.c */ 09266 #line 3518 "ripper.y" 09267 { 09268 (yyvsp[(1) - (1)].vars) = dyna_push(); 09269 #if 0 09270 (yyval.num) = ruby_sourceline; 09271 #endif 09272 } 09273 break; 09274 09275 case 416: 09276 09277 /* Line 1806 of yacc.c */ 09278 #line 3527 "ripper.y" 09279 { 09280 #if 0 09281 (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val)); 09282 nd_set_line((yyval.val), (yyvsp[(2) - (5)].num)); 09283 #endif 09284 (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val)); 09285 09286 dyna_pop((yyvsp[(1) - (5)].vars)); 09287 } 09288 break; 09289 09290 case 417: 09291 09292 /* Line 1806 of yacc.c */ 09293 #line 3539 "ripper.y" 09294 { 09295 #if 0 09296 if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) { 09297 compile_error(PARSER_ARG "block given to yield"); 09298 } 09299 else { 09300 block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val)); 09301 } 09302 (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val); 09303 (yyval.val) = (yyvsp[(2) - (2)].val); 09304 fixpos((yyval.val), (yyvsp[(1) - (2)].val)); 09305 #endif 09306 (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 09307 09308 } 09309 break; 09310 09311 case 418: 09312 09313 /* Line 1806 of yacc.c */ 09314 #line 3555 "ripper.y" 09315 { 09316 #if 0 09317 (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 09318 #endif 09319 (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val)); 09320 (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val)); 09321 09322 } 09323 break; 09324 09325 case 419: 09326 09327 /* Line 1806 of yacc.c */ 09328 #line 3564 "ripper.y" 09329 { 09330 #if 0 09331 block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 09332 (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val)); 09333 (yyval.val) = (yyvsp[(5) - (5)].val); 09334 fixpos((yyval.val), (yyvsp[(1) - (5)].val)); 09335 #endif 09336 (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val)); 09337 (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val)); 09338 09339 } 09340 break; 09341 09342 case 420: 09343 09344 /* Line 1806 of yacc.c */ 09345 #line 3576 "ripper.y" 09346 { 09347 #if 0 09348 block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 09349 (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val)); 09350 (yyval.val) = (yyvsp[(5) - (5)].val); 09351 fixpos((yyval.val), (yyvsp[(1) - (5)].val)); 09352 #endif 09353 (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val)); 09354 (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val)); 09355 09356 } 09357 break; 09358 09359 case 421: 09360 09361 /* Line 1806 of yacc.c */ 09362 #line 3590 "ripper.y" 09363 { 09364 #if 0 09365 (yyval.val) = (yyvsp[(1) - (2)].val); 09366 (yyval.val)->nd_args = (yyvsp[(2) - (2)].val); 09367 #endif 09368 (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val)); 09369 09370 } 09371 break; 09372 09373 case 422: 09374 09375 /* Line 1806 of yacc.c */ 09376 #line 3599 "ripper.y" 09377 { 09378 #if 0 09379 (yyval.num) = ruby_sourceline; 09380 #endif 09381 } 09382 break; 09383 09384 case 423: 09385 09386 /* Line 1806 of yacc.c */ 09387 #line 3605 "ripper.y" 09388 { 09389 #if 0 09390 (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)); 09391 nd_set_line((yyval.val), (yyvsp[(4) - (5)].num)); 09392 #endif 09393 (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val)); 09394 (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val)); 09395 09396 } 09397 break; 09398 09399 case 424: 09400 09401 /* Line 1806 of yacc.c */ 09402 #line 3615 "ripper.y" 09403 { 09404 #if 0 09405 (yyval.num) = ruby_sourceline; 09406 #endif 09407 } 09408 break; 09409 09410 case 425: 09411 09412 /* Line 1806 of yacc.c */ 09413 #line 3621 "ripper.y" 09414 { 09415 #if 0 09416 (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)); 09417 nd_set_line((yyval.val), (yyvsp[(4) - (5)].num)); 09418 #endif 09419 (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val)); 09420 (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val)); 09421 09422 } 09423 break; 09424 09425 case 426: 09426 09427 /* Line 1806 of yacc.c */ 09428 #line 3631 "ripper.y" 09429 { 09430 #if 0 09431 (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0); 09432 #endif 09433 (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val)); 09434 09435 } 09436 break; 09437 09438 case 427: 09439 09440 /* Line 1806 of yacc.c */ 09441 #line 3639 "ripper.y" 09442 { 09443 #if 0 09444 (yyval.num) = ruby_sourceline; 09445 #endif 09446 } 09447 break; 09448 09449 case 428: 09450 09451 /* Line 1806 of yacc.c */ 09452 #line 3645 "ripper.y" 09453 { 09454 #if 0 09455 (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val)); 09456 nd_set_line((yyval.val), (yyvsp[(3) - (4)].num)); 09457 #endif 09458 (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), 09459 ripper_intern("call")); 09460 (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val)); 09461 09462 } 09463 break; 09464 09465 case 429: 09466 09467 /* Line 1806 of yacc.c */ 09468 #line 3656 "ripper.y" 09469 { 09470 #if 0 09471 (yyval.num) = ruby_sourceline; 09472 #endif 09473 } 09474 break; 09475 09476 case 430: 09477 09478 /* Line 1806 of yacc.c */ 09479 #line 3662 "ripper.y" 09480 { 09481 #if 0 09482 (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val)); 09483 nd_set_line((yyval.val), (yyvsp[(3) - (4)].num)); 09484 #endif 09485 (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"), 09486 ripper_intern("call")); 09487 (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val)); 09488 09489 } 09490 break; 09491 09492 case 431: 09493 09494 /* Line 1806 of yacc.c */ 09495 #line 3673 "ripper.y" 09496 { 09497 #if 0 09498 (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val)); 09499 #endif 09500 (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val)); 09501 09502 } 09503 break; 09504 09505 case 432: 09506 09507 /* Line 1806 of yacc.c */ 09508 #line 3681 "ripper.y" 09509 { 09510 #if 0 09511 (yyval.val) = NEW_ZSUPER(); 09512 #endif 09513 (yyval.val) = dispatch0(zsuper); 09514 09515 } 09516 break; 09517 09518 case 433: 09519 09520 /* Line 1806 of yacc.c */ 09521 #line 3689 "ripper.y" 09522 { 09523 #if 0 09524 if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF) 09525 (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val)); 09526 else 09527 (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val)); 09528 fixpos((yyval.val), (yyvsp[(1) - (4)].val)); 09529 #endif 09530 (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val))); 09531 09532 } 09533 break; 09534 09535 case 434: 09536 09537 /* Line 1806 of yacc.c */ 09538 #line 3703 "ripper.y" 09539 { 09540 (yyvsp[(1) - (1)].vars) = dyna_push(); 09541 #if 0 09542 (yyval.num) = ruby_sourceline; 09543 #endif 09544 09545 } 09546 break; 09547 09548 case 435: 09549 09550 /* Line 1806 of yacc.c */ 09551 #line 3712 "ripper.y" 09552 { 09553 #if 0 09554 (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val)); 09555 nd_set_line((yyval.val), (yyvsp[(2) - (5)].num)); 09556 #endif 09557 (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val)); 09558 09559 dyna_pop((yyvsp[(1) - (5)].vars)); 09560 } 09561 break; 09562 09563 case 436: 09564 09565 /* Line 1806 of yacc.c */ 09566 #line 3722 "ripper.y" 09567 { 09568 (yyvsp[(1) - (1)].vars) = dyna_push(); 09569 #if 0 09570 (yyval.num) = ruby_sourceline; 09571 #endif 09572 09573 } 09574 break; 09575 09576 case 437: 09577 09578 /* Line 1806 of yacc.c */ 09579 #line 3731 "ripper.y" 09580 { 09581 #if 0 09582 (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val)); 09583 nd_set_line((yyval.val), (yyvsp[(2) - (5)].num)); 09584 #endif 09585 (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val)); 09586 09587 dyna_pop((yyvsp[(1) - (5)].vars)); 09588 } 09589 break; 09590 09591 case 438: 09592 09593 /* Line 1806 of yacc.c */ 09594 #line 3745 "ripper.y" 09595 { 09596 #if 0 09597 (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val)); 09598 #endif 09599 (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val))); 09600 09601 } 09602 break; 09603 09604 case 441: 09605 09606 /* Line 1806 of yacc.c */ 09607 #line 3761 "ripper.y" 09608 { 09609 #if 0 09610 if ((yyvsp[(3) - (6)].val)) { 09611 (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO()); 09612 (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val)); 09613 } 09614 (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val)); 09615 fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val)); 09616 #endif 09617 (yyval.val) = dispatch4(rescue, 09618 escape_Qundef((yyvsp[(2) - (6)].val)), 09619 escape_Qundef((yyvsp[(3) - (6)].val)), 09620 escape_Qundef((yyvsp[(5) - (6)].val)), 09621 escape_Qundef((yyvsp[(6) - (6)].val))); 09622 09623 } 09624 break; 09625 09626 case 443: 09627 09628 /* Line 1806 of yacc.c */ 09629 #line 3781 "ripper.y" 09630 { 09631 #if 0 09632 (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val)); 09633 #endif 09634 (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val)); 09635 09636 } 09637 break; 09638 09639 case 444: 09640 09641 /* Line 1806 of yacc.c */ 09642 #line 3789 "ripper.y" 09643 { 09644 #if 0 09645 if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val); 09646 #endif 09647 (yyval.val) = (yyvsp[(1) - (1)].val); 09648 09649 } 09650 break; 09651 09652 case 446: 09653 09654 /* Line 1806 of yacc.c */ 09655 #line 3800 "ripper.y" 09656 { 09657 (yyval.val) = (yyvsp[(2) - (2)].val); 09658 } 09659 break; 09660 09661 case 448: 09662 09663 /* Line 1806 of yacc.c */ 09664 #line 3807 "ripper.y" 09665 { 09666 #if 0 09667 (yyval.val) = (yyvsp[(2) - (2)].val); 09668 #endif 09669 (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val)); 09670 09671 } 09672 break; 09673 09674 case 451: 09675 09676 /* Line 1806 of yacc.c */ 09677 #line 3819 "ripper.y" 09678 { 09679 #if 0 09680 (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val))); 09681 #endif 09682 (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val)); 09683 09684 } 09685 break; 09686 09687 case 453: 09688 09689 /* Line 1806 of yacc.c */ 09690 #line 3830 "ripper.y" 09691 { 09692 #if 0 09693 NODE *node = (yyvsp[(1) - (1)].val); 09694 if (!node) { 09695 node = NEW_STR(STR_NEW0()); 09696 } 09697 else { 09698 node = evstr2dstr(node); 09699 } 09700 (yyval.val) = node; 09701 #endif 09702 (yyval.val) = (yyvsp[(1) - (1)].val); 09703 09704 } 09705 break; 09706 09707 case 456: 09708 09709 /* Line 1806 of yacc.c */ 09710 #line 3849 "ripper.y" 09711 { 09712 #if 0 09713 (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 09714 #endif 09715 (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 09716 09717 } 09718 break; 09719 09720 case 457: 09721 09722 /* Line 1806 of yacc.c */ 09723 #line 3859 "ripper.y" 09724 { 09725 #if 0 09726 (yyval.val) = (yyvsp[(2) - (3)].val); 09727 #endif 09728 (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val)); 09729 09730 } 09731 break; 09732 09733 case 458: 09734 09735 /* Line 1806 of yacc.c */ 09736 #line 3869 "ripper.y" 09737 { 09738 #if 0 09739 NODE *node = (yyvsp[(2) - (3)].val); 09740 if (!node) { 09741 node = NEW_XSTR(STR_NEW0()); 09742 } 09743 else { 09744 switch (nd_type(node)) { 09745 case NODE_STR: 09746 nd_set_type(node, NODE_XSTR); 09747 break; 09748 case NODE_DSTR: 09749 nd_set_type(node, NODE_DXSTR); 09750 break; 09751 default: 09752 node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node)); 09753 break; 09754 } 09755 } 09756 (yyval.val) = node; 09757 #endif 09758 (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val)); 09759 09760 } 09761 break; 09762 09763 case 459: 09764 09765 /* Line 1806 of yacc.c */ 09766 #line 3896 "ripper.y" 09767 { 09768 #if 0 09769 int options = (yyvsp[(3) - (3)].val); 09770 NODE *node = (yyvsp[(2) - (3)].val); 09771 NODE *list, *prev; 09772 if (!node) { 09773 node = NEW_LIT(reg_compile(STR_NEW0(), options)); 09774 } 09775 else switch (nd_type(node)) { 09776 case NODE_STR: 09777 { 09778 VALUE src = node->nd_lit; 09779 nd_set_type(node, NODE_LIT); 09780 node->nd_lit = reg_compile(src, options); 09781 } 09782 break; 09783 default: 09784 node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node)); 09785 case NODE_DSTR: 09786 if (options & RE_OPTION_ONCE) { 09787 nd_set_type(node, NODE_DREGX_ONCE); 09788 } 09789 else { 09790 nd_set_type(node, NODE_DREGX); 09791 } 09792 node->nd_cflag = options & RE_OPTION_MASK; 09793 if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options); 09794 for (list = (prev = node)->nd_next; list; list = list->nd_next) { 09795 if (nd_type(list->nd_head) == NODE_STR) { 09796 VALUE tail = list->nd_head->nd_lit; 09797 if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) { 09798 VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit; 09799 if (!literal_concat0(parser, lit, tail)) { 09800 node = 0; 09801 break; 09802 } 09803 rb_str_resize(tail, 0); 09804 prev->nd_next = list->nd_next; 09805 rb_gc_force_recycle((VALUE)list->nd_head); 09806 rb_gc_force_recycle((VALUE)list); 09807 list = prev; 09808 } 09809 else { 09810 prev = list; 09811 } 09812 } 09813 else { 09814 prev = 0; 09815 } 09816 } 09817 if (!node->nd_next) { 09818 VALUE src = node->nd_lit; 09819 nd_set_type(node, NODE_LIT); 09820 node->nd_lit = reg_compile(src, options); 09821 } 09822 break; 09823 } 09824 (yyval.val) = node; 09825 #endif 09826 (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val)); 09827 09828 } 09829 break; 09830 09831 case 460: 09832 09833 /* Line 1806 of yacc.c */ 09834 #line 3961 "ripper.y" 09835 { 09836 #if 0 09837 (yyval.val) = NEW_ZARRAY(); 09838 #endif 09839 (yyval.val) = dispatch0(words_new); 09840 (yyval.val) = dispatch1(array, (yyval.val)); 09841 09842 } 09843 break; 09844 09845 case 461: 09846 09847 /* Line 1806 of yacc.c */ 09848 #line 3970 "ripper.y" 09849 { 09850 #if 0 09851 (yyval.val) = (yyvsp[(2) - (3)].val); 09852 #endif 09853 (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val)); 09854 09855 } 09856 break; 09857 09858 case 462: 09859 09860 /* Line 1806 of yacc.c */ 09861 #line 3980 "ripper.y" 09862 { 09863 #if 0 09864 (yyval.val) = 0; 09865 #endif 09866 (yyval.val) = dispatch0(words_new); 09867 09868 } 09869 break; 09870 09871 case 463: 09872 09873 /* Line 1806 of yacc.c */ 09874 #line 3988 "ripper.y" 09875 { 09876 #if 0 09877 (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val))); 09878 #endif 09879 (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val)); 09880 09881 } 09882 break; 09883 09884 case 464: 09885 09886 /* Line 1806 of yacc.c */ 09887 #line 4000 "ripper.y" 09888 { 09889 (yyval.val) = dispatch0(word_new); 09890 (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val)); 09891 } 09892 break; 09893 09894 case 465: 09895 09896 /* Line 1806 of yacc.c */ 09897 #line 4006 "ripper.y" 09898 { 09899 #if 0 09900 (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 09901 #endif 09902 (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 09903 09904 } 09905 break; 09906 09907 case 466: 09908 09909 /* Line 1806 of yacc.c */ 09910 #line 4016 "ripper.y" 09911 { 09912 #if 0 09913 (yyval.val) = NEW_ZARRAY(); 09914 #endif 09915 (yyval.val) = dispatch0(symbols_new); 09916 (yyval.val) = dispatch1(array, (yyval.val)); 09917 09918 } 09919 break; 09920 09921 case 467: 09922 09923 /* Line 1806 of yacc.c */ 09924 #line 4025 "ripper.y" 09925 { 09926 #if 0 09927 (yyval.val) = (yyvsp[(2) - (3)].val); 09928 #endif 09929 (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val)); 09930 09931 } 09932 break; 09933 09934 case 468: 09935 09936 /* Line 1806 of yacc.c */ 09937 #line 4035 "ripper.y" 09938 { 09939 #if 0 09940 (yyval.val) = 0; 09941 #endif 09942 (yyval.val) = dispatch0(symbols_new); 09943 09944 } 09945 break; 09946 09947 case 469: 09948 09949 /* Line 1806 of yacc.c */ 09950 #line 4043 "ripper.y" 09951 { 09952 #if 0 09953 (yyvsp[(2) - (3)].val) = evstr2dstr((yyvsp[(2) - (3)].val)); 09954 nd_set_type((yyvsp[(2) - (3)].val), NODE_DSYM); 09955 (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val)); 09956 #endif 09957 (yyval.val) = dispatch2(symbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val)); 09958 09959 } 09960 break; 09961 09962 case 470: 09963 09964 /* Line 1806 of yacc.c */ 09965 #line 4055 "ripper.y" 09966 { 09967 #if 0 09968 (yyval.val) = NEW_ZARRAY(); 09969 #endif 09970 (yyval.val) = dispatch0(qwords_new); 09971 (yyval.val) = dispatch1(array, (yyval.val)); 09972 09973 } 09974 break; 09975 09976 case 471: 09977 09978 /* Line 1806 of yacc.c */ 09979 #line 4064 "ripper.y" 09980 { 09981 #if 0 09982 (yyval.val) = (yyvsp[(2) - (3)].val); 09983 #endif 09984 (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val)); 09985 09986 } 09987 break; 09988 09989 case 472: 09990 09991 /* Line 1806 of yacc.c */ 09992 #line 4074 "ripper.y" 09993 { 09994 #if 0 09995 (yyval.val) = NEW_ZARRAY(); 09996 #endif 09997 (yyval.val) = dispatch0(qsymbols_new); 09998 (yyval.val) = dispatch1(array, (yyval.val)); 09999 10000 } 10001 break; 10002 10003 case 473: 10004 10005 /* Line 1806 of yacc.c */ 10006 #line 4083 "ripper.y" 10007 { 10008 #if 0 10009 (yyval.val) = (yyvsp[(2) - (3)].val); 10010 #endif 10011 (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val)); 10012 10013 } 10014 break; 10015 10016 case 474: 10017 10018 /* Line 1806 of yacc.c */ 10019 #line 4093 "ripper.y" 10020 { 10021 #if 0 10022 (yyval.val) = 0; 10023 #endif 10024 (yyval.val) = dispatch0(qwords_new); 10025 10026 } 10027 break; 10028 10029 case 475: 10030 10031 /* Line 1806 of yacc.c */ 10032 #line 4101 "ripper.y" 10033 { 10034 #if 0 10035 (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val)); 10036 #endif 10037 (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val)); 10038 10039 } 10040 break; 10041 10042 case 476: 10043 10044 /* Line 1806 of yacc.c */ 10045 #line 4111 "ripper.y" 10046 { 10047 #if 0 10048 (yyval.val) = 0; 10049 #endif 10050 (yyval.val) = dispatch0(qsymbols_new); 10051 10052 } 10053 break; 10054 10055 case 477: 10056 10057 /* Line 1806 of yacc.c */ 10058 #line 4119 "ripper.y" 10059 { 10060 #if 0 10061 VALUE lit; 10062 lit = (yyvsp[(2) - (3)].val)->nd_lit; 10063 (yyvsp[(2) - (3)].val)->nd_lit = ID2SYM(rb_intern_str(lit)); 10064 nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT); 10065 (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val)); 10066 #endif 10067 (yyval.val) = dispatch2(qsymbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val)); 10068 10069 } 10070 break; 10071 10072 case 478: 10073 10074 /* Line 1806 of yacc.c */ 10075 #line 4133 "ripper.y" 10076 { 10077 #if 0 10078 (yyval.val) = 0; 10079 #endif 10080 (yyval.val) = dispatch0(string_content); 10081 10082 } 10083 break; 10084 10085 case 479: 10086 10087 /* Line 1806 of yacc.c */ 10088 #line 4141 "ripper.y" 10089 { 10090 #if 0 10091 (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 10092 #endif 10093 (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 10094 10095 } 10096 break; 10097 10098 case 480: 10099 10100 /* Line 1806 of yacc.c */ 10101 #line 4151 "ripper.y" 10102 { 10103 #if 0 10104 (yyval.val) = 0; 10105 #endif 10106 (yyval.val) = dispatch0(xstring_new); 10107 10108 } 10109 break; 10110 10111 case 481: 10112 10113 /* Line 1806 of yacc.c */ 10114 #line 4159 "ripper.y" 10115 { 10116 #if 0 10117 (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 10118 #endif 10119 (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 10120 10121 } 10122 break; 10123 10124 case 482: 10125 10126 /* Line 1806 of yacc.c */ 10127 #line 4169 "ripper.y" 10128 { 10129 #if 0 10130 (yyval.val) = 0; 10131 #endif 10132 (yyval.val) = dispatch0(regexp_new); 10133 10134 } 10135 break; 10136 10137 case 483: 10138 10139 /* Line 1806 of yacc.c */ 10140 #line 4177 "ripper.y" 10141 { 10142 #if 0 10143 NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val); 10144 if (!head) { 10145 (yyval.val) = tail; 10146 } 10147 else if (!tail) { 10148 (yyval.val) = head; 10149 } 10150 else { 10151 switch (nd_type(head)) { 10152 case NODE_STR: 10153 nd_set_type(head, NODE_DSTR); 10154 break; 10155 case NODE_DSTR: 10156 break; 10157 default: 10158 head = list_append(NEW_DSTR(Qnil), head); 10159 break; 10160 } 10161 (yyval.val) = list_append(head, tail); 10162 } 10163 #endif 10164 (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 10165 10166 } 10167 break; 10168 10169 case 485: 10170 10171 /* Line 1806 of yacc.c */ 10172 #line 4207 "ripper.y" 10173 { 10174 (yyval.node) = lex_strterm; 10175 lex_strterm = 0; 10176 lex_state = EXPR_BEG; 10177 } 10178 break; 10179 10180 case 486: 10181 10182 /* Line 1806 of yacc.c */ 10183 #line 4213 "ripper.y" 10184 { 10185 #if 0 10186 lex_strterm = (yyvsp[(2) - (3)].node); 10187 (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val)); 10188 #endif 10189 lex_strterm = (yyvsp[(2) - (3)].node); 10190 (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val)); 10191 10192 } 10193 break; 10194 10195 case 487: 10196 10197 /* Line 1806 of yacc.c */ 10198 #line 4223 "ripper.y" 10199 { 10200 (yyvsp[(1) - (1)].val) = cond_stack; 10201 (yyval.val) = cmdarg_stack; 10202 cond_stack = 0; 10203 cmdarg_stack = 0; 10204 } 10205 break; 10206 10207 case 488: 10208 10209 /* Line 1806 of yacc.c */ 10210 #line 4229 "ripper.y" 10211 { 10212 (yyval.node) = lex_strterm; 10213 lex_strterm = 0; 10214 lex_state = EXPR_BEG; 10215 } 10216 break; 10217 10218 case 489: 10219 10220 /* Line 1806 of yacc.c */ 10221 #line 4234 "ripper.y" 10222 { 10223 (yyval.num) = brace_nest; 10224 brace_nest = 0; 10225 } 10226 break; 10227 10228 case 490: 10229 10230 /* Line 1806 of yacc.c */ 10231 #line 4239 "ripper.y" 10232 { 10233 cond_stack = (yyvsp[(1) - (6)].val); 10234 cmdarg_stack = (yyvsp[(2) - (6)].val); 10235 lex_strterm = (yyvsp[(3) - (6)].node); 10236 brace_nest = (yyvsp[(4) - (6)].num); 10237 #if 0 10238 if ((yyvsp[(5) - (6)].val)) (yyvsp[(5) - (6)].val)->flags &= ~NODE_FL_NEWLINE; 10239 (yyval.val) = new_evstr((yyvsp[(5) - (6)].val)); 10240 #endif 10241 (yyval.val) = dispatch1(string_embexpr, (yyvsp[(5) - (6)].val)); 10242 10243 } 10244 break; 10245 10246 case 491: 10247 10248 /* Line 1806 of yacc.c */ 10249 #line 4254 "ripper.y" 10250 { 10251 #if 0 10252 (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val)); 10253 #endif 10254 (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val)); 10255 10256 } 10257 break; 10258 10259 case 492: 10260 10261 /* Line 1806 of yacc.c */ 10262 #line 4262 "ripper.y" 10263 { 10264 #if 0 10265 (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val)); 10266 #endif 10267 (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val)); 10268 10269 } 10270 break; 10271 10272 case 493: 10273 10274 /* Line 1806 of yacc.c */ 10275 #line 4270 "ripper.y" 10276 { 10277 #if 0 10278 (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val)); 10279 #endif 10280 (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val)); 10281 10282 } 10283 break; 10284 10285 case 495: 10286 10287 /* Line 1806 of yacc.c */ 10288 #line 4281 "ripper.y" 10289 { 10290 lex_state = EXPR_END; 10291 #if 0 10292 (yyval.val) = (yyvsp[(2) - (2)].val); 10293 #endif 10294 (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val)); 10295 10296 } 10297 break; 10298 10299 case 500: 10300 10301 /* Line 1806 of yacc.c */ 10302 #line 4298 "ripper.y" 10303 { 10304 lex_state = EXPR_END; 10305 #if 0 10306 (yyval.val) = dsym_node((yyvsp[(2) - (3)].val)); 10307 #endif 10308 (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val)); 10309 10310 } 10311 break; 10312 10313 case 503: 10314 10315 /* Line 1806 of yacc.c */ 10316 #line 4311 "ripper.y" 10317 { 10318 #if 0 10319 (yyval.val) = negate_lit((yyvsp[(2) - (2)].val)); 10320 #endif 10321 (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val)); 10322 10323 } 10324 break; 10325 10326 case 504: 10327 10328 /* Line 1806 of yacc.c */ 10329 #line 4319 "ripper.y" 10330 { 10331 #if 0 10332 (yyval.val) = negate_lit((yyvsp[(2) - (2)].val)); 10333 #endif 10334 (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val)); 10335 10336 } 10337 break; 10338 10339 case 510: 10340 10341 /* Line 1806 of yacc.c */ 10342 #line 4335 "ripper.y" 10343 {ifndef_ripper((yyval.val) = keyword_nil);} 10344 break; 10345 10346 case 511: 10347 10348 /* Line 1806 of yacc.c */ 10349 #line 4336 "ripper.y" 10350 {ifndef_ripper((yyval.val) = keyword_self);} 10351 break; 10352 10353 case 512: 10354 10355 /* Line 1806 of yacc.c */ 10356 #line 4337 "ripper.y" 10357 {ifndef_ripper((yyval.val) = keyword_true);} 10358 break; 10359 10360 case 513: 10361 10362 /* Line 1806 of yacc.c */ 10363 #line 4338 "ripper.y" 10364 {ifndef_ripper((yyval.val) = keyword_false);} 10365 break; 10366 10367 case 514: 10368 10369 /* Line 1806 of yacc.c */ 10370 #line 4339 "ripper.y" 10371 {ifndef_ripper((yyval.val) = keyword__FILE__);} 10372 break; 10373 10374 case 515: 10375 10376 /* Line 1806 of yacc.c */ 10377 #line 4340 "ripper.y" 10378 {ifndef_ripper((yyval.val) = keyword__LINE__);} 10379 break; 10380 10381 case 516: 10382 10383 /* Line 1806 of yacc.c */ 10384 #line 4341 "ripper.y" 10385 {ifndef_ripper((yyval.val) = keyword__ENCODING__);} 10386 break; 10387 10388 case 517: 10389 10390 /* Line 1806 of yacc.c */ 10391 #line 4345 "ripper.y" 10392 { 10393 #if 0 10394 if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0); 10395 #endif 10396 if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) { 10397 (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val)); 10398 } 10399 else { 10400 (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val)); 10401 } 10402 10403 } 10404 break; 10405 10406 case 518: 10407 10408 /* Line 1806 of yacc.c */ 10409 #line 4358 "ripper.y" 10410 { 10411 #if 0 10412 if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0); 10413 #endif 10414 (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val)); 10415 10416 } 10417 break; 10418 10419 case 519: 10420 10421 /* Line 1806 of yacc.c */ 10422 #line 4368 "ripper.y" 10423 { 10424 (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0); 10425 #if 0 10426 #endif 10427 (yyval.val) = dispatch1(var_field, (yyval.val)); 10428 10429 } 10430 break; 10431 10432 case 520: 10433 10434 /* Line 1806 of yacc.c */ 10435 #line 4376 "ripper.y" 10436 { 10437 (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0); 10438 #if 0 10439 #endif 10440 (yyval.val) = dispatch1(var_field, (yyval.val)); 10441 10442 } 10443 break; 10444 10445 case 523: 10446 10447 /* Line 1806 of yacc.c */ 10448 #line 4390 "ripper.y" 10449 { 10450 #if 0 10451 (yyval.val) = 0; 10452 #endif 10453 (yyval.val) = Qnil; 10454 10455 } 10456 break; 10457 10458 case 524: 10459 10460 /* Line 1806 of yacc.c */ 10461 #line 4398 "ripper.y" 10462 { 10463 lex_state = EXPR_BEG; 10464 command_start = TRUE; 10465 } 10466 break; 10467 10468 case 525: 10469 10470 /* Line 1806 of yacc.c */ 10471 #line 4403 "ripper.y" 10472 { 10473 (yyval.val) = (yyvsp[(3) - (4)].val); 10474 } 10475 break; 10476 10477 case 526: 10478 10479 /* Line 1806 of yacc.c */ 10480 #line 4407 "ripper.y" 10481 { 10482 #if 0 10483 yyerrok; 10484 (yyval.val) = 0; 10485 #endif 10486 yyerrok; 10487 (yyval.val) = Qnil; 10488 10489 } 10490 break; 10491 10492 case 527: 10493 10494 /* Line 1806 of yacc.c */ 10495 #line 4419 "ripper.y" 10496 { 10497 #if 0 10498 (yyval.val) = (yyvsp[(2) - (3)].val); 10499 #endif 10500 (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val)); 10501 10502 lex_state = EXPR_BEG; 10503 command_start = TRUE; 10504 } 10505 break; 10506 10507 case 528: 10508 10509 /* Line 1806 of yacc.c */ 10510 #line 4429 "ripper.y" 10511 { 10512 (yyval.val) = (yyvsp[(1) - (2)].val); 10513 lex_state = EXPR_BEG; 10514 command_start = TRUE; 10515 } 10516 break; 10517 10518 case 529: 10519 10520 /* Line 1806 of yacc.c */ 10521 #line 4437 "ripper.y" 10522 { 10523 (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 10524 } 10525 break; 10526 10527 case 530: 10528 10529 /* Line 1806 of yacc.c */ 10530 #line 4441 "ripper.y" 10531 { 10532 (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val)); 10533 } 10534 break; 10535 10536 case 531: 10537 10538 /* Line 1806 of yacc.c */ 10539 #line 4445 "ripper.y" 10540 { 10541 (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 10542 } 10543 break; 10544 10545 case 532: 10546 10547 /* Line 1806 of yacc.c */ 10548 #line 4449 "ripper.y" 10549 { 10550 (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val)); 10551 } 10552 break; 10553 10554 case 533: 10555 10556 /* Line 1806 of yacc.c */ 10557 #line 4455 "ripper.y" 10558 { 10559 (yyval.val) = (yyvsp[(2) - (2)].val); 10560 } 10561 break; 10562 10563 case 534: 10564 10565 /* Line 1806 of yacc.c */ 10566 #line 4459 "ripper.y" 10567 { 10568 (yyval.val) = new_args_tail(Qnone, Qnone, Qnone); 10569 } 10570 break; 10571 10572 case 535: 10573 10574 /* Line 1806 of yacc.c */ 10575 #line 4465 "ripper.y" 10576 { 10577 (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val)); 10578 } 10579 break; 10580 10581 case 536: 10582 10583 /* Line 1806 of yacc.c */ 10584 #line 4469 "ripper.y" 10585 { 10586 (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val)); 10587 } 10588 break; 10589 10590 case 537: 10591 10592 /* Line 1806 of yacc.c */ 10593 #line 4473 "ripper.y" 10594 { 10595 (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val)); 10596 } 10597 break; 10598 10599 case 538: 10600 10601 /* Line 1806 of yacc.c */ 10602 #line 4477 "ripper.y" 10603 { 10604 (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val)); 10605 } 10606 break; 10607 10608 case 539: 10609 10610 /* Line 1806 of yacc.c */ 10611 #line 4481 "ripper.y" 10612 { 10613 (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val)); 10614 } 10615 break; 10616 10617 case 540: 10618 10619 /* Line 1806 of yacc.c */ 10620 #line 4485 "ripper.y" 10621 { 10622 (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val)); 10623 } 10624 break; 10625 10626 case 541: 10627 10628 /* Line 1806 of yacc.c */ 10629 #line 4489 "ripper.y" 10630 { 10631 (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val)); 10632 } 10633 break; 10634 10635 case 542: 10636 10637 /* Line 1806 of yacc.c */ 10638 #line 4493 "ripper.y" 10639 { 10640 (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val)); 10641 } 10642 break; 10643 10644 case 543: 10645 10646 /* Line 1806 of yacc.c */ 10647 #line 4497 "ripper.y" 10648 { 10649 (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val)); 10650 } 10651 break; 10652 10653 case 544: 10654 10655 /* Line 1806 of yacc.c */ 10656 #line 4501 "ripper.y" 10657 { 10658 (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val)); 10659 } 10660 break; 10661 10662 case 545: 10663 10664 /* Line 1806 of yacc.c */ 10665 #line 4505 "ripper.y" 10666 { 10667 (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 10668 } 10669 break; 10670 10671 case 546: 10672 10673 /* Line 1806 of yacc.c */ 10674 #line 4509 "ripper.y" 10675 { 10676 (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val)); 10677 } 10678 break; 10679 10680 case 547: 10681 10682 /* Line 1806 of yacc.c */ 10683 #line 4513 "ripper.y" 10684 { 10685 (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val)); 10686 } 10687 break; 10688 10689 case 548: 10690 10691 /* Line 1806 of yacc.c */ 10692 #line 4517 "ripper.y" 10693 { 10694 (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val)); 10695 } 10696 break; 10697 10698 case 549: 10699 10700 /* Line 1806 of yacc.c */ 10701 #line 4521 "ripper.y" 10702 { 10703 (yyval.val) = new_args_tail(Qnone, Qnone, Qnone); 10704 (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.val)); 10705 } 10706 break; 10707 10708 case 550: 10709 10710 /* Line 1806 of yacc.c */ 10711 #line 4528 "ripper.y" 10712 { 10713 #if 0 10714 yyerror("formal argument cannot be a constant"); 10715 (yyval.val) = 0; 10716 #endif 10717 (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val)); 10718 10719 } 10720 break; 10721 10722 case 551: 10723 10724 /* Line 1806 of yacc.c */ 10725 #line 4537 "ripper.y" 10726 { 10727 #if 0 10728 yyerror("formal argument cannot be an instance variable"); 10729 (yyval.val) = 0; 10730 #endif 10731 (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val)); 10732 10733 } 10734 break; 10735 10736 case 552: 10737 10738 /* Line 1806 of yacc.c */ 10739 #line 4546 "ripper.y" 10740 { 10741 #if 0 10742 yyerror("formal argument cannot be a global variable"); 10743 (yyval.val) = 0; 10744 #endif 10745 (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val)); 10746 10747 } 10748 break; 10749 10750 case 553: 10751 10752 /* Line 1806 of yacc.c */ 10753 #line 4555 "ripper.y" 10754 { 10755 #if 0 10756 yyerror("formal argument cannot be a class variable"); 10757 (yyval.val) = 0; 10758 #endif 10759 (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val)); 10760 10761 } 10762 break; 10763 10764 case 555: 10765 10766 /* Line 1806 of yacc.c */ 10767 #line 4567 "ripper.y" 10768 { 10769 formal_argument(get_id((yyvsp[(1) - (1)].val))); 10770 (yyval.val) = (yyvsp[(1) - (1)].val); 10771 } 10772 break; 10773 10774 case 556: 10775 10776 /* Line 1806 of yacc.c */ 10777 #line 4574 "ripper.y" 10778 { 10779 arg_var(get_id((yyvsp[(1) - (1)].val))); 10780 #if 0 10781 (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1); 10782 #endif 10783 (yyval.val) = get_value((yyvsp[(1) - (1)].val)); 10784 10785 } 10786 break; 10787 10788 case 557: 10789 10790 /* Line 1806 of yacc.c */ 10791 #line 4583 "ripper.y" 10792 { 10793 ID tid = internal_id(); 10794 arg_var(tid); 10795 #if 0 10796 if (dyna_in_block()) { 10797 (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid); 10798 } 10799 else { 10800 (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid); 10801 } 10802 (yyval.val) = NEW_ARGS_AUX(tid, 1); 10803 (yyval.val)->nd_next = (yyvsp[(2) - (3)].val); 10804 #endif 10805 (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val)); 10806 10807 } 10808 break; 10809 10810 case 558: 10811 10812 /* Line 1806 of yacc.c */ 10813 #line 4604 "ripper.y" 10814 { 10815 (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val)); 10816 } 10817 break; 10818 10819 case 559: 10820 10821 /* Line 1806 of yacc.c */ 10822 #line 4609 "ripper.y" 10823 { 10824 #if 0 10825 (yyval.val) = (yyvsp[(1) - (3)].val); 10826 (yyval.val)->nd_plen++; 10827 (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next); 10828 rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val)); 10829 #endif 10830 (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 10831 10832 } 10833 break; 10834 10835 case 560: 10836 10837 /* Line 1806 of yacc.c */ 10838 #line 4622 "ripper.y" 10839 { 10840 arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val)))); 10841 (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 10842 #if 0 10843 (yyval.val) = NEW_KW_ARG(0, (yyval.val)); 10844 #endif 10845 (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val)); 10846 10847 } 10848 break; 10849 10850 case 561: 10851 10852 /* Line 1806 of yacc.c */ 10853 #line 4634 "ripper.y" 10854 { 10855 arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val)))); 10856 (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 10857 #if 0 10858 (yyval.val) = NEW_KW_ARG(0, (yyval.val)); 10859 #endif 10860 (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val)); 10861 10862 } 10863 break; 10864 10865 case 562: 10866 10867 /* Line 1806 of yacc.c */ 10868 #line 4646 "ripper.y" 10869 { 10870 #if 0 10871 (yyval.val) = (yyvsp[(1) - (1)].val); 10872 #endif 10873 (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val)); 10874 10875 } 10876 break; 10877 10878 case 563: 10879 10880 /* Line 1806 of yacc.c */ 10881 #line 4654 "ripper.y" 10882 { 10883 #if 0 10884 NODE *kws = (yyvsp[(1) - (3)].val); 10885 10886 while (kws->nd_next) { 10887 kws = kws->nd_next; 10888 } 10889 kws->nd_next = (yyvsp[(3) - (3)].val); 10890 (yyval.val) = (yyvsp[(1) - (3)].val); 10891 #endif 10892 (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 10893 10894 } 10895 break; 10896 10897 case 564: 10898 10899 /* Line 1806 of yacc.c */ 10900 #line 4671 "ripper.y" 10901 { 10902 #if 0 10903 (yyval.val) = (yyvsp[(1) - (1)].val); 10904 #endif 10905 (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val)); 10906 10907 } 10908 break; 10909 10910 case 565: 10911 10912 /* Line 1806 of yacc.c */ 10913 #line 4679 "ripper.y" 10914 { 10915 #if 0 10916 NODE *kws = (yyvsp[(1) - (3)].val); 10917 10918 while (kws->nd_next) { 10919 kws = kws->nd_next; 10920 } 10921 kws->nd_next = (yyvsp[(3) - (3)].val); 10922 (yyval.val) = (yyvsp[(1) - (3)].val); 10923 #endif 10924 (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 10925 10926 } 10927 break; 10928 10929 case 568: 10930 10931 /* Line 1806 of yacc.c */ 10932 #line 4699 "ripper.y" 10933 { 10934 shadowing_lvar(get_id((yyvsp[(2) - (2)].val))); 10935 (yyval.val) = (yyvsp[(2) - (2)].val); 10936 } 10937 break; 10938 10939 case 569: 10940 10941 /* Line 1806 of yacc.c */ 10942 #line 4704 "ripper.y" 10943 { 10944 (yyval.val) = internal_id(); 10945 } 10946 break; 10947 10948 case 570: 10949 10950 /* Line 1806 of yacc.c */ 10951 #line 4710 "ripper.y" 10952 { 10953 arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val)))); 10954 (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 10955 #if 0 10956 (yyval.val) = NEW_OPT_ARG(0, (yyval.val)); 10957 #endif 10958 (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val)); 10959 10960 } 10961 break; 10962 10963 case 571: 10964 10965 /* Line 1806 of yacc.c */ 10966 #line 4722 "ripper.y" 10967 { 10968 arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val)))); 10969 (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 10970 #if 0 10971 (yyval.val) = NEW_OPT_ARG(0, (yyval.val)); 10972 #endif 10973 (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val)); 10974 10975 } 10976 break; 10977 10978 case 572: 10979 10980 /* Line 1806 of yacc.c */ 10981 #line 4734 "ripper.y" 10982 { 10983 #if 0 10984 (yyval.val) = (yyvsp[(1) - (1)].val); 10985 #endif 10986 (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val)); 10987 10988 } 10989 break; 10990 10991 case 573: 10992 10993 /* Line 1806 of yacc.c */ 10994 #line 4742 "ripper.y" 10995 { 10996 #if 0 10997 NODE *opts = (yyvsp[(1) - (3)].val); 10998 10999 while (opts->nd_next) { 11000 opts = opts->nd_next; 11001 } 11002 opts->nd_next = (yyvsp[(3) - (3)].val); 11003 (yyval.val) = (yyvsp[(1) - (3)].val); 11004 #endif 11005 (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 11006 11007 } 11008 break; 11009 11010 case 574: 11011 11012 /* Line 1806 of yacc.c */ 11013 #line 4758 "ripper.y" 11014 { 11015 #if 0 11016 (yyval.val) = (yyvsp[(1) - (1)].val); 11017 #endif 11018 (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val)); 11019 11020 } 11021 break; 11022 11023 case 575: 11024 11025 /* Line 1806 of yacc.c */ 11026 #line 4766 "ripper.y" 11027 { 11028 #if 0 11029 NODE *opts = (yyvsp[(1) - (3)].val); 11030 11031 while (opts->nd_next) { 11032 opts = opts->nd_next; 11033 } 11034 opts->nd_next = (yyvsp[(3) - (3)].val); 11035 (yyval.val) = (yyvsp[(1) - (3)].val); 11036 #endif 11037 (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 11038 11039 } 11040 break; 11041 11042 case 578: 11043 11044 /* Line 1806 of yacc.c */ 11045 #line 4786 "ripper.y" 11046 { 11047 #if 0 11048 if (!is_local_id((yyvsp[(2) - (2)].val))) 11049 yyerror("rest argument must be local variable"); 11050 #endif 11051 arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val)))); 11052 #if 0 11053 (yyval.val) = (yyvsp[(2) - (2)].val); 11054 #endif 11055 (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val)); 11056 11057 } 11058 break; 11059 11060 case 579: 11061 11062 /* Line 1806 of yacc.c */ 11063 #line 4799 "ripper.y" 11064 { 11065 #if 0 11066 (yyval.val) = internal_id(); 11067 arg_var((yyval.val)); 11068 #endif 11069 (yyval.val) = dispatch1(rest_param, Qnil); 11070 11071 } 11072 break; 11073 11074 case 582: 11075 11076 /* Line 1806 of yacc.c */ 11077 #line 4814 "ripper.y" 11078 { 11079 #if 0 11080 if (!is_local_id((yyvsp[(2) - (2)].val))) 11081 yyerror("block argument must be local variable"); 11082 else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val))) 11083 yyerror("duplicated block argument name"); 11084 #endif 11085 arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val)))); 11086 #if 0 11087 (yyval.val) = (yyvsp[(2) - (2)].val); 11088 #endif 11089 (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val)); 11090 11091 } 11092 break; 11093 11094 case 583: 11095 11096 /* Line 1806 of yacc.c */ 11097 #line 4831 "ripper.y" 11098 { 11099 (yyval.val) = (yyvsp[(2) - (2)].val); 11100 } 11101 break; 11102 11103 case 584: 11104 11105 /* Line 1806 of yacc.c */ 11106 #line 4835 "ripper.y" 11107 { 11108 #if 0 11109 (yyval.val) = 0; 11110 #endif 11111 (yyval.val) = Qundef; 11112 11113 } 11114 break; 11115 11116 case 585: 11117 11118 /* Line 1806 of yacc.c */ 11119 #line 4845 "ripper.y" 11120 { 11121 #if 0 11122 value_expr((yyvsp[(1) - (1)].val)); 11123 (yyval.val) = (yyvsp[(1) - (1)].val); 11124 if (!(yyval.val)) (yyval.val) = NEW_NIL(); 11125 #endif 11126 (yyval.val) = (yyvsp[(1) - (1)].val); 11127 11128 } 11129 break; 11130 11131 case 586: 11132 11133 /* Line 1806 of yacc.c */ 11134 #line 4854 "ripper.y" 11135 {lex_state = EXPR_BEG;} 11136 break; 11137 11138 case 587: 11139 11140 /* Line 1806 of yacc.c */ 11141 #line 4855 "ripper.y" 11142 { 11143 #if 0 11144 if ((yyvsp[(3) - (4)].val) == 0) { 11145 yyerror("can't define singleton method for ()."); 11146 } 11147 else { 11148 switch (nd_type((yyvsp[(3) - (4)].val))) { 11149 case NODE_STR: 11150 case NODE_DSTR: 11151 case NODE_XSTR: 11152 case NODE_DXSTR: 11153 case NODE_DREGX: 11154 case NODE_LIT: 11155 case NODE_ARRAY: 11156 case NODE_ZARRAY: 11157 yyerror("can't define singleton method for literals"); 11158 default: 11159 value_expr((yyvsp[(3) - (4)].val)); 11160 break; 11161 } 11162 } 11163 (yyval.val) = (yyvsp[(3) - (4)].val); 11164 #endif 11165 (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val)); 11166 11167 } 11168 break; 11169 11170 case 589: 11171 11172 /* Line 1806 of yacc.c */ 11173 #line 4885 "ripper.y" 11174 { 11175 #if 0 11176 (yyval.val) = (yyvsp[(1) - (2)].val); 11177 #endif 11178 (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val)); 11179 11180 } 11181 break; 11182 11183 case 590: 11184 11185 /* Line 1806 of yacc.c */ 11186 #line 4897 "ripper.y" 11187 { 11188 (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val)); 11189 } 11190 break; 11191 11192 case 591: 11193 11194 /* Line 1806 of yacc.c */ 11195 #line 4902 "ripper.y" 11196 { 11197 #if 0 11198 (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 11199 #endif 11200 (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 11201 11202 } 11203 break; 11204 11205 case 592: 11206 11207 /* Line 1806 of yacc.c */ 11208 #line 4912 "ripper.y" 11209 { 11210 #if 0 11211 (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val)); 11212 #endif 11213 (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); 11214 11215 } 11216 break; 11217 11218 case 593: 11219 11220 /* Line 1806 of yacc.c */ 11221 #line 4920 "ripper.y" 11222 { 11223 #if 0 11224 (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val)); 11225 #endif 11226 (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); 11227 11228 } 11229 break; 11230 11231 case 594: 11232 11233 /* Line 1806 of yacc.c */ 11234 #line 4928 "ripper.y" 11235 { 11236 #if 0 11237 (yyval.val) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].val)); 11238 #endif 11239 (yyval.val) = dispatch1(assoc_splat, (yyvsp[(2) - (2)].val)); 11240 11241 } 11242 break; 11243 11244 case 605: 11245 11246 /* Line 1806 of yacc.c */ 11247 #line 4958 "ripper.y" 11248 { (yyval.val) = (yyvsp[(1) - (1)].val); } 11249 break; 11250 11251 case 606: 11252 11253 /* Line 1806 of yacc.c */ 11254 #line 4963 "ripper.y" 11255 { (yyval.val) = (yyvsp[(1) - (1)].val); } 11256 break; 11257 11258 case 616: 11259 11260 /* Line 1806 of yacc.c */ 11261 #line 4986 "ripper.y" 11262 {yyerrok;} 11263 break; 11264 11265 case 619: 11266 11267 /* Line 1806 of yacc.c */ 11268 #line 4991 "ripper.y" 11269 {yyerrok;} 11270 break; 11271 11272 case 620: 11273 11274 /* Line 1806 of yacc.c */ 11275 #line 4995 "ripper.y" 11276 { 11277 #if 0 11278 (yyval.val) = 0; 11279 #endif 11280 (yyval.val) = Qundef; 11281 11282 } 11283 break; 11284 11285 11286 11287 /* Line 1806 of yacc.c */ 11288 #line 11287 "parse.c" 11289 default: break; 11290 } 11291 /* User semantic actions sometimes alter yychar, and that requires 11292 that yytoken be updated with the new translation. We take the 11293 approach of translating immediately before every use of yytoken. 11294 One alternative is translating here after every semantic action, 11295 but that translation would be missed if the semantic action invokes 11296 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 11297 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 11298 incorrect destructor might then be invoked immediately. In the 11299 case of YYERROR or YYBACKUP, subsequent parser actions might lead 11300 to an incorrect destructor call or verbose syntax error message 11301 before the lookahead is translated. */ 11302 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 11303 11304 YYPOPSTACK (yylen); 11305 yylen = 0; 11306 YY_STACK_PRINT (yyss, yyssp); 11307 11308 *++yyvsp = yyval; 11309 11310 /* Now `shift' the result of the reduction. Determine what state 11311 that goes to, based on the state we popped back to and the rule 11312 number reduced by. */ 11313 11314 yyn = yyr1[yyn]; 11315 11316 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 11317 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 11318 yystate = yytable[yystate]; 11319 else 11320 yystate = yydefgoto[yyn - YYNTOKENS]; 11321 11322 goto yynewstate; 11323 11324 11325 /*------------------------------------. 11326 | yyerrlab -- here on detecting error | 11327 `------------------------------------*/ 11328 yyerrlab: 11329 /* Make sure we have latest lookahead translation. See comments at 11330 user semantic actions for why this is necessary. */ 11331 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 11332 11333 /* If not already recovering from an error, report this error. */ 11334 if (!yyerrstatus) 11335 { 11336 ++yynerrs; 11337 #if ! YYERROR_VERBOSE 11338 parser_yyerror (parser, YY_("syntax error")); 11339 #else 11340 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 11341 yyssp, yytoken) 11342 { 11343 char const *yymsgp = YY_("syntax error"); 11344 int yysyntax_error_status; 11345 yysyntax_error_status = YYSYNTAX_ERROR; 11346 if (yysyntax_error_status == 0) 11347 yymsgp = yymsg; 11348 else if (yysyntax_error_status == 1) 11349 { 11350 if (yymsg != yymsgbuf) 11351 YYSTACK_FREE (yymsg); 11352 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 11353 if (!yymsg) 11354 { 11355 yymsg = yymsgbuf; 11356 yymsg_alloc = sizeof yymsgbuf; 11357 yysyntax_error_status = 2; 11358 } 11359 else 11360 { 11361 yysyntax_error_status = YYSYNTAX_ERROR; 11362 yymsgp = yymsg; 11363 } 11364 } 11365 parser_yyerror (parser, yymsgp); 11366 if (yysyntax_error_status == 2) 11367 goto yyexhaustedlab; 11368 } 11369 # undef YYSYNTAX_ERROR 11370 #endif 11371 } 11372 11373 11374 11375 if (yyerrstatus == 3) 11376 { 11377 /* If just tried and failed to reuse lookahead token after an 11378 error, discard it. */ 11379 11380 if (yychar <= YYEOF) 11381 { 11382 /* Return failure if at end of input. */ 11383 if (yychar == YYEOF) 11384 YYABORT; 11385 } 11386 else 11387 { 11388 yydestruct ("Error: discarding", 11389 yytoken, &yylval, parser); 11390 yychar = YYEMPTY; 11391 } 11392 } 11393 11394 /* Else will try to reuse lookahead token after shifting the error 11395 token. */ 11396 goto yyerrlab1; 11397 11398 11399 /*---------------------------------------------------. 11400 | yyerrorlab -- error raised explicitly by YYERROR. | 11401 `---------------------------------------------------*/ 11402 yyerrorlab: 11403 11404 /* Pacify compilers like GCC when the user code never invokes 11405 YYERROR and the label yyerrorlab therefore never appears in user 11406 code. */ 11407 if (/*CONSTCOND*/ 0) 11408 goto yyerrorlab; 11409 11410 /* Do not reclaim the symbols of the rule which action triggered 11411 this YYERROR. */ 11412 YYPOPSTACK (yylen); 11413 yylen = 0; 11414 YY_STACK_PRINT (yyss, yyssp); 11415 yystate = *yyssp; 11416 goto yyerrlab1; 11417 11418 11419 /*-------------------------------------------------------------. 11420 | yyerrlab1 -- common code for both syntax error and YYERROR. | 11421 `-------------------------------------------------------------*/ 11422 yyerrlab1: 11423 yyerrstatus = 3; /* Each real token shifted decrements this. */ 11424 11425 for (;;) 11426 { 11427 yyn = yypact[yystate]; 11428 if (!yypact_value_is_default (yyn)) 11429 { 11430 yyn += YYTERROR; 11431 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 11432 { 11433 yyn = yytable[yyn]; 11434 if (0 < yyn) 11435 break; 11436 } 11437 } 11438 11439 /* Pop the current state because it cannot handle the error token. */ 11440 if (yyssp == yyss) 11441 YYABORT; 11442 11443 11444 yydestruct ("Error: popping", 11445 yystos[yystate], yyvsp, parser); 11446 YYPOPSTACK (1); 11447 yystate = *yyssp; 11448 YY_STACK_PRINT (yyss, yyssp); 11449 } 11450 11451 *++yyvsp = yylval; 11452 11453 11454 /* Shift the error token. */ 11455 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 11456 11457 yystate = yyn; 11458 goto yynewstate; 11459 11460 11461 /*-------------------------------------. 11462 | yyacceptlab -- YYACCEPT comes here. | 11463 `-------------------------------------*/ 11464 yyacceptlab: 11465 yyresult = 0; 11466 goto yyreturn; 11467 11468 /*-----------------------------------. 11469 | yyabortlab -- YYABORT comes here. | 11470 `-----------------------------------*/ 11471 yyabortlab: 11472 yyresult = 1; 11473 goto yyreturn; 11474 11475 #if !defined(yyoverflow) || YYERROR_VERBOSE 11476 /*-------------------------------------------------. 11477 | yyexhaustedlab -- memory exhaustion comes here. | 11478 `-------------------------------------------------*/ 11479 yyexhaustedlab: 11480 parser_yyerror (parser, YY_("memory exhausted")); 11481 yyresult = 2; 11482 /* Fall through. */ 11483 #endif 11484 11485 yyreturn: 11486 if (yychar != YYEMPTY) 11487 { 11488 /* Make sure we have latest lookahead translation. See comments at 11489 user semantic actions for why this is necessary. */ 11490 yytoken = YYTRANSLATE (yychar); 11491 yydestruct ("Cleanup: discarding lookahead", 11492 yytoken, &yylval, parser); 11493 } 11494 /* Do not reclaim the symbols of the rule which action triggered 11495 this YYABORT or YYACCEPT. */ 11496 YYPOPSTACK (yylen); 11497 YY_STACK_PRINT (yyss, yyssp); 11498 while (yyssp != yyss) 11499 { 11500 yydestruct ("Cleanup: popping", 11501 yystos[*yyssp], yyvsp, parser); 11502 YYPOPSTACK (1); 11503 } 11504 #ifndef yyoverflow 11505 if (yyss != yyssa) 11506 YYSTACK_FREE (yyss); 11507 #endif 11508 #if YYERROR_VERBOSE 11509 if (yymsg != yymsgbuf) 11510 YYSTACK_FREE (yymsg); 11511 #endif 11512 /* Make sure YYID is used. */ 11513 return YYID (yyresult); 11514 } 11515 11516 11517 11518 /* Line 2067 of yacc.c */ 11519 #line 5003 "ripper.y" 11520 11521 # undef parser 11522 # undef yylex 11523 # undef yylval 11524 # define yylval (*((YYSTYPE*)(parser->parser_yylval))) 11525 11526 static int parser_regx_options(struct parser_params*); 11527 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**); 11528 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc); 11529 static int parser_parse_string(struct parser_params*,NODE*); 11530 static int parser_here_document(struct parser_params*,NODE*); 11531 11532 11533 # define nextc() parser_nextc(parser) 11534 # define pushback(c) parser_pushback(parser, (c)) 11535 # define newtok() parser_newtok(parser) 11536 # define tokspace(n) parser_tokspace(parser, (n)) 11537 # define tokadd(c) parser_tokadd(parser, (c)) 11538 # define tok_hex(numlen) parser_tok_hex(parser, (numlen)) 11539 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e)) 11540 # define tokadd_escape(e) parser_tokadd_escape(parser, (e)) 11541 # define regx_options() parser_regx_options(parser) 11542 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e)) 11543 # define parse_string(n) parser_parse_string(parser,(n)) 11544 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc)) 11545 # define here_document(n) parser_here_document(parser,(n)) 11546 # define heredoc_identifier() parser_heredoc_identifier(parser) 11547 # define heredoc_restore(n) parser_heredoc_restore(parser,(n)) 11548 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i)) 11549 11550 #ifndef RIPPER 11551 # define set_yylval_str(x) (yylval.node = NEW_STR(x)) 11552 # define set_yylval_num(x) (yylval.num = (x)) 11553 # define set_yylval_id(x) (yylval.id = (x)) 11554 # define set_yylval_name(x) (yylval.id = (x)) 11555 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x)) 11556 # define set_yylval_node(x) (yylval.node = (x)) 11557 # define yylval_id() (yylval.id) 11558 #else 11559 static inline VALUE 11560 ripper_yylval_id(ID x) 11561 { 11562 return (VALUE)NEW_LASGN(x, ID2SYM(x)); 11563 } 11564 # define set_yylval_str(x) (void)(x) 11565 # define set_yylval_num(x) (void)(x) 11566 # define set_yylval_id(x) (void)(x) 11567 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x)) 11568 # define set_yylval_literal(x) (void)(x) 11569 # define set_yylval_node(x) (void)(x) 11570 # define yylval_id() yylval.id 11571 #endif 11572 11573 #ifndef RIPPER 11574 #define ripper_flush(p) (void)(p) 11575 #else 11576 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p) 11577 11578 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val)) 11579 11580 static int 11581 ripper_has_scan_event(struct parser_params *parser) 11582 { 11583 11584 if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp"); 11585 return lex_p > parser->tokp; 11586 } 11587 11588 static VALUE 11589 ripper_scan_event_val(struct parser_params *parser, int t) 11590 { 11591 VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp); 11592 VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str); 11593 ripper_flush(parser); 11594 return rval; 11595 } 11596 11597 static void 11598 ripper_dispatch_scan_event(struct parser_params *parser, int t) 11599 { 11600 if (!ripper_has_scan_event(parser)) return; 11601 yylval_rval = ripper_scan_event_val(parser, t); 11602 } 11603 11604 static void 11605 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t) 11606 { 11607 if (!ripper_has_scan_event(parser)) return; 11608 (void)ripper_scan_event_val(parser, t); 11609 } 11610 11611 static void 11612 ripper_dispatch_delayed_token(struct parser_params *parser, int t) 11613 { 11614 int saved_line = ruby_sourceline; 11615 const char *saved_tokp = parser->tokp; 11616 11617 ruby_sourceline = parser->delayed_line; 11618 parser->tokp = lex_pbeg + parser->delayed_col; 11619 yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed); 11620 parser->delayed = Qnil; 11621 ruby_sourceline = saved_line; 11622 parser->tokp = saved_tokp; 11623 } 11624 #endif /* RIPPER */ 11625 11626 #include "ruby/regex.h" 11627 #include "ruby/util.h" 11628 11629 /* We remove any previous definition of `SIGN_EXTEND_CHAR', 11630 since ours (we hope) works properly with all combinations of 11631 machines, compilers, `char' and `unsigned char' argument types. 11632 (Per Bothner suggested the basic approach.) */ 11633 #undef SIGN_EXTEND_CHAR 11634 #if __STDC__ 11635 # define SIGN_EXTEND_CHAR(c) ((signed char)(c)) 11636 #else /* not __STDC__ */ 11637 /* As in Harbison and Steele. */ 11638 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128) 11639 #endif 11640 11641 #define parser_encoding_name() (current_enc->name) 11642 #define parser_mbclen() mbclen((lex_p-1),lex_pend,current_enc) 11643 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc) 11644 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p))) 11645 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc)) 11646 11647 #define parser_isascii() ISASCII(*(lex_p-1)) 11648 11649 #ifndef RIPPER 11650 static int 11651 token_info_get_column(struct parser_params *parser, const char *token) 11652 { 11653 int column = 1; 11654 const char *p, *pend = lex_p - strlen(token); 11655 for (p = lex_pbeg; p < pend; p++) { 11656 if (*p == '\t') { 11657 column = (((column - 1) / 8) + 1) * 8; 11658 } 11659 column++; 11660 } 11661 return column; 11662 } 11663 11664 static int 11665 token_info_has_nonspaces(struct parser_params *parser, const char *token) 11666 { 11667 const char *p, *pend = lex_p - strlen(token); 11668 for (p = lex_pbeg; p < pend; p++) { 11669 if (*p != ' ' && *p != '\t') { 11670 return 1; 11671 } 11672 } 11673 return 0; 11674 } 11675 11676 #undef token_info_push 11677 static void 11678 token_info_push(struct parser_params *parser, const char *token) 11679 { 11680 token_info *ptinfo; 11681 11682 if (!parser->parser_token_info_enabled) return; 11683 ptinfo = ALLOC(token_info); 11684 ptinfo->token = token; 11685 ptinfo->linenum = ruby_sourceline; 11686 ptinfo->column = token_info_get_column(parser, token); 11687 ptinfo->nonspc = token_info_has_nonspaces(parser, token); 11688 ptinfo->next = parser->parser_token_info; 11689 11690 parser->parser_token_info = ptinfo; 11691 } 11692 11693 #undef token_info_pop 11694 static void 11695 token_info_pop(struct parser_params *parser, const char *token) 11696 { 11697 int linenum; 11698 token_info *ptinfo = parser->parser_token_info; 11699 11700 if (!ptinfo) return; 11701 parser->parser_token_info = ptinfo->next; 11702 if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */ 11703 goto finish; 11704 } 11705 linenum = ruby_sourceline; 11706 if (linenum == ptinfo->linenum) { /* SKIP */ 11707 goto finish; 11708 } 11709 if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */ 11710 goto finish; 11711 } 11712 if (parser->parser_token_info_enabled) { 11713 rb_compile_warn(ruby_sourcefile, linenum, 11714 "mismatched indentations at '%s' with '%s' at %d", 11715 token, ptinfo->token, ptinfo->linenum); 11716 } 11717 11718 finish: 11719 xfree(ptinfo); 11720 } 11721 #endif /* RIPPER */ 11722 11723 static int 11724 parser_yyerror(struct parser_params *parser, const char *msg) 11725 { 11726 #ifndef RIPPER 11727 const int max_line_margin = 30; 11728 const char *p, *pe; 11729 char *buf; 11730 long len; 11731 int i; 11732 11733 compile_error(PARSER_ARG "%s", msg); 11734 p = lex_p; 11735 while (lex_pbeg <= p) { 11736 if (*p == '\n') break; 11737 p--; 11738 } 11739 p++; 11740 11741 pe = lex_p; 11742 while (pe < lex_pend) { 11743 if (*pe == '\n') break; 11744 pe++; 11745 } 11746 11747 len = pe - p; 11748 if (len > 4) { 11749 char *p2; 11750 const char *pre = "", *post = ""; 11751 11752 if (len > max_line_margin * 2 + 10) { 11753 if (lex_p - p > max_line_margin) { 11754 p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline)); 11755 pre = "..."; 11756 } 11757 if (pe - lex_p > max_line_margin) { 11758 pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline)); 11759 post = "..."; 11760 } 11761 len = pe - p; 11762 } 11763 buf = ALLOCA_N(char, len+2); 11764 MEMCPY(buf, p, char, len); 11765 buf[len] = '\0'; 11766 rb_compile_error_with_enc(NULL, 0, (void *)current_enc, "%s%s%s", pre, buf, post); 11767 11768 i = (int)(lex_p - p); 11769 p2 = buf; pe = buf + len; 11770 11771 while (p2 < pe) { 11772 if (*p2 != '\t') *p2 = ' '; 11773 p2++; 11774 } 11775 buf[i] = '^'; 11776 buf[i+1] = '\0'; 11777 rb_compile_error_append("%s%s", pre, buf); 11778 } 11779 #else 11780 dispatch1(parse_error, STR_NEW2(msg)); 11781 #endif /* !RIPPER */ 11782 return 0; 11783 } 11784 11785 static void parser_prepare(struct parser_params *parser); 11786 11787 #ifndef RIPPER 11788 static VALUE 11789 debug_lines(VALUE fname) 11790 { 11791 ID script_lines; 11792 CONST_ID(script_lines, "SCRIPT_LINES__"); 11793 if (rb_const_defined_at(rb_cObject, script_lines)) { 11794 VALUE hash = rb_const_get_at(rb_cObject, script_lines); 11795 if (RB_TYPE_P(hash, T_HASH)) { 11796 VALUE lines = rb_ary_new(); 11797 rb_hash_aset(hash, fname, lines); 11798 return lines; 11799 } 11800 } 11801 return 0; 11802 } 11803 11804 static VALUE 11805 coverage(VALUE fname, int n) 11806 { 11807 VALUE coverages = rb_get_coverages(); 11808 if (RTEST(coverages) && RBASIC(coverages)->klass == 0) { 11809 VALUE lines = rb_ary_new2(n); 11810 int i; 11811 RBASIC(lines)->klass = 0; 11812 for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil; 11813 RARRAY(lines)->as.heap.len = n; 11814 rb_hash_aset(coverages, fname, lines); 11815 return lines; 11816 } 11817 return 0; 11818 } 11819 11820 static int 11821 e_option_supplied(struct parser_params *parser) 11822 { 11823 return strcmp(ruby_sourcefile, "-e") == 0; 11824 } 11825 11826 static VALUE 11827 yycompile0(VALUE arg) 11828 { 11829 int n; 11830 NODE *tree; 11831 struct parser_params *parser = (struct parser_params *)arg; 11832 11833 if (!compile_for_eval && rb_safe_level() == 0) { 11834 ruby_debug_lines = debug_lines(ruby_sourcefile_string); 11835 if (ruby_debug_lines && ruby_sourceline > 0) { 11836 VALUE str = STR_NEW0(); 11837 n = ruby_sourceline; 11838 do { 11839 rb_ary_push(ruby_debug_lines, str); 11840 } while (--n); 11841 } 11842 11843 if (!e_option_supplied(parser)) { 11844 ruby_coverage = coverage(ruby_sourcefile_string, ruby_sourceline); 11845 } 11846 } 11847 11848 parser_prepare(parser); 11849 deferred_nodes = 0; 11850 #ifndef RIPPER 11851 parser->parser_token_info_enabled = !compile_for_eval && RTEST(ruby_verbose); 11852 #endif 11853 #ifndef RIPPER 11854 if (RUBY_DTRACE_PARSE_BEGIN_ENABLED()) { 11855 RUBY_DTRACE_PARSE_BEGIN(parser->parser_ruby_sourcefile, 11856 parser->parser_ruby_sourceline); 11857 } 11858 #endif 11859 n = yyparse((void*)parser); 11860 #ifndef RIPPER 11861 if (RUBY_DTRACE_PARSE_END_ENABLED()) { 11862 RUBY_DTRACE_PARSE_END(parser->parser_ruby_sourcefile, 11863 parser->parser_ruby_sourceline); 11864 } 11865 #endif 11866 ruby_debug_lines = 0; 11867 ruby_coverage = 0; 11868 compile_for_eval = 0; 11869 11870 lex_strterm = 0; 11871 lex_p = lex_pbeg = lex_pend = 0; 11872 lex_lastline = lex_nextline = 0; 11873 if (parser->nerr) { 11874 return 0; 11875 } 11876 tree = ruby_eval_tree; 11877 if (!tree) { 11878 tree = NEW_NIL(); 11879 } 11880 else if (ruby_eval_tree_begin) { 11881 tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body); 11882 } 11883 return (VALUE)tree; 11884 } 11885 11886 static NODE* 11887 yycompile(struct parser_params *parser, VALUE fname, int line) 11888 { 11889 ruby_sourcefile_string = rb_str_new_frozen(fname); 11890 ruby_sourcefile = RSTRING_PTR(fname); 11891 ruby_sourceline = line - 1; 11892 return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser); 11893 } 11894 #endif /* !RIPPER */ 11895 11896 static rb_encoding * 11897 must_be_ascii_compatible(VALUE s) 11898 { 11899 rb_encoding *enc = rb_enc_get(s); 11900 if (!rb_enc_asciicompat(enc)) { 11901 rb_raise(rb_eArgError, "invalid source encoding"); 11902 } 11903 return enc; 11904 } 11905 11906 static VALUE 11907 lex_get_str(struct parser_params *parser, VALUE s) 11908 { 11909 char *beg, *end, *pend; 11910 rb_encoding *enc = must_be_ascii_compatible(s); 11911 11912 beg = RSTRING_PTR(s); 11913 if (lex_gets_ptr) { 11914 if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil; 11915 beg += lex_gets_ptr; 11916 } 11917 pend = RSTRING_PTR(s) + RSTRING_LEN(s); 11918 end = beg; 11919 while (end < pend) { 11920 if (*end++ == '\n') break; 11921 } 11922 lex_gets_ptr = end - RSTRING_PTR(s); 11923 return rb_enc_str_new(beg, end - beg, enc); 11924 } 11925 11926 static VALUE 11927 lex_getline(struct parser_params *parser) 11928 { 11929 VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input); 11930 if (NIL_P(line)) return line; 11931 must_be_ascii_compatible(line); 11932 #ifndef RIPPER 11933 if (ruby_debug_lines) { 11934 rb_enc_associate(line, current_enc); 11935 rb_ary_push(ruby_debug_lines, line); 11936 } 11937 if (ruby_coverage) { 11938 rb_ary_push(ruby_coverage, Qnil); 11939 } 11940 #endif 11941 return line; 11942 } 11943 11944 #ifdef RIPPER 11945 static rb_data_type_t parser_data_type; 11946 #else 11947 static const rb_data_type_t parser_data_type; 11948 11949 static NODE* 11950 parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line) 11951 { 11952 struct parser_params *parser; 11953 NODE *node; 11954 11955 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser); 11956 lex_gets = lex_get_str; 11957 lex_gets_ptr = 0; 11958 lex_input = s; 11959 lex_pbeg = lex_p = lex_pend = 0; 11960 compile_for_eval = rb_parse_in_eval(); 11961 11962 node = yycompile(parser, fname, line); 11963 RB_GC_GUARD(vparser); /* prohibit tail call optimization */ 11964 11965 return node; 11966 } 11967 11968 NODE* 11969 rb_compile_string(const char *f, VALUE s, int line) 11970 { 11971 must_be_ascii_compatible(s); 11972 return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), s, line); 11973 } 11974 11975 NODE* 11976 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line) 11977 { 11978 return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line); 11979 } 11980 11981 NODE* 11982 rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line) 11983 { 11984 must_be_ascii_compatible(s); 11985 return parser_compile_string(vparser, f, s, line); 11986 } 11987 11988 NODE* 11989 rb_compile_cstr(const char *f, const char *s, int len, int line) 11990 { 11991 VALUE str = rb_str_new(s, len); 11992 return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), str, line); 11993 } 11994 11995 NODE* 11996 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line) 11997 { 11998 VALUE str = rb_str_new(s, len); 11999 return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line); 12000 } 12001 12002 static VALUE 12003 lex_io_gets(struct parser_params *parser, VALUE io) 12004 { 12005 return rb_io_gets(io); 12006 } 12007 12008 NODE* 12009 rb_compile_file(const char *f, VALUE file, int start) 12010 { 12011 VALUE volatile vparser = rb_parser_new(); 12012 12013 return rb_parser_compile_file(vparser, f, file, start); 12014 } 12015 12016 NODE* 12017 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start) 12018 { 12019 return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start); 12020 } 12021 12022 NODE* 12023 rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start) 12024 { 12025 struct parser_params *parser; 12026 NODE *node; 12027 12028 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser); 12029 lex_gets = lex_io_gets; 12030 lex_input = file; 12031 lex_pbeg = lex_p = lex_pend = 0; 12032 compile_for_eval = rb_parse_in_eval(); 12033 12034 node = yycompile(parser, fname, start); 12035 RB_GC_GUARD(vparser); /* prohibit tail call optimization */ 12036 12037 return node; 12038 } 12039 #endif /* !RIPPER */ 12040 12041 #define STR_FUNC_ESCAPE 0x01 12042 #define STR_FUNC_EXPAND 0x02 12043 #define STR_FUNC_REGEXP 0x04 12044 #define STR_FUNC_QWORDS 0x08 12045 #define STR_FUNC_SYMBOL 0x10 12046 #define STR_FUNC_INDENT 0x20 12047 12048 enum string_type { 12049 str_squote = (0), 12050 str_dquote = (STR_FUNC_EXPAND), 12051 str_xquote = (STR_FUNC_EXPAND), 12052 str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND), 12053 str_sword = (STR_FUNC_QWORDS), 12054 str_dword = (STR_FUNC_QWORDS|STR_FUNC_EXPAND), 12055 str_ssym = (STR_FUNC_SYMBOL), 12056 str_dsym = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND) 12057 }; 12058 12059 static VALUE 12060 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0) 12061 { 12062 VALUE str; 12063 12064 str = rb_enc_str_new(p, n, enc); 12065 if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) { 12066 if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) { 12067 } 12068 else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) { 12069 rb_enc_associate(str, rb_ascii8bit_encoding()); 12070 } 12071 } 12072 12073 return str; 12074 } 12075 12076 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend) 12077 #define lex_eol_p() (lex_p >= lex_pend) 12078 #define peek(c) peek_n((c), 0) 12079 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n]) 12080 12081 static inline int 12082 parser_nextc(struct parser_params *parser) 12083 { 12084 int c; 12085 12086 if (lex_p == lex_pend) { 12087 VALUE v = lex_nextline; 12088 lex_nextline = 0; 12089 if (!v) { 12090 if (parser->eofp) 12091 return -1; 12092 12093 if (!lex_input || NIL_P(v = lex_getline(parser))) { 12094 parser->eofp = Qtrue; 12095 lex_goto_eol(parser); 12096 return -1; 12097 } 12098 } 12099 { 12100 #ifdef RIPPER 12101 if (parser->tokp < lex_pend) { 12102 if (NIL_P(parser->delayed)) { 12103 parser->delayed = rb_str_buf_new(1024); 12104 rb_enc_associate(parser->delayed, current_enc); 12105 rb_str_buf_cat(parser->delayed, 12106 parser->tokp, lex_pend - parser->tokp); 12107 parser->delayed_line = ruby_sourceline; 12108 parser->delayed_col = (int)(parser->tokp - lex_pbeg); 12109 } 12110 else { 12111 rb_str_buf_cat(parser->delayed, 12112 parser->tokp, lex_pend - parser->tokp); 12113 } 12114 } 12115 #endif 12116 if (heredoc_end > 0) { 12117 ruby_sourceline = heredoc_end; 12118 heredoc_end = 0; 12119 } 12120 ruby_sourceline++; 12121 parser->line_count++; 12122 lex_pbeg = lex_p = RSTRING_PTR(v); 12123 lex_pend = lex_p + RSTRING_LEN(v); 12124 ripper_flush(parser); 12125 lex_lastline = v; 12126 } 12127 } 12128 c = (unsigned char)*lex_p++; 12129 if (c == '\r' && peek('\n')) { 12130 lex_p++; 12131 c = '\n'; 12132 } 12133 12134 return c; 12135 } 12136 12137 static void 12138 parser_pushback(struct parser_params *parser, int c) 12139 { 12140 if (c == -1) return; 12141 lex_p--; 12142 if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') { 12143 lex_p--; 12144 } 12145 } 12146 12147 #define was_bol() (lex_p == lex_pbeg + 1) 12148 12149 #define tokfix() (tokenbuf[tokidx]='\0') 12150 #define tok() tokenbuf 12151 #define toklen() tokidx 12152 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0) 12153 12154 static char* 12155 parser_newtok(struct parser_params *parser) 12156 { 12157 tokidx = 0; 12158 tokline = ruby_sourceline; 12159 if (!tokenbuf) { 12160 toksiz = 60; 12161 tokenbuf = ALLOC_N(char, 60); 12162 } 12163 if (toksiz > 4096) { 12164 toksiz = 60; 12165 REALLOC_N(tokenbuf, char, 60); 12166 } 12167 return tokenbuf; 12168 } 12169 12170 static char * 12171 parser_tokspace(struct parser_params *parser, int n) 12172 { 12173 tokidx += n; 12174 12175 if (tokidx >= toksiz) { 12176 do {toksiz *= 2;} while (toksiz < tokidx); 12177 REALLOC_N(tokenbuf, char, toksiz); 12178 } 12179 return &tokenbuf[tokidx-n]; 12180 } 12181 12182 static void 12183 parser_tokadd(struct parser_params *parser, int c) 12184 { 12185 tokenbuf[tokidx++] = (char)c; 12186 if (tokidx >= toksiz) { 12187 toksiz *= 2; 12188 REALLOC_N(tokenbuf, char, toksiz); 12189 } 12190 } 12191 12192 static int 12193 parser_tok_hex(struct parser_params *parser, size_t *numlen) 12194 { 12195 int c; 12196 12197 c = scan_hex(lex_p, 2, numlen); 12198 if (!*numlen) { 12199 yyerror("invalid hex escape"); 12200 return 0; 12201 } 12202 lex_p += *numlen; 12203 return c; 12204 } 12205 12206 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n)) 12207 12208 /* return value is for ?\u3042 */ 12209 static int 12210 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp, 12211 int string_literal, int symbol_literal, int regexp_literal) 12212 { 12213 /* 12214 * If string_literal is true, then we allow multiple codepoints 12215 * in \u{}, and add the codepoints to the current token. 12216 * Otherwise we're parsing a character literal and return a single 12217 * codepoint without adding it 12218 */ 12219 12220 int codepoint; 12221 size_t numlen; 12222 12223 if (regexp_literal) { tokadd('\\'); tokadd('u'); } 12224 12225 if (peek('{')) { /* handle \u{...} form */ 12226 do { 12227 if (regexp_literal) { tokadd(*lex_p); } 12228 nextc(); 12229 codepoint = scan_hex(lex_p, 6, &numlen); 12230 if (numlen == 0) { 12231 yyerror("invalid Unicode escape"); 12232 return 0; 12233 } 12234 if (codepoint > 0x10ffff) { 12235 yyerror("invalid Unicode codepoint (too large)"); 12236 return 0; 12237 } 12238 lex_p += numlen; 12239 if (regexp_literal) { 12240 tokcopy((int)numlen); 12241 } 12242 else if (codepoint >= 0x80) { 12243 *encp = rb_utf8_encoding(); 12244 if (string_literal) tokaddmbc(codepoint, *encp); 12245 } 12246 else if (string_literal) { 12247 tokadd(codepoint); 12248 } 12249 } while (string_literal && (peek(' ') || peek('\t'))); 12250 12251 if (!peek('}')) { 12252 yyerror("unterminated Unicode escape"); 12253 return 0; 12254 } 12255 12256 if (regexp_literal) { tokadd('}'); } 12257 nextc(); 12258 } 12259 else { /* handle \uxxxx form */ 12260 codepoint = scan_hex(lex_p, 4, &numlen); 12261 if (numlen < 4) { 12262 yyerror("invalid Unicode escape"); 12263 return 0; 12264 } 12265 lex_p += 4; 12266 if (regexp_literal) { 12267 tokcopy(4); 12268 } 12269 else if (codepoint >= 0x80) { 12270 *encp = rb_utf8_encoding(); 12271 if (string_literal) tokaddmbc(codepoint, *encp); 12272 } 12273 else if (string_literal) { 12274 tokadd(codepoint); 12275 } 12276 } 12277 12278 return codepoint; 12279 } 12280 12281 #define ESCAPE_CONTROL 1 12282 #define ESCAPE_META 2 12283 12284 static int 12285 parser_read_escape(struct parser_params *parser, int flags, 12286 rb_encoding **encp) 12287 { 12288 int c; 12289 size_t numlen; 12290 12291 switch (c = nextc()) { 12292 case '\\': /* Backslash */ 12293 return c; 12294 12295 case 'n': /* newline */ 12296 return '\n'; 12297 12298 case 't': /* horizontal tab */ 12299 return '\t'; 12300 12301 case 'r': /* carriage-return */ 12302 return '\r'; 12303 12304 case 'f': /* form-feed */ 12305 return '\f'; 12306 12307 case 'v': /* vertical tab */ 12308 return '\13'; 12309 12310 case 'a': /* alarm(bell) */ 12311 return '\007'; 12312 12313 case 'e': /* escape */ 12314 return 033; 12315 12316 case '0': case '1': case '2': case '3': /* octal constant */ 12317 case '4': case '5': case '6': case '7': 12318 pushback(c); 12319 c = scan_oct(lex_p, 3, &numlen); 12320 lex_p += numlen; 12321 return c; 12322 12323 case 'x': /* hex constant */ 12324 c = tok_hex(&numlen); 12325 if (numlen == 0) return 0; 12326 return c; 12327 12328 case 'b': /* backspace */ 12329 return '\010'; 12330 12331 case 's': /* space */ 12332 return ' '; 12333 12334 case 'M': 12335 if (flags & ESCAPE_META) goto eof; 12336 if ((c = nextc()) != '-') { 12337 pushback(c); 12338 goto eof; 12339 } 12340 if ((c = nextc()) == '\\') { 12341 if (peek('u')) goto eof; 12342 return read_escape(flags|ESCAPE_META, encp) | 0x80; 12343 } 12344 else if (c == -1 || !ISASCII(c)) goto eof; 12345 else { 12346 return ((c & 0xff) | 0x80); 12347 } 12348 12349 case 'C': 12350 if ((c = nextc()) != '-') { 12351 pushback(c); 12352 goto eof; 12353 } 12354 case 'c': 12355 if (flags & ESCAPE_CONTROL) goto eof; 12356 if ((c = nextc())== '\\') { 12357 if (peek('u')) goto eof; 12358 c = read_escape(flags|ESCAPE_CONTROL, encp); 12359 } 12360 else if (c == '?') 12361 return 0177; 12362 else if (c == -1 || !ISASCII(c)) goto eof; 12363 return c & 0x9f; 12364 12365 eof: 12366 case -1: 12367 yyerror("Invalid escape character syntax"); 12368 return '\0'; 12369 12370 default: 12371 return c; 12372 } 12373 } 12374 12375 static void 12376 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc) 12377 { 12378 int len = rb_enc_codelen(c, enc); 12379 rb_enc_mbcput(c, tokspace(len), enc); 12380 } 12381 12382 static int 12383 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp) 12384 { 12385 int c; 12386 int flags = 0; 12387 size_t numlen; 12388 12389 first: 12390 switch (c = nextc()) { 12391 case '\n': 12392 return 0; /* just ignore */ 12393 12394 case '0': case '1': case '2': case '3': /* octal constant */ 12395 case '4': case '5': case '6': case '7': 12396 { 12397 ruby_scan_oct(--lex_p, 3, &numlen); 12398 if (numlen == 0) goto eof; 12399 lex_p += numlen; 12400 tokcopy((int)numlen + 1); 12401 } 12402 return 0; 12403 12404 case 'x': /* hex constant */ 12405 { 12406 tok_hex(&numlen); 12407 if (numlen == 0) return -1; 12408 tokcopy((int)numlen + 2); 12409 } 12410 return 0; 12411 12412 case 'M': 12413 if (flags & ESCAPE_META) goto eof; 12414 if ((c = nextc()) != '-') { 12415 pushback(c); 12416 goto eof; 12417 } 12418 tokcopy(3); 12419 flags |= ESCAPE_META; 12420 goto escaped; 12421 12422 case 'C': 12423 if (flags & ESCAPE_CONTROL) goto eof; 12424 if ((c = nextc()) != '-') { 12425 pushback(c); 12426 goto eof; 12427 } 12428 tokcopy(3); 12429 goto escaped; 12430 12431 case 'c': 12432 if (flags & ESCAPE_CONTROL) goto eof; 12433 tokcopy(2); 12434 flags |= ESCAPE_CONTROL; 12435 escaped: 12436 if ((c = nextc()) == '\\') { 12437 goto first; 12438 } 12439 else if (c == -1) goto eof; 12440 tokadd(c); 12441 return 0; 12442 12443 eof: 12444 case -1: 12445 yyerror("Invalid escape character syntax"); 12446 return -1; 12447 12448 default: 12449 tokadd('\\'); 12450 tokadd(c); 12451 } 12452 return 0; 12453 } 12454 12455 static int 12456 parser_regx_options(struct parser_params *parser) 12457 { 12458 int kcode = 0; 12459 int kopt = 0; 12460 int options = 0; 12461 int c, opt, kc; 12462 12463 newtok(); 12464 while (c = nextc(), ISALPHA(c)) { 12465 if (c == 'o') { 12466 options |= RE_OPTION_ONCE; 12467 } 12468 else if (rb_char_to_option_kcode(c, &opt, &kc)) { 12469 if (kc >= 0) { 12470 if (kc != rb_ascii8bit_encindex()) kcode = c; 12471 kopt = opt; 12472 } 12473 else { 12474 options |= opt; 12475 } 12476 } 12477 else { 12478 tokadd(c); 12479 } 12480 } 12481 options |= kopt; 12482 pushback(c); 12483 if (toklen()) { 12484 tokfix(); 12485 compile_error(PARSER_ARG "unknown regexp option%s - %s", 12486 toklen() > 1 ? "s" : "", tok()); 12487 } 12488 return options | RE_OPTION_ENCODING(kcode); 12489 } 12490 12491 static void 12492 dispose_string(VALUE str) 12493 { 12494 rb_str_free(str); 12495 rb_gc_force_recycle(str); 12496 } 12497 12498 static int 12499 parser_tokadd_mbchar(struct parser_params *parser, int c) 12500 { 12501 int len = parser_precise_mbclen(); 12502 if (!MBCLEN_CHARFOUND_P(len)) { 12503 compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name()); 12504 return -1; 12505 } 12506 tokadd(c); 12507 lex_p += --len; 12508 if (len > 0) tokcopy(len); 12509 return c; 12510 } 12511 12512 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c)) 12513 12514 static inline int 12515 simple_re_meta(int c) 12516 { 12517 switch (c) { 12518 case '$': case '*': case '+': case '.': 12519 case '?': case '^': case '|': 12520 case ')': case ']': case '}': case '>': 12521 return TRUE; 12522 default: 12523 return FALSE; 12524 } 12525 } 12526 12527 static int 12528 parser_tokadd_string(struct parser_params *parser, 12529 int func, int term, int paren, long *nest, 12530 rb_encoding **encp) 12531 { 12532 int c; 12533 int has_nonascii = 0; 12534 rb_encoding *enc = *encp; 12535 char *errbuf = 0; 12536 static const char mixed_msg[] = "%s mixed within %s source"; 12537 12538 #define mixed_error(enc1, enc2) if (!errbuf) { \ 12539 size_t len = sizeof(mixed_msg) - 4; \ 12540 len += strlen(rb_enc_name(enc1)); \ 12541 len += strlen(rb_enc_name(enc2)); \ 12542 errbuf = ALLOCA_N(char, len); \ 12543 snprintf(errbuf, len, mixed_msg, \ 12544 rb_enc_name(enc1), \ 12545 rb_enc_name(enc2)); \ 12546 yyerror(errbuf); \ 12547 } 12548 #define mixed_escape(beg, enc1, enc2) do { \ 12549 const char *pos = lex_p; \ 12550 lex_p = (beg); \ 12551 mixed_error((enc1), (enc2)); \ 12552 lex_p = pos; \ 12553 } while (0) 12554 12555 while ((c = nextc()) != -1) { 12556 if (paren && c == paren) { 12557 ++*nest; 12558 } 12559 else if (c == term) { 12560 if (!nest || !*nest) { 12561 pushback(c); 12562 break; 12563 } 12564 --*nest; 12565 } 12566 else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) { 12567 int c2 = *lex_p; 12568 if (c2 == '$' || c2 == '@' || c2 == '{') { 12569 pushback(c); 12570 break; 12571 } 12572 } 12573 else if (c == '\\') { 12574 const char *beg = lex_p - 1; 12575 c = nextc(); 12576 switch (c) { 12577 case '\n': 12578 if (func & STR_FUNC_QWORDS) break; 12579 if (func & STR_FUNC_EXPAND) continue; 12580 tokadd('\\'); 12581 break; 12582 12583 case '\\': 12584 if (func & STR_FUNC_ESCAPE) tokadd(c); 12585 break; 12586 12587 case 'u': 12588 if ((func & STR_FUNC_EXPAND) == 0) { 12589 tokadd('\\'); 12590 break; 12591 } 12592 parser_tokadd_utf8(parser, &enc, 1, 12593 func & STR_FUNC_SYMBOL, 12594 func & STR_FUNC_REGEXP); 12595 if (has_nonascii && enc != *encp) { 12596 mixed_escape(beg, enc, *encp); 12597 } 12598 continue; 12599 12600 default: 12601 if (c == -1) return -1; 12602 if (!ISASCII(c)) { 12603 if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\'); 12604 goto non_ascii; 12605 } 12606 if (func & STR_FUNC_REGEXP) { 12607 if (c == term && !simple_re_meta(c)) { 12608 tokadd(c); 12609 continue; 12610 } 12611 pushback(c); 12612 if ((c = tokadd_escape(&enc)) < 0) 12613 return -1; 12614 if (has_nonascii && enc != *encp) { 12615 mixed_escape(beg, enc, *encp); 12616 } 12617 continue; 12618 } 12619 else if (func & STR_FUNC_EXPAND) { 12620 pushback(c); 12621 if (func & STR_FUNC_ESCAPE) tokadd('\\'); 12622 c = read_escape(0, &enc); 12623 } 12624 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) { 12625 /* ignore backslashed spaces in %w */ 12626 } 12627 else if (c != term && !(paren && c == paren)) { 12628 tokadd('\\'); 12629 pushback(c); 12630 continue; 12631 } 12632 } 12633 } 12634 else if (!parser_isascii()) { 12635 non_ascii: 12636 has_nonascii = 1; 12637 if (enc != *encp) { 12638 mixed_error(enc, *encp); 12639 continue; 12640 } 12641 if (tokadd_mbchar(c) == -1) return -1; 12642 continue; 12643 } 12644 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) { 12645 pushback(c); 12646 break; 12647 } 12648 if (c & 0x80) { 12649 has_nonascii = 1; 12650 if (enc != *encp) { 12651 mixed_error(enc, *encp); 12652 continue; 12653 } 12654 } 12655 tokadd(c); 12656 } 12657 *encp = enc; 12658 return c; 12659 } 12660 12661 #define NEW_STRTERM(func, term, paren) \ 12662 rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0) 12663 12664 #ifdef RIPPER 12665 static void 12666 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc) 12667 { 12668 if (!NIL_P(parser->delayed)) { 12669 ptrdiff_t len = lex_p - parser->tokp; 12670 if (len > 0) { 12671 rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc); 12672 } 12673 ripper_dispatch_delayed_token(parser, tSTRING_CONTENT); 12674 parser->tokp = lex_p; 12675 } 12676 } 12677 12678 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc)) 12679 #else 12680 #define flush_string_content(enc) ((void)(enc)) 12681 #endif 12682 12683 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32]; 12684 /* this can be shared with ripper, since it's independent from struct 12685 * parser_params. */ 12686 #ifndef RIPPER 12687 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0) 12688 #define SPECIAL_PUNCT(idx) ( \ 12689 BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \ 12690 BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \ 12691 BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \ 12692 BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \ 12693 BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \ 12694 BIT('0', idx)) 12695 const unsigned int ruby_global_name_punct_bits[] = { 12696 SPECIAL_PUNCT(0), 12697 SPECIAL_PUNCT(1), 12698 SPECIAL_PUNCT(2), 12699 }; 12700 #undef BIT 12701 #undef SPECIAL_PUNCT 12702 #endif 12703 12704 static inline int 12705 is_global_name_punct(const char c) 12706 { 12707 if (c <= 0x20 || 0x7e < c) return 0; 12708 return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1; 12709 } 12710 12711 static int 12712 parser_peek_variable_name(struct parser_params *parser) 12713 { 12714 int c; 12715 const char *p = lex_p; 12716 12717 if (p + 1 >= lex_pend) return 0; 12718 c = *p++; 12719 switch (c) { 12720 case '$': 12721 if ((c = *p) == '-') { 12722 if (++p >= lex_pend) return 0; 12723 c = *p; 12724 } 12725 else if (is_global_name_punct(c) || ISDIGIT(c)) { 12726 return tSTRING_DVAR; 12727 } 12728 break; 12729 case '@': 12730 if ((c = *p) == '@') { 12731 if (++p >= lex_pend) return 0; 12732 c = *p; 12733 } 12734 break; 12735 case '{': 12736 lex_p = p; 12737 command_start = TRUE; 12738 return tSTRING_DBEG; 12739 default: 12740 return 0; 12741 } 12742 if (!ISASCII(c) || c == '_' || ISALPHA(c)) 12743 return tSTRING_DVAR; 12744 return 0; 12745 } 12746 12747 static int 12748 parser_parse_string(struct parser_params *parser, NODE *quote) 12749 { 12750 int func = (int)quote->nd_func; 12751 int term = nd_term(quote); 12752 int paren = nd_paren(quote); 12753 int c, space = 0; 12754 rb_encoding *enc = current_enc; 12755 12756 if (func == -1) return tSTRING_END; 12757 c = nextc(); 12758 if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) { 12759 do {c = nextc();} while (ISSPACE(c)); 12760 space = 1; 12761 } 12762 if (c == term && !quote->nd_nest) { 12763 if (func & STR_FUNC_QWORDS) { 12764 quote->nd_func = -1; 12765 return ' '; 12766 } 12767 if (!(func & STR_FUNC_REGEXP)) return tSTRING_END; 12768 set_yylval_num(regx_options()); 12769 return tREGEXP_END; 12770 } 12771 if (space) { 12772 pushback(c); 12773 return ' '; 12774 } 12775 newtok(); 12776 if ((func & STR_FUNC_EXPAND) && c == '#') { 12777 int t = parser_peek_variable_name(parser); 12778 if (t) return t; 12779 tokadd('#'); 12780 c = nextc(); 12781 } 12782 pushback(c); 12783 if (tokadd_string(func, term, paren, "e->nd_nest, 12784 &enc) == -1) { 12785 ruby_sourceline = nd_line(quote); 12786 if (func & STR_FUNC_REGEXP) { 12787 if (parser->eofp) 12788 compile_error(PARSER_ARG "unterminated regexp meets end of file"); 12789 return tREGEXP_END; 12790 } 12791 else { 12792 if (parser->eofp) 12793 compile_error(PARSER_ARG "unterminated string meets end of file"); 12794 return tSTRING_END; 12795 } 12796 } 12797 12798 tokfix(); 12799 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func)); 12800 flush_string_content(enc); 12801 12802 return tSTRING_CONTENT; 12803 } 12804 12805 static int 12806 parser_heredoc_identifier(struct parser_params *parser) 12807 { 12808 int c = nextc(), term, func = 0; 12809 long len; 12810 12811 if (c == '-') { 12812 c = nextc(); 12813 func = STR_FUNC_INDENT; 12814 } 12815 switch (c) { 12816 case '\'': 12817 func |= str_squote; goto quoted; 12818 case '"': 12819 func |= str_dquote; goto quoted; 12820 case '`': 12821 func |= str_xquote; 12822 quoted: 12823 newtok(); 12824 tokadd(func); 12825 term = c; 12826 while ((c = nextc()) != -1 && c != term) { 12827 if (tokadd_mbchar(c) == -1) return 0; 12828 } 12829 if (c == -1) { 12830 compile_error(PARSER_ARG "unterminated here document identifier"); 12831 return 0; 12832 } 12833 break; 12834 12835 default: 12836 if (!parser_is_identchar()) { 12837 pushback(c); 12838 if (func & STR_FUNC_INDENT) { 12839 pushback('-'); 12840 } 12841 return 0; 12842 } 12843 newtok(); 12844 term = '"'; 12845 tokadd(func |= str_dquote); 12846 do { 12847 if (tokadd_mbchar(c) == -1) return 0; 12848 } while ((c = nextc()) != -1 && parser_is_identchar()); 12849 pushback(c); 12850 break; 12851 } 12852 12853 tokfix(); 12854 #ifdef RIPPER 12855 ripper_dispatch_scan_event(parser, tHEREDOC_BEG); 12856 #endif 12857 len = lex_p - lex_pbeg; 12858 lex_goto_eol(parser); 12859 lex_strterm = rb_node_newnode(NODE_HEREDOC, 12860 STR_NEW(tok(), toklen()), /* nd_lit */ 12861 len, /* nd_nth */ 12862 lex_lastline); /* nd_orig */ 12863 nd_set_line(lex_strterm, ruby_sourceline); 12864 ripper_flush(parser); 12865 return term == '`' ? tXSTRING_BEG : tSTRING_BEG; 12866 } 12867 12868 static void 12869 parser_heredoc_restore(struct parser_params *parser, NODE *here) 12870 { 12871 VALUE line; 12872 12873 line = here->nd_orig; 12874 lex_lastline = line; 12875 lex_pbeg = RSTRING_PTR(line); 12876 lex_pend = lex_pbeg + RSTRING_LEN(line); 12877 lex_p = lex_pbeg + here->nd_nth; 12878 heredoc_end = ruby_sourceline; 12879 ruby_sourceline = nd_line(here); 12880 dispose_string(here->nd_lit); 12881 rb_gc_force_recycle((VALUE)here); 12882 ripper_flush(parser); 12883 } 12884 12885 static int 12886 parser_whole_match_p(struct parser_params *parser, 12887 const char *eos, long len, int indent) 12888 { 12889 const char *p = lex_pbeg; 12890 long n; 12891 12892 if (indent) { 12893 while (*p && ISSPACE(*p)) p++; 12894 } 12895 n = lex_pend - (p + len); 12896 if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE; 12897 return strncmp(eos, p, len) == 0; 12898 } 12899 12900 #ifdef RIPPER 12901 static void 12902 ripper_dispatch_heredoc_end(struct parser_params *parser) 12903 { 12904 if (!NIL_P(parser->delayed)) 12905 ripper_dispatch_delayed_token(parser, tSTRING_CONTENT); 12906 lex_goto_eol(parser); 12907 ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END); 12908 } 12909 12910 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser) 12911 #else 12912 #define dispatch_heredoc_end() ((void)0) 12913 #endif 12914 12915 static int 12916 parser_here_document(struct parser_params *parser, NODE *here) 12917 { 12918 int c, func, indent = 0; 12919 const char *eos, *p, *pend; 12920 long len; 12921 VALUE str = 0; 12922 rb_encoding *enc = current_enc; 12923 12924 eos = RSTRING_PTR(here->nd_lit); 12925 len = RSTRING_LEN(here->nd_lit) - 1; 12926 indent = (func = *eos++) & STR_FUNC_INDENT; 12927 12928 if ((c = nextc()) == -1) { 12929 error: 12930 compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos); 12931 #ifdef RIPPER 12932 if (NIL_P(parser->delayed)) { 12933 ripper_dispatch_scan_event(parser, tSTRING_CONTENT); 12934 } 12935 else { 12936 if (str || 12937 ((len = lex_p - parser->tokp) > 0 && 12938 (str = STR_NEW3(parser->tokp, len, enc, func), 1))) { 12939 rb_str_append(parser->delayed, str); 12940 } 12941 ripper_dispatch_delayed_token(parser, tSTRING_CONTENT); 12942 } 12943 lex_goto_eol(parser); 12944 #endif 12945 restore: 12946 heredoc_restore(lex_strterm); 12947 lex_strterm = 0; 12948 return 0; 12949 } 12950 if (was_bol() && whole_match_p(eos, len, indent)) { 12951 dispatch_heredoc_end(); 12952 heredoc_restore(lex_strterm); 12953 return tSTRING_END; 12954 } 12955 12956 if (!(func & STR_FUNC_EXPAND)) { 12957 do { 12958 p = RSTRING_PTR(lex_lastline); 12959 pend = lex_pend; 12960 if (pend > p) { 12961 switch (pend[-1]) { 12962 case '\n': 12963 if (--pend == p || pend[-1] != '\r') { 12964 pend++; 12965 break; 12966 } 12967 case '\r': 12968 --pend; 12969 } 12970 } 12971 if (str) 12972 rb_str_cat(str, p, pend - p); 12973 else 12974 str = STR_NEW(p, pend - p); 12975 if (pend < lex_pend) rb_str_cat(str, "\n", 1); 12976 lex_goto_eol(parser); 12977 if (nextc() == -1) { 12978 if (str) { 12979 dispose_string(str); 12980 str = 0; 12981 } 12982 goto error; 12983 } 12984 } while (!whole_match_p(eos, len, indent)); 12985 } 12986 else { 12987 /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/ 12988 newtok(); 12989 if (c == '#') { 12990 int t = parser_peek_variable_name(parser); 12991 if (t) return t; 12992 tokadd('#'); 12993 c = nextc(); 12994 } 12995 do { 12996 pushback(c); 12997 if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) { 12998 if (parser->eofp) goto error; 12999 goto restore; 13000 } 13001 if (c != '\n') { 13002 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func)); 13003 flush_string_content(enc); 13004 return tSTRING_CONTENT; 13005 } 13006 tokadd(nextc()); 13007 /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/ 13008 if ((c = nextc()) == -1) goto error; 13009 } while (!whole_match_p(eos, len, indent)); 13010 str = STR_NEW3(tok(), toklen(), enc, func); 13011 } 13012 dispatch_heredoc_end(); 13013 heredoc_restore(lex_strterm); 13014 lex_strterm = NEW_STRTERM(-1, 0, 0); 13015 set_yylval_str(str); 13016 return tSTRING_CONTENT; 13017 } 13018 13019 #include "lex.c" 13020 13021 static void 13022 arg_ambiguous_gen(struct parser_params *parser) 13023 { 13024 #ifndef RIPPER 13025 rb_warning0("ambiguous first argument; put parentheses or even spaces"); 13026 #else 13027 dispatch0(arg_ambiguous); 13028 #endif 13029 } 13030 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1) 13031 13032 static ID 13033 formal_argument_gen(struct parser_params *parser, ID lhs) 13034 { 13035 #ifndef RIPPER 13036 if (!is_local_id(lhs)) 13037 yyerror("formal argument must be local variable"); 13038 #endif 13039 shadowing_lvar(lhs); 13040 return lhs; 13041 } 13042 13043 static int 13044 lvar_defined_gen(struct parser_params *parser, ID id) 13045 { 13046 return (dyna_in_block() && dvar_defined_get(id)) || local_id(id); 13047 } 13048 13049 /* emacsen -*- hack */ 13050 static long 13051 parser_encode_length(struct parser_params *parser, const char *name, long len) 13052 { 13053 long nlen; 13054 13055 if (len > 5 && name[nlen = len - 5] == '-') { 13056 if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0) 13057 return nlen; 13058 } 13059 if (len > 4 && name[nlen = len - 4] == '-') { 13060 if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0) 13061 return nlen; 13062 if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 && 13063 !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0)) 13064 /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */ 13065 return nlen; 13066 } 13067 return len; 13068 } 13069 13070 static void 13071 parser_set_encode(struct parser_params *parser, const char *name) 13072 { 13073 int idx = rb_enc_find_index(name); 13074 rb_encoding *enc; 13075 VALUE excargs[3]; 13076 13077 if (idx < 0) { 13078 excargs[1] = rb_sprintf("unknown encoding name: %s", name); 13079 error: 13080 excargs[0] = rb_eArgError; 13081 excargs[2] = rb_make_backtrace(); 13082 rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline)); 13083 rb_exc_raise(rb_make_exception(3, excargs)); 13084 } 13085 enc = rb_enc_from_index(idx); 13086 if (!rb_enc_asciicompat(enc)) { 13087 excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc)); 13088 goto error; 13089 } 13090 parser->enc = enc; 13091 #ifndef RIPPER 13092 if (ruby_debug_lines) { 13093 long i, n = RARRAY_LEN(ruby_debug_lines); 13094 const VALUE *p = RARRAY_PTR(ruby_debug_lines); 13095 for (i = 0; i < n; ++i) { 13096 rb_enc_associate_index(*p, idx); 13097 } 13098 } 13099 #endif 13100 } 13101 13102 static int 13103 comment_at_top(struct parser_params *parser) 13104 { 13105 const char *p = lex_pbeg, *pend = lex_p - 1; 13106 if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0; 13107 while (p < pend) { 13108 if (!ISSPACE(*p)) return 0; 13109 p++; 13110 } 13111 return 1; 13112 } 13113 13114 #ifndef RIPPER 13115 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len); 13116 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val); 13117 13118 static void 13119 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val) 13120 { 13121 if (!comment_at_top(parser)) { 13122 return; 13123 } 13124 parser_set_encode(parser, val); 13125 } 13126 13127 static void 13128 parser_set_token_info(struct parser_params *parser, const char *name, const char *val) 13129 { 13130 int *p = &parser->parser_token_info_enabled; 13131 13132 switch (*val) { 13133 case 't': case 'T': 13134 if (strcasecmp(val, "true") == 0) { 13135 *p = TRUE; 13136 return; 13137 } 13138 break; 13139 case 'f': case 'F': 13140 if (strcasecmp(val, "false") == 0) { 13141 *p = FALSE; 13142 return; 13143 } 13144 break; 13145 } 13146 rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val); 13147 } 13148 13149 struct magic_comment { 13150 const char *name; 13151 rb_magic_comment_setter_t func; 13152 rb_magic_comment_length_t length; 13153 }; 13154 13155 static const struct magic_comment magic_comments[] = { 13156 {"coding", magic_comment_encoding, parser_encode_length}, 13157 {"encoding", magic_comment_encoding, parser_encode_length}, 13158 {"warn_indent", parser_set_token_info}, 13159 }; 13160 #endif 13161 13162 static const char * 13163 magic_comment_marker(const char *str, long len) 13164 { 13165 long i = 2; 13166 13167 while (i < len) { 13168 switch (str[i]) { 13169 case '-': 13170 if (str[i-1] == '*' && str[i-2] == '-') { 13171 return str + i + 1; 13172 } 13173 i += 2; 13174 break; 13175 case '*': 13176 if (i + 1 >= len) return 0; 13177 if (str[i+1] != '-') { 13178 i += 4; 13179 } 13180 else if (str[i-1] != '-') { 13181 i += 2; 13182 } 13183 else { 13184 return str + i + 2; 13185 } 13186 break; 13187 default: 13188 i += 3; 13189 break; 13190 } 13191 } 13192 return 0; 13193 } 13194 13195 static int 13196 parser_magic_comment(struct parser_params *parser, const char *str, long len) 13197 { 13198 VALUE name = 0, val = 0; 13199 const char *beg, *end, *vbeg, *vend; 13200 #define str_copy(_s, _p, _n) ((_s) \ 13201 ? (void)(rb_str_resize((_s), (_n)), \ 13202 MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \ 13203 : (void)((_s) = STR_NEW((_p), (_n)))) 13204 13205 if (len <= 7) return FALSE; 13206 if (!(beg = magic_comment_marker(str, len))) return FALSE; 13207 if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE; 13208 str = beg; 13209 len = end - beg - 3; 13210 13211 /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */ 13212 while (len > 0) { 13213 #ifndef RIPPER 13214 const struct magic_comment *p = magic_comments; 13215 #endif 13216 char *s; 13217 int i; 13218 long n = 0; 13219 13220 for (; len > 0 && *str; str++, --len) { 13221 switch (*str) { 13222 case '\'': case '"': case ':': case ';': 13223 continue; 13224 } 13225 if (!ISSPACE(*str)) break; 13226 } 13227 for (beg = str; len > 0; str++, --len) { 13228 switch (*str) { 13229 case '\'': case '"': case ':': case ';': 13230 break; 13231 default: 13232 if (ISSPACE(*str)) break; 13233 continue; 13234 } 13235 break; 13236 } 13237 for (end = str; len > 0 && ISSPACE(*str); str++, --len); 13238 if (!len) break; 13239 if (*str != ':') continue; 13240 13241 do str++; while (--len > 0 && ISSPACE(*str)); 13242 if (!len) break; 13243 if (*str == '"') { 13244 for (vbeg = ++str; --len > 0 && *str != '"'; str++) { 13245 if (*str == '\\') { 13246 --len; 13247 ++str; 13248 } 13249 } 13250 vend = str; 13251 if (len) { 13252 --len; 13253 ++str; 13254 } 13255 } 13256 else { 13257 for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++); 13258 vend = str; 13259 } 13260 while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++; 13261 13262 n = end - beg; 13263 str_copy(name, beg, n); 13264 s = RSTRING_PTR(name); 13265 for (i = 0; i < n; ++i) { 13266 if (s[i] == '-') s[i] = '_'; 13267 } 13268 #ifndef RIPPER 13269 do { 13270 if (STRNCASECMP(p->name, s, n) == 0) { 13271 n = vend - vbeg; 13272 if (p->length) { 13273 n = (*p->length)(parser, vbeg, n); 13274 } 13275 str_copy(val, vbeg, n); 13276 (*p->func)(parser, s, RSTRING_PTR(val)); 13277 break; 13278 } 13279 } while (++p < magic_comments + numberof(magic_comments)); 13280 #else 13281 str_copy(val, vbeg, vend - vbeg); 13282 dispatch2(magic_comment, name, val); 13283 #endif 13284 } 13285 13286 return TRUE; 13287 } 13288 13289 static void 13290 set_file_encoding(struct parser_params *parser, const char *str, const char *send) 13291 { 13292 int sep = 0; 13293 const char *beg = str; 13294 VALUE s; 13295 13296 for (;;) { 13297 if (send - str <= 6) return; 13298 switch (str[6]) { 13299 case 'C': case 'c': str += 6; continue; 13300 case 'O': case 'o': str += 5; continue; 13301 case 'D': case 'd': str += 4; continue; 13302 case 'I': case 'i': str += 3; continue; 13303 case 'N': case 'n': str += 2; continue; 13304 case 'G': case 'g': str += 1; continue; 13305 case '=': case ':': 13306 sep = 1; 13307 str += 6; 13308 break; 13309 default: 13310 str += 6; 13311 if (ISSPACE(*str)) break; 13312 continue; 13313 } 13314 if (STRNCASECMP(str-6, "coding", 6) == 0) break; 13315 } 13316 for (;;) { 13317 do { 13318 if (++str >= send) return; 13319 } while (ISSPACE(*str)); 13320 if (sep) break; 13321 if (*str != '=' && *str != ':') return; 13322 sep = 1; 13323 str++; 13324 } 13325 beg = str; 13326 while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send); 13327 s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg)); 13328 parser_set_encode(parser, RSTRING_PTR(s)); 13329 rb_str_resize(s, 0); 13330 } 13331 13332 static void 13333 parser_prepare(struct parser_params *parser) 13334 { 13335 int c = nextc(); 13336 switch (c) { 13337 case '#': 13338 if (peek('!')) parser->has_shebang = 1; 13339 break; 13340 case 0xef: /* UTF-8 BOM marker */ 13341 if (lex_pend - lex_p >= 2 && 13342 (unsigned char)lex_p[0] == 0xbb && 13343 (unsigned char)lex_p[1] == 0xbf) { 13344 parser->enc = rb_utf8_encoding(); 13345 lex_p += 2; 13346 lex_pbeg = lex_p; 13347 return; 13348 } 13349 break; 13350 case EOF: 13351 return; 13352 } 13353 pushback(c); 13354 parser->enc = rb_enc_get(lex_lastline); 13355 } 13356 13357 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY) 13358 #define IS_END() IS_lex_state(EXPR_END_ANY) 13359 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY) 13360 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c)) 13361 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG()) 13362 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1)) 13363 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT) 13364 13365 #ifndef RIPPER 13366 #define ambiguous_operator(op, syn) ( \ 13367 rb_warning0("`"op"' after local variable is interpreted as binary operator"), \ 13368 rb_warning0("even though it seems like "syn"")) 13369 #else 13370 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn)) 13371 #endif 13372 #define warn_balanced(op, syn) ((void) \ 13373 (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \ 13374 space_seen && !ISSPACE(c) && \ 13375 (ambiguous_operator(op, syn), 0))) 13376 13377 static int 13378 parser_yylex(struct parser_params *parser) 13379 { 13380 register int c; 13381 int space_seen = 0; 13382 int cmd_state; 13383 enum lex_state_e last_state; 13384 rb_encoding *enc; 13385 int mb; 13386 #ifdef RIPPER 13387 int fallthru = FALSE; 13388 #endif 13389 13390 if (lex_strterm) { 13391 int token; 13392 if (nd_type(lex_strterm) == NODE_HEREDOC) { 13393 token = here_document(lex_strterm); 13394 if (token == tSTRING_END) { 13395 lex_strterm = 0; 13396 lex_state = EXPR_END; 13397 } 13398 } 13399 else { 13400 token = parse_string(lex_strterm); 13401 if (token == tSTRING_END || token == tREGEXP_END) { 13402 rb_gc_force_recycle((VALUE)lex_strterm); 13403 lex_strterm = 0; 13404 lex_state = EXPR_END; 13405 } 13406 } 13407 return token; 13408 } 13409 cmd_state = command_start; 13410 command_start = FALSE; 13411 retry: 13412 last_state = lex_state; 13413 switch (c = nextc()) { 13414 case '\0': /* NUL */ 13415 case '\004': /* ^D */ 13416 case '\032': /* ^Z */ 13417 case -1: /* end of script. */ 13418 return 0; 13419 13420 /* white spaces */ 13421 case ' ': case '\t': case '\f': case '\r': 13422 case '\13': /* '\v' */ 13423 space_seen = 1; 13424 #ifdef RIPPER 13425 while ((c = nextc())) { 13426 switch (c) { 13427 case ' ': case '\t': case '\f': case '\r': 13428 case '\13': /* '\v' */ 13429 break; 13430 default: 13431 goto outofloop; 13432 } 13433 } 13434 outofloop: 13435 pushback(c); 13436 ripper_dispatch_scan_event(parser, tSP); 13437 #endif 13438 goto retry; 13439 13440 case '#': /* it's a comment */ 13441 /* no magic_comment in shebang line */ 13442 if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) { 13443 if (comment_at_top(parser)) { 13444 set_file_encoding(parser, lex_p, lex_pend); 13445 } 13446 } 13447 lex_p = lex_pend; 13448 #ifdef RIPPER 13449 ripper_dispatch_scan_event(parser, tCOMMENT); 13450 fallthru = TRUE; 13451 #endif 13452 /* fall through */ 13453 case '\n': 13454 if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT)) { 13455 #ifdef RIPPER 13456 if (!fallthru) { 13457 ripper_dispatch_scan_event(parser, tIGNORED_NL); 13458 } 13459 fallthru = FALSE; 13460 #endif 13461 goto retry; 13462 } 13463 while ((c = nextc())) { 13464 switch (c) { 13465 case ' ': case '\t': case '\f': case '\r': 13466 case '\13': /* '\v' */ 13467 space_seen = 1; 13468 break; 13469 case '.': { 13470 if ((c = nextc()) != '.') { 13471 pushback(c); 13472 pushback('.'); 13473 goto retry; 13474 } 13475 } 13476 default: 13477 --ruby_sourceline; 13478 lex_nextline = lex_lastline; 13479 case -1: /* EOF no decrement*/ 13480 lex_goto_eol(parser); 13481 #ifdef RIPPER 13482 if (c != -1) { 13483 parser->tokp = lex_p; 13484 } 13485 #endif 13486 goto normal_newline; 13487 } 13488 } 13489 normal_newline: 13490 command_start = TRUE; 13491 lex_state = EXPR_BEG; 13492 return '\n'; 13493 13494 case '*': 13495 if ((c = nextc()) == '*') { 13496 if ((c = nextc()) == '=') { 13497 set_yylval_id(tPOW); 13498 lex_state = EXPR_BEG; 13499 return tOP_ASGN; 13500 } 13501 pushback(c); 13502 if (IS_SPCARG(c)) { 13503 rb_warning0("`**' interpreted as argument prefix"); 13504 c = tDSTAR; 13505 } 13506 else if (IS_BEG()) { 13507 c = tDSTAR; 13508 } 13509 else { 13510 warn_balanced("**", "argument prefix"); 13511 c = tPOW; 13512 } 13513 } 13514 else { 13515 if (c == '=') { 13516 set_yylval_id('*'); 13517 lex_state = EXPR_BEG; 13518 return tOP_ASGN; 13519 } 13520 pushback(c); 13521 if (IS_SPCARG(c)) { 13522 rb_warning0("`*' interpreted as argument prefix"); 13523 c = tSTAR; 13524 } 13525 else if (IS_BEG()) { 13526 c = tSTAR; 13527 } 13528 else { 13529 warn_balanced("*", "argument prefix"); 13530 c = '*'; 13531 } 13532 } 13533 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; 13534 return c; 13535 13536 case '!': 13537 c = nextc(); 13538 if (IS_AFTER_OPERATOR()) { 13539 lex_state = EXPR_ARG; 13540 if (c == '@') { 13541 return '!'; 13542 } 13543 } 13544 else { 13545 lex_state = EXPR_BEG; 13546 } 13547 if (c == '=') { 13548 return tNEQ; 13549 } 13550 if (c == '~') { 13551 return tNMATCH; 13552 } 13553 pushback(c); 13554 return '!'; 13555 13556 case '=': 13557 if (was_bol()) { 13558 /* skip embedded rd document */ 13559 if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) { 13560 #ifdef RIPPER 13561 int first_p = TRUE; 13562 13563 lex_goto_eol(parser); 13564 ripper_dispatch_scan_event(parser, tEMBDOC_BEG); 13565 #endif 13566 for (;;) { 13567 lex_goto_eol(parser); 13568 #ifdef RIPPER 13569 if (!first_p) { 13570 ripper_dispatch_scan_event(parser, tEMBDOC); 13571 } 13572 first_p = FALSE; 13573 #endif 13574 c = nextc(); 13575 if (c == -1) { 13576 compile_error(PARSER_ARG "embedded document meets end of file"); 13577 return 0; 13578 } 13579 if (c != '=') continue; 13580 if (strncmp(lex_p, "end", 3) == 0 && 13581 (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) { 13582 break; 13583 } 13584 } 13585 lex_goto_eol(parser); 13586 #ifdef RIPPER 13587 ripper_dispatch_scan_event(parser, tEMBDOC_END); 13588 #endif 13589 goto retry; 13590 } 13591 } 13592 13593 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; 13594 if ((c = nextc()) == '=') { 13595 if ((c = nextc()) == '=') { 13596 return tEQQ; 13597 } 13598 pushback(c); 13599 return tEQ; 13600 } 13601 if (c == '~') { 13602 return tMATCH; 13603 } 13604 else if (c == '>') { 13605 return tASSOC; 13606 } 13607 pushback(c); 13608 return '='; 13609 13610 case '<': 13611 last_state = lex_state; 13612 c = nextc(); 13613 if (c == '<' && 13614 !IS_lex_state(EXPR_DOT | EXPR_CLASS) && 13615 !IS_END() && 13616 (!IS_ARG() || space_seen)) { 13617 int token = heredoc_identifier(); 13618 if (token) return token; 13619 } 13620 if (IS_AFTER_OPERATOR()) { 13621 lex_state = EXPR_ARG; 13622 } 13623 else { 13624 if (IS_lex_state(EXPR_CLASS)) 13625 command_start = TRUE; 13626 lex_state = EXPR_BEG; 13627 } 13628 if (c == '=') { 13629 if ((c = nextc()) == '>') { 13630 return tCMP; 13631 } 13632 pushback(c); 13633 return tLEQ; 13634 } 13635 if (c == '<') { 13636 if ((c = nextc()) == '=') { 13637 set_yylval_id(tLSHFT); 13638 lex_state = EXPR_BEG; 13639 return tOP_ASGN; 13640 } 13641 pushback(c); 13642 warn_balanced("<<", "here document"); 13643 return tLSHFT; 13644 } 13645 pushback(c); 13646 return '<'; 13647 13648 case '>': 13649 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; 13650 if ((c = nextc()) == '=') { 13651 return tGEQ; 13652 } 13653 if (c == '>') { 13654 if ((c = nextc()) == '=') { 13655 set_yylval_id(tRSHFT); 13656 lex_state = EXPR_BEG; 13657 return tOP_ASGN; 13658 } 13659 pushback(c); 13660 return tRSHFT; 13661 } 13662 pushback(c); 13663 return '>'; 13664 13665 case '"': 13666 lex_strterm = NEW_STRTERM(str_dquote, '"', 0); 13667 return tSTRING_BEG; 13668 13669 case '`': 13670 if (IS_lex_state(EXPR_FNAME)) { 13671 lex_state = EXPR_ENDFN; 13672 return c; 13673 } 13674 if (IS_lex_state(EXPR_DOT)) { 13675 if (cmd_state) 13676 lex_state = EXPR_CMDARG; 13677 else 13678 lex_state = EXPR_ARG; 13679 return c; 13680 } 13681 lex_strterm = NEW_STRTERM(str_xquote, '`', 0); 13682 return tXSTRING_BEG; 13683 13684 case '\'': 13685 lex_strterm = NEW_STRTERM(str_squote, '\'', 0); 13686 return tSTRING_BEG; 13687 13688 case '?': 13689 if (IS_END()) { 13690 lex_state = EXPR_VALUE; 13691 return '?'; 13692 } 13693 c = nextc(); 13694 if (c == -1) { 13695 compile_error(PARSER_ARG "incomplete character syntax"); 13696 return 0; 13697 } 13698 if (rb_enc_isspace(c, current_enc)) { 13699 if (!IS_ARG()) { 13700 int c2 = 0; 13701 switch (c) { 13702 case ' ': 13703 c2 = 's'; 13704 break; 13705 case '\n': 13706 c2 = 'n'; 13707 break; 13708 case '\t': 13709 c2 = 't'; 13710 break; 13711 case '\v': 13712 c2 = 'v'; 13713 break; 13714 case '\r': 13715 c2 = 'r'; 13716 break; 13717 case '\f': 13718 c2 = 'f'; 13719 break; 13720 } 13721 if (c2) { 13722 rb_warnI("invalid character syntax; use ?\\%c", c2); 13723 } 13724 } 13725 ternary: 13726 pushback(c); 13727 lex_state = EXPR_VALUE; 13728 return '?'; 13729 } 13730 newtok(); 13731 enc = current_enc; 13732 if (!parser_isascii()) { 13733 if (tokadd_mbchar(c) == -1) return 0; 13734 } 13735 else if ((rb_enc_isalnum(c, current_enc) || c == '_') && 13736 lex_p < lex_pend && is_identchar(lex_p, lex_pend, current_enc)) { 13737 goto ternary; 13738 } 13739 else if (c == '\\') { 13740 if (peek('u')) { 13741 nextc(); 13742 c = parser_tokadd_utf8(parser, &enc, 0, 0, 0); 13743 if (0x80 <= c) { 13744 tokaddmbc(c, enc); 13745 } 13746 else { 13747 tokadd(c); 13748 } 13749 } 13750 else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) { 13751 nextc(); 13752 if (tokadd_mbchar(c) == -1) return 0; 13753 } 13754 else { 13755 c = read_escape(0, &enc); 13756 tokadd(c); 13757 } 13758 } 13759 else { 13760 tokadd(c); 13761 } 13762 tokfix(); 13763 set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0)); 13764 lex_state = EXPR_END; 13765 return tCHAR; 13766 13767 case '&': 13768 if ((c = nextc()) == '&') { 13769 lex_state = EXPR_BEG; 13770 if ((c = nextc()) == '=') { 13771 set_yylval_id(tANDOP); 13772 lex_state = EXPR_BEG; 13773 return tOP_ASGN; 13774 } 13775 pushback(c); 13776 return tANDOP; 13777 } 13778 else if (c == '=') { 13779 set_yylval_id('&'); 13780 lex_state = EXPR_BEG; 13781 return tOP_ASGN; 13782 } 13783 pushback(c); 13784 if (IS_SPCARG(c)) { 13785 rb_warning0("`&' interpreted as argument prefix"); 13786 c = tAMPER; 13787 } 13788 else if (IS_BEG()) { 13789 c = tAMPER; 13790 } 13791 else { 13792 warn_balanced("&", "argument prefix"); 13793 c = '&'; 13794 } 13795 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; 13796 return c; 13797 13798 case '|': 13799 if ((c = nextc()) == '|') { 13800 lex_state = EXPR_BEG; 13801 if ((c = nextc()) == '=') { 13802 set_yylval_id(tOROP); 13803 lex_state = EXPR_BEG; 13804 return tOP_ASGN; 13805 } 13806 pushback(c); 13807 return tOROP; 13808 } 13809 if (c == '=') { 13810 set_yylval_id('|'); 13811 lex_state = EXPR_BEG; 13812 return tOP_ASGN; 13813 } 13814 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; 13815 pushback(c); 13816 return '|'; 13817 13818 case '+': 13819 c = nextc(); 13820 if (IS_AFTER_OPERATOR()) { 13821 lex_state = EXPR_ARG; 13822 if (c == '@') { 13823 return tUPLUS; 13824 } 13825 pushback(c); 13826 return '+'; 13827 } 13828 if (c == '=') { 13829 set_yylval_id('+'); 13830 lex_state = EXPR_BEG; 13831 return tOP_ASGN; 13832 } 13833 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) { 13834 lex_state = EXPR_BEG; 13835 pushback(c); 13836 if (c != -1 && ISDIGIT(c)) { 13837 c = '+'; 13838 goto start_num; 13839 } 13840 return tUPLUS; 13841 } 13842 lex_state = EXPR_BEG; 13843 pushback(c); 13844 warn_balanced("+", "unary operator"); 13845 return '+'; 13846 13847 case '-': 13848 c = nextc(); 13849 if (IS_AFTER_OPERATOR()) { 13850 lex_state = EXPR_ARG; 13851 if (c == '@') { 13852 return tUMINUS; 13853 } 13854 pushback(c); 13855 return '-'; 13856 } 13857 if (c == '=') { 13858 set_yylval_id('-'); 13859 lex_state = EXPR_BEG; 13860 return tOP_ASGN; 13861 } 13862 if (c == '>') { 13863 lex_state = EXPR_ENDFN; 13864 return tLAMBDA; 13865 } 13866 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) { 13867 lex_state = EXPR_BEG; 13868 pushback(c); 13869 if (c != -1 && ISDIGIT(c)) { 13870 return tUMINUS_NUM; 13871 } 13872 return tUMINUS; 13873 } 13874 lex_state = EXPR_BEG; 13875 pushback(c); 13876 warn_balanced("-", "unary operator"); 13877 return '-'; 13878 13879 case '.': 13880 lex_state = EXPR_BEG; 13881 if ((c = nextc()) == '.') { 13882 if ((c = nextc()) == '.') { 13883 return tDOT3; 13884 } 13885 pushback(c); 13886 return tDOT2; 13887 } 13888 pushback(c); 13889 if (c != -1 && ISDIGIT(c)) { 13890 yyerror("no .<digit> floating literal anymore; put 0 before dot"); 13891 } 13892 lex_state = EXPR_DOT; 13893 return '.'; 13894 13895 start_num: 13896 case '0': case '1': case '2': case '3': case '4': 13897 case '5': case '6': case '7': case '8': case '9': 13898 { 13899 int is_float, seen_point, seen_e, nondigit; 13900 13901 is_float = seen_point = seen_e = nondigit = 0; 13902 lex_state = EXPR_END; 13903 newtok(); 13904 if (c == '-' || c == '+') { 13905 tokadd(c); 13906 c = nextc(); 13907 } 13908 if (c == '0') { 13909 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0) 13910 int start = toklen(); 13911 c = nextc(); 13912 if (c == 'x' || c == 'X') { 13913 /* hexadecimal */ 13914 c = nextc(); 13915 if (c != -1 && ISXDIGIT(c)) { 13916 do { 13917 if (c == '_') { 13918 if (nondigit) break; 13919 nondigit = c; 13920 continue; 13921 } 13922 if (!ISXDIGIT(c)) break; 13923 nondigit = 0; 13924 tokadd(c); 13925 } while ((c = nextc()) != -1); 13926 } 13927 pushback(c); 13928 tokfix(); 13929 if (toklen() == start) { 13930 no_digits(); 13931 } 13932 else if (nondigit) goto trailing_uc; 13933 set_yylval_literal(rb_cstr_to_inum(tok(), 16, FALSE)); 13934 return tINTEGER; 13935 } 13936 if (c == 'b' || c == 'B') { 13937 /* binary */ 13938 c = nextc(); 13939 if (c == '0' || c == '1') { 13940 do { 13941 if (c == '_') { 13942 if (nondigit) break; 13943 nondigit = c; 13944 continue; 13945 } 13946 if (c != '0' && c != '1') break; 13947 nondigit = 0; 13948 tokadd(c); 13949 } while ((c = nextc()) != -1); 13950 } 13951 pushback(c); 13952 tokfix(); 13953 if (toklen() == start) { 13954 no_digits(); 13955 } 13956 else if (nondigit) goto trailing_uc; 13957 set_yylval_literal(rb_cstr_to_inum(tok(), 2, FALSE)); 13958 return tINTEGER; 13959 } 13960 if (c == 'd' || c == 'D') { 13961 /* decimal */ 13962 c = nextc(); 13963 if (c != -1 && ISDIGIT(c)) { 13964 do { 13965 if (c == '_') { 13966 if (nondigit) break; 13967 nondigit = c; 13968 continue; 13969 } 13970 if (!ISDIGIT(c)) break; 13971 nondigit = 0; 13972 tokadd(c); 13973 } while ((c = nextc()) != -1); 13974 } 13975 pushback(c); 13976 tokfix(); 13977 if (toklen() == start) { 13978 no_digits(); 13979 } 13980 else if (nondigit) goto trailing_uc; 13981 set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE)); 13982 return tINTEGER; 13983 } 13984 if (c == '_') { 13985 /* 0_0 */ 13986 goto octal_number; 13987 } 13988 if (c == 'o' || c == 'O') { 13989 /* prefixed octal */ 13990 c = nextc(); 13991 if (c == -1 || c == '_' || !ISDIGIT(c)) { 13992 no_digits(); 13993 } 13994 } 13995 if (c >= '0' && c <= '7') { 13996 /* octal */ 13997 octal_number: 13998 do { 13999 if (c == '_') { 14000 if (nondigit) break; 14001 nondigit = c; 14002 continue; 14003 } 14004 if (c < '0' || c > '9') break; 14005 if (c > '7') goto invalid_octal; 14006 nondigit = 0; 14007 tokadd(c); 14008 } while ((c = nextc()) != -1); 14009 if (toklen() > start) { 14010 pushback(c); 14011 tokfix(); 14012 if (nondigit) goto trailing_uc; 14013 set_yylval_literal(rb_cstr_to_inum(tok(), 8, FALSE)); 14014 return tINTEGER; 14015 } 14016 if (nondigit) { 14017 pushback(c); 14018 goto trailing_uc; 14019 } 14020 } 14021 if (c > '7' && c <= '9') { 14022 invalid_octal: 14023 yyerror("Invalid octal digit"); 14024 } 14025 else if (c == '.' || c == 'e' || c == 'E') { 14026 tokadd('0'); 14027 } 14028 else { 14029 pushback(c); 14030 set_yylval_literal(INT2FIX(0)); 14031 return tINTEGER; 14032 } 14033 } 14034 14035 for (;;) { 14036 switch (c) { 14037 case '0': case '1': case '2': case '3': case '4': 14038 case '5': case '6': case '7': case '8': case '9': 14039 nondigit = 0; 14040 tokadd(c); 14041 break; 14042 14043 case '.': 14044 if (nondigit) goto trailing_uc; 14045 if (seen_point || seen_e) { 14046 goto decode_num; 14047 } 14048 else { 14049 int c0 = nextc(); 14050 if (c0 == -1 || !ISDIGIT(c0)) { 14051 pushback(c0); 14052 goto decode_num; 14053 } 14054 c = c0; 14055 } 14056 tokadd('.'); 14057 tokadd(c); 14058 is_float++; 14059 seen_point++; 14060 nondigit = 0; 14061 break; 14062 14063 case 'e': 14064 case 'E': 14065 if (nondigit) { 14066 pushback(c); 14067 c = nondigit; 14068 goto decode_num; 14069 } 14070 if (seen_e) { 14071 goto decode_num; 14072 } 14073 tokadd(c); 14074 seen_e++; 14075 is_float++; 14076 nondigit = c; 14077 c = nextc(); 14078 if (c != '-' && c != '+') continue; 14079 tokadd(c); 14080 nondigit = c; 14081 break; 14082 14083 case '_': /* `_' in number just ignored */ 14084 if (nondigit) goto decode_num; 14085 nondigit = c; 14086 break; 14087 14088 default: 14089 goto decode_num; 14090 } 14091 c = nextc(); 14092 } 14093 14094 decode_num: 14095 pushback(c); 14096 if (nondigit) { 14097 char tmp[30]; 14098 trailing_uc: 14099 snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit); 14100 yyerror(tmp); 14101 } 14102 tokfix(); 14103 if (is_float) { 14104 double d = strtod(tok(), 0); 14105 if (errno == ERANGE) { 14106 rb_warningS("Float %s out of range", tok()); 14107 errno = 0; 14108 } 14109 set_yylval_literal(DBL2NUM(d)); 14110 return tFLOAT; 14111 } 14112 set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE)); 14113 return tINTEGER; 14114 } 14115 14116 case ')': 14117 case ']': 14118 paren_nest--; 14119 case '}': 14120 COND_LEXPOP(); 14121 CMDARG_LEXPOP(); 14122 if (c == ')') 14123 lex_state = EXPR_ENDFN; 14124 else 14125 lex_state = EXPR_ENDARG; 14126 if (c == '}') { 14127 if (!brace_nest--) c = tSTRING_DEND; 14128 } 14129 return c; 14130 14131 case ':': 14132 c = nextc(); 14133 if (c == ':') { 14134 if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) { 14135 lex_state = EXPR_BEG; 14136 return tCOLON3; 14137 } 14138 lex_state = EXPR_DOT; 14139 return tCOLON2; 14140 } 14141 if (IS_END() || ISSPACE(c)) { 14142 pushback(c); 14143 warn_balanced(":", "symbol literal"); 14144 lex_state = EXPR_BEG; 14145 return ':'; 14146 } 14147 switch (c) { 14148 case '\'': 14149 lex_strterm = NEW_STRTERM(str_ssym, c, 0); 14150 break; 14151 case '"': 14152 lex_strterm = NEW_STRTERM(str_dsym, c, 0); 14153 break; 14154 default: 14155 pushback(c); 14156 break; 14157 } 14158 lex_state = EXPR_FNAME; 14159 return tSYMBEG; 14160 14161 case '/': 14162 if (IS_lex_state(EXPR_BEG_ANY)) { 14163 lex_strterm = NEW_STRTERM(str_regexp, '/', 0); 14164 return tREGEXP_BEG; 14165 } 14166 if ((c = nextc()) == '=') { 14167 set_yylval_id('/'); 14168 lex_state = EXPR_BEG; 14169 return tOP_ASGN; 14170 } 14171 pushback(c); 14172 if (IS_SPCARG(c)) { 14173 (void)arg_ambiguous(); 14174 lex_strterm = NEW_STRTERM(str_regexp, '/', 0); 14175 return tREGEXP_BEG; 14176 } 14177 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; 14178 warn_balanced("/", "regexp literal"); 14179 return '/'; 14180 14181 case '^': 14182 if ((c = nextc()) == '=') { 14183 set_yylval_id('^'); 14184 lex_state = EXPR_BEG; 14185 return tOP_ASGN; 14186 } 14187 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; 14188 pushback(c); 14189 return '^'; 14190 14191 case ';': 14192 lex_state = EXPR_BEG; 14193 command_start = TRUE; 14194 return ';'; 14195 14196 case ',': 14197 lex_state = EXPR_BEG; 14198 return ','; 14199 14200 case '~': 14201 if (IS_AFTER_OPERATOR()) { 14202 if ((c = nextc()) != '@') { 14203 pushback(c); 14204 } 14205 lex_state = EXPR_ARG; 14206 } 14207 else { 14208 lex_state = EXPR_BEG; 14209 } 14210 return '~'; 14211 14212 case '(': 14213 if (IS_BEG()) { 14214 c = tLPAREN; 14215 } 14216 else if (IS_SPCARG(-1)) { 14217 c = tLPAREN_ARG; 14218 } 14219 paren_nest++; 14220 COND_PUSH(0); 14221 CMDARG_PUSH(0); 14222 lex_state = EXPR_BEG; 14223 return c; 14224 14225 case '[': 14226 paren_nest++; 14227 if (IS_AFTER_OPERATOR()) { 14228 lex_state = EXPR_ARG; 14229 if ((c = nextc()) == ']') { 14230 if ((c = nextc()) == '=') { 14231 return tASET; 14232 } 14233 pushback(c); 14234 return tAREF; 14235 } 14236 pushback(c); 14237 return '['; 14238 } 14239 else if (IS_BEG()) { 14240 c = tLBRACK; 14241 } 14242 else if (IS_ARG() && space_seen) { 14243 c = tLBRACK; 14244 } 14245 lex_state = EXPR_BEG; 14246 COND_PUSH(0); 14247 CMDARG_PUSH(0); 14248 return c; 14249 14250 case '{': 14251 ++brace_nest; 14252 if (lpar_beg && lpar_beg == paren_nest) { 14253 lex_state = EXPR_BEG; 14254 lpar_beg = 0; 14255 --paren_nest; 14256 COND_PUSH(0); 14257 CMDARG_PUSH(0); 14258 return tLAMBEG; 14259 } 14260 if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN)) 14261 c = '{'; /* block (primary) */ 14262 else if (IS_lex_state(EXPR_ENDARG)) 14263 c = tLBRACE_ARG; /* block (expr) */ 14264 else 14265 c = tLBRACE; /* hash */ 14266 COND_PUSH(0); 14267 CMDARG_PUSH(0); 14268 lex_state = EXPR_BEG; 14269 if (c != tLBRACE) command_start = TRUE; 14270 return c; 14271 14272 case '\\': 14273 c = nextc(); 14274 if (c == '\n') { 14275 space_seen = 1; 14276 #ifdef RIPPER 14277 ripper_dispatch_scan_event(parser, tSP); 14278 #endif 14279 goto retry; /* skip \\n */ 14280 } 14281 pushback(c); 14282 return '\\'; 14283 14284 case '%': 14285 if (IS_lex_state(EXPR_BEG_ANY)) { 14286 int term; 14287 int paren; 14288 14289 c = nextc(); 14290 quotation: 14291 if (c == -1 || !ISALNUM(c)) { 14292 term = c; 14293 c = 'Q'; 14294 } 14295 else { 14296 term = nextc(); 14297 if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) { 14298 yyerror("unknown type of %string"); 14299 return 0; 14300 } 14301 } 14302 if (c == -1 || term == -1) { 14303 compile_error(PARSER_ARG "unterminated quoted string meets end of file"); 14304 return 0; 14305 } 14306 paren = term; 14307 if (term == '(') term = ')'; 14308 else if (term == '[') term = ']'; 14309 else if (term == '{') term = '}'; 14310 else if (term == '<') term = '>'; 14311 else paren = 0; 14312 14313 switch (c) { 14314 case 'Q': 14315 lex_strterm = NEW_STRTERM(str_dquote, term, paren); 14316 return tSTRING_BEG; 14317 14318 case 'q': 14319 lex_strterm = NEW_STRTERM(str_squote, term, paren); 14320 return tSTRING_BEG; 14321 14322 case 'W': 14323 lex_strterm = NEW_STRTERM(str_dword, term, paren); 14324 do {c = nextc();} while (ISSPACE(c)); 14325 pushback(c); 14326 return tWORDS_BEG; 14327 14328 case 'w': 14329 lex_strterm = NEW_STRTERM(str_sword, term, paren); 14330 do {c = nextc();} while (ISSPACE(c)); 14331 pushback(c); 14332 return tQWORDS_BEG; 14333 14334 case 'I': 14335 lex_strterm = NEW_STRTERM(str_dword, term, paren); 14336 do {c = nextc();} while (ISSPACE(c)); 14337 pushback(c); 14338 return tSYMBOLS_BEG; 14339 14340 case 'i': 14341 lex_strterm = NEW_STRTERM(str_sword, term, paren); 14342 do {c = nextc();} while (ISSPACE(c)); 14343 pushback(c); 14344 return tQSYMBOLS_BEG; 14345 14346 case 'x': 14347 lex_strterm = NEW_STRTERM(str_xquote, term, paren); 14348 return tXSTRING_BEG; 14349 14350 case 'r': 14351 lex_strterm = NEW_STRTERM(str_regexp, term, paren); 14352 return tREGEXP_BEG; 14353 14354 case 's': 14355 lex_strterm = NEW_STRTERM(str_ssym, term, paren); 14356 lex_state = EXPR_FNAME; 14357 return tSYMBEG; 14358 14359 default: 14360 yyerror("unknown type of %string"); 14361 return 0; 14362 } 14363 } 14364 if ((c = nextc()) == '=') { 14365 set_yylval_id('%'); 14366 lex_state = EXPR_BEG; 14367 return tOP_ASGN; 14368 } 14369 if (IS_SPCARG(c)) { 14370 goto quotation; 14371 } 14372 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG; 14373 pushback(c); 14374 warn_balanced("%%", "string literal"); 14375 return '%'; 14376 14377 case '$': 14378 lex_state = EXPR_END; 14379 newtok(); 14380 c = nextc(); 14381 switch (c) { 14382 case '_': /* $_: last read line string */ 14383 c = nextc(); 14384 if (parser_is_identchar()) { 14385 tokadd('$'); 14386 tokadd('_'); 14387 break; 14388 } 14389 pushback(c); 14390 c = '_'; 14391 /* fall through */ 14392 case '~': /* $~: match-data */ 14393 case '*': /* $*: argv */ 14394 case '$': /* $$: pid */ 14395 case '?': /* $?: last status */ 14396 case '!': /* $!: error string */ 14397 case '@': /* $@: error position */ 14398 case '/': /* $/: input record separator */ 14399 case '\\': /* $\: output record separator */ 14400 case ';': /* $;: field separator */ 14401 case ',': /* $,: output field separator */ 14402 case '.': /* $.: last read line number */ 14403 case '=': /* $=: ignorecase */ 14404 case ':': /* $:: load path */ 14405 case '<': /* $<: reading filename */ 14406 case '>': /* $>: default output handle */ 14407 case '\"': /* $": already loaded files */ 14408 tokadd('$'); 14409 tokadd(c); 14410 tokfix(); 14411 set_yylval_name(rb_intern(tok())); 14412 return tGVAR; 14413 14414 case '-': 14415 tokadd('$'); 14416 tokadd(c); 14417 c = nextc(); 14418 if (parser_is_identchar()) { 14419 if (tokadd_mbchar(c) == -1) return 0; 14420 } 14421 else { 14422 pushback(c); 14423 } 14424 gvar: 14425 tokfix(); 14426 set_yylval_name(rb_intern(tok())); 14427 return tGVAR; 14428 14429 case '&': /* $&: last match */ 14430 case '`': /* $`: string before last match */ 14431 case '\'': /* $': string after last match */ 14432 case '+': /* $+: string matches last paren. */ 14433 if (IS_lex_state_for(last_state, EXPR_FNAME)) { 14434 tokadd('$'); 14435 tokadd(c); 14436 goto gvar; 14437 } 14438 set_yylval_node(NEW_BACK_REF(c)); 14439 return tBACK_REF; 14440 14441 case '1': case '2': case '3': 14442 case '4': case '5': case '6': 14443 case '7': case '8': case '9': 14444 tokadd('$'); 14445 do { 14446 tokadd(c); 14447 c = nextc(); 14448 } while (c != -1 && ISDIGIT(c)); 14449 pushback(c); 14450 if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar; 14451 tokfix(); 14452 set_yylval_node(NEW_NTH_REF(atoi(tok()+1))); 14453 return tNTH_REF; 14454 14455 default: 14456 if (!parser_is_identchar()) { 14457 pushback(c); 14458 compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c); 14459 return 0; 14460 } 14461 case '0': 14462 tokadd('$'); 14463 } 14464 break; 14465 14466 case '@': 14467 c = nextc(); 14468 newtok(); 14469 tokadd('@'); 14470 if (c == '@') { 14471 tokadd('@'); 14472 c = nextc(); 14473 } 14474 if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) { 14475 pushback(c); 14476 if (tokidx == 1) { 14477 compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c); 14478 } 14479 else { 14480 compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c); 14481 } 14482 return 0; 14483 } 14484 break; 14485 14486 case '_': 14487 if (was_bol() && whole_match_p("__END__", 7, 0)) { 14488 ruby__end__seen = 1; 14489 parser->eofp = Qtrue; 14490 #ifndef RIPPER 14491 return -1; 14492 #else 14493 lex_goto_eol(parser); 14494 ripper_dispatch_scan_event(parser, k__END__); 14495 return 0; 14496 #endif 14497 } 14498 newtok(); 14499 break; 14500 14501 default: 14502 if (!parser_is_identchar()) { 14503 compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c); 14504 goto retry; 14505 } 14506 14507 newtok(); 14508 break; 14509 } 14510 14511 mb = ENC_CODERANGE_7BIT; 14512 do { 14513 if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN; 14514 if (tokadd_mbchar(c) == -1) return 0; 14515 c = nextc(); 14516 } while (parser_is_identchar()); 14517 switch (tok()[0]) { 14518 case '@': case '$': 14519 pushback(c); 14520 break; 14521 default: 14522 if ((c == '!' || c == '?') && !peek('=')) { 14523 tokadd(c); 14524 } 14525 else { 14526 pushback(c); 14527 } 14528 } 14529 tokfix(); 14530 14531 { 14532 int result = 0; 14533 14534 last_state = lex_state; 14535 switch (tok()[0]) { 14536 case '$': 14537 lex_state = EXPR_END; 14538 result = tGVAR; 14539 break; 14540 case '@': 14541 lex_state = EXPR_END; 14542 if (tok()[1] == '@') 14543 result = tCVAR; 14544 else 14545 result = tIVAR; 14546 break; 14547 14548 default: 14549 if (toklast() == '!' || toklast() == '?') { 14550 result = tFID; 14551 } 14552 else { 14553 if (IS_lex_state(EXPR_FNAME)) { 14554 if ((c = nextc()) == '=' && !peek('~') && !peek('>') && 14555 (!peek('=') || (peek_n('>', 1)))) { 14556 result = tIDENTIFIER; 14557 tokadd(c); 14558 tokfix(); 14559 } 14560 else { 14561 pushback(c); 14562 } 14563 } 14564 if (result == 0 && ISUPPER(tok()[0])) { 14565 result = tCONSTANT; 14566 } 14567 else { 14568 result = tIDENTIFIER; 14569 } 14570 } 14571 14572 if (IS_LABEL_POSSIBLE()) { 14573 if (IS_LABEL_SUFFIX(0)) { 14574 lex_state = EXPR_BEG; 14575 nextc(); 14576 set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb))); 14577 return tLABEL; 14578 } 14579 } 14580 if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) { 14581 const struct kwtable *kw; 14582 14583 /* See if it is a reserved word. */ 14584 kw = rb_reserved_word(tok(), toklen()); 14585 if (kw) { 14586 enum lex_state_e state = lex_state; 14587 lex_state = kw->state; 14588 if (state == EXPR_FNAME) { 14589 set_yylval_name(rb_intern(kw->name)); 14590 return kw->id[0]; 14591 } 14592 if (lex_state == EXPR_BEG) { 14593 command_start = TRUE; 14594 } 14595 if (kw->id[0] == keyword_do) { 14596 if (lpar_beg && lpar_beg == paren_nest) { 14597 lpar_beg = 0; 14598 --paren_nest; 14599 return keyword_do_LAMBDA; 14600 } 14601 if (COND_P()) return keyword_do_cond; 14602 if (CMDARG_P() && state != EXPR_CMDARG) 14603 return keyword_do_block; 14604 if (state & (EXPR_BEG | EXPR_ENDARG)) 14605 return keyword_do_block; 14606 return keyword_do; 14607 } 14608 if (state & (EXPR_BEG | EXPR_VALUE)) 14609 return kw->id[0]; 14610 else { 14611 if (kw->id[0] != kw->id[1]) 14612 lex_state = EXPR_BEG; 14613 return kw->id[1]; 14614 } 14615 } 14616 } 14617 14618 if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) { 14619 if (cmd_state) { 14620 lex_state = EXPR_CMDARG; 14621 } 14622 else { 14623 lex_state = EXPR_ARG; 14624 } 14625 } 14626 else if (lex_state == EXPR_FNAME) { 14627 lex_state = EXPR_ENDFN; 14628 } 14629 else { 14630 lex_state = EXPR_END; 14631 } 14632 } 14633 { 14634 ID ident = TOK_INTERN(!ENC_SINGLE(mb)); 14635 14636 set_yylval_name(ident); 14637 if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) && 14638 is_local_id(ident) && lvar_defined(ident)) { 14639 lex_state = EXPR_END; 14640 } 14641 } 14642 return result; 14643 } 14644 } 14645 14646 #if YYPURE 14647 static int 14648 yylex(void *lval, void *p) 14649 #else 14650 yylex(void *p) 14651 #endif 14652 { 14653 struct parser_params *parser = (struct parser_params*)p; 14654 int t; 14655 14656 #if YYPURE 14657 parser->parser_yylval = lval; 14658 parser->parser_yylval->val = Qundef; 14659 #endif 14660 t = parser_yylex(parser); 14661 #ifdef RIPPER 14662 if (!NIL_P(parser->delayed)) { 14663 ripper_dispatch_delayed_token(parser, t); 14664 return t; 14665 } 14666 if (t != 0) 14667 ripper_dispatch_scan_event(parser, t); 14668 #endif 14669 14670 return t; 14671 } 14672 14673 #ifndef RIPPER 14674 static NODE* 14675 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2) 14676 { 14677 NODE *n = (rb_node_newnode)(type, a0, a1, a2); 14678 nd_set_line(n, ruby_sourceline); 14679 return n; 14680 } 14681 14682 static enum node_type 14683 nodetype(NODE *node) /* for debug */ 14684 { 14685 return (enum node_type)nd_type(node); 14686 } 14687 14688 static int 14689 nodeline(NODE *node) 14690 { 14691 return nd_line(node); 14692 } 14693 14694 static NODE* 14695 newline_node(NODE *node) 14696 { 14697 if (node) { 14698 node = remove_begin(node); 14699 node->flags |= NODE_FL_NEWLINE; 14700 } 14701 return node; 14702 } 14703 14704 static void 14705 fixpos(NODE *node, NODE *orig) 14706 { 14707 if (!node) return; 14708 if (!orig) return; 14709 if (orig == (NODE*)1) return; 14710 nd_set_line(node, nd_line(orig)); 14711 } 14712 14713 static void 14714 parser_warning(struct parser_params *parser, NODE *node, const char *mesg) 14715 { 14716 rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg); 14717 } 14718 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg)) 14719 14720 static void 14721 parser_warn(struct parser_params *parser, NODE *node, const char *mesg) 14722 { 14723 rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg); 14724 } 14725 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg)) 14726 14727 static NODE* 14728 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail) 14729 { 14730 NODE *end, *h = head, *nd; 14731 14732 if (tail == 0) return head; 14733 14734 if (h == 0) return tail; 14735 switch (nd_type(h)) { 14736 case NODE_LIT: 14737 case NODE_STR: 14738 case NODE_SELF: 14739 case NODE_TRUE: 14740 case NODE_FALSE: 14741 case NODE_NIL: 14742 parser_warning(h, "unused literal ignored"); 14743 return tail; 14744 default: 14745 h = end = NEW_BLOCK(head); 14746 end->nd_end = end; 14747 fixpos(end, head); 14748 head = end; 14749 break; 14750 case NODE_BLOCK: 14751 end = h->nd_end; 14752 break; 14753 } 14754 14755 nd = end->nd_head; 14756 switch (nd_type(nd)) { 14757 case NODE_RETURN: 14758 case NODE_BREAK: 14759 case NODE_NEXT: 14760 case NODE_REDO: 14761 case NODE_RETRY: 14762 if (RTEST(ruby_verbose)) { 14763 parser_warning(tail, "statement not reached"); 14764 } 14765 break; 14766 14767 default: 14768 break; 14769 } 14770 14771 if (nd_type(tail) != NODE_BLOCK) { 14772 tail = NEW_BLOCK(tail); 14773 tail->nd_end = tail; 14774 } 14775 end->nd_next = tail; 14776 h->nd_end = tail->nd_end; 14777 return head; 14778 } 14779 14780 /* append item to the list */ 14781 static NODE* 14782 list_append_gen(struct parser_params *parser, NODE *list, NODE *item) 14783 { 14784 NODE *last; 14785 14786 if (list == 0) return NEW_LIST(item); 14787 if (list->nd_next) { 14788 last = list->nd_next->nd_end; 14789 } 14790 else { 14791 last = list; 14792 } 14793 14794 list->nd_alen += 1; 14795 last->nd_next = NEW_LIST(item); 14796 list->nd_next->nd_end = last->nd_next; 14797 return list; 14798 } 14799 14800 /* concat two lists */ 14801 static NODE* 14802 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail) 14803 { 14804 NODE *last; 14805 14806 if (head->nd_next) { 14807 last = head->nd_next->nd_end; 14808 } 14809 else { 14810 last = head; 14811 } 14812 14813 head->nd_alen += tail->nd_alen; 14814 last->nd_next = tail; 14815 if (tail->nd_next) { 14816 head->nd_next->nd_end = tail->nd_next->nd_end; 14817 } 14818 else { 14819 head->nd_next->nd_end = tail; 14820 } 14821 14822 return head; 14823 } 14824 14825 static int 14826 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail) 14827 { 14828 if (NIL_P(tail)) return 1; 14829 if (!rb_enc_compatible(head, tail)) { 14830 compile_error(PARSER_ARG "string literal encodings differ (%s / %s)", 14831 rb_enc_name(rb_enc_get(head)), 14832 rb_enc_name(rb_enc_get(tail))); 14833 rb_str_resize(head, 0); 14834 rb_str_resize(tail, 0); 14835 return 0; 14836 } 14837 rb_str_buf_append(head, tail); 14838 return 1; 14839 } 14840 14841 /* concat two string literals */ 14842 static NODE * 14843 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail) 14844 { 14845 enum node_type htype; 14846 NODE *headlast; 14847 VALUE lit; 14848 14849 if (!head) return tail; 14850 if (!tail) return head; 14851 14852 htype = nd_type(head); 14853 if (htype == NODE_EVSTR) { 14854 NODE *node = NEW_DSTR(Qnil); 14855 head = list_append(node, head); 14856 htype = NODE_DSTR; 14857 } 14858 switch (nd_type(tail)) { 14859 case NODE_STR: 14860 if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) && 14861 nd_type(headlast) == NODE_STR) { 14862 htype = NODE_STR; 14863 lit = headlast->nd_lit; 14864 } 14865 else { 14866 lit = head->nd_lit; 14867 } 14868 if (htype == NODE_STR) { 14869 if (!literal_concat0(parser, lit, tail->nd_lit)) { 14870 error: 14871 rb_gc_force_recycle((VALUE)head); 14872 rb_gc_force_recycle((VALUE)tail); 14873 return 0; 14874 } 14875 rb_gc_force_recycle((VALUE)tail); 14876 } 14877 else { 14878 list_append(head, tail); 14879 } 14880 break; 14881 14882 case NODE_DSTR: 14883 if (htype == NODE_STR) { 14884 if (!literal_concat0(parser, head->nd_lit, tail->nd_lit)) 14885 goto error; 14886 tail->nd_lit = head->nd_lit; 14887 rb_gc_force_recycle((VALUE)head); 14888 head = tail; 14889 } 14890 else if (NIL_P(tail->nd_lit)) { 14891 append: 14892 head->nd_alen += tail->nd_alen - 1; 14893 head->nd_next->nd_end->nd_next = tail->nd_next; 14894 head->nd_next->nd_end = tail->nd_next->nd_end; 14895 rb_gc_force_recycle((VALUE)tail); 14896 } 14897 else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) && 14898 nd_type(headlast) == NODE_STR) { 14899 lit = headlast->nd_lit; 14900 if (!literal_concat0(parser, lit, tail->nd_lit)) 14901 goto error; 14902 tail->nd_lit = Qnil; 14903 goto append; 14904 } 14905 else { 14906 nd_set_type(tail, NODE_ARRAY); 14907 tail->nd_head = NEW_STR(tail->nd_lit); 14908 list_concat(head, tail); 14909 } 14910 break; 14911 14912 case NODE_EVSTR: 14913 if (htype == NODE_STR) { 14914 nd_set_type(head, NODE_DSTR); 14915 head->nd_alen = 1; 14916 } 14917 list_append(head, tail); 14918 break; 14919 } 14920 return head; 14921 } 14922 14923 static NODE * 14924 evstr2dstr_gen(struct parser_params *parser, NODE *node) 14925 { 14926 if (nd_type(node) == NODE_EVSTR) { 14927 node = list_append(NEW_DSTR(Qnil), node); 14928 } 14929 return node; 14930 } 14931 14932 static NODE * 14933 new_evstr_gen(struct parser_params *parser, NODE *node) 14934 { 14935 NODE *head = node; 14936 14937 if (node) { 14938 switch (nd_type(node)) { 14939 case NODE_STR: case NODE_DSTR: case NODE_EVSTR: 14940 return node; 14941 } 14942 } 14943 return NEW_EVSTR(head); 14944 } 14945 14946 static NODE * 14947 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1) 14948 { 14949 value_expr(recv); 14950 value_expr(arg1); 14951 return NEW_CALL(recv, id, NEW_LIST(arg1)); 14952 } 14953 14954 static NODE * 14955 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id) 14956 { 14957 value_expr(recv); 14958 return NEW_CALL(recv, id, 0); 14959 } 14960 14961 static NODE* 14962 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2) 14963 { 14964 value_expr(node1); 14965 value_expr(node2); 14966 if (node1) { 14967 switch (nd_type(node1)) { 14968 case NODE_DREGX: 14969 case NODE_DREGX_ONCE: 14970 return NEW_MATCH2(node1, node2); 14971 14972 case NODE_LIT: 14973 if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) { 14974 return NEW_MATCH2(node1, node2); 14975 } 14976 } 14977 } 14978 14979 if (node2) { 14980 switch (nd_type(node2)) { 14981 case NODE_DREGX: 14982 case NODE_DREGX_ONCE: 14983 return NEW_MATCH3(node2, node1); 14984 14985 case NODE_LIT: 14986 if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) { 14987 return NEW_MATCH3(node2, node1); 14988 } 14989 } 14990 } 14991 14992 return NEW_CALL(node1, tMATCH, NEW_LIST(node2)); 14993 } 14994 14995 static NODE* 14996 gettable_gen(struct parser_params *parser, ID id) 14997 { 14998 switch (id) { 14999 case keyword_self: 15000 return NEW_SELF(); 15001 case keyword_nil: 15002 return NEW_NIL(); 15003 case keyword_true: 15004 return NEW_TRUE(); 15005 case keyword_false: 15006 return NEW_FALSE(); 15007 case keyword__FILE__: 15008 return NEW_STR(rb_str_dup(ruby_sourcefile_string)); 15009 case keyword__LINE__: 15010 return NEW_LIT(INT2FIX(tokline)); 15011 case keyword__ENCODING__: 15012 return NEW_LIT(rb_enc_from_encoding(current_enc)); 15013 } 15014 switch (id_type(id)) { 15015 case ID_LOCAL: 15016 if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id); 15017 if (local_id(id)) return NEW_LVAR(id); 15018 /* method call without arguments */ 15019 return NEW_VCALL(id); 15020 case ID_GLOBAL: 15021 return NEW_GVAR(id); 15022 case ID_INSTANCE: 15023 return NEW_IVAR(id); 15024 case ID_CONST: 15025 return NEW_CONST(id); 15026 case ID_CLASS: 15027 return NEW_CVAR(id); 15028 } 15029 compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id)); 15030 return 0; 15031 } 15032 #else /* !RIPPER */ 15033 static int 15034 id_is_var_gen(struct parser_params *parser, ID id) 15035 { 15036 if (is_notop_id(id)) { 15037 switch (id & ID_SCOPE_MASK) { 15038 case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS: 15039 return 1; 15040 case ID_LOCAL: 15041 if (dyna_in_block() && dvar_defined(id)) return 1; 15042 if (local_id(id)) return 1; 15043 /* method call without arguments */ 15044 return 0; 15045 } 15046 } 15047 compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id)); 15048 return 0; 15049 } 15050 #endif /* !RIPPER */ 15051 15052 #if PARSER_DEBUG 15053 static const char * 15054 lex_state_name(enum lex_state_e state) 15055 { 15056 static const char names[][12] = { 15057 "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG", 15058 "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS", 15059 "EXPR_VALUE", 15060 }; 15061 15062 if ((unsigned)state & ~(~0u << EXPR_MAX_STATE)) 15063 return names[ffs(state)]; 15064 return NULL; 15065 } 15066 #endif 15067 15068 #ifdef RIPPER 15069 static VALUE 15070 assignable_gen(struct parser_params *parser, VALUE lhs) 15071 #else 15072 static NODE* 15073 assignable_gen(struct parser_params *parser, ID id, NODE *val) 15074 #endif 15075 { 15076 #ifdef RIPPER 15077 ID id = get_id(lhs); 15078 # define assignable_result(x) get_value(lhs) 15079 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs) 15080 #else 15081 # define assignable_result(x) (x) 15082 #endif 15083 if (!id) return assignable_result(0); 15084 switch (id) { 15085 case keyword_self: 15086 yyerror("Can't change the value of self"); 15087 goto error; 15088 case keyword_nil: 15089 yyerror("Can't assign to nil"); 15090 goto error; 15091 case keyword_true: 15092 yyerror("Can't assign to true"); 15093 goto error; 15094 case keyword_false: 15095 yyerror("Can't assign to false"); 15096 goto error; 15097 case keyword__FILE__: 15098 yyerror("Can't assign to __FILE__"); 15099 goto error; 15100 case keyword__LINE__: 15101 yyerror("Can't assign to __LINE__"); 15102 goto error; 15103 case keyword__ENCODING__: 15104 yyerror("Can't assign to __ENCODING__"); 15105 goto error; 15106 } 15107 switch (id_type(id)) { 15108 case ID_LOCAL: 15109 if (dyna_in_block()) { 15110 if (dvar_curr(id)) { 15111 return assignable_result(NEW_DASGN_CURR(id, val)); 15112 } 15113 else if (dvar_defined(id)) { 15114 return assignable_result(NEW_DASGN(id, val)); 15115 } 15116 else if (local_id(id)) { 15117 return assignable_result(NEW_LASGN(id, val)); 15118 } 15119 else { 15120 dyna_var(id); 15121 return assignable_result(NEW_DASGN_CURR(id, val)); 15122 } 15123 } 15124 else { 15125 if (!local_id(id)) { 15126 local_var(id); 15127 } 15128 return assignable_result(NEW_LASGN(id, val)); 15129 } 15130 break; 15131 case ID_GLOBAL: 15132 return assignable_result(NEW_GASGN(id, val)); 15133 case ID_INSTANCE: 15134 return assignable_result(NEW_IASGN(id, val)); 15135 case ID_CONST: 15136 if (!in_def && !in_single) 15137 return assignable_result(NEW_CDECL(id, val, 0)); 15138 yyerror("dynamic constant assignment"); 15139 break; 15140 case ID_CLASS: 15141 return assignable_result(NEW_CVASGN(id, val)); 15142 default: 15143 compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id)); 15144 } 15145 error: 15146 return assignable_result(0); 15147 #undef assignable_result 15148 #undef parser_yyerror 15149 } 15150 15151 static int 15152 is_private_local_id(ID name) 15153 { 15154 VALUE s; 15155 if (name == idUScore) return 1; 15156 if (!is_local_id(name)) return 0; 15157 s = rb_id2str(name); 15158 if (!s) return 0; 15159 return RSTRING_PTR(s)[0] == '_'; 15160 } 15161 15162 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1)) 15163 15164 static ID 15165 shadowing_lvar_gen(struct parser_params *parser, ID name) 15166 { 15167 if (is_private_local_id(name)) return name; 15168 if (dyna_in_block()) { 15169 if (dvar_curr(name)) { 15170 yyerror("duplicated argument name"); 15171 } 15172 else if (dvar_defined_get(name) || local_id(name)) { 15173 rb_warningS("shadowing outer local variable - %s", rb_id2name(name)); 15174 vtable_add(lvtbl->vars, name); 15175 if (lvtbl->used) { 15176 vtable_add(lvtbl->used, (ID)ruby_sourceline | LVAR_USED); 15177 } 15178 } 15179 } 15180 else { 15181 if (local_id(name)) { 15182 yyerror("duplicated argument name"); 15183 } 15184 } 15185 return name; 15186 } 15187 15188 static void 15189 new_bv_gen(struct parser_params *parser, ID name) 15190 { 15191 if (!name) return; 15192 if (!is_local_id(name)) { 15193 compile_error(PARSER_ARG "invalid local variable - %s", 15194 rb_id2name(name)); 15195 return; 15196 } 15197 shadowing_lvar(name); 15198 dyna_var(name); 15199 } 15200 15201 #ifndef RIPPER 15202 static NODE * 15203 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx) 15204 { 15205 if (recv && nd_type(recv) == NODE_SELF) 15206 recv = (NODE *)1; 15207 return NEW_ATTRASGN(recv, tASET, idx); 15208 } 15209 15210 static void 15211 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2) 15212 { 15213 if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) { 15214 compile_error(PARSER_ARG "both block arg and actual block given"); 15215 } 15216 } 15217 15218 static const char id_type_names[][9] = { 15219 "LOCAL", 15220 "INSTANCE", 15221 "", /* INSTANCE2 */ 15222 "GLOBAL", 15223 "ATTRSET", 15224 "CONST", 15225 "CLASS", 15226 "JUNK", 15227 }; 15228 15229 ID 15230 rb_id_attrset(ID id) 15231 { 15232 if (!is_notop_id(id)) { 15233 switch (id) { 15234 case tAREF: case tASET: 15235 return tASET; /* only exception */ 15236 } 15237 rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id)); 15238 } 15239 else { 15240 int scope = (int)(id & ID_SCOPE_MASK); 15241 switch (scope) { 15242 case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL: 15243 case ID_CONST: case ID_CLASS: case ID_JUNK: 15244 break; 15245 case ID_ATTRSET: 15246 return id; 15247 default: 15248 rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset", 15249 id_type_names[scope], ID2SYM(id)); 15250 15251 } 15252 } 15253 id &= ~ID_SCOPE_MASK; 15254 id |= ID_ATTRSET; 15255 return id; 15256 } 15257 15258 static NODE * 15259 attrset_gen(struct parser_params *parser, NODE *recv, ID id) 15260 { 15261 if (recv && nd_type(recv) == NODE_SELF) 15262 recv = (NODE *)1; 15263 return NEW_ATTRASGN(recv, rb_id_attrset(id), 0); 15264 } 15265 15266 static void 15267 rb_backref_error_gen(struct parser_params *parser, NODE *node) 15268 { 15269 switch (nd_type(node)) { 15270 case NODE_NTH_REF: 15271 compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth); 15272 break; 15273 case NODE_BACK_REF: 15274 compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth); 15275 break; 15276 } 15277 } 15278 15279 static NODE * 15280 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2) 15281 { 15282 if (!node2) return node1; 15283 switch (nd_type(node1)) { 15284 case NODE_BLOCK_PASS: 15285 if (node1->nd_head) 15286 node1->nd_head = arg_concat(node1->nd_head, node2); 15287 else 15288 node1->nd_head = NEW_LIST(node2); 15289 return node1; 15290 case NODE_ARGSPUSH: 15291 if (nd_type(node2) != NODE_ARRAY) break; 15292 node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2); 15293 nd_set_type(node1, NODE_ARGSCAT); 15294 return node1; 15295 case NODE_ARGSCAT: 15296 if (nd_type(node2) != NODE_ARRAY || 15297 nd_type(node1->nd_body) != NODE_ARRAY) break; 15298 node1->nd_body = list_concat(node1->nd_body, node2); 15299 return node1; 15300 } 15301 return NEW_ARGSCAT(node1, node2); 15302 } 15303 15304 static NODE * 15305 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2) 15306 { 15307 if (!node1) return NEW_LIST(node2); 15308 switch (nd_type(node1)) { 15309 case NODE_ARRAY: 15310 return list_append(node1, node2); 15311 case NODE_BLOCK_PASS: 15312 node1->nd_head = arg_append(node1->nd_head, node2); 15313 return node1; 15314 case NODE_ARGSPUSH: 15315 node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2); 15316 nd_set_type(node1, NODE_ARGSCAT); 15317 return node1; 15318 } 15319 return NEW_ARGSPUSH(node1, node2); 15320 } 15321 15322 static NODE * 15323 splat_array(NODE* node) 15324 { 15325 if (nd_type(node) == NODE_SPLAT) node = node->nd_head; 15326 if (nd_type(node) == NODE_ARRAY) return node; 15327 return 0; 15328 } 15329 15330 static NODE * 15331 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs) 15332 { 15333 if (!lhs) return 0; 15334 15335 switch (nd_type(lhs)) { 15336 case NODE_GASGN: 15337 case NODE_IASGN: 15338 case NODE_IASGN2: 15339 case NODE_LASGN: 15340 case NODE_DASGN: 15341 case NODE_DASGN_CURR: 15342 case NODE_MASGN: 15343 case NODE_CDECL: 15344 case NODE_CVASGN: 15345 lhs->nd_value = rhs; 15346 break; 15347 15348 case NODE_ATTRASGN: 15349 case NODE_CALL: 15350 lhs->nd_args = arg_append(lhs->nd_args, rhs); 15351 break; 15352 15353 default: 15354 /* should not happen */ 15355 break; 15356 } 15357 15358 return lhs; 15359 } 15360 15361 static int 15362 value_expr_gen(struct parser_params *parser, NODE *node) 15363 { 15364 int cond = 0; 15365 15366 if (!node) { 15367 rb_warning0("empty expression"); 15368 } 15369 while (node) { 15370 switch (nd_type(node)) { 15371 case NODE_DEFN: 15372 case NODE_DEFS: 15373 parser_warning(node, "void value expression"); 15374 return FALSE; 15375 15376 case NODE_RETURN: 15377 case NODE_BREAK: 15378 case NODE_NEXT: 15379 case NODE_REDO: 15380 case NODE_RETRY: 15381 if (!cond) yyerror("void value expression"); 15382 /* or "control never reach"? */ 15383 return FALSE; 15384 15385 case NODE_BLOCK: 15386 while (node->nd_next) { 15387 node = node->nd_next; 15388 } 15389 node = node->nd_head; 15390 break; 15391 15392 case NODE_BEGIN: 15393 node = node->nd_body; 15394 break; 15395 15396 case NODE_IF: 15397 if (!node->nd_body) { 15398 node = node->nd_else; 15399 break; 15400 } 15401 else if (!node->nd_else) { 15402 node = node->nd_body; 15403 break; 15404 } 15405 if (!value_expr(node->nd_body)) return FALSE; 15406 node = node->nd_else; 15407 break; 15408 15409 case NODE_AND: 15410 case NODE_OR: 15411 cond = 1; 15412 node = node->nd_2nd; 15413 break; 15414 15415 default: 15416 return TRUE; 15417 } 15418 } 15419 15420 return TRUE; 15421 } 15422 15423 static void 15424 void_expr_gen(struct parser_params *parser, NODE *node) 15425 { 15426 const char *useless = 0; 15427 15428 if (!RTEST(ruby_verbose)) return; 15429 15430 if (!node) return; 15431 switch (nd_type(node)) { 15432 case NODE_CALL: 15433 switch (node->nd_mid) { 15434 case '+': 15435 case '-': 15436 case '*': 15437 case '/': 15438 case '%': 15439 case tPOW: 15440 case tUPLUS: 15441 case tUMINUS: 15442 case '|': 15443 case '^': 15444 case '&': 15445 case tCMP: 15446 case '>': 15447 case tGEQ: 15448 case '<': 15449 case tLEQ: 15450 case tEQ: 15451 case tNEQ: 15452 useless = rb_id2name(node->nd_mid); 15453 break; 15454 } 15455 break; 15456 15457 case NODE_LVAR: 15458 case NODE_DVAR: 15459 case NODE_GVAR: 15460 case NODE_IVAR: 15461 case NODE_CVAR: 15462 case NODE_NTH_REF: 15463 case NODE_BACK_REF: 15464 useless = "a variable"; 15465 break; 15466 case NODE_CONST: 15467 useless = "a constant"; 15468 break; 15469 case NODE_LIT: 15470 case NODE_STR: 15471 case NODE_DSTR: 15472 case NODE_DREGX: 15473 case NODE_DREGX_ONCE: 15474 useless = "a literal"; 15475 break; 15476 case NODE_COLON2: 15477 case NODE_COLON3: 15478 useless = "::"; 15479 break; 15480 case NODE_DOT2: 15481 useless = ".."; 15482 break; 15483 case NODE_DOT3: 15484 useless = "..."; 15485 break; 15486 case NODE_SELF: 15487 useless = "self"; 15488 break; 15489 case NODE_NIL: 15490 useless = "nil"; 15491 break; 15492 case NODE_TRUE: 15493 useless = "true"; 15494 break; 15495 case NODE_FALSE: 15496 useless = "false"; 15497 break; 15498 case NODE_DEFINED: 15499 useless = "defined?"; 15500 break; 15501 } 15502 15503 if (useless) { 15504 int line = ruby_sourceline; 15505 15506 ruby_sourceline = nd_line(node); 15507 rb_warnS("possibly useless use of %s in void context", useless); 15508 ruby_sourceline = line; 15509 } 15510 } 15511 15512 static void 15513 void_stmts_gen(struct parser_params *parser, NODE *node) 15514 { 15515 if (!RTEST(ruby_verbose)) return; 15516 if (!node) return; 15517 if (nd_type(node) != NODE_BLOCK) return; 15518 15519 for (;;) { 15520 if (!node->nd_next) return; 15521 void_expr0(node->nd_head); 15522 node = node->nd_next; 15523 } 15524 } 15525 15526 static NODE * 15527 remove_begin(NODE *node) 15528 { 15529 NODE **n = &node, *n1 = node; 15530 while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) { 15531 *n = n1 = n1->nd_body; 15532 } 15533 return node; 15534 } 15535 15536 static void 15537 reduce_nodes_gen(struct parser_params *parser, NODE **body) 15538 { 15539 NODE *node = *body; 15540 15541 if (!node) { 15542 *body = NEW_NIL(); 15543 return; 15544 } 15545 #define subnodes(n1, n2) \ 15546 ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \ 15547 (!node->n2) ? (body = &node->n1, 1) : \ 15548 (reduce_nodes(&node->n1), body = &node->n2, 1)) 15549 15550 while (node) { 15551 int newline = (int)(node->flags & NODE_FL_NEWLINE); 15552 switch (nd_type(node)) { 15553 end: 15554 case NODE_NIL: 15555 *body = 0; 15556 return; 15557 case NODE_RETURN: 15558 *body = node = node->nd_stts; 15559 if (newline && node) node->flags |= NODE_FL_NEWLINE; 15560 continue; 15561 case NODE_BEGIN: 15562 *body = node = node->nd_body; 15563 if (newline && node) node->flags |= NODE_FL_NEWLINE; 15564 continue; 15565 case NODE_BLOCK: 15566 body = &node->nd_end->nd_head; 15567 break; 15568 case NODE_IF: 15569 if (subnodes(nd_body, nd_else)) break; 15570 return; 15571 case NODE_CASE: 15572 body = &node->nd_body; 15573 break; 15574 case NODE_WHEN: 15575 if (!subnodes(nd_body, nd_next)) goto end; 15576 break; 15577 case NODE_ENSURE: 15578 if (!subnodes(nd_head, nd_resq)) goto end; 15579 break; 15580 case NODE_RESCUE: 15581 if (node->nd_else) { 15582 body = &node->nd_resq; 15583 break; 15584 } 15585 if (!subnodes(nd_head, nd_resq)) goto end; 15586 break; 15587 default: 15588 return; 15589 } 15590 node = *body; 15591 if (newline && node) node->flags |= NODE_FL_NEWLINE; 15592 } 15593 15594 #undef subnodes 15595 } 15596 15597 static int 15598 is_static_content(NODE *node) 15599 { 15600 if (!node) return 1; 15601 switch (nd_type(node)) { 15602 case NODE_HASH: 15603 if (!(node = node->nd_head)) break; 15604 case NODE_ARRAY: 15605 do { 15606 if (!is_static_content(node->nd_head)) return 0; 15607 } while ((node = node->nd_next) != 0); 15608 case NODE_LIT: 15609 case NODE_STR: 15610 case NODE_NIL: 15611 case NODE_TRUE: 15612 case NODE_FALSE: 15613 case NODE_ZARRAY: 15614 break; 15615 default: 15616 return 0; 15617 } 15618 return 1; 15619 } 15620 15621 static int 15622 assign_in_cond(struct parser_params *parser, NODE *node) 15623 { 15624 switch (nd_type(node)) { 15625 case NODE_MASGN: 15626 yyerror("multiple assignment in conditional"); 15627 return 1; 15628 15629 case NODE_LASGN: 15630 case NODE_DASGN: 15631 case NODE_DASGN_CURR: 15632 case NODE_GASGN: 15633 case NODE_IASGN: 15634 break; 15635 15636 default: 15637 return 0; 15638 } 15639 15640 if (!node->nd_value) return 1; 15641 if (is_static_content(node->nd_value)) { 15642 /* reports always */ 15643 parser_warn(node->nd_value, "found = in conditional, should be =="); 15644 } 15645 return 1; 15646 } 15647 15648 static void 15649 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str) 15650 { 15651 if (!e_option_supplied(parser)) parser_warn(node, str); 15652 } 15653 15654 static void 15655 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str) 15656 { 15657 if (!e_option_supplied(parser)) parser_warning(node, str); 15658 } 15659 15660 static void 15661 fixup_nodes(NODE **rootnode) 15662 { 15663 NODE *node, *next, *head; 15664 15665 for (node = *rootnode; node; node = next) { 15666 enum node_type type; 15667 VALUE val; 15668 15669 next = node->nd_next; 15670 head = node->nd_head; 15671 rb_gc_force_recycle((VALUE)node); 15672 *rootnode = next; 15673 switch (type = nd_type(head)) { 15674 case NODE_DOT2: 15675 case NODE_DOT3: 15676 val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit, 15677 type == NODE_DOT3); 15678 rb_gc_force_recycle((VALUE)head->nd_beg); 15679 rb_gc_force_recycle((VALUE)head->nd_end); 15680 nd_set_type(head, NODE_LIT); 15681 head->nd_lit = val; 15682 break; 15683 default: 15684 break; 15685 } 15686 } 15687 } 15688 15689 static NODE *cond0(struct parser_params*,NODE*); 15690 15691 static NODE* 15692 range_op(struct parser_params *parser, NODE *node) 15693 { 15694 enum node_type type; 15695 15696 if (node == 0) return 0; 15697 15698 type = nd_type(node); 15699 value_expr(node); 15700 if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) { 15701 warn_unless_e_option(parser, node, "integer literal in conditional range"); 15702 return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$.")))); 15703 } 15704 return cond0(parser, node); 15705 } 15706 15707 static int 15708 literal_node(NODE *node) 15709 { 15710 if (!node) return 1; /* same as NODE_NIL */ 15711 switch (nd_type(node)) { 15712 case NODE_LIT: 15713 case NODE_STR: 15714 case NODE_DSTR: 15715 case NODE_EVSTR: 15716 case NODE_DREGX: 15717 case NODE_DREGX_ONCE: 15718 case NODE_DSYM: 15719 return 2; 15720 case NODE_TRUE: 15721 case NODE_FALSE: 15722 case NODE_NIL: 15723 return 1; 15724 } 15725 return 0; 15726 } 15727 15728 static NODE* 15729 cond0(struct parser_params *parser, NODE *node) 15730 { 15731 if (node == 0) return 0; 15732 assign_in_cond(parser, node); 15733 15734 switch (nd_type(node)) { 15735 case NODE_DSTR: 15736 case NODE_EVSTR: 15737 case NODE_STR: 15738 rb_warn0("string literal in condition"); 15739 break; 15740 15741 case NODE_DREGX: 15742 case NODE_DREGX_ONCE: 15743 warning_unless_e_option(parser, node, "regex literal in condition"); 15744 return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_"))); 15745 15746 case NODE_AND: 15747 case NODE_OR: 15748 node->nd_1st = cond0(parser, node->nd_1st); 15749 node->nd_2nd = cond0(parser, node->nd_2nd); 15750 break; 15751 15752 case NODE_DOT2: 15753 case NODE_DOT3: 15754 node->nd_beg = range_op(parser, node->nd_beg); 15755 node->nd_end = range_op(parser, node->nd_end); 15756 if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2); 15757 else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3); 15758 if (!e_option_supplied(parser)) { 15759 int b = literal_node(node->nd_beg); 15760 int e = literal_node(node->nd_end); 15761 if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) { 15762 parser_warn(node, "range literal in condition"); 15763 } 15764 } 15765 break; 15766 15767 case NODE_DSYM: 15768 parser_warning(node, "literal in condition"); 15769 break; 15770 15771 case NODE_LIT: 15772 if (RB_TYPE_P(node->nd_lit, T_REGEXP)) { 15773 warn_unless_e_option(parser, node, "regex literal in condition"); 15774 nd_set_type(node, NODE_MATCH); 15775 } 15776 else { 15777 parser_warning(node, "literal in condition"); 15778 } 15779 default: 15780 break; 15781 } 15782 return node; 15783 } 15784 15785 static NODE* 15786 cond_gen(struct parser_params *parser, NODE *node) 15787 { 15788 if (node == 0) return 0; 15789 return cond0(parser, node); 15790 } 15791 15792 static NODE* 15793 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right) 15794 { 15795 value_expr(left); 15796 if (left && (enum node_type)nd_type(left) == type) { 15797 NODE *node = left, *second; 15798 while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) { 15799 node = second; 15800 } 15801 node->nd_2nd = NEW_NODE(type, second, right, 0); 15802 return left; 15803 } 15804 return NEW_NODE(type, left, right, 0); 15805 } 15806 15807 static void 15808 no_blockarg(struct parser_params *parser, NODE *node) 15809 { 15810 if (node && nd_type(node) == NODE_BLOCK_PASS) { 15811 compile_error(PARSER_ARG "block argument should not be given"); 15812 } 15813 } 15814 15815 static NODE * 15816 ret_args_gen(struct parser_params *parser, NODE *node) 15817 { 15818 if (node) { 15819 no_blockarg(parser, node); 15820 if (nd_type(node) == NODE_ARRAY) { 15821 if (node->nd_next == 0) { 15822 node = node->nd_head; 15823 } 15824 else { 15825 nd_set_type(node, NODE_VALUES); 15826 } 15827 } 15828 } 15829 return node; 15830 } 15831 15832 static NODE * 15833 new_yield_gen(struct parser_params *parser, NODE *node) 15834 { 15835 if (node) no_blockarg(parser, node); 15836 15837 return NEW_YIELD(node); 15838 } 15839 15840 static NODE* 15841 negate_lit(NODE *node) 15842 { 15843 switch (TYPE(node->nd_lit)) { 15844 case T_FIXNUM: 15845 node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit)); 15846 break; 15847 case T_BIGNUM: 15848 node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0); 15849 break; 15850 case T_FLOAT: 15851 #if USE_FLONUM 15852 if (FLONUM_P(node->nd_lit)) { 15853 node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit)); 15854 } 15855 else { 15856 RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit); 15857 } 15858 #else 15859 RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit); 15860 #endif 15861 break; 15862 default: 15863 break; 15864 } 15865 return node; 15866 } 15867 15868 static NODE * 15869 arg_blk_pass(NODE *node1, NODE *node2) 15870 { 15871 if (node2) { 15872 node2->nd_head = node1; 15873 return node2; 15874 } 15875 return node1; 15876 } 15877 15878 15879 static NODE* 15880 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail) 15881 { 15882 int saved_line = ruby_sourceline; 15883 struct rb_args_info *args = tail->nd_ainfo; 15884 15885 args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0; 15886 args->pre_init = m ? m->nd_next : 0; 15887 15888 args->post_args_num = p ? rb_long2int(p->nd_plen) : 0; 15889 args->post_init = p ? p->nd_next : 0; 15890 args->first_post_arg = p ? p->nd_pid : 0; 15891 15892 args->rest_arg = r; 15893 15894 args->opt_args = o; 15895 15896 ruby_sourceline = saved_line; 15897 15898 return tail; 15899 } 15900 15901 static NODE* 15902 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b) 15903 { 15904 int saved_line = ruby_sourceline; 15905 struct rb_args_info *args; 15906 NODE *kw_rest_arg = 0; 15907 NODE *node; 15908 15909 args = ALLOC(struct rb_args_info); 15910 MEMZERO(args, struct rb_args_info, 1); 15911 node = NEW_NODE(NODE_ARGS, 0, 0, args); 15912 15913 args->block_arg = b; 15914 args->kw_args = k; 15915 if (k && !kr) kr = internal_id(); 15916 if (kr) { 15917 arg_var(kr); 15918 kw_rest_arg = NEW_DVAR(kr); 15919 } 15920 args->kw_rest_arg = kw_rest_arg; 15921 15922 ruby_sourceline = saved_line; 15923 return node; 15924 } 15925 15926 static NODE* 15927 dsym_node_gen(struct parser_params *parser, NODE *node) 15928 { 15929 VALUE lit; 15930 15931 if (!node) { 15932 return NEW_LIT(ID2SYM(idNULL)); 15933 } 15934 15935 switch (nd_type(node)) { 15936 case NODE_DSTR: 15937 nd_set_type(node, NODE_DSYM); 15938 break; 15939 case NODE_STR: 15940 lit = node->nd_lit; 15941 node->nd_lit = ID2SYM(rb_intern_str(lit)); 15942 nd_set_type(node, NODE_LIT); 15943 break; 15944 default: 15945 node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node)); 15946 break; 15947 } 15948 return node; 15949 } 15950 #endif /* !RIPPER */ 15951 15952 #ifndef RIPPER 15953 static NODE * 15954 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs) 15955 { 15956 NODE *asgn; 15957 15958 if (lhs) { 15959 ID vid = lhs->nd_vid; 15960 if (op == tOROP) { 15961 lhs->nd_value = rhs; 15962 asgn = NEW_OP_ASGN_OR(gettable(vid), lhs); 15963 if (is_asgn_or_id(vid)) { 15964 asgn->nd_aid = vid; 15965 } 15966 } 15967 else if (op == tANDOP) { 15968 lhs->nd_value = rhs; 15969 asgn = NEW_OP_ASGN_AND(gettable(vid), lhs); 15970 } 15971 else { 15972 asgn = lhs; 15973 asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs)); 15974 } 15975 } 15976 else { 15977 asgn = NEW_BEGIN(0); 15978 } 15979 return asgn; 15980 } 15981 15982 static NODE * 15983 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs) 15984 { 15985 NODE *asgn; 15986 15987 if (op == tOROP) { 15988 op = 0; 15989 } 15990 else if (op == tANDOP) { 15991 op = 1; 15992 } 15993 asgn = NEW_OP_ASGN2(lhs, attr, op, rhs); 15994 fixpos(asgn, lhs); 15995 return asgn; 15996 } 15997 15998 static NODE * 15999 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs) 16000 { 16001 NODE *asgn; 16002 16003 if (op == tOROP) { 16004 op = 0; 16005 } 16006 else if (op == tANDOP) { 16007 op = 1; 16008 } 16009 if (lhs) { 16010 asgn = NEW_OP_CDECL(lhs, op, rhs); 16011 } 16012 else { 16013 asgn = NEW_BEGIN(0); 16014 } 16015 fixpos(asgn, lhs); 16016 return asgn; 16017 } 16018 #else 16019 static VALUE 16020 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs) 16021 { 16022 return dispatch3(opassign, lhs, op, rhs); 16023 } 16024 16025 static VALUE 16026 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs) 16027 { 16028 VALUE recv = dispatch3(field, lhs, type, attr); 16029 return dispatch3(opassign, recv, op, rhs); 16030 } 16031 #endif 16032 16033 static void 16034 warn_unused_var(struct parser_params *parser, struct local_vars *local) 16035 { 16036 int i, cnt; 16037 ID *v, *u; 16038 16039 if (!local->used) return; 16040 v = local->vars->tbl; 16041 u = local->used->tbl; 16042 cnt = local->used->pos; 16043 if (cnt != local->vars->pos) { 16044 rb_bug("local->used->pos != local->vars->pos"); 16045 } 16046 for (i = 0; i < cnt; ++i) { 16047 if (!v[i] || (u[i] & LVAR_USED)) continue; 16048 if (is_private_local_id(v[i])) continue; 16049 rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i])); 16050 } 16051 } 16052 16053 static void 16054 local_push_gen(struct parser_params *parser, int inherit_dvars) 16055 { 16056 struct local_vars *local; 16057 16058 local = ALLOC(struct local_vars); 16059 local->prev = lvtbl; 16060 local->args = vtable_alloc(0); 16061 local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE); 16062 local->used = !(inherit_dvars && 16063 (ifndef_ripper(compile_for_eval || e_option_supplied(parser))+0)) && 16064 RTEST(ruby_verbose) ? vtable_alloc(0) : 0; 16065 local->cmdargs = cmdarg_stack; 16066 cmdarg_stack = 0; 16067 lvtbl = local; 16068 } 16069 16070 static void 16071 local_pop_gen(struct parser_params *parser) 16072 { 16073 struct local_vars *local = lvtbl->prev; 16074 if (lvtbl->used) { 16075 warn_unused_var(parser, lvtbl); 16076 vtable_free(lvtbl->used); 16077 } 16078 vtable_free(lvtbl->args); 16079 vtable_free(lvtbl->vars); 16080 cmdarg_stack = lvtbl->cmdargs; 16081 xfree(lvtbl); 16082 lvtbl = local; 16083 } 16084 16085 #ifndef RIPPER 16086 static ID* 16087 local_tbl_gen(struct parser_params *parser) 16088 { 16089 int cnt_args = vtable_size(lvtbl->args); 16090 int cnt_vars = vtable_size(lvtbl->vars); 16091 int cnt = cnt_args + cnt_vars; 16092 int i, j; 16093 ID *buf; 16094 16095 if (cnt <= 0) return 0; 16096 buf = ALLOC_N(ID, cnt + 1); 16097 MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args); 16098 /* remove IDs duplicated to warn shadowing */ 16099 for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) { 16100 ID id = lvtbl->vars->tbl[i]; 16101 if (!vtable_included(lvtbl->args, id)) { 16102 buf[j++] = id; 16103 } 16104 } 16105 if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1); 16106 buf[0] = cnt; 16107 return buf; 16108 } 16109 #endif 16110 16111 static int 16112 arg_var_gen(struct parser_params *parser, ID id) 16113 { 16114 vtable_add(lvtbl->args, id); 16115 return vtable_size(lvtbl->args) - 1; 16116 } 16117 16118 static int 16119 local_var_gen(struct parser_params *parser, ID id) 16120 { 16121 vtable_add(lvtbl->vars, id); 16122 if (lvtbl->used) { 16123 vtable_add(lvtbl->used, (ID)ruby_sourceline); 16124 } 16125 return vtable_size(lvtbl->vars) - 1; 16126 } 16127 16128 static int 16129 local_id_gen(struct parser_params *parser, ID id) 16130 { 16131 struct vtable *vars, *args, *used; 16132 16133 vars = lvtbl->vars; 16134 args = lvtbl->args; 16135 used = lvtbl->used; 16136 16137 while (vars && POINTER_P(vars->prev)) { 16138 vars = vars->prev; 16139 args = args->prev; 16140 if (used) used = used->prev; 16141 } 16142 16143 if (vars && vars->prev == DVARS_INHERIT) { 16144 return rb_local_defined(id); 16145 } 16146 else if (vtable_included(args, id)) { 16147 return 1; 16148 } 16149 else { 16150 int i = vtable_included(vars, id); 16151 if (i && used) used->tbl[i-1] |= LVAR_USED; 16152 return i != 0; 16153 } 16154 } 16155 16156 static const struct vtable * 16157 dyna_push_gen(struct parser_params *parser) 16158 { 16159 lvtbl->args = vtable_alloc(lvtbl->args); 16160 lvtbl->vars = vtable_alloc(lvtbl->vars); 16161 if (lvtbl->used) { 16162 lvtbl->used = vtable_alloc(lvtbl->used); 16163 } 16164 return lvtbl->args; 16165 } 16166 16167 static void 16168 dyna_pop_1(struct parser_params *parser) 16169 { 16170 struct vtable *tmp; 16171 16172 if ((tmp = lvtbl->used) != 0) { 16173 warn_unused_var(parser, lvtbl); 16174 lvtbl->used = lvtbl->used->prev; 16175 vtable_free(tmp); 16176 } 16177 tmp = lvtbl->args; 16178 lvtbl->args = lvtbl->args->prev; 16179 vtable_free(tmp); 16180 tmp = lvtbl->vars; 16181 lvtbl->vars = lvtbl->vars->prev; 16182 vtable_free(tmp); 16183 } 16184 16185 static void 16186 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs) 16187 { 16188 while (lvtbl->args != lvargs) { 16189 dyna_pop_1(parser); 16190 if (!lvtbl->args) { 16191 struct local_vars *local = lvtbl->prev; 16192 xfree(lvtbl); 16193 lvtbl = local; 16194 } 16195 } 16196 dyna_pop_1(parser); 16197 } 16198 16199 static int 16200 dyna_in_block_gen(struct parser_params *parser) 16201 { 16202 return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE; 16203 } 16204 16205 static int 16206 dvar_defined_gen(struct parser_params *parser, ID id, int get) 16207 { 16208 struct vtable *vars, *args, *used; 16209 int i; 16210 16211 args = lvtbl->args; 16212 vars = lvtbl->vars; 16213 used = lvtbl->used; 16214 16215 while (POINTER_P(vars)) { 16216 if (vtable_included(args, id)) { 16217 return 1; 16218 } 16219 if ((i = vtable_included(vars, id)) != 0) { 16220 if (used) used->tbl[i-1] |= LVAR_USED; 16221 return 1; 16222 } 16223 args = args->prev; 16224 vars = vars->prev; 16225 if (get) used = 0; 16226 if (used) used = used->prev; 16227 } 16228 16229 if (vars == DVARS_INHERIT) { 16230 return rb_dvar_defined(id); 16231 } 16232 16233 return 0; 16234 } 16235 16236 static int 16237 dvar_curr_gen(struct parser_params *parser, ID id) 16238 { 16239 return (vtable_included(lvtbl->args, id) || 16240 vtable_included(lvtbl->vars, id)); 16241 } 16242 16243 #ifndef RIPPER 16244 static void 16245 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options) 16246 { 16247 int c = RE_OPTION_ENCODING_IDX(options); 16248 16249 if (c) { 16250 int opt, idx; 16251 rb_char_to_option_kcode(c, &opt, &idx); 16252 if (idx != ENCODING_GET(str) && 16253 rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) { 16254 goto error; 16255 } 16256 ENCODING_SET(str, idx); 16257 } 16258 else if (RE_OPTION_ENCODING_NONE(options)) { 16259 if (!ENCODING_IS_ASCII8BIT(str) && 16260 rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) { 16261 c = 'n'; 16262 goto error; 16263 } 16264 rb_enc_associate(str, rb_ascii8bit_encoding()); 16265 } 16266 else if (current_enc == rb_usascii_encoding()) { 16267 if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) { 16268 /* raise in re.c */ 16269 rb_enc_associate(str, rb_usascii_encoding()); 16270 } 16271 else { 16272 rb_enc_associate(str, rb_ascii8bit_encoding()); 16273 } 16274 } 16275 return; 16276 16277 error: 16278 compile_error(PARSER_ARG 16279 "regexp encoding option '%c' differs from source encoding '%s'", 16280 c, rb_enc_name(rb_enc_get(str))); 16281 } 16282 16283 static int 16284 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options) 16285 { 16286 VALUE err; 16287 reg_fragment_setenc(str, options); 16288 err = rb_reg_check_preprocess(str); 16289 if (err != Qnil) { 16290 err = rb_obj_as_string(err); 16291 compile_error(PARSER_ARG "%s", RSTRING_PTR(err)); 16292 RB_GC_GUARD(err); 16293 return 0; 16294 } 16295 return 1; 16296 } 16297 16298 typedef struct { 16299 struct parser_params* parser; 16300 rb_encoding *enc; 16301 NODE *succ_block; 16302 NODE *fail_block; 16303 int num; 16304 } reg_named_capture_assign_t; 16305 16306 static int 16307 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end, 16308 int back_num, int *back_refs, OnigRegex regex, void *arg0) 16309 { 16310 reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0; 16311 struct parser_params* parser = arg->parser; 16312 rb_encoding *enc = arg->enc; 16313 long len = name_end - name; 16314 const char *s = (const char *)name; 16315 ID var; 16316 16317 arg->num++; 16318 16319 if (arg->succ_block == 0) { 16320 arg->succ_block = NEW_BEGIN(0); 16321 arg->fail_block = NEW_BEGIN(0); 16322 } 16323 16324 if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) || 16325 (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) || 16326 !rb_enc_symname2_p(s, len, enc)) { 16327 return ST_CONTINUE; 16328 } 16329 var = rb_intern3(s, len, enc); 16330 if (dvar_defined(var) || local_id(var)) { 16331 rb_warningS("named capture conflicts a local variable - %s", 16332 rb_id2name(var)); 16333 } 16334 arg->succ_block = block_append(arg->succ_block, 16335 newline_node(node_assign(assignable(var,0), 16336 NEW_CALL( 16337 gettable(rb_intern("$~")), 16338 idAREF, 16339 NEW_LIST(NEW_LIT(ID2SYM(var)))) 16340 ))); 16341 arg->fail_block = block_append(arg->fail_block, 16342 newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil)))); 16343 return ST_CONTINUE; 16344 } 16345 16346 static NODE * 16347 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match) 16348 { 16349 reg_named_capture_assign_t arg; 16350 16351 arg.parser = parser; 16352 arg.enc = rb_enc_get(regexp); 16353 arg.succ_block = 0; 16354 arg.fail_block = 0; 16355 arg.num = 0; 16356 onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg); 16357 16358 if (arg.num == 0) 16359 return match; 16360 16361 return 16362 block_append( 16363 newline_node(match), 16364 NEW_IF(gettable(rb_intern("$~")), 16365 block_append( 16366 newline_node(arg.succ_block), 16367 newline_node( 16368 NEW_CALL( 16369 gettable(rb_intern("$~")), 16370 rb_intern("begin"), 16371 NEW_LIST(NEW_LIT(INT2FIX(0)))))), 16372 block_append( 16373 newline_node(arg.fail_block), 16374 newline_node( 16375 NEW_LIT(Qnil))))); 16376 } 16377 16378 static VALUE 16379 reg_compile_gen(struct parser_params* parser, VALUE str, int options) 16380 { 16381 VALUE re; 16382 VALUE err; 16383 16384 reg_fragment_setenc(str, options); 16385 err = rb_errinfo(); 16386 re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline); 16387 if (NIL_P(re)) { 16388 ID mesg = rb_intern("mesg"); 16389 VALUE m = rb_attr_get(rb_errinfo(), mesg); 16390 rb_set_errinfo(err); 16391 if (!NIL_P(err)) { 16392 rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m); 16393 } 16394 else { 16395 compile_error(PARSER_ARG "%s", RSTRING_PTR(m)); 16396 } 16397 return Qnil; 16398 } 16399 return re; 16400 } 16401 16402 void 16403 rb_gc_mark_parser(void) 16404 { 16405 } 16406 16407 NODE* 16408 rb_parser_append_print(VALUE vparser, NODE *node) 16409 { 16410 NODE *prelude = 0; 16411 NODE *scope = node; 16412 struct parser_params *parser; 16413 16414 if (!node) return node; 16415 16416 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser); 16417 16418 node = node->nd_body; 16419 16420 if (nd_type(node) == NODE_PRELUDE) { 16421 prelude = node; 16422 node = node->nd_body; 16423 } 16424 16425 node = block_append(node, 16426 NEW_FCALL(rb_intern("print"), 16427 NEW_ARRAY(NEW_GVAR(rb_intern("$_"))))); 16428 if (prelude) { 16429 prelude->nd_body = node; 16430 scope->nd_body = prelude; 16431 } 16432 else { 16433 scope->nd_body = node; 16434 } 16435 16436 return scope; 16437 } 16438 16439 NODE * 16440 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split) 16441 { 16442 NODE *prelude = 0; 16443 NODE *scope = node; 16444 struct parser_params *parser; 16445 16446 if (!node) return node; 16447 16448 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser); 16449 16450 node = node->nd_body; 16451 16452 if (nd_type(node) == NODE_PRELUDE) { 16453 prelude = node; 16454 node = node->nd_body; 16455 } 16456 if (split) { 16457 node = block_append(NEW_GASGN(rb_intern("$F"), 16458 NEW_CALL(NEW_GVAR(rb_intern("$_")), 16459 rb_intern("split"), 0)), 16460 node); 16461 } 16462 if (chop) { 16463 node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")), 16464 rb_intern("chop!"), 0), node); 16465 } 16466 16467 node = NEW_OPT_N(node); 16468 16469 if (prelude) { 16470 prelude->nd_body = node; 16471 scope->nd_body = prelude; 16472 } 16473 else { 16474 scope->nd_body = node; 16475 } 16476 16477 return scope; 16478 } 16479 16480 static const struct { 16481 ID token; 16482 const char *name; 16483 } op_tbl[] = { 16484 {tDOT2, ".."}, 16485 {tDOT3, "..."}, 16486 {tPOW, "**"}, 16487 {tDSTAR, "**"}, 16488 {tUPLUS, "+@"}, 16489 {tUMINUS, "-@"}, 16490 {tCMP, "<=>"}, 16491 {tGEQ, ">="}, 16492 {tLEQ, "<="}, 16493 {tEQ, "=="}, 16494 {tEQQ, "==="}, 16495 {tNEQ, "!="}, 16496 {tMATCH, "=~"}, 16497 {tNMATCH, "!~"}, 16498 {tAREF, "[]"}, 16499 {tASET, "[]="}, 16500 {tLSHFT, "<<"}, 16501 {tRSHFT, ">>"}, 16502 {tCOLON2, "::"}, 16503 }; 16504 16505 #define op_tbl_count numberof(op_tbl) 16506 16507 #ifndef ENABLE_SELECTOR_NAMESPACE 16508 #define ENABLE_SELECTOR_NAMESPACE 0 16509 #endif 16510 16511 static struct symbols { 16512 ID last_id; 16513 st_table *sym_id; 16514 st_table *id_str; 16515 #if ENABLE_SELECTOR_NAMESPACE 16516 st_table *ivar2_id; 16517 st_table *id_ivar2; 16518 #endif 16519 VALUE op_sym[tLAST_OP_ID]; 16520 } global_symbols = {tLAST_TOKEN}; 16521 16522 static const struct st_hash_type symhash = { 16523 rb_str_hash_cmp, 16524 rb_str_hash, 16525 }; 16526 16527 #if ENABLE_SELECTOR_NAMESPACE 16528 struct ivar2_key { 16529 ID id; 16530 VALUE klass; 16531 }; 16532 16533 static int 16534 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2) 16535 { 16536 if (key1->id == key2->id && key1->klass == key2->klass) { 16537 return 0; 16538 } 16539 return 1; 16540 } 16541 16542 static int 16543 ivar2_hash(struct ivar2_key *key) 16544 { 16545 return (key->id << 8) ^ (key->klass >> 2); 16546 } 16547 16548 static const struct st_hash_type ivar2_hash_type = { 16549 ivar2_cmp, 16550 ivar2_hash, 16551 }; 16552 #endif 16553 16554 void 16555 Init_sym(void) 16556 { 16557 global_symbols.sym_id = st_init_table_with_size(&symhash, 1000); 16558 global_symbols.id_str = st_init_numtable_with_size(1000); 16559 #if ENABLE_SELECTOR_NAMESPACE 16560 global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000); 16561 global_symbols.id_ivar2 = st_init_numtable_with_size(1000); 16562 #endif 16563 16564 (void)nodetype; 16565 (void)nodeline; 16566 #if PARSER_DEBUG 16567 (void)lex_state_name(-1); 16568 #endif 16569 16570 Init_id(); 16571 } 16572 16573 void 16574 rb_gc_mark_symbols(void) 16575 { 16576 rb_mark_tbl(global_symbols.id_str); 16577 rb_gc_mark_locations(global_symbols.op_sym, 16578 global_symbols.op_sym + numberof(global_symbols.op_sym)); 16579 } 16580 #endif /* !RIPPER */ 16581 16582 static ID 16583 internal_id_gen(struct parser_params *parser) 16584 { 16585 ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars); 16586 id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1; 16587 return ID_INTERNAL | (id << ID_SCOPE_SHIFT); 16588 } 16589 16590 #ifndef RIPPER 16591 static int 16592 is_special_global_name(const char *m, const char *e, rb_encoding *enc) 16593 { 16594 int mb = 0; 16595 16596 if (m >= e) return 0; 16597 if (is_global_name_punct(*m)) { 16598 ++m; 16599 } 16600 else if (*m == '-') { 16601 ++m; 16602 if (m < e && is_identchar(m, e, enc)) { 16603 if (!ISASCII(*m)) mb = 1; 16604 m += rb_enc_mbclen(m, e, enc); 16605 } 16606 } 16607 else { 16608 if (!rb_enc_isdigit(*m, enc)) return 0; 16609 do { 16610 if (!ISASCII(*m)) mb = 1; 16611 ++m; 16612 } while (m < e && rb_enc_isdigit(*m, enc)); 16613 } 16614 return m == e ? mb + 1 : 0; 16615 } 16616 16617 int 16618 rb_symname_p(const char *name) 16619 { 16620 return rb_enc_symname_p(name, rb_ascii8bit_encoding()); 16621 } 16622 16623 int 16624 rb_enc_symname_p(const char *name, rb_encoding *enc) 16625 { 16626 return rb_enc_symname2_p(name, strlen(name), enc); 16627 } 16628 16629 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST)) 16630 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<(1<<ID_SCOPE_SHIFT)) & ~(1U<<ID_ATTRSET)) 16631 16632 static int 16633 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_atttset) 16634 { 16635 const char *m = name; 16636 const char *e = m + len; 16637 int type = ID_JUNK; 16638 16639 if (!m || len <= 0) return -1; 16640 switch (*m) { 16641 case '\0': 16642 return -1; 16643 16644 case '$': 16645 type = ID_GLOBAL; 16646 if (is_special_global_name(++m, e, enc)) return type; 16647 goto id; 16648 16649 case '@': 16650 type = ID_INSTANCE; 16651 if (*++m == '@') { 16652 ++m; 16653 type = ID_CLASS; 16654 } 16655 goto id; 16656 16657 case '<': 16658 switch (*++m) { 16659 case '<': ++m; break; 16660 case '=': if (*++m == '>') ++m; break; 16661 default: break; 16662 } 16663 break; 16664 16665 case '>': 16666 switch (*++m) { 16667 case '>': case '=': ++m; break; 16668 } 16669 break; 16670 16671 case '=': 16672 switch (*++m) { 16673 case '~': ++m; break; 16674 case '=': if (*++m == '=') ++m; break; 16675 default: return -1; 16676 } 16677 break; 16678 16679 case '*': 16680 if (*++m == '*') ++m; 16681 break; 16682 16683 case '+': case '-': 16684 if (*++m == '@') ++m; 16685 break; 16686 16687 case '|': case '^': case '&': case '/': case '%': case '~': case '`': 16688 ++m; 16689 break; 16690 16691 case '[': 16692 if (*++m != ']') return -1; 16693 if (*++m == '=') ++m; 16694 break; 16695 16696 case '!': 16697 if (len == 1) return ID_JUNK; 16698 switch (*++m) { 16699 case '=': case '~': ++m; break; 16700 default: return -1; 16701 } 16702 break; 16703 16704 default: 16705 type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL; 16706 id: 16707 if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m))) 16708 return -1; 16709 while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc); 16710 if (m >= e) break; 16711 switch (*m) { 16712 case '!': case '?': 16713 if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1; 16714 type = ID_JUNK; 16715 ++m; 16716 if (m + 1 < e || *m != '=') break; 16717 /* fall through */ 16718 case '=': 16719 if (!(allowed_atttset & (1U << type))) return -1; 16720 type = ID_ATTRSET; 16721 ++m; 16722 break; 16723 } 16724 break; 16725 } 16726 return m == e ? type : -1; 16727 } 16728 16729 int 16730 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc) 16731 { 16732 return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1; 16733 } 16734 16735 static int 16736 rb_str_symname_type(VALUE name, unsigned int allowed_atttset) 16737 { 16738 const char *ptr = StringValuePtr(name); 16739 long len = RSTRING_LEN(name); 16740 int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_atttset); 16741 RB_GC_GUARD(name); 16742 return type; 16743 } 16744 16745 static ID 16746 register_symid(ID id, const char *name, long len, rb_encoding *enc) 16747 { 16748 VALUE str = rb_enc_str_new(name, len, enc); 16749 return register_symid_str(id, str); 16750 } 16751 16752 static ID 16753 register_symid_str(ID id, VALUE str) 16754 { 16755 OBJ_FREEZE(str); 16756 st_add_direct(global_symbols.sym_id, (st_data_t)str, id); 16757 st_add_direct(global_symbols.id_str, id, (st_data_t)str); 16758 return id; 16759 } 16760 16761 static int 16762 sym_check_asciionly(VALUE str) 16763 { 16764 if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE; 16765 switch (rb_enc_str_coderange(str)) { 16766 case ENC_CODERANGE_BROKEN: 16767 rb_raise(rb_eEncodingError, "invalid encoding symbol"); 16768 case ENC_CODERANGE_7BIT: 16769 return TRUE; 16770 } 16771 return FALSE; 16772 } 16773 16774 /* 16775 * _str_ itself will be registered at the global symbol table. _str_ 16776 * can be modified before the registration, since the encoding will be 16777 * set to ASCII-8BIT if it is a special global name. 16778 */ 16779 static ID intern_str(VALUE str); 16780 16781 ID 16782 rb_intern3(const char *name, long len, rb_encoding *enc) 16783 { 16784 VALUE str; 16785 st_data_t data; 16786 struct RString fake_str; 16787 fake_str.basic.flags = T_STRING|RSTRING_NOEMBED; 16788 fake_str.basic.klass = rb_cString; 16789 fake_str.as.heap.len = len; 16790 fake_str.as.heap.ptr = (char *)name; 16791 fake_str.as.heap.aux.capa = len; 16792 str = (VALUE)&fake_str; 16793 rb_enc_associate(str, enc); 16794 OBJ_FREEZE(str); 16795 16796 if (st_lookup(global_symbols.sym_id, str, &data)) 16797 return (ID)data; 16798 16799 str = rb_enc_str_new(name, len, enc); /* make true string */ 16800 return intern_str(str); 16801 } 16802 16803 static ID 16804 intern_str(VALUE str) 16805 { 16806 const char *name, *m, *e; 16807 long len, last; 16808 rb_encoding *enc, *symenc; 16809 unsigned char c; 16810 ID id; 16811 int mb; 16812 16813 RSTRING_GETMEM(str, name, len); 16814 m = name; 16815 e = m + len; 16816 enc = rb_enc_get(str); 16817 symenc = enc; 16818 16819 if (!len || (rb_cString && !rb_enc_asciicompat(enc))) { 16820 junk: 16821 id = ID_JUNK; 16822 goto new_id; 16823 } 16824 last = len-1; 16825 id = 0; 16826 switch (*m) { 16827 case '$': 16828 if (len < 2) goto junk; 16829 id |= ID_GLOBAL; 16830 if ((mb = is_special_global_name(++m, e, enc)) != 0) { 16831 if (!--mb) symenc = rb_usascii_encoding(); 16832 goto new_id; 16833 } 16834 break; 16835 case '@': 16836 if (m[1] == '@') { 16837 if (len < 3) goto junk; 16838 m++; 16839 id |= ID_CLASS; 16840 } 16841 else { 16842 if (len < 2) goto junk; 16843 id |= ID_INSTANCE; 16844 } 16845 m++; 16846 break; 16847 default: 16848 c = m[0]; 16849 if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) { 16850 /* operators */ 16851 int i; 16852 16853 if (len == 1) { 16854 id = c; 16855 goto id_register; 16856 } 16857 for (i = 0; i < op_tbl_count; i++) { 16858 if (*op_tbl[i].name == *m && 16859 strcmp(op_tbl[i].name, m) == 0) { 16860 id = op_tbl[i].token; 16861 goto id_register; 16862 } 16863 } 16864 } 16865 break; 16866 } 16867 if (name[last] == '=') { 16868 /* attribute assignment */ 16869 if (last > 1 && name[last-1] == '=') 16870 goto junk; 16871 id = rb_intern3(name, last, enc); 16872 if (id > tLAST_OP_ID && !is_attrset_id(id)) { 16873 enc = rb_enc_get(rb_id2str(id)); 16874 id = rb_id_attrset(id); 16875 goto id_register; 16876 } 16877 id = ID_ATTRSET; 16878 } 16879 else if (id == 0) { 16880 if (rb_enc_isupper(m[0], enc)) { 16881 id = ID_CONST; 16882 } 16883 else { 16884 id = ID_LOCAL; 16885 } 16886 } 16887 if (!rb_enc_isdigit(*m, enc)) { 16888 while (m <= name + last && is_identchar(m, e, enc)) { 16889 if (ISASCII(*m)) { 16890 m++; 16891 } 16892 else { 16893 m += rb_enc_mbclen(m, e, enc); 16894 } 16895 } 16896 } 16897 if (id != ID_ATTRSET && m - name < len) id = ID_JUNK; 16898 if (sym_check_asciionly(str)) symenc = rb_usascii_encoding(); 16899 new_id: 16900 if (symenc != enc) rb_enc_associate(str, symenc); 16901 if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) { 16902 if (len > 20) { 16903 rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)", 16904 name); 16905 } 16906 else { 16907 rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)", 16908 (int)len, name); 16909 } 16910 } 16911 id |= ++global_symbols.last_id << ID_SCOPE_SHIFT; 16912 id_register: 16913 return register_symid_str(id, str); 16914 } 16915 16916 ID 16917 rb_intern2(const char *name, long len) 16918 { 16919 return rb_intern3(name, len, rb_usascii_encoding()); 16920 } 16921 16922 #undef rb_intern 16923 ID 16924 rb_intern(const char *name) 16925 { 16926 return rb_intern2(name, strlen(name)); 16927 } 16928 16929 ID 16930 rb_intern_str(VALUE str) 16931 { 16932 st_data_t id; 16933 16934 if (st_lookup(global_symbols.sym_id, str, &id)) 16935 return (ID)id; 16936 return intern_str(rb_str_dup(str)); 16937 } 16938 16939 VALUE 16940 rb_id2str(ID id) 16941 { 16942 st_data_t data; 16943 16944 if (id < tLAST_TOKEN) { 16945 int i = 0; 16946 16947 if (id < INT_MAX && rb_ispunct((int)id)) { 16948 VALUE str = global_symbols.op_sym[i = (int)id]; 16949 if (!str) { 16950 char name[2]; 16951 name[0] = (char)id; 16952 name[1] = 0; 16953 str = rb_usascii_str_new(name, 1); 16954 OBJ_FREEZE(str); 16955 global_symbols.op_sym[i] = str; 16956 } 16957 return str; 16958 } 16959 for (i = 0; i < op_tbl_count; i++) { 16960 if (op_tbl[i].token == id) { 16961 VALUE str = global_symbols.op_sym[i]; 16962 if (!str) { 16963 str = rb_usascii_str_new2(op_tbl[i].name); 16964 OBJ_FREEZE(str); 16965 global_symbols.op_sym[i] = str; 16966 } 16967 return str; 16968 } 16969 } 16970 } 16971 16972 if (st_lookup(global_symbols.id_str, id, &data)) { 16973 VALUE str = (VALUE)data; 16974 if (RBASIC(str)->klass == 0) 16975 RBASIC(str)->klass = rb_cString; 16976 return str; 16977 } 16978 16979 if (is_attrset_id(id)) { 16980 ID id_stem = (id & ~ID_SCOPE_MASK); 16981 VALUE str; 16982 16983 do { 16984 if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break; 16985 if (!!(str = rb_id2str(id_stem | ID_CONST))) break; 16986 if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break; 16987 if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break; 16988 if (!!(str = rb_id2str(id_stem | ID_CLASS))) break; 16989 if (!!(str = rb_id2str(id_stem | ID_JUNK))) break; 16990 return 0; 16991 } while (0); 16992 str = rb_str_dup(str); 16993 rb_str_cat(str, "=", 1); 16994 register_symid_str(id, str); 16995 if (st_lookup(global_symbols.id_str, id, &data)) { 16996 VALUE str = (VALUE)data; 16997 if (RBASIC(str)->klass == 0) 16998 RBASIC(str)->klass = rb_cString; 16999 return str; 17000 } 17001 } 17002 return 0; 17003 } 17004 17005 const char * 17006 rb_id2name(ID id) 17007 { 17008 VALUE str = rb_id2str(id); 17009 17010 if (!str) return 0; 17011 return RSTRING_PTR(str); 17012 } 17013 17014 static int 17015 symbols_i(VALUE sym, ID value, VALUE ary) 17016 { 17017 rb_ary_push(ary, ID2SYM(value)); 17018 return ST_CONTINUE; 17019 } 17020 17021 /* 17022 * call-seq: 17023 * Symbol.all_symbols => array 17024 * 17025 * Returns an array of all the symbols currently in Ruby's symbol 17026 * table. 17027 * 17028 * Symbol.all_symbols.size #=> 903 17029 * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink, 17030 * :chown, :EOFError, :$;, :String, 17031 * :LOCK_SH, :"setuid?", :$<, 17032 * :default_proc, :compact, :extend, 17033 * :Tms, :getwd, :$=, :ThreadGroup, 17034 * :wait2, :$>] 17035 */ 17036 17037 VALUE 17038 rb_sym_all_symbols(void) 17039 { 17040 VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries); 17041 17042 st_foreach(global_symbols.sym_id, symbols_i, ary); 17043 return ary; 17044 } 17045 17046 int 17047 rb_is_const_id(ID id) 17048 { 17049 return is_const_id(id); 17050 } 17051 17052 int 17053 rb_is_class_id(ID id) 17054 { 17055 return is_class_id(id); 17056 } 17057 17058 int 17059 rb_is_global_id(ID id) 17060 { 17061 return is_global_id(id); 17062 } 17063 17064 int 17065 rb_is_instance_id(ID id) 17066 { 17067 return is_instance_id(id); 17068 } 17069 17070 int 17071 rb_is_attrset_id(ID id) 17072 { 17073 return is_attrset_id(id); 17074 } 17075 17076 int 17077 rb_is_local_id(ID id) 17078 { 17079 return is_local_id(id); 17080 } 17081 17082 int 17083 rb_is_junk_id(ID id) 17084 { 17085 return is_junk_id(id); 17086 } 17087 17099 ID 17100 rb_check_id(volatile VALUE *namep) 17101 { 17102 st_data_t id; 17103 VALUE tmp; 17104 VALUE name = *namep; 17105 17106 if (SYMBOL_P(name)) { 17107 return SYM2ID(name); 17108 } 17109 else if (!RB_TYPE_P(name, T_STRING)) { 17110 tmp = rb_check_string_type(name); 17111 if (NIL_P(tmp)) { 17112 tmp = rb_inspect(name); 17113 rb_raise(rb_eTypeError, "%s is not a symbol", 17114 RSTRING_PTR(tmp)); 17115 } 17116 name = tmp; 17117 *namep = name; 17118 } 17119 17120 sym_check_asciionly(name); 17121 17122 if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) 17123 return (ID)id; 17124 17125 if (rb_is_attrset_name(name)) { 17126 struct RString fake_str; 17127 const VALUE localname = (VALUE)&fake_str; 17128 /* make local name by chopping '=' */ 17129 fake_str.basic.flags = T_STRING|RSTRING_NOEMBED; 17130 fake_str.basic.klass = rb_cString; 17131 fake_str.as.heap.len = RSTRING_LEN(name) - 1; 17132 fake_str.as.heap.ptr = RSTRING_PTR(name); 17133 fake_str.as.heap.aux.capa = fake_str.as.heap.len; 17134 rb_enc_copy(localname, name); 17135 OBJ_FREEZE(localname); 17136 17137 if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) { 17138 return rb_id_attrset((ID)id); 17139 } 17140 RB_GC_GUARD(name); 17141 } 17142 17143 return (ID)0; 17144 } 17145 17146 ID 17147 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc) 17148 { 17149 st_data_t id; 17150 struct RString fake_str; 17151 const VALUE name = (VALUE)&fake_str; 17152 fake_str.basic.flags = T_STRING|RSTRING_NOEMBED; 17153 fake_str.basic.klass = rb_cString; 17154 fake_str.as.heap.len = len; 17155 fake_str.as.heap.ptr = (char *)ptr; 17156 fake_str.as.heap.aux.capa = len; 17157 rb_enc_associate(name, enc); 17158 17159 sym_check_asciionly(name); 17160 17161 if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) 17162 return (ID)id; 17163 17164 if (rb_is_attrset_name(name)) { 17165 fake_str.as.heap.len = len - 1; 17166 if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) { 17167 return rb_id_attrset((ID)id); 17168 } 17169 } 17170 17171 return (ID)0; 17172 } 17173 17174 int 17175 rb_is_const_name(VALUE name) 17176 { 17177 return rb_str_symname_type(name, 0) == ID_CONST; 17178 } 17179 17180 int 17181 rb_is_class_name(VALUE name) 17182 { 17183 return rb_str_symname_type(name, 0) == ID_CLASS; 17184 } 17185 17186 int 17187 rb_is_global_name(VALUE name) 17188 { 17189 return rb_str_symname_type(name, 0) == ID_GLOBAL; 17190 } 17191 17192 int 17193 rb_is_instance_name(VALUE name) 17194 { 17195 return rb_str_symname_type(name, 0) == ID_INSTANCE; 17196 } 17197 17198 int 17199 rb_is_attrset_name(VALUE name) 17200 { 17201 return rb_str_symname_type(name, IDSET_ATTRSET_FOR_INTERN) == ID_ATTRSET; 17202 } 17203 17204 int 17205 rb_is_local_name(VALUE name) 17206 { 17207 return rb_str_symname_type(name, 0) == ID_LOCAL; 17208 } 17209 17210 int 17211 rb_is_method_name(VALUE name) 17212 { 17213 switch (rb_str_symname_type(name, 0)) { 17214 case ID_LOCAL: case ID_ATTRSET: case ID_JUNK: 17215 return TRUE; 17216 } 17217 return FALSE; 17218 } 17219 17220 int 17221 rb_is_junk_name(VALUE name) 17222 { 17223 return rb_str_symname_type(name, IDSET_ATTRSET_FOR_SYNTAX) == -1; 17224 } 17225 17226 #endif /* !RIPPER */ 17227 17228 static void 17229 parser_initialize(struct parser_params *parser) 17230 { 17231 parser->eofp = Qfalse; 17232 17233 parser->parser_lex_strterm = 0; 17234 parser->parser_cond_stack = 0; 17235 parser->parser_cmdarg_stack = 0; 17236 parser->parser_class_nest = 0; 17237 parser->parser_paren_nest = 0; 17238 parser->parser_lpar_beg = 0; 17239 parser->parser_brace_nest = 0; 17240 parser->parser_in_single = 0; 17241 parser->parser_in_def = 0; 17242 parser->parser_in_defined = 0; 17243 parser->parser_compile_for_eval = 0; 17244 parser->parser_cur_mid = 0; 17245 parser->parser_tokenbuf = NULL; 17246 parser->parser_tokidx = 0; 17247 parser->parser_toksiz = 0; 17248 parser->parser_heredoc_end = 0; 17249 parser->parser_command_start = TRUE; 17250 parser->parser_deferred_nodes = 0; 17251 parser->parser_lex_pbeg = 0; 17252 parser->parser_lex_p = 0; 17253 parser->parser_lex_pend = 0; 17254 parser->parser_lvtbl = 0; 17255 parser->parser_ruby__end__seen = 0; 17256 parser->parser_ruby_sourcefile = 0; 17257 parser->parser_ruby_sourcefile_string = Qnil; 17258 #ifndef RIPPER 17259 parser->is_ripper = 0; 17260 parser->parser_eval_tree_begin = 0; 17261 parser->parser_eval_tree = 0; 17262 #else 17263 parser->is_ripper = 1; 17264 parser->delayed = Qnil; 17265 17266 parser->result = Qnil; 17267 parser->parsing_thread = Qnil; 17268 parser->toplevel_p = TRUE; 17269 #endif 17270 #ifdef YYMALLOC 17271 parser->heap = NULL; 17272 #endif 17273 parser->enc = rb_utf8_encoding(); 17274 } 17275 17276 #ifdef RIPPER 17277 #define parser_mark ripper_parser_mark 17278 #define parser_free ripper_parser_free 17279 #endif 17280 17281 static void 17282 parser_mark(void *ptr) 17283 { 17284 struct parser_params *p = (struct parser_params*)ptr; 17285 17286 rb_gc_mark((VALUE)p->parser_lex_strterm); 17287 rb_gc_mark((VALUE)p->parser_deferred_nodes); 17288 rb_gc_mark(p->parser_lex_input); 17289 rb_gc_mark(p->parser_lex_lastline); 17290 rb_gc_mark(p->parser_lex_nextline); 17291 rb_gc_mark(p->parser_ruby_sourcefile_string); 17292 #ifndef RIPPER 17293 rb_gc_mark((VALUE)p->parser_eval_tree_begin) ; 17294 rb_gc_mark((VALUE)p->parser_eval_tree) ; 17295 rb_gc_mark(p->debug_lines); 17296 #else 17297 rb_gc_mark(p->delayed); 17298 rb_gc_mark(p->value); 17299 rb_gc_mark(p->result); 17300 rb_gc_mark(p->parsing_thread); 17301 #endif 17302 #ifdef YYMALLOC 17303 rb_gc_mark((VALUE)p->heap); 17304 #endif 17305 } 17306 17307 static void 17308 parser_free(void *ptr) 17309 { 17310 struct parser_params *p = (struct parser_params*)ptr; 17311 struct local_vars *local, *prev; 17312 17313 if (p->parser_tokenbuf) { 17314 xfree(p->parser_tokenbuf); 17315 } 17316 for (local = p->parser_lvtbl; local; local = prev) { 17317 if (local->vars) xfree(local->vars); 17318 prev = local->prev; 17319 xfree(local); 17320 } 17321 xfree(p); 17322 } 17323 17324 static size_t 17325 parser_memsize(const void *ptr) 17326 { 17327 struct parser_params *p = (struct parser_params*)ptr; 17328 struct local_vars *local; 17329 size_t size = sizeof(*p); 17330 17331 if (!ptr) return 0; 17332 size += p->parser_toksiz; 17333 for (local = p->parser_lvtbl; local; local = local->prev) { 17334 size += sizeof(*local); 17335 if (local->vars) size += local->vars->capa * sizeof(ID); 17336 } 17337 return size; 17338 } 17339 17340 static 17341 #ifndef RIPPER 17342 const 17343 #endif 17344 rb_data_type_t parser_data_type = { 17345 "parser", 17346 { 17347 parser_mark, 17348 parser_free, 17349 parser_memsize, 17350 }, 17351 }; 17352 17353 #ifndef RIPPER 17354 #undef rb_reserved_word 17355 17356 const struct kwtable * 17357 rb_reserved_word(const char *str, unsigned int len) 17358 { 17359 return reserved_word(str, len); 17360 } 17361 17362 static struct parser_params * 17363 parser_new(void) 17364 { 17365 struct parser_params *p; 17366 17367 p = ALLOC_N(struct parser_params, 1); 17368 MEMZERO(p, struct parser_params, 1); 17369 parser_initialize(p); 17370 return p; 17371 } 17372 17373 VALUE 17374 rb_parser_new(void) 17375 { 17376 struct parser_params *p = parser_new(); 17377 17378 return TypedData_Wrap_Struct(0, &parser_data_type, p); 17379 } 17380 17381 /* 17382 * call-seq: 17383 * ripper#end_seen? -> Boolean 17384 * 17385 * Return true if parsed source ended by +\_\_END\_\_+. 17386 */ 17387 VALUE 17388 rb_parser_end_seen_p(VALUE vparser) 17389 { 17390 struct parser_params *parser; 17391 17392 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser); 17393 return ruby__end__seen ? Qtrue : Qfalse; 17394 } 17395 17396 /* 17397 * call-seq: 17398 * ripper#encoding -> encoding 17399 * 17400 * Return encoding of the source. 17401 */ 17402 VALUE 17403 rb_parser_encoding(VALUE vparser) 17404 { 17405 struct parser_params *parser; 17406 17407 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser); 17408 return rb_enc_from_encoding(current_enc); 17409 } 17410 17411 /* 17412 * call-seq: 17413 * ripper.yydebug -> true or false 17414 * 17415 * Get yydebug. 17416 */ 17417 VALUE 17418 rb_parser_get_yydebug(VALUE self) 17419 { 17420 struct parser_params *parser; 17421 17422 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); 17423 return yydebug ? Qtrue : Qfalse; 17424 } 17425 17426 /* 17427 * call-seq: 17428 * ripper.yydebug = flag 17429 * 17430 * Set yydebug. 17431 */ 17432 VALUE 17433 rb_parser_set_yydebug(VALUE self, VALUE flag) 17434 { 17435 struct parser_params *parser; 17436 17437 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); 17438 yydebug = RTEST(flag); 17439 return flag; 17440 } 17441 17442 #ifdef YYMALLOC 17443 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE)) 17444 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0) 17445 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \ 17446 (n)->u3.cnt = (c), (p)) 17447 17448 void * 17449 rb_parser_malloc(struct parser_params *parser, size_t size) 17450 { 17451 size_t cnt = HEAPCNT(1, size); 17452 NODE *n = NEWHEAP(); 17453 void *ptr = xmalloc(size); 17454 17455 return ADD2HEAP(n, cnt, ptr); 17456 } 17457 17458 void * 17459 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size) 17460 { 17461 size_t cnt = HEAPCNT(nelem, size); 17462 NODE *n = NEWHEAP(); 17463 void *ptr = xcalloc(nelem, size); 17464 17465 return ADD2HEAP(n, cnt, ptr); 17466 } 17467 17468 void * 17469 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size) 17470 { 17471 NODE *n; 17472 size_t cnt = HEAPCNT(1, size); 17473 17474 if (ptr && (n = parser->heap) != NULL) { 17475 do { 17476 if (n->u1.node == ptr) { 17477 n->u1.node = ptr = xrealloc(ptr, size); 17478 if (n->u3.cnt) n->u3.cnt = cnt; 17479 return ptr; 17480 } 17481 } while ((n = n->u2.node) != NULL); 17482 } 17483 n = NEWHEAP(); 17484 ptr = xrealloc(ptr, size); 17485 return ADD2HEAP(n, cnt, ptr); 17486 } 17487 17488 void 17489 rb_parser_free(struct parser_params *parser, void *ptr) 17490 { 17491 NODE **prev = &parser->heap, *n; 17492 17493 while ((n = *prev) != NULL) { 17494 if (n->u1.node == ptr) { 17495 *prev = n->u2.node; 17496 rb_gc_force_recycle((VALUE)n); 17497 break; 17498 } 17499 prev = &n->u2.node; 17500 } 17501 xfree(ptr); 17502 } 17503 #endif 17504 #endif 17505 17506 #ifdef RIPPER 17507 #ifdef RIPPER_DEBUG 17508 extern int rb_is_pointer_to_heap(VALUE); 17509 17510 /* :nodoc: */ 17511 static VALUE 17512 ripper_validate_object(VALUE self, VALUE x) 17513 { 17514 if (x == Qfalse) return x; 17515 if (x == Qtrue) return x; 17516 if (x == Qnil) return x; 17517 if (x == Qundef) 17518 rb_raise(rb_eArgError, "Qundef given"); 17519 if (FIXNUM_P(x)) return x; 17520 if (SYMBOL_P(x)) return x; 17521 if (!rb_is_pointer_to_heap(x)) 17522 rb_raise(rb_eArgError, "invalid pointer: %p", x); 17523 switch (TYPE(x)) { 17524 case T_STRING: 17525 case T_OBJECT: 17526 case T_ARRAY: 17527 case T_BIGNUM: 17528 case T_FLOAT: 17529 return x; 17530 case T_NODE: 17531 if (nd_type(x) != NODE_LASGN) { 17532 rb_raise(rb_eArgError, "NODE given: %p", x); 17533 } 17534 return ((NODE *)x)->nd_rval; 17535 default: 17536 rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)", 17537 x, rb_obj_classname(x)); 17538 } 17539 return x; 17540 } 17541 #endif 17542 17543 #define validate(x) ((x) = get_value(x)) 17544 17545 static VALUE 17546 ripper_dispatch0(struct parser_params *parser, ID mid) 17547 { 17548 return rb_funcall(parser->value, mid, 0); 17549 } 17550 17551 static VALUE 17552 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a) 17553 { 17554 validate(a); 17555 return rb_funcall(parser->value, mid, 1, a); 17556 } 17557 17558 static VALUE 17559 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b) 17560 { 17561 validate(a); 17562 validate(b); 17563 return rb_funcall(parser->value, mid, 2, a, b); 17564 } 17565 17566 static VALUE 17567 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c) 17568 { 17569 validate(a); 17570 validate(b); 17571 validate(c); 17572 return rb_funcall(parser->value, mid, 3, a, b, c); 17573 } 17574 17575 static VALUE 17576 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d) 17577 { 17578 validate(a); 17579 validate(b); 17580 validate(c); 17581 validate(d); 17582 return rb_funcall(parser->value, mid, 4, a, b, c, d); 17583 } 17584 17585 static VALUE 17586 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e) 17587 { 17588 validate(a); 17589 validate(b); 17590 validate(c); 17591 validate(d); 17592 validate(e); 17593 return rb_funcall(parser->value, mid, 5, a, b, c, d, e); 17594 } 17595 17596 static VALUE 17597 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g) 17598 { 17599 validate(a); 17600 validate(b); 17601 validate(c); 17602 validate(d); 17603 validate(e); 17604 validate(f); 17605 validate(g); 17606 return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g); 17607 } 17608 17609 static const struct kw_assoc { 17610 ID id; 17611 const char *name; 17612 } keyword_to_name[] = { 17613 {keyword_class, "class"}, 17614 {keyword_module, "module"}, 17615 {keyword_def, "def"}, 17616 {keyword_undef, "undef"}, 17617 {keyword_begin, "begin"}, 17618 {keyword_rescue, "rescue"}, 17619 {keyword_ensure, "ensure"}, 17620 {keyword_end, "end"}, 17621 {keyword_if, "if"}, 17622 {keyword_unless, "unless"}, 17623 {keyword_then, "then"}, 17624 {keyword_elsif, "elsif"}, 17625 {keyword_else, "else"}, 17626 {keyword_case, "case"}, 17627 {keyword_when, "when"}, 17628 {keyword_while, "while"}, 17629 {keyword_until, "until"}, 17630 {keyword_for, "for"}, 17631 {keyword_break, "break"}, 17632 {keyword_next, "next"}, 17633 {keyword_redo, "redo"}, 17634 {keyword_retry, "retry"}, 17635 {keyword_in, "in"}, 17636 {keyword_do, "do"}, 17637 {keyword_do_cond, "do"}, 17638 {keyword_do_block, "do"}, 17639 {keyword_return, "return"}, 17640 {keyword_yield, "yield"}, 17641 {keyword_super, "super"}, 17642 {keyword_self, "self"}, 17643 {keyword_nil, "nil"}, 17644 {keyword_true, "true"}, 17645 {keyword_false, "false"}, 17646 {keyword_and, "and"}, 17647 {keyword_or, "or"}, 17648 {keyword_not, "not"}, 17649 {modifier_if, "if"}, 17650 {modifier_unless, "unless"}, 17651 {modifier_while, "while"}, 17652 {modifier_until, "until"}, 17653 {modifier_rescue, "rescue"}, 17654 {keyword_alias, "alias"}, 17655 {keyword_defined, "defined?"}, 17656 {keyword_BEGIN, "BEGIN"}, 17657 {keyword_END, "END"}, 17658 {keyword__LINE__, "__LINE__"}, 17659 {keyword__FILE__, "__FILE__"}, 17660 {keyword__ENCODING__, "__ENCODING__"}, 17661 {0, NULL} 17662 }; 17663 17664 static const char* 17665 keyword_id_to_str(ID id) 17666 { 17667 const struct kw_assoc *a; 17668 17669 for (a = keyword_to_name; a->id; a++) { 17670 if (a->id == id) 17671 return a->name; 17672 } 17673 return NULL; 17674 } 17675 17676 #undef ripper_id2sym 17677 static VALUE 17678 ripper_id2sym(ID id) 17679 { 17680 const char *name; 17681 char buf[8]; 17682 17683 if (id <= 256) { 17684 buf[0] = (char)id; 17685 buf[1] = '\0'; 17686 return ID2SYM(rb_intern2(buf, 1)); 17687 } 17688 if ((name = keyword_id_to_str(id))) { 17689 return ID2SYM(rb_intern(name)); 17690 } 17691 switch (id) { 17692 case tOROP: 17693 name = "||"; 17694 break; 17695 case tANDOP: 17696 name = "&&"; 17697 break; 17698 default: 17699 name = rb_id2name(id); 17700 if (!name) { 17701 rb_bug("cannot convert ID to string: %ld", (unsigned long)id); 17702 } 17703 return ID2SYM(id); 17704 } 17705 return ID2SYM(rb_intern(name)); 17706 } 17707 17708 static ID 17709 ripper_get_id(VALUE v) 17710 { 17711 NODE *nd; 17712 if (!RB_TYPE_P(v, T_NODE)) return 0; 17713 nd = (NODE *)v; 17714 if (nd_type(nd) != NODE_LASGN) return 0; 17715 return nd->nd_vid; 17716 } 17717 17718 static VALUE 17719 ripper_get_value(VALUE v) 17720 { 17721 NODE *nd; 17722 if (v == Qundef) return Qnil; 17723 if (!RB_TYPE_P(v, T_NODE)) return v; 17724 nd = (NODE *)v; 17725 if (nd_type(nd) != NODE_LASGN) return Qnil; 17726 return nd->nd_rval; 17727 } 17728 17729 static void 17730 ripper_compile_error(struct parser_params *parser, const char *fmt, ...) 17731 { 17732 VALUE str; 17733 va_list args; 17734 17735 va_start(args, fmt); 17736 str = rb_vsprintf(fmt, args); 17737 va_end(args); 17738 rb_funcall(parser->value, rb_intern("compile_error"), 1, str); 17739 } 17740 17741 static void 17742 ripper_warn0(struct parser_params *parser, const char *fmt) 17743 { 17744 rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt)); 17745 } 17746 17747 static void 17748 ripper_warnI(struct parser_params *parser, const char *fmt, int a) 17749 { 17750 rb_funcall(parser->value, rb_intern("warn"), 2, 17751 STR_NEW2(fmt), INT2NUM(a)); 17752 } 17753 17754 static void 17755 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str) 17756 { 17757 rb_funcall(parser->value, rb_intern("warn"), 2, 17758 STR_NEW2(fmt), STR_NEW2(str)); 17759 } 17760 17761 static void 17762 ripper_warning0(struct parser_params *parser, const char *fmt) 17763 { 17764 rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt)); 17765 } 17766 17767 static void 17768 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str) 17769 { 17770 rb_funcall(parser->value, rb_intern("warning"), 2, 17771 STR_NEW2(fmt), STR_NEW2(str)); 17772 } 17773 17774 static VALUE 17775 ripper_lex_get_generic(struct parser_params *parser, VALUE src) 17776 { 17777 return rb_io_gets(src); 17778 } 17779 17780 static VALUE 17781 ripper_s_allocate(VALUE klass) 17782 { 17783 struct parser_params *p; 17784 VALUE self; 17785 17786 p = ALLOC_N(struct parser_params, 1); 17787 MEMZERO(p, struct parser_params, 1); 17788 self = TypedData_Wrap_Struct(klass, &parser_data_type, p); 17789 p->value = self; 17790 return self; 17791 } 17792 17793 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0) 17794 17795 /* 17796 * call-seq: 17797 * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper 17798 * 17799 * Create a new Ripper object. 17800 * _src_ must be a String, an IO, or an Object which has #gets method. 17801 * 17802 * This method does not starts parsing. 17803 * See also Ripper#parse and Ripper.parse. 17804 */ 17805 static VALUE 17806 ripper_initialize(int argc, VALUE *argv, VALUE self) 17807 { 17808 struct parser_params *parser; 17809 VALUE src, fname, lineno; 17810 17811 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); 17812 rb_scan_args(argc, argv, "12", &src, &fname, &lineno); 17813 if (RB_TYPE_P(src, T_FILE)) { 17814 parser->parser_lex_gets = ripper_lex_get_generic; 17815 } 17816 else { 17817 StringValue(src); 17818 parser->parser_lex_gets = lex_get_str; 17819 } 17820 parser->parser_lex_input = src; 17821 parser->eofp = Qfalse; 17822 if (NIL_P(fname)) { 17823 fname = STR_NEW2("(ripper)"); 17824 } 17825 else { 17826 StringValue(fname); 17827 } 17828 parser_initialize(parser); 17829 17830 parser->parser_ruby_sourcefile_string = fname; 17831 parser->parser_ruby_sourcefile = RSTRING_PTR(fname); 17832 parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1; 17833 17834 return Qnil; 17835 } 17836 17837 struct ripper_args { 17838 struct parser_params *parser; 17839 int argc; 17840 VALUE *argv; 17841 }; 17842 17843 static VALUE 17844 ripper_parse0(VALUE parser_v) 17845 { 17846 struct parser_params *parser; 17847 17848 TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser); 17849 parser_prepare(parser); 17850 ripper_yyparse((void*)parser); 17851 return parser->result; 17852 } 17853 17854 static VALUE 17855 ripper_ensure(VALUE parser_v) 17856 { 17857 struct parser_params *parser; 17858 17859 TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser); 17860 parser->parsing_thread = Qnil; 17861 return Qnil; 17862 } 17863 17864 /* 17865 * call-seq: 17866 * ripper#parse 17867 * 17868 * Start parsing and returns the value of the root action. 17869 */ 17870 static VALUE 17871 ripper_parse(VALUE self) 17872 { 17873 struct parser_params *parser; 17874 17875 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); 17876 if (!ripper_initialized_p(parser)) { 17877 rb_raise(rb_eArgError, "method called for uninitialized object"); 17878 } 17879 if (!NIL_P(parser->parsing_thread)) { 17880 if (parser->parsing_thread == rb_thread_current()) 17881 rb_raise(rb_eArgError, "Ripper#parse is not reentrant"); 17882 else 17883 rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe"); 17884 } 17885 parser->parsing_thread = rb_thread_current(); 17886 rb_ensure(ripper_parse0, self, ripper_ensure, self); 17887 17888 return parser->result; 17889 } 17890 17891 /* 17892 * call-seq: 17893 * ripper#column -> Integer 17894 * 17895 * Return column number of current parsing line. 17896 * This number starts from 0. 17897 */ 17898 static VALUE 17899 ripper_column(VALUE self) 17900 { 17901 struct parser_params *parser; 17902 long col; 17903 17904 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); 17905 if (!ripper_initialized_p(parser)) { 17906 rb_raise(rb_eArgError, "method called for uninitialized object"); 17907 } 17908 if (NIL_P(parser->parsing_thread)) return Qnil; 17909 col = parser->tokp - parser->parser_lex_pbeg; 17910 return LONG2NUM(col); 17911 } 17912 17913 /* 17914 * call-seq: 17915 * ripper#filename -> String 17916 * 17917 * Return current parsing filename. 17918 */ 17919 static VALUE 17920 ripper_filename(VALUE self) 17921 { 17922 struct parser_params *parser; 17923 17924 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); 17925 if (!ripper_initialized_p(parser)) { 17926 rb_raise(rb_eArgError, "method called for uninitialized object"); 17927 } 17928 return parser->parser_ruby_sourcefile_string; 17929 } 17930 17931 /* 17932 * call-seq: 17933 * ripper#lineno -> Integer 17934 * 17935 * Return line number of current parsing line. 17936 * This number starts from 1. 17937 */ 17938 static VALUE 17939 ripper_lineno(VALUE self) 17940 { 17941 struct parser_params *parser; 17942 17943 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser); 17944 if (!ripper_initialized_p(parser)) { 17945 rb_raise(rb_eArgError, "method called for uninitialized object"); 17946 } 17947 if (NIL_P(parser->parsing_thread)) return Qnil; 17948 return INT2NUM(parser->parser_ruby_sourceline); 17949 } 17950 17951 #ifdef RIPPER_DEBUG 17952 /* :nodoc: */ 17953 static VALUE 17954 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg) 17955 { 17956 StringValue(msg); 17957 if (obj == Qundef) { 17958 rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg)); 17959 } 17960 return Qnil; 17961 } 17962 17963 /* :nodoc: */ 17964 static VALUE 17965 ripper_value(VALUE self, VALUE obj) 17966 { 17967 return ULONG2NUM(obj); 17968 } 17969 #endif 17970 17971 17972 void 17973 Init_ripper(void) 17974 { 17975 parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new()); 17976 17977 ripper_init_eventids1(); 17978 ripper_init_eventids2(); 17979 /* ensure existing in symbol table */ 17980 (void)rb_intern("||"); 17981 (void)rb_intern("&&"); 17982 17983 InitVM(ripper); 17984 } 17985 17986 void 17987 InitVM_ripper(void) 17988 { 17989 VALUE Ripper; 17990 17991 Ripper = rb_define_class("Ripper", rb_cObject); 17992 rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION)); 17993 rb_define_alloc_func(Ripper, ripper_s_allocate); 17994 rb_define_method(Ripper, "initialize", ripper_initialize, -1); 17995 rb_define_method(Ripper, "parse", ripper_parse, 0); 17996 rb_define_method(Ripper, "column", ripper_column, 0); 17997 rb_define_method(Ripper, "filename", ripper_filename, 0); 17998 rb_define_method(Ripper, "lineno", ripper_lineno, 0); 17999 rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0); 18000 rb_define_method(Ripper, "encoding", rb_parser_encoding, 0); 18001 rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0); 18002 rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1); 18003 #ifdef RIPPER_DEBUG 18004 rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2); 18005 rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1); 18006 rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1); 18007 #endif 18008 18009 ripper_init_eventids1_table(Ripper); 18010 ripper_init_eventids2_table(Ripper); 18011 18012 # if 0 18013 /* Hack to let RDoc document SCRIPT_LINES__ */ 18014 18015 /* 18016 * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded 18017 * after the assignment will be added as an Array of lines with the file 18018 * name as the key. 18019 */ 18020 rb_define_global_const("SCRIPT_LINES__", Qnil); 18021 #endif 18022 18023 } 18024 #endif /* RIPPER */ 18025 18026
1.7.6.1