Ruby  2.0.0p598(2014-11-13revision48408)
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  stack_type cmdargs;
194 };
195 
196 #define DVARS_INHERIT ((void*)1)
197 #define DVARS_TOPSCOPE NULL
198 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
199 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
200 
201 static int
202 vtable_size(const struct vtable *tbl)
203 {
204  if (POINTER_P(tbl)) {
205  return tbl->pos;
206  }
207  else {
208  return 0;
209  }
210 }
211 
212 #define VTBL_DEBUG 0
213 
214 static struct vtable *
216 {
217  struct vtable *tbl = ALLOC(struct vtable);
218  tbl->pos = 0;
219  tbl->capa = 8;
220  tbl->tbl = ALLOC_N(ID, tbl->capa);
221  tbl->prev = prev;
222  if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
223  return tbl;
224 }
225 
226 static void
228 {
229  if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
230  if (POINTER_P(tbl)) {
231  if (tbl->tbl) {
232  xfree(tbl->tbl);
233  }
234  xfree(tbl);
235  }
236 }
237 
238 static void
239 vtable_add(struct vtable *tbl, ID id)
240 {
241  if (!POINTER_P(tbl)) {
242  rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
243  }
244  if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
245 
246  if (tbl->pos == tbl->capa) {
247  tbl->capa = tbl->capa * 2;
248  REALLOC_N(tbl->tbl, ID, tbl->capa);
249  }
250  tbl->tbl[tbl->pos++] = id;
251 }
252 
253 static int
254 vtable_included(const struct vtable * tbl, ID id)
255 {
256  int i;
257 
258  if (POINTER_P(tbl)) {
259  for (i = 0; i < tbl->pos; i++) {
260  if (tbl->tbl[i] == id) {
261  return i+1;
262  }
263  }
264  }
265  return 0;
266 }
267 
268 
269 #ifndef RIPPER
270 typedef struct token_info {
271  const char *token;
272  int linenum;
273  int column;
274  int nonspc;
275  struct token_info *next;
276 } token_info;
277 #endif
278 
279 /*
280  Structure of Lexer Buffer:
281 
282  lex_pbeg tokp lex_p lex_pend
283  | | | |
284  |-----------+--------------+------------|
285  |<------------>|
286  token
287 */
291 
294 
297  stack_type parser_cond_stack;
315  const char *parser_lex_pbeg;
316  const char *parser_lex_p;
317  const char *parser_lex_pend;
327  char *parser_ruby_sourcefile; /* current source file */
328  int parser_ruby_sourceline; /* current line no. */
331 
333 
334 #ifndef RIPPER
335  /* Ruby core only */
340  int nerr;
341 
344 #else
345  /* Ripper only */
346  const char *tokp;
347  VALUE delayed;
348  int delayed_line;
349  int delayed_col;
350 
351  VALUE value;
352  VALUE result;
353  VALUE parsing_thread;
354  int toplevel_p;
355 #endif
356 };
357 
358 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)
359 #define STR_NEW0() rb_enc_str_new(0,0,current_enc)
360 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)
361 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)
362 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
363 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc)
364 
365 static int parser_yyerror(struct parser_params*, const char*);
366 #define yyerror(msg) parser_yyerror(parser, (msg))
367 
368 #define lex_strterm (parser->parser_lex_strterm)
369 #define lex_state (parser->parser_lex_state)
370 #define cond_stack (parser->parser_cond_stack)
371 #define cmdarg_stack (parser->parser_cmdarg_stack)
372 #define class_nest (parser->parser_class_nest)
373 #define paren_nest (parser->parser_paren_nest)
374 #define lpar_beg (parser->parser_lpar_beg)
375 #define brace_nest (parser->parser_brace_nest)
376 #define in_single (parser->parser_in_single)
377 #define in_def (parser->parser_in_def)
378 #define compile_for_eval (parser->parser_compile_for_eval)
379 #define cur_mid (parser->parser_cur_mid)
380 #define in_defined (parser->parser_in_defined)
381 #define tokenbuf (parser->parser_tokenbuf)
382 #define tokidx (parser->parser_tokidx)
383 #define toksiz (parser->parser_toksiz)
384 #define tokline (parser->parser_tokline)
385 #define lex_input (parser->parser_lex_input)
386 #define lex_lastline (parser->parser_lex_lastline)
387 #define lex_nextline (parser->parser_lex_nextline)
388 #define lex_pbeg (parser->parser_lex_pbeg)
389 #define lex_p (parser->parser_lex_p)
390 #define lex_pend (parser->parser_lex_pend)
391 #define heredoc_end (parser->parser_heredoc_end)
392 #define command_start (parser->parser_command_start)
393 #define deferred_nodes (parser->parser_deferred_nodes)
394 #define lex_gets_ptr (parser->parser_lex_gets_ptr)
395 #define lex_gets (parser->parser_lex_gets)
396 #define lvtbl (parser->parser_lvtbl)
397 #define ruby__end__seen (parser->parser_ruby__end__seen)
398 #define ruby_sourceline (parser->parser_ruby_sourceline)
399 #define ruby_sourcefile (parser->parser_ruby_sourcefile)
400 #define ruby_sourcefile_string (parser->parser_ruby_sourcefile_string)
401 #define current_enc (parser->enc)
402 #define yydebug (parser->parser_yydebug)
403 #ifdef RIPPER
404 #else
405 #define ruby_eval_tree (parser->parser_eval_tree)
406 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin)
407 #define ruby_debug_lines (parser->debug_lines)
408 #define ruby_coverage (parser->coverage)
409 #endif
410 
411 #if YYPURE
412 static int yylex(void*, void*);
413 #else
414 static int yylex(void*);
415 #endif
416 
417 #ifndef RIPPER
418 #define yyparse ruby_yyparse
419 
420 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
421 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
422 
423 static NODE *cond_gen(struct parser_params*,NODE*);
424 #define cond(node) cond_gen(parser, (node))
425 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
426 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
427 
428 static NODE *newline_node(NODE*);
429 static void fixpos(NODE*,NODE*);
430 
431 static int value_expr_gen(struct parser_params*,NODE*);
432 static void void_expr_gen(struct parser_params*,NODE*);
433 static NODE *remove_begin(NODE*);
434 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
435 #define void_expr0(node) void_expr_gen(parser, (node))
436 #define void_expr(node) void_expr0((node) = remove_begin(node))
437 static void void_stmts_gen(struct parser_params*,NODE*);
438 #define void_stmts(node) void_stmts_gen(parser, (node))
439 static void reduce_nodes_gen(struct parser_params*,NODE**);
440 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
441 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
442 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
443 
444 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
445 #define block_append(h,t) block_append_gen(parser,(h),(t))
446 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
447 #define list_append(l,i) list_append_gen(parser,(l),(i))
448 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
449 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
450 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
451 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
452 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
453 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
454 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
455 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
456 static int literal_concat0(struct parser_params *, VALUE, VALUE);
457 static NODE *new_evstr_gen(struct parser_params*,NODE*);
458 #define new_evstr(n) new_evstr_gen(parser,(n))
459 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
460 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
461 static NODE *splat_array(NODE*);
462 
463 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
464 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
465 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
466 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
467 
468 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
469 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
470 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);
471 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
472 
473 static NODE *negate_lit(NODE*);
474 static NODE *ret_args_gen(struct parser_params*,NODE*);
475 #define ret_args(node) ret_args_gen(parser, (node))
476 static NODE *arg_blk_pass(NODE*,NODE*);
477 static NODE *new_yield_gen(struct parser_params*,NODE*);
478 #define new_yield(node) new_yield_gen(parser, (node))
479 static NODE *dsym_node_gen(struct parser_params*,NODE*);
480 #define dsym_node(node) dsym_node_gen(parser, (node))
481 
482 static NODE *gettable_gen(struct parser_params*,ID);
483 #define gettable(id) gettable_gen(parser,(id))
484 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
485 #define assignable(id,node) assignable_gen(parser, (id), (node))
486 
487 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
488 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
489 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
490 #define attrset(node,id) attrset_gen(parser, (node), (id))
491 
492 static void rb_backref_error_gen(struct parser_params*,NODE*);
493 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
494 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
495 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
496 
497 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
498 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
499 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
500 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
501 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
502 
503 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
504 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
505 
506 static ID *local_tbl_gen(struct parser_params*);
507 #define local_tbl() local_tbl_gen(parser)
508 
509 static void fixup_nodes(NODE **);
510 
511 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
512 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
513 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
514 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
515 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
516 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
518 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
519 
520 #define get_id(id) (id)
521 #define get_value(val) (val)
522 #else
523 #define value_expr(node) ((void)(node))
524 #define remove_begin(node) (node)
525 #define rb_dvar_defined(id) 0
526 #define rb_local_defined(id) 0
527 static ID ripper_get_id(VALUE);
528 #define get_id(id) ripper_get_id(id)
529 static VALUE ripper_get_value(VALUE);
530 #define get_value(val) ripper_get_value(val)
531 static VALUE assignable_gen(struct parser_params*,VALUE);
532 #define assignable(lhs,node) assignable_gen(parser, (lhs))
533 static int id_is_var_gen(struct parser_params *parser, ID id);
534 #define id_is_var(id) id_is_var_gen(parser, (id))
535 
536 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2))
537 
538 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
540 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
541 
542 #endif /* !RIPPER */
543 
544 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
545 
546 static ID formal_argument_gen(struct parser_params*, ID);
547 #define formal_argument(id) formal_argument_gen(parser, (id))
548 static ID shadowing_lvar_gen(struct parser_params*,ID);
549 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
550 static void new_bv_gen(struct parser_params*,ID);
551 #define new_bv(id) new_bv_gen(parser, (id))
552 
553 static void local_push_gen(struct parser_params*,int);
554 #define local_push(top) local_push_gen(parser,(top))
555 static void local_pop_gen(struct parser_params*);
556 #define local_pop() local_pop_gen(parser)
557 static int local_var_gen(struct parser_params*, ID);
558 #define local_var(id) local_var_gen(parser, (id))
559 static int arg_var_gen(struct parser_params*, ID);
560 #define arg_var(id) arg_var_gen(parser, (id))
561 static int local_id_gen(struct parser_params*, ID);
562 #define local_id(id) local_id_gen(parser, (id))
563 static ID internal_id_gen(struct parser_params*);
564 #define internal_id() internal_id_gen(parser)
565 
566 static const struct vtable *dyna_push_gen(struct parser_params *);
567 #define dyna_push() dyna_push_gen(parser)
568 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
569 #define dyna_pop(node) dyna_pop_gen(parser, (node))
570 static int dyna_in_block_gen(struct parser_params*);
571 #define dyna_in_block() dyna_in_block_gen(parser)
572 #define dyna_var(id) local_var(id)
573 static int dvar_defined_gen(struct parser_params*,ID,int);
574 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
575 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
576 static int dvar_curr_gen(struct parser_params*,ID);
577 #define dvar_curr(id) dvar_curr_gen(parser, (id))
578 
579 static int lvar_defined_gen(struct parser_params*, ID);
580 #define lvar_defined(id) lvar_defined_gen(parser, (id))
581 
582 #define RE_OPTION_ONCE (1<<16)
583 #define RE_OPTION_ENCODING_SHIFT 8
584 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
585 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
586 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
587 #define RE_OPTION_MASK 0xff
588 #define RE_OPTION_ARG_ENCODING_NONE 32
589 
590 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
591 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
592 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
593 #define nd_func u1.id
594 #if SIZEOF_SHORT == 2
595 #define nd_term(node) ((signed short)(node)->u2.id)
596 #else
597 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
598 #endif
599 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
600 #define nd_nest u3.cnt
601 
602 /****** Ripper *******/
603 
604 #ifdef RIPPER
605 #define RIPPER_VERSION "0.1.0"
606 
607 #include "eventids1.c"
608 #include "eventids2.c"
609 
610 static VALUE ripper_dispatch0(struct parser_params*,ID);
611 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
612 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
613 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
614 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
615 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
616 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
617 
618 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
619 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
620 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
621 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
622 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
623 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
624 #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))
625 
626 #define yyparse ripper_yyparse
627 
628 #define ripper_intern(s) ID2SYM(rb_intern(s))
629 static VALUE ripper_id2sym(ID);
630 #ifdef __GNUC__
631 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
632  ID2SYM(id) : ripper_id2sym(id))
633 #endif
634 
635 #define arg_new() dispatch0(args_new)
636 #define arg_add(l,a) dispatch2(args_add, (l), (a))
637 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
638 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
639 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
640 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
641 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
642 
643 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
644 #define mrhs_new() dispatch0(mrhs_new)
645 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
646 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
647 
648 #define mlhs_new() dispatch0(mlhs_new)
649 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
650 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
651 
652 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
653  dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
654 
655 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
656 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
657 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
658 
659 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
660 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
661 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
662 
663 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
664 
665 static inline VALUE
667 {
668  NODE *t = (NODE *)tail;
669  VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
670  return params_new(f, o, r, p, k, kr, escape_Qundef(b));
671 }
672 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
673 
674 static inline VALUE
675 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
676 {
677  return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);
678 }
679 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
680 
681 #define FIXME 0
682 
683 #endif /* RIPPER */
684 
685 #ifndef RIPPER
686 # define Qnone 0
687 # define ifndef_ripper(x) (x)
688 #else
689 # define Qnone Qnil
690 # define ifndef_ripper(x)
691 #endif
692 
693 #ifndef RIPPER
694 # define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
695 # define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
696 # define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
697 # define rb_warn4S(file,line,fmt,a) rb_compile_warn((file), (line), (fmt), (a))
698 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
699 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
700 #else
701 # define rb_warn0(fmt) ripper_warn0(parser, (fmt))
702 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))
703 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))
704 # define rb_warn4S(file,line,fmt,a) ripper_warnS(parser, (fmt), (a))
705 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
706 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
707 static void ripper_warn0(struct parser_params*, const char*);
708 static void ripper_warnI(struct parser_params*, const char*, int);
709 static void ripper_warnS(struct parser_params*, const char*, const char*);
710 static void ripper_warning0(struct parser_params*, const char*);
711 static void ripper_warningS(struct parser_params*, const char*, const char*);
712 #endif
713 
714 #ifdef RIPPER
715 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
716 # define rb_compile_error ripper_compile_error
717 # define compile_error ripper_compile_error
718 # define PARSER_ARG parser,
719 #else
720 # define rb_compile_error rb_compile_error_with_enc
721 # define compile_error parser->nerr++,rb_compile_error_with_enc
722 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
723 #endif
724 
725 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
726  for instance). This is too low for Ruby to parse some files, such as
727  date/format.rb, therefore bump the value up to at least Bison's default. */
728 #ifdef OLD_YACC
729 #ifndef YYMAXDEPTH
730 #define YYMAXDEPTH 10000
731 #endif
732 #endif
733 
734 #ifndef RIPPER
735 static void token_info_push(struct parser_params*, const char *token);
736 static void token_info_pop(struct parser_params*, const char *token);
737 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
738 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
739 #else
740 #define token_info_push(token) /* nothing */
741 #define token_info_pop(token) /* nothing */
742 #endif
743 
744 
745 /* Line 268 of yacc.c */
746 #line 747 "parse.c"
747 
748 /* Enabling traces. */
749 #ifndef YYDEBUG
750 # define YYDEBUG 1
751 #endif
752 
753 /* Enabling verbose error messages. */
754 #ifdef YYERROR_VERBOSE
755 # undef YYERROR_VERBOSE
756 # define YYERROR_VERBOSE 1
757 #else
758 # define YYERROR_VERBOSE 0
759 #endif
760 
761 /* Enabling the token table. */
762 #ifndef YYTOKEN_TABLE
763 # define YYTOKEN_TABLE 0
764 #endif
765 
766 
767 /* Tokens. */
768 #ifndef YYTOKENTYPE
769 # define YYTOKENTYPE
770  /* Put the tokens into the symbol table, so that GDB and other debuggers
771  know about them. */
772  enum yytokentype {
773  END_OF_INPUT = 0,
774  keyword_class = 258,
775  keyword_module = 259,
776  keyword_def = 260,
777  keyword_undef = 261,
778  keyword_begin = 262,
779  keyword_rescue = 263,
780  keyword_ensure = 264,
781  keyword_end = 265,
782  keyword_if = 266,
783  keyword_unless = 267,
784  keyword_then = 268,
785  keyword_elsif = 269,
786  keyword_else = 270,
787  keyword_case = 271,
788  keyword_when = 272,
789  keyword_while = 273,
790  keyword_until = 274,
791  keyword_for = 275,
792  keyword_break = 276,
793  keyword_next = 277,
794  keyword_redo = 278,
795  keyword_retry = 279,
796  keyword_in = 280,
797  keyword_do = 281,
798  keyword_do_cond = 282,
799  keyword_do_block = 283,
800  keyword_do_LAMBDA = 284,
801  keyword_return = 285,
802  keyword_yield = 286,
803  keyword_super = 287,
804  keyword_self = 288,
805  keyword_nil = 289,
806  keyword_true = 290,
807  keyword_false = 291,
808  keyword_and = 292,
809  keyword_or = 293,
810  keyword_not = 294,
811  modifier_if = 295,
812  modifier_unless = 296,
813  modifier_while = 297,
814  modifier_until = 298,
815  modifier_rescue = 299,
816  keyword_alias = 300,
817  keyword_defined = 301,
818  keyword_BEGIN = 302,
819  keyword_END = 303,
820  keyword__LINE__ = 304,
821  keyword__FILE__ = 305,
822  keyword__ENCODING__ = 306,
823  tIDENTIFIER = 307,
824  tFID = 308,
825  tGVAR = 309,
826  tIVAR = 310,
827  tCONSTANT = 311,
828  tCVAR = 312,
829  tLABEL = 313,
830  tINTEGER = 314,
831  tFLOAT = 315,
832  tSTRING_CONTENT = 316,
833  tCHAR = 317,
834  tNTH_REF = 318,
835  tBACK_REF = 319,
836  tREGEXP_END = 320,
837  tUPLUS = 130,
838  tUMINUS = 131,
839  tPOW = 132,
840  tCMP = 134,
841  tEQ = 139,
842  tEQQ = 140,
843  tNEQ = 141,
844  tGEQ = 138,
845  tLEQ = 137,
846  tANDOP = 321,
847  tOROP = 322,
848  tMATCH = 142,
849  tNMATCH = 143,
850  tDOT2 = 128,
851  tDOT3 = 129,
852  tAREF = 144,
853  tASET = 145,
854  tLSHFT = 135,
855  tRSHFT = 136,
856  tCOLON2 = 323,
857  tCOLON3 = 324,
858  tOP_ASGN = 325,
859  tASSOC = 326,
860  tLPAREN = 327,
861  tLPAREN_ARG = 328,
862  tRPAREN = 329,
863  tLBRACK = 330,
864  tLBRACE = 331,
865  tLBRACE_ARG = 332,
866  tSTAR = 333,
867  tDSTAR = 334,
868  tAMPER = 335,
869  tLAMBDA = 336,
870  tSYMBEG = 337,
871  tSTRING_BEG = 338,
872  tXSTRING_BEG = 339,
873  tREGEXP_BEG = 340,
874  tWORDS_BEG = 341,
875  tQWORDS_BEG = 342,
876  tSYMBOLS_BEG = 343,
877  tQSYMBOLS_BEG = 344,
878  tSTRING_DBEG = 345,
879  tSTRING_DEND = 346,
880  tSTRING_DVAR = 347,
881  tSTRING_END = 348,
882  tLAMBEG = 349,
883  tLOWEST = 350,
884  tUMINUS_NUM = 351,
885  tLAST_TOKEN = 352
886  };
887 #endif
888 
889 
890 
891 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
892 typedef union YYSTYPE
893 {
894 
895 /* Line 293 of yacc.c */
896 #line 691 "ripper.y"
897 
898  VALUE val;
899  NODE *node;
900  ID id;
901  int num;
902  const struct vtable *vars;
903 
904 
905 
906 /* Line 293 of yacc.c */
907 #line 908 "parse.c"
908 } YYSTYPE;
909 # define YYSTYPE_IS_TRIVIAL 1
910 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
911 # define YYSTYPE_IS_DECLARED 1
912 #endif
913 
914 
915 /* Copy the second part of user declarations. */
916 
917 
918 /* Line 343 of yacc.c */
919 #line 920 "parse.c"
920 
921 #ifdef short
922 # undef short
923 #endif
924 
925 #ifdef YYTYPE_UINT8
926 typedef YYTYPE_UINT8 yytype_uint8;
927 #else
928 typedef unsigned char yytype_uint8;
929 #endif
930 
931 #ifdef YYTYPE_INT8
932 typedef YYTYPE_INT8 yytype_int8;
933 #elif (defined __STDC__ || defined __C99__FUNC__ \
934  || defined __cplusplus || defined _MSC_VER)
935 typedef signed char yytype_int8;
936 #else
937 typedef short int yytype_int8;
938 #endif
939 
940 #ifdef YYTYPE_UINT16
941 typedef YYTYPE_UINT16 yytype_uint16;
942 #else
943 typedef unsigned short int yytype_uint16;
944 #endif
945 
946 #ifdef YYTYPE_INT16
947 typedef YYTYPE_INT16 yytype_int16;
948 #else
949 typedef short int yytype_int16;
950 #endif
951 
952 #ifndef YYSIZE_T
953 # ifdef __SIZE_TYPE__
954 # define YYSIZE_T __SIZE_TYPE__
955 # elif defined size_t
956 # define YYSIZE_T size_t
957 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
958  || defined __cplusplus || defined _MSC_VER)
959 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
960 # define YYSIZE_T size_t
961 # else
962 # define YYSIZE_T unsigned int
963 # endif
964 #endif
965 
966 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
967 
968 #ifndef YY_
969 # if defined YYENABLE_NLS && YYENABLE_NLS
970 # if ENABLE_NLS
971 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
972 # define YY_(msgid) dgettext ("bison-runtime", msgid)
973 # endif
974 # endif
975 # ifndef YY_
976 # define YY_(msgid) msgid
977 # endif
978 #endif
979 
980 /* Suppress unused-variable warnings by "using" E. */
981 #if ! defined lint || defined __GNUC__
982 # define YYUSE(e) ((void) (e))
983 #else
984 # define YYUSE(e) /* empty */
985 #endif
986 
987 /* Identity function, used to suppress warnings about constant conditions. */
988 #ifndef lint
989 # define YYID(n) (n)
990 #else
991 #if (defined __STDC__ || defined __C99__FUNC__ \
992  || defined __cplusplus || defined _MSC_VER)
993 static int
994 YYID (int yyi)
995 #else
996 static int
997 YYID (yyi)
998  int yyi;
999 #endif
1000 {
1001  return yyi;
1002 }
1003 #endif
1004 
1005 #if ! defined yyoverflow || YYERROR_VERBOSE
1006 
1007 /* The parser invokes alloca or malloc; define the necessary symbols. */
1008 
1009 # ifdef YYSTACK_USE_ALLOCA
1010 # if YYSTACK_USE_ALLOCA
1011 # ifdef __GNUC__
1012 # define YYSTACK_ALLOC __builtin_alloca
1013 # elif defined __BUILTIN_VA_ARG_INCR
1014 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1015 # elif defined _AIX
1016 # define YYSTACK_ALLOC __alloca
1017 # elif defined _MSC_VER
1018 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1019 # define alloca _alloca
1020 # else
1021 # define YYSTACK_ALLOC alloca
1022 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1023  || defined __cplusplus || defined _MSC_VER)
1024 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1025 # ifndef EXIT_SUCCESS
1026 # define EXIT_SUCCESS 0
1027 # endif
1028 # endif
1029 # endif
1030 # endif
1031 # endif
1032 
1033 # ifdef YYSTACK_ALLOC
1034  /* Pacify GCC's `empty if-body' warning. */
1035 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1036 # ifndef YYSTACK_ALLOC_MAXIMUM
1037  /* The OS might guarantee only one guard page at the bottom of the stack,
1038  and a page size can be as small as 4096 bytes. So we cannot safely
1039  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1040  to allow for a few compiler-allocated temporary stack slots. */
1041 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1042 # endif
1043 # else
1044 # define YYSTACK_ALLOC YYMALLOC
1045 # define YYSTACK_FREE YYFREE
1046 # ifndef YYSTACK_ALLOC_MAXIMUM
1047 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1048 # endif
1049 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
1050  && ! ((defined YYMALLOC || defined malloc) \
1051  && (defined YYFREE || defined free)))
1052 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1053 # ifndef EXIT_SUCCESS
1054 # define EXIT_SUCCESS 0
1055 # endif
1056 # endif
1057 # ifndef YYMALLOC
1058 # define YYMALLOC malloc
1059 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1060  || defined __cplusplus || defined _MSC_VER)
1061 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1062 # endif
1063 # endif
1064 # ifndef YYFREE
1065 # define YYFREE free
1066 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1067  || defined __cplusplus || defined _MSC_VER)
1068 void free (void *); /* INFRINGES ON USER NAME SPACE */
1069 # endif
1070 # endif
1071 # endif
1072 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1073 
1074 
1075 #if (! defined yyoverflow \
1076  && (! defined __cplusplus \
1077  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1078 
1079 /* A type that is properly aligned for any stack member. */
1080 union yyalloc
1081 {
1082  yytype_int16 yyss_alloc;
1084 };
1085 
1086 /* The size of the maximum gap between one aligned stack and the next. */
1087 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1088 
1089 /* The size of an array large to enough to hold all stacks, each with
1090  N elements. */
1091 # define YYSTACK_BYTES(N) \
1092  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1093  + YYSTACK_GAP_MAXIMUM)
1094 
1095 # define YYCOPY_NEEDED 1
1096 
1097 /* Relocate STACK from its old location to the new one. The
1098  local variables YYSIZE and YYSTACKSIZE give the old and new number of
1099  elements in the stack, and YYPTR gives the new location of the
1100  stack. Advance YYPTR to a properly aligned location for the next
1101  stack. */
1102 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1103  do \
1104  { \
1105  YYSIZE_T yynewbytes; \
1106  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1107  Stack = &yyptr->Stack_alloc; \
1108  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1109  yyptr += yynewbytes / sizeof (*yyptr); \
1110  } \
1111  while (YYID (0))
1112 
1113 #endif
1114 
1115 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1116 /* Copy COUNT objects from FROM to TO. The source and destination do
1117  not overlap. */
1118 # ifndef YYCOPY
1119 # if defined __GNUC__ && 1 < __GNUC__
1120 # define YYCOPY(To, From, Count) \
1121  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1122 # else
1123 # define YYCOPY(To, From, Count) \
1124  do \
1125  { \
1126  YYSIZE_T yyi; \
1127  for (yyi = 0; yyi < (Count); yyi++) \
1128  (To)[yyi] = (From)[yyi]; \
1129  } \
1130  while (YYID (0))
1131 # endif
1132 # endif
1133 #endif /* !YYCOPY_NEEDED */
1134 
1135 /* YYFINAL -- State number of the termination state. */
1136 #define YYFINAL 3
1137 /* YYLAST -- Last index in YYTABLE. */
1138 #define YYLAST 10700
1139 
1140 /* YYNTOKENS -- Number of terminals. */
1141 #define YYNTOKENS 142
1142 /* YYNNTS -- Number of nonterminals. */
1143 #define YYNNTS 199
1144 /* YYNRULES -- Number of rules. */
1145 #define YYNRULES 620
1146 /* YYNRULES -- Number of states. */
1147 #define YYNSTATES 1057
1148 
1149 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1150 #define YYUNDEFTOK 2
1151 #define YYMAXUTOK 352
1152 
1153 #define YYTRANSLATE(YYX) \
1154  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1155 
1156 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1157 static const yytype_uint8 yytranslate[] =
1158 {
1159  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1160  141, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1161  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1162  2, 2, 140, 127, 2, 2, 2, 125, 120, 2,
1163  136, 137, 123, 121, 134, 122, 133, 124, 2, 2,
1164  2, 2, 2, 2, 2, 2, 2, 2, 115, 139,
1165  117, 113, 116, 114, 2, 2, 2, 2, 2, 2,
1166  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1167  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1168  2, 132, 2, 138, 119, 2, 135, 2, 2, 2,
1169  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1170  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1171  2, 2, 2, 130, 118, 131, 128, 2, 79, 80,
1172  66, 67, 68, 2, 69, 83, 84, 74, 73, 70,
1173  71, 72, 77, 78, 81, 82, 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, 2, 2, 2, 2,
1183  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1184  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1185  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1186  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1187  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1188  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1189  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1190  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1191  65, 75, 76, 85, 86, 87, 88, 89, 90, 91,
1192  92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
1193  102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
1194  112, 126, 129
1195 };
1196 
1197 #if YYDEBUG
1198 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1199  YYRHS. */
1200 static const yytype_uint16 yyprhs[] =
1201 {
1202  0, 0, 3, 4, 7, 10, 12, 14, 18, 21,
1203  23, 24, 30, 35, 38, 40, 42, 46, 49, 51,
1204  52, 58, 59, 64, 68, 72, 76, 79, 83, 87,
1205  91, 95, 99, 104, 106, 110, 114, 121, 127, 133,
1206  139, 145, 149, 153, 157, 161, 163, 167, 171, 173,
1207  177, 181, 185, 188, 190, 192, 194, 196, 198, 203,
1208  204, 210, 212, 215, 219, 224, 230, 235, 241, 244,
1209  247, 250, 253, 256, 258, 262, 264, 268, 270, 273,
1210  277, 283, 286, 291, 294, 299, 301, 305, 307, 311,
1211  314, 318, 320, 324, 326, 328, 333, 337, 341, 345,
1212  349, 352, 354, 356, 358, 363, 367, 371, 375, 379,
1213  382, 384, 386, 388, 391, 393, 397, 399, 401, 403,
1214  405, 407, 409, 411, 413, 415, 417, 418, 423, 425,
1215  427, 429, 431, 433, 435, 437, 439, 441, 443, 445,
1216  447, 449, 451, 453, 455, 457, 459, 461, 463, 465,
1217  467, 469, 471, 473, 475, 477, 479, 481, 483, 485,
1218  487, 489, 491, 493, 495, 497, 499, 501, 503, 505,
1219  507, 509, 511, 513, 515, 517, 519, 521, 523, 525,
1220  527, 529, 531, 533, 535, 537, 539, 541, 543, 545,
1221  547, 549, 551, 553, 555, 557, 559, 561, 563, 565,
1222  569, 575, 579, 585, 592, 598, 604, 610, 616, 621,
1223  625, 629, 633, 637, 641, 645, 649, 653, 657, 662,
1224  667, 670, 673, 677, 681, 685, 689, 693, 697, 701,
1225  705, 709, 713, 717, 721, 725, 728, 731, 735, 739,
1226  743, 747, 748, 753, 760, 762, 764, 766, 769, 774,
1227  777, 781, 783, 785, 787, 789, 792, 797, 800, 802,
1228  805, 808, 813, 815, 816, 819, 822, 825, 827, 829,
1229  832, 836, 841, 845, 850, 853, 855, 857, 859, 861,
1230  863, 865, 867, 869, 871, 873, 875, 876, 881, 882,
1231  886, 887, 888, 894, 898, 902, 905, 909, 913, 915,
1232  920, 924, 926, 927, 934, 939, 943, 946, 948, 951,
1233  954, 961, 968, 969, 970, 978, 979, 980, 988, 994,
1234  999, 1000, 1001, 1011, 1012, 1019, 1020, 1021, 1030, 1031,
1235  1037, 1038, 1045, 1046, 1047, 1057, 1059, 1061, 1063, 1065,
1236  1067, 1069, 1071, 1073, 1075, 1077, 1079, 1081, 1083, 1085,
1237  1087, 1089, 1091, 1093, 1096, 1098, 1100, 1102, 1108, 1110,
1238  1113, 1115, 1117, 1119, 1123, 1125, 1129, 1131, 1136, 1143,
1239  1147, 1153, 1156, 1161, 1163, 1167, 1172, 1175, 1178, 1180,
1240  1183, 1184, 1191, 1200, 1205, 1212, 1217, 1220, 1227, 1230,
1241  1235, 1242, 1245, 1250, 1253, 1258, 1260, 1262, 1264, 1268,
1242  1270, 1275, 1277, 1282, 1284, 1288, 1290, 1292, 1293, 1294,
1243  1295, 1301, 1306, 1308, 1312, 1316, 1317, 1323, 1326, 1331,
1244  1337, 1343, 1346, 1347, 1353, 1354, 1360, 1364, 1365, 1370,
1245  1371, 1376, 1379, 1381, 1386, 1387, 1393, 1394, 1400, 1406,
1246  1408, 1410, 1417, 1419, 1421, 1423, 1425, 1428, 1430, 1433,
1247  1435, 1437, 1439, 1441, 1443, 1445, 1447, 1450, 1454, 1458,
1248  1462, 1466, 1470, 1471, 1475, 1477, 1480, 1484, 1488, 1489,
1249  1493, 1497, 1501, 1505, 1509, 1510, 1514, 1515, 1519, 1520,
1250  1523, 1524, 1527, 1528, 1531, 1533, 1534, 1538, 1539, 1540,
1251  1541, 1548, 1550, 1552, 1554, 1556, 1559, 1561, 1563, 1565,
1252  1567, 1571, 1573, 1575, 1578, 1581, 1583, 1585, 1587, 1589,
1253  1591, 1593, 1595, 1597, 1599, 1601, 1603, 1605, 1607, 1609,
1254  1611, 1613, 1615, 1617, 1619, 1620, 1625, 1628, 1632, 1635,
1255  1640, 1643, 1646, 1648, 1651, 1652, 1659, 1668, 1673, 1680,
1256  1685, 1692, 1695, 1700, 1707, 1710, 1715, 1718, 1723, 1725,
1257  1726, 1728, 1730, 1732, 1734, 1736, 1738, 1740, 1744, 1746,
1258  1750, 1753, 1756, 1758, 1762, 1764, 1768, 1770, 1772, 1775,
1259  1777, 1781, 1785, 1787, 1791, 1793, 1797, 1799, 1801, 1804,
1260  1806, 1808, 1810, 1813, 1816, 1818, 1820, 1821, 1826, 1828,
1261  1831, 1833, 1837, 1841, 1844, 1847, 1849, 1851, 1853, 1855,
1262  1857, 1859, 1861, 1863, 1865, 1867, 1869, 1871, 1872, 1874,
1263  1875, 1877, 1880, 1883, 1884, 1886, 1888, 1890, 1892, 1894,
1264  1897
1265 };
1266 
1267 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1268 static const yytype_int16 yyrhs[] =
1269 {
1270  143, 0, -1, -1, 144, 145, -1, 146, 333, -1,
1271  340, -1, 147, -1, 146, 339, 147, -1, 1, 147,
1272  -1, 154, -1, -1, 47, 148, 130, 145, 131, -1,
1273  150, 262, 230, 265, -1, 151, 333, -1, 340, -1,
1274  152, -1, 151, 339, 152, -1, 1, 154, -1, 154,
1275  -1, -1, 47, 153, 130, 145, 131, -1, -1, 45,
1276  177, 155, 177, -1, 45, 54, 54, -1, 45, 54,
1277  64, -1, 45, 54, 63, -1, 6, 178, -1, 154,
1278  40, 158, -1, 154, 41, 158, -1, 154, 42, 158,
1279  -1, 154, 43, 158, -1, 154, 44, 154, -1, 48,
1280  130, 150, 131, -1, 156, -1, 165, 113, 159, -1,
1281  297, 87, 159, -1, 215, 132, 188, 336, 87, 159,
1282  -1, 215, 133, 52, 87, 159, -1, 215, 133, 56,
1283  87, 159, -1, 215, 85, 56, 87, 159, -1, 215,
1284  85, 52, 87, 159, -1, 298, 87, 159, -1, 172,
1285  113, 195, -1, 165, 113, 184, -1, 165, 113, 195,
1286  -1, 157, -1, 172, 113, 159, -1, 172, 113, 156,
1287  -1, 159, -1, 157, 37, 157, -1, 157, 38, 157,
1288  -1, 39, 334, 157, -1, 127, 159, -1, 182, -1,
1289  157, -1, 164, -1, 160, -1, 251, -1, 251, 332,
1290  330, 190, -1, -1, 94, 162, 238, 150, 131, -1,
1291  329, -1, 163, 190, -1, 163, 190, 161, -1, 215,
1292  133, 330, 190, -1, 215, 133, 330, 190, 161, -1,
1293  215, 85, 330, 190, -1, 215, 85, 330, 190, 161,
1294  -1, 32, 190, -1, 31, 190, -1, 30, 189, -1,
1295  21, 189, -1, 22, 189, -1, 167, -1, 89, 166,
1296  335, -1, 167, -1, 89, 166, 335, -1, 169, -1,
1297  169, 168, -1, 169, 95, 171, -1, 169, 95, 171,
1298  134, 170, -1, 169, 95, -1, 169, 95, 134, 170,
1299  -1, 95, 171, -1, 95, 171, 134, 170, -1, 95,
1300  -1, 95, 134, 170, -1, 171, -1, 89, 166, 335,
1301  -1, 168, 134, -1, 169, 168, 134, -1, 168, -1,
1302  170, 134, 168, -1, 294, -1, 295, -1, 215, 132,
1303  188, 336, -1, 215, 133, 52, -1, 215, 85, 52,
1304  -1, 215, 133, 56, -1, 215, 85, 56, -1, 86,
1305  56, -1, 298, -1, 294, -1, 295, -1, 215, 132,
1306  188, 336, -1, 215, 133, 52, -1, 215, 85, 52,
1307  -1, 215, 133, 56, -1, 215, 85, 56, -1, 86,
1308  56, -1, 298, -1, 52, -1, 56, -1, 86, 173,
1309  -1, 173, -1, 215, 85, 173, -1, 52, -1, 56,
1310  -1, 53, -1, 180, -1, 181, -1, 175, -1, 290,
1311  -1, 176, -1, 292, -1, 177, -1, -1, 178, 134,
1312  179, 177, -1, 118, -1, 119, -1, 120, -1, 69,
1313  -1, 70, -1, 71, -1, 77, -1, 78, -1, 116,
1314  -1, 73, -1, 117, -1, 74, -1, 72, -1, 83,
1315  -1, 84, -1, 121, -1, 122, -1, 123, -1, 95,
1316  -1, 124, -1, 125, -1, 68, -1, 96, -1, 127,
1317  -1, 128, -1, 66, -1, 67, -1, 81, -1, 82,
1318  -1, 135, -1, 49, -1, 50, -1, 51, -1, 47,
1319  -1, 48, -1, 45, -1, 37, -1, 7, -1, 21,
1320  -1, 16, -1, 3, -1, 5, -1, 46, -1, 26,
1321  -1, 15, -1, 14, -1, 10, -1, 9, -1, 36,
1322  -1, 20, -1, 25, -1, 4, -1, 22, -1, 34,
1323  -1, 39, -1, 38, -1, 23, -1, 8, -1, 24,
1324  -1, 30, -1, 33, -1, 32, -1, 13, -1, 35,
1325  -1, 6, -1, 17, -1, 31, -1, 11, -1, 12,
1326  -1, 18, -1, 19, -1, 172, 113, 182, -1, 172,
1327  113, 182, 44, 182, -1, 297, 87, 182, -1, 297,
1328  87, 182, 44, 182, -1, 215, 132, 188, 336, 87,
1329  182, -1, 215, 133, 52, 87, 182, -1, 215, 133,
1330  56, 87, 182, -1, 215, 85, 52, 87, 182, -1,
1331  215, 85, 56, 87, 182, -1, 86, 56, 87, 182,
1332  -1, 298, 87, 182, -1, 182, 79, 182, -1, 182,
1333  80, 182, -1, 182, 121, 182, -1, 182, 122, 182,
1334  -1, 182, 123, 182, -1, 182, 124, 182, -1, 182,
1335  125, 182, -1, 182, 68, 182, -1, 126, 59, 68,
1336  182, -1, 126, 60, 68, 182, -1, 66, 182, -1,
1337  67, 182, -1, 182, 118, 182, -1, 182, 119, 182,
1338  -1, 182, 120, 182, -1, 182, 69, 182, -1, 182,
1339  116, 182, -1, 182, 73, 182, -1, 182, 117, 182,
1340  -1, 182, 74, 182, -1, 182, 70, 182, -1, 182,
1341  71, 182, -1, 182, 72, 182, -1, 182, 77, 182,
1342  -1, 182, 78, 182, -1, 127, 182, -1, 128, 182,
1343  -1, 182, 83, 182, -1, 182, 84, 182, -1, 182,
1344  75, 182, -1, 182, 76, 182, -1, -1, 46, 334,
1345  183, 182, -1, 182, 114, 182, 334, 115, 182, -1,
1346  196, -1, 182, -1, 340, -1, 194, 337, -1, 194,
1347  134, 327, 337, -1, 327, 337, -1, 136, 188, 335,
1348  -1, 340, -1, 186, -1, 340, -1, 189, -1, 194,
1349  134, -1, 194, 134, 327, 134, -1, 327, 134, -1,
1350  164, -1, 194, 193, -1, 327, 193, -1, 194, 134,
1351  327, 193, -1, 192, -1, -1, 191, 189, -1, 97,
1352  184, -1, 134, 192, -1, 340, -1, 184, -1, 95,
1353  184, -1, 194, 134, 184, -1, 194, 134, 95, 184,
1354  -1, 194, 134, 184, -1, 194, 134, 95, 184, -1,
1355  95, 184, -1, 266, -1, 267, -1, 270, -1, 271,
1356  -1, 272, -1, 277, -1, 275, -1, 278, -1, 296,
1357  -1, 298, -1, 53, -1, -1, 216, 197, 149, 226,
1358  -1, -1, 90, 198, 335, -1, -1, -1, 90, 199,
1359  157, 200, 335, -1, 89, 150, 137, -1, 215, 85,
1360  56, -1, 86, 56, -1, 92, 185, 138, -1, 93,
1361  326, 131, -1, 30, -1, 31, 136, 189, 335, -1,
1362  31, 136, 335, -1, 31, -1, -1, 46, 334, 136,
1363  201, 157, 335, -1, 39, 136, 157, 335, -1, 39,
1364  136, 335, -1, 163, 257, -1, 252, -1, 252, 257,
1365  -1, 98, 243, -1, 217, 158, 227, 150, 229, 226,
1366  -1, 218, 158, 227, 150, 230, 226, -1, -1, -1,
1367  219, 202, 158, 228, 203, 150, 226, -1, -1, -1,
1368  220, 204, 158, 228, 205, 150, 226, -1, 221, 158,
1369  333, 260, 226, -1, 221, 333, 260, 226, -1, -1,
1370  -1, 222, 231, 25, 206, 158, 228, 207, 150, 226,
1371  -1, -1, 223, 174, 299, 208, 149, 226, -1, -1,
1372  -1, 223, 83, 157, 209, 338, 210, 149, 226, -1,
1373  -1, 224, 174, 211, 149, 226, -1, -1, 225, 175,
1374  212, 301, 149, 226, -1, -1, -1, 225, 324, 332,
1375  213, 175, 214, 301, 149, 226, -1, 21, -1, 22,
1376  -1, 23, -1, 24, -1, 196, -1, 7, -1, 11,
1377  -1, 12, -1, 18, -1, 19, -1, 16, -1, 20,
1378  -1, 3, -1, 4, -1, 5, -1, 10, -1, 338,
1379  -1, 13, -1, 338, 13, -1, 338, -1, 27, -1,
1380  230, -1, 14, 158, 227, 150, 229, -1, 340, -1,
1381  15, 150, -1, 172, -1, 165, -1, 306, -1, 89,
1382  234, 335, -1, 232, -1, 233, 134, 232, -1, 233,
1383  -1, 233, 134, 95, 306, -1, 233, 134, 95, 306,
1384  134, 233, -1, 233, 134, 95, -1, 233, 134, 95,
1385  134, 233, -1, 95, 306, -1, 95, 306, 134, 233,
1386  -1, 95, -1, 95, 134, 233, -1, 311, 134, 314,
1387  323, -1, 311, 323, -1, 314, 323, -1, 322, -1,
1388  134, 235, -1, -1, 308, 134, 317, 134, 320, 236,
1389  -1, 308, 134, 317, 134, 320, 134, 308, 236, -1,
1390  308, 134, 317, 236, -1, 308, 134, 317, 134, 308,
1391  236, -1, 308, 134, 320, 236, -1, 308, 134, -1,
1392  308, 134, 320, 134, 308, 236, -1, 308, 236, -1,
1393  317, 134, 320, 236, -1, 317, 134, 320, 134, 308,
1394  236, -1, 317, 236, -1, 317, 134, 308, 236, -1,
1395  320, 236, -1, 320, 134, 308, 236, -1, 235, -1,
1396  340, -1, 239, -1, 118, 240, 118, -1, 76, -1,
1397  118, 237, 240, 118, -1, 334, -1, 334, 139, 241,
1398  334, -1, 242, -1, 241, 134, 242, -1, 52, -1,
1399  305, -1, -1, -1, -1, 244, 245, 247, 246, 248,
1400  -1, 136, 304, 240, 137, -1, 304, -1, 111, 150,
1401  131, -1, 29, 150, 10, -1, -1, 28, 250, 238,
1402  150, 10, -1, 164, 249, -1, 251, 332, 330, 187,
1403  -1, 251, 332, 330, 187, 257, -1, 251, 332, 330,
1404  190, 249, -1, 163, 186, -1, -1, 215, 133, 330,
1405  253, 187, -1, -1, 215, 85, 330, 254, 186, -1,
1406  215, 85, 331, -1, -1, 215, 133, 255, 186, -1,
1407  -1, 215, 85, 256, 186, -1, 32, 186, -1, 32,
1408  -1, 215, 132, 188, 336, -1, -1, 130, 258, 238,
1409  150, 131, -1, -1, 26, 259, 238, 150, 10, -1,
1410  17, 194, 227, 150, 261, -1, 230, -1, 260, -1,
1411  8, 263, 264, 227, 150, 262, -1, 340, -1, 184,
1412  -1, 195, -1, 340, -1, 88, 172, -1, 340, -1,
1413  9, 150, -1, 340, -1, 293, -1, 290, -1, 292,
1414  -1, 268, -1, 62, -1, 269, -1, 268, 269, -1,
1415  100, 281, 110, -1, 101, 282, 110, -1, 102, 283,
1416  65, -1, 103, 140, 110, -1, 103, 273, 110, -1,
1417  -1, 273, 274, 140, -1, 284, -1, 274, 284, -1,
1418  105, 140, 110, -1, 105, 276, 110, -1, -1, 276,
1419  274, 140, -1, 104, 140, 110, -1, 104, 279, 110,
1420  -1, 106, 140, 110, -1, 106, 280, 110, -1, -1,
1421  279, 61, 140, -1, -1, 280, 61, 140, -1, -1,
1422  281, 284, -1, -1, 282, 284, -1, -1, 283, 284,
1423  -1, 61, -1, -1, 109, 285, 289, -1, -1, -1,
1424  -1, 107, 286, 287, 288, 150, 108, -1, 54, -1,
1425  55, -1, 57, -1, 298, -1, 99, 291, -1, 175,
1426  -1, 55, -1, 54, -1, 57, -1, 99, 282, 110,
1427  -1, 59, -1, 60, -1, 126, 59, -1, 126, 60,
1428  -1, 52, -1, 55, -1, 54, -1, 56, -1, 57,
1429  -1, 34, -1, 33, -1, 35, -1, 36, -1, 50,
1430  -1, 49, -1, 51, -1, 294, -1, 295, -1, 294,
1431  -1, 295, -1, 63, -1, 64, -1, 338, -1, -1,
1432  117, 300, 158, 338, -1, 1, 338, -1, 136, 304,
1433  335, -1, 304, 338, -1, 312, 134, 314, 323, -1,
1434  312, 323, -1, 314, 323, -1, 322, -1, 134, 302,
1435  -1, -1, 308, 134, 318, 134, 320, 303, -1, 308,
1436  134, 318, 134, 320, 134, 308, 303, -1, 308, 134,
1437  318, 303, -1, 308, 134, 318, 134, 308, 303, -1,
1438  308, 134, 320, 303, -1, 308, 134, 320, 134, 308,
1439  303, -1, 308, 303, -1, 318, 134, 320, 303, -1,
1440  318, 134, 320, 134, 308, 303, -1, 318, 303, -1,
1441  318, 134, 308, 303, -1, 320, 303, -1, 320, 134,
1442  308, 303, -1, 302, -1, -1, 56, -1, 55, -1,
1443  54, -1, 57, -1, 305, -1, 52, -1, 306, -1,
1444  89, 234, 335, -1, 307, -1, 308, 134, 307, -1,
1445  58, 184, -1, 58, 215, -1, 310, -1, 311, 134,
1446  310, -1, 309, -1, 312, 134, 309, -1, 68, -1,
1447  96, -1, 313, 52, -1, 313, -1, 52, 113, 184,
1448  -1, 52, 113, 215, -1, 316, -1, 317, 134, 316,
1449  -1, 315, -1, 318, 134, 315, -1, 123, -1, 95,
1450  -1, 319, 52, -1, 319, -1, 120, -1, 97, -1,
1451  321, 52, -1, 134, 322, -1, 340, -1, 296, -1,
1452  -1, 136, 325, 157, 335, -1, 340, -1, 327, 337,
1453  -1, 328, -1, 327, 134, 328, -1, 184, 88, 184,
1454  -1, 58, 184, -1, 96, 184, -1, 52, -1, 56,
1455  -1, 53, -1, 52, -1, 56, -1, 53, -1, 180,
1456  -1, 52, -1, 53, -1, 180, -1, 133, -1, 85,
1457  -1, -1, 339, -1, -1, 141, -1, 334, 137, -1,
1458  334, 138, -1, -1, 141, -1, 134, -1, 139, -1,
1459  141, -1, 338, -1, 339, 139, -1, -1
1460 };
1461 
1462 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1463 static const yytype_uint16 yyrline[] =
1464 {
1465  0, 855, 855, 855, 886, 897, 906, 914, 922, 928,
1466  930, 929, 950, 983, 994, 1003, 1011, 1019, 1025, 1030,
1467  1029, 1050, 1050, 1058, 1066, 1077, 1087, 1095, 1104, 1113,
1468  1126, 1139, 1148, 1160, 1161, 1171, 1176, 1197, 1202, 1207,
1469  1217, 1222, 1232, 1241, 1250, 1259, 1262, 1271, 1283, 1284,
1470  1292, 1300, 1308, 1316, 1319, 1331, 1332, 1335, 1336, 1348,
1471  1347, 1369, 1379, 1388, 1401, 1410, 1422, 1431, 1443, 1452,
1472  1461, 1469, 1477, 1487, 1488, 1498, 1499, 1509, 1517, 1525,
1473  1533, 1542, 1550, 1559, 1567, 1576, 1584, 1595, 1596, 1606,
1474  1614, 1624, 1632, 1642, 1646, 1650, 1658, 1666, 1674, 1682,
1475  1694, 1704, 1716, 1725, 1734, 1742, 1750, 1758, 1766, 1779,
1476  1792, 1803, 1811, 1814, 1822, 1830, 1840, 1841, 1842, 1843,
1477  1848, 1859, 1860, 1863, 1871, 1874, 1882, 1882, 1892, 1893,
1478  1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1903,
1479  1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913,
1480  1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1924, 1924,
1481  1924, 1925, 1925, 1926, 1926, 1926, 1927, 1927, 1927, 1927,
1482  1928, 1928, 1928, 1928, 1929, 1929, 1929, 1930, 1930, 1930,
1483  1930, 1931, 1931, 1931, 1931, 1932, 1932, 1932, 1932, 1933,
1484  1933, 1933, 1933, 1934, 1934, 1934, 1934, 1935, 1935, 1938,
1485  1947, 1957, 1962, 1972, 1998, 2003, 2008, 2013, 2023, 2033,
1486  2044, 2058, 2072, 2080, 2088, 2096, 2104, 2112, 2120, 2129,
1487  2138, 2146, 2154, 2162, 2170, 2178, 2186, 2194, 2202, 2210,
1488  2218, 2226, 2234, 2242, 2253, 2261, 2269, 2277, 2285, 2293,
1489  2301, 2309, 2309, 2319, 2329, 2335, 2347, 2348, 2352, 2360,
1490  2370, 2380, 2381, 2384, 2385, 2386, 2390, 2398, 2408, 2417,
1491  2425, 2435, 2444, 2453, 2453, 2465, 2475, 2479, 2485, 2493,
1492  2501, 2515, 2531, 2545, 2560, 2570, 2571, 2572, 2573, 2574,
1493  2575, 2576, 2577, 2578, 2579, 2580, 2589, 2588, 2616, 2616,
1494  2625, 2629, 2624, 2638, 2646, 2654, 2662, 2675, 2683, 2691,
1495  2699, 2707, 2715, 2715, 2725, 2733, 2741, 2751, 2752, 2762,
1496  2766, 2778, 2790, 2790, 2790, 2801, 2801, 2801, 2812, 2823,
1497  2832, 2834, 2831, 2898, 2897, 2919, 2924, 2918, 2943, 2942,
1498  2964, 2963, 2986, 2987, 2986, 3007, 3015, 3023, 3031, 3041,
1499  3053, 3059, 3065, 3071, 3077, 3083, 3089, 3095, 3101, 3107,
1500  3117, 3123, 3128, 3129, 3136, 3141, 3144, 3145, 3158, 3159,
1501  3169, 3170, 3173, 3181, 3191, 3199, 3209, 3217, 3226, 3235,
1502  3243, 3251, 3260, 3272, 3280, 3291, 3295, 3299, 3303, 3309,
1503  3314, 3319, 3323, 3327, 3331, 3335, 3339, 3347, 3351, 3355,
1504  3359, 3363, 3367, 3371, 3375, 3379, 3385, 3386, 3392, 3401,
1505  3410, 3421, 3425, 3435, 3442, 3451, 3459, 3465, 3468, 3473,
1506  3465, 3489, 3497, 3507, 3511, 3518, 3517, 3538, 3554, 3563,
1507  3575, 3589, 3599, 3598, 3615, 3614, 3630, 3639, 3638, 3656,
1508  3655, 3672, 3680, 3688, 3703, 3702, 3722, 3721, 3742, 3754,
1509  3755, 3758, 3777, 3780, 3788, 3796, 3799, 3803, 3806, 3814,
1510  3817, 3818, 3826, 3829, 3846, 3847, 3848, 3858, 3868, 3895,
1511  3960, 3969, 3980, 3987, 3997, 4005, 4015, 4024, 4035, 4042,
1512  4054, 4063, 4073, 4082, 4093, 4100, 4111, 4118, 4133, 4140,
1513  4151, 4158, 4169, 4176, 4205, 4207, 4206, 4223, 4229, 4234,
1514  4222, 4253, 4261, 4269, 4277, 4280, 4291, 4292, 4293, 4294,
1515  4297, 4308, 4309, 4310, 4318, 4328, 4329, 4330, 4331, 4332,
1516  4335, 4336, 4337, 4338, 4339, 4340, 4341, 4344, 4357, 4367,
1517  4375, 4385, 4386, 4389, 4398, 4397, 4406, 4418, 4428, 4436,
1518  4440, 4444, 4448, 4454, 4459, 4464, 4468, 4472, 4476, 4480,
1519  4484, 4488, 4492, 4496, 4500, 4504, 4508, 4512, 4516, 4521,
1520  4527, 4536, 4545, 4554, 4565, 4566, 4573, 4582, 4601, 4608,
1521  4621, 4633, 4645, 4653, 4670, 4678, 4694, 4695, 4698, 4703,
1522  4709, 4721, 4733, 4741, 4757, 4765, 4781, 4782, 4785, 4798,
1523  4809, 4810, 4813, 4830, 4834, 4844, 4854, 4854, 4883, 4884,
1524  4894, 4901, 4911, 4919, 4927, 4939, 4940, 4941, 4944, 4945,
1525  4946, 4947, 4950, 4951, 4952, 4955, 4960, 4967, 4968, 4971,
1526  4972, 4975, 4978, 4981, 4982, 4983, 4986, 4987, 4990, 4991,
1527  4995
1528 };
1529 #endif
1530 
1531 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1532 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1533  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1534 static const char *const yytname[] =
1535 {
1536  "\"end-of-input\"", "error", "$undefined", "keyword_class",
1537  "keyword_module", "keyword_def", "keyword_undef", "keyword_begin",
1538  "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if",
1539  "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else",
1540  "keyword_case", "keyword_when", "keyword_while", "keyword_until",
1541  "keyword_for", "keyword_break", "keyword_next", "keyword_redo",
1542  "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond",
1543  "keyword_do_block", "keyword_do_LAMBDA", "keyword_return",
1544  "keyword_yield", "keyword_super", "keyword_self", "keyword_nil",
1545  "keyword_true", "keyword_false", "keyword_and", "keyword_or",
1546  "keyword_not", "modifier_if", "modifier_unless", "modifier_while",
1547  "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined",
1548  "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__",
1549  "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR",
1550  "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tSTRING_CONTENT",
1551  "tCHAR", "tNTH_REF", "tBACK_REF", "tREGEXP_END", "\"unary+\"",
1552  "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"", "\"===\"", "\"!=\"",
1553  "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"", "\"!~\"", "\"..\"",
1554  "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"", "\"::\"",
1555  "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"", "\"( arg\"",
1556  "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"", "\"**arg\"", "\"&\"",
1557  "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG",
1558  "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG", "tQSYMBOLS_BEG",
1559  "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
1560  "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
1561  "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "tLAST_TOKEN",
1562  "'{'", "'}'", "'['", "'.'", "','", "'`'", "'('", "')'", "']'", "';'",
1563  "' '", "'\\n'", "$accept", "program", "$@1", "top_compstmt", "top_stmts",
1564  "top_stmt", "$@2", "bodystmt", "compstmt", "stmts", "stmt_or_begin",
1565  "$@3", "stmt", "$@4", "command_asgn", "expr", "expr_value",
1566  "command_call", "block_command", "cmd_brace_block", "@5", "fcall",
1567  "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head",
1568  "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
1569  "fitem", "undef_list", "$@6", "op", "reswords", "arg", "$@7",
1570  "arg_value", "aref_args", "paren_args", "opt_paren_args",
1571  "opt_call_args", "call_args", "command_args", "@8", "block_arg",
1572  "opt_block_arg", "args", "mrhs", "primary", "@9", "$@10", "$@11", "$@12",
1573  "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "$@19", "@20", "@21",
1574  "@22", "@23", "@24", "$@25", "$@26", "primary_value", "k_begin", "k_if",
1575  "k_unless", "k_while", "k_until", "k_case", "k_for", "k_class",
1576  "k_module", "k_def", "k_end", "then", "do", "if_tail", "opt_else",
1577  "for_var", "f_marg", "f_marg_list", "f_margs", "block_args_tail",
1578  "opt_block_args_tail", "block_param", "opt_block_param",
1579  "block_param_def", "opt_bv_decl", "bv_decls", "bvar", "lambda", "@27",
1580  "@28", "@29", "f_larglist", "lambda_body", "do_block", "@30",
1581  "block_call", "method_call", "@31", "@32", "@33", "@34", "brace_block",
1582  "@35", "@36", "case_body", "cases", "opt_rescue", "exc_list", "exc_var",
1583  "opt_ensure", "literal", "strings", "string", "string1", "xstring",
1584  "regexp", "words", "word_list", "word", "symbols", "symbol_list",
1585  "qwords", "qsymbols", "qword_list", "qsym_list", "string_contents",
1586  "xstring_contents", "regexp_contents", "string_content", "@37", "@38",
1587  "@39", "@40", "string_dvar", "symbol", "sym", "dsym", "numeric",
1588  "user_variable", "keyword_variable", "var_ref", "var_lhs", "backref",
1589  "superclass", "$@41", "f_arglist", "args_tail", "opt_args_tail",
1590  "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_kw",
1591  "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest",
1592  "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
1593  "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
1594  "singleton", "$@42", "assoc_list", "assocs", "assoc", "operation",
1595  "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
1596  "rparen", "rbracket", "trailer", "term", "terms", "none", 0
1597 };
1598 #endif
1599 
1600 # ifdef YYPRINT
1601 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1602  token YYLEX-NUM. */
1603 static const yytype_uint16 yytoknum[] =
1604 {
1605  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1606  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1607  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1608  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1609  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1610  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1611  315, 316, 317, 318, 319, 320, 130, 131, 132, 134,
1612  139, 140, 141, 138, 137, 321, 322, 142, 143, 128,
1613  129, 144, 145, 135, 136, 323, 324, 325, 326, 327,
1614  328, 329, 330, 331, 332, 333, 334, 335, 336, 337,
1615  338, 339, 340, 341, 342, 343, 344, 345, 346, 347,
1616  348, 349, 350, 61, 63, 58, 62, 60, 124, 94,
1617  38, 43, 45, 42, 47, 37, 351, 33, 126, 352,
1618  123, 125, 91, 46, 44, 96, 40, 41, 93, 59,
1619  32, 10
1620 };
1621 # endif
1622 
1623 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1624 static const yytype_uint16 yyr1[] =
1625 {
1626  0, 142, 144, 143, 145, 146, 146, 146, 146, 147,
1627  148, 147, 149, 150, 151, 151, 151, 151, 152, 153,
1628  152, 155, 154, 154, 154, 154, 154, 154, 154, 154,
1629  154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1630  154, 154, 154, 154, 154, 154, 156, 156, 157, 157,
1631  157, 157, 157, 157, 158, 159, 159, 160, 160, 162,
1632  161, 163, 164, 164, 164, 164, 164, 164, 164, 164,
1633  164, 164, 164, 165, 165, 166, 166, 167, 167, 167,
1634  167, 167, 167, 167, 167, 167, 167, 168, 168, 169,
1635  169, 170, 170, 171, 171, 171, 171, 171, 171, 171,
1636  171, 171, 172, 172, 172, 172, 172, 172, 172, 172,
1637  172, 173, 173, 174, 174, 174, 175, 175, 175, 175,
1638  175, 176, 176, 177, 177, 178, 179, 178, 180, 180,
1639  180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
1640  180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
1641  180, 180, 180, 180, 180, 180, 180, 180, 181, 181,
1642  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1643  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1644  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1645  181, 181, 181, 181, 181, 181, 181, 181, 181, 182,
1646  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1647  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1648  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1649  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1650  182, 183, 182, 182, 182, 184, 185, 185, 185, 185,
1651  186, 187, 187, 188, 188, 188, 188, 188, 189, 189,
1652  189, 189, 189, 191, 190, 192, 193, 193, 194, 194,
1653  194, 194, 195, 195, 195, 196, 196, 196, 196, 196,
1654  196, 196, 196, 196, 196, 196, 197, 196, 198, 196,
1655  199, 200, 196, 196, 196, 196, 196, 196, 196, 196,
1656  196, 196, 201, 196, 196, 196, 196, 196, 196, 196,
1657  196, 196, 202, 203, 196, 204, 205, 196, 196, 196,
1658  206, 207, 196, 208, 196, 209, 210, 196, 211, 196,
1659  212, 196, 213, 214, 196, 196, 196, 196, 196, 215,
1660  216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1661  226, 227, 227, 227, 228, 228, 229, 229, 230, 230,
1662  231, 231, 232, 232, 233, 233, 234, 234, 234, 234,
1663  234, 234, 234, 234, 234, 235, 235, 235, 235, 236,
1664  236, 237, 237, 237, 237, 237, 237, 237, 237, 237,
1665  237, 237, 237, 237, 237, 237, 238, 238, 239, 239,
1666  239, 240, 240, 241, 241, 242, 242, 244, 245, 246,
1667  243, 247, 247, 248, 248, 250, 249, 251, 251, 251,
1668  251, 252, 253, 252, 254, 252, 252, 255, 252, 256,
1669  252, 252, 252, 252, 258, 257, 259, 257, 260, 261,
1670  261, 262, 262, 263, 263, 263, 264, 264, 265, 265,
1671  266, 266, 266, 267, 268, 268, 268, 269, 270, 271,
1672  272, 272, 273, 273, 274, 274, 275, 275, 276, 276,
1673  277, 277, 278, 278, 279, 279, 280, 280, 281, 281,
1674  282, 282, 283, 283, 284, 285, 284, 286, 287, 288,
1675  284, 289, 289, 289, 289, 290, 291, 291, 291, 291,
1676  292, 293, 293, 293, 293, 294, 294, 294, 294, 294,
1677  295, 295, 295, 295, 295, 295, 295, 296, 296, 297,
1678  297, 298, 298, 299, 300, 299, 299, 301, 301, 302,
1679  302, 302, 302, 303, 303, 304, 304, 304, 304, 304,
1680  304, 304, 304, 304, 304, 304, 304, 304, 304, 304,
1681  305, 305, 305, 305, 306, 306, 307, 307, 308, 308,
1682  309, 310, 311, 311, 312, 312, 313, 313, 314, 314,
1683  315, 316, 317, 317, 318, 318, 319, 319, 320, 320,
1684  321, 321, 322, 323, 323, 324, 325, 324, 326, 326,
1685  327, 327, 328, 328, 328, 329, 329, 329, 330, 330,
1686  330, 330, 331, 331, 331, 332, 332, 333, 333, 334,
1687  334, 335, 336, 337, 337, 337, 338, 338, 339, 339,
1688  340
1689 };
1690 
1691 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1692 static const yytype_uint8 yyr2[] =
1693 {
1694  0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
1695  0, 5, 4, 2, 1, 1, 3, 2, 1, 0,
1696  5, 0, 4, 3, 3, 3, 2, 3, 3, 3,
1697  3, 3, 4, 1, 3, 3, 6, 5, 5, 5,
1698  5, 3, 3, 3, 3, 1, 3, 3, 1, 3,
1699  3, 3, 2, 1, 1, 1, 1, 1, 4, 0,
1700  5, 1, 2, 3, 4, 5, 4, 5, 2, 2,
1701  2, 2, 2, 1, 3, 1, 3, 1, 2, 3,
1702  5, 2, 4, 2, 4, 1, 3, 1, 3, 2,
1703  3, 1, 3, 1, 1, 4, 3, 3, 3, 3,
1704  2, 1, 1, 1, 4, 3, 3, 3, 3, 2,
1705  1, 1, 1, 2, 1, 3, 1, 1, 1, 1,
1706  1, 1, 1, 1, 1, 1, 0, 4, 1, 1,
1707  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1708  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1709  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1710  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1711  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1712  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1713  1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
1714  5, 3, 5, 6, 5, 5, 5, 5, 4, 3,
1715  3, 3, 3, 3, 3, 3, 3, 3, 4, 4,
1716  2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
1717  3, 3, 3, 3, 3, 2, 2, 3, 3, 3,
1718  3, 0, 4, 6, 1, 1, 1, 2, 4, 2,
1719  3, 1, 1, 1, 1, 2, 4, 2, 1, 2,
1720  2, 4, 1, 0, 2, 2, 2, 1, 1, 2,
1721  3, 4, 3, 4, 2, 1, 1, 1, 1, 1,
1722  1, 1, 1, 1, 1, 1, 0, 4, 0, 3,
1723  0, 0, 5, 3, 3, 2, 3, 3, 1, 4,
1724  3, 1, 0, 6, 4, 3, 2, 1, 2, 2,
1725  6, 6, 0, 0, 7, 0, 0, 7, 5, 4,
1726  0, 0, 9, 0, 6, 0, 0, 8, 0, 5,
1727  0, 6, 0, 0, 9, 1, 1, 1, 1, 1,
1728  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1729  1, 1, 1, 2, 1, 1, 1, 5, 1, 2,
1730  1, 1, 1, 3, 1, 3, 1, 4, 6, 3,
1731  5, 2, 4, 1, 3, 4, 2, 2, 1, 2,
1732  0, 6, 8, 4, 6, 4, 2, 6, 2, 4,
1733  6, 2, 4, 2, 4, 1, 1, 1, 3, 1,
1734  4, 1, 4, 1, 3, 1, 1, 0, 0, 0,
1735  5, 4, 1, 3, 3, 0, 5, 2, 4, 5,
1736  5, 2, 0, 5, 0, 5, 3, 0, 4, 0,
1737  4, 2, 1, 4, 0, 5, 0, 5, 5, 1,
1738  1, 6, 1, 1, 1, 1, 2, 1, 2, 1,
1739  1, 1, 1, 1, 1, 1, 2, 3, 3, 3,
1740  3, 3, 0, 3, 1, 2, 3, 3, 0, 3,
1741  3, 3, 3, 3, 0, 3, 0, 3, 0, 2,
1742  0, 2, 0, 2, 1, 0, 3, 0, 0, 0,
1743  6, 1, 1, 1, 1, 2, 1, 1, 1, 1,
1744  3, 1, 1, 2, 2, 1, 1, 1, 1, 1,
1745  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1746  1, 1, 1, 1, 0, 4, 2, 3, 2, 4,
1747  2, 2, 1, 2, 0, 6, 8, 4, 6, 4,
1748  6, 2, 4, 6, 2, 4, 2, 4, 1, 0,
1749  1, 1, 1, 1, 1, 1, 1, 3, 1, 3,
1750  2, 2, 1, 3, 1, 3, 1, 1, 2, 1,
1751  3, 3, 1, 3, 1, 3, 1, 1, 2, 1,
1752  1, 1, 2, 2, 1, 1, 0, 4, 1, 2,
1753  1, 3, 3, 2, 2, 1, 1, 1, 1, 1,
1754  1, 1, 1, 1, 1, 1, 1, 0, 1, 0,
1755  1, 2, 2, 0, 1, 1, 1, 1, 1, 2,
1756  0
1757 };
1758 
1759 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1760  Performed when YYTABLE doesn't specify something else to do. Zero
1761  means the default is an error. */
1762 static const yytype_uint16 yydefact[] =
1763 {
1764  2, 0, 0, 1, 0, 347, 348, 349, 0, 340,
1765  341, 342, 345, 343, 344, 346, 335, 336, 337, 338,
1766  298, 263, 263, 511, 510, 512, 513, 609, 0, 609,
1767  10, 0, 515, 514, 516, 595, 597, 507, 506, 596,
1768  509, 501, 502, 454, 521, 522, 0, 0, 0, 0,
1769  290, 620, 620, 85, 407, 480, 478, 480, 482, 462,
1770  474, 468, 476, 0, 0, 0, 3, 607, 6, 9,
1771  33, 45, 48, 56, 263, 55, 0, 73, 0, 77,
1772  87, 0, 53, 244, 0, 286, 0, 0, 312, 315,
1773  607, 0, 0, 0, 0, 57, 307, 275, 276, 453,
1774  455, 277, 278, 279, 281, 280, 282, 451, 452, 450,
1775  517, 518, 283, 0, 284, 61, 5, 8, 168, 179,
1776  169, 192, 165, 185, 175, 174, 195, 196, 190, 173,
1777  172, 167, 193, 197, 198, 177, 166, 180, 184, 186,
1778  178, 171, 187, 194, 189, 188, 181, 191, 176, 164,
1779  183, 182, 163, 170, 161, 162, 158, 159, 160, 116,
1780  118, 117, 153, 154, 149, 131, 132, 133, 140, 137,
1781  139, 134, 135, 155, 156, 141, 142, 146, 150, 136,
1782  138, 128, 129, 130, 143, 144, 145, 147, 148, 151,
1783  152, 157, 121, 123, 125, 26, 119, 120, 122, 124,
1784  0, 0, 0, 0, 0, 0, 0, 0, 258, 0,
1785  245, 268, 71, 262, 620, 0, 517, 518, 0, 284,
1786  620, 590, 72, 70, 609, 69, 0, 620, 431, 68,
1787  609, 610, 0, 0, 21, 241, 0, 0, 335, 336,
1788  298, 301, 432, 0, 220, 0, 221, 295, 0, 19,
1789  0, 0, 607, 15, 18, 609, 75, 14, 609, 0,
1790  0, 613, 613, 246, 0, 0, 613, 588, 609, 0,
1791  0, 0, 83, 339, 0, 93, 94, 101, 309, 408,
1792  498, 497, 499, 496, 0, 495, 0, 0, 0, 0,
1793  0, 0, 0, 0, 0, 0, 0, 503, 504, 52,
1794  235, 236, 616, 617, 4, 618, 608, 0, 0, 0,
1795  0, 0, 0, 0, 436, 434, 421, 62, 306, 415,
1796  417, 0, 89, 0, 81, 78, 0, 0, 0, 0,
1797  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1798  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1799  0, 0, 0, 429, 620, 427, 0, 54, 0, 0,
1800  0, 0, 607, 0, 608, 0, 361, 360, 0, 0,
1801  517, 518, 284, 111, 112, 0, 0, 114, 0, 0,
1802  517, 518, 284, 328, 188, 181, 191, 176, 158, 159,
1803  160, 116, 117, 586, 330, 585, 0, 606, 605, 0,
1804  308, 456, 0, 0, 126, 593, 295, 269, 594, 265,
1805  0, 0, 0, 259, 267, 429, 620, 427, 0, 0,
1806  0, 260, 609, 0, 300, 264, 609, 254, 620, 620,
1807  253, 609, 305, 51, 23, 25, 24, 0, 302, 0,
1808  0, 0, 429, 427, 0, 17, 0, 609, 293, 13,
1809  608, 74, 289, 291, 296, 615, 614, 247, 615, 249,
1810  297, 589, 0, 100, 503, 504, 91, 86, 0, 429,
1811  620, 427, 549, 484, 487, 485, 500, 481, 457, 479,
1812  458, 459, 483, 460, 461, 0, 464, 470, 0, 471,
1813  466, 467, 0, 472, 0, 473, 0, 0, 619, 7,
1814  27, 28, 29, 30, 31, 49, 50, 620, 620, 59,
1815  63, 620, 0, 34, 43, 0, 44, 609, 0, 79,
1816  90, 47, 46, 0, 199, 268, 42, 217, 225, 230,
1817  231, 232, 227, 229, 239, 240, 233, 234, 210, 211,
1818  237, 238, 609, 226, 228, 222, 223, 224, 212, 213,
1819  214, 215, 216, 598, 600, 599, 601, 0, 263, 426,
1820  609, 598, 600, 599, 601, 0, 263, 0, 620, 352,
1821  0, 351, 0, 0, 0, 0, 0, 0, 295, 429,
1822  620, 427, 320, 325, 111, 112, 113, 0, 524, 323,
1823  523, 429, 620, 427, 0, 0, 549, 332, 598, 599,
1824  263, 35, 201, 41, 209, 0, 199, 592, 0, 270,
1825  266, 620, 598, 599, 609, 598, 599, 591, 299, 611,
1826  250, 255, 257, 304, 22, 0, 242, 0, 32, 424,
1827  422, 208, 0, 76, 16, 609, 613, 0, 84, 97,
1828  99, 609, 598, 599, 555, 552, 551, 550, 553, 0,
1829  566, 0, 577, 567, 581, 580, 576, 549, 409, 548,
1830  412, 554, 556, 558, 534, 564, 620, 569, 620, 574,
1831  534, 579, 534, 0, 532, 488, 0, 463, 465, 475,
1832  469, 477, 218, 219, 399, 609, 0, 397, 396, 0,
1833  620, 0, 274, 0, 88, 82, 0, 0, 0, 0,
1834  0, 0, 430, 66, 0, 0, 433, 0, 0, 428,
1835  64, 620, 350, 287, 620, 620, 442, 620, 353, 620,
1836  355, 313, 354, 316, 0, 0, 319, 602, 294, 609,
1837  598, 599, 0, 0, 526, 0, 0, 111, 112, 115,
1838  609, 0, 609, 549, 0, 0, 0, 252, 418, 58,
1839  251, 0, 127, 271, 261, 0, 0, 433, 0, 0,
1840  620, 609, 11, 0, 292, 248, 92, 95, 0, 560,
1841  555, 0, 373, 364, 366, 609, 362, 609, 0, 0,
1842  541, 0, 530, 584, 568, 0, 531, 0, 544, 578,
1843  0, 546, 582, 489, 491, 492, 493, 486, 494, 555,
1844  0, 395, 609, 0, 380, 562, 620, 620, 572, 380,
1845  380, 378, 401, 0, 0, 0, 0, 0, 272, 80,
1846  200, 0, 40, 206, 39, 207, 67, 425, 612, 0,
1847  37, 204, 38, 205, 65, 423, 443, 444, 620, 445,
1848  0, 620, 358, 0, 0, 356, 0, 0, 0, 318,
1849  0, 0, 433, 0, 326, 0, 0, 433, 329, 587,
1850  609, 0, 528, 333, 419, 420, 202, 0, 256, 303,
1851  20, 570, 609, 0, 371, 0, 557, 0, 0, 0,
1852  410, 533, 559, 534, 534, 565, 620, 583, 534, 575,
1853  534, 534, 0, 0, 0, 561, 0, 398, 386, 388,
1854  0, 376, 377, 0, 391, 0, 393, 0, 437, 435,
1855  0, 416, 273, 243, 36, 203, 0, 0, 447, 359,
1856  0, 12, 449, 0, 310, 311, 0, 0, 270, 620,
1857  321, 0, 525, 324, 527, 331, 549, 363, 374, 0,
1858  369, 365, 411, 0, 0, 0, 537, 0, 539, 529,
1859  0, 545, 0, 542, 547, 0, 571, 295, 429, 400,
1860  379, 380, 380, 563, 620, 380, 573, 380, 380, 405,
1861  609, 403, 406, 60, 0, 446, 0, 102, 103, 110,
1862  0, 448, 0, 314, 317, 439, 440, 438, 0, 0,
1863  0, 0, 372, 0, 367, 414, 413, 534, 534, 534,
1864  534, 490, 602, 294, 0, 383, 0, 385, 375, 0,
1865  392, 0, 389, 394, 0, 402, 109, 429, 620, 427,
1866  620, 620, 0, 327, 0, 370, 0, 538, 0, 535,
1867  540, 543, 380, 380, 380, 380, 404, 602, 108, 609,
1868  598, 599, 441, 357, 322, 334, 368, 534, 384, 0,
1869  381, 387, 390, 433, 536, 380, 382
1870 };
1871 
1872 /* YYDEFGOTO[NTERM-NUM]. */
1873 static const yytype_int16 yydefgoto[] =
1874 {
1875  -1, 1, 2, 66, 67, 68, 236, 567, 568, 252,
1876  253, 446, 254, 437, 70, 71, 358, 72, 73, 510,
1877  690, 243, 75, 76, 255, 77, 78, 79, 467, 80,
1878  209, 377, 378, 192, 193, 194, 195, 605, 556, 197,
1879  82, 439, 211, 260, 228, 748, 426, 427, 225, 226,
1880  213, 413, 428, 516, 83, 356, 258, 259, 635, 625,
1881  360, 847, 361, 848, 732, 988, 736, 733, 931, 594,
1882  596, 746, 936, 245, 85, 86, 87, 88, 89, 90,
1883  91, 92, 93, 94, 713, 570, 721, 844, 845, 369,
1884  773, 774, 775, 960, 899, 802, 686, 687, 803, 970,
1885  971, 278, 279, 472, 778, 658, 880, 320, 511, 95,
1886  96, 711, 704, 565, 557, 318, 508, 507, 577, 987,
1887  715, 838, 917, 921, 97, 98, 99, 100, 101, 102,
1888  103, 290, 485, 104, 294, 105, 106, 292, 296, 286,
1889  284, 288, 477, 676, 675, 793, 892, 797, 107, 285,
1890  108, 109, 216, 217, 112, 218, 219, 589, 735, 744,
1891  881, 780, 745, 661, 662, 663, 664, 665, 805, 806,
1892  666, 667, 668, 669, 808, 809, 670, 671, 672, 673,
1893  674, 782, 396, 595, 265, 429, 221, 115, 629, 559,
1894  399, 304, 423, 424, 706, 457, 571, 364, 257
1895 };
1896 
1897 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1898  STATE-NUM. */
1899 #define YYPACT_NINF -808
1900 static const yytype_int16 yypact[] =
1901 {
1902  -808, 134, 2562, -808, 7195, -808, -808, -808, 6718, -808,
1903  -808, -808, -808, -808, -808, -808, 7308, 7308, -808, -808,
1904  7308, 3884, 3479, -808, -808, -808, -808, 455, 6585, 17,
1905  -808, 60, -808, -808, -808, 2804, 3614, -808, -808, 2939,
1906  -808, -808, -808, -808, -808, -808, 8664, 8664, 140, 4955,
1907  462, 7647, 7986, 6977, -808, 6452, -808, -808, -808, 103,
1908  115, 126, 206, 117, 8777, 8664, -808, -25, -808, 1007,
1909  -808, 322, -808, -808, 141, 372, 352, -808, 337, 9003,
1910  -808, 379, 2918, 247, 278, -808, 8890, 8890, -808, -808,
1911  5842, 9112, 9221, 9330, 6318, 33, 65, -808, -808, 410,
1912  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1913  205, 409, -808, 441, 433, -808, -808, -808, -808, -808,
1914  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1915  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1916  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1917  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1918  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1919  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1920  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1921  -808, -808, -808, -808, -808, 396, -808, -808, -808, -808,
1922  427, 8664, 519, 5094, 8664, 8664, 8664, 8664, -808, 468,
1923  2918, 500, -808, -808, 463, 304, 22, 344, 517, 363,
1924  479, -808, -808, -808, 5729, -808, 7308, 7308, -808, -808,
1925  5955, -808, 8890, 498, -808, 482, 491, 5233, -808, -808,
1926  -808, 497, 499, 141, -808, 361, 570, 458, 7421, -808,
1927  4955, 505, -25, -808, 1007, 17, 538, -808, 17, 8890,
1928  515, 188, 318, -808, 500, 523, 318, -808, 17, 617,
1929  338, 9439, 540, -808, 474, 572, 613, 674, -808, -808,
1930  -808, -808, -808, -808, 522, -808, 601, 669, 284, 576,
1931  752, 577, 58, 582, 759, 584, 68, 609, 612, -808,
1932  -808, -808, -808, -808, -808, -808, 6068, 8890, 8890, 8890,
1933  8890, 7421, 8890, 8890, -808, -808, -808, 588, -808, -808,
1934  -808, 8099, -808, 4955, 7086, 561, 8099, 8664, 8664, 8664,
1935  8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664,
1936  8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664,
1937  8664, 8664, 8664, 2012, 7308, 9718, 4312, 322, 109, 109,
1938  8890, 8890, -25, 689, 563, 651, -808, -808, 685, 691,
1939  53, 57, 100, 328, 393, 8890, 568, -808, 199, 708,
1940  -808, -808, -808, -808, 55, 223, 249, 279, 283, 301,
1941  316, 384, 417, -808, -808, -808, 33, -808, -808, 9795,
1942  -808, -808, 8777, 8777, -808, -808, 414, -808, -808, -808,
1943  8664, 8664, 7534, -808, -808, 9872, 7308, 9949, 8664, 8664,
1944  7760, -808, 17, 595, -808, -808, 17, -808, 580, 599,
1945  -808, 61, -808, -808, -808, -808, -808, 6718, -808, 8664,
1946  5364, 604, 9872, 9949, 8664, 1007, 607, 17, -808, -808,
1947  6181, 618, -808, 322, -808, 7873, -808, -808, 7986, -808,
1948  -808, -808, 482, 769, -808, -808, -808, 622, 9439, 10026,
1949  7308, 10103, 1417, -808, -808, -808, -808, -808, -808, -808,
1950  -808, -808, -808, -808, -808, 244, -808, -808, 611, -808,
1951  -808, -808, 347, -808, 623, -808, 8664, 8664, -808, -808,
1952  -808, -808, -808, -808, -808, -808, -808, 51, 51, -808,
1953  -808, 51, 8664, -808, 628, 634, -808, 17, 9439, 655,
1954  -808, -808, -808, 678, 1866, -808, -808, 570, 2240, 2240,
1955  2240, 2240, 727, 727, 3323, 3188, 2240, 2240, 3053, 3053,
1956  415, 415, 1674, 727, 727, 907, 907, 660, 40, 40,
1957  570, 570, 570, 4019, 3074, 4154, 3209, 499, 661, -808,
1958  17, 535, -808, 688, -808, 499, 3749, 737, 790, -808,
1959  4451, 799, 4729, 66, 66, 689, 8212, 737, 147, 10180,
1960  7308, 10257, -808, 322, -808, 769, -808, -25, -808, -808,
1961  -808, 10334, 7308, 9795, 4312, 8890, 1538, -808, -808, -808,
1962  4173, -808, 2648, -808, 2918, 6718, 2783, -808, 8664, 500,
1963  -808, 479, 2669, 3344, 17, 420, 444, -808, -808, -808,
1964  -808, 7534, 7760, -808, -808, 8890, 2918, 672, -808, -808,
1965  -808, 2918, 5364, 2, -808, 17, 318, 9439, 622, 701,
1966  469, 17, 207, 224, 711, -808, -808, -808, -808, 8664,
1967  -808, 947, -808, -808, -808, -808, -808, 1789, -808, -808,
1968  -808, -808, -808, -808, 680, -808, 687, 773, 694, -808,
1969  698, 783, 704, 791, -808, -808, 834, -808, -808, -808,
1970  -808, -808, 570, 570, -808, 1322, 5503, -808, -808, 5233,
1971  51, 5503, 721, 8325, -808, 622, 9439, 8777, 8664, 741,
1972  8777, 8777, -808, 588, 499, 722, 818, 8777, 8777, -808,
1973  588, 499, -808, -808, 8438, 827, -808, 597, -808, 827,
1974  -808, -808, -808, -808, 737, 70, -808, 67, 136, 17,
1975  148, 149, 8890, -25, -808, 8890, 4312, 701, 469, -808,
1976  17, 737, 61, 1789, 4312, -25, 6851, -808, 65, 372,
1977  -808, 8664, -808, -808, -808, 8664, 8664, 466, 8664, 8664,
1978  731, 61, -808, 736, -808, -808, -808, 567, 8664, -808,
1979  -808, 947, 350, -808, 738, 17, -808, 17, 72, 1789,
1980  -808, 42, -808, -808, -808, 272, -808, 1789, -808, -808,
1981  892, -808, -808, -808, -808, -808, -808, -808, -808, 762,
1982  9548, -808, 17, 764, 746, -808, 751, 694, -808, 758,
1983  760, -808, 761, 893, 775, 5233, 899, 8664, 776, 622,
1984  2918, 8664, -808, 2918, -808, 2918, -808, -808, -808, 8777,
1985  -808, 2918, -808, 2918, -808, -808, 628, -808, 826, -808,
1986  4842, 909, -808, 8890, 737, -808, 737, 5503, 5503, -808,
1987  8551, 4590, 155, 66, -808, -25, 737, -808, -808, -808,
1988  17, 737, -808, -808, -808, -808, 2918, 8664, 7760, -808,
1989  -808, -808, 17, 1011, 789, 1003, -808, 793, 5503, 5233,
1990  -808, -808, -808, 798, 803, -808, 694, -808, 804, -808,
1991  811, 804, 5616, 9548, 877, 792, 808, -808, 1910, -808,
1992  490, -808, -808, 1910, -808, 1368, -808, 1032, -808, -808,
1993  820, -808, 819, 2918, -808, 2918, 9657, 109, -808, -808,
1994  5503, -808, -808, 109, -808, -808, 737, 737, -808, 130,
1995  -808, 4312, -808, -808, -808, -808, 1538, -808, 821, 1011,
1996  434, -808, -808, 944, 832, 1789, -808, 892, -808, -808,
1997  892, -808, 892, -808, -808, 850, 792, -808, 10411, -808,
1998  -808, 830, 831, -808, 694, 835, -808, 837, 835, -808,
1999  443, -808, -808, -808, 910, -808, 796, 572, 613, 674,
2000  4312, -808, 4451, -808, -808, -808, -808, -808, 5503, 737,
2001  4312, 1011, 821, 1011, 838, -808, -808, 804, 839, 804,
2002  804, -808, 840, 841, 1910, -808, 1368, -808, -808, 1368,
2003  -808, 1368, -808, -808, 1032, -808, 769, 10488, 7308, 10565,
2004  790, 597, 737, -808, 737, 821, 1011, -808, 892, -808,
2005  -808, -808, 835, 844, 835, 835, -808, 74, 469, 17,
2006  146, 158, -808, -808, -808, -808, 821, 804, -808, 1368,
2007  -808, -808, -808, 176, -808, 835, -808
2008 };
2009 
2010 /* YYPGOTO[NTERM-NUM]. */
2011 static const yytype_int16 yypgoto[] =
2012 {
2013  -808, -808, -808, -363, -808, 27, -808, -550, -21, -808,
2014  518, -808, 15, -808, -301, -51, -86, 41, -808, -268,
2015  -808, 413, -7, 888, -153, -4, -73, -808, -416, 7,
2016  1571, -315, 889, -53, -808, -5, -808, -808, 98, -808,
2017  870, -808, 735, -808, -44, 275, -340, 87, -11, -808,
2018  -386, -188, 4, -311, -20, -808, -808, -808, -808, -808,
2019  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
2020  -808, -808, -808, 64, -808, -808, -808, -808, -808, -808,
2021  -808, -808, -808, -808, 154, -347, -526, -34, -645, -808,
2022  -785, -779, 221, 309, 374, -808, -446, -808, -665, -808,
2023  -18, -808, -808, -808, -808, -808, -808, 248, -808, -808,
2024  -808, -808, -808, -808, -808, -93, -808, -808, -535, -808,
2025  -6, -808, -808, -808, -808, -808, -808, 918, -808, -808,
2026  -808, -808, 712, -808, -808, -808, -808, -808, -808, -808,
2027  963, -808, -142, -808, -808, -808, -808, -808, 10, -808,
2028  14, -808, 1081, 1361, 928, 1531, 1552, -808, -808, 89,
2029  -464, -372, -415, -783, -518, -723, 234, 242, 133, -808,
2030  -808, -808, 289, -708, -807, 128, 255, -808, -638, -808,
2031  228, -622, -808, -808, -808, 69, -383, -808, -348, -808,
2032  639, -26, 0, 48, -598, -208, 21, -14, -2
2033 };
2034 
2035 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2036  positive, shift that token. If negative, reduce the rule which
2037  number is the opposite. If YYTABLE_NINF, syntax error. */
2038 #define YYTABLE_NINF -621
2039 static const yytype_int16 yytable[] =
2040 {
2041  116, 359, 283, 400, 362, 558, 325, 566, 659, 208,
2042  208, 229, 572, 208, 560, 526, 757, 69, 198, 69,
2043  214, 214, 199, 234, 214, 521, 610, 232, 251, 235,
2044  316, 117, 421, 273, 610, 357, 357, 617, 198, 357,
2045  724, 394, 199, 767, 741, 256, 786, 810, 723, 263,
2046  267, 600, 638, 306, 459, 261, 882, 660, 461, 273,
2047  272, 586, 689, 317, 363, 691, 84, 558, 84, 566,
2048  841, 273, 273, 273, 846, 617, 614, 627, -102, 889,
2049  215, 215, -103, 569, 215, 220, 220, -106, 305, 220,
2050  941, 314, -106, 720, 938, 630, 966, 447, 312, 313,
2051  649, 878, 695, 212, 222, 299, 196, 223, 327, -519,
2052  650, 305, 877, 84, 302, -74, 303, 274, 397, 488,
2053  262, 266, 569, 630, 972, -110, 196, 684, 215, 494,
2054  641, 852, 659, 776, 3, -102, -88, 896, 653, 654,
2055  -511, 884, 857, 274, 479, 840, 482, 576, 486, 890,
2056  215, 215, 486, 196, 215, 368, 379, 379, 231, -105,
2057  992, -108, 655, 350, 351, 352, 398, 314, 489, 685,
2058  517, -107, -109, -105, -107, 882, 297, 298, 495, 431,
2059  -104, 433, 251, 879, 901, 902, 856, -93, -511, -104,
2060  237, -94, 196, 659, 861, 315, 247, 966, 466, 316,
2061  587, -97, 231, -598, 850, 302, 941, 303, 453, 302,
2062  -598, 303, 414, -106, 1025, -106, 441, 208, 414, 208,
2063  208, 500, 501, 502, 503, 430, 449, 882, 214, 251,
2064  214, 972, -96, 630, -101, 610, 610, 889, 450, 617,
2065  729, 421, 777, 289, 815, 630, 256, 1046, 302, -98,
2066  303, 273, 740, 776, 874, 291, 357, 357, 357, 357,
2067  962, 505, 506, 445, 949, 967, 293, 84, 462, 763,
2068  -99, 315, -599, 305, 573, 574, 739, 227, 432, 659,
2069  819, -100, -96, -98, 985, -105, 882, -105, 215, -95,
2070  215, 215, -519, 220, 215, 220, 215, -107, 788, -107,
2071  791, 84, 251, 451, 273, 473, 452, 998, -510, 357,
2072  357, 422, 84, 425, 84, -104, 588, -104, -102, 256,
2073  -96, 69, 455, 215, 583, 515, 504, 930, 860, 456,
2074  515, 519, -339, 499, -512, 274, 575, -98, 302, -93,
2075  303, -96, 1008, 678, -96, 473, 295, 208, -96, 481,
2076  678, 474, 430, 475, -595, 776, -510, 776, -98, 312,
2077  313, -98, 513, 353, -513, -98, 1033, 522, -515, 654,
2078  84, 215, 215, 215, 215, 84, 215, 215, 851, -339,
2079  -339, 989, -512, 305, 677, 215, -514, 84, 274, 415,
2080  215, 474, 655, 475, 986, 466, 521, 464, 465, 590,
2081  319, -516, 770, 837, 645, 646, 647, 648, 473, 208,
2082  354, 355, -513, -505, 430, 74, -515, 74, 215, -596,
2083  84, 776, 994, 754, 215, 215, 414, 414, 765, 74,
2084  74, -520, 624, 74, -514, 826, 416, 417, 116, 215,
2085  1024, 1053, 834, 601, 603, 466, 442, 198, 273, -516,
2086  419, 199, 458, 564, 474, 69, 475, -103, -595, 456,
2087  -505, -505, 74, 208, -595, 321, 215, 215, 430, -505,
2088  618, 322, 659, 776, 620, 776, -110, 74, -508, 623,
2089  215, 611, 610, 327, 873, 617, 770, 680, 645, 646,
2090  647, 648, 326, 416, 443, 633, -520, 564, 273, 74,
2091  74, 444, -508, 74, 84, 688, 688, 758, 776, 688,
2092  56, 946, 948, 702, 84, 564, 951, -505, 953, 954,
2093  403, 709, -103, -596, 636, -508, -508, -109, 402, -596,
2094  404, 759, 274, -105, 215, 196, 348, 349, 350, 351,
2095  352, 564, 699, -94, 742, 444, -110, 703, 800, 717,
2096  -508, 719, 434, 867, -294, 710, 747, -107, 650, 469,
2097  705, 435, 436, 230, 766, 694, 716, -101, 993, 564,
2098  980, -109, 754, 208, 761, 406, 982, 1014, 430, -104,
2099  725, 410, 274, 473, 231, 208, 653, 654, 411, 749,
2100  430, 230, -100, -433, 722, 722, 231, 412, 750, -288,
2101  752, -294, -294, -288, 418, -599, 470, 471, 734, 414,
2102  655, 843, 840, 420, 705, 198, 74, 273, 438, 199,
2103  584, 440, 707, 466, 585, 1027, 1029, 1030, 1031, 474,
2104  116, 475, 476, 224, 84, 227, 84, 74, 327, 74,
2105  74, 705, 448, 74, 215, 74, 853, 69, -105, 855,
2106  74, -73, -433, 454, 460, 864, 215, -517, 84, 215,
2107  827, 74, 473, 74, 783, 813, 783, 747, 814, -96,
2108  816, 630, 74, 463, 468, 1054, 273, 496, 1039, 564,
2109  497, 357, 509, 764, 357, 812, 483, 487, 688, 215,
2110  760, 564, 490, 863, 493, 520, 84, -433, -518, -433,
2111  -433, 274, 498, 196, -517, -517, 576, 578, 474, 750,
2112  475, 478, 839, 842, 621, 842, 582, 842, 515, 74,
2113  74, 74, 74, 74, 74, 74, 74, -602, 327, 705,
2114  473, 726, 619, 622, 74, 628, 74, 632, 522, 74,
2115  705, 822, 824, 340, 341, -518, -518, 712, 830, 832,
2116  84, 679, -88, 84, 854, 84, 637, 923, 414, -284,
2117  274, 215, -268, 681, 215, 215, 862, 74, 693, 74,
2118  579, 215, 215, 74, 74, 708, 474, 812, 475, 480,
2119  273, 348, 349, 350, 351, 352, -602, 264, 74, 696,
2120  859, 697, 357, 591, 910, 327, 215, -424, 714, 215,
2121  84, -107, 812, 762, 783, 783, -284, -284, 84, 869,
2122  340, 341, 718, 473, 779, 74, 74, 580, 581, 919,
2123  473, 781, -98, 876, 768, 784, 926, 927, 785, 74,
2124  929, -602, 787, -602, -602, 789, 918, -598, 790, 922,
2125  592, 593, 840, 792, 196, 345, 346, 347, 348, 349,
2126  350, 351, 352, 74, -295, -269, 821, 943, 944, 474,
2127  828, 475, 484, 74, 895, 868, 474, 870, 475, 491,
2128  914, 955, 875, 273, 722, 893, 932, 958, 849, 84,
2129  898, 1017, 897, 74, 783, 900, 210, 210, 794, 795,
2130  210, 796, 903, 215, 905, 858, 273, 44, 45, 981,
2131  907, -295, -295, 908, 84, 829, 909, 215, 934, 911,
2132  -270, 84, 84, 811, 916, 84, 244, 246, 920, 804,
2133  937, 210, 210, 939, 592, 593, 959, 842, 1018, 1019,
2134  942, -104, 945, 957, 300, 301, 405, 947, 950, 407,
2135  408, 409, 84, 84, 770, 952, 645, 646, 647, 648,
2136  649, 973, -95, -271, 995, 991, 84, 956, 1001, 1020,
2137  650, 1021, 783, 996, 1004, 1006, 1016, 1022, 634, 1009,
2138  1015, 1011, 1026, 1028, 807, 327, -598, -599, 1049, 366,
2139  976, 651, 383, 74, 84, 74, 835, 1043, 653, 654,
2140  340, 341, 872, 74, 801, 84, 1036, 865, 924, 770,
2141  925, 645, 646, 647, 648, 74, 492, 74, 74, 887,
2142  933, 208, 655, 887, 1042, 935, 430, 401, 716, 842,
2143  287, 888, 395, 885, 891, 990, 961, 347, 348, 349,
2144  350, 351, 352, 963, 883, 597, 771, 0, 74, 705,
2145  0, 0, 772, 0, 84, 74, 84, 307, 308, 309,
2146  310, 311, 84, 0, 84, 770, 514, 645, 646, 647,
2147  648, 525, 0, 770, 0, 645, 646, 647, 648, 0,
2148  886, 210, 0, 0, 210, 210, 210, 300, 0, 0,
2149  983, 984, 215, 110, 969, 110, 645, 646, 647, 648,
2150  0, 0, 771, 0, 210, 0, 210, 210, 940, 74,
2151  771, 0, 74, 0, 74, 0, 0, 0, 0, 0,
2152  74, 0, 0, 74, 74, 0, 0, 564, 0, 0,
2153  74, 74, 0, 0, 0, 0, 811, 0, 887, 0,
2154  110, 811, 0, 811, 275, 0, 0, 965, 0, 968,
2155  0, 0, 0, 1023, 0, 74, 607, 609, 74, 74,
2156  0, 0, 0, 0, 0, 264, 0, 74, 0, 0,
2157  275, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2158  0, 0, 370, 380, 380, 380, 1044, 0, 1045, 997,
2159  0, 999, 0, 904, 906, 0, 1000, 807, 0, 964,
2160  609, 210, 807, 264, 807, 0, 524, 527, 528, 529,
2161  530, 531, 532, 533, 534, 535, 536, 537, 538, 539,
2162  540, 541, 542, 543, 544, 545, 546, 547, 548, 549,
2163  550, 551, 552, 0, 210, 0, 0, 0, 74, 0,
2164  0, 0, 811, 0, 811, 0, 0, 811, 1032, 811,
2165  1034, 0, 74, 0, 0, 1035, 0, 692, 0, 0,
2166  0, 0, 0, 74, 0, 0, 74, 0, 0, 0,
2167  74, 74, 1047, 0, 74, 0, 0, 0, 0, 0,
2168  0, 0, 602, 604, 0, 0, 0, 811, 0, 0,
2169  606, 210, 210, 1055, 110, 0, 210, 0, 602, 604,
2170  210, 74, 74, 807, 0, 807, 0, 0, 807, 0,
2171  807, 0, 0, 0, 0, 74, 0, 0, 0, 626,
2172  0, 525, 0, 0, 631, 0, 0, 0, 110, 0,
2173  0, 0, 0, 0, 0, 210, 0, 0, 210, 110,
2174  0, 110, 0, 74, 0, 1005, 1007, 0, 807, 1010,
2175  210, 1012, 1013, 753, 74, 0, 0, 0, 0, 0,
2176  0, 0, 275, 0, 0, 0, 609, 264, 0, 0,
2177  0, 0, 0, 111, 0, 111, 682, 683, 0, 0,
2178  0, 0, 0, 0, 799, 0, 645, 646, 647, 648,
2179  800, 0, 210, 0, 769, 0, 0, 110, 0, 0,
2180  650, 0, 110, 74, 0, 74, 0, 0, 0, 0,
2181  0, 74, 0, 74, 110, 275, 1048, 1050, 1051, 1052,
2182  111, 651, 0, 0, 276, 0, 0, 652, 653, 654,
2183  770, 0, 645, 646, 647, 648, 800, 0, 818, 1056,
2184  0, 74, 0, 0, 0, 0, 650, 110, 0, 0,
2185  276, 0, 655, 0, 0, 656, 210, 0, 0, 836,
2186  210, 0, 371, 381, 381, 381, 0, 651, 0, 0,
2187  0, 0, 210, 231, 653, 654, 0, 0, 0, 644,
2188  0, 645, 646, 647, 648, 649, 0, 0, 210, 0,
2189  0, 0, 0, 0, 0, 650, 0, 0, 655, 0,
2190  0, 210, 210, 0, 0, 0, 0, 0, 0, 0,
2191  0, 0, 0, 871, 0, 0, 651, 0, 0, 0,
2192  0, 0, 652, 653, 654, 0, 0, 0, 0, 210,
2193  0, 110, 0, 0, 0, 0, 0, 0, 0, 0,
2194  0, 110, 0, 113, 0, 113, 0, 655, 0, 0,
2195  656, 0, 0, 0, 0, 0, 0, 0, 0, 275,
2196  0, 0, 912, 657, 114, 0, 114, 0, 0, 0,
2197  0, 0, 0, 210, 111, 0, 0, 606, 820, 0,
2198  823, 825, 0, 81, 0, 81, 0, 831, 833, 0,
2199  113, 0, 0, 0, 210, 928, 0, 0, 0, 0,
2200  644, 0, 645, 646, 647, 648, 649, 0, 111, 275,
2201  0, 114, 0, 264, 0, 277, 650, 0, 0, 111,
2202  0, 111, 0, 0, 0, 0, 0, 0, 0, 0,
2203  81, 866, 0, 0, 0, 823, 825, 651, 831, 833,
2204  0, 277, 276, 652, 653, 654, 0, 0, 210, 0,
2205  0, 0, 0, 372, 382, 382, 0, 0, 0, 0,
2206  0, 110, 0, 110, 0, 0, 0, 0, 655, 0,
2207  0, 656, 367, 0, 0, 0, 0, 111, 0, 0,
2208  0, 0, 111, 0, 743, 110, 0, 0, 0, 0,
2209  0, 0, 0, 0, 111, 276, 0, 210, 0, 0,
2210  0, 913, 0, 0, 0, 0, 0, 0, 0, 915,
2211  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2212  0, 0, 0, 110, 0, 0, 0, 111, 275, 0,
2213  210, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2214  0, 0, 0, 0, 113, 0, 0, 915, 210, 0,
2215  0, 0, 327, 328, 329, 330, 331, 332, 333, 334,
2216  335, 336, 337, 338, 339, 114, 0, 340, 341, 0,
2217  0, 0, 0, 0, 0, 0, 0, 110, 113, 0,
2218  110, 0, 110, 0, 81, 0, 0, 275, 0, 113,
2219  0, 113, 0, 0, 0, 0, 0, 0, 342, 114,
2220  343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
2221  114, 111, 114, 0, 0, 0, 0, 0, 81, 0,
2222  0, 111, 0, 0, 0, 231, 0, 110, 0, 81,
2223  0, 81, 0, 277, 0, 110, 0, 0, 0, 276,
2224  0, 0, 0, 0, 0, 0, 0, 113, 0, 0,
2225  0, 644, 113, 645, 646, 647, 648, 649, 0, 0,
2226  0, 0, 0, 0, 113, 0, 0, 650, 114, 0,
2227  0, 0, 0, 114, 0, 0, 0, 0, 0, 0,
2228  0, 0, 0, 0, 0, 114, 277, 81, 651, 276,
2229  0, 380, 81, 0, 652, 653, 654, 113, 210, 0,
2230  0, 0, 0, 0, 81, 0, 110, 523, 0, 0,
2231  0, 0, 0, 0, 0, 0, 0, 0, 114, 655,
2232  698, 0, 656, 0, 0, 0, 0, 0, 0, 0,
2233  0, 110, 0, 0, 0, 0, 0, 81, 110, 110,
2234  0, 111, 110, 111, 327, 328, 329, 330, 331, 332,
2235  333, 334, 335, 336, 337, 338, 339, 0, 0, 340,
2236  341, 0, 0, 0, 0, 111, 0, 0, 0, 110,
2237  110, 0, 799, 0, 645, 646, 647, 648, 800, 0,
2238  0, 113, 0, 110, 380, 0, 0, 0, 650, 0,
2239  342, 113, 343, 344, 345, 346, 347, 348, 349, 350,
2240  351, 352, 114, 111, 0, 0, 0, 977, 276, 651,
2241  -245, 110, 114, 0, 0, 652, 653, 654, 0, 0,
2242  0, 81, 110, 0, 0, 0, 0, 0, 0, 0,
2243  277, 81, 0, 0, 0, 0, 0, 0, 0, 0,
2244  655, 0, 0, 656, 0, 0, 0, 0, 0, 0,
2245  0, 0, 0, 0, 0, 0, 0, 111, 0, 0,
2246  111, 0, 111, 0, 0, 0, 0, 276, 0, 0,
2247  0, 110, 0, 110, 553, 554, 0, 0, 555, 110,
2248  277, 110, 0, 0, 0, 0, 0, 0, 162, 163,
2249  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
2250  172, 0, 0, 173, 174, 175, 176, 111, 0, 0,
2251  0, 113, 0, 113, 0, 111, 0, 177, 178, 0,
2252  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2253  0, 0, 114, 0, 114, 113, 0, 0, 179, 180,
2254  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
2255  190, 81, 0, 81, 0, 0, 114, 191, 0, 0,
2256  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2257  0, 381, 0, 113, 0, 81, 0, 0, 0, 0,
2258  0, 0, 0, 0, 0, 0, 111, 0, 0, 0,
2259  0, 0, 0, 0, 114, 0, 0, 0, 0, 277,
2260  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2261  0, 111, 0, 81, 0, 0, 0, 0, 111, 111,
2262  0, 0, 111, 0, 0, 0, 0, 113, 0, 0,
2263  113, 0, 113, 0, 0, 0, 0, 0, 798, 0,
2264  0, 0, 0, 0, 0, 0, 0, 0, 114, 111,
2265  111, 114, 0, 114, 0, 0, 0, 0, 277, 0,
2266  0, 0, 0, 111, 381, 0, 0, 81, 0, 0,
2267  81, 0, 81, 0, 0, 0, 0, 113, 523, 0,
2268  0, 0, 0, 0, 0, 113, 0, 978, 0, 0,
2269  0, 111, 0, 0, 0, 0, 0, 0, 114, 0,
2270  0, 0, 111, 0, 0, 0, 114, 0, 0, 0,
2271  0, 0, 0, 0, 0, 0, 0, 81, 327, -621,
2272  -621, -621, -621, 332, 333, 81, 0, -621, -621, 0,
2273  0, 0, 0, 340, 341, 0, 0, 0, 0, 0,
2274  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2275  0, 111, 0, 111, 0, 0, 113, 0, 0, 111,
2276  0, 111, 382, 0, 0, 0, 343, 344, 345, 346,
2277  347, 348, 349, 350, 351, 352, 0, 114, 0, 0,
2278  0, 113, 0, 0, 0, 0, 0, 0, 113, 113,
2279  0, 0, 113, 0, 0, 0, 81, 0, 0, 0,
2280  0, 0, 114, 0, 0, 0, 0, 0, 0, 114,
2281  114, 0, 0, 114, 0, 0, 0, 0, 0, 113,
2282  113, 81, 0, 0, 0, 0, 0, 0, 81, 81,
2283  0, 0, 81, 113, 0, 0, 0, 0, 0, 0,
2284  114, 114, 0, 0, 0, 0, 0, 0, 0, 0,
2285  0, 0, 0, 0, 114, 382, 0, 0, 0, 81,
2286  81, 113, 0, 0, 0, 0, 0, 0, 0, 0,
2287  0, 0, 113, 81, 0, 0, 0, 0, 979, 0,
2288  0, 0, 114, 0, 0, 0, 0, 0, 0, 0,
2289  0, 0, 0, 114, 0, 0, 0, 975, 0, 0,
2290  0, 81, 0, 0, 0, 0, 0, 0, 0, 0,
2291  0, 0, 81, 0, 0, 0, 0, 0, 0, 0,
2292  0, 113, 0, 113, 0, 0, 0, 0, 0, 113,
2293  0, 113, 0, 0, 0, 0, 0, 0, 0, 0,
2294  0, 0, 114, 0, 114, 0, 0, 0, 0, 0,
2295  114, 0, 114, 0, 0, 0, 0, 0, 0, 0,
2296  0, 81, 0, 81, 0, 0, 0, 0, 0, 81,
2297  0, 81, -620, 4, 0, 5, 6, 7, 8, 9,
2298  0, 0, 0, 10, 11, 0, 0, 0, 12, 0,
2299  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2300  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2301  0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
2302  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2303  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2304  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2305  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2306  0, 49, 50, 0, 51, 52, 0, 53, 0, 0,
2307  54, 55, 56, 57, 58, 59, 60, 61, 62, -602,
2308  0, 0, 0, 0, 0, 0, 0, -602, -602, -602,
2309  0, 0, -602, -602, -602, 0, -602, 0, 63, 64,
2310  65, 0, 751, 0, 0, -602, -602, -602, -602, 0,
2311  0, -620, 0, -620, 0, 0, -602, -602, 0, -602,
2312  -602, -602, -602, -602, 0, 0, 327, 328, 329, 330,
2313  331, 332, 333, 334, 335, 336, 337, 338, 339, 0,
2314  0, 340, 341, 0, 0, 0, 0, -602, -602, -602,
2315  -602, -602, -602, -602, -602, -602, -602, -602, -602, -602,
2316  0, 0, -602, -602, -602, 0, 755, -602, 0, 0,
2317  0, 0, 342, -602, 343, 344, 345, 346, 347, 348,
2318  349, 350, 351, 352, 0, 0, 0, -602, 0, 0,
2319  -602, 0, -106, -602, -602, -602, -602, -602, -602, -602,
2320  -602, -602, -602, -602, -602, 0, 0, 0, 0, -602,
2321  -602, -602, -602, -602, -505, 0, -602, -602, -602, 0,
2322  -602, 0, -505, -505, -505, 0, 0, -505, -505, -505,
2323  0, -505, 0, 0, 0, 0, 0, 698, 0, -505,
2324  0, -505, -505, -505, 0, 0, 0, 0, 0, 0,
2325  0, -505, -505, 0, -505, -505, -505, -505, -505, 0,
2326  0, 327, 328, 329, 330, 331, 332, 333, 334, 335,
2327  336, 337, 338, 339, 0, 0, 340, 341, 0, 0,
2328  0, 0, -505, -505, -505, -505, -505, -505, -505, -505,
2329  -505, -505, -505, -505, -505, 0, 0, -505, -505, -505,
2330  0, -505, -505, 0, 0, 0, 0, 342, -505, 343,
2331  344, 345, 346, 347, 348, 349, 350, 351, 352, 0,
2332  0, 0, -505, 0, 0, -505, 0, -505, -505, -505,
2333  -505, -505, -505, -505, -505, -505, -505, -505, -505, -505,
2334  0, 0, 0, 0, 0, -505, -505, -505, -505, -508,
2335  0, -505, -505, -505, 0, -505, 0, -508, -508, -508,
2336  0, 0, -508, -508, -508, 0, -508, 0, 0, 0,
2337  0, 0, 0, 0, -508, 0, -508, -508, -508, 0,
2338  0, 0, 0, 0, 0, 0, -508, -508, 0, -508,
2339  -508, -508, -508, -508, 0, 0, 327, 328, 329, 330,
2340  331, 332, 333, 334, 335, 336, 337, 338, 339, 0,
2341  0, 340, 341, 0, 0, 0, 0, -508, -508, -508,
2342  -508, -508, -508, -508, -508, -508, -508, -508, -508, -508,
2343  0, 0, -508, -508, -508, 0, -508, -508, 0, 0,
2344  0, 0, 342, -508, 343, 344, 345, 346, 347, 348,
2345  349, 350, 351, 352, 0, 0, 0, -508, 0, 0,
2346  -508, 0, -508, -508, -508, -508, -508, -508, -508, -508,
2347  -508, -508, -508, -508, -508, 0, 0, 0, 0, 0,
2348  -508, -508, -508, -508, -603, 0, -508, -508, -508, 0,
2349  -508, 0, -603, -603, -603, 0, 0, -603, -603, -603,
2350  0, -603, 0, 0, 0, 0, 0, 0, 0, 0,
2351  -603, -603, -603, -603, 0, 0, 0, 0, 0, 0,
2352  0, -603, -603, 0, -603, -603, -603, -603, -603, 0,
2353  0, 327, 328, 329, 330, 331, 332, 333, 334, 335,
2354  336, 337, -621, -621, 0, 0, 340, 341, 0, 0,
2355  0, 0, -603, -603, -603, -603, -603, -603, -603, -603,
2356  -603, -603, -603, -603, -603, 0, 0, -603, -603, -603,
2357  0, 0, -603, 0, 0, 0, 0, 0, -603, 343,
2358  344, 345, 346, 347, 348, 349, 350, 351, 352, 0,
2359  0, 0, -603, 0, 0, -603, 0, 0, -603, -603,
2360  -603, -603, -603, -603, -603, -603, -603, -603, -603, -603,
2361  0, 0, 0, 0, -603, -603, -603, -603, -603, -604,
2362  0, -603, -603, -603, 0, -603, 0, -604, -604, -604,
2363  0, 0, -604, -604, -604, 0, -604, 0, 0, 0,
2364  0, 0, 0, 0, 0, -604, -604, -604, -604, 0,
2365  0, 0, 0, 0, 0, 0, -604, -604, 0, -604,
2366  -604, -604, -604, -604, 0, 0, 327, 328, 329, 330,
2367  331, 332, 333, 334, 0, 336, 337, 0, 0, 0,
2368  0, 340, 341, 0, 0, 0, 0, -604, -604, -604,
2369  -604, -604, -604, -604, -604, -604, -604, -604, -604, -604,
2370  0, 0, -604, -604, -604, 0, 0, -604, 0, 0,
2371  0, 0, 0, -604, 343, 344, 345, 346, 347, 348,
2372  349, 350, 351, 352, 0, 0, 0, -604, 0, 0,
2373  -604, 0, 0, -604, -604, -604, -604, -604, -604, -604,
2374  -604, -604, -604, -604, -604, 0, 0, 0, 0, -604,
2375  -604, -604, -604, -604, -294, 0, -604, -604, -604, 0,
2376  -604, 0, -294, -294, -294, 0, 0, -294, -294, -294,
2377  0, -294, 0, 0, 0, 0, 0, 0, 0, 0,
2378  0, -294, -294, -294, 0, 0, 0, 0, 0, 0,
2379  0, -294, -294, 0, -294, -294, -294, -294, -294, 0,
2380  0, 327, 328, 329, 330, 331, 332, 333, 0, 0,
2381  336, 337, 0, 0, 0, 0, 340, 341, 0, 0,
2382  0, 0, -294, -294, -294, -294, -294, -294, -294, -294,
2383  -294, -294, -294, -294, -294, 0, 0, -294, -294, -294,
2384  0, 756, -294, 0, 0, 0, 0, 0, -294, 343,
2385  344, 345, 346, 347, 348, 349, 350, 351, 352, 0,
2386  0, 0, -294, 0, 0, -294, 0, -108, -294, -294,
2387  -294, -294, -294, -294, -294, -294, -294, -294, -294, -294,
2388  0, 0, 0, 0, 0, -294, -294, -294, -294, -432,
2389  0, -294, -294, -294, 0, -294, 0, -432, -432, -432,
2390  0, 0, -432, -432, -432, 0, -432, 0, 0, 0,
2391  0, 0, 0, 0, 0, -432, -432, -432, 0, 0,
2392  0, 0, 0, 0, 0, 0, -432, -432, 0, -432,
2393  -432, -432, -432, -432, 0, 0, 0, 0, 0, 0,
2394  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2395  0, 0, 0, 0, 0, 0, 0, -432, -432, -432,
2396  -432, -432, -432, -432, -432, -432, -432, -432, -432, -432,
2397  0, 0, -432, -432, -432, 0, 0, -432, 0, 0,
2398  0, 0, 0, -432, 0, 0, 0, 0, 0, 0,
2399  0, 0, 0, 0, 0, 0, 0, -432, 0, 0,
2400  0, 0, 0, -432, 0, -432, -432, -432, -432, -432,
2401  -432, -432, -432, -432, -432, 0, 0, 0, 0, -432,
2402  -432, -432, -432, -432, -285, 227, -432, -432, -432, 0,
2403  -432, 0, -285, -285, -285, 0, 0, -285, -285, -285,
2404  0, -285, 0, 0, 0, 0, 0, 0, 0, 0,
2405  0, -285, -285, -285, 0, 0, 0, 0, 0, 0,
2406  0, -285, -285, 0, -285, -285, -285, -285, -285, 0,
2407  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2408  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2409  0, 0, -285, -285, -285, -285, -285, -285, -285, -285,
2410  -285, -285, -285, -285, -285, 0, 0, -285, -285, -285,
2411  0, 0, -285, 0, 0, 0, 0, 0, -285, 0,
2412  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2413  0, 0, -285, 0, 0, -285, 0, 0, -285, -285,
2414  -285, -285, -285, -285, -285, -285, -285, -285, -285, -285,
2415  0, 0, 0, 0, 0, -285, -285, -285, -285, -422,
2416  0, -285, -285, -285, 0, -285, 0, -422, -422, -422,
2417  0, 0, -422, -422, -422, 0, -422, 0, 0, 0,
2418  0, 0, 0, 0, 0, -422, -422, -422, 0, 0,
2419  0, 0, 0, 0, 0, 0, -422, -422, 0, -422,
2420  -422, -422, -422, -422, 0, 0, 0, 0, 0, 0,
2421  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2422  0, 0, 0, 0, 0, 0, 0, -422, -422, -422,
2423  -422, -422, -422, -422, -422, -422, -422, -422, -422, -422,
2424  0, 0, -422, -422, -422, 0, 0, -422, 0, 0,
2425  0, 0, 0, -422, 0, 0, 0, 0, 0, 0,
2426  0, 0, 0, 0, 0, 0, 0, -422, 0, 0,
2427  0, 0, 0, -422, 0, -422, -422, -422, -422, -422,
2428  -422, -422, -422, -422, -422, 0, 0, 0, 0, -422,
2429  -422, -422, -422, -422, -301, -422, -422, -422, -422, 0,
2430  -422, 0, -301, -301, -301, 0, 0, -301, -301, -301,
2431  0, -301, 0, 0, 0, 0, 0, 0, 0, 0,
2432  0, -301, -301, 0, 0, 0, 0, 0, 0, 0,
2433  0, -301, -301, 0, -301, -301, -301, -301, -301, 0,
2434  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2435  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2436  0, 0, -301, -301, -301, -301, -301, -301, -301, -301,
2437  -301, -301, -301, -301, -301, 0, 0, -301, -301, -301,
2438  0, 0, -301, 0, 0, 0, 0, 0, -301, 0,
2439  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2440  0, 0, -301, 0, 0, 0, 0, 0, -301, 0,
2441  -301, -301, -301, -301, -301, -301, -301, -301, -301, -301,
2442  0, 0, 0, 0, 0, -301, -301, -301, -301, -602,
2443  224, -301, -301, -301, 0, -301, 0, -602, -602, -602,
2444  0, 0, 0, -602, -602, 0, -602, 0, 0, 0,
2445  0, 0, 0, 0, 0, -602, 0, 0, 0, 0,
2446  0, 0, 0, 0, 0, 0, -602, -602, 0, -602,
2447  -602, -602, -602, -602, 0, 0, 0, 0, 0, 0,
2448  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2449  0, 0, 0, 0, 0, 0, 0, -602, -602, -602,
2450  -602, -602, -602, -602, -602, -602, -602, -602, -602, -602,
2451  0, 0, -602, -602, -602, 0, 700, 0, 0, 0,
2452  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2453  0, 0, 0, 0, 0, 0, 0, -602, 0, 0,
2454  0, 0, -106, -602, 0, -602, -602, -602, -602, -602,
2455  -602, -602, -602, -602, -602, 0, 0, 0, 0, -602,
2456  -602, -602, -602, -97, -294, 0, -602, 0, -602, 0,
2457  -602, 0, -294, -294, -294, 0, 0, 0, -294, -294,
2458  0, -294, 0, -620, 0, 0, 0, 0, 0, 0,
2459  0, -620, -620, -620, 0, 0, -620, -620, -620, 0,
2460  -620, -294, -294, 0, -294, -294, -294, -294, -294, -620,
2461  -620, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2462  -620, -620, 0, -620, -620, -620, -620, -620, 0, 0,
2463  0, 0, -294, -294, -294, -294, -294, -294, -294, -294,
2464  -294, -294, -294, -294, -294, 0, 0, -294, -294, -294,
2465  0, 701, 0, 0, 0, 0, 0, 0, 0, 0,
2466  0, 0, 0, 0, 0, 0, 0, 0, -620, 0,
2467  0, 0, -294, 0, 0, 0, 0, -108, -294, 0,
2468  -294, -294, -294, -294, -294, -294, -294, -294, -294, -294,
2469  0, -620, 0, 0, 0, -294, -294, -294, -99, 0,
2470  0, -294, 0, -294, 0, -294, 0, 0, 0, 0,
2471  0, 0, 0, -620, -620, 0, -620, 0, 0, 227,
2472  -620, 0, -620, 248, -620, 5, 6, 7, 8, 9,
2473  -620, -620, -620, 10, 11, 0, 0, -620, 12, 0,
2474  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2475  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2476  0, 27, 0, 0, 0, 0, 0, 28, 29, 249,
2477  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2478  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2479  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2480  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2481  0, 49, 50, 0, 51, 52, 0, 53, 0, 0,
2482  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2483  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2484  0, 0, 0, 0, 0, 0, 0, 0, 63, 64,
2485  65, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2486  0, -620, 248, -620, 5, 6, 7, 8, 9, 0,
2487  0, -620, 10, 11, 0, -620, -620, 12, 0, 13,
2488  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2489  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2490  27, 0, 0, 0, 0, 0, 28, 29, 249, 31,
2491  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2492  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2493  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2494  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2495  49, 50, 0, 51, 52, 0, 53, 0, 0, 54,
2496  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2497  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2498  0, 0, 0, 0, 0, 0, 0, 63, 64, 65,
2499  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2500  -620, 248, -620, 5, 6, 7, 8, 9, 0, 0,
2501  -620, 10, 11, 0, 0, -620, 12, -620, 13, 14,
2502  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2503  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2504  0, 0, 0, 0, 0, 28, 29, 249, 31, 32,
2505  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2506  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2507  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2508  0, 0, 0, 0, 0, 0, 48, 0, 0, 49,
2509  50, 0, 51, 52, 0, 53, 0, 0, 54, 55,
2510  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2511  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2512  0, 0, 0, 0, 0, 0, 63, 64, 65, 0,
2513  0, 0, 0, 0, 0, 0, 0, 0, 0, -620,
2514  248, -620, 5, 6, 7, 8, 9, 0, 0, -620,
2515  10, 11, 0, 0, -620, 12, 0, 13, 14, 15,
2516  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2517  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2518  0, 0, 0, 0, 28, 29, 249, 31, 32, 33,
2519  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2520  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2521  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2522  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2523  0, 51, 52, 0, 53, 0, 0, 54, 55, 56,
2524  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2525  0, 0, 0, 248, 0, 5, 6, 7, 8, 9,
2526  0, -620, -620, 10, 11, 63, 64, 65, 12, 0,
2527  13, 14, 15, 16, 17, 18, 19, 0, -620, 0,
2528  -620, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2529  0, 27, 0, 0, 0, 0, 0, 28, 29, 249,
2530  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2531  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2532  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2533  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2534  0, 49, 50, 0, 51, 52, 0, 53, 0, 0,
2535  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2536  0, 0, 0, 0, 0, 0, 248, 0, 5, 6,
2537  7, 8, 9, 0, 0, 0, 10, 11, 63, 64,
2538  65, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2539  0, -620, 0, -620, 0, 20, 21, 22, 23, 24,
2540  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2541  28, 29, 249, 31, 32, 33, 34, 35, 36, 37,
2542  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2543  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2544  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2545  0, 48, 0, 0, 250, 50, 0, 51, 52, 0,
2546  53, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2547  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2548  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2549  0, 63, 64, 65, 0, 0, 0, 0, 0, 0,
2550  0, 0, -620, 0, -620, 248, -620, 5, 6, 7,
2551  8, 9, 0, 0, 0, 10, 11, 0, 0, 0,
2552  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2553  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2554  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2555  29, 249, 31, 32, 33, 34, 35, 36, 37, 38,
2556  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2557  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2558  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2559  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2560  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2561  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2562  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2563  63, 64, 65, 0, 0, 0, 0, 0, 0, 0,
2564  0, -620, 0, -620, 248, -620, 5, 6, 7, 8,
2565  9, 0, 0, 0, 10, 11, 0, 0, 0, 12,
2566  0, 13, 14, 15, 16, 17, 18, 19, 0, 0,
2567  0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
2568  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2569  249, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2570  40, 0, 41, 42, 0, 43, 44, 45, 0, 46,
2571  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2572  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
2573  0, 0, 49, 50, 0, 51, 52, 0, 53, 0,
2574  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2575  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2576  0, 0, 0, 0, 0, 0, 0, 0, 0, 63,
2577  64, 65, 0, 0, -620, 4, 0, 5, 6, 7,
2578  8, 9, -620, 0, -620, 10, 11, 0, 0, 0,
2579  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2580  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2581  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2582  29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
2583  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2584  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2585  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2586  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2587  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2588  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2589  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2590  63, 64, 65, 0, 0, -620, 0, 0, 0, 0,
2591  0, 0, 0, -620, 248, -620, 5, 6, 7, 8,
2592  9, 0, 0, -620, 10, 11, 0, 0, 0, 12,
2593  0, 13, 14, 15, 16, 17, 18, 19, 0, 0,
2594  0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
2595  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2596  249, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2597  40, 0, 41, 42, 0, 43, 44, 45, 0, 46,
2598  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2599  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
2600  0, 0, 49, 50, 0, 51, 52, 0, 53, 0,
2601  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2602  0, 0, 0, 0, 0, 0, 0, 248, 0, 5,
2603  6, 7, 8, 9, 0, 0, 0, 10, 11, 63,
2604  64, 65, 12, 0, 13, 14, 15, 16, 17, 18,
2605  19, 0, -620, 0, -620, 0, 20, 21, 22, 23,
2606  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2607  0, 28, 29, 249, 31, 32, 33, 34, 35, 36,
2608  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2609  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2610  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2611  0, 0, 48, 0, 0, 49, 50, 0, 51, 52,
2612  0, 53, 0, 0, 54, 55, 56, 57, 58, 59,
2613  60, 61, 62, 0, -620, 0, 0, 0, 0, 0,
2614  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2615  10, 11, 63, 64, 65, 12, 0, 13, 14, 15,
2616  16, 17, 18, 19, 0, -620, 0, -620, 0, 20,
2617  21, 22, 23, 24, 25, 26, 0, 0, 200, 0,
2618  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2619  34, 35, 36, 37, 38, 39, 40, 201, 41, 42,
2620  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2621  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2622  0, 0, 0, 0, 0, 202, 0, 0, 203, 50,
2623  0, 51, 52, 0, 204, 205, 206, 54, 55, 56,
2624  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2625  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2626  0, 0, 0, 10, 11, 63, 207, 65, 12, 0,
2627  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2628  231, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2629  0, 27, 0, 0, 0, 0, 0, 0, 29, 0,
2630  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2631  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2632  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2633  0, 0, 0, 0, 0, 0, 0, 0, 202, 0,
2634  0, 203, 50, 0, 51, 52, 0, 0, 0, 0,
2635  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2636  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2637  7, 0, 9, 0, 0, 0, 10, 11, 63, 64,
2638  65, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2639  0, 302, 0, 303, 0, 20, 21, 22, 23, 24,
2640  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2641  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2642  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2643  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2644  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2645  0, 202, 0, 0, 203, 50, 0, 51, 52, 0,
2646  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2647  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2648  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2649  11, 63, 64, 65, 12, 0, 13, 14, 15, 16,
2650  17, 18, 19, 0, 0, 0, 231, 0, 20, 21,
2651  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2652  0, 0, 0, 28, 29, 30, 31, 32, 33, 34,
2653  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2654  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2655  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2656  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2657  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2658  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2659  0, 0, 0, 0, 5, 6, 7, 8, 9, 0,
2660  0, 0, 10, 11, 63, 64, 65, 12, 0, 13,
2661  14, 15, 16, 17, 18, 19, 0, 498, 0, 0,
2662  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2663  27, 0, 0, 0, 0, 0, 28, 29, 249, 31,
2664  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2665  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2666  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2667  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2668  49, 50, 0, 51, 52, 0, 53, 0, 0, 54,
2669  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2670  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2671  0, 0, 0, 0, 0, 0, 0, 63, 64, 65,
2672  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2673  498, 118, 119, 120, 121, 122, 123, 124, 125, 126,
2674  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
2675  137, 138, 139, 140, 141, 0, 0, 0, 142, 143,
2676  144, 384, 385, 386, 387, 149, 150, 151, 0, 0,
2677  0, 0, 0, 152, 153, 154, 155, 388, 389, 390,
2678  391, 160, 37, 38, 392, 40, 0, 0, 0, 0,
2679  0, 0, 0, 0, 162, 163, 164, 165, 166, 167,
2680  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
2681  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
2682  0, 0, 0, 177, 178, 0, 0, 0, 0, 0,
2683  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2684  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
2685  185, 186, 187, 188, 0, 189, 190, 0, 0, 0,
2686  0, 0, 0, 191, 393, 118, 119, 120, 121, 122,
2687  123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
2688  133, 134, 135, 136, 137, 138, 139, 140, 141, 0,
2689  0, 0, 142, 143, 144, 145, 146, 147, 148, 149,
2690  150, 151, 0, 0, 0, 0, 0, 152, 153, 154,
2691  155, 156, 157, 158, 159, 160, 280, 281, 161, 282,
2692  0, 0, 0, 0, 0, 0, 0, 0, 162, 163,
2693  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
2694  172, 0, 0, 173, 174, 175, 176, 0, 0, 0,
2695  0, 0, 0, 0, 0, 0, 0, 177, 178, 0,
2696  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2697  0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
2698  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
2699  190, 0, 0, 0, 0, 0, 0, 191, 118, 119,
2700  120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
2701  130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2702  140, 141, 0, 0, 0, 142, 143, 144, 145, 146,
2703  147, 148, 149, 150, 151, 0, 0, 0, 0, 0,
2704  152, 153, 154, 155, 156, 157, 158, 159, 160, 233,
2705  0, 161, 0, 0, 0, 0, 0, 0, 0, 0,
2706  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
2707  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
2708  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2709  177, 178, 0, 0, 55, 0, 0, 0, 0, 0,
2710  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2711  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
2712  188, 0, 189, 190, 0, 0, 0, 0, 0, 0,
2713  191, 118, 119, 120, 121, 122, 123, 124, 125, 126,
2714  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
2715  137, 138, 139, 140, 141, 0, 0, 0, 142, 143,
2716  144, 145, 146, 147, 148, 149, 150, 151, 0, 0,
2717  0, 0, 0, 152, 153, 154, 155, 156, 157, 158,
2718  159, 160, 0, 0, 161, 0, 0, 0, 0, 0,
2719  0, 0, 0, 0, 162, 163, 164, 165, 166, 167,
2720  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
2721  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
2722  0, 0, 0, 177, 178, 0, 0, 55, 0, 0,
2723  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2724  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
2725  185, 186, 187, 188, 0, 189, 190, 0, 0, 0,
2726  0, 0, 0, 191, 118, 119, 120, 121, 122, 123,
2727  124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
2728  134, 135, 136, 137, 138, 139, 140, 141, 0, 0,
2729  0, 142, 143, 144, 145, 146, 147, 148, 149, 150,
2730  151, 0, 0, 0, 0, 0, 152, 153, 154, 155,
2731  156, 157, 158, 159, 160, 0, 0, 161, 0, 0,
2732  0, 0, 0, 0, 0, 0, 0, 162, 163, 164,
2733  165, 166, 167, 168, 169, 170, 0, 0, 171, 172,
2734  0, 0, 173, 174, 175, 176, 0, 0, 0, 0,
2735  0, 0, 0, 0, 0, 0, 177, 178, 0, 0,
2736  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2737  0, 0, 0, 0, 0, 0, 0, 179, 180, 181,
2738  182, 183, 184, 185, 186, 187, 188, 0, 189, 190,
2739  5, 6, 7, 0, 9, 0, 191, 0, 10, 11,
2740  0, 0, 0, 12, 0, 13, 14, 15, 238, 239,
2741  18, 19, 0, 0, 0, 0, 0, 240, 241, 242,
2742  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
2743  0, 0, 0, 268, 0, 0, 32, 33, 34, 35,
2744  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2745  44, 45, 0, 0, 0, 0, 0, 0, 0, 0,
2746  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2747  0, 0, 0, 269, 0, 0, 203, 50, 0, 51,
2748  52, 0, 0, 0, 0, 54, 55, 56, 57, 58,
2749  59, 60, 61, 62, 0, 0, 0, 0, 0, 5,
2750  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
2751  0, 0, 12, 270, 13, 14, 15, 238, 239, 18,
2752  19, 271, 0, 0, 0, 0, 240, 241, 242, 23,
2753  24, 25, 26, 0, 0, 200, 0, 0, 0, 0,
2754  0, 0, 268, 0, 0, 32, 33, 34, 35, 36,
2755  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2756  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2757  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2758  0, 0, 269, 0, 0, 203, 50, 0, 51, 52,
2759  0, 0, 0, 0, 54, 55, 56, 57, 58, 59,
2760  60, 61, 62, 0, 0, 0, 0, 0, 5, 6,
2761  7, 8, 9, 0, 0, 0, 10, 11, 0, 0,
2762  0, 12, 270, 13, 14, 15, 16, 17, 18, 19,
2763  518, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2764  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2765  28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
2766  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2767  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2768  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2769  0, 48, 0, 0, 49, 50, 0, 51, 52, 0,
2770  53, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2771  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2772  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2773  11, 63, 64, 65, 12, 0, 13, 14, 15, 16,
2774  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2775  22, 23, 24, 25, 26, 0, 0, 200, 0, 0,
2776  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2777  35, 36, 37, 38, 39, 40, 201, 41, 42, 0,
2778  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2779  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2780  0, 0, 0, 0, 202, 0, 0, 203, 50, 0,
2781  51, 52, 0, 204, 205, 206, 54, 55, 56, 57,
2782  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2783  0, 0, 0, 0, 5, 6, 7, 8, 9, 0,
2784  0, 0, 10, 11, 63, 207, 65, 12, 0, 13,
2785  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2786  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2787  27, 0, 0, 0, 0, 0, 28, 29, 0, 31,
2788  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2789  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2790  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2791  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2792  49, 50, 0, 51, 52, 0, 53, 0, 0, 54,
2793  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2794  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2795  0, 9, 0, 0, 0, 10, 11, 63, 64, 65,
2796  12, 0, 13, 14, 15, 238, 239, 18, 19, 0,
2797  0, 0, 0, 0, 240, 241, 242, 23, 24, 25,
2798  26, 0, 0, 200, 0, 0, 0, 0, 0, 0,
2799  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2800  39, 40, 201, 41, 42, 0, 43, 44, 45, 0,
2801  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2802  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2803  202, 0, 0, 203, 50, 0, 51, 52, 0, 608,
2804  205, 206, 54, 55, 56, 57, 58, 59, 60, 61,
2805  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2806  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2807  63, 207, 65, 12, 0, 13, 14, 15, 238, 239,
2808  18, 19, 0, 0, 0, 0, 0, 240, 241, 242,
2809  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
2810  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2811  36, 37, 38, 39, 40, 201, 41, 42, 0, 43,
2812  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2813  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2814  0, 0, 0, 202, 0, 0, 203, 50, 0, 51,
2815  52, 0, 204, 205, 0, 54, 55, 56, 57, 58,
2816  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
2817  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2818  0, 10, 11, 63, 207, 65, 12, 0, 13, 14,
2819  15, 238, 239, 18, 19, 0, 0, 0, 0, 0,
2820  240, 241, 242, 23, 24, 25, 26, 0, 0, 200,
2821  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
2822  33, 34, 35, 36, 37, 38, 39, 40, 201, 41,
2823  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2824  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2825  0, 0, 0, 0, 0, 0, 202, 0, 0, 203,
2826  50, 0, 51, 52, 0, 0, 205, 206, 54, 55,
2827  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2828  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2829  9, 0, 0, 0, 10, 11, 63, 207, 65, 12,
2830  0, 13, 14, 15, 238, 239, 18, 19, 0, 0,
2831  0, 0, 0, 240, 241, 242, 23, 24, 25, 26,
2832  0, 0, 200, 0, 0, 0, 0, 0, 0, 29,
2833  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2834  40, 201, 41, 42, 0, 43, 44, 45, 0, 46,
2835  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2836  0, 0, 0, 0, 0, 0, 0, 0, 0, 202,
2837  0, 0, 203, 50, 0, 51, 52, 0, 608, 205,
2838  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2839  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2840  6, 7, 0, 9, 0, 0, 0, 10, 11, 63,
2841  207, 65, 12, 0, 13, 14, 15, 238, 239, 18,
2842  19, 0, 0, 0, 0, 0, 240, 241, 242, 23,
2843  24, 25, 26, 0, 0, 200, 0, 0, 0, 0,
2844  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2845  37, 38, 39, 40, 201, 41, 42, 0, 43, 44,
2846  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2847  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2848  0, 0, 202, 0, 0, 203, 50, 0, 51, 52,
2849  0, 0, 205, 0, 54, 55, 56, 57, 58, 59,
2850  60, 61, 62, 0, 0, 0, 0, 0, 0, 0,
2851  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2852  10, 11, 63, 207, 65, 12, 0, 13, 14, 15,
2853  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2854  21, 22, 23, 24, 25, 26, 0, 0, 200, 0,
2855  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2856  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2857  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2858  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2859  0, 0, 0, 0, 0, 202, 0, 0, 203, 50,
2860  0, 51, 52, 0, 512, 0, 0, 54, 55, 56,
2861  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2862  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2863  0, 0, 0, 10, 11, 63, 207, 65, 12, 0,
2864  13, 14, 15, 238, 239, 18, 19, 0, 0, 0,
2865  0, 0, 240, 241, 242, 23, 24, 25, 26, 0,
2866  0, 200, 0, 0, 0, 0, 0, 0, 29, 0,
2867  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2868  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2869  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2870  0, 0, 0, 0, 0, 0, 0, 0, 202, 0,
2871  0, 203, 50, 0, 51, 52, 0, 204, 0, 0,
2872  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2873  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2874  7, 0, 9, 0, 0, 0, 10, 11, 63, 207,
2875  65, 12, 0, 13, 14, 15, 238, 239, 18, 19,
2876  0, 0, 0, 0, 0, 240, 241, 242, 23, 24,
2877  25, 26, 0, 0, 200, 0, 0, 0, 0, 0,
2878  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2879  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2880  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2881  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2882  0, 202, 0, 0, 203, 50, 0, 51, 52, 0,
2883  817, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2884  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2885  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2886  11, 63, 207, 65, 12, 0, 13, 14, 15, 238,
2887  239, 18, 19, 0, 0, 0, 0, 0, 240, 241,
2888  242, 23, 24, 25, 26, 0, 0, 200, 0, 0,
2889  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2890  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2891  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2892  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2893  0, 0, 0, 0, 202, 0, 0, 203, 50, 0,
2894  51, 52, 0, 512, 0, 0, 54, 55, 56, 57,
2895  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2896  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2897  0, 0, 10, 11, 63, 207, 65, 12, 0, 13,
2898  14, 15, 238, 239, 18, 19, 0, 0, 0, 0,
2899  0, 240, 241, 242, 23, 24, 25, 26, 0, 0,
2900  200, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2901  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2902  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2903  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2904  0, 0, 0, 0, 0, 0, 0, 202, 0, 0,
2905  203, 50, 0, 51, 52, 0, 608, 0, 0, 54,
2906  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2907  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2908  0, 9, 0, 0, 0, 10, 11, 63, 207, 65,
2909  12, 0, 13, 14, 15, 238, 239, 18, 19, 0,
2910  0, 0, 0, 0, 240, 241, 242, 23, 24, 25,
2911  26, 0, 0, 200, 0, 0, 0, 0, 0, 0,
2912  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2913  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2914  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2915  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2916  202, 0, 0, 203, 50, 0, 51, 52, 0, 0,
2917  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2918  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2919  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2920  63, 207, 65, 12, 0, 13, 14, 15, 16, 17,
2921  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2922  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
2923  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2924  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2925  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2926  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2927  0, 0, 0, 202, 0, 0, 203, 50, 0, 51,
2928  52, 0, 0, 0, 0, 54, 55, 56, 57, 58,
2929  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
2930  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2931  0, 10, 11, 63, 207, 65, 12, 0, 13, 14,
2932  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2933  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2934  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
2935  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2936  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2937  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2938  0, 0, 0, 0, 0, 0, 202, 0, 0, 203,
2939  50, 0, 51, 52, 0, 0, 0, 0, 54, 55,
2940  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2941  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2942  9, 0, 0, 0, 10, 11, 63, 64, 65, 12,
2943  0, 13, 14, 15, 238, 239, 18, 19, 0, 0,
2944  0, 0, 0, 240, 241, 242, 23, 24, 25, 26,
2945  0, 0, 200, 0, 0, 0, 0, 0, 0, 268,
2946  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2947  40, 0, 41, 42, 0, 43, 44, 45, 0, 0,
2948  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2949  0, 0, 0, 0, 0, 0, 0, 0, 0, 269,
2950  0, 0, 323, 50, 0, 51, 52, 0, 324, 0,
2951  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2952  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2953  0, 0, 0, 10, 11, 0, 0, 0, 12, 270,
2954  13, 14, 15, 238, 239, 18, 19, 0, 0, 0,
2955  0, 0, 240, 241, 242, 23, 24, 25, 26, 0,
2956  0, 200, 0, 0, 0, 0, 0, 0, 268, 0,
2957  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2958  0, 41, 42, 0, 43, 44, 45, 0, 0, 0,
2959  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2960  0, 0, 0, 0, 0, 0, 0, 0, 365, 0,
2961  0, 49, 50, 0, 51, 52, 0, 53, 0, 0,
2962  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2963  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2964  0, 0, 10, 11, 0, 0, 0, 12, 270, 13,
2965  14, 15, 238, 239, 18, 19, 0, 0, 0, 0,
2966  0, 240, 241, 242, 23, 24, 25, 26, 0, 0,
2967  200, 0, 0, 0, 0, 0, 0, 268, 0, 0,
2968  32, 33, 34, 373, 36, 37, 38, 374, 40, 0,
2969  41, 42, 0, 43, 44, 45, 0, 0, 0, 0,
2970  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2971  0, 0, 0, 0, 375, 0, 0, 376, 0, 0,
2972  203, 50, 0, 51, 52, 0, 0, 0, 0, 54,
2973  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2974  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2975  0, 10, 11, 0, 0, 0, 12, 270, 13, 14,
2976  15, 238, 239, 18, 19, 0, 0, 0, 0, 0,
2977  240, 241, 242, 23, 24, 25, 26, 0, 0, 200,
2978  0, 0, 0, 0, 0, 0, 268, 0, 0, 32,
2979  33, 34, 373, 36, 37, 38, 374, 40, 0, 41,
2980  42, 0, 43, 44, 45, 0, 0, 0, 0, 0,
2981  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2982  0, 0, 0, 0, 0, 0, 376, 0, 0, 203,
2983  50, 0, 51, 52, 0, 0, 0, 0, 54, 55,
2984  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2985  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2986  10, 11, 0, 0, 0, 12, 270, 13, 14, 15,
2987  238, 239, 18, 19, 0, 0, 0, 0, 0, 240,
2988  241, 242, 23, 24, 25, 26, 0, 0, 200, 0,
2989  0, 0, 0, 0, 0, 268, 0, 0, 32, 33,
2990  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2991  0, 43, 44, 45, 0, 0, 0, 0, 0, 0,
2992  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2993  0, 0, 0, 0, 0, 269, 0, 0, 323, 50,
2994  0, 51, 52, 0, 0, 0, 0, 54, 55, 56,
2995  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2996  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2997  11, 0, 0, 0, 12, 270, 13, 14, 15, 238,
2998  239, 18, 19, 0, 0, 0, 0, 0, 240, 241,
2999  242, 23, 24, 25, 26, 0, 0, 200, 0, 0,
3000  0, 0, 0, 0, 268, 0, 0, 32, 33, 34,
3001  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
3002  43, 44, 45, 0, 0, 0, 0, 0, 0, 0,
3003  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3004  0, 0, 0, 0, 894, 0, 0, 203, 50, 0,
3005  51, 52, 0, 0, 0, 0, 54, 55, 56, 57,
3006  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
3007  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
3008  0, 0, 0, 12, 270, 13, 14, 15, 238, 239,
3009  18, 19, 0, 0, 0, 0, 0, 240, 241, 242,
3010  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
3011  0, 0, 0, 268, 0, 0, 32, 33, 34, 35,
3012  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
3013  44, 45, 0, 0, 0, 0, 0, 0, 0, 0,
3014  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3015  0, 0, 0, 974, 0, 0, 203, 50, 0, 51,
3016  52, 0, 0, 0, 0, 54, 55, 56, 57, 58,
3017  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
3018  561, 562, 0, 0, 563, 0, 0, 0, 0, 0,
3019  0, 0, 0, 270, 162, 163, 164, 165, 166, 167,
3020  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
3021  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
3022  0, 0, 0, 177, 178, 0, 0, 0, 0, 0,
3023  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3024  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
3025  185, 186, 187, 188, 0, 189, 190, 598, 562, 0,
3026  0, 599, 0, 191, 0, 0, 0, 0, 0, 0,
3027  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
3028  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
3029  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3030  177, 178, 0, 0, 0, 0, 0, 0, 0, 0,
3031  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3032  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
3033  188, 0, 189, 190, 612, 554, 0, 0, 613, 0,
3034  191, 0, 0, 0, 0, 0, 0, 0, 162, 163,
3035  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
3036  172, 0, 0, 173, 174, 175, 176, 0, 0, 0,
3037  0, 0, 0, 0, 0, 0, 0, 177, 178, 0,
3038  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3039  0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
3040  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
3041  190, 615, 562, 0, 0, 616, 0, 191, 0, 0,
3042  0, 0, 0, 0, 0, 162, 163, 164, 165, 166,
3043  167, 168, 169, 170, 0, 0, 171, 172, 0, 0,
3044  173, 174, 175, 176, 0, 0, 0, 0, 0, 0,
3045  0, 0, 0, 0, 177, 178, 0, 0, 0, 0,
3046  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3047  0, 0, 0, 0, 0, 179, 180, 181, 182, 183,
3048  184, 185, 186, 187, 188, 0, 189, 190, 639, 554,
3049  0, 0, 640, 0, 191, 0, 0, 0, 0, 0,
3050  0, 0, 162, 163, 164, 165, 166, 167, 168, 169,
3051  170, 0, 0, 171, 172, 0, 0, 173, 174, 175,
3052  176, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3053  0, 177, 178, 0, 0, 0, 0, 0, 0, 0,
3054  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3055  0, 0, 179, 180, 181, 182, 183, 184, 185, 186,
3056  187, 188, 0, 189, 190, 642, 562, 0, 0, 643,
3057  0, 191, 0, 0, 0, 0, 0, 0, 0, 162,
3058  163, 164, 165, 166, 167, 168, 169, 170, 0, 0,
3059  171, 172, 0, 0, 173, 174, 175, 176, 0, 0,
3060  0, 0, 0, 0, 0, 0, 0, 0, 177, 178,
3061  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3062  0, 0, 0, 0, 0, 0, 0, 0, 0, 179,
3063  180, 181, 182, 183, 184, 185, 186, 187, 188, 0,
3064  189, 190, 727, 554, 0, 0, 728, 0, 191, 0,
3065  0, 0, 0, 0, 0, 0, 162, 163, 164, 165,
3066  166, 167, 168, 169, 170, 0, 0, 171, 172, 0,
3067  0, 173, 174, 175, 176, 0, 0, 0, 0, 0,
3068  0, 0, 0, 0, 0, 177, 178, 0, 0, 0,
3069  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3070  0, 0, 0, 0, 0, 0, 179, 180, 181, 182,
3071  183, 184, 185, 186, 187, 188, 0, 189, 190, 730,
3072  562, 0, 0, 731, 0, 191, 0, 0, 0, 0,
3073  0, 0, 0, 162, 163, 164, 165, 166, 167, 168,
3074  169, 170, 0, 0, 171, 172, 0, 0, 173, 174,
3075  175, 176, 0, 0, 0, 0, 0, 0, 0, 0,
3076  0, 0, 177, 178, 0, 0, 0, 0, 0, 0,
3077  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3078  0, 0, 0, 179, 180, 181, 182, 183, 184, 185,
3079  186, 187, 188, 0, 189, 190, 737, 554, 0, 0,
3080  738, 0, 191, 0, 0, 0, 0, 0, 0, 0,
3081  162, 163, 164, 165, 166, 167, 168, 169, 170, 0,
3082  0, 171, 172, 0, 0, 173, 174, 175, 176, 0,
3083  0, 0, 0, 0, 0, 0, 0, 0, 0, 177,
3084  178, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3085  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3086  179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
3087  0, 189, 190, 1002, 554, 0, 0, 1003, 0, 191,
3088  0, 0, 0, 0, 0, 0, 0, 162, 163, 164,
3089  165, 166, 167, 168, 169, 170, 0, 0, 171, 172,
3090  0, 0, 173, 174, 175, 176, 0, 0, 0, 0,
3091  0, 0, 0, 0, 0, 0, 177, 178, 0, 0,
3092  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3093  0, 0, 0, 0, 0, 0, 0, 179, 180, 181,
3094  182, 183, 184, 185, 186, 187, 188, 0, 189, 190,
3095  1037, 554, 0, 0, 1038, 0, 191, 0, 0, 0,
3096  0, 0, 0, 0, 162, 163, 164, 165, 166, 167,
3097  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
3098  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
3099  0, 0, 0, 177, 178, 0, 0, 0, 0, 0,
3100  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3101  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
3102  185, 186, 187, 188, 0, 189, 190, 1040, 562, 0,
3103  0, 1041, 0, 191, 0, 0, 0, 0, 0, 0,
3104  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
3105  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
3106  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3107  177, 178, 0, 0, 0, 0, 0, 0, 0, 0,
3108  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3109  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
3110  188, 0, 189, 190, 0, 0, 0, 0, 0, 0,
3111  191
3112 };
3113 
3114 #define yypact_value_is_default(yystate) \
3115  ((yystate) == (-808))
3116 
3117 #define yytable_value_is_error(yytable_value) \
3118  ((yytable_value) == (-621))
3119 
3120 static const yytype_int16 yycheck[] =
3121 {
3122  2, 87, 55, 96, 90, 353, 79, 355, 472, 16,
3123  17, 22, 359, 20, 354, 326, 614, 2, 8, 4,
3124  16, 17, 8, 28, 20, 326, 412, 27, 49, 29,
3125  74, 4, 220, 53, 420, 86, 87, 420, 28, 90,
3126  575, 94, 28, 641, 594, 49, 668, 685, 574, 51,
3127  52, 399, 468, 67, 262, 51, 779, 472, 266, 79,
3128  53, 376, 508, 74, 90, 511, 2, 415, 4, 417,
3129  715, 91, 92, 93, 719, 458, 416, 440, 25, 787,
3130  16, 17, 25, 13, 20, 16, 17, 13, 67, 20,
3131  875, 26, 25, 27, 873, 443, 903, 250, 37, 38,
3132  58, 29, 518, 16, 17, 64, 8, 20, 68, 87,
3133  68, 90, 777, 49, 139, 113, 141, 53, 85, 61,
3134  51, 52, 13, 471, 907, 25, 28, 76, 64, 61,
3135  470, 729, 596, 651, 0, 113, 134, 802, 96, 97,
3136  85, 779, 740, 79, 286, 15, 288, 17, 290, 787,
3137  86, 87, 294, 55, 90, 91, 92, 93, 141, 13,
3138  939, 25, 120, 123, 124, 125, 133, 26, 110, 118,
3139  323, 13, 25, 25, 25, 898, 59, 60, 110, 230,
3140  25, 232, 203, 111, 806, 807, 736, 134, 133, 13,
3141  130, 134, 94, 657, 744, 130, 56, 1004, 271, 243,
3142  1, 134, 141, 136, 134, 139, 991, 141, 259, 139,
3143  136, 141, 214, 139, 993, 141, 237, 224, 220, 226,
3144  227, 307, 308, 309, 310, 227, 252, 950, 224, 250,
3145  226, 1014, 25, 581, 134, 621, 622, 945, 252, 622,
3146  580, 429, 657, 140, 690, 593, 250, 1026, 139, 25,
3147  141, 271, 592, 771, 772, 140, 307, 308, 309, 310,
3148  898, 312, 313, 248, 886, 903, 140, 203, 268, 632,
3149  134, 130, 136, 252, 360, 361, 591, 136, 230, 743,
3150  696, 134, 134, 134, 929, 139, 1009, 141, 224, 134,
3151  226, 227, 87, 224, 230, 226, 232, 139, 670, 141,
3152  672, 237, 323, 255, 324, 61, 258, 945, 85, 360,
3153  361, 224, 248, 226, 250, 139, 117, 141, 113, 323,
3154  113, 306, 134, 259, 375, 321, 311, 853, 743, 141,
3155  326, 324, 85, 306, 85, 271, 362, 113, 139, 134,
3156  141, 134, 964, 485, 137, 61, 140, 354, 141, 65,
3157  492, 107, 354, 109, 26, 873, 133, 875, 134, 37,
3158  38, 137, 321, 85, 85, 141, 1004, 326, 85, 97,
3159  306, 307, 308, 309, 310, 311, 312, 313, 725, 132,
3160  133, 931, 133, 362, 140, 321, 85, 323, 324, 85,
3161  326, 107, 120, 109, 929, 468, 697, 59, 60, 378,
3162  28, 85, 52, 714, 54, 55, 56, 57, 61, 416,
3163  132, 133, 133, 85, 416, 2, 133, 4, 354, 26,
3164  356, 939, 940, 611, 360, 361, 428, 429, 636, 16,
3165  17, 87, 437, 20, 133, 703, 132, 133, 440, 375,
3166  990, 1039, 710, 402, 403, 518, 85, 437, 468, 133,
3167  87, 437, 134, 355, 107, 440, 109, 113, 130, 141,
3168  132, 133, 49, 470, 136, 113, 402, 403, 470, 85,
3169  422, 134, 936, 991, 426, 993, 113, 64, 85, 431,
3170  416, 412, 868, 68, 134, 868, 52, 140, 54, 55,
3171  56, 57, 113, 132, 133, 447, 87, 399, 518, 86,
3172  87, 87, 85, 90, 440, 507, 508, 87, 1026, 511,
3173  100, 883, 884, 557, 450, 417, 888, 133, 890, 891,
3174  87, 565, 113, 130, 455, 132, 133, 113, 87, 136,
3175  134, 87, 468, 113, 470, 437, 121, 122, 123, 124,
3176  125, 443, 542, 134, 595, 87, 113, 558, 58, 570,
3177  133, 572, 54, 87, 85, 566, 600, 113, 68, 85,
3178  560, 63, 64, 136, 637, 517, 568, 134, 134, 471,
3179  917, 113, 760, 580, 625, 56, 923, 134, 580, 113,
3180  576, 113, 518, 61, 141, 592, 96, 97, 88, 600,
3181  592, 136, 134, 26, 573, 574, 141, 134, 600, 137,
3182  605, 132, 133, 141, 87, 136, 132, 133, 587, 611,
3183  120, 14, 15, 134, 614, 605, 203, 637, 136, 605,
3184  52, 130, 87, 696, 56, 997, 998, 999, 1000, 107,
3185  632, 109, 110, 136, 570, 136, 572, 224, 68, 226,
3186  227, 641, 137, 230, 580, 232, 732, 632, 113, 735,
3187  237, 113, 85, 138, 131, 748, 592, 85, 594, 595,
3188  704, 248, 61, 250, 666, 686, 668, 711, 689, 134,
3189  691, 1019, 259, 56, 134, 1047, 696, 68, 1018, 581,
3190  68, 732, 94, 635, 735, 685, 110, 110, 690, 625,
3191  621, 593, 110, 746, 110, 134, 632, 130, 85, 132,
3192  133, 637, 139, 605, 132, 133, 17, 56, 107, 711,
3193  109, 110, 714, 715, 134, 717, 25, 719, 714, 306,
3194  307, 308, 309, 310, 311, 312, 313, 26, 68, 729,
3195  61, 577, 137, 134, 321, 131, 323, 130, 697, 326,
3196  740, 700, 701, 83, 84, 132, 133, 10, 707, 708,
3197  686, 140, 134, 689, 733, 691, 134, 843, 760, 85,
3198  696, 697, 134, 140, 700, 701, 745, 354, 134, 356,
3199  85, 707, 708, 360, 361, 87, 107, 777, 109, 110,
3200  800, 121, 122, 123, 124, 125, 85, 52, 375, 134,
3201  742, 113, 843, 85, 815, 68, 732, 136, 8, 735,
3202  736, 113, 802, 131, 806, 807, 132, 133, 744, 761,
3203  83, 84, 13, 61, 134, 402, 403, 132, 133, 840,
3204  61, 134, 134, 775, 113, 52, 847, 848, 134, 416,
3205  851, 130, 134, 132, 133, 52, 838, 136, 134, 841,
3206  132, 133, 15, 52, 746, 118, 119, 120, 121, 122,
3207  123, 124, 125, 440, 85, 134, 115, 878, 879, 107,
3208  138, 109, 110, 450, 800, 134, 107, 131, 109, 110,
3209  829, 892, 134, 893, 853, 113, 855, 85, 724, 815,
3210  134, 85, 118, 470, 886, 134, 16, 17, 54, 55,
3211  20, 57, 134, 829, 134, 741, 916, 63, 64, 920,
3212  139, 132, 133, 10, 840, 87, 131, 843, 860, 10,
3213  134, 847, 848, 685, 88, 851, 46, 47, 9, 685,
3214  872, 51, 52, 134, 132, 133, 118, 929, 132, 133,
3215  137, 113, 134, 56, 64, 65, 201, 134, 134, 204,
3216  205, 206, 878, 879, 52, 134, 54, 55, 56, 57,
3217  58, 131, 134, 134, 10, 134, 892, 893, 108, 980,
3218  68, 982, 964, 131, 134, 134, 56, 988, 450, 134,
3219  970, 134, 134, 134, 685, 68, 136, 136, 134, 91,
3220  916, 89, 93, 570, 920, 572, 711, 1021, 96, 97,
3221  83, 84, 771, 580, 685, 931, 1014, 749, 844, 52,
3222  846, 54, 55, 56, 57, 592, 294, 594, 595, 781,
3223  856, 1018, 120, 785, 1020, 861, 1018, 99, 1020, 1021,
3224  57, 787, 94, 781, 790, 936, 898, 120, 121, 122,
3225  123, 124, 125, 900, 779, 396, 89, -1, 625, 1039,
3226  -1, -1, 95, -1, 980, 632, 982, 40, 41, 42,
3227  43, 44, 988, -1, 990, 52, 321, 54, 55, 56,
3228  57, 326, -1, 52, -1, 54, 55, 56, 57, -1,
3229  781, 201, -1, -1, 204, 205, 206, 207, -1, -1,
3230  926, 927, 1018, 2, 52, 4, 54, 55, 56, 57,
3231  -1, -1, 89, -1, 224, -1, 226, 227, 95, 686,
3232  89, -1, 689, -1, 691, -1, -1, -1, -1, -1,
3233  697, -1, -1, 700, 701, -1, -1, 1019, -1, -1,
3234  707, 708, -1, -1, -1, -1, 898, -1, 900, -1,
3235  49, 903, -1, 905, 53, -1, -1, 903, -1, 905,
3236  -1, -1, -1, 989, -1, 732, 411, 412, 735, 736,
3237  -1, -1, -1, -1, -1, 420, -1, 744, -1, -1,
3238  79, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3239  -1, -1, 91, 92, 93, 94, 1022, -1, 1024, 945,
3240  -1, 947, -1, 809, 810, -1, 952, 898, -1, 900,
3241  455, 321, 903, 458, 905, -1, 326, 327, 328, 329,
3242  330, 331, 332, 333, 334, 335, 336, 337, 338, 339,
3243  340, 341, 342, 343, 344, 345, 346, 347, 348, 349,
3244  350, 351, 352, -1, 354, -1, -1, -1, 815, -1,
3245  -1, -1, 1004, -1, 1006, -1, -1, 1009, 1004, 1011,
3246  1006, -1, 829, -1, -1, 1011, -1, 512, -1, -1,
3247  -1, -1, -1, 840, -1, -1, 843, -1, -1, -1,
3248  847, 848, 1028, -1, 851, -1, -1, -1, -1, -1,
3249  -1, -1, 402, 403, -1, -1, -1, 1049, -1, -1,
3250  410, 411, 412, 1049, 203, -1, 416, -1, 418, 419,
3251  420, 878, 879, 1004, -1, 1006, -1, -1, 1009, -1,
3252  1011, -1, -1, -1, -1, 892, -1, -1, -1, 439,
3253  -1, 576, -1, -1, 444, -1, -1, -1, 237, -1,
3254  -1, -1, -1, -1, -1, 455, -1, -1, 458, 248,
3255  -1, 250, -1, 920, -1, 961, 962, -1, 1049, 965,
3256  470, 967, 968, 608, 931, -1, -1, -1, -1, -1,
3257  -1, -1, 271, -1, -1, -1, 621, 622, -1, -1,
3258  -1, -1, -1, 2, -1, 4, 496, 497, -1, -1,
3259  -1, -1, -1, -1, 52, -1, 54, 55, 56, 57,
3260  58, -1, 512, -1, 649, -1, -1, 306, -1, -1,
3261  68, -1, 311, 980, -1, 982, -1, -1, -1, -1,
3262  -1, 988, -1, 990, 323, 324, 1032, 1033, 1034, 1035,
3263  49, 89, -1, -1, 53, -1, -1, 95, 96, 97,
3264  52, -1, 54, 55, 56, 57, 58, -1, 693, 1055,
3265  -1, 1018, -1, -1, -1, -1, 68, 356, -1, -1,
3266  79, -1, 120, -1, -1, 123, 576, -1, -1, 714,
3267  580, -1, 91, 92, 93, 94, -1, 89, -1, -1,
3268  -1, -1, 592, 141, 96, 97, -1, -1, -1, 52,
3269  -1, 54, 55, 56, 57, 58, -1, -1, 608, -1,
3270  -1, -1, -1, -1, -1, 68, -1, -1, 120, -1,
3271  -1, 621, 622, -1, -1, -1, -1, -1, -1, -1,
3272  -1, -1, -1, 768, -1, -1, 89, -1, -1, -1,
3273  -1, -1, 95, 96, 97, -1, -1, -1, -1, 649,
3274  -1, 440, -1, -1, -1, -1, -1, -1, -1, -1,
3275  -1, 450, -1, 2, -1, 4, -1, 120, -1, -1,
3276  123, -1, -1, -1, -1, -1, -1, -1, -1, 468,
3277  -1, -1, 817, 136, 2, -1, 4, -1, -1, -1,
3278  -1, -1, -1, 693, 203, -1, -1, 697, 698, -1,
3279  700, 701, -1, 2, -1, 4, -1, 707, 708, -1,
3280  49, -1, -1, -1, 714, 850, -1, -1, -1, -1,
3281  52, -1, 54, 55, 56, 57, 58, -1, 237, 518,
3282  -1, 49, -1, 868, -1, 53, 68, -1, -1, 248,
3283  -1, 250, -1, -1, -1, -1, -1, -1, -1, -1,
3284  49, 751, -1, -1, -1, 755, 756, 89, 758, 759,
3285  -1, 79, 271, 95, 96, 97, -1, -1, 768, -1,
3286  -1, -1, -1, 91, 92, 93, -1, -1, -1, -1,
3287  -1, 570, -1, 572, -1, -1, -1, -1, 120, -1,
3288  -1, 123, 91, -1, -1, -1, -1, 306, -1, -1,
3289  -1, -1, 311, -1, 136, 594, -1, -1, -1, -1,
3290  -1, -1, -1, -1, 323, 324, -1, 817, -1, -1,
3291  -1, 821, -1, -1, -1, -1, -1, -1, -1, 829,
3292  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3293  -1, -1, -1, 632, -1, -1, -1, 356, 637, -1,
3294  850, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3295  -1, -1, -1, -1, 203, -1, -1, 867, 868, -1,
3296  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3297  76, 77, 78, 79, 80, 203, -1, 83, 84, -1,
3298  -1, -1, -1, -1, -1, -1, -1, 686, 237, -1,
3299  689, -1, 691, -1, 203, -1, -1, 696, -1, 248,
3300  -1, 250, -1, -1, -1, -1, -1, -1, 114, 237,
3301  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3302  248, 440, 250, -1, -1, -1, -1, -1, 237, -1,
3303  -1, 450, -1, -1, -1, 141, -1, 736, -1, 248,
3304  -1, 250, -1, 271, -1, 744, -1, -1, -1, 468,
3305  -1, -1, -1, -1, -1, -1, -1, 306, -1, -1,
3306  -1, 52, 311, 54, 55, 56, 57, 58, -1, -1,
3307  -1, -1, -1, -1, 323, -1, -1, 68, 306, -1,
3308  -1, -1, -1, 311, -1, -1, -1, -1, -1, -1,
3309  -1, -1, -1, -1, -1, 323, 324, 306, 89, 518,
3310  -1, 800, 311, -1, 95, 96, 97, 356, 1018, -1,
3311  -1, -1, -1, -1, 323, -1, 815, 326, -1, -1,
3312  -1, -1, -1, -1, -1, -1, -1, -1, 356, 120,
3313  44, -1, 123, -1, -1, -1, -1, -1, -1, -1,
3314  -1, 840, -1, -1, -1, -1, -1, 356, 847, 848,
3315  -1, 570, 851, 572, 68, 69, 70, 71, 72, 73,
3316  74, 75, 76, 77, 78, 79, 80, -1, -1, 83,
3317  84, -1, -1, -1, -1, 594, -1, -1, -1, 878,
3318  879, -1, 52, -1, 54, 55, 56, 57, 58, -1,
3319  -1, 440, -1, 892, 893, -1, -1, -1, 68, -1,
3320  114, 450, 116, 117, 118, 119, 120, 121, 122, 123,
3321  124, 125, 440, 632, -1, -1, -1, 916, 637, 89,
3322  134, 920, 450, -1, -1, 95, 96, 97, -1, -1,
3323  -1, 440, 931, -1, -1, -1, -1, -1, -1, -1,
3324  468, 450, -1, -1, -1, -1, -1, -1, -1, -1,
3325  120, -1, -1, 123, -1, -1, -1, -1, -1, -1,
3326  -1, -1, -1, -1, -1, -1, -1, 686, -1, -1,
3327  689, -1, 691, -1, -1, -1, -1, 696, -1, -1,
3328  -1, 980, -1, 982, 52, 53, -1, -1, 56, 988,
3329  518, 990, -1, -1, -1, -1, -1, -1, 66, 67,
3330  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
3331  78, -1, -1, 81, 82, 83, 84, 736, -1, -1,
3332  -1, 570, -1, 572, -1, 744, -1, 95, 96, -1,
3333  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3334  -1, -1, 570, -1, 572, 594, -1, -1, 116, 117,
3335  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
3336  128, 570, -1, 572, -1, -1, 594, 135, -1, -1,
3337  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3338  -1, 800, -1, 632, -1, 594, -1, -1, -1, -1,
3339  -1, -1, -1, -1, -1, -1, 815, -1, -1, -1,
3340  -1, -1, -1, -1, 632, -1, -1, -1, -1, 637,
3341  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3342  -1, 840, -1, 632, -1, -1, -1, -1, 847, 848,
3343  -1, -1, 851, -1, -1, -1, -1, 686, -1, -1,
3344  689, -1, 691, -1, -1, -1, -1, -1, 676, -1,
3345  -1, -1, -1, -1, -1, -1, -1, -1, 686, 878,
3346  879, 689, -1, 691, -1, -1, -1, -1, 696, -1,
3347  -1, -1, -1, 892, 893, -1, -1, 686, -1, -1,
3348  689, -1, 691, -1, -1, -1, -1, 736, 697, -1,
3349  -1, -1, -1, -1, -1, 744, -1, 916, -1, -1,
3350  -1, 920, -1, -1, -1, -1, -1, -1, 736, -1,
3351  -1, -1, 931, -1, -1, -1, 744, -1, -1, -1,
3352  -1, -1, -1, -1, -1, -1, -1, 736, 68, 69,
3353  70, 71, 72, 73, 74, 744, -1, 77, 78, -1,
3354  -1, -1, -1, 83, 84, -1, -1, -1, -1, -1,
3355  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3356  -1, 980, -1, 982, -1, -1, 815, -1, -1, 988,
3357  -1, 990, 800, -1, -1, -1, 116, 117, 118, 119,
3358  120, 121, 122, 123, 124, 125, -1, 815, -1, -1,
3359  -1, 840, -1, -1, -1, -1, -1, -1, 847, 848,
3360  -1, -1, 851, -1, -1, -1, 815, -1, -1, -1,
3361  -1, -1, 840, -1, -1, -1, -1, -1, -1, 847,
3362  848, -1, -1, 851, -1, -1, -1, -1, -1, 878,
3363  879, 840, -1, -1, -1, -1, -1, -1, 847, 848,
3364  -1, -1, 851, 892, -1, -1, -1, -1, -1, -1,
3365  878, 879, -1, -1, -1, -1, -1, -1, -1, -1,
3366  -1, -1, -1, -1, 892, 893, -1, -1, -1, 878,
3367  879, 920, -1, -1, -1, -1, -1, -1, -1, -1,
3368  -1, -1, 931, 892, -1, -1, -1, -1, 916, -1,
3369  -1, -1, 920, -1, -1, -1, -1, -1, -1, -1,
3370  -1, -1, -1, 931, -1, -1, -1, 916, -1, -1,
3371  -1, 920, -1, -1, -1, -1, -1, -1, -1, -1,
3372  -1, -1, 931, -1, -1, -1, -1, -1, -1, -1,
3373  -1, 980, -1, 982, -1, -1, -1, -1, -1, 988,
3374  -1, 990, -1, -1, -1, -1, -1, -1, -1, -1,
3375  -1, -1, 980, -1, 982, -1, -1, -1, -1, -1,
3376  988, -1, 990, -1, -1, -1, -1, -1, -1, -1,
3377  -1, 980, -1, 982, -1, -1, -1, -1, -1, 988,
3378  -1, 990, 0, 1, -1, 3, 4, 5, 6, 7,
3379  -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
3380  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3381  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3382  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3383  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3384  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3385  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3386  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3387  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3388  98, 99, 100, 101, 102, 103, 104, 105, 106, 0,
3389  -1, -1, -1, -1, -1, -1, -1, 8, 9, 10,
3390  -1, -1, 13, 14, 15, -1, 17, -1, 126, 127,
3391  128, -1, 44, -1, -1, 26, 27, 28, 29, -1,
3392  -1, 139, -1, 141, -1, -1, 37, 38, -1, 40,
3393  41, 42, 43, 44, -1, -1, 68, 69, 70, 71,
3394  72, 73, 74, 75, 76, 77, 78, 79, 80, -1,
3395  -1, 83, 84, -1, -1, -1, -1, 68, 69, 70,
3396  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3397  -1, -1, 83, 84, 85, -1, 87, 88, -1, -1,
3398  -1, -1, 114, 94, 116, 117, 118, 119, 120, 121,
3399  122, 123, 124, 125, -1, -1, -1, 108, -1, -1,
3400  111, -1, 113, 114, 115, 116, 117, 118, 119, 120,
3401  121, 122, 123, 124, 125, -1, -1, -1, -1, 130,
3402  131, 132, 133, 134, 0, -1, 137, 138, 139, -1,
3403  141, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3404  -1, 17, -1, -1, -1, -1, -1, 44, -1, 25,
3405  -1, 27, 28, 29, -1, -1, -1, -1, -1, -1,
3406  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3407  -1, 68, 69, 70, 71, 72, 73, 74, 75, 76,
3408  77, 78, 79, 80, -1, -1, 83, 84, -1, -1,
3409  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3410  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3411  -1, 87, 88, -1, -1, -1, -1, 114, 94, 116,
3412  117, 118, 119, 120, 121, 122, 123, 124, 125, -1,
3413  -1, -1, 108, -1, -1, 111, -1, 113, 114, 115,
3414  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3415  -1, -1, -1, -1, -1, 131, 132, 133, 134, 0,
3416  -1, 137, 138, 139, -1, 141, -1, 8, 9, 10,
3417  -1, -1, 13, 14, 15, -1, 17, -1, -1, -1,
3418  -1, -1, -1, -1, 25, -1, 27, 28, 29, -1,
3419  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3420  41, 42, 43, 44, -1, -1, 68, 69, 70, 71,
3421  72, 73, 74, 75, 76, 77, 78, 79, 80, -1,
3422  -1, 83, 84, -1, -1, -1, -1, 68, 69, 70,
3423  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3424  -1, -1, 83, 84, 85, -1, 87, 88, -1, -1,
3425  -1, -1, 114, 94, 116, 117, 118, 119, 120, 121,
3426  122, 123, 124, 125, -1, -1, -1, 108, -1, -1,
3427  111, -1, 113, 114, 115, 116, 117, 118, 119, 120,
3428  121, 122, 123, 124, 125, -1, -1, -1, -1, -1,
3429  131, 132, 133, 134, 0, -1, 137, 138, 139, -1,
3430  141, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3431  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3432  26, 27, 28, 29, -1, -1, -1, -1, -1, -1,
3433  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3434  -1, 68, 69, 70, 71, 72, 73, 74, 75, 76,
3435  77, 78, 79, 80, -1, -1, 83, 84, -1, -1,
3436  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3437  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3438  -1, -1, 88, -1, -1, -1, -1, -1, 94, 116,
3439  117, 118, 119, 120, 121, 122, 123, 124, 125, -1,
3440  -1, -1, 108, -1, -1, 111, -1, -1, 114, 115,
3441  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3442  -1, -1, -1, -1, 130, 131, 132, 133, 134, 0,
3443  -1, 137, 138, 139, -1, 141, -1, 8, 9, 10,
3444  -1, -1, 13, 14, 15, -1, 17, -1, -1, -1,
3445  -1, -1, -1, -1, -1, 26, 27, 28, 29, -1,
3446  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3447  41, 42, 43, 44, -1, -1, 68, 69, 70, 71,
3448  72, 73, 74, 75, -1, 77, 78, -1, -1, -1,
3449  -1, 83, 84, -1, -1, -1, -1, 68, 69, 70,
3450  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3451  -1, -1, 83, 84, 85, -1, -1, 88, -1, -1,
3452  -1, -1, -1, 94, 116, 117, 118, 119, 120, 121,
3453  122, 123, 124, 125, -1, -1, -1, 108, -1, -1,
3454  111, -1, -1, 114, 115, 116, 117, 118, 119, 120,
3455  121, 122, 123, 124, 125, -1, -1, -1, -1, 130,
3456  131, 132, 133, 134, 0, -1, 137, 138, 139, -1,
3457  141, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3458  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3459  -1, 27, 28, 29, -1, -1, -1, -1, -1, -1,
3460  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3461  -1, 68, 69, 70, 71, 72, 73, 74, -1, -1,
3462  77, 78, -1, -1, -1, -1, 83, 84, -1, -1,
3463  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3464  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3465  -1, 87, 88, -1, -1, -1, -1, -1, 94, 116,
3466  117, 118, 119, 120, 121, 122, 123, 124, 125, -1,
3467  -1, -1, 108, -1, -1, 111, -1, 113, 114, 115,
3468  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3469  -1, -1, -1, -1, -1, 131, 132, 133, 134, 0,
3470  -1, 137, 138, 139, -1, 141, -1, 8, 9, 10,
3471  -1, -1, 13, 14, 15, -1, 17, -1, -1, -1,
3472  -1, -1, -1, -1, -1, 26, 27, 28, -1, -1,
3473  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3474  41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
3475  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3476  -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
3477  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3478  -1, -1, 83, 84, 85, -1, -1, 88, -1, -1,
3479  -1, -1, -1, 94, -1, -1, -1, -1, -1, -1,
3480  -1, -1, -1, -1, -1, -1, -1, 108, -1, -1,
3481  -1, -1, -1, 114, -1, 116, 117, 118, 119, 120,
3482  121, 122, 123, 124, 125, -1, -1, -1, -1, 130,
3483  131, 132, 133, 134, 0, 136, 137, 138, 139, -1,
3484  141, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3485  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3486  -1, 27, 28, 29, -1, -1, -1, -1, -1, -1,
3487  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3488  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3489  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3490  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3491  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3492  -1, -1, 88, -1, -1, -1, -1, -1, 94, -1,
3493  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3494  -1, -1, 108, -1, -1, 111, -1, -1, 114, 115,
3495  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3496  -1, -1, -1, -1, -1, 131, 132, 133, 134, 0,
3497  -1, 137, 138, 139, -1, 141, -1, 8, 9, 10,
3498  -1, -1, 13, 14, 15, -1, 17, -1, -1, -1,
3499  -1, -1, -1, -1, -1, 26, 27, 28, -1, -1,
3500  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3501  41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
3502  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3503  -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
3504  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3505  -1, -1, 83, 84, 85, -1, -1, 88, -1, -1,
3506  -1, -1, -1, 94, -1, -1, -1, -1, -1, -1,
3507  -1, -1, -1, -1, -1, -1, -1, 108, -1, -1,
3508  -1, -1, -1, 114, -1, 116, 117, 118, 119, 120,
3509  121, 122, 123, 124, 125, -1, -1, -1, -1, 130,
3510  131, 132, 133, 134, 0, 136, 137, 138, 139, -1,
3511  141, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3512  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3513  -1, 27, 28, -1, -1, -1, -1, -1, -1, -1,
3514  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3515  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3516  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3517  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3518  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3519  -1, -1, 88, -1, -1, -1, -1, -1, 94, -1,
3520  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3521  -1, -1, 108, -1, -1, -1, -1, -1, 114, -1,
3522  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3523  -1, -1, -1, -1, -1, 131, 132, 133, 134, 0,
3524  136, 137, 138, 139, -1, 141, -1, 8, 9, 10,
3525  -1, -1, -1, 14, 15, -1, 17, -1, -1, -1,
3526  -1, -1, -1, -1, -1, 26, -1, -1, -1, -1,
3527  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3528  41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
3529  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3530  -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
3531  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3532  -1, -1, 83, 84, 85, -1, 87, -1, -1, -1,
3533  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3534  -1, -1, -1, -1, -1, -1, -1, 108, -1, -1,
3535  -1, -1, 113, 114, -1, 116, 117, 118, 119, 120,
3536  121, 122, 123, 124, 125, -1, -1, -1, -1, 130,
3537  131, 132, 133, 134, 0, -1, 137, -1, 139, -1,
3538  141, -1, 8, 9, 10, -1, -1, -1, 14, 15,
3539  -1, 17, -1, 0, -1, -1, -1, -1, -1, -1,
3540  -1, 8, 9, 10, -1, -1, 13, 14, 15, -1,
3541  17, 37, 38, -1, 40, 41, 42, 43, 44, 26,
3542  27, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3543  37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
3544  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3545  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3546  -1, 87, -1, -1, -1, -1, -1, -1, -1, -1,
3547  -1, -1, -1, -1, -1, -1, -1, -1, 85, -1,
3548  -1, -1, 108, -1, -1, -1, -1, 113, 114, -1,
3549  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3550  -1, 108, -1, -1, -1, 131, 132, 133, 134, -1,
3551  -1, 137, -1, 139, -1, 141, -1, -1, -1, -1,
3552  -1, -1, -1, 130, 131, -1, 133, -1, -1, 136,
3553  137, -1, 139, 1, 141, 3, 4, 5, 6, 7,
3554  8, 9, 10, 11, 12, -1, -1, 15, 16, -1,
3555  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3556  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3557  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3558  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3559  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3560  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3561  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3562  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3563  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3564  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3565  -1, -1, -1, -1, -1, -1, -1, -1, 126, 127,
3566  128, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3567  -1, 139, 1, 141, 3, 4, 5, 6, 7, -1,
3568  -1, 10, 11, 12, -1, 14, 15, 16, -1, 18,
3569  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3570  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3571  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3572  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3573  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3574  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3575  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3576  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3577  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3578  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3579  -1, -1, -1, -1, -1, -1, -1, 126, 127, 128,
3580  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3581  139, 1, 141, 3, 4, 5, 6, 7, -1, -1,
3582  10, 11, 12, -1, -1, 15, 16, 17, 18, 19,
3583  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3584  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3585  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
3586  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3587  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3588  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3589  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3590  90, -1, 92, 93, -1, 95, -1, -1, 98, 99,
3591  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
3592  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3593  -1, -1, -1, -1, -1, -1, 126, 127, 128, -1,
3594  -1, -1, -1, -1, -1, -1, -1, -1, -1, 139,
3595  1, 141, 3, 4, 5, 6, 7, -1, -1, 10,
3596  11, 12, -1, -1, 15, 16, -1, 18, 19, 20,
3597  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3598  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3599  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3600  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3601  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3602  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3603  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3604  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
3605  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3606  -1, -1, -1, 1, -1, 3, 4, 5, 6, 7,
3607  -1, 9, 10, 11, 12, 126, 127, 128, 16, -1,
3608  18, 19, 20, 21, 22, 23, 24, -1, 139, -1,
3609  141, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3610  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3611  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3612  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3613  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3614  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3615  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3616  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3617  -1, -1, -1, -1, -1, -1, 1, -1, 3, 4,
3618  5, 6, 7, -1, -1, -1, 11, 12, 126, 127,
3619  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3620  -1, 139, -1, 141, -1, 30, 31, 32, 33, 34,
3621  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3622  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3623  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3624  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3625  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3626  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3627  95, -1, -1, 98, 99, 100, 101, 102, 103, 104,
3628  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3629  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3630  -1, 126, 127, 128, -1, -1, -1, -1, -1, -1,
3631  -1, -1, 137, -1, 139, 1, 141, 3, 4, 5,
3632  6, 7, -1, -1, -1, 11, 12, -1, -1, -1,
3633  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3634  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3635  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3636  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
3637  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3638  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3639  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3640  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3641  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
3642  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3643  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3644  126, 127, 128, -1, -1, -1, -1, -1, -1, -1,
3645  -1, 137, -1, 139, 1, 141, 3, 4, 5, 6,
3646  7, -1, -1, -1, 11, 12, -1, -1, -1, 16,
3647  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3648  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3649  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
3650  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
3651  57, -1, 59, 60, -1, 62, 63, 64, -1, 66,
3652  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3653  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3654  -1, -1, 89, 90, -1, 92, 93, -1, 95, -1,
3655  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3656  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3657  -1, -1, -1, -1, -1, -1, -1, -1, -1, 126,
3658  127, 128, -1, -1, 131, 1, -1, 3, 4, 5,
3659  6, 7, 139, -1, 141, 11, 12, -1, -1, -1,
3660  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3661  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3662  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3663  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
3664  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3665  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3666  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3667  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3668  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
3669  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3670  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3671  126, 127, 128, -1, -1, 131, -1, -1, -1, -1,
3672  -1, -1, -1, 139, 1, 141, 3, 4, 5, 6,
3673  7, -1, -1, 10, 11, 12, -1, -1, -1, 16,
3674  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3675  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3676  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
3677  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
3678  57, -1, 59, 60, -1, 62, 63, 64, -1, 66,
3679  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3680  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3681  -1, -1, 89, 90, -1, 92, 93, -1, 95, -1,
3682  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3683  -1, -1, -1, -1, -1, -1, -1, 1, -1, 3,
3684  4, 5, 6, 7, -1, -1, -1, 11, 12, 126,
3685  127, 128, 16, -1, 18, 19, 20, 21, 22, 23,
3686  24, -1, 139, -1, 141, -1, 30, 31, 32, 33,
3687  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3688  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3689  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3690  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
3691  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3692  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3693  -1, 95, -1, -1, 98, 99, 100, 101, 102, 103,
3694  104, 105, 106, -1, 108, -1, -1, -1, -1, -1,
3695  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3696  11, 12, 126, 127, 128, 16, -1, 18, 19, 20,
3697  21, 22, 23, 24, -1, 139, -1, 141, -1, 30,
3698  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3699  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3700  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3701  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3702  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3703  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3704  -1, 92, 93, -1, 95, 96, 97, 98, 99, 100,
3705  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3706  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
3707  -1, -1, -1, 11, 12, 126, 127, 128, 16, -1,
3708  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3709  141, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3710  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3711  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3712  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3713  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3714  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3715  -1, 89, 90, -1, 92, 93, -1, -1, -1, -1,
3716  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3717  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
3718  5, -1, 7, -1, -1, -1, 11, 12, 126, 127,
3719  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3720  -1, 139, -1, 141, -1, 30, 31, 32, 33, 34,
3721  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3722  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3723  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3724  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3725  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3726  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3727  -1, -1, -1, 98, 99, 100, 101, 102, 103, 104,
3728  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3729  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
3730  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
3731  22, 23, 24, -1, -1, -1, 141, -1, 30, 31,
3732  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3733  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3734  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3735  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3736  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3737  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3738  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3739  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3740  -1, -1, -1, -1, 3, 4, 5, 6, 7, -1,
3741  -1, -1, 11, 12, 126, 127, 128, 16, -1, 18,
3742  19, 20, 21, 22, 23, 24, -1, 139, -1, -1,
3743  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3744  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3745  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3746  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3747  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3748  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3749  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3750  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3751  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3752  -1, -1, -1, -1, -1, -1, -1, 126, 127, 128,
3753  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3754  139, 3, 4, 5, 6, 7, 8, 9, 10, 11,
3755  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
3756  22, 23, 24, 25, 26, -1, -1, -1, 30, 31,
3757  32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
3758  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3759  52, 53, 54, 55, 56, 57, -1, -1, -1, -1,
3760  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
3761  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
3762  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
3763  -1, -1, -1, 95, 96, -1, -1, -1, -1, -1,
3764  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3765  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
3766  122, 123, 124, 125, -1, 127, 128, -1, -1, -1,
3767  -1, -1, -1, 135, 136, 3, 4, 5, 6, 7,
3768  8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
3769  18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
3770  -1, -1, 30, 31, 32, 33, 34, 35, 36, 37,
3771  38, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3772  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3773  -1, -1, -1, -1, -1, -1, -1, -1, 66, 67,
3774  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
3775  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
3776  -1, -1, -1, -1, -1, -1, -1, 95, 96, -1,
3777  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3778  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
3779  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
3780  128, -1, -1, -1, -1, -1, -1, 135, 3, 4,
3781  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3782  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3783  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3784  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
3785  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3786  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
3787  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3788  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3789  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3790  95, 96, -1, -1, 99, -1, -1, -1, -1, -1,
3791  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3792  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3793  125, -1, 127, 128, -1, -1, -1, -1, -1, -1,
3794  135, 3, 4, 5, 6, 7, 8, 9, 10, 11,
3795  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
3796  22, 23, 24, 25, 26, -1, -1, -1, 30, 31,
3797  32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
3798  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3799  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
3800  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
3801  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
3802  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
3803  -1, -1, -1, 95, 96, -1, -1, 99, -1, -1,
3804  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3805  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
3806  122, 123, 124, 125, -1, 127, 128, -1, -1, -1,
3807  -1, -1, -1, 135, 3, 4, 5, 6, 7, 8,
3808  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
3809  19, 20, 21, 22, 23, 24, 25, 26, -1, -1,
3810  -1, 30, 31, 32, 33, 34, 35, 36, 37, 38,
3811  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3812  49, 50, 51, 52, 53, -1, -1, 56, -1, -1,
3813  -1, -1, -1, -1, -1, -1, -1, 66, 67, 68,
3814  69, 70, 71, 72, 73, 74, -1, -1, 77, 78,
3815  -1, -1, 81, 82, 83, 84, -1, -1, -1, -1,
3816  -1, -1, -1, -1, -1, -1, 95, 96, -1, -1,
3817  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3818  -1, -1, -1, -1, -1, -1, -1, 116, 117, 118,
3819  119, 120, 121, 122, 123, 124, 125, -1, 127, 128,
3820  3, 4, 5, -1, 7, -1, 135, -1, 11, 12,
3821  -1, -1, -1, 16, -1, 18, 19, 20, 21, 22,
3822  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3823  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3824  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3825  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
3826  63, 64, -1, -1, -1, -1, -1, -1, -1, -1,
3827  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3828  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3829  93, -1, -1, -1, -1, 98, 99, 100, 101, 102,
3830  103, 104, 105, 106, -1, -1, -1, -1, -1, 3,
3831  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
3832  -1, -1, 16, 126, 18, 19, 20, 21, 22, 23,
3833  24, 134, -1, -1, -1, -1, 30, 31, 32, 33,
3834  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3835  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3836  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3837  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3838  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3839  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3840  -1, -1, -1, -1, 98, 99, 100, 101, 102, 103,
3841  104, 105, 106, -1, -1, -1, -1, -1, 3, 4,
3842  5, 6, 7, -1, -1, -1, 11, 12, -1, -1,
3843  -1, 16, 126, 18, 19, 20, 21, 22, 23, 24,
3844  134, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3845  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3846  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3847  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3848  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3849  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3850  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3851  95, -1, -1, 98, 99, 100, 101, 102, 103, 104,
3852  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3853  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3854  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
3855  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3856  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3857  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3858  52, 53, 54, 55, 56, 57, 58, 59, 60, -1,
3859  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3860  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3861  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3862  92, 93, -1, 95, 96, 97, 98, 99, 100, 101,
3863  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3864  -1, -1, -1, -1, 3, 4, 5, 6, 7, -1,
3865  -1, -1, 11, 12, 126, 127, 128, 16, -1, 18,
3866  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3867  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3868  39, -1, -1, -1, -1, -1, 45, 46, -1, 48,
3869  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3870  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3871  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3872  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3873  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3874  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3875  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3876  -1, 7, -1, -1, -1, 11, 12, 126, 127, 128,
3877  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3878  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3879  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3880  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3881  56, 57, 58, 59, 60, -1, 62, 63, 64, -1,
3882  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3883  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3884  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3885  96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
3886  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3887  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
3888  126, 127, 128, 16, -1, 18, 19, 20, 21, 22,
3889  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3890  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3891  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3892  53, 54, 55, 56, 57, 58, 59, 60, -1, 62,
3893  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3894  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3895  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3896  93, -1, 95, 96, -1, 98, 99, 100, 101, 102,
3897  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
3898  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3899  -1, 11, 12, 126, 127, 128, 16, -1, 18, 19,
3900  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3901  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3902  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3903  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
3904  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3905  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3906  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3907  90, -1, 92, 93, -1, -1, 96, 97, 98, 99,
3908  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
3909  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3910  7, -1, -1, -1, 11, 12, 126, 127, 128, 16,
3911  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3912  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3913  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3914  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3915  57, 58, 59, 60, -1, 62, 63, 64, -1, 66,
3916  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3917  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3918  -1, -1, 89, 90, -1, 92, 93, -1, 95, 96,
3919  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3920  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3921  4, 5, -1, 7, -1, -1, -1, 11, 12, 126,
3922  127, 128, 16, -1, 18, 19, 20, 21, 22, 23,
3923  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3924  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3925  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3926  54, 55, 56, 57, 58, 59, 60, -1, 62, 63,
3927  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
3928  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3929  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3930  -1, -1, 96, -1, 98, 99, 100, 101, 102, 103,
3931  104, 105, 106, -1, -1, -1, -1, -1, -1, -1,
3932  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3933  11, 12, 126, 127, 128, 16, -1, 18, 19, 20,
3934  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3935  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3936  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3937  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3938  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3939  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3940  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3941  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
3942  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3943  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
3944  -1, -1, -1, 11, 12, 126, 127, 128, 16, -1,
3945  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3946  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3947  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3948  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3949  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3950  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3951  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3952  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3953  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3954  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
3955  5, -1, 7, -1, -1, -1, 11, 12, 126, 127,
3956  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3957  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3958  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3959  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3960  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3961  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3962  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3963  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3964  95, -1, -1, 98, 99, 100, 101, 102, 103, 104,
3965  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3966  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3967  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
3968  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3969  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3970  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3971  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3972  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3973  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3974  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3975  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3976  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3977  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3978  -1, -1, 11, 12, 126, 127, 128, 16, -1, 18,
3979  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3980  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3981  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3982  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3983  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3984  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3985  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3986  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3987  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3988  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3989  -1, 7, -1, -1, -1, 11, 12, 126, 127, 128,
3990  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3991  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3992  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3993  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3994  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3995  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3996  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3997  86, -1, -1, 89, 90, -1, 92, 93, -1, -1,
3998  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
3999  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4000  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4001  126, 127, 128, 16, -1, 18, 19, 20, 21, 22,
4002  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4003  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4004  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4005  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
4006  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
4007  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4008  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
4009  93, -1, -1, -1, -1, 98, 99, 100, 101, 102,
4010  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
4011  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4012  -1, 11, 12, 126, 127, 128, 16, -1, 18, 19,
4013  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4014  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4015  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4016  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4017  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
4018  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4019  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
4020  90, -1, 92, 93, -1, -1, -1, -1, 98, 99,
4021  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
4022  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
4023  7, -1, -1, -1, 11, 12, 126, 127, 128, 16,
4024  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
4025  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4026  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
4027  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
4028  57, -1, 59, 60, -1, 62, 63, 64, -1, -1,
4029  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4030  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
4031  -1, -1, 89, 90, -1, 92, 93, -1, 95, -1,
4032  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
4033  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4034  -1, -1, -1, 11, 12, -1, -1, -1, 16, 126,
4035  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4036  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4037  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4038  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4039  -1, 59, 60, -1, 62, 63, 64, -1, -1, -1,
4040  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4041  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
4042  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
4043  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
4044  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4045  -1, -1, 11, 12, -1, -1, -1, 16, 126, 18,
4046  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4047  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4048  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4049  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4050  59, 60, -1, 62, 63, 64, -1, -1, -1, -1,
4051  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4052  -1, -1, -1, -1, 83, -1, -1, 86, -1, -1,
4053  89, 90, -1, 92, 93, -1, -1, -1, -1, 98,
4054  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
4055  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4056  -1, 11, 12, -1, -1, -1, 16, 126, 18, 19,
4057  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4058  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4059  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4060  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4061  60, -1, 62, 63, 64, -1, -1, -1, -1, -1,
4062  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4063  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
4064  90, -1, 92, 93, -1, -1, -1, -1, 98, 99,
4065  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
4066  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4067  11, 12, -1, -1, -1, 16, 126, 18, 19, 20,
4068  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4069  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4070  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4071  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4072  -1, 62, 63, 64, -1, -1, -1, -1, -1, -1,
4073  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4074  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
4075  -1, 92, 93, -1, -1, -1, -1, 98, 99, 100,
4076  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
4077  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4078  12, -1, -1, -1, 16, 126, 18, 19, 20, 21,
4079  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4080  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4081  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4082  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
4083  62, 63, 64, -1, -1, -1, -1, -1, -1, -1,
4084  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4085  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
4086  92, 93, -1, -1, -1, -1, 98, 99, 100, 101,
4087  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
4088  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4089  -1, -1, -1, 16, 126, 18, 19, 20, 21, 22,
4090  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4091  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4092  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4093  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
4094  63, 64, -1, -1, -1, -1, -1, -1, -1, -1,
4095  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4096  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
4097  93, -1, -1, -1, -1, 98, 99, 100, 101, 102,
4098  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
4099  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
4100  -1, -1, -1, 126, 66, 67, 68, 69, 70, 71,
4101  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
4102  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
4103  -1, -1, -1, 95, 96, -1, -1, -1, -1, -1,
4104  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4105  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
4106  122, 123, 124, 125, -1, 127, 128, 52, 53, -1,
4107  -1, 56, -1, 135, -1, -1, -1, -1, -1, -1,
4108  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
4109  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
4110  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4111  95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
4112  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4113  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
4114  125, -1, 127, 128, 52, 53, -1, -1, 56, -1,
4115  135, -1, -1, -1, -1, -1, -1, -1, 66, 67,
4116  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
4117  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
4118  -1, -1, -1, -1, -1, -1, -1, 95, 96, -1,
4119  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4120  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
4121  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
4122  128, 52, 53, -1, -1, 56, -1, 135, -1, -1,
4123  -1, -1, -1, -1, -1, 66, 67, 68, 69, 70,
4124  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
4125  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
4126  -1, -1, -1, -1, 95, 96, -1, -1, -1, -1,
4127  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4128  -1, -1, -1, -1, -1, 116, 117, 118, 119, 120,
4129  121, 122, 123, 124, 125, -1, 127, 128, 52, 53,
4130  -1, -1, 56, -1, 135, -1, -1, -1, -1, -1,
4131  -1, -1, 66, 67, 68, 69, 70, 71, 72, 73,
4132  74, -1, -1, 77, 78, -1, -1, 81, 82, 83,
4133  84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4134  -1, 95, 96, -1, -1, -1, -1, -1, -1, -1,
4135  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4136  -1, -1, 116, 117, 118, 119, 120, 121, 122, 123,
4137  124, 125, -1, 127, 128, 52, 53, -1, -1, 56,
4138  -1, 135, -1, -1, -1, -1, -1, -1, -1, 66,
4139  67, 68, 69, 70, 71, 72, 73, 74, -1, -1,
4140  77, 78, -1, -1, 81, 82, 83, 84, -1, -1,
4141  -1, -1, -1, -1, -1, -1, -1, -1, 95, 96,
4142  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4143  -1, -1, -1, -1, -1, -1, -1, -1, -1, 116,
4144  117, 118, 119, 120, 121, 122, 123, 124, 125, -1,
4145  127, 128, 52, 53, -1, -1, 56, -1, 135, -1,
4146  -1, -1, -1, -1, -1, -1, 66, 67, 68, 69,
4147  70, 71, 72, 73, 74, -1, -1, 77, 78, -1,
4148  -1, 81, 82, 83, 84, -1, -1, -1, -1, -1,
4149  -1, -1, -1, -1, -1, 95, 96, -1, -1, -1,
4150  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4151  -1, -1, -1, -1, -1, -1, 116, 117, 118, 119,
4152  120, 121, 122, 123, 124, 125, -1, 127, 128, 52,
4153  53, -1, -1, 56, -1, 135, -1, -1, -1, -1,
4154  -1, -1, -1, 66, 67, 68, 69, 70, 71, 72,
4155  73, 74, -1, -1, 77, 78, -1, -1, 81, 82,
4156  83, 84, -1, -1, -1, -1, -1, -1, -1, -1,
4157  -1, -1, 95, 96, -1, -1, -1, -1, -1, -1,
4158  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4159  -1, -1, -1, 116, 117, 118, 119, 120, 121, 122,
4160  123, 124, 125, -1, 127, 128, 52, 53, -1, -1,
4161  56, -1, 135, -1, -1, -1, -1, -1, -1, -1,
4162  66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
4163  -1, 77, 78, -1, -1, 81, 82, 83, 84, -1,
4164  -1, -1, -1, -1, -1, -1, -1, -1, -1, 95,
4165  96, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4166  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4167  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
4168  -1, 127, 128, 52, 53, -1, -1, 56, -1, 135,
4169  -1, -1, -1, -1, -1, -1, -1, 66, 67, 68,
4170  69, 70, 71, 72, 73, 74, -1, -1, 77, 78,
4171  -1, -1, 81, 82, 83, 84, -1, -1, -1, -1,
4172  -1, -1, -1, -1, -1, -1, 95, 96, -1, -1,
4173  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4174  -1, -1, -1, -1, -1, -1, -1, 116, 117, 118,
4175  119, 120, 121, 122, 123, 124, 125, -1, 127, 128,
4176  52, 53, -1, -1, 56, -1, 135, -1, -1, -1,
4177  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
4178  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
4179  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
4180  -1, -1, -1, 95, 96, -1, -1, -1, -1, -1,
4181  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4182  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
4183  122, 123, 124, 125, -1, 127, 128, 52, 53, -1,
4184  -1, 56, -1, 135, -1, -1, -1, -1, -1, -1,
4185  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
4186  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
4187  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4188  95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
4189  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4190  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
4191  125, -1, 127, 128, -1, -1, -1, -1, -1, -1,
4192  135
4193 };
4194 
4195 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4196  symbol of state STATE-NUM. */
4197 static const yytype_uint16 yystos[] =
4198 {
4199  0, 143, 144, 0, 1, 3, 4, 5, 6, 7,
4200  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4201  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4202  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4203  57, 59, 60, 62, 63, 64, 66, 67, 86, 89,
4204  90, 92, 93, 95, 98, 99, 100, 101, 102, 103,
4205  104, 105, 106, 126, 127, 128, 145, 146, 147, 154,
4206  156, 157, 159, 160, 163, 164, 165, 167, 168, 169,
4207  171, 172, 182, 196, 215, 216, 217, 218, 219, 220,
4208  221, 222, 223, 224, 225, 251, 252, 266, 267, 268,
4209  269, 270, 271, 272, 275, 277, 278, 290, 292, 293,
4210  294, 295, 296, 297, 298, 329, 340, 147, 3, 4,
4211  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
4212  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
4213  25, 26, 30, 31, 32, 33, 34, 35, 36, 37,
4214  38, 39, 45, 46, 47, 48, 49, 50, 51, 52,
4215  53, 56, 66, 67, 68, 69, 70, 71, 72, 73,
4216  74, 77, 78, 81, 82, 83, 84, 95, 96, 116,
4217  117, 118, 119, 120, 121, 122, 123, 124, 125, 127,
4218  128, 135, 175, 176, 177, 178, 180, 181, 290, 292,
4219  39, 58, 86, 89, 95, 96, 97, 127, 164, 172,
4220  182, 184, 189, 192, 194, 215, 294, 295, 297, 298,
4221  327, 328, 189, 189, 136, 190, 191, 136, 186, 190,
4222  136, 141, 334, 54, 177, 334, 148, 130, 21, 22,
4223  30, 31, 32, 163, 182, 215, 182, 56, 1, 47,
4224  89, 150, 151, 152, 154, 166, 167, 340, 198, 199,
4225  185, 194, 327, 340, 184, 326, 327, 340, 46, 86,
4226  126, 134, 171, 196, 215, 294, 295, 298, 243, 244,
4227  54, 55, 57, 175, 282, 291, 281, 282, 283, 140,
4228  273, 140, 279, 140, 276, 140, 280, 59, 60, 159,
4229  182, 182, 139, 141, 333, 338, 339, 40, 41, 42,
4230  43, 44, 37, 38, 26, 130, 186, 190, 257, 28,
4231  249, 113, 134, 89, 95, 168, 113, 68, 69, 70,
4232  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
4233  83, 84, 114, 116, 117, 118, 119, 120, 121, 122,
4234  123, 124, 125, 85, 132, 133, 197, 157, 158, 158,
4235  202, 204, 158, 333, 339, 86, 165, 172, 215, 231,
4236  294, 295, 298, 52, 56, 83, 86, 173, 174, 215,
4237  294, 295, 298, 174, 33, 34, 35, 36, 49, 50,
4238  51, 52, 56, 136, 175, 296, 324, 85, 133, 332,
4239  257, 269, 87, 87, 134, 184, 56, 184, 184, 184,
4240  113, 88, 134, 193, 340, 85, 132, 133, 87, 87,
4241  134, 193, 189, 334, 335, 189, 188, 189, 194, 327,
4242  340, 157, 335, 157, 54, 63, 64, 155, 136, 183,
4243  130, 150, 85, 133, 87, 154, 153, 166, 137, 333,
4244  339, 335, 335, 157, 138, 134, 141, 337, 134, 337,
4245  131, 337, 334, 56, 59, 60, 168, 170, 134, 85,
4246  132, 133, 245, 61, 107, 109, 110, 284, 110, 284,
4247  110, 65, 284, 110, 110, 274, 284, 110, 61, 110,
4248  110, 110, 274, 110, 61, 110, 68, 68, 139, 147,
4249  158, 158, 158, 158, 154, 157, 157, 259, 258, 94,
4250  161, 250, 95, 159, 184, 194, 195, 166, 134, 171,
4251  134, 156, 159, 172, 182, 184, 195, 182, 182, 182,
4252  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
4253  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
4254  182, 182, 182, 52, 53, 56, 180, 256, 330, 331,
4255  188, 52, 53, 56, 180, 255, 330, 149, 150, 13,
4256  227, 338, 227, 158, 158, 333, 17, 260, 56, 85,
4257  132, 133, 25, 157, 52, 56, 173, 1, 117, 299,
4258  338, 85, 132, 133, 211, 325, 212, 332, 52, 56,
4259  330, 159, 182, 159, 182, 179, 182, 184, 95, 184,
4260  192, 327, 52, 56, 188, 52, 56, 328, 335, 137,
4261  335, 134, 134, 335, 177, 201, 182, 145, 131, 330,
4262  330, 182, 130, 335, 152, 200, 327, 134, 170, 52,
4263  56, 188, 52, 56, 52, 54, 55, 56, 57, 58,
4264  68, 89, 95, 96, 97, 120, 123, 136, 247, 302,
4265  304, 305, 306, 307, 308, 309, 312, 313, 314, 315,
4266  318, 319, 320, 321, 322, 286, 285, 140, 284, 140,
4267  140, 140, 182, 182, 76, 118, 238, 239, 340, 238,
4268  162, 238, 184, 134, 335, 170, 134, 113, 44, 334,
4269  87, 87, 186, 190, 254, 334, 336, 87, 87, 186,
4270  190, 253, 10, 226, 8, 262, 340, 150, 13, 150,
4271  27, 228, 338, 228, 260, 194, 226, 52, 56, 188,
4272  52, 56, 206, 209, 338, 300, 208, 52, 56, 173,
4273  188, 149, 157, 136, 301, 304, 213, 186, 187, 190,
4274  340, 44, 177, 184, 193, 87, 87, 336, 87, 87,
4275  327, 157, 131, 145, 335, 337, 168, 336, 113, 184,
4276  52, 89, 95, 232, 233, 234, 306, 304, 246, 134,
4277  303, 134, 323, 340, 52, 134, 323, 134, 303, 52,
4278  134, 303, 52, 287, 54, 55, 57, 289, 298, 52,
4279  58, 235, 237, 240, 308, 310, 311, 314, 316, 317,
4280  320, 322, 334, 150, 150, 238, 150, 95, 184, 170,
4281  182, 115, 159, 182, 159, 182, 161, 186, 138, 87,
4282  159, 182, 159, 182, 161, 187, 184, 195, 263, 340,
4283  15, 230, 340, 14, 229, 230, 230, 203, 205, 226,
4284  134, 227, 336, 158, 338, 158, 149, 336, 226, 335,
4285  304, 149, 338, 175, 257, 249, 182, 87, 134, 335,
4286  131, 184, 234, 134, 306, 134, 335, 240, 29, 111,
4287  248, 302, 307, 318, 320, 309, 314, 322, 308, 315,
4288  320, 308, 288, 113, 86, 215, 240, 118, 134, 236,
4289  134, 323, 323, 134, 236, 134, 236, 139, 10, 131,
4290  150, 10, 184, 182, 159, 182, 88, 264, 340, 150,
4291  9, 265, 340, 158, 226, 226, 150, 150, 184, 150,
4292  228, 210, 338, 226, 335, 226, 214, 335, 233, 134,
4293  95, 232, 137, 150, 150, 134, 303, 134, 303, 323,
4294  134, 303, 134, 303, 303, 150, 215, 56, 85, 118,
4295  235, 317, 320, 310, 314, 308, 316, 320, 308, 52,
4296  241, 242, 305, 131, 86, 172, 215, 294, 295, 298,
4297  227, 150, 227, 226, 226, 230, 260, 261, 207, 149,
4298  301, 134, 233, 134, 306, 10, 131, 308, 320, 308,
4299  308, 108, 52, 56, 134, 236, 134, 236, 323, 134,
4300  236, 134, 236, 236, 134, 334, 56, 85, 132, 133,
4301  150, 150, 150, 226, 149, 233, 134, 303, 134, 303,
4302  303, 303, 308, 320, 308, 308, 242, 52, 56, 188,
4303  52, 56, 262, 229, 226, 226, 233, 308, 236, 134,
4304  236, 236, 236, 336, 303, 308, 236
4305 };
4306 
4307 #define yyerrok (yyerrstatus = 0)
4308 #define yyclearin (yychar = YYEMPTY)
4309 #define YYEMPTY (-2)
4310 #define YYEOF 0
4311 
4312 #define YYACCEPT goto yyacceptlab
4313 #define YYABORT goto yyabortlab
4314 #define YYERROR goto yyerrorlab
4315 
4316 
4317 /* Like YYERROR except do call yyerror. This remains here temporarily
4318  to ease the transition to the new meaning of YYERROR, for GCC.
4319  Once GCC version 2 has supplanted version 1, this can go. However,
4320  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
4321  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
4322  discussed. */
4323 
4324 #define YYFAIL goto yyerrlab
4325 #if defined YYFAIL
4326  /* This is here to suppress warnings from the GCC cpp's
4327  -Wunused-macros. Normally we don't worry about that warning, but
4328  some users do, and we want to make it easy for users to remove
4329  YYFAIL uses, which will produce warnings from Bison 2.5. */
4330 #endif
4331 
4332 #define YYRECOVERING() (!!yyerrstatus)
4333 
4334 #define YYBACKUP(Token, Value) \
4335 do \
4336  if (yychar == YYEMPTY && yylen == 1) \
4337  { \
4338  yychar = (Token); \
4339  yylval = (Value); \
4340  YYPOPSTACK (1); \
4341  goto yybackup; \
4342  } \
4343  else \
4344  { \
4345  parser_yyerror (parser, YY_("syntax error: cannot back up")); \
4346  YYERROR; \
4347  } \
4348 while (YYID (0))
4349 
4350 
4351 #define YYTERROR 1
4352 #define YYERRCODE 256
4353 
4354 
4355 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
4356  If N is 0, then set CURRENT to the empty location which ends
4357  the previous symbol: RHS[0] (always defined). */
4358 
4359 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
4360 #ifndef YYLLOC_DEFAULT
4361 # define YYLLOC_DEFAULT(Current, Rhs, N) \
4362  do \
4363  if (YYID (N)) \
4364  { \
4365  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
4366  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
4367  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
4368  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
4369  } \
4370  else \
4371  { \
4372  (Current).first_line = (Current).last_line = \
4373  YYRHSLOC (Rhs, 0).last_line; \
4374  (Current).first_column = (Current).last_column = \
4375  YYRHSLOC (Rhs, 0).last_column; \
4376  } \
4377  while (YYID (0))
4378 #endif
4379 
4380 
4381 /* This macro is provided for backward compatibility. */
4382 
4383 #ifndef YY_LOCATION_PRINT
4384 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
4385 #endif
4386 
4387 
4388 /* YYLEX -- calling `yylex' with the right arguments. */
4389 
4390 #ifdef YYLEX_PARAM
4391 # define YYLEX yylex (&yylval, YYLEX_PARAM)
4392 #else
4393 # define YYLEX yylex (&yylval, parser)
4394 #endif
4395 
4396 /* Enable debugging if requested. */
4397 #if YYDEBUG
4398 
4399 # ifndef YYFPRINTF
4400 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
4401 # define YYFPRINTF fprintf
4402 # endif
4403 
4404 # define YYDPRINTF(Args) \
4405 do { \
4406  if (yydebug) \
4407  YYFPRINTF Args; \
4408 } while (YYID (0))
4409 
4410 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
4411 do { \
4412  if (yydebug) \
4413  { \
4414  YYFPRINTF (stderr, "%s ", Title); \
4415  yy_symbol_print (stderr, \
4416  Type, Value, parser); \
4417  YYFPRINTF (stderr, "\n"); \
4418  } \
4419 } while (YYID (0))
4420 
4421 
4422 /*--------------------------------.
4423 | Print this symbol on YYOUTPUT. |
4424 `--------------------------------*/
4425 
4426 /*ARGSUSED*/
4427 #if (defined __STDC__ || defined __C99__FUNC__ \
4428  || defined __cplusplus || defined _MSC_VER)
4429 static void
4430 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4431 #else
4432 static void
4433 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
4434  FILE *yyoutput;
4435  int yytype;
4436  YYSTYPE const * const yyvaluep;
4437  struct parser_params *parser;
4438 #endif
4439 {
4440  if (!yyvaluep)
4441  return;
4442  YYUSE (parser);
4443 # ifdef YYPRINT
4444  if (yytype < YYNTOKENS)
4445  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4446 # else
4447  YYUSE (yyoutput);
4448 # endif
4449  switch (yytype)
4450  {
4451  default:
4452  break;
4453  }
4454 }
4455 
4456 
4457 /*--------------------------------.
4458 | Print this symbol on YYOUTPUT. |
4459 `--------------------------------*/
4460 
4461 #if (defined __STDC__ || defined __C99__FUNC__ \
4462  || defined __cplusplus || defined _MSC_VER)
4463 static void
4464 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4465 #else
4466 static void
4467 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
4468  FILE *yyoutput;
4469  int yytype;
4470  YYSTYPE const * const yyvaluep;
4471  struct parser_params *parser;
4472 #endif
4473 {
4474  if (yytype < YYNTOKENS)
4475  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4476  else
4477  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4478 
4479  yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
4480  YYFPRINTF (yyoutput, ")");
4481 }
4482 
4483 /*------------------------------------------------------------------.
4484 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4485 | TOP (included). |
4486 `------------------------------------------------------------------*/
4487 
4488 #if (defined __STDC__ || defined __C99__FUNC__ \
4489  || defined __cplusplus || defined _MSC_VER)
4490 static void
4491 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4492 #else
4493 static void
4494 yy_stack_print (yybottom, yytop)
4495  yytype_int16 *yybottom;
4496  yytype_int16 *yytop;
4497 #endif
4498 {
4499  YYFPRINTF (stderr, "Stack now");
4500  for (; yybottom <= yytop; yybottom++)
4501  {
4502  int yybot = *yybottom;
4503  YYFPRINTF (stderr, " %d", yybot);
4504  }
4505  YYFPRINTF (stderr, "\n");
4506 }
4507 
4508 # define YY_STACK_PRINT(Bottom, Top) \
4509 do { \
4510  if (yydebug) \
4511  yy_stack_print ((Bottom), (Top)); \
4512 } while (YYID (0))
4513 
4514 
4515 /*------------------------------------------------.
4516 | Report that the YYRULE is going to be reduced. |
4517 `------------------------------------------------*/
4518 
4519 #if (defined __STDC__ || defined __C99__FUNC__ \
4520  || defined __cplusplus || defined _MSC_VER)
4521 static void
4522 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
4523 #else
4524 static void
4525 yy_reduce_print (yyvsp, yyrule, parser)
4526  YYSTYPE *yyvsp;
4527  int yyrule;
4528  struct parser_params *parser;
4529 #endif
4531  int yynrhs = yyr2[yyrule];
4532  int yyi;
4533  unsigned long int yylno = yyrline[yyrule];
4534  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4535  yyrule - 1, yylno);
4536  /* The symbols being reduced. */
4537  for (yyi = 0; yyi < yynrhs; yyi++)
4538  {
4539  YYFPRINTF (stderr, " $%d = ", yyi + 1);
4540  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4541  &(yyvsp[(yyi + 1) - (yynrhs)])
4542  , parser);
4543  YYFPRINTF (stderr, "\n");
4544  }
4545 }
4546 
4547 # define YY_REDUCE_PRINT(Rule) \
4548 do { \
4549  if (yydebug) \
4550  yy_reduce_print (yyvsp, Rule, parser); \
4551 } while (YYID (0))
4552 
4553 /* Nonzero means print parse trace. It is left uninitialized so that
4554  multiple parsers can coexist. */
4555 #ifndef yydebug
4556 int yydebug;
4557 #endif
4558 #else /* !YYDEBUG */
4559 # define YYDPRINTF(Args)
4560 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4561 # define YY_STACK_PRINT(Bottom, Top)
4562 # define YY_REDUCE_PRINT(Rule)
4563 #endif /* !YYDEBUG */
4564 
4565 
4566 /* YYINITDEPTH -- initial size of the parser's stacks. */
4567 #ifndef YYINITDEPTH
4568 # define YYINITDEPTH 200
4569 #endif
4570 
4571 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4572  if the built-in stack extension method is used).
4573 
4574  Do not make this value too large; the results are undefined if
4575  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4576  evaluated with infinite-precision integer arithmetic. */
4577 
4578 #ifndef YYMAXDEPTH
4579 # define YYMAXDEPTH 10000
4580 #endif
4581 
4582 
4583 #if YYERROR_VERBOSE
4584 
4585 # ifndef yystrlen
4586 # if defined __GLIBC__ && defined _STRING_H
4587 # define yystrlen strlen
4588 # else
4589 /* Return the length of YYSTR. */
4590 #if (defined __STDC__ || defined __C99__FUNC__ \
4591  || defined __cplusplus || defined _MSC_VER)
4592 static YYSIZE_T
4593 yystrlen (const char *yystr)
4594 #else
4595 static YYSIZE_T
4596 yystrlen (yystr)
4597  const char *yystr;
4598 #endif
4600  YYSIZE_T yylen;
4601  for (yylen = 0; yystr[yylen]; yylen++)
4602  continue;
4603  return yylen;
4604 }
4605 # endif
4606 # endif
4607 
4608 # ifndef yystpcpy
4609 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4610 # define yystpcpy stpcpy
4611 # else
4612 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4613  YYDEST. */
4614 #if (defined __STDC__ || defined __C99__FUNC__ \
4615  || defined __cplusplus || defined _MSC_VER)
4616 static char *
4617 yystpcpy (char *yydest, const char *yysrc)
4618 #else
4619 static char *
4620 yystpcpy (yydest, yysrc)
4621  char *yydest;
4622  const char *yysrc;
4623 #endif
4624 {
4625  char *yyd = yydest;
4626  const char *yys = yysrc;
4627 
4628  while ((*yyd++ = *yys++) != '\0')
4629  continue;
4630 
4631  return yyd - 1;
4632 }
4633 # endif
4634 # endif
4635 
4636 # ifndef yytnamerr
4637 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4638  quotes and backslashes, so that it's suitable for yyerror. The
4639  heuristic is that double-quoting is unnecessary unless the string
4640  contains an apostrophe, a comma, or backslash (other than
4641  backslash-backslash). YYSTR is taken from yytname. If YYRES is
4642  null, do not copy; instead, return the length of what the result
4643  would have been. */
4644 static YYSIZE_T
4645 yytnamerr (char *yyres, const char *yystr)
4646 {
4647  if (*yystr == '"')
4648  {
4649  YYSIZE_T yyn = 0;
4650  char const *yyp = yystr;
4651 
4652  for (;;)
4653  switch (*++yyp)
4654  {
4655  case '\'':
4656  case ',':
4657  goto do_not_strip_quotes;
4658 
4659  case '\\':
4660  if (*++yyp != '\\')
4661  goto do_not_strip_quotes;
4662  /* Fall through. */
4663  default:
4664  if (yyres)
4665  yyres[yyn] = *yyp;
4666  yyn++;
4667  break;
4668 
4669  case '"':
4670  if (yyres)
4671  yyres[yyn] = '\0';
4672  return yyn;
4673  }
4674  do_not_strip_quotes: ;
4675  }
4676 
4677  if (! yyres)
4678  return yystrlen (yystr);
4679 
4680  return yystpcpy (yyres, yystr) - yyres;
4681 }
4682 # endif
4683 
4684 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
4685  about the unexpected token YYTOKEN for the state stack whose top is
4686  YYSSP.
4687 
4688  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
4689  not large enough to hold the message. In that case, also set
4690  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
4691  required number of bytes is too large to store. */
4692 static int
4694  yytype_int16 *yyssp, int yytoken)
4695 {
4696  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
4697  YYSIZE_T yysize = yysize0;
4698  YYSIZE_T yysize1;
4699  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4700  /* Internationalized format string. */
4701  const char *yyformat = 0;
4702  /* Arguments of yyformat. */
4703  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4704  /* Number of reported tokens (one for the "unexpected", one per
4705  "expected"). */
4706  int yycount = 0;
4707 
4708  /* There are many possibilities here to consider:
4709  - Assume YYFAIL is not used. It's too flawed to consider. See
4710  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
4711  for details. YYERROR is fine as it does not invoke this
4712  function.
4713  - If this state is a consistent state with a default action, then
4714  the only way this function was invoked is if the default action
4715  is an error action. In that case, don't check for expected
4716  tokens because there are none.
4717  - The only way there can be no lookahead present (in yychar) is if
4718  this state is a consistent state with a default action. Thus,
4719  detecting the absence of a lookahead is sufficient to determine
4720  that there is no unexpected or expected token to report. In that
4721  case, just report a simple "syntax error".
4722  - Don't assume there isn't a lookahead just because this state is a
4723  consistent state with a default action. There might have been a
4724  previous inconsistent state, consistent state with a non-default
4725  action, or user semantic action that manipulated yychar.
4726  - Of course, the expected token list depends on states to have
4727  correct lookahead information, and it depends on the parser not
4728  to perform extra reductions after fetching a lookahead from the
4729  scanner and before detecting a syntax error. Thus, state merging
4730  (from LALR or IELR) and default reductions corrupt the expected
4731  token list. However, the list is correct for canonical LR with
4732  one exception: it will still contain any token that will not be
4733  accepted due to an error action in a later state.
4734  */
4735  if (yytoken != YYEMPTY)
4736  {
4737  int yyn = yypact[*yyssp];
4738  yyarg[yycount++] = yytname[yytoken];
4739  if (!yypact_value_is_default (yyn))
4740  {
4741  /* Start YYX at -YYN if negative to avoid negative indexes in
4742  YYCHECK. In other words, skip the first -YYN actions for
4743  this state because they are default actions. */
4744  int yyxbegin = yyn < 0 ? -yyn : 0;
4745  /* Stay within bounds of both yycheck and yytname. */
4746  int yychecklim = YYLAST - yyn + 1;
4747  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4748  int yyx;
4749 
4750  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4751  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
4752  && !yytable_value_is_error (yytable[yyx + yyn]))
4753  {
4754  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4755  {
4756  yycount = 1;
4757  yysize = yysize0;
4758  break;
4759  }
4760  yyarg[yycount++] = yytname[yyx];
4761  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4762  if (! (yysize <= yysize1
4763  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4764  return 2;
4765  yysize = yysize1;
4766  }
4767  }
4768  }
4769 
4770  switch (yycount)
4771  {
4772 # define YYCASE_(N, S) \
4773  case N: \
4774  yyformat = S; \
4775  break
4776  YYCASE_(0, YY_("syntax error"));
4777  YYCASE_(1, YY_("syntax error, unexpected %s"));
4778  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
4779  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
4780  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
4781  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
4782 # undef YYCASE_
4783  }
4784 
4785  yysize1 = yysize + yystrlen (yyformat);
4786  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4787  return 2;
4788  yysize = yysize1;
4789 
4790  if (*yymsg_alloc < yysize)
4791  {
4792  *yymsg_alloc = 2 * yysize;
4793  if (! (yysize <= *yymsg_alloc
4794  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
4795  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
4796  return 1;
4797  }
4798 
4799  /* Avoid sprintf, as that infringes on the user's name space.
4800  Don't have undefined behavior even if the translation
4801  produced a string with the wrong number of "%s"s. */
4802  {
4803  char *yyp = *yymsg;
4804  int yyi = 0;
4805  while ((*yyp = *yyformat) != '\0')
4806  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
4807  {
4808  yyp += yytnamerr (yyp, yyarg[yyi++]);
4809  yyformat += 2;
4810  }
4811  else
4812  {
4813  yyp++;
4814  yyformat++;
4815  }
4816  }
4817  return 0;
4818 }
4819 #endif /* YYERROR_VERBOSE */
4820 
4821 /*-----------------------------------------------.
4822 | Release the memory associated to this symbol. |
4823 `-----------------------------------------------*/
4824 
4825 /*ARGSUSED*/
4826 #if (defined __STDC__ || defined __C99__FUNC__ \
4827  || defined __cplusplus || defined _MSC_VER)
4828 static void
4829 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
4830 #else
4831 static void
4832 yydestruct (yymsg, yytype, yyvaluep, parser)
4833  const char *yymsg;
4834  int yytype;
4835  YYSTYPE *yyvaluep;
4836  struct parser_params *parser;
4837 #endif
4838 {
4839  YYUSE (yyvaluep);
4840  YYUSE (parser);
4841 
4842  if (!yymsg)
4843  yymsg = "Deleting";
4844  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4845 
4846  switch (yytype)
4847  {
4848 
4849  default:
4850  break;
4851  }
4852 }
4853 
4854 
4855 /* Prevent warnings from -Wmissing-prototypes. */
4856 #ifdef YYPARSE_PARAM
4857 #if defined __STDC__ || defined __cplusplus
4858 int yyparse (void *YYPARSE_PARAM);
4859 #else
4860 int yyparse ();
4861 #endif
4862 #else /* ! YYPARSE_PARAM */
4863 #if defined __STDC__ || defined __cplusplus
4864 int yyparse (struct parser_params *parser);
4865 #else
4866 int yyparse ();
4867 #endif
4868 #endif /* ! YYPARSE_PARAM */
4869 
4870 
4871 /*----------.
4872 | yyparse. |
4873 `----------*/
4874 
4875 #ifdef YYPARSE_PARAM
4876 #if (defined __STDC__ || defined __C99__FUNC__ \
4877  || defined __cplusplus || defined _MSC_VER)
4878 int
4879 yyparse (void *YYPARSE_PARAM)
4880 #else
4881 int
4882 yyparse (YYPARSE_PARAM)
4883  void *YYPARSE_PARAM;
4884 #endif
4885 #else /* ! YYPARSE_PARAM */
4886 #if (defined __STDC__ || defined __C99__FUNC__ \
4887  || defined __cplusplus || defined _MSC_VER)
4888 int
4889 yyparse (struct parser_params *parser)
4890 #else
4891 int
4892 yyparse (parser)
4893  struct parser_params *parser;
4894 #endif
4895 #endif
4897 /* The lookahead symbol. */
4898 int yychar;
4899 
4900 /* The semantic value of the lookahead symbol. */
4901 YYSTYPE yylval;
4902 
4903  /* Number of syntax errors so far. */
4904  int yynerrs;
4905 
4906  int yystate;
4907  /* Number of tokens to shift before error messages enabled. */
4909 
4910  /* The stacks and their tools:
4911  `yyss': related to states.
4912  `yyvs': related to semantic values.
4913 
4914  Refer to the stacks thru separate pointers, to allow yyoverflow
4915  to reallocate them elsewhere. */
4916 
4917  /* The state stack. */
4918  yytype_int16 yyssa[YYINITDEPTH];
4919  yytype_int16 *yyss;
4920  yytype_int16 *yyssp;
4921 
4922  /* The semantic value stack. */
4925  YYSTYPE *yyvsp;
4926 
4928 
4929  int yyn;
4931  /* Lookahead token as an internal (translated) token number. */
4932  int yytoken;
4933  /* The variables used to return semantic value and location from the
4934  action routines. */
4936 
4937 #if YYERROR_VERBOSE
4938  /* Buffer for error messages, and its allocated size. */
4939  char yymsgbuf[128];
4940  char *yymsg = yymsgbuf;
4942 #endif
4943 
4944 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
4945 
4946  /* The number of symbols on the RHS of the reduced rule.
4947  Keep to zero when no symbol should be popped. */
4948  int yylen = 0;
4949 
4950  yytoken = 0;
4951  yyss = yyssa;
4952  yyvs = yyvsa;
4953  yystacksize = YYINITDEPTH;
4954 
4955  YYDPRINTF ((stderr, "Starting parse\n"));
4956 
4957  yystate = 0;
4958  yyerrstatus = 0;
4959  yynerrs = 0;
4960  yychar = YYEMPTY; /* Cause a token to be read. */
4961 
4962  /* Initialize stack pointers.
4963  Waste one element of value and location stack
4964  so that they stay on the same level as the state stack.
4965  The wasted elements are never initialized. */
4966  yyssp = yyss;
4967  yyvsp = yyvs;
4968 
4970 
4971 /*------------------------------------------------------------.
4972 | yynewstate -- Push a new state, which is found in yystate. |
4973 `------------------------------------------------------------*/
4974  yynewstate:
4975  /* In all cases, when you get here, the value and location stacks
4976  have just been pushed. So pushing a state here evens the stacks. */
4977  yyssp++;
4978 
4979  yysetstate:
4980  *yyssp = yystate;
4981 
4982  if (yyss + yystacksize - 1 <= yyssp)
4983  {
4984  /* Get the current used size of the three stacks, in elements. */
4985  YYSIZE_T yysize = yyssp - yyss + 1;
4986 
4987 #ifdef yyoverflow
4988  {
4989  /* Give user a chance to reallocate the stack. Use copies of
4990  these so that the &'s don't force the real ones into
4991  memory. */
4992  YYSTYPE *yyvs1 = yyvs;
4993  yytype_int16 *yyss1 = yyss;
4994 
4995  /* Each stack pointer address is followed by the size of the
4996  data in use in that stack, in bytes. This used to be a
4997  conditional around just the two extra args, but that might
4998  be undefined if yyoverflow is a macro. */
4999  yyoverflow (YY_("memory exhausted"),
5000  &yyss1, yysize * sizeof (*yyssp),
5001  &yyvs1, yysize * sizeof (*yyvsp),
5002  &yystacksize);
5003 
5004  yyss = yyss1;
5005  yyvs = yyvs1;
5006  }
5007 #else /* no yyoverflow */
5008 # ifndef YYSTACK_RELOCATE
5009  goto yyexhaustedlab;
5010 # else
5011  /* Extend the stack our own way. */
5012  if (YYMAXDEPTH <= yystacksize)
5013  goto yyexhaustedlab;
5014  yystacksize *= 2;
5015  if (YYMAXDEPTH < yystacksize)
5016  yystacksize = YYMAXDEPTH;
5017 
5018  {
5019  yytype_int16 *yyss1 = yyss;
5020  union yyalloc *yyptr =
5021  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
5022  if (! yyptr)
5023  goto yyexhaustedlab;
5024  YYSTACK_RELOCATE (yyss_alloc, yyss);
5025  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
5026 # undef YYSTACK_RELOCATE
5027  if (yyss1 != yyssa)
5028  YYSTACK_FREE (yyss1);
5029  }
5030 # endif
5031 #endif /* no yyoverflow */
5032 
5033  yyssp = yyss + yysize - 1;
5034  yyvsp = yyvs + yysize - 1;
5035 
5036  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
5037  (unsigned long int) yystacksize));
5038 
5039  if (yyss + yystacksize - 1 <= yyssp)
5040  YYABORT;
5041  }
5042 
5043  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
5044 
5045  if (yystate == YYFINAL)
5047 
5048  goto yybackup;
5049 
5050 /*-----------.
5051 | yybackup. |
5052 `-----------*/
5053 yybackup:
5054 
5055  /* Do appropriate processing given the current state. Read a
5056  lookahead token if we need one and don't already have one. */
5057 
5058  /* First try to decide what to do without reference to lookahead token. */
5059  yyn = yypact[yystate];
5060  if (yypact_value_is_default (yyn))
5062 
5063  /* Not known => get a lookahead token if don't already have one. */
5064 
5065  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5066  if (yychar == YYEMPTY)
5067  {
5068  YYDPRINTF ((stderr, "Reading a token: "));
5069  yychar = YYLEX;
5070  }
5071 
5072  if (yychar <= YYEOF)
5073  {
5074  yychar = yytoken = YYEOF;
5075  YYDPRINTF ((stderr, "Now at end of input.\n"));
5076  }
5077  else
5078  {
5079  yytoken = YYTRANSLATE (yychar);
5080  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
5081  }
5082 
5083  /* If the proper action on seeing token YYTOKEN is to reduce or to
5084  detect an error, take that action. */
5085  yyn += yytoken;
5086  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
5087  goto yydefault;
5088  yyn = yytable[yyn];
5089  if (yyn <= 0)
5090  {
5091  if (yytable_value_is_error (yyn))
5092  goto yyerrlab;
5093  yyn = -yyn;
5094  goto yyreduce;
5095  }
5096 
5097  /* Count tokens shifted since error; after three, turn off error
5098  status. */
5099  if (yyerrstatus)
5100  yyerrstatus--;
5101 
5102  /* Shift the lookahead token. */
5103  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
5104 
5105  /* Discard the shifted token. */
5106  yychar = YYEMPTY;
5107 
5108  yystate = yyn;
5109  *++yyvsp = yylval;
5110 
5112 
5113 
5114 /*-----------------------------------------------------------.
5115 | yydefault -- do the default action for the current state. |
5116 `-----------------------------------------------------------*/
5117 yydefault:
5118  yyn = yydefact[yystate];
5119  if (yyn == 0)
5120  goto yyerrlab;
5121  goto yyreduce;
5122 
5123 
5124 /*-----------------------------.
5125 | yyreduce -- Do a reduction. |
5126 `-----------------------------*/
5127 yyreduce:
5128  /* yyn is the number of a rule to reduce with. */
5129  yylen = yyr2[yyn];
5130 
5131  /* If YYLEN is nonzero, implement the default value of the action:
5132  `$$ = $1'.
5133 
5134  Otherwise, the following line sets YYVAL to garbage.
5135  This behavior is undocumented and Bison
5136  users should not rely upon it. Assigning to YYVAL
5137  unconditionally makes the parser a bit smaller, and it avoids a
5138  GCC warning that YYVAL may be used uninitialized. */
5139  yyval = yyvsp[1-yylen];
5140 
5141 
5142  YY_REDUCE_PRINT (yyn);
5143  switch (yyn)
5144  {
5145  case 2:
5146 
5147 /* Line 1806 of yacc.c */
5148 #line 855 "ripper.y"
5149  {
5150  lex_state = EXPR_BEG;
5151 #if 0
5153 #endif
5154  local_push(0);
5155 
5156  }
5157  break;
5158 
5159  case 3:
5160 
5161 /* Line 1806 of yacc.c */
5162 #line 864 "ripper.y"
5163  {
5164 #if 0
5165  if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
5166  /* last expression should not be void */
5167  if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
5168  else {
5169  NODE *node = (yyvsp[(2) - (2)].val);
5170  while (node->nd_next) {
5171  node = node->nd_next;
5172  }
5173  void_expr(node->nd_head);
5174  }
5175  }
5176  ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val)));
5177 #endif
5178  (yyval.val) = (yyvsp[(2) - (2)].val);
5179  parser->result = dispatch1(program, (yyval.val));
5180 
5181  local_pop();
5182  }
5183  break;
5184 
5185  case 4:
5186 
5187 /* Line 1806 of yacc.c */
5188 #line 887 "ripper.y"
5189  {
5190 #if 0
5191  void_stmts((yyvsp[(1) - (2)].val));
5193 #endif
5194 
5195  (yyval.val) = (yyvsp[(1) - (2)].val);
5196  }
5197  break;
5198 
5199  case 5:
5200 
5201 /* Line 1806 of yacc.c */
5202 #line 898 "ripper.y"
5203  {
5204 #if 0
5205  (yyval.val) = NEW_BEGIN(0);
5206 #endif
5207  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5208  dispatch0(void_stmt));
5209 
5210  }
5211  break;
5212 
5213  case 6:
5214 
5215 /* Line 1806 of yacc.c */
5216 #line 907 "ripper.y"
5217  {
5218 #if 0
5219  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5220 #endif
5221  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5222 
5223  }
5224  break;
5225 
5226  case 7:
5227 
5228 /* Line 1806 of yacc.c */
5229 #line 915 "ripper.y"
5230  {
5231 #if 0
5232  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5233 #endif
5234  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5235 
5236  }
5237  break;
5238 
5239  case 8:
5240 
5241 /* Line 1806 of yacc.c */
5242 #line 923 "ripper.y"
5243  {
5244  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5245  }
5246  break;
5247 
5248  case 10:
5249 
5250 /* Line 1806 of yacc.c */
5251 #line 930 "ripper.y"
5252  {
5253 #if 0
5254  /* local_push(0); */
5255 #endif
5256 
5257  }
5258  break;
5259 
5260  case 11:
5261 
5262 /* Line 1806 of yacc.c */
5263 #line 937 "ripper.y"
5264  {
5265 #if 0
5267  (yyvsp[(4) - (5)].val));
5268  /* NEW_PREEXE($4)); */
5269  /* local_pop(); */
5270  (yyval.val) = NEW_BEGIN(0);
5271 #endif
5272  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5273 
5274  }
5275  break;
5276 
5277  case 12:
5278 
5279 /* Line 1806 of yacc.c */
5280 #line 954 "ripper.y"
5281  {
5282 #if 0
5283  (yyval.val) = (yyvsp[(1) - (4)].val);
5284  if ((yyvsp[(2) - (4)].val)) {
5285  (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
5286  }
5287  else if ((yyvsp[(3) - (4)].val)) {
5288  rb_warn0("else without rescue is useless");
5289  (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val));
5290  }
5291  if ((yyvsp[(4) - (4)].val)) {
5292  if ((yyval.val)) {
5293  (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
5294  }
5295  else {
5296  (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL());
5297  }
5298  }
5299  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5300 #endif
5301  (yyval.val) = dispatch4(bodystmt,
5302  escape_Qundef((yyvsp[(1) - (4)].val)),
5303  escape_Qundef((yyvsp[(2) - (4)].val)),
5304  escape_Qundef((yyvsp[(3) - (4)].val)),
5305  escape_Qundef((yyvsp[(4) - (4)].val)));
5306 
5307  }
5308  break;
5309 
5310  case 13:
5311 
5312 /* Line 1806 of yacc.c */
5313 #line 984 "ripper.y"
5314  {
5315 #if 0
5316  void_stmts((yyvsp[(1) - (2)].val));
5318 #endif
5319 
5320  (yyval.val) = (yyvsp[(1) - (2)].val);
5321  }
5322  break;
5323 
5324  case 14:
5325 
5326 /* Line 1806 of yacc.c */
5327 #line 995 "ripper.y"
5328  {
5329 #if 0
5330  (yyval.val) = NEW_BEGIN(0);
5331 #endif
5332  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5333  dispatch0(void_stmt));
5334 
5335  }
5336  break;
5337 
5338  case 15:
5339 
5340 /* Line 1806 of yacc.c */
5341 #line 1004 "ripper.y"
5342  {
5343 #if 0
5344  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5345 #endif
5346  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5347 
5348  }
5349  break;
5350 
5351  case 16:
5352 
5353 /* Line 1806 of yacc.c */
5354 #line 1012 "ripper.y"
5355  {
5356 #if 0
5357  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5358 #endif
5359  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5360 
5361  }
5362  break;
5363 
5364  case 17:
5365 
5366 /* Line 1806 of yacc.c */
5367 #line 1020 "ripper.y"
5368  {
5369  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5370  }
5371  break;
5372 
5373  case 18:
5374 
5375 /* Line 1806 of yacc.c */
5376 #line 1026 "ripper.y"
5377  {
5378  (yyval.val) = (yyvsp[(1) - (1)].val);
5379  }
5380  break;
5381 
5382  case 19:
5383 
5384 /* Line 1806 of yacc.c */
5385 #line 1030 "ripper.y"
5386  {
5387  yyerror("BEGIN is permitted only at toplevel");
5388 #if 0
5389  /* local_push(0); */
5390 #endif
5391 
5392  }
5393  break;
5394 
5395  case 20:
5396 
5397 /* Line 1806 of yacc.c */
5398 #line 1038 "ripper.y"
5399  {
5400 #if 0
5402  (yyvsp[(4) - (5)].val));
5403  /* NEW_PREEXE($4)); */
5404  /* local_pop(); */
5405  (yyval.val) = NEW_BEGIN(0);
5406 #endif
5407  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5408 
5409  }
5410  break;
5411 
5412  case 21:
5413 
5414 /* Line 1806 of yacc.c */
5415 #line 1050 "ripper.y"
5416  {lex_state = EXPR_FNAME;}
5417  break;
5418 
5419  case 22:
5420 
5421 /* Line 1806 of yacc.c */
5422 #line 1051 "ripper.y"
5423  {
5424 #if 0
5425  (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5426 #endif
5427  (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5428 
5429  }
5430  break;
5431 
5432  case 23:
5433 
5434 /* Line 1806 of yacc.c */
5435 #line 1059 "ripper.y"
5436  {
5437 #if 0
5438  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5439 #endif
5440  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5441 
5442  }
5443  break;
5444 
5445  case 24:
5446 
5447 /* Line 1806 of yacc.c */
5448 #line 1067 "ripper.y"
5449  {
5450 #if 0
5451  char buf[2];
5452  buf[0] = '$';
5453  buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
5454  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
5455 #endif
5456  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5457 
5458  }
5459  break;
5460 
5461  case 25:
5462 
5463 /* Line 1806 of yacc.c */
5464 #line 1078 "ripper.y"
5465  {
5466 #if 0
5467  yyerror("can't make alias for the number variables");
5468  (yyval.val) = NEW_BEGIN(0);
5469 #endif
5470  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5471  (yyval.val) = dispatch1(alias_error, (yyval.val));
5472 
5473  }
5474  break;
5475 
5476  case 26:
5477 
5478 /* Line 1806 of yacc.c */
5479 #line 1088 "ripper.y"
5480  {
5481 #if 0
5482  (yyval.val) = (yyvsp[(2) - (2)].val);
5483 #endif
5484  (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
5485 
5486  }
5487  break;
5488 
5489  case 27:
5490 
5491 /* Line 1806 of yacc.c */
5492 #line 1096 "ripper.y"
5493  {
5494 #if 0
5495  (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5496  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5497 #endif
5498  (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5499 
5500  }
5501  break;
5502 
5503  case 28:
5504 
5505 /* Line 1806 of yacc.c */
5506 #line 1105 "ripper.y"
5507  {
5508 #if 0
5509  (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5510  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5511 #endif
5512  (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5513 
5514  }
5515  break;
5516 
5517  case 29:
5518 
5519 /* Line 1806 of yacc.c */
5520 #line 1114 "ripper.y"
5521  {
5522 #if 0
5523  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5524  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5525  }
5526  else {
5527  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5528  }
5529 #endif
5530  (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5531 
5532  }
5533  break;
5534 
5535  case 30:
5536 
5537 /* Line 1806 of yacc.c */
5538 #line 1127 "ripper.y"
5539  {
5540 #if 0
5541  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5542  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5543  }
5544  else {
5545  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5546  }
5547 #endif
5548  (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5549 
5550  }
5551  break;
5552 
5553  case 31:
5554 
5555 /* Line 1806 of yacc.c */
5556 #line 1140 "ripper.y"
5557  {
5558 #if 0
5559  NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0);
5560  (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0);
5561 #endif
5562  (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5563 
5564  }
5565  break;
5566 
5567  case 32:
5568 
5569 /* Line 1806 of yacc.c */
5570 #line 1149 "ripper.y"
5571  {
5572  if (in_def || in_single) {
5573  rb_warn0("END in method; use at_exit");
5574  }
5575 #if 0
5576  (yyval.val) = NEW_POSTEXE(NEW_NODE(
5577  NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */));
5578 #endif
5579  (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
5580 
5581  }
5582  break;
5583 
5584  case 34:
5585 
5586 /* Line 1806 of yacc.c */
5587 #line 1162 "ripper.y"
5588  {
5589 #if 0
5590  value_expr((yyvsp[(3) - (3)].val));
5591  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5592  (yyval.val) = (yyvsp[(1) - (3)].val);
5593 #endif
5594  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5595 
5596  }
5597  break;
5598 
5599  case 35:
5600 
5601 /* Line 1806 of yacc.c */
5602 #line 1172 "ripper.y"
5603  {
5604  value_expr((yyvsp[(3) - (3)].val));
5605  (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5606  }
5607  break;
5608 
5609  case 36:
5610 
5611 /* Line 1806 of yacc.c */
5612 #line 1177 "ripper.y"
5613  {
5614 #if 0
5615  NODE *args;
5616 
5617  value_expr((yyvsp[(6) - (6)].val));
5618  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
5619  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
5620  if ((yyvsp[(5) - (6)].val) == tOROP) {
5621  (yyvsp[(5) - (6)].val) = 0;
5622  }
5623  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
5624  (yyvsp[(5) - (6)].val) = 1;
5625  }
5626  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
5627  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
5628 #endif
5629  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
5630  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
5631 
5632  }
5633  break;
5634 
5635  case 37:
5636 
5637 /* Line 1806 of yacc.c */
5638 #line 1198 "ripper.y"
5639  {
5640  value_expr((yyvsp[(5) - (5)].val));
5641  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5642  }
5643  break;
5644 
5645  case 38:
5646 
5647 /* Line 1806 of yacc.c */
5648 #line 1203 "ripper.y"
5649  {
5650  value_expr((yyvsp[(5) - (5)].val));
5651  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5652  }
5653  break;
5654 
5655  case 39:
5656 
5657 /* Line 1806 of yacc.c */
5658 #line 1208 "ripper.y"
5659  {
5660 #if 0
5661  (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
5662  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5663 #endif
5664  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
5665  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5666 
5667  }
5668  break;
5669 
5670  case 40:
5671 
5672 /* Line 1806 of yacc.c */
5673 #line 1218 "ripper.y"
5674  {
5675  value_expr((yyvsp[(5) - (5)].val));
5676  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5677  }
5678  break;
5679 
5680  case 41:
5681 
5682 /* Line 1806 of yacc.c */
5683 #line 1223 "ripper.y"
5684  {
5685 #if 0
5686  rb_backref_error((yyvsp[(1) - (3)].val));
5687  (yyval.val) = NEW_BEGIN(0);
5688 #endif
5689  (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
5690  (yyval.val) = dispatch1(assign_error, (yyval.val));
5691 
5692  }
5693  break;
5694 
5695  case 42:
5696 
5697 /* Line 1806 of yacc.c */
5698 #line 1233 "ripper.y"
5699  {
5700 #if 0
5701  value_expr((yyvsp[(3) - (3)].val));
5702  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5703 #endif
5704  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5705 
5706  }
5707  break;
5708 
5709  case 43:
5710 
5711 /* Line 1806 of yacc.c */
5712 #line 1242 "ripper.y"
5713  {
5714 #if 0
5715  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5716  (yyval.val) = (yyvsp[(1) - (3)].val);
5717 #endif
5718  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5719 
5720  }
5721  break;
5722 
5723  case 44:
5724 
5725 /* Line 1806 of yacc.c */
5726 #line 1251 "ripper.y"
5727  {
5728 #if 0
5729  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5730  (yyval.val) = (yyvsp[(1) - (3)].val);
5731 #endif
5732  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5733 
5734  }
5735  break;
5736 
5737  case 46:
5738 
5739 /* Line 1806 of yacc.c */
5740 #line 1263 "ripper.y"
5741  {
5742 #if 0
5743  value_expr((yyvsp[(3) - (3)].val));
5744  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5745 #endif
5746  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5747 
5748  }
5749  break;
5750 
5751  case 47:
5752 
5753 /* Line 1806 of yacc.c */
5754 #line 1272 "ripper.y"
5755  {
5756 #if 0
5757  value_expr((yyvsp[(3) - (3)].val));
5758  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5759 #endif
5760  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5761 
5762  }
5763  break;
5764 
5765  case 49:
5766 
5767 /* Line 1806 of yacc.c */
5768 #line 1285 "ripper.y"
5769  {
5770 #if 0
5771  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5772 #endif
5773  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val));
5774 
5775  }
5776  break;
5777 
5778  case 50:
5779 
5780 /* Line 1806 of yacc.c */
5781 #line 1293 "ripper.y"
5782  {
5783 #if 0
5784  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5785 #endif
5786  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val));
5787 
5788  }
5789  break;
5790 
5791  case 51:
5792 
5793 /* Line 1806 of yacc.c */
5794 #line 1301 "ripper.y"
5795  {
5796 #if 0
5797  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!');
5798 #endif
5799  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val));
5800 
5801  }
5802  break;
5803 
5804  case 52:
5805 
5806 /* Line 1806 of yacc.c */
5807 #line 1309 "ripper.y"
5808  {
5809 #if 0
5810  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
5811 #endif
5812  (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val));
5813 
5814  }
5815  break;
5816 
5817  case 54:
5818 
5819 /* Line 1806 of yacc.c */
5820 #line 1320 "ripper.y"
5821  {
5822 #if 0
5823  value_expr((yyvsp[(1) - (1)].val));
5824  (yyval.val) = (yyvsp[(1) - (1)].val);
5825  if (!(yyval.val)) (yyval.val) = NEW_NIL();
5826 #endif
5827  (yyval.val) = (yyvsp[(1) - (1)].val);
5828 
5829  }
5830  break;
5831 
5832  case 58:
5833 
5834 /* Line 1806 of yacc.c */
5835 #line 1337 "ripper.y"
5836  {
5837 #if 0
5838  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5839 #endif
5840  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
5841  (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
5842 
5843  }
5844  break;
5845 
5846  case 59:
5847 
5848 /* Line 1806 of yacc.c */
5849 #line 1348 "ripper.y"
5850  {
5851  (yyvsp[(1) - (1)].vars) = dyna_push();
5852 #if 0
5853  (yyval.num) = ruby_sourceline;
5854 #endif
5855 
5856  }
5857  break;
5858 
5859  case 60:
5860 
5861 /* Line 1806 of yacc.c */
5862 #line 1358 "ripper.y"
5863  {
5864 #if 0
5865  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
5866  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
5867 #endif
5868  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
5869 
5870  dyna_pop((yyvsp[(1) - (5)].vars));
5871  }
5872  break;
5873 
5874  case 61:
5875 
5876 /* Line 1806 of yacc.c */
5877 #line 1370 "ripper.y"
5878  {
5879 #if 0
5880  (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
5881  nd_set_line((yyval.val), tokline);
5882 #endif
5883 
5884  }
5885  break;
5886 
5887  case 62:
5888 
5889 /* Line 1806 of yacc.c */
5890 #line 1380 "ripper.y"
5891  {
5892 #if 0
5893  (yyval.val) = (yyvsp[(1) - (2)].val);
5894  (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
5895 #endif
5896  (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
5897 
5898  }
5899  break;
5900 
5901  case 63:
5902 
5903 /* Line 1806 of yacc.c */
5904 #line 1389 "ripper.y"
5905  {
5906 #if 0
5907  block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
5908  (yyvsp[(1) - (3)].val)->nd_args = (yyvsp[(2) - (3)].val);
5909  (yyvsp[(3) - (3)].val)->nd_iter = (yyvsp[(1) - (3)].val);
5910  (yyval.val) = (yyvsp[(3) - (3)].val);
5911  fixpos((yyval.val), (yyvsp[(1) - (3)].val));
5912 #endif
5913  (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
5914  (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
5915 
5916  }
5917  break;
5918 
5919  case 64:
5920 
5921 /* Line 1806 of yacc.c */
5922 #line 1402 "ripper.y"
5923  {
5924 #if 0
5925  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5926  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5927 #endif
5928  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5929 
5930  }
5931  break;
5932 
5933  case 65:
5934 
5935 /* Line 1806 of yacc.c */
5936 #line 1411 "ripper.y"
5937  {
5938 #if 0
5939  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
5940  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
5941  (yyval.val) = (yyvsp[(5) - (5)].val);
5942  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
5943 #endif
5944  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
5945  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
5946 
5947  }
5948  break;
5949 
5950  case 66:
5951 
5952 /* Line 1806 of yacc.c */
5953 #line 1423 "ripper.y"
5954  {
5955 #if 0
5956  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5957  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5958 #endif
5959  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5960 
5961  }
5962  break;
5963 
5964  case 67:
5965 
5966 /* Line 1806 of yacc.c */
5967 #line 1432 "ripper.y"
5968  {
5969 #if 0
5970  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
5971  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
5972  (yyval.val) = (yyvsp[(5) - (5)].val);
5973  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
5974 #endif
5975  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
5976  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
5977 
5978  }
5979  break;
5980 
5981  case 68:
5982 
5983 /* Line 1806 of yacc.c */
5984 #line 1444 "ripper.y"
5985  {
5986 #if 0
5987  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
5988  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
5989 #endif
5990  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
5991 
5992  }
5993  break;
5994 
5995  case 69:
5996 
5997 /* Line 1806 of yacc.c */
5998 #line 1453 "ripper.y"
5999  {
6000 #if 0
6001  (yyval.val) = new_yield((yyvsp[(2) - (2)].val));
6002  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
6003 #endif
6004  (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
6005 
6006  }
6007  break;
6008 
6009  case 70:
6010 
6011 /* Line 1806 of yacc.c */
6012 #line 1462 "ripper.y"
6013  {
6014 #if 0
6015  (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
6016 #endif
6017  (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
6018 
6019  }
6020  break;
6021 
6022  case 71:
6023 
6024 /* Line 1806 of yacc.c */
6025 #line 1470 "ripper.y"
6026  {
6027 #if 0
6028  (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
6029 #endif
6030  (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
6031 
6032  }
6033  break;
6034 
6035  case 72:
6036 
6037 /* Line 1806 of yacc.c */
6038 #line 1478 "ripper.y"
6039  {
6040 #if 0
6041  (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
6042 #endif
6043  (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
6044 
6045  }
6046  break;
6047 
6048  case 74:
6049 
6050 /* Line 1806 of yacc.c */
6051 #line 1489 "ripper.y"
6052  {
6053 #if 0
6054  (yyval.val) = (yyvsp[(2) - (3)].val);
6055 #endif
6056  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6057 
6058  }
6059  break;
6060 
6061  case 76:
6062 
6063 /* Line 1806 of yacc.c */
6064 #line 1500 "ripper.y"
6065  {
6066 #if 0
6067  (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0);
6068 #endif
6069  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6070 
6071  }
6072  break;
6073 
6074  case 77:
6075 
6076 /* Line 1806 of yacc.c */
6077 #line 1510 "ripper.y"
6078  {
6079 #if 0
6080  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
6081 #endif
6082  (yyval.val) = (yyvsp[(1) - (1)].val);
6083 
6084  }
6085  break;
6086 
6087  case 78:
6088 
6089 /* Line 1806 of yacc.c */
6090 #line 1518 "ripper.y"
6091  {
6092 #if 0
6093  (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0);
6094 #endif
6095  (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
6096 
6097  }
6098  break;
6099 
6100  case 79:
6101 
6102 /* Line 1806 of yacc.c */
6103 #line 1526 "ripper.y"
6104  {
6105 #if 0
6106  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6107 #endif
6108  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6109 
6110  }
6111  break;
6112 
6113  case 80:
6114 
6115 /* Line 1806 of yacc.c */
6116 #line 1534 "ripper.y"
6117  {
6118 #if 0
6119  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val)));
6120 #endif
6121  (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6122  (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
6123 
6124  }
6125  break;
6126 
6127  case 81:
6128 
6129 /* Line 1806 of yacc.c */
6130 #line 1543 "ripper.y"
6131  {
6132 #if 0
6133  (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1);
6134 #endif
6135  (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
6136 
6137  }
6138  break;
6139 
6140  case 82:
6141 
6142 /* Line 1806 of yacc.c */
6143 #line 1551 "ripper.y"
6144  {
6145 #if 0
6146  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
6147 #endif
6148  (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
6149  (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6150 
6151  }
6152  break;
6153 
6154  case 83:
6155 
6156 /* Line 1806 of yacc.c */
6157 #line 1560 "ripper.y"
6158  {
6159 #if 0
6160  (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
6161 #endif
6162  (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
6163 
6164  }
6165  break;
6166 
6167  case 84:
6168 
6169 /* Line 1806 of yacc.c */
6170 #line 1568 "ripper.y"
6171  {
6172 #if 0
6173  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
6174 #endif
6175  (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
6176  (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
6177 
6178  }
6179  break;
6180 
6181  case 85:
6182 
6183 /* Line 1806 of yacc.c */
6184 #line 1577 "ripper.y"
6185  {
6186 #if 0
6187  (yyval.val) = NEW_MASGN(0, -1);
6188 #endif
6189  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6190 
6191  }
6192  break;
6193 
6194  case 86:
6195 
6196 /* Line 1806 of yacc.c */
6197 #line 1585 "ripper.y"
6198  {
6199 #if 0
6200  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
6201 #endif
6202  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6203  (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
6204 
6205  }
6206  break;
6207 
6208  case 88:
6209 
6210 /* Line 1806 of yacc.c */
6211 #line 1597 "ripper.y"
6212  {
6213 #if 0
6214  (yyval.val) = (yyvsp[(2) - (3)].val);
6215 #endif
6216  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6217 
6218  }
6219  break;
6220 
6221  case 89:
6222 
6223 /* Line 1806 of yacc.c */
6224 #line 1607 "ripper.y"
6225  {
6226 #if 0
6227  (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
6228 #endif
6229  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
6230 
6231  }
6232  break;
6233 
6234  case 90:
6235 
6236 /* Line 1806 of yacc.c */
6237 #line 1615 "ripper.y"
6238  {
6239 #if 0
6240  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6241 #endif
6242  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6243 
6244  }
6245  break;
6246 
6247  case 91:
6248 
6249 /* Line 1806 of yacc.c */
6250 #line 1625 "ripper.y"
6251  {
6252 #if 0
6253  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
6254 #endif
6255  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
6256 
6257  }
6258  break;
6259 
6260  case 92:
6261 
6262 /* Line 1806 of yacc.c */
6263 #line 1633 "ripper.y"
6264  {
6265 #if 0
6266  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6267 #endif
6268  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6269 
6270  }
6271  break;
6272 
6273  case 93:
6274 
6275 /* Line 1806 of yacc.c */
6276 #line 1643 "ripper.y"
6277  {
6278  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6279  }
6280  break;
6281 
6282  case 94:
6283 
6284 /* Line 1806 of yacc.c */
6285 #line 1647 "ripper.y"
6286  {
6287  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6288  }
6289  break;
6290 
6291  case 95:
6292 
6293 /* Line 1806 of yacc.c */
6294 #line 1651 "ripper.y"
6295  {
6296 #if 0
6297  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6298 #endif
6299  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6300 
6301  }
6302  break;
6303 
6304  case 96:
6305 
6306 /* Line 1806 of yacc.c */
6307 #line 1659 "ripper.y"
6308  {
6309 #if 0
6310  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6311 #endif
6312  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6313 
6314  }
6315  break;
6316 
6317  case 97:
6318 
6319 /* Line 1806 of yacc.c */
6320 #line 1667 "ripper.y"
6321  {
6322 #if 0
6323  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6324 #endif
6325  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6326 
6327  }
6328  break;
6329 
6330  case 98:
6331 
6332 /* Line 1806 of yacc.c */
6333 #line 1675 "ripper.y"
6334  {
6335 #if 0
6336  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6337 #endif
6338  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6339 
6340  }
6341  break;
6342 
6343  case 99:
6344 
6345 /* Line 1806 of yacc.c */
6346 #line 1683 "ripper.y"
6347  {
6348 #if 0
6349  if (in_def || in_single)
6350  yyerror("dynamic constant assignment");
6351  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6352 #endif
6353  if (in_def || in_single)
6354  yyerror("dynamic constant assignment");
6355  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6356 
6357  }
6358  break;
6359 
6360  case 100:
6361 
6362 /* Line 1806 of yacc.c */
6363 #line 1695 "ripper.y"
6364  {
6365 #if 0
6366  if (in_def || in_single)
6367  yyerror("dynamic constant assignment");
6368  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6369 #endif
6370  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6371 
6372  }
6373  break;
6374 
6375  case 101:
6376 
6377 /* Line 1806 of yacc.c */
6378 #line 1705 "ripper.y"
6379  {
6380 #if 0
6381  rb_backref_error((yyvsp[(1) - (1)].val));
6382  (yyval.val) = NEW_BEGIN(0);
6383 #endif
6384  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val));
6385  (yyval.val) = dispatch1(assign_error, (yyval.val));
6386 
6387  }
6388  break;
6389 
6390  case 102:
6391 
6392 /* Line 1806 of yacc.c */
6393 #line 1717 "ripper.y"
6394  {
6395  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6396 #if 0
6397  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6398 #endif
6399  (yyval.val) = dispatch1(var_field, (yyval.val));
6400 
6401  }
6402  break;
6403 
6404  case 103:
6405 
6406 /* Line 1806 of yacc.c */
6407 #line 1726 "ripper.y"
6408  {
6409  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6410 #if 0
6411  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6412 #endif
6413  (yyval.val) = dispatch1(var_field, (yyval.val));
6414 
6415  }
6416  break;
6417 
6418  case 104:
6419 
6420 /* Line 1806 of yacc.c */
6421 #line 1735 "ripper.y"
6422  {
6423 #if 0
6424  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6425 #endif
6426  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6427 
6428  }
6429  break;
6430 
6431  case 105:
6432 
6433 /* Line 1806 of yacc.c */
6434 #line 1743 "ripper.y"
6435  {
6436 #if 0
6437  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6438 #endif
6439  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6440 
6441  }
6442  break;
6443 
6444  case 106:
6445 
6446 /* Line 1806 of yacc.c */
6447 #line 1751 "ripper.y"
6448  {
6449 #if 0
6450  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6451 #endif
6452  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
6453 
6454  }
6455  break;
6456 
6457  case 107:
6458 
6459 /* Line 1806 of yacc.c */
6460 #line 1759 "ripper.y"
6461  {
6462 #if 0
6463  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6464 #endif
6465  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6466 
6467  }
6468  break;
6469 
6470  case 108:
6471 
6472 /* Line 1806 of yacc.c */
6473 #line 1767 "ripper.y"
6474  {
6475 #if 0
6476  if (in_def || in_single)
6477  yyerror("dynamic constant assignment");
6478  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6479 #endif
6480  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6481  if (in_def || in_single) {
6482  (yyval.val) = dispatch1(assign_error, (yyval.val));
6483  }
6484 
6485  }
6486  break;
6487 
6488  case 109:
6489 
6490 /* Line 1806 of yacc.c */
6491 #line 1780 "ripper.y"
6492  {
6493 #if 0
6494  if (in_def || in_single)
6495  yyerror("dynamic constant assignment");
6496  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6497 #endif
6498  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6499  if (in_def || in_single) {
6500  (yyval.val) = dispatch1(assign_error, (yyval.val));
6501  }
6502 
6503  }
6504  break;
6505 
6506  case 110:
6507 
6508 /* Line 1806 of yacc.c */
6509 #line 1793 "ripper.y"
6510  {
6511 #if 0
6512  rb_backref_error((yyvsp[(1) - (1)].val));
6513  (yyval.val) = NEW_BEGIN(0);
6514 #endif
6515  (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val));
6516 
6517  }
6518  break;
6519 
6520  case 111:
6521 
6522 /* Line 1806 of yacc.c */
6523 #line 1804 "ripper.y"
6524  {
6525 #if 0
6526  yyerror("class/module name must be CONSTANT");
6527 #endif
6528  (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
6529 
6530  }
6531  break;
6532 
6533  case 113:
6534 
6535 /* Line 1806 of yacc.c */
6536 #line 1815 "ripper.y"
6537  {
6538 #if 0
6539  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
6540 #endif
6541  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
6542 
6543  }
6544  break;
6545 
6546  case 114:
6547 
6548 /* Line 1806 of yacc.c */
6549 #line 1823 "ripper.y"
6550  {
6551 #if 0
6552  (yyval.val) = NEW_COLON2(0, (yyval.val));
6553 #endif
6554  (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
6555 
6556  }
6557  break;
6558 
6559  case 115:
6560 
6561 /* Line 1806 of yacc.c */
6562 #line 1831 "ripper.y"
6563  {
6564 #if 0
6565  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6566 #endif
6567  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6568 
6569  }
6570  break;
6571 
6572  case 119:
6573 
6574 /* Line 1806 of yacc.c */
6575 #line 1844 "ripper.y"
6576  {
6577  lex_state = EXPR_ENDFN;
6578  (yyval.val) = (yyvsp[(1) - (1)].val);
6579  }
6580  break;
6581 
6582  case 120:
6583 
6584 /* Line 1806 of yacc.c */
6585 #line 1849 "ripper.y"
6586  {
6587  lex_state = EXPR_ENDFN;
6588 #if 0
6589  (yyval.val) = (yyvsp[(1) - (1)].id);
6590 #endif
6591  (yyval.val) = (yyvsp[(1) - (1)].val);
6592 
6593  }
6594  break;
6595 
6596  case 123:
6597 
6598 /* Line 1806 of yacc.c */
6599 #line 1864 "ripper.y"
6600  {
6601 #if 0
6602  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
6603 #endif
6604  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
6605 
6606  }
6607  break;
6608 
6609  case 125:
6610 
6611 /* Line 1806 of yacc.c */
6612 #line 1875 "ripper.y"
6613  {
6614 #if 0
6615  (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
6616 #endif
6617  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
6618 
6619  }
6620  break;
6621 
6622  case 126:
6623 
6624 /* Line 1806 of yacc.c */
6625 #line 1882 "ripper.y"
6626  {lex_state = EXPR_FNAME;}
6627  break;
6628 
6629  case 127:
6630 
6631 /* Line 1806 of yacc.c */
6632 #line 1883 "ripper.y"
6633  {
6634 #if 0
6635  (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
6636 #endif
6637  rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6638 
6639  }
6640  break;
6641 
6642  case 128:
6643 
6644 /* Line 1806 of yacc.c */
6645 #line 1892 "ripper.y"
6646  { ifndef_ripper((yyval.val) = '|'); }
6647  break;
6648 
6649  case 129:
6650 
6651 /* Line 1806 of yacc.c */
6652 #line 1893 "ripper.y"
6653  { ifndef_ripper((yyval.val) = '^'); }
6654  break;
6655 
6656  case 130:
6657 
6658 /* Line 1806 of yacc.c */
6659 #line 1894 "ripper.y"
6660  { ifndef_ripper((yyval.val) = '&'); }
6661  break;
6662 
6663  case 131:
6664 
6665 /* Line 1806 of yacc.c */
6666 #line 1895 "ripper.y"
6667  { ifndef_ripper((yyval.val) = tCMP); }
6668  break;
6669 
6670  case 132:
6671 
6672 /* Line 1806 of yacc.c */
6673 #line 1896 "ripper.y"
6674  { ifndef_ripper((yyval.val) = tEQ); }
6675  break;
6676 
6677  case 133:
6678 
6679 /* Line 1806 of yacc.c */
6680 #line 1897 "ripper.y"
6681  { ifndef_ripper((yyval.val) = tEQQ); }
6682  break;
6683 
6684  case 134:
6685 
6686 /* Line 1806 of yacc.c */
6687 #line 1898 "ripper.y"
6688  { ifndef_ripper((yyval.val) = tMATCH); }
6689  break;
6690 
6691  case 135:
6692 
6693 /* Line 1806 of yacc.c */
6694 #line 1899 "ripper.y"
6695  { ifndef_ripper((yyval.val) = tNMATCH); }
6696  break;
6697 
6698  case 136:
6699 
6700 /* Line 1806 of yacc.c */
6701 #line 1900 "ripper.y"
6702  { ifndef_ripper((yyval.val) = '>'); }
6703  break;
6704 
6705  case 137:
6706 
6707 /* Line 1806 of yacc.c */
6708 #line 1901 "ripper.y"
6709  { ifndef_ripper((yyval.val) = tGEQ); }
6710  break;
6711 
6712  case 138:
6713 
6714 /* Line 1806 of yacc.c */
6715 #line 1902 "ripper.y"
6716  { ifndef_ripper((yyval.val) = '<'); }
6717  break;
6718 
6719  case 139:
6720 
6721 /* Line 1806 of yacc.c */
6722 #line 1903 "ripper.y"
6723  { ifndef_ripper((yyval.val) = tLEQ); }
6724  break;
6725 
6726  case 140:
6727 
6728 /* Line 1806 of yacc.c */
6729 #line 1904 "ripper.y"
6730  { ifndef_ripper((yyval.val) = tNEQ); }
6731  break;
6732 
6733  case 141:
6734 
6735 /* Line 1806 of yacc.c */
6736 #line 1905 "ripper.y"
6737  { ifndef_ripper((yyval.val) = tLSHFT); }
6738  break;
6739 
6740  case 142:
6741 
6742 /* Line 1806 of yacc.c */
6743 #line 1906 "ripper.y"
6744  { ifndef_ripper((yyval.val) = tRSHFT); }
6745  break;
6746 
6747  case 143:
6748 
6749 /* Line 1806 of yacc.c */
6750 #line 1907 "ripper.y"
6751  { ifndef_ripper((yyval.val) = '+'); }
6752  break;
6753 
6754  case 144:
6755 
6756 /* Line 1806 of yacc.c */
6757 #line 1908 "ripper.y"
6758  { ifndef_ripper((yyval.val) = '-'); }
6759  break;
6760 
6761  case 145:
6762 
6763 /* Line 1806 of yacc.c */
6764 #line 1909 "ripper.y"
6765  { ifndef_ripper((yyval.val) = '*'); }
6766  break;
6767 
6768  case 146:
6769 
6770 /* Line 1806 of yacc.c */
6771 #line 1910 "ripper.y"
6772  { ifndef_ripper((yyval.val) = '*'); }
6773  break;
6774 
6775  case 147:
6776 
6777 /* Line 1806 of yacc.c */
6778 #line 1911 "ripper.y"
6779  { ifndef_ripper((yyval.val) = '/'); }
6780  break;
6781 
6782  case 148:
6783 
6784 /* Line 1806 of yacc.c */
6785 #line 1912 "ripper.y"
6786  { ifndef_ripper((yyval.val) = '%'); }
6787  break;
6788 
6789  case 149:
6790 
6791 /* Line 1806 of yacc.c */
6792 #line 1913 "ripper.y"
6793  { ifndef_ripper((yyval.val) = tPOW); }
6794  break;
6795 
6796  case 150:
6797 
6798 /* Line 1806 of yacc.c */
6799 #line 1914 "ripper.y"
6800  { ifndef_ripper((yyval.val) = tDSTAR); }
6801  break;
6802 
6803  case 151:
6804 
6805 /* Line 1806 of yacc.c */
6806 #line 1915 "ripper.y"
6807  { ifndef_ripper((yyval.val) = '!'); }
6808  break;
6809 
6810  case 152:
6811 
6812 /* Line 1806 of yacc.c */
6813 #line 1916 "ripper.y"
6814  { ifndef_ripper((yyval.val) = '~'); }
6815  break;
6816 
6817  case 153:
6818 
6819 /* Line 1806 of yacc.c */
6820 #line 1917 "ripper.y"
6821  { ifndef_ripper((yyval.val) = tUPLUS); }
6822  break;
6823 
6824  case 154:
6825 
6826 /* Line 1806 of yacc.c */
6827 #line 1918 "ripper.y"
6828  { ifndef_ripper((yyval.val) = tUMINUS); }
6829  break;
6830 
6831  case 155:
6832 
6833 /* Line 1806 of yacc.c */
6834 #line 1919 "ripper.y"
6835  { ifndef_ripper((yyval.val) = tAREF); }
6836  break;
6837 
6838  case 156:
6839 
6840 /* Line 1806 of yacc.c */
6841 #line 1920 "ripper.y"
6842  { ifndef_ripper((yyval.val) = tASET); }
6843  break;
6844 
6845  case 157:
6846 
6847 /* Line 1806 of yacc.c */
6848 #line 1921 "ripper.y"
6849  { ifndef_ripper((yyval.val) = '`'); }
6850  break;
6851 
6852  case 199:
6853 
6854 /* Line 1806 of yacc.c */
6855 #line 1939 "ripper.y"
6856  {
6857 #if 0
6858  value_expr((yyvsp[(3) - (3)].val));
6859  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6860 #endif
6861  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6862 
6863  }
6864  break;
6865 
6866  case 200:
6867 
6868 /* Line 1806 of yacc.c */
6869 #line 1948 "ripper.y"
6870  {
6871 #if 0
6872  value_expr((yyvsp[(3) - (5)].val));
6873  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6874  (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6875 #endif
6876  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)));
6877 
6878  }
6879  break;
6880 
6881  case 201:
6882 
6883 /* Line 1806 of yacc.c */
6884 #line 1958 "ripper.y"
6885  {
6886  value_expr((yyvsp[(3) - (3)].val));
6887  (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
6888  }
6889  break;
6890 
6891  case 202:
6892 
6893 /* Line 1806 of yacc.c */
6894 #line 1963 "ripper.y"
6895  {
6896 #if 0
6897  value_expr((yyvsp[(3) - (5)].val));
6898  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6899 #endif
6900  (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
6901 
6902  (yyval.val) = new_op_assign((yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val));
6903  }
6904  break;
6905 
6906  case 203:
6907 
6908 /* Line 1806 of yacc.c */
6909 #line 1973 "ripper.y"
6910  {
6911 #if 0
6912  NODE *args;
6913 
6914  value_expr((yyvsp[(6) - (6)].val));
6915  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
6916  if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
6917  args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6918  }
6919  else {
6920  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6921  }
6922  if ((yyvsp[(5) - (6)].val) == tOROP) {
6923  (yyvsp[(5) - (6)].val) = 0;
6924  }
6925  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
6926  (yyvsp[(5) - (6)].val) = 1;
6927  }
6928  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
6929  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
6930 #endif
6931  (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
6932  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
6933 
6934  }
6935  break;
6936 
6937  case 204:
6938 
6939 /* Line 1806 of yacc.c */
6940 #line 1999 "ripper.y"
6941  {
6942  value_expr((yyvsp[(5) - (5)].val));
6943  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6944  }
6945  break;
6946 
6947  case 205:
6948 
6949 /* Line 1806 of yacc.c */
6950 #line 2004 "ripper.y"
6951  {
6952  value_expr((yyvsp[(5) - (5)].val));
6953  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6954  }
6955  break;
6956 
6957  case 206:
6958 
6959 /* Line 1806 of yacc.c */
6960 #line 2009 "ripper.y"
6961  {
6962  value_expr((yyvsp[(5) - (5)].val));
6963  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6964  }
6965  break;
6966 
6967  case 207:
6968 
6969 /* Line 1806 of yacc.c */
6970 #line 2014 "ripper.y"
6971  {
6972 #if 0
6973  (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6974  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6975 #endif
6976  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6977  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6978 
6979  }
6980  break;
6981 
6982  case 208:
6983 
6984 /* Line 1806 of yacc.c */
6985 #line 2024 "ripper.y"
6986  {
6987 #if 0
6988  (yyval.val) = NEW_COLON3((yyvsp[(2) - (4)].val));
6989  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6990 #endif
6991  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val));
6992  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6993 
6994  }
6995  break;
6996 
6997  case 209:
6998 
6999 /* Line 1806 of yacc.c */
7000 #line 2034 "ripper.y"
7001  {
7002 #if 0
7003  rb_backref_error((yyvsp[(1) - (3)].val));
7004  (yyval.val) = NEW_BEGIN(0);
7005 #endif
7006  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val));
7007  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
7008  (yyval.val) = dispatch1(assign_error, (yyval.val));
7009 
7010  }
7011  break;
7012 
7013  case 210:
7014 
7015 /* Line 1806 of yacc.c */
7016 #line 2045 "ripper.y"
7017  {
7018 #if 0
7019  value_expr((yyvsp[(1) - (3)].val));
7020  value_expr((yyvsp[(3) - (3)].val));
7021  (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7022  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7023  nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7025  }
7026 #endif
7027  (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7028 
7029  }
7030  break;
7031 
7032  case 211:
7033 
7034 /* Line 1806 of yacc.c */
7035 #line 2059 "ripper.y"
7036  {
7037 #if 0
7038  value_expr((yyvsp[(1) - (3)].val));
7039  value_expr((yyvsp[(3) - (3)].val));
7040  (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7041  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7042  nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7044  }
7045 #endif
7046  (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7047 
7048  }
7049  break;
7050 
7051  case 212:
7052 
7053 /* Line 1806 of yacc.c */
7054 #line 2073 "ripper.y"
7055  {
7056 #if 0
7057  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
7058 #endif
7059  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val));
7060 
7061  }
7062  break;
7063 
7064  case 213:
7065 
7066 /* Line 1806 of yacc.c */
7067 #line 2081 "ripper.y"
7068  {
7069 #if 0
7070  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
7071 #endif
7072  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val));
7073 
7074  }
7075  break;
7076 
7077  case 214:
7078 
7079 /* Line 1806 of yacc.c */
7080 #line 2089 "ripper.y"
7081  {
7082 #if 0
7083  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
7084 #endif
7085  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val));
7086 
7087  }
7088  break;
7089 
7090  case 215:
7091 
7092 /* Line 1806 of yacc.c */
7093 #line 2097 "ripper.y"
7094  {
7095 #if 0
7096  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
7097 #endif
7098  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val));
7099 
7100  }
7101  break;
7102 
7103  case 216:
7104 
7105 /* Line 1806 of yacc.c */
7106 #line 2105 "ripper.y"
7107  {
7108 #if 0
7109  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
7110 #endif
7111  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val));
7112 
7113  }
7114  break;
7115 
7116  case 217:
7117 
7118 /* Line 1806 of yacc.c */
7119 #line 2113 "ripper.y"
7120  {
7121 #if 0
7122  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
7123 #endif
7124  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val));
7125 
7126  }
7127  break;
7128 
7129  case 218:
7130 
7131 /* Line 1806 of yacc.c */
7132 #line 2121 "ripper.y"
7133  {
7134 #if 0
7135  (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
7136 #endif
7137  (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
7138  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
7139 
7140  }
7141  break;
7142 
7143  case 219:
7144 
7145 /* Line 1806 of yacc.c */
7146 #line 2130 "ripper.y"
7147  {
7148 #if 0
7149  (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
7150 #endif
7151  (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
7152  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
7153 
7154  }
7155  break;
7156 
7157  case 220:
7158 
7159 /* Line 1806 of yacc.c */
7160 #line 2139 "ripper.y"
7161  {
7162 #if 0
7163  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
7164 #endif
7165  (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val));
7166 
7167  }
7168  break;
7169 
7170  case 221:
7171 
7172 /* Line 1806 of yacc.c */
7173 #line 2147 "ripper.y"
7174  {
7175 #if 0
7176  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
7177 #endif
7178  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
7179 
7180  }
7181  break;
7182 
7183  case 222:
7184 
7185 /* Line 1806 of yacc.c */
7186 #line 2155 "ripper.y"
7187  {
7188 #if 0
7189  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val));
7190 #endif
7191  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('|'), (yyvsp[(3) - (3)].val));
7192 
7193  }
7194  break;
7195 
7196  case 223:
7197 
7198 /* Line 1806 of yacc.c */
7199 #line 2163 "ripper.y"
7200  {
7201 #if 0
7202  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
7203 #endif
7204  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val));
7205 
7206  }
7207  break;
7208 
7209  case 224:
7210 
7211 /* Line 1806 of yacc.c */
7212 #line 2171 "ripper.y"
7213  {
7214 #if 0
7215  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
7216 #endif
7217  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val));
7218 
7219  }
7220  break;
7221 
7222  case 225:
7223 
7224 /* Line 1806 of yacc.c */
7225 #line 2179 "ripper.y"
7226  {
7227 #if 0
7228  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
7229 #endif
7230  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val));
7231 
7232  }
7233  break;
7234 
7235  case 226:
7236 
7237 /* Line 1806 of yacc.c */
7238 #line 2187 "ripper.y"
7239  {
7240 #if 0
7241  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
7242 #endif
7243  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val));
7244 
7245  }
7246  break;
7247 
7248  case 227:
7249 
7250 /* Line 1806 of yacc.c */
7251 #line 2195 "ripper.y"
7252  {
7253 #if 0
7254  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
7255 #endif
7256  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val));
7257 
7258  }
7259  break;
7260 
7261  case 228:
7262 
7263 /* Line 1806 of yacc.c */
7264 #line 2203 "ripper.y"
7265  {
7266 #if 0
7267  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
7268 #endif
7269  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val));
7270 
7271  }
7272  break;
7273 
7274  case 229:
7275 
7276 /* Line 1806 of yacc.c */
7277 #line 2211 "ripper.y"
7278  {
7279 #if 0
7280  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
7281 #endif
7282  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val));
7283 
7284  }
7285  break;
7286 
7287  case 230:
7288 
7289 /* Line 1806 of yacc.c */
7290 #line 2219 "ripper.y"
7291  {
7292 #if 0
7293  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
7294 #endif
7295  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val));
7296 
7297  }
7298  break;
7299 
7300  case 231:
7301 
7302 /* Line 1806 of yacc.c */
7303 #line 2227 "ripper.y"
7304  {
7305 #if 0
7306  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
7307 #endif
7308  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val));
7309 
7310  }
7311  break;
7312 
7313  case 232:
7314 
7315 /* Line 1806 of yacc.c */
7316 #line 2235 "ripper.y"
7317  {
7318 #if 0
7319  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
7320 #endif
7321  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val));
7322 
7323  }
7324  break;
7325 
7326  case 233:
7327 
7328 /* Line 1806 of yacc.c */
7329 #line 2243 "ripper.y"
7330  {
7331 #if 0
7332  (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7333  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].val)->nd_lit, T_REGEXP)) {
7334  (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val));
7335  }
7336 #endif
7337  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val));
7338 
7339  }
7340  break;
7341 
7342  case 234:
7343 
7344 /* Line 1806 of yacc.c */
7345 #line 2254 "ripper.y"
7346  {
7347 #if 0
7348  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val));
7349 #endif
7350  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!~"), (yyvsp[(3) - (3)].val));
7351 
7352  }
7353  break;
7354 
7355  case 235:
7356 
7357 /* Line 1806 of yacc.c */
7358 #line 2262 "ripper.y"
7359  {
7360 #if 0
7361  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
7362 #endif
7363  (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val));
7364 
7365  }
7366  break;
7367 
7368  case 236:
7369 
7370 /* Line 1806 of yacc.c */
7371 #line 2270 "ripper.y"
7372  {
7373 #if 0
7374  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
7375 #endif
7376  (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val));
7377 
7378  }
7379  break;
7380 
7381  case 237:
7382 
7383 /* Line 1806 of yacc.c */
7384 #line 2278 "ripper.y"
7385  {
7386 #if 0
7387  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val));
7388 #endif
7389  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<<"), (yyvsp[(3) - (3)].val));
7390 
7391  }
7392  break;
7393 
7394  case 238:
7395 
7396 /* Line 1806 of yacc.c */
7397 #line 2286 "ripper.y"
7398  {
7399 #if 0
7400  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val));
7401 #endif
7402  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">>"), (yyvsp[(3) - (3)].val));
7403 
7404  }
7405  break;
7406 
7407  case 239:
7408 
7409 /* Line 1806 of yacc.c */
7410 #line 2294 "ripper.y"
7411  {
7412 #if 0
7413  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7414 #endif
7415  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val));
7416 
7417  }
7418  break;
7419 
7420  case 240:
7421 
7422 /* Line 1806 of yacc.c */
7423 #line 2302 "ripper.y"
7424  {
7425 #if 0
7426  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7427 #endif
7428  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val));
7429 
7430  }
7431  break;
7432 
7433  case 241:
7434 
7435 /* Line 1806 of yacc.c */
7436 #line 2309 "ripper.y"
7437  {in_defined = 1;}
7438  break;
7439 
7440  case 242:
7441 
7442 /* Line 1806 of yacc.c */
7443 #line 2310 "ripper.y"
7444  {
7445 #if 0
7446  in_defined = 0;
7447  (yyval.val) = NEW_DEFINED((yyvsp[(4) - (4)].val));
7448 #endif
7449  in_defined = 0;
7450  (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val));
7451 
7452  }
7453  break;
7454 
7455  case 243:
7456 
7457 /* Line 1806 of yacc.c */
7458 #line 2320 "ripper.y"
7459  {
7460 #if 0
7461  value_expr((yyvsp[(1) - (6)].val));
7462  (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7463  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
7464 #endif
7465  (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7466 
7467  }
7468  break;
7469 
7470  case 244:
7471 
7472 /* Line 1806 of yacc.c */
7473 #line 2330 "ripper.y"
7474  {
7475  (yyval.val) = (yyvsp[(1) - (1)].val);
7476  }
7477  break;
7478 
7479  case 245:
7480 
7481 /* Line 1806 of yacc.c */
7482 #line 2336 "ripper.y"
7483  {
7484 #if 0
7485  value_expr((yyvsp[(1) - (1)].val));
7486  (yyval.val) = (yyvsp[(1) - (1)].val);
7487  if (!(yyval.val)) (yyval.val) = NEW_NIL();
7488 #endif
7489  (yyval.val) = (yyvsp[(1) - (1)].val);
7490 
7491  }
7492  break;
7493 
7494  case 247:
7495 
7496 /* Line 1806 of yacc.c */
7497 #line 2349 "ripper.y"
7498  {
7499  (yyval.val) = (yyvsp[(1) - (2)].val);
7500  }
7501  break;
7502 
7503  case 248:
7504 
7505 /* Line 1806 of yacc.c */
7506 #line 2353 "ripper.y"
7507  {
7508 #if 0
7509  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7510 #endif
7511  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7512 
7513  }
7514  break;
7515 
7516  case 249:
7517 
7518 /* Line 1806 of yacc.c */
7519 #line 2361 "ripper.y"
7520  {
7521 #if 0
7522  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7523 #endif
7524  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7525 
7526  }
7527  break;
7528 
7529  case 250:
7530 
7531 /* Line 1806 of yacc.c */
7532 #line 2371 "ripper.y"
7533  {
7534 #if 0
7535  (yyval.val) = (yyvsp[(2) - (3)].val);
7536 #endif
7537  (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
7538 
7539  }
7540  break;
7541 
7542  case 255:
7543 
7544 /* Line 1806 of yacc.c */
7545 #line 2387 "ripper.y"
7546  {
7547  (yyval.val) = (yyvsp[(1) - (2)].val);
7548  }
7549  break;
7550 
7551  case 256:
7552 
7553 /* Line 1806 of yacc.c */
7554 #line 2391 "ripper.y"
7555  {
7556 #if 0
7557  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7558 #endif
7559  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7560 
7561  }
7562  break;
7563 
7564  case 257:
7565 
7566 /* Line 1806 of yacc.c */
7567 #line 2399 "ripper.y"
7568  {
7569 #if 0
7570  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7571 #endif
7572  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7573 
7574  }
7575  break;
7576 
7577  case 258:
7578 
7579 /* Line 1806 of yacc.c */
7580 #line 2409 "ripper.y"
7581  {
7582 #if 0
7583  value_expr((yyvsp[(1) - (1)].val));
7584  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7585 #endif
7586  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7587 
7588  }
7589  break;
7590 
7591  case 259:
7592 
7593 /* Line 1806 of yacc.c */
7594 #line 2418 "ripper.y"
7595  {
7596 #if 0
7597  (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7598 #endif
7599  (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7600 
7601  }
7602  break;
7603 
7604  case 260:
7605 
7606 /* Line 1806 of yacc.c */
7607 #line 2426 "ripper.y"
7608  {
7609 #if 0
7610  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7611  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
7612 #endif
7613  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7614  (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
7615 
7616  }
7617  break;
7618 
7619  case 261:
7620 
7621 /* Line 1806 of yacc.c */
7622 #line 2436 "ripper.y"
7623  {
7624 #if 0
7625  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7626  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
7627 #endif
7628  (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
7629 
7630  }
7631  break;
7632 
7633  case 262:
7634 
7635 /* Line 1806 of yacc.c */
7636 #line 2447 "ripper.y"
7637  {
7638  (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
7639  }
7640  break;
7641 
7642  case 263:
7643 
7644 /* Line 1806 of yacc.c */
7645 #line 2453 "ripper.y"
7646  {
7647  (yyval.val) = cmdarg_stack;
7648  CMDARG_PUSH(1);
7649  }
7650  break;
7651 
7652  case 264:
7653 
7654 /* Line 1806 of yacc.c */
7655 #line 2458 "ripper.y"
7656  {
7657  /* CMDARG_POP() */
7658  cmdarg_stack = (yyvsp[(1) - (2)].val);
7659  (yyval.val) = (yyvsp[(2) - (2)].val);
7660  }
7661  break;
7662 
7663  case 265:
7664 
7665 /* Line 1806 of yacc.c */
7666 #line 2466 "ripper.y"
7667  {
7668 #if 0
7669  (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
7670 #endif
7671  (yyval.val) = (yyvsp[(2) - (2)].val);
7672 
7673  }
7674  break;
7675 
7676  case 266:
7677 
7678 /* Line 1806 of yacc.c */
7679 #line 2476 "ripper.y"
7680  {
7681  (yyval.val) = (yyvsp[(2) - (2)].val);
7682  }
7683  break;
7684 
7685  case 267:
7686 
7687 /* Line 1806 of yacc.c */
7688 #line 2480 "ripper.y"
7689  {
7690  (yyval.val) = 0;
7691  }
7692  break;
7693 
7694  case 268:
7695 
7696 /* Line 1806 of yacc.c */
7697 #line 2486 "ripper.y"
7698  {
7699 #if 0
7700  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7701 #endif
7702  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7703 
7704  }
7705  break;
7706 
7707  case 269:
7708 
7709 /* Line 1806 of yacc.c */
7710 #line 2494 "ripper.y"
7711  {
7712 #if 0
7713  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7714 #endif
7715  (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
7716 
7717  }
7718  break;
7719 
7720  case 270:
7721 
7722 /* Line 1806 of yacc.c */
7723 #line 2502 "ripper.y"
7724  {
7725 #if 0
7726  NODE *n1;
7727  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7728  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7729  }
7730  else {
7731  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7732  }
7733 #endif
7734  (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7735 
7736  }
7737  break;
7738 
7739  case 271:
7740 
7741 /* Line 1806 of yacc.c */
7742 #line 2516 "ripper.y"
7743  {
7744 #if 0
7745  NODE *n1;
7746  if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7747  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7748  }
7749  else {
7750  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7751  }
7752 #endif
7753  (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7754 
7755  }
7756  break;
7757 
7758  case 272:
7759 
7760 /* Line 1806 of yacc.c */
7761 #line 2532 "ripper.y"
7762  {
7763 #if 0
7764  NODE *n1;
7765  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7766  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7767  }
7768  else {
7769  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7770  }
7771 #endif
7772  (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
7773 
7774  }
7775  break;
7776 
7777  case 273:
7778 
7779 /* Line 1806 of yacc.c */
7780 #line 2546 "ripper.y"
7781  {
7782 #if 0
7783  NODE *n1;
7784  if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
7785  (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7786  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7787  }
7788  else {
7789  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7790  }
7791 #endif
7792  (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
7793 
7794  }
7795  break;
7796 
7797  case 274:
7798 
7799 /* Line 1806 of yacc.c */
7800 #line 2561 "ripper.y"
7801  {
7802 #if 0
7803  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7804 #endif
7805  (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
7806 
7807  }
7808  break;
7809 
7810  case 285:
7811 
7812 /* Line 1806 of yacc.c */
7813 #line 2581 "ripper.y"
7814  {
7815 #if 0
7816  (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
7817 #endif
7818  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
7819 
7820  }
7821  break;
7822 
7823  case 286:
7824 
7825 /* Line 1806 of yacc.c */
7826 #line 2589 "ripper.y"
7827  {
7828  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7829  cmdarg_stack = 0;
7830 #if 0
7831  (yyval.num) = ruby_sourceline;
7832 #endif
7833 
7834  }
7835  break;
7836 
7837  case 287:
7838 
7839 /* Line 1806 of yacc.c */
7840 #line 2599 "ripper.y"
7841  {
7842  cmdarg_stack = (yyvsp[(1) - (4)].val);
7843 #if 0
7844  if ((yyvsp[(3) - (4)].val) == NULL) {
7845  (yyval.val) = NEW_NIL();
7846  }
7847  else {
7848  if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE ||
7849  nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE)
7850  nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
7851  (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val));
7852  }
7853  nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
7854 #endif
7855  (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
7856 
7857  }
7858  break;
7859 
7860  case 288:
7861 
7862 /* Line 1806 of yacc.c */
7863 #line 2616 "ripper.y"
7864  {lex_state = EXPR_ENDARG;}
7865  break;
7866 
7867  case 289:
7868 
7869 /* Line 1806 of yacc.c */
7870 #line 2617 "ripper.y"
7871  {
7872 #if 0
7873  (yyval.val) = 0;
7874 #endif
7875  (yyval.val) = dispatch1(paren, 0);
7876 
7877  }
7878  break;
7879 
7880  case 290:
7881 
7882 /* Line 1806 of yacc.c */
7883 #line 2625 "ripper.y"
7884  {
7885  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7886  cmdarg_stack = 0;
7887  }
7888  break;
7889 
7890  case 291:
7891 
7892 /* Line 1806 of yacc.c */
7893 #line 2629 "ripper.y"
7894  {lex_state = EXPR_ENDARG;}
7895  break;
7896 
7897  case 292:
7898 
7899 /* Line 1806 of yacc.c */
7900 #line 2630 "ripper.y"
7901  {
7902  cmdarg_stack = (yyvsp[(1) - (5)].val);
7903 #if 0
7904  (yyval.val) = (yyvsp[(3) - (5)].val);
7905 #endif
7906  (yyval.val) = dispatch1(paren, (yyvsp[(3) - (5)].val));
7907 
7908  }
7909  break;
7910 
7911  case 293:
7912 
7913 /* Line 1806 of yacc.c */
7914 #line 2639 "ripper.y"
7915  {
7916 #if 0
7917  (yyval.val) = (yyvsp[(2) - (3)].val);
7918 #endif
7919  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
7920 
7921  }
7922  break;
7923 
7924  case 294:
7925 
7926 /* Line 1806 of yacc.c */
7927 #line 2647 "ripper.y"
7928  {
7929 #if 0
7930  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7931 #endif
7932  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7933 
7934  }
7935  break;
7936 
7937  case 295:
7938 
7939 /* Line 1806 of yacc.c */
7940 #line 2655 "ripper.y"
7941  {
7942 #if 0
7943  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
7944 #endif
7945  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
7946 
7947  }
7948  break;
7949 
7950  case 296:
7951 
7952 /* Line 1806 of yacc.c */
7953 #line 2663 "ripper.y"
7954  {
7955 #if 0
7956  if ((yyvsp[(2) - (3)].val) == 0) {
7957  (yyval.val) = NEW_ZARRAY(); /* zero length array*/
7958  }
7959  else {
7960  (yyval.val) = (yyvsp[(2) - (3)].val);
7961  }
7962 #endif
7963  (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
7964 
7965  }
7966  break;
7967 
7968  case 297:
7969 
7970 /* Line 1806 of yacc.c */
7971 #line 2676 "ripper.y"
7972  {
7973 #if 0
7974  (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
7975 #endif
7976  (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
7977 
7978  }
7979  break;
7980 
7981  case 298:
7982 
7983 /* Line 1806 of yacc.c */
7984 #line 2684 "ripper.y"
7985  {
7986 #if 0
7987  (yyval.val) = NEW_RETURN(0);
7988 #endif
7989  (yyval.val) = dispatch0(return0);
7990 
7991  }
7992  break;
7993 
7994  case 299:
7995 
7996 /* Line 1806 of yacc.c */
7997 #line 2692 "ripper.y"
7998  {
7999 #if 0
8000  (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
8001 #endif
8002  (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
8003 
8004  }
8005  break;
8006 
8007  case 300:
8008 
8009 /* Line 1806 of yacc.c */
8010 #line 2700 "ripper.y"
8011  {
8012 #if 0
8013  (yyval.val) = NEW_YIELD(0);
8014 #endif
8015  (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
8016 
8017  }
8018  break;
8019 
8020  case 301:
8021 
8022 /* Line 1806 of yacc.c */
8023 #line 2708 "ripper.y"
8024  {
8025 #if 0
8026  (yyval.val) = NEW_YIELD(0);
8027 #endif
8028  (yyval.val) = dispatch0(yield0);
8029 
8030  }
8031  break;
8032 
8033  case 302:
8034 
8035 /* Line 1806 of yacc.c */
8036 #line 2715 "ripper.y"
8037  {in_defined = 1;}
8038  break;
8039 
8040  case 303:
8041 
8042 /* Line 1806 of yacc.c */
8043 #line 2716 "ripper.y"
8044  {
8045 #if 0
8046  in_defined = 0;
8047  (yyval.val) = NEW_DEFINED((yyvsp[(5) - (6)].val));
8048 #endif
8049  in_defined = 0;
8050  (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val));
8051 
8052  }
8053  break;
8054 
8055  case 304:
8056 
8057 /* Line 1806 of yacc.c */
8058 #line 2726 "ripper.y"
8059  {
8060 #if 0
8061  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
8062 #endif
8063  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val));
8064 
8065  }
8066  break;
8067 
8068  case 305:
8069 
8070 /* Line 1806 of yacc.c */
8071 #line 2734 "ripper.y"
8072  {
8073 #if 0
8074  (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
8075 #endif
8076  (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil);
8077 
8078  }
8079  break;
8080 
8081  case 306:
8082 
8083 /* Line 1806 of yacc.c */
8084 #line 2742 "ripper.y"
8085  {
8086 #if 0
8087  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
8088  (yyval.val) = (yyvsp[(2) - (2)].val);
8089 #endif
8090  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
8091  (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
8092 
8093  }
8094  break;
8095 
8096  case 308:
8097 
8098 /* Line 1806 of yacc.c */
8099 #line 2753 "ripper.y"
8100  {
8101 #if 0
8102  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
8103  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
8104  (yyval.val) = (yyvsp[(2) - (2)].val);
8105 #endif
8106  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
8107 
8108  }
8109  break;
8110 
8111  case 309:
8112 
8113 /* Line 1806 of yacc.c */
8114 #line 2763 "ripper.y"
8115  {
8116  (yyval.val) = (yyvsp[(2) - (2)].val);
8117  }
8118  break;
8119 
8120  case 310:
8121 
8122 /* Line 1806 of yacc.c */
8123 #line 2770 "ripper.y"
8124  {
8125 #if 0
8126  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8127  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8128 #endif
8129  (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8130 
8131  }
8132  break;
8133 
8134  case 311:
8135 
8136 /* Line 1806 of yacc.c */
8137 #line 2782 "ripper.y"
8138  {
8139 #if 0
8140  (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8141  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8142 #endif
8143  (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8144 
8145  }
8146  break;
8147 
8148  case 312:
8149 
8150 /* Line 1806 of yacc.c */
8151 #line 2790 "ripper.y"
8152  {COND_PUSH(1);}
8153  break;
8154 
8155  case 313:
8156 
8157 /* Line 1806 of yacc.c */
8158 #line 2790 "ripper.y"
8159  {COND_POP();}
8160  break;
8161 
8162  case 314:
8163 
8164 /* Line 1806 of yacc.c */
8165 #line 2793 "ripper.y"
8166  {
8167 #if 0
8168  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8169  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8170 #endif
8171  (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8172 
8173  }
8174  break;
8175 
8176  case 315:
8177 
8178 /* Line 1806 of yacc.c */
8179 #line 2801 "ripper.y"
8180  {COND_PUSH(1);}
8181  break;
8182 
8183  case 316:
8184 
8185 /* Line 1806 of yacc.c */
8186 #line 2801 "ripper.y"
8187  {COND_POP();}
8188  break;
8189 
8190  case 317:
8191 
8192 /* Line 1806 of yacc.c */
8193 #line 2804 "ripper.y"
8194  {
8195 #if 0
8196  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8197  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8198 #endif
8199  (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8200 
8201  }
8202  break;
8203 
8204  case 318:
8205 
8206 /* Line 1806 of yacc.c */
8207 #line 2815 "ripper.y"
8208  {
8209 #if 0
8210  (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8211  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8212 #endif
8213  (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8214 
8215  }
8216  break;
8217 
8218  case 319:
8219 
8220 /* Line 1806 of yacc.c */
8221 #line 2824 "ripper.y"
8222  {
8223 #if 0
8224  (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
8225 #endif
8226  (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
8227 
8228  }
8229  break;
8230 
8231  case 320:
8232 
8233 /* Line 1806 of yacc.c */
8234 #line 2832 "ripper.y"
8235  {COND_PUSH(1);}
8236  break;
8237 
8238  case 321:
8239 
8240 /* Line 1806 of yacc.c */
8241 #line 2834 "ripper.y"
8242  {COND_POP();}
8243  break;
8244 
8245  case 322:
8246 
8247 /* Line 1806 of yacc.c */
8248 #line 2837 "ripper.y"
8249  {
8250 #if 0
8251  /*
8252  * for a, b, c in e
8253  * #=>
8254  * e.each{|*x| a, b, c = x
8255  *
8256  * for a in e
8257  * #=>
8258  * e.each{|x| a, = x}
8259  */
8260  ID id = internal_id();
8261  ID *tbl = ALLOC_N(ID, 2);
8262  NODE *m = NEW_ARGS_AUX(0, 0);
8263  NODE *args, *scope;
8264 
8265  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) {
8266  /* if args.length == 1 && args[0].kind_of?(Array)
8267  * args = args[0]
8268  * end
8269  */
8270  NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
8271  NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
8272  m->nd_next = block_append(
8273  NEW_IF(
8275  NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
8276  idEq, one),
8277  NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero),
8278  rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
8279  0),
8280  NEW_DASGN_CURR(id,
8281  NEW_CALL(NEW_DVAR(id), idAREF, zero)),
8282  0),
8283  node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id)));
8284 
8285  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8286  }
8287  else {
8288  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN ||
8289  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN ||
8290  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) {
8291  (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id);
8292  m->nd_plen = 1;
8293  m->nd_next = (yyvsp[(2) - (9)].val);
8294  args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
8295  }
8296  else {
8297  m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id));
8298  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8299  }
8300  }
8301  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
8302  tbl[0] = 1; tbl[1] = id;
8303  (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope);
8304  fixpos((yyval.val), (yyvsp[(2) - (9)].val));
8305 #endif
8306  (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
8307 
8308  }
8309  break;
8310 
8311  case 323:
8312 
8313 /* Line 1806 of yacc.c */
8314 #line 2898 "ripper.y"
8315  {
8316  if (in_def || in_single)
8317  yyerror("class definition in method body");
8318  local_push(0);
8319 #if 0
8320  (yyval.num) = ruby_sourceline;
8321 #endif
8322 
8323  }
8324  break;
8325 
8326  case 324:
8327 
8328 /* Line 1806 of yacc.c */
8329 #line 2909 "ripper.y"
8330  {
8331 #if 0
8332  (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
8333  nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
8334 #endif
8335  (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
8336 
8337  local_pop();
8338  }
8339  break;
8340 
8341  case 325:
8342 
8343 /* Line 1806 of yacc.c */
8344 #line 2919 "ripper.y"
8345  {
8346  (yyval.num) = in_def;
8347  in_def = 0;
8348  }
8349  break;
8350 
8351  case 326:
8352 
8353 /* Line 1806 of yacc.c */
8354 #line 2924 "ripper.y"
8355  {
8356  (yyval.num) = in_single;
8357  in_single = 0;
8358  local_push(0);
8359  }
8360  break;
8361 
8362  case 327:
8363 
8364 /* Line 1806 of yacc.c */
8365 #line 2931 "ripper.y"
8366  {
8367 #if 0
8368  (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8369  fixpos((yyval.val), (yyvsp[(3) - (8)].val));
8370 #endif
8371  (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8372 
8373  local_pop();
8374  in_def = (yyvsp[(4) - (8)].num);
8375  in_single = (yyvsp[(6) - (8)].num);
8376  }
8377  break;
8378 
8379  case 328:
8380 
8381 /* Line 1806 of yacc.c */
8382 #line 2943 "ripper.y"
8383  {
8384  if (in_def || in_single)
8385  yyerror("module definition in method body");
8386  local_push(0);
8387 #if 0
8388  (yyval.num) = ruby_sourceline;
8389 #endif
8390 
8391  }
8392  break;
8393 
8394  case 329:
8395 
8396 /* Line 1806 of yacc.c */
8397 #line 2954 "ripper.y"
8398  {
8399 #if 0
8400  (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8401  nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
8402 #endif
8403  (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8404 
8405  local_pop();
8406  }
8407  break;
8408 
8409  case 330:
8410 
8411 /* Line 1806 of yacc.c */
8412 #line 2964 "ripper.y"
8413  {
8414  (yyval.id) = cur_mid;
8415  cur_mid = (yyvsp[(2) - (2)].val);
8416  in_def++;
8417  local_push(0);
8418  }
8419  break;
8420 
8421  case 331:
8422 
8423 /* Line 1806 of yacc.c */
8424 #line 2973 "ripper.y"
8425  {
8426 #if 0
8427  NODE *body = remove_begin((yyvsp[(5) - (6)].val));
8428  reduce_nodes(&body);
8429  (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE);
8430  nd_set_line((yyval.val), (yyvsp[(1) - (6)].num));
8431 #endif
8432  (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8433 
8434  local_pop();
8435  in_def--;
8436  cur_mid = (yyvsp[(3) - (6)].id);
8437  }
8438  break;
8439 
8440  case 332:
8441 
8442 /* Line 1806 of yacc.c */
8443 #line 2986 "ripper.y"
8444  {lex_state = EXPR_FNAME;}
8445  break;
8446 
8447  case 333:
8448 
8449 /* Line 1806 of yacc.c */
8450 #line 2987 "ripper.y"
8451  {
8452  in_single++;
8453  lex_state = EXPR_ENDFN; /* force for args */
8454  local_push(0);
8455  }
8456  break;
8457 
8458  case 334:
8459 
8460 /* Line 1806 of yacc.c */
8461 #line 2995 "ripper.y"
8462  {
8463 #if 0
8464  NODE *body = remove_begin((yyvsp[(8) - (9)].val));
8465  reduce_nodes(&body);
8466  (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
8467  nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
8468 #endif
8469  (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
8470 
8471  local_pop();
8472  in_single--;
8473  }
8474  break;
8475 
8476  case 335:
8477 
8478 /* Line 1806 of yacc.c */
8479 #line 3008 "ripper.y"
8480  {
8481 #if 0
8482  (yyval.val) = NEW_BREAK(0);
8483 #endif
8484  (yyval.val) = dispatch1(break, arg_new());
8485 
8486  }
8487  break;
8488 
8489  case 336:
8490 
8491 /* Line 1806 of yacc.c */
8492 #line 3016 "ripper.y"
8493  {
8494 #if 0
8495  (yyval.val) = NEW_NEXT(0);
8496 #endif
8497  (yyval.val) = dispatch1(next, arg_new());
8498 
8499  }
8500  break;
8501 
8502  case 337:
8503 
8504 /* Line 1806 of yacc.c */
8505 #line 3024 "ripper.y"
8506  {
8507 #if 0
8508  (yyval.val) = NEW_REDO();
8509 #endif
8510  (yyval.val) = dispatch0(redo);
8511 
8512  }
8513  break;
8514 
8515  case 338:
8516 
8517 /* Line 1806 of yacc.c */
8518 #line 3032 "ripper.y"
8519  {
8520 #if 0
8521  (yyval.val) = NEW_RETRY();
8522 #endif
8523  (yyval.val) = dispatch0(retry);
8524 
8525  }
8526  break;
8527 
8528  case 339:
8529 
8530 /* Line 1806 of yacc.c */
8531 #line 3042 "ripper.y"
8532  {
8533 #if 0
8534  value_expr((yyvsp[(1) - (1)].val));
8535  (yyval.val) = (yyvsp[(1) - (1)].val);
8536  if (!(yyval.val)) (yyval.val) = NEW_NIL();
8537 #endif
8538  (yyval.val) = (yyvsp[(1) - (1)].val);
8539 
8540  }
8541  break;
8542 
8543  case 340:
8544 
8545 /* Line 1806 of yacc.c */
8546 #line 3054 "ripper.y"
8547  {
8548  token_info_push("begin");
8549  }
8550  break;
8551 
8552  case 341:
8553 
8554 /* Line 1806 of yacc.c */
8555 #line 3060 "ripper.y"
8556  {
8557  token_info_push("if");
8558  }
8559  break;
8560 
8561  case 342:
8562 
8563 /* Line 1806 of yacc.c */
8564 #line 3066 "ripper.y"
8565  {
8566  token_info_push("unless");
8567  }
8568  break;
8569 
8570  case 343:
8571 
8572 /* Line 1806 of yacc.c */
8573 #line 3072 "ripper.y"
8574  {
8575  token_info_push("while");
8576  }
8577  break;
8578 
8579  case 344:
8580 
8581 /* Line 1806 of yacc.c */
8582 #line 3078 "ripper.y"
8583  {
8584  token_info_push("until");
8585  }
8586  break;
8587 
8588  case 345:
8589 
8590 /* Line 1806 of yacc.c */
8591 #line 3084 "ripper.y"
8592  {
8593  token_info_push("case");
8594  }
8595  break;
8596 
8597  case 346:
8598 
8599 /* Line 1806 of yacc.c */
8600 #line 3090 "ripper.y"
8601  {
8602  token_info_push("for");
8603  }
8604  break;
8605 
8606  case 347:
8607 
8608 /* Line 1806 of yacc.c */
8609 #line 3096 "ripper.y"
8610  {
8611  token_info_push("class");
8612  }
8613  break;
8614 
8615  case 348:
8616 
8617 /* Line 1806 of yacc.c */
8618 #line 3102 "ripper.y"
8619  {
8620  token_info_push("module");
8621  }
8622  break;
8623 
8624  case 349:
8625 
8626 /* Line 1806 of yacc.c */
8627 #line 3108 "ripper.y"
8628  {
8629  token_info_push("def");
8630 #if 0
8631  (yyval.num) = ruby_sourceline;
8632 #endif
8633 
8634  }
8635  break;
8636 
8637  case 350:
8638 
8639 /* Line 1806 of yacc.c */
8640 #line 3118 "ripper.y"
8641  {
8642  token_info_pop("end");
8643  }
8644  break;
8645 
8646  case 351:
8647 
8648 /* Line 1806 of yacc.c */
8649 #line 3126 "ripper.y"
8650  { (yyval.val) = Qnil; }
8651  break;
8652 
8653  case 353:
8654 
8655 /* Line 1806 of yacc.c */
8656 #line 3132 "ripper.y"
8657  { (yyval.val) = (yyvsp[(2) - (2)].val); }
8658  break;
8659 
8660  case 354:
8661 
8662 /* Line 1806 of yacc.c */
8663 #line 3139 "ripper.y"
8664  { (yyval.val) = Qnil; }
8665  break;
8666 
8667  case 357:
8668 
8669 /* Line 1806 of yacc.c */
8670 #line 3148 "ripper.y"
8671  {
8672 #if 0
8673  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
8674  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8675 #endif
8676  (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
8677 
8678  }
8679  break;
8680 
8681  case 359:
8682 
8683 /* Line 1806 of yacc.c */
8684 #line 3160 "ripper.y"
8685  {
8686 #if 0
8687  (yyval.val) = (yyvsp[(2) - (2)].val);
8688 #endif
8689  (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
8690 
8691  }
8692  break;
8693 
8694  case 362:
8695 
8696 /* Line 1806 of yacc.c */
8697 #line 3174 "ripper.y"
8698  {
8699  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
8700 #if 0
8701 #endif
8702  (yyval.val) = dispatch1(mlhs_paren, (yyval.val));
8703 
8704  }
8705  break;
8706 
8707  case 363:
8708 
8709 /* Line 1806 of yacc.c */
8710 #line 3182 "ripper.y"
8711  {
8712 #if 0
8713  (yyval.val) = (yyvsp[(2) - (3)].val);
8714 #endif
8715  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
8716 
8717  }
8718  break;
8719 
8720  case 364:
8721 
8722 /* Line 1806 of yacc.c */
8723 #line 3192 "ripper.y"
8724  {
8725 #if 0
8726  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
8727 #endif
8728  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
8729 
8730  }
8731  break;
8732 
8733  case 365:
8734 
8735 /* Line 1806 of yacc.c */
8736 #line 3200 "ripper.y"
8737  {
8738 #if 0
8739  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8740 #endif
8741  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8742 
8743  }
8744  break;
8745 
8746  case 366:
8747 
8748 /* Line 1806 of yacc.c */
8749 #line 3210 "ripper.y"
8750  {
8751 #if 0
8752  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
8753 #endif
8754  (yyval.val) = (yyvsp[(1) - (1)].val);
8755 
8756  }
8757  break;
8758 
8759  case 367:
8760 
8761 /* Line 1806 of yacc.c */
8762 #line 3218 "ripper.y"
8763  {
8764  (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
8765 #if 0
8766  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val));
8767 #endif
8768  (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
8769 
8770  }
8771  break;
8772 
8773  case 368:
8774 
8775 /* Line 1806 of yacc.c */
8776 #line 3227 "ripper.y"
8777  {
8778  (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
8779 #if 0
8780  (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val)));
8781 #endif
8782  (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
8783 
8784  }
8785  break;
8786 
8787  case 369:
8788 
8789 /* Line 1806 of yacc.c */
8790 #line 3236 "ripper.y"
8791  {
8792 #if 0
8793  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
8794 #endif
8795  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
8796 
8797  }
8798  break;
8799 
8800  case 370:
8801 
8802 /* Line 1806 of yacc.c */
8803 #line 3244 "ripper.y"
8804  {
8805 #if 0
8806  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
8807 #endif
8808  (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
8809 
8810  }
8811  break;
8812 
8813  case 371:
8814 
8815 /* Line 1806 of yacc.c */
8816 #line 3252 "ripper.y"
8817  {
8818  (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
8819 #if 0
8820  (yyval.val) = NEW_MASGN(0, (yyval.val));
8821 #endif
8822  (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
8823 
8824  }
8825  break;
8826 
8827  case 372:
8828 
8829 /* Line 1806 of yacc.c */
8830 #line 3261 "ripper.y"
8831  {
8832  (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
8833 #if 0
8834  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val)));
8835 #endif
8836  #if 0
8837  TODO: Check me
8838  #endif
8839  (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val));
8840 
8841  }
8842  break;
8843 
8844  case 373:
8845 
8846 /* Line 1806 of yacc.c */
8847 #line 3273 "ripper.y"
8848  {
8849 #if 0
8850  (yyval.val) = NEW_MASGN(0, -1);
8851 #endif
8852  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8853 
8854  }
8855  break;
8856 
8857  case 374:
8858 
8859 /* Line 1806 of yacc.c */
8860 #line 3281 "ripper.y"
8861  {
8862 #if 0
8863  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
8864 #endif
8865  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8866 
8867  }
8868  break;
8869 
8870  case 375:
8871 
8872 /* Line 1806 of yacc.c */
8873 #line 3292 "ripper.y"
8874  {
8875  (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
8876  }
8877  break;
8878 
8879  case 376:
8880 
8881 /* Line 1806 of yacc.c */
8882 #line 3296 "ripper.y"
8883  {
8884  (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
8885  }
8886  break;
8887 
8888  case 377:
8889 
8890 /* Line 1806 of yacc.c */
8891 #line 3300 "ripper.y"
8892  {
8893  (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
8894  }
8895  break;
8896 
8897  case 378:
8898 
8899 /* Line 1806 of yacc.c */
8900 #line 3304 "ripper.y"
8901  {
8902  (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
8903  }
8904  break;
8905 
8906  case 379:
8907 
8908 /* Line 1806 of yacc.c */
8909 #line 3310 "ripper.y"
8910  {
8911  (yyval.val) = (yyvsp[(2) - (2)].val);
8912  }
8913  break;
8914 
8915  case 380:
8916 
8917 /* Line 1806 of yacc.c */
8918 #line 3314 "ripper.y"
8919  {
8920  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
8921  }
8922  break;
8923 
8924  case 381:
8925 
8926 /* Line 1806 of yacc.c */
8927 #line 3320 "ripper.y"
8928  {
8929  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
8930  }
8931  break;
8932 
8933  case 382:
8934 
8935 /* Line 1806 of yacc.c */
8936 #line 3324 "ripper.y"
8937  {
8938  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
8939  }
8940  break;
8941 
8942  case 383:
8943 
8944 /* Line 1806 of yacc.c */
8945 #line 3328 "ripper.y"
8946  {
8947  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
8948  }
8949  break;
8950 
8951  case 384:
8952 
8953 /* Line 1806 of yacc.c */
8954 #line 3332 "ripper.y"
8955  {
8956  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8957  }
8958  break;
8959 
8960  case 385:
8961 
8962 /* Line 1806 of yacc.c */
8963 #line 3336 "ripper.y"
8964  {
8965  (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
8966  }
8967  break;
8968 
8969  case 386:
8970 
8971 /* Line 1806 of yacc.c */
8972 #line 3340 "ripper.y"
8973  {
8974  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
8975 #if 0
8976 #endif
8977  dispatch1(excessed_comma, (yyval.val));
8978 
8979  }
8980  break;
8981 
8982  case 387:
8983 
8984 /* Line 1806 of yacc.c */
8985 #line 3348 "ripper.y"
8986  {
8987  (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8988  }
8989  break;
8990 
8991  case 388:
8992 
8993 /* Line 1806 of yacc.c */
8994 #line 3352 "ripper.y"
8995  {
8996  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
8997  }
8998  break;
8999 
9000  case 389:
9001 
9002 /* Line 1806 of yacc.c */
9003 #line 3356 "ripper.y"
9004  {
9005  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
9006  }
9007  break;
9008 
9009  case 390:
9010 
9011 /* Line 1806 of yacc.c */
9012 #line 3360 "ripper.y"
9013  {
9014  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9015  }
9016  break;
9017 
9018  case 391:
9019 
9020 /* Line 1806 of yacc.c */
9021 #line 3364 "ripper.y"
9022  {
9023  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
9024  }
9025  break;
9026 
9027  case 392:
9028 
9029 /* Line 1806 of yacc.c */
9030 #line 3368 "ripper.y"
9031  {
9032  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9033  }
9034  break;
9035 
9036  case 393:
9037 
9038 /* Line 1806 of yacc.c */
9039 #line 3372 "ripper.y"
9040  {
9041  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
9042  }
9043  break;
9044 
9045  case 394:
9046 
9047 /* Line 1806 of yacc.c */
9048 #line 3376 "ripper.y"
9049  {
9050  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9051  }
9052  break;
9053 
9054  case 395:
9055 
9056 /* Line 1806 of yacc.c */
9057 #line 3380 "ripper.y"
9058  {
9059  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
9060  }
9061  break;
9062 
9063  case 397:
9064 
9065 /* Line 1806 of yacc.c */
9066 #line 3387 "ripper.y"
9067  {
9068  command_start = TRUE;
9069  }
9070  break;
9071 
9072  case 398:
9073 
9074 /* Line 1806 of yacc.c */
9075 #line 3393 "ripper.y"
9076  {
9077 #if 0
9078  (yyval.val) = 0;
9079 #endif
9080  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9081  escape_Qundef((yyvsp[(2) - (3)].val)));
9082 
9083  }
9084  break;
9085 
9086  case 399:
9087 
9088 /* Line 1806 of yacc.c */
9089 #line 3402 "ripper.y"
9090  {
9091 #if 0
9092  (yyval.val) = 0;
9093 #endif
9094  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9095  Qnil);
9096 
9097  }
9098  break;
9099 
9100  case 400:
9101 
9102 /* Line 1806 of yacc.c */
9103 #line 3411 "ripper.y"
9104  {
9105 #if 0
9106  (yyval.val) = (yyvsp[(2) - (4)].val);
9107 #endif
9108  (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
9109 
9110  }
9111  break;
9112 
9113  case 401:
9114 
9115 /* Line 1806 of yacc.c */
9116 #line 3422 "ripper.y"
9117  {
9118  (yyval.val) = 0;
9119  }
9120  break;
9121 
9122  case 402:
9123 
9124 /* Line 1806 of yacc.c */
9125 #line 3426 "ripper.y"
9126  {
9127 #if 0
9128  (yyval.val) = 0;
9129 #endif
9130  (yyval.val) = (yyvsp[(3) - (4)].val);
9131 
9132  }
9133  break;
9134 
9135  case 403:
9136 
9137 /* Line 1806 of yacc.c */
9138 #line 3438 "ripper.y"
9139  {
9140  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9141  }
9142  break;
9143 
9144  case 404:
9145 
9146 /* Line 1806 of yacc.c */
9147 #line 3445 "ripper.y"
9148  {
9149  rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
9150  }
9151  break;
9152 
9153  case 405:
9154 
9155 /* Line 1806 of yacc.c */
9156 #line 3452 "ripper.y"
9157  {
9158  new_bv(get_id((yyvsp[(1) - (1)].val)));
9159 #if 0
9160 #endif
9161  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
9162 
9163  }
9164  break;
9165 
9166  case 406:
9167 
9168 /* Line 1806 of yacc.c */
9169 #line 3460 "ripper.y"
9170  {
9171  (yyval.val) = 0;
9172  }
9173  break;
9174 
9175  case 407:
9176 
9177 /* Line 1806 of yacc.c */
9178 #line 3465 "ripper.y"
9179  {
9180  (yyval.vars) = dyna_push();
9181  }
9182  break;
9183 
9184  case 408:
9185 
9186 /* Line 1806 of yacc.c */
9187 #line 3468 "ripper.y"
9188  {
9189  (yyval.num) = lpar_beg;
9190  lpar_beg = ++paren_nest;
9191  }
9192  break;
9193 
9194  case 409:
9195 
9196 /* Line 1806 of yacc.c */
9197 #line 3473 "ripper.y"
9198  {
9199  (yyval.num) = ruby_sourceline;
9200  }
9201  break;
9202 
9203  case 410:
9204 
9205 /* Line 1806 of yacc.c */
9206 #line 3477 "ripper.y"
9207  {
9208  lpar_beg = (yyvsp[(2) - (5)].num);
9209 #if 0
9210  (yyval.val) = NEW_LAMBDA((yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9211  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9212 #endif
9213  (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9214 
9215  dyna_pop((yyvsp[(1) - (5)].vars));
9216  }
9217  break;
9218 
9219  case 411:
9220 
9221 /* Line 1806 of yacc.c */
9222 #line 3490 "ripper.y"
9223  {
9224 #if 0
9225  (yyval.val) = (yyvsp[(2) - (4)].val);
9226 #endif
9227  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
9228 
9229  }
9230  break;
9231 
9232  case 412:
9233 
9234 /* Line 1806 of yacc.c */
9235 #line 3498 "ripper.y"
9236  {
9237 #if 0
9238  (yyval.val) = (yyvsp[(1) - (1)].val);
9239 #endif
9240  (yyval.val) = (yyvsp[(1) - (1)].val);
9241 
9242  }
9243  break;
9244 
9245  case 413:
9246 
9247 /* Line 1806 of yacc.c */
9248 #line 3508 "ripper.y"
9249  {
9250  (yyval.val) = (yyvsp[(2) - (3)].val);
9251  }
9252  break;
9253 
9254  case 414:
9255 
9256 /* Line 1806 of yacc.c */
9257 #line 3512 "ripper.y"
9258  {
9259  (yyval.val) = (yyvsp[(2) - (3)].val);
9260  }
9261  break;
9262 
9263  case 415:
9264 
9265 /* Line 1806 of yacc.c */
9266 #line 3518 "ripper.y"
9267  {
9268  (yyvsp[(1) - (1)].vars) = dyna_push();
9269 #if 0
9270  (yyval.num) = ruby_sourceline;
9271 #endif
9272  }
9273  break;
9274 
9275  case 416:
9276 
9277 /* Line 1806 of yacc.c */
9278 #line 3527 "ripper.y"
9279  {
9280 #if 0
9281  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9282  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9283 #endif
9284  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9285 
9286  dyna_pop((yyvsp[(1) - (5)].vars));
9287  }
9288  break;
9289 
9290  case 417:
9291 
9292 /* Line 1806 of yacc.c */
9293 #line 3539 "ripper.y"
9294  {
9295 #if 0
9296  if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
9297  compile_error(PARSER_ARG "block given to yield");
9298  }
9299  else {
9300  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
9301  }
9302  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
9303  (yyval.val) = (yyvsp[(2) - (2)].val);
9304  fixpos((yyval.val), (yyvsp[(1) - (2)].val));
9305 #endif
9306  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9307 
9308  }
9309  break;
9310 
9311  case 418:
9312 
9313 /* Line 1806 of yacc.c */
9314 #line 3555 "ripper.y"
9315  {
9316 #if 0
9317  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9318 #endif
9319  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
9320  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9321 
9322  }
9323  break;
9324 
9325  case 419:
9326 
9327 /* Line 1806 of yacc.c */
9328 #line 3564 "ripper.y"
9329  {
9330 #if 0
9331  block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9332  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9333  (yyval.val) = (yyvsp[(5) - (5)].val);
9334  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
9335 #endif
9336  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9337  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
9338 
9339  }
9340  break;
9341 
9342  case 420:
9343 
9344 /* Line 1806 of yacc.c */
9345 #line 3576 "ripper.y"
9346  {
9347 #if 0
9348  block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9349  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9350  (yyval.val) = (yyvsp[(5) - (5)].val);
9351  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
9352 #endif
9353  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9354  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
9355 
9356  }
9357  break;
9358 
9359  case 421:
9360 
9361 /* Line 1806 of yacc.c */
9362 #line 3590 "ripper.y"
9363  {
9364 #if 0
9365  (yyval.val) = (yyvsp[(1) - (2)].val);
9366  (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
9367 #endif
9368  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
9369 
9370  }
9371  break;
9372 
9373  case 422:
9374 
9375 /* Line 1806 of yacc.c */
9376 #line 3599 "ripper.y"
9377  {
9378 #if 0
9379  (yyval.num) = ruby_sourceline;
9380 #endif
9381  }
9382  break;
9383 
9384  case 423:
9385 
9386 /* Line 1806 of yacc.c */
9387 #line 3605 "ripper.y"
9388  {
9389 #if 0
9390  (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9391  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9392 #endif
9393  (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
9394  (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
9395 
9396  }
9397  break;
9398 
9399  case 424:
9400 
9401 /* Line 1806 of yacc.c */
9402 #line 3615 "ripper.y"
9403  {
9404 #if 0
9405  (yyval.num) = ruby_sourceline;
9406 #endif
9407  }
9408  break;
9409 
9410  case 425:
9411 
9412 /* Line 1806 of yacc.c */
9413 #line 3621 "ripper.y"
9414  {
9415 #if 0
9416  (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9417  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9418 #endif
9419  (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
9420  (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
9421 
9422  }
9423  break;
9424 
9425  case 426:
9426 
9427 /* Line 1806 of yacc.c */
9428 #line 3631 "ripper.y"
9429  {
9430 #if 0
9431  (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
9432 #endif
9433  (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
9434 
9435  }
9436  break;
9437 
9438  case 427:
9439 
9440 /* Line 1806 of yacc.c */
9441 #line 3639 "ripper.y"
9442  {
9443 #if 0
9444  (yyval.num) = ruby_sourceline;
9445 #endif
9446  }
9447  break;
9448 
9449  case 428:
9450 
9451 /* Line 1806 of yacc.c */
9452 #line 3645 "ripper.y"
9453  {
9454 #if 0
9455  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
9456  nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
9457 #endif
9458  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'),
9459  ripper_intern("call"));
9460  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9461 
9462  }
9463  break;
9464 
9465  case 429:
9466 
9467 /* Line 1806 of yacc.c */
9468 #line 3656 "ripper.y"
9469  {
9470 #if 0
9471  (yyval.num) = ruby_sourceline;
9472 #endif
9473  }
9474  break;
9475 
9476  case 430:
9477 
9478 /* Line 1806 of yacc.c */
9479 #line 3662 "ripper.y"
9480  {
9481 #if 0
9482  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
9483  nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
9484 #endif
9485  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"),
9486  ripper_intern("call"));
9487  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9488 
9489  }
9490  break;
9491 
9492  case 431:
9493 
9494 /* Line 1806 of yacc.c */
9495 #line 3673 "ripper.y"
9496  {
9497 #if 0
9498  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
9499 #endif
9500  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
9501 
9502  }
9503  break;
9504 
9505  case 432:
9506 
9507 /* Line 1806 of yacc.c */
9508 #line 3681 "ripper.y"
9509  {
9510 #if 0
9511  (yyval.val) = NEW_ZSUPER();
9512 #endif
9513  (yyval.val) = dispatch0(zsuper);
9514 
9515  }
9516  break;
9517 
9518  case 433:
9519 
9520 /* Line 1806 of yacc.c */
9521 #line 3689 "ripper.y"
9522  {
9523 #if 0
9524  if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
9525  (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val));
9526  else
9527  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val));
9528  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
9529 #endif
9530  (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
9531 
9532  }
9533  break;
9534 
9535  case 434:
9536 
9537 /* Line 1806 of yacc.c */
9538 #line 3703 "ripper.y"
9539  {
9540  (yyvsp[(1) - (1)].vars) = dyna_push();
9541 #if 0
9542  (yyval.num) = ruby_sourceline;
9543 #endif
9544 
9545  }
9546  break;
9547 
9548  case 435:
9549 
9550 /* Line 1806 of yacc.c */
9551 #line 3712 "ripper.y"
9552  {
9553 #if 0
9554  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9555  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9556 #endif
9557  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9558 
9559  dyna_pop((yyvsp[(1) - (5)].vars));
9560  }
9561  break;
9562 
9563  case 436:
9564 
9565 /* Line 1806 of yacc.c */
9566 #line 3722 "ripper.y"
9567  {
9568  (yyvsp[(1) - (1)].vars) = dyna_push();
9569 #if 0
9570  (yyval.num) = ruby_sourceline;
9571 #endif
9572 
9573  }
9574  break;
9575 
9576  case 437:
9577 
9578 /* Line 1806 of yacc.c */
9579 #line 3731 "ripper.y"
9580  {
9581 #if 0
9582  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9583  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9584 #endif
9585  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9586 
9587  dyna_pop((yyvsp[(1) - (5)].vars));
9588  }
9589  break;
9590 
9591  case 438:
9592 
9593 /* Line 1806 of yacc.c */
9594 #line 3745 "ripper.y"
9595  {
9596 #if 0
9597  (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9598 #endif
9599  (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
9600 
9601  }
9602  break;
9603 
9604  case 441:
9605 
9606 /* Line 1806 of yacc.c */
9607 #line 3761 "ripper.y"
9608  {
9609 #if 0
9610  if ((yyvsp[(3) - (6)].val)) {
9611  (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO());
9612  (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
9613  }
9614  (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9615  fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
9616 #endif
9617  (yyval.val) = dispatch4(rescue,
9618  escape_Qundef((yyvsp[(2) - (6)].val)),
9619  escape_Qundef((yyvsp[(3) - (6)].val)),
9620  escape_Qundef((yyvsp[(5) - (6)].val)),
9621  escape_Qundef((yyvsp[(6) - (6)].val)));
9622 
9623  }
9624  break;
9625 
9626  case 443:
9627 
9628 /* Line 1806 of yacc.c */
9629 #line 3781 "ripper.y"
9630  {
9631 #if 0
9632  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
9633 #endif
9634  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9635 
9636  }
9637  break;
9638 
9639  case 444:
9640 
9641 /* Line 1806 of yacc.c */
9642 #line 3789 "ripper.y"
9643  {
9644 #if 0
9645  if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
9646 #endif
9647  (yyval.val) = (yyvsp[(1) - (1)].val);
9648 
9649  }
9650  break;
9651 
9652  case 446:
9653 
9654 /* Line 1806 of yacc.c */
9655 #line 3800 "ripper.y"
9656  {
9657  (yyval.val) = (yyvsp[(2) - (2)].val);
9658  }
9659  break;
9660 
9661  case 448:
9662 
9663 /* Line 1806 of yacc.c */
9664 #line 3807 "ripper.y"
9665  {
9666 #if 0
9667  (yyval.val) = (yyvsp[(2) - (2)].val);
9668 #endif
9669  (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
9670 
9671  }
9672  break;
9673 
9674  case 451:
9675 
9676 /* Line 1806 of yacc.c */
9677 #line 3819 "ripper.y"
9678  {
9679 #if 0
9680  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
9681 #endif
9682  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
9683 
9684  }
9685  break;
9686 
9687  case 453:
9688 
9689 /* Line 1806 of yacc.c */
9690 #line 3830 "ripper.y"
9691  {
9692 #if 0
9693  NODE *node = (yyvsp[(1) - (1)].val);
9694  if (!node) {
9695  node = NEW_STR(STR_NEW0());
9696  }
9697  else {
9698  node = evstr2dstr(node);
9699  }
9700  (yyval.val) = node;
9701 #endif
9702  (yyval.val) = (yyvsp[(1) - (1)].val);
9703 
9704  }
9705  break;
9706 
9707  case 456:
9708 
9709 /* Line 1806 of yacc.c */
9710 #line 3849 "ripper.y"
9711  {
9712 #if 0
9713  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9714 #endif
9715  (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9716 
9717  }
9718  break;
9719 
9720  case 457:
9721 
9722 /* Line 1806 of yacc.c */
9723 #line 3859 "ripper.y"
9724  {
9725 #if 0
9726  (yyval.val) = (yyvsp[(2) - (3)].val);
9727 #endif
9728  (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val));
9729 
9730  }
9731  break;
9732 
9733  case 458:
9734 
9735 /* Line 1806 of yacc.c */
9736 #line 3869 "ripper.y"
9737  {
9738 #if 0
9739  NODE *node = (yyvsp[(2) - (3)].val);
9740  if (!node) {
9741  node = NEW_XSTR(STR_NEW0());
9742  }
9743  else {
9744  switch (nd_type(node)) {
9745  case NODE_STR:
9746  nd_set_type(node, NODE_XSTR);
9747  break;
9748  case NODE_DSTR:
9749  nd_set_type(node, NODE_DXSTR);
9750  break;
9751  default:
9752  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
9753  break;
9754  }
9755  }
9756  (yyval.val) = node;
9757 #endif
9758  (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val));
9759 
9760  }
9761  break;
9762 
9763  case 459:
9764 
9765 /* Line 1806 of yacc.c */
9766 #line 3896 "ripper.y"
9767  {
9768 #if 0
9769  int options = (yyvsp[(3) - (3)].val);
9770  NODE *node = (yyvsp[(2) - (3)].val);
9771  NODE *list, *prev;
9772  if (!node) {
9773  node = NEW_LIT(reg_compile(STR_NEW0(), options));
9774  }
9775  else switch (nd_type(node)) {
9776  case NODE_STR:
9777  {
9778  VALUE src = node->nd_lit;
9779  nd_set_type(node, NODE_LIT);
9780  node->nd_lit = reg_compile(src, options);
9781  }
9782  break;
9783  default:
9784  node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
9785  case NODE_DSTR:
9786  if (options & RE_OPTION_ONCE) {
9788  }
9789  else {
9790  nd_set_type(node, NODE_DREGX);
9791  }
9792  node->nd_cflag = options & RE_OPTION_MASK;
9793  if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
9794  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
9795  if (nd_type(list->nd_head) == NODE_STR) {
9796  VALUE tail = list->nd_head->nd_lit;
9797  if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
9798  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
9799  if (!literal_concat0(parser, lit, tail)) {
9800  node = 0;
9801  break;
9802  }
9803  rb_str_resize(tail, 0);
9804  prev->nd_next = list->nd_next;
9805  rb_gc_force_recycle((VALUE)list->nd_head);
9806  rb_gc_force_recycle((VALUE)list);
9807  list = prev;
9808  }
9809  else {
9810  prev = list;
9811  }
9812  }
9813  else {
9814  prev = 0;
9815  }
9816  }
9817  if (!node->nd_next) {
9818  VALUE src = node->nd_lit;
9819  nd_set_type(node, NODE_LIT);
9820  node->nd_lit = reg_compile(src, options);
9821  }
9822  break;
9823  }
9824  (yyval.val) = node;
9825 #endif
9826  (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
9827 
9828  }
9829  break;
9830 
9831  case 460:
9832 
9833 /* Line 1806 of yacc.c */
9834 #line 3961 "ripper.y"
9835  {
9836 #if 0
9837  (yyval.val) = NEW_ZARRAY();
9838 #endif
9839  (yyval.val) = dispatch0(words_new);
9840  (yyval.val) = dispatch1(array, (yyval.val));
9841 
9842  }
9843  break;
9844 
9845  case 461:
9846 
9847 /* Line 1806 of yacc.c */
9848 #line 3970 "ripper.y"
9849  {
9850 #if 0
9851  (yyval.val) = (yyvsp[(2) - (3)].val);
9852 #endif
9853  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9854 
9855  }
9856  break;
9857 
9858  case 462:
9859 
9860 /* Line 1806 of yacc.c */
9861 #line 3980 "ripper.y"
9862  {
9863 #if 0
9864  (yyval.val) = 0;
9865 #endif
9866  (yyval.val) = dispatch0(words_new);
9867 
9868  }
9869  break;
9870 
9871  case 463:
9872 
9873 /* Line 1806 of yacc.c */
9874 #line 3988 "ripper.y"
9875  {
9876 #if 0
9877  (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
9878 #endif
9879  (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9880 
9881  }
9882  break;
9883 
9884  case 464:
9885 
9886 /* Line 1806 of yacc.c */
9887 #line 4000 "ripper.y"
9888  {
9889  (yyval.val) = dispatch0(word_new);
9890  (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
9891  }
9892  break;
9893 
9894  case 465:
9895 
9896 /* Line 1806 of yacc.c */
9897 #line 4006 "ripper.y"
9898  {
9899 #if 0
9900  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9901 #endif
9902  (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9903 
9904  }
9905  break;
9906 
9907  case 466:
9908 
9909 /* Line 1806 of yacc.c */
9910 #line 4016 "ripper.y"
9911  {
9912 #if 0
9913  (yyval.val) = NEW_ZARRAY();
9914 #endif
9915  (yyval.val) = dispatch0(symbols_new);
9916  (yyval.val) = dispatch1(array, (yyval.val));
9917 
9918  }
9919  break;
9920 
9921  case 467:
9922 
9923 /* Line 1806 of yacc.c */
9924 #line 4025 "ripper.y"
9925  {
9926 #if 0
9927  (yyval.val) = (yyvsp[(2) - (3)].val);
9928 #endif
9929  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9930 
9931  }
9932  break;
9933 
9934  case 468:
9935 
9936 /* Line 1806 of yacc.c */
9937 #line 4035 "ripper.y"
9938  {
9939 #if 0
9940  (yyval.val) = 0;
9941 #endif
9942  (yyval.val) = dispatch0(symbols_new);
9943 
9944  }
9945  break;
9946 
9947  case 469:
9948 
9949 /* Line 1806 of yacc.c */
9950 #line 4043 "ripper.y"
9951  {
9952 #if 0
9953  (yyvsp[(2) - (3)].val) = evstr2dstr((yyvsp[(2) - (3)].val));
9954  nd_set_type((yyvsp[(2) - (3)].val), NODE_DSYM);
9955  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9956 #endif
9957  (yyval.val) = dispatch2(symbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9958 
9959  }
9960  break;
9961 
9962  case 470:
9963 
9964 /* Line 1806 of yacc.c */
9965 #line 4055 "ripper.y"
9966  {
9967 #if 0
9968  (yyval.val) = NEW_ZARRAY();
9969 #endif
9970  (yyval.val) = dispatch0(qwords_new);
9971  (yyval.val) = dispatch1(array, (yyval.val));
9972 
9973  }
9974  break;
9975 
9976  case 471:
9977 
9978 /* Line 1806 of yacc.c */
9979 #line 4064 "ripper.y"
9980  {
9981 #if 0
9982  (yyval.val) = (yyvsp[(2) - (3)].val);
9983 #endif
9984  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9985 
9986  }
9987  break;
9988 
9989  case 472:
9990 
9991 /* Line 1806 of yacc.c */
9992 #line 4074 "ripper.y"
9993  {
9994 #if 0
9995  (yyval.val) = NEW_ZARRAY();
9996 #endif
9997  (yyval.val) = dispatch0(qsymbols_new);
9998  (yyval.val) = dispatch1(array, (yyval.val));
9999 
10000  }
10001  break;
10002 
10003  case 473:
10004 
10005 /* Line 1806 of yacc.c */
10006 #line 4083 "ripper.y"
10007  {
10008 #if 0
10009  (yyval.val) = (yyvsp[(2) - (3)].val);
10010 #endif
10011  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10012 
10013  }
10014  break;
10015 
10016  case 474:
10017 
10018 /* Line 1806 of yacc.c */
10019 #line 4093 "ripper.y"
10020  {
10021 #if 0
10022  (yyval.val) = 0;
10023 #endif
10024  (yyval.val) = dispatch0(qwords_new);
10025 
10026  }
10027  break;
10028 
10029  case 475:
10030 
10031 /* Line 1806 of yacc.c */
10032 #line 4101 "ripper.y"
10033  {
10034 #if 0
10035  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10036 #endif
10037  (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10038 
10039  }
10040  break;
10041 
10042  case 476:
10043 
10044 /* Line 1806 of yacc.c */
10045 #line 4111 "ripper.y"
10046  {
10047 #if 0
10048  (yyval.val) = 0;
10049 #endif
10050  (yyval.val) = dispatch0(qsymbols_new);
10051 
10052  }
10053  break;
10054 
10055  case 477:
10056 
10057 /* Line 1806 of yacc.c */
10058 #line 4119 "ripper.y"
10059  {
10060 #if 0
10061  VALUE lit;
10062  lit = (yyvsp[(2) - (3)].val)->nd_lit;
10063  (yyvsp[(2) - (3)].val)->nd_lit = ID2SYM(rb_intern_str(lit));
10064  nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
10065  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10066 #endif
10067  (yyval.val) = dispatch2(qsymbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10068 
10069  }
10070  break;
10071 
10072  case 478:
10073 
10074 /* Line 1806 of yacc.c */
10075 #line 4133 "ripper.y"
10076  {
10077 #if 0
10078  (yyval.val) = 0;
10079 #endif
10080  (yyval.val) = dispatch0(string_content);
10081 
10082  }
10083  break;
10084 
10085  case 479:
10086 
10087 /* Line 1806 of yacc.c */
10088 #line 4141 "ripper.y"
10089  {
10090 #if 0
10091  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10092 #endif
10093  (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10094 
10095  }
10096  break;
10097 
10098  case 480:
10099 
10100 /* Line 1806 of yacc.c */
10101 #line 4151 "ripper.y"
10102  {
10103 #if 0
10104  (yyval.val) = 0;
10105 #endif
10106  (yyval.val) = dispatch0(xstring_new);
10107 
10108  }
10109  break;
10110 
10111  case 481:
10112 
10113 /* Line 1806 of yacc.c */
10114 #line 4159 "ripper.y"
10115  {
10116 #if 0
10117  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10118 #endif
10119  (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10120 
10121  }
10122  break;
10123 
10124  case 482:
10125 
10126 /* Line 1806 of yacc.c */
10127 #line 4169 "ripper.y"
10128  {
10129 #if 0
10130  (yyval.val) = 0;
10131 #endif
10132  (yyval.val) = dispatch0(regexp_new);
10133 
10134  }
10135  break;
10136 
10137  case 483:
10138 
10139 /* Line 1806 of yacc.c */
10140 #line 4177 "ripper.y"
10141  {
10142 #if 0
10143  NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
10144  if (!head) {
10145  (yyval.val) = tail;
10146  }
10147  else if (!tail) {
10148  (yyval.val) = head;
10149  }
10150  else {
10151  switch (nd_type(head)) {
10152  case NODE_STR:
10153  nd_set_type(head, NODE_DSTR);
10154  break;
10155  case NODE_DSTR:
10156  break;
10157  default:
10158  head = list_append(NEW_DSTR(Qnil), head);
10159  break;
10160  }
10161  (yyval.val) = list_append(head, tail);
10162  }
10163 #endif
10164  (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10165 
10166  }
10167  break;
10168 
10169  case 485:
10170 
10171 /* Line 1806 of yacc.c */
10172 #line 4207 "ripper.y"
10173  {
10174  (yyval.node) = lex_strterm;
10175  lex_strterm = 0;
10176  lex_state = EXPR_BEG;
10177  }
10178  break;
10179 
10180  case 486:
10181 
10182 /* Line 1806 of yacc.c */
10183 #line 4213 "ripper.y"
10184  {
10185 #if 0
10186  lex_strterm = (yyvsp[(2) - (3)].node);
10187  (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
10188 #endif
10189  lex_strterm = (yyvsp[(2) - (3)].node);
10190  (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
10191 
10192  }
10193  break;
10194 
10195  case 487:
10196 
10197 /* Line 1806 of yacc.c */
10198 #line 4223 "ripper.y"
10199  {
10200  (yyvsp[(1) - (1)].val) = cond_stack;
10201  (yyval.val) = cmdarg_stack;
10202  cond_stack = 0;
10203  cmdarg_stack = 0;
10204  }
10205  break;
10206 
10207  case 488:
10208 
10209 /* Line 1806 of yacc.c */
10210 #line 4229 "ripper.y"
10211  {
10212  (yyval.node) = lex_strterm;
10213  lex_strterm = 0;
10214  lex_state = EXPR_BEG;
10215  }
10216  break;
10217 
10218  case 489:
10219 
10220 /* Line 1806 of yacc.c */
10221 #line 4234 "ripper.y"
10222  {
10223  (yyval.num) = brace_nest;
10224  brace_nest = 0;
10225  }
10226  break;
10227 
10228  case 490:
10229 
10230 /* Line 1806 of yacc.c */
10231 #line 4239 "ripper.y"
10232  {
10233  cond_stack = (yyvsp[(1) - (6)].val);
10234  cmdarg_stack = (yyvsp[(2) - (6)].val);
10235  lex_strterm = (yyvsp[(3) - (6)].node);
10236  brace_nest = (yyvsp[(4) - (6)].num);
10237 #if 0
10238  if ((yyvsp[(5) - (6)].val)) (yyvsp[(5) - (6)].val)->flags &= ~NODE_FL_NEWLINE;
10239  (yyval.val) = new_evstr((yyvsp[(5) - (6)].val));
10240 #endif
10241  (yyval.val) = dispatch1(string_embexpr, (yyvsp[(5) - (6)].val));
10242 
10243  }
10244  break;
10245 
10246  case 491:
10247 
10248 /* Line 1806 of yacc.c */
10249 #line 4254 "ripper.y"
10250  {
10251 #if 0
10252  (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
10253 #endif
10254  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10255 
10256  }
10257  break;
10258 
10259  case 492:
10260 
10261 /* Line 1806 of yacc.c */
10262 #line 4262 "ripper.y"
10263  {
10264 #if 0
10265  (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
10266 #endif
10267  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10268 
10269  }
10270  break;
10271 
10272  case 493:
10273 
10274 /* Line 1806 of yacc.c */
10275 #line 4270 "ripper.y"
10276  {
10277 #if 0
10278  (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
10279 #endif
10280  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10281 
10282  }
10283  break;
10284 
10285  case 495:
10286 
10287 /* Line 1806 of yacc.c */
10288 #line 4281 "ripper.y"
10289  {
10290  lex_state = EXPR_END;
10291 #if 0
10292  (yyval.val) = (yyvsp[(2) - (2)].val);
10293 #endif
10294  (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
10295 
10296  }
10297  break;
10298 
10299  case 500:
10300 
10301 /* Line 1806 of yacc.c */
10302 #line 4298 "ripper.y"
10303  {
10304  lex_state = EXPR_END;
10305 #if 0
10306  (yyval.val) = dsym_node((yyvsp[(2) - (3)].val));
10307 #endif
10308  (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
10309 
10310  }
10311  break;
10312 
10313  case 503:
10314 
10315 /* Line 1806 of yacc.c */
10316 #line 4311 "ripper.y"
10317  {
10318 #if 0
10319  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10320 #endif
10321  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10322 
10323  }
10324  break;
10325 
10326  case 504:
10327 
10328 /* Line 1806 of yacc.c */
10329 #line 4319 "ripper.y"
10330  {
10331 #if 0
10332  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10333 #endif
10334  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10335 
10336  }
10337  break;
10338 
10339  case 510:
10340 
10341 /* Line 1806 of yacc.c */
10342 #line 4335 "ripper.y"
10343  {ifndef_ripper((yyval.val) = keyword_nil);}
10344  break;
10345 
10346  case 511:
10347 
10348 /* Line 1806 of yacc.c */
10349 #line 4336 "ripper.y"
10350  {ifndef_ripper((yyval.val) = keyword_self);}
10351  break;
10352 
10353  case 512:
10354 
10355 /* Line 1806 of yacc.c */
10356 #line 4337 "ripper.y"
10357  {ifndef_ripper((yyval.val) = keyword_true);}
10358  break;
10359 
10360  case 513:
10361 
10362 /* Line 1806 of yacc.c */
10363 #line 4338 "ripper.y"
10364  {ifndef_ripper((yyval.val) = keyword_false);}
10365  break;
10366 
10367  case 514:
10368 
10369 /* Line 1806 of yacc.c */
10370 #line 4339 "ripper.y"
10371  {ifndef_ripper((yyval.val) = keyword__FILE__);}
10372  break;
10373 
10374  case 515:
10375 
10376 /* Line 1806 of yacc.c */
10377 #line 4340 "ripper.y"
10378  {ifndef_ripper((yyval.val) = keyword__LINE__);}
10379  break;
10380 
10381  case 516:
10382 
10383 /* Line 1806 of yacc.c */
10384 #line 4341 "ripper.y"
10385  {ifndef_ripper((yyval.val) = keyword__ENCODING__);}
10386  break;
10387 
10388  case 517:
10389 
10390 /* Line 1806 of yacc.c */
10391 #line 4345 "ripper.y"
10392  {
10393 #if 0
10394  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10395 #endif
10396  if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) {
10397  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10398  }
10399  else {
10400  (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val));
10401  }
10402 
10403  }
10404  break;
10405 
10406  case 518:
10407 
10408 /* Line 1806 of yacc.c */
10409 #line 4358 "ripper.y"
10410  {
10411 #if 0
10412  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10413 #endif
10414  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10415 
10416  }
10417  break;
10418 
10419  case 519:
10420 
10421 /* Line 1806 of yacc.c */
10422 #line 4368 "ripper.y"
10423  {
10424  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10425 #if 0
10426 #endif
10427  (yyval.val) = dispatch1(var_field, (yyval.val));
10428 
10429  }
10430  break;
10431 
10432  case 520:
10433 
10434 /* Line 1806 of yacc.c */
10435 #line 4376 "ripper.y"
10436  {
10437  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10438 #if 0
10439 #endif
10440  (yyval.val) = dispatch1(var_field, (yyval.val));
10441 
10442  }
10443  break;
10444 
10445  case 523:
10446 
10447 /* Line 1806 of yacc.c */
10448 #line 4390 "ripper.y"
10449  {
10450 #if 0
10451  (yyval.val) = 0;
10452 #endif
10453  (yyval.val) = Qnil;
10454 
10455  }
10456  break;
10457 
10458  case 524:
10459 
10460 /* Line 1806 of yacc.c */
10461 #line 4398 "ripper.y"
10462  {
10463  lex_state = EXPR_BEG;
10464  command_start = TRUE;
10465  }
10466  break;
10467 
10468  case 525:
10469 
10470 /* Line 1806 of yacc.c */
10471 #line 4403 "ripper.y"
10472  {
10473  (yyval.val) = (yyvsp[(3) - (4)].val);
10474  }
10475  break;
10476 
10477  case 526:
10478 
10479 /* Line 1806 of yacc.c */
10480 #line 4407 "ripper.y"
10481  {
10482 #if 0
10483  yyerrok;
10484  (yyval.val) = 0;
10485 #endif
10486  yyerrok;
10487  (yyval.val) = Qnil;
10488 
10489  }
10490  break;
10491 
10492  case 527:
10493 
10494 /* Line 1806 of yacc.c */
10495 #line 4419 "ripper.y"
10496  {
10497 #if 0
10498  (yyval.val) = (yyvsp[(2) - (3)].val);
10499 #endif
10500  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
10501 
10502  lex_state = EXPR_BEG;
10503  command_start = TRUE;
10504  }
10505  break;
10506 
10507  case 528:
10508 
10509 /* Line 1806 of yacc.c */
10510 #line 4429 "ripper.y"
10511  {
10512  (yyval.val) = (yyvsp[(1) - (2)].val);
10513  lex_state = EXPR_BEG;
10514  command_start = TRUE;
10515  }
10516  break;
10517 
10518  case 529:
10519 
10520 /* Line 1806 of yacc.c */
10521 #line 4437 "ripper.y"
10522  {
10523  (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10524  }
10525  break;
10526 
10527  case 530:
10528 
10529 /* Line 1806 of yacc.c */
10530 #line 4441 "ripper.y"
10531  {
10532  (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10533  }
10534  break;
10535 
10536  case 531:
10537 
10538 /* Line 1806 of yacc.c */
10539 #line 4445 "ripper.y"
10540  {
10541  (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10542  }
10543  break;
10544 
10545  case 532:
10546 
10547 /* Line 1806 of yacc.c */
10548 #line 4449 "ripper.y"
10549  {
10550  (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
10551  }
10552  break;
10553 
10554  case 533:
10555 
10556 /* Line 1806 of yacc.c */
10557 #line 4455 "ripper.y"
10558  {
10559  (yyval.val) = (yyvsp[(2) - (2)].val);
10560  }
10561  break;
10562 
10563  case 534:
10564 
10565 /* Line 1806 of yacc.c */
10566 #line 4459 "ripper.y"
10567  {
10568  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10569  }
10570  break;
10571 
10572  case 535:
10573 
10574 /* Line 1806 of yacc.c */
10575 #line 4465 "ripper.y"
10576  {
10577  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
10578  }
10579  break;
10580 
10581  case 536:
10582 
10583 /* Line 1806 of yacc.c */
10584 #line 4469 "ripper.y"
10585  {
10586  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10587  }
10588  break;
10589 
10590  case 537:
10591 
10592 /* Line 1806 of yacc.c */
10593 #line 4473 "ripper.y"
10594  {
10595  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
10596  }
10597  break;
10598 
10599  case 538:
10600 
10601 /* Line 1806 of yacc.c */
10602 #line 4477 "ripper.y"
10603  {
10604  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10605  }
10606  break;
10607 
10608  case 539:
10609 
10610 /* Line 1806 of yacc.c */
10611 #line 4481 "ripper.y"
10612  {
10613  (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10614  }
10615  break;
10616 
10617  case 540:
10618 
10619 /* Line 1806 of yacc.c */
10620 #line 4485 "ripper.y"
10621  {
10622  (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10623  }
10624  break;
10625 
10626  case 541:
10627 
10628 /* Line 1806 of yacc.c */
10629 #line 4489 "ripper.y"
10630  {
10631  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
10632  }
10633  break;
10634 
10635  case 542:
10636 
10637 /* Line 1806 of yacc.c */
10638 #line 4493 "ripper.y"
10639  {
10640  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10641  }
10642  break;
10643 
10644  case 543:
10645 
10646 /* Line 1806 of yacc.c */
10647 #line 4497 "ripper.y"
10648  {
10649  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10650  }
10651  break;
10652 
10653  case 544:
10654 
10655 /* Line 1806 of yacc.c */
10656 #line 4501 "ripper.y"
10657  {
10658  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
10659  }
10660  break;
10661 
10662  case 545:
10663 
10664 /* Line 1806 of yacc.c */
10665 #line 4505 "ripper.y"
10666  {
10667  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10668  }
10669  break;
10670 
10671  case 546:
10672 
10673 /* Line 1806 of yacc.c */
10674 #line 4509 "ripper.y"
10675  {
10676  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10677  }
10678  break;
10679 
10680  case 547:
10681 
10682 /* Line 1806 of yacc.c */
10683 #line 4513 "ripper.y"
10684  {
10685  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10686  }
10687  break;
10688 
10689  case 548:
10690 
10691 /* Line 1806 of yacc.c */
10692 #line 4517 "ripper.y"
10693  {
10694  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
10695  }
10696  break;
10697 
10698  case 549:
10699 
10700 /* Line 1806 of yacc.c */
10701 #line 4521 "ripper.y"
10702  {
10703  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10704  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.val));
10705  }
10706  break;
10707 
10708  case 550:
10709 
10710 /* Line 1806 of yacc.c */
10711 #line 4528 "ripper.y"
10712  {
10713 #if 0
10714  yyerror("formal argument cannot be a constant");
10715  (yyval.val) = 0;
10716 #endif
10717  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10718 
10719  }
10720  break;
10721 
10722  case 551:
10723 
10724 /* Line 1806 of yacc.c */
10725 #line 4537 "ripper.y"
10726  {
10727 #if 0
10728  yyerror("formal argument cannot be an instance variable");
10729  (yyval.val) = 0;
10730 #endif
10731  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10732 
10733  }
10734  break;
10735 
10736  case 552:
10737 
10738 /* Line 1806 of yacc.c */
10739 #line 4546 "ripper.y"
10740  {
10741 #if 0
10742  yyerror("formal argument cannot be a global variable");
10743  (yyval.val) = 0;
10744 #endif
10745  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10746 
10747  }
10748  break;
10749 
10750  case 553:
10751 
10752 /* Line 1806 of yacc.c */
10753 #line 4555 "ripper.y"
10754  {
10755 #if 0
10756  yyerror("formal argument cannot be a class variable");
10757  (yyval.val) = 0;
10758 #endif
10759  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10760 
10761  }
10762  break;
10763 
10764  case 555:
10765 
10766 /* Line 1806 of yacc.c */
10767 #line 4567 "ripper.y"
10768  {
10769  formal_argument(get_id((yyvsp[(1) - (1)].val)));
10770  (yyval.val) = (yyvsp[(1) - (1)].val);
10771  }
10772  break;
10773 
10774  case 556:
10775 
10776 /* Line 1806 of yacc.c */
10777 #line 4574 "ripper.y"
10778  {
10779  arg_var(get_id((yyvsp[(1) - (1)].val)));
10780 #if 0
10781  (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10782 #endif
10783  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10784 
10785  }
10786  break;
10787 
10788  case 557:
10789 
10790 /* Line 1806 of yacc.c */
10791 #line 4583 "ripper.y"
10792  {
10793  ID tid = internal_id();
10794  arg_var(tid);
10795 #if 0
10796  if (dyna_in_block()) {
10797  (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10798  }
10799  else {
10800  (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10801  }
10802  (yyval.val) = NEW_ARGS_AUX(tid, 1);
10803  (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10804 #endif
10805  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10806 
10807  }
10808  break;
10809 
10810  case 558:
10811 
10812 /* Line 1806 of yacc.c */
10813 #line 4604 "ripper.y"
10814  {
10815  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10816  }
10817  break;
10818 
10819  case 559:
10820 
10821 /* Line 1806 of yacc.c */
10822 #line 4609 "ripper.y"
10823  {
10824 #if 0
10825  (yyval.val) = (yyvsp[(1) - (3)].val);
10826  (yyval.val)->nd_plen++;
10827  (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10828  rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10829 #endif
10830  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10831 
10832  }
10833  break;
10834 
10835  case 560:
10836 
10837 /* Line 1806 of yacc.c */
10838 #line 4622 "ripper.y"
10839  {
10840  arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val))));
10841  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10842 #if 0
10843  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10844 #endif
10845  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10846 
10847  }
10848  break;
10849 
10850  case 561:
10851 
10852 /* Line 1806 of yacc.c */
10853 #line 4634 "ripper.y"
10854  {
10855  arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val))));
10856  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10857 #if 0
10858  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10859 #endif
10860  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10861 
10862  }
10863  break;
10864 
10865  case 562:
10866 
10867 /* Line 1806 of yacc.c */
10868 #line 4646 "ripper.y"
10869  {
10870 #if 0
10871  (yyval.val) = (yyvsp[(1) - (1)].val);
10872 #endif
10873  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10874 
10875  }
10876  break;
10877 
10878  case 563:
10879 
10880 /* Line 1806 of yacc.c */
10881 #line 4654 "ripper.y"
10882  {
10883 #if 0
10884  NODE *kws = (yyvsp[(1) - (3)].val);
10885 
10886  while (kws->nd_next) {
10887  kws = kws->nd_next;
10888  }
10889  kws->nd_next = (yyvsp[(3) - (3)].val);
10890  (yyval.val) = (yyvsp[(1) - (3)].val);
10891 #endif
10892  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10893 
10894  }
10895  break;
10896 
10897  case 564:
10898 
10899 /* Line 1806 of yacc.c */
10900 #line 4671 "ripper.y"
10901  {
10902 #if 0
10903  (yyval.val) = (yyvsp[(1) - (1)].val);
10904 #endif
10905  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10906 
10907  }
10908  break;
10909 
10910  case 565:
10911 
10912 /* Line 1806 of yacc.c */
10913 #line 4679 "ripper.y"
10914  {
10915 #if 0
10916  NODE *kws = (yyvsp[(1) - (3)].val);
10917 
10918  while (kws->nd_next) {
10919  kws = kws->nd_next;
10920  }
10921  kws->nd_next = (yyvsp[(3) - (3)].val);
10922  (yyval.val) = (yyvsp[(1) - (3)].val);
10923 #endif
10924  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10925 
10926  }
10927  break;
10928 
10929  case 568:
10930 
10931 /* Line 1806 of yacc.c */
10932 #line 4699 "ripper.y"
10933  {
10934  shadowing_lvar(get_id((yyvsp[(2) - (2)].val)));
10935  (yyval.val) = (yyvsp[(2) - (2)].val);
10936  }
10937  break;
10938 
10939  case 569:
10940 
10941 /* Line 1806 of yacc.c */
10942 #line 4704 "ripper.y"
10943  {
10944  (yyval.val) = internal_id();
10945  }
10946  break;
10947 
10948  case 570:
10949 
10950 /* Line 1806 of yacc.c */
10951 #line 4710 "ripper.y"
10952  {
10953  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10954  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10955 #if 0
10956  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10957 #endif
10958  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10959 
10960  }
10961  break;
10962 
10963  case 571:
10964 
10965 /* Line 1806 of yacc.c */
10966 #line 4722 "ripper.y"
10967  {
10968  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10969  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10970 #if 0
10971  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10972 #endif
10973  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10974 
10975  }
10976  break;
10977 
10978  case 572:
10979 
10980 /* Line 1806 of yacc.c */
10981 #line 4734 "ripper.y"
10982  {
10983 #if 0
10984  (yyval.val) = (yyvsp[(1) - (1)].val);
10985 #endif
10986  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10987 
10988  }
10989  break;
10990 
10991  case 573:
10992 
10993 /* Line 1806 of yacc.c */
10994 #line 4742 "ripper.y"
10995  {
10996 #if 0
10997  NODE *opts = (yyvsp[(1) - (3)].val);
10998 
10999  while (opts->nd_next) {
11000  opts = opts->nd_next;
11001  }
11002  opts->nd_next = (yyvsp[(3) - (3)].val);
11003  (yyval.val) = (yyvsp[(1) - (3)].val);
11004 #endif
11005  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11006 
11007  }
11008  break;
11009 
11010  case 574:
11011 
11012 /* Line 1806 of yacc.c */
11013 #line 4758 "ripper.y"
11014  {
11015 #if 0
11016  (yyval.val) = (yyvsp[(1) - (1)].val);
11017 #endif
11018  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11019 
11020  }
11021  break;
11022 
11023  case 575:
11024 
11025 /* Line 1806 of yacc.c */
11026 #line 4766 "ripper.y"
11027  {
11028 #if 0
11029  NODE *opts = (yyvsp[(1) - (3)].val);
11030 
11031  while (opts->nd_next) {
11032  opts = opts->nd_next;
11033  }
11034  opts->nd_next = (yyvsp[(3) - (3)].val);
11035  (yyval.val) = (yyvsp[(1) - (3)].val);
11036 #endif
11037  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11038 
11039  }
11040  break;
11041 
11042  case 578:
11043 
11044 /* Line 1806 of yacc.c */
11045 #line 4786 "ripper.y"
11046  {
11047 #if 0
11048  if (!is_local_id((yyvsp[(2) - (2)].val)))
11049  yyerror("rest argument must be local variable");
11050 #endif
11051  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11052 #if 0
11053  (yyval.val) = (yyvsp[(2) - (2)].val);
11054 #endif
11055  (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
11056 
11057  }
11058  break;
11059 
11060  case 579:
11061 
11062 /* Line 1806 of yacc.c */
11063 #line 4799 "ripper.y"
11064  {
11065 #if 0
11066  (yyval.val) = internal_id();
11067  arg_var((yyval.val));
11068 #endif
11069  (yyval.val) = dispatch1(rest_param, Qnil);
11070 
11071  }
11072  break;
11073 
11074  case 582:
11075 
11076 /* Line 1806 of yacc.c */
11077 #line 4814 "ripper.y"
11078  {
11079 #if 0
11080  if (!is_local_id((yyvsp[(2) - (2)].val)))
11081  yyerror("block argument must be local variable");
11082  else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
11083  yyerror("duplicated block argument name");
11084 #endif
11085  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11086 #if 0
11087  (yyval.val) = (yyvsp[(2) - (2)].val);
11088 #endif
11089  (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
11090 
11091  }
11092  break;
11093 
11094  case 583:
11095 
11096 /* Line 1806 of yacc.c */
11097 #line 4831 "ripper.y"
11098  {
11099  (yyval.val) = (yyvsp[(2) - (2)].val);
11100  }
11101  break;
11102 
11103  case 584:
11104 
11105 /* Line 1806 of yacc.c */
11106 #line 4835 "ripper.y"
11107  {
11108 #if 0
11109  (yyval.val) = 0;
11110 #endif
11111  (yyval.val) = Qundef;
11112 
11113  }
11114  break;
11115 
11116  case 585:
11117 
11118 /* Line 1806 of yacc.c */
11119 #line 4845 "ripper.y"
11120  {
11121 #if 0
11122  value_expr((yyvsp[(1) - (1)].val));
11123  (yyval.val) = (yyvsp[(1) - (1)].val);
11124  if (!(yyval.val)) (yyval.val) = NEW_NIL();
11125 #endif
11126  (yyval.val) = (yyvsp[(1) - (1)].val);
11127 
11128  }
11129  break;
11130 
11131  case 586:
11132 
11133 /* Line 1806 of yacc.c */
11134 #line 4854 "ripper.y"
11135  {lex_state = EXPR_BEG;}
11136  break;
11137 
11138  case 587:
11139 
11140 /* Line 1806 of yacc.c */
11141 #line 4855 "ripper.y"
11142  {
11143 #if 0
11144  if ((yyvsp[(3) - (4)].val) == 0) {
11145  yyerror("can't define singleton method for ().");
11146  }
11147  else {
11148  switch (nd_type((yyvsp[(3) - (4)].val))) {
11149  case NODE_STR:
11150  case NODE_DSTR:
11151  case NODE_XSTR:
11152  case NODE_DXSTR:
11153  case NODE_DREGX:
11154  case NODE_LIT:
11155  case NODE_ARRAY:
11156  case NODE_ZARRAY:
11157  yyerror("can't define singleton method for literals");
11158  default:
11159  value_expr((yyvsp[(3) - (4)].val));
11160  break;
11161  }
11162  }
11163  (yyval.val) = (yyvsp[(3) - (4)].val);
11164 #endif
11165  (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
11166 
11167  }
11168  break;
11169 
11170  case 589:
11171 
11172 /* Line 1806 of yacc.c */
11173 #line 4885 "ripper.y"
11174  {
11175 #if 0
11176  (yyval.val) = (yyvsp[(1) - (2)].val);
11177 #endif
11178  (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
11179 
11180  }
11181  break;
11182 
11183  case 590:
11184 
11185 /* Line 1806 of yacc.c */
11186 #line 4897 "ripper.y"
11187  {
11188  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11189  }
11190  break;
11191 
11192  case 591:
11193 
11194 /* Line 1806 of yacc.c */
11195 #line 4902 "ripper.y"
11196  {
11197 #if 0
11198  (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11199 #endif
11200  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11201 
11202  }
11203  break;
11204 
11205  case 592:
11206 
11207 /* Line 1806 of yacc.c */
11208 #line 4912 "ripper.y"
11209  {
11210 #if 0
11211  (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
11212 #endif
11213  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11214 
11215  }
11216  break;
11217 
11218  case 593:
11219 
11220 /* Line 1806 of yacc.c */
11221 #line 4920 "ripper.y"
11222  {
11223 #if 0
11224  (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
11225 #endif
11226  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
11227 
11228  }
11229  break;
11230 
11231  case 594:
11232 
11233 /* Line 1806 of yacc.c */
11234 #line 4928 "ripper.y"
11235  {
11236 #if 0
11237  (yyval.val) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].val));
11238 #endif
11239  (yyval.val) = dispatch1(assoc_splat, (yyvsp[(2) - (2)].val));
11240 
11241  }
11242  break;
11243 
11244  case 605:
11245 
11246 /* Line 1806 of yacc.c */
11247 #line 4958 "ripper.y"
11248  { (yyval.val) = (yyvsp[(1) - (1)].val); }
11249  break;
11250 
11251  case 606:
11252 
11253 /* Line 1806 of yacc.c */
11254 #line 4963 "ripper.y"
11255  { (yyval.val) = (yyvsp[(1) - (1)].val); }
11256  break;
11257 
11258  case 616:
11259 
11260 /* Line 1806 of yacc.c */
11261 #line 4986 "ripper.y"
11262  {yyerrok;}
11263  break;
11264 
11265  case 619:
11266 
11267 /* Line 1806 of yacc.c */
11268 #line 4991 "ripper.y"
11269  {yyerrok;}
11270  break;
11271 
11272  case 620:
11273 
11274 /* Line 1806 of yacc.c */
11275 #line 4995 "ripper.y"
11276  {
11277 #if 0
11278  (yyval.val) = 0;
11279 #endif
11280  (yyval.val) = Qundef;
11281 
11282  }
11283  break;
11284 
11285 
11286 
11287 /* Line 1806 of yacc.c */
11288 #line 11287 "parse.c"
11289  default: break;
11290  }
11291  /* User semantic actions sometimes alter yychar, and that requires
11292  that yytoken be updated with the new translation. We take the
11293  approach of translating immediately before every use of yytoken.
11294  One alternative is translating here after every semantic action,
11295  but that translation would be missed if the semantic action invokes
11296  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11297  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
11298  incorrect destructor might then be invoked immediately. In the
11299  case of YYERROR or YYBACKUP, subsequent parser actions might lead
11300  to an incorrect destructor call or verbose syntax error message
11301  before the lookahead is translated. */
11302  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11303 
11304  YYPOPSTACK (yylen);
11305  yylen = 0;
11306  YY_STACK_PRINT (yyss, yyssp);
11307 
11308  *++yyvsp = yyval;
11309 
11310  /* Now `shift' the result of the reduction. Determine what state
11311  that goes to, based on the state we popped back to and the rule
11312  number reduced by. */
11313 
11314  yyn = yyr1[yyn];
11315 
11316  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
11317  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
11318  yystate = yytable[yystate];
11319  else
11320  yystate = yydefgoto[yyn - YYNTOKENS];
11321 
11322  goto yynewstate;
11323 
11324 
11325 /*------------------------------------.
11326 | yyerrlab -- here on detecting error |
11327 `------------------------------------*/
11328 yyerrlab:
11329  /* Make sure we have latest lookahead translation. See comments at
11330  user semantic actions for why this is necessary. */
11331  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
11332 
11333  /* If not already recovering from an error, report this error. */
11334  if (!yyerrstatus)
11335  {
11336  ++yynerrs;
11337 #if ! YYERROR_VERBOSE
11338  parser_yyerror (parser, YY_("syntax error"));
11339 #else
11340 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
11341  yyssp, yytoken)
11342  {
11343  char const *yymsgp = YY_("syntax error");
11344  int yysyntax_error_status;
11345  yysyntax_error_status = YYSYNTAX_ERROR;
11346  if (yysyntax_error_status == 0)
11347  yymsgp = yymsg;
11348  else if (yysyntax_error_status == 1)
11349  {
11350  if (yymsg != yymsgbuf)
11351  YYSTACK_FREE (yymsg);
11352  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11353  if (!yymsg)
11354  {
11355  yymsg = yymsgbuf;
11356  yymsg_alloc = sizeof yymsgbuf;
11357  yysyntax_error_status = 2;
11358  }
11359  else
11360  {
11361  yysyntax_error_status = YYSYNTAX_ERROR;
11362  yymsgp = yymsg;
11363  }
11364  }
11365  parser_yyerror (parser, yymsgp);
11366  if (yysyntax_error_status == 2)
11367  goto yyexhaustedlab;
11368  }
11369 # undef YYSYNTAX_ERROR
11370 #endif
11371  }
11372 
11373 
11374 
11375  if (yyerrstatus == 3)
11376  {
11377  /* If just tried and failed to reuse lookahead token after an
11378  error, discard it. */
11379 
11380  if (yychar <= YYEOF)
11381  {
11382  /* Return failure if at end of input. */
11383  if (yychar == YYEOF)
11384  YYABORT;
11385  }
11386  else
11387  {
11388  yydestruct ("Error: discarding",
11389  yytoken, &yylval, parser);
11390  yychar = YYEMPTY;
11391  }
11392  }
11393 
11394  /* Else will try to reuse lookahead token after shifting the error
11395  token. */
11397 
11398 
11399 /*---------------------------------------------------.
11400 | yyerrorlab -- error raised explicitly by YYERROR. |
11401 `---------------------------------------------------*/
11402 yyerrorlab:
11403 
11404  /* Pacify compilers like GCC when the user code never invokes
11405  YYERROR and the label yyerrorlab therefore never appears in user
11406  code. */
11407  if (/*CONSTCOND*/ 0)
11408  goto yyerrorlab;
11409 
11410  /* Do not reclaim the symbols of the rule which action triggered
11411  this YYERROR. */
11412  YYPOPSTACK (yylen);
11413  yylen = 0;
11414  YY_STACK_PRINT (yyss, yyssp);
11415  yystate = *yyssp;
11416  goto yyerrlab1;
11417 
11418 
11419 /*-------------------------------------------------------------.
11420 | yyerrlab1 -- common code for both syntax error and YYERROR. |
11421 `-------------------------------------------------------------*/
11422 yyerrlab1:
11423  yyerrstatus = 3; /* Each real token shifted decrements this. */
11424 
11425  for (;;)
11426  {
11427  yyn = yypact[yystate];
11428  if (!yypact_value_is_default (yyn))
11429  {
11430  yyn += YYTERROR;
11431  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11432  {
11433  yyn = yytable[yyn];
11434  if (0 < yyn)
11435  break;
11436  }
11437  }
11438 
11439  /* Pop the current state because it cannot handle the error token. */
11440  if (yyssp == yyss)
11441  YYABORT;
11442 
11443 
11444  yydestruct ("Error: popping",
11445  yystos[yystate], yyvsp, parser);
11446  YYPOPSTACK (1);
11447  yystate = *yyssp;
11448  YY_STACK_PRINT (yyss, yyssp);
11449  }
11450 
11451  *++yyvsp = yylval;
11452 
11453 
11454  /* Shift the error token. */
11455  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11456 
11457  yystate = yyn;
11458  goto yynewstate;
11459 
11460 
11461 /*-------------------------------------.
11462 | yyacceptlab -- YYACCEPT comes here. |
11463 `-------------------------------------*/
11464 yyacceptlab:
11465  yyresult = 0;
11466  goto yyreturn;
11467 
11468 /*-----------------------------------.
11469 | yyabortlab -- YYABORT comes here. |
11470 `-----------------------------------*/
11471 yyabortlab:
11472  yyresult = 1;
11473  goto yyreturn;
11474 
11475 #if !defined(yyoverflow) || YYERROR_VERBOSE
11476 /*-------------------------------------------------.
11477 | yyexhaustedlab -- memory exhaustion comes here. |
11478 `-------------------------------------------------*/
11479 yyexhaustedlab:
11480  parser_yyerror (parser, YY_("memory exhausted"));
11481  yyresult = 2;
11482  /* Fall through. */
11483 #endif
11484 
11485 yyreturn:
11486  if (yychar != YYEMPTY)
11487  {
11488  /* Make sure we have latest lookahead translation. See comments at
11489  user semantic actions for why this is necessary. */
11490  yytoken = YYTRANSLATE (yychar);
11491  yydestruct ("Cleanup: discarding lookahead",
11492  yytoken, &yylval, parser);
11493  }
11494  /* Do not reclaim the symbols of the rule which action triggered
11495  this YYABORT or YYACCEPT. */
11496  YYPOPSTACK (yylen);
11497  YY_STACK_PRINT (yyss, yyssp);
11498  while (yyssp != yyss)
11499  {
11500  yydestruct ("Cleanup: popping",
11501  yystos[*yyssp], yyvsp, parser);
11502  YYPOPSTACK (1);
11503  }
11504 #ifndef yyoverflow
11505  if (yyss != yyssa)
11506  YYSTACK_FREE (yyss);
11507 #endif
11508 #if YYERROR_VERBOSE
11509  if (yymsg != yymsgbuf)
11510  YYSTACK_FREE (yymsg);
11511 #endif
11512  /* Make sure YYID is used. */
11513  return YYID (yyresult);
11514 }
11515 
11516 
11517 
11518 /* Line 2067 of yacc.c */
11519 #line 5003 "ripper.y"
11520 
11521 # undef parser
11522 # undef yylex
11523 # undef yylval
11524 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
11525 
11526 static int parser_regx_options(struct parser_params*);
11527 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11528 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11529 static int parser_parse_string(struct parser_params*,NODE*);
11530 static int parser_here_document(struct parser_params*,NODE*);
11531 
11532 
11533 # define nextc() parser_nextc(parser)
11534 # define pushback(c) parser_pushback(parser, (c))
11535 # define newtok() parser_newtok(parser)
11536 # define tokspace(n) parser_tokspace(parser, (n))
11537 # define tokadd(c) parser_tokadd(parser, (c))
11538 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
11539 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
11540 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
11541 # define regx_options() parser_regx_options(parser)
11542 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11543 # define parse_string(n) parser_parse_string(parser,(n))
11544 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
11545 # define here_document(n) parser_here_document(parser,(n))
11546 # define heredoc_identifier() parser_heredoc_identifier(parser)
11547 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
11548 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
11549 
11550 #ifndef RIPPER
11551 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11552 # define set_yylval_num(x) (yylval.num = (x))
11553 # define set_yylval_id(x) (yylval.id = (x))
11554 # define set_yylval_name(x) (yylval.id = (x))
11555 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11556 # define set_yylval_node(x) (yylval.node = (x))
11557 # define yylval_id() (yylval.id)
11558 #else
11559 static inline VALUE
11560 ripper_yylval_id(ID x)
11561 {
11562  return (VALUE)NEW_LASGN(x, ID2SYM(x));
11563 }
11564 # define set_yylval_str(x) (void)(x)
11565 # define set_yylval_num(x) (void)(x)
11566 # define set_yylval_id(x) (void)(x)
11567 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11568 # define set_yylval_literal(x) (void)(x)
11569 # define set_yylval_node(x) (void)(x)
11570 # define yylval_id() yylval.id
11571 #endif
11572 
11573 #ifndef RIPPER
11574 #define ripper_flush(p) (void)(p)
11575 #else
11576 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11577 
11578 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11579 
11580 static int
11581 ripper_has_scan_event(struct parser_params *parser)
11582 {
11583 
11584  if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11585  return lex_p > parser->tokp;
11586 }
11587 
11588 static VALUE
11589 ripper_scan_event_val(struct parser_params *parser, int t)
11590 {
11591  VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11592  VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11593  ripper_flush(parser);
11594  return rval;
11595 }
11596 
11597 static void
11598 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11599 {
11600  if (!ripper_has_scan_event(parser)) return;
11601  yylval_rval = ripper_scan_event_val(parser, t);
11602 }
11603 
11604 static void
11605 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11606 {
11607  if (!ripper_has_scan_event(parser)) return;
11608  (void)ripper_scan_event_val(parser, t);
11609 }
11610 
11611 static void
11612 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11613 {
11614  int saved_line = ruby_sourceline;
11615  const char *saved_tokp = parser->tokp;
11616 
11617  ruby_sourceline = parser->delayed_line;
11618  parser->tokp = lex_pbeg + parser->delayed_col;
11619  yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11620  parser->delayed = Qnil;
11621  ruby_sourceline = saved_line;
11622  parser->tokp = saved_tokp;
11623 }
11624 #endif /* RIPPER */
11625 
11626 #include "ruby/regex.h"
11627 #include "ruby/util.h"
11628 
11629 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11630  since ours (we hope) works properly with all combinations of
11631  machines, compilers, `char' and `unsigned char' argument types.
11632  (Per Bothner suggested the basic approach.) */
11633 #undef SIGN_EXTEND_CHAR
11634 #if __STDC__
11635 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11636 #else /* not __STDC__ */
11637 /* As in Harbison and Steele. */
11638 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11639 #endif
11640 
11641 #define parser_encoding_name() (current_enc->name)
11642 #define parser_mbclen() mbclen((lex_p-1),lex_pend,current_enc)
11643 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
11644 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11645 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11646 
11647 #define parser_isascii() ISASCII(*(lex_p-1))
11648 
11649 #ifndef RIPPER
11650 static int
11651 token_info_get_column(struct parser_params *parser, const char *token)
11652 {
11653  int column = 1;
11654  const char *p, *pend = lex_p - strlen(token);
11655  for (p = lex_pbeg; p < pend; p++) {
11656  if (*p == '\t') {
11657  column = (((column - 1) / 8) + 1) * 8;
11658  }
11659  column++;
11660  }
11661  return column;
11662 }
11663 
11664 static int
11665 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11666 {
11667  const char *p, *pend = lex_p - strlen(token);
11668  for (p = lex_pbeg; p < pend; p++) {
11669  if (*p != ' ' && *p != '\t') {
11670  return 1;
11671  }
11672  }
11673  return 0;
11674 }
11675 
11676 #undef token_info_push
11677 static void
11678 token_info_push(struct parser_params *parser, const char *token)
11679 {
11680  token_info *ptinfo;
11681 
11682  if (!parser->parser_token_info_enabled) return;
11683  ptinfo = ALLOC(token_info);
11684  ptinfo->token = token;
11685  ptinfo->linenum = ruby_sourceline;
11686  ptinfo->column = token_info_get_column(parser, token);
11687  ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11688  ptinfo->next = parser->parser_token_info;
11689 
11690  parser->parser_token_info = ptinfo;
11691 }
11692 
11693 #undef token_info_pop
11694 static void
11695 token_info_pop(struct parser_params *parser, const char *token)
11696 {
11697  int linenum;
11698  token_info *ptinfo = parser->parser_token_info;
11699 
11700  if (!ptinfo) return;
11701  parser->parser_token_info = ptinfo->next;
11702  if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11703  goto finish;
11704  }
11705  linenum = ruby_sourceline;
11706  if (linenum == ptinfo->linenum) { /* SKIP */
11707  goto finish;
11708  }
11709  if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11710  goto finish;
11711  }
11712  if (parser->parser_token_info_enabled) {
11714  "mismatched indentations at '%s' with '%s' at %d",
11715  token, ptinfo->token, ptinfo->linenum);
11716  }
11717 
11718  finish:
11719  xfree(ptinfo);
11720 }
11721 #endif /* RIPPER */
11722 
11723 static int
11724 parser_yyerror(struct parser_params *parser, const char *msg)
11725 {
11726 #ifndef RIPPER
11727  const int max_line_margin = 30;
11728  const char *p, *pe;
11729  char *buf;
11730  long len;
11731  int i;
11732 
11733  compile_error(PARSER_ARG "%s", msg);
11734  p = lex_p;
11735  while (lex_pbeg <= p) {
11736  if (*p == '\n') break;
11737  p--;
11738  }
11739  p++;
11740 
11741  pe = lex_p;
11742  while (pe < lex_pend) {
11743  if (*pe == '\n') break;
11744  pe++;
11745  }
11746 
11747  len = pe - p;
11748  if (len > 4) {
11749  char *p2;
11750  const char *pre = "", *post = "";
11751 
11752  if (len > max_line_margin * 2 + 10) {
11753  if (lex_p - p > max_line_margin) {
11754  p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11755  pre = "...";
11756  }
11757  if (pe - lex_p > max_line_margin) {
11758  pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11759  post = "...";
11760  }
11761  len = pe - p;
11762  }
11763  buf = ALLOCA_N(char, len+2);
11764  MEMCPY(buf, p, char, len);
11765  buf[len] = '\0';
11766  rb_compile_error_with_enc(NULL, 0, (void *)current_enc, "%s%s%s", pre, buf, post);
11767 
11768  i = (int)(lex_p - p);
11769  p2 = buf; pe = buf + len;
11770 
11771  while (p2 < pe) {
11772  if (*p2 != '\t') *p2 = ' ';
11773  p2++;
11774  }
11775  buf[i] = '^';
11776  buf[i+1] = '\0';
11777  rb_compile_error_append("%s%s", pre, buf);
11778  }
11779 #else
11780  dispatch1(parse_error, STR_NEW2(msg));
11781 #endif /* !RIPPER */
11782  return 0;
11783 }
11784 
11785 static void parser_prepare(struct parser_params *parser);
11786 
11787 #ifndef RIPPER
11788 static VALUE
11790 {
11791  ID script_lines;
11792  CONST_ID(script_lines, "SCRIPT_LINES__");
11793  if (rb_const_defined_at(rb_cObject, script_lines)) {
11794  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11795  if (RB_TYPE_P(hash, T_HASH)) {
11796  VALUE lines = rb_ary_new();
11797  rb_hash_aset(hash, fname, lines);
11798  return lines;
11799  }
11800  }
11801  return 0;
11802 }
11803 
11804 static VALUE
11805 coverage(VALUE fname, int n)
11806 {
11807  VALUE coverages = rb_get_coverages();
11808  if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11809  VALUE lines = rb_ary_new2(n);
11810  int i;
11811  RBASIC(lines)->klass = 0;
11812  for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11813  RARRAY(lines)->as.heap.len = n;
11814  rb_hash_aset(coverages, fname, lines);
11815  return lines;
11816  }
11817  return 0;
11818 }
11819 
11820 static int
11822 {
11823  return strcmp(ruby_sourcefile, "-e") == 0;
11824 }
11825 
11826 static VALUE
11828 {
11829  int n;
11830  NODE *tree;
11831  struct parser_params *parser = (struct parser_params *)arg;
11832 
11833  if (!compile_for_eval && rb_safe_level() == 0) {
11835  if (ruby_debug_lines && ruby_sourceline > 0) {
11836  VALUE str = STR_NEW0();
11837  n = ruby_sourceline;
11838  do {
11840  } while (--n);
11841  }
11842 
11843  if (!e_option_supplied(parser)) {
11845  }
11846  }
11847 
11848  parser_prepare(parser);
11849  deferred_nodes = 0;
11850 #ifndef RIPPER
11852 #endif
11853 #ifndef RIPPER
11856  parser->parser_ruby_sourceline);
11857  }
11858 #endif
11859  n = yyparse((void*)parser);
11860 #ifndef RIPPER
11863  parser->parser_ruby_sourceline);
11864  }
11865 #endif
11866  ruby_debug_lines = 0;
11867  ruby_coverage = 0;
11868  compile_for_eval = 0;
11869 
11870  lex_strterm = 0;
11871  lex_p = lex_pbeg = lex_pend = 0;
11872  lex_lastline = lex_nextline = 0;
11873  if (parser->nerr) {
11874  return 0;
11875  }
11876  tree = ruby_eval_tree;
11877  if (!tree) {
11878  tree = NEW_NIL();
11879  }
11880  else if (ruby_eval_tree_begin) {
11881  tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11882  }
11883  return (VALUE)tree;
11884 }
11885 
11886 static NODE*
11887 yycompile(struct parser_params *parser, VALUE fname, int line)
11888 {
11890  ruby_sourcefile = RSTRING_PTR(fname);
11891  ruby_sourceline = line - 1;
11892  return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
11893 }
11894 #endif /* !RIPPER */
11895 
11896 static rb_encoding *
11898 {
11899  rb_encoding *enc = rb_enc_get(s);
11900  if (!rb_enc_asciicompat(enc)) {
11901  rb_raise(rb_eArgError, "invalid source encoding");
11902  }
11903  return enc;
11904 }
11905 
11906 static VALUE
11908 {
11909  char *beg, *end, *pend;
11911 
11912  beg = RSTRING_PTR(s);
11913  if (lex_gets_ptr) {
11914  if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11915  beg += lex_gets_ptr;
11916  }
11917  pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11918  end = beg;
11919  while (end < pend) {
11920  if (*end++ == '\n') break;
11921  }
11922  lex_gets_ptr = end - RSTRING_PTR(s);
11923  return rb_enc_str_new(beg, end - beg, enc);
11924 }
11925 
11926 static VALUE
11928 {
11929  VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11930  if (NIL_P(line)) return line;
11932 #ifndef RIPPER
11933  if (ruby_debug_lines) {
11936  }
11937  if (ruby_coverage) {
11939  }
11940 #endif
11941  return line;
11942 }
11943 
11944 #ifdef RIPPER
11946 #else
11948 
11949 static NODE*
11950 parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
11951 {
11952  struct parser_params *parser;
11953  NODE *node;
11954 
11955  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11957  lex_gets_ptr = 0;
11958  lex_input = s;
11959  lex_pbeg = lex_p = lex_pend = 0;
11961 
11962  node = yycompile(parser, fname, line);
11963  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11964 
11965  return node;
11966 }
11967 
11968 NODE*
11969 rb_compile_string(const char *f, VALUE s, int line)
11970 {
11973 }
11974 
11975 NODE*
11976 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11977 {
11978  return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
11979 }
11980 
11981 NODE*
11982 rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
11983 {
11985  return parser_compile_string(vparser, f, s, line);
11986 }
11987 
11988 NODE*
11989 rb_compile_cstr(const char *f, const char *s, int len, int line)
11990 {
11991  VALUE str = rb_str_new(s, len);
11993 }
11994 
11995 NODE*
11996 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
11997 {
11998  VALUE str = rb_str_new(s, len);
11999  return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line);
12000 }
12001 
12002 static VALUE
12004 {
12005  return rb_io_gets(io);
12006 }
12007 
12008 NODE*
12009 rb_compile_file(const char *f, VALUE file, int start)
12010 {
12011  VALUE volatile vparser = rb_parser_new();
12012 
12013  return rb_parser_compile_file(vparser, f, file, start);
12014 }
12015 
12016 NODE*
12017 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
12018 {
12019  return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start);
12020 }
12021 
12022 NODE*
12023 rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
12024 {
12025  struct parser_params *parser;
12026  NODE *node;
12027 
12028  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12030  lex_input = file;
12031  lex_pbeg = lex_p = lex_pend = 0;
12033 
12034  node = yycompile(parser, fname, start);
12035  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12036 
12037  return node;
12038 }
12039 #endif /* !RIPPER */
12040 
12041 #define STR_FUNC_ESCAPE 0x01
12042 #define STR_FUNC_EXPAND 0x02
12043 #define STR_FUNC_REGEXP 0x04
12044 #define STR_FUNC_QWORDS 0x08
12045 #define STR_FUNC_SYMBOL 0x10
12046 #define STR_FUNC_INDENT 0x20
12047 
12049  str_squote = (0),
12057 };
12058 
12059 static VALUE
12060 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
12061 {
12062  VALUE str;
12063 
12064  str = rb_enc_str_new(p, n, enc);
12065  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12067  }
12068  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12070  }
12071  }
12072 
12073  return str;
12074 }
12075 
12076 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
12077 #define lex_eol_p() (lex_p >= lex_pend)
12078 #define peek(c) peek_n((c), 0)
12079 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
12080 
12081 static inline int
12083 {
12084  int c;
12085 
12086  if (lex_p == lex_pend) {
12087  VALUE v = lex_nextline;
12088  lex_nextline = 0;
12089  if (!v) {
12090  if (parser->eofp)
12091  return -1;
12092 
12093  if (!lex_input || NIL_P(v = lex_getline(parser))) {
12094  parser->eofp = Qtrue;
12095  lex_goto_eol(parser);
12096  return -1;
12097  }
12098  }
12099  {
12100 #ifdef RIPPER
12101  if (parser->tokp < lex_pend) {
12102  if (NIL_P(parser->delayed)) {
12103  parser->delayed = rb_str_buf_new(1024);
12104  rb_enc_associate(parser->delayed, current_enc);
12105  rb_str_buf_cat(parser->delayed,
12106  parser->tokp, lex_pend - parser->tokp);
12107  parser->delayed_line = ruby_sourceline;
12108  parser->delayed_col = (int)(parser->tokp - lex_pbeg);
12109  }
12110  else {
12111  rb_str_buf_cat(parser->delayed,
12112  parser->tokp, lex_pend - parser->tokp);
12113  }
12114  }
12115 #endif
12116  if (heredoc_end > 0) {
12118  heredoc_end = 0;
12119  }
12120  ruby_sourceline++;
12121  parser->line_count++;
12122  lex_pbeg = lex_p = RSTRING_PTR(v);
12123  lex_pend = lex_p + RSTRING_LEN(v);
12124  ripper_flush(parser);
12125  lex_lastline = v;
12126  }
12127  }
12128  c = (unsigned char)*lex_p++;
12129  if (c == '\r' && peek('\n')) {
12130  lex_p++;
12131  c = '\n';
12132  }
12133 
12134  return c;
12135 }
12136 
12137 static void
12138 parser_pushback(struct parser_params *parser, int c)
12139 {
12140  if (c == -1) return;
12141  lex_p--;
12142  if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
12143  lex_p--;
12144  }
12145 }
12146 
12147 #define was_bol() (lex_p == lex_pbeg + 1)
12148 
12149 #define tokfix() (tokenbuf[tokidx]='\0')
12150 #define tok() tokenbuf
12151 #define toklen() tokidx
12152 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
12153 
12154 static char*
12156 {
12157  tokidx = 0;
12159  if (!tokenbuf) {
12160  toksiz = 60;
12161  tokenbuf = ALLOC_N(char, 60);
12162  }
12163  if (toksiz > 4096) {
12164  toksiz = 60;
12165  REALLOC_N(tokenbuf, char, 60);
12166  }
12167  return tokenbuf;
12168 }
12169 
12170 static char *
12171 parser_tokspace(struct parser_params *parser, int n)
12172 {
12173  tokidx += n;
12174 
12175  if (tokidx >= toksiz) {
12176  do {toksiz *= 2;} while (toksiz < tokidx);
12177  REALLOC_N(tokenbuf, char, toksiz);
12178  }
12179  return &tokenbuf[tokidx-n];
12180 }
12181 
12182 static void
12183 parser_tokadd(struct parser_params *parser, int c)
12184 {
12185  tokenbuf[tokidx++] = (char)c;
12186  if (tokidx >= toksiz) {
12187  toksiz *= 2;
12188  REALLOC_N(tokenbuf, char, toksiz);
12189  }
12190 }
12191 
12192 static int
12193 parser_tok_hex(struct parser_params *parser, size_t *numlen)
12194 {
12195  int c;
12196 
12197  c = scan_hex(lex_p, 2, numlen);
12198  if (!*numlen) {
12199  yyerror("invalid hex escape");
12200  return 0;
12201  }
12202  lex_p += *numlen;
12203  return c;
12204 }
12205 
12206 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
12207 
12208 /* return value is for ?\u3042 */
12209 static int
12211  int string_literal, int symbol_literal, int regexp_literal)
12212 {
12213  /*
12214  * If string_literal is true, then we allow multiple codepoints
12215  * in \u{}, and add the codepoints to the current token.
12216  * Otherwise we're parsing a character literal and return a single
12217  * codepoint without adding it
12218  */
12219 
12220  int codepoint;
12221  size_t numlen;
12222 
12223  if (regexp_literal) { tokadd('\\'); tokadd('u'); }
12224 
12225  if (peek('{')) { /* handle \u{...} form */
12226  do {
12227  if (regexp_literal) { tokadd(*lex_p); }
12228  nextc();
12229  codepoint = scan_hex(lex_p, 6, &numlen);
12230  if (numlen == 0) {
12231  yyerror("invalid Unicode escape");
12232  return 0;
12233  }
12234  if (codepoint > 0x10ffff) {
12235  yyerror("invalid Unicode codepoint (too large)");
12236  return 0;
12237  }
12238  lex_p += numlen;
12239  if (regexp_literal) {
12240  tokcopy((int)numlen);
12241  }
12242  else if (codepoint >= 0x80) {
12243  *encp = rb_utf8_encoding();
12244  if (string_literal) tokaddmbc(codepoint, *encp);
12245  }
12246  else if (string_literal) {
12247  tokadd(codepoint);
12248  }
12249  } while (string_literal && (peek(' ') || peek('\t')));
12250 
12251  if (!peek('}')) {
12252  yyerror("unterminated Unicode escape");
12253  return 0;
12254  }
12255 
12256  if (regexp_literal) { tokadd('}'); }
12257  nextc();
12258  }
12259  else { /* handle \uxxxx form */
12260  codepoint = scan_hex(lex_p, 4, &numlen);
12261  if (numlen < 4) {
12262  yyerror("invalid Unicode escape");
12263  return 0;
12264  }
12265  lex_p += 4;
12266  if (regexp_literal) {
12267  tokcopy(4);
12268  }
12269  else if (codepoint >= 0x80) {
12270  *encp = rb_utf8_encoding();
12271  if (string_literal) tokaddmbc(codepoint, *encp);
12272  }
12273  else if (string_literal) {
12274  tokadd(codepoint);
12275  }
12276  }
12277 
12278  return codepoint;
12279 }
12280 
12281 #define ESCAPE_CONTROL 1
12282 #define ESCAPE_META 2
12283 
12284 static int
12286  rb_encoding **encp)
12287 {
12288  int c;
12289  size_t numlen;
12290 
12291  switch (c = nextc()) {
12292  case '\\': /* Backslash */
12293  return c;
12294 
12295  case 'n': /* newline */
12296  return '\n';
12297 
12298  case 't': /* horizontal tab */
12299  return '\t';
12300 
12301  case 'r': /* carriage-return */
12302  return '\r';
12303 
12304  case 'f': /* form-feed */
12305  return '\f';
12306 
12307  case 'v': /* vertical tab */
12308  return '\13';
12309 
12310  case 'a': /* alarm(bell) */
12311  return '\007';
12312 
12313  case 'e': /* escape */
12314  return 033;
12315 
12316  case '0': case '1': case '2': case '3': /* octal constant */
12317  case '4': case '5': case '6': case '7':
12318  pushback(c);
12319  c = scan_oct(lex_p, 3, &numlen);
12320  lex_p += numlen;
12321  return c;
12322 
12323  case 'x': /* hex constant */
12324  c = tok_hex(&numlen);
12325  if (numlen == 0) return 0;
12326  return c;
12327 
12328  case 'b': /* backspace */
12329  return '\010';
12330 
12331  case 's': /* space */
12332  return ' ';
12333 
12334  case 'M':
12335  if (flags & ESCAPE_META) goto eof;
12336  if ((c = nextc()) != '-') {
12337  pushback(c);
12338  goto eof;
12339  }
12340  if ((c = nextc()) == '\\') {
12341  if (peek('u')) goto eof;
12342  return read_escape(flags|ESCAPE_META, encp) | 0x80;
12343  }
12344  else if (c == -1 || !ISASCII(c)) goto eof;
12345  else {
12346  return ((c & 0xff) | 0x80);
12347  }
12348 
12349  case 'C':
12350  if ((c = nextc()) != '-') {
12351  pushback(c);
12352  goto eof;
12353  }
12354  case 'c':
12355  if (flags & ESCAPE_CONTROL) goto eof;
12356  if ((c = nextc())== '\\') {
12357  if (peek('u')) goto eof;
12358  c = read_escape(flags|ESCAPE_CONTROL, encp);
12359  }
12360  else if (c == '?')
12361  return 0177;
12362  else if (c == -1 || !ISASCII(c)) goto eof;
12363  return c & 0x9f;
12364 
12365  eof:
12366  case -1:
12367  yyerror("Invalid escape character syntax");
12368  return '\0';
12369 
12370  default:
12371  return c;
12372  }
12373 }
12374 
12375 static void
12377 {
12378  int len = rb_enc_codelen(c, enc);
12379  rb_enc_mbcput(c, tokspace(len), enc);
12380 }
12381 
12382 static int
12384 {
12385  int c;
12386  int flags = 0;
12387  size_t numlen;
12388 
12389  first:
12390  switch (c = nextc()) {
12391  case '\n':
12392  return 0; /* just ignore */
12393 
12394  case '0': case '1': case '2': case '3': /* octal constant */
12395  case '4': case '5': case '6': case '7':
12396  {
12397  ruby_scan_oct(--lex_p, 3, &numlen);
12398  if (numlen == 0) goto eof;
12399  lex_p += numlen;
12400  tokcopy((int)numlen + 1);
12401  }
12402  return 0;
12403 
12404  case 'x': /* hex constant */
12405  {
12406  tok_hex(&numlen);
12407  if (numlen == 0) return -1;
12408  tokcopy((int)numlen + 2);
12409  }
12410  return 0;
12411 
12412  case 'M':
12413  if (flags & ESCAPE_META) goto eof;
12414  if ((c = nextc()) != '-') {
12415  pushback(c);
12416  goto eof;
12417  }
12418  tokcopy(3);
12419  flags |= ESCAPE_META;
12420  goto escaped;
12421 
12422  case 'C':
12423  if (flags & ESCAPE_CONTROL) goto eof;
12424  if ((c = nextc()) != '-') {
12425  pushback(c);
12426  goto eof;
12427  }
12428  tokcopy(3);
12429  goto escaped;
12430 
12431  case 'c':
12432  if (flags & ESCAPE_CONTROL) goto eof;
12433  tokcopy(2);
12434  flags |= ESCAPE_CONTROL;
12435  escaped:
12436  if ((c = nextc()) == '\\') {
12437  goto first;
12438  }
12439  else if (c == -1) goto eof;
12440  tokadd(c);
12441  return 0;
12442 
12443  eof:
12444  case -1:
12445  yyerror("Invalid escape character syntax");
12446  return -1;
12447 
12448  default:
12449  tokadd('\\');
12450  tokadd(c);
12451  }
12452  return 0;
12453 }
12454 
12455 static int
12457 {
12458  int kcode = 0;
12459  int kopt = 0;
12460  int options = 0;
12461  int c, opt, kc;
12462 
12463  newtok();
12464  while (c = nextc(), ISALPHA(c)) {
12465  if (c == 'o') {
12466  options |= RE_OPTION_ONCE;
12467  }
12468  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12469  if (kc >= 0) {
12470  if (kc != rb_ascii8bit_encindex()) kcode = c;
12471  kopt = opt;
12472  }
12473  else {
12474  options |= opt;
12475  }
12476  }
12477  else {
12478  tokadd(c);
12479  }
12480  }
12481  options |= kopt;
12482  pushback(c);
12483  if (toklen()) {
12484  tokfix();
12485  compile_error(PARSER_ARG "unknown regexp option%s - %s",
12486  toklen() > 1 ? "s" : "", tok());
12487  }
12488  return options | RE_OPTION_ENCODING(kcode);
12489 }
12490 
12491 static void
12493 {
12494  rb_str_free(str);
12495  rb_gc_force_recycle(str);
12496 }
12497 
12498 static int
12500 {
12501  int len = parser_precise_mbclen();
12502  if (!MBCLEN_CHARFOUND_P(len)) {
12503  compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12504  return -1;
12505  }
12506  tokadd(c);
12507  lex_p += --len;
12508  if (len > 0) tokcopy(len);
12509  return c;
12510 }
12511 
12512 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12513 
12514 static inline int
12516 {
12517  switch (c) {
12518  case '$': case '*': case '+': case '.':
12519  case '?': case '^': case '|':
12520  case ')': case ']': case '}': case '>':
12521  return TRUE;
12522  default:
12523  return FALSE;
12524  }
12525 }
12526 
12527 static int
12529  int func, int term, int paren, long *nest,
12530  rb_encoding **encp)
12531 {
12532  int c;
12533  int has_nonascii = 0;
12534  rb_encoding *enc = *encp;
12535  char *errbuf = 0;
12536  static const char mixed_msg[] = "%s mixed within %s source";
12537 
12538 #define mixed_error(enc1, enc2) if (!errbuf) { \
12539  size_t len = sizeof(mixed_msg) - 4; \
12540  len += strlen(rb_enc_name(enc1)); \
12541  len += strlen(rb_enc_name(enc2)); \
12542  errbuf = ALLOCA_N(char, len); \
12543  snprintf(errbuf, len, mixed_msg, \
12544  rb_enc_name(enc1), \
12545  rb_enc_name(enc2)); \
12546  yyerror(errbuf); \
12547  }
12548 #define mixed_escape(beg, enc1, enc2) do { \
12549  const char *pos = lex_p; \
12550  lex_p = (beg); \
12551  mixed_error((enc1), (enc2)); \
12552  lex_p = pos; \
12553  } while (0)
12554 
12555  while ((c = nextc()) != -1) {
12556  if (paren && c == paren) {
12557  ++*nest;
12558  }
12559  else if (c == term) {
12560  if (!nest || !*nest) {
12561  pushback(c);
12562  break;
12563  }
12564  --*nest;
12565  }
12566  else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12567  int c2 = *lex_p;
12568  if (c2 == '$' || c2 == '@' || c2 == '{') {
12569  pushback(c);
12570  break;
12571  }
12572  }
12573  else if (c == '\\') {
12574  const char *beg = lex_p - 1;
12575  c = nextc();
12576  switch (c) {
12577  case '\n':
12578  if (func & STR_FUNC_QWORDS) break;
12579  if (func & STR_FUNC_EXPAND) continue;
12580  tokadd('\\');
12581  break;
12582 
12583  case '\\':
12584  if (func & STR_FUNC_ESCAPE) tokadd(c);
12585  break;
12586 
12587  case 'u':
12588  if ((func & STR_FUNC_EXPAND) == 0) {
12589  tokadd('\\');
12590  break;
12591  }
12592  parser_tokadd_utf8(parser, &enc, 1,
12593  func & STR_FUNC_SYMBOL,
12594  func & STR_FUNC_REGEXP);
12595  if (has_nonascii && enc != *encp) {
12596  mixed_escape(beg, enc, *encp);
12597  }
12598  continue;
12599 
12600  default:
12601  if (c == -1) return -1;
12602  if (!ISASCII(c)) {
12603  if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12604  goto non_ascii;
12605  }
12606  if (func & STR_FUNC_REGEXP) {
12607  if (c == term && !simple_re_meta(c)) {
12608  tokadd(c);
12609  continue;
12610  }
12611  pushback(c);
12612  if ((c = tokadd_escape(&enc)) < 0)
12613  return -1;
12614  if (has_nonascii && enc != *encp) {
12615  mixed_escape(beg, enc, *encp);
12616  }
12617  continue;
12618  }
12619  else if (func & STR_FUNC_EXPAND) {
12620  pushback(c);
12621  if (func & STR_FUNC_ESCAPE) tokadd('\\');
12622  c = read_escape(0, &enc);
12623  }
12624  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12625  /* ignore backslashed spaces in %w */
12626  }
12627  else if (c != term && !(paren && c == paren)) {
12628  tokadd('\\');
12629  pushback(c);
12630  continue;
12631  }
12632  }
12633  }
12634  else if (!parser_isascii()) {
12635  non_ascii:
12636  has_nonascii = 1;
12637  if (enc != *encp) {
12638  mixed_error(enc, *encp);
12639  continue;
12640  }
12641  if (tokadd_mbchar(c) == -1) return -1;
12642  continue;
12643  }
12644  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12645  pushback(c);
12646  break;
12647  }
12648  if (c & 0x80) {
12649  has_nonascii = 1;
12650  if (enc != *encp) {
12651  mixed_error(enc, *encp);
12652  continue;
12653  }
12654  }
12655  tokadd(c);
12656  }
12657  *encp = enc;
12658  return c;
12659 }
12660 
12661 #define NEW_STRTERM(func, term, paren) \
12662  rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12663 
12664 #ifdef RIPPER
12665 static void
12666 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12667 {
12668  if (!NIL_P(parser->delayed)) {
12669  ptrdiff_t len = lex_p - parser->tokp;
12670  if (len > 0) {
12671  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12672  }
12673  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12674  parser->tokp = lex_p;
12675  }
12676 }
12677 
12678 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12679 #else
12680 #define flush_string_content(enc) ((void)(enc))
12681 #endif
12682 
12683 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12684 /* this can be shared with ripper, since it's independent from struct
12685  * parser_params. */
12686 #ifndef RIPPER
12687 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12688 #define SPECIAL_PUNCT(idx) ( \
12689  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12690  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12691  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12692  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12693  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12694  BIT('0', idx))
12695 const unsigned int ruby_global_name_punct_bits[] = {
12696  SPECIAL_PUNCT(0),
12697  SPECIAL_PUNCT(1),
12698  SPECIAL_PUNCT(2),
12699 };
12700 #undef BIT
12701 #undef SPECIAL_PUNCT
12702 #endif
12703 
12704 static inline int
12706 {
12707  if (c <= 0x20 || 0x7e < c) return 0;
12708  return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12709 }
12710 
12711 static int
12713 {
12714  int c;
12715  const char *p = lex_p;
12716 
12717  if (p + 1 >= lex_pend) return 0;
12718  c = *p++;
12719  switch (c) {
12720  case '$':
12721  if ((c = *p) == '-') {
12722  if (++p >= lex_pend) return 0;
12723  c = *p;
12724  }
12725  else if (is_global_name_punct(c) || ISDIGIT(c)) {
12726  return tSTRING_DVAR;
12727  }
12728  break;
12729  case '@':
12730  if ((c = *p) == '@') {
12731  if (++p >= lex_pend) return 0;
12732  c = *p;
12733  }
12734  break;
12735  case '{':
12736  lex_p = p;
12737  command_start = TRUE;
12738  return tSTRING_DBEG;
12739  default:
12740  return 0;
12741  }
12742  if (!ISASCII(c) || c == '_' || ISALPHA(c))
12743  return tSTRING_DVAR;
12744  return 0;
12745 }
12746 
12747 static int
12748 parser_parse_string(struct parser_params *parser, NODE *quote)
12749 {
12750  int func = (int)quote->nd_func;
12751  int term = nd_term(quote);
12752  int paren = nd_paren(quote);
12753  int c, space = 0;
12755 
12756  if (func == -1) return tSTRING_END;
12757  c = nextc();
12758  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12759  do {c = nextc();} while (ISSPACE(c));
12760  space = 1;
12761  }
12762  if (c == term && !quote->nd_nest) {
12763  if (func & STR_FUNC_QWORDS) {
12764  quote->nd_func = -1;
12765  return ' ';
12766  }
12767  if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12769  return tREGEXP_END;
12770  }
12771  if (space) {
12772  pushback(c);
12773  return ' ';
12774  }
12775  newtok();
12776  if ((func & STR_FUNC_EXPAND) && c == '#') {
12777  int t = parser_peek_variable_name(parser);
12778  if (t) return t;
12779  tokadd('#');
12780  c = nextc();
12781  }
12782  pushback(c);
12783  if (tokadd_string(func, term, paren, &quote->nd_nest,
12784  &enc) == -1) {
12785  ruby_sourceline = nd_line(quote);
12786  if (func & STR_FUNC_REGEXP) {
12787  if (parser->eofp)
12788  compile_error(PARSER_ARG "unterminated regexp meets end of file");
12789  return tREGEXP_END;
12790  }
12791  else {
12792  if (parser->eofp)
12793  compile_error(PARSER_ARG "unterminated string meets end of file");
12794  return tSTRING_END;
12795  }
12796  }
12797 
12798  tokfix();
12799  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12800  flush_string_content(enc);
12801 
12802  return tSTRING_CONTENT;
12803 }
12804 
12805 static int
12807 {
12808  int c = nextc(), term, func = 0;
12809  long len;
12810 
12811  if (c == '-') {
12812  c = nextc();
12813  func = STR_FUNC_INDENT;
12814  }
12815  switch (c) {
12816  case '\'':
12817  func |= str_squote; goto quoted;
12818  case '"':
12819  func |= str_dquote; goto quoted;
12820  case '`':
12821  func |= str_xquote;
12822  quoted:
12823  newtok();
12824  tokadd(func);
12825  term = c;
12826  while ((c = nextc()) != -1 && c != term) {
12827  if (tokadd_mbchar(c) == -1) return 0;
12828  }
12829  if (c == -1) {
12830  compile_error(PARSER_ARG "unterminated here document identifier");
12831  return 0;
12832  }
12833  break;
12834 
12835  default:
12836  if (!parser_is_identchar()) {
12837  pushback(c);
12838  if (func & STR_FUNC_INDENT) {
12839  pushback('-');
12840  }
12841  return 0;
12842  }
12843  newtok();
12844  term = '"';
12845  tokadd(func |= str_dquote);
12846  do {
12847  if (tokadd_mbchar(c) == -1) return 0;
12848  } while ((c = nextc()) != -1 && parser_is_identchar());
12849  pushback(c);
12850  break;
12851  }
12852 
12853  tokfix();
12854 #ifdef RIPPER
12855  ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12856 #endif
12857  len = lex_p - lex_pbeg;
12858  lex_goto_eol(parser);
12860  STR_NEW(tok(), toklen()), /* nd_lit */
12861  len, /* nd_nth */
12862  lex_lastline); /* nd_orig */
12864  ripper_flush(parser);
12865  return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12866 }
12867 
12868 static void
12870 {
12871  VALUE line;
12872 
12873  line = here->nd_orig;
12874  lex_lastline = line;
12875  lex_pbeg = RSTRING_PTR(line);
12876  lex_pend = lex_pbeg + RSTRING_LEN(line);
12877  lex_p = lex_pbeg + here->nd_nth;
12879  ruby_sourceline = nd_line(here);
12880  dispose_string(here->nd_lit);
12881  rb_gc_force_recycle((VALUE)here);
12882  ripper_flush(parser);
12883 }
12884 
12885 static int
12887  const char *eos, long len, int indent)
12888 {
12889  const char *p = lex_pbeg;
12890  long n;
12891 
12892  if (indent) {
12893  while (*p && ISSPACE(*p)) p++;
12894  }
12895  n = lex_pend - (p + len);
12896  if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12897  return strncmp(eos, p, len) == 0;
12898 }
12899 
12900 #ifdef RIPPER
12901 static void
12902 ripper_dispatch_heredoc_end(struct parser_params *parser)
12903 {
12904  if (!NIL_P(parser->delayed))
12905  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12906  lex_goto_eol(parser);
12907  ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12908 }
12909 
12910 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12911 #else
12912 #define dispatch_heredoc_end() ((void)0)
12913 #endif
12914 
12915 static int
12917 {
12918  int c, func, indent = 0;
12919  const char *eos, *p, *pend;
12920  long len;
12921  VALUE str = 0;
12923 
12924  eos = RSTRING_PTR(here->nd_lit);
12925  len = RSTRING_LEN(here->nd_lit) - 1;
12926  indent = (func = *eos++) & STR_FUNC_INDENT;
12927 
12928  if ((c = nextc()) == -1) {
12929  error:
12930  compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12931 #ifdef RIPPER
12932  if (NIL_P(parser->delayed)) {
12933  ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12934  }
12935  else {
12936  if (str ||
12937  ((len = lex_p - parser->tokp) > 0 &&
12938  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12939  rb_str_append(parser->delayed, str);
12940  }
12941  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12942  }
12943  lex_goto_eol(parser);
12944 #endif
12945  restore:
12947  lex_strterm = 0;
12948  return 0;
12949  }
12950  if (was_bol() && whole_match_p(eos, len, indent)) {
12953  return tSTRING_END;
12954  }
12955 
12956  if (!(func & STR_FUNC_EXPAND)) {
12957  do {
12959  pend = lex_pend;
12960  if (pend > p) {
12961  switch (pend[-1]) {
12962  case '\n':
12963  if (--pend == p || pend[-1] != '\r') {
12964  pend++;
12965  break;
12966  }
12967  case '\r':
12968  --pend;
12969  }
12970  }
12971  if (str)
12972  rb_str_cat(str, p, pend - p);
12973  else
12974  str = STR_NEW(p, pend - p);
12975  if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12976  lex_goto_eol(parser);
12977  if (nextc() == -1) {
12978  if (str) {
12979  dispose_string(str);
12980  str = 0;
12981  }
12982  goto error;
12983  }
12984  } while (!whole_match_p(eos, len, indent));
12985  }
12986  else {
12987  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12988  newtok();
12989  if (c == '#') {
12990  int t = parser_peek_variable_name(parser);
12991  if (t) return t;
12992  tokadd('#');
12993  c = nextc();
12994  }
12995  do {
12996  pushback(c);
12997  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
12998  if (parser->eofp) goto error;
12999  goto restore;
13000  }
13001  if (c != '\n') {
13002  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
13003  flush_string_content(enc);
13004  return tSTRING_CONTENT;
13005  }
13006  tokadd(nextc());
13007  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
13008  if ((c = nextc()) == -1) goto error;
13009  } while (!whole_match_p(eos, len, indent));
13010  str = STR_NEW3(tok(), toklen(), enc, func);
13011  }
13014  lex_strterm = NEW_STRTERM(-1, 0, 0);
13015  set_yylval_str(str);
13016  return tSTRING_CONTENT;
13017 }
13018 
13019 #include "lex.c"
13020 
13021 static void
13023 {
13024 #ifndef RIPPER
13025  rb_warning0("ambiguous first argument; put parentheses or even spaces");
13026 #else
13028 #endif
13029 }
13030 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
13031 
13032 static ID
13034 {
13035 #ifndef RIPPER
13036  if (!is_local_id(lhs))
13037  yyerror("formal argument must be local variable");
13038 #endif
13039  shadowing_lvar(lhs);
13040  return lhs;
13041 }
13042 
13043 static int
13044 lvar_defined_gen(struct parser_params *parser, ID id)
13045 {
13046  return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
13047 }
13048 
13049 /* emacsen -*- hack */
13050 static long
13051 parser_encode_length(struct parser_params *parser, const char *name, long len)
13052 {
13053  long nlen;
13054 
13055  if (len > 5 && name[nlen = len - 5] == '-') {
13056  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
13057  return nlen;
13058  }
13059  if (len > 4 && name[nlen = len - 4] == '-') {
13060  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
13061  return nlen;
13062  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
13063  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
13064  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
13065  return nlen;
13066  }
13067  return len;
13068 }
13069 
13070 static void
13071 parser_set_encode(struct parser_params *parser, const char *name)
13072 {
13073  int idx = rb_enc_find_index(name);
13074  rb_encoding *enc;
13075  VALUE excargs[3];
13076 
13077  if (idx < 0) {
13078  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
13079  error:
13080  excargs[0] = rb_eArgError;
13081  excargs[2] = rb_make_backtrace();
13082  rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
13083  rb_exc_raise(rb_make_exception(3, excargs));
13084  }
13085  enc = rb_enc_from_index(idx);
13086  if (!rb_enc_asciicompat(enc)) {
13087  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13088  goto error;
13089  }
13090  parser->enc = enc;
13091 #ifndef RIPPER
13092  if (ruby_debug_lines) {
13093  long i, n = RARRAY_LEN(ruby_debug_lines);
13094  const VALUE *p = RARRAY_PTR(ruby_debug_lines);
13095  for (i = 0; i < n; ++i) {
13096  rb_enc_associate_index(*p, idx);
13097  }
13098  }
13099 #endif
13100 }
13101 
13102 static int
13104 {
13105  const char *p = lex_pbeg, *pend = lex_p - 1;
13106  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13107  while (p < pend) {
13108  if (!ISSPACE(*p)) return 0;
13109  p++;
13110  }
13111  return 1;
13112 }
13113 
13114 #ifndef RIPPER
13115 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13116 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13117 
13118 static void
13119 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13120 {
13121  if (!comment_at_top(parser)) {
13122  return;
13123  }
13124  parser_set_encode(parser, val);
13125 }
13126 
13127 static void
13128 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13129 {
13130  int *p = &parser->parser_token_info_enabled;
13131 
13132  switch (*val) {
13133  case 't': case 'T':
13134  if (strcasecmp(val, "true") == 0) {
13135  *p = TRUE;
13136  return;
13137  }
13138  break;
13139  case 'f': case 'F':
13140  if (strcasecmp(val, "false") == 0) {
13141  *p = FALSE;
13142  return;
13143  }
13144  break;
13145  }
13146  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13147 }
13148 
13150  const char *name;
13153 };
13154 
13155 static const struct magic_comment magic_comments[] = {
13158  {"warn_indent", parser_set_token_info},
13159 };
13160 #endif
13161 
13162 static const char *
13163 magic_comment_marker(const char *str, long len)
13164 {
13165  long i = 2;
13166 
13167  while (i < len) {
13168  switch (str[i]) {
13169  case '-':
13170  if (str[i-1] == '*' && str[i-2] == '-') {
13171  return str + i + 1;
13172  }
13173  i += 2;
13174  break;
13175  case '*':
13176  if (i + 1 >= len) return 0;
13177  if (str[i+1] != '-') {
13178  i += 4;
13179  }
13180  else if (str[i-1] != '-') {
13181  i += 2;
13182  }
13183  else {
13184  return str + i + 2;
13185  }
13186  break;
13187  default:
13188  i += 3;
13189  break;
13190  }
13191  }
13192  return 0;
13193 }
13194 
13195 static int
13196 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13197 {
13198  VALUE name = 0, val = 0;
13199  const char *beg, *end, *vbeg, *vend;
13200 #define str_copy(_s, _p, _n) ((_s) \
13201  ? (void)(rb_str_resize((_s), (_n)), \
13202  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13203  : (void)((_s) = STR_NEW((_p), (_n))))
13204 
13205  if (len <= 7) return FALSE;
13206  if (!(beg = magic_comment_marker(str, len))) return FALSE;
13207  if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13208  str = beg;
13209  len = end - beg - 3;
13210 
13211  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13212  while (len > 0) {
13213 #ifndef RIPPER
13214  const struct magic_comment *p = magic_comments;
13215 #endif
13216  char *s;
13217  int i;
13218  long n = 0;
13219 
13220  for (; len > 0 && *str; str++, --len) {
13221  switch (*str) {
13222  case '\'': case '"': case ':': case ';':
13223  continue;
13224  }
13225  if (!ISSPACE(*str)) break;
13226  }
13227  for (beg = str; len > 0; str++, --len) {
13228  switch (*str) {
13229  case '\'': case '"': case ':': case ';':
13230  break;
13231  default:
13232  if (ISSPACE(*str)) break;
13233  continue;
13234  }
13235  break;
13236  }
13237  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13238  if (!len) break;
13239  if (*str != ':') continue;
13240 
13241  do str++; while (--len > 0 && ISSPACE(*str));
13242  if (!len) break;
13243  if (*str == '"') {
13244  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13245  if (*str == '\\') {
13246  --len;
13247  ++str;
13248  }
13249  }
13250  vend = str;
13251  if (len) {
13252  --len;
13253  ++str;
13254  }
13255  }
13256  else {
13257  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13258  vend = str;
13259  }
13260  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13261 
13262  n = end - beg;
13263  str_copy(name, beg, n);
13264  s = RSTRING_PTR(name);
13265  for (i = 0; i < n; ++i) {
13266  if (s[i] == '-') s[i] = '_';
13267  }
13268 #ifndef RIPPER
13269  do {
13270  if (STRNCASECMP(p->name, s, n) == 0) {
13271  n = vend - vbeg;
13272  if (p->length) {
13273  n = (*p->length)(parser, vbeg, n);
13274  }
13275  str_copy(val, vbeg, n);
13276  (*p->func)(parser, s, RSTRING_PTR(val));
13277  break;
13278  }
13279  } while (++p < magic_comments + numberof(magic_comments));
13280 #else
13281  str_copy(val, vbeg, vend - vbeg);
13282  dispatch2(magic_comment, name, val);
13283 #endif
13284  }
13285 
13286  return TRUE;
13287 }
13288 
13289 static void
13290 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13291 {
13292  int sep = 0;
13293  const char *beg = str;
13294  VALUE s;
13295 
13296  for (;;) {
13297  if (send - str <= 6) return;
13298  switch (str[6]) {
13299  case 'C': case 'c': str += 6; continue;
13300  case 'O': case 'o': str += 5; continue;
13301  case 'D': case 'd': str += 4; continue;
13302  case 'I': case 'i': str += 3; continue;
13303  case 'N': case 'n': str += 2; continue;
13304  case 'G': case 'g': str += 1; continue;
13305  case '=': case ':':
13306  sep = 1;
13307  str += 6;
13308  break;
13309  default:
13310  str += 6;
13311  if (ISSPACE(*str)) break;
13312  continue;
13313  }
13314  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13315  }
13316  for (;;) {
13317  do {
13318  if (++str >= send) return;
13319  } while (ISSPACE(*str));
13320  if (sep) break;
13321  if (*str != '=' && *str != ':') return;
13322  sep = 1;
13323  str++;
13324  }
13325  beg = str;
13326  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13327  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13328  parser_set_encode(parser, RSTRING_PTR(s));
13329  rb_str_resize(s, 0);
13330 }
13331 
13332 static void
13334 {
13335  int c = nextc();
13336  switch (c) {
13337  case '#':
13338  if (peek('!')) parser->has_shebang = 1;
13339  break;
13340  case 0xef: /* UTF-8 BOM marker */
13341  if (lex_pend - lex_p >= 2 &&
13342  (unsigned char)lex_p[0] == 0xbb &&
13343  (unsigned char)lex_p[1] == 0xbf) {
13344  parser->enc = rb_utf8_encoding();
13345  lex_p += 2;
13346  lex_pbeg = lex_p;
13347  return;
13348  }
13349  break;
13350  case EOF:
13351  return;
13352  }
13353  pushback(c);
13354  parser->enc = rb_enc_get(lex_lastline);
13355 }
13356 
13357 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13358 #define IS_END() IS_lex_state(EXPR_END_ANY)
13359 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13360 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13361 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13362 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13363 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13364 
13365 #ifndef RIPPER
13366 #define ambiguous_operator(op, syn) ( \
13367  rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
13368  rb_warning0("even though it seems like "syn""))
13369 #else
13370 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13371 #endif
13372 #define warn_balanced(op, syn) ((void) \
13373  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13374  space_seen && !ISSPACE(c) && \
13375  (ambiguous_operator(op, syn), 0)))
13376 
13377 static int
13379 {
13380  register int c;
13381  int space_seen = 0;
13382  int cmd_state;
13383  enum lex_state_e last_state;
13384  rb_encoding *enc;
13385  int mb;
13386 #ifdef RIPPER
13387  int fallthru = FALSE;
13388 #endif
13389 
13390  if (lex_strterm) {
13391  int token;
13392  if (nd_type(lex_strterm) == NODE_HEREDOC) {
13393  token = here_document(lex_strterm);
13394  if (token == tSTRING_END) {
13395  lex_strterm = 0;
13396  lex_state = EXPR_END;
13397  }
13398  }
13399  else {
13400  token = parse_string(lex_strterm);
13401  if (token == tSTRING_END || token == tREGEXP_END) {
13403  lex_strterm = 0;
13404  lex_state = EXPR_END;
13405  }
13406  }
13407  return token;
13408  }
13409  cmd_state = command_start;
13410  command_start = FALSE;
13411  retry:
13412  last_state = lex_state;
13413  switch (c = nextc()) {
13414  case '\0': /* NUL */
13415  case '\004': /* ^D */
13416  case '\032': /* ^Z */
13417  case -1: /* end of script. */
13418  return 0;
13419 
13420  /* white spaces */
13421  case ' ': case '\t': case '\f': case '\r':
13422  case '\13': /* '\v' */
13423  space_seen = 1;
13424 #ifdef RIPPER
13425  while ((c = nextc())) {
13426  switch (c) {
13427  case ' ': case '\t': case '\f': case '\r':
13428  case '\13': /* '\v' */
13429  break;
13430  default:
13431  goto outofloop;
13432  }
13433  }
13434  outofloop:
13435  pushback(c);
13436  ripper_dispatch_scan_event(parser, tSP);
13437 #endif
13438  goto retry;
13439 
13440  case '#': /* it's a comment */
13441  /* no magic_comment in shebang line */
13442  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13443  if (comment_at_top(parser)) {
13444  set_file_encoding(parser, lex_p, lex_pend);
13445  }
13446  }
13447  lex_p = lex_pend;
13448 #ifdef RIPPER
13449  ripper_dispatch_scan_event(parser, tCOMMENT);
13450  fallthru = TRUE;
13451 #endif
13452  /* fall through */
13453  case '\n':
13454  if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT)) {
13455 #ifdef RIPPER
13456  if (!fallthru) {
13457  ripper_dispatch_scan_event(parser, tIGNORED_NL);
13458  }
13459  fallthru = FALSE;
13460 #endif
13461  goto retry;
13462  }
13463  while ((c = nextc())) {
13464  switch (c) {
13465  case ' ': case '\t': case '\f': case '\r':
13466  case '\13': /* '\v' */
13467  space_seen = 1;
13468  break;
13469  case '.': {
13470  if ((c = nextc()) != '.') {
13471  pushback(c);
13472  pushback('.');
13473  goto retry;
13474  }
13475  }
13476  default:
13477  --ruby_sourceline;
13479  case -1: /* EOF no decrement*/
13480  lex_goto_eol(parser);
13481 #ifdef RIPPER
13482  if (c != -1) {
13483  parser->tokp = lex_p;
13484  }
13485 #endif
13486  goto normal_newline;
13487  }
13488  }
13489  normal_newline:
13490  command_start = TRUE;
13491  lex_state = EXPR_BEG;
13492  return '\n';
13493 
13494  case '*':
13495  if ((c = nextc()) == '*') {
13496  if ((c = nextc()) == '=') {
13498  lex_state = EXPR_BEG;
13499  return tOP_ASGN;
13500  }
13501  pushback(c);
13502  if (IS_SPCARG(c)) {
13503  rb_warning0("`**' interpreted as argument prefix");
13504  c = tDSTAR;
13505  }
13506  else if (IS_BEG()) {
13507  c = tDSTAR;
13508  }
13509  else {
13510  warn_balanced("**", "argument prefix");
13511  c = tPOW;
13512  }
13513  }
13514  else {
13515  if (c == '=') {
13516  set_yylval_id('*');
13517  lex_state = EXPR_BEG;
13518  return tOP_ASGN;
13519  }
13520  pushback(c);
13521  if (IS_SPCARG(c)) {
13522  rb_warning0("`*' interpreted as argument prefix");
13523  c = tSTAR;
13524  }
13525  else if (IS_BEG()) {
13526  c = tSTAR;
13527  }
13528  else {
13529  warn_balanced("*", "argument prefix");
13530  c = '*';
13531  }
13532  }
13533  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13534  return c;
13535 
13536  case '!':
13537  c = nextc();
13538  if (IS_AFTER_OPERATOR()) {
13539  lex_state = EXPR_ARG;
13540  if (c == '@') {
13541  return '!';
13542  }
13543  }
13544  else {
13545  lex_state = EXPR_BEG;
13546  }
13547  if (c == '=') {
13548  return tNEQ;
13549  }
13550  if (c == '~') {
13551  return tNMATCH;
13552  }
13553  pushback(c);
13554  return '!';
13555 
13556  case '=':
13557  if (was_bol()) {
13558  /* skip embedded rd document */
13559  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13560 #ifdef RIPPER
13561  int first_p = TRUE;
13562 
13563  lex_goto_eol(parser);
13564  ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13565 #endif
13566  for (;;) {
13567  lex_goto_eol(parser);
13568 #ifdef RIPPER
13569  if (!first_p) {
13570  ripper_dispatch_scan_event(parser, tEMBDOC);
13571  }
13572  first_p = FALSE;
13573 #endif
13574  c = nextc();
13575  if (c == -1) {
13576  compile_error(PARSER_ARG "embedded document meets end of file");
13577  return 0;
13578  }
13579  if (c != '=') continue;
13580  if (strncmp(lex_p, "end", 3) == 0 &&
13581  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13582  break;
13583  }
13584  }
13585  lex_goto_eol(parser);
13586 #ifdef RIPPER
13587  ripper_dispatch_scan_event(parser, tEMBDOC_END);
13588 #endif
13589  goto retry;
13590  }
13591  }
13592 
13593  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13594  if ((c = nextc()) == '=') {
13595  if ((c = nextc()) == '=') {
13596  return tEQQ;
13597  }
13598  pushback(c);
13599  return tEQ;
13600  }
13601  if (c == '~') {
13602  return tMATCH;
13603  }
13604  else if (c == '>') {
13605  return tASSOC;
13606  }
13607  pushback(c);
13608  return '=';
13609 
13610  case '<':
13611  last_state = lex_state;
13612  c = nextc();
13613  if (c == '<' &&
13614  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13615  !IS_END() &&
13616  (!IS_ARG() || space_seen)) {
13617  int token = heredoc_identifier();
13618  if (token) return token;
13619  }
13620  if (IS_AFTER_OPERATOR()) {
13621  lex_state = EXPR_ARG;
13622  }
13623  else {
13624  if (IS_lex_state(EXPR_CLASS))
13625  command_start = TRUE;
13626  lex_state = EXPR_BEG;
13627  }
13628  if (c == '=') {
13629  if ((c = nextc()) == '>') {
13630  return tCMP;
13631  }
13632  pushback(c);
13633  return tLEQ;
13634  }
13635  if (c == '<') {
13636  if ((c = nextc()) == '=') {
13638  lex_state = EXPR_BEG;
13639  return tOP_ASGN;
13640  }
13641  pushback(c);
13642  warn_balanced("<<", "here document");
13643  return tLSHFT;
13644  }
13645  pushback(c);
13646  return '<';
13647 
13648  case '>':
13649  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13650  if ((c = nextc()) == '=') {
13651  return tGEQ;
13652  }
13653  if (c == '>') {
13654  if ((c = nextc()) == '=') {
13656  lex_state = EXPR_BEG;
13657  return tOP_ASGN;
13658  }
13659  pushback(c);
13660  return tRSHFT;
13661  }
13662  pushback(c);
13663  return '>';
13664 
13665  case '"':
13666  lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13667  return tSTRING_BEG;
13668 
13669  case '`':
13670  if (IS_lex_state(EXPR_FNAME)) {
13671  lex_state = EXPR_ENDFN;
13672  return c;
13673  }
13674  if (IS_lex_state(EXPR_DOT)) {
13675  if (cmd_state)
13676  lex_state = EXPR_CMDARG;
13677  else
13678  lex_state = EXPR_ARG;
13679  return c;
13680  }
13681  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13682  return tXSTRING_BEG;
13683 
13684  case '\'':
13685  lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13686  return tSTRING_BEG;
13687 
13688  case '?':
13689  if (IS_END()) {
13690  lex_state = EXPR_VALUE;
13691  return '?';
13692  }
13693  c = nextc();
13694  if (c == -1) {
13695  compile_error(PARSER_ARG "incomplete character syntax");
13696  return 0;
13697  }
13698  if (rb_enc_isspace(c, current_enc)) {
13699  if (!IS_ARG()) {
13700  int c2 = 0;
13701  switch (c) {
13702  case ' ':
13703  c2 = 's';
13704  break;
13705  case '\n':
13706  c2 = 'n';
13707  break;
13708  case '\t':
13709  c2 = 't';
13710  break;
13711  case '\v':
13712  c2 = 'v';
13713  break;
13714  case '\r':
13715  c2 = 'r';
13716  break;
13717  case '\f':
13718  c2 = 'f';
13719  break;
13720  }
13721  if (c2) {
13722  rb_warnI("invalid character syntax; use ?\\%c", c2);
13723  }
13724  }
13725  ternary:
13726  pushback(c);
13727  lex_state = EXPR_VALUE;
13728  return '?';
13729  }
13730  newtok();
13731  enc = current_enc;
13732  if (!parser_isascii()) {
13733  if (tokadd_mbchar(c) == -1) return 0;
13734  }
13735  else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13737  goto ternary;
13738  }
13739  else if (c == '\\') {
13740  if (peek('u')) {
13741  nextc();
13742  c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13743  if (0x80 <= c) {
13744  tokaddmbc(c, enc);
13745  }
13746  else {
13747  tokadd(c);
13748  }
13749  }
13750  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13751  nextc();
13752  if (tokadd_mbchar(c) == -1) return 0;
13753  }
13754  else {
13755  c = read_escape(0, &enc);
13756  tokadd(c);
13757  }
13758  }
13759  else {
13760  tokadd(c);
13761  }
13762  tokfix();
13763  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13764  lex_state = EXPR_END;
13765  return tCHAR;
13766 
13767  case '&':
13768  if ((c = nextc()) == '&') {
13769  lex_state = EXPR_BEG;
13770  if ((c = nextc()) == '=') {
13772  lex_state = EXPR_BEG;
13773  return tOP_ASGN;
13774  }
13775  pushback(c);
13776  return tANDOP;
13777  }
13778  else if (c == '=') {
13779  set_yylval_id('&');
13780  lex_state = EXPR_BEG;
13781  return tOP_ASGN;
13782  }
13783  pushback(c);
13784  if (IS_SPCARG(c)) {
13785  rb_warning0("`&' interpreted as argument prefix");
13786  c = tAMPER;
13787  }
13788  else if (IS_BEG()) {
13789  c = tAMPER;
13790  }
13791  else {
13792  warn_balanced("&", "argument prefix");
13793  c = '&';
13794  }
13795  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13796  return c;
13797 
13798  case '|':
13799  if ((c = nextc()) == '|') {
13800  lex_state = EXPR_BEG;
13801  if ((c = nextc()) == '=') {
13803  lex_state = EXPR_BEG;
13804  return tOP_ASGN;
13805  }
13806  pushback(c);
13807  return tOROP;
13808  }
13809  if (c == '=') {
13810  set_yylval_id('|');
13811  lex_state = EXPR_BEG;
13812  return tOP_ASGN;
13813  }
13814  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13815  pushback(c);
13816  return '|';
13817 
13818  case '+':
13819  c = nextc();
13820  if (IS_AFTER_OPERATOR()) {
13821  lex_state = EXPR_ARG;
13822  if (c == '@') {
13823  return tUPLUS;
13824  }
13825  pushback(c);
13826  return '+';
13827  }
13828  if (c == '=') {
13829  set_yylval_id('+');
13830  lex_state = EXPR_BEG;
13831  return tOP_ASGN;
13832  }
13833  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13834  lex_state = EXPR_BEG;
13835  pushback(c);
13836  if (c != -1 && ISDIGIT(c)) {
13837  c = '+';
13838  goto start_num;
13839  }
13840  return tUPLUS;
13841  }
13842  lex_state = EXPR_BEG;
13843  pushback(c);
13844  warn_balanced("+", "unary operator");
13845  return '+';
13846 
13847  case '-':
13848  c = nextc();
13849  if (IS_AFTER_OPERATOR()) {
13850  lex_state = EXPR_ARG;
13851  if (c == '@') {
13852  return tUMINUS;
13853  }
13854  pushback(c);
13855  return '-';
13856  }
13857  if (c == '=') {
13858  set_yylval_id('-');
13859  lex_state = EXPR_BEG;
13860  return tOP_ASGN;
13861  }
13862  if (c == '>') {
13863  lex_state = EXPR_ENDFN;
13864  return tLAMBDA;
13865  }
13866  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13867  lex_state = EXPR_BEG;
13868  pushback(c);
13869  if (c != -1 && ISDIGIT(c)) {
13870  return tUMINUS_NUM;
13871  }
13872  return tUMINUS;
13873  }
13874  lex_state = EXPR_BEG;
13875  pushback(c);
13876  warn_balanced("-", "unary operator");
13877  return '-';
13878 
13879  case '.':
13880  lex_state = EXPR_BEG;
13881  if ((c = nextc()) == '.') {
13882  if ((c = nextc()) == '.') {
13883  return tDOT3;
13884  }
13885  pushback(c);
13886  return tDOT2;
13887  }
13888  pushback(c);
13889  if (c != -1 && ISDIGIT(c)) {
13890  yyerror("no .<digit> floating literal anymore; put 0 before dot");
13891  }
13892  lex_state = EXPR_DOT;
13893  return '.';
13894 
13895  start_num:
13896  case '0': case '1': case '2': case '3': case '4':
13897  case '5': case '6': case '7': case '8': case '9':
13898  {
13899  int is_float, seen_point, seen_e, nondigit;
13900 
13901  is_float = seen_point = seen_e = nondigit = 0;
13902  lex_state = EXPR_END;
13903  newtok();
13904  if (c == '-' || c == '+') {
13905  tokadd(c);
13906  c = nextc();
13907  }
13908  if (c == '0') {
13909 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13910  int start = toklen();
13911  c = nextc();
13912  if (c == 'x' || c == 'X') {
13913  /* hexadecimal */
13914  c = nextc();
13915  if (c != -1 && ISXDIGIT(c)) {
13916  do {
13917  if (c == '_') {
13918  if (nondigit) break;
13919  nondigit = c;
13920  continue;
13921  }
13922  if (!ISXDIGIT(c)) break;
13923  nondigit = 0;
13924  tokadd(c);
13925  } while ((c = nextc()) != -1);
13926  }
13927  pushback(c);
13928  tokfix();
13929  if (toklen() == start) {
13930  no_digits();
13931  }
13932  else if (nondigit) goto trailing_uc;
13934  return tINTEGER;
13935  }
13936  if (c == 'b' || c == 'B') {
13937  /* binary */
13938  c = nextc();
13939  if (c == '0' || c == '1') {
13940  do {
13941  if (c == '_') {
13942  if (nondigit) break;
13943  nondigit = c;
13944  continue;
13945  }
13946  if (c != '0' && c != '1') break;
13947  nondigit = 0;
13948  tokadd(c);
13949  } while ((c = nextc()) != -1);
13950  }
13951  pushback(c);
13952  tokfix();
13953  if (toklen() == start) {
13954  no_digits();
13955  }
13956  else if (nondigit) goto trailing_uc;
13958  return tINTEGER;
13959  }
13960  if (c == 'd' || c == 'D') {
13961  /* decimal */
13962  c = nextc();
13963  if (c != -1 && ISDIGIT(c)) {
13964  do {
13965  if (c == '_') {
13966  if (nondigit) break;
13967  nondigit = c;
13968  continue;
13969  }
13970  if (!ISDIGIT(c)) break;
13971  nondigit = 0;
13972  tokadd(c);
13973  } while ((c = nextc()) != -1);
13974  }
13975  pushback(c);
13976  tokfix();
13977  if (toklen() == start) {
13978  no_digits();
13979  }
13980  else if (nondigit) goto trailing_uc;
13982  return tINTEGER;
13983  }
13984  if (c == '_') {
13985  /* 0_0 */
13986  goto octal_number;
13987  }
13988  if (c == 'o' || c == 'O') {
13989  /* prefixed octal */
13990  c = nextc();
13991  if (c == -1 || c == '_' || !ISDIGIT(c)) {
13992  no_digits();
13993  }
13994  }
13995  if (c >= '0' && c <= '7') {
13996  /* octal */
13997  octal_number:
13998  do {
13999  if (c == '_') {
14000  if (nondigit) break;
14001  nondigit = c;
14002  continue;
14003  }
14004  if (c < '0' || c > '9') break;
14005  if (c > '7') goto invalid_octal;
14006  nondigit = 0;
14007  tokadd(c);
14008  } while ((c = nextc()) != -1);
14009  if (toklen() > start) {
14010  pushback(c);
14011  tokfix();
14012  if (nondigit) goto trailing_uc;
14014  return tINTEGER;
14015  }
14016  if (nondigit) {
14017  pushback(c);
14018  goto trailing_uc;
14019  }
14020  }
14021  if (c > '7' && c <= '9') {
14022  invalid_octal:
14023  yyerror("Invalid octal digit");
14024  }
14025  else if (c == '.' || c == 'e' || c == 'E') {
14026  tokadd('0');
14027  }
14028  else {
14029  pushback(c);
14031  return tINTEGER;
14032  }
14033  }
14034 
14035  for (;;) {
14036  switch (c) {
14037  case '0': case '1': case '2': case '3': case '4':
14038  case '5': case '6': case '7': case '8': case '9':
14039  nondigit = 0;
14040  tokadd(c);
14041  break;
14042 
14043  case '.':
14044  if (nondigit) goto trailing_uc;
14045  if (seen_point || seen_e) {
14046  goto decode_num;
14047  }
14048  else {
14049  int c0 = nextc();
14050  if (c0 == -1 || !ISDIGIT(c0)) {
14051  pushback(c0);
14052  goto decode_num;
14053  }
14054  c = c0;
14055  }
14056  tokadd('.');
14057  tokadd(c);
14058  is_float++;
14059  seen_point++;
14060  nondigit = 0;
14061  break;
14062 
14063  case 'e':
14064  case 'E':
14065  if (nondigit) {
14066  pushback(c);
14067  c = nondigit;
14068  goto decode_num;
14069  }
14070  if (seen_e) {
14071  goto decode_num;
14072  }
14073  tokadd(c);
14074  seen_e++;
14075  is_float++;
14076  nondigit = c;
14077  c = nextc();
14078  if (c != '-' && c != '+') continue;
14079  tokadd(c);
14080  nondigit = c;
14081  break;
14082 
14083  case '_': /* `_' in number just ignored */
14084  if (nondigit) goto decode_num;
14085  nondigit = c;
14086  break;
14087 
14088  default:
14089  goto decode_num;
14090  }
14091  c = nextc();
14092  }
14093 
14094  decode_num:
14095  pushback(c);
14096  if (nondigit) {
14097  char tmp[30];
14098  trailing_uc:
14099  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14100  yyerror(tmp);
14101  }
14102  tokfix();
14103  if (is_float) {
14104  double d = strtod(tok(), 0);
14105  if (errno == ERANGE) {
14106  rb_warningS("Float %s out of range", tok());
14107  errno = 0;
14108  }
14110  return tFLOAT;
14111  }
14113  return tINTEGER;
14114  }
14115 
14116  case ')':
14117  case ']':
14118  paren_nest--;
14119  case '}':
14120  COND_LEXPOP();
14121  CMDARG_LEXPOP();
14122  if (c == ')')
14123  lex_state = EXPR_ENDFN;
14124  else
14125  lex_state = EXPR_ENDARG;
14126  if (c == '}') {
14127  if (!brace_nest--) c = tSTRING_DEND;
14128  }
14129  return c;
14130 
14131  case ':':
14132  c = nextc();
14133  if (c == ':') {
14134  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14135  lex_state = EXPR_BEG;
14136  return tCOLON3;
14137  }
14138  lex_state = EXPR_DOT;
14139  return tCOLON2;
14140  }
14141  if (IS_END() || ISSPACE(c)) {
14142  pushback(c);
14143  warn_balanced(":", "symbol literal");
14144  lex_state = EXPR_BEG;
14145  return ':';
14146  }
14147  switch (c) {
14148  case '\'':
14149  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14150  break;
14151  case '"':
14152  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14153  break;
14154  default:
14155  pushback(c);
14156  break;
14157  }
14158  lex_state = EXPR_FNAME;
14159  return tSYMBEG;
14160 
14161  case '/':
14162  if (IS_lex_state(EXPR_BEG_ANY)) {
14163  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14164  return tREGEXP_BEG;
14165  }
14166  if ((c = nextc()) == '=') {
14167  set_yylval_id('/');
14168  lex_state = EXPR_BEG;
14169  return tOP_ASGN;
14170  }
14171  pushback(c);
14172  if (IS_SPCARG(c)) {
14173  (void)arg_ambiguous();
14174  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14175  return tREGEXP_BEG;
14176  }
14177  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14178  warn_balanced("/", "regexp literal");
14179  return '/';
14180 
14181  case '^':
14182  if ((c = nextc()) == '=') {
14183  set_yylval_id('^');
14184  lex_state = EXPR_BEG;
14185  return tOP_ASGN;
14186  }
14187  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14188  pushback(c);
14189  return '^';
14190 
14191  case ';':
14192  lex_state = EXPR_BEG;
14193  command_start = TRUE;
14194  return ';';
14195 
14196  case ',':
14197  lex_state = EXPR_BEG;
14198  return ',';
14199 
14200  case '~':
14201  if (IS_AFTER_OPERATOR()) {
14202  if ((c = nextc()) != '@') {
14203  pushback(c);
14204  }
14205  lex_state = EXPR_ARG;
14206  }
14207  else {
14208  lex_state = EXPR_BEG;
14209  }
14210  return '~';
14211 
14212  case '(':
14213  if (IS_BEG()) {
14214  c = tLPAREN;
14215  }
14216  else if (IS_SPCARG(-1)) {
14217  c = tLPAREN_ARG;
14218  }
14219  paren_nest++;
14220  COND_PUSH(0);
14221  CMDARG_PUSH(0);
14222  lex_state = EXPR_BEG;
14223  return c;
14224 
14225  case '[':
14226  paren_nest++;
14227  if (IS_AFTER_OPERATOR()) {
14228  lex_state = EXPR_ARG;
14229  if ((c = nextc()) == ']') {
14230  if ((c = nextc()) == '=') {
14231  return tASET;
14232  }
14233  pushback(c);
14234  return tAREF;
14235  }
14236  pushback(c);
14237  return '[';
14238  }
14239  else if (IS_BEG()) {
14240  c = tLBRACK;
14241  }
14242  else if (IS_ARG() && space_seen) {
14243  c = tLBRACK;
14244  }
14245  lex_state = EXPR_BEG;
14246  COND_PUSH(0);
14247  CMDARG_PUSH(0);
14248  return c;
14249 
14250  case '{':
14251  ++brace_nest;
14252  if (lpar_beg && lpar_beg == paren_nest) {
14253  lex_state = EXPR_BEG;
14254  lpar_beg = 0;
14255  --paren_nest;
14256  COND_PUSH(0);
14257  CMDARG_PUSH(0);
14258  return tLAMBEG;
14259  }
14260  if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14261  c = '{'; /* block (primary) */
14262  else if (IS_lex_state(EXPR_ENDARG))
14263  c = tLBRACE_ARG; /* block (expr) */
14264  else
14265  c = tLBRACE; /* hash */
14266  COND_PUSH(0);
14267  CMDARG_PUSH(0);
14268  lex_state = EXPR_BEG;
14269  if (c != tLBRACE) command_start = TRUE;
14270  return c;
14271 
14272  case '\\':
14273  c = nextc();
14274  if (c == '\n') {
14275  space_seen = 1;
14276 #ifdef RIPPER
14277  ripper_dispatch_scan_event(parser, tSP);
14278 #endif
14279  goto retry; /* skip \\n */
14280  }
14281  pushback(c);
14282  return '\\';
14283 
14284  case '%':
14285  if (IS_lex_state(EXPR_BEG_ANY)) {
14286  int term;
14287  int paren;
14288 
14289  c = nextc();
14290  quotation:
14291  if (c == -1 || !ISALNUM(c)) {
14292  term = c;
14293  c = 'Q';
14294  }
14295  else {
14296  term = nextc();
14297  if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14298  yyerror("unknown type of %string");
14299  return 0;
14300  }
14301  }
14302  if (c == -1 || term == -1) {
14303  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14304  return 0;
14305  }
14306  paren = term;
14307  if (term == '(') term = ')';
14308  else if (term == '[') term = ']';
14309  else if (term == '{') term = '}';
14310  else if (term == '<') term = '>';
14311  else paren = 0;
14312 
14313  switch (c) {
14314  case 'Q':
14315  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14316  return tSTRING_BEG;
14317 
14318  case 'q':
14319  lex_strterm = NEW_STRTERM(str_squote, term, paren);
14320  return tSTRING_BEG;
14321 
14322  case 'W':
14323  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14324  do {c = nextc();} while (ISSPACE(c));
14325  pushback(c);
14326  return tWORDS_BEG;
14327 
14328  case 'w':
14329  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14330  do {c = nextc();} while (ISSPACE(c));
14331  pushback(c);
14332  return tQWORDS_BEG;
14333 
14334  case 'I':
14335  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14336  do {c = nextc();} while (ISSPACE(c));
14337  pushback(c);
14338  return tSYMBOLS_BEG;
14339 
14340  case 'i':
14341  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14342  do {c = nextc();} while (ISSPACE(c));
14343  pushback(c);
14344  return tQSYMBOLS_BEG;
14345 
14346  case 'x':
14347  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14348  return tXSTRING_BEG;
14349 
14350  case 'r':
14351  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14352  return tREGEXP_BEG;
14353 
14354  case 's':
14355  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14356  lex_state = EXPR_FNAME;
14357  return tSYMBEG;
14358 
14359  default:
14360  yyerror("unknown type of %string");
14361  return 0;
14362  }
14363  }
14364  if ((c = nextc()) == '=') {
14365  set_yylval_id('%');
14366  lex_state = EXPR_BEG;
14367  return tOP_ASGN;
14368  }
14369  if (IS_SPCARG(c)) {
14370  goto quotation;
14371  }
14372  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14373  pushback(c);
14374  warn_balanced("%%", "string literal");
14375  return '%';
14376 
14377  case '$':
14378  lex_state = EXPR_END;
14379  newtok();
14380  c = nextc();
14381  switch (c) {
14382  case '_': /* $_: last read line string */
14383  c = nextc();
14384  if (parser_is_identchar()) {
14385  tokadd('$');
14386  tokadd('_');
14387  break;
14388  }
14389  pushback(c);
14390  c = '_';
14391  /* fall through */
14392  case '~': /* $~: match-data */
14393  case '*': /* $*: argv */
14394  case '$': /* $$: pid */
14395  case '?': /* $?: last status */
14396  case '!': /* $!: error string */
14397  case '@': /* $@: error position */
14398  case '/': /* $/: input record separator */
14399  case '\\': /* $\: output record separator */
14400  case ';': /* $;: field separator */
14401  case ',': /* $,: output field separator */
14402  case '.': /* $.: last read line number */
14403  case '=': /* $=: ignorecase */
14404  case ':': /* $:: load path */
14405  case '<': /* $<: reading filename */
14406  case '>': /* $>: default output handle */
14407  case '\"': /* $": already loaded files */
14408  tokadd('$');
14409  tokadd(c);
14410  tokfix();
14412  return tGVAR;
14413 
14414  case '-':
14415  tokadd('$');
14416  tokadd(c);
14417  c = nextc();
14418  if (parser_is_identchar()) {
14419  if (tokadd_mbchar(c) == -1) return 0;
14420  }
14421  else {
14422  pushback(c);
14423  }
14424  gvar:
14425  tokfix();
14427  return tGVAR;
14428 
14429  case '&': /* $&: last match */
14430  case '`': /* $`: string before last match */
14431  case '\'': /* $': string after last match */
14432  case '+': /* $+: string matches last paren. */
14433  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14434  tokadd('$');
14435  tokadd(c);
14436  goto gvar;
14437  }
14439  return tBACK_REF;
14440 
14441  case '1': case '2': case '3':
14442  case '4': case '5': case '6':
14443  case '7': case '8': case '9':
14444  tokadd('$');
14445  do {
14446  tokadd(c);
14447  c = nextc();
14448  } while (c != -1 && ISDIGIT(c));
14449  pushback(c);
14450  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14451  tokfix();
14452  set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
14453  return tNTH_REF;
14454 
14455  default:
14456  if (!parser_is_identchar()) {
14457  pushback(c);
14458  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14459  return 0;
14460  }
14461  case '0':
14462  tokadd('$');
14463  }
14464  break;
14465 
14466  case '@':
14467  c = nextc();
14468  newtok();
14469  tokadd('@');
14470  if (c == '@') {
14471  tokadd('@');
14472  c = nextc();
14473  }
14474  if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14475  pushback(c);
14476  if (tokidx == 1) {
14477  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14478  }
14479  else {
14480  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14481  }
14482  return 0;
14483  }
14484  break;
14485 
14486  case '_':
14487  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14488  ruby__end__seen = 1;
14489  parser->eofp = Qtrue;
14490 #ifndef RIPPER
14491  return -1;
14492 #else
14493  lex_goto_eol(parser);
14494  ripper_dispatch_scan_event(parser, k__END__);
14495  return 0;
14496 #endif
14497  }
14498  newtok();
14499  break;
14500 
14501  default:
14502  if (!parser_is_identchar()) {
14503  compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14504  goto retry;
14505  }
14506 
14507  newtok();
14508  break;
14509  }
14510 
14511  mb = ENC_CODERANGE_7BIT;
14512  do {
14513  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14514  if (tokadd_mbchar(c) == -1) return 0;
14515  c = nextc();
14516  } while (parser_is_identchar());
14517  switch (tok()[0]) {
14518  case '@': case '$':
14519  pushback(c);
14520  break;
14521  default:
14522  if ((c == '!' || c == '?') && !peek('=')) {
14523  tokadd(c);
14524  }
14525  else {
14526  pushback(c);
14527  }
14528  }
14529  tokfix();
14530 
14531  {
14532  int result = 0;
14533 
14534  last_state = lex_state;
14535  switch (tok()[0]) {
14536  case '$':
14537  lex_state = EXPR_END;
14538  result = tGVAR;
14539  break;
14540  case '@':
14541  lex_state = EXPR_END;
14542  if (tok()[1] == '@')
14543  result = tCVAR;
14544  else
14545  result = tIVAR;
14546  break;
14547 
14548  default:
14549  if (toklast() == '!' || toklast() == '?') {
14550  result = tFID;
14551  }
14552  else {
14553  if (IS_lex_state(EXPR_FNAME)) {
14554  if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14555  (!peek('=') || (peek_n('>', 1)))) {
14556  result = tIDENTIFIER;
14557  tokadd(c);
14558  tokfix();
14559  }
14560  else {
14561  pushback(c);
14562  }
14563  }
14564  if (result == 0 && ISUPPER(tok()[0])) {
14565  result = tCONSTANT;
14566  }
14567  else {
14568  result = tIDENTIFIER;
14569  }
14570  }
14571 
14572  if (IS_LABEL_POSSIBLE()) {
14573  if (IS_LABEL_SUFFIX(0)) {
14574  lex_state = EXPR_BEG;
14575  nextc();
14577  return tLABEL;
14578  }
14579  }
14580  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14581  const struct kwtable *kw;
14582 
14583  /* See if it is a reserved word. */
14584  kw = rb_reserved_word(tok(), toklen());
14585  if (kw) {
14586  enum lex_state_e state = lex_state;
14587  lex_state = kw->state;
14588  if (state == EXPR_FNAME) {
14590  return kw->id[0];
14591  }
14592  if (lex_state == EXPR_BEG) {
14593  command_start = TRUE;
14594  }
14595  if (kw->id[0] == keyword_do) {
14596  if (lpar_beg && lpar_beg == paren_nest) {
14597  lpar_beg = 0;
14598  --paren_nest;
14599  return keyword_do_LAMBDA;
14600  }
14601  if (COND_P()) return keyword_do_cond;
14602  if (CMDARG_P() && state != EXPR_CMDARG)
14603  return keyword_do_block;
14604  if (state & (EXPR_BEG | EXPR_ENDARG))
14605  return keyword_do_block;
14606  return keyword_do;
14607  }
14608  if (state & (EXPR_BEG | EXPR_VALUE))
14609  return kw->id[0];
14610  else {
14611  if (kw->id[0] != kw->id[1])
14612  lex_state = EXPR_BEG;
14613  return kw->id[1];
14614  }
14615  }
14616  }
14617 
14618  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14619  if (cmd_state) {
14620  lex_state = EXPR_CMDARG;
14621  }
14622  else {
14623  lex_state = EXPR_ARG;
14624  }
14625  }
14626  else if (lex_state == EXPR_FNAME) {
14627  lex_state = EXPR_ENDFN;
14628  }
14629  else {
14630  lex_state = EXPR_END;
14631  }
14632  }
14633  {
14634  ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14635 
14636  set_yylval_name(ident);
14637  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14638  is_local_id(ident) && lvar_defined(ident)) {
14639  lex_state = EXPR_END;
14640  }
14641  }
14642  return result;
14643  }
14644 }
14645 
14646 #if YYPURE
14647 static int
14648 yylex(void *lval, void *p)
14649 #else
14650 yylex(void *p)
14651 #endif
14653  struct parser_params *parser = (struct parser_params*)p;
14654  int t;
14655 
14656 #if YYPURE
14657  parser->parser_yylval = lval;
14659 #endif
14660  t = parser_yylex(parser);
14661 #ifdef RIPPER
14662  if (!NIL_P(parser->delayed)) {
14663  ripper_dispatch_delayed_token(parser, t);
14664  return t;
14665  }
14666  if (t != 0)
14667  ripper_dispatch_scan_event(parser, t);
14668 #endif
14669 
14670  return t;
14671 }
14672 
14673 #ifndef RIPPER
14674 static NODE*
14675 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14676 {
14677  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14679  return n;
14680 }
14681 
14682 static enum node_type
14683 nodetype(NODE *node) /* for debug */
14684 {
14685  return (enum node_type)nd_type(node);
14686 }
14687 
14688 static int
14690 {
14691  return nd_line(node);
14692 }
14693 
14694 static NODE*
14696 {
14697  if (node) {
14698  node = remove_begin(node);
14699  node->flags |= NODE_FL_NEWLINE;
14700  }
14701  return node;
14702 }
14703 
14704 static void
14705 fixpos(NODE *node, NODE *orig)
14706 {
14707  if (!node) return;
14708  if (!orig) return;
14709  if (orig == (NODE*)1) return;
14710  nd_set_line(node, nd_line(orig));
14711 }
14712 
14713 static void
14714 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14715 {
14716  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14717 }
14718 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14719 
14720 static void
14721 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14722 {
14723  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14724 }
14725 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14726 
14727 static NODE*
14728 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14729 {
14730  NODE *end, *h = head, *nd;
14731 
14732  if (tail == 0) return head;
14733 
14734  if (h == 0) return tail;
14735  switch (nd_type(h)) {
14736  case NODE_LIT:
14737  case NODE_STR:
14738  case NODE_SELF:
14739  case NODE_TRUE:
14740  case NODE_FALSE:
14741  case NODE_NIL:
14742  parser_warning(h, "unused literal ignored");
14743  return tail;
14744  default:
14745  h = end = NEW_BLOCK(head);
14746  end->nd_end = end;
14747  fixpos(end, head);
14748  head = end;
14749  break;
14750  case NODE_BLOCK:
14751  end = h->nd_end;
14752  break;
14753  }
14754 
14755  nd = end->nd_head;
14756  switch (nd_type(nd)) {
14757  case NODE_RETURN:
14758  case NODE_BREAK:
14759  case NODE_NEXT:
14760  case NODE_REDO:
14761  case NODE_RETRY:
14762  if (RTEST(ruby_verbose)) {
14763  parser_warning(tail, "statement not reached");
14764  }
14765  break;
14766 
14767  default:
14768  break;
14769  }
14770 
14771  if (nd_type(tail) != NODE_BLOCK) {
14772  tail = NEW_BLOCK(tail);
14773  tail->nd_end = tail;
14774  }
14775  end->nd_next = tail;
14776  h->nd_end = tail->nd_end;
14777  return head;
14778 }
14779 
14780 /* append item to the list */
14781 static NODE*
14782 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14783 {
14784  NODE *last;
14785 
14786  if (list == 0) return NEW_LIST(item);
14787  if (list->nd_next) {
14788  last = list->nd_next->nd_end;
14789  }
14790  else {
14791  last = list;
14792  }
14793 
14794  list->nd_alen += 1;
14795  last->nd_next = NEW_LIST(item);
14796  list->nd_next->nd_end = last->nd_next;
14797  return list;
14798 }
14799 
14800 /* concat two lists */
14801 static NODE*
14802 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14803 {
14804  NODE *last;
14805 
14806  if (head->nd_next) {
14807  last = head->nd_next->nd_end;
14808  }
14809  else {
14810  last = head;
14811  }
14812 
14813  head->nd_alen += tail->nd_alen;
14814  last->nd_next = tail;
14815  if (tail->nd_next) {
14816  head->nd_next->nd_end = tail->nd_next->nd_end;
14817  }
14818  else {
14819  head->nd_next->nd_end = tail;
14820  }
14821 
14822  return head;
14823 }
14824 
14825 static int
14827 {
14828  if (NIL_P(tail)) return 1;
14829  if (!rb_enc_compatible(head, tail)) {
14830  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14831  rb_enc_name(rb_enc_get(head)),
14832  rb_enc_name(rb_enc_get(tail)));
14833  rb_str_resize(head, 0);
14834  rb_str_resize(tail, 0);
14835  return 0;
14836  }
14837  rb_str_buf_append(head, tail);
14838  return 1;
14839 }
14840 
14841 /* concat two string literals */
14842 static NODE *
14844 {
14845  enum node_type htype;
14846  NODE *headlast;
14847  VALUE lit;
14848 
14849  if (!head) return tail;
14850  if (!tail) return head;
14851 
14852  htype = nd_type(head);
14853  if (htype == NODE_EVSTR) {
14854  NODE *node = NEW_DSTR(Qnil);
14855  head = list_append(node, head);
14856  htype = NODE_DSTR;
14857  }
14858  switch (nd_type(tail)) {
14859  case NODE_STR:
14860  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14861  nd_type(headlast) == NODE_STR) {
14862  htype = NODE_STR;
14863  lit = headlast->nd_lit;
14864  }
14865  else {
14866  lit = head->nd_lit;
14867  }
14868  if (htype == NODE_STR) {
14869  if (!literal_concat0(parser, lit, tail->nd_lit)) {
14870  error:
14871  rb_gc_force_recycle((VALUE)head);
14872  rb_gc_force_recycle((VALUE)tail);
14873  return 0;
14874  }
14875  rb_gc_force_recycle((VALUE)tail);
14876  }
14877  else {
14878  list_append(head, tail);
14879  }
14880  break;
14881 
14882  case NODE_DSTR:
14883  if (htype == NODE_STR) {
14884  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14885  goto error;
14886  tail->nd_lit = head->nd_lit;
14887  rb_gc_force_recycle((VALUE)head);
14888  head = tail;
14889  }
14890  else if (NIL_P(tail->nd_lit)) {
14891  append:
14892  head->nd_alen += tail->nd_alen - 1;
14893  head->nd_next->nd_end->nd_next = tail->nd_next;
14894  head->nd_next->nd_end = tail->nd_next->nd_end;
14895  rb_gc_force_recycle((VALUE)tail);
14896  }
14897  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14898  nd_type(headlast) == NODE_STR) {
14899  lit = headlast->nd_lit;
14900  if (!literal_concat0(parser, lit, tail->nd_lit))
14901  goto error;
14902  tail->nd_lit = Qnil;
14903  goto append;
14904  }
14905  else {
14906  nd_set_type(tail, NODE_ARRAY);
14907  tail->nd_head = NEW_STR(tail->nd_lit);
14908  list_concat(head, tail);
14909  }
14910  break;
14911 
14912  case NODE_EVSTR:
14913  if (htype == NODE_STR) {
14914  nd_set_type(head, NODE_DSTR);
14915  head->nd_alen = 1;
14916  }
14917  list_append(head, tail);
14918  break;
14919  }
14920  return head;
14921 }
14922 
14923 static NODE *
14924 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14925 {
14926  if (nd_type(node) == NODE_EVSTR) {
14927  node = list_append(NEW_DSTR(Qnil), node);
14928  }
14929  return node;
14930 }
14931 
14932 static NODE *
14933 new_evstr_gen(struct parser_params *parser, NODE *node)
14934 {
14935  NODE *head = node;
14936 
14937  if (node) {
14938  switch (nd_type(node)) {
14939  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14940  return node;
14941  }
14942  }
14943  return NEW_EVSTR(head);
14944 }
14945 
14946 static NODE *
14947 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14948 {
14949  value_expr(recv);
14950  value_expr(arg1);
14951  return NEW_CALL(recv, id, NEW_LIST(arg1));
14952 }
14953 
14954 static NODE *
14955 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
14956 {
14957  value_expr(recv);
14958  return NEW_CALL(recv, id, 0);
14959 }
14960 
14961 static NODE*
14962 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14963 {
14964  value_expr(node1);
14965  value_expr(node2);
14966  if (node1) {
14967  switch (nd_type(node1)) {
14968  case NODE_DREGX:
14969  case NODE_DREGX_ONCE:
14970  return NEW_MATCH2(node1, node2);
14971 
14972  case NODE_LIT:
14973  if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
14974  return NEW_MATCH2(node1, node2);
14975  }
14976  }
14977  }
14978 
14979  if (node2) {
14980  switch (nd_type(node2)) {
14981  case NODE_DREGX:
14982  case NODE_DREGX_ONCE:
14983  return NEW_MATCH3(node2, node1);
14984 
14985  case NODE_LIT:
14986  if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
14987  return NEW_MATCH3(node2, node1);
14988  }
14989  }
14990  }
14991 
14992  return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
14993 }
14994 
14995 static NODE*
14996 gettable_gen(struct parser_params *parser, ID id)
14997 {
14998  switch (id) {
14999  case keyword_self:
15000  return NEW_SELF();
15001  case keyword_nil:
15002  return NEW_NIL();
15003  case keyword_true:
15004  return NEW_TRUE();
15005  case keyword_false:
15006  return NEW_FALSE();
15007  case keyword__FILE__:
15009  case keyword__LINE__:
15010  return NEW_LIT(INT2FIX(tokline));
15011  case keyword__ENCODING__:
15013  }
15014  switch (id_type(id)) {
15015  case ID_LOCAL:
15016  if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
15017  if (local_id(id)) return NEW_LVAR(id);
15018  /* method call without arguments */
15019  return NEW_VCALL(id);
15020  case ID_GLOBAL:
15021  return NEW_GVAR(id);
15022  case ID_INSTANCE:
15023  return NEW_IVAR(id);
15024  case ID_CONST:
15025  return NEW_CONST(id);
15026  case ID_CLASS:
15027  return NEW_CVAR(id);
15028  }
15029  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15030  return 0;
15031 }
15032 #else /* !RIPPER */
15033 static int
15034 id_is_var_gen(struct parser_params *parser, ID id)
15035 {
15036  if (is_notop_id(id)) {
15037  switch (id & ID_SCOPE_MASK) {
15038  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
15039  return 1;
15040  case ID_LOCAL:
15041  if (dyna_in_block() && dvar_defined(id)) return 1;
15042  if (local_id(id)) return 1;
15043  /* method call without arguments */
15044  return 0;
15045  }
15046  }
15047  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15048  return 0;
15049 }
15050 #endif /* !RIPPER */
15051 
15052 #if PARSER_DEBUG
15053 static const char *
15054 lex_state_name(enum lex_state_e state)
15055 {
15056  static const char names[][12] = {
15057  "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG",
15058  "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS",
15059  "EXPR_VALUE",
15060  };
15061 
15062  if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
15063  return names[ffs(state)];
15064  return NULL;
15065 }
15066 #endif
15067 
15068 #ifdef RIPPER
15069 static VALUE
15070 assignable_gen(struct parser_params *parser, VALUE lhs)
15071 #else
15072 static NODE*
15073 assignable_gen(struct parser_params *parser, ID id, NODE *val)
15074 #endif
15075 {
15076 #ifdef RIPPER
15077  ID id = get_id(lhs);
15078 # define assignable_result(x) get_value(lhs)
15079 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
15080 #else
15081 # define assignable_result(x) (x)
15082 #endif
15083  if (!id) return assignable_result(0);
15084  switch (id) {
15085  case keyword_self:
15086  yyerror("Can't change the value of self");
15087  goto error;
15088  case keyword_nil:
15089  yyerror("Can't assign to nil");
15090  goto error;
15091  case keyword_true:
15092  yyerror("Can't assign to true");
15093  goto error;
15094  case keyword_false:
15095  yyerror("Can't assign to false");
15096  goto error;
15097  case keyword__FILE__:
15098  yyerror("Can't assign to __FILE__");
15099  goto error;
15100  case keyword__LINE__:
15101  yyerror("Can't assign to __LINE__");
15102  goto error;
15103  case keyword__ENCODING__:
15104  yyerror("Can't assign to __ENCODING__");
15105  goto error;
15106  }
15107  switch (id_type(id)) {
15108  case ID_LOCAL:
15109  if (dyna_in_block()) {
15110  if (dvar_curr(id)) {
15111  return assignable_result(NEW_DASGN_CURR(id, val));
15112  }
15113  else if (dvar_defined(id)) {
15114  return assignable_result(NEW_DASGN(id, val));
15115  }
15116  else if (local_id(id)) {
15117  return assignable_result(NEW_LASGN(id, val));
15118  }
15119  else {
15120  dyna_var(id);
15121  return assignable_result(NEW_DASGN_CURR(id, val));
15122  }
15123  }
15124  else {
15125  if (!local_id(id)) {
15126  local_var(id);
15127  }
15128  return assignable_result(NEW_LASGN(id, val));
15129  }
15130  break;
15131  case ID_GLOBAL:
15132  return assignable_result(NEW_GASGN(id, val));
15133  case ID_INSTANCE:
15134  return assignable_result(NEW_IASGN(id, val));
15135  case ID_CONST:
15136  if (!in_def && !in_single)
15137  return assignable_result(NEW_CDECL(id, val, 0));
15138  yyerror("dynamic constant assignment");
15139  break;
15140  case ID_CLASS:
15141  return assignable_result(NEW_CVASGN(id, val));
15142  default:
15143  compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15144  }
15145  error:
15147 #undef assignable_result
15148 #undef parser_yyerror
15149 }
15150 
15151 static int
15153 {
15154  VALUE s;
15155  if (name == idUScore) return 1;
15156  if (!is_local_id(name)) return 0;
15157  s = rb_id2str(name);
15158  if (!s) return 0;
15159  return RSTRING_PTR(s)[0] == '_';
15160 }
15161 
15162 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15163 
15164 static ID
15165 shadowing_lvar_gen(struct parser_params *parser, ID name)
15166 {
15167  if (is_private_local_id(name)) return name;
15168  if (dyna_in_block()) {
15169  if (dvar_curr(name)) {
15170  yyerror("duplicated argument name");
15171  }
15172  else if (dvar_defined_get(name) || local_id(name)) {
15173  rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15174  vtable_add(lvtbl->vars, name);
15175  if (lvtbl->used) {
15177  }
15178  }
15179  }
15180  else {
15181  if (local_id(name)) {
15182  yyerror("duplicated argument name");
15183  }
15184  }
15185  return name;
15186 }
15187 
15188 static void
15189 new_bv_gen(struct parser_params *parser, ID name)
15190 {
15191  if (!name) return;
15192  if (!is_local_id(name)) {
15193  compile_error(PARSER_ARG "invalid local variable - %s",
15194  rb_id2name(name));
15195  return;
15196  }
15197  shadowing_lvar(name);
15198  dyna_var(name);
15199 }
15200 
15201 #ifndef RIPPER
15202 static NODE *
15203 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15204 {
15205  if (recv && nd_type(recv) == NODE_SELF)
15206  recv = (NODE *)1;
15207  return NEW_ATTRASGN(recv, tASET, idx);
15208 }
15209 
15210 static void
15211 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15212 {
15213  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15214  compile_error(PARSER_ARG "both block arg and actual block given");
15215  }
15216 }
15217 
15218 static const char id_type_names[][9] = {
15219  "LOCAL",
15220  "INSTANCE",
15221  "", /* INSTANCE2 */
15222  "GLOBAL",
15223  "ATTRSET",
15224  "CONST",
15225  "CLASS",
15226  "JUNK",
15227 };
15228 
15229 ID
15231 {
15232  if (!is_notop_id(id)) {
15233  switch (id) {
15234  case tAREF: case tASET:
15235  return tASET; /* only exception */
15236  }
15237  rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
15238  }
15239  else {
15240  int scope = (int)(id & ID_SCOPE_MASK);
15241  switch (scope) {
15242  case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
15243  case ID_CONST: case ID_CLASS: case ID_JUNK:
15244  break;
15245  case ID_ATTRSET:
15246  return id;
15247  default:
15248  rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset",
15249  id_type_names[scope], ID2SYM(id));
15250 
15251  }
15252  }
15253  id &= ~ID_SCOPE_MASK;
15254  id |= ID_ATTRSET;
15255  return id;
15256 }
15257 
15258 static NODE *
15259 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15260 {
15261  if (recv && nd_type(recv) == NODE_SELF)
15262  recv = (NODE *)1;
15263  return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15264 }
15265 
15266 static void
15268 {
15269  switch (nd_type(node)) {
15270  case NODE_NTH_REF:
15271  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15272  break;
15273  case NODE_BACK_REF:
15274  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15275  break;
15276  }
15277 }
15278 
15279 static NODE *
15280 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15281 {
15282  if (!node2) return node1;
15283  switch (nd_type(node1)) {
15284  case NODE_BLOCK_PASS:
15285  if (node1->nd_head)
15286  node1->nd_head = arg_concat(node1->nd_head, node2);
15287  else
15288  node1->nd_head = NEW_LIST(node2);
15289  return node1;
15290  case NODE_ARGSPUSH:
15291  if (nd_type(node2) != NODE_ARRAY) break;
15292  node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15293  nd_set_type(node1, NODE_ARGSCAT);
15294  return node1;
15295  case NODE_ARGSCAT:
15296  if (nd_type(node2) != NODE_ARRAY ||
15297  nd_type(node1->nd_body) != NODE_ARRAY) break;
15298  node1->nd_body = list_concat(node1->nd_body, node2);
15299  return node1;
15300  }
15301  return NEW_ARGSCAT(node1, node2);
15302 }
15303 
15304 static NODE *
15305 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15306 {
15307  if (!node1) return NEW_LIST(node2);
15308  switch (nd_type(node1)) {
15309  case NODE_ARRAY:
15310  return list_append(node1, node2);
15311  case NODE_BLOCK_PASS:
15312  node1->nd_head = arg_append(node1->nd_head, node2);
15313  return node1;
15314  case NODE_ARGSPUSH:
15315  node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15316  nd_set_type(node1, NODE_ARGSCAT);
15317  return node1;
15318  }
15319  return NEW_ARGSPUSH(node1, node2);
15320 }
15321 
15322 static NODE *
15324 {
15325  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15326  if (nd_type(node) == NODE_ARRAY) return node;
15327  return 0;
15328 }
15329 
15330 static NODE *
15331 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15332 {
15333  if (!lhs) return 0;
15334 
15335  switch (nd_type(lhs)) {
15336  case NODE_GASGN:
15337  case NODE_IASGN:
15338  case NODE_IASGN2:
15339  case NODE_LASGN:
15340  case NODE_DASGN:
15341  case NODE_DASGN_CURR:
15342  case NODE_MASGN:
15343  case NODE_CDECL:
15344  case NODE_CVASGN:
15345  lhs->nd_value = rhs;
15346  break;
15347 
15348  case NODE_ATTRASGN:
15349  case NODE_CALL:
15350  lhs->nd_args = arg_append(lhs->nd_args, rhs);
15351  break;
15352 
15353  default:
15354  /* should not happen */
15355  break;
15356  }
15357 
15358  return lhs;
15359 }
15360 
15361 static int
15362 value_expr_gen(struct parser_params *parser, NODE *node)
15363 {
15364  int cond = 0;
15365 
15366  if (!node) {
15367  rb_warning0("empty expression");
15368  }
15369  while (node) {
15370  switch (nd_type(node)) {
15371  case NODE_DEFN:
15372  case NODE_DEFS:
15373  parser_warning(node, "void value expression");
15374  return FALSE;
15375 
15376  case NODE_RETURN:
15377  case NODE_BREAK:
15378  case NODE_NEXT:
15379  case NODE_REDO:
15380  case NODE_RETRY:
15381  if (!cond) yyerror("void value expression");
15382  /* or "control never reach"? */
15383  return FALSE;
15384 
15385  case NODE_BLOCK:
15386  while (node->nd_next) {
15387  node = node->nd_next;
15388  }
15389  node = node->nd_head;
15390  break;
15391 
15392  case NODE_BEGIN:
15393  node = node->nd_body;
15394  break;
15395 
15396  case NODE_IF:
15397  if (!node->nd_body) {
15398  node = node->nd_else;
15399  break;
15400  }
15401  else if (!node->nd_else) {
15402  node = node->nd_body;
15403  break;
15404  }
15405  if (!value_expr(node->nd_body)) return FALSE;
15406  node = node->nd_else;
15407  break;
15408 
15409  case NODE_AND:
15410  case NODE_OR:
15411  cond = 1;
15412  node = node->nd_2nd;
15413  break;
15414 
15415  default:
15416  return TRUE;
15417  }
15418  }
15419 
15420  return TRUE;
15421 }
15422 
15423 static void
15424 void_expr_gen(struct parser_params *parser, NODE *node)
15425 {
15426  const char *useless = 0;
15427 
15428  if (!RTEST(ruby_verbose)) return;
15429 
15430  if (!node) return;
15431  switch (nd_type(node)) {
15432  case NODE_CALL:
15433  switch (node->nd_mid) {
15434  case '+':
15435  case '-':
15436  case '*':
15437  case '/':
15438  case '%':
15439  case tPOW:
15440  case tUPLUS:
15441  case tUMINUS:
15442  case '|':
15443  case '^':
15444  case '&':
15445  case tCMP:
15446  case '>':
15447  case tGEQ:
15448  case '<':
15449  case tLEQ:
15450  case tEQ:
15451  case tNEQ:
15452  useless = rb_id2name(node->nd_mid);
15453  break;
15454  }
15455  break;
15456 
15457  case NODE_LVAR:
15458  case NODE_DVAR:
15459  case NODE_GVAR:
15460  case NODE_IVAR:
15461  case NODE_CVAR:
15462  case NODE_NTH_REF:
15463  case NODE_BACK_REF:
15464  useless = "a variable";
15465  break;
15466  case NODE_CONST:
15467  useless = "a constant";
15468  break;
15469  case NODE_LIT:
15470  case NODE_STR:
15471  case NODE_DSTR:
15472  case NODE_DREGX:
15473  case NODE_DREGX_ONCE:
15474  useless = "a literal";
15475  break;
15476  case NODE_COLON2:
15477  case NODE_COLON3:
15478  useless = "::";
15479  break;
15480  case NODE_DOT2:
15481  useless = "..";
15482  break;
15483  case NODE_DOT3:
15484  useless = "...";
15485  break;
15486  case NODE_SELF:
15487  useless = "self";
15488  break;
15489  case NODE_NIL:
15490  useless = "nil";
15491  break;
15492  case NODE_TRUE:
15493  useless = "true";
15494  break;
15495  case NODE_FALSE:
15496  useless = "false";
15497  break;
15498  case NODE_DEFINED:
15499  useless = "defined?";
15500  break;
15501  }
15502 
15503  if (useless) {
15504  int line = ruby_sourceline;
15505 
15506  ruby_sourceline = nd_line(node);
15507  rb_warnS("possibly useless use of %s in void context", useless);
15508  ruby_sourceline = line;
15509  }
15510 }
15511 
15512 static void
15513 void_stmts_gen(struct parser_params *parser, NODE *node)
15514 {
15515  if (!RTEST(ruby_verbose)) return;
15516  if (!node) return;
15517  if (nd_type(node) != NODE_BLOCK) return;
15518 
15519  for (;;) {
15520  if (!node->nd_next) return;
15521  void_expr0(node->nd_head);
15522  node = node->nd_next;
15523  }
15524 }
15525 
15526 static NODE *
15528 {
15529  NODE **n = &node, *n1 = node;
15530  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15531  *n = n1 = n1->nd_body;
15532  }
15533  return node;
15534 }
15535 
15536 static void
15537 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15538 {
15539  NODE *node = *body;
15540 
15541  if (!node) {
15542  *body = NEW_NIL();
15543  return;
15544  }
15545 #define subnodes(n1, n2) \
15546  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15547  (!node->n2) ? (body = &node->n1, 1) : \
15548  (reduce_nodes(&node->n1), body = &node->n2, 1))
15549 
15550  while (node) {
15551  int newline = (int)(node->flags & NODE_FL_NEWLINE);
15552  switch (nd_type(node)) {
15553  end:
15554  case NODE_NIL:
15555  *body = 0;
15556  return;
15557  case NODE_RETURN:
15558  *body = node = node->nd_stts;
15559  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15560  continue;
15561  case NODE_BEGIN:
15562  *body = node = node->nd_body;
15563  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15564  continue;
15565  case NODE_BLOCK:
15566  body = &node->nd_end->nd_head;
15567  break;
15568  case NODE_IF:
15569  if (subnodes(nd_body, nd_else)) break;
15570  return;
15571  case NODE_CASE:
15572  body = &node->nd_body;
15573  break;
15574  case NODE_WHEN:
15575  if (!subnodes(nd_body, nd_next)) goto end;
15576  break;
15577  case NODE_ENSURE:
15578  if (!subnodes(nd_head, nd_resq)) goto end;
15579  break;
15580  case NODE_RESCUE:
15581  if (node->nd_else) {
15582  body = &node->nd_resq;
15583  break;
15584  }
15585  if (!subnodes(nd_head, nd_resq)) goto end;
15586  break;
15587  default:
15588  return;
15589  }
15590  node = *body;
15591  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15592  }
15593 
15594 #undef subnodes
15595 }
15596 
15597 static int
15599 {
15600  if (!node) return 1;
15601  switch (nd_type(node)) {
15602  case NODE_HASH:
15603  if (!(node = node->nd_head)) break;
15604  case NODE_ARRAY:
15605  do {
15606  if (!is_static_content(node->nd_head)) return 0;
15607  } while ((node = node->nd_next) != 0);
15608  case NODE_LIT:
15609  case NODE_STR:
15610  case NODE_NIL:
15611  case NODE_TRUE:
15612  case NODE_FALSE:
15613  case NODE_ZARRAY:
15614  break;
15615  default:
15616  return 0;
15617  }
15618  return 1;
15619 }
15620 
15621 static int
15622 assign_in_cond(struct parser_params *parser, NODE *node)
15623 {
15624  switch (nd_type(node)) {
15625  case NODE_MASGN:
15626  yyerror("multiple assignment in conditional");
15627  return 1;
15628 
15629  case NODE_LASGN:
15630  case NODE_DASGN:
15631  case NODE_DASGN_CURR:
15632  case NODE_GASGN:
15633  case NODE_IASGN:
15634  break;
15635 
15636  default:
15637  return 0;
15638  }
15639 
15640  if (!node->nd_value) return 1;
15641  if (is_static_content(node->nd_value)) {
15642  /* reports always */
15643  parser_warn(node->nd_value, "found = in conditional, should be ==");
15644  }
15645  return 1;
15646 }
15647 
15648 static void
15649 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15650 {
15651  if (!e_option_supplied(parser)) parser_warn(node, str);
15652 }
15653 
15654 static void
15655 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15656 {
15657  if (!e_option_supplied(parser)) parser_warning(node, str);
15658 }
15659 
15660 static void
15661 fixup_nodes(NODE **rootnode)
15662 {
15663  NODE *node, *next, *head;
15664 
15665  for (node = *rootnode; node; node = next) {
15666  enum node_type type;
15667  VALUE val;
15668 
15669  next = node->nd_next;
15670  head = node->nd_head;
15671  rb_gc_force_recycle((VALUE)node);
15672  *rootnode = next;
15673  switch (type = nd_type(head)) {
15674  case NODE_DOT2:
15675  case NODE_DOT3:
15676  val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15677  type == NODE_DOT3);
15678  rb_gc_force_recycle((VALUE)head->nd_beg);
15679  rb_gc_force_recycle((VALUE)head->nd_end);
15680  nd_set_type(head, NODE_LIT);
15681  head->nd_lit = val;
15682  break;
15683  default:
15684  break;
15685  }
15686  }
15687 }
15688 
15689 static NODE *cond0(struct parser_params*,NODE*);
15690 
15691 static NODE*
15692 range_op(struct parser_params *parser, NODE *node)
15693 {
15694  enum node_type type;
15695 
15696  if (node == 0) return 0;
15697 
15698  type = nd_type(node);
15699  value_expr(node);
15700  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15701  warn_unless_e_option(parser, node, "integer literal in conditional range");
15702  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15703  }
15704  return cond0(parser, node);
15705 }
15706 
15707 static int
15709 {
15710  if (!node) return 1; /* same as NODE_NIL */
15711  switch (nd_type(node)) {
15712  case NODE_LIT:
15713  case NODE_STR:
15714  case NODE_DSTR:
15715  case NODE_EVSTR:
15716  case NODE_DREGX:
15717  case NODE_DREGX_ONCE:
15718  case NODE_DSYM:
15719  return 2;
15720  case NODE_TRUE:
15721  case NODE_FALSE:
15722  case NODE_NIL:
15723  return 1;
15724  }
15725  return 0;
15726 }
15727 
15728 static NODE*
15729 cond0(struct parser_params *parser, NODE *node)
15730 {
15731  if (node == 0) return 0;
15732  assign_in_cond(parser, node);
15733 
15734  switch (nd_type(node)) {
15735  case NODE_DSTR:
15736  case NODE_EVSTR:
15737  case NODE_STR:
15738  rb_warn0("string literal in condition");
15739  break;
15740 
15741  case NODE_DREGX:
15742  case NODE_DREGX_ONCE:
15743  warning_unless_e_option(parser, node, "regex literal in condition");
15744  return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15745 
15746  case NODE_AND:
15747  case NODE_OR:
15748  node->nd_1st = cond0(parser, node->nd_1st);
15749  node->nd_2nd = cond0(parser, node->nd_2nd);
15750  break;
15751 
15752  case NODE_DOT2:
15753  case NODE_DOT3:
15754  node->nd_beg = range_op(parser, node->nd_beg);
15755  node->nd_end = range_op(parser, node->nd_end);
15756  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15757  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15758  if (!e_option_supplied(parser)) {
15759  int b = literal_node(node->nd_beg);
15760  int e = literal_node(node->nd_end);
15761  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15762  parser_warn(node, "range literal in condition");
15763  }
15764  }
15765  break;
15766 
15767  case NODE_DSYM:
15768  parser_warning(node, "literal in condition");
15769  break;
15770 
15771  case NODE_LIT:
15772  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
15773  warn_unless_e_option(parser, node, "regex literal in condition");
15774  nd_set_type(node, NODE_MATCH);
15775  }
15776  else {
15777  parser_warning(node, "literal in condition");
15778  }
15779  default:
15780  break;
15781  }
15782  return node;
15783 }
15784 
15785 static NODE*
15786 cond_gen(struct parser_params *parser, NODE *node)
15787 {
15788  if (node == 0) return 0;
15789  return cond0(parser, node);
15790 }
15791 
15792 static NODE*
15793 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15794 {
15795  value_expr(left);
15796  if (left && (enum node_type)nd_type(left) == type) {
15797  NODE *node = left, *second;
15798  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15799  node = second;
15800  }
15801  node->nd_2nd = NEW_NODE(type, second, right, 0);
15802  return left;
15803  }
15804  return NEW_NODE(type, left, right, 0);
15805 }
15806 
15807 static void
15808 no_blockarg(struct parser_params *parser, NODE *node)
15809 {
15810  if (node && nd_type(node) == NODE_BLOCK_PASS) {
15811  compile_error(PARSER_ARG "block argument should not be given");
15812  }
15813 }
15814 
15815 static NODE *
15816 ret_args_gen(struct parser_params *parser, NODE *node)
15817 {
15818  if (node) {
15819  no_blockarg(parser, node);
15820  if (nd_type(node) == NODE_ARRAY) {
15821  if (node->nd_next == 0) {
15822  node = node->nd_head;
15823  }
15824  else {
15825  nd_set_type(node, NODE_VALUES);
15826  }
15827  }
15828  }
15829  return node;
15830 }
15831 
15832 static NODE *
15833 new_yield_gen(struct parser_params *parser, NODE *node)
15834 {
15835  if (node) no_blockarg(parser, node);
15836 
15837  return NEW_YIELD(node);
15838 }
15839 
15840 static NODE*
15842 {
15843  switch (TYPE(node->nd_lit)) {
15844  case T_FIXNUM:
15845  node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15846  break;
15847  case T_BIGNUM:
15848  node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15849  break;
15850  case T_FLOAT:
15851 #if USE_FLONUM
15852  if (FLONUM_P(node->nd_lit)) {
15853  node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
15854  }
15855  else {
15856  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15857  }
15858 #else
15859  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15860 #endif
15861  break;
15862  default:
15863  break;
15864  }
15865  return node;
15866 }
15867 
15868 static NODE *
15869 arg_blk_pass(NODE *node1, NODE *node2)
15870 {
15871  if (node2) {
15872  node2->nd_head = node1;
15873  return node2;
15874  }
15875  return node1;
15876 }
15877 
15878 
15879 static NODE*
15880 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
15881 {
15882  int saved_line = ruby_sourceline;
15883  struct rb_args_info *args = tail->nd_ainfo;
15884 
15885  args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0;
15886  args->pre_init = m ? m->nd_next : 0;
15887 
15888  args->post_args_num = p ? rb_long2int(p->nd_plen) : 0;
15889  args->post_init = p ? p->nd_next : 0;
15890  args->first_post_arg = p ? p->nd_pid : 0;
15891 
15892  args->rest_arg = r;
15893 
15894  args->opt_args = o;
15895 
15896  ruby_sourceline = saved_line;
15897 
15898  return tail;
15899 }
15900 
15901 static NODE*
15902 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
15903 {
15904  int saved_line = ruby_sourceline;
15905  struct rb_args_info *args;
15906  NODE *kw_rest_arg = 0;
15907  NODE *node;
15908 
15909  args = ALLOC(struct rb_args_info);
15910  MEMZERO(args, struct rb_args_info, 1);
15911  node = NEW_NODE(NODE_ARGS, 0, 0, args);
15912 
15913  args->block_arg = b;
15914  args->kw_args = k;
15915  if (k && !kr) kr = internal_id();
15916  if (kr) {
15917  arg_var(kr);
15918  kw_rest_arg = NEW_DVAR(kr);
15919  }
15920  args->kw_rest_arg = kw_rest_arg;
15921 
15922  ruby_sourceline = saved_line;
15923  return node;
15924 }
15925 
15926 static NODE*
15927 dsym_node_gen(struct parser_params *parser, NODE *node)
15928 {
15929  VALUE lit;
15930 
15931  if (!node) {
15932  return NEW_LIT(ID2SYM(idNULL));
15933  }
15934 
15935  switch (nd_type(node)) {
15936  case NODE_DSTR:
15937  nd_set_type(node, NODE_DSYM);
15938  break;
15939  case NODE_STR:
15940  lit = node->nd_lit;
15941  node->nd_lit = ID2SYM(rb_intern_str(lit));
15942  nd_set_type(node, NODE_LIT);
15943  break;
15944  default:
15945  node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
15946  break;
15947  }
15948  return node;
15949 }
15950 #endif /* !RIPPER */
15951 
15952 #ifndef RIPPER
15953 static NODE *
15954 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
15955 {
15956  NODE *asgn;
15957 
15958  if (lhs) {
15959  ID vid = lhs->nd_vid;
15960  if (op == tOROP) {
15961  lhs->nd_value = rhs;
15962  asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
15963  if (is_asgn_or_id(vid)) {
15964  asgn->nd_aid = vid;
15965  }
15966  }
15967  else if (op == tANDOP) {
15968  lhs->nd_value = rhs;
15969  asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
15970  }
15971  else {
15972  asgn = lhs;
15973  asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
15974  }
15975  }
15976  else {
15977  asgn = NEW_BEGIN(0);
15978  }
15979  return asgn;
15980 }
15981 
15982 static NODE *
15983 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
15984 {
15985  NODE *asgn;
15986 
15987  if (op == tOROP) {
15988  op = 0;
15989  }
15990  else if (op == tANDOP) {
15991  op = 1;
15992  }
15993  asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
15994  fixpos(asgn, lhs);
15995  return asgn;
15996 }
15997 
15998 static NODE *
15999 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16000 {
16001  NODE *asgn;
16002 
16003  if (op == tOROP) {
16004  op = 0;
16005  }
16006  else if (op == tANDOP) {
16007  op = 1;
16008  }
16009  if (lhs) {
16010  asgn = NEW_OP_CDECL(lhs, op, rhs);
16011  }
16012  else {
16013  asgn = NEW_BEGIN(0);
16014  }
16015  fixpos(asgn, lhs);
16016  return asgn;
16017 }
16018 #else
16019 static VALUE
16020 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
16021 {
16022  return dispatch3(opassign, lhs, op, rhs);
16023 }
16024 
16025 static VALUE
16026 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
16027 {
16028  VALUE recv = dispatch3(field, lhs, type, attr);
16029  return dispatch3(opassign, recv, op, rhs);
16030 }
16031 #endif
16032 
16033 static void
16034 warn_unused_var(struct parser_params *parser, struct local_vars *local)
16035 {
16036  int i, cnt;
16037  ID *v, *u;
16038 
16039  if (!local->used) return;
16040  v = local->vars->tbl;
16041  u = local->used->tbl;
16042  cnt = local->used->pos;
16043  if (cnt != local->vars->pos) {
16044  rb_bug("local->used->pos != local->vars->pos");
16045  }
16046  for (i = 0; i < cnt; ++i) {
16047  if (!v[i] || (u[i] & LVAR_USED)) continue;
16048  if (is_private_local_id(v[i])) continue;
16049  rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
16050  }
16051 }
16052 
16053 static void
16054 local_push_gen(struct parser_params *parser, int inherit_dvars)
16055 {
16056  struct local_vars *local;
16057 
16058  local = ALLOC(struct local_vars);
16059  local->prev = lvtbl;
16060  local->args = vtable_alloc(0);
16061  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
16062  local->used = !(inherit_dvars &&
16064  RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
16065  local->cmdargs = cmdarg_stack;
16066  cmdarg_stack = 0;
16067  lvtbl = local;
16068 }
16069 
16070 static void
16072 {
16073  struct local_vars *local = lvtbl->prev;
16074  if (lvtbl->used) {
16075  warn_unused_var(parser, lvtbl);
16076  vtable_free(lvtbl->used);
16077  }
16078  vtable_free(lvtbl->args);
16079  vtable_free(lvtbl->vars);
16080  cmdarg_stack = lvtbl->cmdargs;
16081  xfree(lvtbl);
16082  lvtbl = local;
16083 }
16084 
16085 #ifndef RIPPER
16086 static ID*
16088 {
16089  int cnt_args = vtable_size(lvtbl->args);
16090  int cnt_vars = vtable_size(lvtbl->vars);
16091  int cnt = cnt_args + cnt_vars;
16092  int i, j;
16093  ID *buf;
16094 
16095  if (cnt <= 0) return 0;
16096  buf = ALLOC_N(ID, cnt + 1);
16097  MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args);
16098  /* remove IDs duplicated to warn shadowing */
16099  for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
16100  ID id = lvtbl->vars->tbl[i];
16101  if (!vtable_included(lvtbl->args, id)) {
16102  buf[j++] = id;
16103  }
16104  }
16105  if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1);
16106  buf[0] = cnt;
16107  return buf;
16108 }
16109 #endif
16110 
16111 static int
16112 arg_var_gen(struct parser_params *parser, ID id)
16113 {
16114  vtable_add(lvtbl->args, id);
16115  return vtable_size(lvtbl->args) - 1;
16116 }
16117 
16118 static int
16119 local_var_gen(struct parser_params *parser, ID id)
16120 {
16121  vtable_add(lvtbl->vars, id);
16122  if (lvtbl->used) {
16124  }
16125  return vtable_size(lvtbl->vars) - 1;
16126 }
16127 
16128 static int
16129 local_id_gen(struct parser_params *parser, ID id)
16130 {
16131  struct vtable *vars, *args, *used;
16132 
16133  vars = lvtbl->vars;
16134  args = lvtbl->args;
16135  used = lvtbl->used;
16136 
16137  while (vars && POINTER_P(vars->prev)) {
16138  vars = vars->prev;
16139  args = args->prev;
16140  if (used) used = used->prev;
16141  }
16142 
16143  if (vars && vars->prev == DVARS_INHERIT) {
16144  return rb_local_defined(id);
16145  }
16146  else if (vtable_included(args, id)) {
16147  return 1;
16148  }
16149  else {
16150  int i = vtable_included(vars, id);
16151  if (i && used) used->tbl[i-1] |= LVAR_USED;
16152  return i != 0;
16153  }
16154 }
16155 
16156 static const struct vtable *
16158 {
16159  lvtbl->args = vtable_alloc(lvtbl->args);
16160  lvtbl->vars = vtable_alloc(lvtbl->vars);
16161  if (lvtbl->used) {
16162  lvtbl->used = vtable_alloc(lvtbl->used);
16163  }
16164  return lvtbl->args;
16165 }
16166 
16167 static void
16168 dyna_pop_1(struct parser_params *parser)
16169 {
16170  struct vtable *tmp;
16171 
16172  if ((tmp = lvtbl->used) != 0) {
16173  warn_unused_var(parser, lvtbl);
16174  lvtbl->used = lvtbl->used->prev;
16175  vtable_free(tmp);
16176  }
16177  tmp = lvtbl->args;
16178  lvtbl->args = lvtbl->args->prev;
16179  vtable_free(tmp);
16180  tmp = lvtbl->vars;
16181  lvtbl->vars = lvtbl->vars->prev;
16182  vtable_free(tmp);
16183 }
16184 
16185 static void
16186 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16187 {
16188  while (lvtbl->args != lvargs) {
16189  dyna_pop_1(parser);
16190  if (!lvtbl->args) {
16191  struct local_vars *local = lvtbl->prev;
16192  xfree(lvtbl);
16193  lvtbl = local;
16194  }
16195  }
16196  dyna_pop_1(parser);
16197 }
16198 
16199 static int
16201 {
16202  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16203 }
16204 
16205 static int
16206 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16207 {
16208  struct vtable *vars, *args, *used;
16209  int i;
16210 
16211  args = lvtbl->args;
16212  vars = lvtbl->vars;
16213  used = lvtbl->used;
16214 
16215  while (POINTER_P(vars)) {
16216  if (vtable_included(args, id)) {
16217  return 1;
16218  }
16219  if ((i = vtable_included(vars, id)) != 0) {
16220  if (used) used->tbl[i-1] |= LVAR_USED;
16221  return 1;
16222  }
16223  args = args->prev;
16224  vars = vars->prev;
16225  if (get) used = 0;
16226  if (used) used = used->prev;
16227  }
16228 
16229  if (vars == DVARS_INHERIT) {
16230  return rb_dvar_defined(id);
16231  }
16232 
16233  return 0;
16234 }
16235 
16236 static int
16237 dvar_curr_gen(struct parser_params *parser, ID id)
16238 {
16239  return (vtable_included(lvtbl->args, id) ||
16240  vtable_included(lvtbl->vars, id));
16241 }
16242 
16243 #ifndef RIPPER
16244 static void
16246 {
16247  int c = RE_OPTION_ENCODING_IDX(options);
16248 
16249  if (c) {
16250  int opt, idx;
16251  rb_char_to_option_kcode(c, &opt, &idx);
16252  if (idx != ENCODING_GET(str) &&
16254  goto error;
16255  }
16256  ENCODING_SET(str, idx);
16257  }
16258  else if (RE_OPTION_ENCODING_NONE(options)) {
16259  if (!ENCODING_IS_ASCII8BIT(str) &&
16261  c = 'n';
16262  goto error;
16263  }
16265  }
16266  else if (current_enc == rb_usascii_encoding()) {
16268  /* raise in re.c */
16270  }
16271  else {
16273  }
16274  }
16275  return;
16276 
16277  error:
16279  "regexp encoding option '%c' differs from source encoding '%s'",
16280  c, rb_enc_name(rb_enc_get(str)));
16281 }
16282 
16283 static int
16285 {
16286  VALUE err;
16287  reg_fragment_setenc(str, options);
16288  err = rb_reg_check_preprocess(str);
16289  if (err != Qnil) {
16290  err = rb_obj_as_string(err);
16291  compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
16292  RB_GC_GUARD(err);
16293  return 0;
16294  }
16295  return 1;
16296 }
16297 
16298 typedef struct {
16303  int num;
16305 
16306 static int
16308  int back_num, int *back_refs, OnigRegex regex, void *arg0)
16309 {
16311  struct parser_params* parser = arg->parser;
16312  rb_encoding *enc = arg->enc;
16313  long len = name_end - name;
16314  const char *s = (const char *)name;
16315  ID var;
16316 
16317  arg->num++;
16318 
16319  if (arg->succ_block == 0) {
16320  arg->succ_block = NEW_BEGIN(0);
16321  arg->fail_block = NEW_BEGIN(0);
16322  }
16323 
16324  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16325  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16326  !rb_enc_symname2_p(s, len, enc)) {
16327  return ST_CONTINUE;
16328  }
16329  var = rb_intern3(s, len, enc);
16330  if (dvar_defined(var) || local_id(var)) {
16331  rb_warningS("named capture conflicts a local variable - %s",
16332  rb_id2name(var));
16333  }
16334  arg->succ_block = block_append(arg->succ_block,
16336  NEW_CALL(
16337  gettable(rb_intern("$~")),
16338  idAREF,
16339  NEW_LIST(NEW_LIT(ID2SYM(var))))
16340  )));
16341  arg->fail_block = block_append(arg->fail_block,
16343  return ST_CONTINUE;
16344 }
16345 
16346 static NODE *
16348 {
16350 
16351  arg.parser = parser;
16352  arg.enc = rb_enc_get(regexp);
16353  arg.succ_block = 0;
16354  arg.fail_block = 0;
16355  arg.num = 0;
16357 
16358  if (arg.num == 0)
16359  return match;
16360 
16361  return
16362  block_append(
16363  newline_node(match),
16364  NEW_IF(gettable(rb_intern("$~")),
16365  block_append(
16366  newline_node(arg.succ_block),
16367  newline_node(
16368  NEW_CALL(
16369  gettable(rb_intern("$~")),
16370  rb_intern("begin"),
16371  NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16372  block_append(
16373  newline_node(arg.fail_block),
16374  newline_node(
16375  NEW_LIT(Qnil)))));
16376 }
16377 
16378 static VALUE
16379 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16380 {
16381  VALUE re;
16382  VALUE err;
16383 
16384  reg_fragment_setenc(str, options);
16385  err = rb_errinfo();
16387  if (NIL_P(re)) {
16388  ID mesg = rb_intern("mesg");
16389  VALUE m = rb_attr_get(rb_errinfo(), mesg);
16390  rb_set_errinfo(err);
16391  if (!NIL_P(err)) {
16392  rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16393  }
16394  else {
16396  }
16397  return Qnil;
16398  }
16399  return re;
16400 }
16401 
16402 void
16404 {
16405 }
16406 
16407 NODE*
16409 {
16410  NODE *prelude = 0;
16411  NODE *scope = node;
16412  struct parser_params *parser;
16413 
16414  if (!node) return node;
16415 
16416  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16417 
16418  node = node->nd_body;
16419 
16420  if (nd_type(node) == NODE_PRELUDE) {
16421  prelude = node;
16422  node = node->nd_body;
16423  }
16424 
16425  node = block_append(node,
16426  NEW_FCALL(rb_intern("print"),
16427  NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16428  if (prelude) {
16429  prelude->nd_body = node;
16430  scope->nd_body = prelude;
16431  }
16432  else {
16433  scope->nd_body = node;
16434  }
16435 
16436  return scope;
16437 }
16438 
16439 NODE *
16440 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16441 {
16442  NODE *prelude = 0;
16443  NODE *scope = node;
16444  struct parser_params *parser;
16445 
16446  if (!node) return node;
16447 
16448  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16449 
16450  node = node->nd_body;
16451 
16452  if (nd_type(node) == NODE_PRELUDE) {
16453  prelude = node;
16454  node = node->nd_body;
16455  }
16456  if (split) {
16457  node = block_append(NEW_GASGN(rb_intern("$F"),
16458  NEW_CALL(NEW_GVAR(rb_intern("$_")),
16459  rb_intern("split"), 0)),
16460  node);
16461  }
16462  if (chop) {
16463  node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16464  rb_intern("chop!"), 0), node);
16465  }
16466 
16467  node = NEW_OPT_N(node);
16468 
16469  if (prelude) {
16470  prelude->nd_body = node;
16471  scope->nd_body = prelude;
16472  }
16473  else {
16474  scope->nd_body = node;
16475  }
16476 
16477  return scope;
16478 }
16479 
16480 static const struct {
16482  const char *name;
16483 } op_tbl[] = {
16484  {tDOT2, ".."},
16485  {tDOT3, "..."},
16486  {tPOW, "**"},
16487  {tDSTAR, "**"},
16488  {tUPLUS, "+@"},
16489  {tUMINUS, "-@"},
16490  {tCMP, "<=>"},
16491  {tGEQ, ">="},
16492  {tLEQ, "<="},
16493  {tEQ, "=="},
16494  {tEQQ, "==="},
16495  {tNEQ, "!="},
16496  {tMATCH, "=~"},
16497  {tNMATCH, "!~"},
16498  {tAREF, "[]"},
16499  {tASET, "[]="},
16500  {tLSHFT, "<<"},
16501  {tRSHFT, ">>"},
16502  {tCOLON2, "::"},
16503 };
16504 
16505 #define op_tbl_count numberof(op_tbl)
16506 
16507 #ifndef ENABLE_SELECTOR_NAMESPACE
16508 #define ENABLE_SELECTOR_NAMESPACE 0
16509 #endif
16510 
16511 static struct symbols {
16515 #if ENABLE_SELECTOR_NAMESPACE
16516  st_table *ivar2_id;
16517  st_table *id_ivar2;
16518 #endif
16521 
16522 static const struct st_hash_type symhash = {
16524  rb_str_hash,
16525 };
16526 
16527 #if ENABLE_SELECTOR_NAMESPACE
16528 struct ivar2_key {
16529  ID id;
16530  VALUE klass;
16531 };
16532 
16533 static int
16534 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16535 {
16536  if (key1->id == key2->id && key1->klass == key2->klass) {
16537  return 0;
16538  }
16539  return 1;
16540 }
16541 
16542 static int
16543 ivar2_hash(struct ivar2_key *key)
16544 {
16545  return (key->id << 8) ^ (key->klass >> 2);
16546 }
16547 
16548 static const struct st_hash_type ivar2_hash_type = {
16549  ivar2_cmp,
16550  ivar2_hash,
16551 };
16552 #endif
16553 
16554 void
16556 {
16557  global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
16559 #if ENABLE_SELECTOR_NAMESPACE
16560  global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16561  global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16562 #endif
16563 
16564  (void)nodetype;
16565  (void)nodeline;
16566 #if PARSER_DEBUG
16567  (void)lex_state_name(-1);
16568 #endif
16569 
16570  Init_id();
16571 }
16572 
16573 void
16575 {
16579 }
16580 #endif /* !RIPPER */
16581 
16582 static ID
16584 {
16585  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16586  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16587  return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16588 }
16589 
16590 #ifndef RIPPER
16591 static int
16592 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16593 {
16594  int mb = 0;
16595 
16596  if (m >= e) return 0;
16597  if (is_global_name_punct(*m)) {
16598  ++m;
16599  }
16600  else if (*m == '-') {
16601  ++m;
16602  if (m < e && is_identchar(m, e, enc)) {
16603  if (!ISASCII(*m)) mb = 1;
16604  m += rb_enc_mbclen(m, e, enc);
16605  }
16606  }
16607  else {
16608  if (!rb_enc_isdigit(*m, enc)) return 0;
16609  do {
16610  if (!ISASCII(*m)) mb = 1;
16611  ++m;
16612  } while (m < e && rb_enc_isdigit(*m, enc));
16613  }
16614  return m == e ? mb + 1 : 0;
16615 }
16616 
16617 int
16618 rb_symname_p(const char *name)
16619 {
16620  return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16621 }
16622 
16623 int
16624 rb_enc_symname_p(const char *name, rb_encoding *enc)
16625 {
16626  return rb_enc_symname2_p(name, strlen(name), enc);
16627 }
16628 
16629 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
16630 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<(1<<ID_SCOPE_SHIFT)) & ~(1U<<ID_ATTRSET))
16631 
16632 static int
16633 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_atttset)
16634 {
16635  const char *m = name;
16636  const char *e = m + len;
16637  int type = ID_JUNK;
16638 
16639  if (!m || len <= 0) return -1;
16640  switch (*m) {
16641  case '\0':
16642  return -1;
16643 
16644  case '$':
16645  type = ID_GLOBAL;
16646  if (is_special_global_name(++m, e, enc)) return type;
16647  goto id;
16648 
16649  case '@':
16650  type = ID_INSTANCE;
16651  if (*++m == '@') {
16652  ++m;
16653  type = ID_CLASS;
16654  }
16655  goto id;
16656 
16657  case '<':
16658  switch (*++m) {
16659  case '<': ++m; break;
16660  case '=': if (*++m == '>') ++m; break;
16661  default: break;
16662  }
16663  break;
16664 
16665  case '>':
16666  switch (*++m) {
16667  case '>': case '=': ++m; break;
16668  }
16669  break;
16670 
16671  case '=':
16672  switch (*++m) {
16673  case '~': ++m; break;
16674  case '=': if (*++m == '=') ++m; break;
16675  default: return -1;
16676  }
16677  break;
16678 
16679  case '*':
16680  if (*++m == '*') ++m;
16681  break;
16682 
16683  case '+': case '-':
16684  if (*++m == '@') ++m;
16685  break;
16686 
16687  case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16688  ++m;
16689  break;
16690 
16691  case '[':
16692  if (*++m != ']') return -1;
16693  if (*++m == '=') ++m;
16694  break;
16695 
16696  case '!':
16697  if (len == 1) return ID_JUNK;
16698  switch (*++m) {
16699  case '=': case '~': ++m; break;
16700  default: return -1;
16701  }
16702  break;
16703 
16704  default:
16705  type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16706  id:
16707  if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16708  return -1;
16709  while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16710  if (m >= e) break;
16711  switch (*m) {
16712  case '!': case '?':
16713  if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16714  type = ID_JUNK;
16715  ++m;
16716  if (m + 1 < e || *m != '=') break;
16717  /* fall through */
16718  case '=':
16719  if (!(allowed_atttset & (1U << type))) return -1;
16720  type = ID_ATTRSET;
16721  ++m;
16722  break;
16723  }
16724  break;
16725  }
16726  return m == e ? type : -1;
16727 }
16728 
16729 int
16730 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16731 {
16732  return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
16733 }
16734 
16735 static int
16736 rb_str_symname_type(VALUE name, unsigned int allowed_atttset)
16737 {
16738  const char *ptr = StringValuePtr(name);
16739  long len = RSTRING_LEN(name);
16740  int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_atttset);
16741  RB_GC_GUARD(name);
16742  return type;
16743 }
16744 
16745 static ID
16746 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16747 {
16748  VALUE str = rb_enc_str_new(name, len, enc);
16749  return register_symid_str(id, str);
16750 }
16751 
16752 static ID
16754 {
16755  OBJ_FREEZE(str);
16758  return id;
16759 }
16760 
16761 static int
16763 {
16764  if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
16765  switch (rb_enc_str_coderange(str)) {
16766  case ENC_CODERANGE_BROKEN:
16767  rb_raise(rb_eEncodingError, "invalid encoding symbol");
16768  case ENC_CODERANGE_7BIT:
16769  return TRUE;
16770  }
16771  return FALSE;
16772 }
16773 
16774 /*
16775  * _str_ itself will be registered at the global symbol table. _str_
16776  * can be modified before the registration, since the encoding will be
16777  * set to ASCII-8BIT if it is a special global name.
16778  */
16779 static ID intern_str(VALUE str);
16780 
16781 ID
16782 rb_intern3(const char *name, long len, rb_encoding *enc)
16783 {
16784  VALUE str;
16785  st_data_t data;
16786  struct RString fake_str;
16787  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
16788  fake_str.basic.klass = rb_cString;
16789  fake_str.as.heap.len = len;
16790  fake_str.as.heap.ptr = (char *)name;
16791  fake_str.as.heap.aux.capa = len;
16792  str = (VALUE)&fake_str;
16793  rb_enc_associate(str, enc);
16794  OBJ_FREEZE(str);
16795 
16796  if (st_lookup(global_symbols.sym_id, str, &data))
16797  return (ID)data;
16798 
16799  str = rb_enc_str_new(name, len, enc); /* make true string */
16800  return intern_str(str);
16801 }
16802 
16803 static ID
16805 {
16806  const char *name, *m, *e;
16807  long len, last;
16808  rb_encoding *enc, *symenc;
16809  unsigned char c;
16810  ID id;
16811  int mb;
16812 
16813  RSTRING_GETMEM(str, name, len);
16814  m = name;
16815  e = m + len;
16816  enc = rb_enc_get(str);
16817  symenc = enc;
16818 
16819  if (!len || (rb_cString && !rb_enc_asciicompat(enc))) {
16820  junk:
16821  id = ID_JUNK;
16822  goto new_id;
16823  }
16824  last = len-1;
16825  id = 0;
16826  switch (*m) {
16827  case '$':
16828  if (len < 2) goto junk;
16829  id |= ID_GLOBAL;
16830  if ((mb = is_special_global_name(++m, e, enc)) != 0) {
16831  if (!--mb) symenc = rb_usascii_encoding();
16832  goto new_id;
16833  }
16834  break;
16835  case '@':
16836  if (m[1] == '@') {
16837  if (len < 3) goto junk;
16838  m++;
16839  id |= ID_CLASS;
16840  }
16841  else {
16842  if (len < 2) goto junk;
16843  id |= ID_INSTANCE;
16844  }
16845  m++;
16846  break;
16847  default:
16848  c = m[0];
16849  if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
16850  /* operators */
16851  int i;
16852 
16853  if (len == 1) {
16854  id = c;
16855  goto id_register;
16856  }
16857  for (i = 0; i < op_tbl_count; i++) {
16858  if (*op_tbl[i].name == *m &&
16859  strcmp(op_tbl[i].name, m) == 0) {
16860  id = op_tbl[i].token;
16861  goto id_register;
16862  }
16863  }
16864  }
16865  break;
16866  }
16867  if (name[last] == '=') {
16868  /* attribute assignment */
16869  if (last > 1 && name[last-1] == '=')
16870  goto junk;
16871  id = rb_intern3(name, last, enc);
16872  if (id > tLAST_OP_ID && !is_attrset_id(id)) {
16873  enc = rb_enc_get(rb_id2str(id));
16874  id = rb_id_attrset(id);
16875  goto id_register;
16876  }
16877  id = ID_ATTRSET;
16878  }
16879  else if (id == 0) {
16880  if (rb_enc_isupper(m[0], enc)) {
16881  id = ID_CONST;
16882  }
16883  else {
16884  id = ID_LOCAL;
16885  }
16886  }
16887  if (!rb_enc_isdigit(*m, enc)) {
16888  while (m <= name + last && is_identchar(m, e, enc)) {
16889  if (ISASCII(*m)) {
16890  m++;
16891  }
16892  else {
16893  m += rb_enc_mbclen(m, e, enc);
16894  }
16895  }
16896  }
16897  if (id != ID_ATTRSET && m - name < len) id = ID_JUNK;
16898  if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
16899  new_id:
16900  if (symenc != enc) rb_enc_associate(str, symenc);
16902  if (len > 20) {
16903  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
16904  name);
16905  }
16906  else {
16907  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
16908  (int)len, name);
16909  }
16910  }
16912  id_register:
16913  return register_symid_str(id, str);
16914 }
16915 
16916 ID
16917 rb_intern2(const char *name, long len)
16918 {
16919  return rb_intern3(name, len, rb_usascii_encoding());
16920 }
16921 
16922 #undef rb_intern
16923 ID
16924 rb_intern(const char *name)
16925 {
16926  return rb_intern2(name, strlen(name));
16927 }
16928 
16929 ID
16931 {
16932  st_data_t id;
16933 
16934  if (st_lookup(global_symbols.sym_id, str, &id))
16935  return (ID)id;
16936  return intern_str(rb_str_dup(str));
16937 }
16938 
16939 VALUE
16941 {
16942  st_data_t data;
16943 
16944  if (id < tLAST_TOKEN) {
16945  int i = 0;
16946 
16947  if (id < INT_MAX && rb_ispunct((int)id)) {
16948  VALUE str = global_symbols.op_sym[i = (int)id];
16949  if (!str) {
16950  char name[2];
16951  name[0] = (char)id;
16952  name[1] = 0;
16953  str = rb_usascii_str_new(name, 1);
16954  OBJ_FREEZE(str);
16956  }
16957  return str;
16958  }
16959  for (i = 0; i < op_tbl_count; i++) {
16960  if (op_tbl[i].token == id) {
16961  VALUE str = global_symbols.op_sym[i];
16962  if (!str) {
16963  str = rb_usascii_str_new2(op_tbl[i].name);
16964  OBJ_FREEZE(str);
16966  }
16967  return str;
16968  }
16969  }
16970  }
16971 
16972  if (st_lookup(global_symbols.id_str, id, &data)) {
16973  VALUE str = (VALUE)data;
16974  if (RBASIC(str)->klass == 0)
16975  RBASIC(str)->klass = rb_cString;
16976  return str;
16977  }
16978 
16979  if (is_attrset_id(id)) {
16980  ID id_stem = (id & ~ID_SCOPE_MASK);
16981  VALUE str;
16982 
16983  do {
16984  if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break;
16985  if (!!(str = rb_id2str(id_stem | ID_CONST))) break;
16986  if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break;
16987  if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break;
16988  if (!!(str = rb_id2str(id_stem | ID_CLASS))) break;
16989  if (!!(str = rb_id2str(id_stem | ID_JUNK))) break;
16990  return 0;
16991  } while (0);
16992  str = rb_str_dup(str);
16993  rb_str_cat(str, "=", 1);
16994  register_symid_str(id, str);
16995  if (st_lookup(global_symbols.id_str, id, &data)) {
16996  VALUE str = (VALUE)data;
16997  if (RBASIC(str)->klass == 0)
16998  RBASIC(str)->klass = rb_cString;
16999  return str;
17000  }
17001  }
17002  return 0;
17003 }
17004 
17005 const char *
17007 {
17008  VALUE str = rb_id2str(id);
17009 
17010  if (!str) return 0;
17011  return RSTRING_PTR(str);
17012 }
17013 
17014 static int
17016 {
17017  rb_ary_push(ary, ID2SYM(value));
17018  return ST_CONTINUE;
17019 }
17020 
17021 /*
17022  * call-seq:
17023  * Symbol.all_symbols => array
17024  *
17025  * Returns an array of all the symbols currently in Ruby's symbol
17026  * table.
17027  *
17028  * Symbol.all_symbols.size #=> 903
17029  * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
17030  * :chown, :EOFError, :$;, :String,
17031  * :LOCK_SH, :"setuid?", :$<,
17032  * :default_proc, :compact, :extend,
17033  * :Tms, :getwd, :$=, :ThreadGroup,
17034  * :wait2, :$>]
17035  */
17036 
17037 VALUE
17039 {
17041 
17043  return ary;
17044 }
17045 
17046 int
17048 {
17049  return is_const_id(id);
17050 }
17051 
17052 int
17054 {
17055  return is_class_id(id);
17056 }
17057 
17058 int
17060 {
17061  return is_global_id(id);
17062 }
17063 
17064 int
17066 {
17067  return is_instance_id(id);
17068 }
17069 
17070 int
17072 {
17073  return is_attrset_id(id);
17074 }
17075 
17076 int
17078 {
17079  return is_local_id(id);
17080 }
17081 
17082 int
17084 {
17085  return is_junk_id(id);
17086 }
17087 
17099 ID
17100 rb_check_id(volatile VALUE *namep)
17101 {
17102  st_data_t id;
17103  VALUE tmp;
17104  VALUE name = *namep;
17105 
17106  if (SYMBOL_P(name)) {
17107  return SYM2ID(name);
17108  }
17109  else if (!RB_TYPE_P(name, T_STRING)) {
17110  tmp = rb_check_string_type(name);
17111  if (NIL_P(tmp)) {
17112  tmp = rb_inspect(name);
17113  rb_raise(rb_eTypeError, "%s is not a symbol",
17114  RSTRING_PTR(tmp));
17115  }
17116  name = tmp;
17117  *namep = name;
17118  }
17119 
17120  sym_check_asciionly(name);
17121 
17122  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17123  return (ID)id;
17124 
17125  if (rb_is_attrset_name(name)) {
17126  struct RString fake_str;
17127  const VALUE localname = (VALUE)&fake_str;
17128  /* make local name by chopping '=' */
17129  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17130  fake_str.basic.klass = rb_cString;
17131  fake_str.as.heap.len = RSTRING_LEN(name) - 1;
17132  fake_str.as.heap.ptr = RSTRING_PTR(name);
17133  fake_str.as.heap.aux.capa = fake_str.as.heap.len;
17134  rb_enc_copy(localname, name);
17135  OBJ_FREEZE(localname);
17136 
17137  if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17138  return rb_id_attrset((ID)id);
17139  }
17140  RB_GC_GUARD(name);
17141  }
17142 
17143  return (ID)0;
17144 }
17145 
17146 ID
17148 {
17149  st_data_t id;
17150  struct RString fake_str;
17151  const VALUE name = (VALUE)&fake_str;
17152  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17153  fake_str.basic.klass = rb_cString;
17154  fake_str.as.heap.len = len;
17155  fake_str.as.heap.ptr = (char *)ptr;
17156  fake_str.as.heap.aux.capa = len;
17157  rb_enc_associate(name, enc);
17158 
17159  sym_check_asciionly(name);
17160 
17161  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17162  return (ID)id;
17163 
17164  if (rb_is_attrset_name(name)) {
17165  fake_str.as.heap.len = len - 1;
17166  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
17167  return rb_id_attrset((ID)id);
17168  }
17169  }
17170 
17171  return (ID)0;
17172 }
17173 
17174 int
17176 {
17177  return rb_str_symname_type(name, 0) == ID_CONST;
17178 }
17179 
17180 int
17182 {
17183  return rb_str_symname_type(name, 0) == ID_CLASS;
17184 }
17185 
17186 int
17188 {
17189  return rb_str_symname_type(name, 0) == ID_GLOBAL;
17190 }
17191 
17192 int
17194 {
17195  return rb_str_symname_type(name, 0) == ID_INSTANCE;
17196 }
17197 
17198 int
17200 {
17202 }
17203 
17204 int
17206 {
17207  return rb_str_symname_type(name, 0) == ID_LOCAL;
17208 }
17209 
17210 int
17212 {
17213  switch (rb_str_symname_type(name, 0)) {
17214  case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17215  return TRUE;
17216  }
17217  return FALSE;
17218 }
17219 
17220 int
17222 {
17223  return rb_str_symname_type(name, IDSET_ATTRSET_FOR_SYNTAX) == -1;
17224 }
17225 
17226 #endif /* !RIPPER */
17227 
17228 static void
17230 {
17231  parser->eofp = Qfalse;
17232 
17233  parser->parser_lex_strterm = 0;
17234  parser->parser_cond_stack = 0;
17235  parser->parser_cmdarg_stack = 0;
17236  parser->parser_class_nest = 0;
17237  parser->parser_paren_nest = 0;
17238  parser->parser_lpar_beg = 0;
17239  parser->parser_brace_nest = 0;
17240  parser->parser_in_single = 0;
17241  parser->parser_in_def = 0;
17242  parser->parser_in_defined = 0;
17243  parser->parser_compile_for_eval = 0;
17244  parser->parser_cur_mid = 0;
17245  parser->parser_tokenbuf = NULL;
17246  parser->parser_tokidx = 0;
17247  parser->parser_toksiz = 0;
17248  parser->parser_heredoc_end = 0;
17249  parser->parser_command_start = TRUE;
17250  parser->parser_deferred_nodes = 0;
17251  parser->parser_lex_pbeg = 0;
17252  parser->parser_lex_p = 0;
17253  parser->parser_lex_pend = 0;
17254  parser->parser_lvtbl = 0;
17255  parser->parser_ruby__end__seen = 0;
17256  parser->parser_ruby_sourcefile = 0;
17258 #ifndef RIPPER
17259  parser->is_ripper = 0;
17260  parser->parser_eval_tree_begin = 0;
17261  parser->parser_eval_tree = 0;
17262 #else
17263  parser->is_ripper = 1;
17264  parser->delayed = Qnil;
17265 
17266  parser->result = Qnil;
17267  parser->parsing_thread = Qnil;
17268  parser->toplevel_p = TRUE;
17269 #endif
17270 #ifdef YYMALLOC
17271  parser->heap = NULL;
17272 #endif
17273  parser->enc = rb_utf8_encoding();
17274 }
17275 
17276 #ifdef RIPPER
17277 #define parser_mark ripper_parser_mark
17278 #define parser_free ripper_parser_free
17279 #endif
17280 
17281 static void
17283 {
17284  struct parser_params *p = (struct parser_params*)ptr;
17285 
17292 #ifndef RIPPER
17295  rb_gc_mark(p->debug_lines);
17296 #else
17297  rb_gc_mark(p->delayed);
17298  rb_gc_mark(p->value);
17299  rb_gc_mark(p->result);
17300  rb_gc_mark(p->parsing_thread);
17301 #endif
17302 #ifdef YYMALLOC
17303  rb_gc_mark((VALUE)p->heap);
17304 #endif
17305 }
17306 
17307 static void
17309 {
17310  struct parser_params *p = (struct parser_params*)ptr;
17311  struct local_vars *local, *prev;
17312 
17313  if (p->parser_tokenbuf) {
17314  xfree(p->parser_tokenbuf);
17315  }
17316  for (local = p->parser_lvtbl; local; local = prev) {
17317  if (local->vars) xfree(local->vars);
17318  prev = local->prev;
17319  xfree(local);
17320  }
17321  xfree(p);
17322 }
17323 
17324 static size_t
17325 parser_memsize(const void *ptr)
17326 {
17327  struct parser_params *p = (struct parser_params*)ptr;
17328  struct local_vars *local;
17329  size_t size = sizeof(*p);
17330 
17331  if (!ptr) return 0;
17332  size += p->parser_toksiz;
17333  for (local = p->parser_lvtbl; local; local = local->prev) {
17334  size += sizeof(*local);
17335  if (local->vars) size += local->vars->capa * sizeof(ID);
17336  }
17337  return size;
17338 }
17339 
17340 static
17341 #ifndef RIPPER
17342 const
17343 #endif
17344 rb_data_type_t parser_data_type = {
17345  "parser",
17346  {
17347  parser_mark,
17348  parser_free,
17350  },
17351 };
17352 
17353 #ifndef RIPPER
17354 #undef rb_reserved_word
17355 
17356 const struct kwtable *
17357 rb_reserved_word(const char *str, unsigned int len)
17358 {
17359  return reserved_word(str, len);
17360 }
17361 
17362 static struct parser_params *
17364 {
17365  struct parser_params *p;
17366 
17367  p = ALLOC_N(struct parser_params, 1);
17368  MEMZERO(p, struct parser_params, 1);
17369  parser_initialize(p);
17370  return p;
17371 }
17372 
17373 VALUE
17375 {
17376  struct parser_params *p = parser_new();
17377 
17378  return TypedData_Wrap_Struct(0, &parser_data_type, p);
17379 }
17380 
17381 /*
17382  * call-seq:
17383  * ripper#end_seen? -> Boolean
17384  *
17385  * Return true if parsed source ended by +\_\_END\_\_+.
17386  */
17387 VALUE
17389 {
17390  struct parser_params *parser;
17391 
17392  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17393  return ruby__end__seen ? Qtrue : Qfalse;
17394 }
17395 
17396 /*
17397  * call-seq:
17398  * ripper#encoding -> encoding
17399  *
17400  * Return encoding of the source.
17401  */
17402 VALUE
17404 {
17405  struct parser_params *parser;
17406 
17407  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17409 }
17410 
17411 /*
17412  * call-seq:
17413  * ripper.yydebug -> true or false
17414  *
17415  * Get yydebug.
17416  */
17417 VALUE
17419 {
17420  struct parser_params *parser;
17421 
17422  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17423  return yydebug ? Qtrue : Qfalse;
17424 }
17425 
17426 /*
17427  * call-seq:
17428  * ripper.yydebug = flag
17429  *
17430  * Set yydebug.
17431  */
17432 VALUE
17434 {
17435  struct parser_params *parser;
17436 
17437  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17438  yydebug = RTEST(flag);
17439  return flag;
17440 }
17441 
17442 #ifdef YYMALLOC
17443 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17444 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17445 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17446  (n)->u3.cnt = (c), (p))
17447 
17448 void *
17449 rb_parser_malloc(struct parser_params *parser, size_t size)
17450 {
17451  size_t cnt = HEAPCNT(1, size);
17452  NODE *n = NEWHEAP();
17453  void *ptr = xmalloc(size);
17454 
17455  return ADD2HEAP(n, cnt, ptr);
17456 }
17457 
17458 void *
17459 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17460 {
17461  size_t cnt = HEAPCNT(nelem, size);
17462  NODE *n = NEWHEAP();
17463  void *ptr = xcalloc(nelem, size);
17464 
17465  return ADD2HEAP(n, cnt, ptr);
17466 }
17467 
17468 void *
17469 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17470 {
17471  NODE *n;
17472  size_t cnt = HEAPCNT(1, size);
17473 
17474  if (ptr && (n = parser->heap) != NULL) {
17475  do {
17476  if (n->u1.node == ptr) {
17477  n->u1.node = ptr = xrealloc(ptr, size);
17478  if (n->u3.cnt) n->u3.cnt = cnt;
17479  return ptr;
17480  }
17481  } while ((n = n->u2.node) != NULL);
17482  }
17483  n = NEWHEAP();
17484  ptr = xrealloc(ptr, size);
17485  return ADD2HEAP(n, cnt, ptr);
17486 }
17487 
17488 void
17489 rb_parser_free(struct parser_params *parser, void *ptr)
17490 {
17491  NODE **prev = &parser->heap, *n;
17492 
17493  while ((n = *prev) != NULL) {
17494  if (n->u1.node == ptr) {
17495  *prev = n->u2.node;
17497  break;
17498  }
17499  prev = &n->u2.node;
17500  }
17501  xfree(ptr);
17502 }
17503 #endif
17504 #endif
17505 
17506 #ifdef RIPPER
17507 #ifdef RIPPER_DEBUG
17508 extern int rb_is_pointer_to_heap(VALUE);
17509 
17510 /* :nodoc: */
17511 static VALUE
17512 ripper_validate_object(VALUE self, VALUE x)
17513 {
17514  if (x == Qfalse) return x;
17515  if (x == Qtrue) return x;
17516  if (x == Qnil) return x;
17517  if (x == Qundef)
17518  rb_raise(rb_eArgError, "Qundef given");
17519  if (FIXNUM_P(x)) return x;
17520  if (SYMBOL_P(x)) return x;
17521  if (!rb_is_pointer_to_heap(x))
17522  rb_raise(rb_eArgError, "invalid pointer: %p", x);
17523  switch (TYPE(x)) {
17524  case T_STRING:
17525  case T_OBJECT:
17526  case T_ARRAY:
17527  case T_BIGNUM:
17528  case T_FLOAT:
17529  return x;
17530  case T_NODE:
17531  if (nd_type(x) != NODE_LASGN) {
17532  rb_raise(rb_eArgError, "NODE given: %p", x);
17533  }
17534  return ((NODE *)x)->nd_rval;
17535  default:
17536  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17537  x, rb_obj_classname(x));
17538  }
17539  return x;
17540 }
17541 #endif
17542 
17543 #define validate(x) ((x) = get_value(x))
17544 
17545 static VALUE
17546 ripper_dispatch0(struct parser_params *parser, ID mid)
17547 {
17548  return rb_funcall(parser->value, mid, 0);
17549 }
17550 
17551 static VALUE
17552 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17553 {
17554  validate(a);
17555  return rb_funcall(parser->value, mid, 1, a);
17556 }
17557 
17558 static VALUE
17559 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17560 {
17561  validate(a);
17562  validate(b);
17563  return rb_funcall(parser->value, mid, 2, a, b);
17564 }
17565 
17566 static VALUE
17567 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17568 {
17569  validate(a);
17570  validate(b);
17571  validate(c);
17572  return rb_funcall(parser->value, mid, 3, a, b, c);
17573 }
17574 
17575 static VALUE
17576 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17577 {
17578  validate(a);
17579  validate(b);
17580  validate(c);
17581  validate(d);
17582  return rb_funcall(parser->value, mid, 4, a, b, c, d);
17583 }
17584 
17585 static VALUE
17586 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17587 {
17588  validate(a);
17589  validate(b);
17590  validate(c);
17591  validate(d);
17592  validate(e);
17593  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17594 }
17595 
17596 static VALUE
17597 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17598 {
17599  validate(a);
17600  validate(b);
17601  validate(c);
17602  validate(d);
17603  validate(e);
17604  validate(f);
17605  validate(g);
17606  return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17607 }
17608 
17609 static const struct kw_assoc {
17610  ID id;
17611  const char *name;
17612 } keyword_to_name[] = {
17613  {keyword_class, "class"},
17614  {keyword_module, "module"},
17615  {keyword_def, "def"},
17616  {keyword_undef, "undef"},
17617  {keyword_begin, "begin"},
17618  {keyword_rescue, "rescue"},
17619  {keyword_ensure, "ensure"},
17620  {keyword_end, "end"},
17621  {keyword_if, "if"},
17622  {keyword_unless, "unless"},
17623  {keyword_then, "then"},
17624  {keyword_elsif, "elsif"},
17625  {keyword_else, "else"},
17626  {keyword_case, "case"},
17627  {keyword_when, "when"},
17628  {keyword_while, "while"},
17629  {keyword_until, "until"},
17630  {keyword_for, "for"},
17631  {keyword_break, "break"},
17632  {keyword_next, "next"},
17633  {keyword_redo, "redo"},
17634  {keyword_retry, "retry"},
17635  {keyword_in, "in"},
17636  {keyword_do, "do"},
17637  {keyword_do_cond, "do"},
17638  {keyword_do_block, "do"},
17639  {keyword_return, "return"},
17640  {keyword_yield, "yield"},
17641  {keyword_super, "super"},
17642  {keyword_self, "self"},
17643  {keyword_nil, "nil"},
17644  {keyword_true, "true"},
17645  {keyword_false, "false"},
17646  {keyword_and, "and"},
17647  {keyword_or, "or"},
17648  {keyword_not, "not"},
17649  {modifier_if, "if"},
17650  {modifier_unless, "unless"},
17651  {modifier_while, "while"},
17652  {modifier_until, "until"},
17653  {modifier_rescue, "rescue"},
17654  {keyword_alias, "alias"},
17655  {keyword_defined, "defined?"},
17656  {keyword_BEGIN, "BEGIN"},
17657  {keyword_END, "END"},
17658  {keyword__LINE__, "__LINE__"},
17659  {keyword__FILE__, "__FILE__"},
17660  {keyword__ENCODING__, "__ENCODING__"},
17661  {0, NULL}
17662 };
17663 
17664 static const char*
17665 keyword_id_to_str(ID id)
17666 {
17667  const struct kw_assoc *a;
17668 
17669  for (a = keyword_to_name; a->id; a++) {
17670  if (a->id == id)
17671  return a->name;
17672  }
17673  return NULL;
17674 }
17675 
17676 #undef ripper_id2sym
17677 static VALUE
17678 ripper_id2sym(ID id)
17679 {
17680  const char *name;
17681  char buf[8];
17682 
17683  if (id <= 256) {
17684  buf[0] = (char)id;
17685  buf[1] = '\0';
17686  return ID2SYM(rb_intern2(buf, 1));
17687  }
17688  if ((name = keyword_id_to_str(id))) {
17689  return ID2SYM(rb_intern(name));
17690  }
17691  switch (id) {
17692  case tOROP:
17693  name = "||";
17694  break;
17695  case tANDOP:
17696  name = "&&";
17697  break;
17698  default:
17699  name = rb_id2name(id);
17700  if (!name) {
17701  rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17702  }
17703  return ID2SYM(id);
17704  }
17705  return ID2SYM(rb_intern(name));
17706 }
17707 
17708 static ID
17709 ripper_get_id(VALUE v)
17710 {
17711  NODE *nd;
17712  if (!RB_TYPE_P(v, T_NODE)) return 0;
17713  nd = (NODE *)v;
17714  if (nd_type(nd) != NODE_LASGN) return 0;
17715  return nd->nd_vid;
17716 }
17717 
17718 static VALUE
17719 ripper_get_value(VALUE v)
17720 {
17721  NODE *nd;
17722  if (v == Qundef) return Qnil;
17723  if (!RB_TYPE_P(v, T_NODE)) return v;
17724  nd = (NODE *)v;
17725  if (nd_type(nd) != NODE_LASGN) return Qnil;
17726  return nd->nd_rval;
17727 }
17728 
17729 static void
17730 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17731 {
17732  VALUE str;
17733  va_list args;
17734 
17735  va_start(args, fmt);
17736  str = rb_vsprintf(fmt, args);
17737  va_end(args);
17738  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17739 }
17740 
17741 static void
17742 ripper_warn0(struct parser_params *parser, const char *fmt)
17743 {
17744  rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
17745 }
17746 
17747 static void
17748 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
17749 {
17750  rb_funcall(parser->value, rb_intern("warn"), 2,
17751  STR_NEW2(fmt), INT2NUM(a));
17752 }
17753 
17754 static void
17755 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
17756 {
17757  rb_funcall(parser->value, rb_intern("warn"), 2,
17758  STR_NEW2(fmt), STR_NEW2(str));
17759 }
17760 
17761 static void
17762 ripper_warning0(struct parser_params *parser, const char *fmt)
17763 {
17764  rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
17765 }
17766 
17767 static void
17768 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
17769 {
17770  rb_funcall(parser->value, rb_intern("warning"), 2,
17771  STR_NEW2(fmt), STR_NEW2(str));
17772 }
17773 
17774 static VALUE
17775 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
17776 {
17777  return rb_io_gets(src);
17778 }
17779 
17780 static VALUE
17781 ripper_s_allocate(VALUE klass)
17782 {
17783  struct parser_params *p;
17784  VALUE self;
17785 
17786  p = ALLOC_N(struct parser_params, 1);
17787  MEMZERO(p, struct parser_params, 1);
17788  self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
17789  p->value = self;
17790  return self;
17791 }
17792 
17793 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
17794 
17795 /*
17796  * call-seq:
17797  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
17798  *
17799  * Create a new Ripper object.
17800  * _src_ must be a String, an IO, or an Object which has #gets method.
17801  *
17802  * This method does not starts parsing.
17803  * See also Ripper#parse and Ripper.parse.
17804  */
17805 static VALUE
17806 ripper_initialize(int argc, VALUE *argv, VALUE self)
17807 {
17808  struct parser_params *parser;
17809  VALUE src, fname, lineno;
17810 
17811  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17812  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
17813  if (RB_TYPE_P(src, T_FILE)) {
17814  parser->parser_lex_gets = ripper_lex_get_generic;
17815  }
17816  else {
17817  StringValue(src);
17818  parser->parser_lex_gets = lex_get_str;
17819  }
17820  parser->parser_lex_input = src;
17821  parser->eofp = Qfalse;
17822  if (NIL_P(fname)) {
17823  fname = STR_NEW2("(ripper)");
17824  }
17825  else {
17826  StringValue(fname);
17827  }
17828  parser_initialize(parser);
17829 
17830  parser->parser_ruby_sourcefile_string = fname;
17831  parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
17832  parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
17833 
17834  return Qnil;
17835 }
17836 
17837 struct ripper_args {
17838  struct parser_params *parser;
17839  int argc;
17840  VALUE *argv;
17841 };
17842 
17843 static VALUE
17844 ripper_parse0(VALUE parser_v)
17845 {
17846  struct parser_params *parser;
17847 
17848  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17849  parser_prepare(parser);
17850  ripper_yyparse((void*)parser);
17851  return parser->result;
17852 }
17853 
17854 static VALUE
17855 ripper_ensure(VALUE parser_v)
17856 {
17857  struct parser_params *parser;
17858 
17859  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17860  parser->parsing_thread = Qnil;
17861  return Qnil;
17862 }
17863 
17864 /*
17865  * call-seq:
17866  * ripper#parse
17867  *
17868  * Start parsing and returns the value of the root action.
17869  */
17870 static VALUE
17871 ripper_parse(VALUE self)
17872 {
17873  struct parser_params *parser;
17874 
17875  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17876  if (!ripper_initialized_p(parser)) {
17877  rb_raise(rb_eArgError, "method called for uninitialized object");
17878  }
17879  if (!NIL_P(parser->parsing_thread)) {
17880  if (parser->parsing_thread == rb_thread_current())
17881  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
17882  else
17883  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
17884  }
17885  parser->parsing_thread = rb_thread_current();
17886  rb_ensure(ripper_parse0, self, ripper_ensure, self);
17887 
17888  return parser->result;
17889 }
17890 
17891 /*
17892  * call-seq:
17893  * ripper#column -> Integer
17894  *
17895  * Return column number of current parsing line.
17896  * This number starts from 0.
17897  */
17898 static VALUE
17899 ripper_column(VALUE self)
17900 {
17901  struct parser_params *parser;
17902  long col;
17903 
17904  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17905  if (!ripper_initialized_p(parser)) {
17906  rb_raise(rb_eArgError, "method called for uninitialized object");
17907  }
17908  if (NIL_P(parser->parsing_thread)) return Qnil;
17909  col = parser->tokp - parser->parser_lex_pbeg;
17910  return LONG2NUM(col);
17911 }
17912 
17913 /*
17914  * call-seq:
17915  * ripper#filename -> String
17916  *
17917  * Return current parsing filename.
17918  */
17919 static VALUE
17920 ripper_filename(VALUE self)
17921 {
17922  struct parser_params *parser;
17923 
17924  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17925  if (!ripper_initialized_p(parser)) {
17926  rb_raise(rb_eArgError, "method called for uninitialized object");
17927  }
17928  return parser->parser_ruby_sourcefile_string;
17929 }
17930 
17931 /*
17932  * call-seq:
17933  * ripper#lineno -> Integer
17934  *
17935  * Return line number of current parsing line.
17936  * This number starts from 1.
17937  */
17938 static VALUE
17939 ripper_lineno(VALUE self)
17940 {
17941  struct parser_params *parser;
17942 
17943  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17944  if (!ripper_initialized_p(parser)) {
17945  rb_raise(rb_eArgError, "method called for uninitialized object");
17946  }
17947  if (NIL_P(parser->parsing_thread)) return Qnil;
17948  return INT2NUM(parser->parser_ruby_sourceline);
17949 }
17950 
17951 #ifdef RIPPER_DEBUG
17952 /* :nodoc: */
17953 static VALUE
17954 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
17955 {
17956  StringValue(msg);
17957  if (obj == Qundef) {
17958  rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
17959  }
17960  return Qnil;
17961 }
17962 
17963 /* :nodoc: */
17964 static VALUE
17965 ripper_value(VALUE self, VALUE obj)
17966 {
17967  return ULONG2NUM(obj);
17968 }
17969 #endif
17970 
17971 
17972 void
17973 Init_ripper(void)
17974 {
17975  parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
17976 
17979  /* ensure existing in symbol table */
17980  (void)rb_intern("||");
17981  (void)rb_intern("&&");
17982 
17983  InitVM(ripper);
17984 }
17985 
17986 void
17987 InitVM_ripper(void)
17988 {
17989  VALUE Ripper;
17990 
17991  Ripper = rb_define_class("Ripper", rb_cObject);
17992  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
17993  rb_define_alloc_func(Ripper, ripper_s_allocate);
17994  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
17995  rb_define_method(Ripper, "parse", ripper_parse, 0);
17996  rb_define_method(Ripper, "column", ripper_column, 0);
17997  rb_define_method(Ripper, "filename", ripper_filename, 0);
17998  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
17999  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
18000  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
18001  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
18002  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
18003 #ifdef RIPPER_DEBUG
18004  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
18005  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
18006  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
18007 #endif
18008 
18011 
18012 # if 0
18013  /* Hack to let RDoc document SCRIPT_LINES__ */
18014 
18015  /*
18016  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
18017  * after the assignment will be added as an Array of lines with the file
18018  * name as the key.
18019  */
18020  rb_define_global_const("SCRIPT_LINES__", Qnil);
18021 #endif
18022 
18023 }
18024 #endif /* RIPPER */
18025 
VALUE data
Definition: tcltklib.c:3367
#define in_defined
Definition: ripper.c:380
#define rb_enc_islower(c, enc)
char * parser_ruby_sourcefile
Definition: ripper.c:327
#define RB_TYPE_P(obj, type)
VALUE val
Definition: parse.h:164
#define local_var(id)
Definition: ripper.c:558
#define cond(node)
Definition: ripper.c:424
#define deferred_nodes
Definition: ripper.c:393
#define nd_next
#define nd_type(n)
#define arg_var(id)
Definition: ripper.c:560
#define NEW_ARGSCAT(a, b)
RARRAY_PTR(q->result)[0]
#define NODE_DREGX_ONCE
#define ret_args(node)
Definition: ripper.c:475
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:1882
#define yyparse
Definition: ripper.c:418
stack_type cmdargs
Definition: ripper.c:193
#define ALLOC(type)
volatile VALUE tmp
Definition: tcltklib.c:10208
#define NEW_FALSE()
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: ripper.c:4645
enum lex_state_e state
Definition: lex.c:33
struct local_vars * parser_lvtbl
Definition: ripper.c:323
#define NODE_IF
VALUE rb_ary_unshift(VALUE ary, VALUE item)
Definition: array.c:1071
static ID ripper_token2eventid(int tok)
Definition: eventids2.c:273
#define NODE_RESCUE
Definition: lex.c:33
#define IS_LABEL_SUFFIX(n)
Definition: ripper.c:13362
#define new_args_tail(k, kr, b)
Definition: ripper.c:471
#define YYSTACK_ALLOC
Definition: ripper.c:1044
int rb_is_attrset_id(ID id)
Definition: ripper.c:17071
int rb_enc_codelen(int c, rb_encoding *enc)
Definition: encoding.c:954
#define NODE_RETRY
Definition: ripper.y:119
#define NODE_DEFN
static double zero(void)
Definition: isinf.c:51
#define lex_input
Definition: ripper.c:385
#define lex_state
Definition: ripper.c:369
#define subnodes(n1, n2)
#define parser_precise_mbclen()
Definition: ripper.c:11643
static NODE * remove_begin(NODE *)
Definition: ripper.c:15527
ssize_t n
Definition: bigdecimal.c:5676
#define NEW_STRTERM(func, term, paren)
Definition: ripper.c:12661
VALUE sym
Definition: tkutil.c:1298
static const yytype_int16 yydefgoto[]
Definition: ripper.c:1873
volatile VALUE ary
Definition: tcltklib.c:9712
#define list_concat(h, t)
Definition: ripper.c:449
#define NODE_FALSE
#define NEW_DOT3(b, e)
case return tREGEXP_BEG
Definition: ripper.y:7646
static struct parser_params * parser_new(void)
Definition: ripper.c:17363
#define FLONUM_P(x)
VP_EXPORT int
Definition: bigdecimal.c:5071
#define NODE_OR
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
st_table * st_init_table_with_size(const struct st_hash_type *, st_index_t)
Definition: st.c:229
#define NEW_IASGN(v, val)
VALUE rb_get_coverages(void)
Definition: thread.c:5185
#define yydebug
Definition: ripper.c:402
static char *char * yydest
Definition: ripper.c:4621
static NODE * arg_blk_pass(NODE *, NODE *)
Definition: ripper.c:15869
#define NEW_NTH_REF(n)
static ID internal_id_gen(struct parser_params *)
Definition: ripper.c:16583
Definition: ripper.y:115
void rb_bug(const char *fmt,...)
Definition: error.c:295
#define NEW_DASGN_CURR(v, val)
int num
Definition: parse.h:167
#define IS_END()
Definition: ripper.c:13358
struct token_info * next
Definition: ripper.c:275
#define ENC_SINGLE(cr)
Definition: ripper.c:362
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:15793
#define tail
Definition: st.c:108
Definition: ripper.y:108
void rb_mark_tbl(struct st_table *)
Definition: gc.c:2543
int rb_is_class_name(VALUE name)
Definition: ripper.c:17181
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:12017
static int comment_at_top(struct parser_params *parser)
Definition: ripper.c:13103
#define RE_OPTION_ENCODING_IDX(o)
Definition: ripper.c:585
#define rb_gc_mark_locations(start, end)
Definition: gc.c:2348
size_t strlen(const char *)
#define assignable(id, node)
Definition: ripper.c:485
yytype_int16 yyssa[YYINITDEPTH]
Definition: ripper.c:4918
static size_t parser_memsize(const void *ptr)
Definition: ripper.c:17325
VALUE parser_lex_nextline
Definition: ripper.c:314
VALUE rb_make_exception(int argc, VALUE *argv)
Definition: eval.c:642
#define STR_FUNC_ESCAPE
Definition: ripper.c:12041
#define scan_oct(s, l, e)
Definition: util.h:52
VALUE stack_type
Definition: ripper.c:164
const char * rb_obj_classname(VALUE)
Definition: variable.c:396
#define IDSET_ATTRSET_FOR_SYNTAX
Definition: ripper.c:16629
#define reg_compile(str, options)
Definition: ripper.c:512
VALUE rb_id2str(ID id)
Definition: ripper.c:16940
Win32OLEIDispatch * p
Definition: win32ole.c:786
static NODE * call_uni_op_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:14955
#define toksiz
Definition: ripper.c:383
#define YY_(msgid)
Definition: ripper.c:976
int parser_ruby__end__seen
Definition: ripper.c:324
#define NODE_DSYM
int parser_command_start
Definition: ripper.c:319
static void fixpos(NODE *, NODE *)
Definition: ripper.c:14705
#define NODE_DEFS
#define YYSTACK_FREE
Definition: ripper.c:1045
#define NEW_CALL(r, m, a)
int st_lookup(st_table *, st_data_t, st_data_t *)
void st_add_direct(st_table *, st_data_t, st_data_t)
Definition: st.c:629
#define nd_body
static void reduce_nodes_gen(struct parser_params *, NODE **)
Definition: ripper.c:15537
#define value_expr(node)
Definition: ripper.c:434
#define nd_paren(node)
Definition: ripper.c:599
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2109
#define NODE_HASH
#define NODE_DOT3
static NODE * call_bin_op_gen(struct parser_params *, NODE *, ID, NODE *)
Definition: ripper.c:14947
const char * name
Definition: lex.c:33
#define tEMBDOC_BEG
Definition: eventids2.c:3
Definition: ripper.y:118
static int parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp, int string_literal, int symbol_literal, int regexp_literal)
Definition: ripper.c:12210
int parser_compile_for_eval
Definition: ripper.c:305
#define get_id(id)
Definition: ripper.c:520
int parser_token_info_enabled
Definition: ripper.c:342
#define NEW_ALIAS(n, o)
#define NEW_OP_CDECL(v, op, val)
int parser_brace_nest
Definition: ripper.c:304
#define YYLEX
Definition: ripper.c:4393
static NODE * new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: ripper.c:15999
Definition: ripper.y:105
#define YYABORT
Definition: ripper.c:4313
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:108
static void parser_heredoc_restore(struct parser_params *parser, NODE *here)
Definition: ripper.c:12869
#define lex_eol_p()
Definition: ripper.c:12077
#define rb_usascii_str_new2
#define NEW_TRUE()
static int yysyntax_error(YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
Definition: ripper.c:4693
#define dyna_in_block()
Definition: ripper.c:571
#define nd_resq
#define NODE_NTH_REF
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:2218
static NODE * gettable_gen(struct parser_params *, ID)
Definition: ripper.c:14996
#define str_copy(_s, _p, _n)
void rb_gc_force_recycle(VALUE)
Definition: gc.c:2963
ssize_t i
Definition: bigdecimal.c:5676
#define NODE_TRUE
#define was_bol()
Definition: ripper.c:12147
#define IS_SPCARG(c)
Definition: ripper.c:13360
#define void_stmts(node)
Definition: ripper.c:438
#define T_NODE
static struct symbols global_symbols
#define rb_enc_name(enc)
VALUE rb_parser_end_seen_p(VALUE vparser)
Definition: ripper.c:17388
#define current_enc
Definition: ripper.c:401
int line_count
Definition: ripper.c:325
#define YYNTOKENS
Definition: ripper.c:1141
#define NEW_EVSTR(n)
#define NODE_ARGS
#define NEW_NEXT(s)
struct token_info token_info
#define new_op_assign(lhs, op, rhs)
Definition: ripper.c:544
stack_type parser_cmdarg_stack
Definition: ripper.c:298
#define RFLOAT_VALUE(v)
int yyresult
Definition: ripper.c:4930
static NODE * parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
Definition: ripper.c:11950
#define new_args(f, o, r, p, t)
Definition: ripper.c:469
yytype_int16 * yyssp
Definition: ripper.c:4920
#define strcasecmp
Definition: win32.h:200
#define nextc()
Definition: ripper.c:11533
#define rb_warning0(fmt)
Definition: ripper.c:698
VALUE rb_enc_from_encoding(rb_encoding *encoding)
Definition: encoding.c:103
static YYSIZE_T const char * yystr
Definition: ripper.c:4597
#define NEW_NIL()
#define token_info_push(token)
Definition: ripper.c:737
Real * a
Definition: bigdecimal.c:1196
#define NODE_ENSURE
VALUE rb_eTypeError
Definition: error.c:516
#define rb_enc_isalnum(c, enc)
static int parser_here_document(struct parser_params *, NODE *)
Definition: ripper.c:12916
#define OBJ_FREEZE(x)
NODE * node
Definition: parse.h:165
#define rb_warnS(fmt, a)
Definition: ripper.c:696
#define dsym_node(node)
Definition: ripper.c:480
Definition: ripper.y:120
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
long(* rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len)
Definition: ripper.c:13115
#define NEW_ZARRAY()
st_table * names
Definition: encoding.c:53
#define logop(type, node1, node2)
Definition: ripper.c:426
#define rb_enc_prev_char(s, p, e, enc)
VALUE enc
Definition: tcltklib.c:10310
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:822
NODE * kw_args
Definition: ripper.y:519
Definition: ripper.y:99
unsigned long int yylno
Definition: ripper.c:4533
#define MAX_WORD_LENGTH
Definition: lex.c:43
static NODE * evstr2dstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:14924
VALUE rb_eEncodingError
Definition: error.c:522
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:16307
static void warn_unused_var(struct parser_params *parser, struct local_vars *local)
Definition: ripper.c:16034
return yyd
Definition: ripper.c:4631
#define TYPE(x)
struct RBasic basic
Definition: ripper.y:843
unsigned short int yytype_uint16
Definition: ripper.c:943
#define nd_else
#define parse_string(n)
Definition: ripper.c:11543
yytokentype
Definition: ripper.y:40
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:789
#define NODE_PRELUDE
#define is_identchar(p, e, enc)
Definition: ripper.c:11644
#define RSTRING_PTR(str)
yytype_int16 * yyss
Definition: ripper.c:4919
#define NEW_MATCH2(n1, n2)
VALUE op_sym[tLAST_OP_ID]
Definition: ripper.c:16519
#define COND_PUSH(n)
Definition: ripper.c:171
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2525
NIL_P(eventloop_thread)
Definition: tcltklib.c:4067
#define T_ARRAY
VALUE debug_lines
Definition: ripper.c:338
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
Definition: string.c:439
#define warn_balanced(op, syn)
Definition: ripper.c:13372
#define NEW_LAMBDA(a, b)
ID id
Definition: parse.h:166
#define nd_plen
#define match_op(node1, node2)
Definition: ripper.c:504
#define CMDARG_P()
Definition: ripper.c:179
#define dvar_defined(id)
Definition: ripper.c:574
#define NEW_POSTEXE(b)
#define NEW_STR(s)
VALUE var
Definition: tcltklib.c:5516
#define yyerrok
Definition: ripper.c:4307
#define NODE_EVSTR
#define YYEMPTY
Definition: ripper.c:4309
#define tok()
Definition: ripper.c:12150
#define xfree
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
Definition: vm_eval.c:773
#define NODE_DXSTR
static void ripper_init_eventids1_table(VALUE self)
Definition: eventids1.c:270
#define reg_fragment_setenc(str, options)
Definition: ripper.c:514
static NODE * match_op_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14962
#define NODE_CASE
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1788
#define rb_warn4S(file, line, fmt, a)
Definition: ripper.c:697
#define rb_warnI(fmt, a)
Definition: ripper.c:695
#define T_HASH
Definition: ripper.y:109
return Qtrue
Definition: tcltklib.c:9609
static NODE * node_assign_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15331
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:14728
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: ripper.c:4410
static NODE * newline_node(NODE *)
Definition: ripper.c:14695
ID * tbl
Definition: ripper.c:182
union RString::@63 as
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:177
#define newtok()
Definition: ripper.c:11535
static NODE * range_op(struct parser_params *parser, NODE *node)
Definition: ripper.c:15692
#define reduce_nodes(n)
Definition: ripper.c:440
#define YYPOPSTACK(N)
Definition: ripper.c:4944
#define T_FILE
#define dyna_var(id)
Definition: ripper.c:572
int pre_args_num
Definition: ripper.y:511
primary_value operation2 command_args prec tLOWEST
Definition: ripper.y:1402
#define NODE_HEREDOC
Definition: ripper.c:591
#define NEW_CONST(v)
int parser_toksiz
Definition: ripper.c:310
#define POINTER_P(val)
Definition: ripper.c:199
#define STR_FUNC_INDENT
Definition: ripper.c:12046
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
Definition: encoding.c:886
VALUE rb_ary_new3(long n,...)
Definition: array.c:432
static void parser_pushback(struct parser_params *parser, int c)
Definition: ripper.c:12138
NODE * kw_rest_arg
Definition: ripper.y:520
#define NODE_STR
ID last_id
Definition: ripper.c:16512
#define Qnone
Definition: ripper.c:686
#define RFLOAT(obj)
#define NODE_REDO
static int lvar_defined_gen(struct parser_params *, ID)
Definition: ripper.c:13044
#define NODE_NEXT
const char * alias
Definition: nkf.c:1151
#define ruby__end__seen
Definition: ripper.c:397
Definition: ripper.y:112
#define NEW_DVAR(v)
void(* rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13116
r
Definition: bigdecimal.c:1210
#define ruby_debug_lines
Definition: ripper.c:407
#define parser_is_identchar()
Definition: ripper.c:11645
#define local_pop()
Definition: ripper.c:556
#define ID_LOCAL
#define ruby_sourcefile
Definition: compile.c:424
Definition: ripper.y:82
#define NODE_XSTR
Definition: ripper.y:107
#define NEW_CVASGN(v, val)
static int parser_whole_match_p(struct parser_params *parser, const char *eos, long len, int indent)
Definition: ripper.c:12886
#define NODE_BLOCK_PASS
#define RE_OPTION_ENCODING(e)
Definition: ripper.c:584
#define rb_backref_error(n)
Definition: ripper.c:493
int state
Definition: tcltklib.c:1461
#define ISDIGIT(c)
#define NEW_BREAK(s)
unsigned int last
Definition: nkf.c:4310
#define NEW_OP_ASGN_OR(i, val)
static void parser_initialize(struct parser_params *parser)
Definition: ripper.c:17229
#define NEW_MASGN(l, r)
ID block_arg
Definition: ripper.y:517
#define ENCODING_IS_ASCII8BIT(obj)
static NODE * node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE)
Definition: ripper.c:14675
#define InitVM(ext)
static const yytype_uint16 yyr1[]
Definition: ripper.c:1624
int yytoken
Definition: ripper.c:4932
ID rb_check_id(volatile VALUE *namep)
Returns ID for the given name if it is interned already, or 0.
Definition: ripper.c:17100
int yystate
Definition: ripper.c:4906
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
Definition: ripper.c:17147
struct RNode * node
Definition: ripper.y:244
#define lex_gets_ptr
Definition: ripper.c:394
rb_encoding * rb_utf8_encoding(void)
Definition: encoding.c:1166
#define ID2SYM(x)
#define here_document(n)
Definition: ripper.c:11545
VALUE parser_lex_input
Definition: ripper.c:312
static long parser_encode_length(struct parser_params *parser, const char *name, long len)
Definition: ripper.c:13051
#define T_FLOAT
VALUE tbl
Definition: tkutil.c:1279
#define is_instance_id(id)
Definition: ripper.c:113
#define NEW_LVAR(v)
#define call_bin_op(recv, id, arg1)
Definition: ripper.c:464
VALUE VALUE args
Definition: tcltklib.c:2560
VALUE klass
Definition: ripper.y:701
#define arg_concat(h, t)
Definition: ripper.c:453
#define rb_enc_isdigit(c, enc)
#define T_OBJECT
static enum node_type nodetype(NODE *node)
Definition: ripper.c:14683
#define ENC_CODERANGE_BROKEN
VALUE rb_sym_all_symbols(void)
Definition: ripper.c:17038
static VALUE lex_getline(struct parser_params *parser)
Definition: ripper.c:11927
static NODE * ret_args_gen(struct parser_params *, NODE *)
Definition: ripper.c:15816
Definition: ripper.y:114
#define ID_INTERNAL
#define LONG2NUM(x)
VALUE rb_str_append(VALUE, VALUE)
Definition: string.c:2125
static const yytype_int16 yytable[]
Definition: ripper.c:2039
VALUE rb_str_new_frozen(VALUE)
Definition: string.c:713
#define RUBY_DTRACE_PARSE_BEGIN(arg0, arg1)
Definition: probes.h:68
Definition: ripper.y:96
int pos
Definition: ripper.c:183
VALUE parser_ruby_sourcefile_string
Definition: ripper.c:329
#define NEW_FOR(v, i, b)
#define YYLAST
Definition: ripper.c:1138
#define NEW_CLASS(n, b, s)
#define YYID(n)
Definition: ripper.c:989
#define NODE_GASGN
int rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:16730
static NODE * yycompile(struct parser_params *parser, VALUE fname, int line)
Definition: ripper.c:11887
#define NEW_SPLAT(a)
#define ID_SCOPE_SHIFT
flag
Definition: tcltklib.c:2047
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: ripper.c:17433
#define NEW_PRELUDE(p, b)
d
Definition: strlcat.c:58
static int yylex(void *, void *)
gz lineno
Definition: zlib.c:2268
#define NEW_ITER(a, b)
#define head
Definition: st.c:107
const char * fmt
Definition: tcltklib.c:841
#define ENCODING_GET(obj)
int parser_yydebug
Definition: ripper.c:332
#define gettable(id)
Definition: ripper.c:483
st_table * id_str
Definition: ripper.c:16514
NODE * parser_eval_tree
Definition: ripper.c:337
#define list_append(l, i)
Definition: ripper.c:447
NODE * parser_deferred_nodes
Definition: ripper.c:320
static int simple_re_meta(int c)
Definition: ripper.c:12515
#define NEW_GVAR(v)
int yyi
Definition: ripper.c:4530
int yynerrs
Definition: ripper.c:4904
void rb_name_error(ID id, const char *fmt,...)
Definition: error.c:904
command_asgn lhs
Definition: ripper.y:1271
#define STR_NEW0()
Definition: ripper.c:359
Definition: ripper.y:240
static int e_option_supplied(struct parser_params *parser)
Definition: ripper.c:11821
static void block_dup_check_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15211
Definition: parse.h:159
int has_shebang
Definition: ripper.c:326
nd_args
Definition: parse.y:1383
#define NEWHEAP()
Definition: ripper.c:17444
#define NEW_DSTR(s)
#define SPECIAL_PUNCT(idx)
Definition: ripper.c:12688
#define nd_set_type(n, t)
static int vtable_size(const struct vtable *tbl)
Definition: ripper.c:202
static int assign_in_cond(struct parser_params *parser, NODE *node)
Definition: ripper.c:15622
#define ISALPHA(c)
Definition: ruby.h:1636
#define MEMZERO(p, type, n)
void rb_exc_raise(VALUE mesg)
Definition: eval.c:527
#define NEW_UNLESS(c, t, e)
#define STR_FUNC_REGEXP
Definition: ripper.c:12043
#define NEW_MODULE(n, b)
static NODE * list_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14782
unsigned long st_data_t
Definition: ripper.y:35
#define strtod(s, e)
Definition: util.h:76
VALUE rb_usascii_str_new(const char *, long)
Definition: string.c:431
static rb_encoding * must_be_ascii_compatible(VALUE s)
Definition: ripper.c:11897
struct vtable * prev
Definition: ripper.c:185
int rb_is_const_id(ID id)
Definition: ripper.c:17047
int rb_is_instance_id(ID id)
Definition: ripper.c:17065
#define RUBY_DTRACE_PARSE_END(arg0, arg1)
Definition: probes.h:72
struct RString::@63::@64 heap
static int parser_tokadd_string(struct parser_params *, int, int, int, long *, rb_encoding **)
Definition: ripper.c:12528
#define VTBL_DEBUG
Definition: ripper.c:212
VALUE hash
Definition: tkutil.c:267
int rb_is_method_name(VALUE name)
Definition: ripper.c:17211
#define arg_append(h, t)
Definition: ripper.c:451
#define assignable_result(x)
#define CMDARG_PUSH(n)
Definition: ripper.c:176
YYSTYPE yyval
Definition: ripper.c:4935
Definition: ripper.y:110
static VALUE coverage(VALUE fname, int n)
Definition: ripper.c:11805
#define RE_OPTION_MASK
Definition: ripper.c:587
Definition: ripper.y:97
#define NEW_OP_ASGN_AND(i, val)
static NODE * arg_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15280
rb_encoding * enc
Definition: ripper.c:330
#define parser_warning(node, mesg)
Definition: ripper.c:14718
#define NODE_LVAR
static int parser_regx_options(struct parser_params *)
Definition: ripper.c:12456
enum lex_state_e parser_lex_state
Definition: ripper.c:296
#define whole_match_p(e, l, i)
Definition: ripper.c:11548
#define op_tbl_count
Definition: ripper.c:16505
#define NODE_LASGN
int capa
Definition: ripper.c:184
VALUE parser_lex_lastline
Definition: ripper.c:313
#define lex_nextline
Definition: ripper.c:387
#define YYTERROR
Definition: ripper.c:4351
#define NEW_OPT_N(b)
Definition: ripper.y:113
NODE * rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: ripper.c:11976
#define set_yylval_literal(x)
Definition: ripper.c:11555
#define NEW_KW_ARG(i, v)
BDIGIT m
Definition: bigdecimal.c:5106
static int parser_yylex(struct parser_params *parser)
Definition: ripper.c:13378
static VALUE parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
Definition: ripper.c:12060
#define scan_hex(s, l, e)
Definition: util.h:54
static int dyna_in_block_gen(struct parser_params *)
Definition: ripper.c:16200
return Qfalse
Definition: tcltklib.c:6778
#define FIXNUM_P(f)
#define rb_intern_str(string)
Definition: generator.h:17
static const yytype_uint16 yystos[]
Definition: ripper.c:4197
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Definition: re.c:301
static char * parser_tokspace(struct parser_params *parser, int n)
Definition: ripper.c:12171
#define arg_ambiguous()
Definition: ripper.c:13030
#define TypedData_Get_Struct(obj, type, data_type, sval)
void rb_compile_error_append(const char *fmt,...)
Definition: error.c:155
void rb_compile_error_with_enc(const char *file, int line, void *enc, const char *fmt,...)
Definition: error.c:131
#define evstr2dstr(n)
Definition: ripper.c:460
#define RARRAY_LEN(a)
static void parser_free(void *ptr)
Definition: ripper.c:17308
#define IS_ARG()
Definition: ripper.c:13357
#define PARSER_ARG
Definition: ripper.c:722
#define NODE_WHEN
#define Qnil
Definition: tcltklib.c:1895
#define StringValuePtr(v)
#define literal_concat(h, t)
Definition: ripper.c:455
#define val
Definition: tcltklib.c:1948
int rb_ispunct(int c)
Definition: encoding.c:1890
VALUE rb_eRuntimeError
Definition: error.c:515
#define compile_error
Definition: ripper.c:721
static int symbols_i(VALUE sym, ID value, VALUE ary)
Definition: ripper.c:17015
const rb_data_type_t * parent
Definition: ripper.y:969
#define NEW_RESCUE(b, res, e)
#define RARRAY(obj)
#define yylval
Definition: ripper.c:11524
static int parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
Definition: ripper.c:12383
static int dvar_curr_gen(struct parser_params *, ID)
Definition: ripper.c:16237
VALUE rb_parser_encoding(VALUE vparser)
Definition: ripper.c:17403
union RNode::@81 u2
#define ifndef_ripper(x)
Definition: ripper.c:687
static const yytype_uint16 yyrline[]
Definition: ripper.c:1463
struct parser_params * parser
Definition: ripper.c:16299
#define NODE_YIELD
#define NEW_NODE(t, a0, a1, a2)
#define yytable_value_is_error(yytable_value)
Definition: ripper.c:3117
#define NEW_LIST(a)
#define NEW_ENSURE(b, en)
RUBY_EXTERN VALUE rb_mKernel
Definition: ripper.y:1414
static struct @60 op_tbl[]
#define cur_mid
Definition: ripper.c:379
static VALUE char * str
Definition: tcltklib.c:3546
#define NODE_FLIP2
#define NODE_BLOCK
#define ID_INSTANCE
NODE * rb_compile_string(const char *f, VALUE s, int line)
Definition: ripper.c:11969
#define NEW_BLOCK(a)
static const yytype_uint16 yyprhs[]
Definition: ripper.c:1200
int yyrule
Definition: ripper.c:4527
#define NODE_DASGN_CURR
static NODE * list_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14802
int parser_paren_nest
Definition: ripper.c:300
VALUE rb_ary_new(void)
Definition: array.c:424
#define NODE_AND
int rb_ascii8bit_encindex(void)
Definition: encoding.c:1160
int flags
Definition: tcltklib.c:3022
unsigned long ID
Definition: ripper.y:105
static int is_global_name_punct(const char c)
Definition: ripper.c:12705
#define NEW_UNDEF(i)
#define ID_JUNK
#define is_attrset_id(id)
Definition: ripper.c:114
#define set_yylval_name(x)
Definition: ripper.c:11554
va_end(args)
void rb_gc_mark(VALUE)
Definition: gc.c:2600
#define IDSET_ATTRSET_FOR_INTERN
Definition: ripper.c:16630
#define ID_GLOBAL
#define tokline
Definition: ripper.c:384
static char * parser_newtok(struct parser_params *parser)
Definition: ripper.c:12155
YYSIZE_T yymsg_alloc
Definition: ripper.c:4941
static int vtable_included(const struct vtable *tbl, ID id)
Definition: ripper.c:254
#define block_dup_check(n1, n2)
Definition: ripper.c:442
#define tokadd(c)
Definition: ripper.c:11537
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:2204
static NODE * arg_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15305
static void local_push_gen(struct parser_params *, int)
Definition: ripper.c:16054
RUBY_EXTERN int ffs(int)
Definition: ffs.c:6
#define NEW_WHEN(c, t, e)
top_stmt escape_Qundef($1)
static void const char * yymsg
Definition: ripper.c:4833
#define ISASCII(c)
Definition: ruby.h:1629
#define tokenbuf
Definition: ripper.c:381
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:503
#define COND_POP()
Definition: ripper.c:172
#define heredoc_identifier()
Definition: ripper.c:11546
static VALUE VALUE obj
Definition: tcltklib.c:3157
#define RSTRING_LEN(str)
static void parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13128
static struct st_hash_type symhash
Definition: ripper.c:16522
#define INT2FIX(i)
#define YYSYNTAX_ERROR
struct vtable * vars
Definition: parse.h:168
int idx
Definition: tcltklib.c:9715
#define new_const_op_assign(lhs, op, rhs)
Definition: ripper.c:501
Definition: ripper.y:135
VALUE value
Definition: ripper.y:246
static void parser_tokadd(struct parser_params *parser, int c)
Definition: ripper.c:12183
#define FIX2LONG(x)
#define k__END__
Definition: eventids2.c:9
static void parser_mark(void *ptr)
Definition: ripper.c:17282
#define ISALNUM(c)
Definition: ruby.h:1635
#define YYDPRINTF(Args)
Definition: ripper.c:4404
return yylen
Definition: ripper.c:4603
#define T_STRING
#define lex_goto_eol(parser)
Definition: ripper.c:12076
#define MBCLEN_CHARFOUND_P(ret)
static double one(void)
Definition: isinf.c:52
int yyn
Definition: ripper.c:4929
unsigned char OnigUChar
Definition: ripper.y:114
#define NODE_ARGSCAT
#define local_id(id)
Definition: ripper.c:562
#define NODE_COLON2
NODE * rb_parser_append_print(VALUE vparser, NODE *node)
Definition: ripper.c:16408
#define nd_set_line(n, l)
#define xmalloc
#define xrealloc
static void ripper_init_eventids1(void)
Definition: eventids1.c:134
yytype_int16 yyss_alloc
Definition: ripper.c:1082
static void vtable_add(struct vtable *tbl, ID id)
Definition: ripper.c:239
#define YYFINAL
Definition: ripper.c:1136
#define dvar_curr(id)
Definition: ripper.c:577
#define flush_string_content(enc)
Definition: ripper.c:12680
#define NEW_ARGS_AUX(r, b)
#define TypedData_Wrap_Struct(klass, data_type, sval)
#define RSTRING_NOEMBED
#define tokadd_string(f, t, p, n, e)
Definition: ripper.c:11542
static NODE * new_yield_gen(struct parser_params *, NODE *)
Definition: ripper.c:15833
#define ripper_flush(p)
Definition: ripper.c:11574
static VALUE lex_get_str(struct parser_params *parser, VALUE s)
Definition: ripper.c:11907
static int rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_atttset)
Definition: ripper.c:16633
#define ISUPPER(c)
Definition: ruby.h:1633
#define RUBY_FUNC_EXPORTED
Definition: defines.h:184
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4308
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:345
VALUE rb_enc_associate_index(VALUE obj, int idx)
Definition: encoding.c:748
int rb_parse_in_main(void)
Definition: compile.c:5943
static int parser_nextc(struct parser_params *parser)
Definition: ripper.c:12082
int err
Definition: win32.c:87
#define dyna_pop(node)
Definition: ripper.c:569
#define YYACCEPT
Definition: ripper.c:4312
const char * parser_lex_pend
Definition: ripper.c:317
#define NEW_DEFINED(e)
static ID formal_argument_gen(struct parser_params *, ID)
Definition: ripper.c:13033
static void void_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15424
#define DBL2NUM(dbl)
#define YYEOF
Definition: ripper.c:4310
#define ALLOCA_N(type, n)
static NODE * dsym_node_gen(struct parser_params *, NODE *)
Definition: ripper.c:15927
#define ENC_CODERANGE_UNKNOWN
void rb_gc_mark_symbols(void)
Definition: ripper.c:16574
long cnt
Definition: ripper.y:262
ID token
Definition: ripper.c:16481
static int VALUE key
Definition: tkutil.c:265
static ID intern_str(VALUE str)
Definition: ripper.c:16804
#define YY_REDUCE_PRINT(Rule)
Definition: ripper.c:4547
YYSTYPE yyvsa[YYINITDEPTH]
Definition: ripper.c:4923
Definition: ripper.y:116
NODE * rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
Definition: ripper.c:16440
Definition: util.c:791
NODE * rb_compile_cstr(const char *f, const char *s, int len, int line)
Definition: ripper.c:11989
token_info * parser_token_info
Definition: ripper.c:343
Definition: ripper.y:123
static void magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13119
int column
Definition: ripper.c:273
#define IS_lex_state(ls)
Definition: ripper.c:158
#define END(no)
Definition: re.c:26
#define EOF
Definition: vsnprintf.c:207
int yyerrstatus
Definition: ripper.c:4908
VALUE rb_str_buf_cat(VALUE, const char *, long)
Definition: string.c:1951
void * rb_parser_malloc(struct parser_params *parser, size_t size)
Definition: ripper.c:17449
VALUE rb_str_dup(VALUE)
Definition: string.c:946
#define peek_n(c, n)
Definition: ripper.c:12079
#define DEF_EXPR(n)
Definition: ripper.c:141
#define tHEREDOC_END
Definition: eventids2.c:8
#define STR_NEW(p, n)
Definition: ripper.c:358
#define rb_long2int(n)
YYSTYPE yyvs_alloc
Definition: ripper.c:1083
#define ID_CLASS
static int parser_peek_variable_name(struct parser_params *parser)
Definition: ripper.c:12712
#define tokcopy(n)
Definition: ripper.c:12206
#define STR_FUNC_SYMBOL
Definition: ripper.c:12045
#define NEW_LASGN(v, val)
node_type
Definition: ripper.y:23
static VALUE yycompile0(VALUE arg)
Definition: ripper.c:11827
#define mixed_escape(beg, enc1, enc2)
VALUE rb_obj_as_string(VALUE)
Definition: string.c:895
#define set_yylval_num(x)
Definition: ripper.c:11552
static ID register_symid_str(ID, VALUE)
Definition: ripper.c:16753
VALUE * argv
Definition: tcltklib.c:1970
goto yysetstate
Definition: ripper.c:4969
#define NODE_MEMO
#define NEW_OPT_ARG(i, v)
VALUE rb_hash_aset(VALUE, VALUE, VALUE)
#define STR_FUNC_QWORDS
Definition: ripper.c:12044
#define dyna_push()
Definition: ripper.c:567
#define command_start
Definition: ripper.c:392
string_type
Definition: ripper.c:12048
int rb_dvar_defined(ID id)
Definition: compile.c:5893
static void dispose_string(VALUE str)
Definition: ripper.c:12492
VALUE rb_str_resize(VALUE, long)
Definition: string.c:1854
#define is_notop_id(id)
Definition: ripper.c:110
static NODE * aryset_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15203
int parser_in_single
Definition: ripper.c:302
#define RTEST(v)
lex_state_bits
Definition: ripper.c:125
const int id
Definition: nkf.c:209
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
Definition: st.c:1006
#define NEW_SCLASS(r, b)
#define RUBY_DTRACE_PARSE_END_ENABLED()
Definition: probes.h:71
static ID shadowing_lvar_gen(struct parser_params *, ID)
Definition: ripper.c:15165
#define CMDARG_LEXPOP()
Definition: ripper.c:178
ID rest_arg
Definition: ripper.y:516
#define local_push(top)
Definition: ripper.c:554
int errno
#define TRUE
Definition: nkf.h:175
int rb_symname_p(const char *name)
Definition: ripper.c:16618
#define new_attr_op_assign(lhs, type, attr, op, rhs)
Definition: ripper.c:499
q result
Definition: tcltklib.c:7069
#define NODE_NIL
VALUE rb_thread_current(void)
Definition: thread.c:2355
#define paren_nest
Definition: ripper.c:373
#define NODE_ATTRASGN
#define token_info_pop(token)
Definition: ripper.c:738
static void dyna_pop_gen(struct parser_params *, const struct vtable *)
Definition: ripper.c:16186
VALUE rb_range_new(VALUE, VALUE, int)
Definition: range.c:67
static NODE * new_evstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:14933
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1275
volatile VALUE value
Definition: tcltklib.c:9441
#define NODE_COLON3
#define StringValue(v)
#define NODE_DEFINED
#define rb_enc_mbcput(c, buf, enc)
#define IS_lex_state_for(x, ls)
Definition: ripper.c:157
#define tokadd_mbchar(c)
Definition: ripper.c:12512
static void reg_fragment_setenc_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16245
#define rb_node_newnode(type, a1, a2, a3)
Definition: ripper.c:421
#define YYMAXDEPTH
Definition: ripper.c:4579
goto yynewstate
Definition: ripper.c:5111
static void set_file_encoding(struct parser_params *parser, const char *str, const char *send)
Definition: ripper.c:13290
#define NEW_DOT2(b, e)
#define NODE_MASGN
#define T_REGEXP
#define const
Definition: strftime.c:102
int rb_is_attrset_name(VALUE name)
Definition: ripper.c:17199
#define NEW_DASGN(v, val)
register char * s
Definition: os2.c:56
#define NEW_VALIAS(n, o)
#define RE_OPTION_ONCE
Definition: ripper.c:582
int rb_enc_symname_p(const char *name, rb_encoding *enc)
Definition: ripper.c:16624
#define NEW_POSTARG(i, v)
#define CONST_ID(var, str)
#define tokidx
Definition: ripper.c:382
#define NEW_ERRINFO()
#define malloc
Definition: ripper.c:98
void Init_sym(void)
Definition: ripper.c:16555
#define NODE_CONST
static int parser_parse_string(struct parser_params *, NODE *)
Definition: ripper.c:12748
#define nd_term(node)
Definition: ripper.c:597
#define STR_FUNC_EXPAND
Definition: ripper.c:12042
VP_EXPORT void
Definition: bigdecimal.c:5104
#define rb_warningS(fmt, a)
Definition: ripper.c:699
static NODE * new_args_tail_gen(struct parser_params *, NODE *, ID, ID)
Definition: ripper.c:15902
static int dvar_defined_gen(struct parser_params *, ID, int)
Definition: ripper.c:16206
int rb_is_local_id(ID id)
Definition: ripper.c:17077
rb_magic_comment_length_t length
Definition: ripper.c:13152
int parser_in_def
Definition: ripper.c:303
#define is_global_id(id)
Definition: ripper.c:112
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1574
#define NEW_SUPER(a)
static int local_id_gen(struct parser_params *, ID)
Definition: ripper.c:16129
#define YYSIZE_T
Definition: ripper.c:962
#define NEW_COLON2(c, i)
#define ESCAPE_META
Definition: ripper.c:12282
VALUE parser_cur_mid
Definition: ripper.c:306
short int yytype_int16
Definition: ripper.c:949
VALUE rb_io_gets(VALUE)
Definition: io.c:3122
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Definition: array.c:545
static void Init_id(void)
Definition: ripper.y:15
long parser_lex_gets_ptr
Definition: ripper.c:321
#define no_digits()
goto yyreturn
Definition: ripper.c:11466
#define NODE_GVAR
#define NODE_CDECL
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1181
#define NEW_HASH(a)
static void rb_backref_error_gen(struct parser_params *, NODE *)
Definition: ripper.c:15267
Definition: ripper.y:94
unsigned char yytype_uint8
Definition: ripper.c:928
union RNode::@82 u3
static const yytype_int16 yyrhs[]
Definition: ripper.c:1268
static void arg_ambiguous_gen(struct parser_params *parser)
Definition: ripper.c:13022
#define heredoc_restore(n)
Definition: ripper.c:11547
static void parser_prepare(struct parser_params *parser)
Definition: ripper.c:13333
static NODE * cond_gen(struct parser_params *, NODE *)
Definition: ripper.c:15786
#define RB_GC_GUARD(v)
#define lex_lastline
Definition: ripper.c:386
#define NODE_LIT
#define rb_reserved_word(str, len)
Definition: lex.c:37
int type
Definition: tcltklib.c:111
int id[2]
Definition: lex.c:33
#define NEW_UNTIL(c, b, n)
static const char *const yytname[]
Definition: ripper.c:1534
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: ripper.c:1102
#define T_FIXNUM
#define NEW_MATCH3(r, n2)
int argc
Definition: tcltklib.c:1969
VALUE rb_str_buf_new(long)
Definition: string.c:777
stack_type parser_cond_stack
Definition: ripper.c:297
NODE * post_init
Definition: ripper.y:509
static void FILE * yyoutput
Definition: ripper.c:4434
static void ripper_init_eventids2(void)
Definition: eventids2.c:64
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:2109
int rb_is_junk_id(ID id)
Definition: ripper.c:17083
static void dyna_pop_1(struct parser_params *parser)
Definition: ripper.c:16168
static int parser_read_escape(struct parser_params *parser, int flags, rb_encoding **encp)
Definition: ripper.c:12285
int parser_heredoc_end
Definition: ripper.c:318
#define ruby_sourceline
Definition: ripper.c:398
static int parser_heredoc_identifier(struct parser_params *parser)
Definition: ripper.c:12806
Definition: ripper.y:101
ID rb_id_attrset(ID id)
Definition: ripper.c:15230
static int value_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15362
Definition: ripper.y:72
mlhs_head tSTAR
Definition: ripper.y:1543
int post_args_num
Definition: ripper.y:512
#define lex_pend
Definition: ripper.c:390
int rb_is_global_id(ID id)
Definition: ripper.c:17059
static int reg_fragment_check_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16284
static const yytype_int16 yycheck[]
Definition: ripper.c:3120
#define NEW_SELF()
#define YYUSE(e)
Definition: ripper.c:982
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1122
#define lvtbl
Definition: ripper.c:396
#define lex_strterm
Definition: ripper.c:368
#define rb_enc_ispunct(c, enc)
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
Definition: eval.c:804
VALUE flags
Definition: ripper.y:700
#define NEW_RESBODY(a, ex, n)
static NODE * new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
Definition: ripper.c:15983
#define NEW_RETURN(s)
#define NODE_ARGSPUSH
#define NODE_BACK_REF
#define set_yylval_str(x)
Definition: ripper.c:11551
#define NODE_MATCH
#define cond_stack
Definition: ripper.c:370
short int yytype_int8
Definition: ripper.c:937
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2299
static NODE * assignable_gen(struct parser_params *, ID, NODE *)
VALUE flags
Definition: ripper.y:241
expr ripper_intern("and")
static int is_static_content(NODE *node)
Definition: ripper.c:15598
yytype_int16 * yytop
Definition: ripper.c:4496
const char * token
Definition: ripper.c:271
ruby_verbose
Definition: tcltklib.c:5817
RUBY_EXTERN VALUE rb_cString
Definition: ripper.y:1456
Real * b
Definition: bigdecimal.c:1196
#define NEW_COLON3(i)
#define RUBY_DTRACE_PARSE_BEGIN_ENABLED()
Definition: probes.h:67
#define NEW_CASE(h, b)
static const yytype_int16 yypgoto[]
Definition: ripper.c:2011
static int arg_var_gen(struct parser_params *, ID)
Definition: ripper.c:16112
return ptr
Definition: tcltklib.c:784
#define free(x)
Definition: dln.c:50
VpDivd * c
Definition: bigdecimal.c:1219
goto yyerrlab1
Definition: ripper.c:11396
#define is_local_id(id)
Definition: ripper.c:111
#define NODE_DASGN
int parser_in_defined
Definition: ripper.c:307
VALUE msg
Definition: tcltklib.c:846
static int literal_concat0(struct parser_params *, VALUE, VALUE)
Definition: ripper.c:14826
static ID * local_tbl_gen(struct parser_params *)
Definition: ripper.c:16087
#define NEW_BACK_REF(n)
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1269
int parser_class_nest
Definition: ripper.c:299
#define T_BIGNUM
#define brace_nest
Definition: ripper.c:375
#define reg_named_capture_assign(regexp, match)
Definition: ripper.c:518
#define MEMCPY(p1, p2, type, n)
Definition: ripper.y:122
static int parser_yyerror(struct parser_params *, const char *)
Definition: ripper.c:11724
gz end
Definition: zlib.c:2270
goto yydefault
Definition: ripper.c:5061
#define NEW_IF(c, t, e)
#define HEAPCNT(n, size)
Definition: ripper.c:17443
nd_iter
Definition: parse.y:1393
#define NEW_GASGN(v, val)
yydestruct("Cleanup: discarding lookahead", yytoken,&yylval, parser)
YYSIZE_T yystacksize
Definition: ripper.c:4927
static void warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15655
#define NEW_ARGSPUSH(a, b)
int rb_is_const_name(VALUE name)
Definition: ripper.c:17175
static void yytype_int16 * yybottom
Definition: ripper.c:4495
#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:12376
static NODE * attrset_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:15259
int rb_is_local_name(VALUE name)
Definition: ripper.c:17205
arg
Definition: ripper.y:1317
static struct vtable * dyna_push_gen(struct parser_params *)
Definition: ripper.c:16157
VALUE src
Definition: tcltklib.c:7952
yy_symbol_value_print(yyoutput, yytype, yyvaluep, parser)
static VALUE reg_compile_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16379
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:1967
#define NEW_XSTR(s)
#define ESCAPE_CONTROL
Definition: ripper.c:12281
Definition: ripper.y:111
#define ENC_CODERANGE_7BIT
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:772
#define NEW_WHILE(c, b, n)
#define NEW_DEFS(r, i, a, d)
#define parser_isascii()
Definition: ripper.c:11647
void rb_gc_mark_parser(void)
Definition: ripper.c:16403
static const yytype_uint8 yytranslate[]
Definition: ripper.c:1157
int nonspc
Definition: ripper.c:274
int size
Definition: encoding.c:52
#define ADD2HEAP(n, c, p)
Definition: ripper.c:17445
#define tokspace(n)
Definition: ripper.c:11536
#define f
#define in_def
Definition: ripper.c:377
static int is_private_local_id(ID name)
Definition: ripper.c:15152
#define SYMBOL_P(x)
#define is_const_id(id)
Definition: ripper.c:115
char yymsgbuf[128]
Definition: ripper.c:4939
static void no_blockarg(struct parser_params *parser, NODE *node)
Definition: ripper.c:15808
static void local_pop_gen(struct parser_params *)
Definition: ripper.c:16071
#define NODE_FLIP3
void rb_parser_free(struct parser_params *parser, void *ptr)
Definition: ripper.c:17489
#define Qundef
int parser_tokidx
Definition: ripper.c:309
#define read_escape(flags, e)
Definition: ripper.c:11539
#define NODE_DVAR
#define tok_hex(numlen)
Definition: ripper.c:11538
static NODE * literal_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14843
static struct magic_comment magic_comments[]
Definition: ripper.c:13155
#define new_evstr(n)
Definition: ripper.c:458
#define parser_warn(node, mesg)
Definition: ripper.c:14725
Definition: ripper.y:92
Definition: ripper.y:127
VALUE coverage
Definition: ripper.c:339
command_call
Definition: ripper.y:1309
int t
Definition: ripper.c:14654
void rb_set_errinfo(VALUE err)
Definition: eval.c:1429
#define tokfix()
Definition: ripper.c:12149
return tOP_ASGN
Definition: ripper.y:7668
#define rb_enc_isspace(c, enc)
#define internal_id()
Definition: ripper.c:564
NODE * parser_lex_strterm
Definition: ripper.c:295
const char * name
Definition: ripper.c:13150
top_stmt bodystmt
Definition: ripper.y:926
#define COND_LEXPOP()
Definition: ripper.c:173
#define lex_p
Definition: ripper.c:389
#define NEW_IVAR(v)
top_stmts dispatch0(stmts_new)
#define tSP
Definition: eventids2.c:6
#define NEW_ATTRASGN(r, m, a)
#define NODE_ZARRAY
static int token_info_get_column(struct parser_params *parser, const char *token)
Definition: ripper.c:11651
#define node_assign(node1, node2)
Definition: ripper.c:495
static void void_stmts_gen(struct parser_params *, NODE *)
Definition: ripper.c:15513
const char * yys
Definition: ripper.c:4626
#define void_expr(node)
Definition: ripper.c:436
static int local_var_gen(struct parser_params *, ID)
Definition: ripper.c:16119
#define pushback(c)
Definition: ripper.c:11534
#define void_expr0(node)
Definition: ripper.c:435
#define NEW_BEGIN(b)
NODE * pre_init
Definition: ripper.y:508
#define NEW_FCALL(m, a)
#define NODE_CVAR
#define lex_pbeg
Definition: ripper.c:388
#define regx_options()
Definition: ripper.c:11541
#define NEW_SCOPE(a, b)
#define numberof(array)
Definition: ripper.c:92
static int token_info_has_nonspaces(struct parser_params *parser, const char *token)
Definition: ripper.c:11665
st_index_t rb_str_hash(VALUE)
Definition: string.c:2248
#define NEW_OP_ASGN2(r, i, o, val)
#define YYSTACK_ALLOC_MAXIMUM
Definition: ripper.c:1047
#define NODE_BREAK
#define TOK_INTERN(mb)
Definition: ripper.c:363
static const rb_data_type_t parser_data_type
Definition: ripper.c:11947
rb_magic_comment_setter_t func
Definition: ripper.c:13151
int parser_lpar_beg
Definition: ripper.c:301
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:190
st_table * sym_id
Definition: ripper.c:16513
RUBY_EXTERN VALUE rb_cObject
Definition: ripper.y:1426
#define ALLOC_N(type, n)
#define LONG2FIX(i)
#define NODE_FL_NEWLINE
#define RBASIC(obj)
struct local_vars * prev
Definition: ripper.c:192
static const yytype_uint16 yydefact[]
Definition: ripper.c:1762
#define NEW_VCALL(m)
static NODE * new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: ripper.c:15954
#define parser_encoding_name()
Definition: ripper.c:11641
#define tokadd_escape(e)
Definition: ripper.c:11540
struct vtable * vars
Definition: ripper.c:190
static const yytype_int16 yypact[]
Definition: ripper.c:1900
static VALUE lex_io_gets(struct parser_params *parser, VALUE io)
Definition: ripper.c:12003
#define new_yield(node)
Definition: ripper.c:478
#define lvar_defined(id)
Definition: ripper.c:580
klass
Definition: tcltklib.c:3503
#define INT2NUM(x)
goto yybackup
Definition: ripper.c:5048
#define NODE_DSTR
struct rb_encoding_entry * list
Definition: encoding.c:50
#define lpar_beg
Definition: ripper.c:374
keyword_BEGIN
Definition: ripper.y:1030
#define YYTRANSLATE(YYX)
Definition: ripper.c:1153
#define NEW_RETRY()
void * rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
Definition: ripper.c:17459
#define STRNCASECMP(s1, s2, n)
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:772
#define yyerror(msg)
Definition: ripper.c:366
#define is_junk_id(id)
Definition: ripper.c:117
static void new_bv_gen(struct parser_params *, ID)
Definition: ripper.c:15189
#define ruby_coverage
Definition: ripper.c:408
int linenum
Definition: ripper.c:272
#define NEW_CVAR(v)
static NODE * negate_lit(NODE *)
Definition: ripper.c:15841
#define tEMBDOC
Definition: eventids2.c:4
Definition: ripper.y:121
#define NODE_BEGIN
gz io
Definition: zlib.c:2261
#define id_type(id)
Definition: ripper.c:118
static void fixup_nodes(NODE **)
Definition: ripper.c:15661
#define DVARS_INHERIT
Definition: ripper.c:196
#define STR_NEW3(p, n, e, func)
Definition: ripper.c:361
char * parser_tokenbuf
Definition: ripper.c:308
VALUE rb_cArray
Definition: array.c:29
static const char * magic_comment_marker(const char *str, long len)
Definition: ripper.c:13163
#define BEG(no)
Definition: re.c:25
#define NEW_OP_ASGN1(p, id, a)
static int parser_magic_comment(struct parser_params *parser, const char *str, long len)
Definition: ripper.c:13196
int parser_tokline
Definition: ripper.c:311
Definition: ripper.y:79
#define IS_LABEL_POSSIBLE()
Definition: ripper.c:13361
VALUE rb_ary_new2(long capa)
Definition: array.c:417
static const char id_type_names[][9]
Definition: ripper.c:15218
VALUE rb_str_new(const char *, long)
Definition: string.c:425
union RNode::@80 u1
const char * parser_lex_pbeg
Definition: ripper.c:315
int rb_is_class_id(ID id)
Definition: ripper.c:17053
#define DVARS_TOPSCOPE
Definition: ripper.c:197
#define YYCASE_(N, S)
#define rb_safe_level()
Definition: tcltklib.c:94
VALUE rb_parser_new(void)
Definition: ripper.c:17374
struct parser_params * parser
Definition: ripper.c:4437
#define NODE_CVASGN
Definition: ripper.c:181
static void parser_set_encode(struct parser_params *parser, const char *name)
Definition: ripper.c:13071
#define call_uni_op(recv, id)
Definition: ripper.c:466
#define NEW_CDECL(v, val, path)
static int literal_node(NODE *node)
Definition: ripper.c:15708
#define set_yylval_node(x)
Definition: ripper.c:11556
static void YYSTYPE * yyvsp
Definition: ripper.c:4526
#define YYSTACK_BYTES(N)
Definition: ripper.c:1091
#define IS_BEG()
Definition: ripper.c:13359
const char * parser_lex_p
Definition: ripper.c:316
#define nd_lit
static int parser_tok_hex(struct parser_params *parser, size_t *numlen)
Definition: ripper.c:12193
#define RE_OPTION_ENCODING_NONE(o)
Definition: ripper.c:586
#define rb_enc_asciicompat(enc)
lex_state_e
Definition: ripper.c:140
#define NUM2INT(x)
#define dvar_defined_get(id)
Definition: ripper.c:575
#define nd_head
int rb_is_instance_name(VALUE name)
Definition: ripper.c:17193
int parser_ruby_sourceline
Definition: ripper.c:328
const char * rb_id2name(ID id)
Definition: ripper.c:17006
#define NODE_CALL
#define ruby_eval_tree_begin
Definition: ripper.c:406
#define rb_errinfo()
Definition: tcltklib.c:89
#define ruby_sourcefile_string
Definition: ripper.c:400
#define formal_argument(id)
Definition: ripper.c:547
#define rb_enc_isupper(c, enc)
int cnt
Definition: tcltklib.c:6148
#define PRIsVALUE
static int nodeline(NODE *node)
Definition: ripper.c:14689
#define dispatch_heredoc_end()
Definition: ripper.c:12912
YYSTYPE * parser_yylval
Definition: ripper.c:292
#define ruby_eval_tree
Definition: ripper.c:405
#define toklast()
Definition: ripper.c:12152
#define lex_gets
Definition: ripper.c:395
#define toklen()
Definition: ripper.c:12151
static const yytype_uint8 yyr2[]
Definition: ripper.c:1692
#define xcalloc
BDIGIT e
Definition: bigdecimal.c:5106
#define cmdarg_stack
Definition: ripper.c:371
yychar
Definition: ripper.c:4960
#define in_single
Definition: ripper.c:376
#define YY_STACK_PRINT(Bottom, Top)
Definition: ripper.c:4508
#define NEW_LIT(l)
#define rb_enc_isascii(c, enc)
int rb_str_hash_cmp(VALUE, VALUE)
Definition: string.c:2258
#define YYFPRINTF
Definition: ripper.c:4401
NODE * rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
Definition: ripper.c:11982
VALUE opts
Definition: tcltklib.c:6145
int is_ripper
Definition: ripper.c:289
unsigned long VALUE
Definition: ripper.y:104
static NODE * cond0(struct parser_params *, NODE *)
Definition: ripper.c:15729
options
Definition: tcltklib.c:4480
rb_encoding * rb_ascii8bit_encoding(void)
Definition: encoding.c:1151
int rb_is_junk_name(VALUE name)
Definition: ripper.c:17221
#define NODE_IVAR
#define peek(c)
Definition: ripper.c:12078
return tSYMBEG
Definition: ripper.y:7642
#define RREGEXP(obj)
int rb_enc_find_index(const char *name)
Definition: encoding.c:635
static NODE * splat_array(NODE *)
Definition: ripper.c:15323
static struct vtable * vtable_alloc(struct vtable *prev)
Definition: ripper.c:215
VALUE eofp
Definition: ripper.c:293
RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e-0x20+31)/32]
Definition: ripper.c:12683
YYSTYPE * yyvs
Definition: ripper.c:4924
goto yyreduce
Definition: ripper.c:5121
NODE * heap
Definition: ripper.c:290
#define RSTRING_GETMEM(str, ptrvar, lenvar)
ID rb_intern3(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:16782
#define attrset(node, id)
Definition: ripper.c:490
#define NODE_DOT2
encp
Definition: crypt.c:564
#define COND_P()
Definition: ripper.c:174
#define ID_SCOPE_MASK
#define mixed_error(enc1, enc2)
static ID register_symid(ID, const char *, long, rb_encoding *)
Definition: ripper.c:16746
#define NODE_DREGX
#define NODE_IASGN
#define NEW_DEFN(i, a, d, p)
#define NODE_RETURN
#define snprintf
ID first_post_arg
Definition: ripper.y:514
void * rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
Definition: ripper.c:17469
#define NEW_REDO()
#define shadowing_lvar(name)
Definition: ripper.c:549
st_table * st_init_numtable_with_size(st_index_t)
Definition: st.c:278
VALUE rb_cstr_to_inum(const char *str, int base, int badcheck)
Definition: bignum.c:579
#define NODE_ARRAY
#define NODE_SPLAT
#define get_value(val)
Definition: ripper.c:521
#define rb_intern(str)
#define reg_fragment_check(str, options)
Definition: ripper.c:516
int rb_parse_in_eval(void)
Definition: compile.c:5937
YYSTYPE const *const yyvaluep
Definition: ripper.c:4436
BDIGIT v
Definition: bigdecimal.c:5677
#define ENCODING_SET(obj, i)
#define compile_for_eval
Definition: ripper.c:378
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:80
#define tCOMMENT
Definition: eventids2.c:2
#define NEW_ZSUPER()
#define set_yylval_id(x)
Definition: ripper.c:11553
VALUE rb_filesystem_str_new_cstr(const char *)
Definition: string.c:614
ID rb_intern2(const char *name, long len)
Definition: ripper.c:16917
NODE * rb_compile_file(const char *f, VALUE file, int start)
Definition: ripper.c:12009
static int is_special_global_name(const char *m, const char *e, rb_encoding *enc)
Definition: ripper.c:16592
#define is_class_id(id)
Definition: ripper.c:116
#define LVAR_USED
Definition: ripper.c:15162
#define nd_line(n)
VALUE rb_parser_get_yydebug(VALUE self)
Definition: ripper.c:17418
VALUE(* parser_lex_gets)(struct parser_params *, VALUE)
Definition: ripper.c:322
#define NULL
Definition: _sdbm.c:103
#define rb_enc_isalpha(c, enc)
static VALUE debug_lines(VALUE fname)
Definition: ripper.c:11789
const char * name
Definition: nkf.c:208
#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:11996
static int rb_str_symname_type(VALUE name, unsigned int allowed_atttset)
Definition: ripper.c:16736
VALUE rb_check_string_type(VALUE)
Definition: string.c:1509
#define REALLOC_N(var, type, n)
#define NODE_SCOPE
#define yypact_value_is_default(yystate)
Definition: ripper.c:3114
static struct kwtable * reserved_word(const char *, unsigned int)
int rb_enc_str_coderange(VALUE)
Definition: string.c:327
#define ISXDIGIT(c)
Definition: ruby.h:1638
#define rb_warn0(fmt)
Definition: ripper.c:694
int rb_local_defined(ID id)
Definition: compile.c:5918
st_index_t num_entries
Definition: ripper.y:93
NODE * parser_eval_tree_begin
Definition: ripper.c:336
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:1348
int retry
Definition: tcltklib.c:10150
#define new_bv(id)
Definition: ripper.c:551
static void warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15649
#define NODE_IASGN2
#define ULONG2NUM(x)
#define NODE_SELF
goto yyerrlab
Definition: ripper.c:5120
#define block_append(h, t)
Definition: ripper.c:445
#define SYM2ID(x)
#define ID_CONST
NODE * rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
Definition: ripper.c:12023
VALUE rb_eArgError
Definition: error.c:517
static void vtable_free(struct vtable *tbl)
Definition: ripper.c:227
#define NEW_ARRAY(a)
Definition: ripper.y:93
void rb_str_free(VALUE)
Definition: string.c:830
#define RTYPEDDATA_TYPE(v)
unsigned long ruby_scan_oct(const char *, size_t, size_t *)
Definition: util.c:28
#define NODE_VALUES
#define heredoc_end
Definition: ripper.c:391
#define ID_ATTRSET
struct vtable * args
Definition: ripper.c:189
#define tokaddmbc(c, enc)
Definition: ripper.c:11544
Definition: ripper.y:136
#define tEMBDOC_END
Definition: eventids2.c:5
int yytype
Definition: ripper.c:4435
static void ripper_init_eventids2_table(VALUE self)
Definition: eventids2table.c:2
#define nd_value
#define NEW_YIELD(a)
#define ISSPACE(c)
Definition: ruby.h:1632
#define STR_NEW2(p)
Definition: ripper.c:360
const char * yysrc
Definition: ripper.c:4622
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:2078
VALUE rb_inspect(VALUE)
Definition: object.c:411
#define YYINITDEPTH
Definition: ripper.c:4568
static int sym_check_asciionly(VALUE str)
Definition: ripper.c:16762
rb_encoding * rb_enc_from_index(int index)
Definition: encoding.c:548
#define aryset(node1, node2)
Definition: ripper.c:488
static NODE * reg_named_capture_assign_gen(struct parser_params *parser, VALUE regexp, NODE *match)
Definition: ripper.c:16347
#define IS_AFTER_OPERATOR()
Definition: ripper.c:13363
#define NEW_BLOCK_PASS(b)
NODE * opt_args
Definition: ripper.y:522
static NODE * new_args_gen(struct parser_params *, NODE *, NODE *, ID, NODE *, NODE *)
Definition: ripper.c:15880
int rb_is_global_name(VALUE name)
Definition: ripper.c:17187
static int parser_tokadd_mbchar(struct parser_params *parser, int c)
Definition: ripper.c:12499
size_t len
Definition: tcltklib.c:3567