Ruby  2.0.0p645(2015-04-13revision50299)
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))
517 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
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);
539 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, 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
666 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
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  4060, 4069, 4079, 4088, 4099, 4106, 4117, 4124, 4139, 4146,
1513  4157, 4164, 4175, 4182, 4211, 4213, 4212, 4229, 4235, 4240,
1514  4228, 4259, 4267, 4275, 4283, 4286, 4297, 4298, 4299, 4300,
1515  4303, 4314, 4315, 4316, 4324, 4334, 4335, 4336, 4337, 4338,
1516  4341, 4342, 4343, 4344, 4345, 4346, 4347, 4350, 4363, 4373,
1517  4381, 4391, 4392, 4395, 4404, 4403, 4412, 4424, 4434, 4442,
1518  4446, 4450, 4454, 4460, 4465, 4470, 4474, 4478, 4482, 4486,
1519  4490, 4494, 4498, 4502, 4506, 4510, 4514, 4518, 4522, 4527,
1520  4533, 4542, 4551, 4560, 4571, 4572, 4579, 4588, 4607, 4614,
1521  4627, 4639, 4651, 4659, 4676, 4684, 4700, 4701, 4704, 4709,
1522  4715, 4727, 4739, 4747, 4763, 4771, 4787, 4788, 4791, 4804,
1523  4815, 4816, 4819, 4836, 4840, 4850, 4860, 4860, 4889, 4890,
1524  4900, 4907, 4917, 4925, 4933, 4945, 4946, 4947, 4950, 4951,
1525  4952, 4953, 4956, 4957, 4958, 4961, 4966, 4973, 4974, 4977,
1526  4978, 4981, 4984, 4987, 4988, 4989, 4992, 4993, 4996, 4997,
1527  5001
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
4530 {
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
4599 {
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
4693 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
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
4896 {
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. */
4908  int yyerrstatus;
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. */
4923  YYSTYPE yyvsa[YYINITDEPTH];
4924  YYSTYPE *yyvs;
4925  YYSTYPE *yyvsp;
4926 
4927  YYSIZE_T yystacksize;
4928 
4929  int yyn;
4930  int yyresult;
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. */
4935  YYSTYPE yyval;
4936 
4937 #if YYERROR_VERBOSE
4938  /* Buffer for error messages, and its allocated size. */
4939  char yymsgbuf[128];
4940  char *yymsg = yymsgbuf;
4941  YYSIZE_T yymsg_alloc = sizeof 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 
4969  goto yysetstate;
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)
5046  YYACCEPT;
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))
5061  goto yydefault;
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 
5111  goto yynewstate;
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  if (nd_type((yyvsp[(2) - (3)].val)) == NODE_DSTR) {
9955  nd_set_type((yyvsp[(2) - (3)].val), NODE_DSYM);
9956  }
9957  else {
9958  nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
9959  (yyvsp[(2) - (3)].val)->nd_lit = rb_str_intern((yyvsp[(2) - (3)].val)->nd_lit);
9960  }
9961  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9962 #endif
9963  (yyval.val) = dispatch2(symbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9964 
9965  }
9966  break;
9967 
9968  case 470:
9969 
9970 /* Line 1806 of yacc.c */
9971 #line 4061 "ripper.y"
9972  {
9973 #if 0
9974  (yyval.val) = NEW_ZARRAY();
9975 #endif
9976  (yyval.val) = dispatch0(qwords_new);
9977  (yyval.val) = dispatch1(array, (yyval.val));
9978 
9979  }
9980  break;
9981 
9982  case 471:
9983 
9984 /* Line 1806 of yacc.c */
9985 #line 4070 "ripper.y"
9986  {
9987 #if 0
9988  (yyval.val) = (yyvsp[(2) - (3)].val);
9989 #endif
9990  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9991 
9992  }
9993  break;
9994 
9995  case 472:
9996 
9997 /* Line 1806 of yacc.c */
9998 #line 4080 "ripper.y"
9999  {
10000 #if 0
10001  (yyval.val) = NEW_ZARRAY();
10002 #endif
10003  (yyval.val) = dispatch0(qsymbols_new);
10004  (yyval.val) = dispatch1(array, (yyval.val));
10005 
10006  }
10007  break;
10008 
10009  case 473:
10010 
10011 /* Line 1806 of yacc.c */
10012 #line 4089 "ripper.y"
10013  {
10014 #if 0
10015  (yyval.val) = (yyvsp[(2) - (3)].val);
10016 #endif
10017  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10018 
10019  }
10020  break;
10021 
10022  case 474:
10023 
10024 /* Line 1806 of yacc.c */
10025 #line 4099 "ripper.y"
10026  {
10027 #if 0
10028  (yyval.val) = 0;
10029 #endif
10030  (yyval.val) = dispatch0(qwords_new);
10031 
10032  }
10033  break;
10034 
10035  case 475:
10036 
10037 /* Line 1806 of yacc.c */
10038 #line 4107 "ripper.y"
10039  {
10040 #if 0
10041  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10042 #endif
10043  (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10044 
10045  }
10046  break;
10047 
10048  case 476:
10049 
10050 /* Line 1806 of yacc.c */
10051 #line 4117 "ripper.y"
10052  {
10053 #if 0
10054  (yyval.val) = 0;
10055 #endif
10056  (yyval.val) = dispatch0(qsymbols_new);
10057 
10058  }
10059  break;
10060 
10061  case 477:
10062 
10063 /* Line 1806 of yacc.c */
10064 #line 4125 "ripper.y"
10065  {
10066 #if 0
10067  VALUE lit;
10068  lit = (yyvsp[(2) - (3)].val)->nd_lit;
10069  (yyvsp[(2) - (3)].val)->nd_lit = ID2SYM(rb_intern_str(lit));
10070  nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
10071  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10072 #endif
10073  (yyval.val) = dispatch2(qsymbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10074 
10075  }
10076  break;
10077 
10078  case 478:
10079 
10080 /* Line 1806 of yacc.c */
10081 #line 4139 "ripper.y"
10082  {
10083 #if 0
10084  (yyval.val) = 0;
10085 #endif
10086  (yyval.val) = dispatch0(string_content);
10087 
10088  }
10089  break;
10090 
10091  case 479:
10092 
10093 /* Line 1806 of yacc.c */
10094 #line 4147 "ripper.y"
10095  {
10096 #if 0
10097  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10098 #endif
10099  (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10100 
10101  }
10102  break;
10103 
10104  case 480:
10105 
10106 /* Line 1806 of yacc.c */
10107 #line 4157 "ripper.y"
10108  {
10109 #if 0
10110  (yyval.val) = 0;
10111 #endif
10112  (yyval.val) = dispatch0(xstring_new);
10113 
10114  }
10115  break;
10116 
10117  case 481:
10118 
10119 /* Line 1806 of yacc.c */
10120 #line 4165 "ripper.y"
10121  {
10122 #if 0
10123  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10124 #endif
10125  (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10126 
10127  }
10128  break;
10129 
10130  case 482:
10131 
10132 /* Line 1806 of yacc.c */
10133 #line 4175 "ripper.y"
10134  {
10135 #if 0
10136  (yyval.val) = 0;
10137 #endif
10138  (yyval.val) = dispatch0(regexp_new);
10139 
10140  }
10141  break;
10142 
10143  case 483:
10144 
10145 /* Line 1806 of yacc.c */
10146 #line 4183 "ripper.y"
10147  {
10148 #if 0
10149  NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
10150  if (!head) {
10151  (yyval.val) = tail;
10152  }
10153  else if (!tail) {
10154  (yyval.val) = head;
10155  }
10156  else {
10157  switch (nd_type(head)) {
10158  case NODE_STR:
10159  nd_set_type(head, NODE_DSTR);
10160  break;
10161  case NODE_DSTR:
10162  break;
10163  default:
10164  head = list_append(NEW_DSTR(Qnil), head);
10165  break;
10166  }
10167  (yyval.val) = list_append(head, tail);
10168  }
10169 #endif
10170  (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10171 
10172  }
10173  break;
10174 
10175  case 485:
10176 
10177 /* Line 1806 of yacc.c */
10178 #line 4213 "ripper.y"
10179  {
10180  (yyval.node) = lex_strterm;
10181  lex_strterm = 0;
10182  lex_state = EXPR_BEG;
10183  }
10184  break;
10185 
10186  case 486:
10187 
10188 /* Line 1806 of yacc.c */
10189 #line 4219 "ripper.y"
10190  {
10191 #if 0
10192  lex_strterm = (yyvsp[(2) - (3)].node);
10193  (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
10194 #endif
10195  lex_strterm = (yyvsp[(2) - (3)].node);
10196  (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
10197 
10198  }
10199  break;
10200 
10201  case 487:
10202 
10203 /* Line 1806 of yacc.c */
10204 #line 4229 "ripper.y"
10205  {
10206  (yyvsp[(1) - (1)].val) = cond_stack;
10207  (yyval.val) = cmdarg_stack;
10208  cond_stack = 0;
10209  cmdarg_stack = 0;
10210  }
10211  break;
10212 
10213  case 488:
10214 
10215 /* Line 1806 of yacc.c */
10216 #line 4235 "ripper.y"
10217  {
10218  (yyval.node) = lex_strterm;
10219  lex_strterm = 0;
10220  lex_state = EXPR_BEG;
10221  }
10222  break;
10223 
10224  case 489:
10225 
10226 /* Line 1806 of yacc.c */
10227 #line 4240 "ripper.y"
10228  {
10229  (yyval.num) = brace_nest;
10230  brace_nest = 0;
10231  }
10232  break;
10233 
10234  case 490:
10235 
10236 /* Line 1806 of yacc.c */
10237 #line 4245 "ripper.y"
10238  {
10239  cond_stack = (yyvsp[(1) - (6)].val);
10240  cmdarg_stack = (yyvsp[(2) - (6)].val);
10241  lex_strterm = (yyvsp[(3) - (6)].node);
10242  brace_nest = (yyvsp[(4) - (6)].num);
10243 #if 0
10244  if ((yyvsp[(5) - (6)].val)) (yyvsp[(5) - (6)].val)->flags &= ~NODE_FL_NEWLINE;
10245  (yyval.val) = new_evstr((yyvsp[(5) - (6)].val));
10246 #endif
10247  (yyval.val) = dispatch1(string_embexpr, (yyvsp[(5) - (6)].val));
10248 
10249  }
10250  break;
10251 
10252  case 491:
10253 
10254 /* Line 1806 of yacc.c */
10255 #line 4260 "ripper.y"
10256  {
10257 #if 0
10258  (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
10259 #endif
10260  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10261 
10262  }
10263  break;
10264 
10265  case 492:
10266 
10267 /* Line 1806 of yacc.c */
10268 #line 4268 "ripper.y"
10269  {
10270 #if 0
10271  (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
10272 #endif
10273  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10274 
10275  }
10276  break;
10277 
10278  case 493:
10279 
10280 /* Line 1806 of yacc.c */
10281 #line 4276 "ripper.y"
10282  {
10283 #if 0
10284  (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
10285 #endif
10286  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10287 
10288  }
10289  break;
10290 
10291  case 495:
10292 
10293 /* Line 1806 of yacc.c */
10294 #line 4287 "ripper.y"
10295  {
10296  lex_state = EXPR_END;
10297 #if 0
10298  (yyval.val) = (yyvsp[(2) - (2)].val);
10299 #endif
10300  (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
10301 
10302  }
10303  break;
10304 
10305  case 500:
10306 
10307 /* Line 1806 of yacc.c */
10308 #line 4304 "ripper.y"
10309  {
10310  lex_state = EXPR_END;
10311 #if 0
10312  (yyval.val) = dsym_node((yyvsp[(2) - (3)].val));
10313 #endif
10314  (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
10315 
10316  }
10317  break;
10318 
10319  case 503:
10320 
10321 /* Line 1806 of yacc.c */
10322 #line 4317 "ripper.y"
10323  {
10324 #if 0
10325  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10326 #endif
10327  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10328 
10329  }
10330  break;
10331 
10332  case 504:
10333 
10334 /* Line 1806 of yacc.c */
10335 #line 4325 "ripper.y"
10336  {
10337 #if 0
10338  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10339 #endif
10340  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10341 
10342  }
10343  break;
10344 
10345  case 510:
10346 
10347 /* Line 1806 of yacc.c */
10348 #line 4341 "ripper.y"
10349  {ifndef_ripper((yyval.val) = keyword_nil);}
10350  break;
10351 
10352  case 511:
10353 
10354 /* Line 1806 of yacc.c */
10355 #line 4342 "ripper.y"
10356  {ifndef_ripper((yyval.val) = keyword_self);}
10357  break;
10358 
10359  case 512:
10360 
10361 /* Line 1806 of yacc.c */
10362 #line 4343 "ripper.y"
10363  {ifndef_ripper((yyval.val) = keyword_true);}
10364  break;
10365 
10366  case 513:
10367 
10368 /* Line 1806 of yacc.c */
10369 #line 4344 "ripper.y"
10370  {ifndef_ripper((yyval.val) = keyword_false);}
10371  break;
10372 
10373  case 514:
10374 
10375 /* Line 1806 of yacc.c */
10376 #line 4345 "ripper.y"
10377  {ifndef_ripper((yyval.val) = keyword__FILE__);}
10378  break;
10379 
10380  case 515:
10381 
10382 /* Line 1806 of yacc.c */
10383 #line 4346 "ripper.y"
10384  {ifndef_ripper((yyval.val) = keyword__LINE__);}
10385  break;
10386 
10387  case 516:
10388 
10389 /* Line 1806 of yacc.c */
10390 #line 4347 "ripper.y"
10391  {ifndef_ripper((yyval.val) = keyword__ENCODING__);}
10392  break;
10393 
10394  case 517:
10395 
10396 /* Line 1806 of yacc.c */
10397 #line 4351 "ripper.y"
10398  {
10399 #if 0
10400  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10401 #endif
10402  if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) {
10403  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10404  }
10405  else {
10406  (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val));
10407  }
10408 
10409  }
10410  break;
10411 
10412  case 518:
10413 
10414 /* Line 1806 of yacc.c */
10415 #line 4364 "ripper.y"
10416  {
10417 #if 0
10418  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10419 #endif
10420  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10421 
10422  }
10423  break;
10424 
10425  case 519:
10426 
10427 /* Line 1806 of yacc.c */
10428 #line 4374 "ripper.y"
10429  {
10430  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10431 #if 0
10432 #endif
10433  (yyval.val) = dispatch1(var_field, (yyval.val));
10434 
10435  }
10436  break;
10437 
10438  case 520:
10439 
10440 /* Line 1806 of yacc.c */
10441 #line 4382 "ripper.y"
10442  {
10443  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10444 #if 0
10445 #endif
10446  (yyval.val) = dispatch1(var_field, (yyval.val));
10447 
10448  }
10449  break;
10450 
10451  case 523:
10452 
10453 /* Line 1806 of yacc.c */
10454 #line 4396 "ripper.y"
10455  {
10456 #if 0
10457  (yyval.val) = 0;
10458 #endif
10459  (yyval.val) = Qnil;
10460 
10461  }
10462  break;
10463 
10464  case 524:
10465 
10466 /* Line 1806 of yacc.c */
10467 #line 4404 "ripper.y"
10468  {
10469  lex_state = EXPR_BEG;
10470  command_start = TRUE;
10471  }
10472  break;
10473 
10474  case 525:
10475 
10476 /* Line 1806 of yacc.c */
10477 #line 4409 "ripper.y"
10478  {
10479  (yyval.val) = (yyvsp[(3) - (4)].val);
10480  }
10481  break;
10482 
10483  case 526:
10484 
10485 /* Line 1806 of yacc.c */
10486 #line 4413 "ripper.y"
10487  {
10488 #if 0
10489  yyerrok;
10490  (yyval.val) = 0;
10491 #endif
10492  yyerrok;
10493  (yyval.val) = Qnil;
10494 
10495  }
10496  break;
10497 
10498  case 527:
10499 
10500 /* Line 1806 of yacc.c */
10501 #line 4425 "ripper.y"
10502  {
10503 #if 0
10504  (yyval.val) = (yyvsp[(2) - (3)].val);
10505 #endif
10506  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
10507 
10508  lex_state = EXPR_BEG;
10509  command_start = TRUE;
10510  }
10511  break;
10512 
10513  case 528:
10514 
10515 /* Line 1806 of yacc.c */
10516 #line 4435 "ripper.y"
10517  {
10518  (yyval.val) = (yyvsp[(1) - (2)].val);
10519  lex_state = EXPR_BEG;
10520  command_start = TRUE;
10521  }
10522  break;
10523 
10524  case 529:
10525 
10526 /* Line 1806 of yacc.c */
10527 #line 4443 "ripper.y"
10528  {
10529  (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10530  }
10531  break;
10532 
10533  case 530:
10534 
10535 /* Line 1806 of yacc.c */
10536 #line 4447 "ripper.y"
10537  {
10538  (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10539  }
10540  break;
10541 
10542  case 531:
10543 
10544 /* Line 1806 of yacc.c */
10545 #line 4451 "ripper.y"
10546  {
10547  (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10548  }
10549  break;
10550 
10551  case 532:
10552 
10553 /* Line 1806 of yacc.c */
10554 #line 4455 "ripper.y"
10555  {
10556  (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
10557  }
10558  break;
10559 
10560  case 533:
10561 
10562 /* Line 1806 of yacc.c */
10563 #line 4461 "ripper.y"
10564  {
10565  (yyval.val) = (yyvsp[(2) - (2)].val);
10566  }
10567  break;
10568 
10569  case 534:
10570 
10571 /* Line 1806 of yacc.c */
10572 #line 4465 "ripper.y"
10573  {
10574  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10575  }
10576  break;
10577 
10578  case 535:
10579 
10580 /* Line 1806 of yacc.c */
10581 #line 4471 "ripper.y"
10582  {
10583  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
10584  }
10585  break;
10586 
10587  case 536:
10588 
10589 /* Line 1806 of yacc.c */
10590 #line 4475 "ripper.y"
10591  {
10592  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10593  }
10594  break;
10595 
10596  case 537:
10597 
10598 /* Line 1806 of yacc.c */
10599 #line 4479 "ripper.y"
10600  {
10601  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
10602  }
10603  break;
10604 
10605  case 538:
10606 
10607 /* Line 1806 of yacc.c */
10608 #line 4483 "ripper.y"
10609  {
10610  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10611  }
10612  break;
10613 
10614  case 539:
10615 
10616 /* Line 1806 of yacc.c */
10617 #line 4487 "ripper.y"
10618  {
10619  (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10620  }
10621  break;
10622 
10623  case 540:
10624 
10625 /* Line 1806 of yacc.c */
10626 #line 4491 "ripper.y"
10627  {
10628  (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10629  }
10630  break;
10631 
10632  case 541:
10633 
10634 /* Line 1806 of yacc.c */
10635 #line 4495 "ripper.y"
10636  {
10637  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
10638  }
10639  break;
10640 
10641  case 542:
10642 
10643 /* Line 1806 of yacc.c */
10644 #line 4499 "ripper.y"
10645  {
10646  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10647  }
10648  break;
10649 
10650  case 543:
10651 
10652 /* Line 1806 of yacc.c */
10653 #line 4503 "ripper.y"
10654  {
10655  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10656  }
10657  break;
10658 
10659  case 544:
10660 
10661 /* Line 1806 of yacc.c */
10662 #line 4507 "ripper.y"
10663  {
10664  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
10665  }
10666  break;
10667 
10668  case 545:
10669 
10670 /* Line 1806 of yacc.c */
10671 #line 4511 "ripper.y"
10672  {
10673  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10674  }
10675  break;
10676 
10677  case 546:
10678 
10679 /* Line 1806 of yacc.c */
10680 #line 4515 "ripper.y"
10681  {
10682  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10683  }
10684  break;
10685 
10686  case 547:
10687 
10688 /* Line 1806 of yacc.c */
10689 #line 4519 "ripper.y"
10690  {
10691  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10692  }
10693  break;
10694 
10695  case 548:
10696 
10697 /* Line 1806 of yacc.c */
10698 #line 4523 "ripper.y"
10699  {
10700  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
10701  }
10702  break;
10703 
10704  case 549:
10705 
10706 /* Line 1806 of yacc.c */
10707 #line 4527 "ripper.y"
10708  {
10709  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10710  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.val));
10711  }
10712  break;
10713 
10714  case 550:
10715 
10716 /* Line 1806 of yacc.c */
10717 #line 4534 "ripper.y"
10718  {
10719 #if 0
10720  yyerror("formal argument cannot be a constant");
10721  (yyval.val) = 0;
10722 #endif
10723  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10724 
10725  }
10726  break;
10727 
10728  case 551:
10729 
10730 /* Line 1806 of yacc.c */
10731 #line 4543 "ripper.y"
10732  {
10733 #if 0
10734  yyerror("formal argument cannot be an instance variable");
10735  (yyval.val) = 0;
10736 #endif
10737  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10738 
10739  }
10740  break;
10741 
10742  case 552:
10743 
10744 /* Line 1806 of yacc.c */
10745 #line 4552 "ripper.y"
10746  {
10747 #if 0
10748  yyerror("formal argument cannot be a global variable");
10749  (yyval.val) = 0;
10750 #endif
10751  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10752 
10753  }
10754  break;
10755 
10756  case 553:
10757 
10758 /* Line 1806 of yacc.c */
10759 #line 4561 "ripper.y"
10760  {
10761 #if 0
10762  yyerror("formal argument cannot be a class variable");
10763  (yyval.val) = 0;
10764 #endif
10765  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10766 
10767  }
10768  break;
10769 
10770  case 555:
10771 
10772 /* Line 1806 of yacc.c */
10773 #line 4573 "ripper.y"
10774  {
10775  formal_argument(get_id((yyvsp[(1) - (1)].val)));
10776  (yyval.val) = (yyvsp[(1) - (1)].val);
10777  }
10778  break;
10779 
10780  case 556:
10781 
10782 /* Line 1806 of yacc.c */
10783 #line 4580 "ripper.y"
10784  {
10785  arg_var(get_id((yyvsp[(1) - (1)].val)));
10786 #if 0
10787  (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10788 #endif
10789  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10790 
10791  }
10792  break;
10793 
10794  case 557:
10795 
10796 /* Line 1806 of yacc.c */
10797 #line 4589 "ripper.y"
10798  {
10799  ID tid = internal_id();
10800  arg_var(tid);
10801 #if 0
10802  if (dyna_in_block()) {
10803  (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10804  }
10805  else {
10806  (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10807  }
10808  (yyval.val) = NEW_ARGS_AUX(tid, 1);
10809  (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10810 #endif
10811  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10812 
10813  }
10814  break;
10815 
10816  case 558:
10817 
10818 /* Line 1806 of yacc.c */
10819 #line 4610 "ripper.y"
10820  {
10821  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10822  }
10823  break;
10824 
10825  case 559:
10826 
10827 /* Line 1806 of yacc.c */
10828 #line 4615 "ripper.y"
10829  {
10830 #if 0
10831  (yyval.val) = (yyvsp[(1) - (3)].val);
10832  (yyval.val)->nd_plen++;
10833  (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10834  rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10835 #endif
10836  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10837 
10838  }
10839  break;
10840 
10841  case 560:
10842 
10843 /* Line 1806 of yacc.c */
10844 #line 4628 "ripper.y"
10845  {
10846  arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val))));
10847  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10848 #if 0
10849  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10850 #endif
10851  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10852 
10853  }
10854  break;
10855 
10856  case 561:
10857 
10858 /* Line 1806 of yacc.c */
10859 #line 4640 "ripper.y"
10860  {
10861  arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val))));
10862  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10863 #if 0
10864  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10865 #endif
10866  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10867 
10868  }
10869  break;
10870 
10871  case 562:
10872 
10873 /* Line 1806 of yacc.c */
10874 #line 4652 "ripper.y"
10875  {
10876 #if 0
10877  (yyval.val) = (yyvsp[(1) - (1)].val);
10878 #endif
10879  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10880 
10881  }
10882  break;
10883 
10884  case 563:
10885 
10886 /* Line 1806 of yacc.c */
10887 #line 4660 "ripper.y"
10888  {
10889 #if 0
10890  NODE *kws = (yyvsp[(1) - (3)].val);
10891 
10892  while (kws->nd_next) {
10893  kws = kws->nd_next;
10894  }
10895  kws->nd_next = (yyvsp[(3) - (3)].val);
10896  (yyval.val) = (yyvsp[(1) - (3)].val);
10897 #endif
10898  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10899 
10900  }
10901  break;
10902 
10903  case 564:
10904 
10905 /* Line 1806 of yacc.c */
10906 #line 4677 "ripper.y"
10907  {
10908 #if 0
10909  (yyval.val) = (yyvsp[(1) - (1)].val);
10910 #endif
10911  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10912 
10913  }
10914  break;
10915 
10916  case 565:
10917 
10918 /* Line 1806 of yacc.c */
10919 #line 4685 "ripper.y"
10920  {
10921 #if 0
10922  NODE *kws = (yyvsp[(1) - (3)].val);
10923 
10924  while (kws->nd_next) {
10925  kws = kws->nd_next;
10926  }
10927  kws->nd_next = (yyvsp[(3) - (3)].val);
10928  (yyval.val) = (yyvsp[(1) - (3)].val);
10929 #endif
10930  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10931 
10932  }
10933  break;
10934 
10935  case 568:
10936 
10937 /* Line 1806 of yacc.c */
10938 #line 4705 "ripper.y"
10939  {
10940  shadowing_lvar(get_id((yyvsp[(2) - (2)].val)));
10941  (yyval.val) = (yyvsp[(2) - (2)].val);
10942  }
10943  break;
10944 
10945  case 569:
10946 
10947 /* Line 1806 of yacc.c */
10948 #line 4710 "ripper.y"
10949  {
10950  (yyval.val) = internal_id();
10951  }
10952  break;
10953 
10954  case 570:
10955 
10956 /* Line 1806 of yacc.c */
10957 #line 4716 "ripper.y"
10958  {
10959  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10960  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10961 #if 0
10962  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10963 #endif
10964  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10965 
10966  }
10967  break;
10968 
10969  case 571:
10970 
10971 /* Line 1806 of yacc.c */
10972 #line 4728 "ripper.y"
10973  {
10974  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10975  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10976 #if 0
10977  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10978 #endif
10979  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10980 
10981  }
10982  break;
10983 
10984  case 572:
10985 
10986 /* Line 1806 of yacc.c */
10987 #line 4740 "ripper.y"
10988  {
10989 #if 0
10990  (yyval.val) = (yyvsp[(1) - (1)].val);
10991 #endif
10992  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10993 
10994  }
10995  break;
10996 
10997  case 573:
10998 
10999 /* Line 1806 of yacc.c */
11000 #line 4748 "ripper.y"
11001  {
11002 #if 0
11003  NODE *opts = (yyvsp[(1) - (3)].val);
11004 
11005  while (opts->nd_next) {
11006  opts = opts->nd_next;
11007  }
11008  opts->nd_next = (yyvsp[(3) - (3)].val);
11009  (yyval.val) = (yyvsp[(1) - (3)].val);
11010 #endif
11011  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11012 
11013  }
11014  break;
11015 
11016  case 574:
11017 
11018 /* Line 1806 of yacc.c */
11019 #line 4764 "ripper.y"
11020  {
11021 #if 0
11022  (yyval.val) = (yyvsp[(1) - (1)].val);
11023 #endif
11024  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11025 
11026  }
11027  break;
11028 
11029  case 575:
11030 
11031 /* Line 1806 of yacc.c */
11032 #line 4772 "ripper.y"
11033  {
11034 #if 0
11035  NODE *opts = (yyvsp[(1) - (3)].val);
11036 
11037  while (opts->nd_next) {
11038  opts = opts->nd_next;
11039  }
11040  opts->nd_next = (yyvsp[(3) - (3)].val);
11041  (yyval.val) = (yyvsp[(1) - (3)].val);
11042 #endif
11043  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11044 
11045  }
11046  break;
11047 
11048  case 578:
11049 
11050 /* Line 1806 of yacc.c */
11051 #line 4792 "ripper.y"
11052  {
11053 #if 0
11054  if (!is_local_id((yyvsp[(2) - (2)].val)))
11055  yyerror("rest argument must be local variable");
11056 #endif
11057  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11058 #if 0
11059  (yyval.val) = (yyvsp[(2) - (2)].val);
11060 #endif
11061  (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
11062 
11063  }
11064  break;
11065 
11066  case 579:
11067 
11068 /* Line 1806 of yacc.c */
11069 #line 4805 "ripper.y"
11070  {
11071 #if 0
11072  (yyval.val) = internal_id();
11073  arg_var((yyval.val));
11074 #endif
11075  (yyval.val) = dispatch1(rest_param, Qnil);
11076 
11077  }
11078  break;
11079 
11080  case 582:
11081 
11082 /* Line 1806 of yacc.c */
11083 #line 4820 "ripper.y"
11084  {
11085 #if 0
11086  if (!is_local_id((yyvsp[(2) - (2)].val)))
11087  yyerror("block argument must be local variable");
11088  else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
11089  yyerror("duplicated block argument name");
11090 #endif
11091  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11092 #if 0
11093  (yyval.val) = (yyvsp[(2) - (2)].val);
11094 #endif
11095  (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
11096 
11097  }
11098  break;
11099 
11100  case 583:
11101 
11102 /* Line 1806 of yacc.c */
11103 #line 4837 "ripper.y"
11104  {
11105  (yyval.val) = (yyvsp[(2) - (2)].val);
11106  }
11107  break;
11108 
11109  case 584:
11110 
11111 /* Line 1806 of yacc.c */
11112 #line 4841 "ripper.y"
11113  {
11114 #if 0
11115  (yyval.val) = 0;
11116 #endif
11117  (yyval.val) = Qundef;
11118 
11119  }
11120  break;
11121 
11122  case 585:
11123 
11124 /* Line 1806 of yacc.c */
11125 #line 4851 "ripper.y"
11126  {
11127 #if 0
11128  value_expr((yyvsp[(1) - (1)].val));
11129  (yyval.val) = (yyvsp[(1) - (1)].val);
11130  if (!(yyval.val)) (yyval.val) = NEW_NIL();
11131 #endif
11132  (yyval.val) = (yyvsp[(1) - (1)].val);
11133 
11134  }
11135  break;
11136 
11137  case 586:
11138 
11139 /* Line 1806 of yacc.c */
11140 #line 4860 "ripper.y"
11141  {lex_state = EXPR_BEG;}
11142  break;
11143 
11144  case 587:
11145 
11146 /* Line 1806 of yacc.c */
11147 #line 4861 "ripper.y"
11148  {
11149 #if 0
11150  if ((yyvsp[(3) - (4)].val) == 0) {
11151  yyerror("can't define singleton method for ().");
11152  }
11153  else {
11154  switch (nd_type((yyvsp[(3) - (4)].val))) {
11155  case NODE_STR:
11156  case NODE_DSTR:
11157  case NODE_XSTR:
11158  case NODE_DXSTR:
11159  case NODE_DREGX:
11160  case NODE_LIT:
11161  case NODE_ARRAY:
11162  case NODE_ZARRAY:
11163  yyerror("can't define singleton method for literals");
11164  default:
11165  value_expr((yyvsp[(3) - (4)].val));
11166  break;
11167  }
11168  }
11169  (yyval.val) = (yyvsp[(3) - (4)].val);
11170 #endif
11171  (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
11172 
11173  }
11174  break;
11175 
11176  case 589:
11177 
11178 /* Line 1806 of yacc.c */
11179 #line 4891 "ripper.y"
11180  {
11181 #if 0
11182  (yyval.val) = (yyvsp[(1) - (2)].val);
11183 #endif
11184  (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
11185 
11186  }
11187  break;
11188 
11189  case 590:
11190 
11191 /* Line 1806 of yacc.c */
11192 #line 4903 "ripper.y"
11193  {
11194  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11195  }
11196  break;
11197 
11198  case 591:
11199 
11200 /* Line 1806 of yacc.c */
11201 #line 4908 "ripper.y"
11202  {
11203 #if 0
11204  (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11205 #endif
11206  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11207 
11208  }
11209  break;
11210 
11211  case 592:
11212 
11213 /* Line 1806 of yacc.c */
11214 #line 4918 "ripper.y"
11215  {
11216 #if 0
11217  (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
11218 #endif
11219  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11220 
11221  }
11222  break;
11223 
11224  case 593:
11225 
11226 /* Line 1806 of yacc.c */
11227 #line 4926 "ripper.y"
11228  {
11229 #if 0
11230  (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
11231 #endif
11232  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
11233 
11234  }
11235  break;
11236 
11237  case 594:
11238 
11239 /* Line 1806 of yacc.c */
11240 #line 4934 "ripper.y"
11241  {
11242 #if 0
11243  (yyval.val) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].val));
11244 #endif
11245  (yyval.val) = dispatch1(assoc_splat, (yyvsp[(2) - (2)].val));
11246 
11247  }
11248  break;
11249 
11250  case 605:
11251 
11252 /* Line 1806 of yacc.c */
11253 #line 4964 "ripper.y"
11254  { (yyval.val) = (yyvsp[(1) - (1)].val); }
11255  break;
11256 
11257  case 606:
11258 
11259 /* Line 1806 of yacc.c */
11260 #line 4969 "ripper.y"
11261  { (yyval.val) = (yyvsp[(1) - (1)].val); }
11262  break;
11263 
11264  case 616:
11265 
11266 /* Line 1806 of yacc.c */
11267 #line 4992 "ripper.y"
11268  {yyerrok;}
11269  break;
11270 
11271  case 619:
11272 
11273 /* Line 1806 of yacc.c */
11274 #line 4997 "ripper.y"
11275  {yyerrok;}
11276  break;
11277 
11278  case 620:
11279 
11280 /* Line 1806 of yacc.c */
11281 #line 5001 "ripper.y"
11282  {
11283 #if 0
11284  (yyval.val) = 0;
11285 #endif
11286  (yyval.val) = Qundef;
11287 
11288  }
11289  break;
11290 
11291 
11292 
11293 /* Line 1806 of yacc.c */
11294 #line 11293 "parse.c"
11295  default: break;
11296  }
11297  /* User semantic actions sometimes alter yychar, and that requires
11298  that yytoken be updated with the new translation. We take the
11299  approach of translating immediately before every use of yytoken.
11300  One alternative is translating here after every semantic action,
11301  but that translation would be missed if the semantic action invokes
11302  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11303  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
11304  incorrect destructor might then be invoked immediately. In the
11305  case of YYERROR or YYBACKUP, subsequent parser actions might lead
11306  to an incorrect destructor call or verbose syntax error message
11307  before the lookahead is translated. */
11308  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11309 
11310  YYPOPSTACK (yylen);
11311  yylen = 0;
11312  YY_STACK_PRINT (yyss, yyssp);
11313 
11314  *++yyvsp = yyval;
11315 
11316  /* Now `shift' the result of the reduction. Determine what state
11317  that goes to, based on the state we popped back to and the rule
11318  number reduced by. */
11319 
11320  yyn = yyr1[yyn];
11321 
11322  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
11323  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
11324  yystate = yytable[yystate];
11325  else
11326  yystate = yydefgoto[yyn - YYNTOKENS];
11327 
11328  goto yynewstate;
11329 
11330 
11331 /*------------------------------------.
11332 | yyerrlab -- here on detecting error |
11333 `------------------------------------*/
11334 yyerrlab:
11335  /* Make sure we have latest lookahead translation. See comments at
11336  user semantic actions for why this is necessary. */
11337  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
11338 
11339  /* If not already recovering from an error, report this error. */
11340  if (!yyerrstatus)
11341  {
11342  ++yynerrs;
11343 #if ! YYERROR_VERBOSE
11344  parser_yyerror (parser, YY_("syntax error"));
11345 #else
11346 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
11347  yyssp, yytoken)
11348  {
11349  char const *yymsgp = YY_("syntax error");
11350  int yysyntax_error_status;
11351  yysyntax_error_status = YYSYNTAX_ERROR;
11352  if (yysyntax_error_status == 0)
11353  yymsgp = yymsg;
11354  else if (yysyntax_error_status == 1)
11355  {
11356  if (yymsg != yymsgbuf)
11357  YYSTACK_FREE (yymsg);
11358  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11359  if (!yymsg)
11360  {
11361  yymsg = yymsgbuf;
11362  yymsg_alloc = sizeof yymsgbuf;
11363  yysyntax_error_status = 2;
11364  }
11365  else
11366  {
11367  yysyntax_error_status = YYSYNTAX_ERROR;
11368  yymsgp = yymsg;
11369  }
11370  }
11371  parser_yyerror (parser, yymsgp);
11372  if (yysyntax_error_status == 2)
11373  goto yyexhaustedlab;
11374  }
11375 # undef YYSYNTAX_ERROR
11376 #endif
11377  }
11378 
11379 
11380 
11381  if (yyerrstatus == 3)
11382  {
11383  /* If just tried and failed to reuse lookahead token after an
11384  error, discard it. */
11385 
11386  if (yychar <= YYEOF)
11387  {
11388  /* Return failure if at end of input. */
11389  if (yychar == YYEOF)
11390  YYABORT;
11391  }
11392  else
11393  {
11394  yydestruct ("Error: discarding",
11395  yytoken, &yylval, parser);
11396  yychar = YYEMPTY;
11397  }
11398  }
11399 
11400  /* Else will try to reuse lookahead token after shifting the error
11401  token. */
11402  goto yyerrlab1;
11403 
11404 
11405 /*---------------------------------------------------.
11406 | yyerrorlab -- error raised explicitly by YYERROR. |
11407 `---------------------------------------------------*/
11408 yyerrorlab:
11409 
11410  /* Pacify compilers like GCC when the user code never invokes
11411  YYERROR and the label yyerrorlab therefore never appears in user
11412  code. */
11413  if (/*CONSTCOND*/ 0)
11414  goto yyerrorlab;
11415 
11416  /* Do not reclaim the symbols of the rule which action triggered
11417  this YYERROR. */
11418  YYPOPSTACK (yylen);
11419  yylen = 0;
11420  YY_STACK_PRINT (yyss, yyssp);
11421  yystate = *yyssp;
11422  goto yyerrlab1;
11423 
11424 
11425 /*-------------------------------------------------------------.
11426 | yyerrlab1 -- common code for both syntax error and YYERROR. |
11427 `-------------------------------------------------------------*/
11428 yyerrlab1:
11429  yyerrstatus = 3; /* Each real token shifted decrements this. */
11430 
11431  for (;;)
11432  {
11433  yyn = yypact[yystate];
11434  if (!yypact_value_is_default (yyn))
11435  {
11436  yyn += YYTERROR;
11437  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11438  {
11439  yyn = yytable[yyn];
11440  if (0 < yyn)
11441  break;
11442  }
11443  }
11444 
11445  /* Pop the current state because it cannot handle the error token. */
11446  if (yyssp == yyss)
11447  YYABORT;
11448 
11449 
11450  yydestruct ("Error: popping",
11451  yystos[yystate], yyvsp, parser);
11452  YYPOPSTACK (1);
11453  yystate = *yyssp;
11454  YY_STACK_PRINT (yyss, yyssp);
11455  }
11456 
11457  *++yyvsp = yylval;
11458 
11459 
11460  /* Shift the error token. */
11461  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11462 
11463  yystate = yyn;
11464  goto yynewstate;
11465 
11466 
11467 /*-------------------------------------.
11468 | yyacceptlab -- YYACCEPT comes here. |
11469 `-------------------------------------*/
11470 yyacceptlab:
11471  yyresult = 0;
11472  goto yyreturn;
11473 
11474 /*-----------------------------------.
11475 | yyabortlab -- YYABORT comes here. |
11476 `-----------------------------------*/
11477 yyabortlab:
11478  yyresult = 1;
11479  goto yyreturn;
11480 
11481 #if !defined(yyoverflow) || YYERROR_VERBOSE
11482 /*-------------------------------------------------.
11483 | yyexhaustedlab -- memory exhaustion comes here. |
11484 `-------------------------------------------------*/
11485 yyexhaustedlab:
11486  parser_yyerror (parser, YY_("memory exhausted"));
11487  yyresult = 2;
11488  /* Fall through. */
11489 #endif
11490 
11491 yyreturn:
11492  if (yychar != YYEMPTY)
11493  {
11494  /* Make sure we have latest lookahead translation. See comments at
11495  user semantic actions for why this is necessary. */
11496  yytoken = YYTRANSLATE (yychar);
11497  yydestruct ("Cleanup: discarding lookahead",
11498  yytoken, &yylval, parser);
11499  }
11500  /* Do not reclaim the symbols of the rule which action triggered
11501  this YYABORT or YYACCEPT. */
11502  YYPOPSTACK (yylen);
11503  YY_STACK_PRINT (yyss, yyssp);
11504  while (yyssp != yyss)
11505  {
11506  yydestruct ("Cleanup: popping",
11507  yystos[*yyssp], yyvsp, parser);
11508  YYPOPSTACK (1);
11509  }
11510 #ifndef yyoverflow
11511  if (yyss != yyssa)
11512  YYSTACK_FREE (yyss);
11513 #endif
11514 #if YYERROR_VERBOSE
11515  if (yymsg != yymsgbuf)
11516  YYSTACK_FREE (yymsg);
11517 #endif
11518  /* Make sure YYID is used. */
11519  return YYID (yyresult);
11520 }
11521 
11522 
11523 
11524 /* Line 2067 of yacc.c */
11525 #line 5009 "ripper.y"
11526 
11527 # undef parser
11528 # undef yylex
11529 # undef yylval
11530 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
11531 
11532 static int parser_regx_options(struct parser_params*);
11533 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11534 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11535 static int parser_parse_string(struct parser_params*,NODE*);
11536 static int parser_here_document(struct parser_params*,NODE*);
11537 
11538 
11539 # define nextc() parser_nextc(parser)
11540 # define pushback(c) parser_pushback(parser, (c))
11541 # define newtok() parser_newtok(parser)
11542 # define tokspace(n) parser_tokspace(parser, (n))
11543 # define tokadd(c) parser_tokadd(parser, (c))
11544 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
11545 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
11546 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
11547 # define regx_options() parser_regx_options(parser)
11548 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11549 # define parse_string(n) parser_parse_string(parser,(n))
11550 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
11551 # define here_document(n) parser_here_document(parser,(n))
11552 # define heredoc_identifier() parser_heredoc_identifier(parser)
11553 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
11554 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
11555 
11556 #ifndef RIPPER
11557 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11558 # define set_yylval_num(x) (yylval.num = (x))
11559 # define set_yylval_id(x) (yylval.id = (x))
11560 # define set_yylval_name(x) (yylval.id = (x))
11561 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11562 # define set_yylval_node(x) (yylval.node = (x))
11563 # define yylval_id() (yylval.id)
11564 #else
11565 static inline VALUE
11566 ripper_yylval_id(ID x)
11567 {
11568  return (VALUE)NEW_LASGN(x, ID2SYM(x));
11569 }
11570 # define set_yylval_str(x) (void)(x)
11571 # define set_yylval_num(x) (void)(x)
11572 # define set_yylval_id(x) (void)(x)
11573 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11574 # define set_yylval_literal(x) (void)(x)
11575 # define set_yylval_node(x) (void)(x)
11576 # define yylval_id() yylval.id
11577 #endif
11578 
11579 #ifndef RIPPER
11580 #define ripper_flush(p) (void)(p)
11581 #else
11582 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11583 
11584 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11585 
11586 static int
11587 ripper_has_scan_event(struct parser_params *parser)
11588 {
11589 
11590  if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11591  return lex_p > parser->tokp;
11592 }
11593 
11594 static VALUE
11595 ripper_scan_event_val(struct parser_params *parser, int t)
11596 {
11597  VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11598  VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11599  ripper_flush(parser);
11600  return rval;
11601 }
11602 
11603 static void
11604 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11605 {
11606  if (!ripper_has_scan_event(parser)) return;
11607  yylval_rval = ripper_scan_event_val(parser, t);
11608 }
11609 
11610 static void
11611 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11612 {
11613  if (!ripper_has_scan_event(parser)) return;
11614  (void)ripper_scan_event_val(parser, t);
11615 }
11616 
11617 static void
11618 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11619 {
11620  int saved_line = ruby_sourceline;
11621  const char *saved_tokp = parser->tokp;
11622 
11623  ruby_sourceline = parser->delayed_line;
11624  parser->tokp = lex_pbeg + parser->delayed_col;
11625  yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11626  parser->delayed = Qnil;
11627  ruby_sourceline = saved_line;
11628  parser->tokp = saved_tokp;
11629 }
11630 #endif /* RIPPER */
11631 
11632 #include "ruby/regex.h"
11633 #include "ruby/util.h"
11634 
11635 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11636  since ours (we hope) works properly with all combinations of
11637  machines, compilers, `char' and `unsigned char' argument types.
11638  (Per Bothner suggested the basic approach.) */
11639 #undef SIGN_EXTEND_CHAR
11640 #if __STDC__
11641 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11642 #else /* not __STDC__ */
11643 /* As in Harbison and Steele. */
11644 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11645 #endif
11646 
11647 #define parser_encoding_name() (current_enc->name)
11648 #define parser_mbclen() mbclen((lex_p-1),lex_pend,current_enc)
11649 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
11650 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11651 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11652 
11653 #define parser_isascii() ISASCII(*(lex_p-1))
11654 
11655 #ifndef RIPPER
11656 static int
11657 token_info_get_column(struct parser_params *parser, const char *token)
11658 {
11659  int column = 1;
11660  const char *p, *pend = lex_p - strlen(token);
11661  for (p = lex_pbeg; p < pend; p++) {
11662  if (*p == '\t') {
11663  column = (((column - 1) / 8) + 1) * 8;
11664  }
11665  column++;
11666  }
11667  return column;
11668 }
11669 
11670 static int
11671 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11672 {
11673  const char *p, *pend = lex_p - strlen(token);
11674  for (p = lex_pbeg; p < pend; p++) {
11675  if (*p != ' ' && *p != '\t') {
11676  return 1;
11677  }
11678  }
11679  return 0;
11680 }
11681 
11682 #undef token_info_push
11683 static void
11684 token_info_push(struct parser_params *parser, const char *token)
11685 {
11686  token_info *ptinfo;
11687 
11688  if (!parser->parser_token_info_enabled) return;
11689  ptinfo = ALLOC(token_info);
11690  ptinfo->token = token;
11691  ptinfo->linenum = ruby_sourceline;
11692  ptinfo->column = token_info_get_column(parser, token);
11693  ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11694  ptinfo->next = parser->parser_token_info;
11695 
11696  parser->parser_token_info = ptinfo;
11697 }
11698 
11699 #undef token_info_pop
11700 static void
11701 token_info_pop(struct parser_params *parser, const char *token)
11702 {
11703  int linenum;
11704  token_info *ptinfo = parser->parser_token_info;
11705 
11706  if (!ptinfo) return;
11707  parser->parser_token_info = ptinfo->next;
11708  if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11709  goto finish;
11710  }
11711  linenum = ruby_sourceline;
11712  if (linenum == ptinfo->linenum) { /* SKIP */
11713  goto finish;
11714  }
11715  if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11716  goto finish;
11717  }
11718  if (parser->parser_token_info_enabled) {
11720  "mismatched indentations at '%s' with '%s' at %d",
11721  token, ptinfo->token, ptinfo->linenum);
11722  }
11723 
11724  finish:
11725  xfree(ptinfo);
11726 }
11727 #endif /* RIPPER */
11728 
11729 static int
11730 parser_yyerror(struct parser_params *parser, const char *msg)
11731 {
11732 #ifndef RIPPER
11733  const int max_line_margin = 30;
11734  const char *p, *pe;
11735  char *buf;
11736  long len;
11737  int i;
11738 
11739  compile_error(PARSER_ARG "%s", msg);
11740  p = lex_p;
11741  while (lex_pbeg <= p) {
11742  if (*p == '\n') break;
11743  p--;
11744  }
11745  p++;
11746 
11747  pe = lex_p;
11748  while (pe < lex_pend) {
11749  if (*pe == '\n') break;
11750  pe++;
11751  }
11752 
11753  len = pe - p;
11754  if (len > 4) {
11755  char *p2;
11756  const char *pre = "", *post = "";
11757 
11758  if (len > max_line_margin * 2 + 10) {
11759  if (lex_p - p > max_line_margin) {
11760  p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11761  pre = "...";
11762  }
11763  if (pe - lex_p > max_line_margin) {
11764  pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11765  post = "...";
11766  }
11767  len = pe - p;
11768  }
11769  buf = ALLOCA_N(char, len+2);
11770  MEMCPY(buf, p, char, len);
11771  buf[len] = '\0';
11772  rb_compile_error_with_enc(NULL, 0, (void *)current_enc, "%s%s%s", pre, buf, post);
11773 
11774  i = (int)(lex_p - p);
11775  p2 = buf; pe = buf + len;
11776 
11777  while (p2 < pe) {
11778  if (*p2 != '\t') *p2 = ' ';
11779  p2++;
11780  }
11781  buf[i] = '^';
11782  buf[i+1] = '\0';
11783  rb_compile_error_append("%s%s", pre, buf);
11784  }
11785 #else
11786  dispatch1(parse_error, STR_NEW2(msg));
11787 #endif /* !RIPPER */
11788  return 0;
11789 }
11790 
11791 static void parser_prepare(struct parser_params *parser);
11792 
11793 #ifndef RIPPER
11794 static VALUE
11796 {
11797  ID script_lines;
11798  CONST_ID(script_lines, "SCRIPT_LINES__");
11799  if (rb_const_defined_at(rb_cObject, script_lines)) {
11800  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11801  if (RB_TYPE_P(hash, T_HASH)) {
11802  VALUE lines = rb_ary_new();
11803  rb_hash_aset(hash, fname, lines);
11804  return lines;
11805  }
11806  }
11807  return 0;
11808 }
11809 
11810 static VALUE
11811 coverage(VALUE fname, int n)
11812 {
11813  VALUE coverages = rb_get_coverages();
11814  if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11815  VALUE lines = rb_ary_new2(n);
11816  int i;
11817  RBASIC(lines)->klass = 0;
11818  for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11819  RARRAY(lines)->as.heap.len = n;
11820  rb_hash_aset(coverages, fname, lines);
11821  return lines;
11822  }
11823  return 0;
11824 }
11825 
11826 static int
11828 {
11829  return strcmp(ruby_sourcefile, "-e") == 0;
11830 }
11831 
11832 static VALUE
11834 {
11835  int n;
11836  NODE *tree;
11837  struct parser_params *parser = (struct parser_params *)arg;
11838 
11839  if (!compile_for_eval && rb_safe_level() == 0) {
11841  if (ruby_debug_lines && ruby_sourceline > 0) {
11842  VALUE str = STR_NEW0();
11843  n = ruby_sourceline;
11844  do {
11846  } while (--n);
11847  }
11848 
11849  if (!e_option_supplied(parser)) {
11851  }
11852  }
11853 
11854  parser_prepare(parser);
11855  deferred_nodes = 0;
11856 #ifndef RIPPER
11858 #endif
11859 #ifndef RIPPER
11862  parser->parser_ruby_sourceline);
11863  }
11864 #endif
11865  n = yyparse((void*)parser);
11866 #ifndef RIPPER
11869  parser->parser_ruby_sourceline);
11870  }
11871 #endif
11872  ruby_debug_lines = 0;
11873  ruby_coverage = 0;
11874  compile_for_eval = 0;
11875 
11876  lex_strterm = 0;
11877  lex_p = lex_pbeg = lex_pend = 0;
11878  lex_lastline = lex_nextline = 0;
11879  if (parser->nerr) {
11880  return 0;
11881  }
11882  tree = ruby_eval_tree;
11883  if (!tree) {
11884  tree = NEW_NIL();
11885  }
11886  else if (ruby_eval_tree_begin) {
11887  tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11888  }
11889  return (VALUE)tree;
11890 }
11891 
11892 static NODE*
11893 yycompile(struct parser_params *parser, VALUE fname, int line)
11894 {
11896  ruby_sourcefile = RSTRING_PTR(fname);
11897  ruby_sourceline = line - 1;
11898  return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
11899 }
11900 #endif /* !RIPPER */
11901 
11902 static rb_encoding *
11904 {
11905  rb_encoding *enc = rb_enc_get(s);
11906  if (!rb_enc_asciicompat(enc)) {
11907  rb_raise(rb_eArgError, "invalid source encoding");
11908  }
11909  return enc;
11910 }
11911 
11912 static VALUE
11913 lex_get_str(struct parser_params *parser, VALUE s)
11914 {
11915  char *beg, *end, *pend;
11917 
11918  beg = RSTRING_PTR(s);
11919  if (lex_gets_ptr) {
11920  if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11921  beg += lex_gets_ptr;
11922  }
11923  pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11924  end = beg;
11925  while (end < pend) {
11926  if (*end++ == '\n') break;
11927  }
11928  lex_gets_ptr = end - RSTRING_PTR(s);
11929  return rb_enc_str_new(beg, end - beg, enc);
11930 }
11931 
11932 static VALUE
11934 {
11935  VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11936  if (NIL_P(line)) return line;
11938 #ifndef RIPPER
11939  if (ruby_debug_lines) {
11942  }
11943  if (ruby_coverage) {
11945  }
11946 #endif
11947  return line;
11948 }
11949 
11950 #ifdef RIPPER
11952 #else
11954 
11955 static NODE*
11956 parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
11957 {
11958  struct parser_params *parser;
11959  NODE *node;
11960 
11961  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11963  lex_gets_ptr = 0;
11964  lex_input = s;
11965  lex_pbeg = lex_p = lex_pend = 0;
11967 
11968  node = yycompile(parser, fname, line);
11969  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11970 
11971  return node;
11972 }
11973 
11974 NODE*
11975 rb_compile_string(const char *f, VALUE s, int line)
11976 {
11979 }
11980 
11981 NODE*
11982 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11983 {
11984  return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
11985 }
11986 
11987 NODE*
11988 rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
11989 {
11991  return parser_compile_string(vparser, f, s, line);
11992 }
11993 
11994 NODE*
11995 rb_compile_cstr(const char *f, const char *s, int len, int line)
11996 {
11997  VALUE str = rb_str_new(s, len);
11999 }
12000 
12001 NODE*
12002 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
12003 {
12004  VALUE str = rb_str_new(s, len);
12005  return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line);
12006 }
12007 
12008 static VALUE
12009 lex_io_gets(struct parser_params *parser, VALUE io)
12010 {
12011  return rb_io_gets(io);
12012 }
12013 
12014 NODE*
12015 rb_compile_file(const char *f, VALUE file, int start)
12016 {
12017  VALUE volatile vparser = rb_parser_new();
12018 
12019  return rb_parser_compile_file(vparser, f, file, start);
12020 }
12021 
12022 NODE*
12023 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
12024 {
12025  return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start);
12026 }
12027 
12028 NODE*
12029 rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
12030 {
12031  struct parser_params *parser;
12032  NODE *node;
12033 
12034  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12036  lex_input = file;
12037  lex_pbeg = lex_p = lex_pend = 0;
12039 
12040  node = yycompile(parser, fname, start);
12041  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12042 
12043  return node;
12044 }
12045 #endif /* !RIPPER */
12046 
12047 #define STR_FUNC_ESCAPE 0x01
12048 #define STR_FUNC_EXPAND 0x02
12049 #define STR_FUNC_REGEXP 0x04
12050 #define STR_FUNC_QWORDS 0x08
12051 #define STR_FUNC_SYMBOL 0x10
12052 #define STR_FUNC_INDENT 0x20
12053 
12055  str_squote = (0),
12063 };
12064 
12065 static VALUE
12066 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
12067 {
12068  VALUE str;
12069 
12070  str = rb_enc_str_new(p, n, enc);
12071  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12073  }
12074  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12076  }
12077  }
12078 
12079  return str;
12080 }
12081 
12082 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
12083 #define lex_eol_p() (lex_p >= lex_pend)
12084 #define peek(c) peek_n((c), 0)
12085 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
12086 
12087 static inline int
12089 {
12090  int c;
12091 
12092  if (lex_p == lex_pend) {
12093  VALUE v = lex_nextline;
12094  lex_nextline = 0;
12095  if (!v) {
12096  if (parser->eofp)
12097  return -1;
12098 
12099  if (!lex_input || NIL_P(v = lex_getline(parser))) {
12100  parser->eofp = Qtrue;
12101  lex_goto_eol(parser);
12102  return -1;
12103  }
12104  }
12105  {
12106 #ifdef RIPPER
12107  if (parser->tokp < lex_pend) {
12108  if (NIL_P(parser->delayed)) {
12109  parser->delayed = rb_str_buf_new(1024);
12110  rb_enc_associate(parser->delayed, current_enc);
12111  rb_str_buf_cat(parser->delayed,
12112  parser->tokp, lex_pend - parser->tokp);
12113  parser->delayed_line = ruby_sourceline;
12114  parser->delayed_col = (int)(parser->tokp - lex_pbeg);
12115  }
12116  else {
12117  rb_str_buf_cat(parser->delayed,
12118  parser->tokp, lex_pend - parser->tokp);
12119  }
12120  }
12121 #endif
12122  if (heredoc_end > 0) {
12124  heredoc_end = 0;
12125  }
12126  ruby_sourceline++;
12127  parser->line_count++;
12128  lex_pbeg = lex_p = RSTRING_PTR(v);
12129  lex_pend = lex_p + RSTRING_LEN(v);
12130  ripper_flush(parser);
12131  lex_lastline = v;
12132  }
12133  }
12134  c = (unsigned char)*lex_p++;
12135  if (c == '\r' && peek('\n')) {
12136  lex_p++;
12137  c = '\n';
12138  }
12139 
12140  return c;
12141 }
12142 
12143 static void
12144 parser_pushback(struct parser_params *parser, int c)
12145 {
12146  if (c == -1) return;
12147  lex_p--;
12148  if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
12149  lex_p--;
12150  }
12151 }
12152 
12153 #define was_bol() (lex_p == lex_pbeg + 1)
12154 
12155 #define tokfix() (tokenbuf[tokidx]='\0')
12156 #define tok() tokenbuf
12157 #define toklen() tokidx
12158 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
12159 
12160 static char*
12162 {
12163  tokidx = 0;
12165  if (!tokenbuf) {
12166  toksiz = 60;
12167  tokenbuf = ALLOC_N(char, 60);
12168  }
12169  if (toksiz > 4096) {
12170  toksiz = 60;
12171  REALLOC_N(tokenbuf, char, 60);
12172  }
12173  return tokenbuf;
12174 }
12175 
12176 static char *
12177 parser_tokspace(struct parser_params *parser, int n)
12178 {
12179  tokidx += n;
12180 
12181  if (tokidx >= toksiz) {
12182  do {toksiz *= 2;} while (toksiz < tokidx);
12183  REALLOC_N(tokenbuf, char, toksiz);
12184  }
12185  return &tokenbuf[tokidx-n];
12186 }
12187 
12188 static void
12189 parser_tokadd(struct parser_params *parser, int c)
12190 {
12191  tokenbuf[tokidx++] = (char)c;
12192  if (tokidx >= toksiz) {
12193  toksiz *= 2;
12194  REALLOC_N(tokenbuf, char, toksiz);
12195  }
12196 }
12197 
12198 static int
12199 parser_tok_hex(struct parser_params *parser, size_t *numlen)
12200 {
12201  int c;
12202 
12203  c = scan_hex(lex_p, 2, numlen);
12204  if (!*numlen) {
12205  yyerror("invalid hex escape");
12206  return 0;
12207  }
12208  lex_p += *numlen;
12209  return c;
12210 }
12211 
12212 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
12213 
12214 /* return value is for ?\u3042 */
12215 static int
12217  int string_literal, int symbol_literal, int regexp_literal)
12218 {
12219  /*
12220  * If string_literal is true, then we allow multiple codepoints
12221  * in \u{}, and add the codepoints to the current token.
12222  * Otherwise we're parsing a character literal and return a single
12223  * codepoint without adding it
12224  */
12225 
12226  int codepoint;
12227  size_t numlen;
12228 
12229  if (regexp_literal) { tokadd('\\'); tokadd('u'); }
12230 
12231  if (peek('{')) { /* handle \u{...} form */
12232  do {
12233  if (regexp_literal) { tokadd(*lex_p); }
12234  nextc();
12235  codepoint = scan_hex(lex_p, 6, &numlen);
12236  if (numlen == 0) {
12237  yyerror("invalid Unicode escape");
12238  return 0;
12239  }
12240  if (codepoint > 0x10ffff) {
12241  yyerror("invalid Unicode codepoint (too large)");
12242  return 0;
12243  }
12244  lex_p += numlen;
12245  if (regexp_literal) {
12246  tokcopy((int)numlen);
12247  }
12248  else if (codepoint >= 0x80) {
12249  *encp = rb_utf8_encoding();
12250  if (string_literal) tokaddmbc(codepoint, *encp);
12251  }
12252  else if (string_literal) {
12253  tokadd(codepoint);
12254  }
12255  } while (string_literal && (peek(' ') || peek('\t')));
12256 
12257  if (!peek('}')) {
12258  yyerror("unterminated Unicode escape");
12259  return 0;
12260  }
12261 
12262  if (regexp_literal) { tokadd('}'); }
12263  nextc();
12264  }
12265  else { /* handle \uxxxx form */
12266  codepoint = scan_hex(lex_p, 4, &numlen);
12267  if (numlen < 4) {
12268  yyerror("invalid Unicode escape");
12269  return 0;
12270  }
12271  lex_p += 4;
12272  if (regexp_literal) {
12273  tokcopy(4);
12274  }
12275  else if (codepoint >= 0x80) {
12276  *encp = rb_utf8_encoding();
12277  if (string_literal) tokaddmbc(codepoint, *encp);
12278  }
12279  else if (string_literal) {
12280  tokadd(codepoint);
12281  }
12282  }
12283 
12284  return codepoint;
12285 }
12286 
12287 #define ESCAPE_CONTROL 1
12288 #define ESCAPE_META 2
12289 
12290 static int
12291 parser_read_escape(struct parser_params *parser, int flags,
12292  rb_encoding **encp)
12293 {
12294  int c;
12295  size_t numlen;
12296 
12297  switch (c = nextc()) {
12298  case '\\': /* Backslash */
12299  return c;
12300 
12301  case 'n': /* newline */
12302  return '\n';
12303 
12304  case 't': /* horizontal tab */
12305  return '\t';
12306 
12307  case 'r': /* carriage-return */
12308  return '\r';
12309 
12310  case 'f': /* form-feed */
12311  return '\f';
12312 
12313  case 'v': /* vertical tab */
12314  return '\13';
12315 
12316  case 'a': /* alarm(bell) */
12317  return '\007';
12318 
12319  case 'e': /* escape */
12320  return 033;
12321 
12322  case '0': case '1': case '2': case '3': /* octal constant */
12323  case '4': case '5': case '6': case '7':
12324  pushback(c);
12325  c = scan_oct(lex_p, 3, &numlen);
12326  lex_p += numlen;
12327  return c;
12328 
12329  case 'x': /* hex constant */
12330  c = tok_hex(&numlen);
12331  if (numlen == 0) return 0;
12332  return c;
12333 
12334  case 'b': /* backspace */
12335  return '\010';
12336 
12337  case 's': /* space */
12338  return ' ';
12339 
12340  case 'M':
12341  if (flags & ESCAPE_META) goto eof;
12342  if ((c = nextc()) != '-') {
12343  pushback(c);
12344  goto eof;
12345  }
12346  if ((c = nextc()) == '\\') {
12347  if (peek('u')) goto eof;
12348  return read_escape(flags|ESCAPE_META, encp) | 0x80;
12349  }
12350  else if (c == -1 || !ISASCII(c)) goto eof;
12351  else {
12352  return ((c & 0xff) | 0x80);
12353  }
12354 
12355  case 'C':
12356  if ((c = nextc()) != '-') {
12357  pushback(c);
12358  goto eof;
12359  }
12360  case 'c':
12361  if (flags & ESCAPE_CONTROL) goto eof;
12362  if ((c = nextc())== '\\') {
12363  if (peek('u')) goto eof;
12364  c = read_escape(flags|ESCAPE_CONTROL, encp);
12365  }
12366  else if (c == '?')
12367  return 0177;
12368  else if (c == -1 || !ISASCII(c)) goto eof;
12369  return c & 0x9f;
12370 
12371  eof:
12372  case -1:
12373  yyerror("Invalid escape character syntax");
12374  return '\0';
12375 
12376  default:
12377  return c;
12378  }
12379 }
12380 
12381 static void
12383 {
12384  int len = rb_enc_codelen(c, enc);
12385  rb_enc_mbcput(c, tokspace(len), enc);
12386 }
12387 
12388 static int
12390 {
12391  int c;
12392  int flags = 0;
12393  size_t numlen;
12394 
12395  first:
12396  switch (c = nextc()) {
12397  case '\n':
12398  return 0; /* just ignore */
12399 
12400  case '0': case '1': case '2': case '3': /* octal constant */
12401  case '4': case '5': case '6': case '7':
12402  {
12403  ruby_scan_oct(--lex_p, 3, &numlen);
12404  if (numlen == 0) goto eof;
12405  lex_p += numlen;
12406  tokcopy((int)numlen + 1);
12407  }
12408  return 0;
12409 
12410  case 'x': /* hex constant */
12411  {
12412  tok_hex(&numlen);
12413  if (numlen == 0) return -1;
12414  tokcopy((int)numlen + 2);
12415  }
12416  return 0;
12417 
12418  case 'M':
12419  if (flags & ESCAPE_META) goto eof;
12420  if ((c = nextc()) != '-') {
12421  pushback(c);
12422  goto eof;
12423  }
12424  tokcopy(3);
12425  flags |= ESCAPE_META;
12426  goto escaped;
12427 
12428  case 'C':
12429  if (flags & ESCAPE_CONTROL) goto eof;
12430  if ((c = nextc()) != '-') {
12431  pushback(c);
12432  goto eof;
12433  }
12434  tokcopy(3);
12435  goto escaped;
12436 
12437  case 'c':
12438  if (flags & ESCAPE_CONTROL) goto eof;
12439  tokcopy(2);
12440  flags |= ESCAPE_CONTROL;
12441  escaped:
12442  if ((c = nextc()) == '\\') {
12443  goto first;
12444  }
12445  else if (c == -1) goto eof;
12446  tokadd(c);
12447  return 0;
12448 
12449  eof:
12450  case -1:
12451  yyerror("Invalid escape character syntax");
12452  return -1;
12453 
12454  default:
12455  tokadd('\\');
12456  tokadd(c);
12457  }
12458  return 0;
12459 }
12460 
12461 static int
12463 {
12464  int kcode = 0;
12465  int kopt = 0;
12466  int options = 0;
12467  int c, opt, kc;
12468 
12469  newtok();
12470  while (c = nextc(), ISALPHA(c)) {
12471  if (c == 'o') {
12472  options |= RE_OPTION_ONCE;
12473  }
12474  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12475  if (kc >= 0) {
12476  if (kc != rb_ascii8bit_encindex()) kcode = c;
12477  kopt = opt;
12478  }
12479  else {
12480  options |= opt;
12481  }
12482  }
12483  else {
12484  tokadd(c);
12485  }
12486  }
12487  options |= kopt;
12488  pushback(c);
12489  if (toklen()) {
12490  tokfix();
12491  compile_error(PARSER_ARG "unknown regexp option%s - %s",
12492  toklen() > 1 ? "s" : "", tok());
12493  }
12494  return options | RE_OPTION_ENCODING(kcode);
12495 }
12496 
12497 static void
12499 {
12500  rb_str_free(str);
12501  rb_gc_force_recycle(str);
12502 }
12503 
12504 static int
12505 parser_tokadd_mbchar(struct parser_params *parser, int c)
12506 {
12507  int len = parser_precise_mbclen();
12508  if (!MBCLEN_CHARFOUND_P(len)) {
12509  compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12510  return -1;
12511  }
12512  tokadd(c);
12513  lex_p += --len;
12514  if (len > 0) tokcopy(len);
12515  return c;
12516 }
12517 
12518 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12519 
12520 static inline int
12522 {
12523  switch (c) {
12524  case '$': case '*': case '+': case '.':
12525  case '?': case '^': case '|':
12526  case ')': case ']': case '}': case '>':
12527  return TRUE;
12528  default:
12529  return FALSE;
12530  }
12531 }
12532 
12533 static int
12535  int func, int term, int paren, long *nest,
12536  rb_encoding **encp)
12537 {
12538  int c;
12539  int has_nonascii = 0;
12540  rb_encoding *enc = *encp;
12541  char *errbuf = 0;
12542  static const char mixed_msg[] = "%s mixed within %s source";
12543 
12544 #define mixed_error(enc1, enc2) if (!errbuf) { \
12545  size_t len = sizeof(mixed_msg) - 4; \
12546  len += strlen(rb_enc_name(enc1)); \
12547  len += strlen(rb_enc_name(enc2)); \
12548  errbuf = ALLOCA_N(char, len); \
12549  snprintf(errbuf, len, mixed_msg, \
12550  rb_enc_name(enc1), \
12551  rb_enc_name(enc2)); \
12552  yyerror(errbuf); \
12553  }
12554 #define mixed_escape(beg, enc1, enc2) do { \
12555  const char *pos = lex_p; \
12556  lex_p = (beg); \
12557  mixed_error((enc1), (enc2)); \
12558  lex_p = pos; \
12559  } while (0)
12560 
12561  while ((c = nextc()) != -1) {
12562  if (paren && c == paren) {
12563  ++*nest;
12564  }
12565  else if (c == term) {
12566  if (!nest || !*nest) {
12567  pushback(c);
12568  break;
12569  }
12570  --*nest;
12571  }
12572  else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12573  int c2 = *lex_p;
12574  if (c2 == '$' || c2 == '@' || c2 == '{') {
12575  pushback(c);
12576  break;
12577  }
12578  }
12579  else if (c == '\\') {
12580  const char *beg = lex_p - 1;
12581  c = nextc();
12582  switch (c) {
12583  case '\n':
12584  if (func & STR_FUNC_QWORDS) break;
12585  if (func & STR_FUNC_EXPAND) continue;
12586  tokadd('\\');
12587  break;
12588 
12589  case '\\':
12590  if (func & STR_FUNC_ESCAPE) tokadd(c);
12591  break;
12592 
12593  case 'u':
12594  if ((func & STR_FUNC_EXPAND) == 0) {
12595  tokadd('\\');
12596  break;
12597  }
12598  parser_tokadd_utf8(parser, &enc, 1,
12599  func & STR_FUNC_SYMBOL,
12600  func & STR_FUNC_REGEXP);
12601  if (has_nonascii && enc != *encp) {
12602  mixed_escape(beg, enc, *encp);
12603  }
12604  continue;
12605 
12606  default:
12607  if (c == -1) return -1;
12608  if (!ISASCII(c)) {
12609  if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12610  goto non_ascii;
12611  }
12612  if (func & STR_FUNC_REGEXP) {
12613  if (c == term && !simple_re_meta(c)) {
12614  tokadd(c);
12615  continue;
12616  }
12617  pushback(c);
12618  if ((c = tokadd_escape(&enc)) < 0)
12619  return -1;
12620  if (has_nonascii && enc != *encp) {
12621  mixed_escape(beg, enc, *encp);
12622  }
12623  continue;
12624  }
12625  else if (func & STR_FUNC_EXPAND) {
12626  pushback(c);
12627  if (func & STR_FUNC_ESCAPE) tokadd('\\');
12628  c = read_escape(0, &enc);
12629  }
12630  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12631  /* ignore backslashed spaces in %w */
12632  }
12633  else if (c != term && !(paren && c == paren)) {
12634  tokadd('\\');
12635  pushback(c);
12636  continue;
12637  }
12638  }
12639  }
12640  else if (!parser_isascii()) {
12641  non_ascii:
12642  has_nonascii = 1;
12643  if (enc != *encp) {
12644  mixed_error(enc, *encp);
12645  continue;
12646  }
12647  if (tokadd_mbchar(c) == -1) return -1;
12648  continue;
12649  }
12650  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12651  pushback(c);
12652  break;
12653  }
12654  if (c & 0x80) {
12655  has_nonascii = 1;
12656  if (enc != *encp) {
12657  mixed_error(enc, *encp);
12658  continue;
12659  }
12660  }
12661  tokadd(c);
12662  }
12663  *encp = enc;
12664  return c;
12665 }
12666 
12667 #define NEW_STRTERM(func, term, paren) \
12668  rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12669 
12670 #ifdef RIPPER
12671 static void
12672 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12673 {
12674  if (!NIL_P(parser->delayed)) {
12675  ptrdiff_t len = lex_p - parser->tokp;
12676  if (len > 0) {
12677  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12678  }
12679  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12680  parser->tokp = lex_p;
12681  }
12682 }
12683 
12684 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12685 #else
12686 #define flush_string_content(enc) ((void)(enc))
12687 #endif
12688 
12689 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12690 /* this can be shared with ripper, since it's independent from struct
12691  * parser_params. */
12692 #ifndef RIPPER
12693 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12694 #define SPECIAL_PUNCT(idx) ( \
12695  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12696  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12697  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12698  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12699  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12700  BIT('0', idx))
12701 const unsigned int ruby_global_name_punct_bits[] = {
12702  SPECIAL_PUNCT(0),
12703  SPECIAL_PUNCT(1),
12704  SPECIAL_PUNCT(2),
12705 };
12706 #undef BIT
12707 #undef SPECIAL_PUNCT
12708 #endif
12709 
12710 static inline int
12712 {
12713  if (c <= 0x20 || 0x7e < c) return 0;
12714  return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12715 }
12716 
12717 static int
12719 {
12720  int c;
12721  const char *p = lex_p;
12722 
12723  if (p + 1 >= lex_pend) return 0;
12724  c = *p++;
12725  switch (c) {
12726  case '$':
12727  if ((c = *p) == '-') {
12728  if (++p >= lex_pend) return 0;
12729  c = *p;
12730  }
12731  else if (is_global_name_punct(c) || ISDIGIT(c)) {
12732  return tSTRING_DVAR;
12733  }
12734  break;
12735  case '@':
12736  if ((c = *p) == '@') {
12737  if (++p >= lex_pend) return 0;
12738  c = *p;
12739  }
12740  break;
12741  case '{':
12742  lex_p = p;
12743  command_start = TRUE;
12744  return tSTRING_DBEG;
12745  default:
12746  return 0;
12747  }
12748  if (!ISASCII(c) || c == '_' || ISALPHA(c))
12749  return tSTRING_DVAR;
12750  return 0;
12751 }
12752 
12753 static int
12754 parser_parse_string(struct parser_params *parser, NODE *quote)
12755 {
12756  int func = (int)quote->nd_func;
12757  int term = nd_term(quote);
12758  int paren = nd_paren(quote);
12759  int c, space = 0;
12761 
12762  if (func == -1) return tSTRING_END;
12763  c = nextc();
12764  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12765  do {c = nextc();} while (ISSPACE(c));
12766  space = 1;
12767  }
12768  if (c == term && !quote->nd_nest) {
12769  if (func & STR_FUNC_QWORDS) {
12770  quote->nd_func = -1;
12771  return ' ';
12772  }
12773  if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12775  return tREGEXP_END;
12776  }
12777  if (space) {
12778  pushback(c);
12779  return ' ';
12780  }
12781  newtok();
12782  if ((func & STR_FUNC_EXPAND) && c == '#') {
12783  int t = parser_peek_variable_name(parser);
12784  if (t) return t;
12785  tokadd('#');
12786  c = nextc();
12787  }
12788  pushback(c);
12789  if (tokadd_string(func, term, paren, &quote->nd_nest,
12790  &enc) == -1) {
12791  ruby_sourceline = nd_line(quote);
12792  if (func & STR_FUNC_REGEXP) {
12793  if (parser->eofp)
12794  compile_error(PARSER_ARG "unterminated regexp meets end of file");
12795  return tREGEXP_END;
12796  }
12797  else {
12798  if (parser->eofp)
12799  compile_error(PARSER_ARG "unterminated string meets end of file");
12800  return tSTRING_END;
12801  }
12802  }
12803 
12804  tokfix();
12805  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12806  flush_string_content(enc);
12807 
12808  return tSTRING_CONTENT;
12809 }
12810 
12811 static int
12813 {
12814  int c = nextc(), term, func = 0;
12815  long len;
12816 
12817  if (c == '-') {
12818  c = nextc();
12819  func = STR_FUNC_INDENT;
12820  }
12821  switch (c) {
12822  case '\'':
12823  func |= str_squote; goto quoted;
12824  case '"':
12825  func |= str_dquote; goto quoted;
12826  case '`':
12827  func |= str_xquote;
12828  quoted:
12829  newtok();
12830  tokadd(func);
12831  term = c;
12832  while ((c = nextc()) != -1 && c != term) {
12833  if (tokadd_mbchar(c) == -1) return 0;
12834  }
12835  if (c == -1) {
12836  compile_error(PARSER_ARG "unterminated here document identifier");
12837  return 0;
12838  }
12839  break;
12840 
12841  default:
12842  if (!parser_is_identchar()) {
12843  pushback(c);
12844  if (func & STR_FUNC_INDENT) {
12845  pushback('-');
12846  }
12847  return 0;
12848  }
12849  newtok();
12850  term = '"';
12851  tokadd(func |= str_dquote);
12852  do {
12853  if (tokadd_mbchar(c) == -1) return 0;
12854  } while ((c = nextc()) != -1 && parser_is_identchar());
12855  pushback(c);
12856  break;
12857  }
12858 
12859  tokfix();
12860 #ifdef RIPPER
12861  ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12862 #endif
12863  len = lex_p - lex_pbeg;
12864  lex_goto_eol(parser);
12866  STR_NEW(tok(), toklen()), /* nd_lit */
12867  len, /* nd_nth */
12868  lex_lastline); /* nd_orig */
12870  ripper_flush(parser);
12871  return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12872 }
12873 
12874 static void
12876 {
12877  VALUE line;
12878 
12879  line = here->nd_orig;
12880  lex_lastline = line;
12881  lex_pbeg = RSTRING_PTR(line);
12882  lex_pend = lex_pbeg + RSTRING_LEN(line);
12883  lex_p = lex_pbeg + here->nd_nth;
12885  ruby_sourceline = nd_line(here);
12886  dispose_string(here->nd_lit);
12887  rb_gc_force_recycle((VALUE)here);
12888  ripper_flush(parser);
12889 }
12890 
12891 static int
12893  const char *eos, long len, int indent)
12894 {
12895  const char *p = lex_pbeg;
12896  long n;
12897 
12898  if (indent) {
12899  while (*p && ISSPACE(*p)) p++;
12900  }
12901  n = lex_pend - (p + len);
12902  if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12903  return strncmp(eos, p, len) == 0;
12904 }
12905 
12906 #ifdef RIPPER
12907 static void
12908 ripper_dispatch_heredoc_end(struct parser_params *parser)
12909 {
12910  if (!NIL_P(parser->delayed))
12911  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12912  lex_goto_eol(parser);
12913  ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12914 }
12915 
12916 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12917 #else
12918 #define dispatch_heredoc_end() ((void)0)
12919 #endif
12920 
12921 static int
12923 {
12924  int c, func, indent = 0;
12925  const char *eos, *p, *pend;
12926  long len;
12927  VALUE str = 0;
12929 
12930  eos = RSTRING_PTR(here->nd_lit);
12931  len = RSTRING_LEN(here->nd_lit) - 1;
12932  indent = (func = *eos++) & STR_FUNC_INDENT;
12933 
12934  if ((c = nextc()) == -1) {
12935  error:
12936  compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12937 #ifdef RIPPER
12938  if (NIL_P(parser->delayed)) {
12939  ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12940  }
12941  else {
12942  if (str ||
12943  ((len = lex_p - parser->tokp) > 0 &&
12944  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12945  rb_str_append(parser->delayed, str);
12946  }
12947  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12948  }
12949  lex_goto_eol(parser);
12950 #endif
12951  restore:
12953  lex_strterm = 0;
12954  return 0;
12955  }
12956  if (was_bol() && whole_match_p(eos, len, indent)) {
12959  return tSTRING_END;
12960  }
12961 
12962  if (!(func & STR_FUNC_EXPAND)) {
12963  do {
12965  pend = lex_pend;
12966  if (pend > p) {
12967  switch (pend[-1]) {
12968  case '\n':
12969  if (--pend == p || pend[-1] != '\r') {
12970  pend++;
12971  break;
12972  }
12973  case '\r':
12974  --pend;
12975  }
12976  }
12977  if (str)
12978  rb_str_cat(str, p, pend - p);
12979  else
12980  str = STR_NEW(p, pend - p);
12981  if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12982  lex_goto_eol(parser);
12983  if (nextc() == -1) {
12984  if (str) {
12985  dispose_string(str);
12986  str = 0;
12987  }
12988  goto error;
12989  }
12990  } while (!whole_match_p(eos, len, indent));
12991  }
12992  else {
12993  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12994  newtok();
12995  if (c == '#') {
12996  int t = parser_peek_variable_name(parser);
12997  if (t) return t;
12998  tokadd('#');
12999  c = nextc();
13000  }
13001  do {
13002  pushback(c);
13003  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
13004  if (parser->eofp) goto error;
13005  goto restore;
13006  }
13007  if (c != '\n') {
13008  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
13009  flush_string_content(enc);
13010  return tSTRING_CONTENT;
13011  }
13012  tokadd(nextc());
13013  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
13014  if ((c = nextc()) == -1) goto error;
13015  } while (!whole_match_p(eos, len, indent));
13016  str = STR_NEW3(tok(), toklen(), enc, func);
13017  }
13020  lex_strterm = NEW_STRTERM(-1, 0, 0);
13021  set_yylval_str(str);
13022  return tSTRING_CONTENT;
13023 }
13024 
13025 #include "lex.c"
13026 
13027 static void
13029 {
13030 #ifndef RIPPER
13031  rb_warning0("ambiguous first argument; put parentheses or even spaces");
13032 #else
13033  dispatch0(arg_ambiguous);
13034 #endif
13035 }
13036 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
13037 
13038 static ID
13040 {
13041 #ifndef RIPPER
13042  if (!is_local_id(lhs))
13043  yyerror("formal argument must be local variable");
13044 #endif
13045  shadowing_lvar(lhs);
13046  return lhs;
13047 }
13048 
13049 static int
13050 lvar_defined_gen(struct parser_params *parser, ID id)
13051 {
13052  return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
13053 }
13054 
13055 /* emacsen -*- hack */
13056 static long
13057 parser_encode_length(struct parser_params *parser, const char *name, long len)
13058 {
13059  long nlen;
13060 
13061  if (len > 5 && name[nlen = len - 5] == '-') {
13062  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
13063  return nlen;
13064  }
13065  if (len > 4 && name[nlen = len - 4] == '-') {
13066  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
13067  return nlen;
13068  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
13069  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
13070  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
13071  return nlen;
13072  }
13073  return len;
13074 }
13075 
13076 static void
13077 parser_set_encode(struct parser_params *parser, const char *name)
13078 {
13079  int idx = rb_enc_find_index(name);
13080  rb_encoding *enc;
13081  VALUE excargs[3];
13082 
13083  if (idx < 0) {
13084  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
13085  error:
13086  excargs[0] = rb_eArgError;
13087  excargs[2] = rb_make_backtrace();
13088  rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
13089  rb_exc_raise(rb_make_exception(3, excargs));
13090  }
13091  enc = rb_enc_from_index(idx);
13092  if (!rb_enc_asciicompat(enc)) {
13093  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13094  goto error;
13095  }
13096  parser->enc = enc;
13097 #ifndef RIPPER
13098  if (ruby_debug_lines) {
13099  long i, n = RARRAY_LEN(ruby_debug_lines);
13100  const VALUE *p = RARRAY_PTR(ruby_debug_lines);
13101  for (i = 0; i < n; ++i) {
13102  rb_enc_associate_index(*p, idx);
13103  }
13104  }
13105 #endif
13106 }
13107 
13108 static int
13110 {
13111  const char *p = lex_pbeg, *pend = lex_p - 1;
13112  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13113  while (p < pend) {
13114  if (!ISSPACE(*p)) return 0;
13115  p++;
13116  }
13117  return 1;
13118 }
13119 
13120 #ifndef RIPPER
13121 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13122 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13123 
13124 static void
13125 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13126 {
13127  if (!comment_at_top(parser)) {
13128  return;
13129  }
13130  parser_set_encode(parser, val);
13131 }
13132 
13133 static void
13134 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13135 {
13136  int *p = &parser->parser_token_info_enabled;
13137 
13138  switch (*val) {
13139  case 't': case 'T':
13140  if (strcasecmp(val, "true") == 0) {
13141  *p = TRUE;
13142  return;
13143  }
13144  break;
13145  case 'f': case 'F':
13146  if (strcasecmp(val, "false") == 0) {
13147  *p = FALSE;
13148  return;
13149  }
13150  break;
13151  }
13152  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13153 }
13154 
13156  const char *name;
13159 };
13160 
13161 static const struct magic_comment magic_comments[] = {
13164  {"warn_indent", parser_set_token_info},
13165 };
13166 #endif
13167 
13168 static const char *
13169 magic_comment_marker(const char *str, long len)
13170 {
13171  long i = 2;
13172 
13173  while (i < len) {
13174  switch (str[i]) {
13175  case '-':
13176  if (str[i-1] == '*' && str[i-2] == '-') {
13177  return str + i + 1;
13178  }
13179  i += 2;
13180  break;
13181  case '*':
13182  if (i + 1 >= len) return 0;
13183  if (str[i+1] != '-') {
13184  i += 4;
13185  }
13186  else if (str[i-1] != '-') {
13187  i += 2;
13188  }
13189  else {
13190  return str + i + 2;
13191  }
13192  break;
13193  default:
13194  i += 3;
13195  break;
13196  }
13197  }
13198  return 0;
13199 }
13200 
13201 static int
13202 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13203 {
13204  VALUE name = 0, val = 0;
13205  const char *beg, *end, *vbeg, *vend;
13206 #define str_copy(_s, _p, _n) ((_s) \
13207  ? (void)(rb_str_resize((_s), (_n)), \
13208  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13209  : (void)((_s) = STR_NEW((_p), (_n))))
13210 
13211  if (len <= 7) return FALSE;
13212  if (!(beg = magic_comment_marker(str, len))) return FALSE;
13213  if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13214  str = beg;
13215  len = end - beg - 3;
13216 
13217  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13218  while (len > 0) {
13219 #ifndef RIPPER
13220  const struct magic_comment *p = magic_comments;
13221 #endif
13222  char *s;
13223  int i;
13224  long n = 0;
13225 
13226  for (; len > 0 && *str; str++, --len) {
13227  switch (*str) {
13228  case '\'': case '"': case ':': case ';':
13229  continue;
13230  }
13231  if (!ISSPACE(*str)) break;
13232  }
13233  for (beg = str; len > 0; str++, --len) {
13234  switch (*str) {
13235  case '\'': case '"': case ':': case ';':
13236  break;
13237  default:
13238  if (ISSPACE(*str)) break;
13239  continue;
13240  }
13241  break;
13242  }
13243  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13244  if (!len) break;
13245  if (*str != ':') continue;
13246 
13247  do str++; while (--len > 0 && ISSPACE(*str));
13248  if (!len) break;
13249  if (*str == '"') {
13250  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13251  if (*str == '\\') {
13252  --len;
13253  ++str;
13254  }
13255  }
13256  vend = str;
13257  if (len) {
13258  --len;
13259  ++str;
13260  }
13261  }
13262  else {
13263  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13264  vend = str;
13265  }
13266  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13267 
13268  n = end - beg;
13269  str_copy(name, beg, n);
13270  s = RSTRING_PTR(name);
13271  for (i = 0; i < n; ++i) {
13272  if (s[i] == '-') s[i] = '_';
13273  }
13274 #ifndef RIPPER
13275  do {
13276  if (STRNCASECMP(p->name, s, n) == 0) {
13277  n = vend - vbeg;
13278  if (p->length) {
13279  n = (*p->length)(parser, vbeg, n);
13280  }
13281  str_copy(val, vbeg, n);
13282  (*p->func)(parser, s, RSTRING_PTR(val));
13283  break;
13284  }
13285  } while (++p < magic_comments + numberof(magic_comments));
13286 #else
13287  str_copy(val, vbeg, vend - vbeg);
13288  dispatch2(magic_comment, name, val);
13289 #endif
13290  }
13291 
13292  return TRUE;
13293 }
13294 
13295 static void
13296 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13297 {
13298  int sep = 0;
13299  const char *beg = str;
13300  VALUE s;
13301 
13302  for (;;) {
13303  if (send - str <= 6) return;
13304  switch (str[6]) {
13305  case 'C': case 'c': str += 6; continue;
13306  case 'O': case 'o': str += 5; continue;
13307  case 'D': case 'd': str += 4; continue;
13308  case 'I': case 'i': str += 3; continue;
13309  case 'N': case 'n': str += 2; continue;
13310  case 'G': case 'g': str += 1; continue;
13311  case '=': case ':':
13312  sep = 1;
13313  str += 6;
13314  break;
13315  default:
13316  str += 6;
13317  if (ISSPACE(*str)) break;
13318  continue;
13319  }
13320  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13321  }
13322  for (;;) {
13323  do {
13324  if (++str >= send) return;
13325  } while (ISSPACE(*str));
13326  if (sep) break;
13327  if (*str != '=' && *str != ':') return;
13328  sep = 1;
13329  str++;
13330  }
13331  beg = str;
13332  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13333  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13334  parser_set_encode(parser, RSTRING_PTR(s));
13335  rb_str_resize(s, 0);
13336 }
13337 
13338 static void
13340 {
13341  int c = nextc();
13342  switch (c) {
13343  case '#':
13344  if (peek('!')) parser->has_shebang = 1;
13345  break;
13346  case 0xef: /* UTF-8 BOM marker */
13347  if (lex_pend - lex_p >= 2 &&
13348  (unsigned char)lex_p[0] == 0xbb &&
13349  (unsigned char)lex_p[1] == 0xbf) {
13350  parser->enc = rb_utf8_encoding();
13351  lex_p += 2;
13352  lex_pbeg = lex_p;
13353  return;
13354  }
13355  break;
13356  case EOF:
13357  return;
13358  }
13359  pushback(c);
13360  parser->enc = rb_enc_get(lex_lastline);
13361 }
13362 
13363 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13364 #define IS_END() IS_lex_state(EXPR_END_ANY)
13365 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13366 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13367 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13368 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13369 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13370 
13371 #ifndef RIPPER
13372 #define ambiguous_operator(op, syn) ( \
13373  rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
13374  rb_warning0("even though it seems like "syn""))
13375 #else
13376 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13377 #endif
13378 #define warn_balanced(op, syn) ((void) \
13379  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13380  space_seen && !ISSPACE(c) && \
13381  (ambiguous_operator(op, syn), 0)))
13382 
13383 static int
13385 {
13386  register int c;
13387  int space_seen = 0;
13388  int cmd_state;
13389  enum lex_state_e last_state;
13390  rb_encoding *enc;
13391  int mb;
13392 #ifdef RIPPER
13393  int fallthru = FALSE;
13394 #endif
13395 
13396  if (lex_strterm) {
13397  int token;
13398  if (nd_type(lex_strterm) == NODE_HEREDOC) {
13399  token = here_document(lex_strterm);
13400  if (token == tSTRING_END) {
13401  lex_strterm = 0;
13402  lex_state = EXPR_END;
13403  }
13404  }
13405  else {
13406  token = parse_string(lex_strterm);
13407  if (token == tSTRING_END || token == tREGEXP_END) {
13409  lex_strterm = 0;
13410  lex_state = EXPR_END;
13411  }
13412  }
13413  return token;
13414  }
13415  cmd_state = command_start;
13416  command_start = FALSE;
13417  retry:
13418  last_state = lex_state;
13419  switch (c = nextc()) {
13420  case '\0': /* NUL */
13421  case '\004': /* ^D */
13422  case '\032': /* ^Z */
13423  case -1: /* end of script. */
13424  return 0;
13425 
13426  /* white spaces */
13427  case ' ': case '\t': case '\f': case '\r':
13428  case '\13': /* '\v' */
13429  space_seen = 1;
13430 #ifdef RIPPER
13431  while ((c = nextc())) {
13432  switch (c) {
13433  case ' ': case '\t': case '\f': case '\r':
13434  case '\13': /* '\v' */
13435  break;
13436  default:
13437  goto outofloop;
13438  }
13439  }
13440  outofloop:
13441  pushback(c);
13442  ripper_dispatch_scan_event(parser, tSP);
13443 #endif
13444  goto retry;
13445 
13446  case '#': /* it's a comment */
13447  /* no magic_comment in shebang line */
13448  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13449  if (comment_at_top(parser)) {
13450  set_file_encoding(parser, lex_p, lex_pend);
13451  }
13452  }
13453  lex_p = lex_pend;
13454 #ifdef RIPPER
13455  ripper_dispatch_scan_event(parser, tCOMMENT);
13456  fallthru = TRUE;
13457 #endif
13458  /* fall through */
13459  case '\n':
13460  if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT)) {
13461 #ifdef RIPPER
13462  if (!fallthru) {
13463  ripper_dispatch_scan_event(parser, tIGNORED_NL);
13464  }
13465  fallthru = FALSE;
13466 #endif
13467  goto retry;
13468  }
13469  while ((c = nextc())) {
13470  switch (c) {
13471  case ' ': case '\t': case '\f': case '\r':
13472  case '\13': /* '\v' */
13473  space_seen = 1;
13474  break;
13475  case '.': {
13476  if ((c = nextc()) != '.') {
13477  pushback(c);
13478  pushback('.');
13479  goto retry;
13480  }
13481  }
13482  default:
13483  --ruby_sourceline;
13485  case -1: /* EOF no decrement*/
13486  lex_goto_eol(parser);
13487 #ifdef RIPPER
13488  if (c != -1) {
13489  parser->tokp = lex_p;
13490  }
13491 #endif
13492  goto normal_newline;
13493  }
13494  }
13495  normal_newline:
13496  command_start = TRUE;
13497  lex_state = EXPR_BEG;
13498  return '\n';
13499 
13500  case '*':
13501  if ((c = nextc()) == '*') {
13502  if ((c = nextc()) == '=') {
13504  lex_state = EXPR_BEG;
13505  return tOP_ASGN;
13506  }
13507  pushback(c);
13508  if (IS_SPCARG(c)) {
13509  rb_warning0("`**' interpreted as argument prefix");
13510  c = tDSTAR;
13511  }
13512  else if (IS_BEG()) {
13513  c = tDSTAR;
13514  }
13515  else {
13516  warn_balanced("**", "argument prefix");
13517  c = tPOW;
13518  }
13519  }
13520  else {
13521  if (c == '=') {
13522  set_yylval_id('*');
13523  lex_state = EXPR_BEG;
13524  return tOP_ASGN;
13525  }
13526  pushback(c);
13527  if (IS_SPCARG(c)) {
13528  rb_warning0("`*' interpreted as argument prefix");
13529  c = tSTAR;
13530  }
13531  else if (IS_BEG()) {
13532  c = tSTAR;
13533  }
13534  else {
13535  warn_balanced("*", "argument prefix");
13536  c = '*';
13537  }
13538  }
13539  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13540  return c;
13541 
13542  case '!':
13543  c = nextc();
13544  if (IS_AFTER_OPERATOR()) {
13545  lex_state = EXPR_ARG;
13546  if (c == '@') {
13547  return '!';
13548  }
13549  }
13550  else {
13551  lex_state = EXPR_BEG;
13552  }
13553  if (c == '=') {
13554  return tNEQ;
13555  }
13556  if (c == '~') {
13557  return tNMATCH;
13558  }
13559  pushback(c);
13560  return '!';
13561 
13562  case '=':
13563  if (was_bol()) {
13564  /* skip embedded rd document */
13565  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13566 #ifdef RIPPER
13567  int first_p = TRUE;
13568 
13569  lex_goto_eol(parser);
13570  ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13571 #endif
13572  for (;;) {
13573  lex_goto_eol(parser);
13574 #ifdef RIPPER
13575  if (!first_p) {
13576  ripper_dispatch_scan_event(parser, tEMBDOC);
13577  }
13578  first_p = FALSE;
13579 #endif
13580  c = nextc();
13581  if (c == -1) {
13582  compile_error(PARSER_ARG "embedded document meets end of file");
13583  return 0;
13584  }
13585  if (c != '=') continue;
13586  if (strncmp(lex_p, "end", 3) == 0 &&
13587  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13588  break;
13589  }
13590  }
13591  lex_goto_eol(parser);
13592 #ifdef RIPPER
13593  ripper_dispatch_scan_event(parser, tEMBDOC_END);
13594 #endif
13595  goto retry;
13596  }
13597  }
13598 
13599  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13600  if ((c = nextc()) == '=') {
13601  if ((c = nextc()) == '=') {
13602  return tEQQ;
13603  }
13604  pushback(c);
13605  return tEQ;
13606  }
13607  if (c == '~') {
13608  return tMATCH;
13609  }
13610  else if (c == '>') {
13611  return tASSOC;
13612  }
13613  pushback(c);
13614  return '=';
13615 
13616  case '<':
13617  last_state = lex_state;
13618  c = nextc();
13619  if (c == '<' &&
13620  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13621  !IS_END() &&
13622  (!IS_ARG() || space_seen)) {
13623  int token = heredoc_identifier();
13624  if (token) return token;
13625  }
13626  if (IS_AFTER_OPERATOR()) {
13627  lex_state = EXPR_ARG;
13628  }
13629  else {
13630  if (IS_lex_state(EXPR_CLASS))
13631  command_start = TRUE;
13632  lex_state = EXPR_BEG;
13633  }
13634  if (c == '=') {
13635  if ((c = nextc()) == '>') {
13636  return tCMP;
13637  }
13638  pushback(c);
13639  return tLEQ;
13640  }
13641  if (c == '<') {
13642  if ((c = nextc()) == '=') {
13644  lex_state = EXPR_BEG;
13645  return tOP_ASGN;
13646  }
13647  pushback(c);
13648  warn_balanced("<<", "here document");
13649  return tLSHFT;
13650  }
13651  pushback(c);
13652  return '<';
13653 
13654  case '>':
13655  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13656  if ((c = nextc()) == '=') {
13657  return tGEQ;
13658  }
13659  if (c == '>') {
13660  if ((c = nextc()) == '=') {
13662  lex_state = EXPR_BEG;
13663  return tOP_ASGN;
13664  }
13665  pushback(c);
13666  return tRSHFT;
13667  }
13668  pushback(c);
13669  return '>';
13670 
13671  case '"':
13672  lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13673  return tSTRING_BEG;
13674 
13675  case '`':
13676  if (IS_lex_state(EXPR_FNAME)) {
13677  lex_state = EXPR_ENDFN;
13678  return c;
13679  }
13680  if (IS_lex_state(EXPR_DOT)) {
13681  if (cmd_state)
13682  lex_state = EXPR_CMDARG;
13683  else
13684  lex_state = EXPR_ARG;
13685  return c;
13686  }
13687  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13688  return tXSTRING_BEG;
13689 
13690  case '\'':
13691  lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13692  return tSTRING_BEG;
13693 
13694  case '?':
13695  if (IS_END()) {
13696  lex_state = EXPR_VALUE;
13697  return '?';
13698  }
13699  c = nextc();
13700  if (c == -1) {
13701  compile_error(PARSER_ARG "incomplete character syntax");
13702  return 0;
13703  }
13704  if (rb_enc_isspace(c, current_enc)) {
13705  if (!IS_ARG()) {
13706  int c2 = 0;
13707  switch (c) {
13708  case ' ':
13709  c2 = 's';
13710  break;
13711  case '\n':
13712  c2 = 'n';
13713  break;
13714  case '\t':
13715  c2 = 't';
13716  break;
13717  case '\v':
13718  c2 = 'v';
13719  break;
13720  case '\r':
13721  c2 = 'r';
13722  break;
13723  case '\f':
13724  c2 = 'f';
13725  break;
13726  }
13727  if (c2) {
13728  rb_warnI("invalid character syntax; use ?\\%c", c2);
13729  }
13730  }
13731  ternary:
13732  pushback(c);
13733  lex_state = EXPR_VALUE;
13734  return '?';
13735  }
13736  newtok();
13737  enc = current_enc;
13738  if (!parser_isascii()) {
13739  if (tokadd_mbchar(c) == -1) return 0;
13740  }
13741  else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13743  goto ternary;
13744  }
13745  else if (c == '\\') {
13746  if (peek('u')) {
13747  nextc();
13748  c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13749  if (0x80 <= c) {
13750  tokaddmbc(c, enc);
13751  }
13752  else {
13753  tokadd(c);
13754  }
13755  }
13756  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13757  nextc();
13758  if (tokadd_mbchar(c) == -1) return 0;
13759  }
13760  else {
13761  c = read_escape(0, &enc);
13762  tokadd(c);
13763  }
13764  }
13765  else {
13766  tokadd(c);
13767  }
13768  tokfix();
13769  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13770  lex_state = EXPR_END;
13771  return tCHAR;
13772 
13773  case '&':
13774  if ((c = nextc()) == '&') {
13775  lex_state = EXPR_BEG;
13776  if ((c = nextc()) == '=') {
13778  lex_state = EXPR_BEG;
13779  return tOP_ASGN;
13780  }
13781  pushback(c);
13782  return tANDOP;
13783  }
13784  else if (c == '=') {
13785  set_yylval_id('&');
13786  lex_state = EXPR_BEG;
13787  return tOP_ASGN;
13788  }
13789  pushback(c);
13790  if (IS_SPCARG(c)) {
13791  rb_warning0("`&' interpreted as argument prefix");
13792  c = tAMPER;
13793  }
13794  else if (IS_BEG()) {
13795  c = tAMPER;
13796  }
13797  else {
13798  warn_balanced("&", "argument prefix");
13799  c = '&';
13800  }
13801  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13802  return c;
13803 
13804  case '|':
13805  if ((c = nextc()) == '|') {
13806  lex_state = EXPR_BEG;
13807  if ((c = nextc()) == '=') {
13809  lex_state = EXPR_BEG;
13810  return tOP_ASGN;
13811  }
13812  pushback(c);
13813  return tOROP;
13814  }
13815  if (c == '=') {
13816  set_yylval_id('|');
13817  lex_state = EXPR_BEG;
13818  return tOP_ASGN;
13819  }
13820  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13821  pushback(c);
13822  return '|';
13823 
13824  case '+':
13825  c = nextc();
13826  if (IS_AFTER_OPERATOR()) {
13827  lex_state = EXPR_ARG;
13828  if (c == '@') {
13829  return tUPLUS;
13830  }
13831  pushback(c);
13832  return '+';
13833  }
13834  if (c == '=') {
13835  set_yylval_id('+');
13836  lex_state = EXPR_BEG;
13837  return tOP_ASGN;
13838  }
13839  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13840  lex_state = EXPR_BEG;
13841  pushback(c);
13842  if (c != -1 && ISDIGIT(c)) {
13843  c = '+';
13844  goto start_num;
13845  }
13846  return tUPLUS;
13847  }
13848  lex_state = EXPR_BEG;
13849  pushback(c);
13850  warn_balanced("+", "unary operator");
13851  return '+';
13852 
13853  case '-':
13854  c = nextc();
13855  if (IS_AFTER_OPERATOR()) {
13856  lex_state = EXPR_ARG;
13857  if (c == '@') {
13858  return tUMINUS;
13859  }
13860  pushback(c);
13861  return '-';
13862  }
13863  if (c == '=') {
13864  set_yylval_id('-');
13865  lex_state = EXPR_BEG;
13866  return tOP_ASGN;
13867  }
13868  if (c == '>') {
13869  lex_state = EXPR_ENDFN;
13870  return tLAMBDA;
13871  }
13872  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13873  lex_state = EXPR_BEG;
13874  pushback(c);
13875  if (c != -1 && ISDIGIT(c)) {
13876  return tUMINUS_NUM;
13877  }
13878  return tUMINUS;
13879  }
13880  lex_state = EXPR_BEG;
13881  pushback(c);
13882  warn_balanced("-", "unary operator");
13883  return '-';
13884 
13885  case '.':
13886  lex_state = EXPR_BEG;
13887  if ((c = nextc()) == '.') {
13888  if ((c = nextc()) == '.') {
13889  return tDOT3;
13890  }
13891  pushback(c);
13892  return tDOT2;
13893  }
13894  pushback(c);
13895  if (c != -1 && ISDIGIT(c)) {
13896  yyerror("no .<digit> floating literal anymore; put 0 before dot");
13897  }
13898  lex_state = EXPR_DOT;
13899  return '.';
13900 
13901  start_num:
13902  case '0': case '1': case '2': case '3': case '4':
13903  case '5': case '6': case '7': case '8': case '9':
13904  {
13905  int is_float, seen_point, seen_e, nondigit;
13906 
13907  is_float = seen_point = seen_e = nondigit = 0;
13908  lex_state = EXPR_END;
13909  newtok();
13910  if (c == '-' || c == '+') {
13911  tokadd(c);
13912  c = nextc();
13913  }
13914  if (c == '0') {
13915 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13916  int start = toklen();
13917  c = nextc();
13918  if (c == 'x' || c == 'X') {
13919  /* hexadecimal */
13920  c = nextc();
13921  if (c != -1 && ISXDIGIT(c)) {
13922  do {
13923  if (c == '_') {
13924  if (nondigit) break;
13925  nondigit = c;
13926  continue;
13927  }
13928  if (!ISXDIGIT(c)) break;
13929  nondigit = 0;
13930  tokadd(c);
13931  } while ((c = nextc()) != -1);
13932  }
13933  pushback(c);
13934  tokfix();
13935  if (toklen() == start) {
13936  no_digits();
13937  }
13938  else if (nondigit) goto trailing_uc;
13940  return tINTEGER;
13941  }
13942  if (c == 'b' || c == 'B') {
13943  /* binary */
13944  c = nextc();
13945  if (c == '0' || c == '1') {
13946  do {
13947  if (c == '_') {
13948  if (nondigit) break;
13949  nondigit = c;
13950  continue;
13951  }
13952  if (c != '0' && c != '1') break;
13953  nondigit = 0;
13954  tokadd(c);
13955  } while ((c = nextc()) != -1);
13956  }
13957  pushback(c);
13958  tokfix();
13959  if (toklen() == start) {
13960  no_digits();
13961  }
13962  else if (nondigit) goto trailing_uc;
13964  return tINTEGER;
13965  }
13966  if (c == 'd' || c == 'D') {
13967  /* decimal */
13968  c = nextc();
13969  if (c != -1 && ISDIGIT(c)) {
13970  do {
13971  if (c == '_') {
13972  if (nondigit) break;
13973  nondigit = c;
13974  continue;
13975  }
13976  if (!ISDIGIT(c)) break;
13977  nondigit = 0;
13978  tokadd(c);
13979  } while ((c = nextc()) != -1);
13980  }
13981  pushback(c);
13982  tokfix();
13983  if (toklen() == start) {
13984  no_digits();
13985  }
13986  else if (nondigit) goto trailing_uc;
13988  return tINTEGER;
13989  }
13990  if (c == '_') {
13991  /* 0_0 */
13992  goto octal_number;
13993  }
13994  if (c == 'o' || c == 'O') {
13995  /* prefixed octal */
13996  c = nextc();
13997  if (c == -1 || c == '_' || !ISDIGIT(c)) {
13998  no_digits();
13999  }
14000  }
14001  if (c >= '0' && c <= '7') {
14002  /* octal */
14003  octal_number:
14004  do {
14005  if (c == '_') {
14006  if (nondigit) break;
14007  nondigit = c;
14008  continue;
14009  }
14010  if (c < '0' || c > '9') break;
14011  if (c > '7') goto invalid_octal;
14012  nondigit = 0;
14013  tokadd(c);
14014  } while ((c = nextc()) != -1);
14015  if (toklen() > start) {
14016  pushback(c);
14017  tokfix();
14018  if (nondigit) goto trailing_uc;
14020  return tINTEGER;
14021  }
14022  if (nondigit) {
14023  pushback(c);
14024  goto trailing_uc;
14025  }
14026  }
14027  if (c > '7' && c <= '9') {
14028  invalid_octal:
14029  yyerror("Invalid octal digit");
14030  }
14031  else if (c == '.' || c == 'e' || c == 'E') {
14032  tokadd('0');
14033  }
14034  else {
14035  pushback(c);
14037  return tINTEGER;
14038  }
14039  }
14040 
14041  for (;;) {
14042  switch (c) {
14043  case '0': case '1': case '2': case '3': case '4':
14044  case '5': case '6': case '7': case '8': case '9':
14045  nondigit = 0;
14046  tokadd(c);
14047  break;
14048 
14049  case '.':
14050  if (nondigit) goto trailing_uc;
14051  if (seen_point || seen_e) {
14052  goto decode_num;
14053  }
14054  else {
14055  int c0 = nextc();
14056  if (c0 == -1 || !ISDIGIT(c0)) {
14057  pushback(c0);
14058  goto decode_num;
14059  }
14060  c = c0;
14061  }
14062  tokadd('.');
14063  tokadd(c);
14064  is_float++;
14065  seen_point++;
14066  nondigit = 0;
14067  break;
14068 
14069  case 'e':
14070  case 'E':
14071  if (nondigit) {
14072  pushback(c);
14073  c = nondigit;
14074  goto decode_num;
14075  }
14076  if (seen_e) {
14077  goto decode_num;
14078  }
14079  tokadd(c);
14080  seen_e++;
14081  is_float++;
14082  nondigit = c;
14083  c = nextc();
14084  if (c != '-' && c != '+') continue;
14085  tokadd(c);
14086  nondigit = c;
14087  break;
14088 
14089  case '_': /* `_' in number just ignored */
14090  if (nondigit) goto decode_num;
14091  nondigit = c;
14092  break;
14093 
14094  default:
14095  goto decode_num;
14096  }
14097  c = nextc();
14098  }
14099 
14100  decode_num:
14101  pushback(c);
14102  if (nondigit) {
14103  char tmp[30];
14104  trailing_uc:
14105  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14106  yyerror(tmp);
14107  }
14108  tokfix();
14109  if (is_float) {
14110  double d = strtod(tok(), 0);
14111  if (errno == ERANGE) {
14112  rb_warningS("Float %s out of range", tok());
14113  errno = 0;
14114  }
14116  return tFLOAT;
14117  }
14119  return tINTEGER;
14120  }
14121 
14122  case ')':
14123  case ']':
14124  paren_nest--;
14125  case '}':
14126  COND_LEXPOP();
14127  CMDARG_LEXPOP();
14128  if (c == ')')
14129  lex_state = EXPR_ENDFN;
14130  else
14131  lex_state = EXPR_ENDARG;
14132  if (c == '}') {
14133  if (!brace_nest--) c = tSTRING_DEND;
14134  }
14135  return c;
14136 
14137  case ':':
14138  c = nextc();
14139  if (c == ':') {
14140  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14141  lex_state = EXPR_BEG;
14142  return tCOLON3;
14143  }
14144  lex_state = EXPR_DOT;
14145  return tCOLON2;
14146  }
14147  if (IS_END() || ISSPACE(c)) {
14148  pushback(c);
14149  warn_balanced(":", "symbol literal");
14150  lex_state = EXPR_BEG;
14151  return ':';
14152  }
14153  switch (c) {
14154  case '\'':
14155  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14156  break;
14157  case '"':
14158  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14159  break;
14160  default:
14161  pushback(c);
14162  break;
14163  }
14164  lex_state = EXPR_FNAME;
14165  return tSYMBEG;
14166 
14167  case '/':
14168  if (IS_lex_state(EXPR_BEG_ANY)) {
14169  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14170  return tREGEXP_BEG;
14171  }
14172  if ((c = nextc()) == '=') {
14173  set_yylval_id('/');
14174  lex_state = EXPR_BEG;
14175  return tOP_ASGN;
14176  }
14177  pushback(c);
14178  if (IS_SPCARG(c)) {
14179  (void)arg_ambiguous();
14180  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14181  return tREGEXP_BEG;
14182  }
14183  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14184  warn_balanced("/", "regexp literal");
14185  return '/';
14186 
14187  case '^':
14188  if ((c = nextc()) == '=') {
14189  set_yylval_id('^');
14190  lex_state = EXPR_BEG;
14191  return tOP_ASGN;
14192  }
14193  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14194  pushback(c);
14195  return '^';
14196 
14197  case ';':
14198  lex_state = EXPR_BEG;
14199  command_start = TRUE;
14200  return ';';
14201 
14202  case ',':
14203  lex_state = EXPR_BEG;
14204  return ',';
14205 
14206  case '~':
14207  if (IS_AFTER_OPERATOR()) {
14208  if ((c = nextc()) != '@') {
14209  pushback(c);
14210  }
14211  lex_state = EXPR_ARG;
14212  }
14213  else {
14214  lex_state = EXPR_BEG;
14215  }
14216  return '~';
14217 
14218  case '(':
14219  if (IS_BEG()) {
14220  c = tLPAREN;
14221  }
14222  else if (IS_SPCARG(-1)) {
14223  c = tLPAREN_ARG;
14224  }
14225  paren_nest++;
14226  COND_PUSH(0);
14227  CMDARG_PUSH(0);
14228  lex_state = EXPR_BEG;
14229  return c;
14230 
14231  case '[':
14232  paren_nest++;
14233  if (IS_AFTER_OPERATOR()) {
14234  lex_state = EXPR_ARG;
14235  if ((c = nextc()) == ']') {
14236  if ((c = nextc()) == '=') {
14237  return tASET;
14238  }
14239  pushback(c);
14240  return tAREF;
14241  }
14242  pushback(c);
14243  return '[';
14244  }
14245  else if (IS_BEG()) {
14246  c = tLBRACK;
14247  }
14248  else if (IS_ARG() && space_seen) {
14249  c = tLBRACK;
14250  }
14251  lex_state = EXPR_BEG;
14252  COND_PUSH(0);
14253  CMDARG_PUSH(0);
14254  return c;
14255 
14256  case '{':
14257  ++brace_nest;
14258  if (lpar_beg && lpar_beg == paren_nest) {
14259  lex_state = EXPR_BEG;
14260  lpar_beg = 0;
14261  --paren_nest;
14262  COND_PUSH(0);
14263  CMDARG_PUSH(0);
14264  return tLAMBEG;
14265  }
14266  if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14267  c = '{'; /* block (primary) */
14268  else if (IS_lex_state(EXPR_ENDARG))
14269  c = tLBRACE_ARG; /* block (expr) */
14270  else
14271  c = tLBRACE; /* hash */
14272  COND_PUSH(0);
14273  CMDARG_PUSH(0);
14274  lex_state = EXPR_BEG;
14275  if (c != tLBRACE) command_start = TRUE;
14276  return c;
14277 
14278  case '\\':
14279  c = nextc();
14280  if (c == '\n') {
14281  space_seen = 1;
14282 #ifdef RIPPER
14283  ripper_dispatch_scan_event(parser, tSP);
14284 #endif
14285  goto retry; /* skip \\n */
14286  }
14287  pushback(c);
14288  return '\\';
14289 
14290  case '%':
14291  if (IS_lex_state(EXPR_BEG_ANY)) {
14292  int term;
14293  int paren;
14294 
14295  c = nextc();
14296  quotation:
14297  if (c == -1 || !ISALNUM(c)) {
14298  term = c;
14299  c = 'Q';
14300  }
14301  else {
14302  term = nextc();
14303  if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14304  yyerror("unknown type of %string");
14305  return 0;
14306  }
14307  }
14308  if (c == -1 || term == -1) {
14309  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14310  return 0;
14311  }
14312  paren = term;
14313  if (term == '(') term = ')';
14314  else if (term == '[') term = ']';
14315  else if (term == '{') term = '}';
14316  else if (term == '<') term = '>';
14317  else paren = 0;
14318 
14319  switch (c) {
14320  case 'Q':
14321  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14322  return tSTRING_BEG;
14323 
14324  case 'q':
14325  lex_strterm = NEW_STRTERM(str_squote, term, paren);
14326  return tSTRING_BEG;
14327 
14328  case 'W':
14329  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14330  do {c = nextc();} while (ISSPACE(c));
14331  pushback(c);
14332  return tWORDS_BEG;
14333 
14334  case 'w':
14335  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14336  do {c = nextc();} while (ISSPACE(c));
14337  pushback(c);
14338  return tQWORDS_BEG;
14339 
14340  case 'I':
14341  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14342  do {c = nextc();} while (ISSPACE(c));
14343  pushback(c);
14344  return tSYMBOLS_BEG;
14345 
14346  case 'i':
14347  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14348  do {c = nextc();} while (ISSPACE(c));
14349  pushback(c);
14350  return tQSYMBOLS_BEG;
14351 
14352  case 'x':
14353  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14354  return tXSTRING_BEG;
14355 
14356  case 'r':
14357  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14358  return tREGEXP_BEG;
14359 
14360  case 's':
14361  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14362  lex_state = EXPR_FNAME;
14363  return tSYMBEG;
14364 
14365  default:
14366  yyerror("unknown type of %string");
14367  return 0;
14368  }
14369  }
14370  if ((c = nextc()) == '=') {
14371  set_yylval_id('%');
14372  lex_state = EXPR_BEG;
14373  return tOP_ASGN;
14374  }
14375  if (IS_SPCARG(c)) {
14376  goto quotation;
14377  }
14378  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14379  pushback(c);
14380  warn_balanced("%%", "string literal");
14381  return '%';
14382 
14383  case '$':
14384  lex_state = EXPR_END;
14385  newtok();
14386  c = nextc();
14387  switch (c) {
14388  case '_': /* $_: last read line string */
14389  c = nextc();
14390  if (parser_is_identchar()) {
14391  tokadd('$');
14392  tokadd('_');
14393  break;
14394  }
14395  pushback(c);
14396  c = '_';
14397  /* fall through */
14398  case '~': /* $~: match-data */
14399  case '*': /* $*: argv */
14400  case '$': /* $$: pid */
14401  case '?': /* $?: last status */
14402  case '!': /* $!: error string */
14403  case '@': /* $@: error position */
14404  case '/': /* $/: input record separator */
14405  case '\\': /* $\: output record separator */
14406  case ';': /* $;: field separator */
14407  case ',': /* $,: output field separator */
14408  case '.': /* $.: last read line number */
14409  case '=': /* $=: ignorecase */
14410  case ':': /* $:: load path */
14411  case '<': /* $<: reading filename */
14412  case '>': /* $>: default output handle */
14413  case '\"': /* $": already loaded files */
14414  tokadd('$');
14415  tokadd(c);
14416  tokfix();
14418  return tGVAR;
14419 
14420  case '-':
14421  tokadd('$');
14422  tokadd(c);
14423  c = nextc();
14424  if (parser_is_identchar()) {
14425  if (tokadd_mbchar(c) == -1) return 0;
14426  }
14427  else {
14428  pushback(c);
14429  }
14430  gvar:
14431  tokfix();
14433  return tGVAR;
14434 
14435  case '&': /* $&: last match */
14436  case '`': /* $`: string before last match */
14437  case '\'': /* $': string after last match */
14438  case '+': /* $+: string matches last paren. */
14439  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14440  tokadd('$');
14441  tokadd(c);
14442  goto gvar;
14443  }
14445  return tBACK_REF;
14446 
14447  case '1': case '2': case '3':
14448  case '4': case '5': case '6':
14449  case '7': case '8': case '9':
14450  tokadd('$');
14451  do {
14452  tokadd(c);
14453  c = nextc();
14454  } while (c != -1 && ISDIGIT(c));
14455  pushback(c);
14456  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14457  tokfix();
14458  set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
14459  return tNTH_REF;
14460 
14461  default:
14462  if (!parser_is_identchar()) {
14463  pushback(c);
14464  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14465  return 0;
14466  }
14467  case '0':
14468  tokadd('$');
14469  }
14470  break;
14471 
14472  case '@':
14473  c = nextc();
14474  newtok();
14475  tokadd('@');
14476  if (c == '@') {
14477  tokadd('@');
14478  c = nextc();
14479  }
14480  if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14481  pushback(c);
14482  if (tokidx == 1) {
14483  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14484  }
14485  else {
14486  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14487  }
14488  return 0;
14489  }
14490  break;
14491 
14492  case '_':
14493  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14494  ruby__end__seen = 1;
14495  parser->eofp = Qtrue;
14496 #ifndef RIPPER
14497  return -1;
14498 #else
14499  lex_goto_eol(parser);
14500  ripper_dispatch_scan_event(parser, k__END__);
14501  return 0;
14502 #endif
14503  }
14504  newtok();
14505  break;
14506 
14507  default:
14508  if (!parser_is_identchar()) {
14509  compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14510  goto retry;
14511  }
14512 
14513  newtok();
14514  break;
14515  }
14516 
14517  mb = ENC_CODERANGE_7BIT;
14518  do {
14519  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14520  if (tokadd_mbchar(c) == -1) return 0;
14521  c = nextc();
14522  } while (parser_is_identchar());
14523  switch (tok()[0]) {
14524  case '@': case '$':
14525  pushback(c);
14526  break;
14527  default:
14528  if ((c == '!' || c == '?') && !peek('=')) {
14529  tokadd(c);
14530  }
14531  else {
14532  pushback(c);
14533  }
14534  }
14535  tokfix();
14536 
14537  {
14538  int result = 0;
14539 
14540  last_state = lex_state;
14541  switch (tok()[0]) {
14542  case '$':
14543  lex_state = EXPR_END;
14544  result = tGVAR;
14545  break;
14546  case '@':
14547  lex_state = EXPR_END;
14548  if (tok()[1] == '@')
14549  result = tCVAR;
14550  else
14551  result = tIVAR;
14552  break;
14553 
14554  default:
14555  if (toklast() == '!' || toklast() == '?') {
14556  result = tFID;
14557  }
14558  else {
14559  if (IS_lex_state(EXPR_FNAME)) {
14560  if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14561  (!peek('=') || (peek_n('>', 1)))) {
14562  result = tIDENTIFIER;
14563  tokadd(c);
14564  tokfix();
14565  }
14566  else {
14567  pushback(c);
14568  }
14569  }
14570  if (result == 0 && ISUPPER(tok()[0])) {
14571  result = tCONSTANT;
14572  }
14573  else {
14574  result = tIDENTIFIER;
14575  }
14576  }
14577 
14578  if (IS_LABEL_POSSIBLE()) {
14579  if (IS_LABEL_SUFFIX(0)) {
14580  lex_state = EXPR_BEG;
14581  nextc();
14583  return tLABEL;
14584  }
14585  }
14586  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14587  const struct kwtable *kw;
14588 
14589  /* See if it is a reserved word. */
14590  kw = rb_reserved_word(tok(), toklen());
14591  if (kw) {
14592  enum lex_state_e state = lex_state;
14593  lex_state = kw->state;
14594  if (state == EXPR_FNAME) {
14596  return kw->id[0];
14597  }
14598  if (lex_state == EXPR_BEG) {
14599  command_start = TRUE;
14600  }
14601  if (kw->id[0] == keyword_do) {
14602  if (lpar_beg && lpar_beg == paren_nest) {
14603  lpar_beg = 0;
14604  --paren_nest;
14605  return keyword_do_LAMBDA;
14606  }
14607  if (COND_P()) return keyword_do_cond;
14608  if (CMDARG_P() && state != EXPR_CMDARG)
14609  return keyword_do_block;
14610  if (state & (EXPR_BEG | EXPR_ENDARG))
14611  return keyword_do_block;
14612  return keyword_do;
14613  }
14614  if (state & (EXPR_BEG | EXPR_VALUE))
14615  return kw->id[0];
14616  else {
14617  if (kw->id[0] != kw->id[1])
14618  lex_state = EXPR_BEG;
14619  return kw->id[1];
14620  }
14621  }
14622  }
14623 
14624  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14625  if (cmd_state) {
14626  lex_state = EXPR_CMDARG;
14627  }
14628  else {
14629  lex_state = EXPR_ARG;
14630  }
14631  }
14632  else if (lex_state == EXPR_FNAME) {
14633  lex_state = EXPR_ENDFN;
14634  }
14635  else {
14636  lex_state = EXPR_END;
14637  }
14638  }
14639  {
14640  ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14641 
14642  set_yylval_name(ident);
14643  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14644  is_local_id(ident) && lvar_defined(ident)) {
14645  lex_state = EXPR_END;
14646  }
14647  }
14648  return result;
14649  }
14650 }
14651 
14652 #if YYPURE
14653 static int
14654 yylex(void *lval, void *p)
14655 #else
14656 yylex(void *p)
14657 #endif
14658 {
14659  struct parser_params *parser = (struct parser_params*)p;
14660  int t;
14661 
14662 #if YYPURE
14663  parser->parser_yylval = lval;
14664  parser->parser_yylval->val = Qundef;
14665 #endif
14666  t = parser_yylex(parser);
14667 #ifdef RIPPER
14668  if (!NIL_P(parser->delayed)) {
14669  ripper_dispatch_delayed_token(parser, t);
14670  return t;
14671  }
14672  if (t != 0)
14673  ripper_dispatch_scan_event(parser, t);
14674 #endif
14675 
14676  return t;
14677 }
14678 
14679 #ifndef RIPPER
14680 static NODE*
14681 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14682 {
14683  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14685  return n;
14686 }
14687 
14688 static enum node_type
14689 nodetype(NODE *node) /* for debug */
14690 {
14691  return (enum node_type)nd_type(node);
14692 }
14693 
14694 static int
14696 {
14697  return nd_line(node);
14698 }
14699 
14700 static NODE*
14702 {
14703  if (node) {
14704  node = remove_begin(node);
14705  node->flags |= NODE_FL_NEWLINE;
14706  }
14707  return node;
14708 }
14709 
14710 static void
14711 fixpos(NODE *node, NODE *orig)
14712 {
14713  if (!node) return;
14714  if (!orig) return;
14715  if (orig == (NODE*)1) return;
14716  nd_set_line(node, nd_line(orig));
14717 }
14718 
14719 static void
14720 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14721 {
14722  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14723 }
14724 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14725 
14726 static void
14727 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14728 {
14729  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14730 }
14731 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14732 
14733 static NODE*
14734 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14735 {
14736  NODE *end, *h = head, *nd;
14737 
14738  if (tail == 0) return head;
14739 
14740  if (h == 0) return tail;
14741  switch (nd_type(h)) {
14742  case NODE_LIT:
14743  case NODE_STR:
14744  case NODE_SELF:
14745  case NODE_TRUE:
14746  case NODE_FALSE:
14747  case NODE_NIL:
14748  parser_warning(h, "unused literal ignored");
14749  return tail;
14750  default:
14751  h = end = NEW_BLOCK(head);
14752  end->nd_end = end;
14753  fixpos(end, head);
14754  head = end;
14755  break;
14756  case NODE_BLOCK:
14757  end = h->nd_end;
14758  break;
14759  }
14760 
14761  nd = end->nd_head;
14762  switch (nd_type(nd)) {
14763  case NODE_RETURN:
14764  case NODE_BREAK:
14765  case NODE_NEXT:
14766  case NODE_REDO:
14767  case NODE_RETRY:
14768  if (RTEST(ruby_verbose)) {
14769  parser_warning(tail, "statement not reached");
14770  }
14771  break;
14772 
14773  default:
14774  break;
14775  }
14776 
14777  if (nd_type(tail) != NODE_BLOCK) {
14778  tail = NEW_BLOCK(tail);
14779  tail->nd_end = tail;
14780  }
14781  end->nd_next = tail;
14782  h->nd_end = tail->nd_end;
14783  return head;
14784 }
14785 
14786 /* append item to the list */
14787 static NODE*
14788 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14789 {
14790  NODE *last;
14791 
14792  if (list == 0) return NEW_LIST(item);
14793  if (list->nd_next) {
14794  last = list->nd_next->nd_end;
14795  }
14796  else {
14797  last = list;
14798  }
14799 
14800  list->nd_alen += 1;
14801  last->nd_next = NEW_LIST(item);
14802  list->nd_next->nd_end = last->nd_next;
14803  return list;
14804 }
14805 
14806 /* concat two lists */
14807 static NODE*
14808 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14809 {
14810  NODE *last;
14811 
14812  if (head->nd_next) {
14813  last = head->nd_next->nd_end;
14814  }
14815  else {
14816  last = head;
14817  }
14818 
14819  head->nd_alen += tail->nd_alen;
14820  last->nd_next = tail;
14821  if (tail->nd_next) {
14822  head->nd_next->nd_end = tail->nd_next->nd_end;
14823  }
14824  else {
14825  head->nd_next->nd_end = tail;
14826  }
14827 
14828  return head;
14829 }
14830 
14831 static int
14833 {
14834  if (NIL_P(tail)) return 1;
14835  if (!rb_enc_compatible(head, tail)) {
14836  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14837  rb_enc_name(rb_enc_get(head)),
14838  rb_enc_name(rb_enc_get(tail)));
14839  rb_str_resize(head, 0);
14840  rb_str_resize(tail, 0);
14841  return 0;
14842  }
14843  rb_str_buf_append(head, tail);
14844  return 1;
14845 }
14846 
14847 /* concat two string literals */
14848 static NODE *
14850 {
14851  enum node_type htype;
14852  NODE *headlast;
14853  VALUE lit;
14854 
14855  if (!head) return tail;
14856  if (!tail) return head;
14857 
14858  htype = nd_type(head);
14859  if (htype == NODE_EVSTR) {
14860  NODE *node = NEW_DSTR(Qnil);
14861  head = list_append(node, head);
14862  htype = NODE_DSTR;
14863  }
14864  switch (nd_type(tail)) {
14865  case NODE_STR:
14866  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14867  nd_type(headlast) == NODE_STR) {
14868  htype = NODE_STR;
14869  lit = headlast->nd_lit;
14870  }
14871  else {
14872  lit = head->nd_lit;
14873  }
14874  if (htype == NODE_STR) {
14875  if (!literal_concat0(parser, lit, tail->nd_lit)) {
14876  error:
14877  rb_gc_force_recycle((VALUE)head);
14878  rb_gc_force_recycle((VALUE)tail);
14879  return 0;
14880  }
14881  rb_gc_force_recycle((VALUE)tail);
14882  }
14883  else {
14884  list_append(head, tail);
14885  }
14886  break;
14887 
14888  case NODE_DSTR:
14889  if (htype == NODE_STR) {
14890  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14891  goto error;
14892  tail->nd_lit = head->nd_lit;
14893  rb_gc_force_recycle((VALUE)head);
14894  head = tail;
14895  }
14896  else if (NIL_P(tail->nd_lit)) {
14897  append:
14898  head->nd_alen += tail->nd_alen - 1;
14899  head->nd_next->nd_end->nd_next = tail->nd_next;
14900  head->nd_next->nd_end = tail->nd_next->nd_end;
14901  rb_gc_force_recycle((VALUE)tail);
14902  }
14903  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14904  nd_type(headlast) == NODE_STR) {
14905  lit = headlast->nd_lit;
14906  if (!literal_concat0(parser, lit, tail->nd_lit))
14907  goto error;
14908  tail->nd_lit = Qnil;
14909  goto append;
14910  }
14911  else {
14912  nd_set_type(tail, NODE_ARRAY);
14913  tail->nd_head = NEW_STR(tail->nd_lit);
14914  list_concat(head, tail);
14915  }
14916  break;
14917 
14918  case NODE_EVSTR:
14919  if (htype == NODE_STR) {
14920  nd_set_type(head, NODE_DSTR);
14921  head->nd_alen = 1;
14922  }
14923  list_append(head, tail);
14924  break;
14925  }
14926  return head;
14927 }
14928 
14929 static NODE *
14930 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14931 {
14932  if (nd_type(node) == NODE_EVSTR) {
14933  node = list_append(NEW_DSTR(Qnil), node);
14934  }
14935  return node;
14936 }
14937 
14938 static NODE *
14939 new_evstr_gen(struct parser_params *parser, NODE *node)
14940 {
14941  NODE *head = node;
14942 
14943  if (node) {
14944  switch (nd_type(node)) {
14945  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14946  return node;
14947  }
14948  }
14949  return NEW_EVSTR(head);
14950 }
14951 
14952 static NODE *
14953 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14954 {
14955  value_expr(recv);
14956  value_expr(arg1);
14957  return NEW_CALL(recv, id, NEW_LIST(arg1));
14958 }
14959 
14960 static NODE *
14961 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
14962 {
14963  value_expr(recv);
14964  return NEW_CALL(recv, id, 0);
14965 }
14966 
14967 static NODE*
14968 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14969 {
14970  value_expr(node1);
14971  value_expr(node2);
14972  if (node1) {
14973  switch (nd_type(node1)) {
14974  case NODE_DREGX:
14975  case NODE_DREGX_ONCE:
14976  return NEW_MATCH2(node1, node2);
14977 
14978  case NODE_LIT:
14979  if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
14980  return NEW_MATCH2(node1, node2);
14981  }
14982  }
14983  }
14984 
14985  if (node2) {
14986  switch (nd_type(node2)) {
14987  case NODE_DREGX:
14988  case NODE_DREGX_ONCE:
14989  return NEW_MATCH3(node2, node1);
14990 
14991  case NODE_LIT:
14992  if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
14993  return NEW_MATCH3(node2, node1);
14994  }
14995  }
14996  }
14997 
14998  return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
14999 }
15000 
15001 static NODE*
15002 gettable_gen(struct parser_params *parser, ID id)
15003 {
15004  switch (id) {
15005  case keyword_self:
15006  return NEW_SELF();
15007  case keyword_nil:
15008  return NEW_NIL();
15009  case keyword_true:
15010  return NEW_TRUE();
15011  case keyword_false:
15012  return NEW_FALSE();
15013  case keyword__FILE__:
15015  case keyword__LINE__:
15016  return NEW_LIT(INT2FIX(tokline));
15017  case keyword__ENCODING__:
15019  }
15020  switch (id_type(id)) {
15021  case ID_LOCAL:
15022  if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
15023  if (local_id(id)) return NEW_LVAR(id);
15024  /* method call without arguments */
15025  return NEW_VCALL(id);
15026  case ID_GLOBAL:
15027  return NEW_GVAR(id);
15028  case ID_INSTANCE:
15029  return NEW_IVAR(id);
15030  case ID_CONST:
15031  return NEW_CONST(id);
15032  case ID_CLASS:
15033  return NEW_CVAR(id);
15034  }
15035  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15036  return 0;
15037 }
15038 #else /* !RIPPER */
15039 static int
15040 id_is_var_gen(struct parser_params *parser, ID id)
15041 {
15042  if (is_notop_id(id)) {
15043  switch (id & ID_SCOPE_MASK) {
15044  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
15045  return 1;
15046  case ID_LOCAL:
15047  if (dyna_in_block() && dvar_defined(id)) return 1;
15048  if (local_id(id)) return 1;
15049  /* method call without arguments */
15050  return 0;
15051  }
15052  }
15053  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15054  return 0;
15055 }
15056 #endif /* !RIPPER */
15057 
15058 #if PARSER_DEBUG
15059 static const char *
15060 lex_state_name(enum lex_state_e state)
15061 {
15062  static const char names[][12] = {
15063  "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG",
15064  "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS",
15065  "EXPR_VALUE",
15066  };
15067 
15068  if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
15069  return names[ffs(state)];
15070  return NULL;
15071 }
15072 #endif
15073 
15074 #ifdef RIPPER
15075 static VALUE
15076 assignable_gen(struct parser_params *parser, VALUE lhs)
15077 #else
15078 static NODE*
15079 assignable_gen(struct parser_params *parser, ID id, NODE *val)
15080 #endif
15081 {
15082 #ifdef RIPPER
15083  ID id = get_id(lhs);
15084 # define assignable_result(x) get_value(lhs)
15085 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
15086 #else
15087 # define assignable_result(x) (x)
15088 #endif
15089  if (!id) return assignable_result(0);
15090  switch (id) {
15091  case keyword_self:
15092  yyerror("Can't change the value of self");
15093  goto error;
15094  case keyword_nil:
15095  yyerror("Can't assign to nil");
15096  goto error;
15097  case keyword_true:
15098  yyerror("Can't assign to true");
15099  goto error;
15100  case keyword_false:
15101  yyerror("Can't assign to false");
15102  goto error;
15103  case keyword__FILE__:
15104  yyerror("Can't assign to __FILE__");
15105  goto error;
15106  case keyword__LINE__:
15107  yyerror("Can't assign to __LINE__");
15108  goto error;
15109  case keyword__ENCODING__:
15110  yyerror("Can't assign to __ENCODING__");
15111  goto error;
15112  }
15113  switch (id_type(id)) {
15114  case ID_LOCAL:
15115  if (dyna_in_block()) {
15116  if (dvar_curr(id)) {
15117  return assignable_result(NEW_DASGN_CURR(id, val));
15118  }
15119  else if (dvar_defined(id)) {
15120  return assignable_result(NEW_DASGN(id, val));
15121  }
15122  else if (local_id(id)) {
15123  return assignable_result(NEW_LASGN(id, val));
15124  }
15125  else {
15126  dyna_var(id);
15127  return assignable_result(NEW_DASGN_CURR(id, val));
15128  }
15129  }
15130  else {
15131  if (!local_id(id)) {
15132  local_var(id);
15133  }
15134  return assignable_result(NEW_LASGN(id, val));
15135  }
15136  break;
15137  case ID_GLOBAL:
15138  return assignable_result(NEW_GASGN(id, val));
15139  case ID_INSTANCE:
15140  return assignable_result(NEW_IASGN(id, val));
15141  case ID_CONST:
15142  if (!in_def && !in_single)
15143  return assignable_result(NEW_CDECL(id, val, 0));
15144  yyerror("dynamic constant assignment");
15145  break;
15146  case ID_CLASS:
15147  return assignable_result(NEW_CVASGN(id, val));
15148  default:
15149  compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15150  }
15151  error:
15152  return assignable_result(0);
15153 #undef assignable_result
15154 #undef parser_yyerror
15155 }
15156 
15157 static int
15159 {
15160  VALUE s;
15161  if (name == idUScore) return 1;
15162  if (!is_local_id(name)) return 0;
15163  s = rb_id2str(name);
15164  if (!s) return 0;
15165  return RSTRING_PTR(s)[0] == '_';
15166 }
15167 
15168 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15169 
15170 static ID
15171 shadowing_lvar_gen(struct parser_params *parser, ID name)
15172 {
15173  if (is_private_local_id(name)) return name;
15174  if (dyna_in_block()) {
15175  if (dvar_curr(name)) {
15176  yyerror("duplicated argument name");
15177  }
15178  else if (dvar_defined_get(name) || local_id(name)) {
15179  rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15180  vtable_add(lvtbl->vars, name);
15181  if (lvtbl->used) {
15183  }
15184  }
15185  }
15186  else {
15187  if (local_id(name)) {
15188  yyerror("duplicated argument name");
15189  }
15190  }
15191  return name;
15192 }
15193 
15194 static void
15195 new_bv_gen(struct parser_params *parser, ID name)
15196 {
15197  if (!name) return;
15198  if (!is_local_id(name)) {
15199  compile_error(PARSER_ARG "invalid local variable - %s",
15200  rb_id2name(name));
15201  return;
15202  }
15203  shadowing_lvar(name);
15204  dyna_var(name);
15205 }
15206 
15207 #ifndef RIPPER
15208 static NODE *
15209 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15210 {
15211  if (recv && nd_type(recv) == NODE_SELF)
15212  recv = (NODE *)1;
15213  return NEW_ATTRASGN(recv, tASET, idx);
15214 }
15215 
15216 static void
15217 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15218 {
15219  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15220  compile_error(PARSER_ARG "both block arg and actual block given");
15221  }
15222 }
15223 
15224 static const char id_type_names[][9] = {
15225  "LOCAL",
15226  "INSTANCE",
15227  "", /* INSTANCE2 */
15228  "GLOBAL",
15229  "ATTRSET",
15230  "CONST",
15231  "CLASS",
15232  "JUNK",
15233 };
15234 
15235 ID
15237 {
15238  if (!is_notop_id(id)) {
15239  switch (id) {
15240  case tAREF: case tASET:
15241  return tASET; /* only exception */
15242  }
15243  rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
15244  }
15245  else {
15246  int scope = (int)(id & ID_SCOPE_MASK);
15247  switch (scope) {
15248  case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
15249  case ID_CONST: case ID_CLASS: case ID_JUNK:
15250  break;
15251  case ID_ATTRSET:
15252  return id;
15253  default:
15254  rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset",
15255  id_type_names[scope], ID2SYM(id));
15256 
15257  }
15258  }
15259  id &= ~ID_SCOPE_MASK;
15260  id |= ID_ATTRSET;
15261  return id;
15262 }
15263 
15264 static NODE *
15265 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15266 {
15267  if (recv && nd_type(recv) == NODE_SELF)
15268  recv = (NODE *)1;
15269  return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15270 }
15271 
15272 static void
15274 {
15275  switch (nd_type(node)) {
15276  case NODE_NTH_REF:
15277  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15278  break;
15279  case NODE_BACK_REF:
15280  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15281  break;
15282  }
15283 }
15284 
15285 static NODE *
15286 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15287 {
15288  if (!node2) return node1;
15289  switch (nd_type(node1)) {
15290  case NODE_BLOCK_PASS:
15291  if (node1->nd_head)
15292  node1->nd_head = arg_concat(node1->nd_head, node2);
15293  else
15294  node1->nd_head = NEW_LIST(node2);
15295  return node1;
15296  case NODE_ARGSPUSH:
15297  if (nd_type(node2) != NODE_ARRAY) break;
15298  node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15299  nd_set_type(node1, NODE_ARGSCAT);
15300  return node1;
15301  case NODE_ARGSCAT:
15302  if (nd_type(node2) != NODE_ARRAY ||
15303  nd_type(node1->nd_body) != NODE_ARRAY) break;
15304  node1->nd_body = list_concat(node1->nd_body, node2);
15305  return node1;
15306  }
15307  return NEW_ARGSCAT(node1, node2);
15308 }
15309 
15310 static NODE *
15311 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15312 {
15313  if (!node1) return NEW_LIST(node2);
15314  switch (nd_type(node1)) {
15315  case NODE_ARRAY:
15316  return list_append(node1, node2);
15317  case NODE_BLOCK_PASS:
15318  node1->nd_head = arg_append(node1->nd_head, node2);
15319  return node1;
15320  case NODE_ARGSPUSH:
15321  node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15322  nd_set_type(node1, NODE_ARGSCAT);
15323  return node1;
15324  }
15325  return NEW_ARGSPUSH(node1, node2);
15326 }
15327 
15328 static NODE *
15330 {
15331  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15332  if (nd_type(node) == NODE_ARRAY) return node;
15333  return 0;
15334 }
15335 
15336 static NODE *
15337 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15338 {
15339  if (!lhs) return 0;
15340 
15341  switch (nd_type(lhs)) {
15342  case NODE_GASGN:
15343  case NODE_IASGN:
15344  case NODE_IASGN2:
15345  case NODE_LASGN:
15346  case NODE_DASGN:
15347  case NODE_DASGN_CURR:
15348  case NODE_MASGN:
15349  case NODE_CDECL:
15350  case NODE_CVASGN:
15351  lhs->nd_value = rhs;
15352  break;
15353 
15354  case NODE_ATTRASGN:
15355  case NODE_CALL:
15356  lhs->nd_args = arg_append(lhs->nd_args, rhs);
15357  break;
15358 
15359  default:
15360  /* should not happen */
15361  break;
15362  }
15363 
15364  return lhs;
15365 }
15366 
15367 static int
15368 value_expr_gen(struct parser_params *parser, NODE *node)
15369 {
15370  int cond = 0;
15371 
15372  if (!node) {
15373  rb_warning0("empty expression");
15374  }
15375  while (node) {
15376  switch (nd_type(node)) {
15377  case NODE_DEFN:
15378  case NODE_DEFS:
15379  parser_warning(node, "void value expression");
15380  return FALSE;
15381 
15382  case NODE_RETURN:
15383  case NODE_BREAK:
15384  case NODE_NEXT:
15385  case NODE_REDO:
15386  case NODE_RETRY:
15387  if (!cond) yyerror("void value expression");
15388  /* or "control never reach"? */
15389  return FALSE;
15390 
15391  case NODE_BLOCK:
15392  while (node->nd_next) {
15393  node = node->nd_next;
15394  }
15395  node = node->nd_head;
15396  break;
15397 
15398  case NODE_BEGIN:
15399  node = node->nd_body;
15400  break;
15401 
15402  case NODE_IF:
15403  if (!node->nd_body) {
15404  node = node->nd_else;
15405  break;
15406  }
15407  else if (!node->nd_else) {
15408  node = node->nd_body;
15409  break;
15410  }
15411  if (!value_expr(node->nd_body)) return FALSE;
15412  node = node->nd_else;
15413  break;
15414 
15415  case NODE_AND:
15416  case NODE_OR:
15417  cond = 1;
15418  node = node->nd_2nd;
15419  break;
15420 
15421  default:
15422  return TRUE;
15423  }
15424  }
15425 
15426  return TRUE;
15427 }
15428 
15429 static void
15430 void_expr_gen(struct parser_params *parser, NODE *node)
15431 {
15432  const char *useless = 0;
15433 
15434  if (!RTEST(ruby_verbose)) return;
15435 
15436  if (!node) return;
15437  switch (nd_type(node)) {
15438  case NODE_CALL:
15439  switch (node->nd_mid) {
15440  case '+':
15441  case '-':
15442  case '*':
15443  case '/':
15444  case '%':
15445  case tPOW:
15446  case tUPLUS:
15447  case tUMINUS:
15448  case '|':
15449  case '^':
15450  case '&':
15451  case tCMP:
15452  case '>':
15453  case tGEQ:
15454  case '<':
15455  case tLEQ:
15456  case tEQ:
15457  case tNEQ:
15458  useless = rb_id2name(node->nd_mid);
15459  break;
15460  }
15461  break;
15462 
15463  case NODE_LVAR:
15464  case NODE_DVAR:
15465  case NODE_GVAR:
15466  case NODE_IVAR:
15467  case NODE_CVAR:
15468  case NODE_NTH_REF:
15469  case NODE_BACK_REF:
15470  useless = "a variable";
15471  break;
15472  case NODE_CONST:
15473  useless = "a constant";
15474  break;
15475  case NODE_LIT:
15476  case NODE_STR:
15477  case NODE_DSTR:
15478  case NODE_DREGX:
15479  case NODE_DREGX_ONCE:
15480  useless = "a literal";
15481  break;
15482  case NODE_COLON2:
15483  case NODE_COLON3:
15484  useless = "::";
15485  break;
15486  case NODE_DOT2:
15487  useless = "..";
15488  break;
15489  case NODE_DOT3:
15490  useless = "...";
15491  break;
15492  case NODE_SELF:
15493  useless = "self";
15494  break;
15495  case NODE_NIL:
15496  useless = "nil";
15497  break;
15498  case NODE_TRUE:
15499  useless = "true";
15500  break;
15501  case NODE_FALSE:
15502  useless = "false";
15503  break;
15504  case NODE_DEFINED:
15505  useless = "defined?";
15506  break;
15507  }
15508 
15509  if (useless) {
15510  int line = ruby_sourceline;
15511 
15512  ruby_sourceline = nd_line(node);
15513  rb_warnS("possibly useless use of %s in void context", useless);
15514  ruby_sourceline = line;
15515  }
15516 }
15517 
15518 static void
15519 void_stmts_gen(struct parser_params *parser, NODE *node)
15520 {
15521  if (!RTEST(ruby_verbose)) return;
15522  if (!node) return;
15523  if (nd_type(node) != NODE_BLOCK) return;
15524 
15525  for (;;) {
15526  if (!node->nd_next) return;
15527  void_expr0(node->nd_head);
15528  node = node->nd_next;
15529  }
15530 }
15531 
15532 static NODE *
15534 {
15535  NODE **n = &node, *n1 = node;
15536  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15537  *n = n1 = n1->nd_body;
15538  }
15539  return node;
15540 }
15541 
15542 static void
15543 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15544 {
15545  NODE *node = *body;
15546 
15547  if (!node) {
15548  *body = NEW_NIL();
15549  return;
15550  }
15551 #define subnodes(n1, n2) \
15552  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15553  (!node->n2) ? (body = &node->n1, 1) : \
15554  (reduce_nodes(&node->n1), body = &node->n2, 1))
15555 
15556  while (node) {
15557  int newline = (int)(node->flags & NODE_FL_NEWLINE);
15558  switch (nd_type(node)) {
15559  end:
15560  case NODE_NIL:
15561  *body = 0;
15562  return;
15563  case NODE_RETURN:
15564  *body = node = node->nd_stts;
15565  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15566  continue;
15567  case NODE_BEGIN:
15568  *body = node = node->nd_body;
15569  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15570  continue;
15571  case NODE_BLOCK:
15572  body = &node->nd_end->nd_head;
15573  break;
15574  case NODE_IF:
15575  if (subnodes(nd_body, nd_else)) break;
15576  return;
15577  case NODE_CASE:
15578  body = &node->nd_body;
15579  break;
15580  case NODE_WHEN:
15581  if (!subnodes(nd_body, nd_next)) goto end;
15582  break;
15583  case NODE_ENSURE:
15584  if (!subnodes(nd_head, nd_resq)) goto end;
15585  break;
15586  case NODE_RESCUE:
15587  if (node->nd_else) {
15588  body = &node->nd_resq;
15589  break;
15590  }
15591  if (!subnodes(nd_head, nd_resq)) goto end;
15592  break;
15593  default:
15594  return;
15595  }
15596  node = *body;
15597  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15598  }
15599 
15600 #undef subnodes
15601 }
15602 
15603 static int
15605 {
15606  if (!node) return 1;
15607  switch (nd_type(node)) {
15608  case NODE_HASH:
15609  if (!(node = node->nd_head)) break;
15610  case NODE_ARRAY:
15611  do {
15612  if (!is_static_content(node->nd_head)) return 0;
15613  } while ((node = node->nd_next) != 0);
15614  case NODE_LIT:
15615  case NODE_STR:
15616  case NODE_NIL:
15617  case NODE_TRUE:
15618  case NODE_FALSE:
15619  case NODE_ZARRAY:
15620  break;
15621  default:
15622  return 0;
15623  }
15624  return 1;
15625 }
15626 
15627 static int
15628 assign_in_cond(struct parser_params *parser, NODE *node)
15629 {
15630  switch (nd_type(node)) {
15631  case NODE_MASGN:
15632  yyerror("multiple assignment in conditional");
15633  return 1;
15634 
15635  case NODE_LASGN:
15636  case NODE_DASGN:
15637  case NODE_DASGN_CURR:
15638  case NODE_GASGN:
15639  case NODE_IASGN:
15640  break;
15641 
15642  default:
15643  return 0;
15644  }
15645 
15646  if (!node->nd_value) return 1;
15647  if (is_static_content(node->nd_value)) {
15648  /* reports always */
15649  parser_warn(node->nd_value, "found = in conditional, should be ==");
15650  }
15651  return 1;
15652 }
15653 
15654 static void
15655 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15656 {
15657  if (!e_option_supplied(parser)) parser_warn(node, str);
15658 }
15659 
15660 static void
15661 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15662 {
15663  if (!e_option_supplied(parser)) parser_warning(node, str);
15664 }
15665 
15666 static void
15667 fixup_nodes(NODE **rootnode)
15668 {
15669  NODE *node, *next, *head;
15670 
15671  for (node = *rootnode; node; node = next) {
15672  enum node_type type;
15673  VALUE val;
15674 
15675  next = node->nd_next;
15676  head = node->nd_head;
15677  rb_gc_force_recycle((VALUE)node);
15678  *rootnode = next;
15679  switch (type = nd_type(head)) {
15680  case NODE_DOT2:
15681  case NODE_DOT3:
15682  val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15683  type == NODE_DOT3);
15684  rb_gc_force_recycle((VALUE)head->nd_beg);
15685  rb_gc_force_recycle((VALUE)head->nd_end);
15686  nd_set_type(head, NODE_LIT);
15687  head->nd_lit = val;
15688  break;
15689  default:
15690  break;
15691  }
15692  }
15693 }
15694 
15695 static NODE *cond0(struct parser_params*,NODE*);
15696 
15697 static NODE*
15698 range_op(struct parser_params *parser, NODE *node)
15699 {
15700  enum node_type type;
15701 
15702  if (node == 0) return 0;
15703 
15704  type = nd_type(node);
15705  value_expr(node);
15706  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15707  warn_unless_e_option(parser, node, "integer literal in conditional range");
15708  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15709  }
15710  return cond0(parser, node);
15711 }
15712 
15713 static int
15715 {
15716  if (!node) return 1; /* same as NODE_NIL */
15717  switch (nd_type(node)) {
15718  case NODE_LIT:
15719  case NODE_STR:
15720  case NODE_DSTR:
15721  case NODE_EVSTR:
15722  case NODE_DREGX:
15723  case NODE_DREGX_ONCE:
15724  case NODE_DSYM:
15725  return 2;
15726  case NODE_TRUE:
15727  case NODE_FALSE:
15728  case NODE_NIL:
15729  return 1;
15730  }
15731  return 0;
15732 }
15733 
15734 static NODE*
15735 cond0(struct parser_params *parser, NODE *node)
15736 {
15737  if (node == 0) return 0;
15738  assign_in_cond(parser, node);
15739 
15740  switch (nd_type(node)) {
15741  case NODE_DSTR:
15742  case NODE_EVSTR:
15743  case NODE_STR:
15744  rb_warn0("string literal in condition");
15745  break;
15746 
15747  case NODE_DREGX:
15748  case NODE_DREGX_ONCE:
15749  warning_unless_e_option(parser, node, "regex literal in condition");
15750  return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15751 
15752  case NODE_AND:
15753  case NODE_OR:
15754  node->nd_1st = cond0(parser, node->nd_1st);
15755  node->nd_2nd = cond0(parser, node->nd_2nd);
15756  break;
15757 
15758  case NODE_DOT2:
15759  case NODE_DOT3:
15760  node->nd_beg = range_op(parser, node->nd_beg);
15761  node->nd_end = range_op(parser, node->nd_end);
15762  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15763  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15764  if (!e_option_supplied(parser)) {
15765  int b = literal_node(node->nd_beg);
15766  int e = literal_node(node->nd_end);
15767  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15768  parser_warn(node, "range literal in condition");
15769  }
15770  }
15771  break;
15772 
15773  case NODE_DSYM:
15774  parser_warning(node, "literal in condition");
15775  break;
15776 
15777  case NODE_LIT:
15778  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
15779  warn_unless_e_option(parser, node, "regex literal in condition");
15780  nd_set_type(node, NODE_MATCH);
15781  }
15782  else {
15783  parser_warning(node, "literal in condition");
15784  }
15785  default:
15786  break;
15787  }
15788  return node;
15789 }
15790 
15791 static NODE*
15792 cond_gen(struct parser_params *parser, NODE *node)
15793 {
15794  if (node == 0) return 0;
15795  return cond0(parser, node);
15796 }
15797 
15798 static NODE*
15799 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15800 {
15801  value_expr(left);
15802  if (left && (enum node_type)nd_type(left) == type) {
15803  NODE *node = left, *second;
15804  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15805  node = second;
15806  }
15807  node->nd_2nd = NEW_NODE(type, second, right, 0);
15808  return left;
15809  }
15810  return NEW_NODE(type, left, right, 0);
15811 }
15812 
15813 static void
15814 no_blockarg(struct parser_params *parser, NODE *node)
15815 {
15816  if (node && nd_type(node) == NODE_BLOCK_PASS) {
15817  compile_error(PARSER_ARG "block argument should not be given");
15818  }
15819 }
15820 
15821 static NODE *
15822 ret_args_gen(struct parser_params *parser, NODE *node)
15823 {
15824  if (node) {
15825  no_blockarg(parser, node);
15826  if (nd_type(node) == NODE_ARRAY) {
15827  if (node->nd_next == 0) {
15828  node = node->nd_head;
15829  }
15830  else {
15831  nd_set_type(node, NODE_VALUES);
15832  }
15833  }
15834  }
15835  return node;
15836 }
15837 
15838 static NODE *
15839 new_yield_gen(struct parser_params *parser, NODE *node)
15840 {
15841  if (node) no_blockarg(parser, node);
15842 
15843  return NEW_YIELD(node);
15844 }
15845 
15846 static NODE*
15848 {
15849  switch (TYPE(node->nd_lit)) {
15850  case T_FIXNUM:
15851  node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15852  break;
15853  case T_BIGNUM:
15854  node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15855  break;
15856  case T_FLOAT:
15857 #if USE_FLONUM
15858  if (FLONUM_P(node->nd_lit)) {
15859  node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
15860  }
15861  else {
15862  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15863  }
15864 #else
15865  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15866 #endif
15867  break;
15868  default:
15869  break;
15870  }
15871  return node;
15872 }
15873 
15874 static NODE *
15875 arg_blk_pass(NODE *node1, NODE *node2)
15876 {
15877  if (node2) {
15878  node2->nd_head = node1;
15879  return node2;
15880  }
15881  return node1;
15882 }
15883 
15884 
15885 static NODE*
15886 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
15887 {
15888  int saved_line = ruby_sourceline;
15889  struct rb_args_info *args = tail->nd_ainfo;
15890 
15891  args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0;
15892  args->pre_init = m ? m->nd_next : 0;
15893 
15894  args->post_args_num = p ? rb_long2int(p->nd_plen) : 0;
15895  args->post_init = p ? p->nd_next : 0;
15896  args->first_post_arg = p ? p->nd_pid : 0;
15897 
15898  args->rest_arg = r;
15899 
15900  args->opt_args = o;
15901 
15902  ruby_sourceline = saved_line;
15903 
15904  return tail;
15905 }
15906 
15907 static NODE*
15908 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
15909 {
15910  int saved_line = ruby_sourceline;
15911  struct rb_args_info *args;
15912  NODE *kw_rest_arg = 0;
15913  NODE *node;
15914 
15915  args = ALLOC(struct rb_args_info);
15916  MEMZERO(args, struct rb_args_info, 1);
15917  node = NEW_NODE(NODE_ARGS, 0, 0, args);
15918 
15919  args->block_arg = b;
15920  args->kw_args = k;
15921  if (k && !kr) kr = internal_id();
15922  if (kr) {
15923  arg_var(kr);
15924  kw_rest_arg = NEW_DVAR(kr);
15925  }
15926  args->kw_rest_arg = kw_rest_arg;
15927 
15928  ruby_sourceline = saved_line;
15929  return node;
15930 }
15931 
15932 static NODE*
15933 dsym_node_gen(struct parser_params *parser, NODE *node)
15934 {
15935  VALUE lit;
15936 
15937  if (!node) {
15938  return NEW_LIT(ID2SYM(idNULL));
15939  }
15940 
15941  switch (nd_type(node)) {
15942  case NODE_DSTR:
15943  nd_set_type(node, NODE_DSYM);
15944  break;
15945  case NODE_STR:
15946  lit = node->nd_lit;
15947  node->nd_lit = ID2SYM(rb_intern_str(lit));
15948  nd_set_type(node, NODE_LIT);
15949  break;
15950  default:
15951  node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
15952  break;
15953  }
15954  return node;
15955 }
15956 #endif /* !RIPPER */
15957 
15958 #ifndef RIPPER
15959 static NODE *
15960 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
15961 {
15962  NODE *asgn;
15963 
15964  if (lhs) {
15965  ID vid = lhs->nd_vid;
15966  if (op == tOROP) {
15967  lhs->nd_value = rhs;
15968  asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
15969  if (is_asgn_or_id(vid)) {
15970  asgn->nd_aid = vid;
15971  }
15972  }
15973  else if (op == tANDOP) {
15974  lhs->nd_value = rhs;
15975  asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
15976  }
15977  else {
15978  asgn = lhs;
15979  asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
15980  }
15981  }
15982  else {
15983  asgn = NEW_BEGIN(0);
15984  }
15985  return asgn;
15986 }
15987 
15988 static NODE *
15989 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
15990 {
15991  NODE *asgn;
15992 
15993  if (op == tOROP) {
15994  op = 0;
15995  }
15996  else if (op == tANDOP) {
15997  op = 1;
15998  }
15999  asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
16000  fixpos(asgn, lhs);
16001  return asgn;
16002 }
16003 
16004 static NODE *
16005 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16006 {
16007  NODE *asgn;
16008 
16009  if (op == tOROP) {
16010  op = 0;
16011  }
16012  else if (op == tANDOP) {
16013  op = 1;
16014  }
16015  if (lhs) {
16016  asgn = NEW_OP_CDECL(lhs, op, rhs);
16017  }
16018  else {
16019  asgn = NEW_BEGIN(0);
16020  }
16021  fixpos(asgn, lhs);
16022  return asgn;
16023 }
16024 #else
16025 static VALUE
16026 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
16027 {
16028  return dispatch3(opassign, lhs, op, rhs);
16029 }
16030 
16031 static VALUE
16032 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
16033 {
16034  VALUE recv = dispatch3(field, lhs, type, attr);
16035  return dispatch3(opassign, recv, op, rhs);
16036 }
16037 #endif
16038 
16039 static void
16040 warn_unused_var(struct parser_params *parser, struct local_vars *local)
16041 {
16042  int i, cnt;
16043  ID *v, *u;
16044 
16045  if (!local->used) return;
16046  v = local->vars->tbl;
16047  u = local->used->tbl;
16048  cnt = local->used->pos;
16049  if (cnt != local->vars->pos) {
16050  rb_bug("local->used->pos != local->vars->pos");
16051  }
16052  for (i = 0; i < cnt; ++i) {
16053  if (!v[i] || (u[i] & LVAR_USED)) continue;
16054  if (is_private_local_id(v[i])) continue;
16055  rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
16056  }
16057 }
16058 
16059 static void
16060 local_push_gen(struct parser_params *parser, int inherit_dvars)
16061 {
16062  struct local_vars *local;
16063 
16064  local = ALLOC(struct local_vars);
16065  local->prev = lvtbl;
16066  local->args = vtable_alloc(0);
16067  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
16068  local->used = !(inherit_dvars &&
16070  RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
16071  local->cmdargs = cmdarg_stack;
16072  cmdarg_stack = 0;
16073  lvtbl = local;
16074 }
16075 
16076 static void
16078 {
16079  struct local_vars *local = lvtbl->prev;
16080  if (lvtbl->used) {
16081  warn_unused_var(parser, lvtbl);
16082  vtable_free(lvtbl->used);
16083  }
16084  vtable_free(lvtbl->args);
16085  vtable_free(lvtbl->vars);
16086  cmdarg_stack = lvtbl->cmdargs;
16087  xfree(lvtbl);
16088  lvtbl = local;
16089 }
16090 
16091 #ifndef RIPPER
16092 static ID*
16094 {
16095  int cnt_args = vtable_size(lvtbl->args);
16096  int cnt_vars = vtable_size(lvtbl->vars);
16097  int cnt = cnt_args + cnt_vars;
16098  int i, j;
16099  ID *buf;
16100 
16101  if (cnt <= 0) return 0;
16102  buf = ALLOC_N(ID, cnt + 1);
16103  MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args);
16104  /* remove IDs duplicated to warn shadowing */
16105  for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
16106  ID id = lvtbl->vars->tbl[i];
16107  if (!vtable_included(lvtbl->args, id)) {
16108  buf[j++] = id;
16109  }
16110  }
16111  if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1);
16112  buf[0] = cnt;
16113  return buf;
16114 }
16115 #endif
16116 
16117 static int
16118 arg_var_gen(struct parser_params *parser, ID id)
16119 {
16120  vtable_add(lvtbl->args, id);
16121  return vtable_size(lvtbl->args) - 1;
16122 }
16123 
16124 static int
16125 local_var_gen(struct parser_params *parser, ID id)
16126 {
16127  vtable_add(lvtbl->vars, id);
16128  if (lvtbl->used) {
16130  }
16131  return vtable_size(lvtbl->vars) - 1;
16132 }
16133 
16134 static int
16135 local_id_gen(struct parser_params *parser, ID id)
16136 {
16137  struct vtable *vars, *args, *used;
16138 
16139  vars = lvtbl->vars;
16140  args = lvtbl->args;
16141  used = lvtbl->used;
16142 
16143  while (vars && POINTER_P(vars->prev)) {
16144  vars = vars->prev;
16145  args = args->prev;
16146  if (used) used = used->prev;
16147  }
16148 
16149  if (vars && vars->prev == DVARS_INHERIT) {
16150  return rb_local_defined(id);
16151  }
16152  else if (vtable_included(args, id)) {
16153  return 1;
16154  }
16155  else {
16156  int i = vtable_included(vars, id);
16157  if (i && used) used->tbl[i-1] |= LVAR_USED;
16158  return i != 0;
16159  }
16160 }
16161 
16162 static const struct vtable *
16164 {
16165  lvtbl->args = vtable_alloc(lvtbl->args);
16166  lvtbl->vars = vtable_alloc(lvtbl->vars);
16167  if (lvtbl->used) {
16168  lvtbl->used = vtable_alloc(lvtbl->used);
16169  }
16170  return lvtbl->args;
16171 }
16172 
16173 static void
16174 dyna_pop_1(struct parser_params *parser)
16175 {
16176  struct vtable *tmp;
16177 
16178  if ((tmp = lvtbl->used) != 0) {
16179  warn_unused_var(parser, lvtbl);
16180  lvtbl->used = lvtbl->used->prev;
16181  vtable_free(tmp);
16182  }
16183  tmp = lvtbl->args;
16184  lvtbl->args = lvtbl->args->prev;
16185  vtable_free(tmp);
16186  tmp = lvtbl->vars;
16187  lvtbl->vars = lvtbl->vars->prev;
16188  vtable_free(tmp);
16189 }
16190 
16191 static void
16192 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16193 {
16194  while (lvtbl->args != lvargs) {
16195  dyna_pop_1(parser);
16196  if (!lvtbl->args) {
16197  struct local_vars *local = lvtbl->prev;
16198  xfree(lvtbl);
16199  lvtbl = local;
16200  }
16201  }
16202  dyna_pop_1(parser);
16203 }
16204 
16205 static int
16207 {
16208  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16209 }
16210 
16211 static int
16212 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16213 {
16214  struct vtable *vars, *args, *used;
16215  int i;
16216 
16217  args = lvtbl->args;
16218  vars = lvtbl->vars;
16219  used = lvtbl->used;
16220 
16221  while (POINTER_P(vars)) {
16222  if (vtable_included(args, id)) {
16223  return 1;
16224  }
16225  if ((i = vtable_included(vars, id)) != 0) {
16226  if (used) used->tbl[i-1] |= LVAR_USED;
16227  return 1;
16228  }
16229  args = args->prev;
16230  vars = vars->prev;
16231  if (get) used = 0;
16232  if (used) used = used->prev;
16233  }
16234 
16235  if (vars == DVARS_INHERIT) {
16236  return rb_dvar_defined(id);
16237  }
16238 
16239  return 0;
16240 }
16241 
16242 static int
16243 dvar_curr_gen(struct parser_params *parser, ID id)
16244 {
16245  return (vtable_included(lvtbl->args, id) ||
16246  vtable_included(lvtbl->vars, id));
16247 }
16248 
16249 #ifndef RIPPER
16250 static void
16252 {
16253  int c = RE_OPTION_ENCODING_IDX(options);
16254 
16255  if (c) {
16256  int opt, idx;
16257  rb_char_to_option_kcode(c, &opt, &idx);
16258  if (idx != ENCODING_GET(str) &&
16260  goto error;
16261  }
16262  ENCODING_SET(str, idx);
16263  }
16264  else if (RE_OPTION_ENCODING_NONE(options)) {
16265  if (!ENCODING_IS_ASCII8BIT(str) &&
16267  c = 'n';
16268  goto error;
16269  }
16271  }
16272  else if (current_enc == rb_usascii_encoding()) {
16274  /* raise in re.c */
16276  }
16277  else {
16279  }
16280  }
16281  return;
16282 
16283  error:
16285  "regexp encoding option '%c' differs from source encoding '%s'",
16286  c, rb_enc_name(rb_enc_get(str)));
16287 }
16288 
16289 static int
16291 {
16292  VALUE err;
16293  reg_fragment_setenc(str, options);
16294  err = rb_reg_check_preprocess(str);
16295  if (err != Qnil) {
16296  err = rb_obj_as_string(err);
16297  compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
16298  RB_GC_GUARD(err);
16299  return 0;
16300  }
16301  return 1;
16302 }
16303 
16304 typedef struct {
16309  int num;
16311 
16312 static int
16314  int back_num, int *back_refs, OnigRegex regex, void *arg0)
16315 {
16317  struct parser_params* parser = arg->parser;
16318  rb_encoding *enc = arg->enc;
16319  long len = name_end - name;
16320  const char *s = (const char *)name;
16321  ID var;
16322 
16323  arg->num++;
16324 
16325  if (arg->succ_block == 0) {
16326  arg->succ_block = NEW_BEGIN(0);
16327  arg->fail_block = NEW_BEGIN(0);
16328  }
16329 
16330  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16331  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16332  !rb_enc_symname2_p(s, len, enc)) {
16333  return ST_CONTINUE;
16334  }
16335  var = rb_intern3(s, len, enc);
16336  if (dvar_defined(var) || local_id(var)) {
16337  rb_warningS("named capture conflicts a local variable - %s",
16338  rb_id2name(var));
16339  }
16340  arg->succ_block = block_append(arg->succ_block,
16342  NEW_CALL(
16343  gettable(rb_intern("$~")),
16344  idAREF,
16345  NEW_LIST(NEW_LIT(ID2SYM(var))))
16346  )));
16347  arg->fail_block = block_append(arg->fail_block,
16349  return ST_CONTINUE;
16350 }
16351 
16352 static NODE *
16354 {
16356 
16357  arg.parser = parser;
16358  arg.enc = rb_enc_get(regexp);
16359  arg.succ_block = 0;
16360  arg.fail_block = 0;
16361  arg.num = 0;
16362  onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
16363 
16364  if (arg.num == 0)
16365  return match;
16366 
16367  return
16368  block_append(
16369  newline_node(match),
16370  NEW_IF(gettable(rb_intern("$~")),
16371  block_append(
16372  newline_node(arg.succ_block),
16373  newline_node(
16374  NEW_CALL(
16375  gettable(rb_intern("$~")),
16376  rb_intern("begin"),
16377  NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16378  block_append(
16379  newline_node(arg.fail_block),
16380  newline_node(
16381  NEW_LIT(Qnil)))));
16382 }
16383 
16384 static VALUE
16385 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16386 {
16387  VALUE re;
16388  VALUE err;
16389 
16390  reg_fragment_setenc(str, options);
16391  err = rb_errinfo();
16393  if (NIL_P(re)) {
16394  ID mesg = rb_intern("mesg");
16395  VALUE m = rb_attr_get(rb_errinfo(), mesg);
16396  rb_set_errinfo(err);
16397  if (!NIL_P(err)) {
16398  rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16399  }
16400  else {
16402  }
16403  return Qnil;
16404  }
16405  return re;
16406 }
16407 
16408 void
16410 {
16411 }
16412 
16413 NODE*
16415 {
16416  NODE *prelude = 0;
16417  NODE *scope = node;
16418  struct parser_params *parser;
16419 
16420  if (!node) return node;
16421 
16422  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16423 
16424  node = node->nd_body;
16425 
16426  if (nd_type(node) == NODE_PRELUDE) {
16427  prelude = node;
16428  node = node->nd_body;
16429  }
16430 
16431  node = block_append(node,
16432  NEW_FCALL(rb_intern("print"),
16433  NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16434  if (prelude) {
16435  prelude->nd_body = node;
16436  scope->nd_body = prelude;
16437  }
16438  else {
16439  scope->nd_body = node;
16440  }
16441 
16442  return scope;
16443 }
16444 
16445 NODE *
16446 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16447 {
16448  NODE *prelude = 0;
16449  NODE *scope = node;
16450  struct parser_params *parser;
16451 
16452  if (!node) return node;
16453 
16454  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16455 
16456  node = node->nd_body;
16457 
16458  if (nd_type(node) == NODE_PRELUDE) {
16459  prelude = node;
16460  node = node->nd_body;
16461  }
16462  if (split) {
16463  node = block_append(NEW_GASGN(rb_intern("$F"),
16464  NEW_CALL(NEW_GVAR(rb_intern("$_")),
16465  rb_intern("split"), 0)),
16466  node);
16467  }
16468  if (chop) {
16469  node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16470  rb_intern("chop!"), 0), node);
16471  }
16472 
16473  node = NEW_OPT_N(node);
16474 
16475  if (prelude) {
16476  prelude->nd_body = node;
16477  scope->nd_body = prelude;
16478  }
16479  else {
16480  scope->nd_body = node;
16481  }
16482 
16483  return scope;
16484 }
16485 
16486 static const struct {
16488  const char *name;
16489 } op_tbl[] = {
16490  {tDOT2, ".."},
16491  {tDOT3, "..."},
16492  {tPOW, "**"},
16493  {tDSTAR, "**"},
16494  {tUPLUS, "+@"},
16495  {tUMINUS, "-@"},
16496  {tCMP, "<=>"},
16497  {tGEQ, ">="},
16498  {tLEQ, "<="},
16499  {tEQ, "=="},
16500  {tEQQ, "==="},
16501  {tNEQ, "!="},
16502  {tMATCH, "=~"},
16503  {tNMATCH, "!~"},
16504  {tAREF, "[]"},
16505  {tASET, "[]="},
16506  {tLSHFT, "<<"},
16507  {tRSHFT, ">>"},
16508  {tCOLON2, "::"},
16509 };
16510 
16511 #define op_tbl_count numberof(op_tbl)
16512 
16513 #ifndef ENABLE_SELECTOR_NAMESPACE
16514 #define ENABLE_SELECTOR_NAMESPACE 0
16515 #endif
16516 
16517 static struct symbols {
16521 #if ENABLE_SELECTOR_NAMESPACE
16522  st_table *ivar2_id;
16523  st_table *id_ivar2;
16524 #endif
16527 
16528 static const struct st_hash_type symhash = {
16530  rb_str_hash,
16531 };
16532 
16533 #if ENABLE_SELECTOR_NAMESPACE
16534 struct ivar2_key {
16535  ID id;
16536  VALUE klass;
16537 };
16538 
16539 static int
16540 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16541 {
16542  if (key1->id == key2->id && key1->klass == key2->klass) {
16543  return 0;
16544  }
16545  return 1;
16546 }
16547 
16548 static int
16549 ivar2_hash(struct ivar2_key *key)
16550 {
16551  return (key->id << 8) ^ (key->klass >> 2);
16552 }
16553 
16554 static const struct st_hash_type ivar2_hash_type = {
16555  ivar2_cmp,
16556  ivar2_hash,
16557 };
16558 #endif
16559 
16560 void
16562 {
16563  global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
16565 #if ENABLE_SELECTOR_NAMESPACE
16566  global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16567  global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16568 #endif
16569 
16570  (void)nodetype;
16571  (void)nodeline;
16572 #if PARSER_DEBUG
16573  (void)lex_state_name(-1);
16574 #endif
16575 
16576  Init_id();
16577 }
16578 
16579 void
16581 {
16585 }
16586 #endif /* !RIPPER */
16587 
16588 static ID
16590 {
16591  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16592  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16593  return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16594 }
16595 
16596 #ifndef RIPPER
16597 static int
16598 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16599 {
16600  int mb = 0;
16601 
16602  if (m >= e) return 0;
16603  if (is_global_name_punct(*m)) {
16604  ++m;
16605  }
16606  else if (*m == '-') {
16607  ++m;
16608  if (m < e && is_identchar(m, e, enc)) {
16609  if (!ISASCII(*m)) mb = 1;
16610  m += rb_enc_mbclen(m, e, enc);
16611  }
16612  }
16613  else {
16614  if (!rb_enc_isdigit(*m, enc)) return 0;
16615  do {
16616  if (!ISASCII(*m)) mb = 1;
16617  ++m;
16618  } while (m < e && rb_enc_isdigit(*m, enc));
16619  }
16620  return m == e ? mb + 1 : 0;
16621 }
16622 
16623 int
16624 rb_symname_p(const char *name)
16625 {
16626  return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16627 }
16628 
16629 int
16630 rb_enc_symname_p(const char *name, rb_encoding *enc)
16631 {
16632  return rb_enc_symname2_p(name, strlen(name), enc);
16633 }
16634 
16635 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
16636 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<(1<<ID_SCOPE_SHIFT)) & ~(1U<<ID_ATTRSET))
16637 
16638 static int
16639 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_atttset)
16640 {
16641  const char *m = name;
16642  const char *e = m + len;
16643  int type = ID_JUNK;
16644 
16645  if (!m || len <= 0) return -1;
16646  switch (*m) {
16647  case '\0':
16648  return -1;
16649 
16650  case '$':
16651  type = ID_GLOBAL;
16652  if (is_special_global_name(++m, e, enc)) return type;
16653  goto id;
16654 
16655  case '@':
16656  type = ID_INSTANCE;
16657  if (*++m == '@') {
16658  ++m;
16659  type = ID_CLASS;
16660  }
16661  goto id;
16662 
16663  case '<':
16664  switch (*++m) {
16665  case '<': ++m; break;
16666  case '=': if (*++m == '>') ++m; break;
16667  default: break;
16668  }
16669  break;
16670 
16671  case '>':
16672  switch (*++m) {
16673  case '>': case '=': ++m; break;
16674  }
16675  break;
16676 
16677  case '=':
16678  switch (*++m) {
16679  case '~': ++m; break;
16680  case '=': if (*++m == '=') ++m; break;
16681  default: return -1;
16682  }
16683  break;
16684 
16685  case '*':
16686  if (*++m == '*') ++m;
16687  break;
16688 
16689  case '+': case '-':
16690  if (*++m == '@') ++m;
16691  break;
16692 
16693  case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16694  ++m;
16695  break;
16696 
16697  case '[':
16698  if (*++m != ']') return -1;
16699  if (*++m == '=') ++m;
16700  break;
16701 
16702  case '!':
16703  if (len == 1) return ID_JUNK;
16704  switch (*++m) {
16705  case '=': case '~': ++m; break;
16706  default: return -1;
16707  }
16708  break;
16709 
16710  default:
16711  type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16712  id:
16713  if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16714  return -1;
16715  while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16716  if (m >= e) break;
16717  switch (*m) {
16718  case '!': case '?':
16719  if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16720  type = ID_JUNK;
16721  ++m;
16722  if (m + 1 < e || *m != '=') break;
16723  /* fall through */
16724  case '=':
16725  if (!(allowed_atttset & (1U << type))) return -1;
16726  type = ID_ATTRSET;
16727  ++m;
16728  break;
16729  }
16730  break;
16731  }
16732  return m == e ? type : -1;
16733 }
16734 
16735 int
16736 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16737 {
16738  return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
16739 }
16740 
16741 static int
16742 rb_str_symname_type(VALUE name, unsigned int allowed_atttset)
16743 {
16744  const char *ptr = StringValuePtr(name);
16745  long len = RSTRING_LEN(name);
16746  int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_atttset);
16747  RB_GC_GUARD(name);
16748  return type;
16749 }
16750 
16751 static ID
16752 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16753 {
16754  VALUE str = rb_enc_str_new(name, len, enc);
16755  return register_symid_str(id, str);
16756 }
16757 
16758 static ID
16760 {
16761  OBJ_FREEZE(str);
16764  return id;
16765 }
16766 
16767 static int
16769 {
16770  if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
16771  switch (rb_enc_str_coderange(str)) {
16772  case ENC_CODERANGE_BROKEN:
16773  rb_raise(rb_eEncodingError, "invalid encoding symbol");
16774  case ENC_CODERANGE_7BIT:
16775  return TRUE;
16776  }
16777  return FALSE;
16778 }
16779 
16780 /*
16781  * _str_ itself will be registered at the global symbol table. _str_
16782  * can be modified before the registration, since the encoding will be
16783  * set to ASCII-8BIT if it is a special global name.
16784  */
16785 static ID intern_str(VALUE str);
16786 
16787 ID
16788 rb_intern3(const char *name, long len, rb_encoding *enc)
16789 {
16790  VALUE str;
16791  st_data_t data;
16792  struct RString fake_str;
16793  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
16794  fake_str.basic.klass = rb_cString;
16795  fake_str.as.heap.len = len;
16796  fake_str.as.heap.ptr = (char *)name;
16797  fake_str.as.heap.aux.capa = len;
16798  str = (VALUE)&fake_str;
16799  rb_enc_associate(str, enc);
16800  OBJ_FREEZE(str);
16801 
16802  if (st_lookup(global_symbols.sym_id, str, &data))
16803  return (ID)data;
16804 
16805  str = rb_enc_str_new(name, len, enc); /* make true string */
16806  return intern_str(str);
16807 }
16808 
16809 static ID
16811 {
16812  const char *name, *m, *e;
16813  long len, last;
16814  rb_encoding *enc, *symenc;
16815  unsigned char c;
16816  ID id;
16817  int mb;
16818 
16819  RSTRING_GETMEM(str, name, len);
16820  m = name;
16821  e = m + len;
16822  enc = rb_enc_get(str);
16823  symenc = enc;
16824 
16825  if (!len || (rb_cString && !rb_enc_asciicompat(enc))) {
16826  junk:
16827  id = ID_JUNK;
16828  goto new_id;
16829  }
16830  last = len-1;
16831  id = 0;
16832  switch (*m) {
16833  case '$':
16834  if (len < 2) goto junk;
16835  id |= ID_GLOBAL;
16836  if ((mb = is_special_global_name(++m, e, enc)) != 0) {
16837  if (!--mb) symenc = rb_usascii_encoding();
16838  goto new_id;
16839  }
16840  break;
16841  case '@':
16842  if (m[1] == '@') {
16843  if (len < 3) goto junk;
16844  m++;
16845  id |= ID_CLASS;
16846  }
16847  else {
16848  if (len < 2) goto junk;
16849  id |= ID_INSTANCE;
16850  }
16851  m++;
16852  break;
16853  default:
16854  c = m[0];
16855  if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
16856  /* operators */
16857  int i;
16858 
16859  if (len == 1) {
16860  id = c;
16861  goto id_register;
16862  }
16863  for (i = 0; i < op_tbl_count; i++) {
16864  if (*op_tbl[i].name == *m &&
16865  strcmp(op_tbl[i].name, m) == 0) {
16866  id = op_tbl[i].token;
16867  goto id_register;
16868  }
16869  }
16870  }
16871  break;
16872  }
16873  if (name[last] == '=') {
16874  /* attribute assignment */
16875  if (last > 1 && name[last-1] == '=')
16876  goto junk;
16877  id = rb_intern3(name, last, enc);
16878  if (id > tLAST_OP_ID && !is_attrset_id(id)) {
16879  enc = rb_enc_get(rb_id2str(id));
16880  id = rb_id_attrset(id);
16881  goto id_register;
16882  }
16883  id = ID_ATTRSET;
16884  }
16885  else if (id == 0) {
16886  if (rb_enc_isupper(m[0], enc)) {
16887  id = ID_CONST;
16888  }
16889  else {
16890  id = ID_LOCAL;
16891  }
16892  }
16893  if (!rb_enc_isdigit(*m, enc)) {
16894  while (m <= name + last && is_identchar(m, e, enc)) {
16895  if (ISASCII(*m)) {
16896  m++;
16897  }
16898  else {
16899  m += rb_enc_mbclen(m, e, enc);
16900  }
16901  }
16902  }
16903  if (id != ID_ATTRSET && m - name < len) id = ID_JUNK;
16904  if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
16905  new_id:
16906  if (symenc != enc) rb_enc_associate(str, symenc);
16908  if (len > 20) {
16909  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
16910  name);
16911  }
16912  else {
16913  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
16914  (int)len, name);
16915  }
16916  }
16918  id_register:
16919  return register_symid_str(id, str);
16920 }
16921 
16922 ID
16923 rb_intern2(const char *name, long len)
16924 {
16925  return rb_intern3(name, len, rb_usascii_encoding());
16926 }
16927 
16928 #undef rb_intern
16929 ID
16930 rb_intern(const char *name)
16931 {
16932  return rb_intern2(name, strlen(name));
16933 }
16934 
16935 ID
16937 {
16938  st_data_t id;
16939 
16940  if (st_lookup(global_symbols.sym_id, str, &id))
16941  return (ID)id;
16942  return intern_str(rb_str_dup(str));
16943 }
16944 
16945 VALUE
16947 {
16948  st_data_t data;
16949 
16950  if (id < tLAST_TOKEN) {
16951  int i = 0;
16952 
16953  if (id < INT_MAX && rb_ispunct((int)id)) {
16954  VALUE str = global_symbols.op_sym[i = (int)id];
16955  if (!str) {
16956  char name[2];
16957  name[0] = (char)id;
16958  name[1] = 0;
16959  str = rb_usascii_str_new(name, 1);
16960  OBJ_FREEZE(str);
16961  global_symbols.op_sym[i] = str;
16962  }
16963  return str;
16964  }
16965  for (i = 0; i < op_tbl_count; i++) {
16966  if (op_tbl[i].token == id) {
16967  VALUE str = global_symbols.op_sym[i];
16968  if (!str) {
16969  str = rb_usascii_str_new2(op_tbl[i].name);
16970  OBJ_FREEZE(str);
16971  global_symbols.op_sym[i] = str;
16972  }
16973  return str;
16974  }
16975  }
16976  }
16977 
16978  if (st_lookup(global_symbols.id_str, id, &data)) {
16979  VALUE str = (VALUE)data;
16980  if (RBASIC(str)->klass == 0)
16981  RBASIC(str)->klass = rb_cString;
16982  return str;
16983  }
16984 
16985  if (is_attrset_id(id)) {
16986  ID id_stem = (id & ~ID_SCOPE_MASK);
16987  VALUE str;
16988 
16989  do {
16990  if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break;
16991  if (!!(str = rb_id2str(id_stem | ID_CONST))) break;
16992  if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break;
16993  if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break;
16994  if (!!(str = rb_id2str(id_stem | ID_CLASS))) break;
16995  if (!!(str = rb_id2str(id_stem | ID_JUNK))) break;
16996  return 0;
16997  } while (0);
16998  str = rb_str_dup(str);
16999  rb_str_cat(str, "=", 1);
17000  register_symid_str(id, str);
17001  if (st_lookup(global_symbols.id_str, id, &data)) {
17002  VALUE str = (VALUE)data;
17003  if (RBASIC(str)->klass == 0)
17004  RBASIC(str)->klass = rb_cString;
17005  return str;
17006  }
17007  }
17008  return 0;
17009 }
17010 
17011 const char *
17013 {
17014  VALUE str = rb_id2str(id);
17015 
17016  if (!str) return 0;
17017  return RSTRING_PTR(str);
17018 }
17019 
17020 static int
17022 {
17023  rb_ary_push(ary, ID2SYM(value));
17024  return ST_CONTINUE;
17025 }
17026 
17027 /*
17028  * call-seq:
17029  * Symbol.all_symbols => array
17030  *
17031  * Returns an array of all the symbols currently in Ruby's symbol
17032  * table.
17033  *
17034  * Symbol.all_symbols.size #=> 903
17035  * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
17036  * :chown, :EOFError, :$;, :String,
17037  * :LOCK_SH, :"setuid?", :$<,
17038  * :default_proc, :compact, :extend,
17039  * :Tms, :getwd, :$=, :ThreadGroup,
17040  * :wait2, :$>]
17041  */
17042 
17043 VALUE
17045 {
17047 
17049  return ary;
17050 }
17051 
17052 int
17054 {
17055  return is_const_id(id);
17056 }
17057 
17058 int
17060 {
17061  return is_class_id(id);
17062 }
17063 
17064 int
17066 {
17067  return is_global_id(id);
17068 }
17069 
17070 int
17072 {
17073  return is_instance_id(id);
17074 }
17075 
17076 int
17078 {
17079  return is_attrset_id(id);
17080 }
17081 
17082 int
17084 {
17085  return is_local_id(id);
17086 }
17087 
17088 int
17090 {
17091  return is_junk_id(id);
17092 }
17093 
17105 ID
17106 rb_check_id(volatile VALUE *namep)
17107 {
17108  st_data_t id;
17109  VALUE tmp;
17110  VALUE name = *namep;
17111 
17112  if (SYMBOL_P(name)) {
17113  return SYM2ID(name);
17114  }
17115  else if (!RB_TYPE_P(name, T_STRING)) {
17116  tmp = rb_check_string_type(name);
17117  if (NIL_P(tmp)) {
17118  tmp = rb_inspect(name);
17119  rb_raise(rb_eTypeError, "%s is not a symbol",
17120  RSTRING_PTR(tmp));
17121  }
17122  name = tmp;
17123  *namep = name;
17124  }
17125 
17126  sym_check_asciionly(name);
17127 
17128  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17129  return (ID)id;
17130 
17131  if (rb_is_attrset_name(name)) {
17132  struct RString fake_str;
17133  const VALUE localname = (VALUE)&fake_str;
17134  /* make local name by chopping '=' */
17135  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17136  fake_str.basic.klass = rb_cString;
17137  fake_str.as.heap.len = RSTRING_LEN(name) - 1;
17138  fake_str.as.heap.ptr = RSTRING_PTR(name);
17139  fake_str.as.heap.aux.capa = fake_str.as.heap.len;
17140  rb_enc_copy(localname, name);
17141  OBJ_FREEZE(localname);
17142 
17143  if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17144  return rb_id_attrset((ID)id);
17145  }
17146  RB_GC_GUARD(name);
17147  }
17148 
17149  return (ID)0;
17150 }
17151 
17152 ID
17153 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
17154 {
17155  st_data_t id;
17156  struct RString fake_str;
17157  const VALUE name = (VALUE)&fake_str;
17158  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17159  fake_str.basic.klass = rb_cString;
17160  fake_str.as.heap.len = len;
17161  fake_str.as.heap.ptr = (char *)ptr;
17162  fake_str.as.heap.aux.capa = len;
17163  rb_enc_associate(name, enc);
17164 
17165  sym_check_asciionly(name);
17166 
17167  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17168  return (ID)id;
17169 
17170  if (rb_is_attrset_name(name)) {
17171  fake_str.as.heap.len = len - 1;
17172  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
17173  return rb_id_attrset((ID)id);
17174  }
17175  }
17176 
17177  return (ID)0;
17178 }
17179 
17180 int
17182 {
17183  return rb_str_symname_type(name, 0) == ID_CONST;
17184 }
17185 
17186 int
17188 {
17189  return rb_str_symname_type(name, 0) == ID_CLASS;
17190 }
17191 
17192 int
17194 {
17195  return rb_str_symname_type(name, 0) == ID_GLOBAL;
17196 }
17197 
17198 int
17200 {
17201  return rb_str_symname_type(name, 0) == ID_INSTANCE;
17202 }
17203 
17204 int
17206 {
17208 }
17209 
17210 int
17212 {
17213  return rb_str_symname_type(name, 0) == ID_LOCAL;
17214 }
17215 
17216 int
17218 {
17219  switch (rb_str_symname_type(name, 0)) {
17220  case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17221  return TRUE;
17222  }
17223  return FALSE;
17224 }
17225 
17226 int
17228 {
17229  return rb_str_symname_type(name, IDSET_ATTRSET_FOR_SYNTAX) == -1;
17230 }
17231 
17232 #endif /* !RIPPER */
17233 
17234 static void
17236 {
17237  parser->eofp = Qfalse;
17238 
17239  parser->parser_lex_strterm = 0;
17240  parser->parser_cond_stack = 0;
17241  parser->parser_cmdarg_stack = 0;
17242  parser->parser_class_nest = 0;
17243  parser->parser_paren_nest = 0;
17244  parser->parser_lpar_beg = 0;
17245  parser->parser_brace_nest = 0;
17246  parser->parser_in_single = 0;
17247  parser->parser_in_def = 0;
17248  parser->parser_in_defined = 0;
17249  parser->parser_compile_for_eval = 0;
17250  parser->parser_cur_mid = 0;
17251  parser->parser_tokenbuf = NULL;
17252  parser->parser_tokidx = 0;
17253  parser->parser_toksiz = 0;
17254  parser->parser_heredoc_end = 0;
17255  parser->parser_command_start = TRUE;
17256  parser->parser_deferred_nodes = 0;
17257  parser->parser_lex_pbeg = 0;
17258  parser->parser_lex_p = 0;
17259  parser->parser_lex_pend = 0;
17260  parser->parser_lvtbl = 0;
17261  parser->parser_ruby__end__seen = 0;
17262  parser->parser_ruby_sourcefile = 0;
17264 #ifndef RIPPER
17265  parser->is_ripper = 0;
17266  parser->parser_eval_tree_begin = 0;
17267  parser->parser_eval_tree = 0;
17268 #else
17269  parser->is_ripper = 1;
17270  parser->delayed = Qnil;
17271 
17272  parser->result = Qnil;
17273  parser->parsing_thread = Qnil;
17274  parser->toplevel_p = TRUE;
17275 #endif
17276 #ifdef YYMALLOC
17277  parser->heap = NULL;
17278 #endif
17279  parser->enc = rb_utf8_encoding();
17280 }
17281 
17282 #ifdef RIPPER
17283 #define parser_mark ripper_parser_mark
17284 #define parser_free ripper_parser_free
17285 #endif
17286 
17287 static void
17289 {
17290  struct parser_params *p = (struct parser_params*)ptr;
17291 
17298 #ifndef RIPPER
17301  rb_gc_mark(p->debug_lines);
17302 #else
17303  rb_gc_mark(p->delayed);
17304  rb_gc_mark(p->value);
17305  rb_gc_mark(p->result);
17306  rb_gc_mark(p->parsing_thread);
17307 #endif
17308 #ifdef YYMALLOC
17309  rb_gc_mark((VALUE)p->heap);
17310 #endif
17311 }
17312 
17313 static void
17314 parser_free(void *ptr)
17315 {
17316  struct parser_params *p = (struct parser_params*)ptr;
17317  struct local_vars *local, *prev;
17318 
17319  if (p->parser_tokenbuf) {
17320  xfree(p->parser_tokenbuf);
17321  }
17322  for (local = p->parser_lvtbl; local; local = prev) {
17323  if (local->vars) xfree(local->vars);
17324  prev = local->prev;
17325  xfree(local);
17326  }
17327  xfree(p);
17328 }
17329 
17330 static size_t
17331 parser_memsize(const void *ptr)
17332 {
17333  struct parser_params *p = (struct parser_params*)ptr;
17334  struct local_vars *local;
17335  size_t size = sizeof(*p);
17336 
17337  if (!ptr) return 0;
17338  size += p->parser_toksiz;
17339  for (local = p->parser_lvtbl; local; local = local->prev) {
17340  size += sizeof(*local);
17341  if (local->vars) size += local->vars->capa * sizeof(ID);
17342  }
17343  return size;
17344 }
17345 
17346 static
17347 #ifndef RIPPER
17348 const
17349 #endif
17350 rb_data_type_t parser_data_type = {
17351  "parser",
17352  {
17353  parser_mark,
17354  parser_free,
17356  },
17357 };
17358 
17359 #ifndef RIPPER
17360 #undef rb_reserved_word
17361 
17362 const struct kwtable *
17363 rb_reserved_word(const char *str, unsigned int len)
17364 {
17365  return reserved_word(str, len);
17366 }
17367 
17368 static struct parser_params *
17370 {
17371  struct parser_params *p;
17372 
17373  p = ALLOC_N(struct parser_params, 1);
17374  MEMZERO(p, struct parser_params, 1);
17375  parser_initialize(p);
17376  return p;
17377 }
17378 
17379 VALUE
17381 {
17382  struct parser_params *p = parser_new();
17383 
17384  return TypedData_Wrap_Struct(0, &parser_data_type, p);
17385 }
17386 
17387 /*
17388  * call-seq:
17389  * ripper#end_seen? -> Boolean
17390  *
17391  * Return true if parsed source ended by +\_\_END\_\_+.
17392  */
17393 VALUE
17395 {
17396  struct parser_params *parser;
17397 
17398  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17399  return ruby__end__seen ? Qtrue : Qfalse;
17400 }
17401 
17402 /*
17403  * call-seq:
17404  * ripper#encoding -> encoding
17405  *
17406  * Return encoding of the source.
17407  */
17408 VALUE
17410 {
17411  struct parser_params *parser;
17412 
17413  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17415 }
17416 
17417 /*
17418  * call-seq:
17419  * ripper.yydebug -> true or false
17420  *
17421  * Get yydebug.
17422  */
17423 VALUE
17425 {
17426  struct parser_params *parser;
17427 
17428  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17429  return yydebug ? Qtrue : Qfalse;
17430 }
17431 
17432 /*
17433  * call-seq:
17434  * ripper.yydebug = flag
17435  *
17436  * Set yydebug.
17437  */
17438 VALUE
17440 {
17441  struct parser_params *parser;
17442 
17443  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17444  yydebug = RTEST(flag);
17445  return flag;
17446 }
17447 
17448 #ifdef YYMALLOC
17449 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17450 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17451 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17452  (n)->u3.cnt = (c), (p))
17453 
17454 void *
17455 rb_parser_malloc(struct parser_params *parser, size_t size)
17456 {
17457  size_t cnt = HEAPCNT(1, size);
17458  NODE *n = NEWHEAP();
17459  void *ptr = xmalloc(size);
17460 
17461  return ADD2HEAP(n, cnt, ptr);
17462 }
17463 
17464 void *
17465 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17466 {
17467  size_t cnt = HEAPCNT(nelem, size);
17468  NODE *n = NEWHEAP();
17469  void *ptr = xcalloc(nelem, size);
17470 
17471  return ADD2HEAP(n, cnt, ptr);
17472 }
17473 
17474 void *
17475 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17476 {
17477  NODE *n;
17478  size_t cnt = HEAPCNT(1, size);
17479 
17480  if (ptr && (n = parser->heap) != NULL) {
17481  do {
17482  if (n->u1.node == ptr) {
17483  n->u1.node = ptr = xrealloc(ptr, size);
17484  if (n->u3.cnt) n->u3.cnt = cnt;
17485  return ptr;
17486  }
17487  } while ((n = n->u2.node) != NULL);
17488  }
17489  n = NEWHEAP();
17490  ptr = xrealloc(ptr, size);
17491  return ADD2HEAP(n, cnt, ptr);
17492 }
17493 
17494 void
17495 rb_parser_free(struct parser_params *parser, void *ptr)
17496 {
17497  NODE **prev = &parser->heap, *n;
17498 
17499  while ((n = *prev) != NULL) {
17500  if (n->u1.node == ptr) {
17501  *prev = n->u2.node;
17503  break;
17504  }
17505  prev = &n->u2.node;
17506  }
17507  xfree(ptr);
17508 }
17509 #endif
17510 #endif
17511 
17512 #ifdef RIPPER
17513 #ifdef RIPPER_DEBUG
17514 extern int rb_is_pointer_to_heap(VALUE);
17515 
17516 /* :nodoc: */
17517 static VALUE
17518 ripper_validate_object(VALUE self, VALUE x)
17519 {
17520  if (x == Qfalse) return x;
17521  if (x == Qtrue) return x;
17522  if (x == Qnil) return x;
17523  if (x == Qundef)
17524  rb_raise(rb_eArgError, "Qundef given");
17525  if (FIXNUM_P(x)) return x;
17526  if (SYMBOL_P(x)) return x;
17527  if (!rb_is_pointer_to_heap(x))
17528  rb_raise(rb_eArgError, "invalid pointer: %p", x);
17529  switch (TYPE(x)) {
17530  case T_STRING:
17531  case T_OBJECT:
17532  case T_ARRAY:
17533  case T_BIGNUM:
17534  case T_FLOAT:
17535  return x;
17536  case T_NODE:
17537  if (nd_type(x) != NODE_LASGN) {
17538  rb_raise(rb_eArgError, "NODE given: %p", x);
17539  }
17540  return ((NODE *)x)->nd_rval;
17541  default:
17542  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17543  x, rb_obj_classname(x));
17544  }
17545  return x;
17546 }
17547 #endif
17548 
17549 #define validate(x) ((x) = get_value(x))
17550 
17551 static VALUE
17552 ripper_dispatch0(struct parser_params *parser, ID mid)
17553 {
17554  return rb_funcall(parser->value, mid, 0);
17555 }
17556 
17557 static VALUE
17558 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17559 {
17560  validate(a);
17561  return rb_funcall(parser->value, mid, 1, a);
17562 }
17563 
17564 static VALUE
17565 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17566 {
17567  validate(a);
17568  validate(b);
17569  return rb_funcall(parser->value, mid, 2, a, b);
17570 }
17571 
17572 static VALUE
17573 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17574 {
17575  validate(a);
17576  validate(b);
17577  validate(c);
17578  return rb_funcall(parser->value, mid, 3, a, b, c);
17579 }
17580 
17581 static VALUE
17582 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17583 {
17584  validate(a);
17585  validate(b);
17586  validate(c);
17587  validate(d);
17588  return rb_funcall(parser->value, mid, 4, a, b, c, d);
17589 }
17590 
17591 static VALUE
17592 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17593 {
17594  validate(a);
17595  validate(b);
17596  validate(c);
17597  validate(d);
17598  validate(e);
17599  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17600 }
17601 
17602 static VALUE
17603 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17604 {
17605  validate(a);
17606  validate(b);
17607  validate(c);
17608  validate(d);
17609  validate(e);
17610  validate(f);
17611  validate(g);
17612  return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17613 }
17614 
17615 static const struct kw_assoc {
17616  ID id;
17617  const char *name;
17618 } keyword_to_name[] = {
17619  {keyword_class, "class"},
17620  {keyword_module, "module"},
17621  {keyword_def, "def"},
17622  {keyword_undef, "undef"},
17623  {keyword_begin, "begin"},
17624  {keyword_rescue, "rescue"},
17625  {keyword_ensure, "ensure"},
17626  {keyword_end, "end"},
17627  {keyword_if, "if"},
17628  {keyword_unless, "unless"},
17629  {keyword_then, "then"},
17630  {keyword_elsif, "elsif"},
17631  {keyword_else, "else"},
17632  {keyword_case, "case"},
17633  {keyword_when, "when"},
17634  {keyword_while, "while"},
17635  {keyword_until, "until"},
17636  {keyword_for, "for"},
17637  {keyword_break, "break"},
17638  {keyword_next, "next"},
17639  {keyword_redo, "redo"},
17640  {keyword_retry, "retry"},
17641  {keyword_in, "in"},
17642  {keyword_do, "do"},
17643  {keyword_do_cond, "do"},
17644  {keyword_do_block, "do"},
17645  {keyword_return, "return"},
17646  {keyword_yield, "yield"},
17647  {keyword_super, "super"},
17648  {keyword_self, "self"},
17649  {keyword_nil, "nil"},
17650  {keyword_true, "true"},
17651  {keyword_false, "false"},
17652  {keyword_and, "and"},
17653  {keyword_or, "or"},
17654  {keyword_not, "not"},
17655  {modifier_if, "if"},
17656  {modifier_unless, "unless"},
17657  {modifier_while, "while"},
17658  {modifier_until, "until"},
17659  {modifier_rescue, "rescue"},
17660  {keyword_alias, "alias"},
17661  {keyword_defined, "defined?"},
17662  {keyword_BEGIN, "BEGIN"},
17663  {keyword_END, "END"},
17664  {keyword__LINE__, "__LINE__"},
17665  {keyword__FILE__, "__FILE__"},
17666  {keyword__ENCODING__, "__ENCODING__"},
17667  {0, NULL}
17668 };
17669 
17670 static const char*
17671 keyword_id_to_str(ID id)
17672 {
17673  const struct kw_assoc *a;
17674 
17675  for (a = keyword_to_name; a->id; a++) {
17676  if (a->id == id)
17677  return a->name;
17678  }
17679  return NULL;
17680 }
17681 
17682 #undef ripper_id2sym
17683 static VALUE
17684 ripper_id2sym(ID id)
17685 {
17686  const char *name;
17687  char buf[8];
17688 
17689  if (id <= 256) {
17690  buf[0] = (char)id;
17691  buf[1] = '\0';
17692  return ID2SYM(rb_intern2(buf, 1));
17693  }
17694  if ((name = keyword_id_to_str(id))) {
17695  return ID2SYM(rb_intern(name));
17696  }
17697  switch (id) {
17698  case tOROP:
17699  name = "||";
17700  break;
17701  case tANDOP:
17702  name = "&&";
17703  break;
17704  default:
17705  name = rb_id2name(id);
17706  if (!name) {
17707  rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17708  }
17709  return ID2SYM(id);
17710  }
17711  return ID2SYM(rb_intern(name));
17712 }
17713 
17714 static ID
17715 ripper_get_id(VALUE v)
17716 {
17717  NODE *nd;
17718  if (!RB_TYPE_P(v, T_NODE)) return 0;
17719  nd = (NODE *)v;
17720  if (nd_type(nd) != NODE_LASGN) return 0;
17721  return nd->nd_vid;
17722 }
17723 
17724 static VALUE
17725 ripper_get_value(VALUE v)
17726 {
17727  NODE *nd;
17728  if (v == Qundef) return Qnil;
17729  if (!RB_TYPE_P(v, T_NODE)) return v;
17730  nd = (NODE *)v;
17731  if (nd_type(nd) != NODE_LASGN) return Qnil;
17732  return nd->nd_rval;
17733 }
17734 
17735 static void
17736 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17737 {
17738  VALUE str;
17739  va_list args;
17740 
17741  va_start(args, fmt);
17742  str = rb_vsprintf(fmt, args);
17743  va_end(args);
17744  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17745 }
17746 
17747 static void
17748 ripper_warn0(struct parser_params *parser, const char *fmt)
17749 {
17750  rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
17751 }
17752 
17753 static void
17754 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
17755 {
17756  rb_funcall(parser->value, rb_intern("warn"), 2,
17757  STR_NEW2(fmt), INT2NUM(a));
17758 }
17759 
17760 static void
17761 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
17762 {
17763  rb_funcall(parser->value, rb_intern("warn"), 2,
17764  STR_NEW2(fmt), STR_NEW2(str));
17765 }
17766 
17767 static void
17768 ripper_warning0(struct parser_params *parser, const char *fmt)
17769 {
17770  rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
17771 }
17772 
17773 static void
17774 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
17775 {
17776  rb_funcall(parser->value, rb_intern("warning"), 2,
17777  STR_NEW2(fmt), STR_NEW2(str));
17778 }
17779 
17780 static VALUE
17781 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
17782 {
17783  return rb_io_gets(src);
17784 }
17785 
17786 static VALUE
17787 ripper_s_allocate(VALUE klass)
17788 {
17789  struct parser_params *p;
17790  VALUE self;
17791 
17792  p = ALLOC_N(struct parser_params, 1);
17793  MEMZERO(p, struct parser_params, 1);
17794  self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
17795  p->value = self;
17796  return self;
17797 }
17798 
17799 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
17800 
17801 /*
17802  * call-seq:
17803  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
17804  *
17805  * Create a new Ripper object.
17806  * _src_ must be a String, an IO, or an Object which has #gets method.
17807  *
17808  * This method does not starts parsing.
17809  * See also Ripper#parse and Ripper.parse.
17810  */
17811 static VALUE
17812 ripper_initialize(int argc, VALUE *argv, VALUE self)
17813 {
17814  struct parser_params *parser;
17815  VALUE src, fname, lineno;
17816 
17817  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17818  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
17819  if (RB_TYPE_P(src, T_FILE)) {
17820  parser->parser_lex_gets = ripper_lex_get_generic;
17821  }
17822  else {
17823  StringValue(src);
17824  parser->parser_lex_gets = lex_get_str;
17825  }
17826  parser->parser_lex_input = src;
17827  parser->eofp = Qfalse;
17828  if (NIL_P(fname)) {
17829  fname = STR_NEW2("(ripper)");
17830  }
17831  else {
17832  StringValue(fname);
17833  }
17834  parser_initialize(parser);
17835 
17836  parser->parser_ruby_sourcefile_string = fname;
17837  parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
17838  parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
17839 
17840  return Qnil;
17841 }
17842 
17843 struct ripper_args {
17844  struct parser_params *parser;
17845  int argc;
17846  VALUE *argv;
17847 };
17848 
17849 static VALUE
17850 ripper_parse0(VALUE parser_v)
17851 {
17852  struct parser_params *parser;
17853 
17854  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17855  parser_prepare(parser);
17856  ripper_yyparse((void*)parser);
17857  return parser->result;
17858 }
17859 
17860 static VALUE
17861 ripper_ensure(VALUE parser_v)
17862 {
17863  struct parser_params *parser;
17864 
17865  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17866  parser->parsing_thread = Qnil;
17867  return Qnil;
17868 }
17869 
17870 /*
17871  * call-seq:
17872  * ripper#parse
17873  *
17874  * Start parsing and returns the value of the root action.
17875  */
17876 static VALUE
17877 ripper_parse(VALUE self)
17878 {
17879  struct parser_params *parser;
17880 
17881  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17882  if (!ripper_initialized_p(parser)) {
17883  rb_raise(rb_eArgError, "method called for uninitialized object");
17884  }
17885  if (!NIL_P(parser->parsing_thread)) {
17886  if (parser->parsing_thread == rb_thread_current())
17887  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
17888  else
17889  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
17890  }
17891  parser->parsing_thread = rb_thread_current();
17892  rb_ensure(ripper_parse0, self, ripper_ensure, self);
17893 
17894  return parser->result;
17895 }
17896 
17897 /*
17898  * call-seq:
17899  * ripper#column -> Integer
17900  *
17901  * Return column number of current parsing line.
17902  * This number starts from 0.
17903  */
17904 static VALUE
17905 ripper_column(VALUE self)
17906 {
17907  struct parser_params *parser;
17908  long col;
17909 
17910  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17911  if (!ripper_initialized_p(parser)) {
17912  rb_raise(rb_eArgError, "method called for uninitialized object");
17913  }
17914  if (NIL_P(parser->parsing_thread)) return Qnil;
17915  col = parser->tokp - parser->parser_lex_pbeg;
17916  return LONG2NUM(col);
17917 }
17918 
17919 /*
17920  * call-seq:
17921  * ripper#filename -> String
17922  *
17923  * Return current parsing filename.
17924  */
17925 static VALUE
17926 ripper_filename(VALUE self)
17927 {
17928  struct parser_params *parser;
17929 
17930  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17931  if (!ripper_initialized_p(parser)) {
17932  rb_raise(rb_eArgError, "method called for uninitialized object");
17933  }
17934  return parser->parser_ruby_sourcefile_string;
17935 }
17936 
17937 /*
17938  * call-seq:
17939  * ripper#lineno -> Integer
17940  *
17941  * Return line number of current parsing line.
17942  * This number starts from 1.
17943  */
17944 static VALUE
17945 ripper_lineno(VALUE self)
17946 {
17947  struct parser_params *parser;
17948 
17949  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17950  if (!ripper_initialized_p(parser)) {
17951  rb_raise(rb_eArgError, "method called for uninitialized object");
17952  }
17953  if (NIL_P(parser->parsing_thread)) return Qnil;
17954  return INT2NUM(parser->parser_ruby_sourceline);
17955 }
17956 
17957 #ifdef RIPPER_DEBUG
17958 /* :nodoc: */
17959 static VALUE
17960 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
17961 {
17962  StringValue(msg);
17963  if (obj == Qundef) {
17964  rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
17965  }
17966  return Qnil;
17967 }
17968 
17969 /* :nodoc: */
17970 static VALUE
17971 ripper_value(VALUE self, VALUE obj)
17972 {
17973  return ULONG2NUM(obj);
17974 }
17975 #endif
17976 
17977 
17978 void
17979 Init_ripper(void)
17980 {
17981  parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
17982 
17985  /* ensure existing in symbol table */
17986  (void)rb_intern("||");
17987  (void)rb_intern("&&");
17988 
17989  InitVM(ripper);
17990 }
17991 
17992 void
17993 InitVM_ripper(void)
17994 {
17995  VALUE Ripper;
17996 
17997  Ripper = rb_define_class("Ripper", rb_cObject);
17998  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
17999  rb_define_alloc_func(Ripper, ripper_s_allocate);
18000  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
18001  rb_define_method(Ripper, "parse", ripper_parse, 0);
18002  rb_define_method(Ripper, "column", ripper_column, 0);
18003  rb_define_method(Ripper, "filename", ripper_filename, 0);
18004  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
18005  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
18006  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
18007  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
18008  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
18009 #ifdef RIPPER_DEBUG
18010  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
18011  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
18012  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
18013 #endif
18014 
18017 
18018 # if 0
18019  /* Hack to let RDoc document SCRIPT_LINES__ */
18020 
18021  /*
18022  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
18023  * after the assignment will be added as an Array of lines with the file
18024  * name as the key.
18025  */
18026  rb_define_global_const("SCRIPT_LINES__", Qnil);
18027 #endif
18028 
18029 }
18030 #endif /* RIPPER */
18031 
#define STRNCASECMP(s1, s2, n)
Definition: ruby.h:1646
RUBY_EXTERN VALUE rb_cString
Definition: ruby.h:1456
#define in_defined
Definition: ripper.c:380
static const struct @60 op_tbl[]
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:2218
char * parser_ruby_sourcefile
Definition: ripper.c:327
VALUE val
Definition: parse.h:164
#define local_var(id)
Definition: ripper.c:558
#define cond(node)
Definition: ripper.c:424
#define arg_var(id)
Definition: ripper.c:560
#define ret_args(node)
Definition: ripper.c:475
#define yyparse
Definition: ripper.c:418
#define T_OBJECT
Definition: ruby.h:485
Definition: node.h:93
Definition: node.h:29
stack_type cmdargs
Definition: ripper.c:193
#define NEW_RETURN(s)
Definition: node.h:383
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
VALUE rb_ary_unshift(VALUE ary, VALUE item)
Definition: array.c:1071
static ID ripper_token2eventid(int tok)
Definition: eventids2.c:273
Definition: lex.c:33
#define IS_LABEL_SUFFIX(n)
Definition: ripper.c:13368
#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:17077
int rb_enc_codelen(int c, rb_encoding *enc)
Definition: encoding.c:954
#define NEW_OP_ASGN_AND(i, val)
Definition: node.h:403
static double zero(void)
Definition: isinf.c:51
#define lex_input
Definition: ripper.c:385
#define lex_state
Definition: ripper.c:369
#define subnodes(n1, n2)
#define parser_precise_mbclen()
Definition: ripper.c:11649
static NODE * remove_begin(NODE *)
Definition: ripper.c:15533
#define MBCLEN_CHARFOUND_P(ret)
Definition: encoding.h:138
#define NEW_STRTERM(func, term, paren)
Definition: ripper.c:12667
static const yytype_int16 yydefgoto[]
Definition: ripper.c:1873
#define list_concat(h, t)
Definition: ripper.c:449
static struct parser_params * parser_new(void)
Definition: ripper.c:17369
Definition: parse.c:862
#define NEW_OP_ASGN1(p, id, a)
Definition: node.h:399
int onig_foreach_name(regex_t *reg, int(*func)(const UChar *, const UChar *, int, int *, regex_t *, void *), void *arg)
Definition: regparse.c:537
union YYSTYPE YYSTYPE
#define NEW_SCLASS(r, b)
Definition: node.h:442
#define yydebug
Definition: ripper.c:402
static NODE * arg_blk_pass(NODE *, NODE *)
Definition: ripper.c:15875
static void Init_id(void)
Definition: id.c:14
static ID internal_id_gen(struct parser_params *)
Definition: ripper.c:16589
#define RARRAY_LEN(a)
Definition: ruby.h:899
Definition: parse.c:870
void rb_bug(const char *fmt,...)
Definition: error.c:295
int num
Definition: parse.h:167
#define IS_END()
Definition: ripper.c:13364
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:15799
static const struct kwtable * reserved_word(const char *, unsigned int)
#define tail
Definition: st.c:108
#define NEW_LIST(a)
Definition: node.h:385
int rb_is_class_name(VALUE name)
Definition: ripper.c:17187
#define NEW_DEFINED(e)
Definition: node.h:454
struct vtable * used
Definition: ripper.c:191
#define tHEREDOC_BEG
Definition: eventids2.c:7
NODE * rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
Definition: ripper.c:12023
static int comment_at_top(struct parser_params *parser)
Definition: ripper.c:13109
#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
#define INT2NUM(x)
Definition: ruby.h:1178
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2525
int i
Definition: win32ole.c:784
static size_t parser_memsize(const void *ptr)
Definition: ripper.c:17331
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:12047
#define scan_oct(s, l, e)
Definition: util.h:52
#define nd_plen
Definition: node.h:327
#define T_FIXNUM
Definition: ruby.h:497
Definition: st.h:77
VALUE stack_type
Definition: ripper.c:164
#define IDSET_ATTRSET_FOR_SYNTAX
Definition: ripper.c:16635
#define reg_compile(str, options)
Definition: ripper.c:512
VALUE rb_id2str(ID id)
Definition: ripper.c:16946
static NODE * call_uni_op_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:14961
Definition: node.h:47
#define toksiz
Definition: ripper.c:383
#define NEW_XSTR(s)
Definition: node.h:419
#define YY_(msgid)
Definition: ripper.c:976
int parser_ruby__end__seen
Definition: ripper.c:324
int parser_command_start
Definition: ripper.c:319
static void fixpos(NODE *, NODE *)
Definition: ripper.c:14711
VALUE rb_range_new(VALUE, VALUE, int)
Definition: range.c:67
#define NUM2INT(x)
Definition: ruby.h:622
#define YYSTACK_FREE
Definition: ripper.c:1045
#define NEW_DOT2(b, e)
Definition: node.h:447
static void reduce_nodes_gen(struct parser_params *, NODE **)
Definition: ripper.c:15543
#define value_expr(node)
Definition: ripper.c:434
#define nd_paren(node)
Definition: ripper.c:599
static NODE * call_bin_op_gen(struct parser_params *, NODE *, ID, NODE *)
Definition: ripper.c:14953
const char * name
Definition: lex.c:33
#define tEMBDOC_BEG
Definition: eventids2.c:3
static int parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp, int string_literal, int symbol_literal, int regexp_literal)
Definition: ripper.c:12216
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
int parser_brace_nest
Definition: ripper.c:304
#define YYLEX
Definition: ripper.c:4393
#define InitVM(ext)
Definition: ruby.h:1651
static NODE * new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: ripper.c:16005
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:1967
#define YYABORT
Definition: ripper.c:4313
Definition: id.h:81
#define nd_line(n)
Definition: node.h:282
static void parser_heredoc_restore(struct parser_params *parser, NODE *here)
Definition: ripper.c:12875
#define lex_eol_p()
Definition: ripper.c:12083
#define Qtrue
Definition: ruby.h:434
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2299
Definition: id.h:78
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 CMDARG_LEXPOP()
Definition: ripper.c:178
static NODE * gettable_gen(struct parser_params *, ID)
Definition: ripper.c:15002
#define str_copy(_s, _p, _n)
#define was_bol()
Definition: ripper.c:12153
#define TypedData_Wrap_Struct(klass, data_type, sval)
Definition: ruby.h:1016
#define IS_SPCARG(c)
Definition: ripper.c:13366
#define void_stmts(node)
Definition: ripper.c:438
static struct symbols global_symbols
Definition: parse.c:854
static YYSIZE_T yystrlen(char *yystr) const
Definition: ripper.c:4596
VALUE rb_parser_end_seen_p(VALUE vparser)
Definition: ripper.c:17394
#define TypedData_Get_Struct(obj, type, data_type, sval)
Definition: ruby.h:1030
const int id
Definition: nkf.c:209
#define current_enc
Definition: ripper.c:401
int line_count
Definition: ripper.c:325
#define YYNTOKENS
Definition: ripper.c:1141
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
node_type
Definition: node.h:22
static NODE * parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
Definition: ripper.c:11956
#define new_args(f, o, r, p, t)
Definition: ripper.c:469
#define strcasecmp
Definition: win32.h:200
Definition: parse.c:839
Definition: parse.c:867
#define ID_CONST
Definition: id.h:22
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:345
#define nextc()
Definition: ripper.c:11539
#define rb_warning0(fmt)
Definition: ripper.c:698
VALUE rb_enc_from_encoding(rb_encoding *encoding)
Definition: encoding.c:103
#define token_info_push(token)
Definition: ripper.c:737
VALUE rb_eTypeError
Definition: error.c:516
static int parser_here_document(struct parser_params *, NODE *)
Definition: ripper.c:12922
NODE * node
Definition: parse.h:165
#define rb_warnS(fmt, a)
Definition: ripper.c:696
#define dsym_node(node)
Definition: ripper.c:480
long(* rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len)
Definition: ripper.c:13121
st_table * names
Definition: encoding.c:53
#define ID_JUNK
Definition: id.h:24
#define ULONG2NUM(x)
Definition: ruby.h:1209
#define logop(type, node1, node2)
Definition: ripper.c:426
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:822
#define rb_long2int(n)
Definition: ruby.h:325
static void yydestruct(char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser) const
Definition: ripper.c:4832
#define NEW_CLASS(n, b, s)
Definition: node.h:441
#define MAX_WORD_LENGTH
Definition: lex.c:43
static NODE * evstr2dstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:14930
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:16313
union RNode::@93 u1
static void warn_unused_var(struct parser_params *parser, struct local_vars *local)
Definition: ripper.c:16040
#define SYM2ID(x)
Definition: ruby.h:364
struct RBasic basic
Definition: ruby.h:843
unsigned short int yytype_uint16
Definition: ripper.c:943
#define parse_string(n)
Definition: ripper.c:11549
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:789
Definition: parse.c:860
#define NEW_OPT_N(b)
Definition: node.h:369
const struct kwtable * rb_reserved_word(const char *str, unsigned int len)
Definition: ripper.c:17363
#define is_identchar(p, e, enc)
Definition: ripper.c:11650
VALUE op_sym[tLAST_OP_ID]
Definition: ripper.c:16525
#define COND_PUSH(n)
Definition: ripper.c:171
VALUE debug_lines
Definition: ripper.c:338
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
Definition: vm_eval.c:773
#define warn_balanced(op, syn)
Definition: ripper.c:13378
struct RString::@73::@74 heap
ID id
Definition: parse.h:166
#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 yyerrok
Definition: ripper.c:4307
#define YYEMPTY
Definition: ripper.c:4309
#define tok()
Definition: ripper.c:12156
int rb_enc_str_coderange(VALUE)
Definition: string.c:327
static void ripper_init_eventids1_table(VALUE self)
Definition: eventids1.c:270
#define reg_fragment_setenc(str, options)
Definition: ripper.c:514
static NODE * match_op_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14968
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1788
#define rb_warn4S(file, line, fmt, a)
Definition: ripper.c:697
Definition: parse.c:840
#define rb_warnI(fmt, a)
Definition: ripper.c:695
#define NEW_NIL()
Definition: node.h:450
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Definition: ruby.h:875
static NODE * node_assign_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15337
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:14734
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: ripper.c:4410
static NODE * newline_node(NODE *)
Definition: ripper.c:14701
ID * tbl
Definition: ripper.c:182
const rb_data_type_t * parent
Definition: ruby.h:969
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:177
#define newtok()
Definition: ripper.c:11541
static NODE * range_op(struct parser_params *parser, NODE *node)
Definition: ripper.c:15698
#define reduce_nodes(n)
Definition: ripper.c:440
#define YYPOPSTACK(N)
#define dyna_var(id)
Definition: ripper.c:572
int pre_args_num
Definition: node.h:510
#define RB_GC_GUARD(v)
Definition: ruby.h:530
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
#define NODE_HEREDOC
Definition: ripper.c:591
#define T_HASH
Definition: ruby.h:493
int parser_toksiz
Definition: ripper.c:310
#define POINTER_P(val)
Definition: ripper.c:199
#define STR_FUNC_INDENT
Definition: ripper.c:12052
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
Definition: encoding.c:886
#define ID_LOCAL
Definition: id.h:18
st_index_t rb_str_hash(VALUE)
Definition: string.c:2248
#define nd_args
Definition: node.h:331
VALUE rb_ary_new3(long n,...)
Definition: array.c:432
Definition: parse.c:882
static void parser_pushback(struct parser_params *parser, int c)
Definition: ripper.c:12144
#define nd_set_type(n, t)
Definition: node.h:277
ID last_id
Definition: ripper.c:16518
#define Qnone
Definition: ripper.c:686
static int lvar_defined_gen(struct parser_params *, ID)
Definition: ripper.c:13050
const char * alias
Definition: nkf.c:1151
void rb_gc_mark(VALUE ptr)
Definition: gc.c:2600
#define ruby__end__seen
Definition: ripper.c:397
void(* rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13122
#define T_ARRAY
Definition: ruby.h:492
#define NEW_DOT3(b, e)
Definition: node.h:448
#define ruby_debug_lines
Definition: ripper.c:407
#define parser_is_identchar()
Definition: ripper.c:11651
#define rb_enc_islower(c, enc)
Definition: encoding.h:176
#define local_pop()
Definition: ripper.c:556
#define NEW_ITER(a, b)
Definition: node.h:373
static int parser_whole_match_p(struct parser_params *parser, const char *eos, long len, int indent)
Definition: ripper.c:12892
#define RE_OPTION_ENCODING(e)
Definition: ripper.c:584
#define rb_backref_error(n)
Definition: ripper.c:493
NODE * pre_init
Definition: node.h:507
#define ISDIGIT(c)
#define NEW_IVAR(v)
Definition: node.h:408
unsigned int last
Definition: nkf.c:4310
static void parser_initialize(struct parser_params *parser)
Definition: ripper.c:17235
ID block_arg
Definition: node.h:516
static NODE * node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE)
Definition: ripper.c:14681
static const yytype_uint16 yyr1[]
Definition: ripper.c:1624
ID rb_check_id(volatile VALUE *namep)
Returns ID for the given name if it is interned already, or 0.
Definition: ripper.c:17106
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
Definition: ripper.c:17153
struct RNode * node
Definition: node.h:243
#define NEW_IASGN(v, val)
Definition: node.h:394
#define FIXNUM_P(f)
Definition: ruby.h:355
#define lex_gets_ptr
Definition: ripper.c:394
rb_encoding * rb_utf8_encoding(void)
Definition: encoding.c:1166
#define here_document(n)
Definition: ripper.c:11551
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:13057
#define nd_type(n)
Definition: node.h:276
#define is_instance_id(id)
Definition: ripper.c:113
#define call_bin_op(recv, id, arg1)
Definition: ripper.c:464
Definition: parse.c:859
VALUE klass
Definition: ruby.h:701
#define arg_concat(h, t)
Definition: ripper.c:453
static enum node_type nodetype(NODE *node)
Definition: ripper.c:14689
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2109
VALUE rb_sym_all_symbols(void)
Definition: ripper.c:17044
static VALUE lex_getline(struct parser_params *parser)
Definition: ripper.c:11933
static NODE * ret_args_gen(struct parser_params *, NODE *)
Definition: ripper.c:15822
static const yytype_int16 yytable[]
Definition: ripper.c:2039
#define RUBY_DTRACE_PARSE_BEGIN(arg0, arg1)
Definition: probes.h:68
int pos
Definition: ripper.c:183
VALUE parser_ruby_sourcefile_string
Definition: ripper.c:329
Definition: parse.c:825
Definition: parse.c:883
#define YYLAST
Definition: ripper.c:1138
#define YYID(n)
Definition: ripper.c:989
int rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:16736
static NODE * yycompile(struct parser_params *parser, VALUE fname, int line)
Definition: ripper.c:11893
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: ripper.c:17439
#define ENC_CODERANGE_7BIT
Definition: encoding.h:58
const char * rb_obj_classname(VALUE)
Definition: variable.c:396
void rb_gc_force_recycle(VALUE p)
Definition: gc.c:2963
static int yylex(void *, void *)
Definition: ripper.c:14654
#define NEW_SCOPE(a, b)
Definition: node.h:363
#define head
Definition: st.c:107
#define ruby_sourcefile
Definition: ripper.c:399
unsigned char OnigUChar
Definition: oniguruma.h:113
int parser_yydebug
Definition: ripper.c:332
#define gettable(id)
Definition: ripper.c:483
Definition: node.h:27
st_table * id_str
Definition: ripper.c:16520
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
#define sym(x)
Definition: date_core.c:3715
static int simple_re_meta(int c)
Definition: ripper.c:12521
VALUE rb_str_buf_cat(VALUE, const char *, long)
Definition: string.c:1951
void rb_name_error(ID id, const char *fmt,...)
Definition: error.c:904
#define STR_NEW0()
Definition: ripper.c:359
Definition: node.h:239
static int e_option_supplied(struct parser_params *parser)
Definition: ripper.c:11827
static void block_dup_check_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15217
Definition: parse.h:159
int has_shebang
Definition: ripper.c:326
#define NEWHEAP()
Definition: ripper.c:17450
Win32OLEIDispatch * p
Definition: win32ole.c:786
#define SPECIAL_PUNCT(idx)
Definition: ripper.c:12694
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:15628
#define ISALPHA(c)
Definition: ruby.h:1636
void rb_exc_raise(VALUE mesg)
Definition: eval.c:527
#define STR_FUNC_REGEXP
Definition: ripper.c:12049
#define NEW_VCALL(m)
Definition: node.h:425
static NODE * list_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14788
int args
Definition: win32ole.c:785
#define strtod(s, e)
Definition: util.h:76
static rb_encoding * must_be_ascii_compatible(VALUE s)
Definition: ripper.c:11903
struct vtable * prev
Definition: ripper.c:185
int rb_is_const_id(ID id)
Definition: ripper.c:17053
int rb_is_instance_id(ID id)
Definition: ripper.c:17071
#define NEW_VALIAS(n, o)
Definition: node.h:439
#define RUBY_DTRACE_PARSE_END(arg0, arg1)
Definition: probes.h:72
#define RB_TYPE_P(obj, type)
Definition: ruby.h:1537
static int parser_tokadd_string(struct parser_params *, int, int, int, long *, rb_encoding **)
Definition: ripper.c:12534
#define NEW_LVAR(v)
Definition: node.h:406
#define VTBL_DEBUG
Definition: ripper.c:212
int rb_is_method_name(VALUE name)
Definition: ripper.c:17217
#define arg_append(h, t)
Definition: ripper.c:451
#define assignable_result(x)
int st_lookup(st_table *, st_data_t, st_data_t *)
#define CMDARG_PUSH(n)
Definition: ripper.c:176
#define NEW_ATTRASGN(r, m, a)
Definition: node.h:458
#define MEMZERO(p, type, n)
Definition: ruby.h:1241
Definition: ruby.h:842
static VALUE coverage(VALUE fname, int n)
Definition: ripper.c:11811
#define RE_OPTION_MASK
Definition: ripper.c:587
#define ID_SCOPE_MASK
Definition: id.h:17
static NODE * arg_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15286
rb_encoding * enc
Definition: ripper.c:330
#define parser_warning(node, mesg)
Definition: ripper.c:14724
static int parser_regx_options(struct parser_params *)
Definition: ripper.c:12462
static void yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: ripper.c:4433
enum lex_state_e parser_lex_state
Definition: ripper.c:296
#define whole_match_p(e, l, i)
Definition: ripper.c:11554
#define op_tbl_count
Definition: ripper.c:16511
#define NEW_POSTEXE(b)
Definition: node.h:456
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
NODE * rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: ripper.c:11982
#define set_yylval_literal(x)
Definition: ripper.c:11561
static int parser_yylex(struct parser_params *parser)
Definition: ripper.c:13384
static VALUE parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
Definition: ripper.c:12066
#define scan_hex(s, l, e)
Definition: util.h:54
static int dyna_in_block_gen(struct parser_params *)
Definition: ripper.c:16206
#define NEW_IF(c, t, e)
Definition: node.h:365
static const yytype_uint16 yystos[]
Definition: ripper.c:4197
static char * parser_tokspace(struct parser_params *parser, int n)
Definition: ripper.c:12177
#define RARRAY(obj)
Definition: ruby.h:1101
#define arg_ambiguous()
Definition: ripper.c:13036
#define ALLOC_N(type, n)
Definition: ruby.h:1223
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
static void parser_free(void *ptr)
Definition: ripper.c:17314
#define IS_ARG()
Definition: ripper.c:13363
#define PARSER_ARG
Definition: ripper.c:722
#define NEW_PRELUDE(p, b)
Definition: node.h:459
#define literal_concat(h, t)
Definition: ripper.c:455
#define val
int rb_ispunct(int c)
Definition: encoding.c:1890
Definition: parse.c:833
#define NEW_ARRAY(a)
Definition: node.h:386
RUBY_EXTERN VALUE rb_cObject
Definition: ruby.h:1426
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:17021
#define ID_INSTANCE
Definition: id.h:19
#define yylval
Definition: ripper.c:11530
static int parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
Definition: ripper.c:12389
#define rb_enc_isascii(c, enc)
Definition: encoding.h:174
static int dvar_curr_gen(struct parser_params *, ID)
Definition: ripper.c:16243
VALUE rb_parser_encoding(VALUE vparser)
Definition: ripper.c:17409
#define ifndef_ripper(x)
Definition: ripper.c:687
static const yytype_uint16 yyrline[]
Definition: ripper.c:1463
void rb_str_free(VALUE)
Definition: string.c:830
struct parser_params * parser
Definition: ripper.c:16305
#define yytable_value_is_error(yytable_value)
Definition: ripper.c:3117
#define cur_mid
Definition: ripper.c:379
#define NEW_HASH(a)
Definition: node.h:388
VALUE rb_get_coverages(void)
Definition: thread.c:5191
#define NEW_ZARRAY()
Definition: node.h:387
NODE * rb_compile_string(const char *f, VALUE s, int line)
Definition: ripper.c:11975
static const yytype_uint16 yyprhs[]
Definition: ripper.c:1200
#define NEW_FALSE()
Definition: node.h:452
VALUE rb_obj_as_string(VALUE)
Definition: string.c:895
static NODE * list_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14808
int parser_paren_nest
Definition: ripper.c:300
VALUE rb_ary_new(void)
Definition: array.c:424
int rb_ascii8bit_encindex(void)
Definition: encoding.c:1160
#define NEW_ARGSPUSH(a, b)
Definition: node.h:433
static int is_global_name_punct(const char c)
Definition: ripper.c:12711
#define is_attrset_id(id)
Definition: ripper.c:114
#define set_yylval_name(x)
Definition: ripper.c:11560
#define NEW_REDO()
Definition: node.h:377
#define NEW_NTH_REF(n)
Definition: node.h:411
#define IDSET_ATTRSET_FOR_INTERN
Definition: ripper.c:16636
#define tokline
Definition: ripper.c:384
#define NEW_UNLESS(c, t, e)
Definition: node.h:366
static char * parser_newtok(struct parser_params *parser)
Definition: ripper.c:12161
RUBY_EXTERN VALUE rb_mKernel
Definition: ruby.h:1414
#define snprintf
Definition: subst.h:6
VALUE rb_thread_current(void)
Definition: thread.c:2358
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:11543
static NODE * arg_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15311
static void local_push_gen(struct parser_params *, int)
Definition: ripper.c:16060
#define NIL_P(v)
Definition: ruby.h:446
#define ISASCII(c)
Definition: ruby.h:1629
void st_add_direct(st_table *, st_data_t, st_data_t)
Definition: st.c:629
#define tokenbuf
Definition: ripper.c:381
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:488
static char msg[50]
Definition: strerror.c:8
ID rb_intern(const char *name)
Definition: ripper.c:16930
#define COND_POP()
Definition: ripper.c:172
#define NEW_GVAR(v)
Definition: node.h:405
#define heredoc_identifier()
Definition: ripper.c:11552
NODE * opt_args
Definition: node.h:521
static void parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13134
#define NEW_YIELD(a)
Definition: node.h:384
#define YYSYNTAX_ERROR
#define new_const_op_assign(lhs, op, rhs)
Definition: ripper.c:501
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:2204
VALUE value
Definition: node.h:245
static void parser_tokadd(struct parser_params *parser, int c)
Definition: ripper.c:12189
#define ID_SCOPE_SHIFT
Definition: id.h:16
#define k__END__
Definition: eventids2.c:9
static void parser_mark(void *ptr)
Definition: ripper.c:17288
static void yy_reduce_print(YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
Definition: ripper.c:4525
#define ISALNUM(c)
Definition: ruby.h:1635
#define YYDPRINTF(Args)
Definition: ripper.c:4404
#define NEW_CASE(h, b)
Definition: node.h:367
rb_atomic_t cnt[RUBY_NSIG]
Definition: signal.c:432
#define RFLOAT(obj)
Definition: ruby.h:1098
Definition: parse.c:831
#define lex_goto_eol(parser)
Definition: ripper.c:12082
static double one(void)
Definition: isinf.c:52
Definition: parse.c:829
Definition: parse.c:864
#define FLONUM_P(x)
Definition: ruby.h:375
#define local_id(id)
Definition: ripper.c:562
#define T_FLOAT
Definition: ruby.h:489
NODE * rb_parser_append_print(VALUE vparser, NODE *node)
Definition: ripper.c:16414
#define TYPE(x)
Definition: ruby.h:513
static void ripper_init_eventids1(void)
Definition: eventids1.c:134
int argc
Definition: ruby.c:130
Definition: node.h:59
yytype_int16 yyss_alloc
Definition: ripper.c:1082
static void vtable_add(struct vtable *tbl, ID id)
Definition: ripper.c:239
Definition: parse.c:852
char ary[RSTRING_EMBED_LEN_MAX+1]
Definition: ruby.h:853
#define YYFINAL
Definition: ripper.c:1136
#define Qfalse
Definition: ruby.h:433
#define dvar_curr(id)
Definition: ripper.c:577
#define NEW_EVSTR(n)
Definition: node.h:422
#define ALLOCA_N(type, n)
Definition: ruby.h:1227
#define flush_string_content(enc)
Definition: ripper.c:12686
#define NEW_OP_CDECL(v, op, val)
Definition: node.h:404
#define T_BIGNUM
Definition: ruby.h:495
#define ENC_CODERANGE_UNKNOWN
Definition: encoding.h:57
#define tokadd_string(f, t, p, n, e)
Definition: ripper.c:11548
static NODE * new_yield_gen(struct parser_params *, NODE *)
Definition: ripper.c:15839
#define ripper_flush(p)
Definition: ripper.c:11580
static VALUE lex_get_str(struct parser_params *parser, VALUE s)
Definition: ripper.c:11913
static int rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_atttset)
Definition: ripper.c:16639
#define ISUPPER(c)
Definition: ruby.h:1633
#define RUBY_FUNC_EXPORTED
Definition: defines.h:184
#define MEMCPY(p1, p2, type, n)
Definition: ruby.h:1242
#define T_NODE
Definition: ruby.h:506
#define ENC_CODERANGE_BROKEN
Definition: encoding.h:60
Definition: parse.c:869
#define rb_enc_isupper(c, enc)
Definition: encoding.h:177
VALUE rb_enc_associate_index(VALUE obj, int idx)
Definition: encoding.c:748
int rb_parse_in_main(void)
Definition: compile.c:5943
static int parser_nextc(struct parser_params *parser)
Definition: ripper.c:12088
int err
Definition: win32.c:87
#define dyna_pop(node)
Definition: ripper.c:569
Definition: parse.c:845
#define OBJ_FREEZE(x)
Definition: ruby.h:1164
#define YYACCEPT
Definition: ripper.c:4312
const char * parser_lex_pend
Definition: ripper.c:317
static ID formal_argument_gen(struct parser_params *, ID)
Definition: ripper.c:13039
static void void_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15430
#define YYEOF
Definition: ripper.c:4310
#define nd_else
Definition: node.h:294
static NODE * dsym_node_gen(struct parser_params *, NODE *)
Definition: ripper.c:15933
void rb_gc_mark_symbols(void)
Definition: ripper.c:16580
long cnt
Definition: node.h:261
ID token
Definition: ripper.c:16487
static ID intern_str(VALUE str)
Definition: ripper.c:16810
#define YY_REDUCE_PRINT(Rule)
Definition: ripper.c:4547
NODE * rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
Definition: ripper.c:16446
Definition: util.c:791
NODE * rb_compile_cstr(const char *f, const char *s, int len, int line)
Definition: ripper.c:11995
token_info * parser_token_info
Definition: ripper.c:343
static void magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13125
int column
Definition: ripper.c:273
static char * yystpcpy(char *yydest, const char *yysrc)
Definition: ripper.c:4620
#define IS_lex_state(ls)
Definition: ripper.c:158
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:772
#define ALLOC(type)
Definition: ruby.h:1224
#define END(no)
Definition: re.c:26
#define NEW_FOR(v, i, b)
Definition: node.h:372
#define EOF
Definition: vsnprintf.c:207
void * rb_parser_malloc(struct parser_params *parser, size_t size)
Definition: ripper.c:17455
#define NEW_WHEN(c, t, e)
Definition: node.h:368
#define peek_n(c, n)
Definition: ripper.c:12085
VALUE rb_str_resize(VALUE, long)
Definition: string.c:1854
#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 NEW_DASGN(v, val)
Definition: node.h:392
YYSTYPE yyvs_alloc
Definition: ripper.c:1083
static int parser_peek_variable_name(struct parser_params *parser)
Definition: ripper.c:12718
#define tokcopy(n)
Definition: ripper.c:12212
#define STR_FUNC_SYMBOL
Definition: ripper.c:12051
static VALUE yycompile0(VALUE arg)
Definition: ripper.c:11833
#define mixed_escape(beg, enc1, enc2)
int rb_str_hash_cmp(VALUE, VALUE)
Definition: string.c:2258
#define set_yylval_num(x)
Definition: ripper.c:11558
static ID register_symid_str(ID, VALUE)
Definition: ripper.c:16759
#define NEW_ERRINFO()
Definition: node.h:453
#define NEW_BLOCK_PASS(b)
Definition: node.h:437
#define STR_FUNC_QWORDS
Definition: ripper.c:12050
Definition: parse.c:846
#define dyna_push()
Definition: ripper.c:567
#define command_start
Definition: ripper.c:392
string_type
Definition: ripper.c:12054
int rb_dvar_defined(ID id)
Definition: compile.c:5893
static void dispose_string(VALUE str)
Definition: ripper.c:12498
union RString::@73 as
union RNode::@94 u2
#define is_notop_id(id)
Definition: ripper.c:110
#define RSTRING_LEN(str)
Definition: ruby.h:862
static NODE * aryset_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15209
int parser_in_single
Definition: ripper.c:302
lex_state_bits
Definition: ripper.c:125
#define RUBY_DTRACE_PARSE_END_ENABLED()
Definition: probes.h:71
static ID shadowing_lvar_gen(struct parser_params *, ID)
Definition: ripper.c:15171
ID rest_arg
Definition: node.h:515
#define REALLOC_N(var, type, n)
Definition: ruby.h:1225
#define local_push(top)
Definition: ripper.c:554
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:108
int errno
#define TRUE
Definition: nkf.h:175
int rb_symname_p(const char *name)
Definition: ripper.c:16624
#define nd_next
Definition: node.h:290
#define new_attr_op_assign(lhs, type, attr, op, rhs)
Definition: ripper.c:499
#define NEW_CONST(v)
Definition: node.h:409
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
Definition: ripper.c:4494
#define NEW_LIT(l)
Definition: node.h:416
VALUE rb_io_gets(VALUE)
Definition: io.c:3122
#define paren_nest
Definition: ripper.c:373
#define token_info_pop(token)
Definition: ripper.c:738
static void dyna_pop_gen(struct parser_params *, const struct vtable *)
Definition: ripper.c:16192
static NODE * new_evstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:14939
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1275
#define IS_lex_state_for(x, ls)
Definition: ripper.c:157
#define tokadd_mbchar(c)
Definition: ripper.c:12518
static void reg_fragment_setenc_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16251
#define NEW_OP_ASGN_OR(i, val)
Definition: node.h:402
#define rb_enc_isspace(c, enc)
Definition: encoding.h:181
#define rb_node_newnode(type, a1, a2, a3)
Definition: ripper.c:421
#define YYMAXDEPTH
Definition: ripper.c:4579
#define NEW_NEXT(s)
Definition: node.h:376
static void set_file_encoding(struct parser_params *parser, const char *str, const char *send)
Definition: ripper.c:13296
#define const
Definition: strftime.c:102
#define rb_enc_name(enc)
Definition: encoding.h:124
union RNode::@95 u3
int rb_is_attrset_name(VALUE name)
Definition: ripper.c:17205
#define RE_OPTION_ONCE
Definition: ripper.c:582
int rb_enc_symname_p(const char *name, rb_encoding *enc)
Definition: ripper.c:16630
#define tokidx
Definition: ripper.c:382
#define malloc
Definition: ripper.c:98
static const struct magic_comment magic_comments[]
Definition: ripper.c:13161
void Init_sym(void)
Definition: ripper.c:16561
const char * name
Definition: ripper.c:16488
static int parser_parse_string(struct parser_params *, NODE *)
Definition: ripper.c:12754
#define nd_term(node)
Definition: ripper.c:597
#define STR_FUNC_EXPAND
Definition: ripper.c:12048
#define rb_warningS(fmt, a)
Definition: ripper.c:699
static NODE * new_args_tail_gen(struct parser_params *, NODE *, ID, ID)
Definition: ripper.c:15908
#define NEW_RESCUE(b, res, e)
Definition: node.h:380
static int dvar_defined_gen(struct parser_params *, ID, int)
Definition: ripper.c:16212
int rb_is_local_id(ID id)
Definition: ripper.c:17083
rb_magic_comment_length_t length
Definition: ripper.c:13158
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:1570
static int local_id_gen(struct parser_params *, ID)
Definition: ripper.c:16135
#define YYSIZE_T
Definition: ripper.c:962
#define ESCAPE_META
Definition: ripper.c:12288
VALUE parser_cur_mid
Definition: ripper.c:306
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4308
short int yytype_int16
Definition: ripper.c:949
Definition: parse.c:826
Definition: parse.c:866
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Definition: array.c:545
#define PRIsVALUE
Definition: ruby.h:147
long parser_lex_gets_ptr
Definition: ripper.c:321
#define no_digits()
unsigned long ID
Definition: ruby.h:105
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1181
#define rb_enc_isalnum(c, enc)
Definition: encoding.h:179
static void rb_backref_error_gen(struct parser_params *, NODE *)
Definition: ripper.c:15273
#define rb_enc_isdigit(c, enc)
Definition: encoding.h:182
unsigned char yytype_uint8
Definition: ripper.c:928
#define nd_resq
Definition: node.h:298
static const yytype_int16 yyrhs[]
Definition: ripper.c:1268
#define Qnil
Definition: ruby.h:435
static void arg_ambiguous_gen(struct parser_params *parser)
Definition: ripper.c:13028
#define heredoc_restore(n)
Definition: ripper.c:11553
#define NEW_BACK_REF(n)
Definition: node.h:412
static void parser_prepare(struct parser_params *parser)
Definition: ripper.c:13339
static NODE * cond_gen(struct parser_params *, NODE *)
Definition: ripper.c:15792
Definition: parse.c:857
#define lex_lastline
Definition: ripper.c:386
int type
Definition: tcltklib.c:111
int id[2]
Definition: lex.c:33
#define NODE_FL_NEWLINE
Definition: node.h:269
static int options(unsigned char *cp)
Definition: nkf.c:6355
#define NEW_MASGN(l, r)
Definition: node.h:389
static const char *const yytname[]
Definition: ripper.c:1534
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: ripper.c:1102
#define NEW_COLON2(c, i)
Definition: node.h:444
unsigned long VALUE
Definition: ruby.h:104
stack_type parser_cond_stack
Definition: ripper.c:297
static VALUE result
Definition: nkf.c:40
NODE * post_init
Definition: node.h:508
static void ripper_init_eventids2(void)
Definition: eventids2.c:64
#define RBASIC(obj)
Definition: ruby.h:1094
int rb_is_junk_id(ID id)
Definition: ripper.c:17089
static void dyna_pop_1(struct parser_params *parser)
Definition: ripper.c:16174
static int parser_read_escape(struct parser_params *parser, int flags, rb_encoding **encp)
Definition: ripper.c:12291
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:12812
#define rb_enc_ispunct(c, enc)
Definition: encoding.h:178
ID rb_id_attrset(ID id)
Definition: ripper.c:15236
static int value_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15368
#define NEW_KW_ARG(i, v)
Definition: node.h:430
void rb_mark_tbl(st_table *tbl)
Definition: gc.c:2543
int post_args_num
Definition: node.h:511
#define lex_pend
Definition: ripper.c:390
#define NEW_ENSURE(b, en)
Definition: node.h:382
yytokentype
Definition: parse.c:772
int rb_is_global_id(ID id)
Definition: ripper.c:17065
static int reg_fragment_check_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16290
static const yytype_int16 yycheck[]
Definition: ripper.c:3120
#define YYUSE(e)
Definition: ripper.c:982
#define lvtbl
Definition: ripper.c:396
#define lex_strterm
Definition: ripper.c:368
#define NEW_ZSUPER()
Definition: node.h:427
#define rb_enc_asciicompat(enc)
Definition: encoding.h:184
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
Definition: eval.c:804
VALUE flags
Definition: ruby.h:700
#define free
Definition: ripper.c:101
static NODE * new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
Definition: ripper.c:15989
#define set_yylval_str(x)
Definition: ripper.c:11557
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Definition: re.c:301
#define NEW_COLON3(i)
Definition: node.h:445
#define NEW_BLOCK(a)
Definition: node.h:364
#define cond_stack
Definition: ripper.c:370
short int yytype_int8
Definition: ripper.c:937
#define nd_body
Definition: node.h:293
VALUE flags
Definition: node.h:240
static int is_static_content(NODE *node)
Definition: ripper.c:15604
const char * token
Definition: ripper.c:271
#define ENCODING_IS_ASCII8BIT(obj)
Definition: encoding.h:52
VALUE rb_str_dup(VALUE)
Definition: string.c:946
#define RUBY_DTRACE_PARSE_BEGIN_ENABLED()
Definition: probes.h:67
static const yytype_int16 yypgoto[]
Definition: ripper.c:2011
static int arg_var_gen(struct parser_params *, ID)
Definition: ripper.c:16118
#define rb_enc_isalpha(c, enc)
Definition: encoding.h:175
#define is_local_id(id)
Definition: ripper.c:111
Definition: parse.c:847
void xfree(void *)
int parser_in_defined
Definition: ripper.c:307
static int literal_concat0(struct parser_params *, VALUE, VALUE)
Definition: ripper.c:14832
static ID * local_tbl_gen(struct parser_params *)
Definition: ripper.c:16093
#define LONG2NUM(x)
Definition: ruby.h:1199
int parser_class_nest
Definition: ripper.c:299
#define brace_nest
Definition: ripper.c:375
#define reg_named_capture_assign(regexp, match)
Definition: ripper.c:518
#define NEW_BEGIN(b)
Definition: node.h:379
static int parser_yyerror(struct parser_params *, const char *)
Definition: ripper.c:11730
#define HEAPCNT(n, size)
Definition: ripper.c:17449
static void warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15661
#define RSTRING_PTR(str)
Definition: ruby.h:866
int rb_is_const_name(VALUE name)
Definition: ripper.c:17181
#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:12382
static void yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: ripper.c:4467
#define NEW_SPLAT(a)
Definition: node.h:434
static NODE * attrset_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:15265
int rb_is_local_name(VALUE name)
Definition: ripper.c:17211
VALUE rb_usascii_str_new2(const char *)
const struct vtable * vars
Definition: parse.h:168
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:2109
static VALUE reg_compile_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16385
st_table * st_init_table_with_size(const struct st_hash_type *, st_index_t)
Definition: st.c:229
#define ENCODING_GET(obj)
Definition: encoding.h:47
#define ESCAPE_CONTROL
Definition: ripper.c:12287
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:772
RUBY_EXTERN int ffs(int)
Definition: ffs.c:6
#define parser_isascii()
Definition: ripper.c:11653
void rb_gc_mark_parser(void)
Definition: ripper.c:16409
static const yytype_uint8 yytranslate[]
Definition: ripper.c:1157
#define RFLOAT_VALUE(v)
Definition: ruby.h:836
int nonspc
Definition: ripper.c:274
int size
Definition: encoding.c:52
#define NEW_DSTR(s)
Definition: node.h:418
#define ADD2HEAP(n, c, p)
Definition: ripper.c:17451
#define tokspace(n)
Definition: ripper.c:11542
#define f
#define in_def
Definition: ripper.c:377
#define INT2FIX(i)
Definition: ruby.h:241
static int is_private_local_id(ID name)
Definition: ripper.c:15158
#define NEW_GASGN(v, val)
Definition: node.h:390
#define is_const_id(id)
Definition: ripper.c:115
#define NEW_BREAK(s)
Definition: node.h:375
static void no_blockarg(struct parser_params *parser, NODE *node)
Definition: ripper.c:15814
static void local_pop_gen(struct parser_params *)
Definition: ripper.c:16077
Definition: parse.c:842
void rb_parser_free(struct parser_params *parser, void *ptr)
Definition: ripper.c:17495
int parser_tokidx
Definition: ripper.c:309
#define read_escape(flags, e)
Definition: ripper.c:11545
Definition: node.h:45
#define tok_hex(numlen)
Definition: ripper.c:11544
static NODE * literal_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14849
#define new_evstr(n)
Definition: ripper.c:458
#define xmalloc
Definition: defines.h:64
#define parser_warn(node, mesg)
Definition: ripper.c:14731
ID rb_intern_str(VALUE str)
Definition: ripper.c:16936
VALUE coverage
Definition: ripper.c:339
void rb_set_errinfo(VALUE err)
Definition: eval.c:1442
#define tokfix()
Definition: ripper.c:12155
#define NEW_TRUE()
Definition: node.h:451
#define internal_id()
Definition: ripper.c:564
NODE * parser_lex_strterm
Definition: ripper.c:295
const char * name
Definition: ripper.c:13156
#define COND_LEXPOP()
Definition: ripper.c:173
#define lex_p
Definition: ripper.c:389
#define tSP
Definition: eventids2.c:6
#define NEW_LAMBDA(a, b)
Definition: node.h:374
Definition: node.h:207
#define NEW_UNTIL(c, b, n)
Definition: node.h:371
static int token_info_get_column(struct parser_params *parser, const char *token)
Definition: ripper.c:11657
static const struct st_hash_type symhash
Definition: ripper.c:16528
#define node_assign(node1, node2)
Definition: ripper.c:495
static void void_stmts_gen(struct parser_params *, NODE *)
Definition: ripper.c:15519
#define void_expr(node)
Definition: ripper.c:436
static int local_var_gen(struct parser_params *, ID)
Definition: ripper.c:16125
#define RARRAY_PTR(a)
Definition: ruby.h:904
#define void_expr0(node)
Definition: ripper.c:435
#define lex_pbeg
Definition: ripper.c:388
#define regx_options()
Definition: ripper.c:11547
#define NEW_MODULE(n, b)
Definition: node.h:443
#define numberof(array)
Definition: ripper.c:92
static int token_info_has_nonspaces(struct parser_params *parser, const char *token)
Definition: ripper.c:11671
#define YYSTACK_ALLOC_MAXIMUM
Definition: ripper.c:1047
#define TOK_INTERN(mb)
Definition: ripper.c:363
static const rb_data_type_t parser_data_type
Definition: ripper.c:11953
rb_magic_comment_setter_t func
Definition: ripper.c:13157
int parser_lpar_beg
Definition: ripper.c:301
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:190
VALUE rb_check_string_type(VALUE)
Definition: string.c:1509
st_table * sym_id
Definition: ripper.c:16519
Definition: parse.c:850
uint8_t key[16]
Definition: random.c:1370
#define nd_head
Definition: node.h:288
struct local_vars * prev
Definition: ripper.c:192
static const yytype_uint16 yydefact[]
Definition: ripper.c:1762
static NODE * new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: ripper.c:15960
#define LONG2FIX(i)
Definition: ruby.h:242
#define parser_encoding_name()
Definition: ripper.c:11647
#define tokadd_escape(e)
Definition: ripper.c:11546
#define NEW_WHILE(c, b, n)
Definition: node.h:370
struct vtable * vars
Definition: ripper.c:190
#define RTEST(v)
Definition: ruby.h:445
Definition: node.h:139
#define T_STRING
Definition: ruby.h:490
static const yytype_int16 yypact[]
Definition: ripper.c:1900
static VALUE lex_io_gets(struct parser_params *parser, VALUE io)
Definition: ripper.c:12009
#define new_yield(node)
Definition: ripper.c:478
#define lvar_defined(id)
Definition: ripper.c:580
#define NEW_POSTARG(i, v)
Definition: node.h:431
#define RREGEXP(obj)
Definition: ruby.h:1100
#define NEW_UNDEF(i)
Definition: node.h:440
struct rb_encoding_entry * list
Definition: encoding.c:50
#define lpar_beg
Definition: ripper.c:374
#define YYTRANSLATE(YYX)
Definition: ripper.c:1153
void * rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
Definition: ripper.c:17465
v
Definition: win32ole.c:798
#define ID_ATTRSET
Definition: id.h:21
#define T_FILE
Definition: ruby.h:496
#define NEW_CVASGN(v, val)
Definition: node.h:397
#define yyerror(msg)
Definition: ripper.c:366
#define is_junk_id(id)
Definition: ripper.c:117
static void new_bv_gen(struct parser_params *, ID)
Definition: ripper.c:15195
#define deferred_nodes
Definition: ripper.c:393
#define ruby_coverage
Definition: ripper.c:408
#define NEW_FCALL(m, a)
Definition: node.h:424
Definition: parse.c:844
int linenum
Definition: ripper.c:272
static NODE * negate_lit(NODE *)
Definition: ripper.c:15847
#define tEMBDOC
Definition: eventids2.c:4
#define NEW_OP_ASGN2(r, i, o, val)
Definition: node.h:400
#define id_type(id)
Definition: ripper.c:118
#define NEW_MATCH3(r, n2)
Definition: node.h:415
Definition: parse.c:863
static void fixup_nodes(NODE **)
Definition: ripper.c:15667
#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:13169
#define NEW_OPT_ARG(i, v)
Definition: node.h:429
#define BEG(no)
Definition: re.c:25
static unsigned int hash(const char *str, unsigned int len)
Definition: lex.c:56
static int parser_magic_comment(struct parser_params *parser, const char *str, long len)
Definition: ripper.c:13202
int parser_tokline
Definition: ripper.c:311
#define IS_LABEL_POSSIBLE()
Definition: ripper.c:13367
VALUE rb_ary_new2(long capa)
Definition: array.c:417
VALUE rb_filesystem_str_new_cstr(const char *)
Definition: string.c:614
static const char id_type_names[][9]
Definition: ripper.c:15224
const char * parser_lex_pbeg
Definition: ripper.c:315
int rb_is_class_id(ID id)
Definition: ripper.c:17059
#define DVARS_TOPSCOPE
Definition: ripper.c:197
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
Definition: string.c:439
#define YYCASE_(N, S)
#define rb_safe_level()
Definition: tcltklib.c:94
VALUE rb_parser_new(void)
Definition: ripper.c:17380
Definition: ripper.c:181
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:1882
static void parser_set_encode(struct parser_params *parser, const char *name)
Definition: ripper.c:13077
#define call_uni_op(recv, id)
Definition: ripper.c:466
static int literal_node(NODE *node)
Definition: ripper.c:15714
#define set_yylval_node(x)
Definition: ripper.c:11562
#define YYSTACK_BYTES(N)
Definition: ripper.c:1091
#define IS_BEG()
Definition: ripper.c:13365
const char * parser_lex_p
Definition: ripper.c:316
static int parser_tok_hex(struct parser_params *parser, size_t *numlen)
Definition: ripper.c:12199
Definition: parse.c:841
#define xrealloc
Definition: defines.h:67
#define RE_OPTION_ENCODING_NONE(o)
Definition: ripper.c:586
lex_state_e
Definition: ripper.c:140
#define ID2SYM(x)
Definition: ruby.h:363
Definition: node.h:61
#define dvar_defined_get(id)
Definition: ripper.c:575
int rb_is_instance_name(VALUE name)
Definition: ripper.c:17199
int parser_ruby_sourceline
Definition: ripper.c:328
const char * rb_id2name(ID id)
Definition: ripper.c:17012
#define NEW_RETRY()
Definition: node.h:378
#define ruby_eval_tree_begin
Definition: ripper.c:406
#define rb_errinfo()
Definition: tcltklib.c:89
#define ruby_sourcefile_string
Definition: ripper.c:400
unsigned long st_data_t
Definition: st.h:35
#define StringValuePtr(v)
Definition: ruby.h:547
#define formal_argument(id)
Definition: ripper.c:547
#define nd_value
Definition: node.h:318
#define ID_INTERNAL
Definition: id.h:25
Definition: parse.c:851
static int nodeline(NODE *node)
Definition: ripper.c:14695
#define dispatch_heredoc_end()
Definition: ripper.c:12918
YYSTYPE * parser_yylval
Definition: ripper.c:292
#define ruby_eval_tree
Definition: ripper.c:405
VALUE rb_str_new_frozen(VALUE)
Definition: string.c:713
#define toklast()
Definition: ripper.c:12158
#define lex_gets
Definition: ripper.c:395
#define toklen()
Definition: ripper.c:12157
static const yytype_uint8 yyr2[]
Definition: ripper.c:1692
#define NEW_RESBODY(a, ex, n)
Definition: node.h:381
Definition: parse.c:853
#define NEW_ARGSCAT(a, b)
Definition: node.h:432
#define NEW_DASGN_CURR(v, val)
Definition: node.h:393
VALUE rb_inspect(VALUE)
Definition: object.c:411
#define cmdarg_stack
Definition: ripper.c:371
#define in_single
Definition: ripper.c:376
#define YY_STACK_PRINT(Bottom, Top)
Definition: ripper.c:4508
#define YYFPRINTF
Definition: ripper.c:4401
NODE * rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
Definition: ripper.c:11988
#define NEW_SUPER(a)
Definition: node.h:426
#define NEW_CALL(r, m, a)
Definition: node.h:423
int is_ripper
Definition: ripper.c:289
static NODE * cond0(struct parser_params *, NODE *)
Definition: ripper.c:15735
rb_encoding * rb_ascii8bit_encoding(void)
Definition: encoding.c:1151
int rb_is_junk_name(VALUE name)
Definition: ripper.c:17227
#define peek(c)
Definition: ripper.c:12084
int rb_enc_find_index(const char *name)
Definition: encoding.c:635
static NODE * splat_array(NODE *)
Definition: ripper.c:15329
static struct vtable * vtable_alloc(struct vtable *prev)
Definition: ripper.c:215
VALUE eofp
Definition: ripper.c:293
Definition: node.h:31
RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e-0x20+31)/32]
Definition: ripper.c:12689
long len
Definition: ruby.h:846
#define CONST_ID(var, str)
Definition: ruby.h:1318
NODE * heap
Definition: ripper.c:290
ID rb_intern3(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:16788
#define attrset(node, id)
Definition: ripper.c:490
VALUE rb_str_intern(VALUE)
Definition: string.c:7229
#define NEW_CVAR(v)
Definition: node.h:410
#define COND_P()
Definition: ripper.c:174
#define mixed_error(enc1, enc2)
static ID register_symid(ID, const char *, long, rb_encoding *)
Definition: ripper.c:16752
Definition: parse.c:868
#define NEW_MATCH2(n1, n2)
Definition: node.h:414
static const struct vtable * dyna_push_gen(struct parser_params *)
Definition: ripper.c:16163
ID first_post_arg
Definition: node.h:513
void * rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
Definition: ripper.c:17475
st_table * st_init_numtable_with_size(st_index_t)
Definition: st.c:278
#define shadowing_lvar(name)
Definition: ripper.c:549
Definition: parse.c:856
VALUE rb_cstr_to_inum(const char *str, int base, int badcheck)
Definition: bignum.c:579
#define get_value(val)
Definition: ripper.c:521
Definition: id.h:71
#define rb_enc_mbcput(c, buf, enc)
Definition: encoding.h:161
#define NEW_DVAR(v)
Definition: node.h:407
#define NEW_DEFN(i, a, d, p)
Definition: node.h:360
#define reg_fragment_check(str, options)
Definition: ripper.c:516
int rb_parse_in_eval(void)
Definition: compile.c:5937
VALUE rb_str_buf_new(long)
Definition: string.c:777
VALUE rb_usascii_str_new(const char *, long)
Definition: string.c:431
#define compile_for_eval
Definition: ripper.c:378
#define SYMBOL_P(x)
Definition: ruby.h:362
#define tCOMMENT
Definition: eventids2.c:2
NODE * kw_args
Definition: node.h:518
#define set_yylval_id(x)
Definition: ripper.c:11559
ID rb_intern2(const char *name, long len)
Definition: ripper.c:16923
#define nd_iter
Definition: node.h:316
#define nd_set_line(n, l)
Definition: node.h:283
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1269
NODE * rb_compile_file(const char *f, VALUE file, int start)
Definition: ripper.c:12015
Definition: parse.c:838
static int is_special_global_name(const char *m, const char *e, rb_encoding *enc)
Definition: ripper.c:16598
#define is_class_id(id)
Definition: ripper.c:116
#define LVAR_USED
Definition: ripper.c:15168
static NODE * assignable_gen(struct parser_params *, ID, NODE *)
Definition: ripper.c:15079
VALUE rb_parser_get_yydebug(VALUE self)
Definition: ripper.c:17424
VALUE(* parser_lex_gets)(struct parser_params *, VALUE)
Definition: ripper.c:322
#define NULL
Definition: _sdbm.c:102
#define RTYPEDDATA_TYPE(v)
Definition: ruby.h:988
#define NEW_LASGN(v, val)
Definition: node.h:391
#define FIX2LONG(x)
Definition: ruby.h:353
static VALUE debug_lines(VALUE fname)
Definition: ripper.c:11795
#define Qundef
Definition: ruby.h:436
VALUE rb_hash_aset(VALUE, VALUE, VALUE)
#define tIGNORED_NL
Definition: eventids2.c:1
NODE * rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
Definition: ripper.c:12002
static int rb_str_symname_type(VALUE name, unsigned int allowed_atttset)
Definition: ripper.c:16742
#define NEW_STR(s)
Definition: node.h:417
#define yypact_value_is_default(yystate)
Definition: ripper.c:3114
Definition: parse.c:837
NODE * kw_rest_arg
Definition: node.h:519
#define ID_GLOBAL
Definition: id.h:20
#define ISXDIGIT(c)
Definition: ruby.h:1638
#define rb_warn0(fmt)
Definition: ripper.c:694
#define ENCODING_SET(obj, i)
Definition: encoding.h:37
int rb_local_defined(ID id)
Definition: compile.c:5918
st_index_t num_entries
Definition: st.h:93
Definition: parse.c:848
#define NEW_SELF()
Definition: node.h:449
Definition: parse.c:824
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:1344
Definition: parse.c:855
#define ruby_verbose
Definition: ruby.h:1363
VALUE rb_str_append(VALUE, VALUE)
Definition: string.c:2125
#define new_bv(id)
Definition: ripper.c:551
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
Definition: st.c:1006
static void warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15655
#define NEW_NODE(t, a0, a1, a2)
Definition: node.h:358
#define NEW_ARGS_AUX(r, b)
Definition: node.h:428
#define RSTRING_NOEMBED
Definition: ruby.h:856
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:80
#define block_append(h, t)
Definition: ripper.c:445
#define NEW_ALIAS(n, o)
Definition: node.h:438
NODE * rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
Definition: ripper.c:12029
VALUE rb_eArgError
Definition: error.c:517
static void vtable_free(struct vtable *tbl)
Definition: ripper.c:227
#define nd_lit
Definition: node.h:321
#define rb_enc_prev_char(s, p, e, enc)
Definition: encoding.h:164
#define T_REGEXP
Definition: ruby.h:491
Definition: node.h:137
unsigned long ruby_scan_oct(const char *, size_t, size_t *)
Definition: util.c:28
#define heredoc_end
Definition: ripper.c:391
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1122
struct vtable * args
Definition: ripper.c:189
#define tokaddmbc(c, enc)
Definition: ripper.c:11550
#define NEW_CDECL(v, val, path)
Definition: node.h:396
#define NEW_DEFS(r, i, a, d)
Definition: node.h:361
char ** argv
Definition: ruby.c:131
#define tEMBDOC_END
Definition: eventids2.c:5
char * ptr
Definition: ruby.h:847
#define DBL2NUM(dbl)
Definition: ruby.h:837
static void ripper_init_eventids2_table(VALUE self)
Definition: eventids2table.c:2
Definition: parse.c:849
#define ISSPACE(c)
Definition: ruby.h:1632
#define StringValue(v)
Definition: ruby.h:546
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:2078
#define pushback(c)
Definition: ripper.c:11540
#define STR_NEW2(p)
Definition: ripper.c:360
#define YYINITDEPTH
Definition: ripper.c:4568
static int sym_check_asciionly(VALUE str)
Definition: ripper.c:16768
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:16353
#define IS_AFTER_OPERATOR()
Definition: ripper.c:13369
VALUE rb_str_new(const char *, long)
Definition: string.c:425
Definition: parse.c:828
#define xcalloc
Definition: defines.h:66
#define ID_CLASS
Definition: id.h:23
static NODE * new_args_gen(struct parser_params *, NODE *, NODE *, ID, NODE *, NODE *)
Definition: ripper.c:15886
Definition: parse.c:843
int rb_is_global_name(VALUE name)
Definition: ripper.c:17193
static int parser_tokadd_mbchar(struct parser_params *parser, int c)
Definition: ripper.c:12505