Ruby  2.0.0p353(2013-11-22revision43784)
ripper.c
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 2.5. */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
6 
7  This program is free software: you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation, either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 /* As a special exception, you may create a larger work that contains
21  part or all of the Bison parser skeleton and distribute that work
22  under terms of your choice, so long as that work isn't itself a
23  parser generator using the skeleton or a modified version thereof
24  as a parser skeleton. Alternatively, if you modify or redistribute
25  the parser skeleton itself, you may (at your option) remove this
26  special exception, which will cause the skeleton and the resulting
27  Bison output files to be licensed under the GNU General Public
28  License without this special exception.
29 
30  This special exception was added by the Free Software Foundation in
31  version 2.2 of Bison. */
32 
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34  simplifying the original so-called "semantic" parser. */
35 
36 /* All symbols defined below should begin with yy or YY, to avoid
37  infringing on user name space. This should be done even for local
38  variables, as they might otherwise be expanded by user macros.
39  There are some unavoidable exceptions within include files to
40  define necessary library symbols; they are noted "INFRINGES ON
41  USER NAME SPACE" below. */
42 
43 /* Identify Bison output. */
44 #define YYBISON 1
45 
46 /* Bison version. */
47 #define YYBISON_VERSION "2.5"
48 
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51 
52 /* Pure parsers. */
53 #define YYPURE 1
54 
55 /* Push parsers. */
56 #define YYPUSH 0
57 
58 /* Pull parsers. */
59 #define YYPULL 1
60 
61 /* Using locations. */
62 #define YYLSP_NEEDED 0
63 
64 
65 
66 /* Copy the first part of user declarations. */
67 
68 /* Line 268 of yacc.c */
69 #line 12 "ripper.y"
70 
71 
72 #ifndef PARSER_DEBUG
73 #define PARSER_DEBUG 0
74 #endif
75 #define YYDEBUG 1
76 #define YYERROR_VERBOSE 1
77 #define YYSTACK_USE_ALLOCA 0
78 
79 #include "ruby/ruby.h"
80 #include "ruby/st.h"
81 #include "ruby/encoding.h"
82 #include "internal.h"
83 #include "node.h"
84 #include "parse.h"
85 #include "id.h"
86 #include "regenc.h"
87 #include <stdio.h>
88 #include <errno.h>
89 #include <ctype.h>
90 #include "probes.h"
91 
92 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
93 
94 #define YYMALLOC(size) rb_parser_malloc(parser, (size))
95 #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
96 #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
97 #define YYFREE(ptr) rb_parser_free(parser, (ptr))
98 #define malloc YYMALLOC
99 #define realloc YYREALLOC
100 #define calloc YYCALLOC
101 #define free YYFREE
102 
103 #ifndef RIPPER
104 static ID register_symid(ID, const char *, long, rb_encoding *);
105 static ID register_symid_str(ID, VALUE);
106 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
107 #include "id.c"
108 #endif
109 
110 #define is_notop_id(id) ((id)>tLAST_OP_ID)
111 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
112 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
113 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
114 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
115 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
116 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
117 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
118 #define id_type(id) (is_notop_id(id) ? (int)((id)&ID_SCOPE_MASK) : -1)
119 
120 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
121  (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
122  ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
123  ((id)&ID_SCOPE_MASK) == ID_CLASS))
124 
126  EXPR_BEG_bit, /* ignore newline, +/- is a sign. */
127  EXPR_END_bit, /* newline significant, +/- is an operator. */
128  EXPR_ENDARG_bit, /* ditto, and unbound braces. */
129  EXPR_ENDFN_bit, /* ditto, and unbound braces. */
130  EXPR_ARG_bit, /* newline significant, +/- is an operator. */
131  EXPR_CMDARG_bit, /* newline significant, +/- is an operator. */
132  EXPR_MID_bit, /* newline significant, +/- is an operator. */
133  EXPR_FNAME_bit, /* ignore newline, no reserved words. */
134  EXPR_DOT_bit, /* right after `.' or `::', no reserved words. */
135  EXPR_CLASS_bit, /* immediate after `class', no here document. */
136  EXPR_VALUE_bit, /* alike EXPR_BEG but label is disallowed. */
138 };
139 /* examine combinations */
141 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
143  DEF_EXPR(END),
144  DEF_EXPR(ENDARG),
145  DEF_EXPR(ENDFN),
146  DEF_EXPR(ARG),
147  DEF_EXPR(CMDARG),
148  DEF_EXPR(MID),
149  DEF_EXPR(FNAME),
150  DEF_EXPR(DOT),
151  DEF_EXPR(CLASS),
152  DEF_EXPR(VALUE),
153  EXPR_BEG_ANY = (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS),
154  EXPR_ARG_ANY = (EXPR_ARG | EXPR_CMDARG),
155  EXPR_END_ANY = (EXPR_END | EXPR_ENDARG | EXPR_ENDFN)
156 };
157 #define IS_lex_state_for(x, ls) ((x) & (ls))
158 #define IS_lex_state(ls) IS_lex_state_for(lex_state, (ls))
159 
160 #if PARSER_DEBUG
161 static const char *lex_state_name(enum lex_state_e state);
162 #endif
163 
165 
166 # define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
167 # define BITSTACK_POP(stack) ((stack) = (stack) >> 1)
168 # define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
169 # define BITSTACK_SET_P(stack) ((stack)&1)
170 
171 #define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n))
172 #define COND_POP() BITSTACK_POP(cond_stack)
173 #define COND_LEXPOP() BITSTACK_LEXPOP(cond_stack)
174 #define COND_P() BITSTACK_SET_P(cond_stack)
175 
176 #define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n))
177 #define CMDARG_POP() BITSTACK_POP(cmdarg_stack)
178 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
179 #define CMDARG_P() BITSTACK_SET_P(cmdarg_stack)
180 
181 struct vtable {
182  ID *tbl;
183  int pos;
184  int capa;
185  struct vtable *prev;
186 };
187 
188 struct local_vars {
189  struct vtable *args;
190  struct vtable *vars;
191  struct vtable *used;
192  struct local_vars *prev;
193 };
194 
195 #define DVARS_INHERIT ((void*)1)
196 #define DVARS_TOPSCOPE NULL
197 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
198 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
199 
200 static int
201 vtable_size(const struct vtable *tbl)
202 {
203  if (POINTER_P(tbl)) {
204  return tbl->pos;
205  }
206  else {
207  return 0;
208  }
209 }
210 
211 #define VTBL_DEBUG 0
212 
213 static struct vtable *
215 {
216  struct vtable *tbl = ALLOC(struct vtable);
217  tbl->pos = 0;
218  tbl->capa = 8;
219  tbl->tbl = ALLOC_N(ID, tbl->capa);
220  tbl->prev = prev;
221  if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
222  return tbl;
223 }
224 
225 static void
227 {
228  if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
229  if (POINTER_P(tbl)) {
230  if (tbl->tbl) {
231  xfree(tbl->tbl);
232  }
233  xfree(tbl);
234  }
235 }
236 
237 static void
238 vtable_add(struct vtable *tbl, ID id)
239 {
240  if (!POINTER_P(tbl)) {
241  rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
242  }
243  if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
244 
245  if (tbl->pos == tbl->capa) {
246  tbl->capa = tbl->capa * 2;
247  REALLOC_N(tbl->tbl, ID, tbl->capa);
248  }
249  tbl->tbl[tbl->pos++] = id;
250 }
251 
252 static int
253 vtable_included(const struct vtable * tbl, ID id)
254 {
255  int i;
256 
257  if (POINTER_P(tbl)) {
258  for (i = 0; i < tbl->pos; i++) {
259  if (tbl->tbl[i] == id) {
260  return i+1;
261  }
262  }
263  }
264  return 0;
265 }
266 
267 
268 #ifndef RIPPER
269 typedef struct token_info {
270  const char *token;
271  int linenum;
272  int column;
273  int nonspc;
274  struct token_info *next;
275 } token_info;
276 #endif
277 
278 /*
279  Structure of Lexer Buffer:
280 
281  lex_pbeg tokp lex_p lex_pend
282  | | | |
283  |-----------+--------------+------------|
284  |<------------>|
285  token
286 */
290 
293 
296  stack_type parser_cond_stack;
314  const char *parser_lex_pbeg;
315  const char *parser_lex_p;
316  const char *parser_lex_pend;
326  char *parser_ruby_sourcefile; /* current source file */
327  int parser_ruby_sourceline; /* current line no. */
329 
331 
332 #ifndef RIPPER
333  /* Ruby core only */
338  int nerr;
339 
342 #else
343  /* Ripper only */
344  VALUE parser_ruby_sourcefile_string;
345  const char *tokp;
346  VALUE delayed;
347  int delayed_line;
348  int delayed_col;
349 
350  VALUE value;
351  VALUE result;
352  VALUE parsing_thread;
353  int toplevel_p;
354 #endif
355 };
356 
357 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)
358 #define STR_NEW0() rb_enc_str_new(0,0,current_enc)
359 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)
360 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)
361 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
362 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc)
363 
364 static int parser_yyerror(struct parser_params*, const char*);
365 #define yyerror(msg) parser_yyerror(parser, (msg))
366 
367 #define lex_strterm (parser->parser_lex_strterm)
368 #define lex_state (parser->parser_lex_state)
369 #define cond_stack (parser->parser_cond_stack)
370 #define cmdarg_stack (parser->parser_cmdarg_stack)
371 #define class_nest (parser->parser_class_nest)
372 #define paren_nest (parser->parser_paren_nest)
373 #define lpar_beg (parser->parser_lpar_beg)
374 #define brace_nest (parser->parser_brace_nest)
375 #define in_single (parser->parser_in_single)
376 #define in_def (parser->parser_in_def)
377 #define compile_for_eval (parser->parser_compile_for_eval)
378 #define cur_mid (parser->parser_cur_mid)
379 #define in_defined (parser->parser_in_defined)
380 #define tokenbuf (parser->parser_tokenbuf)
381 #define tokidx (parser->parser_tokidx)
382 #define toksiz (parser->parser_toksiz)
383 #define tokline (parser->parser_tokline)
384 #define lex_input (parser->parser_lex_input)
385 #define lex_lastline (parser->parser_lex_lastline)
386 #define lex_nextline (parser->parser_lex_nextline)
387 #define lex_pbeg (parser->parser_lex_pbeg)
388 #define lex_p (parser->parser_lex_p)
389 #define lex_pend (parser->parser_lex_pend)
390 #define heredoc_end (parser->parser_heredoc_end)
391 #define command_start (parser->parser_command_start)
392 #define deferred_nodes (parser->parser_deferred_nodes)
393 #define lex_gets_ptr (parser->parser_lex_gets_ptr)
394 #define lex_gets (parser->parser_lex_gets)
395 #define lvtbl (parser->parser_lvtbl)
396 #define ruby__end__seen (parser->parser_ruby__end__seen)
397 #define ruby_sourceline (parser->parser_ruby_sourceline)
398 #define ruby_sourcefile (parser->parser_ruby_sourcefile)
399 #define current_enc (parser->enc)
400 #define yydebug (parser->parser_yydebug)
401 #ifdef RIPPER
402 #else
403 #define ruby_eval_tree (parser->parser_eval_tree)
404 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin)
405 #define ruby_debug_lines (parser->debug_lines)
406 #define ruby_coverage (parser->coverage)
407 #endif
408 
409 #if YYPURE
410 static int yylex(void*, void*);
411 #else
412 static int yylex(void*);
413 #endif
414 
415 #ifndef RIPPER
416 #define yyparse ruby_yyparse
417 
418 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
419 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
420 
421 static NODE *cond_gen(struct parser_params*,NODE*);
422 #define cond(node) cond_gen(parser, (node))
423 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
424 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
425 
426 static NODE *newline_node(NODE*);
427 static void fixpos(NODE*,NODE*);
428 
429 static int value_expr_gen(struct parser_params*,NODE*);
430 static void void_expr_gen(struct parser_params*,NODE*);
431 static NODE *remove_begin(NODE*);
432 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
433 #define void_expr0(node) void_expr_gen(parser, (node))
434 #define void_expr(node) void_expr0((node) = remove_begin(node))
435 static void void_stmts_gen(struct parser_params*,NODE*);
436 #define void_stmts(node) void_stmts_gen(parser, (node))
437 static void reduce_nodes_gen(struct parser_params*,NODE**);
438 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
439 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
440 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
441 
442 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
443 #define block_append(h,t) block_append_gen(parser,(h),(t))
444 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
445 #define list_append(l,i) list_append_gen(parser,(l),(i))
446 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
447 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
448 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
449 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
450 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
451 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
452 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
453 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
454 static int literal_concat0(struct parser_params *, VALUE, VALUE);
455 static NODE *new_evstr_gen(struct parser_params*,NODE*);
456 #define new_evstr(n) new_evstr_gen(parser,(n))
457 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
458 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
459 static NODE *splat_array(NODE*);
460 
461 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
462 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
463 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
464 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
465 
466 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
467 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
468 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);
469 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
470 
471 static NODE *negate_lit(NODE*);
472 static NODE *ret_args_gen(struct parser_params*,NODE*);
473 #define ret_args(node) ret_args_gen(parser, (node))
474 static NODE *arg_blk_pass(NODE*,NODE*);
475 static NODE *new_yield_gen(struct parser_params*,NODE*);
476 #define new_yield(node) new_yield_gen(parser, (node))
477 static NODE *dsym_node_gen(struct parser_params*,NODE*);
478 #define dsym_node(node) dsym_node_gen(parser, (node))
479 
480 static NODE *gettable_gen(struct parser_params*,ID);
481 #define gettable(id) gettable_gen(parser,(id))
482 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
483 #define assignable(id,node) assignable_gen(parser, (id), (node))
484 
485 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
486 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
487 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
488 #define attrset(node,id) attrset_gen(parser, (node), (id))
489 
490 static void rb_backref_error_gen(struct parser_params*,NODE*);
491 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
492 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
493 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
494 
495 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
496 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
497 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
498 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
499 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
500 
501 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
502 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
503 
504 static ID *local_tbl_gen(struct parser_params*);
505 #define local_tbl() local_tbl_gen(parser)
506 
507 static void fixup_nodes(NODE **);
508 
509 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
510 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
511 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
512 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
513 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
514 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
515 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
516 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
517 
518 #define get_id(id) (id)
519 #define get_value(val) (val)
520 #else
521 #define value_expr(node) ((void)(node))
522 #define remove_begin(node) (node)
523 #define rb_dvar_defined(id) 0
524 #define rb_local_defined(id) 0
525 static ID ripper_get_id(VALUE);
526 #define get_id(id) ripper_get_id(id)
527 static VALUE ripper_get_value(VALUE);
528 #define get_value(val) ripper_get_value(val)
529 static VALUE assignable_gen(struct parser_params*,VALUE);
530 #define assignable(lhs,node) assignable_gen(parser, (lhs))
531 static int id_is_var_gen(struct parser_params *parser, ID id);
532 #define id_is_var(id) id_is_var_gen(parser, (id))
533 
534 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2))
535 
536 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
537 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);
538 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
539 
540 #endif /* !RIPPER */
541 
542 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
543 
544 static ID formal_argument_gen(struct parser_params*, ID);
545 #define formal_argument(id) formal_argument_gen(parser, (id))
546 static ID shadowing_lvar_gen(struct parser_params*,ID);
547 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
548 static void new_bv_gen(struct parser_params*,ID);
549 #define new_bv(id) new_bv_gen(parser, (id))
550 
551 static void local_push_gen(struct parser_params*,int);
552 #define local_push(top) local_push_gen(parser,(top))
553 static void local_pop_gen(struct parser_params*);
554 #define local_pop() local_pop_gen(parser)
555 static int local_var_gen(struct parser_params*, ID);
556 #define local_var(id) local_var_gen(parser, (id))
557 static int arg_var_gen(struct parser_params*, ID);
558 #define arg_var(id) arg_var_gen(parser, (id))
559 static int local_id_gen(struct parser_params*, ID);
560 #define local_id(id) local_id_gen(parser, (id))
561 static ID internal_id_gen(struct parser_params*);
562 #define internal_id() internal_id_gen(parser)
563 
564 static const struct vtable *dyna_push_gen(struct parser_params *);
565 #define dyna_push() dyna_push_gen(parser)
566 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
567 #define dyna_pop(node) dyna_pop_gen(parser, (node))
568 static int dyna_in_block_gen(struct parser_params*);
569 #define dyna_in_block() dyna_in_block_gen(parser)
570 #define dyna_var(id) local_var(id)
571 static int dvar_defined_gen(struct parser_params*,ID,int);
572 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
573 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
574 static int dvar_curr_gen(struct parser_params*,ID);
575 #define dvar_curr(id) dvar_curr_gen(parser, (id))
576 
577 static int lvar_defined_gen(struct parser_params*, ID);
578 #define lvar_defined(id) lvar_defined_gen(parser, (id))
579 
580 #define RE_OPTION_ONCE (1<<16)
581 #define RE_OPTION_ENCODING_SHIFT 8
582 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
583 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
584 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
585 #define RE_OPTION_MASK 0xff
586 #define RE_OPTION_ARG_ENCODING_NONE 32
587 
588 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
589 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
590 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
591 #define nd_func u1.id
592 #if SIZEOF_SHORT == 2
593 #define nd_term(node) ((signed short)(node)->u2.id)
594 #else
595 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
596 #endif
597 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
598 #define nd_nest u3.cnt
599 
600 /****** Ripper *******/
601 
602 #ifdef RIPPER
603 #define RIPPER_VERSION "0.1.0"
604 
605 #include "eventids1.c"
606 #include "eventids2.c"
607 
608 static VALUE ripper_dispatch0(struct parser_params*,ID);
609 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
610 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
611 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
612 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
613 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
614 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
615 
616 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
617 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
618 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
619 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
620 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
621 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
622 #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))
623 
624 #define yyparse ripper_yyparse
625 
626 #define ripper_intern(s) ID2SYM(rb_intern(s))
627 static VALUE ripper_id2sym(ID);
628 #ifdef __GNUC__
629 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
630  ID2SYM(id) : ripper_id2sym(id))
631 #endif
632 
633 #define arg_new() dispatch0(args_new)
634 #define arg_add(l,a) dispatch2(args_add, (l), (a))
635 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
636 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
637 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
638 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
639 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
640 
641 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
642 #define mrhs_new() dispatch0(mrhs_new)
643 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
644 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
645 
646 #define mlhs_new() dispatch0(mlhs_new)
647 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
648 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
649 
650 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
651  dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
652 
653 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
654 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
655 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
656 
657 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
658 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
659 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
660 
661 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
662 
663 static inline VALUE
664 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
665 {
666  NODE *t = (NODE *)tail;
667  VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
668  return params_new(f, o, r, p, k, kr, escape_Qundef(b));
669 }
670 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
671 
672 static inline VALUE
673 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
674 {
675  return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);
676 }
677 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
678 
679 #define FIXME 0
680 
681 #endif /* RIPPER */
682 
683 #ifndef RIPPER
684 # define Qnone 0
685 # define ifndef_ripper(x) (x)
686 #else
687 # define Qnone Qnil
688 # define ifndef_ripper(x)
689 #endif
690 
691 #ifndef RIPPER
692 # define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
693 # define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
694 # define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
695 # define rb_warn4S(file,line,fmt,a) rb_compile_warn((file), (line), (fmt), (a))
696 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
697 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
698 #else
699 # define rb_warn0(fmt) ripper_warn0(parser, (fmt))
700 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))
701 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))
702 # define rb_warn4S(file,line,fmt,a) ripper_warnS(parser, (fmt), (a))
703 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
704 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
705 static void ripper_warn0(struct parser_params*, const char*);
706 static void ripper_warnI(struct parser_params*, const char*, int);
707 static void ripper_warnS(struct parser_params*, const char*, const char*);
708 static void ripper_warning0(struct parser_params*, const char*);
709 static void ripper_warningS(struct parser_params*, const char*, const char*);
710 #endif
711 
712 #ifdef RIPPER
713 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
714 # define rb_compile_error ripper_compile_error
715 # define compile_error ripper_compile_error
716 # define PARSER_ARG parser,
717 #else
718 # define rb_compile_error rb_compile_error_with_enc
719 # define compile_error parser->nerr++,rb_compile_error_with_enc
720 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
721 #endif
722 
723 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
724  for instance). This is too low for Ruby to parse some files, such as
725  date/format.rb, therefore bump the value up to at least Bison's default. */
726 #ifdef OLD_YACC
727 #ifndef YYMAXDEPTH
728 #define YYMAXDEPTH 10000
729 #endif
730 #endif
731 
732 #ifndef RIPPER
733 static void token_info_push(struct parser_params*, const char *token);
734 static void token_info_pop(struct parser_params*, const char *token);
735 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
736 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
737 #else
738 #define token_info_push(token) /* nothing */
739 #define token_info_pop(token) /* nothing */
740 #endif
741 
742 
743 /* Line 268 of yacc.c */
744 #line 745 "parse.c"
745 
746 /* Enabling traces. */
747 #ifndef YYDEBUG
748 # define YYDEBUG 1
749 #endif
750 
751 /* Enabling verbose error messages. */
752 #ifdef YYERROR_VERBOSE
753 # undef YYERROR_VERBOSE
754 # define YYERROR_VERBOSE 1
755 #else
756 # define YYERROR_VERBOSE 0
757 #endif
758 
759 /* Enabling the token table. */
760 #ifndef YYTOKEN_TABLE
761 # define YYTOKEN_TABLE 0
762 #endif
763 
764 
765 /* Tokens. */
766 #ifndef YYTOKENTYPE
767 # define YYTOKENTYPE
768  /* Put the tokens into the symbol table, so that GDB and other debuggers
769  know about them. */
770  enum yytokentype {
771  END_OF_INPUT = 0,
772  keyword_class = 258,
773  keyword_module = 259,
774  keyword_def = 260,
775  keyword_undef = 261,
776  keyword_begin = 262,
777  keyword_rescue = 263,
778  keyword_ensure = 264,
779  keyword_end = 265,
780  keyword_if = 266,
781  keyword_unless = 267,
782  keyword_then = 268,
783  keyword_elsif = 269,
784  keyword_else = 270,
785  keyword_case = 271,
786  keyword_when = 272,
787  keyword_while = 273,
788  keyword_until = 274,
789  keyword_for = 275,
790  keyword_break = 276,
791  keyword_next = 277,
792  keyword_redo = 278,
793  keyword_retry = 279,
794  keyword_in = 280,
795  keyword_do = 281,
796  keyword_do_cond = 282,
797  keyword_do_block = 283,
798  keyword_do_LAMBDA = 284,
799  keyword_return = 285,
800  keyword_yield = 286,
801  keyword_super = 287,
802  keyword_self = 288,
803  keyword_nil = 289,
804  keyword_true = 290,
805  keyword_false = 291,
806  keyword_and = 292,
807  keyword_or = 293,
808  keyword_not = 294,
809  modifier_if = 295,
810  modifier_unless = 296,
811  modifier_while = 297,
812  modifier_until = 298,
813  modifier_rescue = 299,
814  keyword_alias = 300,
815  keyword_defined = 301,
816  keyword_BEGIN = 302,
817  keyword_END = 303,
818  keyword__LINE__ = 304,
819  keyword__FILE__ = 305,
820  keyword__ENCODING__ = 306,
821  tIDENTIFIER = 307,
822  tFID = 308,
823  tGVAR = 309,
824  tIVAR = 310,
825  tCONSTANT = 311,
826  tCVAR = 312,
827  tLABEL = 313,
828  tINTEGER = 314,
829  tFLOAT = 315,
830  tSTRING_CONTENT = 316,
831  tCHAR = 317,
832  tNTH_REF = 318,
833  tBACK_REF = 319,
834  tREGEXP_END = 320,
835  tUPLUS = 130,
836  tUMINUS = 131,
837  tPOW = 132,
838  tCMP = 134,
839  tEQ = 139,
840  tEQQ = 140,
841  tNEQ = 141,
842  tGEQ = 138,
843  tLEQ = 137,
844  tANDOP = 321,
845  tOROP = 322,
846  tMATCH = 142,
847  tNMATCH = 143,
848  tDOT2 = 128,
849  tDOT3 = 129,
850  tAREF = 144,
851  tASET = 145,
852  tLSHFT = 135,
853  tRSHFT = 136,
854  tCOLON2 = 323,
855  tCOLON3 = 324,
856  tOP_ASGN = 325,
857  tASSOC = 326,
858  tLPAREN = 327,
859  tLPAREN_ARG = 328,
860  tRPAREN = 329,
861  tLBRACK = 330,
862  tLBRACE = 331,
863  tLBRACE_ARG = 332,
864  tSTAR = 333,
865  tDSTAR = 334,
866  tAMPER = 335,
867  tLAMBDA = 336,
868  tSYMBEG = 337,
869  tSTRING_BEG = 338,
870  tXSTRING_BEG = 339,
871  tREGEXP_BEG = 340,
872  tWORDS_BEG = 341,
873  tQWORDS_BEG = 342,
874  tSYMBOLS_BEG = 343,
875  tQSYMBOLS_BEG = 344,
876  tSTRING_DBEG = 345,
877  tSTRING_DEND = 346,
878  tSTRING_DVAR = 347,
879  tSTRING_END = 348,
880  tLAMBEG = 349,
881  tLOWEST = 350,
882  tUMINUS_NUM = 351,
883  tLAST_TOKEN = 352
884  };
885 #endif
886 
887 
888 
889 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
890 typedef union YYSTYPE
891 {
892 
893 /* Line 293 of yacc.c */
894 #line 689 "ripper.y"
895 
896  VALUE val;
897  NODE *node;
898  ID id;
899  int num;
900  const struct vtable *vars;
901 
902 
903 
904 /* Line 293 of yacc.c */
905 #line 906 "parse.c"
906 } YYSTYPE;
907 # define YYSTYPE_IS_TRIVIAL 1
908 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
909 # define YYSTYPE_IS_DECLARED 1
910 #endif
911 
912 
913 /* Copy the second part of user declarations. */
914 
915 
916 /* Line 343 of yacc.c */
917 #line 918 "parse.c"
918 
919 #ifdef short
920 # undef short
921 #endif
922 
923 #ifdef YYTYPE_UINT8
924 typedef YYTYPE_UINT8 yytype_uint8;
925 #else
926 typedef unsigned char yytype_uint8;
927 #endif
928 
929 #ifdef YYTYPE_INT8
930 typedef YYTYPE_INT8 yytype_int8;
931 #elif (defined __STDC__ || defined __C99__FUNC__ \
932  || defined __cplusplus || defined _MSC_VER)
933 typedef signed char yytype_int8;
934 #else
935 typedef short int yytype_int8;
936 #endif
937 
938 #ifdef YYTYPE_UINT16
939 typedef YYTYPE_UINT16 yytype_uint16;
940 #else
941 typedef unsigned short int yytype_uint16;
942 #endif
943 
944 #ifdef YYTYPE_INT16
945 typedef YYTYPE_INT16 yytype_int16;
946 #else
947 typedef short int yytype_int16;
948 #endif
949 
950 #ifndef YYSIZE_T
951 # ifdef __SIZE_TYPE__
952 # define YYSIZE_T __SIZE_TYPE__
953 # elif defined size_t
954 # define YYSIZE_T size_t
955 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
956  || defined __cplusplus || defined _MSC_VER)
957 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
958 # define YYSIZE_T size_t
959 # else
960 # define YYSIZE_T unsigned int
961 # endif
962 #endif
963 
964 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
965 
966 #ifndef YY_
967 # if defined YYENABLE_NLS && YYENABLE_NLS
968 # if ENABLE_NLS
969 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
970 # define YY_(msgid) dgettext ("bison-runtime", msgid)
971 # endif
972 # endif
973 # ifndef YY_
974 # define YY_(msgid) msgid
975 # endif
976 #endif
977 
978 /* Suppress unused-variable warnings by "using" E. */
979 #if ! defined lint || defined __GNUC__
980 # define YYUSE(e) ((void) (e))
981 #else
982 # define YYUSE(e) /* empty */
983 #endif
984 
985 /* Identity function, used to suppress warnings about constant conditions. */
986 #ifndef lint
987 # define YYID(n) (n)
988 #else
989 #if (defined __STDC__ || defined __C99__FUNC__ \
990  || defined __cplusplus || defined _MSC_VER)
991 static int
992 YYID (int yyi)
993 #else
994 static int
995 YYID (yyi)
996  int yyi;
997 #endif
998 {
999  return yyi;
1000 }
1001 #endif
1002 
1003 #if ! defined yyoverflow || YYERROR_VERBOSE
1004 
1005 /* The parser invokes alloca or malloc; define the necessary symbols. */
1006 
1007 # ifdef YYSTACK_USE_ALLOCA
1008 # if YYSTACK_USE_ALLOCA
1009 # ifdef __GNUC__
1010 # define YYSTACK_ALLOC __builtin_alloca
1011 # elif defined __BUILTIN_VA_ARG_INCR
1012 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1013 # elif defined _AIX
1014 # define YYSTACK_ALLOC __alloca
1015 # elif defined _MSC_VER
1016 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1017 # define alloca _alloca
1018 # else
1019 # define YYSTACK_ALLOC alloca
1020 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1021  || defined __cplusplus || defined _MSC_VER)
1022 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1023 # ifndef EXIT_SUCCESS
1024 # define EXIT_SUCCESS 0
1025 # endif
1026 # endif
1027 # endif
1028 # endif
1029 # endif
1030 
1031 # ifdef YYSTACK_ALLOC
1032  /* Pacify GCC's `empty if-body' warning. */
1033 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1034 # ifndef YYSTACK_ALLOC_MAXIMUM
1035  /* The OS might guarantee only one guard page at the bottom of the stack,
1036  and a page size can be as small as 4096 bytes. So we cannot safely
1037  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1038  to allow for a few compiler-allocated temporary stack slots. */
1039 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1040 # endif
1041 # else
1042 # define YYSTACK_ALLOC YYMALLOC
1043 # define YYSTACK_FREE YYFREE
1044 # ifndef YYSTACK_ALLOC_MAXIMUM
1045 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1046 # endif
1047 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
1048  && ! ((defined YYMALLOC || defined malloc) \
1049  && (defined YYFREE || defined free)))
1050 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1051 # ifndef EXIT_SUCCESS
1052 # define EXIT_SUCCESS 0
1053 # endif
1054 # endif
1055 # ifndef YYMALLOC
1056 # define YYMALLOC malloc
1057 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1058  || defined __cplusplus || defined _MSC_VER)
1059 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1060 # endif
1061 # endif
1062 # ifndef YYFREE
1063 # define YYFREE free
1064 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1065  || defined __cplusplus || defined _MSC_VER)
1066 void free (void *); /* INFRINGES ON USER NAME SPACE */
1067 # endif
1068 # endif
1069 # endif
1070 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1071 
1072 
1073 #if (! defined yyoverflow \
1074  && (! defined __cplusplus \
1075  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1076 
1077 /* A type that is properly aligned for any stack member. */
1078 union yyalloc
1079 {
1080  yytype_int16 yyss_alloc;
1082 };
1083 
1084 /* The size of the maximum gap between one aligned stack and the next. */
1085 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1086 
1087 /* The size of an array large to enough to hold all stacks, each with
1088  N elements. */
1089 # define YYSTACK_BYTES(N) \
1090  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1091  + YYSTACK_GAP_MAXIMUM)
1092 
1093 # define YYCOPY_NEEDED 1
1094 
1095 /* Relocate STACK from its old location to the new one. The
1096  local variables YYSIZE and YYSTACKSIZE give the old and new number of
1097  elements in the stack, and YYPTR gives the new location of the
1098  stack. Advance YYPTR to a properly aligned location for the next
1099  stack. */
1100 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1101  do \
1102  { \
1103  YYSIZE_T yynewbytes; \
1104  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1105  Stack = &yyptr->Stack_alloc; \
1106  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1107  yyptr += yynewbytes / sizeof (*yyptr); \
1108  } \
1109  while (YYID (0))
1110 
1111 #endif
1112 
1113 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1114 /* Copy COUNT objects from FROM to TO. The source and destination do
1115  not overlap. */
1116 # ifndef YYCOPY
1117 # if defined __GNUC__ && 1 < __GNUC__
1118 # define YYCOPY(To, From, Count) \
1119  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1120 # else
1121 # define YYCOPY(To, From, Count) \
1122  do \
1123  { \
1124  YYSIZE_T yyi; \
1125  for (yyi = 0; yyi < (Count); yyi++) \
1126  (To)[yyi] = (From)[yyi]; \
1127  } \
1128  while (YYID (0))
1129 # endif
1130 # endif
1131 #endif /* !YYCOPY_NEEDED */
1132 
1133 /* YYFINAL -- State number of the termination state. */
1134 #define YYFINAL 3
1135 /* YYLAST -- Last index in YYTABLE. */
1136 #define YYLAST 11084
1137 
1138 /* YYNTOKENS -- Number of terminals. */
1139 #define YYNTOKENS 142
1140 /* YYNNTS -- Number of nonterminals. */
1141 #define YYNNTS 198
1142 /* YYNRULES -- Number of rules. */
1143 #define YYNRULES 619
1144 /* YYNRULES -- Number of states. */
1145 #define YYNSTATES 1056
1146 
1147 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1148 #define YYUNDEFTOK 2
1149 #define YYMAXUTOK 352
1150 
1151 #define YYTRANSLATE(YYX) \
1152  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1153 
1154 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1155 static const yytype_uint8 yytranslate[] =
1156 {
1157  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1158  141, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1159  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1160  2, 2, 140, 127, 2, 2, 2, 125, 120, 2,
1161  136, 137, 123, 121, 134, 122, 133, 124, 2, 2,
1162  2, 2, 2, 2, 2, 2, 2, 2, 115, 139,
1163  117, 113, 116, 114, 2, 2, 2, 2, 2, 2,
1164  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1165  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1166  2, 132, 2, 138, 119, 2, 135, 2, 2, 2,
1167  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1168  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1169  2, 2, 2, 130, 118, 131, 128, 2, 79, 80,
1170  66, 67, 68, 2, 69, 83, 84, 74, 73, 70,
1171  71, 72, 77, 78, 81, 82, 2, 2, 2, 2,
1172  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1173  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1174  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1175  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1176  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1177  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1178  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1179  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1180  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1181  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1182  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1183  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1184  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1185  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1186  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1187  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1188  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1189  65, 75, 76, 85, 86, 87, 88, 89, 90, 91,
1190  92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
1191  102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
1192  112, 126, 129
1193 };
1194 
1195 #if YYDEBUG
1196 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1197  YYRHS. */
1198 static const yytype_uint16 yyprhs[] =
1199 {
1200  0, 0, 3, 4, 7, 10, 12, 14, 18, 21,
1201  23, 24, 30, 35, 38, 40, 42, 46, 49, 51,
1202  52, 58, 59, 64, 68, 72, 76, 79, 83, 87,
1203  91, 95, 99, 104, 106, 110, 114, 121, 127, 133,
1204  139, 145, 149, 153, 157, 161, 163, 167, 171, 173,
1205  177, 181, 185, 188, 190, 192, 194, 196, 198, 203,
1206  204, 210, 212, 215, 219, 224, 230, 235, 241, 244,
1207  247, 250, 253, 256, 258, 262, 264, 268, 270, 273,
1208  277, 283, 286, 291, 294, 299, 301, 305, 307, 311,
1209  314, 318, 320, 324, 326, 328, 333, 337, 341, 345,
1210  349, 352, 354, 356, 358, 363, 367, 371, 375, 379,
1211  382, 384, 386, 388, 391, 393, 397, 399, 401, 403,
1212  405, 407, 409, 411, 413, 415, 417, 418, 423, 425,
1213  427, 429, 431, 433, 435, 437, 439, 441, 443, 445,
1214  447, 449, 451, 453, 455, 457, 459, 461, 463, 465,
1215  467, 469, 471, 473, 475, 477, 479, 481, 483, 485,
1216  487, 489, 491, 493, 495, 497, 499, 501, 503, 505,
1217  507, 509, 511, 513, 515, 517, 519, 521, 523, 525,
1218  527, 529, 531, 533, 535, 537, 539, 541, 543, 545,
1219  547, 549, 551, 553, 555, 557, 559, 561, 563, 565,
1220  569, 575, 579, 585, 592, 598, 604, 610, 616, 621,
1221  625, 629, 633, 637, 641, 645, 649, 653, 657, 662,
1222  667, 670, 673, 677, 681, 685, 689, 693, 697, 701,
1223  705, 709, 713, 717, 721, 725, 728, 731, 735, 739,
1224  743, 747, 748, 753, 760, 762, 764, 766, 769, 774,
1225  777, 781, 783, 785, 787, 789, 792, 797, 800, 802,
1226  805, 808, 813, 815, 816, 819, 822, 825, 827, 829,
1227  832, 836, 841, 845, 850, 853, 855, 857, 859, 861,
1228  863, 865, 867, 869, 871, 873, 875, 876, 881, 882,
1229  886, 887, 892, 896, 900, 903, 907, 911, 913, 918,
1230  922, 924, 925, 932, 937, 941, 944, 946, 949, 952,
1231  959, 966, 967, 968, 976, 977, 978, 986, 992, 997,
1232  998, 999, 1009, 1010, 1017, 1018, 1019, 1028, 1029, 1035,
1233  1036, 1043, 1044, 1045, 1055, 1057, 1059, 1061, 1063, 1065,
1234  1067, 1069, 1071, 1073, 1075, 1077, 1079, 1081, 1083, 1085,
1235  1087, 1089, 1091, 1094, 1096, 1098, 1100, 1106, 1108, 1111,
1236  1113, 1115, 1117, 1121, 1123, 1127, 1129, 1134, 1141, 1145,
1237  1151, 1154, 1159, 1161, 1165, 1170, 1173, 1176, 1178, 1181,
1238  1182, 1189, 1198, 1203, 1210, 1215, 1218, 1225, 1228, 1233,
1239  1240, 1243, 1248, 1251, 1256, 1258, 1260, 1262, 1266, 1268,
1240  1273, 1275, 1280, 1282, 1286, 1288, 1290, 1291, 1292, 1293,
1241  1299, 1304, 1306, 1310, 1314, 1315, 1321, 1324, 1329, 1335,
1242  1341, 1344, 1345, 1351, 1352, 1358, 1362, 1363, 1368, 1369,
1243  1374, 1377, 1379, 1384, 1385, 1391, 1392, 1398, 1404, 1406,
1244  1408, 1415, 1417, 1419, 1421, 1423, 1426, 1428, 1431, 1433,
1245  1435, 1437, 1439, 1441, 1443, 1445, 1448, 1452, 1456, 1460,
1246  1464, 1468, 1469, 1473, 1475, 1478, 1482, 1486, 1487, 1491,
1247  1495, 1499, 1503, 1507, 1508, 1512, 1513, 1517, 1518, 1521,
1248  1522, 1525, 1526, 1529, 1531, 1532, 1536, 1537, 1538, 1539,
1249  1546, 1548, 1550, 1552, 1554, 1557, 1559, 1561, 1563, 1565,
1250  1569, 1571, 1573, 1576, 1579, 1581, 1583, 1585, 1587, 1589,
1251  1591, 1593, 1595, 1597, 1599, 1601, 1603, 1605, 1607, 1609,
1252  1611, 1613, 1615, 1617, 1618, 1623, 1626, 1630, 1633, 1638,
1253  1641, 1644, 1646, 1649, 1650, 1657, 1666, 1671, 1678, 1683,
1254  1690, 1693, 1698, 1705, 1708, 1713, 1716, 1721, 1723, 1724,
1255  1726, 1728, 1730, 1732, 1734, 1736, 1738, 1742, 1744, 1748,
1256  1751, 1754, 1756, 1760, 1762, 1766, 1768, 1770, 1773, 1775,
1257  1779, 1783, 1785, 1789, 1791, 1795, 1797, 1799, 1802, 1804,
1258  1806, 1808, 1811, 1814, 1816, 1818, 1819, 1824, 1826, 1829,
1259  1831, 1835, 1839, 1842, 1845, 1847, 1849, 1851, 1853, 1855,
1260  1857, 1859, 1861, 1863, 1865, 1867, 1869, 1870, 1872, 1873,
1261  1875, 1878, 1881, 1882, 1884, 1886, 1888, 1890, 1892, 1895
1262 };
1263 
1264 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1265 static const yytype_int16 yyrhs[] =
1266 {
1267  143, 0, -1, -1, 144, 145, -1, 146, 332, -1,
1268  339, -1, 147, -1, 146, 338, 147, -1, 1, 147,
1269  -1, 154, -1, -1, 47, 148, 130, 145, 131, -1,
1270  150, 261, 229, 264, -1, 151, 332, -1, 339, -1,
1271  152, -1, 151, 338, 152, -1, 1, 154, -1, 154,
1272  -1, -1, 47, 153, 130, 145, 131, -1, -1, 45,
1273  177, 155, 177, -1, 45, 54, 54, -1, 45, 54,
1274  64, -1, 45, 54, 63, -1, 6, 178, -1, 154,
1275  40, 158, -1, 154, 41, 158, -1, 154, 42, 158,
1276  -1, 154, 43, 158, -1, 154, 44, 154, -1, 48,
1277  130, 150, 131, -1, 156, -1, 165, 113, 159, -1,
1278  296, 87, 159, -1, 214, 132, 188, 335, 87, 159,
1279  -1, 214, 133, 52, 87, 159, -1, 214, 133, 56,
1280  87, 159, -1, 214, 85, 56, 87, 159, -1, 214,
1281  85, 52, 87, 159, -1, 297, 87, 159, -1, 172,
1282  113, 195, -1, 165, 113, 184, -1, 165, 113, 195,
1283  -1, 157, -1, 172, 113, 159, -1, 172, 113, 156,
1284  -1, 159, -1, 157, 37, 157, -1, 157, 38, 157,
1285  -1, 39, 333, 157, -1, 127, 159, -1, 182, -1,
1286  157, -1, 164, -1, 160, -1, 250, -1, 250, 331,
1287  329, 190, -1, -1, 94, 162, 237, 150, 131, -1,
1288  328, -1, 163, 190, -1, 163, 190, 161, -1, 214,
1289  133, 329, 190, -1, 214, 133, 329, 190, 161, -1,
1290  214, 85, 329, 190, -1, 214, 85, 329, 190, 161,
1291  -1, 32, 190, -1, 31, 190, -1, 30, 189, -1,
1292  21, 189, -1, 22, 189, -1, 167, -1, 89, 166,
1293  334, -1, 167, -1, 89, 166, 334, -1, 169, -1,
1294  169, 168, -1, 169, 95, 171, -1, 169, 95, 171,
1295  134, 170, -1, 169, 95, -1, 169, 95, 134, 170,
1296  -1, 95, 171, -1, 95, 171, 134, 170, -1, 95,
1297  -1, 95, 134, 170, -1, 171, -1, 89, 166, 334,
1298  -1, 168, 134, -1, 169, 168, 134, -1, 168, -1,
1299  170, 134, 168, -1, 293, -1, 294, -1, 214, 132,
1300  188, 335, -1, 214, 133, 52, -1, 214, 85, 52,
1301  -1, 214, 133, 56, -1, 214, 85, 56, -1, 86,
1302  56, -1, 297, -1, 293, -1, 294, -1, 214, 132,
1303  188, 335, -1, 214, 133, 52, -1, 214, 85, 52,
1304  -1, 214, 133, 56, -1, 214, 85, 56, -1, 86,
1305  56, -1, 297, -1, 52, -1, 56, -1, 86, 173,
1306  -1, 173, -1, 214, 85, 173, -1, 52, -1, 56,
1307  -1, 53, -1, 180, -1, 181, -1, 175, -1, 289,
1308  -1, 176, -1, 291, -1, 177, -1, -1, 178, 134,
1309  179, 177, -1, 118, -1, 119, -1, 120, -1, 69,
1310  -1, 70, -1, 71, -1, 77, -1, 78, -1, 116,
1311  -1, 73, -1, 117, -1, 74, -1, 72, -1, 83,
1312  -1, 84, -1, 121, -1, 122, -1, 123, -1, 95,
1313  -1, 124, -1, 125, -1, 68, -1, 96, -1, 127,
1314  -1, 128, -1, 66, -1, 67, -1, 81, -1, 82,
1315  -1, 135, -1, 49, -1, 50, -1, 51, -1, 47,
1316  -1, 48, -1, 45, -1, 37, -1, 7, -1, 21,
1317  -1, 16, -1, 3, -1, 5, -1, 46, -1, 26,
1318  -1, 15, -1, 14, -1, 10, -1, 9, -1, 36,
1319  -1, 20, -1, 25, -1, 4, -1, 22, -1, 34,
1320  -1, 39, -1, 38, -1, 23, -1, 8, -1, 24,
1321  -1, 30, -1, 33, -1, 32, -1, 13, -1, 35,
1322  -1, 6, -1, 17, -1, 31, -1, 11, -1, 12,
1323  -1, 18, -1, 19, -1, 172, 113, 182, -1, 172,
1324  113, 182, 44, 182, -1, 296, 87, 182, -1, 296,
1325  87, 182, 44, 182, -1, 214, 132, 188, 335, 87,
1326  182, -1, 214, 133, 52, 87, 182, -1, 214, 133,
1327  56, 87, 182, -1, 214, 85, 52, 87, 182, -1,
1328  214, 85, 56, 87, 182, -1, 86, 56, 87, 182,
1329  -1, 297, 87, 182, -1, 182, 79, 182, -1, 182,
1330  80, 182, -1, 182, 121, 182, -1, 182, 122, 182,
1331  -1, 182, 123, 182, -1, 182, 124, 182, -1, 182,
1332  125, 182, -1, 182, 68, 182, -1, 126, 59, 68,
1333  182, -1, 126, 60, 68, 182, -1, 66, 182, -1,
1334  67, 182, -1, 182, 118, 182, -1, 182, 119, 182,
1335  -1, 182, 120, 182, -1, 182, 69, 182, -1, 182,
1336  116, 182, -1, 182, 73, 182, -1, 182, 117, 182,
1337  -1, 182, 74, 182, -1, 182, 70, 182, -1, 182,
1338  71, 182, -1, 182, 72, 182, -1, 182, 77, 182,
1339  -1, 182, 78, 182, -1, 127, 182, -1, 128, 182,
1340  -1, 182, 83, 182, -1, 182, 84, 182, -1, 182,
1341  75, 182, -1, 182, 76, 182, -1, -1, 46, 333,
1342  183, 182, -1, 182, 114, 182, 333, 115, 182, -1,
1343  196, -1, 182, -1, 339, -1, 194, 336, -1, 194,
1344  134, 326, 336, -1, 326, 336, -1, 136, 188, 334,
1345  -1, 339, -1, 186, -1, 339, -1, 189, -1, 194,
1346  134, -1, 194, 134, 326, 134, -1, 326, 134, -1,
1347  164, -1, 194, 193, -1, 326, 193, -1, 194, 134,
1348  326, 193, -1, 192, -1, -1, 191, 189, -1, 97,
1349  184, -1, 134, 192, -1, 339, -1, 184, -1, 95,
1350  184, -1, 194, 134, 184, -1, 194, 134, 95, 184,
1351  -1, 194, 134, 184, -1, 194, 134, 95, 184, -1,
1352  95, 184, -1, 265, -1, 266, -1, 269, -1, 270,
1353  -1, 271, -1, 276, -1, 274, -1, 277, -1, 295,
1354  -1, 297, -1, 53, -1, -1, 215, 197, 149, 225,
1355  -1, -1, 90, 198, 334, -1, -1, 90, 157, 199,
1356  334, -1, 89, 150, 137, -1, 214, 85, 56, -1,
1357  86, 56, -1, 92, 185, 138, -1, 93, 325, 131,
1358  -1, 30, -1, 31, 136, 189, 334, -1, 31, 136,
1359  334, -1, 31, -1, -1, 46, 333, 136, 200, 157,
1360  334, -1, 39, 136, 157, 334, -1, 39, 136, 334,
1361  -1, 163, 256, -1, 251, -1, 251, 256, -1, 98,
1362  242, -1, 216, 158, 226, 150, 228, 225, -1, 217,
1363  158, 226, 150, 229, 225, -1, -1, -1, 218, 201,
1364  158, 227, 202, 150, 225, -1, -1, -1, 219, 203,
1365  158, 227, 204, 150, 225, -1, 220, 158, 332, 259,
1366  225, -1, 220, 332, 259, 225, -1, -1, -1, 221,
1367  230, 25, 205, 158, 227, 206, 150, 225, -1, -1,
1368  222, 174, 298, 207, 149, 225, -1, -1, -1, 222,
1369  83, 157, 208, 337, 209, 149, 225, -1, -1, 223,
1370  174, 210, 149, 225, -1, -1, 224, 175, 211, 300,
1371  149, 225, -1, -1, -1, 224, 323, 331, 212, 175,
1372  213, 300, 149, 225, -1, 21, -1, 22, -1, 23,
1373  -1, 24, -1, 196, -1, 7, -1, 11, -1, 12,
1374  -1, 18, -1, 19, -1, 16, -1, 20, -1, 3,
1375  -1, 4, -1, 5, -1, 10, -1, 337, -1, 13,
1376  -1, 337, 13, -1, 337, -1, 27, -1, 229, -1,
1377  14, 158, 226, 150, 228, -1, 339, -1, 15, 150,
1378  -1, 172, -1, 165, -1, 305, -1, 89, 233, 334,
1379  -1, 231, -1, 232, 134, 231, -1, 232, -1, 232,
1380  134, 95, 305, -1, 232, 134, 95, 305, 134, 232,
1381  -1, 232, 134, 95, -1, 232, 134, 95, 134, 232,
1382  -1, 95, 305, -1, 95, 305, 134, 232, -1, 95,
1383  -1, 95, 134, 232, -1, 310, 134, 313, 322, -1,
1384  310, 322, -1, 313, 322, -1, 321, -1, 134, 234,
1385  -1, -1, 307, 134, 316, 134, 319, 235, -1, 307,
1386  134, 316, 134, 319, 134, 307, 235, -1, 307, 134,
1387  316, 235, -1, 307, 134, 316, 134, 307, 235, -1,
1388  307, 134, 319, 235, -1, 307, 134, -1, 307, 134,
1389  319, 134, 307, 235, -1, 307, 235, -1, 316, 134,
1390  319, 235, -1, 316, 134, 319, 134, 307, 235, -1,
1391  316, 235, -1, 316, 134, 307, 235, -1, 319, 235,
1392  -1, 319, 134, 307, 235, -1, 234, -1, 339, -1,
1393  238, -1, 118, 239, 118, -1, 76, -1, 118, 236,
1394  239, 118, -1, 333, -1, 333, 139, 240, 333, -1,
1395  241, -1, 240, 134, 241, -1, 52, -1, 304, -1,
1396  -1, -1, -1, 243, 244, 246, 245, 247, -1, 136,
1397  303, 239, 137, -1, 303, -1, 111, 150, 131, -1,
1398  29, 150, 10, -1, -1, 28, 249, 237, 150, 10,
1399  -1, 164, 248, -1, 250, 331, 329, 187, -1, 250,
1400  331, 329, 187, 256, -1, 250, 331, 329, 190, 248,
1401  -1, 163, 186, -1, -1, 214, 133, 329, 252, 187,
1402  -1, -1, 214, 85, 329, 253, 186, -1, 214, 85,
1403  330, -1, -1, 214, 133, 254, 186, -1, -1, 214,
1404  85, 255, 186, -1, 32, 186, -1, 32, -1, 214,
1405  132, 188, 335, -1, -1, 130, 257, 237, 150, 131,
1406  -1, -1, 26, 258, 237, 150, 10, -1, 17, 194,
1407  226, 150, 260, -1, 229, -1, 259, -1, 8, 262,
1408  263, 226, 150, 261, -1, 339, -1, 184, -1, 195,
1409  -1, 339, -1, 88, 172, -1, 339, -1, 9, 150,
1410  -1, 339, -1, 292, -1, 289, -1, 291, -1, 267,
1411  -1, 62, -1, 268, -1, 267, 268, -1, 100, 280,
1412  110, -1, 101, 281, 110, -1, 102, 282, 65, -1,
1413  103, 140, 110, -1, 103, 272, 110, -1, -1, 272,
1414  273, 140, -1, 283, -1, 273, 283, -1, 105, 140,
1415  110, -1, 105, 275, 110, -1, -1, 275, 273, 140,
1416  -1, 104, 140, 110, -1, 104, 278, 110, -1, 106,
1417  140, 110, -1, 106, 279, 110, -1, -1, 278, 61,
1418  140, -1, -1, 279, 61, 140, -1, -1, 280, 283,
1419  -1, -1, 281, 283, -1, -1, 282, 283, -1, 61,
1420  -1, -1, 109, 284, 288, -1, -1, -1, -1, 107,
1421  285, 286, 287, 150, 108, -1, 54, -1, 55, -1,
1422  57, -1, 297, -1, 99, 290, -1, 175, -1, 55,
1423  -1, 54, -1, 57, -1, 99, 281, 110, -1, 59,
1424  -1, 60, -1, 126, 59, -1, 126, 60, -1, 52,
1425  -1, 55, -1, 54, -1, 56, -1, 57, -1, 34,
1426  -1, 33, -1, 35, -1, 36, -1, 50, -1, 49,
1427  -1, 51, -1, 293, -1, 294, -1, 293, -1, 294,
1428  -1, 63, -1, 64, -1, 337, -1, -1, 117, 299,
1429  158, 337, -1, 1, 337, -1, 136, 303, 334, -1,
1430  303, 337, -1, 311, 134, 313, 322, -1, 311, 322,
1431  -1, 313, 322, -1, 321, -1, 134, 301, -1, -1,
1432  307, 134, 317, 134, 319, 302, -1, 307, 134, 317,
1433  134, 319, 134, 307, 302, -1, 307, 134, 317, 302,
1434  -1, 307, 134, 317, 134, 307, 302, -1, 307, 134,
1435  319, 302, -1, 307, 134, 319, 134, 307, 302, -1,
1436  307, 302, -1, 317, 134, 319, 302, -1, 317, 134,
1437  319, 134, 307, 302, -1, 317, 302, -1, 317, 134,
1438  307, 302, -1, 319, 302, -1, 319, 134, 307, 302,
1439  -1, 301, -1, -1, 56, -1, 55, -1, 54, -1,
1440  57, -1, 304, -1, 52, -1, 305, -1, 89, 233,
1441  334, -1, 306, -1, 307, 134, 306, -1, 58, 184,
1442  -1, 58, 214, -1, 309, -1, 310, 134, 309, -1,
1443  308, -1, 311, 134, 308, -1, 68, -1, 96, -1,
1444  312, 52, -1, 312, -1, 52, 113, 184, -1, 52,
1445  113, 214, -1, 315, -1, 316, 134, 315, -1, 314,
1446  -1, 317, 134, 314, -1, 123, -1, 95, -1, 318,
1447  52, -1, 318, -1, 120, -1, 97, -1, 320, 52,
1448  -1, 134, 321, -1, 339, -1, 295, -1, -1, 136,
1449  324, 157, 334, -1, 339, -1, 326, 336, -1, 327,
1450  -1, 326, 134, 327, -1, 184, 88, 184, -1, 58,
1451  184, -1, 96, 184, -1, 52, -1, 56, -1, 53,
1452  -1, 52, -1, 56, -1, 53, -1, 180, -1, 52,
1453  -1, 53, -1, 180, -1, 133, -1, 85, -1, -1,
1454  338, -1, -1, 141, -1, 333, 137, -1, 333, 138,
1455  -1, -1, 141, -1, 134, -1, 139, -1, 141, -1,
1456  337, -1, 338, 139, -1, -1
1457 };
1458 
1459 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1460 static const yytype_uint16 yyrline[] =
1461 {
1462  0, 853, 853, 853, 884, 895, 904, 912, 920, 926,
1463  928, 927, 948, 981, 992, 1001, 1009, 1017, 1023, 1028,
1464  1027, 1048, 1048, 1056, 1064, 1075, 1085, 1093, 1102, 1111,
1465  1124, 1137, 1146, 1158, 1159, 1169, 1174, 1195, 1200, 1205,
1466  1215, 1220, 1230, 1239, 1248, 1257, 1260, 1269, 1281, 1282,
1467  1290, 1298, 1306, 1314, 1317, 1329, 1330, 1333, 1334, 1346,
1468  1345, 1367, 1377, 1386, 1399, 1408, 1420, 1429, 1441, 1450,
1469  1459, 1467, 1475, 1485, 1486, 1496, 1497, 1507, 1515, 1523,
1470  1531, 1540, 1548, 1557, 1565, 1574, 1582, 1593, 1594, 1604,
1471  1612, 1622, 1630, 1640, 1644, 1648, 1656, 1664, 1672, 1680,
1472  1692, 1702, 1714, 1723, 1732, 1740, 1748, 1756, 1764, 1777,
1473  1790, 1801, 1809, 1812, 1820, 1828, 1838, 1839, 1840, 1841,
1474  1846, 1857, 1858, 1861, 1869, 1872, 1880, 1880, 1890, 1891,
1475  1892, 1893, 1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901,
1476  1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911,
1477  1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, 1922, 1922,
1478  1922, 1923, 1923, 1924, 1924, 1924, 1925, 1925, 1925, 1925,
1479  1926, 1926, 1926, 1926, 1927, 1927, 1927, 1928, 1928, 1928,
1480  1928, 1929, 1929, 1929, 1929, 1930, 1930, 1930, 1930, 1931,
1481  1931, 1931, 1931, 1932, 1932, 1932, 1932, 1933, 1933, 1936,
1482  1945, 1955, 1960, 1970, 1996, 2001, 2006, 2011, 2021, 2031,
1483  2042, 2056, 2070, 2078, 2086, 2094, 2102, 2110, 2118, 2127,
1484  2136, 2144, 2152, 2160, 2168, 2176, 2184, 2192, 2200, 2208,
1485  2216, 2224, 2232, 2240, 2251, 2259, 2267, 2275, 2283, 2291,
1486  2299, 2307, 2307, 2317, 2327, 2333, 2345, 2346, 2350, 2358,
1487  2368, 2378, 2379, 2382, 2383, 2384, 2388, 2396, 2406, 2415,
1488  2423, 2433, 2442, 2451, 2451, 2463, 2473, 2477, 2483, 2491,
1489  2499, 2513, 2529, 2543, 2558, 2568, 2569, 2570, 2571, 2572,
1490  2573, 2574, 2575, 2576, 2577, 2578, 2587, 2586, 2614, 2614,
1491  2622, 2622, 2630, 2638, 2646, 2654, 2667, 2675, 2683, 2691,
1492  2699, 2707, 2707, 2717, 2725, 2733, 2743, 2744, 2754, 2758,
1493  2770, 2782, 2782, 2782, 2793, 2793, 2793, 2804, 2815, 2824,
1494  2826, 2823, 2890, 2889, 2911, 2916, 2910, 2935, 2934, 2956,
1495  2955, 2978, 2979, 2978, 2999, 3007, 3015, 3023, 3033, 3045,
1496  3051, 3057, 3063, 3069, 3075, 3081, 3087, 3093, 3099, 3109,
1497  3115, 3120, 3121, 3128, 3133, 3136, 3137, 3150, 3151, 3161,
1498  3162, 3165, 3173, 3183, 3191, 3201, 3209, 3218, 3227, 3235,
1499  3243, 3252, 3264, 3272, 3283, 3287, 3291, 3295, 3301, 3306,
1500  3311, 3315, 3319, 3323, 3327, 3331, 3339, 3343, 3347, 3351,
1501  3355, 3359, 3363, 3367, 3371, 3377, 3378, 3384, 3393, 3402,
1502  3413, 3417, 3427, 3434, 3443, 3451, 3457, 3460, 3465, 3457,
1503  3481, 3489, 3499, 3503, 3510, 3509, 3530, 3546, 3555, 3567,
1504  3581, 3591, 3590, 3607, 3606, 3622, 3631, 3630, 3648, 3647,
1505  3664, 3672, 3680, 3695, 3694, 3714, 3713, 3734, 3746, 3747,
1506  3750, 3769, 3772, 3780, 3788, 3791, 3795, 3798, 3806, 3809,
1507  3810, 3818, 3821, 3838, 3839, 3840, 3850, 3860, 3887, 3952,
1508  3961, 3972, 3979, 3989, 3997, 4007, 4016, 4027, 4034, 4046,
1509  4055, 4065, 4074, 4085, 4092, 4103, 4110, 4125, 4132, 4143,
1510  4150, 4161, 4168, 4197, 4199, 4198, 4215, 4221, 4226, 4214,
1511  4245, 4253, 4261, 4269, 4272, 4283, 4284, 4285, 4286, 4289,
1512  4300, 4301, 4302, 4310, 4320, 4321, 4322, 4323, 4324, 4327,
1513  4328, 4329, 4330, 4331, 4332, 4333, 4336, 4349, 4359, 4367,
1514  4377, 4378, 4381, 4390, 4389, 4398, 4410, 4420, 4428, 4432,
1515  4436, 4440, 4446, 4451, 4456, 4460, 4464, 4468, 4472, 4476,
1516  4480, 4484, 4488, 4492, 4496, 4500, 4504, 4508, 4513, 4519,
1517  4528, 4537, 4546, 4557, 4558, 4565, 4574, 4593, 4600, 4613,
1518  4625, 4637, 4645, 4662, 4670, 4686, 4687, 4690, 4695, 4701,
1519  4713, 4725, 4733, 4749, 4757, 4773, 4774, 4777, 4790, 4801,
1520  4802, 4805, 4822, 4826, 4836, 4846, 4846, 4875, 4876, 4886,
1521  4893, 4903, 4911, 4919, 4931, 4932, 4933, 4936, 4937, 4938,
1522  4939, 4942, 4943, 4944, 4947, 4952, 4959, 4960, 4963, 4964,
1523  4967, 4970, 4973, 4974, 4975, 4978, 4979, 4982, 4983, 4987
1524 };
1525 #endif
1526 
1527 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1528 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1529  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1530 static const char *const yytname[] =
1531 {
1532  "\"end-of-input\"", "error", "$undefined", "keyword_class",
1533  "keyword_module", "keyword_def", "keyword_undef", "keyword_begin",
1534  "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if",
1535  "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else",
1536  "keyword_case", "keyword_when", "keyword_while", "keyword_until",
1537  "keyword_for", "keyword_break", "keyword_next", "keyword_redo",
1538  "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond",
1539  "keyword_do_block", "keyword_do_LAMBDA", "keyword_return",
1540  "keyword_yield", "keyword_super", "keyword_self", "keyword_nil",
1541  "keyword_true", "keyword_false", "keyword_and", "keyword_or",
1542  "keyword_not", "modifier_if", "modifier_unless", "modifier_while",
1543  "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined",
1544  "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__",
1545  "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR",
1546  "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tSTRING_CONTENT",
1547  "tCHAR", "tNTH_REF", "tBACK_REF", "tREGEXP_END", "\"unary+\"",
1548  "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"", "\"===\"", "\"!=\"",
1549  "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"", "\"!~\"", "\"..\"",
1550  "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"", "\"::\"",
1551  "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"", "\"( arg\"",
1552  "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"", "\"**arg\"", "\"&\"",
1553  "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG",
1554  "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG", "tQSYMBOLS_BEG",
1555  "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
1556  "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
1557  "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "tLAST_TOKEN",
1558  "'{'", "'}'", "'['", "'.'", "','", "'`'", "'('", "')'", "']'", "';'",
1559  "' '", "'\\n'", "$accept", "program", "$@1", "top_compstmt", "top_stmts",
1560  "top_stmt", "$@2", "bodystmt", "compstmt", "stmts", "stmt_or_begin",
1561  "$@3", "stmt", "$@4", "command_asgn", "expr", "expr_value",
1562  "command_call", "block_command", "cmd_brace_block", "@5", "fcall",
1563  "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head",
1564  "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
1565  "fitem", "undef_list", "$@6", "op", "reswords", "arg", "$@7",
1566  "arg_value", "aref_args", "paren_args", "opt_paren_args",
1567  "opt_call_args", "call_args", "command_args", "@8", "block_arg",
1568  "opt_block_arg", "args", "mrhs", "primary", "@9", "$@10", "$@11", "$@12",
1569  "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "@19", "@20", "@21",
1570  "@22", "@23", "$@24", "$@25", "primary_value", "k_begin", "k_if",
1571  "k_unless", "k_while", "k_until", "k_case", "k_for", "k_class",
1572  "k_module", "k_def", "k_end", "then", "do", "if_tail", "opt_else",
1573  "for_var", "f_marg", "f_marg_list", "f_margs", "block_args_tail",
1574  "opt_block_args_tail", "block_param", "opt_block_param",
1575  "block_param_def", "opt_bv_decl", "bv_decls", "bvar", "lambda", "@26",
1576  "@27", "@28", "f_larglist", "lambda_body", "do_block", "@29",
1577  "block_call", "method_call", "@30", "@31", "@32", "@33", "brace_block",
1578  "@34", "@35", "case_body", "cases", "opt_rescue", "exc_list", "exc_var",
1579  "opt_ensure", "literal", "strings", "string", "string1", "xstring",
1580  "regexp", "words", "word_list", "word", "symbols", "symbol_list",
1581  "qwords", "qsymbols", "qword_list", "qsym_list", "string_contents",
1582  "xstring_contents", "regexp_contents", "string_content", "@36", "@37",
1583  "@38", "@39", "string_dvar", "symbol", "sym", "dsym", "numeric",
1584  "user_variable", "keyword_variable", "var_ref", "var_lhs", "backref",
1585  "superclass", "$@40", "f_arglist", "args_tail", "opt_args_tail",
1586  "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_kw",
1587  "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest",
1588  "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
1589  "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
1590  "singleton", "$@41", "assoc_list", "assocs", "assoc", "operation",
1591  "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
1592  "rparen", "rbracket", "trailer", "term", "terms", "none", 0
1593 };
1594 #endif
1595 
1596 # ifdef YYPRINT
1597 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1598  token YYLEX-NUM. */
1599 static const yytype_uint16 yytoknum[] =
1600 {
1601  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1602  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1603  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1604  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1605  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1606  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1607  315, 316, 317, 318, 319, 320, 130, 131, 132, 134,
1608  139, 140, 141, 138, 137, 321, 322, 142, 143, 128,
1609  129, 144, 145, 135, 136, 323, 324, 325, 326, 327,
1610  328, 329, 330, 331, 332, 333, 334, 335, 336, 337,
1611  338, 339, 340, 341, 342, 343, 344, 345, 346, 347,
1612  348, 349, 350, 61, 63, 58, 62, 60, 124, 94,
1613  38, 43, 45, 42, 47, 37, 351, 33, 126, 352,
1614  123, 125, 91, 46, 44, 96, 40, 41, 93, 59,
1615  32, 10
1616 };
1617 # endif
1618 
1619 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1620 static const yytype_uint16 yyr1[] =
1621 {
1622  0, 142, 144, 143, 145, 146, 146, 146, 146, 147,
1623  148, 147, 149, 150, 151, 151, 151, 151, 152, 153,
1624  152, 155, 154, 154, 154, 154, 154, 154, 154, 154,
1625  154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1626  154, 154, 154, 154, 154, 154, 156, 156, 157, 157,
1627  157, 157, 157, 157, 158, 159, 159, 160, 160, 162,
1628  161, 163, 164, 164, 164, 164, 164, 164, 164, 164,
1629  164, 164, 164, 165, 165, 166, 166, 167, 167, 167,
1630  167, 167, 167, 167, 167, 167, 167, 168, 168, 169,
1631  169, 170, 170, 171, 171, 171, 171, 171, 171, 171,
1632  171, 171, 172, 172, 172, 172, 172, 172, 172, 172,
1633  172, 173, 173, 174, 174, 174, 175, 175, 175, 175,
1634  175, 176, 176, 177, 177, 178, 179, 178, 180, 180,
1635  180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
1636  180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
1637  180, 180, 180, 180, 180, 180, 180, 180, 181, 181,
1638  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1639  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1640  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1641  181, 181, 181, 181, 181, 181, 181, 181, 181, 182,
1642  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1643  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1644  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1645  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1646  182, 183, 182, 182, 182, 184, 185, 185, 185, 185,
1647  186, 187, 187, 188, 188, 188, 188, 188, 189, 189,
1648  189, 189, 189, 191, 190, 192, 193, 193, 194, 194,
1649  194, 194, 195, 195, 195, 196, 196, 196, 196, 196,
1650  196, 196, 196, 196, 196, 196, 197, 196, 198, 196,
1651  199, 196, 196, 196, 196, 196, 196, 196, 196, 196,
1652  196, 200, 196, 196, 196, 196, 196, 196, 196, 196,
1653  196, 201, 202, 196, 203, 204, 196, 196, 196, 205,
1654  206, 196, 207, 196, 208, 209, 196, 210, 196, 211,
1655  196, 212, 213, 196, 196, 196, 196, 196, 214, 215,
1656  216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1657  226, 226, 226, 227, 227, 228, 228, 229, 229, 230,
1658  230, 231, 231, 232, 232, 233, 233, 233, 233, 233,
1659  233, 233, 233, 233, 234, 234, 234, 234, 235, 235,
1660  236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
1661  236, 236, 236, 236, 236, 237, 237, 238, 238, 238,
1662  239, 239, 240, 240, 241, 241, 243, 244, 245, 242,
1663  246, 246, 247, 247, 249, 248, 250, 250, 250, 250,
1664  251, 252, 251, 253, 251, 251, 254, 251, 255, 251,
1665  251, 251, 251, 257, 256, 258, 256, 259, 260, 260,
1666  261, 261, 262, 262, 262, 263, 263, 264, 264, 265,
1667  265, 265, 266, 267, 267, 267, 268, 269, 270, 271,
1668  271, 272, 272, 273, 273, 274, 274, 275, 275, 276,
1669  276, 277, 277, 278, 278, 279, 279, 280, 280, 281,
1670  281, 282, 282, 283, 284, 283, 285, 286, 287, 283,
1671  288, 288, 288, 288, 289, 290, 290, 290, 290, 291,
1672  292, 292, 292, 292, 293, 293, 293, 293, 293, 294,
1673  294, 294, 294, 294, 294, 294, 295, 295, 296, 296,
1674  297, 297, 298, 299, 298, 298, 300, 300, 301, 301,
1675  301, 301, 302, 302, 303, 303, 303, 303, 303, 303,
1676  303, 303, 303, 303, 303, 303, 303, 303, 303, 304,
1677  304, 304, 304, 305, 305, 306, 306, 307, 307, 308,
1678  309, 310, 310, 311, 311, 312, 312, 313, 313, 314,
1679  315, 316, 316, 317, 317, 318, 318, 319, 319, 320,
1680  320, 321, 322, 322, 323, 324, 323, 325, 325, 326,
1681  326, 327, 327, 327, 328, 328, 328, 329, 329, 329,
1682  329, 330, 330, 330, 331, 331, 332, 332, 333, 333,
1683  334, 335, 336, 336, 336, 337, 337, 338, 338, 339
1684 };
1685 
1686 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1687 static const yytype_uint8 yyr2[] =
1688 {
1689  0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
1690  0, 5, 4, 2, 1, 1, 3, 2, 1, 0,
1691  5, 0, 4, 3, 3, 3, 2, 3, 3, 3,
1692  3, 3, 4, 1, 3, 3, 6, 5, 5, 5,
1693  5, 3, 3, 3, 3, 1, 3, 3, 1, 3,
1694  3, 3, 2, 1, 1, 1, 1, 1, 4, 0,
1695  5, 1, 2, 3, 4, 5, 4, 5, 2, 2,
1696  2, 2, 2, 1, 3, 1, 3, 1, 2, 3,
1697  5, 2, 4, 2, 4, 1, 3, 1, 3, 2,
1698  3, 1, 3, 1, 1, 4, 3, 3, 3, 3,
1699  2, 1, 1, 1, 4, 3, 3, 3, 3, 2,
1700  1, 1, 1, 2, 1, 3, 1, 1, 1, 1,
1701  1, 1, 1, 1, 1, 1, 0, 4, 1, 1,
1702  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1703  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1704  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1705  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1706  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1707  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1708  1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
1709  5, 3, 5, 6, 5, 5, 5, 5, 4, 3,
1710  3, 3, 3, 3, 3, 3, 3, 3, 4, 4,
1711  2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
1712  3, 3, 3, 3, 3, 2, 2, 3, 3, 3,
1713  3, 0, 4, 6, 1, 1, 1, 2, 4, 2,
1714  3, 1, 1, 1, 1, 2, 4, 2, 1, 2,
1715  2, 4, 1, 0, 2, 2, 2, 1, 1, 2,
1716  3, 4, 3, 4, 2, 1, 1, 1, 1, 1,
1717  1, 1, 1, 1, 1, 1, 0, 4, 0, 3,
1718  0, 4, 3, 3, 2, 3, 3, 1, 4, 3,
1719  1, 0, 6, 4, 3, 2, 1, 2, 2, 6,
1720  6, 0, 0, 7, 0, 0, 7, 5, 4, 0,
1721  0, 9, 0, 6, 0, 0, 8, 0, 5, 0,
1722  6, 0, 0, 9, 1, 1, 1, 1, 1, 1,
1723  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1724  1, 1, 2, 1, 1, 1, 5, 1, 2, 1,
1725  1, 1, 3, 1, 3, 1, 4, 6, 3, 5,
1726  2, 4, 1, 3, 4, 2, 2, 1, 2, 0,
1727  6, 8, 4, 6, 4, 2, 6, 2, 4, 6,
1728  2, 4, 2, 4, 1, 1, 1, 3, 1, 4,
1729  1, 4, 1, 3, 1, 1, 0, 0, 0, 5,
1730  4, 1, 3, 3, 0, 5, 2, 4, 5, 5,
1731  2, 0, 5, 0, 5, 3, 0, 4, 0, 4,
1732  2, 1, 4, 0, 5, 0, 5, 5, 1, 1,
1733  6, 1, 1, 1, 1, 2, 1, 2, 1, 1,
1734  1, 1, 1, 1, 1, 2, 3, 3, 3, 3,
1735  3, 0, 3, 1, 2, 3, 3, 0, 3, 3,
1736  3, 3, 3, 0, 3, 0, 3, 0, 2, 0,
1737  2, 0, 2, 1, 0, 3, 0, 0, 0, 6,
1738  1, 1, 1, 1, 2, 1, 1, 1, 1, 3,
1739  1, 1, 2, 2, 1, 1, 1, 1, 1, 1,
1740  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1741  1, 1, 1, 0, 4, 2, 3, 2, 4, 2,
1742  2, 1, 2, 0, 6, 8, 4, 6, 4, 6,
1743  2, 4, 6, 2, 4, 2, 4, 1, 0, 1,
1744  1, 1, 1, 1, 1, 1, 3, 1, 3, 2,
1745  2, 1, 3, 1, 3, 1, 1, 2, 1, 3,
1746  3, 1, 3, 1, 3, 1, 1, 2, 1, 1,
1747  1, 2, 2, 1, 1, 0, 4, 1, 2, 1,
1748  3, 3, 2, 2, 1, 1, 1, 1, 1, 1,
1749  1, 1, 1, 1, 1, 1, 0, 1, 0, 1,
1750  2, 2, 0, 1, 1, 1, 1, 1, 2, 0
1751 };
1752 
1753 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1754  Performed when YYTABLE doesn't specify something else to do. Zero
1755  means the default is an error. */
1756 static const yytype_uint16 yydefact[] =
1757 {
1758  2, 0, 0, 1, 0, 346, 347, 348, 0, 339,
1759  340, 341, 344, 342, 343, 345, 334, 335, 336, 337,
1760  297, 263, 263, 510, 509, 511, 512, 608, 0, 608,
1761  10, 0, 514, 513, 515, 594, 596, 506, 505, 595,
1762  508, 500, 501, 453, 520, 521, 0, 0, 0, 0,
1763  288, 619, 619, 85, 406, 479, 477, 479, 481, 461,
1764  473, 467, 475, 0, 0, 0, 3, 606, 6, 9,
1765  33, 45, 48, 56, 263, 55, 0, 73, 0, 77,
1766  87, 0, 53, 244, 0, 286, 0, 0, 311, 314,
1767  606, 0, 0, 0, 0, 57, 306, 275, 276, 452,
1768  454, 277, 278, 279, 281, 280, 282, 450, 451, 449,
1769  516, 517, 283, 0, 284, 61, 5, 8, 168, 179,
1770  169, 192, 165, 185, 175, 174, 195, 196, 190, 173,
1771  172, 167, 193, 197, 198, 177, 166, 180, 184, 186,
1772  178, 171, 187, 194, 189, 188, 181, 191, 176, 164,
1773  183, 182, 163, 170, 161, 162, 158, 159, 160, 116,
1774  118, 117, 153, 154, 149, 131, 132, 133, 140, 137,
1775  139, 134, 135, 155, 156, 141, 142, 146, 150, 136,
1776  138, 128, 129, 130, 143, 144, 145, 147, 148, 151,
1777  152, 157, 121, 123, 125, 26, 119, 120, 122, 124,
1778  0, 0, 0, 0, 0, 0, 0, 0, 258, 0,
1779  245, 268, 71, 262, 619, 0, 516, 517, 0, 284,
1780  619, 589, 72, 70, 608, 69, 0, 619, 430, 68,
1781  608, 609, 0, 0, 21, 241, 0, 0, 334, 335,
1782  297, 300, 431, 0, 220, 0, 221, 294, 0, 19,
1783  0, 0, 606, 15, 18, 608, 75, 14, 290, 608,
1784  0, 612, 612, 246, 0, 0, 612, 587, 608, 0,
1785  0, 0, 83, 338, 0, 93, 94, 101, 308, 407,
1786  497, 496, 498, 495, 0, 494, 0, 0, 0, 0,
1787  0, 0, 0, 0, 0, 0, 0, 502, 503, 52,
1788  235, 236, 615, 616, 4, 617, 607, 0, 0, 0,
1789  0, 0, 0, 0, 435, 433, 420, 62, 305, 414,
1790  416, 0, 89, 0, 81, 78, 0, 0, 0, 0,
1791  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1792  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1793  0, 0, 0, 428, 619, 426, 0, 54, 0, 0,
1794  0, 0, 606, 0, 607, 0, 360, 359, 0, 0,
1795  516, 517, 284, 111, 112, 0, 0, 114, 0, 0,
1796  516, 517, 284, 327, 188, 181, 191, 176, 158, 159,
1797  160, 116, 117, 585, 329, 584, 0, 605, 604, 0,
1798  307, 455, 0, 0, 126, 592, 294, 269, 593, 265,
1799  0, 0, 0, 259, 267, 428, 619, 426, 0, 0,
1800  0, 260, 608, 0, 299, 264, 608, 254, 619, 619,
1801  253, 608, 304, 51, 23, 25, 24, 0, 301, 0,
1802  0, 0, 428, 426, 0, 17, 0, 608, 292, 13,
1803  607, 74, 608, 289, 295, 614, 613, 247, 614, 249,
1804  296, 588, 0, 100, 502, 503, 91, 86, 0, 428,
1805  619, 426, 548, 483, 486, 484, 499, 480, 456, 478,
1806  457, 458, 482, 459, 460, 0, 463, 469, 0, 470,
1807  465, 466, 0, 471, 0, 472, 0, 0, 618, 7,
1808  27, 28, 29, 30, 31, 49, 50, 619, 619, 59,
1809  63, 619, 0, 34, 43, 0, 44, 608, 0, 79,
1810  90, 47, 46, 0, 199, 268, 42, 217, 225, 230,
1811  231, 232, 227, 229, 239, 240, 233, 234, 210, 211,
1812  237, 238, 608, 226, 228, 222, 223, 224, 212, 213,
1813  214, 215, 216, 597, 599, 598, 600, 0, 263, 425,
1814  608, 597, 599, 598, 600, 0, 263, 0, 619, 351,
1815  0, 350, 0, 0, 0, 0, 0, 0, 294, 428,
1816  619, 426, 319, 324, 111, 112, 113, 0, 523, 322,
1817  522, 428, 619, 426, 0, 0, 548, 331, 597, 598,
1818  263, 35, 201, 41, 209, 0, 199, 591, 0, 270,
1819  266, 619, 597, 598, 608, 597, 598, 590, 298, 610,
1820  250, 255, 257, 303, 22, 0, 242, 0, 32, 423,
1821  421, 208, 0, 76, 16, 291, 612, 0, 84, 97,
1822  99, 608, 597, 598, 554, 551, 550, 549, 552, 0,
1823  565, 0, 576, 566, 580, 579, 575, 548, 408, 547,
1824  411, 553, 555, 557, 533, 563, 619, 568, 619, 573,
1825  533, 578, 533, 0, 531, 487, 0, 462, 464, 474,
1826  468, 476, 218, 219, 398, 608, 0, 396, 395, 0,
1827  619, 0, 274, 0, 88, 82, 0, 0, 0, 0,
1828  0, 0, 429, 66, 0, 0, 432, 0, 0, 427,
1829  64, 619, 349, 287, 619, 619, 441, 619, 352, 619,
1830  354, 312, 353, 315, 0, 0, 318, 601, 293, 608,
1831  597, 598, 0, 0, 525, 0, 0, 111, 112, 115,
1832  608, 0, 608, 548, 0, 0, 0, 252, 417, 58,
1833  251, 0, 127, 271, 261, 0, 0, 432, 0, 0,
1834  619, 608, 11, 0, 248, 92, 95, 0, 559, 554,
1835  0, 372, 363, 365, 608, 361, 608, 0, 0, 540,
1836  0, 529, 583, 567, 0, 530, 0, 543, 577, 0,
1837  545, 581, 488, 490, 491, 492, 485, 493, 554, 0,
1838  394, 608, 0, 379, 561, 619, 619, 571, 379, 379,
1839  377, 400, 0, 0, 0, 0, 0, 272, 80, 200,
1840  0, 40, 206, 39, 207, 67, 424, 611, 0, 37,
1841  204, 38, 205, 65, 422, 442, 443, 619, 444, 0,
1842  619, 357, 0, 0, 355, 0, 0, 0, 317, 0,
1843  0, 432, 0, 325, 0, 0, 432, 328, 586, 608,
1844  0, 527, 332, 418, 419, 202, 0, 256, 302, 20,
1845  569, 608, 0, 370, 0, 556, 0, 0, 0, 409,
1846  532, 558, 533, 533, 564, 619, 582, 533, 574, 533,
1847  533, 0, 0, 0, 560, 0, 397, 385, 387, 0,
1848  375, 376, 0, 390, 0, 392, 0, 436, 434, 0,
1849  415, 273, 243, 36, 203, 0, 0, 446, 358, 0,
1850  12, 448, 0, 309, 310, 0, 0, 270, 619, 320,
1851  0, 524, 323, 526, 330, 548, 362, 373, 0, 368,
1852  364, 410, 0, 0, 0, 536, 0, 538, 528, 0,
1853  544, 0, 541, 546, 0, 570, 294, 428, 399, 378,
1854  379, 379, 562, 619, 379, 572, 379, 379, 404, 608,
1855  402, 405, 60, 0, 445, 0, 102, 103, 110, 0,
1856  447, 0, 313, 316, 438, 439, 437, 0, 0, 0,
1857  0, 371, 0, 366, 413, 412, 533, 533, 533, 533,
1858  489, 601, 293, 0, 382, 0, 384, 374, 0, 391,
1859  0, 388, 393, 0, 401, 109, 428, 619, 426, 619,
1860  619, 0, 326, 0, 369, 0, 537, 0, 534, 539,
1861  542, 379, 379, 379, 379, 403, 601, 108, 608, 597,
1862  598, 440, 356, 321, 333, 367, 533, 383, 0, 380,
1863  386, 389, 432, 535, 379, 381
1864 };
1865 
1866 /* YYDEFGOTO[NTERM-NUM]. */
1867 static const yytype_int16 yydefgoto[] =
1868 {
1869  -1, 1, 2, 66, 67, 68, 236, 567, 568, 252,
1870  253, 446, 254, 437, 70, 71, 358, 72, 73, 510,
1871  690, 243, 75, 76, 255, 77, 78, 79, 467, 80,
1872  209, 377, 378, 192, 193, 194, 195, 605, 556, 197,
1873  82, 439, 211, 260, 228, 748, 426, 427, 225, 226,
1874  213, 413, 428, 516, 83, 356, 259, 452, 625, 360,
1875  846, 361, 847, 732, 987, 736, 733, 930, 594, 596,
1876  746, 935, 245, 85, 86, 87, 88, 89, 90, 91,
1877  92, 93, 94, 713, 570, 721, 843, 844, 369, 772,
1878  773, 774, 959, 898, 801, 686, 687, 802, 969, 970,
1879  278, 279, 472, 777, 658, 879, 320, 511, 95, 96,
1880  711, 704, 565, 557, 318, 508, 507, 577, 986, 715,
1881  837, 916, 920, 97, 98, 99, 100, 101, 102, 103,
1882  290, 485, 104, 294, 105, 106, 292, 296, 286, 284,
1883  288, 477, 676, 675, 792, 891, 796, 107, 285, 108,
1884  109, 216, 217, 112, 218, 219, 589, 735, 744, 880,
1885  779, 745, 661, 662, 663, 664, 665, 804, 805, 666,
1886  667, 668, 669, 807, 808, 670, 671, 672, 673, 674,
1887  781, 396, 595, 265, 429, 221, 115, 629, 559, 399,
1888  304, 423, 424, 706, 457, 571, 364, 257
1889 };
1890 
1891 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1892  STATE-NUM. */
1893 #define YYPACT_NINF -810
1894 static const yytype_int16 yypact[] =
1895 {
1896  -810, 102, 2888, -810, 7502, -810, -810, -810, 7025, -810,
1897  -810, -810, -810, -810, -810, -810, 7615, 7615, -810, -810,
1898  7615, 4210, 3805, -810, -810, -810, -810, 190, 6892, -21,
1899  -810, 10, -810, -810, -810, 3130, 3940, -810, -810, 3265,
1900  -810, -810, -810, -810, -810, -810, 8971, 8971, 130, 5262,
1901  9084, 7954, 8293, 7284, -810, 6759, -810, -810, -810, 54,
1902  70, 225, 228, 515, 9197, 8971, -810, 245, -810, 1021,
1903  -810, 269, -810, -810, 73, 120, 87, -810, 98, 9310,
1904  -810, 148, 3109, 44, 359, -810, 9084, 9084, -810, -810,
1905  6149, 9419, 9528, 9637, 6625, 30, 86, -810, -810, 230,
1906  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1907  3, 385, -810, 348, 490, -810, -810, -810, -810, -810,
1908  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1909  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1910  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1911  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1912  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1913  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1914  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1915  -810, -810, -810, -810, -810, 285, -810, -810, -810, -810,
1916  253, 8971, 374, 5401, 8971, 8971, 8971, 8971, -810, 328,
1917  3109, 364, -810, -810, 313, 369, 208, 224, 395, 247,
1918  354, -810, -810, -810, 6036, -810, 7615, 7615, -810, -810,
1919  6262, -810, 9084, 844, -810, 360, 388, 5540, -810, -810,
1920  -810, 379, 400, 73, -810, 464, 463, 501, 7728, -810,
1921  5262, 402, 245, -810, 1021, -21, 437, -810, 269, -21,
1922  415, 8, 317, -810, 364, 440, 317, -810, -21, 525,
1923  615, 9746, 470, -810, 488, 508, 575, 612, -810, -810,
1924  -810, -810, -810, -810, 438, -810, 447, 451, 284, 475,
1925  540, 496, 60, 502, 576, 516, 61, 550, 565, -810,
1926  -810, -810, -810, -810, -810, -810, 6375, 9084, 9084, 9084,
1927  9084, 7728, 9084, 9084, -810, -810, -810, 549, -810, -810,
1928  -810, 8406, -810, 5262, 7393, 527, 8406, 8971, 8971, 8971,
1929  8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971,
1930  8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971,
1931  8971, 8971, 8971, 10025, 7615, 10102, 4619, 269, 110, 110,
1932  9084, 9084, 245, 654, 538, 631, -810, -810, 645, 668,
1933  85, 93, 108, 405, 410, 9084, 377, -810, 123, 661,
1934  -810, -810, -810, -810, 40, 42, 56, 167, 180, 279,
1935  332, 336, 343, -810, -810, -810, 30, -810, -810, 10179,
1936  -810, -810, 9197, 9197, -810, -810, 394, -810, -810, -810,
1937  8971, 8971, 7841, -810, -810, 10256, 7615, 10333, 8971, 8971,
1938  8067, -810, -21, 558, -810, -810, -21, -810, 564, 566,
1939  -810, 66, -810, -810, -810, -810, -810, 7025, -810, 8971,
1940  5671, 574, 10256, 10333, 8971, 1021, 581, -21, -810, -810,
1941  6488, 572, -21, -810, -810, 8180, -810, -810, 8293, -810,
1942  -810, -810, 360, 678, -810, -810, -810, 588, 9746, 10410,
1943  7615, 10487, 1081, -810, -810, -810, -810, -810, -810, -810,
1944  -810, -810, -810, -810, -810, 302, -810, -810, 594, -810,
1945  -810, -810, 306, -810, 597, -810, 8971, 8971, -810, -810,
1946  -810, -810, -810, -810, -810, -810, -810, 63, 63, -810,
1947  -810, 63, 8971, -810, 605, 607, -810, -21, 9746, 617,
1948  -810, -810, -810, 636, 1231, -810, -810, 463, 2567, 2567,
1949  2567, 2567, 976, 976, 2722, 2633, 2567, 2567, 3244, 3244,
1950  339, 339, 1305, 976, 976, 986, 986, 1119, 255, 255,
1951  463, 463, 463, 4345, 3400, 4480, 3535, 400, 620, -810,
1952  -21, 591, -810, 742, -810, 400, 4075, 747, 754, -810,
1953  4758, 756, 5036, 52, 52, 654, 8519, 747, 121, 10564,
1954  7615, 10641, -810, 269, -810, 678, -810, 245, -810, -810,
1955  -810, 10718, 7615, 10179, 4619, 9084, 1274, -810, -810, -810,
1956  1148, -810, 2322, -810, 3109, 7025, 2974, -810, 8971, 364,
1957  -810, 354, 2995, 3670, -21, 398, 497, -810, -810, -810,
1958  -810, 7841, 8067, -810, -810, 9084, 3109, 644, -810, -810,
1959  -810, 3109, 5671, 212, -810, -810, 317, 9746, 588, 495,
1960  323, -21, 337, 376, 676, -810, -810, -810, -810, 8971,
1961  -810, 896, -810, -810, -810, -810, -810, 1142, -810, -810,
1962  -810, -810, -810, -810, 656, -810, 657, 743, 663, -810,
1963  667, 750, 671, 760, -810, -810, 763, -810, -810, -810,
1964  -810, -810, 463, 463, -810, 793, 5810, -810, -810, 5540,
1965  63, 5810, 679, 8632, -810, 588, 9746, 9197, 8971, 699,
1966  9197, 9197, -810, 549, 400, 681, 759, 9197, 9197, -810,
1967  549, 400, -810, -810, 8745, 810, -810, 718, -810, 810,
1968  -810, -810, -810, -810, 747, 92, -810, 81, 149, -21,
1969  144, 155, 9084, 245, -810, 9084, 4619, 495, 323, -810,
1970  -21, 747, 66, 1142, 4619, 245, 7158, -810, 86, 120,
1971  -810, 8971, -810, -810, -810, 8971, 8971, 504, 8971, 8971,
1972  694, 66, -810, 700, -810, -810, 390, 8971, -810, -810,
1973  896, 473, -810, 702, -21, -810, -21, 124, 1142, -810,
1974  571, -810, -810, -810, 38, -810, 1142, -810, -810, 881,
1975  -810, -810, -810, -810, -810, -810, -810, -810, 720, 9855,
1976  -810, -21, 716, 703, -810, 707, 663, -810, 723, 724,
1977  -810, 725, 856, 737, 5540, 859, 8971, 740, 588, 3109,
1978  8971, -810, 3109, -810, 3109, -810, -810, -810, 9197, -810,
1979  3109, -810, 3109, -810, -810, 605, -810, 797, -810, 5149,
1980  872, -810, 9084, 747, -810, 747, 5810, 5810, -810, 8858,
1981  4897, 159, 52, -810, 245, 747, -810, -810, -810, -21,
1982  747, -810, -810, -810, -810, 3109, 8971, 8067, -810, -810,
1983  -810, -21, 875, 752, 953, -810, 762, 5810, 5540, -810,
1984  -810, -810, 753, 757, -810, 663, -810, 767, -810, 768,
1985  767, 5923, 9855, 848, 689, 787, -810, 1386, -810, 622,
1986  -810, -810, 1386, -810, 1533, -810, 1028, -810, -810, 778,
1987  -810, 784, 3109, -810, 3109, 9964, 110, -810, -810, 5810,
1988  -810, -810, 110, -810, -810, 747, 747, -810, 383, -810,
1989  4619, -810, -810, -810, -810, 1274, -810, 785, 875, 672,
1990  -810, -810, 911, 792, 1142, -810, 881, -810, -810, 881,
1991  -810, 881, -810, -810, 820, 689, -810, 10795, -810, -810,
1992  806, 809, -810, 663, 811, -810, 812, 811, -810, 352,
1993  -810, -810, -810, 891, -810, 691, 508, 575, 612, 4619,
1994  -810, 4758, -810, -810, -810, -810, -810, 5810, 747, 4619,
1995  875, 785, 875, 823, -810, -810, 767, 824, 767, 767,
1996  -810, 818, 826, 1386, -810, 1533, -810, -810, 1533, -810,
1997  1533, -810, -810, 1028, -810, 678, 10872, 7615, 10949, 754,
1998  718, 747, -810, 747, 785, 875, -810, 881, -810, -810,
1999  -810, 811, 825, 811, 811, -810, 49, 323, -21, 179,
2000  215, -810, -810, -810, -810, 785, 767, -810, 1533, -810,
2001  -810, -810, 216, -810, 811, -810
2002 };
2003 
2004 /* YYPGOTO[NTERM-NUM]. */
2005 static const yytype_int16 yypgoto[] =
2006 {
2007  -810, -810, -810, -382, -810, 26, -810, -549, -7, -810,
2008  513, -810, 33, -810, -315, -33, -63, -55, -810, -216,
2009  -810, 766, -13, 874, -164, 20, -73, -810, -409, 29,
2010  1882, -309, 882, -54, -810, -5, -810, -810, 6, -810,
2011  1208, -810, 1366, -810, -41, 256, -344, 78, -14, -810,
2012  -384, -205, -4, -304, -15, -810, -810, -810, -810, -810,
2013  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
2014  -810, -810, 64, -810, -810, -810, -810, -810, -810, -810,
2015  -810, -810, -810, -1, -333, -519, -44, -623, -810, -789,
2016  -771, 211, 297, 71, -810, -437, -810, -693, -810, -29,
2017  -810, -810, -810, -810, -810, -810, 237, -810, -810, -810,
2018  -810, -810, -810, -810, -94, -810, -810, -531, -810, -31,
2019  -810, -810, -810, -810, -810, -810, 890, -810, -810, -810,
2020  -810, 701, -810, -810, -810, -810, -810, -810, -810, 940,
2021  -810, -126, -810, -810, -810, -810, -810, -3, -810, 11,
2022  -810, 1400, 1673, 905, 1898, 1689, -810, -810, 65, -451,
2023  -102, -385, -809, -588, -689, -289, 222, 107, -810, -810,
2024  -810, 18, -721, -764, 115, 235, -810, -634, -810, -37,
2025  -627, -810, -810, -810, 114, -388, -810, -324, -810, 623,
2026  -47, -9, -123, -568, -214, 21, -11, -2
2027 };
2028 
2029 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2030  positive, shift that token. If negative, reduce the rule which
2031  number is the opposite. If YYTABLE_NINF, syntax error. */
2032 #define YYTABLE_NINF -620
2033 static const yytype_int16 yytable[] =
2034 {
2035  116, 283, 400, 208, 208, 198, 325, 208, 229, 299,
2036  560, 521, 214, 214, 196, 421, 214, 258, 232, 199,
2037  235, 659, 526, 234, 359, 198, 572, 362, 610, 558,
2038  117, 566, 617, 316, 196, 69, 610, 69, 273, 199,
2039  394, 785, 251, 363, 724, 741, 757, 261, 459, 263,
2040  267, 809, 461, 357, 357, 723, 306, 357, 627, 638,
2041  317, 196, -106, 775, 273, 888, 84, 586, 84, 256,
2042  617, 689, 614, 766, 691, 600, 273, 273, 273, 720,
2043  215, 215, 272, 876, 215, 940, 447, 660, 305, 881,
2044  -518, 558, 840, 566, 212, 222, 845, 971, 223, 314,
2045  196, 937, 3, 312, 313, 569, -106, 432, 895, 695,
2046  -102, 305, 314, 84, 215, 397, -102, 274, -103, 630,
2047  231, 488, 494, 569, 587, -510, 641, -509, 215, -338,
2048  220, 220, 451, -110, 220, 654, 453, -93, 965, 684,
2049  237, -511, 455, 274, 883, 659, -109, 630, 319, 456,
2050  215, 215, 889, 877, 215, 368, 379, 379, 655, 517,
2051  479, 851, 482, 398, 486, 262, 266, 991, 486, -105,
2052  489, 495, 856, -510, -108, -509, -338, -338, 900, 901,
2053  -107, 685, 775, 873, -104, -597, 247, 855, -106, -511,
2054  -106, 302, -105, 303, 289, 860, 251, 431, 466, 433,
2055  321, 940, 316, 315, 971, 449, 659, 231, 881, 227,
2056  291, 208, 414, 208, 208, -97, 315, -597, 414, -93,
2057  214, 1024, 214, 888, 421, 430, 849, -94, -107, -104,
2058  441, 302, 322, 303, 617, 878, 729, 610, 610, 965,
2059  588, 450, -101, 251, 500, 501, 502, 503, 740, 302,
2060  763, 303, -512, 814, 1045, -100, 273, 630, 948, 462,
2061  881, 326, 302, 961, 303, -514, 513, 84, 966, 630,
2062  256, 522, 776, 305, 357, 357, 357, 357, -96, 505,
2063  506, 445, 739, -99, 775, -598, 775, 818, 215, -98,
2064  215, 215, 659, -95, 215, -518, 215, 573, 574, 618,
2065  -512, 84, 422, 620, 425, 984, 312, 313, 623, 273,
2066  997, -519, 84, -514, 84, 575, 251, 515, -105, 881,
2067  -105, -102, 515, 327, 633, -74, 230, 357, 357, 635,
2068  56, 231, 499, 929, 419, 274, 1007, -103, 220, 69,
2069  220, 208, 583, 256, 504, 473, -88, 601, 603, 481,
2070  775, 993, 430, 519, -107, -104, -107, -104, 859, 678,
2071  -110, 564, -96, 473, -513, 293, 678, 473, 295, 1032,
2072  84, 215, 215, 215, 215, 84, 215, 215, 350, 351,
2073  352, 988, 521, 305, 302, 215, 303, 84, 274, 230,
2074  215, 474, 850, 475, 694, 466, 803, 985, 839, 590,
2075  576, -98, 775, 208, 775, 564, 754, 327, -293, 474,
2076  836, 475, -513, 474, 430, 475, -432, -515, 215, 404,
2077  84, -504, 764, 564, 215, 215, 414, 414, -507, 584,
2078  406, -594, 624, 585, 198, 402, -595, 775, 116, 215,
2079  1023, 410, 677, 196, 353, 466, 680, 412, 199, 564,
2080  -96, 458, 411, 273, 415, -293, -293, 208, 456, -598,
2081  348, 349, 350, 351, 352, -515, 215, 215, 430, -504,
2082  1052, -96, -519, 69, -96, -432, -507, 564, -96, 617,
2083  215, 444, 418, 610, 659, 758, 1013, 825, 420, -98,
2084  -504, 354, 355, 231, 833, -507, 438, 887, -103, 473,
2085  890, 416, 417, 273, 84, 688, 688, -109, 473, 688,
2086  -98, -105, 473, -98, 84, 224, 702, -98, 440, -94,
2087  -432, -601, -432, -432, 709, 769, 611, 645, 646, 647,
2088  648, 327, 274, 699, 215, -594, 227, -504, -504, 448,
2089  -595, -594, -507, -507, 703, 474, -595, 475, 476, 442,
2090  -73, 705, 710, 454, 474, 754, 475, 478, 474, 747,
2091  475, 480, 742, 717, 765, 719, 716, 208, 787, 636,
2092  790, 460, 725, 469, 297, 298, 726, 403, 430, 208,
2093  -601, 463, 274, 979, 759, 483, 749, 564, 444, 981,
2094  430, 866, 761, -516, 722, 722, 416, 443, 750, 564,
2095  752, 473, 198, -110, 468, 705, 487, 872, 734, 414,
2096  -107, 196, 490, 964, -109, 967, 199, -104, 496, 858,
2097  470, 471, 273, 466, -101, -601, 493, -601, -601, 649,
2098  116, -597, 705, 497, 84, -100, 84, 473, 868, 650,
2099  -516, -516, 522, 509, 215, 821, 823, 474, 810, 475,
2100  484, 875, 829, 831, 863, 996, 215, 998, 84, 215,
2101  -517, 520, 999, 826, 782, 69, 782, 653, 654, 852,
2102  747, 576, 854, 1038, 464, 465, 811, 498, 707, 812,
2103  799, 273, 813, 474, 815, 475, 491, 578, 688, 215,
2104  650, 655, 862, 582, 630, 619, 84, -284, 621, 357,
2105  622, 274, 357, 806, -105, 628, -88, -517, -517, 750,
2106  515, 632, 838, 841, 1031, 841, 1033, 841, 653, 654,
2107  705, 1034, 637, 848, 769, -96, 645, 646, 647, 648,
2108  579, 705, 842, 839, 679, 760, 933, 681, 1046, -268,
2109  857, 693, 655, 886, -284, -284, 591, 886, 936, 697,
2110  84, 696, 196, 84, 853, 84, -423, 712, 414, 1054,
2111  274, 215, 714, -294, 215, 215, 861, 811, 74, 718,
2112  74, 215, 215, 913, 957, 762, 1016, 580, 581, 922,
2113  945, 947, 74, 74, 273, 950, 74, 952, 953, 767,
2114  778, 780, 811, 592, 593, 783, 215, 784, 885, 215,
2115  84, 786, 788, 782, 782, 789, 992, 909, 84, 357,
2116  -294, -294, 791, -269, 820, 74, 74, 793, 794, 827,
2117  795, 592, 593, 1017, 1018, 839, 44, 45, 867, 708,
2118  74, 869, 918, 892, 896, 917, 874, 897, 921, 925,
2119  926, 899, 923, 928, 924, 798, 828, 645, 646, 647,
2120  648, 799, 74, 74, 932, -107, 74, 902, 904, 934,
2121  810, 650, 886, 894, 906, 810, 907, 810, 908, 910,
2122  942, 943, -104, 722, -270, 931, -98, 273, 84, 903,
2123  905, 919, 651, 782, 954, 915, 938, 944, 652, 653,
2124  654, 946, 215, -95, 1026, 1028, 1029, 1030, 434, 941,
2125  273, 949, 951, 84, 956, 958, 215, 435, 436, 972,
2126  84, 84, 980, 655, 84, 806, 656, 963, -271, 990,
2127  806, 994, 806, 995, 982, 983, 841, 769, 1000, 645,
2128  646, 647, 648, 769, 231, 645, 646, 647, 648, 649,
2129  1003, 84, 84, 1005, 1053, 1008, 1010, 1015, 769, 650,
2130  645, 646, 647, 648, -597, 84, 955, 1025, 1027, 1048,
2131  1014, 782, -598, 634, 770, 366, 810, 834, 810, 74,
2132  651, 810, 1019, 810, 1020, 383, 1042, 653, 654, 975,
2133  1021, 871, 800, 84, 1035, 770, 864, 1022, 1041, 401,
2134  74, 771, 74, 74, 84, 492, 74, 287, 74, 395,
2135  989, 655, 884, 74, 208, 769, 962, 645, 646, 647,
2136  648, 810, 960, 882, 74, 430, 74, 716, 841, 597,
2137  1043, 806, 1044, 806, 564, 0, 806, 0, 806, 705,
2138  0, 1004, 1006, 0, 0, 1009, 0, 1011, 1012, 0,
2139  0, 0, 770, 84, 327, 84, 0, 0, 939, 0,
2140  0, 84, 0, 84, 327, 0, 0, 0, 0, 340,
2141  341, 307, 308, 309, 310, 311, 806, 0, 0, 340,
2142  341, 0, 74, 74, 74, 74, 74, 74, 74, 74,
2143  968, 215, 645, 646, 647, 648, 0, 74, 0, 74,
2144  0, 0, 74, 0, 345, 346, 347, 348, 349, 350,
2145  351, 352, 1047, 1049, 1050, 1051, 347, 348, 349, 350,
2146  351, 352, 0, 0, 0, 0, 0, 0, 0, 0,
2147  74, 0, 74, 0, 0, 1055, 74, 74, 0, 0,
2148  0, 0, 0, 644, 0, 645, 646, 647, 648, 649,
2149  0, 74, 0, 0, 0, 0, 0, 0, -619, 650,
2150  0, 0, 0, 0, 0, 0, -619, -619, -619, 0,
2151  0, -619, -619, -619, 0, -619, 0, 0, 74, 74,
2152  651, 0, 0, 0, -619, -619, 652, 653, 654, 0,
2153  0, 0, 74, 0, 0, -619, -619, 327, -619, -619,
2154  -619, -619, -619, 0, 644, 0, 645, 646, 647, 648,
2155  649, 655, 340, 341, 656, 0, 74, 0, 0, 0,
2156  650, 0, 0, 0, 0, 0, 74, 657, 0, 0,
2157  0, 0, 0, 0, 210, 210, 0, 0, 210, 0,
2158  0, 651, 0, -619, 0, 0, 74, 652, 653, 654,
2159  348, 349, 350, 351, 352, 0, 0, 0, 0, 0,
2160  0, 0, 0, 0, 244, 246, -619, 0, 0, 210,
2161  210, 0, 655, 0, 0, 656, 0, 0, 0, 0,
2162  0, 0, 300, 301, 0, 698, 0, 0, -619, -619,
2163  0, -619, 0, 0, 227, -619, 0, -619, 0, -619,
2164  0, 0, 0, 0, 0, 0, 0, 0, 0, 327,
2165  328, 329, 330, 331, 332, 333, 334, 335, 336, 337,
2166  338, 339, 0, 0, 340, 341, 0, 0, 0, 0,
2167  0, 0, 0, 0, 0, 0, 644, 0, 645, 646,
2168  647, 648, 649, 0, 0, 0, 74, 0, 74, 0,
2169  0, 0, 650, 0, 0, 342, 74, 343, 344, 345,
2170  346, 347, 348, 349, 350, 351, 352, 0, 74, 0,
2171  74, 74, 0, 651, 0, -245, 0, 0, 0, 652,
2172  653, 654, 0, 327, 328, 329, 330, 331, 332, 333,
2173  334, 335, 336, 337, 338, 339, 0, 0, 340, 341,
2174  0, 74, 0, 0, 655, 0, 0, 656, 74, 0,
2175  0, 0, 110, 0, 110, 0, 0, 0, 0, 210,
2176  743, 0, 210, 210, 210, 300, 0, 0, 264, 342,
2177  0, 343, 344, 345, 346, 347, 348, 349, 350, 351,
2178  352, 0, 210, 0, 210, 210, 0, 0, 798, 0,
2179  645, 646, 647, 648, 799, 0, 231, 0, 0, 110,
2180  0, 0, 74, 275, 650, 74, 0, 74, 0, 0,
2181  0, 0, 0, 74, 0, 0, 74, 74, 0, 0,
2182  0, 0, 0, 74, 74, 651, 0, 0, 0, 275,
2183  0, 652, 653, 654, 0, 0, 0, 0, 0, 0,
2184  0, 370, 380, 380, 380, 0, 0, 0, 74, 0,
2185  0, 74, 74, 0, 0, 0, 655, 0, 0, 656,
2186  74, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2187  0, 0, 0, 0, 0, 0, 0, 0, 0, 210,
2188  0, 0, 0, 0, 524, 527, 528, 529, 530, 531,
2189  532, 533, 534, 535, 536, 537, 538, 539, 540, 541,
2190  542, 543, 544, 545, 546, 547, 548, 549, 550, 551,
2191  552, 0, 210, 0, 0, 0, 0, 405, 0, 0,
2192  407, 408, 409, 0, 0, 0, 0, 0, 0, 0,
2193  74, 0, 0, 0, 0, 769, 0, 645, 646, 647,
2194  648, 799, 0, 0, 74, 0, 0, 0, 0, 0,
2195  0, 650, 0, 110, 0, 74, 0, 0, 74, 0,
2196  602, 604, 74, 74, 0, 0, 74, 0, 606, 210,
2197  210, 0, 651, 0, 210, 0, 602, 604, 210, 653,
2198  654, 0, 0, 0, 0, 0, 0, 110, 0, 0,
2199  0, 0, 0, 74, 74, 0, 0, 626, 110, 0,
2200  110, 0, 631, 655, 0, 0, 0, 74, 0, 0,
2201  0, 0, 0, 210, 0, 0, 210, 0, 0, 0,
2202  0, 275, 0, 0, 0, 111, 0, 111, 210, 0,
2203  0, 0, 0, 0, 0, 74, 0, 514, 0, 0,
2204  0, 114, 525, 114, 0, 0, 74, 0, 0, 0,
2205  0, 0, 0, 0, 682, 683, 110, 0, 0, 0,
2206  0, 110, 0, 0, 0, 0, 0, 0, 0, 0,
2207  210, 0, 111, 110, 275, 0, 276, 0, 0, 0,
2208  0, 0, 0, 0, 0, 0, 0, 0, 114, 0,
2209  0, 0, 277, 0, 0, 74, 0, 74, 0, 0,
2210  0, 0, 276, 74, 0, 74, 110, 0, 0, 0,
2211  0, 0, 0, 0, 371, 381, 381, 381, 277, 0,
2212  0, 0, 0, 0, 0, 0, 0, 607, 609, 0,
2213  372, 382, 382, 74, 210, 0, 264, 0, 210, 0,
2214  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2215  210, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2216  0, 0, 0, 0, 0, 0, 210, 0, 0, 0,
2217  0, 609, 0, 0, 264, 0, 0, 0, 0, 210,
2218  210, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2219  110, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2220  110, 0, 0, 0, 0, 0, 0, 210, 0, 0,
2221  0, 0, 0, 0, 0, 0, 0, 0, 275, 0,
2222  0, 0, 0, 0, 0, 0, 111, 0, 692, 0,
2223  0, 0, 0, 0, 81, 0, 81, 0, 0, 0,
2224  0, 0, 114, 0, 0, 0, 0, 0, 0, 0,
2225  113, 210, 113, 0, 0, 606, 819, 0, 822, 824,
2226  111, 0, 0, 0, 0, 830, 832, 0, 275, 0,
2227  0, 111, 210, 111, 0, 0, 114, 0, 0, 0,
2228  0, 81, 0, 0, 0, 0, 0, 114, 0, 114,
2229  0, 0, 525, 0, 276, 0, 0, 113, 0, 0,
2230  0, 0, 0, 0, 0, 0, 0, 0, 0, 865,
2231  277, 0, 0, 822, 824, 0, 830, 832, 0, 0,
2232  110, 0, 110, 367, 753, 210, 0, 0, 0, 111,
2233  0, 0, 0, 0, 111, 0, 0, 609, 264, 0,
2234  0, 0, 0, 0, 110, 114, 111, 276, 0, 0,
2235  114, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2236  0, 0, 114, 277, 0, 768, 0, 0, 0, 0,
2237  0, 0, 0, 0, 210, 0, 0, 0, 912, 111,
2238  0, 0, 110, 0, 0, 0, 914, 275, 0, 0,
2239  0, 0, 0, 0, 0, 114, 0, 0, 0, 0,
2240  0, 0, 0, 0, 0, 0, 0, 210, 0, 817,
2241  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2242  0, 0, 0, 0, 914, 210, 0, 0, 0, 0,
2243  835, 0, 0, 0, 0, 81, 110, 0, 0, 110,
2244  0, 110, 0, 0, 0, 0, 275, 0, 0, 0,
2245  0, 113, 0, 0, 0, 0, 0, 0, 0, 0,
2246  0, 0, 0, 111, 0, 0, 0, 0, 0, 81,
2247  0, 0, 0, 111, 0, 0, 0, 0, 0, 114,
2248  81, 0, 81, 870, 0, 113, 110, 0, 0, 114,
2249  0, 276, 0, 0, 110, 0, 113, 0, 113, 0,
2250  0, 0, 0, 0, 0, 0, 0, 277, 0, 0,
2251  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2252  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2253  0, 0, 911, 0, 0, 0, 0, 0, 81, 0,
2254  0, 276, 0, 81, 0, 0, 0, 0, 0, 380,
2255  0, 0, 0, 0, 113, 81, 0, 277, 523, 113,
2256  0, 0, 0, 0, 110, 927, 0, 0, 0, 0,
2257  0, 113, 0, 0, 0, 210, 0, 0, 0, 0,
2258  0, 0, 0, 264, 0, 0, 0, 0, 81, 110,
2259  0, 0, 0, 111, 0, 111, 110, 110, 0, 0,
2260  110, 0, 0, 0, 113, 0, 0, 0, 0, 114,
2261  0, 114, 0, 0, 0, 0, 0, 111, 0, 0,
2262  0, 0, 0, 0, 0, 0, 0, 110, 110, 0,
2263  0, 0, 0, 114, 0, 0, 0, 0, 0, 0,
2264  0, 110, 380, 0, 0, 0, 0, 0, 0, 0,
2265  0, 0, 0, 0, 0, 111, 0, 0, 0, 0,
2266  276, 0, 0, 0, 0, 976, 0, 0, 0, 110,
2267  0, 114, 81, 0, 0, 0, 277, 0, 0, 0,
2268  110, 0, 81, 0, 0, 0, 0, 0, 113, 0,
2269  0, 0, 0, 0, 0, 0, 0, 0, 113, 0,
2270  0, 0, 0, 0, 0, 0, 0, 0, 0, 111,
2271  0, 0, 111, 0, 111, 797, 751, 0, 0, 276,
2272  0, 0, 0, 0, 0, 114, 0, 0, 114, 110,
2273  114, 110, 0, 0, 0, 277, 0, 110, 0, 110,
2274  327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
2275  337, 338, 339, 0, 0, 340, 341, 0, 0, 111,
2276  0, 0, 0, 0, 0, 0, 0, 111, 0, 0,
2277  0, 0, 0, 0, 0, 114, 0, 0, 0, 0,
2278  0, 0, 0, 114, 0, 0, 342, 0, 343, 344,
2279  345, 346, 347, 348, 349, 350, 351, 352, 0, 0,
2280  0, 0, 81, 0, 81, 0, 0, 0, 0, 0,
2281  0, 0, 0, 0, 0, 0, 0, 0, 113, 0,
2282  113, 0, 381, 0, 0, 0, 81, 0, 0, 0,
2283  0, 0, 0, 0, 0, 0, 0, 111, 382, 0,
2284  0, 0, 113, 0, 0, 0, 0, 0, 0, 0,
2285  0, 0, 0, 114, 0, 0, 0, 0, 0, 0,
2286  0, 0, 111, 0, 81, 0, 0, 0, 0, 111,
2287  111, 0, 0, 111, 0, 0, 0, 0, 114, 0,
2288  113, 0, 0, 0, 0, 114, 114, 0, 0, 114,
2289  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2290  111, 111, 0, 0, 0, 0, 0, 0, 0, 0,
2291  0, 0, 0, 0, 111, 381, 114, 114, 81, 0,
2292  0, 81, 0, 81, 0, 0, 0, 0, 0, 523,
2293  114, 382, 0, 0, 113, 0, 0, 113, 977, 113,
2294  0, 0, 111, 0, 0, 0, 0, 0, 0, 0,
2295  0, 0, 0, 111, 978, 0, 0, 0, 114, 0,
2296  0, 0, 0, 0, 0, 0, 0, 0, 81, 114,
2297  0, 0, 0, 0, 0, 0, 81, 0, 0, 0,
2298  0, 0, 0, 0, 113, 327, -620, -620, -620, -620,
2299  332, 333, 113, 0, -620, -620, 0, 0, 0, 0,
2300  340, 341, 111, 0, 111, 0, 0, 0, 0, 0,
2301  111, 0, 111, 0, 0, 0, 0, 0, 114, 0,
2302  114, 0, 0, 0, 0, 0, 114, 0, 114, 0,
2303  0, 0, 0, 343, 344, 345, 346, 347, 348, 349,
2304  350, 351, 352, 0, 0, 0, 81, 0, 0, 0,
2305  0, 327, 328, 329, 330, 331, 332, 333, 334, 0,
2306  336, 337, 113, 0, 0, 0, 340, 341, 0, 0,
2307  0, 81, 0, 0, 0, 0, 0, 0, 81, 81,
2308  0, 0, 81, 0, 0, 0, 0, 113, 0, 0,
2309  0, 0, 0, 0, 113, 113, 0, 0, 113, 343,
2310  344, 345, 346, 347, 348, 349, 350, 351, 352, 81,
2311  81, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2312  0, 0, 0, 81, 0, 113, 113, 0, 0, 0,
2313  0, 0, 0, 0, 0, 0, 0, 0, 0, 113,
2314  327, 328, 329, 330, 331, 332, 333, 974, 0, 336,
2315  337, 81, 0, 0, 0, 340, 341, 0, 0, 0,
2316  0, 0, 81, 0, 0, 0, 0, 113, 0, 0,
2317  0, 0, 0, 0, 0, 0, 0, 0, 113, 0,
2318  0, 0, 0, 0, 0, 0, 0, 0, 343, 344,
2319  345, 346, 347, 348, 349, 350, 351, 352, 0, 0,
2320  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2321  0, 81, 0, 81, 0, 0, 0, 0, 0, 81,
2322  0, 81, 0, 0, 0, 0, 0, 113, 0, 113,
2323  0, 0, 0, 0, 0, 113, 0, 113, -619, 4,
2324  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2325  11, 0, 0, 0, 12, 0, 13, 14, 15, 16,
2326  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2327  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2328  0, 0, 0, 28, 29, 30, 31, 32, 33, 34,
2329  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2330  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2331  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2332  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2333  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2334  58, 59, 60, 61, 62, -601, 0, 0, 0, 0,
2335  0, 0, 0, -601, -601, -601, 0, 0, -601, -601,
2336  -601, 0, -601, 0, 63, 64, 65, 0, 698, 0,
2337  0, -601, -601, -601, -601, 0, 0, -619, 0, -619,
2338  0, 0, -601, -601, 0, -601, -601, -601, -601, -601,
2339  0, 0, 327, 328, 329, 330, 331, 332, 333, 334,
2340  335, 336, 337, 338, 339, 0, 0, 340, 341, 0,
2341  0, 0, 0, -601, -601, -601, -601, -601, -601, -601,
2342  -601, -601, -601, -601, -601, -601, 0, 0, -601, -601,
2343  -601, 0, 755, -601, 0, 0, 0, 0, 342, -601,
2344  343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
2345  0, 0, 0, -601, 0, 0, -601, 0, -106, -601,
2346  -601, -601, -601, -601, -601, -601, -601, -601, -601, -601,
2347  -601, 0, 0, 0, 0, -601, -601, -601, -601, -601,
2348  -504, 0, -601, -601, -601, 0, -601, 0, -504, -504,
2349  -504, 0, 0, -504, -504, -504, 0, -504, 0, 0,
2350  0, 0, 0, 0, 0, -504, 0, -504, -504, -504,
2351  0, 0, 0, 0, 0, 0, 0, -504, -504, 0,
2352  -504, -504, -504, -504, -504, 0, 0, 327, 328, 329,
2353  330, 331, 332, 333, 334, 335, 336, 337, 338, 339,
2354  0, 0, 340, 341, 0, 0, 0, 0, -504, -504,
2355  -504, -504, -504, -504, -504, -504, -504, -504, -504, -504,
2356  -504, 0, 0, -504, -504, -504, 0, -504, -504, 0,
2357  0, 0, 0, 342, -504, 343, 344, 345, 346, 347,
2358  348, 349, 350, 351, 352, 0, 0, 0, -504, 0,
2359  0, -504, 0, -504, -504, -504, -504, -504, -504, -504,
2360  -504, -504, -504, -504, -504, -504, 0, 0, 0, 0,
2361  0, -504, -504, -504, -504, -507, 0, -504, -504, -504,
2362  0, -504, 0, -507, -507, -507, 0, 0, -507, -507,
2363  -507, 0, -507, 0, 0, 0, 0, 0, 0, 0,
2364  -507, 0, -507, -507, -507, 0, 0, 0, 0, 0,
2365  0, 0, -507, -507, 0, -507, -507, -507, -507, -507,
2366  0, 0, 327, 328, 329, 330, 331, 332, 333, 334,
2367  335, 336, 337, -620, -620, 0, 0, 340, 341, 0,
2368  0, 0, 0, -507, -507, -507, -507, -507, -507, -507,
2369  -507, -507, -507, -507, -507, -507, 0, 0, -507, -507,
2370  -507, 0, -507, -507, 0, 0, 0, 0, 0, -507,
2371  343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
2372  0, 0, 0, -507, 0, 0, -507, 0, -507, -507,
2373  -507, -507, -507, -507, -507, -507, -507, -507, -507, -507,
2374  -507, 0, 0, 0, 0, 0, -507, -507, -507, -507,
2375  -602, 0, -507, -507, -507, 0, -507, 0, -602, -602,
2376  -602, 0, 0, -602, -602, -602, 0, -602, 0, 0,
2377  0, 0, 0, 0, 0, 0, -602, -602, -602, -602,
2378  0, 0, 0, 0, 0, 0, 0, -602, -602, 0,
2379  -602, -602, -602, -602, -602, 0, 0, 0, 0, 0,
2380  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2381  0, 0, 0, 0, 0, 0, 0, 0, -602, -602,
2382  -602, -602, -602, -602, -602, -602, -602, -602, -602, -602,
2383  -602, 0, 0, -602, -602, -602, 0, 0, -602, 0,
2384  0, 0, 0, 0, -602, 0, 0, 0, 0, 0,
2385  0, 0, 0, 0, 0, 0, 0, 0, -602, 0,
2386  0, -602, 0, 0, -602, -602, -602, -602, -602, -602,
2387  -602, -602, -602, -602, -602, -602, 0, 0, 0, 0,
2388  -602, -602, -602, -602, -602, -603, 0, -602, -602, -602,
2389  0, -602, 0, -603, -603, -603, 0, 0, -603, -603,
2390  -603, 0, -603, 0, 0, 0, 0, 0, 0, 0,
2391  0, -603, -603, -603, -603, 0, 0, 0, 0, 0,
2392  0, 0, -603, -603, 0, -603, -603, -603, -603, -603,
2393  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2394  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2395  0, 0, 0, -603, -603, -603, -603, -603, -603, -603,
2396  -603, -603, -603, -603, -603, -603, 0, 0, -603, -603,
2397  -603, 0, 0, -603, 0, 0, 0, 0, 0, -603,
2398  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2399  0, 0, 0, -603, 0, 0, -603, 0, 0, -603,
2400  -603, -603, -603, -603, -603, -603, -603, -603, -603, -603,
2401  -603, 0, 0, 0, 0, -603, -603, -603, -603, -603,
2402  -293, 0, -603, -603, -603, 0, -603, 0, -293, -293,
2403  -293, 0, 0, -293, -293, -293, 0, -293, 0, 0,
2404  0, 0, 0, 0, 0, 0, 0, -293, -293, -293,
2405  0, 0, 0, 0, 0, 0, 0, -293, -293, 0,
2406  -293, -293, -293, -293, -293, 0, 0, 0, 0, 0,
2407  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2408  0, 0, 0, 0, 0, 0, 0, 0, -293, -293,
2409  -293, -293, -293, -293, -293, -293, -293, -293, -293, -293,
2410  -293, 0, 0, -293, -293, -293, 0, 756, -293, 0,
2411  0, 0, 0, 0, -293, 0, 0, 0, 0, 0,
2412  0, 0, 0, 0, 0, 0, 0, 0, -293, 0,
2413  0, -293, 0, -108, -293, -293, -293, -293, -293, -293,
2414  -293, -293, -293, -293, -293, -293, 0, 0, 0, 0,
2415  0, -293, -293, -293, -293, -431, 0, -293, -293, -293,
2416  0, -293, 0, -431, -431, -431, 0, 0, -431, -431,
2417  -431, 0, -431, 0, 0, 0, 0, 0, 0, 0,
2418  0, -431, -431, -431, 0, 0, 0, 0, 0, 0,
2419  0, 0, -431, -431, 0, -431, -431, -431, -431, -431,
2420  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2421  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2422  0, 0, 0, -431, -431, -431, -431, -431, -431, -431,
2423  -431, -431, -431, -431, -431, -431, 0, 0, -431, -431,
2424  -431, 0, 0, -431, 0, 0, 0, 0, 0, -431,
2425  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2426  0, 0, 0, -431, 0, 0, 0, 0, 0, -431,
2427  0, -431, -431, -431, -431, -431, -431, -431, -431, -431,
2428  -431, 0, 0, 0, 0, -431, -431, -431, -431, -431,
2429  -285, 227, -431, -431, -431, 0, -431, 0, -285, -285,
2430  -285, 0, 0, -285, -285, -285, 0, -285, 0, 0,
2431  0, 0, 0, 0, 0, 0, 0, -285, -285, -285,
2432  0, 0, 0, 0, 0, 0, 0, -285, -285, 0,
2433  -285, -285, -285, -285, -285, 0, 0, 0, 0, 0,
2434  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2435  0, 0, 0, 0, 0, 0, 0, 0, -285, -285,
2436  -285, -285, -285, -285, -285, -285, -285, -285, -285, -285,
2437  -285, 0, 0, -285, -285, -285, 0, 0, -285, 0,
2438  0, 0, 0, 0, -285, 0, 0, 0, 0, 0,
2439  0, 0, 0, 0, 0, 0, 0, 0, -285, 0,
2440  0, -285, 0, 0, -285, -285, -285, -285, -285, -285,
2441  -285, -285, -285, -285, -285, -285, 0, 0, 0, 0,
2442  0, -285, -285, -285, -285, -421, 0, -285, -285, -285,
2443  0, -285, 0, -421, -421, -421, 0, 0, -421, -421,
2444  -421, 0, -421, 0, 0, 0, 0, 0, 0, 0,
2445  0, -421, -421, -421, 0, 0, 0, 0, 0, 0,
2446  0, 0, -421, -421, 0, -421, -421, -421, -421, -421,
2447  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2448  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2449  0, 0, 0, -421, -421, -421, -421, -421, -421, -421,
2450  -421, -421, -421, -421, -421, -421, 0, 0, -421, -421,
2451  -421, 0, 0, -421, 0, 0, 0, 0, 0, -421,
2452  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2453  0, 0, 0, -421, 0, 0, 0, 0, 0, -421,
2454  0, -421, -421, -421, -421, -421, -421, -421, -421, -421,
2455  -421, 0, 0, 0, 0, -421, -421, -421, -421, -421,
2456  -300, -421, -421, -421, -421, 0, -421, 0, -300, -300,
2457  -300, 0, 0, -300, -300, -300, 0, -300, 0, 0,
2458  0, 0, 0, 0, 0, 0, 0, -300, -300, 0,
2459  0, 0, 0, 0, 0, 0, 0, -300, -300, 0,
2460  -300, -300, -300, -300, -300, 0, 0, 0, 0, 0,
2461  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2462  0, 0, 0, 0, 0, 0, 0, 0, -300, -300,
2463  -300, -300, -300, -300, -300, -300, -300, -300, -300, -300,
2464  -300, 0, 0, -300, -300, -300, 0, 0, -300, 0,
2465  0, 0, 0, 0, -300, 0, 0, 0, 0, 0,
2466  0, 0, 0, 0, 0, 0, 0, 0, -300, 0,
2467  0, 0, 0, 0, -300, 0, -300, -300, -300, -300,
2468  -300, -300, -300, -300, -300, -300, 0, 0, 0, 0,
2469  0, -300, -300, -300, -300, -601, 224, -300, -300, -300,
2470  0, -300, 0, -601, -601, -601, 0, 0, 0, -601,
2471  -601, 0, -601, 0, 0, 0, 0, 0, 0, 0,
2472  0, -601, 0, 0, 0, 0, 0, 0, 0, 0,
2473  0, 0, -601, -601, 0, -601, -601, -601, -601, -601,
2474  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2475  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2476  0, 0, 0, -601, -601, -601, -601, -601, -601, -601,
2477  -601, -601, -601, -601, -601, -601, 0, 0, -601, -601,
2478  -601, 0, 700, 0, 0, 0, 0, 0, 0, 0,
2479  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2480  0, 0, 0, -601, 0, 0, 0, 0, -106, -601,
2481  0, -601, -601, -601, -601, -601, -601, -601, -601, -601,
2482  -601, 0, 0, 0, 0, -601, -601, -601, -601, -97,
2483  -293, 0, -601, 0, -601, 0, -601, 0, -293, -293,
2484  -293, 0, 0, 0, -293, -293, 0, -293, 0, 0,
2485  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2486  0, 0, 0, 0, 0, 0, 0, -293, -293, 0,
2487  -293, -293, -293, -293, -293, 0, 0, 0, 0, 0,
2488  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2489  0, 0, 0, 0, 0, 0, 0, 0, -293, -293,
2490  -293, -293, -293, -293, -293, -293, -293, -293, -293, -293,
2491  -293, 0, 0, -293, -293, -293, 0, 701, 0, 0,
2492  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2493  0, 0, 0, 0, 0, 0, 0, 0, -293, 0,
2494  0, 0, 0, -108, -293, 0, -293, -293, -293, -293,
2495  -293, -293, -293, -293, -293, -293, 0, 0, 0, 0,
2496  0, -293, -293, -293, -99, 0, 0, -293, 0, -293,
2497  248, -293, 5, 6, 7, 8, 9, -619, -619, -619,
2498  10, 11, 0, 0, -619, 12, 0, 13, 14, 15,
2499  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2500  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2501  0, 0, 0, 0, 28, 29, 249, 31, 32, 33,
2502  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2503  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2504  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2505  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2506  0, 51, 52, 0, 53, 0, 0, 54, 55, 56,
2507  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2508  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2509  0, 0, 0, 0, 0, 63, 64, 65, 0, 0,
2510  0, 0, 0, 0, 0, 0, 0, 0, -619, 248,
2511  -619, 5, 6, 7, 8, 9, 0, 0, -619, 10,
2512  11, 0, -619, -619, 12, 0, 13, 14, 15, 16,
2513  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2514  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2515  0, 0, 0, 28, 29, 249, 31, 32, 33, 34,
2516  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2517  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2518  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2519  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2520  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2521  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2522  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2523  0, 0, 0, 0, 63, 64, 65, 0, 0, 0,
2524  0, 0, 0, 0, 0, 0, 0, -619, 248, -619,
2525  5, 6, 7, 8, 9, 0, 0, -619, 10, 11,
2526  0, 0, -619, 12, -619, 13, 14, 15, 16, 17,
2527  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2528  23, 24, 25, 26, 0, 0, 27, 0, 0, 0,
2529  0, 0, 28, 29, 249, 31, 32, 33, 34, 35,
2530  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2531  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2532  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2533  0, 0, 0, 48, 0, 0, 49, 50, 0, 51,
2534  52, 0, 53, 0, 0, 54, 55, 56, 57, 58,
2535  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
2536  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2537  0, 0, 0, 63, 64, 65, 0, 0, 0, 0,
2538  0, 0, 0, 0, 0, 0, -619, 248, -619, 5,
2539  6, 7, 8, 9, 0, 0, -619, 10, 11, 0,
2540  0, -619, 12, 0, 13, 14, 15, 16, 17, 18,
2541  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2542  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2543  0, 28, 29, 249, 31, 32, 33, 34, 35, 36,
2544  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2545  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2546  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2547  0, 0, 48, 0, 0, 49, 50, 0, 51, 52,
2548  0, 53, 0, 0, 54, 55, 56, 57, 58, 59,
2549  60, 61, 62, 0, 0, 0, 0, 0, 0, 0,
2550  248, 0, 5, 6, 7, 8, 9, 0, -619, -619,
2551  10, 11, 63, 64, 65, 12, 0, 13, 14, 15,
2552  16, 17, 18, 19, 0, -619, 0, -619, 0, 20,
2553  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2554  0, 0, 0, 0, 28, 29, 249, 31, 32, 33,
2555  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2556  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2557  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2558  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2559  0, 51, 52, 0, 53, 0, 0, 54, 55, 56,
2560  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2561  0, 0, 0, 248, 0, 5, 6, 7, 8, 9,
2562  0, 0, 0, 10, 11, 63, 64, 65, 12, 0,
2563  13, 14, 15, 16, 17, 18, 19, 0, -619, 0,
2564  -619, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2565  0, 27, 0, 0, 0, 0, 0, 28, 29, 249,
2566  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2567  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2568  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2569  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2570  0, 250, 50, 0, 51, 52, 0, 53, 0, 0,
2571  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2572  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2573  0, 0, 0, 0, 0, 0, 0, 0, 63, 64,
2574  65, 0, 0, 0, 0, 0, 0, 0, 0, -619,
2575  0, -619, 248, -619, 5, 6, 7, 8, 9, 0,
2576  0, 0, 10, 11, 0, 0, 0, 12, 0, 13,
2577  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2578  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2579  27, 0, 0, 0, 0, 0, 28, 29, 249, 31,
2580  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2581  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2582  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2583  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2584  49, 50, 0, 51, 52, 0, 53, 0, 0, 54,
2585  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2586  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2587  0, 0, 0, 0, 0, 0, 0, 63, 64, 65,
2588  0, 0, 0, 0, 0, 0, 0, 0, -619, 0,
2589  -619, 248, -619, 5, 6, 7, 8, 9, 0, 0,
2590  0, 10, 11, 0, 0, 0, 12, 0, 13, 14,
2591  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2592  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2593  0, 0, 0, 0, 0, 28, 29, 249, 31, 32,
2594  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2595  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2596  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2597  0, 0, 0, 0, 0, 0, 48, 0, 0, 49,
2598  50, 0, 51, 52, 0, 53, 0, 0, 54, 55,
2599  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2600  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2601  0, 0, 0, 0, 0, 0, 63, 64, 65, 0,
2602  0, -619, 4, 0, 5, 6, 7, 8, 9, -619,
2603  0, -619, 10, 11, 0, 0, 0, 12, 0, 13,
2604  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2605  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2606  27, 0, 0, 0, 0, 0, 28, 29, 30, 31,
2607  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2608  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2609  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2610  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2611  49, 50, 0, 51, 52, 0, 53, 0, 0, 54,
2612  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2613  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2614  0, 0, 0, 0, 0, 0, 0, 63, 64, 65,
2615  0, 0, -619, 0, 0, 0, 0, 0, 0, 0,
2616  -619, 248, -619, 5, 6, 7, 8, 9, 0, 0,
2617  -619, 10, 11, 0, 0, 0, 12, 0, 13, 14,
2618  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2619  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2620  0, 0, 0, 0, 0, 28, 29, 249, 31, 32,
2621  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2622  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2623  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2624  0, 0, 0, 0, 0, 0, 48, 0, 0, 49,
2625  50, 0, 51, 52, 0, 53, 0, 0, 54, 55,
2626  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2627  0, 0, 0, 0, 248, 0, 5, 6, 7, 8,
2628  9, 0, 0, 0, 10, 11, 63, 64, 65, 12,
2629  0, 13, 14, 15, 16, 17, 18, 19, 0, -619,
2630  0, -619, 0, 20, 21, 22, 23, 24, 25, 26,
2631  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2632  249, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2633  40, 0, 41, 42, 0, 43, 44, 45, 0, 46,
2634  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2635  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
2636  0, 0, 49, 50, 0, 51, 52, 0, 53, 0,
2637  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2638  0, -619, 0, 0, 0, 0, 0, 0, 0, 5,
2639  6, 7, 0, 9, 0, 0, 0, 10, 11, 63,
2640  64, 65, 12, 0, 13, 14, 15, 16, 17, 18,
2641  19, 0, -619, 0, -619, 0, 20, 21, 22, 23,
2642  24, 25, 26, 0, 0, 200, 0, 0, 0, 0,
2643  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2644  37, 38, 39, 40, 201, 41, 42, 0, 43, 44,
2645  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2646  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2647  0, 0, 202, 0, 0, 203, 50, 0, 51, 52,
2648  0, 204, 205, 206, 54, 55, 56, 57, 58, 59,
2649  60, 61, 62, 0, 0, 0, 0, 0, 0, 0,
2650  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2651  10, 11, 63, 207, 65, 12, 0, 13, 14, 15,
2652  16, 17, 18, 19, 0, 0, 0, 231, 0, 20,
2653  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2654  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2655  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2656  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2657  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2658  0, 0, 0, 0, 0, 202, 0, 0, 203, 50,
2659  0, 51, 52, 0, 0, 0, 0, 54, 55, 56,
2660  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2661  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2662  0, 0, 0, 10, 11, 63, 64, 65, 12, 0,
2663  13, 14, 15, 16, 17, 18, 19, 0, 302, 0,
2664  303, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2665  0, 27, 0, 0, 0, 0, 0, 0, 29, 0,
2666  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2667  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2668  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2669  0, 0, 0, 0, 0, 0, 0, 0, 202, 0,
2670  0, 203, 50, 0, 51, 52, 0, 0, 0, 0,
2671  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2672  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2673  7, 8, 9, 0, 0, 0, 10, 11, 63, 64,
2674  65, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2675  0, 0, 0, 231, 0, 20, 21, 22, 23, 24,
2676  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2677  28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
2678  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2679  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2680  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2681  0, 48, 0, 0, 49, 50, 0, 51, 52, 0,
2682  53, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2683  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2684  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2685  11, 63, 64, 65, 12, 0, 13, 14, 15, 16,
2686  17, 18, 19, 0, 498, 0, 0, 0, 20, 21,
2687  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2688  0, 0, 0, 28, 29, 249, 31, 32, 33, 34,
2689  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2690  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2691  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2692  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2693  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2694  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2695  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2696  0, 0, 0, 0, 63, 64, 65, 0, 0, 0,
2697  0, 0, 0, 0, 0, 0, 0, 498, 118, 119,
2698  120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
2699  130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2700  140, 141, 0, 0, 0, 142, 143, 144, 384, 385,
2701  386, 387, 149, 150, 151, 0, 0, 0, 0, 0,
2702  152, 153, 154, 155, 388, 389, 390, 391, 160, 37,
2703  38, 392, 40, 0, 0, 0, 0, 0, 0, 0,
2704  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
2705  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
2706  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2707  177, 178, 0, 0, 0, 0, 0, 0, 0, 0,
2708  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2709  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
2710  188, 0, 189, 190, 0, 0, 0, 0, 0, 0,
2711  191, 393, 118, 119, 120, 121, 122, 123, 124, 125,
2712  126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
2713  136, 137, 138, 139, 140, 141, 0, 0, 0, 142,
2714  143, 144, 145, 146, 147, 148, 149, 150, 151, 0,
2715  0, 0, 0, 0, 152, 153, 154, 155, 156, 157,
2716  158, 159, 160, 280, 281, 161, 282, 0, 0, 0,
2717  0, 0, 0, 0, 0, 162, 163, 164, 165, 166,
2718  167, 168, 169, 170, 0, 0, 171, 172, 0, 0,
2719  173, 174, 175, 176, 0, 0, 0, 0, 0, 0,
2720  0, 0, 0, 0, 177, 178, 0, 0, 0, 0,
2721  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2722  0, 0, 0, 0, 0, 179, 180, 181, 182, 183,
2723  184, 185, 186, 187, 188, 0, 189, 190, 0, 0,
2724  0, 0, 0, 0, 191, 118, 119, 120, 121, 122,
2725  123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
2726  133, 134, 135, 136, 137, 138, 139, 140, 141, 0,
2727  0, 0, 142, 143, 144, 145, 146, 147, 148, 149,
2728  150, 151, 0, 0, 0, 0, 0, 152, 153, 154,
2729  155, 156, 157, 158, 159, 160, 233, 0, 161, 0,
2730  0, 0, 0, 0, 0, 0, 0, 0, 162, 163,
2731  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
2732  172, 0, 0, 173, 174, 175, 176, 0, 0, 0,
2733  0, 0, 0, 0, 0, 0, 0, 177, 178, 0,
2734  0, 55, 0, 0, 0, 0, 0, 0, 0, 0,
2735  0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
2736  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
2737  190, 0, 0, 0, 0, 0, 0, 191, 118, 119,
2738  120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
2739  130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2740  140, 141, 0, 0, 0, 142, 143, 144, 145, 146,
2741  147, 148, 149, 150, 151, 0, 0, 0, 0, 0,
2742  152, 153, 154, 155, 156, 157, 158, 159, 160, 0,
2743  0, 161, 0, 0, 0, 0, 0, 0, 0, 0,
2744  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
2745  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
2746  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2747  177, 178, 0, 0, 55, 0, 0, 0, 0, 0,
2748  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2749  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
2750  188, 0, 189, 190, 0, 0, 0, 0, 0, 0,
2751  191, 118, 119, 120, 121, 122, 123, 124, 125, 126,
2752  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
2753  137, 138, 139, 140, 141, 0, 0, 0, 142, 143,
2754  144, 145, 146, 147, 148, 149, 150, 151, 0, 0,
2755  0, 0, 0, 152, 153, 154, 155, 156, 157, 158,
2756  159, 160, 0, 0, 161, 0, 0, 0, 0, 0,
2757  0, 0, 0, 0, 162, 163, 164, 165, 166, 167,
2758  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
2759  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
2760  0, 0, 0, 177, 178, 0, 0, 0, 0, 0,
2761  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2762  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
2763  185, 186, 187, 188, 0, 189, 190, 5, 6, 7,
2764  0, 9, 0, 191, 0, 10, 11, 0, 0, 0,
2765  12, 0, 13, 14, 15, 238, 239, 18, 19, 0,
2766  0, 0, 0, 0, 240, 241, 242, 23, 24, 25,
2767  26, 0, 0, 200, 0, 0, 0, 0, 0, 0,
2768  268, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2769  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2770  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2771  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2772  269, 0, 0, 203, 50, 0, 51, 52, 0, 0,
2773  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2774  62, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2775  9, 0, 0, 0, 10, 11, 0, 0, 0, 12,
2776  270, 13, 14, 15, 238, 239, 18, 19, 271, 0,
2777  0, 0, 0, 240, 241, 242, 23, 24, 25, 26,
2778  0, 0, 200, 0, 0, 0, 0, 0, 0, 268,
2779  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2780  40, 0, 41, 42, 0, 43, 44, 45, 0, 0,
2781  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2782  0, 0, 0, 0, 0, 0, 0, 0, 0, 269,
2783  0, 0, 203, 50, 0, 51, 52, 0, 0, 0,
2784  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2785  0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
2786  0, 0, 0, 10, 11, 0, 0, 0, 12, 270,
2787  13, 14, 15, 16, 17, 18, 19, 518, 0, 0,
2788  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2789  0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
2790  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2791  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2792  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2793  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2794  0, 49, 50, 0, 51, 52, 0, 53, 0, 0,
2795  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2796  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2797  7, 0, 9, 0, 0, 0, 10, 11, 63, 64,
2798  65, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2799  0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2800  25, 26, 0, 0, 200, 0, 0, 0, 0, 0,
2801  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2802  38, 39, 40, 201, 41, 42, 0, 43, 44, 45,
2803  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2804  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2805  0, 202, 0, 0, 203, 50, 0, 51, 52, 0,
2806  204, 205, 206, 54, 55, 56, 57, 58, 59, 60,
2807  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2808  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2809  11, 63, 207, 65, 12, 0, 13, 14, 15, 16,
2810  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2811  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2812  0, 0, 0, 28, 29, 0, 31, 32, 33, 34,
2813  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2814  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2815  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2816  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2817  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2818  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2819  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2820  0, 0, 10, 11, 63, 64, 65, 12, 0, 13,
2821  14, 15, 238, 239, 18, 19, 0, 0, 0, 0,
2822  0, 240, 241, 242, 23, 24, 25, 26, 0, 0,
2823  200, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2824  32, 33, 34, 35, 36, 37, 38, 39, 40, 201,
2825  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2826  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2827  0, 0, 0, 0, 0, 0, 0, 202, 0, 0,
2828  203, 50, 0, 51, 52, 0, 608, 205, 206, 54,
2829  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2830  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2831  0, 9, 0, 0, 0, 10, 11, 63, 207, 65,
2832  12, 0, 13, 14, 15, 238, 239, 18, 19, 0,
2833  0, 0, 0, 0, 240, 241, 242, 23, 24, 25,
2834  26, 0, 0, 200, 0, 0, 0, 0, 0, 0,
2835  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2836  39, 40, 201, 41, 42, 0, 43, 44, 45, 0,
2837  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2838  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2839  202, 0, 0, 203, 50, 0, 51, 52, 0, 204,
2840  205, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2841  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2842  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2843  63, 207, 65, 12, 0, 13, 14, 15, 238, 239,
2844  18, 19, 0, 0, 0, 0, 0, 240, 241, 242,
2845  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
2846  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2847  36, 37, 38, 39, 40, 201, 41, 42, 0, 43,
2848  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2849  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2850  0, 0, 0, 202, 0, 0, 203, 50, 0, 51,
2851  52, 0, 0, 205, 206, 54, 55, 56, 57, 58,
2852  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
2853  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2854  0, 10, 11, 63, 207, 65, 12, 0, 13, 14,
2855  15, 238, 239, 18, 19, 0, 0, 0, 0, 0,
2856  240, 241, 242, 23, 24, 25, 26, 0, 0, 200,
2857  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
2858  33, 34, 35, 36, 37, 38, 39, 40, 201, 41,
2859  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2860  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2861  0, 0, 0, 0, 0, 0, 202, 0, 0, 203,
2862  50, 0, 51, 52, 0, 608, 205, 0, 54, 55,
2863  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2864  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2865  9, 0, 0, 0, 10, 11, 63, 207, 65, 12,
2866  0, 13, 14, 15, 238, 239, 18, 19, 0, 0,
2867  0, 0, 0, 240, 241, 242, 23, 24, 25, 26,
2868  0, 0, 200, 0, 0, 0, 0, 0, 0, 29,
2869  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2870  40, 201, 41, 42, 0, 43, 44, 45, 0, 46,
2871  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2872  0, 0, 0, 0, 0, 0, 0, 0, 0, 202,
2873  0, 0, 203, 50, 0, 51, 52, 0, 0, 205,
2874  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2875  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2876  6, 7, 0, 9, 0, 0, 0, 10, 11, 63,
2877  207, 65, 12, 0, 13, 14, 15, 16, 17, 18,
2878  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2879  24, 25, 26, 0, 0, 200, 0, 0, 0, 0,
2880  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2881  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2882  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2883  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2884  0, 0, 202, 0, 0, 203, 50, 0, 51, 52,
2885  0, 512, 0, 0, 54, 55, 56, 57, 58, 59,
2886  60, 61, 62, 0, 0, 0, 0, 0, 0, 0,
2887  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2888  10, 11, 63, 207, 65, 12, 0, 13, 14, 15,
2889  238, 239, 18, 19, 0, 0, 0, 0, 0, 240,
2890  241, 242, 23, 24, 25, 26, 0, 0, 200, 0,
2891  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2892  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2893  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2894  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2895  0, 0, 0, 0, 0, 202, 0, 0, 203, 50,
2896  0, 51, 52, 0, 204, 0, 0, 54, 55, 56,
2897  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2898  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2899  0, 0, 0, 10, 11, 63, 207, 65, 12, 0,
2900  13, 14, 15, 238, 239, 18, 19, 0, 0, 0,
2901  0, 0, 240, 241, 242, 23, 24, 25, 26, 0,
2902  0, 200, 0, 0, 0, 0, 0, 0, 29, 0,
2903  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2904  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2905  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2906  0, 0, 0, 0, 0, 0, 0, 0, 202, 0,
2907  0, 203, 50, 0, 51, 52, 0, 816, 0, 0,
2908  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2909  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2910  7, 0, 9, 0, 0, 0, 10, 11, 63, 207,
2911  65, 12, 0, 13, 14, 15, 238, 239, 18, 19,
2912  0, 0, 0, 0, 0, 240, 241, 242, 23, 24,
2913  25, 26, 0, 0, 200, 0, 0, 0, 0, 0,
2914  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2915  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2916  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2917  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2918  0, 202, 0, 0, 203, 50, 0, 51, 52, 0,
2919  512, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2920  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2921  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2922  11, 63, 207, 65, 12, 0, 13, 14, 15, 238,
2923  239, 18, 19, 0, 0, 0, 0, 0, 240, 241,
2924  242, 23, 24, 25, 26, 0, 0, 200, 0, 0,
2925  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2926  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2927  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2928  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2929  0, 0, 0, 0, 202, 0, 0, 203, 50, 0,
2930  51, 52, 0, 608, 0, 0, 54, 55, 56, 57,
2931  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2932  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2933  0, 0, 10, 11, 63, 207, 65, 12, 0, 13,
2934  14, 15, 238, 239, 18, 19, 0, 0, 0, 0,
2935  0, 240, 241, 242, 23, 24, 25, 26, 0, 0,
2936  200, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2937  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2938  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2939  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2940  0, 0, 0, 0, 0, 0, 0, 202, 0, 0,
2941  203, 50, 0, 51, 52, 0, 0, 0, 0, 54,
2942  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2943  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2944  0, 9, 0, 0, 0, 10, 11, 63, 207, 65,
2945  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2946  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2947  26, 0, 0, 27, 0, 0, 0, 0, 0, 0,
2948  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2949  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2950  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2951  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2952  202, 0, 0, 203, 50, 0, 51, 52, 0, 0,
2953  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2954  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2955  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2956  63, 64, 65, 12, 0, 13, 14, 15, 16, 17,
2957  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2958  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
2959  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2960  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2961  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2962  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2963  0, 0, 0, 202, 0, 0, 203, 50, 0, 51,
2964  52, 0, 0, 0, 0, 54, 55, 56, 57, 58,
2965  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
2966  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2967  0, 10, 11, 63, 207, 65, 12, 0, 13, 14,
2968  15, 238, 239, 18, 19, 0, 0, 0, 0, 0,
2969  240, 241, 242, 23, 24, 25, 26, 0, 0, 200,
2970  0, 0, 0, 0, 0, 0, 268, 0, 0, 32,
2971  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2972  42, 0, 43, 44, 45, 0, 0, 0, 0, 0,
2973  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2974  0, 0, 0, 0, 0, 0, 269, 0, 0, 323,
2975  50, 0, 51, 52, 0, 324, 0, 0, 54, 55,
2976  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2977  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2978  10, 11, 0, 0, 0, 12, 270, 13, 14, 15,
2979  238, 239, 18, 19, 0, 0, 0, 0, 0, 240,
2980  241, 242, 23, 24, 25, 26, 0, 0, 200, 0,
2981  0, 0, 0, 0, 0, 268, 0, 0, 32, 33,
2982  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2983  0, 43, 44, 45, 0, 0, 0, 0, 0, 0,
2984  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2985  0, 0, 0, 0, 0, 365, 0, 0, 49, 50,
2986  0, 51, 52, 0, 53, 0, 0, 54, 55, 56,
2987  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2988  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2989  11, 0, 0, 0, 12, 270, 13, 14, 15, 238,
2990  239, 18, 19, 0, 0, 0, 0, 0, 240, 241,
2991  242, 23, 24, 25, 26, 0, 0, 200, 0, 0,
2992  0, 0, 0, 0, 268, 0, 0, 32, 33, 34,
2993  373, 36, 37, 38, 374, 40, 0, 41, 42, 0,
2994  43, 44, 45, 0, 0, 0, 0, 0, 0, 0,
2995  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2996  0, 375, 0, 0, 376, 0, 0, 203, 50, 0,
2997  51, 52, 0, 0, 0, 0, 54, 55, 56, 57,
2998  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2999  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
3000  0, 0, 0, 12, 270, 13, 14, 15, 238, 239,
3001  18, 19, 0, 0, 0, 0, 0, 240, 241, 242,
3002  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
3003  0, 0, 0, 268, 0, 0, 32, 33, 34, 373,
3004  36, 37, 38, 374, 40, 0, 41, 42, 0, 43,
3005  44, 45, 0, 0, 0, 0, 0, 0, 0, 0,
3006  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3007  0, 0, 0, 376, 0, 0, 203, 50, 0, 51,
3008  52, 0, 0, 0, 0, 54, 55, 56, 57, 58,
3009  59, 60, 61, 62, 0, 0, 0, 0, 0, 5,
3010  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
3011  0, 0, 12, 270, 13, 14, 15, 238, 239, 18,
3012  19, 0, 0, 0, 0, 0, 240, 241, 242, 23,
3013  24, 25, 26, 0, 0, 200, 0, 0, 0, 0,
3014  0, 0, 268, 0, 0, 32, 33, 34, 35, 36,
3015  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
3016  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3017  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3018  0, 0, 269, 0, 0, 323, 50, 0, 51, 52,
3019  0, 0, 0, 0, 54, 55, 56, 57, 58, 59,
3020  60, 61, 62, 0, 0, 0, 0, 0, 5, 6,
3021  7, 0, 9, 0, 0, 0, 10, 11, 0, 0,
3022  0, 12, 270, 13, 14, 15, 238, 239, 18, 19,
3023  0, 0, 0, 0, 0, 240, 241, 242, 23, 24,
3024  25, 26, 0, 0, 200, 0, 0, 0, 0, 0,
3025  0, 268, 0, 0, 32, 33, 34, 35, 36, 37,
3026  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
3027  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3028  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3029  0, 893, 0, 0, 203, 50, 0, 51, 52, 0,
3030  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
3031  61, 62, 0, 0, 0, 0, 0, 5, 6, 7,
3032  0, 9, 0, 0, 0, 10, 11, 0, 0, 0,
3033  12, 270, 13, 14, 15, 238, 239, 18, 19, 0,
3034  0, 0, 0, 0, 240, 241, 242, 23, 24, 25,
3035  26, 0, 0, 200, 0, 0, 0, 0, 0, 0,
3036  268, 0, 0, 32, 33, 34, 35, 36, 37, 38,
3037  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
3038  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3039  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3040  973, 0, 0, 203, 50, 0, 51, 52, 0, 0,
3041  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
3042  62, 0, 0, 0, 0, 0, 0, 553, 554, 0,
3043  0, 555, 0, 0, 0, 0, 0, 0, 0, 0,
3044  270, 162, 163, 164, 165, 166, 167, 168, 169, 170,
3045  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
3046  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3047  177, 178, 0, 0, 0, 0, 0, 0, 0, 0,
3048  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3049  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
3050  188, 0, 189, 190, 561, 562, 0, 0, 563, 0,
3051  191, 0, 0, 0, 0, 0, 0, 0, 162, 163,
3052  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
3053  172, 0, 0, 173, 174, 175, 176, 0, 0, 0,
3054  0, 0, 0, 0, 0, 0, 0, 177, 178, 0,
3055  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3056  0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
3057  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
3058  190, 598, 562, 0, 0, 599, 0, 191, 0, 0,
3059  0, 0, 0, 0, 0, 162, 163, 164, 165, 166,
3060  167, 168, 169, 170, 0, 0, 171, 172, 0, 0,
3061  173, 174, 175, 176, 0, 0, 0, 0, 0, 0,
3062  0, 0, 0, 0, 177, 178, 0, 0, 0, 0,
3063  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3064  0, 0, 0, 0, 0, 179, 180, 181, 182, 183,
3065  184, 185, 186, 187, 188, 0, 189, 190, 612, 554,
3066  0, 0, 613, 0, 191, 0, 0, 0, 0, 0,
3067  0, 0, 162, 163, 164, 165, 166, 167, 168, 169,
3068  170, 0, 0, 171, 172, 0, 0, 173, 174, 175,
3069  176, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3070  0, 177, 178, 0, 0, 0, 0, 0, 0, 0,
3071  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3072  0, 0, 179, 180, 181, 182, 183, 184, 185, 186,
3073  187, 188, 0, 189, 190, 615, 562, 0, 0, 616,
3074  0, 191, 0, 0, 0, 0, 0, 0, 0, 162,
3075  163, 164, 165, 166, 167, 168, 169, 170, 0, 0,
3076  171, 172, 0, 0, 173, 174, 175, 176, 0, 0,
3077  0, 0, 0, 0, 0, 0, 0, 0, 177, 178,
3078  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3079  0, 0, 0, 0, 0, 0, 0, 0, 0, 179,
3080  180, 181, 182, 183, 184, 185, 186, 187, 188, 0,
3081  189, 190, 639, 554, 0, 0, 640, 0, 191, 0,
3082  0, 0, 0, 0, 0, 0, 162, 163, 164, 165,
3083  166, 167, 168, 169, 170, 0, 0, 171, 172, 0,
3084  0, 173, 174, 175, 176, 0, 0, 0, 0, 0,
3085  0, 0, 0, 0, 0, 177, 178, 0, 0, 0,
3086  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3087  0, 0, 0, 0, 0, 0, 179, 180, 181, 182,
3088  183, 184, 185, 186, 187, 188, 0, 189, 190, 642,
3089  562, 0, 0, 643, 0, 191, 0, 0, 0, 0,
3090  0, 0, 0, 162, 163, 164, 165, 166, 167, 168,
3091  169, 170, 0, 0, 171, 172, 0, 0, 173, 174,
3092  175, 176, 0, 0, 0, 0, 0, 0, 0, 0,
3093  0, 0, 177, 178, 0, 0, 0, 0, 0, 0,
3094  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3095  0, 0, 0, 179, 180, 181, 182, 183, 184, 185,
3096  186, 187, 188, 0, 189, 190, 727, 554, 0, 0,
3097  728, 0, 191, 0, 0, 0, 0, 0, 0, 0,
3098  162, 163, 164, 165, 166, 167, 168, 169, 170, 0,
3099  0, 171, 172, 0, 0, 173, 174, 175, 176, 0,
3100  0, 0, 0, 0, 0, 0, 0, 0, 0, 177,
3101  178, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3102  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3103  179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
3104  0, 189, 190, 730, 562, 0, 0, 731, 0, 191,
3105  0, 0, 0, 0, 0, 0, 0, 162, 163, 164,
3106  165, 166, 167, 168, 169, 170, 0, 0, 171, 172,
3107  0, 0, 173, 174, 175, 176, 0, 0, 0, 0,
3108  0, 0, 0, 0, 0, 0, 177, 178, 0, 0,
3109  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3110  0, 0, 0, 0, 0, 0, 0, 179, 180, 181,
3111  182, 183, 184, 185, 186, 187, 188, 0, 189, 190,
3112  737, 554, 0, 0, 738, 0, 191, 0, 0, 0,
3113  0, 0, 0, 0, 162, 163, 164, 165, 166, 167,
3114  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
3115  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
3116  0, 0, 0, 177, 178, 0, 0, 0, 0, 0,
3117  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3118  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
3119  185, 186, 187, 188, 0, 189, 190, 1001, 554, 0,
3120  0, 1002, 0, 191, 0, 0, 0, 0, 0, 0,
3121  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
3122  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
3123  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3124  177, 178, 0, 0, 0, 0, 0, 0, 0, 0,
3125  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3126  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
3127  188, 0, 189, 190, 1036, 554, 0, 0, 1037, 0,
3128  191, 0, 0, 0, 0, 0, 0, 0, 162, 163,
3129  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
3130  172, 0, 0, 173, 174, 175, 176, 0, 0, 0,
3131  0, 0, 0, 0, 0, 0, 0, 177, 178, 0,
3132  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3133  0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
3134  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
3135  190, 1039, 562, 0, 0, 1040, 0, 191, 0, 0,
3136  0, 0, 0, 0, 0, 162, 163, 164, 165, 166,
3137  167, 168, 169, 170, 0, 0, 171, 172, 0, 0,
3138  173, 174, 175, 176, 0, 0, 0, 0, 0, 0,
3139  0, 0, 0, 0, 177, 178, 0, 0, 0, 0,
3140  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3141  0, 0, 0, 0, 0, 179, 180, 181, 182, 183,
3142  184, 185, 186, 187, 188, 0, 189, 190, 0, 0,
3143  0, 0, 0, 0, 191
3144 };
3145 
3146 #define yypact_value_is_default(yystate) \
3147  ((yystate) == (-810))
3148 
3149 #define yytable_value_is_error(yytable_value) \
3150  ((yytable_value) == (-620))
3151 
3152 static const yytype_int16 yycheck[] =
3153 {
3154  2, 55, 96, 16, 17, 8, 79, 20, 22, 64,
3155  354, 326, 16, 17, 8, 220, 20, 50, 27, 8,
3156  29, 472, 326, 28, 87, 28, 359, 90, 412, 353,
3157  4, 355, 420, 74, 28, 2, 420, 4, 53, 28,
3158  94, 668, 49, 90, 575, 594, 614, 51, 262, 51,
3159  52, 685, 266, 86, 87, 574, 67, 90, 440, 468,
3160  74, 55, 13, 651, 79, 786, 2, 376, 4, 49,
3161  458, 508, 416, 641, 511, 399, 91, 92, 93, 27,
3162  16, 17, 53, 776, 20, 874, 250, 472, 67, 778,
3163  87, 415, 715, 417, 16, 17, 719, 906, 20, 26,
3164  94, 872, 0, 37, 38, 13, 25, 230, 801, 518,
3165  25, 90, 26, 49, 50, 85, 113, 53, 25, 443,
3166  141, 61, 61, 13, 1, 85, 470, 85, 64, 85,
3167  16, 17, 255, 25, 20, 97, 259, 134, 902, 76,
3168  130, 85, 134, 79, 778, 596, 25, 471, 28, 141,
3169  86, 87, 786, 29, 90, 91, 92, 93, 120, 323,
3170  286, 729, 288, 133, 290, 51, 52, 938, 294, 25,
3171  110, 110, 740, 133, 25, 133, 132, 133, 805, 806,
3172  25, 118, 770, 771, 25, 136, 56, 736, 139, 133,
3173  141, 139, 13, 141, 140, 744, 203, 230, 271, 232,
3174  113, 990, 243, 130, 1013, 252, 657, 141, 897, 136,
3175  140, 224, 214, 226, 227, 134, 130, 136, 220, 134,
3176  224, 992, 226, 944, 429, 227, 134, 134, 13, 13,
3177  237, 139, 134, 141, 622, 111, 580, 621, 622, 1003,
3178  117, 252, 134, 250, 307, 308, 309, 310, 592, 139,
3179  632, 141, 85, 690, 1025, 134, 271, 581, 885, 268,
3180  949, 113, 139, 897, 141, 85, 321, 203, 902, 593,
3181  250, 326, 657, 252, 307, 308, 309, 310, 134, 312,
3182  313, 248, 591, 134, 872, 136, 874, 696, 224, 134,
3183  226, 227, 743, 134, 230, 87, 232, 360, 361, 422,
3184  133, 237, 224, 426, 226, 928, 37, 38, 431, 324,
3185  944, 87, 248, 133, 250, 362, 323, 321, 139, 1008,
3186  141, 113, 326, 68, 447, 113, 136, 360, 361, 452,
3187  100, 141, 306, 852, 87, 271, 963, 113, 224, 306,
3188  226, 354, 375, 323, 311, 61, 134, 402, 403, 65,
3189  938, 939, 354, 324, 139, 139, 141, 141, 743, 485,
3190  113, 355, 25, 61, 85, 140, 492, 61, 140, 1003,
3191  306, 307, 308, 309, 310, 311, 312, 313, 123, 124,
3192  125, 930, 697, 362, 139, 321, 141, 323, 324, 136,
3193  326, 107, 725, 109, 517, 468, 685, 928, 15, 378,
3194  17, 25, 990, 416, 992, 399, 611, 68, 85, 107,
3195  714, 109, 133, 107, 416, 109, 26, 85, 354, 134,
3196  356, 85, 636, 417, 360, 361, 428, 429, 85, 52,
3197  56, 26, 437, 56, 437, 87, 26, 1025, 440, 375,
3198  989, 113, 140, 437, 85, 518, 140, 134, 437, 443,
3199  113, 134, 88, 468, 85, 132, 133, 470, 141, 136,
3200  121, 122, 123, 124, 125, 133, 402, 403, 470, 133,
3201  1038, 134, 87, 440, 137, 85, 133, 471, 141, 867,
3202  416, 87, 87, 867, 935, 87, 134, 703, 134, 113,
3203  85, 132, 133, 141, 710, 85, 136, 786, 113, 61,
3204  789, 132, 133, 518, 440, 507, 508, 113, 61, 511,
3205  134, 113, 61, 137, 450, 136, 557, 141, 130, 134,
3206  130, 26, 132, 133, 565, 52, 412, 54, 55, 56,
3207  57, 68, 468, 542, 470, 130, 136, 132, 133, 137,
3208  130, 136, 132, 133, 558, 107, 136, 109, 110, 85,
3209  113, 560, 566, 138, 107, 760, 109, 110, 107, 600,
3210  109, 110, 595, 570, 637, 572, 568, 580, 670, 455,
3211  672, 131, 576, 85, 59, 60, 577, 87, 580, 592,
3212  85, 56, 518, 916, 87, 110, 600, 581, 87, 922,
3213  592, 87, 625, 85, 573, 574, 132, 133, 600, 593,
3214  605, 61, 605, 113, 134, 614, 110, 134, 587, 611,
3215  113, 605, 110, 902, 113, 904, 605, 113, 68, 742,
3216  132, 133, 637, 696, 134, 130, 110, 132, 133, 58,
3217  632, 136, 641, 68, 570, 134, 572, 61, 761, 68,
3218  132, 133, 697, 94, 580, 700, 701, 107, 685, 109,
3219  110, 774, 707, 708, 748, 944, 592, 946, 594, 595,
3220  85, 134, 951, 704, 666, 632, 668, 96, 97, 732,
3221  711, 17, 735, 1017, 59, 60, 685, 139, 87, 686,
3222  58, 696, 689, 107, 691, 109, 110, 56, 690, 625,
3223  68, 120, 746, 25, 1018, 137, 632, 85, 134, 732,
3224  134, 637, 735, 685, 113, 131, 134, 132, 133, 711,
3225  714, 130, 714, 715, 1003, 717, 1005, 719, 96, 97,
3226  729, 1010, 134, 724, 52, 134, 54, 55, 56, 57,
3227  85, 740, 14, 15, 140, 621, 859, 140, 1027, 134,
3228  741, 134, 120, 780, 132, 133, 85, 784, 871, 113,
3229  686, 134, 746, 689, 733, 691, 136, 10, 760, 1048,
3230  696, 697, 8, 85, 700, 701, 745, 776, 2, 13,
3231  4, 707, 708, 828, 85, 131, 85, 132, 133, 842,
3232  882, 883, 16, 17, 799, 887, 20, 889, 890, 113,
3233  134, 134, 801, 132, 133, 52, 732, 134, 780, 735,
3234  736, 134, 52, 805, 806, 134, 134, 814, 744, 842,
3235  132, 133, 52, 134, 115, 49, 50, 54, 55, 138,
3236  57, 132, 133, 132, 133, 15, 63, 64, 134, 87,
3237  64, 131, 839, 113, 118, 837, 134, 134, 840, 846,
3238  847, 134, 843, 850, 845, 52, 87, 54, 55, 56,
3239  57, 58, 86, 87, 855, 113, 90, 134, 134, 860,
3240  897, 68, 899, 799, 139, 902, 10, 904, 131, 10,
3241  877, 878, 113, 852, 134, 854, 134, 892, 814, 808,
3242  809, 9, 89, 885, 891, 88, 134, 134, 95, 96,
3243  97, 134, 828, 134, 996, 997, 998, 999, 54, 137,
3244  915, 134, 134, 839, 56, 118, 842, 63, 64, 131,
3245  846, 847, 919, 120, 850, 897, 123, 899, 134, 134,
3246  902, 10, 904, 131, 925, 926, 928, 52, 108, 54,
3247  55, 56, 57, 52, 141, 54, 55, 56, 57, 58,
3248  134, 877, 878, 134, 1046, 134, 134, 56, 52, 68,
3249  54, 55, 56, 57, 136, 891, 892, 134, 134, 134,
3250  969, 963, 136, 450, 89, 91, 1003, 711, 1005, 203,
3251  89, 1008, 979, 1010, 981, 93, 1020, 96, 97, 915,
3252  987, 770, 685, 919, 1013, 89, 749, 988, 1019, 99,
3253  224, 95, 226, 227, 930, 294, 230, 57, 232, 94,
3254  935, 120, 780, 237, 1017, 52, 899, 54, 55, 56,
3255  57, 1048, 897, 778, 248, 1017, 250, 1019, 1020, 396,
3256  1021, 1003, 1023, 1005, 1018, -1, 1008, -1, 1010, 1038,
3257  -1, 960, 961, -1, -1, 964, -1, 966, 967, -1,
3258  -1, -1, 89, 979, 68, 981, -1, -1, 95, -1,
3259  -1, 987, -1, 989, 68, -1, -1, -1, -1, 83,
3260  84, 40, 41, 42, 43, 44, 1048, -1, -1, 83,
3261  84, -1, 306, 307, 308, 309, 310, 311, 312, 313,
3262  52, 1017, 54, 55, 56, 57, -1, 321, -1, 323,
3263  -1, -1, 326, -1, 118, 119, 120, 121, 122, 123,
3264  124, 125, 1031, 1032, 1033, 1034, 120, 121, 122, 123,
3265  124, 125, -1, -1, -1, -1, -1, -1, -1, -1,
3266  354, -1, 356, -1, -1, 1054, 360, 361, -1, -1,
3267  -1, -1, -1, 52, -1, 54, 55, 56, 57, 58,
3268  -1, 375, -1, -1, -1, -1, -1, -1, 0, 68,
3269  -1, -1, -1, -1, -1, -1, 8, 9, 10, -1,
3270  -1, 13, 14, 15, -1, 17, -1, -1, 402, 403,
3271  89, -1, -1, -1, 26, 27, 95, 96, 97, -1,
3272  -1, -1, 416, -1, -1, 37, 38, 68, 40, 41,
3273  42, 43, 44, -1, 52, -1, 54, 55, 56, 57,
3274  58, 120, 83, 84, 123, -1, 440, -1, -1, -1,
3275  68, -1, -1, -1, -1, -1, 450, 136, -1, -1,
3276  -1, -1, -1, -1, 16, 17, -1, -1, 20, -1,
3277  -1, 89, -1, 85, -1, -1, 470, 95, 96, 97,
3278  121, 122, 123, 124, 125, -1, -1, -1, -1, -1,
3279  -1, -1, -1, -1, 46, 47, 108, -1, -1, 51,
3280  52, -1, 120, -1, -1, 123, -1, -1, -1, -1,
3281  -1, -1, 64, 65, -1, 44, -1, -1, 130, 131,
3282  -1, 133, -1, -1, 136, 137, -1, 139, -1, 141,
3283  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
3284  69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
3285  79, 80, -1, -1, 83, 84, -1, -1, -1, -1,
3286  -1, -1, -1, -1, -1, -1, 52, -1, 54, 55,
3287  56, 57, 58, -1, -1, -1, 570, -1, 572, -1,
3288  -1, -1, 68, -1, -1, 114, 580, 116, 117, 118,
3289  119, 120, 121, 122, 123, 124, 125, -1, 592, -1,
3290  594, 595, -1, 89, -1, 134, -1, -1, -1, 95,
3291  96, 97, -1, 68, 69, 70, 71, 72, 73, 74,
3292  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3293  -1, 625, -1, -1, 120, -1, -1, 123, 632, -1,
3294  -1, -1, 2, -1, 4, -1, -1, -1, -1, 201,
3295  136, -1, 204, 205, 206, 207, -1, -1, 52, 114,
3296  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3297  125, -1, 224, -1, 226, 227, -1, -1, 52, -1,
3298  54, 55, 56, 57, 58, -1, 141, -1, -1, 49,
3299  -1, -1, 686, 53, 68, 689, -1, 691, -1, -1,
3300  -1, -1, -1, 697, -1, -1, 700, 701, -1, -1,
3301  -1, -1, -1, 707, 708, 89, -1, -1, -1, 79,
3302  -1, 95, 96, 97, -1, -1, -1, -1, -1, -1,
3303  -1, 91, 92, 93, 94, -1, -1, -1, 732, -1,
3304  -1, 735, 736, -1, -1, -1, 120, -1, -1, 123,
3305  744, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3306  -1, -1, -1, -1, -1, -1, -1, -1, -1, 321,
3307  -1, -1, -1, -1, 326, 327, 328, 329, 330, 331,
3308  332, 333, 334, 335, 336, 337, 338, 339, 340, 341,
3309  342, 343, 344, 345, 346, 347, 348, 349, 350, 351,
3310  352, -1, 354, -1, -1, -1, -1, 201, -1, -1,
3311  204, 205, 206, -1, -1, -1, -1, -1, -1, -1,
3312  814, -1, -1, -1, -1, 52, -1, 54, 55, 56,
3313  57, 58, -1, -1, 828, -1, -1, -1, -1, -1,
3314  -1, 68, -1, 203, -1, 839, -1, -1, 842, -1,
3315  402, 403, 846, 847, -1, -1, 850, -1, 410, 411,
3316  412, -1, 89, -1, 416, -1, 418, 419, 420, 96,
3317  97, -1, -1, -1, -1, -1, -1, 237, -1, -1,
3318  -1, -1, -1, 877, 878, -1, -1, 439, 248, -1,
3319  250, -1, 444, 120, -1, -1, -1, 891, -1, -1,
3320  -1, -1, -1, 455, -1, -1, 458, -1, -1, -1,
3321  -1, 271, -1, -1, -1, 2, -1, 4, 470, -1,
3322  -1, -1, -1, -1, -1, 919, -1, 321, -1, -1,
3323  -1, 2, 326, 4, -1, -1, 930, -1, -1, -1,
3324  -1, -1, -1, -1, 496, 497, 306, -1, -1, -1,
3325  -1, 311, -1, -1, -1, -1, -1, -1, -1, -1,
3326  512, -1, 49, 323, 324, -1, 53, -1, -1, -1,
3327  -1, -1, -1, -1, -1, -1, -1, -1, 49, -1,
3328  -1, -1, 53, -1, -1, 979, -1, 981, -1, -1,
3329  -1, -1, 79, 987, -1, 989, 356, -1, -1, -1,
3330  -1, -1, -1, -1, 91, 92, 93, 94, 79, -1,
3331  -1, -1, -1, -1, -1, -1, -1, 411, 412, -1,
3332  91, 92, 93, 1017, 576, -1, 420, -1, 580, -1,
3333  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3334  592, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3335  -1, -1, -1, -1, -1, -1, 608, -1, -1, -1,
3336  -1, 455, -1, -1, 458, -1, -1, -1, -1, 621,
3337  622, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3338  440, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3339  450, -1, -1, -1, -1, -1, -1, 649, -1, -1,
3340  -1, -1, -1, -1, -1, -1, -1, -1, 468, -1,
3341  -1, -1, -1, -1, -1, -1, 203, -1, 512, -1,
3342  -1, -1, -1, -1, 2, -1, 4, -1, -1, -1,
3343  -1, -1, 203, -1, -1, -1, -1, -1, -1, -1,
3344  2, 693, 4, -1, -1, 697, 698, -1, 700, 701,
3345  237, -1, -1, -1, -1, 707, 708, -1, 518, -1,
3346  -1, 248, 714, 250, -1, -1, 237, -1, -1, -1,
3347  -1, 49, -1, -1, -1, -1, -1, 248, -1, 250,
3348  -1, -1, 576, -1, 271, -1, -1, 49, -1, -1,
3349  -1, -1, -1, -1, -1, -1, -1, -1, -1, 751,
3350  271, -1, -1, 755, 756, -1, 758, 759, -1, -1,
3351  570, -1, 572, 91, 608, 767, -1, -1, -1, 306,
3352  -1, -1, -1, -1, 311, -1, -1, 621, 622, -1,
3353  -1, -1, -1, -1, 594, 306, 323, 324, -1, -1,
3354  311, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3355  -1, -1, 323, 324, -1, 649, -1, -1, -1, -1,
3356  -1, -1, -1, -1, 816, -1, -1, -1, 820, 356,
3357  -1, -1, 632, -1, -1, -1, 828, 637, -1, -1,
3358  -1, -1, -1, -1, -1, 356, -1, -1, -1, -1,
3359  -1, -1, -1, -1, -1, -1, -1, 849, -1, 693,
3360  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3361  -1, -1, -1, -1, 866, 867, -1, -1, -1, -1,
3362  714, -1, -1, -1, -1, 203, 686, -1, -1, 689,
3363  -1, 691, -1, -1, -1, -1, 696, -1, -1, -1,
3364  -1, 203, -1, -1, -1, -1, -1, -1, -1, -1,
3365  -1, -1, -1, 440, -1, -1, -1, -1, -1, 237,
3366  -1, -1, -1, 450, -1, -1, -1, -1, -1, 440,
3367  248, -1, 250, 767, -1, 237, 736, -1, -1, 450,
3368  -1, 468, -1, -1, 744, -1, 248, -1, 250, -1,
3369  -1, -1, -1, -1, -1, -1, -1, 468, -1, -1,
3370  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3371  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3372  -1, -1, 816, -1, -1, -1, -1, -1, 306, -1,
3373  -1, 518, -1, 311, -1, -1, -1, -1, -1, 799,
3374  -1, -1, -1, -1, 306, 323, -1, 518, 326, 311,
3375  -1, -1, -1, -1, 814, 849, -1, -1, -1, -1,
3376  -1, 323, -1, -1, -1, 1017, -1, -1, -1, -1,
3377  -1, -1, -1, 867, -1, -1, -1, -1, 356, 839,
3378  -1, -1, -1, 570, -1, 572, 846, 847, -1, -1,
3379  850, -1, -1, -1, 356, -1, -1, -1, -1, 570,
3380  -1, 572, -1, -1, -1, -1, -1, 594, -1, -1,
3381  -1, -1, -1, -1, -1, -1, -1, 877, 878, -1,
3382  -1, -1, -1, 594, -1, -1, -1, -1, -1, -1,
3383  -1, 891, 892, -1, -1, -1, -1, -1, -1, -1,
3384  -1, -1, -1, -1, -1, 632, -1, -1, -1, -1,
3385  637, -1, -1, -1, -1, 915, -1, -1, -1, 919,
3386  -1, 632, 440, -1, -1, -1, 637, -1, -1, -1,
3387  930, -1, 450, -1, -1, -1, -1, -1, 440, -1,
3388  -1, -1, -1, -1, -1, -1, -1, -1, 450, -1,
3389  -1, -1, -1, -1, -1, -1, -1, -1, -1, 686,
3390  -1, -1, 689, -1, 691, 676, 44, -1, -1, 696,
3391  -1, -1, -1, -1, -1, 686, -1, -1, 689, 979,
3392  691, 981, -1, -1, -1, 696, -1, 987, -1, 989,
3393  68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
3394  78, 79, 80, -1, -1, 83, 84, -1, -1, 736,
3395  -1, -1, -1, -1, -1, -1, -1, 744, -1, -1,
3396  -1, -1, -1, -1, -1, 736, -1, -1, -1, -1,
3397  -1, -1, -1, 744, -1, -1, 114, -1, 116, 117,
3398  118, 119, 120, 121, 122, 123, 124, 125, -1, -1,
3399  -1, -1, 570, -1, 572, -1, -1, -1, -1, -1,
3400  -1, -1, -1, -1, -1, -1, -1, -1, 570, -1,
3401  572, -1, 799, -1, -1, -1, 594, -1, -1, -1,
3402  -1, -1, -1, -1, -1, -1, -1, 814, 799, -1,
3403  -1, -1, 594, -1, -1, -1, -1, -1, -1, -1,
3404  -1, -1, -1, 814, -1, -1, -1, -1, -1, -1,
3405  -1, -1, 839, -1, 632, -1, -1, -1, -1, 846,
3406  847, -1, -1, 850, -1, -1, -1, -1, 839, -1,
3407  632, -1, -1, -1, -1, 846, 847, -1, -1, 850,
3408  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3409  877, 878, -1, -1, -1, -1, -1, -1, -1, -1,
3410  -1, -1, -1, -1, 891, 892, 877, 878, 686, -1,
3411  -1, 689, -1, 691, -1, -1, -1, -1, -1, 697,
3412  891, 892, -1, -1, 686, -1, -1, 689, 915, 691,
3413  -1, -1, 919, -1, -1, -1, -1, -1, -1, -1,
3414  -1, -1, -1, 930, 915, -1, -1, -1, 919, -1,
3415  -1, -1, -1, -1, -1, -1, -1, -1, 736, 930,
3416  -1, -1, -1, -1, -1, -1, 744, -1, -1, -1,
3417  -1, -1, -1, -1, 736, 68, 69, 70, 71, 72,
3418  73, 74, 744, -1, 77, 78, -1, -1, -1, -1,
3419  83, 84, 979, -1, 981, -1, -1, -1, -1, -1,
3420  987, -1, 989, -1, -1, -1, -1, -1, 979, -1,
3421  981, -1, -1, -1, -1, -1, 987, -1, 989, -1,
3422  -1, -1, -1, 116, 117, 118, 119, 120, 121, 122,
3423  123, 124, 125, -1, -1, -1, 814, -1, -1, -1,
3424  -1, 68, 69, 70, 71, 72, 73, 74, 75, -1,
3425  77, 78, 814, -1, -1, -1, 83, 84, -1, -1,
3426  -1, 839, -1, -1, -1, -1, -1, -1, 846, 847,
3427  -1, -1, 850, -1, -1, -1, -1, 839, -1, -1,
3428  -1, -1, -1, -1, 846, 847, -1, -1, 850, 116,
3429  117, 118, 119, 120, 121, 122, 123, 124, 125, 877,
3430  878, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3431  -1, -1, -1, 891, -1, 877, 878, -1, -1, -1,
3432  -1, -1, -1, -1, -1, -1, -1, -1, -1, 891,
3433  68, 69, 70, 71, 72, 73, 74, 915, -1, 77,
3434  78, 919, -1, -1, -1, 83, 84, -1, -1, -1,
3435  -1, -1, 930, -1, -1, -1, -1, 919, -1, -1,
3436  -1, -1, -1, -1, -1, -1, -1, -1, 930, -1,
3437  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
3438  118, 119, 120, 121, 122, 123, 124, 125, -1, -1,
3439  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3440  -1, 979, -1, 981, -1, -1, -1, -1, -1, 987,
3441  -1, 989, -1, -1, -1, -1, -1, 979, -1, 981,
3442  -1, -1, -1, -1, -1, 987, -1, 989, 0, 1,
3443  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
3444  12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
3445  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3446  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3447  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3448  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3449  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3450  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3451  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3452  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3453  102, 103, 104, 105, 106, 0, -1, -1, -1, -1,
3454  -1, -1, -1, 8, 9, 10, -1, -1, 13, 14,
3455  15, -1, 17, -1, 126, 127, 128, -1, 44, -1,
3456  -1, 26, 27, 28, 29, -1, -1, 139, -1, 141,
3457  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3458  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3459  76, 77, 78, 79, 80, -1, -1, 83, 84, -1,
3460  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3461  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3462  85, -1, 87, 88, -1, -1, -1, -1, 114, 94,
3463  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3464  -1, -1, -1, 108, -1, -1, 111, -1, 113, 114,
3465  115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3466  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3467  0, -1, 137, 138, 139, -1, 141, -1, 8, 9,
3468  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3469  -1, -1, -1, -1, -1, 25, -1, 27, 28, 29,
3470  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3471  40, 41, 42, 43, 44, -1, -1, 68, 69, 70,
3472  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3473  -1, -1, 83, 84, -1, -1, -1, -1, 68, 69,
3474  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3475  80, -1, -1, 83, 84, 85, -1, 87, 88, -1,
3476  -1, -1, -1, 114, 94, 116, 117, 118, 119, 120,
3477  121, 122, 123, 124, 125, -1, -1, -1, 108, -1,
3478  -1, 111, -1, 113, 114, 115, 116, 117, 118, 119,
3479  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3480  -1, 131, 132, 133, 134, 0, -1, 137, 138, 139,
3481  -1, 141, -1, 8, 9, 10, -1, -1, 13, 14,
3482  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3483  25, -1, 27, 28, 29, -1, -1, -1, -1, -1,
3484  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3485  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3486  76, 77, 78, 79, 80, -1, -1, 83, 84, -1,
3487  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3488  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3489  85, -1, 87, 88, -1, -1, -1, -1, -1, 94,
3490  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3491  -1, -1, -1, 108, -1, -1, 111, -1, 113, 114,
3492  115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3493  125, -1, -1, -1, -1, -1, 131, 132, 133, 134,
3494  0, -1, 137, 138, 139, -1, 141, -1, 8, 9,
3495  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3496  -1, -1, -1, -1, -1, -1, 26, 27, 28, 29,
3497  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3498  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3499  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3500  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3501  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3502  80, -1, -1, 83, 84, 85, -1, -1, 88, -1,
3503  -1, -1, -1, -1, 94, -1, -1, -1, -1, -1,
3504  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3505  -1, 111, -1, -1, 114, 115, 116, 117, 118, 119,
3506  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3507  130, 131, 132, 133, 134, 0, -1, 137, 138, 139,
3508  -1, 141, -1, 8, 9, 10, -1, -1, 13, 14,
3509  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3510  -1, 26, 27, 28, 29, -1, -1, -1, -1, -1,
3511  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3512  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3513  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3514  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3515  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3516  85, -1, -1, 88, -1, -1, -1, -1, -1, 94,
3517  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3518  -1, -1, -1, 108, -1, -1, 111, -1, -1, 114,
3519  115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3520  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3521  0, -1, 137, 138, 139, -1, 141, -1, 8, 9,
3522  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3523  -1, -1, -1, -1, -1, -1, -1, 27, 28, 29,
3524  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3525  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3526  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3527  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3528  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3529  80, -1, -1, 83, 84, 85, -1, 87, 88, -1,
3530  -1, -1, -1, -1, 94, -1, -1, -1, -1, -1,
3531  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3532  -1, 111, -1, 113, 114, 115, 116, 117, 118, 119,
3533  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3534  -1, 131, 132, 133, 134, 0, -1, 137, 138, 139,
3535  -1, 141, -1, 8, 9, 10, -1, -1, 13, 14,
3536  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3537  -1, 26, 27, 28, -1, -1, -1, -1, -1, -1,
3538  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3539  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3540  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3541  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3542  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3543  85, -1, -1, 88, -1, -1, -1, -1, -1, 94,
3544  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3545  -1, -1, -1, 108, -1, -1, -1, -1, -1, 114,
3546  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3547  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3548  0, 136, 137, 138, 139, -1, 141, -1, 8, 9,
3549  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3550  -1, -1, -1, -1, -1, -1, -1, 27, 28, 29,
3551  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3552  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3553  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3554  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3555  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3556  80, -1, -1, 83, 84, 85, -1, -1, 88, -1,
3557  -1, -1, -1, -1, 94, -1, -1, -1, -1, -1,
3558  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3559  -1, 111, -1, -1, 114, 115, 116, 117, 118, 119,
3560  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3561  -1, 131, 132, 133, 134, 0, -1, 137, 138, 139,
3562  -1, 141, -1, 8, 9, 10, -1, -1, 13, 14,
3563  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3564  -1, 26, 27, 28, -1, -1, -1, -1, -1, -1,
3565  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3566  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3567  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3568  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3569  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3570  85, -1, -1, 88, -1, -1, -1, -1, -1, 94,
3571  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3572  -1, -1, -1, 108, -1, -1, -1, -1, -1, 114,
3573  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3574  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3575  0, 136, 137, 138, 139, -1, 141, -1, 8, 9,
3576  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3577  -1, -1, -1, -1, -1, -1, -1, 27, 28, -1,
3578  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3579  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3580  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3581  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3582  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3583  80, -1, -1, 83, 84, 85, -1, -1, 88, -1,
3584  -1, -1, -1, -1, 94, -1, -1, -1, -1, -1,
3585  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3586  -1, -1, -1, -1, 114, -1, 116, 117, 118, 119,
3587  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3588  -1, 131, 132, 133, 134, 0, 136, 137, 138, 139,
3589  -1, 141, -1, 8, 9, 10, -1, -1, -1, 14,
3590  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3591  -1, 26, -1, -1, -1, -1, -1, -1, -1, -1,
3592  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3593  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3594  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3595  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3596  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3597  85, -1, 87, -1, -1, -1, -1, -1, -1, -1,
3598  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3599  -1, -1, -1, 108, -1, -1, -1, -1, 113, 114,
3600  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3601  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3602  0, -1, 137, -1, 139, -1, 141, -1, 8, 9,
3603  10, -1, -1, -1, 14, 15, -1, 17, -1, -1,
3604  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3605  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3606  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3607  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3608  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3609  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3610  80, -1, -1, 83, 84, 85, -1, 87, -1, -1,
3611  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3612  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3613  -1, -1, -1, 113, 114, -1, 116, 117, 118, 119,
3614  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3615  -1, 131, 132, 133, 134, -1, -1, 137, -1, 139,
3616  1, 141, 3, 4, 5, 6, 7, 8, 9, 10,
3617  11, 12, -1, -1, 15, 16, -1, 18, 19, 20,
3618  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3619  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3620  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3621  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3622  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3623  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3624  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3625  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
3626  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3627  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3628  -1, -1, -1, -1, -1, 126, 127, 128, -1, -1,
3629  -1, -1, -1, -1, -1, -1, -1, -1, 139, 1,
3630  141, 3, 4, 5, 6, 7, -1, -1, 10, 11,
3631  12, -1, 14, 15, 16, -1, 18, 19, 20, 21,
3632  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3633  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3634  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3635  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3636  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3637  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3638  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3639  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3640  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3641  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3642  -1, -1, -1, -1, 126, 127, 128, -1, -1, -1,
3643  -1, -1, -1, -1, -1, -1, -1, 139, 1, 141,
3644  3, 4, 5, 6, 7, -1, -1, 10, 11, 12,
3645  -1, -1, 15, 16, 17, 18, 19, 20, 21, 22,
3646  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3647  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3648  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3649  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
3650  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3651  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3652  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3653  93, -1, 95, -1, -1, 98, 99, 100, 101, 102,
3654  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
3655  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3656  -1, -1, -1, 126, 127, 128, -1, -1, -1, -1,
3657  -1, -1, -1, -1, -1, -1, 139, 1, 141, 3,
3658  4, 5, 6, 7, -1, -1, 10, 11, 12, -1,
3659  -1, 15, 16, -1, 18, 19, 20, 21, 22, 23,
3660  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3661  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3662  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3663  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3664  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
3665  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3666  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3667  -1, 95, -1, -1, 98, 99, 100, 101, 102, 103,
3668  104, 105, 106, -1, -1, -1, -1, -1, -1, -1,
3669  1, -1, 3, 4, 5, 6, 7, -1, 9, 10,
3670  11, 12, 126, 127, 128, 16, -1, 18, 19, 20,
3671  21, 22, 23, 24, -1, 139, -1, 141, -1, 30,
3672  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3673  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3674  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3675  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3676  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3677  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3678  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
3679  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3680  -1, -1, -1, 1, -1, 3, 4, 5, 6, 7,
3681  -1, -1, -1, 11, 12, 126, 127, 128, 16, -1,
3682  18, 19, 20, 21, 22, 23, 24, -1, 139, -1,
3683  141, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3684  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3685  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3686  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3687  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3688  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3689  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3690  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3691  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3692  -1, -1, -1, -1, -1, -1, -1, -1, 126, 127,
3693  128, -1, -1, -1, -1, -1, -1, -1, -1, 137,
3694  -1, 139, 1, 141, 3, 4, 5, 6, 7, -1,
3695  -1, -1, 11, 12, -1, -1, -1, 16, -1, 18,
3696  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3697  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3698  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3699  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3700  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3701  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3702  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3703  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3704  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3705  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3706  -1, -1, -1, -1, -1, -1, -1, 126, 127, 128,
3707  -1, -1, -1, -1, -1, -1, -1, -1, 137, -1,
3708  139, 1, 141, 3, 4, 5, 6, 7, -1, -1,
3709  -1, 11, 12, -1, -1, -1, 16, -1, 18, 19,
3710  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3711  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3712  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
3713  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3714  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3715  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3716  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3717  90, -1, 92, 93, -1, 95, -1, -1, 98, 99,
3718  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
3719  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3720  -1, -1, -1, -1, -1, -1, 126, 127, 128, -1,
3721  -1, 131, 1, -1, 3, 4, 5, 6, 7, 139,
3722  -1, 141, 11, 12, -1, -1, -1, 16, -1, 18,
3723  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3724  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3725  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3726  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3727  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3728  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3729  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3730  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3731  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3732  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3733  -1, -1, -1, -1, -1, -1, -1, 126, 127, 128,
3734  -1, -1, 131, -1, -1, -1, -1, -1, -1, -1,
3735  139, 1, 141, 3, 4, 5, 6, 7, -1, -1,
3736  10, 11, 12, -1, -1, -1, 16, -1, 18, 19,
3737  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3738  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3739  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
3740  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3741  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3742  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3743  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3744  90, -1, 92, 93, -1, 95, -1, -1, 98, 99,
3745  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
3746  -1, -1, -1, -1, 1, -1, 3, 4, 5, 6,
3747  7, -1, -1, -1, 11, 12, 126, 127, 128, 16,
3748  -1, 18, 19, 20, 21, 22, 23, 24, -1, 139,
3749  -1, 141, -1, 30, 31, 32, 33, 34, 35, 36,
3750  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
3751  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
3752  57, -1, 59, 60, -1, 62, 63, 64, -1, 66,
3753  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3754  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3755  -1, -1, 89, 90, -1, 92, 93, -1, 95, -1,
3756  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3757  -1, 108, -1, -1, -1, -1, -1, -1, -1, 3,
3758  4, 5, -1, 7, -1, -1, -1, 11, 12, 126,
3759  127, 128, 16, -1, 18, 19, 20, 21, 22, 23,
3760  24, -1, 139, -1, 141, -1, 30, 31, 32, 33,
3761  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3762  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3763  54, 55, 56, 57, 58, 59, 60, -1, 62, 63,
3764  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
3765  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3766  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3767  -1, 95, 96, 97, 98, 99, 100, 101, 102, 103,
3768  104, 105, 106, -1, -1, -1, -1, -1, -1, -1,
3769  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3770  11, 12, 126, 127, 128, 16, -1, 18, 19, 20,
3771  21, 22, 23, 24, -1, -1, -1, 141, -1, 30,
3772  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3773  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3774  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3775  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3776  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3777  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3778  -1, 92, 93, -1, -1, -1, -1, 98, 99, 100,
3779  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3780  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
3781  -1, -1, -1, 11, 12, 126, 127, 128, 16, -1,
3782  18, 19, 20, 21, 22, 23, 24, -1, 139, -1,
3783  141, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3784  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3785  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3786  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3787  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3788  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3789  -1, 89, 90, -1, 92, 93, -1, -1, -1, -1,
3790  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3791  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
3792  5, 6, 7, -1, -1, -1, 11, 12, 126, 127,
3793  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3794  -1, -1, -1, 141, -1, 30, 31, 32, 33, 34,
3795  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3796  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3797  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3798  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3799  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3800  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3801  95, -1, -1, 98, 99, 100, 101, 102, 103, 104,
3802  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3803  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
3804  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
3805  22, 23, 24, -1, 139, -1, -1, -1, 30, 31,
3806  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3807  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3808  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3809  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3810  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3811  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3812  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3813  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3814  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3815  -1, -1, -1, -1, 126, 127, 128, -1, -1, -1,
3816  -1, -1, -1, -1, -1, -1, -1, 139, 3, 4,
3817  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3818  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3819  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3820  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
3821  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3822  55, 56, 57, -1, -1, -1, -1, -1, -1, -1,
3823  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3824  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3825  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3826  95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
3827  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3828  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3829  125, -1, 127, 128, -1, -1, -1, -1, -1, -1,
3830  135, 136, 3, 4, 5, 6, 7, 8, 9, 10,
3831  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
3832  21, 22, 23, 24, 25, 26, -1, -1, -1, 30,
3833  31, 32, 33, 34, 35, 36, 37, 38, 39, -1,
3834  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3835  51, 52, 53, 54, 55, 56, 57, -1, -1, -1,
3836  -1, -1, -1, -1, -1, 66, 67, 68, 69, 70,
3837  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
3838  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
3839  -1, -1, -1, -1, 95, 96, -1, -1, -1, -1,
3840  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3841  -1, -1, -1, -1, -1, 116, 117, 118, 119, 120,
3842  121, 122, 123, 124, 125, -1, 127, 128, -1, -1,
3843  -1, -1, -1, -1, 135, 3, 4, 5, 6, 7,
3844  8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
3845  18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
3846  -1, -1, 30, 31, 32, 33, 34, 35, 36, 37,
3847  38, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3848  48, 49, 50, 51, 52, 53, 54, -1, 56, -1,
3849  -1, -1, -1, -1, -1, -1, -1, -1, 66, 67,
3850  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
3851  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
3852  -1, -1, -1, -1, -1, -1, -1, 95, 96, -1,
3853  -1, 99, -1, -1, -1, -1, -1, -1, -1, -1,
3854  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
3855  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
3856  128, -1, -1, -1, -1, -1, -1, 135, 3, 4,
3857  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3858  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3859  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3860  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
3861  45, 46, 47, 48, 49, 50, 51, 52, 53, -1,
3862  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
3863  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3864  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3865  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3866  95, 96, -1, -1, 99, -1, -1, -1, -1, -1,
3867  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3868  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3869  125, -1, 127, 128, -1, -1, -1, -1, -1, -1,
3870  135, 3, 4, 5, 6, 7, 8, 9, 10, 11,
3871  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
3872  22, 23, 24, 25, 26, -1, -1, -1, 30, 31,
3873  32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
3874  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3875  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
3876  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
3877  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
3878  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
3879  -1, -1, -1, 95, 96, -1, -1, -1, -1, -1,
3880  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3881  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
3882  122, 123, 124, 125, -1, 127, 128, 3, 4, 5,
3883  -1, 7, -1, 135, -1, 11, 12, -1, -1, -1,
3884  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3885  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3886  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3887  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3888  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3889  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3890  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3891  86, -1, -1, 89, 90, -1, 92, 93, -1, -1,
3892  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
3893  106, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3894  7, -1, -1, -1, 11, 12, -1, -1, -1, 16,
3895  126, 18, 19, 20, 21, 22, 23, 24, 134, -1,
3896  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3897  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3898  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3899  57, -1, 59, 60, -1, 62, 63, 64, -1, -1,
3900  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3901  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3902  -1, -1, 89, 90, -1, 92, 93, -1, -1, -1,
3903  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3904  -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
3905  -1, -1, -1, 11, 12, -1, -1, -1, 16, 126,
3906  18, 19, 20, 21, 22, 23, 24, 134, -1, -1,
3907  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3908  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3909  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3910  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3911  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3912  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3913  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3914  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3915  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
3916  5, -1, 7, -1, -1, -1, 11, 12, 126, 127,
3917  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3918  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3919  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3920  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3921  55, 56, 57, 58, 59, 60, -1, 62, 63, 64,
3922  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3923  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3924  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3925  95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
3926  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3927  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
3928  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
3929  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3930  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3931  -1, -1, -1, 45, 46, -1, 48, 49, 50, 51,
3932  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3933  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3934  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3935  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3936  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3937  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3938  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3939  -1, -1, 11, 12, 126, 127, 128, 16, -1, 18,
3940  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3941  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3942  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3943  49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
3944  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3945  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3946  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3947  89, 90, -1, 92, 93, -1, 95, 96, 97, 98,
3948  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3949  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3950  -1, 7, -1, -1, -1, 11, 12, 126, 127, 128,
3951  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3952  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3953  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3954  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3955  56, 57, 58, 59, 60, -1, 62, 63, 64, -1,
3956  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3957  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3958  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3959  96, -1, 98, 99, 100, 101, 102, 103, 104, 105,
3960  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3961  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
3962  126, 127, 128, 16, -1, 18, 19, 20, 21, 22,
3963  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3964  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3965  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3966  53, 54, 55, 56, 57, 58, 59, 60, -1, 62,
3967  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3968  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3969  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3970  93, -1, -1, 96, 97, 98, 99, 100, 101, 102,
3971  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
3972  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3973  -1, 11, 12, 126, 127, 128, 16, -1, 18, 19,
3974  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3975  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3976  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3977  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
3978  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3979  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3980  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3981  90, -1, 92, 93, -1, 95, 96, -1, 98, 99,
3982  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
3983  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3984  7, -1, -1, -1, 11, 12, 126, 127, 128, 16,
3985  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3986  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3987  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3988  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3989  57, 58, 59, 60, -1, 62, 63, 64, -1, 66,
3990  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3991  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3992  -1, -1, 89, 90, -1, 92, 93, -1, -1, 96,
3993  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3994  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3995  4, 5, -1, 7, -1, -1, -1, 11, 12, 126,
3996  127, 128, 16, -1, 18, 19, 20, 21, 22, 23,
3997  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3998  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3999  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4000  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
4001  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
4002  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4003  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
4004  -1, 95, -1, -1, 98, 99, 100, 101, 102, 103,
4005  104, 105, 106, -1, -1, -1, -1, -1, -1, -1,
4006  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4007  11, 12, 126, 127, 128, 16, -1, 18, 19, 20,
4008  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4009  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4010  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4011  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4012  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
4013  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4014  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
4015  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
4016  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
4017  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4018  -1, -1, -1, 11, 12, 126, 127, 128, 16, -1,
4019  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4020  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4021  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4022  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4023  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
4024  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4025  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
4026  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
4027  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
4028  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
4029  5, -1, 7, -1, -1, -1, 11, 12, 126, 127,
4030  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
4031  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4032  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4033  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
4034  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
4035  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
4036  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4037  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
4038  95, -1, -1, 98, 99, 100, 101, 102, 103, 104,
4039  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
4040  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4041  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
4042  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4043  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4044  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4045  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
4046  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
4047  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4048  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
4049  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
4050  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
4051  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4052  -1, -1, 11, 12, 126, 127, 128, 16, -1, 18,
4053  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4054  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4055  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4056  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4057  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
4058  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4059  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
4060  89, 90, -1, 92, 93, -1, -1, -1, -1, 98,
4061  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
4062  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4063  -1, 7, -1, -1, -1, 11, 12, 126, 127, 128,
4064  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4065  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4066  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4067  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4068  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
4069  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
4070  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4071  86, -1, -1, 89, 90, -1, 92, 93, -1, -1,
4072  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
4073  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4074  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4075  126, 127, 128, 16, -1, 18, 19, 20, 21, 22,
4076  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4077  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4078  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4079  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
4080  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
4081  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4082  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
4083  93, -1, -1, -1, -1, 98, 99, 100, 101, 102,
4084  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
4085  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4086  -1, 11, 12, 126, 127, 128, 16, -1, 18, 19,
4087  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4088  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4089  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4090  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4091  60, -1, 62, 63, 64, -1, -1, -1, -1, -1,
4092  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4093  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
4094  90, -1, 92, 93, -1, 95, -1, -1, 98, 99,
4095  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
4096  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4097  11, 12, -1, -1, -1, 16, 126, 18, 19, 20,
4098  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4099  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4100  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4101  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4102  -1, 62, 63, 64, -1, -1, -1, -1, -1, -1,
4103  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4104  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
4105  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
4106  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
4107  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4108  12, -1, -1, -1, 16, 126, 18, 19, 20, 21,
4109  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4110  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4111  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4112  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
4113  62, 63, 64, -1, -1, -1, -1, -1, -1, -1,
4114  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4115  -1, 83, -1, -1, 86, -1, -1, 89, 90, -1,
4116  92, 93, -1, -1, -1, -1, 98, 99, 100, 101,
4117  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
4118  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4119  -1, -1, -1, 16, 126, 18, 19, 20, 21, 22,
4120  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4121  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4122  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4123  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
4124  63, 64, -1, -1, -1, -1, -1, -1, -1, -1,
4125  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4126  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
4127  93, -1, -1, -1, -1, 98, 99, 100, 101, 102,
4128  103, 104, 105, 106, -1, -1, -1, -1, -1, 3,
4129  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
4130  -1, -1, 16, 126, 18, 19, 20, 21, 22, 23,
4131  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4132  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4133  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4134  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
4135  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4136  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4137  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
4138  -1, -1, -1, -1, 98, 99, 100, 101, 102, 103,
4139  104, 105, 106, -1, -1, -1, -1, -1, 3, 4,
4140  5, -1, 7, -1, -1, -1, 11, 12, -1, -1,
4141  -1, 16, 126, 18, 19, 20, 21, 22, 23, 24,
4142  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4143  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4144  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
4145  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
4146  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4147  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4148  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
4149  -1, -1, -1, 98, 99, 100, 101, 102, 103, 104,
4150  105, 106, -1, -1, -1, -1, -1, 3, 4, 5,
4151  -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
4152  16, 126, 18, 19, 20, 21, 22, 23, 24, -1,
4153  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4154  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4155  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4156  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
4157  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4158  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4159  86, -1, -1, 89, 90, -1, 92, 93, -1, -1,
4160  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
4161  106, -1, -1, -1, -1, -1, -1, 52, 53, -1,
4162  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
4163  126, 66, 67, 68, 69, 70, 71, 72, 73, 74,
4164  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
4165  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4166  95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
4167  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4168  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
4169  125, -1, 127, 128, 52, 53, -1, -1, 56, -1,
4170  135, -1, -1, -1, -1, -1, -1, -1, 66, 67,
4171  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
4172  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
4173  -1, -1, -1, -1, -1, -1, -1, 95, 96, -1,
4174  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4175  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
4176  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
4177  128, 52, 53, -1, -1, 56, -1, 135, -1, -1,
4178  -1, -1, -1, -1, -1, 66, 67, 68, 69, 70,
4179  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
4180  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
4181  -1, -1, -1, -1, 95, 96, -1, -1, -1, -1,
4182  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4183  -1, -1, -1, -1, -1, 116, 117, 118, 119, 120,
4184  121, 122, 123, 124, 125, -1, 127, 128, 52, 53,
4185  -1, -1, 56, -1, 135, -1, -1, -1, -1, -1,
4186  -1, -1, 66, 67, 68, 69, 70, 71, 72, 73,
4187  74, -1, -1, 77, 78, -1, -1, 81, 82, 83,
4188  84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4189  -1, 95, 96, -1, -1, -1, -1, -1, -1, -1,
4190  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4191  -1, -1, 116, 117, 118, 119, 120, 121, 122, 123,
4192  124, 125, -1, 127, 128, 52, 53, -1, -1, 56,
4193  -1, 135, -1, -1, -1, -1, -1, -1, -1, 66,
4194  67, 68, 69, 70, 71, 72, 73, 74, -1, -1,
4195  77, 78, -1, -1, 81, 82, 83, 84, -1, -1,
4196  -1, -1, -1, -1, -1, -1, -1, -1, 95, 96,
4197  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4198  -1, -1, -1, -1, -1, -1, -1, -1, -1, 116,
4199  117, 118, 119, 120, 121, 122, 123, 124, 125, -1,
4200  127, 128, 52, 53, -1, -1, 56, -1, 135, -1,
4201  -1, -1, -1, -1, -1, -1, 66, 67, 68, 69,
4202  70, 71, 72, 73, 74, -1, -1, 77, 78, -1,
4203  -1, 81, 82, 83, 84, -1, -1, -1, -1, -1,
4204  -1, -1, -1, -1, -1, 95, 96, -1, -1, -1,
4205  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4206  -1, -1, -1, -1, -1, -1, 116, 117, 118, 119,
4207  120, 121, 122, 123, 124, 125, -1, 127, 128, 52,
4208  53, -1, -1, 56, -1, 135, -1, -1, -1, -1,
4209  -1, -1, -1, 66, 67, 68, 69, 70, 71, 72,
4210  73, 74, -1, -1, 77, 78, -1, -1, 81, 82,
4211  83, 84, -1, -1, -1, -1, -1, -1, -1, -1,
4212  -1, -1, 95, 96, -1, -1, -1, -1, -1, -1,
4213  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4214  -1, -1, -1, 116, 117, 118, 119, 120, 121, 122,
4215  123, 124, 125, -1, 127, 128, 52, 53, -1, -1,
4216  56, -1, 135, -1, -1, -1, -1, -1, -1, -1,
4217  66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
4218  -1, 77, 78, -1, -1, 81, 82, 83, 84, -1,
4219  -1, -1, -1, -1, -1, -1, -1, -1, -1, 95,
4220  96, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4221  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4222  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
4223  -1, 127, 128, 52, 53, -1, -1, 56, -1, 135,
4224  -1, -1, -1, -1, -1, -1, -1, 66, 67, 68,
4225  69, 70, 71, 72, 73, 74, -1, -1, 77, 78,
4226  -1, -1, 81, 82, 83, 84, -1, -1, -1, -1,
4227  -1, -1, -1, -1, -1, -1, 95, 96, -1, -1,
4228  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4229  -1, -1, -1, -1, -1, -1, -1, 116, 117, 118,
4230  119, 120, 121, 122, 123, 124, 125, -1, 127, 128,
4231  52, 53, -1, -1, 56, -1, 135, -1, -1, -1,
4232  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
4233  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
4234  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
4235  -1, -1, -1, 95, 96, -1, -1, -1, -1, -1,
4236  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4237  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
4238  122, 123, 124, 125, -1, 127, 128, 52, 53, -1,
4239  -1, 56, -1, 135, -1, -1, -1, -1, -1, -1,
4240  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
4241  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
4242  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4243  95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
4244  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4245  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
4246  125, -1, 127, 128, 52, 53, -1, -1, 56, -1,
4247  135, -1, -1, -1, -1, -1, -1, -1, 66, 67,
4248  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
4249  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
4250  -1, -1, -1, -1, -1, -1, -1, 95, 96, -1,
4251  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4252  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
4253  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
4254  128, 52, 53, -1, -1, 56, -1, 135, -1, -1,
4255  -1, -1, -1, -1, -1, 66, 67, 68, 69, 70,
4256  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
4257  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
4258  -1, -1, -1, -1, 95, 96, -1, -1, -1, -1,
4259  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4260  -1, -1, -1, -1, -1, 116, 117, 118, 119, 120,
4261  121, 122, 123, 124, 125, -1, 127, 128, -1, -1,
4262  -1, -1, -1, -1, 135
4263 };
4264 
4265 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4266  symbol of state STATE-NUM. */
4267 static const yytype_uint16 yystos[] =
4268 {
4269  0, 143, 144, 0, 1, 3, 4, 5, 6, 7,
4270  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4271  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4272  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4273  57, 59, 60, 62, 63, 64, 66, 67, 86, 89,
4274  90, 92, 93, 95, 98, 99, 100, 101, 102, 103,
4275  104, 105, 106, 126, 127, 128, 145, 146, 147, 154,
4276  156, 157, 159, 160, 163, 164, 165, 167, 168, 169,
4277  171, 172, 182, 196, 214, 215, 216, 217, 218, 219,
4278  220, 221, 222, 223, 224, 250, 251, 265, 266, 267,
4279  268, 269, 270, 271, 274, 276, 277, 289, 291, 292,
4280  293, 294, 295, 296, 297, 328, 339, 147, 3, 4,
4281  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
4282  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
4283  25, 26, 30, 31, 32, 33, 34, 35, 36, 37,
4284  38, 39, 45, 46, 47, 48, 49, 50, 51, 52,
4285  53, 56, 66, 67, 68, 69, 70, 71, 72, 73,
4286  74, 77, 78, 81, 82, 83, 84, 95, 96, 116,
4287  117, 118, 119, 120, 121, 122, 123, 124, 125, 127,
4288  128, 135, 175, 176, 177, 178, 180, 181, 289, 291,
4289  39, 58, 86, 89, 95, 96, 97, 127, 164, 172,
4290  182, 184, 189, 192, 194, 214, 293, 294, 296, 297,
4291  326, 327, 189, 189, 136, 190, 191, 136, 186, 190,
4292  136, 141, 333, 54, 177, 333, 148, 130, 21, 22,
4293  30, 31, 32, 163, 182, 214, 182, 56, 1, 47,
4294  89, 150, 151, 152, 154, 166, 167, 339, 157, 198,
4295  185, 194, 326, 339, 184, 325, 326, 339, 46, 86,
4296  126, 134, 171, 196, 214, 293, 294, 297, 242, 243,
4297  54, 55, 57, 175, 281, 290, 280, 281, 282, 140,
4298  272, 140, 278, 140, 275, 140, 279, 59, 60, 159,
4299  182, 182, 139, 141, 332, 337, 338, 40, 41, 42,
4300  43, 44, 37, 38, 26, 130, 186, 190, 256, 28,
4301  248, 113, 134, 89, 95, 168, 113, 68, 69, 70,
4302  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
4303  83, 84, 114, 116, 117, 118, 119, 120, 121, 122,
4304  123, 124, 125, 85, 132, 133, 197, 157, 158, 158,
4305  201, 203, 158, 332, 338, 86, 165, 172, 214, 230,
4306  293, 294, 297, 52, 56, 83, 86, 173, 174, 214,
4307  293, 294, 297, 174, 33, 34, 35, 36, 49, 50,
4308  51, 52, 56, 136, 175, 295, 323, 85, 133, 331,
4309  256, 268, 87, 87, 134, 184, 56, 184, 184, 184,
4310  113, 88, 134, 193, 339, 85, 132, 133, 87, 87,
4311  134, 193, 189, 333, 334, 189, 188, 189, 194, 326,
4312  339, 157, 334, 157, 54, 63, 64, 155, 136, 183,
4313  130, 150, 85, 133, 87, 154, 153, 166, 137, 332,
4314  338, 334, 199, 334, 138, 134, 141, 336, 134, 336,
4315  131, 336, 333, 56, 59, 60, 168, 170, 134, 85,
4316  132, 133, 244, 61, 107, 109, 110, 283, 110, 283,
4317  110, 65, 283, 110, 110, 273, 283, 110, 61, 110,
4318  110, 110, 273, 110, 61, 110, 68, 68, 139, 147,
4319  158, 158, 158, 158, 154, 157, 157, 258, 257, 94,
4320  161, 249, 95, 159, 184, 194, 195, 166, 134, 171,
4321  134, 156, 159, 172, 182, 184, 195, 182, 182, 182,
4322  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
4323  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
4324  182, 182, 182, 52, 53, 56, 180, 255, 329, 330,
4325  188, 52, 53, 56, 180, 254, 329, 149, 150, 13,
4326  226, 337, 226, 158, 158, 332, 17, 259, 56, 85,
4327  132, 133, 25, 157, 52, 56, 173, 1, 117, 298,
4328  337, 85, 132, 133, 210, 324, 211, 331, 52, 56,
4329  329, 159, 182, 159, 182, 179, 182, 184, 95, 184,
4330  192, 326, 52, 56, 188, 52, 56, 327, 334, 137,
4331  334, 134, 134, 334, 177, 200, 182, 145, 131, 329,
4332  329, 182, 130, 334, 152, 334, 326, 134, 170, 52,
4333  56, 188, 52, 56, 52, 54, 55, 56, 57, 58,
4334  68, 89, 95, 96, 97, 120, 123, 136, 246, 301,
4335  303, 304, 305, 306, 307, 308, 311, 312, 313, 314,
4336  317, 318, 319, 320, 321, 285, 284, 140, 283, 140,
4337  140, 140, 182, 182, 76, 118, 237, 238, 339, 237,
4338  162, 237, 184, 134, 334, 170, 134, 113, 44, 333,
4339  87, 87, 186, 190, 253, 333, 335, 87, 87, 186,
4340  190, 252, 10, 225, 8, 261, 339, 150, 13, 150,
4341  27, 227, 337, 227, 259, 194, 225, 52, 56, 188,
4342  52, 56, 205, 208, 337, 299, 207, 52, 56, 173,
4343  188, 149, 157, 136, 300, 303, 212, 186, 187, 190,
4344  339, 44, 177, 184, 193, 87, 87, 335, 87, 87,
4345  326, 157, 131, 145, 336, 168, 335, 113, 184, 52,
4346  89, 95, 231, 232, 233, 305, 303, 245, 134, 302,
4347  134, 322, 339, 52, 134, 322, 134, 302, 52, 134,
4348  302, 52, 286, 54, 55, 57, 288, 297, 52, 58,
4349  234, 236, 239, 307, 309, 310, 313, 315, 316, 319,
4350  321, 333, 150, 150, 237, 150, 95, 184, 170, 182,
4351  115, 159, 182, 159, 182, 161, 186, 138, 87, 159,
4352  182, 159, 182, 161, 187, 184, 195, 262, 339, 15,
4353  229, 339, 14, 228, 229, 229, 202, 204, 225, 134,
4354  226, 335, 158, 337, 158, 149, 335, 225, 334, 303,
4355  149, 337, 175, 256, 248, 182, 87, 134, 334, 131,
4356  184, 233, 134, 305, 134, 334, 239, 29, 111, 247,
4357  301, 306, 317, 319, 308, 313, 321, 307, 314, 319,
4358  307, 287, 113, 86, 214, 239, 118, 134, 235, 134,
4359  322, 322, 134, 235, 134, 235, 139, 10, 131, 150,
4360  10, 184, 182, 159, 182, 88, 263, 339, 150, 9,
4361  264, 339, 158, 225, 225, 150, 150, 184, 150, 227,
4362  209, 337, 225, 334, 225, 213, 334, 232, 134, 95,
4363  231, 137, 150, 150, 134, 302, 134, 302, 322, 134,
4364  302, 134, 302, 302, 150, 214, 56, 85, 118, 234,
4365  316, 319, 309, 313, 307, 315, 319, 307, 52, 240,
4366  241, 304, 131, 86, 172, 214, 293, 294, 297, 226,
4367  150, 226, 225, 225, 229, 259, 260, 206, 149, 300,
4368  134, 232, 134, 305, 10, 131, 307, 319, 307, 307,
4369  108, 52, 56, 134, 235, 134, 235, 322, 134, 235,
4370  134, 235, 235, 134, 333, 56, 85, 132, 133, 150,
4371  150, 150, 225, 149, 232, 134, 302, 134, 302, 302,
4372  302, 307, 319, 307, 307, 241, 52, 56, 188, 52,
4373  56, 261, 228, 225, 225, 232, 307, 235, 134, 235,
4374  235, 235, 335, 302, 307, 235
4375 };
4376 
4377 #define yyerrok (yyerrstatus = 0)
4378 #define yyclearin (yychar = YYEMPTY)
4379 #define YYEMPTY (-2)
4380 #define YYEOF 0
4381 
4382 #define YYACCEPT goto yyacceptlab
4383 #define YYABORT goto yyabortlab
4384 #define YYERROR goto yyerrorlab
4385 
4386 
4387 /* Like YYERROR except do call yyerror. This remains here temporarily
4388  to ease the transition to the new meaning of YYERROR, for GCC.
4389  Once GCC version 2 has supplanted version 1, this can go. However,
4390  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
4391  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
4392  discussed. */
4393 
4394 #define YYFAIL goto yyerrlab
4395 #if defined YYFAIL
4396  /* This is here to suppress warnings from the GCC cpp's
4397  -Wunused-macros. Normally we don't worry about that warning, but
4398  some users do, and we want to make it easy for users to remove
4399  YYFAIL uses, which will produce warnings from Bison 2.5. */
4400 #endif
4401 
4402 #define YYRECOVERING() (!!yyerrstatus)
4403 
4404 #define YYBACKUP(Token, Value) \
4405 do \
4406  if (yychar == YYEMPTY && yylen == 1) \
4407  { \
4408  yychar = (Token); \
4409  yylval = (Value); \
4410  YYPOPSTACK (1); \
4411  goto yybackup; \
4412  } \
4413  else \
4414  { \
4415  parser_yyerror (parser, YY_("syntax error: cannot back up")); \
4416  YYERROR; \
4417  } \
4418 while (YYID (0))
4419 
4420 
4421 #define YYTERROR 1
4422 #define YYERRCODE 256
4423 
4424 
4425 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
4426  If N is 0, then set CURRENT to the empty location which ends
4427  the previous symbol: RHS[0] (always defined). */
4428 
4429 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
4430 #ifndef YYLLOC_DEFAULT
4431 # define YYLLOC_DEFAULT(Current, Rhs, N) \
4432  do \
4433  if (YYID (N)) \
4434  { \
4435  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
4436  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
4437  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
4438  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
4439  } \
4440  else \
4441  { \
4442  (Current).first_line = (Current).last_line = \
4443  YYRHSLOC (Rhs, 0).last_line; \
4444  (Current).first_column = (Current).last_column = \
4445  YYRHSLOC (Rhs, 0).last_column; \
4446  } \
4447  while (YYID (0))
4448 #endif
4449 
4450 
4451 /* This macro is provided for backward compatibility. */
4452 
4453 #ifndef YY_LOCATION_PRINT
4454 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
4455 #endif
4456 
4457 
4458 /* YYLEX -- calling `yylex' with the right arguments. */
4459 
4460 #ifdef YYLEX_PARAM
4461 # define YYLEX yylex (&yylval, YYLEX_PARAM)
4462 #else
4463 # define YYLEX yylex (&yylval, parser)
4464 #endif
4465 
4466 /* Enable debugging if requested. */
4467 #if YYDEBUG
4468 
4469 # ifndef YYFPRINTF
4470 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
4471 # define YYFPRINTF fprintf
4472 # endif
4473 
4474 # define YYDPRINTF(Args) \
4475 do { \
4476  if (yydebug) \
4477  YYFPRINTF Args; \
4478 } while (YYID (0))
4479 
4480 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
4481 do { \
4482  if (yydebug) \
4483  { \
4484  YYFPRINTF (stderr, "%s ", Title); \
4485  yy_symbol_print (stderr, \
4486  Type, Value, parser); \
4487  YYFPRINTF (stderr, "\n"); \
4488  } \
4489 } while (YYID (0))
4490 
4491 
4492 /*--------------------------------.
4493 | Print this symbol on YYOUTPUT. |
4494 `--------------------------------*/
4495 
4496 /*ARGSUSED*/
4497 #if (defined __STDC__ || defined __C99__FUNC__ \
4498  || defined __cplusplus || defined _MSC_VER)
4499 static void
4500 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4501 #else
4502 static void
4503 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
4504  FILE *yyoutput;
4505  int yytype;
4506  YYSTYPE const * const yyvaluep;
4507  struct parser_params *parser;
4508 #endif
4509 {
4510  if (!yyvaluep)
4511  return;
4512  YYUSE (parser);
4513 # ifdef YYPRINT
4514  if (yytype < YYNTOKENS)
4515  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4516 # else
4517  YYUSE (yyoutput);
4518 # endif
4519  switch (yytype)
4520  {
4521  default:
4522  break;
4523  }
4524 }
4525 
4526 
4527 /*--------------------------------.
4528 | Print this symbol on YYOUTPUT. |
4529 `--------------------------------*/
4530 
4531 #if (defined __STDC__ || defined __C99__FUNC__ \
4532  || defined __cplusplus || defined _MSC_VER)
4533 static void
4534 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4535 #else
4536 static void
4537 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
4538  FILE *yyoutput;
4539  int yytype;
4540  YYSTYPE const * const yyvaluep;
4541  struct parser_params *parser;
4542 #endif
4543 {
4544  if (yytype < YYNTOKENS)
4545  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4546  else
4547  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4548 
4549  yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
4550  YYFPRINTF (yyoutput, ")");
4551 }
4552 
4553 /*------------------------------------------------------------------.
4554 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4555 | TOP (included). |
4556 `------------------------------------------------------------------*/
4557 
4558 #if (defined __STDC__ || defined __C99__FUNC__ \
4559  || defined __cplusplus || defined _MSC_VER)
4560 static void
4561 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4562 #else
4563 static void
4564 yy_stack_print (yybottom, yytop)
4565  yytype_int16 *yybottom;
4566  yytype_int16 *yytop;
4567 #endif
4568 {
4569  YYFPRINTF (stderr, "Stack now");
4570  for (; yybottom <= yytop; yybottom++)
4571  {
4572  int yybot = *yybottom;
4573  YYFPRINTF (stderr, " %d", yybot);
4574  }
4575  YYFPRINTF (stderr, "\n");
4576 }
4577 
4578 # define YY_STACK_PRINT(Bottom, Top) \
4579 do { \
4580  if (yydebug) \
4581  yy_stack_print ((Bottom), (Top)); \
4582 } while (YYID (0))
4583 
4584 
4585 /*------------------------------------------------.
4586 | Report that the YYRULE is going to be reduced. |
4587 `------------------------------------------------*/
4588 
4589 #if (defined __STDC__ || defined __C99__FUNC__ \
4590  || defined __cplusplus || defined _MSC_VER)
4591 static void
4592 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
4593 #else
4594 static void
4595 yy_reduce_print (yyvsp, yyrule, parser)
4596  YYSTYPE *yyvsp;
4597  int yyrule;
4598  struct parser_params *parser;
4599 #endif
4600 {
4601  int yynrhs = yyr2[yyrule];
4602  int yyi;
4603  unsigned long int yylno = yyrline[yyrule];
4604  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4605  yyrule - 1, yylno);
4606  /* The symbols being reduced. */
4607  for (yyi = 0; yyi < yynrhs; yyi++)
4608  {
4609  YYFPRINTF (stderr, " $%d = ", yyi + 1);
4610  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4611  &(yyvsp[(yyi + 1) - (yynrhs)])
4612  , parser);
4613  YYFPRINTF (stderr, "\n");
4614  }
4615 }
4616 
4617 # define YY_REDUCE_PRINT(Rule) \
4618 do { \
4619  if (yydebug) \
4620  yy_reduce_print (yyvsp, Rule, parser); \
4621 } while (YYID (0))
4622 
4623 /* Nonzero means print parse trace. It is left uninitialized so that
4624  multiple parsers can coexist. */
4625 #ifndef yydebug
4626 int yydebug;
4627 #endif
4628 #else /* !YYDEBUG */
4629 # define YYDPRINTF(Args)
4630 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4631 # define YY_STACK_PRINT(Bottom, Top)
4632 # define YY_REDUCE_PRINT(Rule)
4633 #endif /* !YYDEBUG */
4634 
4635 
4636 /* YYINITDEPTH -- initial size of the parser's stacks. */
4637 #ifndef YYINITDEPTH
4638 # define YYINITDEPTH 200
4639 #endif
4640 
4641 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4642  if the built-in stack extension method is used).
4643 
4644  Do not make this value too large; the results are undefined if
4645  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4646  evaluated with infinite-precision integer arithmetic. */
4647 
4648 #ifndef YYMAXDEPTH
4649 # define YYMAXDEPTH 10000
4650 #endif
4651 
4652 
4653 #if YYERROR_VERBOSE
4654 
4655 # ifndef yystrlen
4656 # if defined __GLIBC__ && defined _STRING_H
4657 # define yystrlen strlen
4658 # else
4659 /* Return the length of YYSTR. */
4660 #if (defined __STDC__ || defined __C99__FUNC__ \
4661  || defined __cplusplus || defined _MSC_VER)
4662 static YYSIZE_T
4663 yystrlen (const char *yystr)
4664 #else
4665 static YYSIZE_T
4666 yystrlen (yystr)
4667  const char *yystr;
4668 #endif
4669 {
4670  YYSIZE_T yylen;
4671  for (yylen = 0; yystr[yylen]; yylen++)
4672  continue;
4673  return yylen;
4674 }
4675 # endif
4676 # endif
4677 
4678 # ifndef yystpcpy
4679 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4680 # define yystpcpy stpcpy
4681 # else
4682 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4683  YYDEST. */
4684 #if (defined __STDC__ || defined __C99__FUNC__ \
4685  || defined __cplusplus || defined _MSC_VER)
4686 static char *
4687 yystpcpy (char *yydest, const char *yysrc)
4688 #else
4689 static char *
4690 yystpcpy (yydest, yysrc)
4691  char *yydest;
4692  const char *yysrc;
4693 #endif
4694 {
4695  char *yyd = yydest;
4696  const char *yys = yysrc;
4697 
4698  while ((*yyd++ = *yys++) != '\0')
4699  continue;
4700 
4701  return yyd - 1;
4702 }
4703 # endif
4704 # endif
4705 
4706 # ifndef yytnamerr
4707 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4708  quotes and backslashes, so that it's suitable for yyerror. The
4709  heuristic is that double-quoting is unnecessary unless the string
4710  contains an apostrophe, a comma, or backslash (other than
4711  backslash-backslash). YYSTR is taken from yytname. If YYRES is
4712  null, do not copy; instead, return the length of what the result
4713  would have been. */
4714 static YYSIZE_T
4715 yytnamerr (char *yyres, const char *yystr)
4716 {
4717  if (*yystr == '"')
4718  {
4719  YYSIZE_T yyn = 0;
4720  char const *yyp = yystr;
4721 
4722  for (;;)
4723  switch (*++yyp)
4724  {
4725  case '\'':
4726  case ',':
4727  goto do_not_strip_quotes;
4728 
4729  case '\\':
4730  if (*++yyp != '\\')
4731  goto do_not_strip_quotes;
4732  /* Fall through. */
4733  default:
4734  if (yyres)
4735  yyres[yyn] = *yyp;
4736  yyn++;
4737  break;
4738 
4739  case '"':
4740  if (yyres)
4741  yyres[yyn] = '\0';
4742  return yyn;
4743  }
4744  do_not_strip_quotes: ;
4745  }
4746 
4747  if (! yyres)
4748  return yystrlen (yystr);
4749 
4750  return yystpcpy (yyres, yystr) - yyres;
4751 }
4752 # endif
4753 
4754 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
4755  about the unexpected token YYTOKEN for the state stack whose top is
4756  YYSSP.
4757 
4758  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
4759  not large enough to hold the message. In that case, also set
4760  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
4761  required number of bytes is too large to store. */
4762 static int
4763 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
4764  yytype_int16 *yyssp, int yytoken)
4765 {
4766  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
4767  YYSIZE_T yysize = yysize0;
4768  YYSIZE_T yysize1;
4769  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4770  /* Internationalized format string. */
4771  const char *yyformat = 0;
4772  /* Arguments of yyformat. */
4773  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4774  /* Number of reported tokens (one for the "unexpected", one per
4775  "expected"). */
4776  int yycount = 0;
4777 
4778  /* There are many possibilities here to consider:
4779  - Assume YYFAIL is not used. It's too flawed to consider. See
4780  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
4781  for details. YYERROR is fine as it does not invoke this
4782  function.
4783  - If this state is a consistent state with a default action, then
4784  the only way this function was invoked is if the default action
4785  is an error action. In that case, don't check for expected
4786  tokens because there are none.
4787  - The only way there can be no lookahead present (in yychar) is if
4788  this state is a consistent state with a default action. Thus,
4789  detecting the absence of a lookahead is sufficient to determine
4790  that there is no unexpected or expected token to report. In that
4791  case, just report a simple "syntax error".
4792  - Don't assume there isn't a lookahead just because this state is a
4793  consistent state with a default action. There might have been a
4794  previous inconsistent state, consistent state with a non-default
4795  action, or user semantic action that manipulated yychar.
4796  - Of course, the expected token list depends on states to have
4797  correct lookahead information, and it depends on the parser not
4798  to perform extra reductions after fetching a lookahead from the
4799  scanner and before detecting a syntax error. Thus, state merging
4800  (from LALR or IELR) and default reductions corrupt the expected
4801  token list. However, the list is correct for canonical LR with
4802  one exception: it will still contain any token that will not be
4803  accepted due to an error action in a later state.
4804  */
4805  if (yytoken != YYEMPTY)
4806  {
4807  int yyn = yypact[*yyssp];
4808  yyarg[yycount++] = yytname[yytoken];
4809  if (!yypact_value_is_default (yyn))
4810  {
4811  /* Start YYX at -YYN if negative to avoid negative indexes in
4812  YYCHECK. In other words, skip the first -YYN actions for
4813  this state because they are default actions. */
4814  int yyxbegin = yyn < 0 ? -yyn : 0;
4815  /* Stay within bounds of both yycheck and yytname. */
4816  int yychecklim = YYLAST - yyn + 1;
4817  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4818  int yyx;
4819 
4820  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4821  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
4822  && !yytable_value_is_error (yytable[yyx + yyn]))
4823  {
4824  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4825  {
4826  yycount = 1;
4827  yysize = yysize0;
4828  break;
4829  }
4830  yyarg[yycount++] = yytname[yyx];
4831  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4832  if (! (yysize <= yysize1
4833  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4834  return 2;
4835  yysize = yysize1;
4836  }
4837  }
4838  }
4839 
4840  switch (yycount)
4841  {
4842 # define YYCASE_(N, S) \
4843  case N: \
4844  yyformat = S; \
4845  break
4846  YYCASE_(0, YY_("syntax error"));
4847  YYCASE_(1, YY_("syntax error, unexpected %s"));
4848  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
4849  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
4850  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
4851  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
4852 # undef YYCASE_
4853  }
4854 
4855  yysize1 = yysize + yystrlen (yyformat);
4856  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4857  return 2;
4858  yysize = yysize1;
4859 
4860  if (*yymsg_alloc < yysize)
4861  {
4862  *yymsg_alloc = 2 * yysize;
4863  if (! (yysize <= *yymsg_alloc
4864  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
4865  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
4866  return 1;
4867  }
4868 
4869  /* Avoid sprintf, as that infringes on the user's name space.
4870  Don't have undefined behavior even if the translation
4871  produced a string with the wrong number of "%s"s. */
4872  {
4873  char *yyp = *yymsg;
4874  int yyi = 0;
4875  while ((*yyp = *yyformat) != '\0')
4876  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
4877  {
4878  yyp += yytnamerr (yyp, yyarg[yyi++]);
4879  yyformat += 2;
4880  }
4881  else
4882  {
4883  yyp++;
4884  yyformat++;
4885  }
4886  }
4887  return 0;
4888 }
4889 #endif /* YYERROR_VERBOSE */
4890 
4891 /*-----------------------------------------------.
4892 | Release the memory associated to this symbol. |
4893 `-----------------------------------------------*/
4894 
4895 /*ARGSUSED*/
4896 #if (defined __STDC__ || defined __C99__FUNC__ \
4897  || defined __cplusplus || defined _MSC_VER)
4898 static void
4899 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
4900 #else
4901 static void
4902 yydestruct (yymsg, yytype, yyvaluep, parser)
4903  const char *yymsg;
4904  int yytype;
4905  YYSTYPE *yyvaluep;
4906  struct parser_params *parser;
4907 #endif
4908 {
4909  YYUSE (yyvaluep);
4910  YYUSE (parser);
4911 
4912  if (!yymsg)
4913  yymsg = "Deleting";
4914  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4915 
4916  switch (yytype)
4917  {
4918 
4919  default:
4920  break;
4921  }
4922 }
4923 
4924 
4925 /* Prevent warnings from -Wmissing-prototypes. */
4926 #ifdef YYPARSE_PARAM
4927 #if defined __STDC__ || defined __cplusplus
4928 int yyparse (void *YYPARSE_PARAM);
4929 #else
4930 int yyparse ();
4931 #endif
4932 #else /* ! YYPARSE_PARAM */
4933 #if defined __STDC__ || defined __cplusplus
4934 int yyparse (struct parser_params *parser);
4935 #else
4936 int yyparse ();
4937 #endif
4938 #endif /* ! YYPARSE_PARAM */
4939 
4940 
4941 /*----------.
4942 | yyparse. |
4943 `----------*/
4944 
4945 #ifdef YYPARSE_PARAM
4946 #if (defined __STDC__ || defined __C99__FUNC__ \
4947  || defined __cplusplus || defined _MSC_VER)
4948 int
4949 yyparse (void *YYPARSE_PARAM)
4950 #else
4951 int
4952 yyparse (YYPARSE_PARAM)
4953  void *YYPARSE_PARAM;
4954 #endif
4955 #else /* ! YYPARSE_PARAM */
4956 #if (defined __STDC__ || defined __C99__FUNC__ \
4957  || defined __cplusplus || defined _MSC_VER)
4958 int
4959 yyparse (struct parser_params *parser)
4960 #else
4961 int
4962 yyparse (parser)
4963  struct parser_params *parser;
4964 #endif
4965 #endif
4966 {
4967 /* The lookahead symbol. */
4968 int yychar;
4969 
4970 /* The semantic value of the lookahead symbol. */
4971 YYSTYPE yylval;
4972 
4973  /* Number of syntax errors so far. */
4974  int yynerrs;
4975 
4976  int yystate;
4977  /* Number of tokens to shift before error messages enabled. */
4978  int yyerrstatus;
4979 
4980  /* The stacks and their tools:
4981  `yyss': related to states.
4982  `yyvs': related to semantic values.
4983 
4984  Refer to the stacks thru separate pointers, to allow yyoverflow
4985  to reallocate them elsewhere. */
4986 
4987  /* The state stack. */
4988  yytype_int16 yyssa[YYINITDEPTH];
4989  yytype_int16 *yyss;
4990  yytype_int16 *yyssp;
4991 
4992  /* The semantic value stack. */
4993  YYSTYPE yyvsa[YYINITDEPTH];
4994  YYSTYPE *yyvs;
4995  YYSTYPE *yyvsp;
4996 
4997  YYSIZE_T yystacksize;
4998 
4999  int yyn;
5000  int yyresult;
5001  /* Lookahead token as an internal (translated) token number. */
5002  int yytoken;
5003  /* The variables used to return semantic value and location from the
5004  action routines. */
5005  YYSTYPE yyval;
5006 
5007 #if YYERROR_VERBOSE
5008  /* Buffer for error messages, and its allocated size. */
5009  char yymsgbuf[128];
5010  char *yymsg = yymsgbuf;
5011  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
5012 #endif
5013 
5014 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
5015 
5016  /* The number of symbols on the RHS of the reduced rule.
5017  Keep to zero when no symbol should be popped. */
5018  int yylen = 0;
5019 
5020  yytoken = 0;
5021  yyss = yyssa;
5022  yyvs = yyvsa;
5023  yystacksize = YYINITDEPTH;
5024 
5025  YYDPRINTF ((stderr, "Starting parse\n"));
5026 
5027  yystate = 0;
5028  yyerrstatus = 0;
5029  yynerrs = 0;
5030  yychar = YYEMPTY; /* Cause a token to be read. */
5031 
5032  /* Initialize stack pointers.
5033  Waste one element of value and location stack
5034  so that they stay on the same level as the state stack.
5035  The wasted elements are never initialized. */
5036  yyssp = yyss;
5037  yyvsp = yyvs;
5038 
5039  goto yysetstate;
5040 
5041 /*------------------------------------------------------------.
5042 | yynewstate -- Push a new state, which is found in yystate. |
5043 `------------------------------------------------------------*/
5044  yynewstate:
5045  /* In all cases, when you get here, the value and location stacks
5046  have just been pushed. So pushing a state here evens the stacks. */
5047  yyssp++;
5048 
5049  yysetstate:
5050  *yyssp = yystate;
5051 
5052  if (yyss + yystacksize - 1 <= yyssp)
5053  {
5054  /* Get the current used size of the three stacks, in elements. */
5055  YYSIZE_T yysize = yyssp - yyss + 1;
5056 
5057 #ifdef yyoverflow
5058  {
5059  /* Give user a chance to reallocate the stack. Use copies of
5060  these so that the &'s don't force the real ones into
5061  memory. */
5062  YYSTYPE *yyvs1 = yyvs;
5063  yytype_int16 *yyss1 = yyss;
5064 
5065  /* Each stack pointer address is followed by the size of the
5066  data in use in that stack, in bytes. This used to be a
5067  conditional around just the two extra args, but that might
5068  be undefined if yyoverflow is a macro. */
5069  yyoverflow (YY_("memory exhausted"),
5070  &yyss1, yysize * sizeof (*yyssp),
5071  &yyvs1, yysize * sizeof (*yyvsp),
5072  &yystacksize);
5073 
5074  yyss = yyss1;
5075  yyvs = yyvs1;
5076  }
5077 #else /* no yyoverflow */
5078 # ifndef YYSTACK_RELOCATE
5079  goto yyexhaustedlab;
5080 # else
5081  /* Extend the stack our own way. */
5082  if (YYMAXDEPTH <= yystacksize)
5083  goto yyexhaustedlab;
5084  yystacksize *= 2;
5085  if (YYMAXDEPTH < yystacksize)
5086  yystacksize = YYMAXDEPTH;
5087 
5088  {
5089  yytype_int16 *yyss1 = yyss;
5090  union yyalloc *yyptr =
5091  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
5092  if (! yyptr)
5093  goto yyexhaustedlab;
5094  YYSTACK_RELOCATE (yyss_alloc, yyss);
5095  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
5096 # undef YYSTACK_RELOCATE
5097  if (yyss1 != yyssa)
5098  YYSTACK_FREE (yyss1);
5099  }
5100 # endif
5101 #endif /* no yyoverflow */
5102 
5103  yyssp = yyss + yysize - 1;
5104  yyvsp = yyvs + yysize - 1;
5105 
5106  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
5107  (unsigned long int) yystacksize));
5108 
5109  if (yyss + yystacksize - 1 <= yyssp)
5110  YYABORT;
5111  }
5112 
5113  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
5114 
5115  if (yystate == YYFINAL)
5116  YYACCEPT;
5117 
5118  goto yybackup;
5119 
5120 /*-----------.
5121 | yybackup. |
5122 `-----------*/
5123 yybackup:
5124 
5125  /* Do appropriate processing given the current state. Read a
5126  lookahead token if we need one and don't already have one. */
5127 
5128  /* First try to decide what to do without reference to lookahead token. */
5129  yyn = yypact[yystate];
5130  if (yypact_value_is_default (yyn))
5131  goto yydefault;
5132 
5133  /* Not known => get a lookahead token if don't already have one. */
5134 
5135  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5136  if (yychar == YYEMPTY)
5137  {
5138  YYDPRINTF ((stderr, "Reading a token: "));
5139  yychar = YYLEX;
5140  }
5141 
5142  if (yychar <= YYEOF)
5143  {
5144  yychar = yytoken = YYEOF;
5145  YYDPRINTF ((stderr, "Now at end of input.\n"));
5146  }
5147  else
5148  {
5149  yytoken = YYTRANSLATE (yychar);
5150  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
5151  }
5152 
5153  /* If the proper action on seeing token YYTOKEN is to reduce or to
5154  detect an error, take that action. */
5155  yyn += yytoken;
5156  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
5157  goto yydefault;
5158  yyn = yytable[yyn];
5159  if (yyn <= 0)
5160  {
5161  if (yytable_value_is_error (yyn))
5162  goto yyerrlab;
5163  yyn = -yyn;
5164  goto yyreduce;
5165  }
5166 
5167  /* Count tokens shifted since error; after three, turn off error
5168  status. */
5169  if (yyerrstatus)
5170  yyerrstatus--;
5171 
5172  /* Shift the lookahead token. */
5173  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
5174 
5175  /* Discard the shifted token. */
5176  yychar = YYEMPTY;
5177 
5178  yystate = yyn;
5179  *++yyvsp = yylval;
5180 
5181  goto yynewstate;
5182 
5183 
5184 /*-----------------------------------------------------------.
5185 | yydefault -- do the default action for the current state. |
5186 `-----------------------------------------------------------*/
5187 yydefault:
5188  yyn = yydefact[yystate];
5189  if (yyn == 0)
5190  goto yyerrlab;
5191  goto yyreduce;
5192 
5193 
5194 /*-----------------------------.
5195 | yyreduce -- Do a reduction. |
5196 `-----------------------------*/
5197 yyreduce:
5198  /* yyn is the number of a rule to reduce with. */
5199  yylen = yyr2[yyn];
5200 
5201  /* If YYLEN is nonzero, implement the default value of the action:
5202  `$$ = $1'.
5203 
5204  Otherwise, the following line sets YYVAL to garbage.
5205  This behavior is undocumented and Bison
5206  users should not rely upon it. Assigning to YYVAL
5207  unconditionally makes the parser a bit smaller, and it avoids a
5208  GCC warning that YYVAL may be used uninitialized. */
5209  yyval = yyvsp[1-yylen];
5210 
5211 
5212  YY_REDUCE_PRINT (yyn);
5213  switch (yyn)
5214  {
5215  case 2:
5216 
5217 /* Line 1806 of yacc.c */
5218 #line 853 "ripper.y"
5219  {
5220  lex_state = EXPR_BEG;
5221 #if 0
5223 #endif
5224  local_push(0);
5225 
5226  }
5227  break;
5228 
5229  case 3:
5230 
5231 /* Line 1806 of yacc.c */
5232 #line 862 "ripper.y"
5233  {
5234 #if 0
5235  if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
5236  /* last expression should not be void */
5237  if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
5238  else {
5239  NODE *node = (yyvsp[(2) - (2)].val);
5240  while (node->nd_next) {
5241  node = node->nd_next;
5242  }
5243  void_expr(node->nd_head);
5244  }
5245  }
5246  ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val)));
5247 #endif
5248  (yyval.val) = (yyvsp[(2) - (2)].val);
5249  parser->result = dispatch1(program, (yyval.val));
5250 
5251  local_pop();
5252  }
5253  break;
5254 
5255  case 4:
5256 
5257 /* Line 1806 of yacc.c */
5258 #line 885 "ripper.y"
5259  {
5260 #if 0
5261  void_stmts((yyvsp[(1) - (2)].val));
5263 #endif
5264 
5265  (yyval.val) = (yyvsp[(1) - (2)].val);
5266  }
5267  break;
5268 
5269  case 5:
5270 
5271 /* Line 1806 of yacc.c */
5272 #line 896 "ripper.y"
5273  {
5274 #if 0
5275  (yyval.val) = NEW_BEGIN(0);
5276 #endif
5277  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5278  dispatch0(void_stmt));
5279 
5280  }
5281  break;
5282 
5283  case 6:
5284 
5285 /* Line 1806 of yacc.c */
5286 #line 905 "ripper.y"
5287  {
5288 #if 0
5289  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5290 #endif
5291  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5292 
5293  }
5294  break;
5295 
5296  case 7:
5297 
5298 /* Line 1806 of yacc.c */
5299 #line 913 "ripper.y"
5300  {
5301 #if 0
5302  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5303 #endif
5304  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5305 
5306  }
5307  break;
5308 
5309  case 8:
5310 
5311 /* Line 1806 of yacc.c */
5312 #line 921 "ripper.y"
5313  {
5314  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5315  }
5316  break;
5317 
5318  case 10:
5319 
5320 /* Line 1806 of yacc.c */
5321 #line 928 "ripper.y"
5322  {
5323 #if 0
5324  /* local_push(0); */
5325 #endif
5326 
5327  }
5328  break;
5329 
5330  case 11:
5331 
5332 /* Line 1806 of yacc.c */
5333 #line 935 "ripper.y"
5334  {
5335 #if 0
5337  (yyvsp[(4) - (5)].val));
5338  /* NEW_PREEXE($4)); */
5339  /* local_pop(); */
5340  (yyval.val) = NEW_BEGIN(0);
5341 #endif
5342  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5343 
5344  }
5345  break;
5346 
5347  case 12:
5348 
5349 /* Line 1806 of yacc.c */
5350 #line 952 "ripper.y"
5351  {
5352 #if 0
5353  (yyval.val) = (yyvsp[(1) - (4)].val);
5354  if ((yyvsp[(2) - (4)].val)) {
5355  (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
5356  }
5357  else if ((yyvsp[(3) - (4)].val)) {
5358  rb_warn0("else without rescue is useless");
5359  (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val));
5360  }
5361  if ((yyvsp[(4) - (4)].val)) {
5362  if ((yyval.val)) {
5363  (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
5364  }
5365  else {
5366  (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL());
5367  }
5368  }
5369  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5370 #endif
5371  (yyval.val) = dispatch4(bodystmt,
5372  escape_Qundef((yyvsp[(1) - (4)].val)),
5373  escape_Qundef((yyvsp[(2) - (4)].val)),
5374  escape_Qundef((yyvsp[(3) - (4)].val)),
5375  escape_Qundef((yyvsp[(4) - (4)].val)));
5376 
5377  }
5378  break;
5379 
5380  case 13:
5381 
5382 /* Line 1806 of yacc.c */
5383 #line 982 "ripper.y"
5384  {
5385 #if 0
5386  void_stmts((yyvsp[(1) - (2)].val));
5388 #endif
5389 
5390  (yyval.val) = (yyvsp[(1) - (2)].val);
5391  }
5392  break;
5393 
5394  case 14:
5395 
5396 /* Line 1806 of yacc.c */
5397 #line 993 "ripper.y"
5398  {
5399 #if 0
5400  (yyval.val) = NEW_BEGIN(0);
5401 #endif
5402  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5403  dispatch0(void_stmt));
5404 
5405  }
5406  break;
5407 
5408  case 15:
5409 
5410 /* Line 1806 of yacc.c */
5411 #line 1002 "ripper.y"
5412  {
5413 #if 0
5414  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5415 #endif
5416  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5417 
5418  }
5419  break;
5420 
5421  case 16:
5422 
5423 /* Line 1806 of yacc.c */
5424 #line 1010 "ripper.y"
5425  {
5426 #if 0
5427  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5428 #endif
5429  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5430 
5431  }
5432  break;
5433 
5434  case 17:
5435 
5436 /* Line 1806 of yacc.c */
5437 #line 1018 "ripper.y"
5438  {
5439  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5440  }
5441  break;
5442 
5443  case 18:
5444 
5445 /* Line 1806 of yacc.c */
5446 #line 1024 "ripper.y"
5447  {
5448  (yyval.val) = (yyvsp[(1) - (1)].val);
5449  }
5450  break;
5451 
5452  case 19:
5453 
5454 /* Line 1806 of yacc.c */
5455 #line 1028 "ripper.y"
5456  {
5457  yyerror("BEGIN is permitted only at toplevel");
5458 #if 0
5459  /* local_push(0); */
5460 #endif
5461 
5462  }
5463  break;
5464 
5465  case 20:
5466 
5467 /* Line 1806 of yacc.c */
5468 #line 1036 "ripper.y"
5469  {
5470 #if 0
5472  (yyvsp[(4) - (5)].val));
5473  /* NEW_PREEXE($4)); */
5474  /* local_pop(); */
5475  (yyval.val) = NEW_BEGIN(0);
5476 #endif
5477  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5478 
5479  }
5480  break;
5481 
5482  case 21:
5483 
5484 /* Line 1806 of yacc.c */
5485 #line 1048 "ripper.y"
5486  {lex_state = EXPR_FNAME;}
5487  break;
5488 
5489  case 22:
5490 
5491 /* Line 1806 of yacc.c */
5492 #line 1049 "ripper.y"
5493  {
5494 #if 0
5495  (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5496 #endif
5497  (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5498 
5499  }
5500  break;
5501 
5502  case 23:
5503 
5504 /* Line 1806 of yacc.c */
5505 #line 1057 "ripper.y"
5506  {
5507 #if 0
5508  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5509 #endif
5510  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5511 
5512  }
5513  break;
5514 
5515  case 24:
5516 
5517 /* Line 1806 of yacc.c */
5518 #line 1065 "ripper.y"
5519  {
5520 #if 0
5521  char buf[2];
5522  buf[0] = '$';
5523  buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
5524  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
5525 #endif
5526  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5527 
5528  }
5529  break;
5530 
5531  case 25:
5532 
5533 /* Line 1806 of yacc.c */
5534 #line 1076 "ripper.y"
5535  {
5536 #if 0
5537  yyerror("can't make alias for the number variables");
5538  (yyval.val) = NEW_BEGIN(0);
5539 #endif
5540  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5541  (yyval.val) = dispatch1(alias_error, (yyval.val));
5542 
5543  }
5544  break;
5545 
5546  case 26:
5547 
5548 /* Line 1806 of yacc.c */
5549 #line 1086 "ripper.y"
5550  {
5551 #if 0
5552  (yyval.val) = (yyvsp[(2) - (2)].val);
5553 #endif
5554  (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
5555 
5556  }
5557  break;
5558 
5559  case 27:
5560 
5561 /* Line 1806 of yacc.c */
5562 #line 1094 "ripper.y"
5563  {
5564 #if 0
5565  (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5566  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5567 #endif
5568  (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5569 
5570  }
5571  break;
5572 
5573  case 28:
5574 
5575 /* Line 1806 of yacc.c */
5576 #line 1103 "ripper.y"
5577  {
5578 #if 0
5579  (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5580  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5581 #endif
5582  (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5583 
5584  }
5585  break;
5586 
5587  case 29:
5588 
5589 /* Line 1806 of yacc.c */
5590 #line 1112 "ripper.y"
5591  {
5592 #if 0
5593  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5594  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5595  }
5596  else {
5597  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5598  }
5599 #endif
5600  (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5601 
5602  }
5603  break;
5604 
5605  case 30:
5606 
5607 /* Line 1806 of yacc.c */
5608 #line 1125 "ripper.y"
5609  {
5610 #if 0
5611  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5612  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5613  }
5614  else {
5615  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5616  }
5617 #endif
5618  (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5619 
5620  }
5621  break;
5622 
5623  case 31:
5624 
5625 /* Line 1806 of yacc.c */
5626 #line 1138 "ripper.y"
5627  {
5628 #if 0
5629  NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0);
5630  (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0);
5631 #endif
5632  (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5633 
5634  }
5635  break;
5636 
5637  case 32:
5638 
5639 /* Line 1806 of yacc.c */
5640 #line 1147 "ripper.y"
5641  {
5642  if (in_def || in_single) {
5643  rb_warn0("END in method; use at_exit");
5644  }
5645 #if 0
5646  (yyval.val) = NEW_POSTEXE(NEW_NODE(
5647  NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */));
5648 #endif
5649  (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
5650 
5651  }
5652  break;
5653 
5654  case 34:
5655 
5656 /* Line 1806 of yacc.c */
5657 #line 1160 "ripper.y"
5658  {
5659 #if 0
5660  value_expr((yyvsp[(3) - (3)].val));
5661  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5662  (yyval.val) = (yyvsp[(1) - (3)].val);
5663 #endif
5664  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5665 
5666  }
5667  break;
5668 
5669  case 35:
5670 
5671 /* Line 1806 of yacc.c */
5672 #line 1170 "ripper.y"
5673  {
5674  value_expr((yyvsp[(3) - (3)].val));
5675  (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5676  }
5677  break;
5678 
5679  case 36:
5680 
5681 /* Line 1806 of yacc.c */
5682 #line 1175 "ripper.y"
5683  {
5684 #if 0
5685  NODE *args;
5686 
5687  value_expr((yyvsp[(6) - (6)].val));
5688  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
5689  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
5690  if ((yyvsp[(5) - (6)].val) == tOROP) {
5691  (yyvsp[(5) - (6)].val) = 0;
5692  }
5693  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
5694  (yyvsp[(5) - (6)].val) = 1;
5695  }
5696  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
5697  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
5698 #endif
5699  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
5700  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
5701 
5702  }
5703  break;
5704 
5705  case 37:
5706 
5707 /* Line 1806 of yacc.c */
5708 #line 1196 "ripper.y"
5709  {
5710  value_expr((yyvsp[(5) - (5)].val));
5711  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5712  }
5713  break;
5714 
5715  case 38:
5716 
5717 /* Line 1806 of yacc.c */
5718 #line 1201 "ripper.y"
5719  {
5720  value_expr((yyvsp[(5) - (5)].val));
5721  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5722  }
5723  break;
5724 
5725  case 39:
5726 
5727 /* Line 1806 of yacc.c */
5728 #line 1206 "ripper.y"
5729  {
5730 #if 0
5731  (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
5732  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5733 #endif
5734  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
5735  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5736 
5737  }
5738  break;
5739 
5740  case 40:
5741 
5742 /* Line 1806 of yacc.c */
5743 #line 1216 "ripper.y"
5744  {
5745  value_expr((yyvsp[(5) - (5)].val));
5746  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5747  }
5748  break;
5749 
5750  case 41:
5751 
5752 /* Line 1806 of yacc.c */
5753 #line 1221 "ripper.y"
5754  {
5755 #if 0
5756  rb_backref_error((yyvsp[(1) - (3)].val));
5757  (yyval.val) = NEW_BEGIN(0);
5758 #endif
5759  (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
5760  (yyval.val) = dispatch1(assign_error, (yyval.val));
5761 
5762  }
5763  break;
5764 
5765  case 42:
5766 
5767 /* Line 1806 of yacc.c */
5768 #line 1231 "ripper.y"
5769  {
5770 #if 0
5771  value_expr((yyvsp[(3) - (3)].val));
5772  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5773 #endif
5774  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5775 
5776  }
5777  break;
5778 
5779  case 43:
5780 
5781 /* Line 1806 of yacc.c */
5782 #line 1240 "ripper.y"
5783  {
5784 #if 0
5785  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5786  (yyval.val) = (yyvsp[(1) - (3)].val);
5787 #endif
5788  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5789 
5790  }
5791  break;
5792 
5793  case 44:
5794 
5795 /* Line 1806 of yacc.c */
5796 #line 1249 "ripper.y"
5797  {
5798 #if 0
5799  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5800  (yyval.val) = (yyvsp[(1) - (3)].val);
5801 #endif
5802  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5803 
5804  }
5805  break;
5806 
5807  case 46:
5808 
5809 /* Line 1806 of yacc.c */
5810 #line 1261 "ripper.y"
5811  {
5812 #if 0
5813  value_expr((yyvsp[(3) - (3)].val));
5814  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5815 #endif
5816  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5817 
5818  }
5819  break;
5820 
5821  case 47:
5822 
5823 /* Line 1806 of yacc.c */
5824 #line 1270 "ripper.y"
5825  {
5826 #if 0
5827  value_expr((yyvsp[(3) - (3)].val));
5828  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5829 #endif
5830  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5831 
5832  }
5833  break;
5834 
5835  case 49:
5836 
5837 /* Line 1806 of yacc.c */
5838 #line 1283 "ripper.y"
5839  {
5840 #if 0
5841  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5842 #endif
5843  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val));
5844 
5845  }
5846  break;
5847 
5848  case 50:
5849 
5850 /* Line 1806 of yacc.c */
5851 #line 1291 "ripper.y"
5852  {
5853 #if 0
5854  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5855 #endif
5856  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val));
5857 
5858  }
5859  break;
5860 
5861  case 51:
5862 
5863 /* Line 1806 of yacc.c */
5864 #line 1299 "ripper.y"
5865  {
5866 #if 0
5867  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!');
5868 #endif
5869  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val));
5870 
5871  }
5872  break;
5873 
5874  case 52:
5875 
5876 /* Line 1806 of yacc.c */
5877 #line 1307 "ripper.y"
5878  {
5879 #if 0
5880  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
5881 #endif
5882  (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val));
5883 
5884  }
5885  break;
5886 
5887  case 54:
5888 
5889 /* Line 1806 of yacc.c */
5890 #line 1318 "ripper.y"
5891  {
5892 #if 0
5893  value_expr((yyvsp[(1) - (1)].val));
5894  (yyval.val) = (yyvsp[(1) - (1)].val);
5895  if (!(yyval.val)) (yyval.val) = NEW_NIL();
5896 #endif
5897  (yyval.val) = (yyvsp[(1) - (1)].val);
5898 
5899  }
5900  break;
5901 
5902  case 58:
5903 
5904 /* Line 1806 of yacc.c */
5905 #line 1335 "ripper.y"
5906  {
5907 #if 0
5908  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5909 #endif
5910  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
5911  (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
5912 
5913  }
5914  break;
5915 
5916  case 59:
5917 
5918 /* Line 1806 of yacc.c */
5919 #line 1346 "ripper.y"
5920  {
5921  (yyvsp[(1) - (1)].vars) = dyna_push();
5922 #if 0
5923  (yyval.num) = ruby_sourceline;
5924 #endif
5925 
5926  }
5927  break;
5928 
5929  case 60:
5930 
5931 /* Line 1806 of yacc.c */
5932 #line 1356 "ripper.y"
5933  {
5934 #if 0
5935  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
5936  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
5937 #endif
5938  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
5939 
5940  dyna_pop((yyvsp[(1) - (5)].vars));
5941  }
5942  break;
5943 
5944  case 61:
5945 
5946 /* Line 1806 of yacc.c */
5947 #line 1368 "ripper.y"
5948  {
5949 #if 0
5950  (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
5951  nd_set_line((yyval.val), tokline);
5952 #endif
5953 
5954  }
5955  break;
5956 
5957  case 62:
5958 
5959 /* Line 1806 of yacc.c */
5960 #line 1378 "ripper.y"
5961  {
5962 #if 0
5963  (yyval.val) = (yyvsp[(1) - (2)].val);
5964  (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
5965 #endif
5966  (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
5967 
5968  }
5969  break;
5970 
5971  case 63:
5972 
5973 /* Line 1806 of yacc.c */
5974 #line 1387 "ripper.y"
5975  {
5976 #if 0
5977  block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
5978  (yyvsp[(1) - (3)].val)->nd_args = (yyvsp[(2) - (3)].val);
5979  (yyvsp[(3) - (3)].val)->nd_iter = (yyvsp[(1) - (3)].val);
5980  (yyval.val) = (yyvsp[(3) - (3)].val);
5981  fixpos((yyval.val), (yyvsp[(1) - (3)].val));
5982 #endif
5983  (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
5984  (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
5985 
5986  }
5987  break;
5988 
5989  case 64:
5990 
5991 /* Line 1806 of yacc.c */
5992 #line 1400 "ripper.y"
5993  {
5994 #if 0
5995  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5996  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5997 #endif
5998  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5999 
6000  }
6001  break;
6002 
6003  case 65:
6004 
6005 /* Line 1806 of yacc.c */
6006 #line 1409 "ripper.y"
6007  {
6008 #if 0
6009  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
6010  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6011  (yyval.val) = (yyvsp[(5) - (5)].val);
6012  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6013 #endif
6014  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6015  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
6016 
6017  }
6018  break;
6019 
6020  case 66:
6021 
6022 /* Line 1806 of yacc.c */
6023 #line 1421 "ripper.y"
6024  {
6025 #if 0
6026  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6027  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
6028 #endif
6029  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6030 
6031  }
6032  break;
6033 
6034  case 67:
6035 
6036 /* Line 1806 of yacc.c */
6037 #line 1430 "ripper.y"
6038  {
6039 #if 0
6040  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
6041  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6042  (yyval.val) = (yyvsp[(5) - (5)].val);
6043  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6044 #endif
6045  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6046  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
6047 
6048  }
6049  break;
6050 
6051  case 68:
6052 
6053 /* Line 1806 of yacc.c */
6054 #line 1442 "ripper.y"
6055  {
6056 #if 0
6057  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
6058  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
6059 #endif
6060  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
6061 
6062  }
6063  break;
6064 
6065  case 69:
6066 
6067 /* Line 1806 of yacc.c */
6068 #line 1451 "ripper.y"
6069  {
6070 #if 0
6071  (yyval.val) = new_yield((yyvsp[(2) - (2)].val));
6072  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
6073 #endif
6074  (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
6075 
6076  }
6077  break;
6078 
6079  case 70:
6080 
6081 /* Line 1806 of yacc.c */
6082 #line 1460 "ripper.y"
6083  {
6084 #if 0
6085  (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
6086 #endif
6087  (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
6088 
6089  }
6090  break;
6091 
6092  case 71:
6093 
6094 /* Line 1806 of yacc.c */
6095 #line 1468 "ripper.y"
6096  {
6097 #if 0
6098  (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
6099 #endif
6100  (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
6101 
6102  }
6103  break;
6104 
6105  case 72:
6106 
6107 /* Line 1806 of yacc.c */
6108 #line 1476 "ripper.y"
6109  {
6110 #if 0
6111  (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
6112 #endif
6113  (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
6114 
6115  }
6116  break;
6117 
6118  case 74:
6119 
6120 /* Line 1806 of yacc.c */
6121 #line 1487 "ripper.y"
6122  {
6123 #if 0
6124  (yyval.val) = (yyvsp[(2) - (3)].val);
6125 #endif
6126  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6127 
6128  }
6129  break;
6130 
6131  case 76:
6132 
6133 /* Line 1806 of yacc.c */
6134 #line 1498 "ripper.y"
6135  {
6136 #if 0
6137  (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0);
6138 #endif
6139  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6140 
6141  }
6142  break;
6143 
6144  case 77:
6145 
6146 /* Line 1806 of yacc.c */
6147 #line 1508 "ripper.y"
6148  {
6149 #if 0
6150  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
6151 #endif
6152  (yyval.val) = (yyvsp[(1) - (1)].val);
6153 
6154  }
6155  break;
6156 
6157  case 78:
6158 
6159 /* Line 1806 of yacc.c */
6160 #line 1516 "ripper.y"
6161  {
6162 #if 0
6163  (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0);
6164 #endif
6165  (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
6166 
6167  }
6168  break;
6169 
6170  case 79:
6171 
6172 /* Line 1806 of yacc.c */
6173 #line 1524 "ripper.y"
6174  {
6175 #if 0
6176  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6177 #endif
6178  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6179 
6180  }
6181  break;
6182 
6183  case 80:
6184 
6185 /* Line 1806 of yacc.c */
6186 #line 1532 "ripper.y"
6187  {
6188 #if 0
6189  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val)));
6190 #endif
6191  (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6192  (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
6193 
6194  }
6195  break;
6196 
6197  case 81:
6198 
6199 /* Line 1806 of yacc.c */
6200 #line 1541 "ripper.y"
6201  {
6202 #if 0
6203  (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1);
6204 #endif
6205  (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
6206 
6207  }
6208  break;
6209 
6210  case 82:
6211 
6212 /* Line 1806 of yacc.c */
6213 #line 1549 "ripper.y"
6214  {
6215 #if 0
6216  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
6217 #endif
6218  (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
6219  (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6220 
6221  }
6222  break;
6223 
6224  case 83:
6225 
6226 /* Line 1806 of yacc.c */
6227 #line 1558 "ripper.y"
6228  {
6229 #if 0
6230  (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
6231 #endif
6232  (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
6233 
6234  }
6235  break;
6236 
6237  case 84:
6238 
6239 /* Line 1806 of yacc.c */
6240 #line 1566 "ripper.y"
6241  {
6242 #if 0
6243  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
6244 #endif
6245  (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
6246  (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
6247 
6248  }
6249  break;
6250 
6251  case 85:
6252 
6253 /* Line 1806 of yacc.c */
6254 #line 1575 "ripper.y"
6255  {
6256 #if 0
6257  (yyval.val) = NEW_MASGN(0, -1);
6258 #endif
6259  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6260 
6261  }
6262  break;
6263 
6264  case 86:
6265 
6266 /* Line 1806 of yacc.c */
6267 #line 1583 "ripper.y"
6268  {
6269 #if 0
6270  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
6271 #endif
6272  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6273  (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
6274 
6275  }
6276  break;
6277 
6278  case 88:
6279 
6280 /* Line 1806 of yacc.c */
6281 #line 1595 "ripper.y"
6282  {
6283 #if 0
6284  (yyval.val) = (yyvsp[(2) - (3)].val);
6285 #endif
6286  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6287 
6288  }
6289  break;
6290 
6291  case 89:
6292 
6293 /* Line 1806 of yacc.c */
6294 #line 1605 "ripper.y"
6295  {
6296 #if 0
6297  (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
6298 #endif
6299  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
6300 
6301  }
6302  break;
6303 
6304  case 90:
6305 
6306 /* Line 1806 of yacc.c */
6307 #line 1613 "ripper.y"
6308  {
6309 #if 0
6310  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6311 #endif
6312  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6313 
6314  }
6315  break;
6316 
6317  case 91:
6318 
6319 /* Line 1806 of yacc.c */
6320 #line 1623 "ripper.y"
6321  {
6322 #if 0
6323  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
6324 #endif
6325  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
6326 
6327  }
6328  break;
6329 
6330  case 92:
6331 
6332 /* Line 1806 of yacc.c */
6333 #line 1631 "ripper.y"
6334  {
6335 #if 0
6336  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6337 #endif
6338  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6339 
6340  }
6341  break;
6342 
6343  case 93:
6344 
6345 /* Line 1806 of yacc.c */
6346 #line 1641 "ripper.y"
6347  {
6348  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6349  }
6350  break;
6351 
6352  case 94:
6353 
6354 /* Line 1806 of yacc.c */
6355 #line 1645 "ripper.y"
6356  {
6357  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6358  }
6359  break;
6360 
6361  case 95:
6362 
6363 /* Line 1806 of yacc.c */
6364 #line 1649 "ripper.y"
6365  {
6366 #if 0
6367  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6368 #endif
6369  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6370 
6371  }
6372  break;
6373 
6374  case 96:
6375 
6376 /* Line 1806 of yacc.c */
6377 #line 1657 "ripper.y"
6378  {
6379 #if 0
6380  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6381 #endif
6382  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6383 
6384  }
6385  break;
6386 
6387  case 97:
6388 
6389 /* Line 1806 of yacc.c */
6390 #line 1665 "ripper.y"
6391  {
6392 #if 0
6393  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6394 #endif
6395  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6396 
6397  }
6398  break;
6399 
6400  case 98:
6401 
6402 /* Line 1806 of yacc.c */
6403 #line 1673 "ripper.y"
6404  {
6405 #if 0
6406  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6407 #endif
6408  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6409 
6410  }
6411  break;
6412 
6413  case 99:
6414 
6415 /* Line 1806 of yacc.c */
6416 #line 1681 "ripper.y"
6417  {
6418 #if 0
6419  if (in_def || in_single)
6420  yyerror("dynamic constant assignment");
6421  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6422 #endif
6423  if (in_def || in_single)
6424  yyerror("dynamic constant assignment");
6425  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6426 
6427  }
6428  break;
6429 
6430  case 100:
6431 
6432 /* Line 1806 of yacc.c */
6433 #line 1693 "ripper.y"
6434  {
6435 #if 0
6436  if (in_def || in_single)
6437  yyerror("dynamic constant assignment");
6438  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6439 #endif
6440  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6441 
6442  }
6443  break;
6444 
6445  case 101:
6446 
6447 /* Line 1806 of yacc.c */
6448 #line 1703 "ripper.y"
6449  {
6450 #if 0
6451  rb_backref_error((yyvsp[(1) - (1)].val));
6452  (yyval.val) = NEW_BEGIN(0);
6453 #endif
6454  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val));
6455  (yyval.val) = dispatch1(assign_error, (yyval.val));
6456 
6457  }
6458  break;
6459 
6460  case 102:
6461 
6462 /* Line 1806 of yacc.c */
6463 #line 1715 "ripper.y"
6464  {
6465  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6466 #if 0
6467  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6468 #endif
6469  (yyval.val) = dispatch1(var_field, (yyval.val));
6470 
6471  }
6472  break;
6473 
6474  case 103:
6475 
6476 /* Line 1806 of yacc.c */
6477 #line 1724 "ripper.y"
6478  {
6479  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6480 #if 0
6481  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6482 #endif
6483  (yyval.val) = dispatch1(var_field, (yyval.val));
6484 
6485  }
6486  break;
6487 
6488  case 104:
6489 
6490 /* Line 1806 of yacc.c */
6491 #line 1733 "ripper.y"
6492  {
6493 #if 0
6494  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6495 #endif
6496  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6497 
6498  }
6499  break;
6500 
6501  case 105:
6502 
6503 /* Line 1806 of yacc.c */
6504 #line 1741 "ripper.y"
6505  {
6506 #if 0
6507  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6508 #endif
6509  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6510 
6511  }
6512  break;
6513 
6514  case 106:
6515 
6516 /* Line 1806 of yacc.c */
6517 #line 1749 "ripper.y"
6518  {
6519 #if 0
6520  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6521 #endif
6522  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
6523 
6524  }
6525  break;
6526 
6527  case 107:
6528 
6529 /* Line 1806 of yacc.c */
6530 #line 1757 "ripper.y"
6531  {
6532 #if 0
6533  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6534 #endif
6535  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6536 
6537  }
6538  break;
6539 
6540  case 108:
6541 
6542 /* Line 1806 of yacc.c */
6543 #line 1765 "ripper.y"
6544  {
6545 #if 0
6546  if (in_def || in_single)
6547  yyerror("dynamic constant assignment");
6548  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6549 #endif
6550  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6551  if (in_def || in_single) {
6552  (yyval.val) = dispatch1(assign_error, (yyval.val));
6553  }
6554 
6555  }
6556  break;
6557 
6558  case 109:
6559 
6560 /* Line 1806 of yacc.c */
6561 #line 1778 "ripper.y"
6562  {
6563 #if 0
6564  if (in_def || in_single)
6565  yyerror("dynamic constant assignment");
6566  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6567 #endif
6568  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6569  if (in_def || in_single) {
6570  (yyval.val) = dispatch1(assign_error, (yyval.val));
6571  }
6572 
6573  }
6574  break;
6575 
6576  case 110:
6577 
6578 /* Line 1806 of yacc.c */
6579 #line 1791 "ripper.y"
6580  {
6581 #if 0
6582  rb_backref_error((yyvsp[(1) - (1)].val));
6583  (yyval.val) = NEW_BEGIN(0);
6584 #endif
6585  (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val));
6586 
6587  }
6588  break;
6589 
6590  case 111:
6591 
6592 /* Line 1806 of yacc.c */
6593 #line 1802 "ripper.y"
6594  {
6595 #if 0
6596  yyerror("class/module name must be CONSTANT");
6597 #endif
6598  (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
6599 
6600  }
6601  break;
6602 
6603  case 113:
6604 
6605 /* Line 1806 of yacc.c */
6606 #line 1813 "ripper.y"
6607  {
6608 #if 0
6609  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
6610 #endif
6611  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
6612 
6613  }
6614  break;
6615 
6616  case 114:
6617 
6618 /* Line 1806 of yacc.c */
6619 #line 1821 "ripper.y"
6620  {
6621 #if 0
6622  (yyval.val) = NEW_COLON2(0, (yyval.val));
6623 #endif
6624  (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
6625 
6626  }
6627  break;
6628 
6629  case 115:
6630 
6631 /* Line 1806 of yacc.c */
6632 #line 1829 "ripper.y"
6633  {
6634 #if 0
6635  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6636 #endif
6637  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6638 
6639  }
6640  break;
6641 
6642  case 119:
6643 
6644 /* Line 1806 of yacc.c */
6645 #line 1842 "ripper.y"
6646  {
6647  lex_state = EXPR_ENDFN;
6648  (yyval.val) = (yyvsp[(1) - (1)].val);
6649  }
6650  break;
6651 
6652  case 120:
6653 
6654 /* Line 1806 of yacc.c */
6655 #line 1847 "ripper.y"
6656  {
6657  lex_state = EXPR_ENDFN;
6658 #if 0
6659  (yyval.val) = (yyvsp[(1) - (1)].id);
6660 #endif
6661  (yyval.val) = (yyvsp[(1) - (1)].val);
6662 
6663  }
6664  break;
6665 
6666  case 123:
6667 
6668 /* Line 1806 of yacc.c */
6669 #line 1862 "ripper.y"
6670  {
6671 #if 0
6672  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
6673 #endif
6674  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
6675 
6676  }
6677  break;
6678 
6679  case 125:
6680 
6681 /* Line 1806 of yacc.c */
6682 #line 1873 "ripper.y"
6683  {
6684 #if 0
6685  (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
6686 #endif
6687  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
6688 
6689  }
6690  break;
6691 
6692  case 126:
6693 
6694 /* Line 1806 of yacc.c */
6695 #line 1880 "ripper.y"
6696  {lex_state = EXPR_FNAME;}
6697  break;
6698 
6699  case 127:
6700 
6701 /* Line 1806 of yacc.c */
6702 #line 1881 "ripper.y"
6703  {
6704 #if 0
6705  (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
6706 #endif
6707  rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6708 
6709  }
6710  break;
6711 
6712  case 128:
6713 
6714 /* Line 1806 of yacc.c */
6715 #line 1890 "ripper.y"
6716  { ifndef_ripper((yyval.val) = '|'); }
6717  break;
6718 
6719  case 129:
6720 
6721 /* Line 1806 of yacc.c */
6722 #line 1891 "ripper.y"
6723  { ifndef_ripper((yyval.val) = '^'); }
6724  break;
6725 
6726  case 130:
6727 
6728 /* Line 1806 of yacc.c */
6729 #line 1892 "ripper.y"
6730  { ifndef_ripper((yyval.val) = '&'); }
6731  break;
6732 
6733  case 131:
6734 
6735 /* Line 1806 of yacc.c */
6736 #line 1893 "ripper.y"
6737  { ifndef_ripper((yyval.val) = tCMP); }
6738  break;
6739 
6740  case 132:
6741 
6742 /* Line 1806 of yacc.c */
6743 #line 1894 "ripper.y"
6744  { ifndef_ripper((yyval.val) = tEQ); }
6745  break;
6746 
6747  case 133:
6748 
6749 /* Line 1806 of yacc.c */
6750 #line 1895 "ripper.y"
6751  { ifndef_ripper((yyval.val) = tEQQ); }
6752  break;
6753 
6754  case 134:
6755 
6756 /* Line 1806 of yacc.c */
6757 #line 1896 "ripper.y"
6758  { ifndef_ripper((yyval.val) = tMATCH); }
6759  break;
6760 
6761  case 135:
6762 
6763 /* Line 1806 of yacc.c */
6764 #line 1897 "ripper.y"
6765  { ifndef_ripper((yyval.val) = tNMATCH); }
6766  break;
6767 
6768  case 136:
6769 
6770 /* Line 1806 of yacc.c */
6771 #line 1898 "ripper.y"
6772  { ifndef_ripper((yyval.val) = '>'); }
6773  break;
6774 
6775  case 137:
6776 
6777 /* Line 1806 of yacc.c */
6778 #line 1899 "ripper.y"
6779  { ifndef_ripper((yyval.val) = tGEQ); }
6780  break;
6781 
6782  case 138:
6783 
6784 /* Line 1806 of yacc.c */
6785 #line 1900 "ripper.y"
6786  { ifndef_ripper((yyval.val) = '<'); }
6787  break;
6788 
6789  case 139:
6790 
6791 /* Line 1806 of yacc.c */
6792 #line 1901 "ripper.y"
6793  { ifndef_ripper((yyval.val) = tLEQ); }
6794  break;
6795 
6796  case 140:
6797 
6798 /* Line 1806 of yacc.c */
6799 #line 1902 "ripper.y"
6800  { ifndef_ripper((yyval.val) = tNEQ); }
6801  break;
6802 
6803  case 141:
6804 
6805 /* Line 1806 of yacc.c */
6806 #line 1903 "ripper.y"
6807  { ifndef_ripper((yyval.val) = tLSHFT); }
6808  break;
6809 
6810  case 142:
6811 
6812 /* Line 1806 of yacc.c */
6813 #line 1904 "ripper.y"
6814  { ifndef_ripper((yyval.val) = tRSHFT); }
6815  break;
6816 
6817  case 143:
6818 
6819 /* Line 1806 of yacc.c */
6820 #line 1905 "ripper.y"
6821  { ifndef_ripper((yyval.val) = '+'); }
6822  break;
6823 
6824  case 144:
6825 
6826 /* Line 1806 of yacc.c */
6827 #line 1906 "ripper.y"
6828  { ifndef_ripper((yyval.val) = '-'); }
6829  break;
6830 
6831  case 145:
6832 
6833 /* Line 1806 of yacc.c */
6834 #line 1907 "ripper.y"
6835  { ifndef_ripper((yyval.val) = '*'); }
6836  break;
6837 
6838  case 146:
6839 
6840 /* Line 1806 of yacc.c */
6841 #line 1908 "ripper.y"
6842  { ifndef_ripper((yyval.val) = '*'); }
6843  break;
6844 
6845  case 147:
6846 
6847 /* Line 1806 of yacc.c */
6848 #line 1909 "ripper.y"
6849  { ifndef_ripper((yyval.val) = '/'); }
6850  break;
6851 
6852  case 148:
6853 
6854 /* Line 1806 of yacc.c */
6855 #line 1910 "ripper.y"
6856  { ifndef_ripper((yyval.val) = '%'); }
6857  break;
6858 
6859  case 149:
6860 
6861 /* Line 1806 of yacc.c */
6862 #line 1911 "ripper.y"
6863  { ifndef_ripper((yyval.val) = tPOW); }
6864  break;
6865 
6866  case 150:
6867 
6868 /* Line 1806 of yacc.c */
6869 #line 1912 "ripper.y"
6870  { ifndef_ripper((yyval.val) = tDSTAR); }
6871  break;
6872 
6873  case 151:
6874 
6875 /* Line 1806 of yacc.c */
6876 #line 1913 "ripper.y"
6877  { ifndef_ripper((yyval.val) = '!'); }
6878  break;
6879 
6880  case 152:
6881 
6882 /* Line 1806 of yacc.c */
6883 #line 1914 "ripper.y"
6884  { ifndef_ripper((yyval.val) = '~'); }
6885  break;
6886 
6887  case 153:
6888 
6889 /* Line 1806 of yacc.c */
6890 #line 1915 "ripper.y"
6891  { ifndef_ripper((yyval.val) = tUPLUS); }
6892  break;
6893 
6894  case 154:
6895 
6896 /* Line 1806 of yacc.c */
6897 #line 1916 "ripper.y"
6898  { ifndef_ripper((yyval.val) = tUMINUS); }
6899  break;
6900 
6901  case 155:
6902 
6903 /* Line 1806 of yacc.c */
6904 #line 1917 "ripper.y"
6905  { ifndef_ripper((yyval.val) = tAREF); }
6906  break;
6907 
6908  case 156:
6909 
6910 /* Line 1806 of yacc.c */
6911 #line 1918 "ripper.y"
6912  { ifndef_ripper((yyval.val) = tASET); }
6913  break;
6914 
6915  case 157:
6916 
6917 /* Line 1806 of yacc.c */
6918 #line 1919 "ripper.y"
6919  { ifndef_ripper((yyval.val) = '`'); }
6920  break;
6921 
6922  case 199:
6923 
6924 /* Line 1806 of yacc.c */
6925 #line 1937 "ripper.y"
6926  {
6927 #if 0
6928  value_expr((yyvsp[(3) - (3)].val));
6929  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6930 #endif
6931  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6932 
6933  }
6934  break;
6935 
6936  case 200:
6937 
6938 /* Line 1806 of yacc.c */
6939 #line 1946 "ripper.y"
6940  {
6941 #if 0
6942  value_expr((yyvsp[(3) - (5)].val));
6943  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6944  (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6945 #endif
6946  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)));
6947 
6948  }
6949  break;
6950 
6951  case 201:
6952 
6953 /* Line 1806 of yacc.c */
6954 #line 1956 "ripper.y"
6955  {
6956  value_expr((yyvsp[(3) - (3)].val));
6957  (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
6958  }
6959  break;
6960 
6961  case 202:
6962 
6963 /* Line 1806 of yacc.c */
6964 #line 1961 "ripper.y"
6965  {
6966 #if 0
6967  value_expr((yyvsp[(3) - (5)].val));
6968  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6969 #endif
6970  (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
6971 
6972  (yyval.val) = new_op_assign((yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val));
6973  }
6974  break;
6975 
6976  case 203:
6977 
6978 /* Line 1806 of yacc.c */
6979 #line 1971 "ripper.y"
6980  {
6981 #if 0
6982  NODE *args;
6983 
6984  value_expr((yyvsp[(6) - (6)].val));
6985  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
6986  if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
6987  args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6988  }
6989  else {
6990  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6991  }
6992  if ((yyvsp[(5) - (6)].val) == tOROP) {
6993  (yyvsp[(5) - (6)].val) = 0;
6994  }
6995  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
6996  (yyvsp[(5) - (6)].val) = 1;
6997  }
6998  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
6999  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
7000 #endif
7001  (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
7002  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
7003 
7004  }
7005  break;
7006 
7007  case 204:
7008 
7009 /* Line 1806 of yacc.c */
7010 #line 1997 "ripper.y"
7011  {
7012  value_expr((yyvsp[(5) - (5)].val));
7013  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7014  }
7015  break;
7016 
7017  case 205:
7018 
7019 /* Line 1806 of yacc.c */
7020 #line 2002 "ripper.y"
7021  {
7022  value_expr((yyvsp[(5) - (5)].val));
7023  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7024  }
7025  break;
7026 
7027  case 206:
7028 
7029 /* Line 1806 of yacc.c */
7030 #line 2007 "ripper.y"
7031  {
7032  value_expr((yyvsp[(5) - (5)].val));
7033  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7034  }
7035  break;
7036 
7037  case 207:
7038 
7039 /* Line 1806 of yacc.c */
7040 #line 2012 "ripper.y"
7041  {
7042 #if 0
7043  (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
7044  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7045 #endif
7046  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
7047  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7048 
7049  }
7050  break;
7051 
7052  case 208:
7053 
7054 /* Line 1806 of yacc.c */
7055 #line 2022 "ripper.y"
7056  {
7057 #if 0
7058  (yyval.val) = NEW_COLON3((yyvsp[(2) - (4)].val));
7059  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
7060 #endif
7061  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val));
7062  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
7063 
7064  }
7065  break;
7066 
7067  case 209:
7068 
7069 /* Line 1806 of yacc.c */
7070 #line 2032 "ripper.y"
7071  {
7072 #if 0
7073  rb_backref_error((yyvsp[(1) - (3)].val));
7074  (yyval.val) = NEW_BEGIN(0);
7075 #endif
7076  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val));
7077  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
7078  (yyval.val) = dispatch1(assign_error, (yyval.val));
7079 
7080  }
7081  break;
7082 
7083  case 210:
7084 
7085 /* Line 1806 of yacc.c */
7086 #line 2043 "ripper.y"
7087  {
7088 #if 0
7089  value_expr((yyvsp[(1) - (3)].val));
7090  value_expr((yyvsp[(3) - (3)].val));
7091  (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7092  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7093  nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7095  }
7096 #endif
7097  (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7098 
7099  }
7100  break;
7101 
7102  case 211:
7103 
7104 /* Line 1806 of yacc.c */
7105 #line 2057 "ripper.y"
7106  {
7107 #if 0
7108  value_expr((yyvsp[(1) - (3)].val));
7109  value_expr((yyvsp[(3) - (3)].val));
7110  (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7111  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7112  nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7114  }
7115 #endif
7116  (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7117 
7118  }
7119  break;
7120 
7121  case 212:
7122 
7123 /* Line 1806 of yacc.c */
7124 #line 2071 "ripper.y"
7125  {
7126 #if 0
7127  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
7128 #endif
7129  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val));
7130 
7131  }
7132  break;
7133 
7134  case 213:
7135 
7136 /* Line 1806 of yacc.c */
7137 #line 2079 "ripper.y"
7138  {
7139 #if 0
7140  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
7141 #endif
7142  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val));
7143 
7144  }
7145  break;
7146 
7147  case 214:
7148 
7149 /* Line 1806 of yacc.c */
7150 #line 2087 "ripper.y"
7151  {
7152 #if 0
7153  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
7154 #endif
7155  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val));
7156 
7157  }
7158  break;
7159 
7160  case 215:
7161 
7162 /* Line 1806 of yacc.c */
7163 #line 2095 "ripper.y"
7164  {
7165 #if 0
7166  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
7167 #endif
7168  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val));
7169 
7170  }
7171  break;
7172 
7173  case 216:
7174 
7175 /* Line 1806 of yacc.c */
7176 #line 2103 "ripper.y"
7177  {
7178 #if 0
7179  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
7180 #endif
7181  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val));
7182 
7183  }
7184  break;
7185 
7186  case 217:
7187 
7188 /* Line 1806 of yacc.c */
7189 #line 2111 "ripper.y"
7190  {
7191 #if 0
7192  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
7193 #endif
7194  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val));
7195 
7196  }
7197  break;
7198 
7199  case 218:
7200 
7201 /* Line 1806 of yacc.c */
7202 #line 2119 "ripper.y"
7203  {
7204 #if 0
7205  (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
7206 #endif
7207  (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
7208  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
7209 
7210  }
7211  break;
7212 
7213  case 219:
7214 
7215 /* Line 1806 of yacc.c */
7216 #line 2128 "ripper.y"
7217  {
7218 #if 0
7219  (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
7220 #endif
7221  (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
7222  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
7223 
7224  }
7225  break;
7226 
7227  case 220:
7228 
7229 /* Line 1806 of yacc.c */
7230 #line 2137 "ripper.y"
7231  {
7232 #if 0
7233  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
7234 #endif
7235  (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val));
7236 
7237  }
7238  break;
7239 
7240  case 221:
7241 
7242 /* Line 1806 of yacc.c */
7243 #line 2145 "ripper.y"
7244  {
7245 #if 0
7246  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
7247 #endif
7248  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
7249 
7250  }
7251  break;
7252 
7253  case 222:
7254 
7255 /* Line 1806 of yacc.c */
7256 #line 2153 "ripper.y"
7257  {
7258 #if 0
7259  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val));
7260 #endif
7261  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('|'), (yyvsp[(3) - (3)].val));
7262 
7263  }
7264  break;
7265 
7266  case 223:
7267 
7268 /* Line 1806 of yacc.c */
7269 #line 2161 "ripper.y"
7270  {
7271 #if 0
7272  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
7273 #endif
7274  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val));
7275 
7276  }
7277  break;
7278 
7279  case 224:
7280 
7281 /* Line 1806 of yacc.c */
7282 #line 2169 "ripper.y"
7283  {
7284 #if 0
7285  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
7286 #endif
7287  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val));
7288 
7289  }
7290  break;
7291 
7292  case 225:
7293 
7294 /* Line 1806 of yacc.c */
7295 #line 2177 "ripper.y"
7296  {
7297 #if 0
7298  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
7299 #endif
7300  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val));
7301 
7302  }
7303  break;
7304 
7305  case 226:
7306 
7307 /* Line 1806 of yacc.c */
7308 #line 2185 "ripper.y"
7309  {
7310 #if 0
7311  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
7312 #endif
7313  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val));
7314 
7315  }
7316  break;
7317 
7318  case 227:
7319 
7320 /* Line 1806 of yacc.c */
7321 #line 2193 "ripper.y"
7322  {
7323 #if 0
7324  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
7325 #endif
7326  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val));
7327 
7328  }
7329  break;
7330 
7331  case 228:
7332 
7333 /* Line 1806 of yacc.c */
7334 #line 2201 "ripper.y"
7335  {
7336 #if 0
7337  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
7338 #endif
7339  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val));
7340 
7341  }
7342  break;
7343 
7344  case 229:
7345 
7346 /* Line 1806 of yacc.c */
7347 #line 2209 "ripper.y"
7348  {
7349 #if 0
7350  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
7351 #endif
7352  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val));
7353 
7354  }
7355  break;
7356 
7357  case 230:
7358 
7359 /* Line 1806 of yacc.c */
7360 #line 2217 "ripper.y"
7361  {
7362 #if 0
7363  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
7364 #endif
7365  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val));
7366 
7367  }
7368  break;
7369 
7370  case 231:
7371 
7372 /* Line 1806 of yacc.c */
7373 #line 2225 "ripper.y"
7374  {
7375 #if 0
7376  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
7377 #endif
7378  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val));
7379 
7380  }
7381  break;
7382 
7383  case 232:
7384 
7385 /* Line 1806 of yacc.c */
7386 #line 2233 "ripper.y"
7387  {
7388 #if 0
7389  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
7390 #endif
7391  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val));
7392 
7393  }
7394  break;
7395 
7396  case 233:
7397 
7398 /* Line 1806 of yacc.c */
7399 #line 2241 "ripper.y"
7400  {
7401 #if 0
7402  (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7403  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].val)->nd_lit, T_REGEXP)) {
7404  (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val));
7405  }
7406 #endif
7407  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val));
7408 
7409  }
7410  break;
7411 
7412  case 234:
7413 
7414 /* Line 1806 of yacc.c */
7415 #line 2252 "ripper.y"
7416  {
7417 #if 0
7418  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val));
7419 #endif
7420  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!~"), (yyvsp[(3) - (3)].val));
7421 
7422  }
7423  break;
7424 
7425  case 235:
7426 
7427 /* Line 1806 of yacc.c */
7428 #line 2260 "ripper.y"
7429  {
7430 #if 0
7431  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
7432 #endif
7433  (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val));
7434 
7435  }
7436  break;
7437 
7438  case 236:
7439 
7440 /* Line 1806 of yacc.c */
7441 #line 2268 "ripper.y"
7442  {
7443 #if 0
7444  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
7445 #endif
7446  (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val));
7447 
7448  }
7449  break;
7450 
7451  case 237:
7452 
7453 /* Line 1806 of yacc.c */
7454 #line 2276 "ripper.y"
7455  {
7456 #if 0
7457  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val));
7458 #endif
7459  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<<"), (yyvsp[(3) - (3)].val));
7460 
7461  }
7462  break;
7463 
7464  case 238:
7465 
7466 /* Line 1806 of yacc.c */
7467 #line 2284 "ripper.y"
7468  {
7469 #if 0
7470  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val));
7471 #endif
7472  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">>"), (yyvsp[(3) - (3)].val));
7473 
7474  }
7475  break;
7476 
7477  case 239:
7478 
7479 /* Line 1806 of yacc.c */
7480 #line 2292 "ripper.y"
7481  {
7482 #if 0
7483  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7484 #endif
7485  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val));
7486 
7487  }
7488  break;
7489 
7490  case 240:
7491 
7492 /* Line 1806 of yacc.c */
7493 #line 2300 "ripper.y"
7494  {
7495 #if 0
7496  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7497 #endif
7498  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val));
7499 
7500  }
7501  break;
7502 
7503  case 241:
7504 
7505 /* Line 1806 of yacc.c */
7506 #line 2307 "ripper.y"
7507  {in_defined = 1;}
7508  break;
7509 
7510  case 242:
7511 
7512 /* Line 1806 of yacc.c */
7513 #line 2308 "ripper.y"
7514  {
7515 #if 0
7516  in_defined = 0;
7517  (yyval.val) = NEW_DEFINED((yyvsp[(4) - (4)].val));
7518 #endif
7519  in_defined = 0;
7520  (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val));
7521 
7522  }
7523  break;
7524 
7525  case 243:
7526 
7527 /* Line 1806 of yacc.c */
7528 #line 2318 "ripper.y"
7529  {
7530 #if 0
7531  value_expr((yyvsp[(1) - (6)].val));
7532  (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7533  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
7534 #endif
7535  (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7536 
7537  }
7538  break;
7539 
7540  case 244:
7541 
7542 /* Line 1806 of yacc.c */
7543 #line 2328 "ripper.y"
7544  {
7545  (yyval.val) = (yyvsp[(1) - (1)].val);
7546  }
7547  break;
7548 
7549  case 245:
7550 
7551 /* Line 1806 of yacc.c */
7552 #line 2334 "ripper.y"
7553  {
7554 #if 0
7555  value_expr((yyvsp[(1) - (1)].val));
7556  (yyval.val) = (yyvsp[(1) - (1)].val);
7557  if (!(yyval.val)) (yyval.val) = NEW_NIL();
7558 #endif
7559  (yyval.val) = (yyvsp[(1) - (1)].val);
7560 
7561  }
7562  break;
7563 
7564  case 247:
7565 
7566 /* Line 1806 of yacc.c */
7567 #line 2347 "ripper.y"
7568  {
7569  (yyval.val) = (yyvsp[(1) - (2)].val);
7570  }
7571  break;
7572 
7573  case 248:
7574 
7575 /* Line 1806 of yacc.c */
7576 #line 2351 "ripper.y"
7577  {
7578 #if 0
7579  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7580 #endif
7581  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7582 
7583  }
7584  break;
7585 
7586  case 249:
7587 
7588 /* Line 1806 of yacc.c */
7589 #line 2359 "ripper.y"
7590  {
7591 #if 0
7592  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7593 #endif
7594  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7595 
7596  }
7597  break;
7598 
7599  case 250:
7600 
7601 /* Line 1806 of yacc.c */
7602 #line 2369 "ripper.y"
7603  {
7604 #if 0
7605  (yyval.val) = (yyvsp[(2) - (3)].val);
7606 #endif
7607  (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
7608 
7609  }
7610  break;
7611 
7612  case 255:
7613 
7614 /* Line 1806 of yacc.c */
7615 #line 2385 "ripper.y"
7616  {
7617  (yyval.val) = (yyvsp[(1) - (2)].val);
7618  }
7619  break;
7620 
7621  case 256:
7622 
7623 /* Line 1806 of yacc.c */
7624 #line 2389 "ripper.y"
7625  {
7626 #if 0
7627  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7628 #endif
7629  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7630 
7631  }
7632  break;
7633 
7634  case 257:
7635 
7636 /* Line 1806 of yacc.c */
7637 #line 2397 "ripper.y"
7638  {
7639 #if 0
7640  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7641 #endif
7642  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7643 
7644  }
7645  break;
7646 
7647  case 258:
7648 
7649 /* Line 1806 of yacc.c */
7650 #line 2407 "ripper.y"
7651  {
7652 #if 0
7653  value_expr((yyvsp[(1) - (1)].val));
7654  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7655 #endif
7656  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7657 
7658  }
7659  break;
7660 
7661  case 259:
7662 
7663 /* Line 1806 of yacc.c */
7664 #line 2416 "ripper.y"
7665  {
7666 #if 0
7667  (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7668 #endif
7669  (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7670 
7671  }
7672  break;
7673 
7674  case 260:
7675 
7676 /* Line 1806 of yacc.c */
7677 #line 2424 "ripper.y"
7678  {
7679 #if 0
7680  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7681  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
7682 #endif
7683  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7684  (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
7685 
7686  }
7687  break;
7688 
7689  case 261:
7690 
7691 /* Line 1806 of yacc.c */
7692 #line 2434 "ripper.y"
7693  {
7694 #if 0
7695  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7696  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
7697 #endif
7698  (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
7699 
7700  }
7701  break;
7702 
7703  case 262:
7704 
7705 /* Line 1806 of yacc.c */
7706 #line 2445 "ripper.y"
7707  {
7708  (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
7709  }
7710  break;
7711 
7712  case 263:
7713 
7714 /* Line 1806 of yacc.c */
7715 #line 2451 "ripper.y"
7716  {
7717  (yyval.val) = cmdarg_stack;
7718  CMDARG_PUSH(1);
7719  }
7720  break;
7721 
7722  case 264:
7723 
7724 /* Line 1806 of yacc.c */
7725 #line 2456 "ripper.y"
7726  {
7727  /* CMDARG_POP() */
7728  cmdarg_stack = (yyvsp[(1) - (2)].val);
7729  (yyval.val) = (yyvsp[(2) - (2)].val);
7730  }
7731  break;
7732 
7733  case 265:
7734 
7735 /* Line 1806 of yacc.c */
7736 #line 2464 "ripper.y"
7737  {
7738 #if 0
7739  (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
7740 #endif
7741  (yyval.val) = (yyvsp[(2) - (2)].val);
7742 
7743  }
7744  break;
7745 
7746  case 266:
7747 
7748 /* Line 1806 of yacc.c */
7749 #line 2474 "ripper.y"
7750  {
7751  (yyval.val) = (yyvsp[(2) - (2)].val);
7752  }
7753  break;
7754 
7755  case 267:
7756 
7757 /* Line 1806 of yacc.c */
7758 #line 2478 "ripper.y"
7759  {
7760  (yyval.val) = 0;
7761  }
7762  break;
7763 
7764  case 268:
7765 
7766 /* Line 1806 of yacc.c */
7767 #line 2484 "ripper.y"
7768  {
7769 #if 0
7770  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7771 #endif
7772  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7773 
7774  }
7775  break;
7776 
7777  case 269:
7778 
7779 /* Line 1806 of yacc.c */
7780 #line 2492 "ripper.y"
7781  {
7782 #if 0
7783  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7784 #endif
7785  (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
7786 
7787  }
7788  break;
7789 
7790  case 270:
7791 
7792 /* Line 1806 of yacc.c */
7793 #line 2500 "ripper.y"
7794  {
7795 #if 0
7796  NODE *n1;
7797  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7798  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7799  }
7800  else {
7801  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7802  }
7803 #endif
7804  (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7805 
7806  }
7807  break;
7808 
7809  case 271:
7810 
7811 /* Line 1806 of yacc.c */
7812 #line 2514 "ripper.y"
7813  {
7814 #if 0
7815  NODE *n1;
7816  if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7817  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7818  }
7819  else {
7820  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7821  }
7822 #endif
7823  (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7824 
7825  }
7826  break;
7827 
7828  case 272:
7829 
7830 /* Line 1806 of yacc.c */
7831 #line 2530 "ripper.y"
7832  {
7833 #if 0
7834  NODE *n1;
7835  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7836  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7837  }
7838  else {
7839  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7840  }
7841 #endif
7842  (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
7843 
7844  }
7845  break;
7846 
7847  case 273:
7848 
7849 /* Line 1806 of yacc.c */
7850 #line 2544 "ripper.y"
7851  {
7852 #if 0
7853  NODE *n1;
7854  if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
7855  (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7856  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7857  }
7858  else {
7859  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7860  }
7861 #endif
7862  (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
7863 
7864  }
7865  break;
7866 
7867  case 274:
7868 
7869 /* Line 1806 of yacc.c */
7870 #line 2559 "ripper.y"
7871  {
7872 #if 0
7873  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7874 #endif
7875  (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
7876 
7877  }
7878  break;
7879 
7880  case 285:
7881 
7882 /* Line 1806 of yacc.c */
7883 #line 2579 "ripper.y"
7884  {
7885 #if 0
7886  (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
7887 #endif
7888  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
7889 
7890  }
7891  break;
7892 
7893  case 286:
7894 
7895 /* Line 1806 of yacc.c */
7896 #line 2587 "ripper.y"
7897  {
7898  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7899  cmdarg_stack = 0;
7900 #if 0
7901  (yyval.num) = ruby_sourceline;
7902 #endif
7903 
7904  }
7905  break;
7906 
7907  case 287:
7908 
7909 /* Line 1806 of yacc.c */
7910 #line 2597 "ripper.y"
7911  {
7912  cmdarg_stack = (yyvsp[(1) - (4)].val);
7913 #if 0
7914  if ((yyvsp[(3) - (4)].val) == NULL) {
7915  (yyval.val) = NEW_NIL();
7916  }
7917  else {
7918  if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE ||
7919  nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE)
7920  nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
7921  (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val));
7922  }
7923  nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
7924 #endif
7925  (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
7926 
7927  }
7928  break;
7929 
7930  case 288:
7931 
7932 /* Line 1806 of yacc.c */
7933 #line 2614 "ripper.y"
7934  {lex_state = EXPR_ENDARG;}
7935  break;
7936 
7937  case 289:
7938 
7939 /* Line 1806 of yacc.c */
7940 #line 2615 "ripper.y"
7941  {
7942 #if 0
7943  (yyval.val) = 0;
7944 #endif
7945  (yyval.val) = dispatch1(paren, 0);
7946 
7947  }
7948  break;
7949 
7950  case 290:
7951 
7952 /* Line 1806 of yacc.c */
7953 #line 2622 "ripper.y"
7954  {lex_state = EXPR_ENDARG;}
7955  break;
7956 
7957  case 291:
7958 
7959 /* Line 1806 of yacc.c */
7960 #line 2623 "ripper.y"
7961  {
7962 #if 0
7963  (yyval.val) = (yyvsp[(2) - (4)].val);
7964 #endif
7965  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
7966 
7967  }
7968  break;
7969 
7970  case 292:
7971 
7972 /* Line 1806 of yacc.c */
7973 #line 2631 "ripper.y"
7974  {
7975 #if 0
7976  (yyval.val) = (yyvsp[(2) - (3)].val);
7977 #endif
7978  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
7979 
7980  }
7981  break;
7982 
7983  case 293:
7984 
7985 /* Line 1806 of yacc.c */
7986 #line 2639 "ripper.y"
7987  {
7988 #if 0
7989  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7990 #endif
7991  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7992 
7993  }
7994  break;
7995 
7996  case 294:
7997 
7998 /* Line 1806 of yacc.c */
7999 #line 2647 "ripper.y"
8000  {
8001 #if 0
8002  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
8003 #endif
8004  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
8005 
8006  }
8007  break;
8008 
8009  case 295:
8010 
8011 /* Line 1806 of yacc.c */
8012 #line 2655 "ripper.y"
8013  {
8014 #if 0
8015  if ((yyvsp[(2) - (3)].val) == 0) {
8016  (yyval.val) = NEW_ZARRAY(); /* zero length array*/
8017  }
8018  else {
8019  (yyval.val) = (yyvsp[(2) - (3)].val);
8020  }
8021 #endif
8022  (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
8023 
8024  }
8025  break;
8026 
8027  case 296:
8028 
8029 /* Line 1806 of yacc.c */
8030 #line 2668 "ripper.y"
8031  {
8032 #if 0
8033  (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
8034 #endif
8035  (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
8036 
8037  }
8038  break;
8039 
8040  case 297:
8041 
8042 /* Line 1806 of yacc.c */
8043 #line 2676 "ripper.y"
8044  {
8045 #if 0
8046  (yyval.val) = NEW_RETURN(0);
8047 #endif
8048  (yyval.val) = dispatch0(return0);
8049 
8050  }
8051  break;
8052 
8053  case 298:
8054 
8055 /* Line 1806 of yacc.c */
8056 #line 2684 "ripper.y"
8057  {
8058 #if 0
8059  (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
8060 #endif
8061  (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
8062 
8063  }
8064  break;
8065 
8066  case 299:
8067 
8068 /* Line 1806 of yacc.c */
8069 #line 2692 "ripper.y"
8070  {
8071 #if 0
8072  (yyval.val) = NEW_YIELD(0);
8073 #endif
8074  (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
8075 
8076  }
8077  break;
8078 
8079  case 300:
8080 
8081 /* Line 1806 of yacc.c */
8082 #line 2700 "ripper.y"
8083  {
8084 #if 0
8085  (yyval.val) = NEW_YIELD(0);
8086 #endif
8087  (yyval.val) = dispatch0(yield0);
8088 
8089  }
8090  break;
8091 
8092  case 301:
8093 
8094 /* Line 1806 of yacc.c */
8095 #line 2707 "ripper.y"
8096  {in_defined = 1;}
8097  break;
8098 
8099  case 302:
8100 
8101 /* Line 1806 of yacc.c */
8102 #line 2708 "ripper.y"
8103  {
8104 #if 0
8105  in_defined = 0;
8106  (yyval.val) = NEW_DEFINED((yyvsp[(5) - (6)].val));
8107 #endif
8108  in_defined = 0;
8109  (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val));
8110 
8111  }
8112  break;
8113 
8114  case 303:
8115 
8116 /* Line 1806 of yacc.c */
8117 #line 2718 "ripper.y"
8118  {
8119 #if 0
8120  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
8121 #endif
8122  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val));
8123 
8124  }
8125  break;
8126 
8127  case 304:
8128 
8129 /* Line 1806 of yacc.c */
8130 #line 2726 "ripper.y"
8131  {
8132 #if 0
8133  (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
8134 #endif
8135  (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil);
8136 
8137  }
8138  break;
8139 
8140  case 305:
8141 
8142 /* Line 1806 of yacc.c */
8143 #line 2734 "ripper.y"
8144  {
8145 #if 0
8146  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
8147  (yyval.val) = (yyvsp[(2) - (2)].val);
8148 #endif
8149  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
8150  (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
8151 
8152  }
8153  break;
8154 
8155  case 307:
8156 
8157 /* Line 1806 of yacc.c */
8158 #line 2745 "ripper.y"
8159  {
8160 #if 0
8161  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
8162  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
8163  (yyval.val) = (yyvsp[(2) - (2)].val);
8164 #endif
8165  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
8166 
8167  }
8168  break;
8169 
8170  case 308:
8171 
8172 /* Line 1806 of yacc.c */
8173 #line 2755 "ripper.y"
8174  {
8175  (yyval.val) = (yyvsp[(2) - (2)].val);
8176  }
8177  break;
8178 
8179  case 309:
8180 
8181 /* Line 1806 of yacc.c */
8182 #line 2762 "ripper.y"
8183  {
8184 #if 0
8185  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8186  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8187 #endif
8188  (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8189 
8190  }
8191  break;
8192 
8193  case 310:
8194 
8195 /* Line 1806 of yacc.c */
8196 #line 2774 "ripper.y"
8197  {
8198 #if 0
8199  (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8200  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8201 #endif
8202  (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8203 
8204  }
8205  break;
8206 
8207  case 311:
8208 
8209 /* Line 1806 of yacc.c */
8210 #line 2782 "ripper.y"
8211  {COND_PUSH(1);}
8212  break;
8213 
8214  case 312:
8215 
8216 /* Line 1806 of yacc.c */
8217 #line 2782 "ripper.y"
8218  {COND_POP();}
8219  break;
8220 
8221  case 313:
8222 
8223 /* Line 1806 of yacc.c */
8224 #line 2785 "ripper.y"
8225  {
8226 #if 0
8227  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8228  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8229 #endif
8230  (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8231 
8232  }
8233  break;
8234 
8235  case 314:
8236 
8237 /* Line 1806 of yacc.c */
8238 #line 2793 "ripper.y"
8239  {COND_PUSH(1);}
8240  break;
8241 
8242  case 315:
8243 
8244 /* Line 1806 of yacc.c */
8245 #line 2793 "ripper.y"
8246  {COND_POP();}
8247  break;
8248 
8249  case 316:
8250 
8251 /* Line 1806 of yacc.c */
8252 #line 2796 "ripper.y"
8253  {
8254 #if 0
8255  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8256  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8257 #endif
8258  (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8259 
8260  }
8261  break;
8262 
8263  case 317:
8264 
8265 /* Line 1806 of yacc.c */
8266 #line 2807 "ripper.y"
8267  {
8268 #if 0
8269  (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8270  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8271 #endif
8272  (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8273 
8274  }
8275  break;
8276 
8277  case 318:
8278 
8279 /* Line 1806 of yacc.c */
8280 #line 2816 "ripper.y"
8281  {
8282 #if 0
8283  (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
8284 #endif
8285  (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
8286 
8287  }
8288  break;
8289 
8290  case 319:
8291 
8292 /* Line 1806 of yacc.c */
8293 #line 2824 "ripper.y"
8294  {COND_PUSH(1);}
8295  break;
8296 
8297  case 320:
8298 
8299 /* Line 1806 of yacc.c */
8300 #line 2826 "ripper.y"
8301  {COND_POP();}
8302  break;
8303 
8304  case 321:
8305 
8306 /* Line 1806 of yacc.c */
8307 #line 2829 "ripper.y"
8308  {
8309 #if 0
8310  /*
8311  * for a, b, c in e
8312  * #=>
8313  * e.each{|*x| a, b, c = x
8314  *
8315  * for a in e
8316  * #=>
8317  * e.each{|x| a, = x}
8318  */
8319  ID id = internal_id();
8320  ID *tbl = ALLOC_N(ID, 2);
8321  NODE *m = NEW_ARGS_AUX(0, 0);
8322  NODE *args, *scope;
8323 
8324  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) {
8325  /* if args.length == 1 && args[0].kind_of?(Array)
8326  * args = args[0]
8327  * end
8328  */
8329  NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
8330  NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
8331  m->nd_next = block_append(
8332  NEW_IF(
8334  NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
8335  idEq, one),
8336  NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero),
8337  rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
8338  0),
8339  NEW_DASGN_CURR(id,
8340  NEW_CALL(NEW_DVAR(id), idAREF, zero)),
8341  0),
8342  node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id)));
8343 
8344  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8345  }
8346  else {
8347  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN ||
8348  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN ||
8349  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) {
8350  (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id);
8351  m->nd_plen = 1;
8352  m->nd_next = (yyvsp[(2) - (9)].val);
8353  args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
8354  }
8355  else {
8356  m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id));
8357  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8358  }
8359  }
8360  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
8361  tbl[0] = 1; tbl[1] = id;
8362  (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope);
8363  fixpos((yyval.val), (yyvsp[(2) - (9)].val));
8364 #endif
8365  (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
8366 
8367  }
8368  break;
8369 
8370  case 322:
8371 
8372 /* Line 1806 of yacc.c */
8373 #line 2890 "ripper.y"
8374  {
8375  if (in_def || in_single)
8376  yyerror("class definition in method body");
8377  local_push(0);
8378 #if 0
8379  (yyval.num) = ruby_sourceline;
8380 #endif
8381 
8382  }
8383  break;
8384 
8385  case 323:
8386 
8387 /* Line 1806 of yacc.c */
8388 #line 2901 "ripper.y"
8389  {
8390 #if 0
8391  (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
8392  nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
8393 #endif
8394  (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
8395 
8396  local_pop();
8397  }
8398  break;
8399 
8400  case 324:
8401 
8402 /* Line 1806 of yacc.c */
8403 #line 2911 "ripper.y"
8404  {
8405  (yyval.num) = in_def;
8406  in_def = 0;
8407  }
8408  break;
8409 
8410  case 325:
8411 
8412 /* Line 1806 of yacc.c */
8413 #line 2916 "ripper.y"
8414  {
8415  (yyval.num) = in_single;
8416  in_single = 0;
8417  local_push(0);
8418  }
8419  break;
8420 
8421  case 326:
8422 
8423 /* Line 1806 of yacc.c */
8424 #line 2923 "ripper.y"
8425  {
8426 #if 0
8427  (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8428  fixpos((yyval.val), (yyvsp[(3) - (8)].val));
8429 #endif
8430  (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8431 
8432  local_pop();
8433  in_def = (yyvsp[(4) - (8)].num);
8434  in_single = (yyvsp[(6) - (8)].num);
8435  }
8436  break;
8437 
8438  case 327:
8439 
8440 /* Line 1806 of yacc.c */
8441 #line 2935 "ripper.y"
8442  {
8443  if (in_def || in_single)
8444  yyerror("module definition in method body");
8445  local_push(0);
8446 #if 0
8447  (yyval.num) = ruby_sourceline;
8448 #endif
8449 
8450  }
8451  break;
8452 
8453  case 328:
8454 
8455 /* Line 1806 of yacc.c */
8456 #line 2946 "ripper.y"
8457  {
8458 #if 0
8459  (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8460  nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
8461 #endif
8462  (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8463 
8464  local_pop();
8465  }
8466  break;
8467 
8468  case 329:
8469 
8470 /* Line 1806 of yacc.c */
8471 #line 2956 "ripper.y"
8472  {
8473  (yyval.id) = cur_mid;
8474  cur_mid = (yyvsp[(2) - (2)].val);
8475  in_def++;
8476  local_push(0);
8477  }
8478  break;
8479 
8480  case 330:
8481 
8482 /* Line 1806 of yacc.c */
8483 #line 2965 "ripper.y"
8484  {
8485 #if 0
8486  NODE *body = remove_begin((yyvsp[(5) - (6)].val));
8487  reduce_nodes(&body);
8488  (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE);
8489  nd_set_line((yyval.val), (yyvsp[(1) - (6)].num));
8490 #endif
8491  (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8492 
8493  local_pop();
8494  in_def--;
8495  cur_mid = (yyvsp[(3) - (6)].id);
8496  }
8497  break;
8498 
8499  case 331:
8500 
8501 /* Line 1806 of yacc.c */
8502 #line 2978 "ripper.y"
8503  {lex_state = EXPR_FNAME;}
8504  break;
8505 
8506  case 332:
8507 
8508 /* Line 1806 of yacc.c */
8509 #line 2979 "ripper.y"
8510  {
8511  in_single++;
8512  lex_state = EXPR_ENDFN; /* force for args */
8513  local_push(0);
8514  }
8515  break;
8516 
8517  case 333:
8518 
8519 /* Line 1806 of yacc.c */
8520 #line 2987 "ripper.y"
8521  {
8522 #if 0
8523  NODE *body = remove_begin((yyvsp[(8) - (9)].val));
8524  reduce_nodes(&body);
8525  (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
8526  nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
8527 #endif
8528  (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
8529 
8530  local_pop();
8531  in_single--;
8532  }
8533  break;
8534 
8535  case 334:
8536 
8537 /* Line 1806 of yacc.c */
8538 #line 3000 "ripper.y"
8539  {
8540 #if 0
8541  (yyval.val) = NEW_BREAK(0);
8542 #endif
8543  (yyval.val) = dispatch1(break, arg_new());
8544 
8545  }
8546  break;
8547 
8548  case 335:
8549 
8550 /* Line 1806 of yacc.c */
8551 #line 3008 "ripper.y"
8552  {
8553 #if 0
8554  (yyval.val) = NEW_NEXT(0);
8555 #endif
8556  (yyval.val) = dispatch1(next, arg_new());
8557 
8558  }
8559  break;
8560 
8561  case 336:
8562 
8563 /* Line 1806 of yacc.c */
8564 #line 3016 "ripper.y"
8565  {
8566 #if 0
8567  (yyval.val) = NEW_REDO();
8568 #endif
8569  (yyval.val) = dispatch0(redo);
8570 
8571  }
8572  break;
8573 
8574  case 337:
8575 
8576 /* Line 1806 of yacc.c */
8577 #line 3024 "ripper.y"
8578  {
8579 #if 0
8580  (yyval.val) = NEW_RETRY();
8581 #endif
8582  (yyval.val) = dispatch0(retry);
8583 
8584  }
8585  break;
8586 
8587  case 338:
8588 
8589 /* Line 1806 of yacc.c */
8590 #line 3034 "ripper.y"
8591  {
8592 #if 0
8593  value_expr((yyvsp[(1) - (1)].val));
8594  (yyval.val) = (yyvsp[(1) - (1)].val);
8595  if (!(yyval.val)) (yyval.val) = NEW_NIL();
8596 #endif
8597  (yyval.val) = (yyvsp[(1) - (1)].val);
8598 
8599  }
8600  break;
8601 
8602  case 339:
8603 
8604 /* Line 1806 of yacc.c */
8605 #line 3046 "ripper.y"
8606  {
8607  token_info_push("begin");
8608  }
8609  break;
8610 
8611  case 340:
8612 
8613 /* Line 1806 of yacc.c */
8614 #line 3052 "ripper.y"
8615  {
8616  token_info_push("if");
8617  }
8618  break;
8619 
8620  case 341:
8621 
8622 /* Line 1806 of yacc.c */
8623 #line 3058 "ripper.y"
8624  {
8625  token_info_push("unless");
8626  }
8627  break;
8628 
8629  case 342:
8630 
8631 /* Line 1806 of yacc.c */
8632 #line 3064 "ripper.y"
8633  {
8634  token_info_push("while");
8635  }
8636  break;
8637 
8638  case 343:
8639 
8640 /* Line 1806 of yacc.c */
8641 #line 3070 "ripper.y"
8642  {
8643  token_info_push("until");
8644  }
8645  break;
8646 
8647  case 344:
8648 
8649 /* Line 1806 of yacc.c */
8650 #line 3076 "ripper.y"
8651  {
8652  token_info_push("case");
8653  }
8654  break;
8655 
8656  case 345:
8657 
8658 /* Line 1806 of yacc.c */
8659 #line 3082 "ripper.y"
8660  {
8661  token_info_push("for");
8662  }
8663  break;
8664 
8665  case 346:
8666 
8667 /* Line 1806 of yacc.c */
8668 #line 3088 "ripper.y"
8669  {
8670  token_info_push("class");
8671  }
8672  break;
8673 
8674  case 347:
8675 
8676 /* Line 1806 of yacc.c */
8677 #line 3094 "ripper.y"
8678  {
8679  token_info_push("module");
8680  }
8681  break;
8682 
8683  case 348:
8684 
8685 /* Line 1806 of yacc.c */
8686 #line 3100 "ripper.y"
8687  {
8688  token_info_push("def");
8689 #if 0
8690  (yyval.num) = ruby_sourceline;
8691 #endif
8692 
8693  }
8694  break;
8695 
8696  case 349:
8697 
8698 /* Line 1806 of yacc.c */
8699 #line 3110 "ripper.y"
8700  {
8701  token_info_pop("end");
8702  }
8703  break;
8704 
8705  case 350:
8706 
8707 /* Line 1806 of yacc.c */
8708 #line 3118 "ripper.y"
8709  { (yyval.val) = Qnil; }
8710  break;
8711 
8712  case 352:
8713 
8714 /* Line 1806 of yacc.c */
8715 #line 3124 "ripper.y"
8716  { (yyval.val) = (yyvsp[(2) - (2)].val); }
8717  break;
8718 
8719  case 353:
8720 
8721 /* Line 1806 of yacc.c */
8722 #line 3131 "ripper.y"
8723  { (yyval.val) = Qnil; }
8724  break;
8725 
8726  case 356:
8727 
8728 /* Line 1806 of yacc.c */
8729 #line 3140 "ripper.y"
8730  {
8731 #if 0
8732  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
8733  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8734 #endif
8735  (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
8736 
8737  }
8738  break;
8739 
8740  case 358:
8741 
8742 /* Line 1806 of yacc.c */
8743 #line 3152 "ripper.y"
8744  {
8745 #if 0
8746  (yyval.val) = (yyvsp[(2) - (2)].val);
8747 #endif
8748  (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
8749 
8750  }
8751  break;
8752 
8753  case 361:
8754 
8755 /* Line 1806 of yacc.c */
8756 #line 3166 "ripper.y"
8757  {
8758  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
8759 #if 0
8760 #endif
8761  (yyval.val) = dispatch1(mlhs_paren, (yyval.val));
8762 
8763  }
8764  break;
8765 
8766  case 362:
8767 
8768 /* Line 1806 of yacc.c */
8769 #line 3174 "ripper.y"
8770  {
8771 #if 0
8772  (yyval.val) = (yyvsp[(2) - (3)].val);
8773 #endif
8774  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
8775 
8776  }
8777  break;
8778 
8779  case 363:
8780 
8781 /* Line 1806 of yacc.c */
8782 #line 3184 "ripper.y"
8783  {
8784 #if 0
8785  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
8786 #endif
8787  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
8788 
8789  }
8790  break;
8791 
8792  case 364:
8793 
8794 /* Line 1806 of yacc.c */
8795 #line 3192 "ripper.y"
8796  {
8797 #if 0
8798  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8799 #endif
8800  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8801 
8802  }
8803  break;
8804 
8805  case 365:
8806 
8807 /* Line 1806 of yacc.c */
8808 #line 3202 "ripper.y"
8809  {
8810 #if 0
8811  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
8812 #endif
8813  (yyval.val) = (yyvsp[(1) - (1)].val);
8814 
8815  }
8816  break;
8817 
8818  case 366:
8819 
8820 /* Line 1806 of yacc.c */
8821 #line 3210 "ripper.y"
8822  {
8823  (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
8824 #if 0
8825  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val));
8826 #endif
8827  (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
8828 
8829  }
8830  break;
8831 
8832  case 367:
8833 
8834 /* Line 1806 of yacc.c */
8835 #line 3219 "ripper.y"
8836  {
8837  (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
8838 #if 0
8839  (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val)));
8840 #endif
8841  (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
8842 
8843  }
8844  break;
8845 
8846  case 368:
8847 
8848 /* Line 1806 of yacc.c */
8849 #line 3228 "ripper.y"
8850  {
8851 #if 0
8852  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
8853 #endif
8854  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
8855 
8856  }
8857  break;
8858 
8859  case 369:
8860 
8861 /* Line 1806 of yacc.c */
8862 #line 3236 "ripper.y"
8863  {
8864 #if 0
8865  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
8866 #endif
8867  (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
8868 
8869  }
8870  break;
8871 
8872  case 370:
8873 
8874 /* Line 1806 of yacc.c */
8875 #line 3244 "ripper.y"
8876  {
8877  (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
8878 #if 0
8879  (yyval.val) = NEW_MASGN(0, (yyval.val));
8880 #endif
8881  (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
8882 
8883  }
8884  break;
8885 
8886  case 371:
8887 
8888 /* Line 1806 of yacc.c */
8889 #line 3253 "ripper.y"
8890  {
8891  (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
8892 #if 0
8893  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val)));
8894 #endif
8895  #if 0
8896  TODO: Check me
8897  #endif
8898  (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val));
8899 
8900  }
8901  break;
8902 
8903  case 372:
8904 
8905 /* Line 1806 of yacc.c */
8906 #line 3265 "ripper.y"
8907  {
8908 #if 0
8909  (yyval.val) = NEW_MASGN(0, -1);
8910 #endif
8911  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8912 
8913  }
8914  break;
8915 
8916  case 373:
8917 
8918 /* Line 1806 of yacc.c */
8919 #line 3273 "ripper.y"
8920  {
8921 #if 0
8922  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
8923 #endif
8924  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8925 
8926  }
8927  break;
8928 
8929  case 374:
8930 
8931 /* Line 1806 of yacc.c */
8932 #line 3284 "ripper.y"
8933  {
8934  (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
8935  }
8936  break;
8937 
8938  case 375:
8939 
8940 /* Line 1806 of yacc.c */
8941 #line 3288 "ripper.y"
8942  {
8943  (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
8944  }
8945  break;
8946 
8947  case 376:
8948 
8949 /* Line 1806 of yacc.c */
8950 #line 3292 "ripper.y"
8951  {
8952  (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
8953  }
8954  break;
8955 
8956  case 377:
8957 
8958 /* Line 1806 of yacc.c */
8959 #line 3296 "ripper.y"
8960  {
8961  (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
8962  }
8963  break;
8964 
8965  case 378:
8966 
8967 /* Line 1806 of yacc.c */
8968 #line 3302 "ripper.y"
8969  {
8970  (yyval.val) = (yyvsp[(2) - (2)].val);
8971  }
8972  break;
8973 
8974  case 379:
8975 
8976 /* Line 1806 of yacc.c */
8977 #line 3306 "ripper.y"
8978  {
8979  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
8980  }
8981  break;
8982 
8983  case 380:
8984 
8985 /* Line 1806 of yacc.c */
8986 #line 3312 "ripper.y"
8987  {
8988  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
8989  }
8990  break;
8991 
8992  case 381:
8993 
8994 /* Line 1806 of yacc.c */
8995 #line 3316 "ripper.y"
8996  {
8997  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
8998  }
8999  break;
9000 
9001  case 382:
9002 
9003 /* Line 1806 of yacc.c */
9004 #line 3320 "ripper.y"
9005  {
9006  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
9007  }
9008  break;
9009 
9010  case 383:
9011 
9012 /* Line 1806 of yacc.c */
9013 #line 3324 "ripper.y"
9014  {
9015  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9016  }
9017  break;
9018 
9019  case 384:
9020 
9021 /* Line 1806 of yacc.c */
9022 #line 3328 "ripper.y"
9023  {
9024  (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
9025  }
9026  break;
9027 
9028  case 385:
9029 
9030 /* Line 1806 of yacc.c */
9031 #line 3332 "ripper.y"
9032  {
9033  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
9034 #if 0
9035 #endif
9036  dispatch1(excessed_comma, (yyval.val));
9037 
9038  }
9039  break;
9040 
9041  case 386:
9042 
9043 /* Line 1806 of yacc.c */
9044 #line 3340 "ripper.y"
9045  {
9046  (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9047  }
9048  break;
9049 
9050  case 387:
9051 
9052 /* Line 1806 of yacc.c */
9053 #line 3344 "ripper.y"
9054  {
9055  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
9056  }
9057  break;
9058 
9059  case 388:
9060 
9061 /* Line 1806 of yacc.c */
9062 #line 3348 "ripper.y"
9063  {
9064  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
9065  }
9066  break;
9067 
9068  case 389:
9069 
9070 /* Line 1806 of yacc.c */
9071 #line 3352 "ripper.y"
9072  {
9073  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9074  }
9075  break;
9076 
9077  case 390:
9078 
9079 /* Line 1806 of yacc.c */
9080 #line 3356 "ripper.y"
9081  {
9082  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
9083  }
9084  break;
9085 
9086  case 391:
9087 
9088 /* Line 1806 of yacc.c */
9089 #line 3360 "ripper.y"
9090  {
9091  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9092  }
9093  break;
9094 
9095  case 392:
9096 
9097 /* Line 1806 of yacc.c */
9098 #line 3364 "ripper.y"
9099  {
9100  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
9101  }
9102  break;
9103 
9104  case 393:
9105 
9106 /* Line 1806 of yacc.c */
9107 #line 3368 "ripper.y"
9108  {
9109  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9110  }
9111  break;
9112 
9113  case 394:
9114 
9115 /* Line 1806 of yacc.c */
9116 #line 3372 "ripper.y"
9117  {
9118  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
9119  }
9120  break;
9121 
9122  case 396:
9123 
9124 /* Line 1806 of yacc.c */
9125 #line 3379 "ripper.y"
9126  {
9127  command_start = TRUE;
9128  }
9129  break;
9130 
9131  case 397:
9132 
9133 /* Line 1806 of yacc.c */
9134 #line 3385 "ripper.y"
9135  {
9136 #if 0
9137  (yyval.val) = 0;
9138 #endif
9139  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9140  escape_Qundef((yyvsp[(2) - (3)].val)));
9141 
9142  }
9143  break;
9144 
9145  case 398:
9146 
9147 /* Line 1806 of yacc.c */
9148 #line 3394 "ripper.y"
9149  {
9150 #if 0
9151  (yyval.val) = 0;
9152 #endif
9153  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9154  Qnil);
9155 
9156  }
9157  break;
9158 
9159  case 399:
9160 
9161 /* Line 1806 of yacc.c */
9162 #line 3403 "ripper.y"
9163  {
9164 #if 0
9165  (yyval.val) = (yyvsp[(2) - (4)].val);
9166 #endif
9167  (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
9168 
9169  }
9170  break;
9171 
9172  case 400:
9173 
9174 /* Line 1806 of yacc.c */
9175 #line 3414 "ripper.y"
9176  {
9177  (yyval.val) = 0;
9178  }
9179  break;
9180 
9181  case 401:
9182 
9183 /* Line 1806 of yacc.c */
9184 #line 3418 "ripper.y"
9185  {
9186 #if 0
9187  (yyval.val) = 0;
9188 #endif
9189  (yyval.val) = (yyvsp[(3) - (4)].val);
9190 
9191  }
9192  break;
9193 
9194  case 402:
9195 
9196 /* Line 1806 of yacc.c */
9197 #line 3430 "ripper.y"
9198  {
9199  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9200  }
9201  break;
9202 
9203  case 403:
9204 
9205 /* Line 1806 of yacc.c */
9206 #line 3437 "ripper.y"
9207  {
9208  rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
9209  }
9210  break;
9211 
9212  case 404:
9213 
9214 /* Line 1806 of yacc.c */
9215 #line 3444 "ripper.y"
9216  {
9217  new_bv(get_id((yyvsp[(1) - (1)].val)));
9218 #if 0
9219 #endif
9220  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
9221 
9222  }
9223  break;
9224 
9225  case 405:
9226 
9227 /* Line 1806 of yacc.c */
9228 #line 3452 "ripper.y"
9229  {
9230  (yyval.val) = 0;
9231  }
9232  break;
9233 
9234  case 406:
9235 
9236 /* Line 1806 of yacc.c */
9237 #line 3457 "ripper.y"
9238  {
9239  (yyval.vars) = dyna_push();
9240  }
9241  break;
9242 
9243  case 407:
9244 
9245 /* Line 1806 of yacc.c */
9246 #line 3460 "ripper.y"
9247  {
9248  (yyval.num) = lpar_beg;
9249  lpar_beg = ++paren_nest;
9250  }
9251  break;
9252 
9253  case 408:
9254 
9255 /* Line 1806 of yacc.c */
9256 #line 3465 "ripper.y"
9257  {
9258  (yyval.num) = ruby_sourceline;
9259  }
9260  break;
9261 
9262  case 409:
9263 
9264 /* Line 1806 of yacc.c */
9265 #line 3469 "ripper.y"
9266  {
9267  lpar_beg = (yyvsp[(2) - (5)].num);
9268 #if 0
9269  (yyval.val) = NEW_LAMBDA((yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9270  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9271 #endif
9272  (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9273 
9274  dyna_pop((yyvsp[(1) - (5)].vars));
9275  }
9276  break;
9277 
9278  case 410:
9279 
9280 /* Line 1806 of yacc.c */
9281 #line 3482 "ripper.y"
9282  {
9283 #if 0
9284  (yyval.val) = (yyvsp[(2) - (4)].val);
9285 #endif
9286  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
9287 
9288  }
9289  break;
9290 
9291  case 411:
9292 
9293 /* Line 1806 of yacc.c */
9294 #line 3490 "ripper.y"
9295  {
9296 #if 0
9297  (yyval.val) = (yyvsp[(1) - (1)].val);
9298 #endif
9299  (yyval.val) = (yyvsp[(1) - (1)].val);
9300 
9301  }
9302  break;
9303 
9304  case 412:
9305 
9306 /* Line 1806 of yacc.c */
9307 #line 3500 "ripper.y"
9308  {
9309  (yyval.val) = (yyvsp[(2) - (3)].val);
9310  }
9311  break;
9312 
9313  case 413:
9314 
9315 /* Line 1806 of yacc.c */
9316 #line 3504 "ripper.y"
9317  {
9318  (yyval.val) = (yyvsp[(2) - (3)].val);
9319  }
9320  break;
9321 
9322  case 414:
9323 
9324 /* Line 1806 of yacc.c */
9325 #line 3510 "ripper.y"
9326  {
9327  (yyvsp[(1) - (1)].vars) = dyna_push();
9328 #if 0
9329  (yyval.num) = ruby_sourceline;
9330 #endif
9331  }
9332  break;
9333 
9334  case 415:
9335 
9336 /* Line 1806 of yacc.c */
9337 #line 3519 "ripper.y"
9338  {
9339 #if 0
9340  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9341  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9342 #endif
9343  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9344 
9345  dyna_pop((yyvsp[(1) - (5)].vars));
9346  }
9347  break;
9348 
9349  case 416:
9350 
9351 /* Line 1806 of yacc.c */
9352 #line 3531 "ripper.y"
9353  {
9354 #if 0
9355  if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
9356  compile_error(PARSER_ARG "block given to yield");
9357  }
9358  else {
9359  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
9360  }
9361  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
9362  (yyval.val) = (yyvsp[(2) - (2)].val);
9363  fixpos((yyval.val), (yyvsp[(1) - (2)].val));
9364 #endif
9365  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9366 
9367  }
9368  break;
9369 
9370  case 417:
9371 
9372 /* Line 1806 of yacc.c */
9373 #line 3547 "ripper.y"
9374  {
9375 #if 0
9376  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9377 #endif
9378  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
9379  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9380 
9381  }
9382  break;
9383 
9384  case 418:
9385 
9386 /* Line 1806 of yacc.c */
9387 #line 3556 "ripper.y"
9388  {
9389 #if 0
9390  block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9391  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9392  (yyval.val) = (yyvsp[(5) - (5)].val);
9393  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
9394 #endif
9395  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9396  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
9397 
9398  }
9399  break;
9400 
9401  case 419:
9402 
9403 /* Line 1806 of yacc.c */
9404 #line 3568 "ripper.y"
9405  {
9406 #if 0
9407  block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9408  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9409  (yyval.val) = (yyvsp[(5) - (5)].val);
9410  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
9411 #endif
9412  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9413  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
9414 
9415  }
9416  break;
9417 
9418  case 420:
9419 
9420 /* Line 1806 of yacc.c */
9421 #line 3582 "ripper.y"
9422  {
9423 #if 0
9424  (yyval.val) = (yyvsp[(1) - (2)].val);
9425  (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
9426 #endif
9427  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
9428 
9429  }
9430  break;
9431 
9432  case 421:
9433 
9434 /* Line 1806 of yacc.c */
9435 #line 3591 "ripper.y"
9436  {
9437 #if 0
9438  (yyval.num) = ruby_sourceline;
9439 #endif
9440  }
9441  break;
9442 
9443  case 422:
9444 
9445 /* Line 1806 of yacc.c */
9446 #line 3597 "ripper.y"
9447  {
9448 #if 0
9449  (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9450  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9451 #endif
9452  (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
9453  (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
9454 
9455  }
9456  break;
9457 
9458  case 423:
9459 
9460 /* Line 1806 of yacc.c */
9461 #line 3607 "ripper.y"
9462  {
9463 #if 0
9464  (yyval.num) = ruby_sourceline;
9465 #endif
9466  }
9467  break;
9468 
9469  case 424:
9470 
9471 /* Line 1806 of yacc.c */
9472 #line 3613 "ripper.y"
9473  {
9474 #if 0
9475  (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9476  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9477 #endif
9478  (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
9479  (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
9480 
9481  }
9482  break;
9483 
9484  case 425:
9485 
9486 /* Line 1806 of yacc.c */
9487 #line 3623 "ripper.y"
9488  {
9489 #if 0
9490  (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
9491 #endif
9492  (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
9493 
9494  }
9495  break;
9496 
9497  case 426:
9498 
9499 /* Line 1806 of yacc.c */
9500 #line 3631 "ripper.y"
9501  {
9502 #if 0
9503  (yyval.num) = ruby_sourceline;
9504 #endif
9505  }
9506  break;
9507 
9508  case 427:
9509 
9510 /* Line 1806 of yacc.c */
9511 #line 3637 "ripper.y"
9512  {
9513 #if 0
9514  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
9515  nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
9516 #endif
9517  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'),
9518  ripper_intern("call"));
9519  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9520 
9521  }
9522  break;
9523 
9524  case 428:
9525 
9526 /* Line 1806 of yacc.c */
9527 #line 3648 "ripper.y"
9528  {
9529 #if 0
9530  (yyval.num) = ruby_sourceline;
9531 #endif
9532  }
9533  break;
9534 
9535  case 429:
9536 
9537 /* Line 1806 of yacc.c */
9538 #line 3654 "ripper.y"
9539  {
9540 #if 0
9541  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
9542  nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
9543 #endif
9544  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"),
9545  ripper_intern("call"));
9546  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9547 
9548  }
9549  break;
9550 
9551  case 430:
9552 
9553 /* Line 1806 of yacc.c */
9554 #line 3665 "ripper.y"
9555  {
9556 #if 0
9557  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
9558 #endif
9559  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
9560 
9561  }
9562  break;
9563 
9564  case 431:
9565 
9566 /* Line 1806 of yacc.c */
9567 #line 3673 "ripper.y"
9568  {
9569 #if 0
9570  (yyval.val) = NEW_ZSUPER();
9571 #endif
9572  (yyval.val) = dispatch0(zsuper);
9573 
9574  }
9575  break;
9576 
9577  case 432:
9578 
9579 /* Line 1806 of yacc.c */
9580 #line 3681 "ripper.y"
9581  {
9582 #if 0
9583  if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
9584  (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val));
9585  else
9586  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val));
9587  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
9588 #endif
9589  (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
9590 
9591  }
9592  break;
9593 
9594  case 433:
9595 
9596 /* Line 1806 of yacc.c */
9597 #line 3695 "ripper.y"
9598  {
9599  (yyvsp[(1) - (1)].vars) = dyna_push();
9600 #if 0
9601  (yyval.num) = ruby_sourceline;
9602 #endif
9603 
9604  }
9605  break;
9606 
9607  case 434:
9608 
9609 /* Line 1806 of yacc.c */
9610 #line 3704 "ripper.y"
9611  {
9612 #if 0
9613  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9614  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9615 #endif
9616  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9617 
9618  dyna_pop((yyvsp[(1) - (5)].vars));
9619  }
9620  break;
9621 
9622  case 435:
9623 
9624 /* Line 1806 of yacc.c */
9625 #line 3714 "ripper.y"
9626  {
9627  (yyvsp[(1) - (1)].vars) = dyna_push();
9628 #if 0
9629  (yyval.num) = ruby_sourceline;
9630 #endif
9631 
9632  }
9633  break;
9634 
9635  case 436:
9636 
9637 /* Line 1806 of yacc.c */
9638 #line 3723 "ripper.y"
9639  {
9640 #if 0
9641  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9642  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9643 #endif
9644  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9645 
9646  dyna_pop((yyvsp[(1) - (5)].vars));
9647  }
9648  break;
9649 
9650  case 437:
9651 
9652 /* Line 1806 of yacc.c */
9653 #line 3737 "ripper.y"
9654  {
9655 #if 0
9656  (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9657 #endif
9658  (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
9659 
9660  }
9661  break;
9662 
9663  case 440:
9664 
9665 /* Line 1806 of yacc.c */
9666 #line 3753 "ripper.y"
9667  {
9668 #if 0
9669  if ((yyvsp[(3) - (6)].val)) {
9670  (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO());
9671  (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
9672  }
9673  (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9674  fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
9675 #endif
9676  (yyval.val) = dispatch4(rescue,
9677  escape_Qundef((yyvsp[(2) - (6)].val)),
9678  escape_Qundef((yyvsp[(3) - (6)].val)),
9679  escape_Qundef((yyvsp[(5) - (6)].val)),
9680  escape_Qundef((yyvsp[(6) - (6)].val)));
9681 
9682  }
9683  break;
9684 
9685  case 442:
9686 
9687 /* Line 1806 of yacc.c */
9688 #line 3773 "ripper.y"
9689  {
9690 #if 0
9691  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
9692 #endif
9693  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9694 
9695  }
9696  break;
9697 
9698  case 443:
9699 
9700 /* Line 1806 of yacc.c */
9701 #line 3781 "ripper.y"
9702  {
9703 #if 0
9704  if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
9705 #endif
9706  (yyval.val) = (yyvsp[(1) - (1)].val);
9707 
9708  }
9709  break;
9710 
9711  case 445:
9712 
9713 /* Line 1806 of yacc.c */
9714 #line 3792 "ripper.y"
9715  {
9716  (yyval.val) = (yyvsp[(2) - (2)].val);
9717  }
9718  break;
9719 
9720  case 447:
9721 
9722 /* Line 1806 of yacc.c */
9723 #line 3799 "ripper.y"
9724  {
9725 #if 0
9726  (yyval.val) = (yyvsp[(2) - (2)].val);
9727 #endif
9728  (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
9729 
9730  }
9731  break;
9732 
9733  case 450:
9734 
9735 /* Line 1806 of yacc.c */
9736 #line 3811 "ripper.y"
9737  {
9738 #if 0
9739  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
9740 #endif
9741  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
9742 
9743  }
9744  break;
9745 
9746  case 452:
9747 
9748 /* Line 1806 of yacc.c */
9749 #line 3822 "ripper.y"
9750  {
9751 #if 0
9752  NODE *node = (yyvsp[(1) - (1)].val);
9753  if (!node) {
9754  node = NEW_STR(STR_NEW0());
9755  }
9756  else {
9757  node = evstr2dstr(node);
9758  }
9759  (yyval.val) = node;
9760 #endif
9761  (yyval.val) = (yyvsp[(1) - (1)].val);
9762 
9763  }
9764  break;
9765 
9766  case 455:
9767 
9768 /* Line 1806 of yacc.c */
9769 #line 3841 "ripper.y"
9770  {
9771 #if 0
9772  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9773 #endif
9774  (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9775 
9776  }
9777  break;
9778 
9779  case 456:
9780 
9781 /* Line 1806 of yacc.c */
9782 #line 3851 "ripper.y"
9783  {
9784 #if 0
9785  (yyval.val) = (yyvsp[(2) - (3)].val);
9786 #endif
9787  (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val));
9788 
9789  }
9790  break;
9791 
9792  case 457:
9793 
9794 /* Line 1806 of yacc.c */
9795 #line 3861 "ripper.y"
9796  {
9797 #if 0
9798  NODE *node = (yyvsp[(2) - (3)].val);
9799  if (!node) {
9800  node = NEW_XSTR(STR_NEW0());
9801  }
9802  else {
9803  switch (nd_type(node)) {
9804  case NODE_STR:
9805  nd_set_type(node, NODE_XSTR);
9806  break;
9807  case NODE_DSTR:
9808  nd_set_type(node, NODE_DXSTR);
9809  break;
9810  default:
9811  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
9812  break;
9813  }
9814  }
9815  (yyval.val) = node;
9816 #endif
9817  (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val));
9818 
9819  }
9820  break;
9821 
9822  case 458:
9823 
9824 /* Line 1806 of yacc.c */
9825 #line 3888 "ripper.y"
9826  {
9827 #if 0
9828  int options = (yyvsp[(3) - (3)].val);
9829  NODE *node = (yyvsp[(2) - (3)].val);
9830  NODE *list, *prev;
9831  if (!node) {
9832  node = NEW_LIT(reg_compile(STR_NEW0(), options));
9833  }
9834  else switch (nd_type(node)) {
9835  case NODE_STR:
9836  {
9837  VALUE src = node->nd_lit;
9838  nd_set_type(node, NODE_LIT);
9839  node->nd_lit = reg_compile(src, options);
9840  }
9841  break;
9842  default:
9843  node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
9844  case NODE_DSTR:
9845  if (options & RE_OPTION_ONCE) {
9847  }
9848  else {
9849  nd_set_type(node, NODE_DREGX);
9850  }
9851  node->nd_cflag = options & RE_OPTION_MASK;
9852  if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
9853  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
9854  if (nd_type(list->nd_head) == NODE_STR) {
9855  VALUE tail = list->nd_head->nd_lit;
9856  if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
9857  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
9858  if (!literal_concat0(parser, lit, tail)) {
9859  node = 0;
9860  break;
9861  }
9862  rb_str_resize(tail, 0);
9863  prev->nd_next = list->nd_next;
9864  rb_gc_force_recycle((VALUE)list->nd_head);
9865  rb_gc_force_recycle((VALUE)list);
9866  list = prev;
9867  }
9868  else {
9869  prev = list;
9870  }
9871  }
9872  else {
9873  prev = 0;
9874  }
9875  }
9876  if (!node->nd_next) {
9877  VALUE src = node->nd_lit;
9878  nd_set_type(node, NODE_LIT);
9879  node->nd_lit = reg_compile(src, options);
9880  }
9881  break;
9882  }
9883  (yyval.val) = node;
9884 #endif
9885  (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
9886 
9887  }
9888  break;
9889 
9890  case 459:
9891 
9892 /* Line 1806 of yacc.c */
9893 #line 3953 "ripper.y"
9894  {
9895 #if 0
9896  (yyval.val) = NEW_ZARRAY();
9897 #endif
9898  (yyval.val) = dispatch0(words_new);
9899  (yyval.val) = dispatch1(array, (yyval.val));
9900 
9901  }
9902  break;
9903 
9904  case 460:
9905 
9906 /* Line 1806 of yacc.c */
9907 #line 3962 "ripper.y"
9908  {
9909 #if 0
9910  (yyval.val) = (yyvsp[(2) - (3)].val);
9911 #endif
9912  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9913 
9914  }
9915  break;
9916 
9917  case 461:
9918 
9919 /* Line 1806 of yacc.c */
9920 #line 3972 "ripper.y"
9921  {
9922 #if 0
9923  (yyval.val) = 0;
9924 #endif
9925  (yyval.val) = dispatch0(words_new);
9926 
9927  }
9928  break;
9929 
9930  case 462:
9931 
9932 /* Line 1806 of yacc.c */
9933 #line 3980 "ripper.y"
9934  {
9935 #if 0
9936  (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
9937 #endif
9938  (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9939 
9940  }
9941  break;
9942 
9943  case 463:
9944 
9945 /* Line 1806 of yacc.c */
9946 #line 3992 "ripper.y"
9947  {
9948  (yyval.val) = dispatch0(word_new);
9949  (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
9950  }
9951  break;
9952 
9953  case 464:
9954 
9955 /* Line 1806 of yacc.c */
9956 #line 3998 "ripper.y"
9957  {
9958 #if 0
9959  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9960 #endif
9961  (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9962 
9963  }
9964  break;
9965 
9966  case 465:
9967 
9968 /* Line 1806 of yacc.c */
9969 #line 4008 "ripper.y"
9970  {
9971 #if 0
9972  (yyval.val) = NEW_ZARRAY();
9973 #endif
9974  (yyval.val) = dispatch0(symbols_new);
9975  (yyval.val) = dispatch1(array, (yyval.val));
9976 
9977  }
9978  break;
9979 
9980  case 466:
9981 
9982 /* Line 1806 of yacc.c */
9983 #line 4017 "ripper.y"
9984  {
9985 #if 0
9986  (yyval.val) = (yyvsp[(2) - (3)].val);
9987 #endif
9988  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9989 
9990  }
9991  break;
9992 
9993  case 467:
9994 
9995 /* Line 1806 of yacc.c */
9996 #line 4027 "ripper.y"
9997  {
9998 #if 0
9999  (yyval.val) = 0;
10000 #endif
10001  (yyval.val) = dispatch0(symbols_new);
10002 
10003  }
10004  break;
10005 
10006  case 468:
10007 
10008 /* Line 1806 of yacc.c */
10009 #line 4035 "ripper.y"
10010  {
10011 #if 0
10012  (yyvsp[(2) - (3)].val) = evstr2dstr((yyvsp[(2) - (3)].val));
10013  nd_set_type((yyvsp[(2) - (3)].val), NODE_DSYM);
10014  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10015 #endif
10016  (yyval.val) = dispatch2(symbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10017 
10018  }
10019  break;
10020 
10021  case 469:
10022 
10023 /* Line 1806 of yacc.c */
10024 #line 4047 "ripper.y"
10025  {
10026 #if 0
10027  (yyval.val) = NEW_ZARRAY();
10028 #endif
10029  (yyval.val) = dispatch0(qwords_new);
10030  (yyval.val) = dispatch1(array, (yyval.val));
10031 
10032  }
10033  break;
10034 
10035  case 470:
10036 
10037 /* Line 1806 of yacc.c */
10038 #line 4056 "ripper.y"
10039  {
10040 #if 0
10041  (yyval.val) = (yyvsp[(2) - (3)].val);
10042 #endif
10043  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10044 
10045  }
10046  break;
10047 
10048  case 471:
10049 
10050 /* Line 1806 of yacc.c */
10051 #line 4066 "ripper.y"
10052  {
10053 #if 0
10054  (yyval.val) = NEW_ZARRAY();
10055 #endif
10056  (yyval.val) = dispatch0(qsymbols_new);
10057  (yyval.val) = dispatch1(array, (yyval.val));
10058 
10059  }
10060  break;
10061 
10062  case 472:
10063 
10064 /* Line 1806 of yacc.c */
10065 #line 4075 "ripper.y"
10066  {
10067 #if 0
10068  (yyval.val) = (yyvsp[(2) - (3)].val);
10069 #endif
10070  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10071 
10072  }
10073  break;
10074 
10075  case 473:
10076 
10077 /* Line 1806 of yacc.c */
10078 #line 4085 "ripper.y"
10079  {
10080 #if 0
10081  (yyval.val) = 0;
10082 #endif
10083  (yyval.val) = dispatch0(qwords_new);
10084 
10085  }
10086  break;
10087 
10088  case 474:
10089 
10090 /* Line 1806 of yacc.c */
10091 #line 4093 "ripper.y"
10092  {
10093 #if 0
10094  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10095 #endif
10096  (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10097 
10098  }
10099  break;
10100 
10101  case 475:
10102 
10103 /* Line 1806 of yacc.c */
10104 #line 4103 "ripper.y"
10105  {
10106 #if 0
10107  (yyval.val) = 0;
10108 #endif
10109  (yyval.val) = dispatch0(qsymbols_new);
10110 
10111  }
10112  break;
10113 
10114  case 476:
10115 
10116 /* Line 1806 of yacc.c */
10117 #line 4111 "ripper.y"
10118  {
10119 #if 0
10120  VALUE lit;
10121  lit = (yyvsp[(2) - (3)].val)->nd_lit;
10122  (yyvsp[(2) - (3)].val)->nd_lit = ID2SYM(rb_intern_str(lit));
10123  nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
10124  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10125 #endif
10126  (yyval.val) = dispatch2(qsymbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10127 
10128  }
10129  break;
10130 
10131  case 477:
10132 
10133 /* Line 1806 of yacc.c */
10134 #line 4125 "ripper.y"
10135  {
10136 #if 0
10137  (yyval.val) = 0;
10138 #endif
10139  (yyval.val) = dispatch0(string_content);
10140 
10141  }
10142  break;
10143 
10144  case 478:
10145 
10146 /* Line 1806 of yacc.c */
10147 #line 4133 "ripper.y"
10148  {
10149 #if 0
10150  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10151 #endif
10152  (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10153 
10154  }
10155  break;
10156 
10157  case 479:
10158 
10159 /* Line 1806 of yacc.c */
10160 #line 4143 "ripper.y"
10161  {
10162 #if 0
10163  (yyval.val) = 0;
10164 #endif
10165  (yyval.val) = dispatch0(xstring_new);
10166 
10167  }
10168  break;
10169 
10170  case 480:
10171 
10172 /* Line 1806 of yacc.c */
10173 #line 4151 "ripper.y"
10174  {
10175 #if 0
10176  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10177 #endif
10178  (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10179 
10180  }
10181  break;
10182 
10183  case 481:
10184 
10185 /* Line 1806 of yacc.c */
10186 #line 4161 "ripper.y"
10187  {
10188 #if 0
10189  (yyval.val) = 0;
10190 #endif
10191  (yyval.val) = dispatch0(regexp_new);
10192 
10193  }
10194  break;
10195 
10196  case 482:
10197 
10198 /* Line 1806 of yacc.c */
10199 #line 4169 "ripper.y"
10200  {
10201 #if 0
10202  NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
10203  if (!head) {
10204  (yyval.val) = tail;
10205  }
10206  else if (!tail) {
10207  (yyval.val) = head;
10208  }
10209  else {
10210  switch (nd_type(head)) {
10211  case NODE_STR:
10212  nd_set_type(head, NODE_DSTR);
10213  break;
10214  case NODE_DSTR:
10215  break;
10216  default:
10217  head = list_append(NEW_DSTR(Qnil), head);
10218  break;
10219  }
10220  (yyval.val) = list_append(head, tail);
10221  }
10222 #endif
10223  (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10224 
10225  }
10226  break;
10227 
10228  case 484:
10229 
10230 /* Line 1806 of yacc.c */
10231 #line 4199 "ripper.y"
10232  {
10233  (yyval.node) = lex_strterm;
10234  lex_strterm = 0;
10235  lex_state = EXPR_BEG;
10236  }
10237  break;
10238 
10239  case 485:
10240 
10241 /* Line 1806 of yacc.c */
10242 #line 4205 "ripper.y"
10243  {
10244 #if 0
10245  lex_strterm = (yyvsp[(2) - (3)].node);
10246  (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
10247 #endif
10248  lex_strterm = (yyvsp[(2) - (3)].node);
10249  (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
10250 
10251  }
10252  break;
10253 
10254  case 486:
10255 
10256 /* Line 1806 of yacc.c */
10257 #line 4215 "ripper.y"
10258  {
10259  (yyvsp[(1) - (1)].val) = cond_stack;
10260  (yyval.val) = cmdarg_stack;
10261  cond_stack = 0;
10262  cmdarg_stack = 0;
10263  }
10264  break;
10265 
10266  case 487:
10267 
10268 /* Line 1806 of yacc.c */
10269 #line 4221 "ripper.y"
10270  {
10271  (yyval.node) = lex_strterm;
10272  lex_strterm = 0;
10273  lex_state = EXPR_BEG;
10274  }
10275  break;
10276 
10277  case 488:
10278 
10279 /* Line 1806 of yacc.c */
10280 #line 4226 "ripper.y"
10281  {
10282  (yyval.num) = brace_nest;
10283  brace_nest = 0;
10284  }
10285  break;
10286 
10287  case 489:
10288 
10289 /* Line 1806 of yacc.c */
10290 #line 4231 "ripper.y"
10291  {
10292  cond_stack = (yyvsp[(1) - (6)].val);
10293  cmdarg_stack = (yyvsp[(2) - (6)].val);
10294  lex_strterm = (yyvsp[(3) - (6)].node);
10295  brace_nest = (yyvsp[(4) - (6)].num);
10296 #if 0
10297  if ((yyvsp[(5) - (6)].val)) (yyvsp[(5) - (6)].val)->flags &= ~NODE_FL_NEWLINE;
10298  (yyval.val) = new_evstr((yyvsp[(5) - (6)].val));
10299 #endif
10300  (yyval.val) = dispatch1(string_embexpr, (yyvsp[(5) - (6)].val));
10301 
10302  }
10303  break;
10304 
10305  case 490:
10306 
10307 /* Line 1806 of yacc.c */
10308 #line 4246 "ripper.y"
10309  {
10310 #if 0
10311  (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
10312 #endif
10313  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10314 
10315  }
10316  break;
10317 
10318  case 491:
10319 
10320 /* Line 1806 of yacc.c */
10321 #line 4254 "ripper.y"
10322  {
10323 #if 0
10324  (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
10325 #endif
10326  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10327 
10328  }
10329  break;
10330 
10331  case 492:
10332 
10333 /* Line 1806 of yacc.c */
10334 #line 4262 "ripper.y"
10335  {
10336 #if 0
10337  (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
10338 #endif
10339  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10340 
10341  }
10342  break;
10343 
10344  case 494:
10345 
10346 /* Line 1806 of yacc.c */
10347 #line 4273 "ripper.y"
10348  {
10349  lex_state = EXPR_END;
10350 #if 0
10351  (yyval.val) = (yyvsp[(2) - (2)].val);
10352 #endif
10353  (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
10354 
10355  }
10356  break;
10357 
10358  case 499:
10359 
10360 /* Line 1806 of yacc.c */
10361 #line 4290 "ripper.y"
10362  {
10363  lex_state = EXPR_END;
10364 #if 0
10365  (yyval.val) = dsym_node((yyvsp[(2) - (3)].val));
10366 #endif
10367  (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
10368 
10369  }
10370  break;
10371 
10372  case 502:
10373 
10374 /* Line 1806 of yacc.c */
10375 #line 4303 "ripper.y"
10376  {
10377 #if 0
10378  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10379 #endif
10380  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10381 
10382  }
10383  break;
10384 
10385  case 503:
10386 
10387 /* Line 1806 of yacc.c */
10388 #line 4311 "ripper.y"
10389  {
10390 #if 0
10391  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10392 #endif
10393  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10394 
10395  }
10396  break;
10397 
10398  case 509:
10399 
10400 /* Line 1806 of yacc.c */
10401 #line 4327 "ripper.y"
10402  {ifndef_ripper((yyval.val) = keyword_nil);}
10403  break;
10404 
10405  case 510:
10406 
10407 /* Line 1806 of yacc.c */
10408 #line 4328 "ripper.y"
10409  {ifndef_ripper((yyval.val) = keyword_self);}
10410  break;
10411 
10412  case 511:
10413 
10414 /* Line 1806 of yacc.c */
10415 #line 4329 "ripper.y"
10416  {ifndef_ripper((yyval.val) = keyword_true);}
10417  break;
10418 
10419  case 512:
10420 
10421 /* Line 1806 of yacc.c */
10422 #line 4330 "ripper.y"
10423  {ifndef_ripper((yyval.val) = keyword_false);}
10424  break;
10425 
10426  case 513:
10427 
10428 /* Line 1806 of yacc.c */
10429 #line 4331 "ripper.y"
10430  {ifndef_ripper((yyval.val) = keyword__FILE__);}
10431  break;
10432 
10433  case 514:
10434 
10435 /* Line 1806 of yacc.c */
10436 #line 4332 "ripper.y"
10437  {ifndef_ripper((yyval.val) = keyword__LINE__);}
10438  break;
10439 
10440  case 515:
10441 
10442 /* Line 1806 of yacc.c */
10443 #line 4333 "ripper.y"
10444  {ifndef_ripper((yyval.val) = keyword__ENCODING__);}
10445  break;
10446 
10447  case 516:
10448 
10449 /* Line 1806 of yacc.c */
10450 #line 4337 "ripper.y"
10451  {
10452 #if 0
10453  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10454 #endif
10455  if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) {
10456  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10457  }
10458  else {
10459  (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val));
10460  }
10461 
10462  }
10463  break;
10464 
10465  case 517:
10466 
10467 /* Line 1806 of yacc.c */
10468 #line 4350 "ripper.y"
10469  {
10470 #if 0
10471  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10472 #endif
10473  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10474 
10475  }
10476  break;
10477 
10478  case 518:
10479 
10480 /* Line 1806 of yacc.c */
10481 #line 4360 "ripper.y"
10482  {
10483  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10484 #if 0
10485 #endif
10486  (yyval.val) = dispatch1(var_field, (yyval.val));
10487 
10488  }
10489  break;
10490 
10491  case 519:
10492 
10493 /* Line 1806 of yacc.c */
10494 #line 4368 "ripper.y"
10495  {
10496  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10497 #if 0
10498 #endif
10499  (yyval.val) = dispatch1(var_field, (yyval.val));
10500 
10501  }
10502  break;
10503 
10504  case 522:
10505 
10506 /* Line 1806 of yacc.c */
10507 #line 4382 "ripper.y"
10508  {
10509 #if 0
10510  (yyval.val) = 0;
10511 #endif
10512  (yyval.val) = Qnil;
10513 
10514  }
10515  break;
10516 
10517  case 523:
10518 
10519 /* Line 1806 of yacc.c */
10520 #line 4390 "ripper.y"
10521  {
10522  lex_state = EXPR_BEG;
10523  command_start = TRUE;
10524  }
10525  break;
10526 
10527  case 524:
10528 
10529 /* Line 1806 of yacc.c */
10530 #line 4395 "ripper.y"
10531  {
10532  (yyval.val) = (yyvsp[(3) - (4)].val);
10533  }
10534  break;
10535 
10536  case 525:
10537 
10538 /* Line 1806 of yacc.c */
10539 #line 4399 "ripper.y"
10540  {
10541 #if 0
10542  yyerrok;
10543  (yyval.val) = 0;
10544 #endif
10545  yyerrok;
10546  (yyval.val) = Qnil;
10547 
10548  }
10549  break;
10550 
10551  case 526:
10552 
10553 /* Line 1806 of yacc.c */
10554 #line 4411 "ripper.y"
10555  {
10556 #if 0
10557  (yyval.val) = (yyvsp[(2) - (3)].val);
10558 #endif
10559  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
10560 
10561  lex_state = EXPR_BEG;
10562  command_start = TRUE;
10563  }
10564  break;
10565 
10566  case 527:
10567 
10568 /* Line 1806 of yacc.c */
10569 #line 4421 "ripper.y"
10570  {
10571  (yyval.val) = (yyvsp[(1) - (2)].val);
10572  lex_state = EXPR_BEG;
10573  command_start = TRUE;
10574  }
10575  break;
10576 
10577  case 528:
10578 
10579 /* Line 1806 of yacc.c */
10580 #line 4429 "ripper.y"
10581  {
10582  (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10583  }
10584  break;
10585 
10586  case 529:
10587 
10588 /* Line 1806 of yacc.c */
10589 #line 4433 "ripper.y"
10590  {
10591  (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10592  }
10593  break;
10594 
10595  case 530:
10596 
10597 /* Line 1806 of yacc.c */
10598 #line 4437 "ripper.y"
10599  {
10600  (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10601  }
10602  break;
10603 
10604  case 531:
10605 
10606 /* Line 1806 of yacc.c */
10607 #line 4441 "ripper.y"
10608  {
10609  (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
10610  }
10611  break;
10612 
10613  case 532:
10614 
10615 /* Line 1806 of yacc.c */
10616 #line 4447 "ripper.y"
10617  {
10618  (yyval.val) = (yyvsp[(2) - (2)].val);
10619  }
10620  break;
10621 
10622  case 533:
10623 
10624 /* Line 1806 of yacc.c */
10625 #line 4451 "ripper.y"
10626  {
10627  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10628  }
10629  break;
10630 
10631  case 534:
10632 
10633 /* Line 1806 of yacc.c */
10634 #line 4457 "ripper.y"
10635  {
10636  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
10637  }
10638  break;
10639 
10640  case 535:
10641 
10642 /* Line 1806 of yacc.c */
10643 #line 4461 "ripper.y"
10644  {
10645  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10646  }
10647  break;
10648 
10649  case 536:
10650 
10651 /* Line 1806 of yacc.c */
10652 #line 4465 "ripper.y"
10653  {
10654  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
10655  }
10656  break;
10657 
10658  case 537:
10659 
10660 /* Line 1806 of yacc.c */
10661 #line 4469 "ripper.y"
10662  {
10663  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10664  }
10665  break;
10666 
10667  case 538:
10668 
10669 /* Line 1806 of yacc.c */
10670 #line 4473 "ripper.y"
10671  {
10672  (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10673  }
10674  break;
10675 
10676  case 539:
10677 
10678 /* Line 1806 of yacc.c */
10679 #line 4477 "ripper.y"
10680  {
10681  (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10682  }
10683  break;
10684 
10685  case 540:
10686 
10687 /* Line 1806 of yacc.c */
10688 #line 4481 "ripper.y"
10689  {
10690  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
10691  }
10692  break;
10693 
10694  case 541:
10695 
10696 /* Line 1806 of yacc.c */
10697 #line 4485 "ripper.y"
10698  {
10699  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10700  }
10701  break;
10702 
10703  case 542:
10704 
10705 /* Line 1806 of yacc.c */
10706 #line 4489 "ripper.y"
10707  {
10708  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10709  }
10710  break;
10711 
10712  case 543:
10713 
10714 /* Line 1806 of yacc.c */
10715 #line 4493 "ripper.y"
10716  {
10717  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
10718  }
10719  break;
10720 
10721  case 544:
10722 
10723 /* Line 1806 of yacc.c */
10724 #line 4497 "ripper.y"
10725  {
10726  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10727  }
10728  break;
10729 
10730  case 545:
10731 
10732 /* Line 1806 of yacc.c */
10733 #line 4501 "ripper.y"
10734  {
10735  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10736  }
10737  break;
10738 
10739  case 546:
10740 
10741 /* Line 1806 of yacc.c */
10742 #line 4505 "ripper.y"
10743  {
10744  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10745  }
10746  break;
10747 
10748  case 547:
10749 
10750 /* Line 1806 of yacc.c */
10751 #line 4509 "ripper.y"
10752  {
10753  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
10754  }
10755  break;
10756 
10757  case 548:
10758 
10759 /* Line 1806 of yacc.c */
10760 #line 4513 "ripper.y"
10761  {
10762  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10763  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.val));
10764  }
10765  break;
10766 
10767  case 549:
10768 
10769 /* Line 1806 of yacc.c */
10770 #line 4520 "ripper.y"
10771  {
10772 #if 0
10773  yyerror("formal argument cannot be a constant");
10774  (yyval.val) = 0;
10775 #endif
10776  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10777 
10778  }
10779  break;
10780 
10781  case 550:
10782 
10783 /* Line 1806 of yacc.c */
10784 #line 4529 "ripper.y"
10785  {
10786 #if 0
10787  yyerror("formal argument cannot be an instance variable");
10788  (yyval.val) = 0;
10789 #endif
10790  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10791 
10792  }
10793  break;
10794 
10795  case 551:
10796 
10797 /* Line 1806 of yacc.c */
10798 #line 4538 "ripper.y"
10799  {
10800 #if 0
10801  yyerror("formal argument cannot be a global variable");
10802  (yyval.val) = 0;
10803 #endif
10804  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10805 
10806  }
10807  break;
10808 
10809  case 552:
10810 
10811 /* Line 1806 of yacc.c */
10812 #line 4547 "ripper.y"
10813  {
10814 #if 0
10815  yyerror("formal argument cannot be a class variable");
10816  (yyval.val) = 0;
10817 #endif
10818  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10819 
10820  }
10821  break;
10822 
10823  case 554:
10824 
10825 /* Line 1806 of yacc.c */
10826 #line 4559 "ripper.y"
10827  {
10828  formal_argument(get_id((yyvsp[(1) - (1)].val)));
10829  (yyval.val) = (yyvsp[(1) - (1)].val);
10830  }
10831  break;
10832 
10833  case 555:
10834 
10835 /* Line 1806 of yacc.c */
10836 #line 4566 "ripper.y"
10837  {
10838  arg_var(get_id((yyvsp[(1) - (1)].val)));
10839 #if 0
10840  (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10841 #endif
10842  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10843 
10844  }
10845  break;
10846 
10847  case 556:
10848 
10849 /* Line 1806 of yacc.c */
10850 #line 4575 "ripper.y"
10851  {
10852  ID tid = internal_id();
10853  arg_var(tid);
10854 #if 0
10855  if (dyna_in_block()) {
10856  (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10857  }
10858  else {
10859  (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10860  }
10861  (yyval.val) = NEW_ARGS_AUX(tid, 1);
10862  (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10863 #endif
10864  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10865 
10866  }
10867  break;
10868 
10869  case 557:
10870 
10871 /* Line 1806 of yacc.c */
10872 #line 4596 "ripper.y"
10873  {
10874  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10875  }
10876  break;
10877 
10878  case 558:
10879 
10880 /* Line 1806 of yacc.c */
10881 #line 4601 "ripper.y"
10882  {
10883 #if 0
10884  (yyval.val) = (yyvsp[(1) - (3)].val);
10885  (yyval.val)->nd_plen++;
10886  (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10887  rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10888 #endif
10889  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10890 
10891  }
10892  break;
10893 
10894  case 559:
10895 
10896 /* Line 1806 of yacc.c */
10897 #line 4614 "ripper.y"
10898  {
10899  arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val))));
10900  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10901 #if 0
10902  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10903 #endif
10904  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10905 
10906  }
10907  break;
10908 
10909  case 560:
10910 
10911 /* Line 1806 of yacc.c */
10912 #line 4626 "ripper.y"
10913  {
10914  arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val))));
10915  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10916 #if 0
10917  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10918 #endif
10919  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10920 
10921  }
10922  break;
10923 
10924  case 561:
10925 
10926 /* Line 1806 of yacc.c */
10927 #line 4638 "ripper.y"
10928  {
10929 #if 0
10930  (yyval.val) = (yyvsp[(1) - (1)].val);
10931 #endif
10932  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10933 
10934  }
10935  break;
10936 
10937  case 562:
10938 
10939 /* Line 1806 of yacc.c */
10940 #line 4646 "ripper.y"
10941  {
10942 #if 0
10943  NODE *kws = (yyvsp[(1) - (3)].val);
10944 
10945  while (kws->nd_next) {
10946  kws = kws->nd_next;
10947  }
10948  kws->nd_next = (yyvsp[(3) - (3)].val);
10949  (yyval.val) = (yyvsp[(1) - (3)].val);
10950 #endif
10951  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10952 
10953  }
10954  break;
10955 
10956  case 563:
10957 
10958 /* Line 1806 of yacc.c */
10959 #line 4663 "ripper.y"
10960  {
10961 #if 0
10962  (yyval.val) = (yyvsp[(1) - (1)].val);
10963 #endif
10964  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10965 
10966  }
10967  break;
10968 
10969  case 564:
10970 
10971 /* Line 1806 of yacc.c */
10972 #line 4671 "ripper.y"
10973  {
10974 #if 0
10975  NODE *kws = (yyvsp[(1) - (3)].val);
10976 
10977  while (kws->nd_next) {
10978  kws = kws->nd_next;
10979  }
10980  kws->nd_next = (yyvsp[(3) - (3)].val);
10981  (yyval.val) = (yyvsp[(1) - (3)].val);
10982 #endif
10983  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10984 
10985  }
10986  break;
10987 
10988  case 567:
10989 
10990 /* Line 1806 of yacc.c */
10991 #line 4691 "ripper.y"
10992  {
10993  shadowing_lvar(get_id((yyvsp[(2) - (2)].val)));
10994  (yyval.val) = (yyvsp[(2) - (2)].val);
10995  }
10996  break;
10997 
10998  case 568:
10999 
11000 /* Line 1806 of yacc.c */
11001 #line 4696 "ripper.y"
11002  {
11003  (yyval.val) = internal_id();
11004  }
11005  break;
11006 
11007  case 569:
11008 
11009 /* Line 1806 of yacc.c */
11010 #line 4702 "ripper.y"
11011  {
11012  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
11013  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11014 #if 0
11015  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
11016 #endif
11017  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
11018 
11019  }
11020  break;
11021 
11022  case 570:
11023 
11024 /* Line 1806 of yacc.c */
11025 #line 4714 "ripper.y"
11026  {
11027  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
11028  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11029 #if 0
11030  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
11031 #endif
11032  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
11033 
11034  }
11035  break;
11036 
11037  case 571:
11038 
11039 /* Line 1806 of yacc.c */
11040 #line 4726 "ripper.y"
11041  {
11042 #if 0
11043  (yyval.val) = (yyvsp[(1) - (1)].val);
11044 #endif
11045  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11046 
11047  }
11048  break;
11049 
11050  case 572:
11051 
11052 /* Line 1806 of yacc.c */
11053 #line 4734 "ripper.y"
11054  {
11055 #if 0
11056  NODE *opts = (yyvsp[(1) - (3)].val);
11057 
11058  while (opts->nd_next) {
11059  opts = opts->nd_next;
11060  }
11061  opts->nd_next = (yyvsp[(3) - (3)].val);
11062  (yyval.val) = (yyvsp[(1) - (3)].val);
11063 #endif
11064  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11065 
11066  }
11067  break;
11068 
11069  case 573:
11070 
11071 /* Line 1806 of yacc.c */
11072 #line 4750 "ripper.y"
11073  {
11074 #if 0
11075  (yyval.val) = (yyvsp[(1) - (1)].val);
11076 #endif
11077  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11078 
11079  }
11080  break;
11081 
11082  case 574:
11083 
11084 /* Line 1806 of yacc.c */
11085 #line 4758 "ripper.y"
11086  {
11087 #if 0
11088  NODE *opts = (yyvsp[(1) - (3)].val);
11089 
11090  while (opts->nd_next) {
11091  opts = opts->nd_next;
11092  }
11093  opts->nd_next = (yyvsp[(3) - (3)].val);
11094  (yyval.val) = (yyvsp[(1) - (3)].val);
11095 #endif
11096  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11097 
11098  }
11099  break;
11100 
11101  case 577:
11102 
11103 /* Line 1806 of yacc.c */
11104 #line 4778 "ripper.y"
11105  {
11106 #if 0
11107  if (!is_local_id((yyvsp[(2) - (2)].val)))
11108  yyerror("rest argument must be local variable");
11109 #endif
11110  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11111 #if 0
11112  (yyval.val) = (yyvsp[(2) - (2)].val);
11113 #endif
11114  (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
11115 
11116  }
11117  break;
11118 
11119  case 578:
11120 
11121 /* Line 1806 of yacc.c */
11122 #line 4791 "ripper.y"
11123  {
11124 #if 0
11125  (yyval.val) = internal_id();
11126  arg_var((yyval.val));
11127 #endif
11128  (yyval.val) = dispatch1(rest_param, Qnil);
11129 
11130  }
11131  break;
11132 
11133  case 581:
11134 
11135 /* Line 1806 of yacc.c */
11136 #line 4806 "ripper.y"
11137  {
11138 #if 0
11139  if (!is_local_id((yyvsp[(2) - (2)].val)))
11140  yyerror("block argument must be local variable");
11141  else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
11142  yyerror("duplicated block argument name");
11143 #endif
11144  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11145 #if 0
11146  (yyval.val) = (yyvsp[(2) - (2)].val);
11147 #endif
11148  (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
11149 
11150  }
11151  break;
11152 
11153  case 582:
11154 
11155 /* Line 1806 of yacc.c */
11156 #line 4823 "ripper.y"
11157  {
11158  (yyval.val) = (yyvsp[(2) - (2)].val);
11159  }
11160  break;
11161 
11162  case 583:
11163 
11164 /* Line 1806 of yacc.c */
11165 #line 4827 "ripper.y"
11166  {
11167 #if 0
11168  (yyval.val) = 0;
11169 #endif
11170  (yyval.val) = Qundef;
11171 
11172  }
11173  break;
11174 
11175  case 584:
11176 
11177 /* Line 1806 of yacc.c */
11178 #line 4837 "ripper.y"
11179  {
11180 #if 0
11181  value_expr((yyvsp[(1) - (1)].val));
11182  (yyval.val) = (yyvsp[(1) - (1)].val);
11183  if (!(yyval.val)) (yyval.val) = NEW_NIL();
11184 #endif
11185  (yyval.val) = (yyvsp[(1) - (1)].val);
11186 
11187  }
11188  break;
11189 
11190  case 585:
11191 
11192 /* Line 1806 of yacc.c */
11193 #line 4846 "ripper.y"
11194  {lex_state = EXPR_BEG;}
11195  break;
11196 
11197  case 586:
11198 
11199 /* Line 1806 of yacc.c */
11200 #line 4847 "ripper.y"
11201  {
11202 #if 0
11203  if ((yyvsp[(3) - (4)].val) == 0) {
11204  yyerror("can't define singleton method for ().");
11205  }
11206  else {
11207  switch (nd_type((yyvsp[(3) - (4)].val))) {
11208  case NODE_STR:
11209  case NODE_DSTR:
11210  case NODE_XSTR:
11211  case NODE_DXSTR:
11212  case NODE_DREGX:
11213  case NODE_LIT:
11214  case NODE_ARRAY:
11215  case NODE_ZARRAY:
11216  yyerror("can't define singleton method for literals");
11217  default:
11218  value_expr((yyvsp[(3) - (4)].val));
11219  break;
11220  }
11221  }
11222  (yyval.val) = (yyvsp[(3) - (4)].val);
11223 #endif
11224  (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
11225 
11226  }
11227  break;
11228 
11229  case 588:
11230 
11231 /* Line 1806 of yacc.c */
11232 #line 4877 "ripper.y"
11233  {
11234 #if 0
11235  (yyval.val) = (yyvsp[(1) - (2)].val);
11236 #endif
11237  (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
11238 
11239  }
11240  break;
11241 
11242  case 589:
11243 
11244 /* Line 1806 of yacc.c */
11245 #line 4889 "ripper.y"
11246  {
11247  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11248  }
11249  break;
11250 
11251  case 590:
11252 
11253 /* Line 1806 of yacc.c */
11254 #line 4894 "ripper.y"
11255  {
11256 #if 0
11257  (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11258 #endif
11259  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11260 
11261  }
11262  break;
11263 
11264  case 591:
11265 
11266 /* Line 1806 of yacc.c */
11267 #line 4904 "ripper.y"
11268  {
11269 #if 0
11270  (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
11271 #endif
11272  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11273 
11274  }
11275  break;
11276 
11277  case 592:
11278 
11279 /* Line 1806 of yacc.c */
11280 #line 4912 "ripper.y"
11281  {
11282 #if 0
11283  (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
11284 #endif
11285  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
11286 
11287  }
11288  break;
11289 
11290  case 593:
11291 
11292 /* Line 1806 of yacc.c */
11293 #line 4920 "ripper.y"
11294  {
11295 #if 0
11296  (yyval.val) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].val));
11297 #endif
11298  (yyval.val) = dispatch1(assoc_splat, (yyvsp[(2) - (2)].val));
11299 
11300  }
11301  break;
11302 
11303  case 604:
11304 
11305 /* Line 1806 of yacc.c */
11306 #line 4950 "ripper.y"
11307  { (yyval.val) = (yyvsp[(1) - (1)].val); }
11308  break;
11309 
11310  case 605:
11311 
11312 /* Line 1806 of yacc.c */
11313 #line 4955 "ripper.y"
11314  { (yyval.val) = (yyvsp[(1) - (1)].val); }
11315  break;
11316 
11317  case 615:
11318 
11319 /* Line 1806 of yacc.c */
11320 #line 4978 "ripper.y"
11321  {yyerrok;}
11322  break;
11323 
11324  case 618:
11325 
11326 /* Line 1806 of yacc.c */
11327 #line 4983 "ripper.y"
11328  {yyerrok;}
11329  break;
11330 
11331  case 619:
11332 
11333 /* Line 1806 of yacc.c */
11334 #line 4987 "ripper.y"
11335  {
11336 #if 0
11337  (yyval.val) = 0;
11338 #endif
11339  (yyval.val) = Qundef;
11340 
11341  }
11342  break;
11343 
11344 
11345 
11346 /* Line 1806 of yacc.c */
11347 #line 11346 "parse.c"
11348  default: break;
11349  }
11350  /* User semantic actions sometimes alter yychar, and that requires
11351  that yytoken be updated with the new translation. We take the
11352  approach of translating immediately before every use of yytoken.
11353  One alternative is translating here after every semantic action,
11354  but that translation would be missed if the semantic action invokes
11355  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11356  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
11357  incorrect destructor might then be invoked immediately. In the
11358  case of YYERROR or YYBACKUP, subsequent parser actions might lead
11359  to an incorrect destructor call or verbose syntax error message
11360  before the lookahead is translated. */
11361  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11362 
11363  YYPOPSTACK (yylen);
11364  yylen = 0;
11365  YY_STACK_PRINT (yyss, yyssp);
11366 
11367  *++yyvsp = yyval;
11368 
11369  /* Now `shift' the result of the reduction. Determine what state
11370  that goes to, based on the state we popped back to and the rule
11371  number reduced by. */
11372 
11373  yyn = yyr1[yyn];
11374 
11375  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
11376  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
11377  yystate = yytable[yystate];
11378  else
11379  yystate = yydefgoto[yyn - YYNTOKENS];
11380 
11381  goto yynewstate;
11382 
11383 
11384 /*------------------------------------.
11385 | yyerrlab -- here on detecting error |
11386 `------------------------------------*/
11387 yyerrlab:
11388  /* Make sure we have latest lookahead translation. See comments at
11389  user semantic actions for why this is necessary. */
11390  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
11391 
11392  /* If not already recovering from an error, report this error. */
11393  if (!yyerrstatus)
11394  {
11395  ++yynerrs;
11396 #if ! YYERROR_VERBOSE
11397  parser_yyerror (parser, YY_("syntax error"));
11398 #else
11399 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
11400  yyssp, yytoken)
11401  {
11402  char const *yymsgp = YY_("syntax error");
11403  int yysyntax_error_status;
11404  yysyntax_error_status = YYSYNTAX_ERROR;
11405  if (yysyntax_error_status == 0)
11406  yymsgp = yymsg;
11407  else if (yysyntax_error_status == 1)
11408  {
11409  if (yymsg != yymsgbuf)
11410  YYSTACK_FREE (yymsg);
11411  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11412  if (!yymsg)
11413  {
11414  yymsg = yymsgbuf;
11415  yymsg_alloc = sizeof yymsgbuf;
11416  yysyntax_error_status = 2;
11417  }
11418  else
11419  {
11420  yysyntax_error_status = YYSYNTAX_ERROR;
11421  yymsgp = yymsg;
11422  }
11423  }
11424  parser_yyerror (parser, yymsgp);
11425  if (yysyntax_error_status == 2)
11426  goto yyexhaustedlab;
11427  }
11428 # undef YYSYNTAX_ERROR
11429 #endif
11430  }
11431 
11432 
11433 
11434  if (yyerrstatus == 3)
11435  {
11436  /* If just tried and failed to reuse lookahead token after an
11437  error, discard it. */
11438 
11439  if (yychar <= YYEOF)
11440  {
11441  /* Return failure if at end of input. */
11442  if (yychar == YYEOF)
11443  YYABORT;
11444  }
11445  else
11446  {
11447  yydestruct ("Error: discarding",
11448  yytoken, &yylval, parser);
11449  yychar = YYEMPTY;
11450  }
11451  }
11452 
11453  /* Else will try to reuse lookahead token after shifting the error
11454  token. */
11455  goto yyerrlab1;
11456 
11457 
11458 /*---------------------------------------------------.
11459 | yyerrorlab -- error raised explicitly by YYERROR. |
11460 `---------------------------------------------------*/
11461 yyerrorlab:
11462 
11463  /* Pacify compilers like GCC when the user code never invokes
11464  YYERROR and the label yyerrorlab therefore never appears in user
11465  code. */
11466  if (/*CONSTCOND*/ 0)
11467  goto yyerrorlab;
11468 
11469  /* Do not reclaim the symbols of the rule which action triggered
11470  this YYERROR. */
11471  YYPOPSTACK (yylen);
11472  yylen = 0;
11473  YY_STACK_PRINT (yyss, yyssp);
11474  yystate = *yyssp;
11475  goto yyerrlab1;
11476 
11477 
11478 /*-------------------------------------------------------------.
11479 | yyerrlab1 -- common code for both syntax error and YYERROR. |
11480 `-------------------------------------------------------------*/
11481 yyerrlab1:
11482  yyerrstatus = 3; /* Each real token shifted decrements this. */
11483 
11484  for (;;)
11485  {
11486  yyn = yypact[yystate];
11487  if (!yypact_value_is_default (yyn))
11488  {
11489  yyn += YYTERROR;
11490  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11491  {
11492  yyn = yytable[yyn];
11493  if (0 < yyn)
11494  break;
11495  }
11496  }
11497 
11498  /* Pop the current state because it cannot handle the error token. */
11499  if (yyssp == yyss)
11500  YYABORT;
11501 
11502 
11503  yydestruct ("Error: popping",
11504  yystos[yystate], yyvsp, parser);
11505  YYPOPSTACK (1);
11506  yystate = *yyssp;
11507  YY_STACK_PRINT (yyss, yyssp);
11508  }
11509 
11510  *++yyvsp = yylval;
11511 
11512 
11513  /* Shift the error token. */
11514  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11515 
11516  yystate = yyn;
11517  goto yynewstate;
11518 
11519 
11520 /*-------------------------------------.
11521 | yyacceptlab -- YYACCEPT comes here. |
11522 `-------------------------------------*/
11523 yyacceptlab:
11524  yyresult = 0;
11525  goto yyreturn;
11526 
11527 /*-----------------------------------.
11528 | yyabortlab -- YYABORT comes here. |
11529 `-----------------------------------*/
11530 yyabortlab:
11531  yyresult = 1;
11532  goto yyreturn;
11533 
11534 #if !defined(yyoverflow) || YYERROR_VERBOSE
11535 /*-------------------------------------------------.
11536 | yyexhaustedlab -- memory exhaustion comes here. |
11537 `-------------------------------------------------*/
11538 yyexhaustedlab:
11539  parser_yyerror (parser, YY_("memory exhausted"));
11540  yyresult = 2;
11541  /* Fall through. */
11542 #endif
11543 
11544 yyreturn:
11545  if (yychar != YYEMPTY)
11546  {
11547  /* Make sure we have latest lookahead translation. See comments at
11548  user semantic actions for why this is necessary. */
11549  yytoken = YYTRANSLATE (yychar);
11550  yydestruct ("Cleanup: discarding lookahead",
11551  yytoken, &yylval, parser);
11552  }
11553  /* Do not reclaim the symbols of the rule which action triggered
11554  this YYABORT or YYACCEPT. */
11555  YYPOPSTACK (yylen);
11556  YY_STACK_PRINT (yyss, yyssp);
11557  while (yyssp != yyss)
11558  {
11559  yydestruct ("Cleanup: popping",
11560  yystos[*yyssp], yyvsp, parser);
11561  YYPOPSTACK (1);
11562  }
11563 #ifndef yyoverflow
11564  if (yyss != yyssa)
11565  YYSTACK_FREE (yyss);
11566 #endif
11567 #if YYERROR_VERBOSE
11568  if (yymsg != yymsgbuf)
11569  YYSTACK_FREE (yymsg);
11570 #endif
11571  /* Make sure YYID is used. */
11572  return YYID (yyresult);
11573 }
11574 
11575 
11576 
11577 /* Line 2067 of yacc.c */
11578 #line 4995 "ripper.y"
11579 
11580 # undef parser
11581 # undef yylex
11582 # undef yylval
11583 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
11584 
11585 static int parser_regx_options(struct parser_params*);
11586 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11587 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11588 static int parser_parse_string(struct parser_params*,NODE*);
11589 static int parser_here_document(struct parser_params*,NODE*);
11590 
11591 
11592 # define nextc() parser_nextc(parser)
11593 # define pushback(c) parser_pushback(parser, (c))
11594 # define newtok() parser_newtok(parser)
11595 # define tokspace(n) parser_tokspace(parser, (n))
11596 # define tokadd(c) parser_tokadd(parser, (c))
11597 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
11598 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
11599 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
11600 # define regx_options() parser_regx_options(parser)
11601 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11602 # define parse_string(n) parser_parse_string(parser,(n))
11603 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
11604 # define here_document(n) parser_here_document(parser,(n))
11605 # define heredoc_identifier() parser_heredoc_identifier(parser)
11606 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
11607 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
11608 
11609 #ifndef RIPPER
11610 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11611 # define set_yylval_num(x) (yylval.num = (x))
11612 # define set_yylval_id(x) (yylval.id = (x))
11613 # define set_yylval_name(x) (yylval.id = (x))
11614 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11615 # define set_yylval_node(x) (yylval.node = (x))
11616 # define yylval_id() (yylval.id)
11617 #else
11618 static inline VALUE
11619 ripper_yylval_id(ID x)
11620 {
11621  return (VALUE)NEW_LASGN(x, ID2SYM(x));
11622 }
11623 # define set_yylval_str(x) (void)(x)
11624 # define set_yylval_num(x) (void)(x)
11625 # define set_yylval_id(x) (void)(x)
11626 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11627 # define set_yylval_literal(x) (void)(x)
11628 # define set_yylval_node(x) (void)(x)
11629 # define yylval_id() yylval.id
11630 #endif
11631 
11632 #ifndef RIPPER
11633 #define ripper_flush(p) (void)(p)
11634 #else
11635 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11636 
11637 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11638 
11639 static int
11640 ripper_has_scan_event(struct parser_params *parser)
11641 {
11642 
11643  if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11644  return lex_p > parser->tokp;
11645 }
11646 
11647 static VALUE
11648 ripper_scan_event_val(struct parser_params *parser, int t)
11649 {
11650  VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11651  VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11652  ripper_flush(parser);
11653  return rval;
11654 }
11655 
11656 static void
11657 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11658 {
11659  if (!ripper_has_scan_event(parser)) return;
11660  yylval_rval = ripper_scan_event_val(parser, t);
11661 }
11662 
11663 static void
11664 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11665 {
11666  if (!ripper_has_scan_event(parser)) return;
11667  (void)ripper_scan_event_val(parser, t);
11668 }
11669 
11670 static void
11671 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11672 {
11673  int saved_line = ruby_sourceline;
11674  const char *saved_tokp = parser->tokp;
11675 
11676  ruby_sourceline = parser->delayed_line;
11677  parser->tokp = lex_pbeg + parser->delayed_col;
11678  yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11679  parser->delayed = Qnil;
11680  ruby_sourceline = saved_line;
11681  parser->tokp = saved_tokp;
11682 }
11683 #endif /* RIPPER */
11684 
11685 #include "ruby/regex.h"
11686 #include "ruby/util.h"
11687 
11688 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11689  since ours (we hope) works properly with all combinations of
11690  machines, compilers, `char' and `unsigned char' argument types.
11691  (Per Bothner suggested the basic approach.) */
11692 #undef SIGN_EXTEND_CHAR
11693 #if __STDC__
11694 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11695 #else /* not __STDC__ */
11696 /* As in Harbison and Steele. */
11697 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11698 #endif
11699 
11700 #define parser_encoding_name() (current_enc->name)
11701 #define parser_mbclen() mbclen((lex_p-1),lex_pend,current_enc)
11702 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
11703 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11704 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11705 
11706 #define parser_isascii() ISASCII(*(lex_p-1))
11707 
11708 #ifndef RIPPER
11709 static int
11710 token_info_get_column(struct parser_params *parser, const char *token)
11711 {
11712  int column = 1;
11713  const char *p, *pend = lex_p - strlen(token);
11714  for (p = lex_pbeg; p < pend; p++) {
11715  if (*p == '\t') {
11716  column = (((column - 1) / 8) + 1) * 8;
11717  }
11718  column++;
11719  }
11720  return column;
11721 }
11722 
11723 static int
11724 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11725 {
11726  const char *p, *pend = lex_p - strlen(token);
11727  for (p = lex_pbeg; p < pend; p++) {
11728  if (*p != ' ' && *p != '\t') {
11729  return 1;
11730  }
11731  }
11732  return 0;
11733 }
11734 
11735 #undef token_info_push
11736 static void
11737 token_info_push(struct parser_params *parser, const char *token)
11738 {
11739  token_info *ptinfo;
11740 
11741  if (!parser->parser_token_info_enabled) return;
11742  ptinfo = ALLOC(token_info);
11743  ptinfo->token = token;
11744  ptinfo->linenum = ruby_sourceline;
11745  ptinfo->column = token_info_get_column(parser, token);
11746  ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11747  ptinfo->next = parser->parser_token_info;
11748 
11749  parser->parser_token_info = ptinfo;
11750 }
11751 
11752 #undef token_info_pop
11753 static void
11754 token_info_pop(struct parser_params *parser, const char *token)
11755 {
11756  int linenum;
11757  token_info *ptinfo = parser->parser_token_info;
11758 
11759  if (!ptinfo) return;
11760  parser->parser_token_info = ptinfo->next;
11761  if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11762  goto finish;
11763  }
11764  linenum = ruby_sourceline;
11765  if (linenum == ptinfo->linenum) { /* SKIP */
11766  goto finish;
11767  }
11768  if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11769  goto finish;
11770  }
11771  if (parser->parser_token_info_enabled) {
11773  "mismatched indentations at '%s' with '%s' at %d",
11774  token, ptinfo->token, ptinfo->linenum);
11775  }
11776 
11777  finish:
11778  xfree(ptinfo);
11779 }
11780 #endif /* RIPPER */
11781 
11782 static int
11783 parser_yyerror(struct parser_params *parser, const char *msg)
11784 {
11785 #ifndef RIPPER
11786  const int max_line_margin = 30;
11787  const char *p, *pe;
11788  char *buf;
11789  long len;
11790  int i;
11791 
11792  compile_error(PARSER_ARG "%s", msg);
11793  p = lex_p;
11794  while (lex_pbeg <= p) {
11795  if (*p == '\n') break;
11796  p--;
11797  }
11798  p++;
11799 
11800  pe = lex_p;
11801  while (pe < lex_pend) {
11802  if (*pe == '\n') break;
11803  pe++;
11804  }
11805 
11806  len = pe - p;
11807  if (len > 4) {
11808  char *p2;
11809  const char *pre = "", *post = "";
11810 
11811  if (len > max_line_margin * 2 + 10) {
11812  if (lex_p - p > max_line_margin) {
11813  p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11814  pre = "...";
11815  }
11816  if (pe - lex_p > max_line_margin) {
11817  pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11818  post = "...";
11819  }
11820  len = pe - p;
11821  }
11822  buf = ALLOCA_N(char, len+2);
11823  MEMCPY(buf, p, char, len);
11824  buf[len] = '\0';
11825  rb_compile_error_append("%s%s%s", pre, buf, post);
11826 
11827  i = (int)(lex_p - p);
11828  p2 = buf; pe = buf + len;
11829 
11830  while (p2 < pe) {
11831  if (*p2 != '\t') *p2 = ' ';
11832  p2++;
11833  }
11834  buf[i] = '^';
11835  buf[i+1] = '\0';
11836  rb_compile_error_append("%s%s", pre, buf);
11837  }
11838 #else
11839  dispatch1(parse_error, STR_NEW2(msg));
11840 #endif /* !RIPPER */
11841  return 0;
11842 }
11843 
11844 static void parser_prepare(struct parser_params *parser);
11845 
11846 #ifndef RIPPER
11847 static VALUE
11848 debug_lines(const char *f)
11849 {
11850  ID script_lines;
11851  CONST_ID(script_lines, "SCRIPT_LINES__");
11852  if (rb_const_defined_at(rb_cObject, script_lines)) {
11853  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11854  if (RB_TYPE_P(hash, T_HASH)) {
11856  VALUE lines = rb_ary_new();
11857  rb_hash_aset(hash, fname, lines);
11858  return lines;
11859  }
11860  }
11861  return 0;
11862 }
11863 
11864 static VALUE
11865 coverage(const char *f, int n)
11866 {
11867  VALUE coverages = rb_get_coverages();
11868  if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11870  VALUE lines = rb_ary_new2(n);
11871  int i;
11872  RBASIC(lines)->klass = 0;
11873  for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11874  RARRAY(lines)->as.heap.len = n;
11875  rb_hash_aset(coverages, fname, lines);
11876  return lines;
11877  }
11878  return 0;
11879 }
11880 
11881 static int
11883 {
11884  return strcmp(ruby_sourcefile, "-e") == 0;
11885 }
11886 
11887 static VALUE
11889 {
11890  int n;
11891  NODE *tree;
11892  struct parser_params *parser = (struct parser_params *)arg;
11893 
11894  if (!compile_for_eval && rb_safe_level() == 0) {
11896  if (ruby_debug_lines && ruby_sourceline > 0) {
11897  VALUE str = STR_NEW0();
11898  n = ruby_sourceline;
11899  do {
11901  } while (--n);
11902  }
11903 
11904  if (!e_option_supplied(parser)) {
11906  }
11907  }
11908 
11909  parser_prepare(parser);
11910  deferred_nodes = 0;
11911 #ifndef RIPPER
11913 #endif
11914 #ifndef RIPPER
11917  parser->parser_ruby_sourceline);
11918  }
11919 #endif
11920  n = yyparse((void*)parser);
11921 #ifndef RIPPER
11924  parser->parser_ruby_sourceline);
11925  }
11926 #endif
11927  ruby_debug_lines = 0;
11928  ruby_coverage = 0;
11929  compile_for_eval = 0;
11930 
11931  lex_strterm = 0;
11932  lex_p = lex_pbeg = lex_pend = 0;
11933  lex_lastline = lex_nextline = 0;
11934  if (parser->nerr) {
11935  return 0;
11936  }
11937  tree = ruby_eval_tree;
11938  if (!tree) {
11939  tree = NEW_NIL();
11940  }
11941  else if (ruby_eval_tree_begin) {
11942  tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11943  }
11944  return (VALUE)tree;
11945 }
11946 
11947 static NODE*
11948 yycompile(struct parser_params *parser, const char *f, int line)
11949 {
11951  ruby_sourceline = line - 1;
11952  return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
11953 }
11954 #endif /* !RIPPER */
11955 
11956 static rb_encoding *
11958 {
11959  rb_encoding *enc = rb_enc_get(s);
11960  if (!rb_enc_asciicompat(enc)) {
11961  rb_raise(rb_eArgError, "invalid source encoding");
11962  }
11963  return enc;
11964 }
11965 
11966 static VALUE
11967 lex_get_str(struct parser_params *parser, VALUE s)
11968 {
11969  char *beg, *end, *pend;
11971 
11972  beg = RSTRING_PTR(s);
11973  if (lex_gets_ptr) {
11974  if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11975  beg += lex_gets_ptr;
11976  }
11977  pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11978  end = beg;
11979  while (end < pend) {
11980  if (*end++ == '\n') break;
11981  }
11982  lex_gets_ptr = end - RSTRING_PTR(s);
11983  return rb_enc_str_new(beg, end - beg, enc);
11984 }
11985 
11986 static VALUE
11988 {
11989  VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11990  if (NIL_P(line)) return line;
11992 #ifndef RIPPER
11993  if (ruby_debug_lines) {
11996  }
11997  if (ruby_coverage) {
11999  }
12000 #endif
12001  return line;
12002 }
12003 
12004 #ifdef RIPPER
12006 #else
12008 
12009 static NODE*
12010 parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
12011 {
12012  struct parser_params *parser;
12013  NODE *node;
12014 
12015  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12017  lex_gets_ptr = 0;
12018  lex_input = s;
12019  lex_pbeg = lex_p = lex_pend = 0;
12021 
12022  node = yycompile(parser, f, line);
12023  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12024 
12025  return node;
12026 }
12027 
12028 NODE*
12029 rb_compile_string(const char *f, VALUE s, int line)
12030 {
12032  return parser_compile_string(rb_parser_new(), f, s, line);
12033 }
12034 
12035 NODE*
12036 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
12037 {
12039  return parser_compile_string(vparser, f, s, line);
12040 }
12041 
12042 NODE*
12043 rb_compile_cstr(const char *f, const char *s, int len, int line)
12044 {
12045  VALUE str = rb_str_new(s, len);
12046  return parser_compile_string(rb_parser_new(), f, str, line);
12047 }
12048 
12049 NODE*
12050 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
12051 {
12052  VALUE str = rb_str_new(s, len);
12053  return parser_compile_string(vparser, f, str, line);
12054 }
12055 
12056 static VALUE
12057 lex_io_gets(struct parser_params *parser, VALUE io)
12058 {
12059  return rb_io_gets(io);
12060 }
12061 
12062 NODE*
12063 rb_compile_file(const char *f, VALUE file, int start)
12064 {
12065  VALUE volatile vparser = rb_parser_new();
12066 
12067  return rb_parser_compile_file(vparser, f, file, start);
12068 }
12069 
12070 NODE*
12071 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
12072 {
12073  struct parser_params *parser;
12074  NODE *node;
12075 
12076  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12078  lex_input = file;
12079  lex_pbeg = lex_p = lex_pend = 0;
12081 
12082  node = yycompile(parser, f, start);
12083  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12084 
12085  return node;
12086 }
12087 #endif /* !RIPPER */
12088 
12089 #define STR_FUNC_ESCAPE 0x01
12090 #define STR_FUNC_EXPAND 0x02
12091 #define STR_FUNC_REGEXP 0x04
12092 #define STR_FUNC_QWORDS 0x08
12093 #define STR_FUNC_SYMBOL 0x10
12094 #define STR_FUNC_INDENT 0x20
12095 
12097  str_squote = (0),
12105 };
12106 
12107 static VALUE
12108 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
12109 {
12110  VALUE str;
12111 
12112  str = rb_enc_str_new(p, n, enc);
12113  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12115  }
12116  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12118  }
12119  }
12120 
12121  return str;
12122 }
12123 
12124 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
12125 #define lex_eol_p() (lex_p >= lex_pend)
12126 #define peek(c) peek_n((c), 0)
12127 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
12128 
12129 static inline int
12131 {
12132  int c;
12133 
12134  if (lex_p == lex_pend) {
12135  VALUE v = lex_nextline;
12136  lex_nextline = 0;
12137  if (!v) {
12138  if (parser->eofp)
12139  return -1;
12140 
12141  if (!lex_input || NIL_P(v = lex_getline(parser))) {
12142  parser->eofp = Qtrue;
12143  lex_goto_eol(parser);
12144  return -1;
12145  }
12146  }
12147  {
12148 #ifdef RIPPER
12149  if (parser->tokp < lex_pend) {
12150  if (NIL_P(parser->delayed)) {
12151  parser->delayed = rb_str_buf_new(1024);
12152  rb_enc_associate(parser->delayed, current_enc);
12153  rb_str_buf_cat(parser->delayed,
12154  parser->tokp, lex_pend - parser->tokp);
12155  parser->delayed_line = ruby_sourceline;
12156  parser->delayed_col = (int)(parser->tokp - lex_pbeg);
12157  }
12158  else {
12159  rb_str_buf_cat(parser->delayed,
12160  parser->tokp, lex_pend - parser->tokp);
12161  }
12162  }
12163 #endif
12164  if (heredoc_end > 0) {
12166  heredoc_end = 0;
12167  }
12168  ruby_sourceline++;
12169  parser->line_count++;
12170  lex_pbeg = lex_p = RSTRING_PTR(v);
12171  lex_pend = lex_p + RSTRING_LEN(v);
12172  ripper_flush(parser);
12173  lex_lastline = v;
12174  }
12175  }
12176  c = (unsigned char)*lex_p++;
12177  if (c == '\r' && peek('\n')) {
12178  lex_p++;
12179  c = '\n';
12180  }
12181 
12182  return c;
12183 }
12184 
12185 static void
12186 parser_pushback(struct parser_params *parser, int c)
12187 {
12188  if (c == -1) return;
12189  lex_p--;
12190  if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
12191  lex_p--;
12192  }
12193 }
12194 
12195 #define was_bol() (lex_p == lex_pbeg + 1)
12196 
12197 #define tokfix() (tokenbuf[tokidx]='\0')
12198 #define tok() tokenbuf
12199 #define toklen() tokidx
12200 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
12201 
12202 static char*
12204 {
12205  tokidx = 0;
12207  if (!tokenbuf) {
12208  toksiz = 60;
12209  tokenbuf = ALLOC_N(char, 60);
12210  }
12211  if (toksiz > 4096) {
12212  toksiz = 60;
12213  REALLOC_N(tokenbuf, char, 60);
12214  }
12215  return tokenbuf;
12216 }
12217 
12218 static char *
12219 parser_tokspace(struct parser_params *parser, int n)
12220 {
12221  tokidx += n;
12222 
12223  if (tokidx >= toksiz) {
12224  do {toksiz *= 2;} while (toksiz < tokidx);
12225  REALLOC_N(tokenbuf, char, toksiz);
12226  }
12227  return &tokenbuf[tokidx-n];
12228 }
12229 
12230 static void
12231 parser_tokadd(struct parser_params *parser, int c)
12232 {
12233  tokenbuf[tokidx++] = (char)c;
12234  if (tokidx >= toksiz) {
12235  toksiz *= 2;
12236  REALLOC_N(tokenbuf, char, toksiz);
12237  }
12238 }
12239 
12240 static int
12241 parser_tok_hex(struct parser_params *parser, size_t *numlen)
12242 {
12243  int c;
12244 
12245  c = scan_hex(lex_p, 2, numlen);
12246  if (!*numlen) {
12247  yyerror("invalid hex escape");
12248  return 0;
12249  }
12250  lex_p += *numlen;
12251  return c;
12252 }
12253 
12254 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
12255 
12256 /* return value is for ?\u3042 */
12257 static int
12259  int string_literal, int symbol_literal, int regexp_literal)
12260 {
12261  /*
12262  * If string_literal is true, then we allow multiple codepoints
12263  * in \u{}, and add the codepoints to the current token.
12264  * Otherwise we're parsing a character literal and return a single
12265  * codepoint without adding it
12266  */
12267 
12268  int codepoint;
12269  size_t numlen;
12270 
12271  if (regexp_literal) { tokadd('\\'); tokadd('u'); }
12272 
12273  if (peek('{')) { /* handle \u{...} form */
12274  do {
12275  if (regexp_literal) { tokadd(*lex_p); }
12276  nextc();
12277  codepoint = scan_hex(lex_p, 6, &numlen);
12278  if (numlen == 0) {
12279  yyerror("invalid Unicode escape");
12280  return 0;
12281  }
12282  if (codepoint > 0x10ffff) {
12283  yyerror("invalid Unicode codepoint (too large)");
12284  return 0;
12285  }
12286  lex_p += numlen;
12287  if (regexp_literal) {
12288  tokcopy((int)numlen);
12289  }
12290  else if (codepoint >= 0x80) {
12291  *encp = rb_utf8_encoding();
12292  if (string_literal) tokaddmbc(codepoint, *encp);
12293  }
12294  else if (string_literal) {
12295  tokadd(codepoint);
12296  }
12297  } while (string_literal && (peek(' ') || peek('\t')));
12298 
12299  if (!peek('}')) {
12300  yyerror("unterminated Unicode escape");
12301  return 0;
12302  }
12303 
12304  if (regexp_literal) { tokadd('}'); }
12305  nextc();
12306  }
12307  else { /* handle \uxxxx form */
12308  codepoint = scan_hex(lex_p, 4, &numlen);
12309  if (numlen < 4) {
12310  yyerror("invalid Unicode escape");
12311  return 0;
12312  }
12313  lex_p += 4;
12314  if (regexp_literal) {
12315  tokcopy(4);
12316  }
12317  else if (codepoint >= 0x80) {
12318  *encp = rb_utf8_encoding();
12319  if (string_literal) tokaddmbc(codepoint, *encp);
12320  }
12321  else if (string_literal) {
12322  tokadd(codepoint);
12323  }
12324  }
12325 
12326  return codepoint;
12327 }
12328 
12329 #define ESCAPE_CONTROL 1
12330 #define ESCAPE_META 2
12331 
12332 static int
12333 parser_read_escape(struct parser_params *parser, int flags,
12334  rb_encoding **encp)
12335 {
12336  int c;
12337  size_t numlen;
12338 
12339  switch (c = nextc()) {
12340  case '\\': /* Backslash */
12341  return c;
12342 
12343  case 'n': /* newline */
12344  return '\n';
12345 
12346  case 't': /* horizontal tab */
12347  return '\t';
12348 
12349  case 'r': /* carriage-return */
12350  return '\r';
12351 
12352  case 'f': /* form-feed */
12353  return '\f';
12354 
12355  case 'v': /* vertical tab */
12356  return '\13';
12357 
12358  case 'a': /* alarm(bell) */
12359  return '\007';
12360 
12361  case 'e': /* escape */
12362  return 033;
12363 
12364  case '0': case '1': case '2': case '3': /* octal constant */
12365  case '4': case '5': case '6': case '7':
12366  pushback(c);
12367  c = scan_oct(lex_p, 3, &numlen);
12368  lex_p += numlen;
12369  return c;
12370 
12371  case 'x': /* hex constant */
12372  c = tok_hex(&numlen);
12373  if (numlen == 0) return 0;
12374  return c;
12375 
12376  case 'b': /* backspace */
12377  return '\010';
12378 
12379  case 's': /* space */
12380  return ' ';
12381 
12382  case 'M':
12383  if (flags & ESCAPE_META) goto eof;
12384  if ((c = nextc()) != '-') {
12385  pushback(c);
12386  goto eof;
12387  }
12388  if ((c = nextc()) == '\\') {
12389  if (peek('u')) goto eof;
12390  return read_escape(flags|ESCAPE_META, encp) | 0x80;
12391  }
12392  else if (c == -1 || !ISASCII(c)) goto eof;
12393  else {
12394  return ((c & 0xff) | 0x80);
12395  }
12396 
12397  case 'C':
12398  if ((c = nextc()) != '-') {
12399  pushback(c);
12400  goto eof;
12401  }
12402  case 'c':
12403  if (flags & ESCAPE_CONTROL) goto eof;
12404  if ((c = nextc())== '\\') {
12405  if (peek('u')) goto eof;
12406  c = read_escape(flags|ESCAPE_CONTROL, encp);
12407  }
12408  else if (c == '?')
12409  return 0177;
12410  else if (c == -1 || !ISASCII(c)) goto eof;
12411  return c & 0x9f;
12412 
12413  eof:
12414  case -1:
12415  yyerror("Invalid escape character syntax");
12416  return '\0';
12417 
12418  default:
12419  return c;
12420  }
12421 }
12422 
12423 static void
12425 {
12426  int len = rb_enc_codelen(c, enc);
12427  rb_enc_mbcput(c, tokspace(len), enc);
12428 }
12429 
12430 static int
12432 {
12433  int c;
12434  int flags = 0;
12435  size_t numlen;
12436 
12437  first:
12438  switch (c = nextc()) {
12439  case '\n':
12440  return 0; /* just ignore */
12441 
12442  case '0': case '1': case '2': case '3': /* octal constant */
12443  case '4': case '5': case '6': case '7':
12444  {
12445  ruby_scan_oct(--lex_p, 3, &numlen);
12446  if (numlen == 0) goto eof;
12447  lex_p += numlen;
12448  tokcopy((int)numlen + 1);
12449  }
12450  return 0;
12451 
12452  case 'x': /* hex constant */
12453  {
12454  tok_hex(&numlen);
12455  if (numlen == 0) return -1;
12456  tokcopy((int)numlen + 2);
12457  }
12458  return 0;
12459 
12460  case 'M':
12461  if (flags & ESCAPE_META) goto eof;
12462  if ((c = nextc()) != '-') {
12463  pushback(c);
12464  goto eof;
12465  }
12466  tokcopy(3);
12467  flags |= ESCAPE_META;
12468  goto escaped;
12469 
12470  case 'C':
12471  if (flags & ESCAPE_CONTROL) goto eof;
12472  if ((c = nextc()) != '-') {
12473  pushback(c);
12474  goto eof;
12475  }
12476  tokcopy(3);
12477  goto escaped;
12478 
12479  case 'c':
12480  if (flags & ESCAPE_CONTROL) goto eof;
12481  tokcopy(2);
12482  flags |= ESCAPE_CONTROL;
12483  escaped:
12484  if ((c = nextc()) == '\\') {
12485  goto first;
12486  }
12487  else if (c == -1) goto eof;
12488  tokadd(c);
12489  return 0;
12490 
12491  eof:
12492  case -1:
12493  yyerror("Invalid escape character syntax");
12494  return -1;
12495 
12496  default:
12497  tokadd('\\');
12498  tokadd(c);
12499  }
12500  return 0;
12501 }
12502 
12503 static int
12505 {
12506  int kcode = 0;
12507  int kopt = 0;
12508  int options = 0;
12509  int c, opt, kc;
12510 
12511  newtok();
12512  while (c = nextc(), ISALPHA(c)) {
12513  if (c == 'o') {
12514  options |= RE_OPTION_ONCE;
12515  }
12516  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12517  if (kc >= 0) {
12518  if (kc != rb_ascii8bit_encindex()) kcode = c;
12519  kopt = opt;
12520  }
12521  else {
12522  options |= opt;
12523  }
12524  }
12525  else {
12526  tokadd(c);
12527  }
12528  }
12529  options |= kopt;
12530  pushback(c);
12531  if (toklen()) {
12532  tokfix();
12533  compile_error(PARSER_ARG "unknown regexp option%s - %s",
12534  toklen() > 1 ? "s" : "", tok());
12535  }
12536  return options | RE_OPTION_ENCODING(kcode);
12537 }
12538 
12539 static void
12541 {
12542  rb_str_free(str);
12543  rb_gc_force_recycle(str);
12544 }
12545 
12546 static int
12547 parser_tokadd_mbchar(struct parser_params *parser, int c)
12548 {
12549  int len = parser_precise_mbclen();
12550  if (!MBCLEN_CHARFOUND_P(len)) {
12551  compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12552  return -1;
12553  }
12554  tokadd(c);
12555  lex_p += --len;
12556  if (len > 0) tokcopy(len);
12557  return c;
12558 }
12559 
12560 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12561 
12562 static inline int
12564 {
12565  switch (c) {
12566  case '$': case '*': case '+': case '.':
12567  case '?': case '^': case '|':
12568  case ')': case ']': case '}': case '>':
12569  return TRUE;
12570  default:
12571  return FALSE;
12572  }
12573 }
12574 
12575 static int
12577  int func, int term, int paren, long *nest,
12578  rb_encoding **encp)
12579 {
12580  int c;
12581  int has_nonascii = 0;
12582  rb_encoding *enc = *encp;
12583  char *errbuf = 0;
12584  static const char mixed_msg[] = "%s mixed within %s source";
12585 
12586 #define mixed_error(enc1, enc2) if (!errbuf) { \
12587  size_t len = sizeof(mixed_msg) - 4; \
12588  len += strlen(rb_enc_name(enc1)); \
12589  len += strlen(rb_enc_name(enc2)); \
12590  errbuf = ALLOCA_N(char, len); \
12591  snprintf(errbuf, len, mixed_msg, \
12592  rb_enc_name(enc1), \
12593  rb_enc_name(enc2)); \
12594  yyerror(errbuf); \
12595  }
12596 #define mixed_escape(beg, enc1, enc2) do { \
12597  const char *pos = lex_p; \
12598  lex_p = (beg); \
12599  mixed_error((enc1), (enc2)); \
12600  lex_p = pos; \
12601  } while (0)
12602 
12603  while ((c = nextc()) != -1) {
12604  if (paren && c == paren) {
12605  ++*nest;
12606  }
12607  else if (c == term) {
12608  if (!nest || !*nest) {
12609  pushback(c);
12610  break;
12611  }
12612  --*nest;
12613  }
12614  else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12615  int c2 = *lex_p;
12616  if (c2 == '$' || c2 == '@' || c2 == '{') {
12617  pushback(c);
12618  break;
12619  }
12620  }
12621  else if (c == '\\') {
12622  const char *beg = lex_p - 1;
12623  c = nextc();
12624  switch (c) {
12625  case '\n':
12626  if (func & STR_FUNC_QWORDS) break;
12627  if (func & STR_FUNC_EXPAND) continue;
12628  tokadd('\\');
12629  break;
12630 
12631  case '\\':
12632  if (func & STR_FUNC_ESCAPE) tokadd(c);
12633  break;
12634 
12635  case 'u':
12636  if ((func & STR_FUNC_EXPAND) == 0) {
12637  tokadd('\\');
12638  break;
12639  }
12640  parser_tokadd_utf8(parser, &enc, 1,
12641  func & STR_FUNC_SYMBOL,
12642  func & STR_FUNC_REGEXP);
12643  if (has_nonascii && enc != *encp) {
12644  mixed_escape(beg, enc, *encp);
12645  }
12646  continue;
12647 
12648  default:
12649  if (c == -1) return -1;
12650  if (!ISASCII(c)) {
12651  if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12652  goto non_ascii;
12653  }
12654  if (func & STR_FUNC_REGEXP) {
12655  if (c == term && !simple_re_meta(c)) {
12656  tokadd(c);
12657  continue;
12658  }
12659  pushback(c);
12660  if ((c = tokadd_escape(&enc)) < 0)
12661  return -1;
12662  if (has_nonascii && enc != *encp) {
12663  mixed_escape(beg, enc, *encp);
12664  }
12665  continue;
12666  }
12667  else if (func & STR_FUNC_EXPAND) {
12668  pushback(c);
12669  if (func & STR_FUNC_ESCAPE) tokadd('\\');
12670  c = read_escape(0, &enc);
12671  }
12672  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12673  /* ignore backslashed spaces in %w */
12674  }
12675  else if (c != term && !(paren && c == paren)) {
12676  tokadd('\\');
12677  pushback(c);
12678  continue;
12679  }
12680  }
12681  }
12682  else if (!parser_isascii()) {
12683  non_ascii:
12684  has_nonascii = 1;
12685  if (enc != *encp) {
12686  mixed_error(enc, *encp);
12687  continue;
12688  }
12689  if (tokadd_mbchar(c) == -1) return -1;
12690  continue;
12691  }
12692  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12693  pushback(c);
12694  break;
12695  }
12696  if (c & 0x80) {
12697  has_nonascii = 1;
12698  if (enc != *encp) {
12699  mixed_error(enc, *encp);
12700  continue;
12701  }
12702  }
12703  tokadd(c);
12704  }
12705  *encp = enc;
12706  return c;
12707 }
12708 
12709 #define NEW_STRTERM(func, term, paren) \
12710  rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12711 
12712 #ifdef RIPPER
12713 static void
12714 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12715 {
12716  if (!NIL_P(parser->delayed)) {
12717  ptrdiff_t len = lex_p - parser->tokp;
12718  if (len > 0) {
12719  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12720  }
12721  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12722  parser->tokp = lex_p;
12723  }
12724 }
12725 
12726 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12727 #else
12728 #define flush_string_content(enc) ((void)(enc))
12729 #endif
12730 
12731 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12732 /* this can be shared with ripper, since it's independent from struct
12733  * parser_params. */
12734 #ifndef RIPPER
12735 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12736 #define SPECIAL_PUNCT(idx) ( \
12737  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12738  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12739  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12740  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12741  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12742  BIT('0', idx))
12743 const unsigned int ruby_global_name_punct_bits[] = {
12744  SPECIAL_PUNCT(0),
12745  SPECIAL_PUNCT(1),
12746  SPECIAL_PUNCT(2),
12747 };
12748 #undef BIT
12749 #undef SPECIAL_PUNCT
12750 #endif
12751 
12752 static inline int
12754 {
12755  if (c <= 0x20 || 0x7e < c) return 0;
12756  return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12757 }
12758 
12759 static int
12761 {
12762  int c;
12763  const char *p = lex_p;
12764 
12765  if (p + 1 >= lex_pend) return 0;
12766  c = *p++;
12767  switch (c) {
12768  case '$':
12769  if ((c = *p) == '-') {
12770  if (++p >= lex_pend) return 0;
12771  c = *p;
12772  }
12773  else if (is_global_name_punct(c) || ISDIGIT(c)) {
12774  return tSTRING_DVAR;
12775  }
12776  break;
12777  case '@':
12778  if ((c = *p) == '@') {
12779  if (++p >= lex_pend) return 0;
12780  c = *p;
12781  }
12782  break;
12783  case '{':
12784  lex_p = p;
12785  command_start = TRUE;
12786  return tSTRING_DBEG;
12787  default:
12788  return 0;
12789  }
12790  if (!ISASCII(c) || c == '_' || ISALPHA(c))
12791  return tSTRING_DVAR;
12792  return 0;
12793 }
12794 
12795 static int
12796 parser_parse_string(struct parser_params *parser, NODE *quote)
12797 {
12798  int func = (int)quote->nd_func;
12799  int term = nd_term(quote);
12800  int paren = nd_paren(quote);
12801  int c, space = 0;
12803 
12804  if (func == -1) return tSTRING_END;
12805  c = nextc();
12806  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12807  do {c = nextc();} while (ISSPACE(c));
12808  space = 1;
12809  }
12810  if (c == term && !quote->nd_nest) {
12811  if (func & STR_FUNC_QWORDS) {
12812  quote->nd_func = -1;
12813  return ' ';
12814  }
12815  if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12817  return tREGEXP_END;
12818  }
12819  if (space) {
12820  pushback(c);
12821  return ' ';
12822  }
12823  newtok();
12824  if ((func & STR_FUNC_EXPAND) && c == '#') {
12825  int t = parser_peek_variable_name(parser);
12826  if (t) return t;
12827  tokadd('#');
12828  c = nextc();
12829  }
12830  pushback(c);
12831  if (tokadd_string(func, term, paren, &quote->nd_nest,
12832  &enc) == -1) {
12833  ruby_sourceline = nd_line(quote);
12834  if (func & STR_FUNC_REGEXP) {
12835  if (parser->eofp)
12836  compile_error(PARSER_ARG "unterminated regexp meets end of file");
12837  return tREGEXP_END;
12838  }
12839  else {
12840  if (parser->eofp)
12841  compile_error(PARSER_ARG "unterminated string meets end of file");
12842  return tSTRING_END;
12843  }
12844  }
12845 
12846  tokfix();
12847  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12848  flush_string_content(enc);
12849 
12850  return tSTRING_CONTENT;
12851 }
12852 
12853 static int
12855 {
12856  int c = nextc(), term, func = 0;
12857  long len;
12858 
12859  if (c == '-') {
12860  c = nextc();
12861  func = STR_FUNC_INDENT;
12862  }
12863  switch (c) {
12864  case '\'':
12865  func |= str_squote; goto quoted;
12866  case '"':
12867  func |= str_dquote; goto quoted;
12868  case '`':
12869  func |= str_xquote;
12870  quoted:
12871  newtok();
12872  tokadd(func);
12873  term = c;
12874  while ((c = nextc()) != -1 && c != term) {
12875  if (tokadd_mbchar(c) == -1) return 0;
12876  }
12877  if (c == -1) {
12878  compile_error(PARSER_ARG "unterminated here document identifier");
12879  return 0;
12880  }
12881  break;
12882 
12883  default:
12884  if (!parser_is_identchar()) {
12885  pushback(c);
12886  if (func & STR_FUNC_INDENT) {
12887  pushback('-');
12888  }
12889  return 0;
12890  }
12891  newtok();
12892  term = '"';
12893  tokadd(func |= str_dquote);
12894  do {
12895  if (tokadd_mbchar(c) == -1) return 0;
12896  } while ((c = nextc()) != -1 && parser_is_identchar());
12897  pushback(c);
12898  break;
12899  }
12900 
12901  tokfix();
12902 #ifdef RIPPER
12903  ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12904 #endif
12905  len = lex_p - lex_pbeg;
12906  lex_goto_eol(parser);
12908  STR_NEW(tok(), toklen()), /* nd_lit */
12909  len, /* nd_nth */
12910  lex_lastline); /* nd_orig */
12912  ripper_flush(parser);
12913  return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12914 }
12915 
12916 static void
12918 {
12919  VALUE line;
12920 
12921  line = here->nd_orig;
12922  lex_lastline = line;
12923  lex_pbeg = RSTRING_PTR(line);
12924  lex_pend = lex_pbeg + RSTRING_LEN(line);
12925  lex_p = lex_pbeg + here->nd_nth;
12927  ruby_sourceline = nd_line(here);
12928  dispose_string(here->nd_lit);
12929  rb_gc_force_recycle((VALUE)here);
12930  ripper_flush(parser);
12931 }
12932 
12933 static int
12935  const char *eos, long len, int indent)
12936 {
12937  const char *p = lex_pbeg;
12938  long n;
12939 
12940  if (indent) {
12941  while (*p && ISSPACE(*p)) p++;
12942  }
12943  n = lex_pend - (p + len);
12944  if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12945  return strncmp(eos, p, len) == 0;
12946 }
12947 
12948 #ifdef RIPPER
12949 static void
12950 ripper_dispatch_heredoc_end(struct parser_params *parser)
12951 {
12952  if (!NIL_P(parser->delayed))
12953  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12954  lex_goto_eol(parser);
12955  ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12956 }
12957 
12958 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12959 #else
12960 #define dispatch_heredoc_end() ((void)0)
12961 #endif
12962 
12963 static int
12965 {
12966  int c, func, indent = 0;
12967  const char *eos, *p, *pend;
12968  long len;
12969  VALUE str = 0;
12971 
12972  eos = RSTRING_PTR(here->nd_lit);
12973  len = RSTRING_LEN(here->nd_lit) - 1;
12974  indent = (func = *eos++) & STR_FUNC_INDENT;
12975 
12976  if ((c = nextc()) == -1) {
12977  error:
12978  compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12979 #ifdef RIPPER
12980  if (NIL_P(parser->delayed)) {
12981  ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12982  }
12983  else {
12984  if (str ||
12985  ((len = lex_p - parser->tokp) > 0 &&
12986  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12987  rb_str_append(parser->delayed, str);
12988  }
12989  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12990  }
12991  lex_goto_eol(parser);
12992 #endif
12993  restore:
12995  lex_strterm = 0;
12996  return 0;
12997  }
12998  if (was_bol() && whole_match_p(eos, len, indent)) {
13001  return tSTRING_END;
13002  }
13003 
13004  if (!(func & STR_FUNC_EXPAND)) {
13005  do {
13007  pend = lex_pend;
13008  if (pend > p) {
13009  switch (pend[-1]) {
13010  case '\n':
13011  if (--pend == p || pend[-1] != '\r') {
13012  pend++;
13013  break;
13014  }
13015  case '\r':
13016  --pend;
13017  }
13018  }
13019  if (str)
13020  rb_str_cat(str, p, pend - p);
13021  else
13022  str = STR_NEW(p, pend - p);
13023  if (pend < lex_pend) rb_str_cat(str, "\n", 1);
13024  lex_goto_eol(parser);
13025  if (nextc() == -1) {
13026  if (str) dispose_string(str);
13027  goto error;
13028  }
13029  } while (!whole_match_p(eos, len, indent));
13030  }
13031  else {
13032  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
13033  newtok();
13034  if (c == '#') {
13035  int t = parser_peek_variable_name(parser);
13036  if (t) return t;
13037  tokadd('#');
13038  c = nextc();
13039  }
13040  do {
13041  pushback(c);
13042  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
13043  if (parser->eofp) goto error;
13044  goto restore;
13045  }
13046  if (c != '\n') {
13047  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
13048  flush_string_content(enc);
13049  return tSTRING_CONTENT;
13050  }
13051  tokadd(nextc());
13052  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
13053  if ((c = nextc()) == -1) goto error;
13054  } while (!whole_match_p(eos, len, indent));
13055  str = STR_NEW3(tok(), toklen(), enc, func);
13056  }
13059  lex_strterm = NEW_STRTERM(-1, 0, 0);
13060  set_yylval_str(str);
13061  return tSTRING_CONTENT;
13062 }
13063 
13064 #include "lex.c"
13065 
13066 static void
13068 {
13069 #ifndef RIPPER
13070  rb_warning0("ambiguous first argument; put parentheses or even spaces");
13071 #else
13072  dispatch0(arg_ambiguous);
13073 #endif
13074 }
13075 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
13076 
13077 static ID
13079 {
13080 #ifndef RIPPER
13081  if (!is_local_id(lhs))
13082  yyerror("formal argument must be local variable");
13083 #endif
13084  shadowing_lvar(lhs);
13085  return lhs;
13086 }
13087 
13088 static int
13089 lvar_defined_gen(struct parser_params *parser, ID id)
13090 {
13091  return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
13092 }
13093 
13094 /* emacsen -*- hack */
13095 static long
13096 parser_encode_length(struct parser_params *parser, const char *name, long len)
13097 {
13098  long nlen;
13099 
13100  if (len > 5 && name[nlen = len - 5] == '-') {
13101  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
13102  return nlen;
13103  }
13104  if (len > 4 && name[nlen = len - 4] == '-') {
13105  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
13106  return nlen;
13107  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
13108  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
13109  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
13110  return nlen;
13111  }
13112  return len;
13113 }
13114 
13115 static void
13116 parser_set_encode(struct parser_params *parser, const char *name)
13117 {
13118  int idx = rb_enc_find_index(name);
13119  rb_encoding *enc;
13120  VALUE excargs[3];
13121 
13122  if (idx < 0) {
13123  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
13124  error:
13125  excargs[0] = rb_eArgError;
13126  excargs[2] = rb_make_backtrace();
13127  rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
13128  rb_exc_raise(rb_make_exception(3, excargs));
13129  }
13130  enc = rb_enc_from_index(idx);
13131  if (!rb_enc_asciicompat(enc)) {
13132  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13133  goto error;
13134  }
13135  parser->enc = enc;
13136 #ifndef RIPPER
13137  if (ruby_debug_lines) {
13138  long i, n = RARRAY_LEN(ruby_debug_lines);
13139  const VALUE *p = RARRAY_PTR(ruby_debug_lines);
13140  for (i = 0; i < n; ++i) {
13141  rb_enc_associate_index(*p, idx);
13142  }
13143  }
13144 #endif
13145 }
13146 
13147 static int
13149 {
13150  const char *p = lex_pbeg, *pend = lex_p - 1;
13151  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13152  while (p < pend) {
13153  if (!ISSPACE(*p)) return 0;
13154  p++;
13155  }
13156  return 1;
13157 }
13158 
13159 #ifndef RIPPER
13160 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13161 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13162 
13163 static void
13164 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13165 {
13166  if (!comment_at_top(parser)) {
13167  return;
13168  }
13169  parser_set_encode(parser, val);
13170 }
13171 
13172 static void
13173 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13174 {
13175  int *p = &parser->parser_token_info_enabled;
13176 
13177  switch (*val) {
13178  case 't': case 'T':
13179  if (strcasecmp(val, "true") == 0) {
13180  *p = TRUE;
13181  return;
13182  }
13183  break;
13184  case 'f': case 'F':
13185  if (strcasecmp(val, "false") == 0) {
13186  *p = FALSE;
13187  return;
13188  }
13189  break;
13190  }
13191  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13192 }
13193 
13195  const char *name;
13198 };
13199 
13200 static const struct magic_comment magic_comments[] = {
13203  {"warn_indent", parser_set_token_info},
13204 };
13205 #endif
13206 
13207 static const char *
13208 magic_comment_marker(const char *str, long len)
13209 {
13210  long i = 2;
13211 
13212  while (i < len) {
13213  switch (str[i]) {
13214  case '-':
13215  if (str[i-1] == '*' && str[i-2] == '-') {
13216  return str + i + 1;
13217  }
13218  i += 2;
13219  break;
13220  case '*':
13221  if (i + 1 >= len) return 0;
13222  if (str[i+1] != '-') {
13223  i += 4;
13224  }
13225  else if (str[i-1] != '-') {
13226  i += 2;
13227  }
13228  else {
13229  return str + i + 2;
13230  }
13231  break;
13232  default:
13233  i += 3;
13234  break;
13235  }
13236  }
13237  return 0;
13238 }
13239 
13240 static int
13241 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13242 {
13243  VALUE name = 0, val = 0;
13244  const char *beg, *end, *vbeg, *vend;
13245 #define str_copy(_s, _p, _n) ((_s) \
13246  ? (void)(rb_str_resize((_s), (_n)), \
13247  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13248  : (void)((_s) = STR_NEW((_p), (_n))))
13249 
13250  if (len <= 7) return FALSE;
13251  if (!(beg = magic_comment_marker(str, len))) return FALSE;
13252  if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13253  str = beg;
13254  len = end - beg - 3;
13255 
13256  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13257  while (len > 0) {
13258 #ifndef RIPPER
13259  const struct magic_comment *p = magic_comments;
13260 #endif
13261  char *s;
13262  int i;
13263  long n = 0;
13264 
13265  for (; len > 0 && *str; str++, --len) {
13266  switch (*str) {
13267  case '\'': case '"': case ':': case ';':
13268  continue;
13269  }
13270  if (!ISSPACE(*str)) break;
13271  }
13272  for (beg = str; len > 0; str++, --len) {
13273  switch (*str) {
13274  case '\'': case '"': case ':': case ';':
13275  break;
13276  default:
13277  if (ISSPACE(*str)) break;
13278  continue;
13279  }
13280  break;
13281  }
13282  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13283  if (!len) break;
13284  if (*str != ':') continue;
13285 
13286  do str++; while (--len > 0 && ISSPACE(*str));
13287  if (!len) break;
13288  if (*str == '"') {
13289  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13290  if (*str == '\\') {
13291  --len;
13292  ++str;
13293  }
13294  }
13295  vend = str;
13296  if (len) {
13297  --len;
13298  ++str;
13299  }
13300  }
13301  else {
13302  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13303  vend = str;
13304  }
13305  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13306 
13307  n = end - beg;
13308  str_copy(name, beg, n);
13309  s = RSTRING_PTR(name);
13310  for (i = 0; i < n; ++i) {
13311  if (s[i] == '-') s[i] = '_';
13312  }
13313 #ifndef RIPPER
13314  do {
13315  if (STRNCASECMP(p->name, s, n) == 0) {
13316  n = vend - vbeg;
13317  if (p->length) {
13318  n = (*p->length)(parser, vbeg, n);
13319  }
13320  str_copy(val, vbeg, n);
13321  (*p->func)(parser, s, RSTRING_PTR(val));
13322  break;
13323  }
13324  } while (++p < magic_comments + numberof(magic_comments));
13325 #else
13326  str_copy(val, vbeg, vend - vbeg);
13327  dispatch2(magic_comment, name, val);
13328 #endif
13329  }
13330 
13331  return TRUE;
13332 }
13333 
13334 static void
13335 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13336 {
13337  int sep = 0;
13338  const char *beg = str;
13339  VALUE s;
13340 
13341  for (;;) {
13342  if (send - str <= 6) return;
13343  switch (str[6]) {
13344  case 'C': case 'c': str += 6; continue;
13345  case 'O': case 'o': str += 5; continue;
13346  case 'D': case 'd': str += 4; continue;
13347  case 'I': case 'i': str += 3; continue;
13348  case 'N': case 'n': str += 2; continue;
13349  case 'G': case 'g': str += 1; continue;
13350  case '=': case ':':
13351  sep = 1;
13352  str += 6;
13353  break;
13354  default:
13355  str += 6;
13356  if (ISSPACE(*str)) break;
13357  continue;
13358  }
13359  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13360  }
13361  for (;;) {
13362  do {
13363  if (++str >= send) return;
13364  } while (ISSPACE(*str));
13365  if (sep) break;
13366  if (*str != '=' && *str != ':') return;
13367  sep = 1;
13368  str++;
13369  }
13370  beg = str;
13371  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13372  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13373  parser_set_encode(parser, RSTRING_PTR(s));
13374  rb_str_resize(s, 0);
13375 }
13376 
13377 static void
13379 {
13380  int c = nextc();
13381  switch (c) {
13382  case '#':
13383  if (peek('!')) parser->has_shebang = 1;
13384  break;
13385  case 0xef: /* UTF-8 BOM marker */
13386  if (lex_pend - lex_p >= 2 &&
13387  (unsigned char)lex_p[0] == 0xbb &&
13388  (unsigned char)lex_p[1] == 0xbf) {
13389  parser->enc = rb_utf8_encoding();
13390  lex_p += 2;
13391  lex_pbeg = lex_p;
13392  return;
13393  }
13394  break;
13395  case EOF:
13396  return;
13397  }
13398  pushback(c);
13399  parser->enc = rb_enc_get(lex_lastline);
13400 }
13401 
13402 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13403 #define IS_END() IS_lex_state(EXPR_END_ANY)
13404 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13405 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13406 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13407 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13408 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13409 
13410 #ifndef RIPPER
13411 #define ambiguous_operator(op, syn) ( \
13412  rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
13413  rb_warning0("even though it seems like "syn""))
13414 #else
13415 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13416 #endif
13417 #define warn_balanced(op, syn) ((void) \
13418  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13419  space_seen && !ISSPACE(c) && \
13420  (ambiguous_operator(op, syn), 0)))
13421 
13422 static int
13424 {
13425  register int c;
13426  int space_seen = 0;
13427  int cmd_state;
13428  enum lex_state_e last_state;
13429  rb_encoding *enc;
13430  int mb;
13431 #ifdef RIPPER
13432  int fallthru = FALSE;
13433 #endif
13434 
13435  if (lex_strterm) {
13436  int token;
13437  if (nd_type(lex_strterm) == NODE_HEREDOC) {
13438  token = here_document(lex_strterm);
13439  if (token == tSTRING_END) {
13440  lex_strterm = 0;
13441  lex_state = EXPR_END;
13442  }
13443  }
13444  else {
13445  token = parse_string(lex_strterm);
13446  if (token == tSTRING_END || token == tREGEXP_END) {
13448  lex_strterm = 0;
13449  lex_state = EXPR_END;
13450  }
13451  }
13452  return token;
13453  }
13454  cmd_state = command_start;
13455  command_start = FALSE;
13456  retry:
13457  last_state = lex_state;
13458  switch (c = nextc()) {
13459  case '\0': /* NUL */
13460  case '\004': /* ^D */
13461  case '\032': /* ^Z */
13462  case -1: /* end of script. */
13463  return 0;
13464 
13465  /* white spaces */
13466  case ' ': case '\t': case '\f': case '\r':
13467  case '\13': /* '\v' */
13468  space_seen = 1;
13469 #ifdef RIPPER
13470  while ((c = nextc())) {
13471  switch (c) {
13472  case ' ': case '\t': case '\f': case '\r':
13473  case '\13': /* '\v' */
13474  break;
13475  default:
13476  goto outofloop;
13477  }
13478  }
13479  outofloop:
13480  pushback(c);
13481  ripper_dispatch_scan_event(parser, tSP);
13482 #endif
13483  goto retry;
13484 
13485  case '#': /* it's a comment */
13486  /* no magic_comment in shebang line */
13487  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13488  if (comment_at_top(parser)) {
13489  set_file_encoding(parser, lex_p, lex_pend);
13490  }
13491  }
13492  lex_p = lex_pend;
13493 #ifdef RIPPER
13494  ripper_dispatch_scan_event(parser, tCOMMENT);
13495  fallthru = TRUE;
13496 #endif
13497  /* fall through */
13498  case '\n':
13499  if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT)) {
13500 #ifdef RIPPER
13501  if (!fallthru) {
13502  ripper_dispatch_scan_event(parser, tIGNORED_NL);
13503  }
13504  fallthru = FALSE;
13505 #endif
13506  goto retry;
13507  }
13508  while ((c = nextc())) {
13509  switch (c) {
13510  case ' ': case '\t': case '\f': case '\r':
13511  case '\13': /* '\v' */
13512  space_seen = 1;
13513  break;
13514  case '.': {
13515  if ((c = nextc()) != '.') {
13516  pushback(c);
13517  pushback('.');
13518  goto retry;
13519  }
13520  }
13521  default:
13522  --ruby_sourceline;
13524  case -1: /* EOF no decrement*/
13525  lex_goto_eol(parser);
13526 #ifdef RIPPER
13527  if (c != -1) {
13528  parser->tokp = lex_p;
13529  }
13530 #endif
13531  goto normal_newline;
13532  }
13533  }
13534  normal_newline:
13535  command_start = TRUE;
13536  lex_state = EXPR_BEG;
13537  return '\n';
13538 
13539  case '*':
13540  if ((c = nextc()) == '*') {
13541  if ((c = nextc()) == '=') {
13543  lex_state = EXPR_BEG;
13544  return tOP_ASGN;
13545  }
13546  pushback(c);
13547  if (IS_SPCARG(c)) {
13548  rb_warning0("`**' interpreted as argument prefix");
13549  c = tDSTAR;
13550  }
13551  else if (IS_BEG()) {
13552  c = tDSTAR;
13553  }
13554  else {
13555  warn_balanced("**", "argument prefix");
13556  c = tPOW;
13557  }
13558  }
13559  else {
13560  if (c == '=') {
13561  set_yylval_id('*');
13562  lex_state = EXPR_BEG;
13563  return tOP_ASGN;
13564  }
13565  pushback(c);
13566  if (IS_SPCARG(c)) {
13567  rb_warning0("`*' interpreted as argument prefix");
13568  c = tSTAR;
13569  }
13570  else if (IS_BEG()) {
13571  c = tSTAR;
13572  }
13573  else {
13574  warn_balanced("*", "argument prefix");
13575  c = '*';
13576  }
13577  }
13578  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13579  return c;
13580 
13581  case '!':
13582  c = nextc();
13583  if (IS_AFTER_OPERATOR()) {
13584  lex_state = EXPR_ARG;
13585  if (c == '@') {
13586  return '!';
13587  }
13588  }
13589  else {
13590  lex_state = EXPR_BEG;
13591  }
13592  if (c == '=') {
13593  return tNEQ;
13594  }
13595  if (c == '~') {
13596  return tNMATCH;
13597  }
13598  pushback(c);
13599  return '!';
13600 
13601  case '=':
13602  if (was_bol()) {
13603  /* skip embedded rd document */
13604  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13605 #ifdef RIPPER
13606  int first_p = TRUE;
13607 
13608  lex_goto_eol(parser);
13609  ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13610 #endif
13611  for (;;) {
13612  lex_goto_eol(parser);
13613 #ifdef RIPPER
13614  if (!first_p) {
13615  ripper_dispatch_scan_event(parser, tEMBDOC);
13616  }
13617  first_p = FALSE;
13618 #endif
13619  c = nextc();
13620  if (c == -1) {
13621  compile_error(PARSER_ARG "embedded document meets end of file");
13622  return 0;
13623  }
13624  if (c != '=') continue;
13625  if (strncmp(lex_p, "end", 3) == 0 &&
13626  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13627  break;
13628  }
13629  }
13630  lex_goto_eol(parser);
13631 #ifdef RIPPER
13632  ripper_dispatch_scan_event(parser, tEMBDOC_END);
13633 #endif
13634  goto retry;
13635  }
13636  }
13637 
13638  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13639  if ((c = nextc()) == '=') {
13640  if ((c = nextc()) == '=') {
13641  return tEQQ;
13642  }
13643  pushback(c);
13644  return tEQ;
13645  }
13646  if (c == '~') {
13647  return tMATCH;
13648  }
13649  else if (c == '>') {
13650  return tASSOC;
13651  }
13652  pushback(c);
13653  return '=';
13654 
13655  case '<':
13656  last_state = lex_state;
13657  c = nextc();
13658  if (c == '<' &&
13659  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13660  !IS_END() &&
13661  (!IS_ARG() || space_seen)) {
13662  int token = heredoc_identifier();
13663  if (token) return token;
13664  }
13665  if (IS_AFTER_OPERATOR()) {
13666  lex_state = EXPR_ARG;
13667  }
13668  else {
13669  if (IS_lex_state(EXPR_CLASS))
13670  command_start = TRUE;
13671  lex_state = EXPR_BEG;
13672  }
13673  if (c == '=') {
13674  if ((c = nextc()) == '>') {
13675  return tCMP;
13676  }
13677  pushback(c);
13678  return tLEQ;
13679  }
13680  if (c == '<') {
13681  if ((c = nextc()) == '=') {
13683  lex_state = EXPR_BEG;
13684  return tOP_ASGN;
13685  }
13686  pushback(c);
13687  warn_balanced("<<", "here document");
13688  return tLSHFT;
13689  }
13690  pushback(c);
13691  return '<';
13692 
13693  case '>':
13694  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13695  if ((c = nextc()) == '=') {
13696  return tGEQ;
13697  }
13698  if (c == '>') {
13699  if ((c = nextc()) == '=') {
13701  lex_state = EXPR_BEG;
13702  return tOP_ASGN;
13703  }
13704  pushback(c);
13705  return tRSHFT;
13706  }
13707  pushback(c);
13708  return '>';
13709 
13710  case '"':
13711  lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13712  return tSTRING_BEG;
13713 
13714  case '`':
13715  if (IS_lex_state(EXPR_FNAME)) {
13716  lex_state = EXPR_ENDFN;
13717  return c;
13718  }
13719  if (IS_lex_state(EXPR_DOT)) {
13720  if (cmd_state)
13721  lex_state = EXPR_CMDARG;
13722  else
13723  lex_state = EXPR_ARG;
13724  return c;
13725  }
13726  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13727  return tXSTRING_BEG;
13728 
13729  case '\'':
13730  lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13731  return tSTRING_BEG;
13732 
13733  case '?':
13734  if (IS_END()) {
13735  lex_state = EXPR_VALUE;
13736  return '?';
13737  }
13738  c = nextc();
13739  if (c == -1) {
13740  compile_error(PARSER_ARG "incomplete character syntax");
13741  return 0;
13742  }
13743  if (rb_enc_isspace(c, current_enc)) {
13744  if (!IS_ARG()) {
13745  int c2 = 0;
13746  switch (c) {
13747  case ' ':
13748  c2 = 's';
13749  break;
13750  case '\n':
13751  c2 = 'n';
13752  break;
13753  case '\t':
13754  c2 = 't';
13755  break;
13756  case '\v':
13757  c2 = 'v';
13758  break;
13759  case '\r':
13760  c2 = 'r';
13761  break;
13762  case '\f':
13763  c2 = 'f';
13764  break;
13765  }
13766  if (c2) {
13767  rb_warnI("invalid character syntax; use ?\\%c", c2);
13768  }
13769  }
13770  ternary:
13771  pushback(c);
13772  lex_state = EXPR_VALUE;
13773  return '?';
13774  }
13775  newtok();
13776  enc = current_enc;
13777  if (!parser_isascii()) {
13778  if (tokadd_mbchar(c) == -1) return 0;
13779  }
13780  else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13782  goto ternary;
13783  }
13784  else if (c == '\\') {
13785  if (peek('u')) {
13786  nextc();
13787  c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13788  if (0x80 <= c) {
13789  tokaddmbc(c, enc);
13790  }
13791  else {
13792  tokadd(c);
13793  }
13794  }
13795  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13796  nextc();
13797  if (tokadd_mbchar(c) == -1) return 0;
13798  }
13799  else {
13800  c = read_escape(0, &enc);
13801  tokadd(c);
13802  }
13803  }
13804  else {
13805  tokadd(c);
13806  }
13807  tokfix();
13808  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13809  lex_state = EXPR_END;
13810  return tCHAR;
13811 
13812  case '&':
13813  if ((c = nextc()) == '&') {
13814  lex_state = EXPR_BEG;
13815  if ((c = nextc()) == '=') {
13817  lex_state = EXPR_BEG;
13818  return tOP_ASGN;
13819  }
13820  pushback(c);
13821  return tANDOP;
13822  }
13823  else if (c == '=') {
13824  set_yylval_id('&');
13825  lex_state = EXPR_BEG;
13826  return tOP_ASGN;
13827  }
13828  pushback(c);
13829  if (IS_SPCARG(c)) {
13830  rb_warning0("`&' interpreted as argument prefix");
13831  c = tAMPER;
13832  }
13833  else if (IS_BEG()) {
13834  c = tAMPER;
13835  }
13836  else {
13837  warn_balanced("&", "argument prefix");
13838  c = '&';
13839  }
13840  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13841  return c;
13842 
13843  case '|':
13844  if ((c = nextc()) == '|') {
13845  lex_state = EXPR_BEG;
13846  if ((c = nextc()) == '=') {
13848  lex_state = EXPR_BEG;
13849  return tOP_ASGN;
13850  }
13851  pushback(c);
13852  return tOROP;
13853  }
13854  if (c == '=') {
13855  set_yylval_id('|');
13856  lex_state = EXPR_BEG;
13857  return tOP_ASGN;
13858  }
13859  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13860  pushback(c);
13861  return '|';
13862 
13863  case '+':
13864  c = nextc();
13865  if (IS_AFTER_OPERATOR()) {
13866  lex_state = EXPR_ARG;
13867  if (c == '@') {
13868  return tUPLUS;
13869  }
13870  pushback(c);
13871  return '+';
13872  }
13873  if (c == '=') {
13874  set_yylval_id('+');
13875  lex_state = EXPR_BEG;
13876  return tOP_ASGN;
13877  }
13878  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13879  lex_state = EXPR_BEG;
13880  pushback(c);
13881  if (c != -1 && ISDIGIT(c)) {
13882  c = '+';
13883  goto start_num;
13884  }
13885  return tUPLUS;
13886  }
13887  lex_state = EXPR_BEG;
13888  pushback(c);
13889  warn_balanced("+", "unary operator");
13890  return '+';
13891 
13892  case '-':
13893  c = nextc();
13894  if (IS_AFTER_OPERATOR()) {
13895  lex_state = EXPR_ARG;
13896  if (c == '@') {
13897  return tUMINUS;
13898  }
13899  pushback(c);
13900  return '-';
13901  }
13902  if (c == '=') {
13903  set_yylval_id('-');
13904  lex_state = EXPR_BEG;
13905  return tOP_ASGN;
13906  }
13907  if (c == '>') {
13908  lex_state = EXPR_ENDFN;
13909  return tLAMBDA;
13910  }
13911  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13912  lex_state = EXPR_BEG;
13913  pushback(c);
13914  if (c != -1 && ISDIGIT(c)) {
13915  return tUMINUS_NUM;
13916  }
13917  return tUMINUS;
13918  }
13919  lex_state = EXPR_BEG;
13920  pushback(c);
13921  warn_balanced("-", "unary operator");
13922  return '-';
13923 
13924  case '.':
13925  lex_state = EXPR_BEG;
13926  if ((c = nextc()) == '.') {
13927  if ((c = nextc()) == '.') {
13928  return tDOT3;
13929  }
13930  pushback(c);
13931  return tDOT2;
13932  }
13933  pushback(c);
13934  if (c != -1 && ISDIGIT(c)) {
13935  yyerror("no .<digit> floating literal anymore; put 0 before dot");
13936  }
13937  lex_state = EXPR_DOT;
13938  return '.';
13939 
13940  start_num:
13941  case '0': case '1': case '2': case '3': case '4':
13942  case '5': case '6': case '7': case '8': case '9':
13943  {
13944  int is_float, seen_point, seen_e, nondigit;
13945 
13946  is_float = seen_point = seen_e = nondigit = 0;
13947  lex_state = EXPR_END;
13948  newtok();
13949  if (c == '-' || c == '+') {
13950  tokadd(c);
13951  c = nextc();
13952  }
13953  if (c == '0') {
13954 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13955  int start = toklen();
13956  c = nextc();
13957  if (c == 'x' || c == 'X') {
13958  /* hexadecimal */
13959  c = nextc();
13960  if (c != -1 && ISXDIGIT(c)) {
13961  do {
13962  if (c == '_') {
13963  if (nondigit) break;
13964  nondigit = c;
13965  continue;
13966  }
13967  if (!ISXDIGIT(c)) break;
13968  nondigit = 0;
13969  tokadd(c);
13970  } while ((c = nextc()) != -1);
13971  }
13972  pushback(c);
13973  tokfix();
13974  if (toklen() == start) {
13975  no_digits();
13976  }
13977  else if (nondigit) goto trailing_uc;
13979  return tINTEGER;
13980  }
13981  if (c == 'b' || c == 'B') {
13982  /* binary */
13983  c = nextc();
13984  if (c == '0' || c == '1') {
13985  do {
13986  if (c == '_') {
13987  if (nondigit) break;
13988  nondigit = c;
13989  continue;
13990  }
13991  if (c != '0' && c != '1') break;
13992  nondigit = 0;
13993  tokadd(c);
13994  } while ((c = nextc()) != -1);
13995  }
13996  pushback(c);
13997  tokfix();
13998  if (toklen() == start) {
13999  no_digits();
14000  }
14001  else if (nondigit) goto trailing_uc;
14003  return tINTEGER;
14004  }
14005  if (c == 'd' || c == 'D') {
14006  /* decimal */
14007  c = nextc();
14008  if (c != -1 && ISDIGIT(c)) {
14009  do {
14010  if (c == '_') {
14011  if (nondigit) break;
14012  nondigit = c;
14013  continue;
14014  }
14015  if (!ISDIGIT(c)) break;
14016  nondigit = 0;
14017  tokadd(c);
14018  } while ((c = nextc()) != -1);
14019  }
14020  pushback(c);
14021  tokfix();
14022  if (toklen() == start) {
14023  no_digits();
14024  }
14025  else if (nondigit) goto trailing_uc;
14027  return tINTEGER;
14028  }
14029  if (c == '_') {
14030  /* 0_0 */
14031  goto octal_number;
14032  }
14033  if (c == 'o' || c == 'O') {
14034  /* prefixed octal */
14035  c = nextc();
14036  if (c == -1 || c == '_' || !ISDIGIT(c)) {
14037  no_digits();
14038  }
14039  }
14040  if (c >= '0' && c <= '7') {
14041  /* octal */
14042  octal_number:
14043  do {
14044  if (c == '_') {
14045  if (nondigit) break;
14046  nondigit = c;
14047  continue;
14048  }
14049  if (c < '0' || c > '9') break;
14050  if (c > '7') goto invalid_octal;
14051  nondigit = 0;
14052  tokadd(c);
14053  } while ((c = nextc()) != -1);
14054  if (toklen() > start) {
14055  pushback(c);
14056  tokfix();
14057  if (nondigit) goto trailing_uc;
14059  return tINTEGER;
14060  }
14061  if (nondigit) {
14062  pushback(c);
14063  goto trailing_uc;
14064  }
14065  }
14066  if (c > '7' && c <= '9') {
14067  invalid_octal:
14068  yyerror("Invalid octal digit");
14069  }
14070  else if (c == '.' || c == 'e' || c == 'E') {
14071  tokadd('0');
14072  }
14073  else {
14074  pushback(c);
14076  return tINTEGER;
14077  }
14078  }
14079 
14080  for (;;) {
14081  switch (c) {
14082  case '0': case '1': case '2': case '3': case '4':
14083  case '5': case '6': case '7': case '8': case '9':
14084  nondigit = 0;
14085  tokadd(c);
14086  break;
14087 
14088  case '.':
14089  if (nondigit) goto trailing_uc;
14090  if (seen_point || seen_e) {
14091  goto decode_num;
14092  }
14093  else {
14094  int c0 = nextc();
14095  if (c0 == -1 || !ISDIGIT(c0)) {
14096  pushback(c0);
14097  goto decode_num;
14098  }
14099  c = c0;
14100  }
14101  tokadd('.');
14102  tokadd(c);
14103  is_float++;
14104  seen_point++;
14105  nondigit = 0;
14106  break;
14107 
14108  case 'e':
14109  case 'E':
14110  if (nondigit) {
14111  pushback(c);
14112  c = nondigit;
14113  goto decode_num;
14114  }
14115  if (seen_e) {
14116  goto decode_num;
14117  }
14118  tokadd(c);
14119  seen_e++;
14120  is_float++;
14121  nondigit = c;
14122  c = nextc();
14123  if (c != '-' && c != '+') continue;
14124  tokadd(c);
14125  nondigit = c;
14126  break;
14127 
14128  case '_': /* `_' in number just ignored */
14129  if (nondigit) goto decode_num;
14130  nondigit = c;
14131  break;
14132 
14133  default:
14134  goto decode_num;
14135  }
14136  c = nextc();
14137  }
14138 
14139  decode_num:
14140  pushback(c);
14141  if (nondigit) {
14142  char tmp[30];
14143  trailing_uc:
14144  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14145  yyerror(tmp);
14146  }
14147  tokfix();
14148  if (is_float) {
14149  double d = strtod(tok(), 0);
14150  if (errno == ERANGE) {
14151  rb_warningS("Float %s out of range", tok());
14152  errno = 0;
14153  }
14155  return tFLOAT;
14156  }
14158  return tINTEGER;
14159  }
14160 
14161  case ')':
14162  case ']':
14163  paren_nest--;
14164  case '}':
14165  COND_LEXPOP();
14166  CMDARG_LEXPOP();
14167  if (c == ')')
14168  lex_state = EXPR_ENDFN;
14169  else
14170  lex_state = EXPR_ENDARG;
14171  if (c == '}') {
14172  if (!brace_nest--) c = tSTRING_DEND;
14173  }
14174  return c;
14175 
14176  case ':':
14177  c = nextc();
14178  if (c == ':') {
14179  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14180  lex_state = EXPR_BEG;
14181  return tCOLON3;
14182  }
14183  lex_state = EXPR_DOT;
14184  return tCOLON2;
14185  }
14186  if (IS_END() || ISSPACE(c)) {
14187  pushback(c);
14188  warn_balanced(":", "symbol literal");
14189  lex_state = EXPR_BEG;
14190  return ':';
14191  }
14192  switch (c) {
14193  case '\'':
14194  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14195  break;
14196  case '"':
14197  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14198  break;
14199  default:
14200  pushback(c);
14201  break;
14202  }
14203  lex_state = EXPR_FNAME;
14204  return tSYMBEG;
14205 
14206  case '/':
14207  if (IS_lex_state(EXPR_BEG_ANY)) {
14208  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14209  return tREGEXP_BEG;
14210  }
14211  if ((c = nextc()) == '=') {
14212  set_yylval_id('/');
14213  lex_state = EXPR_BEG;
14214  return tOP_ASGN;
14215  }
14216  pushback(c);
14217  if (IS_SPCARG(c)) {
14218  (void)arg_ambiguous();
14219  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14220  return tREGEXP_BEG;
14221  }
14222  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14223  warn_balanced("/", "regexp literal");
14224  return '/';
14225 
14226  case '^':
14227  if ((c = nextc()) == '=') {
14228  set_yylval_id('^');
14229  lex_state = EXPR_BEG;
14230  return tOP_ASGN;
14231  }
14232  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14233  pushback(c);
14234  return '^';
14235 
14236  case ';':
14237  lex_state = EXPR_BEG;
14238  command_start = TRUE;
14239  return ';';
14240 
14241  case ',':
14242  lex_state = EXPR_BEG;
14243  return ',';
14244 
14245  case '~':
14246  if (IS_AFTER_OPERATOR()) {
14247  if ((c = nextc()) != '@') {
14248  pushback(c);
14249  }
14250  lex_state = EXPR_ARG;
14251  }
14252  else {
14253  lex_state = EXPR_BEG;
14254  }
14255  return '~';
14256 
14257  case '(':
14258  if (IS_BEG()) {
14259  c = tLPAREN;
14260  }
14261  else if (IS_SPCARG(-1)) {
14262  c = tLPAREN_ARG;
14263  }
14264  paren_nest++;
14265  COND_PUSH(0);
14266  CMDARG_PUSH(0);
14267  lex_state = EXPR_BEG;
14268  return c;
14269 
14270  case '[':
14271  paren_nest++;
14272  if (IS_AFTER_OPERATOR()) {
14273  lex_state = EXPR_ARG;
14274  if ((c = nextc()) == ']') {
14275  if ((c = nextc()) == '=') {
14276  return tASET;
14277  }
14278  pushback(c);
14279  return tAREF;
14280  }
14281  pushback(c);
14282  return '[';
14283  }
14284  else if (IS_BEG()) {
14285  c = tLBRACK;
14286  }
14287  else if (IS_ARG() && space_seen) {
14288  c = tLBRACK;
14289  }
14290  lex_state = EXPR_BEG;
14291  COND_PUSH(0);
14292  CMDARG_PUSH(0);
14293  return c;
14294 
14295  case '{':
14296  ++brace_nest;
14297  if (lpar_beg && lpar_beg == paren_nest) {
14298  lex_state = EXPR_BEG;
14299  lpar_beg = 0;
14300  --paren_nest;
14301  COND_PUSH(0);
14302  CMDARG_PUSH(0);
14303  return tLAMBEG;
14304  }
14305  if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14306  c = '{'; /* block (primary) */
14307  else if (IS_lex_state(EXPR_ENDARG))
14308  c = tLBRACE_ARG; /* block (expr) */
14309  else
14310  c = tLBRACE; /* hash */
14311  COND_PUSH(0);
14312  CMDARG_PUSH(0);
14313  lex_state = EXPR_BEG;
14314  if (c != tLBRACE) command_start = TRUE;
14315  return c;
14316 
14317  case '\\':
14318  c = nextc();
14319  if (c == '\n') {
14320  space_seen = 1;
14321 #ifdef RIPPER
14322  ripper_dispatch_scan_event(parser, tSP);
14323 #endif
14324  goto retry; /* skip \\n */
14325  }
14326  pushback(c);
14327  return '\\';
14328 
14329  case '%':
14330  if (IS_lex_state(EXPR_BEG_ANY)) {
14331  int term;
14332  int paren;
14333 
14334  c = nextc();
14335  quotation:
14336  if (c == -1 || !ISALNUM(c)) {
14337  term = c;
14338  c = 'Q';
14339  }
14340  else {
14341  term = nextc();
14342  if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14343  yyerror("unknown type of %string");
14344  return 0;
14345  }
14346  }
14347  if (c == -1 || term == -1) {
14348  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14349  return 0;
14350  }
14351  paren = term;
14352  if (term == '(') term = ')';
14353  else if (term == '[') term = ']';
14354  else if (term == '{') term = '}';
14355  else if (term == '<') term = '>';
14356  else paren = 0;
14357 
14358  switch (c) {
14359  case 'Q':
14360  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14361  return tSTRING_BEG;
14362 
14363  case 'q':
14364  lex_strterm = NEW_STRTERM(str_squote, term, paren);
14365  return tSTRING_BEG;
14366 
14367  case 'W':
14368  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14369  do {c = nextc();} while (ISSPACE(c));
14370  pushback(c);
14371  return tWORDS_BEG;
14372 
14373  case 'w':
14374  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14375  do {c = nextc();} while (ISSPACE(c));
14376  pushback(c);
14377  return tQWORDS_BEG;
14378 
14379  case 'I':
14380  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14381  do {c = nextc();} while (ISSPACE(c));
14382  pushback(c);
14383  return tSYMBOLS_BEG;
14384 
14385  case 'i':
14386  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14387  do {c = nextc();} while (ISSPACE(c));
14388  pushback(c);
14389  return tQSYMBOLS_BEG;
14390 
14391  case 'x':
14392  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14393  return tXSTRING_BEG;
14394 
14395  case 'r':
14396  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14397  return tREGEXP_BEG;
14398 
14399  case 's':
14400  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14401  lex_state = EXPR_FNAME;
14402  return tSYMBEG;
14403 
14404  default:
14405  yyerror("unknown type of %string");
14406  return 0;
14407  }
14408  }
14409  if ((c = nextc()) == '=') {
14410  set_yylval_id('%');
14411  lex_state = EXPR_BEG;
14412  return tOP_ASGN;
14413  }
14414  if (IS_SPCARG(c)) {
14415  goto quotation;
14416  }
14417  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14418  pushback(c);
14419  warn_balanced("%%", "string literal");
14420  return '%';
14421 
14422  case '$':
14423  lex_state = EXPR_END;
14424  newtok();
14425  c = nextc();
14426  switch (c) {
14427  case '_': /* $_: last read line string */
14428  c = nextc();
14429  if (parser_is_identchar()) {
14430  tokadd('$');
14431  tokadd('_');
14432  break;
14433  }
14434  pushback(c);
14435  c = '_';
14436  /* fall through */
14437  case '~': /* $~: match-data */
14438  case '*': /* $*: argv */
14439  case '$': /* $$: pid */
14440  case '?': /* $?: last status */
14441  case '!': /* $!: error string */
14442  case '@': /* $@: error position */
14443  case '/': /* $/: input record separator */
14444  case '\\': /* $\: output record separator */
14445  case ';': /* $;: field separator */
14446  case ',': /* $,: output field separator */
14447  case '.': /* $.: last read line number */
14448  case '=': /* $=: ignorecase */
14449  case ':': /* $:: load path */
14450  case '<': /* $<: reading filename */
14451  case '>': /* $>: default output handle */
14452  case '\"': /* $": already loaded files */
14453  tokadd('$');
14454  tokadd(c);
14455  tokfix();
14457  return tGVAR;
14458 
14459  case '-':
14460  tokadd('$');
14461  tokadd(c);
14462  c = nextc();
14463  if (parser_is_identchar()) {
14464  if (tokadd_mbchar(c) == -1) return 0;
14465  }
14466  else {
14467  pushback(c);
14468  }
14469  gvar:
14470  tokfix();
14472  return tGVAR;
14473 
14474  case '&': /* $&: last match */
14475  case '`': /* $`: string before last match */
14476  case '\'': /* $': string after last match */
14477  case '+': /* $+: string matches last paren. */
14478  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14479  tokadd('$');
14480  tokadd(c);
14481  goto gvar;
14482  }
14484  return tBACK_REF;
14485 
14486  case '1': case '2': case '3':
14487  case '4': case '5': case '6':
14488  case '7': case '8': case '9':
14489  tokadd('$');
14490  do {
14491  tokadd(c);
14492  c = nextc();
14493  } while (c != -1 && ISDIGIT(c));
14494  pushback(c);
14495  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14496  tokfix();
14497  set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
14498  return tNTH_REF;
14499 
14500  default:
14501  if (!parser_is_identchar()) {
14502  pushback(c);
14503  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14504  return 0;
14505  }
14506  case '0':
14507  tokadd('$');
14508  }
14509  break;
14510 
14511  case '@':
14512  c = nextc();
14513  newtok();
14514  tokadd('@');
14515  if (c == '@') {
14516  tokadd('@');
14517  c = nextc();
14518  }
14519  if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14520  pushback(c);
14521  if (tokidx == 1) {
14522  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14523  }
14524  else {
14525  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14526  }
14527  return 0;
14528  }
14529  break;
14530 
14531  case '_':
14532  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14533  ruby__end__seen = 1;
14534  parser->eofp = Qtrue;
14535 #ifndef RIPPER
14536  return -1;
14537 #else
14538  lex_goto_eol(parser);
14539  ripper_dispatch_scan_event(parser, k__END__);
14540  return 0;
14541 #endif
14542  }
14543  newtok();
14544  break;
14545 
14546  default:
14547  if (!parser_is_identchar()) {
14548  rb_compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14549  goto retry;
14550  }
14551 
14552  newtok();
14553  break;
14554  }
14555 
14556  mb = ENC_CODERANGE_7BIT;
14557  do {
14558  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14559  if (tokadd_mbchar(c) == -1) return 0;
14560  c = nextc();
14561  } while (parser_is_identchar());
14562  switch (tok()[0]) {
14563  case '@': case '$':
14564  pushback(c);
14565  break;
14566  default:
14567  if ((c == '!' || c == '?') && !peek('=')) {
14568  tokadd(c);
14569  }
14570  else {
14571  pushback(c);
14572  }
14573  }
14574  tokfix();
14575 
14576  {
14577  int result = 0;
14578 
14579  last_state = lex_state;
14580  switch (tok()[0]) {
14581  case '$':
14582  lex_state = EXPR_END;
14583  result = tGVAR;
14584  break;
14585  case '@':
14586  lex_state = EXPR_END;
14587  if (tok()[1] == '@')
14588  result = tCVAR;
14589  else
14590  result = tIVAR;
14591  break;
14592 
14593  default:
14594  if (toklast() == '!' || toklast() == '?') {
14595  result = tFID;
14596  }
14597  else {
14598  if (IS_lex_state(EXPR_FNAME)) {
14599  if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14600  (!peek('=') || (peek_n('>', 1)))) {
14601  result = tIDENTIFIER;
14602  tokadd(c);
14603  tokfix();
14604  }
14605  else {
14606  pushback(c);
14607  }
14608  }
14609  if (result == 0 && ISUPPER(tok()[0])) {
14610  result = tCONSTANT;
14611  }
14612  else {
14613  result = tIDENTIFIER;
14614  }
14615  }
14616 
14617  if (IS_LABEL_POSSIBLE()) {
14618  if (IS_LABEL_SUFFIX(0)) {
14619  lex_state = EXPR_BEG;
14620  nextc();
14622  return tLABEL;
14623  }
14624  }
14625  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14626  const struct kwtable *kw;
14627 
14628  /* See if it is a reserved word. */
14629  kw = rb_reserved_word(tok(), toklen());
14630  if (kw) {
14631  enum lex_state_e state = lex_state;
14632  lex_state = kw->state;
14633  if (state == EXPR_FNAME) {
14635  return kw->id[0];
14636  }
14637  if (lex_state == EXPR_BEG) {
14638  command_start = TRUE;
14639  }
14640  if (kw->id[0] == keyword_do) {
14641  if (lpar_beg && lpar_beg == paren_nest) {
14642  lpar_beg = 0;
14643  --paren_nest;
14644  return keyword_do_LAMBDA;
14645  }
14646  if (COND_P()) return keyword_do_cond;
14647  if (CMDARG_P() && state != EXPR_CMDARG)
14648  return keyword_do_block;
14649  if (state & (EXPR_BEG | EXPR_ENDARG))
14650  return keyword_do_block;
14651  return keyword_do;
14652  }
14653  if (state & (EXPR_BEG | EXPR_VALUE))
14654  return kw->id[0];
14655  else {
14656  if (kw->id[0] != kw->id[1])
14657  lex_state = EXPR_BEG;
14658  return kw->id[1];
14659  }
14660  }
14661  }
14662 
14663  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14664  if (cmd_state) {
14665  lex_state = EXPR_CMDARG;
14666  }
14667  else {
14668  lex_state = EXPR_ARG;
14669  }
14670  }
14671  else if (lex_state == EXPR_FNAME) {
14672  lex_state = EXPR_ENDFN;
14673  }
14674  else {
14675  lex_state = EXPR_END;
14676  }
14677  }
14678  {
14679  ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14680 
14681  set_yylval_name(ident);
14682  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14683  is_local_id(ident) && lvar_defined(ident)) {
14684  lex_state = EXPR_END;
14685  }
14686  }
14687  return result;
14688  }
14689 }
14690 
14691 #if YYPURE
14692 static int
14693 yylex(void *lval, void *p)
14694 #else
14695 yylex(void *p)
14696 #endif
14697 {
14698  struct parser_params *parser = (struct parser_params*)p;
14699  int t;
14700 
14701 #if YYPURE
14702  parser->parser_yylval = lval;
14703  parser->parser_yylval->val = Qundef;
14704 #endif
14705  t = parser_yylex(parser);
14706 #ifdef RIPPER
14707  if (!NIL_P(parser->delayed)) {
14708  ripper_dispatch_delayed_token(parser, t);
14709  return t;
14710  }
14711  if (t != 0)
14712  ripper_dispatch_scan_event(parser, t);
14713 #endif
14714 
14715  return t;
14716 }
14717 
14718 #ifndef RIPPER
14719 static NODE*
14720 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14721 {
14722  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14724  return n;
14725 }
14726 
14727 static enum node_type
14728 nodetype(NODE *node) /* for debug */
14729 {
14730  return (enum node_type)nd_type(node);
14731 }
14732 
14733 static int
14735 {
14736  return nd_line(node);
14737 }
14738 
14739 static NODE*
14741 {
14742  if (node) {
14743  node = remove_begin(node);
14744  node->flags |= NODE_FL_NEWLINE;
14745  }
14746  return node;
14747 }
14748 
14749 static void
14750 fixpos(NODE *node, NODE *orig)
14751 {
14752  if (!node) return;
14753  if (!orig) return;
14754  if (orig == (NODE*)1) return;
14755  nd_set_line(node, nd_line(orig));
14756 }
14757 
14758 static void
14759 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14760 {
14761  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14762 }
14763 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14764 
14765 static void
14766 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14767 {
14768  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14769 }
14770 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14771 
14772 static NODE*
14773 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14774 {
14775  NODE *end, *h = head, *nd;
14776 
14777  if (tail == 0) return head;
14778 
14779  if (h == 0) return tail;
14780  switch (nd_type(h)) {
14781  case NODE_LIT:
14782  case NODE_STR:
14783  case NODE_SELF:
14784  case NODE_TRUE:
14785  case NODE_FALSE:
14786  case NODE_NIL:
14787  parser_warning(h, "unused literal ignored");
14788  return tail;
14789  default:
14790  h = end = NEW_BLOCK(head);
14791  end->nd_end = end;
14792  fixpos(end, head);
14793  head = end;
14794  break;
14795  case NODE_BLOCK:
14796  end = h->nd_end;
14797  break;
14798  }
14799 
14800  nd = end->nd_head;
14801  switch (nd_type(nd)) {
14802  case NODE_RETURN:
14803  case NODE_BREAK:
14804  case NODE_NEXT:
14805  case NODE_REDO:
14806  case NODE_RETRY:
14807  if (RTEST(ruby_verbose)) {
14808  parser_warning(tail, "statement not reached");
14809  }
14810  break;
14811 
14812  default:
14813  break;
14814  }
14815 
14816  if (nd_type(tail) != NODE_BLOCK) {
14817  tail = NEW_BLOCK(tail);
14818  tail->nd_end = tail;
14819  }
14820  end->nd_next = tail;
14821  h->nd_end = tail->nd_end;
14822  return head;
14823 }
14824 
14825 /* append item to the list */
14826 static NODE*
14827 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14828 {
14829  NODE *last;
14830 
14831  if (list == 0) return NEW_LIST(item);
14832  if (list->nd_next) {
14833  last = list->nd_next->nd_end;
14834  }
14835  else {
14836  last = list;
14837  }
14838 
14839  list->nd_alen += 1;
14840  last->nd_next = NEW_LIST(item);
14841  list->nd_next->nd_end = last->nd_next;
14842  return list;
14843 }
14844 
14845 /* concat two lists */
14846 static NODE*
14847 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14848 {
14849  NODE *last;
14850 
14851  if (head->nd_next) {
14852  last = head->nd_next->nd_end;
14853  }
14854  else {
14855  last = head;
14856  }
14857 
14858  head->nd_alen += tail->nd_alen;
14859  last->nd_next = tail;
14860  if (tail->nd_next) {
14861  head->nd_next->nd_end = tail->nd_next->nd_end;
14862  }
14863  else {
14864  head->nd_next->nd_end = tail;
14865  }
14866 
14867  return head;
14868 }
14869 
14870 static int
14872 {
14873  if (NIL_P(tail)) return 1;
14874  if (!rb_enc_compatible(head, tail)) {
14875  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14876  rb_enc_name(rb_enc_get(head)),
14877  rb_enc_name(rb_enc_get(tail)));
14878  rb_str_resize(head, 0);
14879  rb_str_resize(tail, 0);
14880  return 0;
14881  }
14882  rb_str_buf_append(head, tail);
14883  return 1;
14884 }
14885 
14886 /* concat two string literals */
14887 static NODE *
14889 {
14890  enum node_type htype;
14891  NODE *headlast;
14892  VALUE lit;
14893 
14894  if (!head) return tail;
14895  if (!tail) return head;
14896 
14897  htype = nd_type(head);
14898  if (htype == NODE_EVSTR) {
14899  NODE *node = NEW_DSTR(Qnil);
14900  head = list_append(node, head);
14901  htype = NODE_DSTR;
14902  }
14903  switch (nd_type(tail)) {
14904  case NODE_STR:
14905  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14906  nd_type(headlast) == NODE_STR) {
14907  htype = NODE_STR;
14908  lit = headlast->nd_lit;
14909  }
14910  else {
14911  lit = head->nd_lit;
14912  }
14913  if (htype == NODE_STR) {
14914  if (!literal_concat0(parser, lit, tail->nd_lit)) {
14915  error:
14916  rb_gc_force_recycle((VALUE)head);
14917  rb_gc_force_recycle((VALUE)tail);
14918  return 0;
14919  }
14920  rb_gc_force_recycle((VALUE)tail);
14921  }
14922  else {
14923  list_append(head, tail);
14924  }
14925  break;
14926 
14927  case NODE_DSTR:
14928  if (htype == NODE_STR) {
14929  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14930  goto error;
14931  tail->nd_lit = head->nd_lit;
14932  rb_gc_force_recycle((VALUE)head);
14933  head = tail;
14934  }
14935  else if (NIL_P(tail->nd_lit)) {
14936  append:
14937  head->nd_alen += tail->nd_alen - 1;
14938  head->nd_next->nd_end->nd_next = tail->nd_next;
14939  head->nd_next->nd_end = tail->nd_next->nd_end;
14940  rb_gc_force_recycle((VALUE)tail);
14941  }
14942  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14943  nd_type(headlast) == NODE_STR) {
14944  lit = headlast->nd_lit;
14945  if (!literal_concat0(parser, lit, tail->nd_lit))
14946  goto error;
14947  tail->nd_lit = Qnil;
14948  goto append;
14949  }
14950  else {
14951  nd_set_type(tail, NODE_ARRAY);
14952  tail->nd_head = NEW_STR(tail->nd_lit);
14953  list_concat(head, tail);
14954  }
14955  break;
14956 
14957  case NODE_EVSTR:
14958  if (htype == NODE_STR) {
14959  nd_set_type(head, NODE_DSTR);
14960  head->nd_alen = 1;
14961  }
14962  list_append(head, tail);
14963  break;
14964  }
14965  return head;
14966 }
14967 
14968 static NODE *
14969 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14970 {
14971  if (nd_type(node) == NODE_EVSTR) {
14972  node = list_append(NEW_DSTR(Qnil), node);
14973  }
14974  return node;
14975 }
14976 
14977 static NODE *
14978 new_evstr_gen(struct parser_params *parser, NODE *node)
14979 {
14980  NODE *head = node;
14981 
14982  if (node) {
14983  switch (nd_type(node)) {
14984  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14985  return node;
14986  }
14987  }
14988  return NEW_EVSTR(head);
14989 }
14990 
14991 static NODE *
14992 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14993 {
14994  value_expr(recv);
14995  value_expr(arg1);
14996  return NEW_CALL(recv, id, NEW_LIST(arg1));
14997 }
14998 
14999 static NODE *
15000 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
15001 {
15002  value_expr(recv);
15003  return NEW_CALL(recv, id, 0);
15004 }
15005 
15006 static NODE*
15007 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15008 {
15009  value_expr(node1);
15010  value_expr(node2);
15011  if (node1) {
15012  switch (nd_type(node1)) {
15013  case NODE_DREGX:
15014  case NODE_DREGX_ONCE:
15015  return NEW_MATCH2(node1, node2);
15016 
15017  case NODE_LIT:
15018  if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
15019  return NEW_MATCH2(node1, node2);
15020  }
15021  }
15022  }
15023 
15024  if (node2) {
15025  switch (nd_type(node2)) {
15026  case NODE_DREGX:
15027  case NODE_DREGX_ONCE:
15028  return NEW_MATCH3(node2, node1);
15029 
15030  case NODE_LIT:
15031  if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
15032  return NEW_MATCH3(node2, node1);
15033  }
15034  }
15035  }
15036 
15037  return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
15038 }
15039 
15040 static NODE*
15041 gettable_gen(struct parser_params *parser, ID id)
15042 {
15043  switch (id) {
15044  case keyword_self:
15045  return NEW_SELF();
15046  case keyword_nil:
15047  return NEW_NIL();
15048  case keyword_true:
15049  return NEW_TRUE();
15050  case keyword_false:
15051  return NEW_FALSE();
15052  case keyword__FILE__:
15055  case keyword__LINE__:
15056  return NEW_LIT(INT2FIX(tokline));
15057  case keyword__ENCODING__:
15059  }
15060  switch (id_type(id)) {
15061  case ID_LOCAL:
15062  if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
15063  if (local_id(id)) return NEW_LVAR(id);
15064  /* method call without arguments */
15065  return NEW_VCALL(id);
15066  case ID_GLOBAL:
15067  return NEW_GVAR(id);
15068  case ID_INSTANCE:
15069  return NEW_IVAR(id);
15070  case ID_CONST:
15071  return NEW_CONST(id);
15072  case ID_CLASS:
15073  return NEW_CVAR(id);
15074  }
15075  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15076  return 0;
15077 }
15078 #else /* !RIPPER */
15079 static int
15080 id_is_var_gen(struct parser_params *parser, ID id)
15081 {
15082  if (is_notop_id(id)) {
15083  switch (id & ID_SCOPE_MASK) {
15084  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
15085  return 1;
15086  case ID_LOCAL:
15087  if (dyna_in_block() && dvar_defined(id)) return 1;
15088  if (local_id(id)) return 1;
15089  /* method call without arguments */
15090  return 0;
15091  }
15092  }
15093  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15094  return 0;
15095 }
15096 #endif /* !RIPPER */
15097 
15098 #if PARSER_DEBUG
15099 static const char *
15100 lex_state_name(enum lex_state_e state)
15101 {
15102  static const char names[][12] = {
15103  "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG",
15104  "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS",
15105  "EXPR_VALUE",
15106  };
15107 
15108  if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
15109  return names[ffs(state)];
15110  return NULL;
15111 }
15112 #endif
15113 
15114 #ifdef RIPPER
15115 static VALUE
15116 assignable_gen(struct parser_params *parser, VALUE lhs)
15117 #else
15118 static NODE*
15119 assignable_gen(struct parser_params *parser, ID id, NODE *val)
15120 #endif
15121 {
15122 #ifdef RIPPER
15123  ID id = get_id(lhs);
15124 # define assignable_result(x) get_value(lhs)
15125 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
15126 #else
15127 # define assignable_result(x) (x)
15128 #endif
15129  if (!id) return assignable_result(0);
15130  switch (id) {
15131  case keyword_self:
15132  yyerror("Can't change the value of self");
15133  goto error;
15134  case keyword_nil:
15135  yyerror("Can't assign to nil");
15136  goto error;
15137  case keyword_true:
15138  yyerror("Can't assign to true");
15139  goto error;
15140  case keyword_false:
15141  yyerror("Can't assign to false");
15142  goto error;
15143  case keyword__FILE__:
15144  yyerror("Can't assign to __FILE__");
15145  goto error;
15146  case keyword__LINE__:
15147  yyerror("Can't assign to __LINE__");
15148  goto error;
15149  case keyword__ENCODING__:
15150  yyerror("Can't assign to __ENCODING__");
15151  goto error;
15152  }
15153  switch (id_type(id)) {
15154  case ID_LOCAL:
15155  if (dyna_in_block()) {
15156  if (dvar_curr(id)) {
15157  return assignable_result(NEW_DASGN_CURR(id, val));
15158  }
15159  else if (dvar_defined(id)) {
15160  return assignable_result(NEW_DASGN(id, val));
15161  }
15162  else if (local_id(id)) {
15163  return assignable_result(NEW_LASGN(id, val));
15164  }
15165  else {
15166  dyna_var(id);
15167  return assignable_result(NEW_DASGN_CURR(id, val));
15168  }
15169  }
15170  else {
15171  if (!local_id(id)) {
15172  local_var(id);
15173  }
15174  return assignable_result(NEW_LASGN(id, val));
15175  }
15176  break;
15177  case ID_GLOBAL:
15178  return assignable_result(NEW_GASGN(id, val));
15179  case ID_INSTANCE:
15180  return assignable_result(NEW_IASGN(id, val));
15181  case ID_CONST:
15182  if (!in_def && !in_single)
15183  return assignable_result(NEW_CDECL(id, val, 0));
15184  yyerror("dynamic constant assignment");
15185  break;
15186  case ID_CLASS:
15187  return assignable_result(NEW_CVASGN(id, val));
15188  default:
15189  compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15190  }
15191  error:
15192  return assignable_result(0);
15193 #undef assignable_result
15194 #undef parser_yyerror
15195 }
15196 
15197 static int
15199 {
15200  VALUE s;
15201  if (name == idUScore) return 1;
15202  if (!is_local_id(name)) return 0;
15203  s = rb_id2str(name);
15204  if (!s) return 0;
15205  return RSTRING_PTR(s)[0] == '_';
15206 }
15207 
15208 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15209 
15210 static ID
15211 shadowing_lvar_gen(struct parser_params *parser, ID name)
15212 {
15213  if (is_private_local_id(name)) return name;
15214  if (dyna_in_block()) {
15215  if (dvar_curr(name)) {
15216  yyerror("duplicated argument name");
15217  }
15218  else if (dvar_defined_get(name) || local_id(name)) {
15219  rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15220  vtable_add(lvtbl->vars, name);
15221  if (lvtbl->used) {
15223  }
15224  }
15225  }
15226  else {
15227  if (local_id(name)) {
15228  yyerror("duplicated argument name");
15229  }
15230  }
15231  return name;
15232 }
15233 
15234 static void
15235 new_bv_gen(struct parser_params *parser, ID name)
15236 {
15237  if (!name) return;
15238  if (!is_local_id(name)) {
15239  compile_error(PARSER_ARG "invalid local variable - %s",
15240  rb_id2name(name));
15241  return;
15242  }
15243  shadowing_lvar(name);
15244  dyna_var(name);
15245 }
15246 
15247 #ifndef RIPPER
15248 static NODE *
15249 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15250 {
15251  if (recv && nd_type(recv) == NODE_SELF)
15252  recv = (NODE *)1;
15253  return NEW_ATTRASGN(recv, tASET, idx);
15254 }
15255 
15256 static void
15257 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15258 {
15259  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15260  compile_error(PARSER_ARG "both block arg and actual block given");
15261  }
15262 }
15263 
15264 ID
15266 {
15267  id &= ~ID_SCOPE_MASK;
15268  id |= ID_ATTRSET;
15269  return id;
15270 }
15271 
15272 static NODE *
15273 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15274 {
15275  if (recv && nd_type(recv) == NODE_SELF)
15276  recv = (NODE *)1;
15277  return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15278 }
15279 
15280 static void
15282 {
15283  switch (nd_type(node)) {
15284  case NODE_NTH_REF:
15285  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15286  break;
15287  case NODE_BACK_REF:
15288  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15289  break;
15290  }
15291 }
15292 
15293 static NODE *
15294 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15295 {
15296  if (!node2) return node1;
15297  switch (nd_type(node1)) {
15298  case NODE_BLOCK_PASS:
15299  if (node1->nd_head)
15300  node1->nd_head = arg_concat(node1->nd_head, node2);
15301  else
15302  node1->nd_head = NEW_LIST(node2);
15303  return node1;
15304  case NODE_ARGSPUSH:
15305  if (nd_type(node2) != NODE_ARRAY) break;
15306  node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15307  nd_set_type(node1, NODE_ARGSCAT);
15308  return node1;
15309  case NODE_ARGSCAT:
15310  if (nd_type(node2) != NODE_ARRAY ||
15311  nd_type(node1->nd_body) != NODE_ARRAY) break;
15312  node1->nd_body = list_concat(node1->nd_body, node2);
15313  return node1;
15314  }
15315  return NEW_ARGSCAT(node1, node2);
15316 }
15317 
15318 static NODE *
15319 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15320 {
15321  if (!node1) return NEW_LIST(node2);
15322  switch (nd_type(node1)) {
15323  case NODE_ARRAY:
15324  return list_append(node1, node2);
15325  case NODE_BLOCK_PASS:
15326  node1->nd_head = arg_append(node1->nd_head, node2);
15327  return node1;
15328  case NODE_ARGSPUSH:
15329  node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15330  nd_set_type(node1, NODE_ARGSCAT);
15331  return node1;
15332  }
15333  return NEW_ARGSPUSH(node1, node2);
15334 }
15335 
15336 static NODE *
15338 {
15339  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15340  if (nd_type(node) == NODE_ARRAY) return node;
15341  return 0;
15342 }
15343 
15344 static NODE *
15345 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15346 {
15347  if (!lhs) return 0;
15348 
15349  switch (nd_type(lhs)) {
15350  case NODE_GASGN:
15351  case NODE_IASGN:
15352  case NODE_IASGN2:
15353  case NODE_LASGN:
15354  case NODE_DASGN:
15355  case NODE_DASGN_CURR:
15356  case NODE_MASGN:
15357  case NODE_CDECL:
15358  case NODE_CVASGN:
15359  lhs->nd_value = rhs;
15360  break;
15361 
15362  case NODE_ATTRASGN:
15363  case NODE_CALL:
15364  lhs->nd_args = arg_append(lhs->nd_args, rhs);
15365  break;
15366 
15367  default:
15368  /* should not happen */
15369  break;
15370  }
15371 
15372  return lhs;
15373 }
15374 
15375 static int
15376 value_expr_gen(struct parser_params *parser, NODE *node)
15377 {
15378  int cond = 0;
15379 
15380  if (!node) {
15381  rb_warning0("empty expression");
15382  }
15383  while (node) {
15384  switch (nd_type(node)) {
15385  case NODE_DEFN:
15386  case NODE_DEFS:
15387  parser_warning(node, "void value expression");
15388  return FALSE;
15389 
15390  case NODE_RETURN:
15391  case NODE_BREAK:
15392  case NODE_NEXT:
15393  case NODE_REDO:
15394  case NODE_RETRY:
15395  if (!cond) yyerror("void value expression");
15396  /* or "control never reach"? */
15397  return FALSE;
15398 
15399  case NODE_BLOCK:
15400  while (node->nd_next) {
15401  node = node->nd_next;
15402  }
15403  node = node->nd_head;
15404  break;
15405 
15406  case NODE_BEGIN:
15407  node = node->nd_body;
15408  break;
15409 
15410  case NODE_IF:
15411  if (!node->nd_body) {
15412  node = node->nd_else;
15413  break;
15414  }
15415  else if (!node->nd_else) {
15416  node = node->nd_body;
15417  break;
15418  }
15419  if (!value_expr(node->nd_body)) return FALSE;
15420  node = node->nd_else;
15421  break;
15422 
15423  case NODE_AND:
15424  case NODE_OR:
15425  cond = 1;
15426  node = node->nd_2nd;
15427  break;
15428 
15429  default:
15430  return TRUE;
15431  }
15432  }
15433 
15434  return TRUE;
15435 }
15436 
15437 static void
15438 void_expr_gen(struct parser_params *parser, NODE *node)
15439 {
15440  const char *useless = 0;
15441 
15442  if (!RTEST(ruby_verbose)) return;
15443 
15444  if (!node) return;
15445  switch (nd_type(node)) {
15446  case NODE_CALL:
15447  switch (node->nd_mid) {
15448  case '+':
15449  case '-':
15450  case '*':
15451  case '/':
15452  case '%':
15453  case tPOW:
15454  case tUPLUS:
15455  case tUMINUS:
15456  case '|':
15457  case '^':
15458  case '&':
15459  case tCMP:
15460  case '>':
15461  case tGEQ:
15462  case '<':
15463  case tLEQ:
15464  case tEQ:
15465  case tNEQ:
15466  useless = rb_id2name(node->nd_mid);
15467  break;
15468  }
15469  break;
15470 
15471  case NODE_LVAR:
15472  case NODE_DVAR:
15473  case NODE_GVAR:
15474  case NODE_IVAR:
15475  case NODE_CVAR:
15476  case NODE_NTH_REF:
15477  case NODE_BACK_REF:
15478  useless = "a variable";
15479  break;
15480  case NODE_CONST:
15481  useless = "a constant";
15482  break;
15483  case NODE_LIT:
15484  case NODE_STR:
15485  case NODE_DSTR:
15486  case NODE_DREGX:
15487  case NODE_DREGX_ONCE:
15488  useless = "a literal";
15489  break;
15490  case NODE_COLON2:
15491  case NODE_COLON3:
15492  useless = "::";
15493  break;
15494  case NODE_DOT2:
15495  useless = "..";
15496  break;
15497  case NODE_DOT3:
15498  useless = "...";
15499  break;
15500  case NODE_SELF:
15501  useless = "self";
15502  break;
15503  case NODE_NIL:
15504  useless = "nil";
15505  break;
15506  case NODE_TRUE:
15507  useless = "true";
15508  break;
15509  case NODE_FALSE:
15510  useless = "false";
15511  break;
15512  case NODE_DEFINED:
15513  useless = "defined?";
15514  break;
15515  }
15516 
15517  if (useless) {
15518  int line = ruby_sourceline;
15519 
15520  ruby_sourceline = nd_line(node);
15521  rb_warnS("possibly useless use of %s in void context", useless);
15522  ruby_sourceline = line;
15523  }
15524 }
15525 
15526 static void
15527 void_stmts_gen(struct parser_params *parser, NODE *node)
15528 {
15529  if (!RTEST(ruby_verbose)) return;
15530  if (!node) return;
15531  if (nd_type(node) != NODE_BLOCK) return;
15532 
15533  for (;;) {
15534  if (!node->nd_next) return;
15535  void_expr0(node->nd_head);
15536  node = node->nd_next;
15537  }
15538 }
15539 
15540 static NODE *
15542 {
15543  NODE **n = &node, *n1 = node;
15544  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15545  *n = n1 = n1->nd_body;
15546  }
15547  return node;
15548 }
15549 
15550 static void
15551 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15552 {
15553  NODE *node = *body;
15554 
15555  if (!node) {
15556  *body = NEW_NIL();
15557  return;
15558  }
15559 #define subnodes(n1, n2) \
15560  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15561  (!node->n2) ? (body = &node->n1, 1) : \
15562  (reduce_nodes(&node->n1), body = &node->n2, 1))
15563 
15564  while (node) {
15565  int newline = (int)(node->flags & NODE_FL_NEWLINE);
15566  switch (nd_type(node)) {
15567  end:
15568  case NODE_NIL:
15569  *body = 0;
15570  return;
15571  case NODE_RETURN:
15572  *body = node = node->nd_stts;
15573  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15574  continue;
15575  case NODE_BEGIN:
15576  *body = node = node->nd_body;
15577  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15578  continue;
15579  case NODE_BLOCK:
15580  body = &node->nd_end->nd_head;
15581  break;
15582  case NODE_IF:
15583  if (subnodes(nd_body, nd_else)) break;
15584  return;
15585  case NODE_CASE:
15586  body = &node->nd_body;
15587  break;
15588  case NODE_WHEN:
15589  if (!subnodes(nd_body, nd_next)) goto end;
15590  break;
15591  case NODE_ENSURE:
15592  if (!subnodes(nd_head, nd_resq)) goto end;
15593  break;
15594  case NODE_RESCUE:
15595  if (node->nd_else) {
15596  body = &node->nd_resq;
15597  break;
15598  }
15599  if (!subnodes(nd_head, nd_resq)) goto end;
15600  break;
15601  default:
15602  return;
15603  }
15604  node = *body;
15605  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15606  }
15607 
15608 #undef subnodes
15609 }
15610 
15611 static int
15613 {
15614  if (!node) return 1;
15615  switch (nd_type(node)) {
15616  case NODE_HASH:
15617  if (!(node = node->nd_head)) break;
15618  case NODE_ARRAY:
15619  do {
15620  if (!is_static_content(node->nd_head)) return 0;
15621  } while ((node = node->nd_next) != 0);
15622  case NODE_LIT:
15623  case NODE_STR:
15624  case NODE_NIL:
15625  case NODE_TRUE:
15626  case NODE_FALSE:
15627  case NODE_ZARRAY:
15628  break;
15629  default:
15630  return 0;
15631  }
15632  return 1;
15633 }
15634 
15635 static int
15636 assign_in_cond(struct parser_params *parser, NODE *node)
15637 {
15638  switch (nd_type(node)) {
15639  case NODE_MASGN:
15640  yyerror("multiple assignment in conditional");
15641  return 1;
15642 
15643  case NODE_LASGN:
15644  case NODE_DASGN:
15645  case NODE_DASGN_CURR:
15646  case NODE_GASGN:
15647  case NODE_IASGN:
15648  break;
15649 
15650  default:
15651  return 0;
15652  }
15653 
15654  if (!node->nd_value) return 1;
15655  if (is_static_content(node->nd_value)) {
15656  /* reports always */
15657  parser_warn(node->nd_value, "found = in conditional, should be ==");
15658  }
15659  return 1;
15660 }
15661 
15662 static void
15663 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15664 {
15665  if (!e_option_supplied(parser)) parser_warn(node, str);
15666 }
15667 
15668 static void
15669 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15670 {
15671  if (!e_option_supplied(parser)) parser_warning(node, str);
15672 }
15673 
15674 static void
15675 fixup_nodes(NODE **rootnode)
15676 {
15677  NODE *node, *next, *head;
15678 
15679  for (node = *rootnode; node; node = next) {
15680  enum node_type type;
15681  VALUE val;
15682 
15683  next = node->nd_next;
15684  head = node->nd_head;
15685  rb_gc_force_recycle((VALUE)node);
15686  *rootnode = next;
15687  switch (type = nd_type(head)) {
15688  case NODE_DOT2:
15689  case NODE_DOT3:
15690  val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15691  type == NODE_DOT3);
15692  rb_gc_force_recycle((VALUE)head->nd_beg);
15693  rb_gc_force_recycle((VALUE)head->nd_end);
15694  nd_set_type(head, NODE_LIT);
15695  head->nd_lit = val;
15696  break;
15697  default:
15698  break;
15699  }
15700  }
15701 }
15702 
15703 static NODE *cond0(struct parser_params*,NODE*);
15704 
15705 static NODE*
15706 range_op(struct parser_params *parser, NODE *node)
15707 {
15708  enum node_type type;
15709 
15710  if (node == 0) return 0;
15711 
15712  type = nd_type(node);
15713  value_expr(node);
15714  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15715  warn_unless_e_option(parser, node, "integer literal in conditional range");
15716  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15717  }
15718  return cond0(parser, node);
15719 }
15720 
15721 static int
15723 {
15724  if (!node) return 1; /* same as NODE_NIL */
15725  switch (nd_type(node)) {
15726  case NODE_LIT:
15727  case NODE_STR:
15728  case NODE_DSTR:
15729  case NODE_EVSTR:
15730  case NODE_DREGX:
15731  case NODE_DREGX_ONCE:
15732  case NODE_DSYM:
15733  return 2;
15734  case NODE_TRUE:
15735  case NODE_FALSE:
15736  case NODE_NIL:
15737  return 1;
15738  }
15739  return 0;
15740 }
15741 
15742 static NODE*
15743 cond0(struct parser_params *parser, NODE *node)
15744 {
15745  if (node == 0) return 0;
15746  assign_in_cond(parser, node);
15747 
15748  switch (nd_type(node)) {
15749  case NODE_DSTR:
15750  case NODE_EVSTR:
15751  case NODE_STR:
15752  rb_warn0("string literal in condition");
15753  break;
15754 
15755  case NODE_DREGX:
15756  case NODE_DREGX_ONCE:
15757  warning_unless_e_option(parser, node, "regex literal in condition");
15758  return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15759 
15760  case NODE_AND:
15761  case NODE_OR:
15762  node->nd_1st = cond0(parser, node->nd_1st);
15763  node->nd_2nd = cond0(parser, node->nd_2nd);
15764  break;
15765 
15766  case NODE_DOT2:
15767  case NODE_DOT3:
15768  node->nd_beg = range_op(parser, node->nd_beg);
15769  node->nd_end = range_op(parser, node->nd_end);
15770  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15771  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15772  if (!e_option_supplied(parser)) {
15773  int b = literal_node(node->nd_beg);
15774  int e = literal_node(node->nd_end);
15775  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15776  parser_warn(node, "range literal in condition");
15777  }
15778  }
15779  break;
15780 
15781  case NODE_DSYM:
15782  parser_warning(node, "literal in condition");
15783  break;
15784 
15785  case NODE_LIT:
15786  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
15787  warn_unless_e_option(parser, node, "regex literal in condition");
15788  nd_set_type(node, NODE_MATCH);
15789  }
15790  else {
15791  parser_warning(node, "literal in condition");
15792  }
15793  default:
15794  break;
15795  }
15796  return node;
15797 }
15798 
15799 static NODE*
15800 cond_gen(struct parser_params *parser, NODE *node)
15801 {
15802  if (node == 0) return 0;
15803  return cond0(parser, node);
15804 }
15805 
15806 static NODE*
15807 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15808 {
15809  value_expr(left);
15810  if (left && (enum node_type)nd_type(left) == type) {
15811  NODE *node = left, *second;
15812  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15813  node = second;
15814  }
15815  node->nd_2nd = NEW_NODE(type, second, right, 0);
15816  return left;
15817  }
15818  return NEW_NODE(type, left, right, 0);
15819 }
15820 
15821 static void
15822 no_blockarg(struct parser_params *parser, NODE *node)
15823 {
15824  if (node && nd_type(node) == NODE_BLOCK_PASS) {
15825  compile_error(PARSER_ARG "block argument should not be given");
15826  }
15827 }
15828 
15829 static NODE *
15830 ret_args_gen(struct parser_params *parser, NODE *node)
15831 {
15832  if (node) {
15833  no_blockarg(parser, node);
15834  if (nd_type(node) == NODE_ARRAY) {
15835  if (node->nd_next == 0) {
15836  node = node->nd_head;
15837  }
15838  else {
15839  nd_set_type(node, NODE_VALUES);
15840  }
15841  }
15842  }
15843  return node;
15844 }
15845 
15846 static NODE *
15847 new_yield_gen(struct parser_params *parser, NODE *node)
15848 {
15849  if (node) no_blockarg(parser, node);
15850 
15851  return NEW_YIELD(node);
15852 }
15853 
15854 static NODE*
15856 {
15857  switch (TYPE(node->nd_lit)) {
15858  case T_FIXNUM:
15859  node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15860  break;
15861  case T_BIGNUM:
15862  node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15863  break;
15864  case T_FLOAT:
15865 #if USE_FLONUM
15866  if (FLONUM_P(node->nd_lit)) {
15867  node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
15868  }
15869  else {
15870  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15871  }
15872 #else
15873  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15874 #endif
15875  break;
15876  default:
15877  break;
15878  }
15879  return node;
15880 }
15881 
15882 static NODE *
15883 arg_blk_pass(NODE *node1, NODE *node2)
15884 {
15885  if (node2) {
15886  node2->nd_head = node1;
15887  return node2;
15888  }
15889  return node1;
15890 }
15891 
15892 
15893 static NODE*
15894 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
15895 {
15896  int saved_line = ruby_sourceline;
15897  struct rb_args_info *args = tail->nd_ainfo;
15898 
15899  args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0;
15900  args->pre_init = m ? m->nd_next : 0;
15901 
15902  args->post_args_num = p ? rb_long2int(p->nd_plen) : 0;
15903  args->post_init = p ? p->nd_next : 0;
15904  args->first_post_arg = p ? p->nd_pid : 0;
15905 
15906  args->rest_arg = r;
15907 
15908  args->opt_args = o;
15909 
15910  ruby_sourceline = saved_line;
15911 
15912  return tail;
15913 }
15914 
15915 static NODE*
15916 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
15917 {
15918  int saved_line = ruby_sourceline;
15919  struct rb_args_info *args;
15920  NODE *kw_rest_arg = 0;
15921  NODE *node;
15922 
15923  args = ALLOC(struct rb_args_info);
15924  MEMZERO(args, struct rb_args_info, 1);
15925  node = NEW_NODE(NODE_ARGS, 0, 0, args);
15926 
15927  args->block_arg = b;
15928  args->kw_args = k;
15929  if (k && !kr) kr = internal_id();
15930  if (kr) {
15931  arg_var(kr);
15932  kw_rest_arg = NEW_DVAR(kr);
15933  }
15934  args->kw_rest_arg = kw_rest_arg;
15935 
15936  ruby_sourceline = saved_line;
15937  return node;
15938 }
15939 
15940 static NODE*
15941 dsym_node_gen(struct parser_params *parser, NODE *node)
15942 {
15943  VALUE lit;
15944 
15945  if (!node) {
15946  return NEW_LIT(ID2SYM(idNULL));
15947  }
15948 
15949  switch (nd_type(node)) {
15950  case NODE_DSTR:
15951  nd_set_type(node, NODE_DSYM);
15952  break;
15953  case NODE_STR:
15954  lit = node->nd_lit;
15955  node->nd_lit = ID2SYM(rb_intern_str(lit));
15956  nd_set_type(node, NODE_LIT);
15957  break;
15958  default:
15959  node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
15960  break;
15961  }
15962  return node;
15963 }
15964 #endif /* !RIPPER */
15965 
15966 #ifndef RIPPER
15967 static NODE *
15968 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
15969 {
15970  NODE *asgn;
15971 
15972  if (lhs) {
15973  ID vid = lhs->nd_vid;
15974  if (op == tOROP) {
15975  lhs->nd_value = rhs;
15976  asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
15977  if (is_asgn_or_id(vid)) {
15978  asgn->nd_aid = vid;
15979  }
15980  }
15981  else if (op == tANDOP) {
15982  lhs->nd_value = rhs;
15983  asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
15984  }
15985  else {
15986  asgn = lhs;
15987  asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
15988  }
15989  }
15990  else {
15991  asgn = NEW_BEGIN(0);
15992  }
15993  return asgn;
15994 }
15995 
15996 static NODE *
15997 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
15998 {
15999  NODE *asgn;
16000 
16001  if (op == tOROP) {
16002  op = 0;
16003  }
16004  else if (op == tANDOP) {
16005  op = 1;
16006  }
16007  asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
16008  fixpos(asgn, lhs);
16009  return asgn;
16010 }
16011 
16012 static NODE *
16013 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16014 {
16015  NODE *asgn;
16016 
16017  if (op == tOROP) {
16018  op = 0;
16019  }
16020  else if (op == tANDOP) {
16021  op = 1;
16022  }
16023  if (lhs) {
16024  asgn = NEW_OP_CDECL(lhs, op, rhs);
16025  }
16026  else {
16027  asgn = NEW_BEGIN(0);
16028  }
16029  fixpos(asgn, lhs);
16030  return asgn;
16031 }
16032 #else
16033 static VALUE
16034 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
16035 {
16036  return dispatch3(opassign, lhs, op, rhs);
16037 }
16038 
16039 static VALUE
16040 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
16041 {
16042  VALUE recv = dispatch3(field, lhs, type, attr);
16043  return dispatch3(opassign, recv, op, rhs);
16044 }
16045 #endif
16046 
16047 static void
16048 warn_unused_var(struct parser_params *parser, struct local_vars *local)
16049 {
16050  int i, cnt;
16051  ID *v, *u;
16052 
16053  if (!local->used) return;
16054  v = local->vars->tbl;
16055  u = local->used->tbl;
16056  cnt = local->used->pos;
16057  if (cnt != local->vars->pos) {
16058  rb_bug("local->used->pos != local->vars->pos");
16059  }
16060  for (i = 0; i < cnt; ++i) {
16061  if (!v[i] || (u[i] & LVAR_USED)) continue;
16062  if (is_private_local_id(v[i])) continue;
16063  rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
16064  }
16065 }
16066 
16067 static void
16068 local_push_gen(struct parser_params *parser, int inherit_dvars)
16069 {
16070  struct local_vars *local;
16071 
16072  local = ALLOC(struct local_vars);
16073  local->prev = lvtbl;
16074  local->args = vtable_alloc(0);
16075  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
16076  local->used = !(inherit_dvars &&
16078  RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
16079  lvtbl = local;
16080 }
16081 
16082 static void
16084 {
16085  struct local_vars *local = lvtbl->prev;
16086  if (lvtbl->used) {
16087  warn_unused_var(parser, lvtbl);
16088  vtable_free(lvtbl->used);
16089  }
16090  vtable_free(lvtbl->args);
16091  vtable_free(lvtbl->vars);
16092  xfree(lvtbl);
16093  lvtbl = local;
16094 }
16095 
16096 #ifndef RIPPER
16097 static ID*
16098 vtable_tblcpy(ID *buf, const struct vtable *src)
16099 {
16100  int i, cnt = vtable_size(src);
16101 
16102  if (cnt > 0) {
16103  buf[0] = cnt;
16104  for (i = 0; i < cnt; i++) {
16105  buf[i] = src->tbl[i];
16106  }
16107  return buf;
16108  }
16109  return 0;
16110 }
16111 
16112 static ID*
16114 {
16115  int cnt = vtable_size(lvtbl->args) + vtable_size(lvtbl->vars);
16116  ID *buf;
16117 
16118  if (cnt <= 0) return 0;
16119  buf = ALLOC_N(ID, cnt + 1);
16120  vtable_tblcpy(buf+1, lvtbl->args);
16121  vtable_tblcpy(buf+vtable_size(lvtbl->args)+1, lvtbl->vars);
16122  buf[0] = cnt;
16123  return buf;
16124 }
16125 #endif
16126 
16127 static int
16128 arg_var_gen(struct parser_params *parser, ID id)
16129 {
16130  vtable_add(lvtbl->args, id);
16131  return vtable_size(lvtbl->args) - 1;
16132 }
16133 
16134 static int
16135 local_var_gen(struct parser_params *parser, ID id)
16136 {
16137  vtable_add(lvtbl->vars, id);
16138  if (lvtbl->used) {
16140  }
16141  return vtable_size(lvtbl->vars) - 1;
16142 }
16143 
16144 static int
16145 local_id_gen(struct parser_params *parser, ID id)
16146 {
16147  struct vtable *vars, *args, *used;
16148 
16149  vars = lvtbl->vars;
16150  args = lvtbl->args;
16151  used = lvtbl->used;
16152 
16153  while (vars && POINTER_P(vars->prev)) {
16154  vars = vars->prev;
16155  args = args->prev;
16156  if (used) used = used->prev;
16157  }
16158 
16159  if (vars && vars->prev == DVARS_INHERIT) {
16160  return rb_local_defined(id);
16161  }
16162  else if (vtable_included(args, id)) {
16163  return 1;
16164  }
16165  else {
16166  int i = vtable_included(vars, id);
16167  if (i && used) used->tbl[i-1] |= LVAR_USED;
16168  return i != 0;
16169  }
16170 }
16171 
16172 static const struct vtable *
16174 {
16175  lvtbl->args = vtable_alloc(lvtbl->args);
16176  lvtbl->vars = vtable_alloc(lvtbl->vars);
16177  if (lvtbl->used) {
16178  lvtbl->used = vtable_alloc(lvtbl->used);
16179  }
16180  return lvtbl->args;
16181 }
16182 
16183 static void
16184 dyna_pop_1(struct parser_params *parser)
16185 {
16186  struct vtable *tmp;
16187 
16188  if ((tmp = lvtbl->used) != 0) {
16189  warn_unused_var(parser, lvtbl);
16190  lvtbl->used = lvtbl->used->prev;
16191  vtable_free(tmp);
16192  }
16193  tmp = lvtbl->args;
16194  lvtbl->args = lvtbl->args->prev;
16195  vtable_free(tmp);
16196  tmp = lvtbl->vars;
16197  lvtbl->vars = lvtbl->vars->prev;
16198  vtable_free(tmp);
16199 }
16200 
16201 static void
16202 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16203 {
16204  while (lvtbl->args != lvargs) {
16205  dyna_pop_1(parser);
16206  if (!lvtbl->args) {
16207  struct local_vars *local = lvtbl->prev;
16208  xfree(lvtbl);
16209  lvtbl = local;
16210  }
16211  }
16212  dyna_pop_1(parser);
16213 }
16214 
16215 static int
16217 {
16218  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16219 }
16220 
16221 static int
16222 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16223 {
16224  struct vtable *vars, *args, *used;
16225  int i;
16226 
16227  args = lvtbl->args;
16228  vars = lvtbl->vars;
16229  used = lvtbl->used;
16230 
16231  while (POINTER_P(vars)) {
16232  if (vtable_included(args, id)) {
16233  return 1;
16234  }
16235  if ((i = vtable_included(vars, id)) != 0) {
16236  if (used) used->tbl[i-1] |= LVAR_USED;
16237  return 1;
16238  }
16239  args = args->prev;
16240  vars = vars->prev;
16241  if (get) used = 0;
16242  if (used) used = used->prev;
16243  }
16244 
16245  if (vars == DVARS_INHERIT) {
16246  return rb_dvar_defined(id);
16247  }
16248 
16249  return 0;
16250 }
16251 
16252 static int
16253 dvar_curr_gen(struct parser_params *parser, ID id)
16254 {
16255  return (vtable_included(lvtbl->args, id) ||
16256  vtable_included(lvtbl->vars, id));
16257 }
16258 
16259 #ifndef RIPPER
16260 static void
16262 {
16263  int c = RE_OPTION_ENCODING_IDX(options);
16264 
16265  if (c) {
16266  int opt, idx;
16267  rb_char_to_option_kcode(c, &opt, &idx);
16268  if (idx != ENCODING_GET(str) &&
16270  goto error;
16271  }
16272  ENCODING_SET(str, idx);
16273  }
16274  else if (RE_OPTION_ENCODING_NONE(options)) {
16275  if (!ENCODING_IS_ASCII8BIT(str) &&
16277  c = 'n';
16278  goto error;
16279  }
16281  }
16282  else if (current_enc == rb_usascii_encoding()) {
16284  /* raise in re.c */
16286  }
16287  else {
16289  }
16290  }
16291  return;
16292 
16293  error:
16295  "regexp encoding option '%c' differs from source encoding '%s'",
16296  c, rb_enc_name(rb_enc_get(str)));
16297 }
16298 
16299 static int
16301 {
16302  VALUE err;
16303  reg_fragment_setenc(str, options);
16304  err = rb_reg_check_preprocess(str);
16305  if (err != Qnil) {
16306  err = rb_obj_as_string(err);
16307  compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
16308  RB_GC_GUARD(err);
16309  return 0;
16310  }
16311  return 1;
16312 }
16313 
16314 typedef struct {
16319  int num;
16321 
16322 static int
16324  int back_num, int *back_refs, OnigRegex regex, void *arg0)
16325 {
16327  struct parser_params* parser = arg->parser;
16328  rb_encoding *enc = arg->enc;
16329  long len = name_end - name;
16330  const char *s = (const char *)name;
16331  ID var;
16332 
16333  arg->num++;
16334 
16335  if (arg->succ_block == 0) {
16336  arg->succ_block = NEW_BEGIN(0);
16337  arg->fail_block = NEW_BEGIN(0);
16338  }
16339 
16340  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16341  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16342  !rb_enc_symname2_p(s, len, enc)) {
16343  return ST_CONTINUE;
16344  }
16345  var = rb_intern3(s, len, enc);
16346  if (dvar_defined(var) || local_id(var)) {
16347  rb_warningS("named capture conflicts a local variable - %s",
16348  rb_id2name(var));
16349  }
16350  arg->succ_block = block_append(arg->succ_block,
16352  NEW_CALL(
16353  gettable(rb_intern("$~")),
16354  idAREF,
16355  NEW_LIST(NEW_LIT(ID2SYM(var))))
16356  )));
16357  arg->fail_block = block_append(arg->fail_block,
16359  return ST_CONTINUE;
16360 }
16361 
16362 static NODE *
16364 {
16366 
16367  arg.parser = parser;
16368  arg.enc = rb_enc_get(regexp);
16369  arg.succ_block = 0;
16370  arg.fail_block = 0;
16371  arg.num = 0;
16372  onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
16373 
16374  if (arg.num == 0)
16375  return match;
16376 
16377  return
16378  block_append(
16379  newline_node(match),
16380  NEW_IF(gettable(rb_intern("$~")),
16381  block_append(
16382  newline_node(arg.succ_block),
16383  newline_node(
16384  NEW_CALL(
16385  gettable(rb_intern("$~")),
16386  rb_intern("begin"),
16387  NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16388  block_append(
16389  newline_node(arg.fail_block),
16390  newline_node(
16391  NEW_LIT(Qnil)))));
16392 }
16393 
16394 static VALUE
16395 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16396 {
16397  VALUE re;
16398  VALUE err;
16399 
16400  reg_fragment_setenc(str, options);
16401  err = rb_errinfo();
16403  if (NIL_P(re)) {
16404  ID mesg = rb_intern("mesg");
16405  VALUE m = rb_attr_get(rb_errinfo(), mesg);
16406  rb_set_errinfo(err);
16407  if (!NIL_P(err)) {
16408  rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16409  }
16410  else {
16412  }
16413  return Qnil;
16414  }
16415  return re;
16416 }
16417 
16418 void
16420 {
16421 }
16422 
16423 NODE*
16425 {
16426  NODE *prelude = 0;
16427  NODE *scope = node;
16428  struct parser_params *parser;
16429 
16430  if (!node) return node;
16431 
16432  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16433 
16434  node = node->nd_body;
16435 
16436  if (nd_type(node) == NODE_PRELUDE) {
16437  prelude = node;
16438  node = node->nd_body;
16439  }
16440 
16441  node = block_append(node,
16442  NEW_FCALL(rb_intern("print"),
16443  NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16444  if (prelude) {
16445  prelude->nd_body = node;
16446  scope->nd_body = prelude;
16447  }
16448  else {
16449  scope->nd_body = node;
16450  }
16451 
16452  return scope;
16453 }
16454 
16455 NODE *
16456 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16457 {
16458  NODE *prelude = 0;
16459  NODE *scope = node;
16460  struct parser_params *parser;
16461 
16462  if (!node) return node;
16463 
16464  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16465 
16466  node = node->nd_body;
16467 
16468  if (nd_type(node) == NODE_PRELUDE) {
16469  prelude = node;
16470  node = node->nd_body;
16471  }
16472  if (split) {
16473  node = block_append(NEW_GASGN(rb_intern("$F"),
16474  NEW_CALL(NEW_GVAR(rb_intern("$_")),
16475  rb_intern("split"), 0)),
16476  node);
16477  }
16478  if (chop) {
16479  node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16480  rb_intern("chop!"), 0), node);
16481  }
16482 
16483  node = NEW_OPT_N(node);
16484 
16485  if (prelude) {
16486  prelude->nd_body = node;
16487  scope->nd_body = prelude;
16488  }
16489  else {
16490  scope->nd_body = node;
16491  }
16492 
16493  return scope;
16494 }
16495 
16496 static const struct {
16498  const char *name;
16499 } op_tbl[] = {
16500  {tDOT2, ".."},
16501  {tDOT3, "..."},
16502  {tPOW, "**"},
16503  {tDSTAR, "**"},
16504  {tUPLUS, "+@"},
16505  {tUMINUS, "-@"},
16506  {tCMP, "<=>"},
16507  {tGEQ, ">="},
16508  {tLEQ, "<="},
16509  {tEQ, "=="},
16510  {tEQQ, "==="},
16511  {tNEQ, "!="},
16512  {tMATCH, "=~"},
16513  {tNMATCH, "!~"},
16514  {tAREF, "[]"},
16515  {tASET, "[]="},
16516  {tLSHFT, "<<"},
16517  {tRSHFT, ">>"},
16518  {tCOLON2, "::"},
16519 };
16520 
16521 #define op_tbl_count numberof(op_tbl)
16522 
16523 #ifndef ENABLE_SELECTOR_NAMESPACE
16524 #define ENABLE_SELECTOR_NAMESPACE 0
16525 #endif
16526 
16527 static struct symbols {
16531 #if ENABLE_SELECTOR_NAMESPACE
16532  st_table *ivar2_id;
16533  st_table *id_ivar2;
16534 #endif
16537 
16538 static const struct st_hash_type symhash = {
16540  rb_str_hash,
16541 };
16542 
16543 #if ENABLE_SELECTOR_NAMESPACE
16544 struct ivar2_key {
16545  ID id;
16546  VALUE klass;
16547 };
16548 
16549 static int
16550 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16551 {
16552  if (key1->id == key2->id && key1->klass == key2->klass) {
16553  return 0;
16554  }
16555  return 1;
16556 }
16557 
16558 static int
16559 ivar2_hash(struct ivar2_key *key)
16560 {
16561  return (key->id << 8) ^ (key->klass >> 2);
16562 }
16563 
16564 static const struct st_hash_type ivar2_hash_type = {
16565  ivar2_cmp,
16566  ivar2_hash,
16567 };
16568 #endif
16569 
16570 void
16572 {
16573  global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
16575 #if ENABLE_SELECTOR_NAMESPACE
16576  global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16577  global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16578 #endif
16579 
16580  (void)nodetype;
16581  (void)nodeline;
16582 #if PARSER_DEBUG
16583  (void)lex_state_name(-1);
16584 #endif
16585 
16586  Init_id();
16587 }
16588 
16589 void
16591 {
16595 }
16596 #endif /* !RIPPER */
16597 
16598 static ID
16600 {
16601  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16602  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16603  return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16604 }
16605 
16606 #ifndef RIPPER
16607 static int
16608 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16609 {
16610  int mb = 0;
16611 
16612  if (m >= e) return 0;
16613  if (is_global_name_punct(*m)) {
16614  ++m;
16615  }
16616  else if (*m == '-') {
16617  ++m;
16618  if (m < e && is_identchar(m, e, enc)) {
16619  if (!ISASCII(*m)) mb = 1;
16620  m += rb_enc_mbclen(m, e, enc);
16621  }
16622  }
16623  else {
16624  if (!rb_enc_isdigit(*m, enc)) return 0;
16625  do {
16626  if (!ISASCII(*m)) mb = 1;
16627  ++m;
16628  } while (m < e && rb_enc_isdigit(*m, enc));
16629  }
16630  return m == e ? mb + 1 : 0;
16631 }
16632 
16633 int
16634 rb_symname_p(const char *name)
16635 {
16636  return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16637 }
16638 
16639 int
16640 rb_enc_symname_p(const char *name, rb_encoding *enc)
16641 {
16642  return rb_enc_symname2_p(name, strlen(name), enc);
16643 }
16644 
16645 static int
16646 rb_enc_symname_type(const char *name, long len, rb_encoding *enc)
16647 {
16648  const char *m = name;
16649  const char *e = m + len;
16650  int type = ID_JUNK;
16651 
16652  if (!m || len <= 0) return -1;
16653  switch (*m) {
16654  case '\0':
16655  return -1;
16656 
16657  case '$':
16658  type = ID_GLOBAL;
16659  if (is_special_global_name(++m, e, enc)) return type;
16660  goto id;
16661 
16662  case '@':
16663  type = ID_INSTANCE;
16664  if (*++m == '@') {
16665  ++m;
16666  type = ID_CLASS;
16667  }
16668  goto id;
16669 
16670  case '<':
16671  switch (*++m) {
16672  case '<': ++m; break;
16673  case '=': if (*++m == '>') ++m; break;
16674  default: break;
16675  }
16676  break;
16677 
16678  case '>':
16679  switch (*++m) {
16680  case '>': case '=': ++m; break;
16681  }
16682  break;
16683 
16684  case '=':
16685  switch (*++m) {
16686  case '~': ++m; break;
16687  case '=': if (*++m == '=') ++m; break;
16688  default: return -1;
16689  }
16690  break;
16691 
16692  case '*':
16693  if (*++m == '*') ++m;
16694  break;
16695 
16696  case '+': case '-':
16697  if (*++m == '@') ++m;
16698  break;
16699 
16700  case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16701  ++m;
16702  break;
16703 
16704  case '[':
16705  if (*++m != ']') return -1;
16706  if (*++m == '=') ++m;
16707  break;
16708 
16709  case '!':
16710  if (len == 1) return ID_JUNK;
16711  switch (*++m) {
16712  case '=': case '~': ++m; break;
16713  default: return -1;
16714  }
16715  break;
16716 
16717  default:
16718  type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16719  id:
16720  if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16721  return -1;
16722  while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16723  switch (*m) {
16724  case '!': case '?':
16725  if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16726  type = ID_JUNK;
16727  ++m;
16728  break;
16729  case '=':
16730  if (type != ID_CONST && type != ID_LOCAL) return -1;
16731  type = ID_ATTRSET;
16732  ++m;
16733  break;
16734  }
16735  break;
16736  }
16737  return m == e ? type : -1;
16738 }
16739 
16740 int
16741 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16742 {
16743  return rb_enc_symname_type(name, len, enc) != -1;
16744 }
16745 
16746 static int
16748 {
16749  const char *ptr = StringValuePtr(name);
16750  long len = RSTRING_LEN(name);
16751  int type = rb_enc_symname_type(ptr, len, rb_enc_get(name));
16752  RB_GC_GUARD(name);
16753  return type;
16754 }
16755 
16756 static ID
16757 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16758 {
16759  VALUE str = rb_enc_str_new(name, len, enc);
16760  return register_symid_str(id, str);
16761 }
16762 
16763 static ID
16765 {
16766  OBJ_FREEZE(str);
16769  return id;
16770 }
16771 
16772 static int
16774 {
16775  if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
16776  switch (rb_enc_str_coderange(str)) {
16777  case ENC_CODERANGE_BROKEN:
16778  rb_raise(rb_eEncodingError, "invalid encoding symbol");
16779  case ENC_CODERANGE_7BIT:
16780  return TRUE;
16781  }
16782  return FALSE;
16783 }
16784 
16785 /*
16786  * _str_ itself will be registered at the global symbol table. _str_
16787  * can be modified before the registration, since the encoding will be
16788  * set to ASCII-8BIT if it is a special global name.
16789  */
16790 static ID intern_str(VALUE str);
16791 
16792 ID
16793 rb_intern3(const char *name, long len, rb_encoding *enc)
16794 {
16795  VALUE str;
16796  st_data_t data;
16797  struct RString fake_str;
16798  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
16799  fake_str.basic.klass = rb_cString;
16800  fake_str.as.heap.len = len;
16801  fake_str.as.heap.ptr = (char *)name;
16802  fake_str.as.heap.aux.capa = len;
16803  str = (VALUE)&fake_str;
16804  rb_enc_associate(str, enc);
16805  OBJ_FREEZE(str);
16806 
16807  if (st_lookup(global_symbols.sym_id, str, &data))
16808  return (ID)data;
16809 
16810  str = rb_enc_str_new(name, len, enc); /* make true string */
16811  return intern_str(str);
16812 }
16813 
16814 static ID
16816 {
16817  const char *name, *m, *e;
16818  long len, last;
16819  rb_encoding *enc, *symenc;
16820  unsigned char c;
16821  ID id;
16822  int mb;
16823 
16824  RSTRING_GETMEM(str, name, len);
16825  m = name;
16826  e = m + len;
16827  enc = rb_enc_get(str);
16828  symenc = enc;
16829 
16830  if (rb_cString && !rb_enc_asciicompat(enc)) {
16831  id = ID_JUNK;
16832  goto new_id;
16833  }
16834  last = len-1;
16835  id = 0;
16836  switch (*m) {
16837  case '$':
16838  id |= ID_GLOBAL;
16839  if ((mb = is_special_global_name(++m, e, enc)) != 0) {
16840  if (!--mb) symenc = rb_usascii_encoding();
16841  goto new_id;
16842  }
16843  break;
16844  case '@':
16845  if (m[1] == '@') {
16846  m++;
16847  id |= ID_CLASS;
16848  }
16849  else {
16850  id |= ID_INSTANCE;
16851  }
16852  m++;
16853  break;
16854  default:
16855  c = m[0];
16856  if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
16857  /* operators */
16858  int i;
16859 
16860  if (len == 1) {
16861  id = c;
16862  goto id_register;
16863  }
16864  for (i = 0; i < op_tbl_count; i++) {
16865  if (*op_tbl[i].name == *m &&
16866  strcmp(op_tbl[i].name, m) == 0) {
16867  id = op_tbl[i].token;
16868  goto id_register;
16869  }
16870  }
16871  }
16872 
16873  if (m[last] == '=') {
16874  /* attribute assignment */
16875  id = rb_intern3(name, last, enc);
16876  if (id > tLAST_OP_ID && !is_attrset_id(id)) {
16877  enc = rb_enc_get(rb_id2str(id));
16878  id = rb_id_attrset(id);
16879  goto id_register;
16880  }
16881  id = ID_ATTRSET;
16882  }
16883  else if (rb_enc_isupper(m[0], enc)) {
16884  id = ID_CONST;
16885  }
16886  else {
16887  id = ID_LOCAL;
16888  }
16889  break;
16890  }
16891  if (!rb_enc_isdigit(*m, enc)) {
16892  while (m <= name + last && is_identchar(m, e, enc)) {
16893  if (ISASCII(*m)) {
16894  m++;
16895  }
16896  else {
16897  m += rb_enc_mbclen(m, e, enc);
16898  }
16899  }
16900  }
16901  if (m - name < len) id = ID_JUNK;
16902  if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
16903  new_id:
16904  if (symenc != enc) rb_enc_associate(str, symenc);
16906  if (len > 20) {
16907  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
16908  name);
16909  }
16910  else {
16911  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
16912  (int)len, name);
16913  }
16914  }
16916  id_register:
16917  return register_symid_str(id, str);
16918 }
16919 
16920 ID
16921 rb_intern2(const char *name, long len)
16922 {
16923  return rb_intern3(name, len, rb_usascii_encoding());
16924 }
16925 
16926 #undef rb_intern
16927 ID
16928 rb_intern(const char *name)
16929 {
16930  return rb_intern2(name, strlen(name));
16931 }
16932 
16933 ID
16935 {
16936  st_data_t id;
16937 
16938  if (st_lookup(global_symbols.sym_id, str, &id))
16939  return (ID)id;
16940  return intern_str(rb_str_dup(str));
16941 }
16942 
16943 VALUE
16945 {
16946  st_data_t data;
16947 
16948  if (id < tLAST_TOKEN) {
16949  int i = 0;
16950 
16951  if (id < INT_MAX && rb_ispunct((int)id)) {
16952  VALUE str = global_symbols.op_sym[i = (int)id];
16953  if (!str) {
16954  char name[2];
16955  name[0] = (char)id;
16956  name[1] = 0;
16957  str = rb_usascii_str_new(name, 1);
16958  OBJ_FREEZE(str);
16959  global_symbols.op_sym[i] = str;
16960  }
16961  return str;
16962  }
16963  for (i = 0; i < op_tbl_count; i++) {
16964  if (op_tbl[i].token == id) {
16965  VALUE str = global_symbols.op_sym[i];
16966  if (!str) {
16967  str = rb_usascii_str_new2(op_tbl[i].name);
16968  OBJ_FREEZE(str);
16969  global_symbols.op_sym[i] = str;
16970  }
16971  return str;
16972  }
16973  }
16974  }
16975 
16976  if (st_lookup(global_symbols.id_str, id, &data)) {
16977  VALUE str = (VALUE)data;
16978  if (RBASIC(str)->klass == 0)
16979  RBASIC(str)->klass = rb_cString;
16980  return str;
16981  }
16982 
16983  if (is_attrset_id(id)) {
16984  ID id2 = (id & ~ID_SCOPE_MASK) | ID_LOCAL;
16985  VALUE str;
16986 
16987  while (!(str = rb_id2str(id2))) {
16988  if (!is_local_id(id2)) return 0;
16989  id2 = (id & ~ID_SCOPE_MASK) | ID_CONST;
16990  }
16991  str = rb_str_dup(str);
16992  rb_str_cat(str, "=", 1);
16993  rb_intern_str(str);
16994  if (st_lookup(global_symbols.id_str, id, &data)) {
16995  VALUE str = (VALUE)data;
16996  if (RBASIC(str)->klass == 0)
16997  RBASIC(str)->klass = rb_cString;
16998  return str;
16999  }
17000  }
17001  return 0;
17002 }
17003 
17004 const char *
17006 {
17007  VALUE str = rb_id2str(id);
17008 
17009  if (!str) return 0;
17010  return RSTRING_PTR(str);
17011 }
17012 
17013 static int
17015 {
17016  rb_ary_push(ary, ID2SYM(value));
17017  return ST_CONTINUE;
17018 }
17019 
17020 /*
17021  * call-seq:
17022  * Symbol.all_symbols => array
17023  *
17024  * Returns an array of all the symbols currently in Ruby's symbol
17025  * table.
17026  *
17027  * Symbol.all_symbols.size #=> 903
17028  * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
17029  * :chown, :EOFError, :$;, :String,
17030  * :LOCK_SH, :"setuid?", :$<,
17031  * :default_proc, :compact, :extend,
17032  * :Tms, :getwd, :$=, :ThreadGroup,
17033  * :wait2, :$>]
17034  */
17035 
17036 VALUE
17038 {
17040 
17042  return ary;
17043 }
17044 
17045 int
17047 {
17048  return is_const_id(id);
17049 }
17050 
17051 int
17053 {
17054  return is_class_id(id);
17055 }
17056 
17057 int
17059 {
17060  return is_global_id(id);
17061 }
17062 
17063 int
17065 {
17066  return is_instance_id(id);
17067 }
17068 
17069 int
17071 {
17072  return is_attrset_id(id);
17073 }
17074 
17075 int
17077 {
17078  return is_local_id(id);
17079 }
17080 
17081 int
17083 {
17084  return is_junk_id(id);
17085 }
17086 
17098 ID
17099 rb_check_id(volatile VALUE *namep)
17100 {
17101  st_data_t id;
17102  VALUE tmp;
17103  VALUE name = *namep;
17104 
17105  if (SYMBOL_P(name)) {
17106  return SYM2ID(name);
17107  }
17108  else if (!RB_TYPE_P(name, T_STRING)) {
17109  tmp = rb_check_string_type(name);
17110  if (NIL_P(tmp)) {
17111  tmp = rb_inspect(name);
17112  rb_raise(rb_eTypeError, "%s is not a symbol",
17113  RSTRING_PTR(tmp));
17114  }
17115  name = tmp;
17116  *namep = name;
17117  }
17118 
17119  sym_check_asciionly(name);
17120 
17121  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17122  return (ID)id;
17123 
17124  if (rb_is_attrset_name(name)) {
17125  struct RString fake_str;
17126  const VALUE localname = (VALUE)&fake_str;
17127  /* make local name by chopping '=' */
17128  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17129  fake_str.basic.klass = rb_cString;
17130  fake_str.as.heap.len = RSTRING_LEN(name) - 1;
17131  fake_str.as.heap.ptr = RSTRING_PTR(name);
17132  fake_str.as.heap.aux.capa = fake_str.as.heap.len;
17133  rb_enc_copy(localname, name);
17134  OBJ_FREEZE(localname);
17135 
17136  if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17137  return rb_id_attrset((ID)id);
17138  }
17139  RB_GC_GUARD(name);
17140  }
17141 
17142  return (ID)0;
17143 }
17144 
17145 ID
17146 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
17147 {
17148  st_data_t id;
17149  struct RString fake_str;
17150  const VALUE name = (VALUE)&fake_str;
17151  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17152  fake_str.basic.klass = rb_cString;
17153  fake_str.as.heap.len = len;
17154  fake_str.as.heap.ptr = (char *)ptr;
17155  fake_str.as.heap.aux.capa = len;
17156  rb_enc_associate(name, enc);
17157 
17158  sym_check_asciionly(name);
17159 
17160  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17161  return (ID)id;
17162 
17163  if (rb_is_attrset_name(name)) {
17164  fake_str.as.heap.len = len - 1;
17165  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
17166  return rb_id_attrset((ID)id);
17167  }
17168  }
17169 
17170  return (ID)0;
17171 }
17172 
17173 int
17175 {
17176  return rb_str_symname_type(name) == ID_CONST;
17177 }
17178 
17179 int
17181 {
17182  return rb_str_symname_type(name) == ID_CLASS;
17183 }
17184 
17185 int
17187 {
17188  return rb_str_symname_type(name) == ID_GLOBAL;
17189 }
17190 
17191 int
17193 {
17194  return rb_str_symname_type(name) == ID_INSTANCE;
17195 }
17196 
17197 int
17199 {
17200  return rb_str_symname_type(name) == ID_ATTRSET;
17201 }
17202 
17203 int
17205 {
17206  return rb_str_symname_type(name) == ID_LOCAL;
17207 }
17208 
17209 int
17211 {
17212  switch (rb_str_symname_type(name)) {
17213  case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17214  return TRUE;
17215  }
17216  return FALSE;
17217 }
17218 
17219 int
17221 {
17222  return rb_str_symname_type(name) == -1;
17223 }
17224 
17225 #endif /* !RIPPER */
17226 
17227 static void
17229 {
17230  parser->eofp = Qfalse;
17231 
17232  parser->parser_lex_strterm = 0;
17233  parser->parser_cond_stack = 0;
17234  parser->parser_cmdarg_stack = 0;
17235  parser->parser_class_nest = 0;
17236  parser->parser_paren_nest = 0;
17237  parser->parser_lpar_beg = 0;
17238  parser->parser_brace_nest = 0;
17239  parser->parser_in_single = 0;
17240  parser->parser_in_def = 0;
17241  parser->parser_in_defined = 0;
17242  parser->parser_compile_for_eval = 0;
17243  parser->parser_cur_mid = 0;
17244  parser->parser_tokenbuf = NULL;
17245  parser->parser_tokidx = 0;
17246  parser->parser_toksiz = 0;
17247  parser->parser_heredoc_end = 0;
17248  parser->parser_command_start = TRUE;
17249  parser->parser_deferred_nodes = 0;
17250  parser->parser_lex_pbeg = 0;
17251  parser->parser_lex_p = 0;
17252  parser->parser_lex_pend = 0;
17253  parser->parser_lvtbl = 0;
17254  parser->parser_ruby__end__seen = 0;
17255  parser->parser_ruby_sourcefile = 0;
17256 #ifndef RIPPER
17257  parser->is_ripper = 0;
17258  parser->parser_eval_tree_begin = 0;
17259  parser->parser_eval_tree = 0;
17260 #else
17261  parser->is_ripper = 1;
17262  parser->parser_ruby_sourcefile_string = Qnil;
17263  parser->delayed = Qnil;
17264 
17265  parser->result = Qnil;
17266  parser->parsing_thread = Qnil;
17267  parser->toplevel_p = TRUE;
17268 #endif
17269 #ifdef YYMALLOC
17270  parser->heap = NULL;
17271 #endif
17272  parser->enc = rb_utf8_encoding();
17273 }
17274 
17275 #ifdef RIPPER
17276 #define parser_mark ripper_parser_mark
17277 #define parser_free ripper_parser_free
17278 #endif
17279 
17280 static void
17282 {
17283  struct parser_params *p = (struct parser_params*)ptr;
17284 
17290 #ifndef RIPPER
17293  rb_gc_mark(p->debug_lines);
17294 #else
17295  rb_gc_mark(p->parser_ruby_sourcefile_string);
17296  rb_gc_mark(p->delayed);
17297  rb_gc_mark(p->value);
17298  rb_gc_mark(p->result);
17299  rb_gc_mark(p->parsing_thread);
17300 #endif
17301 #ifdef YYMALLOC
17302  rb_gc_mark((VALUE)p->heap);
17303 #endif
17304 }
17305 
17306 static void
17307 parser_free(void *ptr)
17308 {
17309  struct parser_params *p = (struct parser_params*)ptr;
17310  struct local_vars *local, *prev;
17311 
17312  if (p->parser_tokenbuf) {
17313  xfree(p->parser_tokenbuf);
17314  }
17315  for (local = p->parser_lvtbl; local; local = prev) {
17316  if (local->vars) xfree(local->vars);
17317  prev = local->prev;
17318  xfree(local);
17319  }
17320 #ifndef RIPPER
17322 #endif
17323  xfree(p);
17324 }
17325 
17326 static size_t
17327 parser_memsize(const void *ptr)
17328 {
17329  struct parser_params *p = (struct parser_params*)ptr;
17330  struct local_vars *local;
17331  size_t size = sizeof(*p);
17332 
17333  if (!ptr) return 0;
17334  size += p->parser_toksiz;
17335  for (local = p->parser_lvtbl; local; local = local->prev) {
17336  size += sizeof(*local);
17337  if (local->vars) size += local->vars->capa * sizeof(ID);
17338  }
17339 #ifndef RIPPER
17340  if (p->parser_ruby_sourcefile) {
17341  size += strlen(p->parser_ruby_sourcefile) + 1;
17342  }
17343 #endif
17344  return size;
17345 }
17346 
17347 static
17348 #ifndef RIPPER
17349 const
17350 #endif
17351 rb_data_type_t parser_data_type = {
17352  "parser",
17353  {
17354  parser_mark,
17355  parser_free,
17357  },
17358 };
17359 
17360 #ifndef RIPPER
17361 #undef rb_reserved_word
17362 
17363 const struct kwtable *
17364 rb_reserved_word(const char *str, unsigned int len)
17365 {
17366  return reserved_word(str, len);
17367 }
17368 
17369 static struct parser_params *
17371 {
17372  struct parser_params *p;
17373 
17374  p = ALLOC_N(struct parser_params, 1);
17375  MEMZERO(p, struct parser_params, 1);
17376  parser_initialize(p);
17377  return p;
17378 }
17379 
17380 VALUE
17382 {
17383  struct parser_params *p = parser_new();
17384 
17385  return TypedData_Wrap_Struct(0, &parser_data_type, p);
17386 }
17387 
17388 /*
17389  * call-seq:
17390  * ripper#end_seen? -> Boolean
17391  *
17392  * Return true if parsed source ended by +\_\_END\_\_+.
17393  */
17394 VALUE
17396 {
17397  struct parser_params *parser;
17398 
17399  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17400  return ruby__end__seen ? Qtrue : Qfalse;
17401 }
17402 
17403 /*
17404  * call-seq:
17405  * ripper#encoding -> encoding
17406  *
17407  * Return encoding of the source.
17408  */
17409 VALUE
17411 {
17412  struct parser_params *parser;
17413 
17414  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17416 }
17417 
17418 /*
17419  * call-seq:
17420  * ripper.yydebug -> true or false
17421  *
17422  * Get yydebug.
17423  */
17424 VALUE
17426 {
17427  struct parser_params *parser;
17428 
17429  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17430  return yydebug ? Qtrue : Qfalse;
17431 }
17432 
17433 /*
17434  * call-seq:
17435  * ripper.yydebug = flag
17436  *
17437  * Set yydebug.
17438  */
17439 VALUE
17441 {
17442  struct parser_params *parser;
17443 
17444  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17445  yydebug = RTEST(flag);
17446  return flag;
17447 }
17448 
17449 #ifdef YYMALLOC
17450 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17451 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17452 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17453  (n)->u3.cnt = (c), (p))
17454 
17455 void *
17456 rb_parser_malloc(struct parser_params *parser, size_t size)
17457 {
17458  size_t cnt = HEAPCNT(1, size);
17459  NODE *n = NEWHEAP();
17460  void *ptr = xmalloc(size);
17461 
17462  return ADD2HEAP(n, cnt, ptr);
17463 }
17464 
17465 void *
17466 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17467 {
17468  size_t cnt = HEAPCNT(nelem, size);
17469  NODE *n = NEWHEAP();
17470  void *ptr = xcalloc(nelem, size);
17471 
17472  return ADD2HEAP(n, cnt, ptr);
17473 }
17474 
17475 void *
17476 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17477 {
17478  NODE *n;
17479  size_t cnt = HEAPCNT(1, size);
17480 
17481  if (ptr && (n = parser->heap) != NULL) {
17482  do {
17483  if (n->u1.node == ptr) {
17484  n->u1.node = ptr = xrealloc(ptr, size);
17485  if (n->u3.cnt) n->u3.cnt = cnt;
17486  return ptr;
17487  }
17488  } while ((n = n->u2.node) != NULL);
17489  }
17490  n = NEWHEAP();
17491  ptr = xrealloc(ptr, size);
17492  return ADD2HEAP(n, cnt, ptr);
17493 }
17494 
17495 void
17496 rb_parser_free(struct parser_params *parser, void *ptr)
17497 {
17498  NODE **prev = &parser->heap, *n;
17499 
17500  while ((n = *prev) != NULL) {
17501  if (n->u1.node == ptr) {
17502  *prev = n->u2.node;
17504  break;
17505  }
17506  prev = &n->u2.node;
17507  }
17508  xfree(ptr);
17509 }
17510 #endif
17511 #endif
17512 
17513 #ifdef RIPPER
17514 #ifdef RIPPER_DEBUG
17515 extern int rb_is_pointer_to_heap(VALUE);
17516 
17517 /* :nodoc: */
17518 static VALUE
17519 ripper_validate_object(VALUE self, VALUE x)
17520 {
17521  if (x == Qfalse) return x;
17522  if (x == Qtrue) return x;
17523  if (x == Qnil) return x;
17524  if (x == Qundef)
17525  rb_raise(rb_eArgError, "Qundef given");
17526  if (FIXNUM_P(x)) return x;
17527  if (SYMBOL_P(x)) return x;
17528  if (!rb_is_pointer_to_heap(x))
17529  rb_raise(rb_eArgError, "invalid pointer: %p", x);
17530  switch (TYPE(x)) {
17531  case T_STRING:
17532  case T_OBJECT:
17533  case T_ARRAY:
17534  case T_BIGNUM:
17535  case T_FLOAT:
17536  return x;
17537  case T_NODE:
17538  if (nd_type(x) != NODE_LASGN) {
17539  rb_raise(rb_eArgError, "NODE given: %p", x);
17540  }
17541  return ((NODE *)x)->nd_rval;
17542  default:
17543  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17544  x, rb_obj_classname(x));
17545  }
17546  return x;
17547 }
17548 #endif
17549 
17550 #define validate(x) ((x) = get_value(x))
17551 
17552 static VALUE
17553 ripper_dispatch0(struct parser_params *parser, ID mid)
17554 {
17555  return rb_funcall(parser->value, mid, 0);
17556 }
17557 
17558 static VALUE
17559 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17560 {
17561  validate(a);
17562  return rb_funcall(parser->value, mid, 1, a);
17563 }
17564 
17565 static VALUE
17566 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17567 {
17568  validate(a);
17569  validate(b);
17570  return rb_funcall(parser->value, mid, 2, a, b);
17571 }
17572 
17573 static VALUE
17574 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17575 {
17576  validate(a);
17577  validate(b);
17578  validate(c);
17579  return rb_funcall(parser->value, mid, 3, a, b, c);
17580 }
17581 
17582 static VALUE
17583 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17584 {
17585  validate(a);
17586  validate(b);
17587  validate(c);
17588  validate(d);
17589  return rb_funcall(parser->value, mid, 4, a, b, c, d);
17590 }
17591 
17592 static VALUE
17593 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17594 {
17595  validate(a);
17596  validate(b);
17597  validate(c);
17598  validate(d);
17599  validate(e);
17600  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17601 }
17602 
17603 static VALUE
17604 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17605 {
17606  validate(a);
17607  validate(b);
17608  validate(c);
17609  validate(d);
17610  validate(e);
17611  validate(f);
17612  validate(g);
17613  return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17614 }
17615 
17616 static const struct kw_assoc {
17617  ID id;
17618  const char *name;
17619 } keyword_to_name[] = {
17620  {keyword_class, "class"},
17621  {keyword_module, "module"},
17622  {keyword_def, "def"},
17623  {keyword_undef, "undef"},
17624  {keyword_begin, "begin"},
17625  {keyword_rescue, "rescue"},
17626  {keyword_ensure, "ensure"},
17627  {keyword_end, "end"},
17628  {keyword_if, "if"},
17629  {keyword_unless, "unless"},
17630  {keyword_then, "then"},
17631  {keyword_elsif, "elsif"},
17632  {keyword_else, "else"},
17633  {keyword_case, "case"},
17634  {keyword_when, "when"},
17635  {keyword_while, "while"},
17636  {keyword_until, "until"},
17637  {keyword_for, "for"},
17638  {keyword_break, "break"},
17639  {keyword_next, "next"},
17640  {keyword_redo, "redo"},
17641  {keyword_retry, "retry"},
17642  {keyword_in, "in"},
17643  {keyword_do, "do"},
17644  {keyword_do_cond, "do"},
17645  {keyword_do_block, "do"},
17646  {keyword_return, "return"},
17647  {keyword_yield, "yield"},
17648  {keyword_super, "super"},
17649  {keyword_self, "self"},
17650  {keyword_nil, "nil"},
17651  {keyword_true, "true"},
17652  {keyword_false, "false"},
17653  {keyword_and, "and"},
17654  {keyword_or, "or"},
17655  {keyword_not, "not"},
17656  {modifier_if, "if"},
17657  {modifier_unless, "unless"},
17658  {modifier_while, "while"},
17659  {modifier_until, "until"},
17660  {modifier_rescue, "rescue"},
17661  {keyword_alias, "alias"},
17662  {keyword_defined, "defined?"},
17663  {keyword_BEGIN, "BEGIN"},
17664  {keyword_END, "END"},
17665  {keyword__LINE__, "__LINE__"},
17666  {keyword__FILE__, "__FILE__"},
17667  {keyword__ENCODING__, "__ENCODING__"},
17668  {0, NULL}
17669 };
17670 
17671 static const char*
17672 keyword_id_to_str(ID id)
17673 {
17674  const struct kw_assoc *a;
17675 
17676  for (a = keyword_to_name; a->id; a++) {
17677  if (a->id == id)
17678  return a->name;
17679  }
17680  return NULL;
17681 }
17682 
17683 #undef ripper_id2sym
17684 static VALUE
17685 ripper_id2sym(ID id)
17686 {
17687  const char *name;
17688  char buf[8];
17689 
17690  if (id <= 256) {
17691  buf[0] = (char)id;
17692  buf[1] = '\0';
17693  return ID2SYM(rb_intern2(buf, 1));
17694  }
17695  if ((name = keyword_id_to_str(id))) {
17696  return ID2SYM(rb_intern(name));
17697  }
17698  switch (id) {
17699  case tOROP:
17700  name = "||";
17701  break;
17702  case tANDOP:
17703  name = "&&";
17704  break;
17705  default:
17706  name = rb_id2name(id);
17707  if (!name) {
17708  rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17709  }
17710  return ID2SYM(id);
17711  }
17712  return ID2SYM(rb_intern(name));
17713 }
17714 
17715 static ID
17716 ripper_get_id(VALUE v)
17717 {
17718  NODE *nd;
17719  if (!RB_TYPE_P(v, T_NODE)) return 0;
17720  nd = (NODE *)v;
17721  if (nd_type(nd) != NODE_LASGN) return 0;
17722  return nd->nd_vid;
17723 }
17724 
17725 static VALUE
17726 ripper_get_value(VALUE v)
17727 {
17728  NODE *nd;
17729  if (v == Qundef) return Qnil;
17730  if (!RB_TYPE_P(v, T_NODE)) return v;
17731  nd = (NODE *)v;
17732  if (nd_type(nd) != NODE_LASGN) return Qnil;
17733  return nd->nd_rval;
17734 }
17735 
17736 static void
17737 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17738 {
17739  VALUE str;
17740  va_list args;
17741 
17742  va_start(args, fmt);
17743  str = rb_vsprintf(fmt, args);
17744  va_end(args);
17745  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17746 }
17747 
17748 static void
17749 ripper_warn0(struct parser_params *parser, const char *fmt)
17750 {
17751  rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
17752 }
17753 
17754 static void
17755 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
17756 {
17757  rb_funcall(parser->value, rb_intern("warn"), 2,
17758  STR_NEW2(fmt), INT2NUM(a));
17759 }
17760 
17761 static void
17762 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
17763 {
17764  rb_funcall(parser->value, rb_intern("warn"), 2,
17765  STR_NEW2(fmt), STR_NEW2(str));
17766 }
17767 
17768 static void
17769 ripper_warning0(struct parser_params *parser, const char *fmt)
17770 {
17771  rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
17772 }
17773 
17774 static void
17775 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
17776 {
17777  rb_funcall(parser->value, rb_intern("warning"), 2,
17778  STR_NEW2(fmt), STR_NEW2(str));
17779 }
17780 
17781 static VALUE
17782 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
17783 {
17784  return rb_io_gets(src);
17785 }
17786 
17787 static VALUE
17788 ripper_s_allocate(VALUE klass)
17789 {
17790  struct parser_params *p;
17791  VALUE self;
17792 
17793  p = ALLOC_N(struct parser_params, 1);
17794  MEMZERO(p, struct parser_params, 1);
17795  self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
17796  p->value = self;
17797  return self;
17798 }
17799 
17800 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
17801 
17802 /*
17803  * call-seq:
17804  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
17805  *
17806  * Create a new Ripper object.
17807  * _src_ must be a String, an IO, or an Object which has #gets method.
17808  *
17809  * This method does not starts parsing.
17810  * See also Ripper#parse and Ripper.parse.
17811  */
17812 static VALUE
17813 ripper_initialize(int argc, VALUE *argv, VALUE self)
17814 {
17815  struct parser_params *parser;
17816  VALUE src, fname, lineno;
17817 
17818  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17819  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
17820  if (RB_TYPE_P(src, T_FILE)) {
17821  parser->parser_lex_gets = ripper_lex_get_generic;
17822  }
17823  else {
17824  StringValue(src);
17825  parser->parser_lex_gets = lex_get_str;
17826  }
17827  parser->parser_lex_input = src;
17828  parser->eofp = Qfalse;
17829  if (NIL_P(fname)) {
17830  fname = STR_NEW2("(ripper)");
17831  }
17832  else {
17833  StringValue(fname);
17834  }
17835  parser_initialize(parser);
17836 
17837  parser->parser_ruby_sourcefile_string = fname;
17838  parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
17839  parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
17840 
17841  return Qnil;
17842 }
17843 
17844 struct ripper_args {
17845  struct parser_params *parser;
17846  int argc;
17847  VALUE *argv;
17848 };
17849 
17850 static VALUE
17851 ripper_parse0(VALUE parser_v)
17852 {
17853  struct parser_params *parser;
17854 
17855  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17856  parser_prepare(parser);
17857  ripper_yyparse((void*)parser);
17858  return parser->result;
17859 }
17860 
17861 static VALUE
17862 ripper_ensure(VALUE parser_v)
17863 {
17864  struct parser_params *parser;
17865 
17866  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17867  parser->parsing_thread = Qnil;
17868  return Qnil;
17869 }
17870 
17871 /*
17872  * call-seq:
17873  * ripper#parse
17874  *
17875  * Start parsing and returns the value of the root action.
17876  */
17877 static VALUE
17878 ripper_parse(VALUE self)
17879 {
17880  struct parser_params *parser;
17881 
17882  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17883  if (!ripper_initialized_p(parser)) {
17884  rb_raise(rb_eArgError, "method called for uninitialized object");
17885  }
17886  if (!NIL_P(parser->parsing_thread)) {
17887  if (parser->parsing_thread == rb_thread_current())
17888  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
17889  else
17890  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
17891  }
17892  parser->parsing_thread = rb_thread_current();
17893  rb_ensure(ripper_parse0, self, ripper_ensure, self);
17894 
17895  return parser->result;
17896 }
17897 
17898 /*
17899  * call-seq:
17900  * ripper#column -> Integer
17901  *
17902  * Return column number of current parsing line.
17903  * This number starts from 0.
17904  */
17905 static VALUE
17906 ripper_column(VALUE self)
17907 {
17908  struct parser_params *parser;
17909  long col;
17910 
17911  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17912  if (!ripper_initialized_p(parser)) {
17913  rb_raise(rb_eArgError, "method called for uninitialized object");
17914  }
17915  if (NIL_P(parser->parsing_thread)) return Qnil;
17916  col = parser->tokp - parser->parser_lex_pbeg;
17917  return LONG2NUM(col);
17918 }
17919 
17920 /*
17921  * call-seq:
17922  * ripper#filename -> String
17923  *
17924  * Return current parsing filename.
17925  */
17926 static VALUE
17927 ripper_filename(VALUE self)
17928 {
17929  struct parser_params *parser;
17930 
17931  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17932  if (!ripper_initialized_p(parser)) {
17933  rb_raise(rb_eArgError, "method called for uninitialized object");
17934  }
17935  return parser->parser_ruby_sourcefile_string;
17936 }
17937 
17938 /*
17939  * call-seq:
17940  * ripper#lineno -> Integer
17941  *
17942  * Return line number of current parsing line.
17943  * This number starts from 1.
17944  */
17945 static VALUE
17946 ripper_lineno(VALUE self)
17947 {
17948  struct parser_params *parser;
17949 
17950  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17951  if (!ripper_initialized_p(parser)) {
17952  rb_raise(rb_eArgError, "method called for uninitialized object");
17953  }
17954  if (NIL_P(parser->parsing_thread)) return Qnil;
17955  return INT2NUM(parser->parser_ruby_sourceline);
17956 }
17957 
17958 #ifdef RIPPER_DEBUG
17959 /* :nodoc: */
17960 static VALUE
17961 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
17962 {
17963  StringValue(msg);
17964  if (obj == Qundef) {
17965  rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
17966  }
17967  return Qnil;
17968 }
17969 
17970 /* :nodoc: */
17971 static VALUE
17972 ripper_value(VALUE self, VALUE obj)
17973 {
17974  return ULONG2NUM(obj);
17975 }
17976 #endif
17977 
17978 
17979 void
17980 Init_ripper(void)
17981 {
17982  parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
17983 
17986  /* ensure existing in symbol table */
17987  (void)rb_intern("||");
17988  (void)rb_intern("&&");
17989 
17990  InitVM(ripper);
17991 }
17992 
17993 void
17994 InitVM_ripper(void)
17995 {
17996  VALUE Ripper;
17997 
17998  Ripper = rb_define_class("Ripper", rb_cObject);
17999  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
18000  rb_define_alloc_func(Ripper, ripper_s_allocate);
18001  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
18002  rb_define_method(Ripper, "parse", ripper_parse, 0);
18003  rb_define_method(Ripper, "column", ripper_column, 0);
18004  rb_define_method(Ripper, "filename", ripper_filename, 0);
18005  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
18006  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
18007  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
18008  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
18009  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
18010 #ifdef RIPPER_DEBUG
18011  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
18012  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
18013  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
18014 #endif
18015 
18018 
18019 # if 0
18020  /* Hack to let RDoc document SCRIPT_LINES__ */
18021 
18022  /*
18023  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
18024  * after the assignment will be added as an Array of lines with the file
18025  * name as the key.
18026  */
18027  rb_define_global_const("SCRIPT_LINES__", Qnil);
18028 #endif
18029 
18030 }
18031 #endif /* RIPPER */
18032 
#define STRNCASECMP(s1, s2, n)
Definition: ruby.h:1646
RUBY_EXTERN VALUE rb_cString
Definition: ruby.h:1456
#define in_defined
Definition: ripper.c:379
static const struct @60 op_tbl[]
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:2216
char * parser_ruby_sourcefile
Definition: ripper.c:326
VALUE val
Definition: parse.h:164
#define local_var(id)
Definition: ripper.c:556
#define cond(node)
Definition: ripper.c:422
#define arg_var(id)
Definition: ripper.c:558
#define ret_args(node)
Definition: ripper.c:473
#define yyparse
Definition: ripper.c:416
#define T_OBJECT
Definition: ruby.h:485
Definition: node.h:93
Definition: node.h:29
#define NEW_RETURN(s)
Definition: node.h:383
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: ripper.c:4715
enum lex_state_e state
Definition: lex.c:33
struct local_vars * parser_lvtbl
Definition: ripper.c:322
VALUE rb_ary_unshift(VALUE ary, VALUE item)
Definition: array.c:1084
static ID ripper_token2eventid(int tok)
Definition: eventids2.c:273
Definition: lex.c:33
#define IS_LABEL_SUFFIX(n)
Definition: ripper.c:13407
#define new_args_tail(k, kr, b)
Definition: ripper.c:469
#define YYSTACK_ALLOC
Definition: ripper.c:1042
int rb_is_attrset_id(ID id)
Definition: ripper.c:17070
int rb_enc_codelen(int c, rb_encoding *enc)
Definition: encoding.c:954
#define NEW_OP_ASGN_AND(i, val)
Definition: node.h:403
static double zero(void)
Definition: isinf.c:51
#define lex_input
Definition: ripper.c:384
#define lex_state
Definition: ripper.c:368
#define subnodes(n1, n2)
#define parser_precise_mbclen()
Definition: ripper.c:11702
static NODE * remove_begin(NODE *)
Definition: ripper.c:15541
#define MBCLEN_CHARFOUND_P(ret)
Definition: encoding.h:138
#define NEW_STRTERM(func, term, paren)
Definition: ripper.c:12709
static const yytype_int16 yydefgoto[]
Definition: ripper.c:1867
#define list_concat(h, t)
Definition: ripper.c:447
static struct parser_params * parser_new(void)
Definition: ripper.c:17370
Definition: parse.c:860
#define NEW_OP_ASGN1(p, id, a)
Definition: node.h:399
int onig_foreach_name(regex_t *reg, int(*func)(const UChar *, const UChar *, int, int *, regex_t *, void *), void *arg)
Definition: regparse.c:537
union YYSTYPE YYSTYPE
#define NEW_SCLASS(r, b)
Definition: node.h:442
#define yydebug
Definition: ripper.c:400
static NODE * arg_blk_pass(NODE *, NODE *)
Definition: ripper.c:15883
static void Init_id(void)
Definition: id.c:14
static ID internal_id_gen(struct parser_params *)
Definition: ripper.c:16599
#define RARRAY_LEN(a)
Definition: ruby.h:899
Definition: parse.c:868
void rb_bug(const char *fmt,...)
Definition: error.c:290
int num
Definition: parse.h:167
#define IS_END()
Definition: ripper.c:13403
struct token_info * next
Definition: ripper.c:274
#define ENC_SINGLE(cr)
Definition: ripper.c:361
void rb_enc_copy(VALUE obj1, VALUE obj2)
Definition: encoding.c:856
#define FALSE
Definition: nkf.h:174
static NODE * logop_gen(struct parser_params *, enum node_type, NODE *, NODE *)
Definition: ripper.c:15807
static const struct kwtable * reserved_word(const char *, unsigned int)
#define tail
Definition: st.c:108
#define NEW_LIST(a)
Definition: node.h:385
int rb_is_class_name(VALUE name)
Definition: ripper.c:17180
#define NEW_DEFINED(e)
Definition: node.h:454
struct vtable * used
Definition: ripper.c:191
#define tHEREDOC_BEG
Definition: eventids2.c:7
NODE * rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
Definition: ripper.c:12071
static int comment_at_top(struct parser_params *parser)
Definition: ripper.c:13148
#define RE_OPTION_ENCODING_IDX(o)
Definition: ripper.c:583
#define rb_gc_mark_locations(start, end)
Definition: gc.c:2346
size_t strlen(const char *)
#define assignable(id, node)
Definition: ripper.c:483
#define INT2NUM(x)
Definition: ruby.h:1178
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2530
int i
Definition: win32ole.c:784
static size_t parser_memsize(const void *ptr)
Definition: ripper.c:17327
VALUE parser_lex_nextline
Definition: ripper.c:313
VALUE rb_make_exception(int argc, VALUE *argv)
Definition: eval.c:642
#define STR_FUNC_ESCAPE
Definition: ripper.c:12089
#define scan_oct(s, l, e)
Definition: util.h:52
#define nd_plen
Definition: node.h:327
#define T_FIXNUM
Definition: ruby.h:497
Definition: st.h:77
VALUE stack_type
Definition: ripper.c:164
#define reg_compile(str, options)
Definition: ripper.c:510
VALUE rb_id2str(ID id)
Definition: ripper.c:16944
static NODE * call_uni_op_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:15000
Definition: node.h:47
#define toksiz
Definition: ripper.c:382
#define NEW_XSTR(s)
Definition: node.h:419
#define YY_(msgid)
Definition: ripper.c:974
int parser_ruby__end__seen
Definition: ripper.c:323
int parser_command_start
Definition: ripper.c:318
static void fixpos(NODE *, NODE *)
Definition: ripper.c:14750
VALUE rb_range_new(VALUE, VALUE, int)
Definition: range.c:67
#define NUM2INT(x)
Definition: ruby.h:622
#define YYSTACK_FREE
Definition: ripper.c:1043
#define NEW_DOT2(b, e)
Definition: node.h:447
static void reduce_nodes_gen(struct parser_params *, NODE **)
Definition: ripper.c:15551
#define value_expr(node)
Definition: ripper.c:432
#define nd_paren(node)
Definition: ripper.c:597
static NODE * call_bin_op_gen(struct parser_params *, NODE *, ID, NODE *)
Definition: ripper.c:14992
const char * name
Definition: lex.c:33
#define tEMBDOC_BEG
Definition: eventids2.c:3
static int parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp, int string_literal, int symbol_literal, int regexp_literal)
Definition: ripper.c:12258
int parser_compile_for_eval
Definition: ripper.c:304
#define get_id(id)
Definition: ripper.c:518
int parser_token_info_enabled
Definition: ripper.c:340
int parser_brace_nest
Definition: ripper.c:303
#define YYLEX
Definition: ripper.c:4463
#define InitVM(ext)
Definition: ruby.h:1651
static NODE * new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: ripper.c:16013
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:1963
#define YYABORT
Definition: ripper.c:4383
Definition: id.h:81
#define nd_line(n)
Definition: node.h:282
static void parser_heredoc_restore(struct parser_params *parser, NODE *here)
Definition: ripper.c:12917
#define lex_eol_p()
Definition: ripper.c:12125
#define Qtrue
Definition: ruby.h:434
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2304
Definition: id.h:78
static int yysyntax_error(YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
Definition: ripper.c:4763
#define dyna_in_block()
Definition: ripper.c:569
#define CMDARG_LEXPOP()
Definition: ripper.c:178
static NODE * gettable_gen(struct parser_params *, ID)
Definition: ripper.c:15041
#define str_copy(_s, _p, _n)
#define was_bol()
Definition: ripper.c:12195
#define TypedData_Wrap_Struct(klass, data_type, sval)
Definition: ruby.h:1016
#define IS_SPCARG(c)
Definition: ripper.c:13405
#define void_stmts(node)
Definition: ripper.c:436
static struct symbols global_symbols
Definition: parse.c:852
static YYSIZE_T yystrlen(char *yystr) const
Definition: ripper.c:4666
VALUE rb_parser_end_seen_p(VALUE vparser)
Definition: ripper.c:17395
#define TypedData_Get_Struct(obj, type, data_type, sval)
Definition: ruby.h:1030
const int id
Definition: nkf.c:209
#define current_enc
Definition: ripper.c:399
int line_count
Definition: ripper.c:324
#define YYNTOKENS
Definition: ripper.c:1139
struct token_info token_info
#define new_op_assign(lhs, op, rhs)
Definition: ripper.c:542
stack_type parser_cmdarg_stack
Definition: ripper.c:297
node_type
Definition: node.h:22
#define new_args(f, o, r, p, t)
Definition: ripper.c:467
VALUE rb_external_str_new_with_enc(const char *ptr, long len, rb_encoding *)
Definition: string.c:569
#define strcasecmp
Definition: win32.h:200
Definition: parse.c:837
Definition: parse.c:865
#define ID_CONST
Definition: id.h:22
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:344
#define nextc()
Definition: ripper.c:11592
#define rb_warning0(fmt)
Definition: ripper.c:696
VALUE rb_enc_from_encoding(rb_encoding *encoding)
Definition: encoding.c:103
#define token_info_push(token)
Definition: ripper.c:735
static VALUE debug_lines(const char *f)
Definition: ripper.c:11848
VALUE rb_eTypeError
Definition: error.c:511
static int parser_here_document(struct parser_params *, NODE *)
Definition: ripper.c:12964
NODE * node
Definition: parse.h:165
#define rb_warnS(fmt, a)
Definition: ripper.c:694
#define dsym_node(node)
Definition: ripper.c:478
st_table * names
Definition: encoding.c:53
#define ID_JUNK
Definition: id.h:24
#define ULONG2NUM(x)
Definition: ruby.h:1209
#define logop(type, node1, node2)
Definition: ripper.c:424
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:822
#define rb_long2int(n)
Definition: ruby.h:325
static void yydestruct(char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser) const
Definition: ripper.c:4902
#define NEW_CLASS(n, b, s)
Definition: node.h:441
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:108
#define MAX_WORD_LENGTH
Definition: lex.c:43
static NODE * evstr2dstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:14969
VALUE rb_eEncodingError
Definition: error.c:517
static int reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end, int back_num, int *back_refs, OnigRegex regex, void *arg0)
Definition: ripper.c:16323
union RNode::@93 u1
static void warn_unused_var(struct parser_params *parser, struct local_vars *local)
Definition: ripper.c:16048
#define SYM2ID(x)
Definition: ruby.h:364
struct RBasic basic
Definition: ruby.h:843
unsigned short int yytype_uint16
Definition: ripper.c:941
#define parse_string(n)
Definition: ripper.c:11602
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:789
Definition: parse.c:858
#define NEW_OPT_N(b)
Definition: node.h:369
const struct kwtable * rb_reserved_word(const char *str, unsigned int len)
Definition: ripper.c:17364
#define is_identchar(p, e, enc)
Definition: ripper.c:11703
VALUE op_sym[tLAST_OP_ID]
Definition: ripper.c:16535
#define COND_PUSH(n)
Definition: ripper.c:171
VALUE debug_lines
Definition: ripper.c:336
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
Definition: vm_eval.c:774
#define warn_balanced(op, syn)
Definition: ripper.c:13417
struct RString::@73::@74 heap
ID id
Definition: parse.h:166
#define match_op(node1, node2)
Definition: ripper.c:502
#define CMDARG_P()
Definition: ripper.c:179
#define dvar_defined(id)
Definition: ripper.c:572
#define yyerrok
Definition: ripper.c:4377
#define YYEMPTY
Definition: ripper.c:4379
#define tok()
Definition: ripper.c:12198
int rb_enc_str_coderange(VALUE)
Definition: string.c:327
static void ripper_init_eventids1_table(VALUE self)
Definition: eventids1.c:270
#define reg_fragment_setenc(str, options)
Definition: ripper.c:512
static NODE * match_op_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15007
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1780
#define rb_warn4S(file, line, fmt, a)
Definition: ripper.c:695
Definition: parse.c:838
#define rb_warnI(fmt, a)
Definition: ripper.c:693
#define NEW_NIL()
Definition: node.h:450
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Definition: ruby.h:875
static NODE * node_assign_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15345
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
Definition: encoding.c:766
static NODE * block_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14773
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: ripper.c:4480
static NODE * newline_node(NODE *)
Definition: ripper.c:14740
ID * tbl
Definition: ripper.c:182
const rb_data_type_t * parent
Definition: ruby.h:969
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:172
#define newtok()
Definition: ripper.c:11594
static NODE * range_op(struct parser_params *parser, NODE *node)
Definition: ripper.c:15706
#define reduce_nodes(n)
Definition: ripper.c:438
#define YYPOPSTACK(N)
#define dyna_var(id)
Definition: ripper.c:570
int pre_args_num
Definition: node.h:508
#define RB_GC_GUARD(v)
Definition: ruby.h:530
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
#define NODE_HEREDOC
Definition: ripper.c:589
#define T_HASH
Definition: ruby.h:493
int parser_toksiz
Definition: ripper.c:309
#define POINTER_P(val)
Definition: ripper.c:198
#define STR_FUNC_INDENT
Definition: ripper.c:12094
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
Definition: encoding.c:886
#define ID_LOCAL
Definition: id.h:18
st_index_t rb_str_hash(VALUE)
Definition: string.c:2244
#define nd_args
Definition: node.h:331
VALUE rb_ary_new3(long n,...)
Definition: array.c:432
Definition: parse.c:880
static void parser_pushback(struct parser_params *parser, int c)
Definition: ripper.c:12186
#define nd_set_type(n, t)
Definition: node.h:277
ID last_id
Definition: ripper.c:16528
#define Qnone
Definition: ripper.c:684
static int lvar_defined_gen(struct parser_params *, ID)
Definition: ripper.c:13089
const char * alias
Definition: nkf.c:1151
void rb_gc_mark(VALUE ptr)
Definition: gc.c:2598
#define ruby__end__seen
Definition: ripper.c:396
#define T_ARRAY
Definition: ruby.h:492
#define NEW_DOT3(b, e)
Definition: node.h:448
#define ruby_debug_lines
Definition: ripper.c:405
#define parser_is_identchar()
Definition: ripper.c:11704
#define rb_enc_islower(c, enc)
Definition: encoding.h:176
#define local_pop()
Definition: ripper.c:554
#define NEW_ITER(a, b)
Definition: node.h:373
static int parser_whole_match_p(struct parser_params *parser, const char *eos, long len, int indent)
Definition: ripper.c:12934
#define RE_OPTION_ENCODING(e)
Definition: ripper.c:582
#define rb_backref_error(n)
Definition: ripper.c:491
NODE * pre_init
Definition: node.h:505
#define ISDIGIT(c)
#define NEW_IVAR(v)
Definition: node.h:408
unsigned int last
Definition: nkf.c:4310
static void parser_initialize(struct parser_params *parser)
Definition: ripper.c:17228
ID block_arg
Definition: node.h:514
static NODE * node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE)
Definition: ripper.c:14720
static const yytype_uint16 yyr1[]
Definition: ripper.c:1620
ID rb_check_id(volatile VALUE *namep)
Returns ID for the given name if it is interned already, or 0.
Definition: ripper.c:17099
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
Definition: ripper.c:17146
static NODE * yycompile(struct parser_params *parser, const char *f, int line)
Definition: ripper.c:11948
struct RNode * node
Definition: node.h:243
static ID * vtable_tblcpy(ID *buf, const struct vtable *src)
Definition: ripper.c:16098
#define NEW_IASGN(v, val)
Definition: node.h:394
#define FIXNUM_P(f)
Definition: ruby.h:355
#define lex_gets_ptr
Definition: ripper.c:393
rb_encoding * rb_utf8_encoding(void)
Definition: encoding.c:1168
#define here_document(n)
Definition: ripper.c:11604
VALUE parser_lex_input
Definition: ripper.c:311
static long parser_encode_length(struct parser_params *parser, const char *name, long len)
Definition: ripper.c:13096
#define nd_type(n)
Definition: node.h:276
#define is_instance_id(id)
Definition: ripper.c:113
#define call_bin_op(recv, id, arg1)
Definition: ripper.c:462
Definition: parse.c:857
VALUE klass
Definition: ruby.h:701
#define arg_concat(h, t)
Definition: ripper.c:451
static enum node_type nodetype(NODE *node)
Definition: ripper.c:14728
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2105
VALUE rb_sym_all_symbols(void)
Definition: ripper.c:17037
static VALUE lex_getline(struct parser_params *parser)
Definition: ripper.c:11987
static NODE * ret_args_gen(struct parser_params *, NODE *)
Definition: ripper.c:15830
static const yytype_int16 yytable[]
Definition: ripper.c:2033
#define RUBY_DTRACE_PARSE_BEGIN(arg0, arg1)
Definition: probes.h:68
int pos
Definition: ripper.c:183
Definition: parse.c:823
Definition: parse.c:881
#define YYLAST
Definition: ripper.c:1136
#define YYID(n)
Definition: ripper.c:987
int rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:16741
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: ripper.c:17440
#define ENC_CODERANGE_7BIT
Definition: encoding.h:58
const char * rb_obj_classname(VALUE)
Definition: variable.c:396
void rb_gc_force_recycle(VALUE p)
Definition: gc.c:2961
static int yylex(void *, void *)
Definition: ripper.c:14693
#define NEW_SCOPE(a, b)
Definition: node.h:363
#define head
Definition: st.c:107
#define ruby_sourcefile
Definition: ripper.c:398
unsigned char OnigUChar
Definition: oniguruma.h:113
int parser_yydebug
Definition: ripper.c:330
#define gettable(id)
Definition: ripper.c:481
Definition: node.h:27
st_table * id_str
Definition: ripper.c:16530
NODE * parser_eval_tree
Definition: ripper.c:335
#define list_append(l, i)
Definition: ripper.c:445
NODE * parser_deferred_nodes
Definition: ripper.c:319
#define sym(x)
Definition: date_core.c:3715
static int simple_re_meta(int c)
Definition: ripper.c:12563
VALUE rb_str_buf_cat(VALUE, const char *, long)
Definition: string.c:1947
#define STR_NEW0()
Definition: ripper.c:358
Definition: node.h:239
static int e_option_supplied(struct parser_params *parser)
Definition: ripper.c:11882
static void block_dup_check_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15257
Definition: parse.h:159
int has_shebang
Definition: ripper.c:325
#define NEWHEAP()
Definition: ripper.c:17451
Win32OLEIDispatch * p
Definition: win32ole.c:786
#define SPECIAL_PUNCT(idx)
Definition: ripper.c:12736
static int vtable_size(const struct vtable *tbl)
Definition: ripper.c:201
static int assign_in_cond(struct parser_params *parser, NODE *node)
Definition: ripper.c:15636
#define ISALPHA(c)
Definition: ruby.h:1636
void rb_exc_raise(VALUE mesg)
Definition: eval.c:527
#define STR_FUNC_REGEXP
Definition: ripper.c:12091
#define NEW_VCALL(m)
Definition: node.h:425
static NODE * list_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14827
int args
Definition: win32ole.c:785
#define strtod(s, e)
Definition: util.h:76
static rb_encoding * must_be_ascii_compatible(VALUE s)
Definition: ripper.c:11957
struct vtable * prev
Definition: ripper.c:185
int rb_is_const_id(ID id)
Definition: ripper.c:17046
int rb_is_instance_id(ID id)
Definition: ripper.c:17064
#define NEW_VALIAS(n, o)
Definition: node.h:439
#define RUBY_DTRACE_PARSE_END(arg0, arg1)
Definition: probes.h:72
#define RB_TYPE_P(obj, type)
Definition: ruby.h:1537
static int parser_tokadd_string(struct parser_params *, int, int, int, long *, rb_encoding **)
Definition: ripper.c:12576
#define NEW_LVAR(v)
Definition: node.h:406
#define VTBL_DEBUG
Definition: ripper.c:211
int rb_is_method_name(VALUE name)
Definition: ripper.c:17210
#define arg_append(h, t)
Definition: ripper.c:449
#define assignable_result(x)
int st_lookup(st_table *, st_data_t, st_data_t *)
#define CMDARG_PUSH(n)
Definition: ripper.c:176
#define NEW_ATTRASGN(r, m, a)
Definition: node.h:458
#define MEMZERO(p, type, n)
Definition: ruby.h:1241
Definition: ruby.h:842
#define RE_OPTION_MASK
Definition: ripper.c:585
#define ID_SCOPE_MASK
Definition: id.h:17
static NODE * arg_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15294
rb_encoding * enc
Definition: ripper.c:328
#define parser_warning(node, mesg)
Definition: ripper.c:14763
static int parser_regx_options(struct parser_params *)
Definition: ripper.c:12504
static void yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: ripper.c:4503
enum lex_state_e parser_lex_state
Definition: ripper.c:295
#define whole_match_p(e, l, i)
Definition: ripper.c:11607
#define op_tbl_count
Definition: ripper.c:16521
#define NEW_POSTEXE(b)
Definition: node.h:456
int capa
Definition: ripper.c:184
VALUE parser_lex_lastline
Definition: ripper.c:312
#define lex_nextline
Definition: ripper.c:386
#define YYTERROR
Definition: ripper.c:4421
NODE * rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: ripper.c:12036
#define set_yylval_literal(x)
Definition: ripper.c:11614
static int parser_yylex(struct parser_params *parser)
Definition: ripper.c:13423
static VALUE parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
Definition: ripper.c:12108
#define scan_hex(s, l, e)
Definition: util.h:54
static int dyna_in_block_gen(struct parser_params *)
Definition: ripper.c:16216
#define NEW_IF(c, t, e)
Definition: node.h:365
static const yytype_uint16 yystos[]
Definition: ripper.c:4267
static char * parser_tokspace(struct parser_params *parser, int n)
Definition: ripper.c:12219
#define RARRAY(obj)
Definition: ruby.h:1101
#define arg_ambiguous()
Definition: ripper.c:13075
#define ALLOC_N(type, n)
Definition: ruby.h:1223
void rb_compile_error_append(const char *fmt,...)
Definition: error.c:150
#define evstr2dstr(n)
Definition: ripper.c:458
static void parser_free(void *ptr)
Definition: ripper.c:17307
#define IS_ARG()
Definition: ripper.c:13402
#define PARSER_ARG
Definition: ripper.c:720
#define NEW_PRELUDE(p, b)
Definition: node.h:459
#define literal_concat(h, t)
Definition: ripper.c:453
#define val
int rb_ispunct(int c)
Definition: encoding.c:1892
Definition: parse.c:831
#define NEW_ARRAY(a)
Definition: node.h:386
RUBY_EXTERN VALUE rb_cObject
Definition: ruby.h:1426
VALUE rb_eRuntimeError
Definition: error.c:510
#define compile_error
Definition: ripper.c:719
static int symbols_i(VALUE sym, ID value, VALUE ary)
Definition: ripper.c:17014
#define ID_INSTANCE
Definition: id.h:19
#define yylval
Definition: ripper.c:11583
static int parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
Definition: ripper.c:12431
#define rb_enc_isascii(c, enc)
Definition: encoding.h:174
static int dvar_curr_gen(struct parser_params *, ID)
Definition: ripper.c:16253
VALUE rb_parser_encoding(VALUE vparser)
Definition: ripper.c:17410
#define ifndef_ripper(x)
Definition: ripper.c:685
static const yytype_uint16 yyrline[]
Definition: ripper.c:1460
void rb_str_free(VALUE)
Definition: string.c:830
struct parser_params * parser
Definition: ripper.c:16315
#define yytable_value_is_error(yytable_value)
Definition: ripper.c:3149
#define cur_mid
Definition: ripper.c:378
char * ruby_strdup(const char *)
Definition: util.c:454
#define NEW_HASH(a)
Definition: node.h:388
VALUE rb_get_coverages(void)
Definition: thread.c:5162
#define NEW_ZARRAY()
Definition: node.h:387
NODE * rb_compile_string(const char *f, VALUE s, int line)
Definition: ripper.c:12029
static const yytype_uint16 yyprhs[]
Definition: ripper.c:1198
#define NEW_FALSE()
Definition: node.h:452
VALUE rb_obj_as_string(VALUE)
Definition: string.c:895
static NODE * list_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14847
int parser_paren_nest
Definition: ripper.c:299
VALUE rb_ary_new(void)
Definition: array.c:424
long(* rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len)
Definition: ripper.c:13160
int rb_ascii8bit_encindex(void)
Definition: encoding.c:1162
#define NEW_ARGSPUSH(a, b)
Definition: node.h:433
static int is_global_name_punct(const char c)
Definition: ripper.c:12753
#define is_attrset_id(id)
Definition: ripper.c:114
#define set_yylval_name(x)
Definition: ripper.c:11613
#define NEW_REDO()
Definition: node.h:377
#define NEW_NTH_REF(n)
Definition: node.h:411
#define tokline
Definition: ripper.c:383
#define NEW_UNLESS(c, t, e)
Definition: node.h:366
static char * parser_newtok(struct parser_params *parser)
Definition: ripper.c:12203
RUBY_EXTERN VALUE rb_mKernel
Definition: ruby.h:1414
#define snprintf
Definition: subst.h:6
VALUE rb_thread_current(void)
Definition: thread.c:2350
static int vtable_included(const struct vtable *tbl, ID id)
Definition: ripper.c:253
#define block_dup_check(n1, n2)
Definition: ripper.c:440
#define tokadd(c)
Definition: ripper.c:11596
static NODE * arg_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15319
static void local_push_gen(struct parser_params *, int)
Definition: ripper.c:16068
#define NIL_P(v)
Definition: ruby.h:446
#define ISASCII(c)
Definition: ruby.h:1629
void st_add_direct(st_table *, st_data_t, st_data_t)
Definition: st.c:624
#define tokenbuf
Definition: ripper.c:380
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:499
static char msg[50]
Definition: strerror.c:8
ID rb_intern(const char *name)
Definition: ripper.c:16928
#define COND_POP()
Definition: ripper.c:172
#define NEW_GVAR(v)
Definition: node.h:405
#define heredoc_identifier()
Definition: ripper.c:11605
NODE * opt_args
Definition: node.h:519
static void parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13173
#define NEW_YIELD(a)
Definition: node.h:384
#define YYSYNTAX_ERROR
#define new_const_op_assign(lhs, op, rhs)
Definition: ripper.c:499
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:2202
VALUE value
Definition: node.h:245
static void parser_tokadd(struct parser_params *parser, int c)
Definition: ripper.c:12231
#define ID_SCOPE_SHIFT
Definition: id.h:16
#define k__END__
Definition: eventids2.c:9
static void parser_mark(void *ptr)
Definition: ripper.c:17281
static void yy_reduce_print(YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
Definition: ripper.c:4595
#define ISALNUM(c)
Definition: ruby.h:1635
#define YYDPRINTF(Args)
Definition: ripper.c:4474
#define NEW_CASE(h, b)
Definition: node.h:367
rb_atomic_t cnt[RUBY_NSIG]
Definition: signal.c:432
#define RFLOAT(obj)
Definition: ruby.h:1098
Definition: parse.c:829
#define lex_goto_eol(parser)
Definition: ripper.c:12124
static double one(void)
Definition: isinf.c:52
Definition: parse.c:827
Definition: parse.c:862
#define FLONUM_P(x)
Definition: ruby.h:375
#define local_id(id)
Definition: ripper.c:560
#define T_FLOAT
Definition: ruby.h:489
NODE * rb_parser_append_print(VALUE vparser, NODE *node)
Definition: ripper.c:16424
#define TYPE(x)
Definition: ruby.h:513
static void ripper_init_eventids1(void)
Definition: eventids1.c:134
int argc
Definition: ruby.c:130
Definition: node.h:59
yytype_int16 yyss_alloc
Definition: ripper.c:1080
static void vtable_add(struct vtable *tbl, ID id)
Definition: ripper.c:238
Definition: parse.c:850
char ary[RSTRING_EMBED_LEN_MAX+1]
Definition: ruby.h:853
#define YYFINAL
Definition: ripper.c:1134
#define Qfalse
Definition: ruby.h:433
#define dvar_curr(id)
Definition: ripper.c:575
static NODE * parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: ripper.c:12010
#define NEW_EVSTR(n)
Definition: node.h:422
#define ALLOCA_N(type, n)
Definition: ruby.h:1227
#define flush_string_content(enc)
Definition: ripper.c:12728
#define NEW_OP_CDECL(v, op, val)
Definition: node.h:404
#define T_BIGNUM
Definition: ruby.h:495
static VALUE coverage(const char *f, int n)
Definition: ripper.c:11865
#define ENC_CODERANGE_UNKNOWN
Definition: encoding.h:57
#define tokadd_string(f, t, p, n, e)
Definition: ripper.c:11601
static NODE * new_yield_gen(struct parser_params *, NODE *)
Definition: ripper.c:15847
#define ripper_flush(p)
Definition: ripper.c:11633
static VALUE lex_get_str(struct parser_params *parser, VALUE s)
Definition: ripper.c:11967
#define ISUPPER(c)
Definition: ruby.h:1633
#define RUBY_FUNC_EXPORTED
Definition: defines.h:184
#define MEMCPY(p1, p2, type, n)
Definition: ruby.h:1242
static int rb_str_symname_type(VALUE name)
Definition: ripper.c:16747
#define T_NODE
Definition: ruby.h:506
#define ENC_CODERANGE_BROKEN
Definition: encoding.h:60
Definition: parse.c:867
#define rb_enc_isupper(c, enc)
Definition: encoding.h:177
VALUE rb_enc_associate_index(VALUE obj, int idx)
Definition: encoding.c:748
int rb_parse_in_main(void)
Definition: compile.c:5882
static int parser_nextc(struct parser_params *parser)
Definition: ripper.c:12130
int err
Definition: win32.c:87
#define dyna_pop(node)
Definition: ripper.c:567
Definition: parse.c:843
#define OBJ_FREEZE(x)
Definition: ruby.h:1164
#define YYACCEPT
Definition: ripper.c:4382
const char * parser_lex_pend
Definition: ripper.c:316
static ID formal_argument_gen(struct parser_params *, ID)
Definition: ripper.c:13078
static void void_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15438
#define YYEOF
Definition: ripper.c:4380
#define nd_else
Definition: node.h:294
static NODE * dsym_node_gen(struct parser_params *, NODE *)
Definition: ripper.c:15941
void rb_gc_mark_symbols(void)
Definition: ripper.c:16590
long cnt
Definition: node.h:261
ID token
Definition: ripper.c:16497
static ID intern_str(VALUE str)
Definition: ripper.c:16815
#define YY_REDUCE_PRINT(Rule)
Definition: ripper.c:4617
NODE * rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
Definition: ripper.c:16456
NODE * rb_compile_cstr(const char *f, const char *s, int len, int line)
Definition: ripper.c:12043
token_info * parser_token_info
Definition: ripper.c:341
static void magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13164
int column
Definition: ripper.c:272
static char * yystpcpy(char *yydest, const char *yysrc)
Definition: ripper.c:4690
#define IS_lex_state(ls)
Definition: ripper.c:158
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:772
#define ALLOC(type)
Definition: ruby.h:1224
#define END(no)
Definition: re.c:26
#define NEW_FOR(v, i, b)
Definition: node.h:372
#define EOF
Definition: vsnprintf.c:207
void * rb_parser_malloc(struct parser_params *parser, size_t size)
Definition: ripper.c:17456
#define NEW_WHEN(c, t, e)
Definition: node.h:368
#define peek_n(c, n)
Definition: ripper.c:12127
VALUE rb_str_resize(VALUE, long)
Definition: string.c:1853
#define DEF_EXPR(n)
Definition: ripper.c:141
#define tHEREDOC_END
Definition: eventids2.c:8
#define STR_NEW(p, n)
Definition: ripper.c:357
#define NEW_DASGN(v, val)
Definition: node.h:392
YYSTYPE yyvs_alloc
Definition: ripper.c:1081
void(* rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13161
static int parser_peek_variable_name(struct parser_params *parser)
Definition: ripper.c:12760
#define tokcopy(n)
Definition: ripper.c:12254
#define STR_FUNC_SYMBOL
Definition: ripper.c:12093
static VALUE yycompile0(VALUE arg)
Definition: ripper.c:11888
#define mixed_escape(beg, enc1, enc2)
int rb_str_hash_cmp(VALUE, VALUE)
Definition: string.c:2254
#define set_yylval_num(x)
Definition: ripper.c:11611
static ID register_symid_str(ID, VALUE)
Definition: ripper.c:16764
#define NEW_ERRINFO()
Definition: node.h:453
#define NEW_BLOCK_PASS(b)
Definition: node.h:437
#define STR_FUNC_QWORDS
Definition: ripper.c:12092
Definition: parse.c:844
#define dyna_push()
Definition: ripper.c:565
#define command_start
Definition: ripper.c:391
string_type
Definition: ripper.c:12096
int rb_dvar_defined(ID id)
Definition: compile.c:5832
static void dispose_string(VALUE str)
Definition: ripper.c:12540
union RString::@73 as
union RNode::@94 u2
#define is_notop_id(id)
Definition: ripper.c:110
#define RSTRING_LEN(str)
Definition: ruby.h:862
static NODE * aryset_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15249
int parser_in_single
Definition: ripper.c:301
lex_state_bits
Definition: ripper.c:125
#define RUBY_DTRACE_PARSE_END_ENABLED()
Definition: probes.h:71
static ID shadowing_lvar_gen(struct parser_params *, ID)
Definition: ripper.c:15211
ID rest_arg
Definition: node.h:513
#define REALLOC_N(var, type, n)
Definition: ruby.h:1225
#define local_push(top)
Definition: ripper.c:552
int errno
#define TRUE
Definition: nkf.h:175
int rb_symname_p(const char *name)
Definition: ripper.c:16634
#define nd_next
Definition: node.h:290
#define new_attr_op_assign(lhs, type, attr, op, rhs)
Definition: ripper.c:497
#define NEW_CONST(v)
Definition: node.h:409
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
Definition: ripper.c:4564
#define NEW_LIT(l)
Definition: node.h:416
VALUE rb_io_gets(VALUE)
Definition: io.c:3110
#define paren_nest
Definition: ripper.c:372
#define token_info_pop(token)
Definition: ripper.c:736
static void dyna_pop_gen(struct parser_params *, const struct vtable *)
Definition: ripper.c:16202
static NODE * new_evstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:14978
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1270
#define IS_lex_state_for(x, ls)
Definition: ripper.c:157
#define tokadd_mbchar(c)
Definition: ripper.c:12560
static void reg_fragment_setenc_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16261
#define NEW_OP_ASGN_OR(i, val)
Definition: node.h:402
#define rb_enc_isspace(c, enc)
Definition: encoding.h:181
#define rb_node_newnode(type, a1, a2, a3)
Definition: ripper.c:419
#define YYMAXDEPTH
Definition: ripper.c:4649
#define NEW_NEXT(s)
Definition: node.h:376
static void set_file_encoding(struct parser_params *parser, const char *str, const char *send)
Definition: ripper.c:13335
#define const
Definition: strftime.c:102
#define rb_enc_name(enc)
Definition: encoding.h:124
union RNode::@95 u3
int rb_is_attrset_name(VALUE name)
Definition: ripper.c:17198
#define RE_OPTION_ONCE
Definition: ripper.c:580
int rb_enc_symname_p(const char *name, rb_encoding *enc)
Definition: ripper.c:16640
#define tokidx
Definition: ripper.c:381
#define malloc
Definition: ripper.c:98
static const struct magic_comment magic_comments[]
Definition: ripper.c:13200
void Init_sym(void)
Definition: ripper.c:16571
const char * name
Definition: ripper.c:16498
static int parser_parse_string(struct parser_params *, NODE *)
Definition: ripper.c:12796
#define nd_term(node)
Definition: ripper.c:595
#define STR_FUNC_EXPAND
Definition: ripper.c:12090
#define rb_warningS(fmt, a)
Definition: ripper.c:697
static NODE * new_args_tail_gen(struct parser_params *, NODE *, ID, ID)
Definition: ripper.c:15916
#define NEW_RESCUE(b, res, e)
Definition: node.h:380
static int dvar_defined_gen(struct parser_params *, ID, int)
Definition: ripper.c:16222
int rb_is_local_id(ID id)
Definition: ripper.c:17076
rb_magic_comment_length_t length
Definition: ripper.c:13197
int parser_in_def
Definition: ripper.c:302
#define is_global_id(id)
Definition: ripper.c:112
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1570
static int local_id_gen(struct parser_params *, ID)
Definition: ripper.c:16145
#define YYSIZE_T
Definition: ripper.c:960
#define ESCAPE_META
Definition: ripper.c:12330
VALUE parser_cur_mid
Definition: ripper.c:305
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4308
short int yytype_int16
Definition: ripper.c:947
Definition: parse.c:824
Definition: parse.c:864
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Definition: array.c:545
long parser_lex_gets_ptr
Definition: ripper.c:320
#define no_digits()
unsigned long ID
Definition: ruby.h:105
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1183
#define rb_enc_isalnum(c, enc)
Definition: encoding.h:179
static void rb_backref_error_gen(struct parser_params *, NODE *)
Definition: ripper.c:15281
#define rb_enc_isdigit(c, enc)
Definition: encoding.h:182
unsigned char yytype_uint8
Definition: ripper.c:926
#define nd_resq
Definition: node.h:298
static const yytype_int16 yyrhs[]
Definition: ripper.c:1265
#define Qnil
Definition: ruby.h:435
static void arg_ambiguous_gen(struct parser_params *parser)
Definition: ripper.c:13067
#define heredoc_restore(n)
Definition: ripper.c:11606
#define NEW_BACK_REF(n)
Definition: node.h:412
static void parser_prepare(struct parser_params *parser)
Definition: ripper.c:13378
static NODE * cond_gen(struct parser_params *, NODE *)
Definition: ripper.c:15800
Definition: parse.c:855
#define lex_lastline
Definition: ripper.c:385
int type
Definition: tcltklib.c:111
int id[2]
Definition: lex.c:33
#define NODE_FL_NEWLINE
Definition: node.h:269
static int options(unsigned char *cp)
Definition: nkf.c:6355
#define NEW_MASGN(l, r)
Definition: node.h:389
static const char *const yytname[]
Definition: ripper.c:1530
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: ripper.c:1100
#define NEW_COLON2(c, i)
Definition: node.h:444
unsigned long VALUE
Definition: ruby.h:104
stack_type parser_cond_stack
Definition: ripper.c:296
static VALUE result
Definition: nkf.c:40
NODE * post_init
Definition: node.h:506
static void ripper_init_eventids2(void)
Definition: eventids2.c:64
#define RBASIC(obj)
Definition: ruby.h:1094
int rb_is_junk_id(ID id)
Definition: ripper.c:17082
static void dyna_pop_1(struct parser_params *parser)
Definition: ripper.c:16184
static int parser_read_escape(struct parser_params *parser, int flags, rb_encoding **encp)
Definition: ripper.c:12333
int parser_heredoc_end
Definition: ripper.c:317
#define ruby_sourceline
Definition: ripper.c:397
static int parser_heredoc_identifier(struct parser_params *parser)
Definition: ripper.c:12854
#define rb_enc_ispunct(c, enc)
Definition: encoding.h:178
ID rb_id_attrset(ID id)
Definition: ripper.c:15265
static int value_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15376
#define NEW_KW_ARG(i, v)
Definition: node.h:430
void rb_mark_tbl(st_table *tbl)
Definition: gc.c:2541
int post_args_num
Definition: node.h:509
#define lex_pend
Definition: ripper.c:389
#define NEW_ENSURE(b, en)
Definition: node.h:382
yytokentype
Definition: parse.c:770
int rb_is_global_id(ID id)
Definition: ripper.c:17058
static int reg_fragment_check_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16300
static const yytype_int16 yycheck[]
Definition: ripper.c:3152
#define YYUSE(e)
Definition: ripper.c:980
#define lvtbl
Definition: ripper.c:395
#define lex_strterm
Definition: ripper.c:367
#define NEW_ZSUPER()
Definition: node.h:427
#define rb_enc_asciicompat(enc)
Definition: encoding.h:184
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
Definition: eval.c:804
VALUE flags
Definition: ruby.h:700
#define free
Definition: ripper.c:101
static NODE * new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
Definition: ripper.c:15997
#define set_yylval_str(x)
Definition: ripper.c:11610
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Definition: re.c:301
#define NEW_COLON3(i)
Definition: node.h:445
#define NEW_BLOCK(a)
Definition: node.h:364
#define cond_stack
Definition: ripper.c:369
short int yytype_int8
Definition: ripper.c:935
#define nd_body
Definition: node.h:293
VALUE flags
Definition: node.h:240
static int is_static_content(NODE *node)
Definition: ripper.c:15612
const char * token
Definition: ripper.c:270
#define ENCODING_IS_ASCII8BIT(obj)
Definition: encoding.h:52
VALUE rb_str_dup(VALUE)
Definition: string.c:946
#define RUBY_DTRACE_PARSE_BEGIN_ENABLED()
Definition: probes.h:67
static const yytype_int16 yypgoto[]
Definition: ripper.c:2005
static int arg_var_gen(struct parser_params *, ID)
Definition: ripper.c:16128
#define rb_enc_isalpha(c, enc)
Definition: encoding.h:175
#define is_local_id(id)
Definition: ripper.c:111
Definition: parse.c:845
void xfree(void *)
int parser_in_defined
Definition: ripper.c:306
static int literal_concat0(struct parser_params *, VALUE, VALUE)
Definition: ripper.c:14871
static ID * local_tbl_gen(struct parser_params *)
Definition: ripper.c:16113
#define LONG2NUM(x)
Definition: ruby.h:1199
int parser_class_nest
Definition: ripper.c:298
#define brace_nest
Definition: ripper.c:374
#define reg_named_capture_assign(regexp, match)
Definition: ripper.c:516
#define NEW_BEGIN(b)
Definition: node.h:379
static int parser_yyerror(struct parser_params *, const char *)
Definition: ripper.c:11783
#define HEAPCNT(n, size)
Definition: ripper.c:17450
static void warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15669
#define RSTRING_PTR(str)
Definition: ruby.h:866
int rb_is_const_name(VALUE name)
Definition: ripper.c:17174
#define is_asgn_or_id(id)
Definition: ripper.c:120
static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
Definition: ripper.c:12424
static void yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: ripper.c:4537
#define NEW_SPLAT(a)
Definition: node.h:434
static NODE * attrset_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:15273
int rb_is_local_name(VALUE name)
Definition: ripper.c:17204
VALUE rb_usascii_str_new2(const char *)
const struct vtable * vars
Definition: parse.h:168
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:2109
static VALUE reg_compile_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16395
st_table * st_init_table_with_size(const struct st_hash_type *, st_index_t)
Definition: st.c:229
#define ENCODING_GET(obj)
Definition: encoding.h:47
#define ESCAPE_CONTROL
Definition: ripper.c:12329
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:772
RUBY_EXTERN int ffs(int)
Definition: ffs.c:6
#define parser_isascii()
Definition: ripper.c:11706
void rb_gc_mark_parser(void)
Definition: ripper.c:16419
static const yytype_uint8 yytranslate[]
Definition: ripper.c:1155
#define RFLOAT_VALUE(v)
Definition: ruby.h:836
int nonspc
Definition: ripper.c:273
int size
Definition: encoding.c:52
#define NEW_DSTR(s)
Definition: node.h:418
#define ADD2HEAP(n, c, p)
Definition: ripper.c:17452
#define tokspace(n)
Definition: ripper.c:11595
#define f
#define in_def
Definition: ripper.c:376
#define INT2FIX(i)
Definition: ruby.h:241
static int is_private_local_id(ID name)
Definition: ripper.c:15198
#define NEW_GASGN(v, val)
Definition: node.h:390
#define is_const_id(id)
Definition: ripper.c:115
static int rb_enc_symname_type(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:16646
#define NEW_BREAK(s)
Definition: node.h:375
static void no_blockarg(struct parser_params *parser, NODE *node)
Definition: ripper.c:15822
static void local_pop_gen(struct parser_params *)
Definition: ripper.c:16083
Definition: parse.c:840
void rb_parser_free(struct parser_params *parser, void *ptr)
Definition: ripper.c:17496
int parser_tokidx
Definition: ripper.c:308
#define read_escape(flags, e)
Definition: ripper.c:11598
Definition: node.h:45
#define tok_hex(numlen)
Definition: ripper.c:11597
static NODE * literal_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14888
#define new_evstr(n)
Definition: ripper.c:456
#define xmalloc
Definition: defines.h:64
#define parser_warn(node, mesg)
Definition: ripper.c:14770
#define rb_compile_error
Definition: ripper.c:718
ID rb_intern_str(VALUE str)
Definition: ripper.c:16934
VALUE coverage
Definition: ripper.c:337
void rb_set_errinfo(VALUE err)
Definition: eval.c:1436
#define tokfix()
Definition: ripper.c:12197
#define NEW_TRUE()
Definition: node.h:451
#define internal_id()
Definition: ripper.c:562
NODE * parser_lex_strterm
Definition: ripper.c:294
const char * name
Definition: ripper.c:13195
#define COND_LEXPOP()
Definition: ripper.c:173
#define lex_p
Definition: ripper.c:388
#define tSP
Definition: eventids2.c:6
#define NEW_LAMBDA(a, b)
Definition: node.h:374
Definition: node.h:207
#define NEW_UNTIL(c, b, n)
Definition: node.h:371
static int token_info_get_column(struct parser_params *parser, const char *token)
Definition: ripper.c:11710
static const struct st_hash_type symhash
Definition: ripper.c:16538
#define node_assign(node1, node2)
Definition: ripper.c:493
static void void_stmts_gen(struct parser_params *, NODE *)
Definition: ripper.c:15527
#define void_expr(node)
Definition: ripper.c:434
static int local_var_gen(struct parser_params *, ID)
Definition: ripper.c:16135
#define RARRAY_PTR(a)
Definition: ruby.h:904
#define void_expr0(node)
Definition: ripper.c:433
#define lex_pbeg
Definition: ripper.c:387
#define regx_options()
Definition: ripper.c:11600
#define NEW_MODULE(n, b)
Definition: node.h:443
#define numberof(array)
Definition: ripper.c:92
static int token_info_has_nonspaces(struct parser_params *parser, const char *token)
Definition: ripper.c:11724
#define YYSTACK_ALLOC_MAXIMUM
Definition: ripper.c:1045
#define TOK_INTERN(mb)
Definition: ripper.c:362
static const rb_data_type_t parser_data_type
Definition: ripper.c:12007
rb_magic_comment_setter_t func
Definition: ripper.c:13196
int parser_lpar_beg
Definition: ripper.c:300
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:185
VALUE rb_check_string_type(VALUE)
Definition: string.c:1508
st_table * sym_id
Definition: ripper.c:16529
Definition: parse.c:848
uint8_t key[16]
Definition: random.c:1370
#define nd_head
Definition: node.h:288
struct local_vars * prev
Definition: ripper.c:192
static const yytype_uint16 yydefact[]
Definition: ripper.c:1756
static NODE * new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: ripper.c:15968
#define LONG2FIX(i)
Definition: ruby.h:242
#define parser_encoding_name()
Definition: ripper.c:11700
#define tokadd_escape(e)
Definition: ripper.c:11599
#define NEW_WHILE(c, b, n)
Definition: node.h:370
struct vtable * vars
Definition: ripper.c:190
#define RTEST(v)
Definition: ruby.h:445
Definition: node.h:139
#define T_STRING
Definition: ruby.h:490
static const yytype_int16 yypact[]
Definition: ripper.c:1894
static VALUE lex_io_gets(struct parser_params *parser, VALUE io)
Definition: ripper.c:12057
#define new_yield(node)
Definition: ripper.c:476
#define lvar_defined(id)
Definition: ripper.c:578
#define NEW_POSTARG(i, v)
Definition: node.h:431
#define RREGEXP(obj)
Definition: ruby.h:1100
#define NEW_UNDEF(i)
Definition: node.h:440
struct rb_encoding_entry * list
Definition: encoding.c:50
#define lpar_beg
Definition: ripper.c:373
#define YYTRANSLATE(YYX)
Definition: ripper.c:1151
void * rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
Definition: ripper.c:17466
rb_encoding * rb_filesystem_encoding(void)
Definition: encoding.c:1248
v
Definition: win32ole.c:798
#define ID_ATTRSET
Definition: id.h:21
#define T_FILE
Definition: ruby.h:496
#define NEW_CVASGN(v, val)
Definition: node.h:397
#define yyerror(msg)
Definition: ripper.c:365
#define is_junk_id(id)
Definition: ripper.c:117
static void new_bv_gen(struct parser_params *, ID)
Definition: ripper.c:15235
#define deferred_nodes
Definition: ripper.c:392
#define ruby_coverage
Definition: ripper.c:406
#define NEW_FCALL(m, a)
Definition: node.h:424
Definition: parse.c:842
int linenum
Definition: ripper.c:271
static NODE * negate_lit(NODE *)
Definition: ripper.c:15855
#define tEMBDOC
Definition: eventids2.c:4
#define NEW_OP_ASGN2(r, i, o, val)
Definition: node.h:400
#define id_type(id)
Definition: ripper.c:118
#define NEW_MATCH3(r, n2)
Definition: node.h:415
Definition: parse.c:861
static void fixup_nodes(NODE **)
Definition: ripper.c:15675
#define DVARS_INHERIT
Definition: ripper.c:195
#define STR_NEW3(p, n, e, func)
Definition: ripper.c:360
char * parser_tokenbuf
Definition: ripper.c:307
VALUE rb_cArray
Definition: array.c:29
static const char * magic_comment_marker(const char *str, long len)
Definition: ripper.c:13208
#define NEW_OPT_ARG(i, v)
Definition: node.h:429
#define BEG(no)
Definition: re.c:25
static unsigned int hash(const char *str, unsigned int len)
Definition: lex.c:56
static int parser_magic_comment(struct parser_params *parser, const char *str, long len)
Definition: ripper.c:13241
int parser_tokline
Definition: ripper.c:310
#define IS_LABEL_POSSIBLE()
Definition: ripper.c:13406
VALUE rb_ary_new2(long capa)
Definition: array.c:417
const char * parser_lex_pbeg
Definition: ripper.c:314
int rb_is_class_id(ID id)
Definition: ripper.c:17052
#define DVARS_TOPSCOPE
Definition: ripper.c:196
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
Definition: string.c:439
#define YYCASE_(N, S)
#define rb_safe_level()
Definition: tcltklib.c:94
VALUE rb_parser_new(void)
Definition: ripper.c:17381
Definition: ripper.c:181
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:1882
static void parser_set_encode(struct parser_params *parser, const char *name)
Definition: ripper.c:13116
#define call_uni_op(recv, id)
Definition: ripper.c:464
static int literal_node(NODE *node)
Definition: ripper.c:15722
#define set_yylval_node(x)
Definition: ripper.c:11615
#define YYSTACK_BYTES(N)
Definition: ripper.c:1089
#define IS_BEG()
Definition: ripper.c:13404
const char * parser_lex_p
Definition: ripper.c:315
static int parser_tok_hex(struct parser_params *parser, size_t *numlen)
Definition: ripper.c:12241
Definition: parse.c:839
#define xrealloc
Definition: defines.h:67
#define RE_OPTION_ENCODING_NONE(o)
Definition: ripper.c:584
lex_state_e
Definition: ripper.c:140
#define ID2SYM(x)
Definition: ruby.h:363
Definition: node.h:61
#define dvar_defined_get(id)
Definition: ripper.c:573
int rb_is_instance_name(VALUE name)
Definition: ripper.c:17192
int parser_ruby_sourceline
Definition: ripper.c:327
const char * rb_id2name(ID id)
Definition: ripper.c:17005
#define NEW_RETRY()
Definition: node.h:378
#define ruby_eval_tree_begin
Definition: ripper.c:404
#define rb_errinfo()
Definition: tcltklib.c:89
unsigned long st_data_t
Definition: st.h:35
#define StringValuePtr(v)
Definition: ruby.h:547
#define formal_argument(id)
Definition: ripper.c:545
#define nd_value
Definition: node.h:318
#define ID_INTERNAL
Definition: id.h:25
Definition: parse.c:849
static int nodeline(NODE *node)
Definition: ripper.c:14734
#define dispatch_heredoc_end()
Definition: ripper.c:12960
YYSTYPE * parser_yylval
Definition: ripper.c:291
#define ruby_eval_tree
Definition: ripper.c:403
#define toklast()
Definition: ripper.c:12200
#define lex_gets
Definition: ripper.c:394
#define toklen()
Definition: ripper.c:12199
static const yytype_uint8 yyr2[]
Definition: ripper.c:1687
#define NEW_RESBODY(a, ex, n)
Definition: node.h:381
Definition: parse.c:851
#define NEW_ARGSCAT(a, b)
Definition: node.h:432
#define NEW_DASGN_CURR(v, val)
Definition: node.h:393
VALUE rb_inspect(VALUE)
Definition: object.c:402
#define cmdarg_stack
Definition: ripper.c:370
#define in_single
Definition: ripper.c:375
#define YY_STACK_PRINT(Bottom, Top)
Definition: ripper.c:4578
#define YYFPRINTF
Definition: ripper.c:4471
#define NEW_SUPER(a)
Definition: node.h:426
#define NEW_CALL(r, m, a)
Definition: node.h:423
int is_ripper
Definition: ripper.c:288
static NODE * cond0(struct parser_params *, NODE *)
Definition: ripper.c:15743
rb_encoding * rb_ascii8bit_encoding(void)
Definition: encoding.c:1153
int rb_is_junk_name(VALUE name)
Definition: ripper.c:17220
#define peek(c)
Definition: ripper.c:12126
int rb_enc_find_index(const char *name)
Definition: encoding.c:635
static NODE * splat_array(NODE *)
Definition: ripper.c:15337
static struct vtable * vtable_alloc(struct vtable *prev)
Definition: ripper.c:214
VALUE eofp
Definition: ripper.c:292
Definition: node.h:31
RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e-0x20+31)/32]
Definition: ripper.c:12731
long len
Definition: ruby.h:846
#define CONST_ID(var, str)
Definition: ruby.h:1318
NODE * heap
Definition: ripper.c:289
ID rb_intern3(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:16793
#define attrset(node, id)
Definition: ripper.c:488
#define NEW_CVAR(v)
Definition: node.h:410
#define COND_P()
Definition: ripper.c:174
#define mixed_error(enc1, enc2)
static ID register_symid(ID, const char *, long, rb_encoding *)
Definition: ripper.c:16757
Definition: parse.c:866
#define NEW_MATCH2(n1, n2)
Definition: node.h:414
static const struct vtable * dyna_push_gen(struct parser_params *)
Definition: ripper.c:16173
ID first_post_arg
Definition: node.h:511
void * rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
Definition: ripper.c:17476
st_table * st_init_numtable_with_size(st_index_t)
Definition: st.c:278
#define shadowing_lvar(name)
Definition: ripper.c:547
Definition: parse.c:854
VALUE rb_cstr_to_inum(const char *str, int base, int badcheck)
Definition: bignum.c:579
#define get_value(val)
Definition: ripper.c:519
Definition: id.h:71
#define rb_enc_mbcput(c, buf, enc)
Definition: encoding.h:161
#define NEW_DVAR(v)
Definition: node.h:407
#define NEW_DEFN(i, a, d, p)
Definition: node.h:360
#define reg_fragment_check(str, options)
Definition: ripper.c:514
int rb_parse_in_eval(void)
Definition: compile.c:5876
VALUE rb_str_buf_new(long)
Definition: string.c:777
VALUE rb_usascii_str_new(const char *, long)
Definition: string.c:431
#define compile_for_eval
Definition: ripper.c:377
#define SYMBOL_P(x)
Definition: ruby.h:362
#define tCOMMENT
Definition: eventids2.c:2
NODE * kw_args
Definition: node.h:516
#define set_yylval_id(x)
Definition: ripper.c:11612
ID rb_intern2(const char *name, long len)
Definition: ripper.c:16921
#define nd_iter
Definition: node.h:316
#define nd_set_line(n, l)
Definition: node.h:283
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1264
NODE * rb_compile_file(const char *f, VALUE file, int start)
Definition: ripper.c:12063
Definition: parse.c:836
static int is_special_global_name(const char *m, const char *e, rb_encoding *enc)
Definition: ripper.c:16608
#define is_class_id(id)
Definition: ripper.c:116
#define LVAR_USED
Definition: ripper.c:15208
static NODE * assignable_gen(struct parser_params *, ID, NODE *)
Definition: ripper.c:15119
VALUE rb_parser_get_yydebug(VALUE self)
Definition: ripper.c:17425
VALUE(* parser_lex_gets)(struct parser_params *, VALUE)
Definition: ripper.c:321
#define NULL
Definition: _sdbm.c:103
#define RTYPEDDATA_TYPE(v)
Definition: ruby.h:988
#define NEW_LASGN(v, val)
Definition: node.h:391
#define FIX2LONG(x)
Definition: ruby.h:353
#define Qundef
Definition: ruby.h:436
VALUE rb_hash_aset(VALUE, VALUE, VALUE)
#define tIGNORED_NL
Definition: eventids2.c:1
NODE * rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
Definition: ripper.c:12050
#define NEW_STR(s)
Definition: node.h:417
#define yypact_value_is_default(yystate)
Definition: ripper.c:3146
Definition: parse.c:835
NODE * kw_rest_arg
Definition: node.h:517
#define ID_GLOBAL
Definition: id.h:20
#define ISXDIGIT(c)
Definition: ruby.h:1638
#define rb_warn0(fmt)
Definition: ripper.c:692
#define ENCODING_SET(obj, i)
Definition: encoding.h:37
int rb_local_defined(ID id)
Definition: compile.c:5857
st_index_t num_entries
Definition: st.h:93
Definition: parse.c:846
#define NEW_SELF()
Definition: node.h:449
Definition: parse.c:822
NODE * parser_eval_tree_begin
Definition: ripper.c:334
static int match(VALUE str, VALUE pat, VALUE hash, int(*cb)(VALUE, VALUE))
Definition: date_parse.c:273
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1344
Definition: parse.c:853
#define ruby_verbose
Definition: ruby.h:1363
VALUE rb_str_append(VALUE, VALUE)
Definition: string.c:2121
#define new_bv(id)
Definition: ripper.c:549
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
Definition: st.c:1000
static void warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15663
#define NEW_NODE(t, a0, a1, a2)
Definition: node.h:358
#define NEW_ARGS_AUX(r, b)
Definition: node.h:428
#define RSTRING_NOEMBED
Definition: ruby.h:856
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:80
#define block_append(h, t)
Definition: ripper.c:443
#define NEW_ALIAS(n, o)
Definition: node.h:438
VALUE rb_eArgError
Definition: error.c:512
static void vtable_free(struct vtable *tbl)
Definition: ripper.c:226
#define nd_lit
Definition: node.h:321
#define rb_enc_prev_char(s, p, e, enc)
Definition: encoding.h:164
#define T_REGEXP
Definition: ruby.h:491
Definition: node.h:137
unsigned long ruby_scan_oct(const char *, size_t, size_t *)
Definition: util.c:28
#define heredoc_end
Definition: ripper.c:390
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1122
struct vtable * args
Definition: ripper.c:189
#define tokaddmbc(c, enc)
Definition: ripper.c:11603
#define NEW_CDECL(v, val, path)
Definition: node.h:396
#define NEW_DEFS(r, i, a, d)
Definition: node.h:361
char ** argv
Definition: ruby.c:131
#define tEMBDOC_END
Definition: eventids2.c:5
char * ptr
Definition: ruby.h:847
#define DBL2NUM(dbl)
Definition: ruby.h:837
static void ripper_init_eventids2_table(VALUE self)
Definition: eventids2table.c:2
Definition: parse.c:847
#define ISSPACE(c)
Definition: ruby.h:1632
#define StringValue(v)
Definition: ruby.h:546
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:2074
#define pushback(c)
Definition: ripper.c:11593
#define STR_NEW2(p)
Definition: ripper.c:359
#define YYINITDEPTH
Definition: ripper.c:4638
static int sym_check_asciionly(VALUE str)
Definition: ripper.c:16773
rb_encoding * rb_enc_from_index(int index)
Definition: encoding.c:548
#define aryset(node1, node2)
Definition: ripper.c:486
static NODE * reg_named_capture_assign_gen(struct parser_params *parser, VALUE regexp, NODE *match)
Definition: ripper.c:16363
#define IS_AFTER_OPERATOR()
Definition: ripper.c:13408
VALUE rb_str_new(const char *, long)
Definition: string.c:425
Definition: parse.c:826
#define xcalloc
Definition: defines.h:66
#define ID_CLASS
Definition: id.h:23
static NODE * new_args_gen(struct parser_params *, NODE *, NODE *, ID, NODE *, NODE *)
Definition: ripper.c:15894
Definition: parse.c:841
int rb_is_global_name(VALUE name)
Definition: ripper.c:17186
static int parser_tokadd_mbchar(struct parser_params *parser, int c)
Definition: ripper.c:12547