Ruby  2.0.0p451(2014-02-24revision45167)
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. */
330 
332 
333 #ifndef RIPPER
334  /* Ruby core only */
339  int nerr;
340 
343 #else
344  /* Ripper only */
345  VALUE parser_ruby_sourcefile_string;
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 current_enc (parser->enc)
401 #define yydebug (parser->parser_yydebug)
402 #ifdef RIPPER
403 #else
404 #define ruby_eval_tree (parser->parser_eval_tree)
405 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin)
406 #define ruby_debug_lines (parser->debug_lines)
407 #define ruby_coverage (parser->coverage)
408 #endif
409 
410 #if YYPURE
411 static int yylex(void*, void*);
412 #else
413 static int yylex(void*);
414 #endif
415 
416 #ifndef RIPPER
417 #define yyparse ruby_yyparse
418 
419 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
420 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
421 
422 static NODE *cond_gen(struct parser_params*,NODE*);
423 #define cond(node) cond_gen(parser, (node))
424 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
425 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
426 
427 static NODE *newline_node(NODE*);
428 static void fixpos(NODE*,NODE*);
429 
430 static int value_expr_gen(struct parser_params*,NODE*);
431 static void void_expr_gen(struct parser_params*,NODE*);
432 static NODE *remove_begin(NODE*);
433 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
434 #define void_expr0(node) void_expr_gen(parser, (node))
435 #define void_expr(node) void_expr0((node) = remove_begin(node))
436 static void void_stmts_gen(struct parser_params*,NODE*);
437 #define void_stmts(node) void_stmts_gen(parser, (node))
438 static void reduce_nodes_gen(struct parser_params*,NODE**);
439 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
440 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
441 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
442 
443 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
444 #define block_append(h,t) block_append_gen(parser,(h),(t))
445 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
446 #define list_append(l,i) list_append_gen(parser,(l),(i))
447 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
448 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
449 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
450 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
451 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
452 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
453 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
454 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
455 static int literal_concat0(struct parser_params *, VALUE, VALUE);
456 static NODE *new_evstr_gen(struct parser_params*,NODE*);
457 #define new_evstr(n) new_evstr_gen(parser,(n))
458 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
459 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
460 static NODE *splat_array(NODE*);
461 
462 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
463 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
464 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
465 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
466 
467 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
468 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
469 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);
470 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
471 
472 static NODE *negate_lit(NODE*);
473 static NODE *ret_args_gen(struct parser_params*,NODE*);
474 #define ret_args(node) ret_args_gen(parser, (node))
475 static NODE *arg_blk_pass(NODE*,NODE*);
476 static NODE *new_yield_gen(struct parser_params*,NODE*);
477 #define new_yield(node) new_yield_gen(parser, (node))
478 static NODE *dsym_node_gen(struct parser_params*,NODE*);
479 #define dsym_node(node) dsym_node_gen(parser, (node))
480 
481 static NODE *gettable_gen(struct parser_params*,ID);
482 #define gettable(id) gettable_gen(parser,(id))
483 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
484 #define assignable(id,node) assignable_gen(parser, (id), (node))
485 
486 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
487 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
488 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
489 #define attrset(node,id) attrset_gen(parser, (node), (id))
490 
491 static void rb_backref_error_gen(struct parser_params*,NODE*);
492 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
493 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
494 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
495 
496 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
497 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
498 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
499 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
500 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
501 
502 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
503 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
504 
505 static ID *local_tbl_gen(struct parser_params*);
506 #define local_tbl() local_tbl_gen(parser)
507 
508 static void fixup_nodes(NODE **);
509 
510 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
511 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
512 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
513 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
514 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
515 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
516 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
517 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
518 
519 #define get_id(id) (id)
520 #define get_value(val) (val)
521 #else
522 #define value_expr(node) ((void)(node))
523 #define remove_begin(node) (node)
524 #define rb_dvar_defined(id) 0
525 #define rb_local_defined(id) 0
526 static ID ripper_get_id(VALUE);
527 #define get_id(id) ripper_get_id(id)
528 static VALUE ripper_get_value(VALUE);
529 #define get_value(val) ripper_get_value(val)
530 static VALUE assignable_gen(struct parser_params*,VALUE);
531 #define assignable(lhs,node) assignable_gen(parser, (lhs))
532 static int id_is_var_gen(struct parser_params *parser, ID id);
533 #define id_is_var(id) id_is_var_gen(parser, (id))
534 
535 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2))
536 
537 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
538 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);
539 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
540 
541 #endif /* !RIPPER */
542 
543 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
544 
545 static ID formal_argument_gen(struct parser_params*, ID);
546 #define formal_argument(id) formal_argument_gen(parser, (id))
547 static ID shadowing_lvar_gen(struct parser_params*,ID);
548 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
549 static void new_bv_gen(struct parser_params*,ID);
550 #define new_bv(id) new_bv_gen(parser, (id))
551 
552 static void local_push_gen(struct parser_params*,int);
553 #define local_push(top) local_push_gen(parser,(top))
554 static void local_pop_gen(struct parser_params*);
555 #define local_pop() local_pop_gen(parser)
556 static int local_var_gen(struct parser_params*, ID);
557 #define local_var(id) local_var_gen(parser, (id))
558 static int arg_var_gen(struct parser_params*, ID);
559 #define arg_var(id) arg_var_gen(parser, (id))
560 static int local_id_gen(struct parser_params*, ID);
561 #define local_id(id) local_id_gen(parser, (id))
562 static ID internal_id_gen(struct parser_params*);
563 #define internal_id() internal_id_gen(parser)
564 
565 static const struct vtable *dyna_push_gen(struct parser_params *);
566 #define dyna_push() dyna_push_gen(parser)
567 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
568 #define dyna_pop(node) dyna_pop_gen(parser, (node))
569 static int dyna_in_block_gen(struct parser_params*);
570 #define dyna_in_block() dyna_in_block_gen(parser)
571 #define dyna_var(id) local_var(id)
572 static int dvar_defined_gen(struct parser_params*,ID,int);
573 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
574 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
575 static int dvar_curr_gen(struct parser_params*,ID);
576 #define dvar_curr(id) dvar_curr_gen(parser, (id))
577 
578 static int lvar_defined_gen(struct parser_params*, ID);
579 #define lvar_defined(id) lvar_defined_gen(parser, (id))
580 
581 #define RE_OPTION_ONCE (1<<16)
582 #define RE_OPTION_ENCODING_SHIFT 8
583 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
584 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
585 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
586 #define RE_OPTION_MASK 0xff
587 #define RE_OPTION_ARG_ENCODING_NONE 32
588 
589 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
590 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
591 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
592 #define nd_func u1.id
593 #if SIZEOF_SHORT == 2
594 #define nd_term(node) ((signed short)(node)->u2.id)
595 #else
596 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
597 #endif
598 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
599 #define nd_nest u3.cnt
600 
601 /****** Ripper *******/
602 
603 #ifdef RIPPER
604 #define RIPPER_VERSION "0.1.0"
605 
606 #include "eventids1.c"
607 #include "eventids2.c"
608 
609 static VALUE ripper_dispatch0(struct parser_params*,ID);
610 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
611 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
612 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
613 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
614 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
615 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
616 
617 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
618 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
619 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
620 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
621 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
622 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
623 #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))
624 
625 #define yyparse ripper_yyparse
626 
627 #define ripper_intern(s) ID2SYM(rb_intern(s))
628 static VALUE ripper_id2sym(ID);
629 #ifdef __GNUC__
630 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
631  ID2SYM(id) : ripper_id2sym(id))
632 #endif
633 
634 #define arg_new() dispatch0(args_new)
635 #define arg_add(l,a) dispatch2(args_add, (l), (a))
636 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
637 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
638 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
639 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
640 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
641 
642 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
643 #define mrhs_new() dispatch0(mrhs_new)
644 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
645 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
646 
647 #define mlhs_new() dispatch0(mlhs_new)
648 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
649 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
650 
651 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
652  dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
653 
654 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
655 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
656 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
657 
658 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
659 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
660 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
661 
662 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
663 
664 static inline VALUE
665 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
666 {
667  NODE *t = (NODE *)tail;
668  VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
669  return params_new(f, o, r, p, k, kr, escape_Qundef(b));
670 }
671 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
672 
673 static inline VALUE
674 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
675 {
676  return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);
677 }
678 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
679 
680 #define FIXME 0
681 
682 #endif /* RIPPER */
683 
684 #ifndef RIPPER
685 # define Qnone 0
686 # define ifndef_ripper(x) (x)
687 #else
688 # define Qnone Qnil
689 # define ifndef_ripper(x)
690 #endif
691 
692 #ifndef RIPPER
693 # define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
694 # define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
695 # define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
696 # define rb_warn4S(file,line,fmt,a) rb_compile_warn((file), (line), (fmt), (a))
697 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
698 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
699 #else
700 # define rb_warn0(fmt) ripper_warn0(parser, (fmt))
701 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))
702 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))
703 # define rb_warn4S(file,line,fmt,a) ripper_warnS(parser, (fmt), (a))
704 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
705 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
706 static void ripper_warn0(struct parser_params*, const char*);
707 static void ripper_warnI(struct parser_params*, const char*, int);
708 static void ripper_warnS(struct parser_params*, const char*, const char*);
709 static void ripper_warning0(struct parser_params*, const char*);
710 static void ripper_warningS(struct parser_params*, const char*, const char*);
711 #endif
712 
713 #ifdef RIPPER
714 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
715 # define rb_compile_error ripper_compile_error
716 # define compile_error ripper_compile_error
717 # define PARSER_ARG parser,
718 #else
719 # define rb_compile_error rb_compile_error_with_enc
720 # define compile_error parser->nerr++,rb_compile_error_with_enc
721 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
722 #endif
723 
724 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
725  for instance). This is too low for Ruby to parse some files, such as
726  date/format.rb, therefore bump the value up to at least Bison's default. */
727 #ifdef OLD_YACC
728 #ifndef YYMAXDEPTH
729 #define YYMAXDEPTH 10000
730 #endif
731 #endif
732 
733 #ifndef RIPPER
734 static void token_info_push(struct parser_params*, const char *token);
735 static void token_info_pop(struct parser_params*, const char *token);
736 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
737 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
738 #else
739 #define token_info_push(token) /* nothing */
740 #define token_info_pop(token) /* nothing */
741 #endif
742 
743 
744 /* Line 268 of yacc.c */
745 #line 746 "parse.c"
746 
747 /* Enabling traces. */
748 #ifndef YYDEBUG
749 # define YYDEBUG 1
750 #endif
751 
752 /* Enabling verbose error messages. */
753 #ifdef YYERROR_VERBOSE
754 # undef YYERROR_VERBOSE
755 # define YYERROR_VERBOSE 1
756 #else
757 # define YYERROR_VERBOSE 0
758 #endif
759 
760 /* Enabling the token table. */
761 #ifndef YYTOKEN_TABLE
762 # define YYTOKEN_TABLE 0
763 #endif
764 
765 
766 /* Tokens. */
767 #ifndef YYTOKENTYPE
768 # define YYTOKENTYPE
769  /* Put the tokens into the symbol table, so that GDB and other debuggers
770  know about them. */
771  enum yytokentype {
772  END_OF_INPUT = 0,
773  keyword_class = 258,
774  keyword_module = 259,
775  keyword_def = 260,
776  keyword_undef = 261,
777  keyword_begin = 262,
778  keyword_rescue = 263,
779  keyword_ensure = 264,
780  keyword_end = 265,
781  keyword_if = 266,
782  keyword_unless = 267,
783  keyword_then = 268,
784  keyword_elsif = 269,
785  keyword_else = 270,
786  keyword_case = 271,
787  keyword_when = 272,
788  keyword_while = 273,
789  keyword_until = 274,
790  keyword_for = 275,
791  keyword_break = 276,
792  keyword_next = 277,
793  keyword_redo = 278,
794  keyword_retry = 279,
795  keyword_in = 280,
796  keyword_do = 281,
797  keyword_do_cond = 282,
798  keyword_do_block = 283,
799  keyword_do_LAMBDA = 284,
800  keyword_return = 285,
801  keyword_yield = 286,
802  keyword_super = 287,
803  keyword_self = 288,
804  keyword_nil = 289,
805  keyword_true = 290,
806  keyword_false = 291,
807  keyword_and = 292,
808  keyword_or = 293,
809  keyword_not = 294,
810  modifier_if = 295,
811  modifier_unless = 296,
812  modifier_while = 297,
813  modifier_until = 298,
814  modifier_rescue = 299,
815  keyword_alias = 300,
816  keyword_defined = 301,
817  keyword_BEGIN = 302,
818  keyword_END = 303,
819  keyword__LINE__ = 304,
820  keyword__FILE__ = 305,
821  keyword__ENCODING__ = 306,
822  tIDENTIFIER = 307,
823  tFID = 308,
824  tGVAR = 309,
825  tIVAR = 310,
826  tCONSTANT = 311,
827  tCVAR = 312,
828  tLABEL = 313,
829  tINTEGER = 314,
830  tFLOAT = 315,
831  tSTRING_CONTENT = 316,
832  tCHAR = 317,
833  tNTH_REF = 318,
834  tBACK_REF = 319,
835  tREGEXP_END = 320,
836  tUPLUS = 130,
837  tUMINUS = 131,
838  tPOW = 132,
839  tCMP = 134,
840  tEQ = 139,
841  tEQQ = 140,
842  tNEQ = 141,
843  tGEQ = 138,
844  tLEQ = 137,
845  tANDOP = 321,
846  tOROP = 322,
847  tMATCH = 142,
848  tNMATCH = 143,
849  tDOT2 = 128,
850  tDOT3 = 129,
851  tAREF = 144,
852  tASET = 145,
853  tLSHFT = 135,
854  tRSHFT = 136,
855  tCOLON2 = 323,
856  tCOLON3 = 324,
857  tOP_ASGN = 325,
858  tASSOC = 326,
859  tLPAREN = 327,
860  tLPAREN_ARG = 328,
861  tRPAREN = 329,
862  tLBRACK = 330,
863  tLBRACE = 331,
864  tLBRACE_ARG = 332,
865  tSTAR = 333,
866  tDSTAR = 334,
867  tAMPER = 335,
868  tLAMBDA = 336,
869  tSYMBEG = 337,
870  tSTRING_BEG = 338,
871  tXSTRING_BEG = 339,
872  tREGEXP_BEG = 340,
873  tWORDS_BEG = 341,
874  tQWORDS_BEG = 342,
875  tSYMBOLS_BEG = 343,
876  tQSYMBOLS_BEG = 344,
877  tSTRING_DBEG = 345,
878  tSTRING_DEND = 346,
879  tSTRING_DVAR = 347,
880  tSTRING_END = 348,
881  tLAMBEG = 349,
882  tLOWEST = 350,
883  tUMINUS_NUM = 351,
884  tLAST_TOKEN = 352
885  };
886 #endif
887 
888 
889 
890 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
891 typedef union YYSTYPE
892 {
893 
894 /* Line 293 of yacc.c */
895 #line 690 "ripper.y"
896 
897  VALUE val;
898  NODE *node;
899  ID id;
900  int num;
901  const struct vtable *vars;
902 
903 
904 
905 /* Line 293 of yacc.c */
906 #line 907 "parse.c"
907 } YYSTYPE;
908 # define YYSTYPE_IS_TRIVIAL 1
909 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
910 # define YYSTYPE_IS_DECLARED 1
911 #endif
912 
913 
914 /* Copy the second part of user declarations. */
915 
916 
917 /* Line 343 of yacc.c */
918 #line 919 "parse.c"
919 
920 #ifdef short
921 # undef short
922 #endif
923 
924 #ifdef YYTYPE_UINT8
925 typedef YYTYPE_UINT8 yytype_uint8;
926 #else
927 typedef unsigned char yytype_uint8;
928 #endif
929 
930 #ifdef YYTYPE_INT8
931 typedef YYTYPE_INT8 yytype_int8;
932 #elif (defined __STDC__ || defined __C99__FUNC__ \
933  || defined __cplusplus || defined _MSC_VER)
934 typedef signed char yytype_int8;
935 #else
936 typedef short int yytype_int8;
937 #endif
938 
939 #ifdef YYTYPE_UINT16
940 typedef YYTYPE_UINT16 yytype_uint16;
941 #else
942 typedef unsigned short int yytype_uint16;
943 #endif
944 
945 #ifdef YYTYPE_INT16
946 typedef YYTYPE_INT16 yytype_int16;
947 #else
948 typedef short int yytype_int16;
949 #endif
950 
951 #ifndef YYSIZE_T
952 # ifdef __SIZE_TYPE__
953 # define YYSIZE_T __SIZE_TYPE__
954 # elif defined size_t
955 # define YYSIZE_T size_t
956 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
957  || defined __cplusplus || defined _MSC_VER)
958 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
959 # define YYSIZE_T size_t
960 # else
961 # define YYSIZE_T unsigned int
962 # endif
963 #endif
964 
965 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
966 
967 #ifndef YY_
968 # if defined YYENABLE_NLS && YYENABLE_NLS
969 # if ENABLE_NLS
970 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
971 # define YY_(msgid) dgettext ("bison-runtime", msgid)
972 # endif
973 # endif
974 # ifndef YY_
975 # define YY_(msgid) msgid
976 # endif
977 #endif
978 
979 /* Suppress unused-variable warnings by "using" E. */
980 #if ! defined lint || defined __GNUC__
981 # define YYUSE(e) ((void) (e))
982 #else
983 # define YYUSE(e) /* empty */
984 #endif
985 
986 /* Identity function, used to suppress warnings about constant conditions. */
987 #ifndef lint
988 # define YYID(n) (n)
989 #else
990 #if (defined __STDC__ || defined __C99__FUNC__ \
991  || defined __cplusplus || defined _MSC_VER)
992 static int
993 YYID (int yyi)
994 #else
995 static int
996 YYID (yyi)
997  int yyi;
998 #endif
999 {
1000  return yyi;
1001 }
1002 #endif
1003 
1004 #if ! defined yyoverflow || YYERROR_VERBOSE
1005 
1006 /* The parser invokes alloca or malloc; define the necessary symbols. */
1007 
1008 # ifdef YYSTACK_USE_ALLOCA
1009 # if YYSTACK_USE_ALLOCA
1010 # ifdef __GNUC__
1011 # define YYSTACK_ALLOC __builtin_alloca
1012 # elif defined __BUILTIN_VA_ARG_INCR
1013 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1014 # elif defined _AIX
1015 # define YYSTACK_ALLOC __alloca
1016 # elif defined _MSC_VER
1017 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1018 # define alloca _alloca
1019 # else
1020 # define YYSTACK_ALLOC alloca
1021 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1022  || defined __cplusplus || defined _MSC_VER)
1023 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1024 # ifndef EXIT_SUCCESS
1025 # define EXIT_SUCCESS 0
1026 # endif
1027 # endif
1028 # endif
1029 # endif
1030 # endif
1031 
1032 # ifdef YYSTACK_ALLOC
1033  /* Pacify GCC's `empty if-body' warning. */
1034 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1035 # ifndef YYSTACK_ALLOC_MAXIMUM
1036  /* The OS might guarantee only one guard page at the bottom of the stack,
1037  and a page size can be as small as 4096 bytes. So we cannot safely
1038  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1039  to allow for a few compiler-allocated temporary stack slots. */
1040 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1041 # endif
1042 # else
1043 # define YYSTACK_ALLOC YYMALLOC
1044 # define YYSTACK_FREE YYFREE
1045 # ifndef YYSTACK_ALLOC_MAXIMUM
1046 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1047 # endif
1048 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
1049  && ! ((defined YYMALLOC || defined malloc) \
1050  && (defined YYFREE || defined free)))
1051 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1052 # ifndef EXIT_SUCCESS
1053 # define EXIT_SUCCESS 0
1054 # endif
1055 # endif
1056 # ifndef YYMALLOC
1057 # define YYMALLOC malloc
1058 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1059  || defined __cplusplus || defined _MSC_VER)
1060 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1061 # endif
1062 # endif
1063 # ifndef YYFREE
1064 # define YYFREE free
1065 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1066  || defined __cplusplus || defined _MSC_VER)
1067 void free (void *); /* INFRINGES ON USER NAME SPACE */
1068 # endif
1069 # endif
1070 # endif
1071 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1072 
1073 
1074 #if (! defined yyoverflow \
1075  && (! defined __cplusplus \
1076  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1077 
1078 /* A type that is properly aligned for any stack member. */
1079 union yyalloc
1080 {
1081  yytype_int16 yyss_alloc;
1083 };
1084 
1085 /* The size of the maximum gap between one aligned stack and the next. */
1086 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1087 
1088 /* The size of an array large to enough to hold all stacks, each with
1089  N elements. */
1090 # define YYSTACK_BYTES(N) \
1091  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1092  + YYSTACK_GAP_MAXIMUM)
1093 
1094 # define YYCOPY_NEEDED 1
1095 
1096 /* Relocate STACK from its old location to the new one. The
1097  local variables YYSIZE and YYSTACKSIZE give the old and new number of
1098  elements in the stack, and YYPTR gives the new location of the
1099  stack. Advance YYPTR to a properly aligned location for the next
1100  stack. */
1101 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1102  do \
1103  { \
1104  YYSIZE_T yynewbytes; \
1105  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1106  Stack = &yyptr->Stack_alloc; \
1107  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1108  yyptr += yynewbytes / sizeof (*yyptr); \
1109  } \
1110  while (YYID (0))
1111 
1112 #endif
1113 
1114 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1115 /* Copy COUNT objects from FROM to TO. The source and destination do
1116  not overlap. */
1117 # ifndef YYCOPY
1118 # if defined __GNUC__ && 1 < __GNUC__
1119 # define YYCOPY(To, From, Count) \
1120  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1121 # else
1122 # define YYCOPY(To, From, Count) \
1123  do \
1124  { \
1125  YYSIZE_T yyi; \
1126  for (yyi = 0; yyi < (Count); yyi++) \
1127  (To)[yyi] = (From)[yyi]; \
1128  } \
1129  while (YYID (0))
1130 # endif
1131 # endif
1132 #endif /* !YYCOPY_NEEDED */
1133 
1134 /* YYFINAL -- State number of the termination state. */
1135 #define YYFINAL 3
1136 /* YYLAST -- Last index in YYTABLE. */
1137 #define YYLAST 11084
1138 
1139 /* YYNTOKENS -- Number of terminals. */
1140 #define YYNTOKENS 142
1141 /* YYNNTS -- Number of nonterminals. */
1142 #define YYNNTS 198
1143 /* YYNRULES -- Number of rules. */
1144 #define YYNRULES 619
1145 /* YYNRULES -- Number of states. */
1146 #define YYNSTATES 1056
1147 
1148 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1149 #define YYUNDEFTOK 2
1150 #define YYMAXUTOK 352
1151 
1152 #define YYTRANSLATE(YYX) \
1153  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1154 
1155 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1156 static const yytype_uint8 yytranslate[] =
1157 {
1158  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1159  141, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1160  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1161  2, 2, 140, 127, 2, 2, 2, 125, 120, 2,
1162  136, 137, 123, 121, 134, 122, 133, 124, 2, 2,
1163  2, 2, 2, 2, 2, 2, 2, 2, 115, 139,
1164  117, 113, 116, 114, 2, 2, 2, 2, 2, 2,
1165  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1166  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1167  2, 132, 2, 138, 119, 2, 135, 2, 2, 2,
1168  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1169  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1170  2, 2, 2, 130, 118, 131, 128, 2, 79, 80,
1171  66, 67, 68, 2, 69, 83, 84, 74, 73, 70,
1172  71, 72, 77, 78, 81, 82, 2, 2, 2, 2,
1173  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1174  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1175  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1176  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1177  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1178  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1179  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1180  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1181  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1182  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1183  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1184  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1185  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1186  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1187  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1188  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1189  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1190  65, 75, 76, 85, 86, 87, 88, 89, 90, 91,
1191  92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
1192  102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
1193  112, 126, 129
1194 };
1195 
1196 #if YYDEBUG
1197 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1198  YYRHS. */
1199 static const yytype_uint16 yyprhs[] =
1200 {
1201  0, 0, 3, 4, 7, 10, 12, 14, 18, 21,
1202  23, 24, 30, 35, 38, 40, 42, 46, 49, 51,
1203  52, 58, 59, 64, 68, 72, 76, 79, 83, 87,
1204  91, 95, 99, 104, 106, 110, 114, 121, 127, 133,
1205  139, 145, 149, 153, 157, 161, 163, 167, 171, 173,
1206  177, 181, 185, 188, 190, 192, 194, 196, 198, 203,
1207  204, 210, 212, 215, 219, 224, 230, 235, 241, 244,
1208  247, 250, 253, 256, 258, 262, 264, 268, 270, 273,
1209  277, 283, 286, 291, 294, 299, 301, 305, 307, 311,
1210  314, 318, 320, 324, 326, 328, 333, 337, 341, 345,
1211  349, 352, 354, 356, 358, 363, 367, 371, 375, 379,
1212  382, 384, 386, 388, 391, 393, 397, 399, 401, 403,
1213  405, 407, 409, 411, 413, 415, 417, 418, 423, 425,
1214  427, 429, 431, 433, 435, 437, 439, 441, 443, 445,
1215  447, 449, 451, 453, 455, 457, 459, 461, 463, 465,
1216  467, 469, 471, 473, 475, 477, 479, 481, 483, 485,
1217  487, 489, 491, 493, 495, 497, 499, 501, 503, 505,
1218  507, 509, 511, 513, 515, 517, 519, 521, 523, 525,
1219  527, 529, 531, 533, 535, 537, 539, 541, 543, 545,
1220  547, 549, 551, 553, 555, 557, 559, 561, 563, 565,
1221  569, 575, 579, 585, 592, 598, 604, 610, 616, 621,
1222  625, 629, 633, 637, 641, 645, 649, 653, 657, 662,
1223  667, 670, 673, 677, 681, 685, 689, 693, 697, 701,
1224  705, 709, 713, 717, 721, 725, 728, 731, 735, 739,
1225  743, 747, 748, 753, 760, 762, 764, 766, 769, 774,
1226  777, 781, 783, 785, 787, 789, 792, 797, 800, 802,
1227  805, 808, 813, 815, 816, 819, 822, 825, 827, 829,
1228  832, 836, 841, 845, 850, 853, 855, 857, 859, 861,
1229  863, 865, 867, 869, 871, 873, 875, 876, 881, 882,
1230  886, 887, 892, 896, 900, 903, 907, 911, 913, 918,
1231  922, 924, 925, 932, 937, 941, 944, 946, 949, 952,
1232  959, 966, 967, 968, 976, 977, 978, 986, 992, 997,
1233  998, 999, 1009, 1010, 1017, 1018, 1019, 1028, 1029, 1035,
1234  1036, 1043, 1044, 1045, 1055, 1057, 1059, 1061, 1063, 1065,
1235  1067, 1069, 1071, 1073, 1075, 1077, 1079, 1081, 1083, 1085,
1236  1087, 1089, 1091, 1094, 1096, 1098, 1100, 1106, 1108, 1111,
1237  1113, 1115, 1117, 1121, 1123, 1127, 1129, 1134, 1141, 1145,
1238  1151, 1154, 1159, 1161, 1165, 1170, 1173, 1176, 1178, 1181,
1239  1182, 1189, 1198, 1203, 1210, 1215, 1218, 1225, 1228, 1233,
1240  1240, 1243, 1248, 1251, 1256, 1258, 1260, 1262, 1266, 1268,
1241  1273, 1275, 1280, 1282, 1286, 1288, 1290, 1291, 1292, 1293,
1242  1299, 1304, 1306, 1310, 1314, 1315, 1321, 1324, 1329, 1335,
1243  1341, 1344, 1345, 1351, 1352, 1358, 1362, 1363, 1368, 1369,
1244  1374, 1377, 1379, 1384, 1385, 1391, 1392, 1398, 1404, 1406,
1245  1408, 1415, 1417, 1419, 1421, 1423, 1426, 1428, 1431, 1433,
1246  1435, 1437, 1439, 1441, 1443, 1445, 1448, 1452, 1456, 1460,
1247  1464, 1468, 1469, 1473, 1475, 1478, 1482, 1486, 1487, 1491,
1248  1495, 1499, 1503, 1507, 1508, 1512, 1513, 1517, 1518, 1521,
1249  1522, 1525, 1526, 1529, 1531, 1532, 1536, 1537, 1538, 1539,
1250  1546, 1548, 1550, 1552, 1554, 1557, 1559, 1561, 1563, 1565,
1251  1569, 1571, 1573, 1576, 1579, 1581, 1583, 1585, 1587, 1589,
1252  1591, 1593, 1595, 1597, 1599, 1601, 1603, 1605, 1607, 1609,
1253  1611, 1613, 1615, 1617, 1618, 1623, 1626, 1630, 1633, 1638,
1254  1641, 1644, 1646, 1649, 1650, 1657, 1666, 1671, 1678, 1683,
1255  1690, 1693, 1698, 1705, 1708, 1713, 1716, 1721, 1723, 1724,
1256  1726, 1728, 1730, 1732, 1734, 1736, 1738, 1742, 1744, 1748,
1257  1751, 1754, 1756, 1760, 1762, 1766, 1768, 1770, 1773, 1775,
1258  1779, 1783, 1785, 1789, 1791, 1795, 1797, 1799, 1802, 1804,
1259  1806, 1808, 1811, 1814, 1816, 1818, 1819, 1824, 1826, 1829,
1260  1831, 1835, 1839, 1842, 1845, 1847, 1849, 1851, 1853, 1855,
1261  1857, 1859, 1861, 1863, 1865, 1867, 1869, 1870, 1872, 1873,
1262  1875, 1878, 1881, 1882, 1884, 1886, 1888, 1890, 1892, 1895
1263 };
1264 
1265 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1266 static const yytype_int16 yyrhs[] =
1267 {
1268  143, 0, -1, -1, 144, 145, -1, 146, 332, -1,
1269  339, -1, 147, -1, 146, 338, 147, -1, 1, 147,
1270  -1, 154, -1, -1, 47, 148, 130, 145, 131, -1,
1271  150, 261, 229, 264, -1, 151, 332, -1, 339, -1,
1272  152, -1, 151, 338, 152, -1, 1, 154, -1, 154,
1273  -1, -1, 47, 153, 130, 145, 131, -1, -1, 45,
1274  177, 155, 177, -1, 45, 54, 54, -1, 45, 54,
1275  64, -1, 45, 54, 63, -1, 6, 178, -1, 154,
1276  40, 158, -1, 154, 41, 158, -1, 154, 42, 158,
1277  -1, 154, 43, 158, -1, 154, 44, 154, -1, 48,
1278  130, 150, 131, -1, 156, -1, 165, 113, 159, -1,
1279  296, 87, 159, -1, 214, 132, 188, 335, 87, 159,
1280  -1, 214, 133, 52, 87, 159, -1, 214, 133, 56,
1281  87, 159, -1, 214, 85, 56, 87, 159, -1, 214,
1282  85, 52, 87, 159, -1, 297, 87, 159, -1, 172,
1283  113, 195, -1, 165, 113, 184, -1, 165, 113, 195,
1284  -1, 157, -1, 172, 113, 159, -1, 172, 113, 156,
1285  -1, 159, -1, 157, 37, 157, -1, 157, 38, 157,
1286  -1, 39, 333, 157, -1, 127, 159, -1, 182, -1,
1287  157, -1, 164, -1, 160, -1, 250, -1, 250, 331,
1288  329, 190, -1, -1, 94, 162, 237, 150, 131, -1,
1289  328, -1, 163, 190, -1, 163, 190, 161, -1, 214,
1290  133, 329, 190, -1, 214, 133, 329, 190, 161, -1,
1291  214, 85, 329, 190, -1, 214, 85, 329, 190, 161,
1292  -1, 32, 190, -1, 31, 190, -1, 30, 189, -1,
1293  21, 189, -1, 22, 189, -1, 167, -1, 89, 166,
1294  334, -1, 167, -1, 89, 166, 334, -1, 169, -1,
1295  169, 168, -1, 169, 95, 171, -1, 169, 95, 171,
1296  134, 170, -1, 169, 95, -1, 169, 95, 134, 170,
1297  -1, 95, 171, -1, 95, 171, 134, 170, -1, 95,
1298  -1, 95, 134, 170, -1, 171, -1, 89, 166, 334,
1299  -1, 168, 134, -1, 169, 168, 134, -1, 168, -1,
1300  170, 134, 168, -1, 293, -1, 294, -1, 214, 132,
1301  188, 335, -1, 214, 133, 52, -1, 214, 85, 52,
1302  -1, 214, 133, 56, -1, 214, 85, 56, -1, 86,
1303  56, -1, 297, -1, 293, -1, 294, -1, 214, 132,
1304  188, 335, -1, 214, 133, 52, -1, 214, 85, 52,
1305  -1, 214, 133, 56, -1, 214, 85, 56, -1, 86,
1306  56, -1, 297, -1, 52, -1, 56, -1, 86, 173,
1307  -1, 173, -1, 214, 85, 173, -1, 52, -1, 56,
1308  -1, 53, -1, 180, -1, 181, -1, 175, -1, 289,
1309  -1, 176, -1, 291, -1, 177, -1, -1, 178, 134,
1310  179, 177, -1, 118, -1, 119, -1, 120, -1, 69,
1311  -1, 70, -1, 71, -1, 77, -1, 78, -1, 116,
1312  -1, 73, -1, 117, -1, 74, -1, 72, -1, 83,
1313  -1, 84, -1, 121, -1, 122, -1, 123, -1, 95,
1314  -1, 124, -1, 125, -1, 68, -1, 96, -1, 127,
1315  -1, 128, -1, 66, -1, 67, -1, 81, -1, 82,
1316  -1, 135, -1, 49, -1, 50, -1, 51, -1, 47,
1317  -1, 48, -1, 45, -1, 37, -1, 7, -1, 21,
1318  -1, 16, -1, 3, -1, 5, -1, 46, -1, 26,
1319  -1, 15, -1, 14, -1, 10, -1, 9, -1, 36,
1320  -1, 20, -1, 25, -1, 4, -1, 22, -1, 34,
1321  -1, 39, -1, 38, -1, 23, -1, 8, -1, 24,
1322  -1, 30, -1, 33, -1, 32, -1, 13, -1, 35,
1323  -1, 6, -1, 17, -1, 31, -1, 11, -1, 12,
1324  -1, 18, -1, 19, -1, 172, 113, 182, -1, 172,
1325  113, 182, 44, 182, -1, 296, 87, 182, -1, 296,
1326  87, 182, 44, 182, -1, 214, 132, 188, 335, 87,
1327  182, -1, 214, 133, 52, 87, 182, -1, 214, 133,
1328  56, 87, 182, -1, 214, 85, 52, 87, 182, -1,
1329  214, 85, 56, 87, 182, -1, 86, 56, 87, 182,
1330  -1, 297, 87, 182, -1, 182, 79, 182, -1, 182,
1331  80, 182, -1, 182, 121, 182, -1, 182, 122, 182,
1332  -1, 182, 123, 182, -1, 182, 124, 182, -1, 182,
1333  125, 182, -1, 182, 68, 182, -1, 126, 59, 68,
1334  182, -1, 126, 60, 68, 182, -1, 66, 182, -1,
1335  67, 182, -1, 182, 118, 182, -1, 182, 119, 182,
1336  -1, 182, 120, 182, -1, 182, 69, 182, -1, 182,
1337  116, 182, -1, 182, 73, 182, -1, 182, 117, 182,
1338  -1, 182, 74, 182, -1, 182, 70, 182, -1, 182,
1339  71, 182, -1, 182, 72, 182, -1, 182, 77, 182,
1340  -1, 182, 78, 182, -1, 127, 182, -1, 128, 182,
1341  -1, 182, 83, 182, -1, 182, 84, 182, -1, 182,
1342  75, 182, -1, 182, 76, 182, -1, -1, 46, 333,
1343  183, 182, -1, 182, 114, 182, 333, 115, 182, -1,
1344  196, -1, 182, -1, 339, -1, 194, 336, -1, 194,
1345  134, 326, 336, -1, 326, 336, -1, 136, 188, 334,
1346  -1, 339, -1, 186, -1, 339, -1, 189, -1, 194,
1347  134, -1, 194, 134, 326, 134, -1, 326, 134, -1,
1348  164, -1, 194, 193, -1, 326, 193, -1, 194, 134,
1349  326, 193, -1, 192, -1, -1, 191, 189, -1, 97,
1350  184, -1, 134, 192, -1, 339, -1, 184, -1, 95,
1351  184, -1, 194, 134, 184, -1, 194, 134, 95, 184,
1352  -1, 194, 134, 184, -1, 194, 134, 95, 184, -1,
1353  95, 184, -1, 265, -1, 266, -1, 269, -1, 270,
1354  -1, 271, -1, 276, -1, 274, -1, 277, -1, 295,
1355  -1, 297, -1, 53, -1, -1, 215, 197, 149, 225,
1356  -1, -1, 90, 198, 334, -1, -1, 90, 157, 199,
1357  334, -1, 89, 150, 137, -1, 214, 85, 56, -1,
1358  86, 56, -1, 92, 185, 138, -1, 93, 325, 131,
1359  -1, 30, -1, 31, 136, 189, 334, -1, 31, 136,
1360  334, -1, 31, -1, -1, 46, 333, 136, 200, 157,
1361  334, -1, 39, 136, 157, 334, -1, 39, 136, 334,
1362  -1, 163, 256, -1, 251, -1, 251, 256, -1, 98,
1363  242, -1, 216, 158, 226, 150, 228, 225, -1, 217,
1364  158, 226, 150, 229, 225, -1, -1, -1, 218, 201,
1365  158, 227, 202, 150, 225, -1, -1, -1, 219, 203,
1366  158, 227, 204, 150, 225, -1, 220, 158, 332, 259,
1367  225, -1, 220, 332, 259, 225, -1, -1, -1, 221,
1368  230, 25, 205, 158, 227, 206, 150, 225, -1, -1,
1369  222, 174, 298, 207, 149, 225, -1, -1, -1, 222,
1370  83, 157, 208, 337, 209, 149, 225, -1, -1, 223,
1371  174, 210, 149, 225, -1, -1, 224, 175, 211, 300,
1372  149, 225, -1, -1, -1, 224, 323, 331, 212, 175,
1373  213, 300, 149, 225, -1, 21, -1, 22, -1, 23,
1374  -1, 24, -1, 196, -1, 7, -1, 11, -1, 12,
1375  -1, 18, -1, 19, -1, 16, -1, 20, -1, 3,
1376  -1, 4, -1, 5, -1, 10, -1, 337, -1, 13,
1377  -1, 337, 13, -1, 337, -1, 27, -1, 229, -1,
1378  14, 158, 226, 150, 228, -1, 339, -1, 15, 150,
1379  -1, 172, -1, 165, -1, 305, -1, 89, 233, 334,
1380  -1, 231, -1, 232, 134, 231, -1, 232, -1, 232,
1381  134, 95, 305, -1, 232, 134, 95, 305, 134, 232,
1382  -1, 232, 134, 95, -1, 232, 134, 95, 134, 232,
1383  -1, 95, 305, -1, 95, 305, 134, 232, -1, 95,
1384  -1, 95, 134, 232, -1, 310, 134, 313, 322, -1,
1385  310, 322, -1, 313, 322, -1, 321, -1, 134, 234,
1386  -1, -1, 307, 134, 316, 134, 319, 235, -1, 307,
1387  134, 316, 134, 319, 134, 307, 235, -1, 307, 134,
1388  316, 235, -1, 307, 134, 316, 134, 307, 235, -1,
1389  307, 134, 319, 235, -1, 307, 134, -1, 307, 134,
1390  319, 134, 307, 235, -1, 307, 235, -1, 316, 134,
1391  319, 235, -1, 316, 134, 319, 134, 307, 235, -1,
1392  316, 235, -1, 316, 134, 307, 235, -1, 319, 235,
1393  -1, 319, 134, 307, 235, -1, 234, -1, 339, -1,
1394  238, -1, 118, 239, 118, -1, 76, -1, 118, 236,
1395  239, 118, -1, 333, -1, 333, 139, 240, 333, -1,
1396  241, -1, 240, 134, 241, -1, 52, -1, 304, -1,
1397  -1, -1, -1, 243, 244, 246, 245, 247, -1, 136,
1398  303, 239, 137, -1, 303, -1, 111, 150, 131, -1,
1399  29, 150, 10, -1, -1, 28, 249, 237, 150, 10,
1400  -1, 164, 248, -1, 250, 331, 329, 187, -1, 250,
1401  331, 329, 187, 256, -1, 250, 331, 329, 190, 248,
1402  -1, 163, 186, -1, -1, 214, 133, 329, 252, 187,
1403  -1, -1, 214, 85, 329, 253, 186, -1, 214, 85,
1404  330, -1, -1, 214, 133, 254, 186, -1, -1, 214,
1405  85, 255, 186, -1, 32, 186, -1, 32, -1, 214,
1406  132, 188, 335, -1, -1, 130, 257, 237, 150, 131,
1407  -1, -1, 26, 258, 237, 150, 10, -1, 17, 194,
1408  226, 150, 260, -1, 229, -1, 259, -1, 8, 262,
1409  263, 226, 150, 261, -1, 339, -1, 184, -1, 195,
1410  -1, 339, -1, 88, 172, -1, 339, -1, 9, 150,
1411  -1, 339, -1, 292, -1, 289, -1, 291, -1, 267,
1412  -1, 62, -1, 268, -1, 267, 268, -1, 100, 280,
1413  110, -1, 101, 281, 110, -1, 102, 282, 65, -1,
1414  103, 140, 110, -1, 103, 272, 110, -1, -1, 272,
1415  273, 140, -1, 283, -1, 273, 283, -1, 105, 140,
1416  110, -1, 105, 275, 110, -1, -1, 275, 273, 140,
1417  -1, 104, 140, 110, -1, 104, 278, 110, -1, 106,
1418  140, 110, -1, 106, 279, 110, -1, -1, 278, 61,
1419  140, -1, -1, 279, 61, 140, -1, -1, 280, 283,
1420  -1, -1, 281, 283, -1, -1, 282, 283, -1, 61,
1421  -1, -1, 109, 284, 288, -1, -1, -1, -1, 107,
1422  285, 286, 287, 150, 108, -1, 54, -1, 55, -1,
1423  57, -1, 297, -1, 99, 290, -1, 175, -1, 55,
1424  -1, 54, -1, 57, -1, 99, 281, 110, -1, 59,
1425  -1, 60, -1, 126, 59, -1, 126, 60, -1, 52,
1426  -1, 55, -1, 54, -1, 56, -1, 57, -1, 34,
1427  -1, 33, -1, 35, -1, 36, -1, 50, -1, 49,
1428  -1, 51, -1, 293, -1, 294, -1, 293, -1, 294,
1429  -1, 63, -1, 64, -1, 337, -1, -1, 117, 299,
1430  158, 337, -1, 1, 337, -1, 136, 303, 334, -1,
1431  303, 337, -1, 311, 134, 313, 322, -1, 311, 322,
1432  -1, 313, 322, -1, 321, -1, 134, 301, -1, -1,
1433  307, 134, 317, 134, 319, 302, -1, 307, 134, 317,
1434  134, 319, 134, 307, 302, -1, 307, 134, 317, 302,
1435  -1, 307, 134, 317, 134, 307, 302, -1, 307, 134,
1436  319, 302, -1, 307, 134, 319, 134, 307, 302, -1,
1437  307, 302, -1, 317, 134, 319, 302, -1, 317, 134,
1438  319, 134, 307, 302, -1, 317, 302, -1, 317, 134,
1439  307, 302, -1, 319, 302, -1, 319, 134, 307, 302,
1440  -1, 301, -1, -1, 56, -1, 55, -1, 54, -1,
1441  57, -1, 304, -1, 52, -1, 305, -1, 89, 233,
1442  334, -1, 306, -1, 307, 134, 306, -1, 58, 184,
1443  -1, 58, 214, -1, 309, -1, 310, 134, 309, -1,
1444  308, -1, 311, 134, 308, -1, 68, -1, 96, -1,
1445  312, 52, -1, 312, -1, 52, 113, 184, -1, 52,
1446  113, 214, -1, 315, -1, 316, 134, 315, -1, 314,
1447  -1, 317, 134, 314, -1, 123, -1, 95, -1, 318,
1448  52, -1, 318, -1, 120, -1, 97, -1, 320, 52,
1449  -1, 134, 321, -1, 339, -1, 295, -1, -1, 136,
1450  324, 157, 334, -1, 339, -1, 326, 336, -1, 327,
1451  -1, 326, 134, 327, -1, 184, 88, 184, -1, 58,
1452  184, -1, 96, 184, -1, 52, -1, 56, -1, 53,
1453  -1, 52, -1, 56, -1, 53, -1, 180, -1, 52,
1454  -1, 53, -1, 180, -1, 133, -1, 85, -1, -1,
1455  338, -1, -1, 141, -1, 333, 137, -1, 333, 138,
1456  -1, -1, 141, -1, 134, -1, 139, -1, 141, -1,
1457  337, -1, 338, 139, -1, -1
1458 };
1459 
1460 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1461 static const yytype_uint16 yyrline[] =
1462 {
1463  0, 854, 854, 854, 885, 896, 905, 913, 921, 927,
1464  929, 928, 949, 982, 993, 1002, 1010, 1018, 1024, 1029,
1465  1028, 1049, 1049, 1057, 1065, 1076, 1086, 1094, 1103, 1112,
1466  1125, 1138, 1147, 1159, 1160, 1170, 1175, 1196, 1201, 1206,
1467  1216, 1221, 1231, 1240, 1249, 1258, 1261, 1270, 1282, 1283,
1468  1291, 1299, 1307, 1315, 1318, 1330, 1331, 1334, 1335, 1347,
1469  1346, 1368, 1378, 1387, 1400, 1409, 1421, 1430, 1442, 1451,
1470  1460, 1468, 1476, 1486, 1487, 1497, 1498, 1508, 1516, 1524,
1471  1532, 1541, 1549, 1558, 1566, 1575, 1583, 1594, 1595, 1605,
1472  1613, 1623, 1631, 1641, 1645, 1649, 1657, 1665, 1673, 1681,
1473  1693, 1703, 1715, 1724, 1733, 1741, 1749, 1757, 1765, 1778,
1474  1791, 1802, 1810, 1813, 1821, 1829, 1839, 1840, 1841, 1842,
1475  1847, 1858, 1859, 1862, 1870, 1873, 1881, 1881, 1891, 1892,
1476  1893, 1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902,
1477  1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912,
1478  1913, 1914, 1915, 1916, 1917, 1918, 1919, 1920, 1923, 1923,
1479  1923, 1924, 1924, 1925, 1925, 1925, 1926, 1926, 1926, 1926,
1480  1927, 1927, 1927, 1927, 1928, 1928, 1928, 1929, 1929, 1929,
1481  1929, 1930, 1930, 1930, 1930, 1931, 1931, 1931, 1931, 1932,
1482  1932, 1932, 1932, 1933, 1933, 1933, 1933, 1934, 1934, 1937,
1483  1946, 1956, 1961, 1971, 1997, 2002, 2007, 2012, 2022, 2032,
1484  2043, 2057, 2071, 2079, 2087, 2095, 2103, 2111, 2119, 2128,
1485  2137, 2145, 2153, 2161, 2169, 2177, 2185, 2193, 2201, 2209,
1486  2217, 2225, 2233, 2241, 2252, 2260, 2268, 2276, 2284, 2292,
1487  2300, 2308, 2308, 2318, 2328, 2334, 2346, 2347, 2351, 2359,
1488  2369, 2379, 2380, 2383, 2384, 2385, 2389, 2397, 2407, 2416,
1489  2424, 2434, 2443, 2452, 2452, 2464, 2474, 2478, 2484, 2492,
1490  2500, 2514, 2530, 2544, 2559, 2569, 2570, 2571, 2572, 2573,
1491  2574, 2575, 2576, 2577, 2578, 2579, 2588, 2587, 2615, 2615,
1492  2623, 2623, 2631, 2639, 2647, 2655, 2668, 2676, 2684, 2692,
1493  2700, 2708, 2708, 2718, 2726, 2734, 2744, 2745, 2755, 2759,
1494  2771, 2783, 2783, 2783, 2794, 2794, 2794, 2805, 2816, 2825,
1495  2827, 2824, 2891, 2890, 2912, 2917, 2911, 2936, 2935, 2957,
1496  2956, 2979, 2980, 2979, 3000, 3008, 3016, 3024, 3034, 3046,
1497  3052, 3058, 3064, 3070, 3076, 3082, 3088, 3094, 3100, 3110,
1498  3116, 3121, 3122, 3129, 3134, 3137, 3138, 3151, 3152, 3162,
1499  3163, 3166, 3174, 3184, 3192, 3202, 3210, 3219, 3228, 3236,
1500  3244, 3253, 3265, 3273, 3284, 3288, 3292, 3296, 3302, 3307,
1501  3312, 3316, 3320, 3324, 3328, 3332, 3340, 3344, 3348, 3352,
1502  3356, 3360, 3364, 3368, 3372, 3378, 3379, 3385, 3394, 3403,
1503  3414, 3418, 3428, 3435, 3444, 3452, 3458, 3461, 3466, 3458,
1504  3482, 3490, 3500, 3504, 3511, 3510, 3531, 3547, 3556, 3568,
1505  3582, 3592, 3591, 3608, 3607, 3623, 3632, 3631, 3649, 3648,
1506  3665, 3673, 3681, 3696, 3695, 3715, 3714, 3735, 3747, 3748,
1507  3751, 3770, 3773, 3781, 3789, 3792, 3796, 3799, 3807, 3810,
1508  3811, 3819, 3822, 3839, 3840, 3841, 3851, 3861, 3888, 3953,
1509  3962, 3973, 3980, 3990, 3998, 4008, 4017, 4028, 4035, 4047,
1510  4056, 4066, 4075, 4086, 4093, 4104, 4111, 4126, 4133, 4144,
1511  4151, 4162, 4169, 4198, 4200, 4199, 4216, 4222, 4227, 4215,
1512  4246, 4254, 4262, 4270, 4273, 4284, 4285, 4286, 4287, 4290,
1513  4301, 4302, 4303, 4311, 4321, 4322, 4323, 4324, 4325, 4328,
1514  4329, 4330, 4331, 4332, 4333, 4334, 4337, 4350, 4360, 4368,
1515  4378, 4379, 4382, 4391, 4390, 4399, 4411, 4421, 4429, 4433,
1516  4437, 4441, 4447, 4452, 4457, 4461, 4465, 4469, 4473, 4477,
1517  4481, 4485, 4489, 4493, 4497, 4501, 4505, 4509, 4514, 4520,
1518  4529, 4538, 4547, 4558, 4559, 4566, 4575, 4594, 4601, 4614,
1519  4626, 4638, 4646, 4663, 4671, 4687, 4688, 4691, 4696, 4702,
1520  4714, 4726, 4734, 4750, 4758, 4774, 4775, 4778, 4791, 4802,
1521  4803, 4806, 4823, 4827, 4837, 4847, 4847, 4876, 4877, 4887,
1522  4894, 4904, 4912, 4920, 4932, 4933, 4934, 4937, 4938, 4939,
1523  4940, 4943, 4944, 4945, 4948, 4953, 4960, 4961, 4964, 4965,
1524  4968, 4971, 4974, 4975, 4976, 4979, 4980, 4983, 4984, 4988
1525 };
1526 #endif
1527 
1528 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1529 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1530  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1531 static const char *const yytname[] =
1532 {
1533  "\"end-of-input\"", "error", "$undefined", "keyword_class",
1534  "keyword_module", "keyword_def", "keyword_undef", "keyword_begin",
1535  "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if",
1536  "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else",
1537  "keyword_case", "keyword_when", "keyword_while", "keyword_until",
1538  "keyword_for", "keyword_break", "keyword_next", "keyword_redo",
1539  "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond",
1540  "keyword_do_block", "keyword_do_LAMBDA", "keyword_return",
1541  "keyword_yield", "keyword_super", "keyword_self", "keyword_nil",
1542  "keyword_true", "keyword_false", "keyword_and", "keyword_or",
1543  "keyword_not", "modifier_if", "modifier_unless", "modifier_while",
1544  "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined",
1545  "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__",
1546  "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR",
1547  "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tSTRING_CONTENT",
1548  "tCHAR", "tNTH_REF", "tBACK_REF", "tREGEXP_END", "\"unary+\"",
1549  "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"", "\"===\"", "\"!=\"",
1550  "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"", "\"!~\"", "\"..\"",
1551  "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"", "\"::\"",
1552  "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"", "\"( arg\"",
1553  "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"", "\"**arg\"", "\"&\"",
1554  "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG",
1555  "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG", "tQSYMBOLS_BEG",
1556  "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
1557  "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
1558  "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "tLAST_TOKEN",
1559  "'{'", "'}'", "'['", "'.'", "','", "'`'", "'('", "')'", "']'", "';'",
1560  "' '", "'\\n'", "$accept", "program", "$@1", "top_compstmt", "top_stmts",
1561  "top_stmt", "$@2", "bodystmt", "compstmt", "stmts", "stmt_or_begin",
1562  "$@3", "stmt", "$@4", "command_asgn", "expr", "expr_value",
1563  "command_call", "block_command", "cmd_brace_block", "@5", "fcall",
1564  "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head",
1565  "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
1566  "fitem", "undef_list", "$@6", "op", "reswords", "arg", "$@7",
1567  "arg_value", "aref_args", "paren_args", "opt_paren_args",
1568  "opt_call_args", "call_args", "command_args", "@8", "block_arg",
1569  "opt_block_arg", "args", "mrhs", "primary", "@9", "$@10", "$@11", "$@12",
1570  "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "@19", "@20", "@21",
1571  "@22", "@23", "$@24", "$@25", "primary_value", "k_begin", "k_if",
1572  "k_unless", "k_while", "k_until", "k_case", "k_for", "k_class",
1573  "k_module", "k_def", "k_end", "then", "do", "if_tail", "opt_else",
1574  "for_var", "f_marg", "f_marg_list", "f_margs", "block_args_tail",
1575  "opt_block_args_tail", "block_param", "opt_block_param",
1576  "block_param_def", "opt_bv_decl", "bv_decls", "bvar", "lambda", "@26",
1577  "@27", "@28", "f_larglist", "lambda_body", "do_block", "@29",
1578  "block_call", "method_call", "@30", "@31", "@32", "@33", "brace_block",
1579  "@34", "@35", "case_body", "cases", "opt_rescue", "exc_list", "exc_var",
1580  "opt_ensure", "literal", "strings", "string", "string1", "xstring",
1581  "regexp", "words", "word_list", "word", "symbols", "symbol_list",
1582  "qwords", "qsymbols", "qword_list", "qsym_list", "string_contents",
1583  "xstring_contents", "regexp_contents", "string_content", "@36", "@37",
1584  "@38", "@39", "string_dvar", "symbol", "sym", "dsym", "numeric",
1585  "user_variable", "keyword_variable", "var_ref", "var_lhs", "backref",
1586  "superclass", "$@40", "f_arglist", "args_tail", "opt_args_tail",
1587  "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_kw",
1588  "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest",
1589  "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
1590  "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
1591  "singleton", "$@41", "assoc_list", "assocs", "assoc", "operation",
1592  "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
1593  "rparen", "rbracket", "trailer", "term", "terms", "none", 0
1594 };
1595 #endif
1596 
1597 # ifdef YYPRINT
1598 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1599  token YYLEX-NUM. */
1600 static const yytype_uint16 yytoknum[] =
1601 {
1602  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1603  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1604  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1605  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1606  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1607  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1608  315, 316, 317, 318, 319, 320, 130, 131, 132, 134,
1609  139, 140, 141, 138, 137, 321, 322, 142, 143, 128,
1610  129, 144, 145, 135, 136, 323, 324, 325, 326, 327,
1611  328, 329, 330, 331, 332, 333, 334, 335, 336, 337,
1612  338, 339, 340, 341, 342, 343, 344, 345, 346, 347,
1613  348, 349, 350, 61, 63, 58, 62, 60, 124, 94,
1614  38, 43, 45, 42, 47, 37, 351, 33, 126, 352,
1615  123, 125, 91, 46, 44, 96, 40, 41, 93, 59,
1616  32, 10
1617 };
1618 # endif
1619 
1620 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1621 static const yytype_uint16 yyr1[] =
1622 {
1623  0, 142, 144, 143, 145, 146, 146, 146, 146, 147,
1624  148, 147, 149, 150, 151, 151, 151, 151, 152, 153,
1625  152, 155, 154, 154, 154, 154, 154, 154, 154, 154,
1626  154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1627  154, 154, 154, 154, 154, 154, 156, 156, 157, 157,
1628  157, 157, 157, 157, 158, 159, 159, 160, 160, 162,
1629  161, 163, 164, 164, 164, 164, 164, 164, 164, 164,
1630  164, 164, 164, 165, 165, 166, 166, 167, 167, 167,
1631  167, 167, 167, 167, 167, 167, 167, 168, 168, 169,
1632  169, 170, 170, 171, 171, 171, 171, 171, 171, 171,
1633  171, 171, 172, 172, 172, 172, 172, 172, 172, 172,
1634  172, 173, 173, 174, 174, 174, 175, 175, 175, 175,
1635  175, 176, 176, 177, 177, 178, 179, 178, 180, 180,
1636  180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
1637  180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
1638  180, 180, 180, 180, 180, 180, 180, 180, 181, 181,
1639  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1640  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1641  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1642  181, 181, 181, 181, 181, 181, 181, 181, 181, 182,
1643  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1644  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1645  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1646  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1647  182, 183, 182, 182, 182, 184, 185, 185, 185, 185,
1648  186, 187, 187, 188, 188, 188, 188, 188, 189, 189,
1649  189, 189, 189, 191, 190, 192, 193, 193, 194, 194,
1650  194, 194, 195, 195, 195, 196, 196, 196, 196, 196,
1651  196, 196, 196, 196, 196, 196, 197, 196, 198, 196,
1652  199, 196, 196, 196, 196, 196, 196, 196, 196, 196,
1653  196, 200, 196, 196, 196, 196, 196, 196, 196, 196,
1654  196, 201, 202, 196, 203, 204, 196, 196, 196, 205,
1655  206, 196, 207, 196, 208, 209, 196, 210, 196, 211,
1656  196, 212, 213, 196, 196, 196, 196, 196, 214, 215,
1657  216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1658  226, 226, 226, 227, 227, 228, 228, 229, 229, 230,
1659  230, 231, 231, 232, 232, 233, 233, 233, 233, 233,
1660  233, 233, 233, 233, 234, 234, 234, 234, 235, 235,
1661  236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
1662  236, 236, 236, 236, 236, 237, 237, 238, 238, 238,
1663  239, 239, 240, 240, 241, 241, 243, 244, 245, 242,
1664  246, 246, 247, 247, 249, 248, 250, 250, 250, 250,
1665  251, 252, 251, 253, 251, 251, 254, 251, 255, 251,
1666  251, 251, 251, 257, 256, 258, 256, 259, 260, 260,
1667  261, 261, 262, 262, 262, 263, 263, 264, 264, 265,
1668  265, 265, 266, 267, 267, 267, 268, 269, 270, 271,
1669  271, 272, 272, 273, 273, 274, 274, 275, 275, 276,
1670  276, 277, 277, 278, 278, 279, 279, 280, 280, 281,
1671  281, 282, 282, 283, 284, 283, 285, 286, 287, 283,
1672  288, 288, 288, 288, 289, 290, 290, 290, 290, 291,
1673  292, 292, 292, 292, 293, 293, 293, 293, 293, 294,
1674  294, 294, 294, 294, 294, 294, 295, 295, 296, 296,
1675  297, 297, 298, 299, 298, 298, 300, 300, 301, 301,
1676  301, 301, 302, 302, 303, 303, 303, 303, 303, 303,
1677  303, 303, 303, 303, 303, 303, 303, 303, 303, 304,
1678  304, 304, 304, 305, 305, 306, 306, 307, 307, 308,
1679  309, 310, 310, 311, 311, 312, 312, 313, 313, 314,
1680  315, 316, 316, 317, 317, 318, 318, 319, 319, 320,
1681  320, 321, 322, 322, 323, 324, 323, 325, 325, 326,
1682  326, 327, 327, 327, 328, 328, 328, 329, 329, 329,
1683  329, 330, 330, 330, 331, 331, 332, 332, 333, 333,
1684  334, 335, 336, 336, 336, 337, 337, 338, 338, 339
1685 };
1686 
1687 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1688 static const yytype_uint8 yyr2[] =
1689 {
1690  0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
1691  0, 5, 4, 2, 1, 1, 3, 2, 1, 0,
1692  5, 0, 4, 3, 3, 3, 2, 3, 3, 3,
1693  3, 3, 4, 1, 3, 3, 6, 5, 5, 5,
1694  5, 3, 3, 3, 3, 1, 3, 3, 1, 3,
1695  3, 3, 2, 1, 1, 1, 1, 1, 4, 0,
1696  5, 1, 2, 3, 4, 5, 4, 5, 2, 2,
1697  2, 2, 2, 1, 3, 1, 3, 1, 2, 3,
1698  5, 2, 4, 2, 4, 1, 3, 1, 3, 2,
1699  3, 1, 3, 1, 1, 4, 3, 3, 3, 3,
1700  2, 1, 1, 1, 4, 3, 3, 3, 3, 2,
1701  1, 1, 1, 2, 1, 3, 1, 1, 1, 1,
1702  1, 1, 1, 1, 1, 1, 0, 4, 1, 1,
1703  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1704  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1705  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1706  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1707  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1708  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1709  1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
1710  5, 3, 5, 6, 5, 5, 5, 5, 4, 3,
1711  3, 3, 3, 3, 3, 3, 3, 3, 4, 4,
1712  2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
1713  3, 3, 3, 3, 3, 2, 2, 3, 3, 3,
1714  3, 0, 4, 6, 1, 1, 1, 2, 4, 2,
1715  3, 1, 1, 1, 1, 2, 4, 2, 1, 2,
1716  2, 4, 1, 0, 2, 2, 2, 1, 1, 2,
1717  3, 4, 3, 4, 2, 1, 1, 1, 1, 1,
1718  1, 1, 1, 1, 1, 1, 0, 4, 0, 3,
1719  0, 4, 3, 3, 2, 3, 3, 1, 4, 3,
1720  1, 0, 6, 4, 3, 2, 1, 2, 2, 6,
1721  6, 0, 0, 7, 0, 0, 7, 5, 4, 0,
1722  0, 9, 0, 6, 0, 0, 8, 0, 5, 0,
1723  6, 0, 0, 9, 1, 1, 1, 1, 1, 1,
1724  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1725  1, 1, 2, 1, 1, 1, 5, 1, 2, 1,
1726  1, 1, 3, 1, 3, 1, 4, 6, 3, 5,
1727  2, 4, 1, 3, 4, 2, 2, 1, 2, 0,
1728  6, 8, 4, 6, 4, 2, 6, 2, 4, 6,
1729  2, 4, 2, 4, 1, 1, 1, 3, 1, 4,
1730  1, 4, 1, 3, 1, 1, 0, 0, 0, 5,
1731  4, 1, 3, 3, 0, 5, 2, 4, 5, 5,
1732  2, 0, 5, 0, 5, 3, 0, 4, 0, 4,
1733  2, 1, 4, 0, 5, 0, 5, 5, 1, 1,
1734  6, 1, 1, 1, 1, 2, 1, 2, 1, 1,
1735  1, 1, 1, 1, 1, 2, 3, 3, 3, 3,
1736  3, 0, 3, 1, 2, 3, 3, 0, 3, 3,
1737  3, 3, 3, 0, 3, 0, 3, 0, 2, 0,
1738  2, 0, 2, 1, 0, 3, 0, 0, 0, 6,
1739  1, 1, 1, 1, 2, 1, 1, 1, 1, 3,
1740  1, 1, 2, 2, 1, 1, 1, 1, 1, 1,
1741  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1742  1, 1, 1, 0, 4, 2, 3, 2, 4, 2,
1743  2, 1, 2, 0, 6, 8, 4, 6, 4, 6,
1744  2, 4, 6, 2, 4, 2, 4, 1, 0, 1,
1745  1, 1, 1, 1, 1, 1, 3, 1, 3, 2,
1746  2, 1, 3, 1, 3, 1, 1, 2, 1, 3,
1747  3, 1, 3, 1, 3, 1, 1, 2, 1, 1,
1748  1, 2, 2, 1, 1, 0, 4, 1, 2, 1,
1749  3, 3, 2, 2, 1, 1, 1, 1, 1, 1,
1750  1, 1, 1, 1, 1, 1, 0, 1, 0, 1,
1751  2, 2, 0, 1, 1, 1, 1, 1, 2, 0
1752 };
1753 
1754 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1755  Performed when YYTABLE doesn't specify something else to do. Zero
1756  means the default is an error. */
1757 static const yytype_uint16 yydefact[] =
1758 {
1759  2, 0, 0, 1, 0, 346, 347, 348, 0, 339,
1760  340, 341, 344, 342, 343, 345, 334, 335, 336, 337,
1761  297, 263, 263, 510, 509, 511, 512, 608, 0, 608,
1762  10, 0, 514, 513, 515, 594, 596, 506, 505, 595,
1763  508, 500, 501, 453, 520, 521, 0, 0, 0, 0,
1764  288, 619, 619, 85, 406, 479, 477, 479, 481, 461,
1765  473, 467, 475, 0, 0, 0, 3, 606, 6, 9,
1766  33, 45, 48, 56, 263, 55, 0, 73, 0, 77,
1767  87, 0, 53, 244, 0, 286, 0, 0, 311, 314,
1768  606, 0, 0, 0, 0, 57, 306, 275, 276, 452,
1769  454, 277, 278, 279, 281, 280, 282, 450, 451, 449,
1770  516, 517, 283, 0, 284, 61, 5, 8, 168, 179,
1771  169, 192, 165, 185, 175, 174, 195, 196, 190, 173,
1772  172, 167, 193, 197, 198, 177, 166, 180, 184, 186,
1773  178, 171, 187, 194, 189, 188, 181, 191, 176, 164,
1774  183, 182, 163, 170, 161, 162, 158, 159, 160, 116,
1775  118, 117, 153, 154, 149, 131, 132, 133, 140, 137,
1776  139, 134, 135, 155, 156, 141, 142, 146, 150, 136,
1777  138, 128, 129, 130, 143, 144, 145, 147, 148, 151,
1778  152, 157, 121, 123, 125, 26, 119, 120, 122, 124,
1779  0, 0, 0, 0, 0, 0, 0, 0, 258, 0,
1780  245, 268, 71, 262, 619, 0, 516, 517, 0, 284,
1781  619, 589, 72, 70, 608, 69, 0, 619, 430, 68,
1782  608, 609, 0, 0, 21, 241, 0, 0, 334, 335,
1783  297, 300, 431, 0, 220, 0, 221, 294, 0, 19,
1784  0, 0, 606, 15, 18, 608, 75, 14, 290, 608,
1785  0, 612, 612, 246, 0, 0, 612, 587, 608, 0,
1786  0, 0, 83, 338, 0, 93, 94, 101, 308, 407,
1787  497, 496, 498, 495, 0, 494, 0, 0, 0, 0,
1788  0, 0, 0, 0, 0, 0, 0, 502, 503, 52,
1789  235, 236, 615, 616, 4, 617, 607, 0, 0, 0,
1790  0, 0, 0, 0, 435, 433, 420, 62, 305, 414,
1791  416, 0, 89, 0, 81, 78, 0, 0, 0, 0,
1792  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1793  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1794  0, 0, 0, 428, 619, 426, 0, 54, 0, 0,
1795  0, 0, 606, 0, 607, 0, 360, 359, 0, 0,
1796  516, 517, 284, 111, 112, 0, 0, 114, 0, 0,
1797  516, 517, 284, 327, 188, 181, 191, 176, 158, 159,
1798  160, 116, 117, 585, 329, 584, 0, 605, 604, 0,
1799  307, 455, 0, 0, 126, 592, 294, 269, 593, 265,
1800  0, 0, 0, 259, 267, 428, 619, 426, 0, 0,
1801  0, 260, 608, 0, 299, 264, 608, 254, 619, 619,
1802  253, 608, 304, 51, 23, 25, 24, 0, 301, 0,
1803  0, 0, 428, 426, 0, 17, 0, 608, 292, 13,
1804  607, 74, 608, 289, 295, 614, 613, 247, 614, 249,
1805  296, 588, 0, 100, 502, 503, 91, 86, 0, 428,
1806  619, 426, 548, 483, 486, 484, 499, 480, 456, 478,
1807  457, 458, 482, 459, 460, 0, 463, 469, 0, 470,
1808  465, 466, 0, 471, 0, 472, 0, 0, 618, 7,
1809  27, 28, 29, 30, 31, 49, 50, 619, 619, 59,
1810  63, 619, 0, 34, 43, 0, 44, 608, 0, 79,
1811  90, 47, 46, 0, 199, 268, 42, 217, 225, 230,
1812  231, 232, 227, 229, 239, 240, 233, 234, 210, 211,
1813  237, 238, 608, 226, 228, 222, 223, 224, 212, 213,
1814  214, 215, 216, 597, 599, 598, 600, 0, 263, 425,
1815  608, 597, 599, 598, 600, 0, 263, 0, 619, 351,
1816  0, 350, 0, 0, 0, 0, 0, 0, 294, 428,
1817  619, 426, 319, 324, 111, 112, 113, 0, 523, 322,
1818  522, 428, 619, 426, 0, 0, 548, 331, 597, 598,
1819  263, 35, 201, 41, 209, 0, 199, 591, 0, 270,
1820  266, 619, 597, 598, 608, 597, 598, 590, 298, 610,
1821  250, 255, 257, 303, 22, 0, 242, 0, 32, 423,
1822  421, 208, 0, 76, 16, 291, 612, 0, 84, 97,
1823  99, 608, 597, 598, 554, 551, 550, 549, 552, 0,
1824  565, 0, 576, 566, 580, 579, 575, 548, 408, 547,
1825  411, 553, 555, 557, 533, 563, 619, 568, 619, 573,
1826  533, 578, 533, 0, 531, 487, 0, 462, 464, 474,
1827  468, 476, 218, 219, 398, 608, 0, 396, 395, 0,
1828  619, 0, 274, 0, 88, 82, 0, 0, 0, 0,
1829  0, 0, 429, 66, 0, 0, 432, 0, 0, 427,
1830  64, 619, 349, 287, 619, 619, 441, 619, 352, 619,
1831  354, 312, 353, 315, 0, 0, 318, 601, 293, 608,
1832  597, 598, 0, 0, 525, 0, 0, 111, 112, 115,
1833  608, 0, 608, 548, 0, 0, 0, 252, 417, 58,
1834  251, 0, 127, 271, 261, 0, 0, 432, 0, 0,
1835  619, 608, 11, 0, 248, 92, 95, 0, 559, 554,
1836  0, 372, 363, 365, 608, 361, 608, 0, 0, 540,
1837  0, 529, 583, 567, 0, 530, 0, 543, 577, 0,
1838  545, 581, 488, 490, 491, 492, 485, 493, 554, 0,
1839  394, 608, 0, 379, 561, 619, 619, 571, 379, 379,
1840  377, 400, 0, 0, 0, 0, 0, 272, 80, 200,
1841  0, 40, 206, 39, 207, 67, 424, 611, 0, 37,
1842  204, 38, 205, 65, 422, 442, 443, 619, 444, 0,
1843  619, 357, 0, 0, 355, 0, 0, 0, 317, 0,
1844  0, 432, 0, 325, 0, 0, 432, 328, 586, 608,
1845  0, 527, 332, 418, 419, 202, 0, 256, 302, 20,
1846  569, 608, 0, 370, 0, 556, 0, 0, 0, 409,
1847  532, 558, 533, 533, 564, 619, 582, 533, 574, 533,
1848  533, 0, 0, 0, 560, 0, 397, 385, 387, 0,
1849  375, 376, 0, 390, 0, 392, 0, 436, 434, 0,
1850  415, 273, 243, 36, 203, 0, 0, 446, 358, 0,
1851  12, 448, 0, 309, 310, 0, 0, 270, 619, 320,
1852  0, 524, 323, 526, 330, 548, 362, 373, 0, 368,
1853  364, 410, 0, 0, 0, 536, 0, 538, 528, 0,
1854  544, 0, 541, 546, 0, 570, 294, 428, 399, 378,
1855  379, 379, 562, 619, 379, 572, 379, 379, 404, 608,
1856  402, 405, 60, 0, 445, 0, 102, 103, 110, 0,
1857  447, 0, 313, 316, 438, 439, 437, 0, 0, 0,
1858  0, 371, 0, 366, 413, 412, 533, 533, 533, 533,
1859  489, 601, 293, 0, 382, 0, 384, 374, 0, 391,
1860  0, 388, 393, 0, 401, 109, 428, 619, 426, 619,
1861  619, 0, 326, 0, 369, 0, 537, 0, 534, 539,
1862  542, 379, 379, 379, 379, 403, 601, 108, 608, 597,
1863  598, 440, 356, 321, 333, 367, 533, 383, 0, 380,
1864  386, 389, 432, 535, 379, 381
1865 };
1866 
1867 /* YYDEFGOTO[NTERM-NUM]. */
1868 static const yytype_int16 yydefgoto[] =
1869 {
1870  -1, 1, 2, 66, 67, 68, 236, 567, 568, 252,
1871  253, 446, 254, 437, 70, 71, 358, 72, 73, 510,
1872  690, 243, 75, 76, 255, 77, 78, 79, 467, 80,
1873  209, 377, 378, 192, 193, 194, 195, 605, 556, 197,
1874  82, 439, 211, 260, 228, 748, 426, 427, 225, 226,
1875  213, 413, 428, 516, 83, 356, 259, 452, 625, 360,
1876  846, 361, 847, 732, 987, 736, 733, 930, 594, 596,
1877  746, 935, 245, 85, 86, 87, 88, 89, 90, 91,
1878  92, 93, 94, 713, 570, 721, 843, 844, 369, 772,
1879  773, 774, 959, 898, 801, 686, 687, 802, 969, 970,
1880  278, 279, 472, 777, 658, 879, 320, 511, 95, 96,
1881  711, 704, 565, 557, 318, 508, 507, 577, 986, 715,
1882  837, 916, 920, 97, 98, 99, 100, 101, 102, 103,
1883  290, 485, 104, 294, 105, 106, 292, 296, 286, 284,
1884  288, 477, 676, 675, 792, 891, 796, 107, 285, 108,
1885  109, 216, 217, 112, 218, 219, 589, 735, 744, 880,
1886  779, 745, 661, 662, 663, 664, 665, 804, 805, 666,
1887  667, 668, 669, 807, 808, 670, 671, 672, 673, 674,
1888  781, 396, 595, 265, 429, 221, 115, 629, 559, 399,
1889  304, 423, 424, 706, 457, 571, 364, 257
1890 };
1891 
1892 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1893  STATE-NUM. */
1894 #define YYPACT_NINF -810
1895 static const yytype_int16 yypact[] =
1896 {
1897  -810, 102, 2888, -810, 7502, -810, -810, -810, 7025, -810,
1898  -810, -810, -810, -810, -810, -810, 7615, 7615, -810, -810,
1899  7615, 4210, 3805, -810, -810, -810, -810, 190, 6892, -21,
1900  -810, 10, -810, -810, -810, 3130, 3940, -810, -810, 3265,
1901  -810, -810, -810, -810, -810, -810, 8971, 8971, 130, 5262,
1902  9084, 7954, 8293, 7284, -810, 6759, -810, -810, -810, 54,
1903  70, 225, 228, 515, 9197, 8971, -810, 245, -810, 1021,
1904  -810, 269, -810, -810, 73, 120, 87, -810, 98, 9310,
1905  -810, 148, 3109, 44, 359, -810, 9084, 9084, -810, -810,
1906  6149, 9419, 9528, 9637, 6625, 30, 86, -810, -810, 230,
1907  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1908  3, 385, -810, 348, 490, -810, -810, -810, -810, -810,
1909  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1910  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1911  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1912  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1913  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1914  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1915  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1916  -810, -810, -810, -810, -810, 285, -810, -810, -810, -810,
1917  253, 8971, 374, 5401, 8971, 8971, 8971, 8971, -810, 328,
1918  3109, 364, -810, -810, 313, 369, 208, 224, 395, 247,
1919  354, -810, -810, -810, 6036, -810, 7615, 7615, -810, -810,
1920  6262, -810, 9084, 844, -810, 360, 388, 5540, -810, -810,
1921  -810, 379, 400, 73, -810, 464, 463, 501, 7728, -810,
1922  5262, 402, 245, -810, 1021, -21, 437, -810, 269, -21,
1923  415, 8, 317, -810, 364, 440, 317, -810, -21, 525,
1924  615, 9746, 470, -810, 488, 508, 575, 612, -810, -810,
1925  -810, -810, -810, -810, 438, -810, 447, 451, 284, 475,
1926  540, 496, 60, 502, 576, 516, 61, 550, 565, -810,
1927  -810, -810, -810, -810, -810, -810, 6375, 9084, 9084, 9084,
1928  9084, 7728, 9084, 9084, -810, -810, -810, 549, -810, -810,
1929  -810, 8406, -810, 5262, 7393, 527, 8406, 8971, 8971, 8971,
1930  8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971,
1931  8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971,
1932  8971, 8971, 8971, 10025, 7615, 10102, 4619, 269, 110, 110,
1933  9084, 9084, 245, 654, 538, 631, -810, -810, 645, 668,
1934  85, 93, 108, 405, 410, 9084, 377, -810, 123, 661,
1935  -810, -810, -810, -810, 40, 42, 56, 167, 180, 279,
1936  332, 336, 343, -810, -810, -810, 30, -810, -810, 10179,
1937  -810, -810, 9197, 9197, -810, -810, 394, -810, -810, -810,
1938  8971, 8971, 7841, -810, -810, 10256, 7615, 10333, 8971, 8971,
1939  8067, -810, -21, 558, -810, -810, -21, -810, 564, 566,
1940  -810, 66, -810, -810, -810, -810, -810, 7025, -810, 8971,
1941  5671, 574, 10256, 10333, 8971, 1021, 581, -21, -810, -810,
1942  6488, 572, -21, -810, -810, 8180, -810, -810, 8293, -810,
1943  -810, -810, 360, 678, -810, -810, -810, 588, 9746, 10410,
1944  7615, 10487, 1081, -810, -810, -810, -810, -810, -810, -810,
1945  -810, -810, -810, -810, -810, 302, -810, -810, 594, -810,
1946  -810, -810, 306, -810, 597, -810, 8971, 8971, -810, -810,
1947  -810, -810, -810, -810, -810, -810, -810, 63, 63, -810,
1948  -810, 63, 8971, -810, 605, 607, -810, -21, 9746, 617,
1949  -810, -810, -810, 636, 1231, -810, -810, 463, 2567, 2567,
1950  2567, 2567, 976, 976, 2722, 2633, 2567, 2567, 3244, 3244,
1951  339, 339, 1305, 976, 976, 986, 986, 1119, 255, 255,
1952  463, 463, 463, 4345, 3400, 4480, 3535, 400, 620, -810,
1953  -21, 591, -810, 742, -810, 400, 4075, 747, 754, -810,
1954  4758, 756, 5036, 52, 52, 654, 8519, 747, 121, 10564,
1955  7615, 10641, -810, 269, -810, 678, -810, 245, -810, -810,
1956  -810, 10718, 7615, 10179, 4619, 9084, 1274, -810, -810, -810,
1957  1148, -810, 2322, -810, 3109, 7025, 2974, -810, 8971, 364,
1958  -810, 354, 2995, 3670, -21, 398, 497, -810, -810, -810,
1959  -810, 7841, 8067, -810, -810, 9084, 3109, 644, -810, -810,
1960  -810, 3109, 5671, 212, -810, -810, 317, 9746, 588, 495,
1961  323, -21, 337, 376, 676, -810, -810, -810, -810, 8971,
1962  -810, 896, -810, -810, -810, -810, -810, 1142, -810, -810,
1963  -810, -810, -810, -810, 656, -810, 657, 743, 663, -810,
1964  667, 750, 671, 760, -810, -810, 763, -810, -810, -810,
1965  -810, -810, 463, 463, -810, 793, 5810, -810, -810, 5540,
1966  63, 5810, 679, 8632, -810, 588, 9746, 9197, 8971, 699,
1967  9197, 9197, -810, 549, 400, 681, 759, 9197, 9197, -810,
1968  549, 400, -810, -810, 8745, 810, -810, 718, -810, 810,
1969  -810, -810, -810, -810, 747, 92, -810, 81, 149, -21,
1970  144, 155, 9084, 245, -810, 9084, 4619, 495, 323, -810,
1971  -21, 747, 66, 1142, 4619, 245, 7158, -810, 86, 120,
1972  -810, 8971, -810, -810, -810, 8971, 8971, 504, 8971, 8971,
1973  694, 66, -810, 700, -810, -810, 390, 8971, -810, -810,
1974  896, 473, -810, 702, -21, -810, -21, 124, 1142, -810,
1975  571, -810, -810, -810, 38, -810, 1142, -810, -810, 881,
1976  -810, -810, -810, -810, -810, -810, -810, -810, 720, 9855,
1977  -810, -21, 716, 703, -810, 707, 663, -810, 723, 724,
1978  -810, 725, 856, 737, 5540, 859, 8971, 740, 588, 3109,
1979  8971, -810, 3109, -810, 3109, -810, -810, -810, 9197, -810,
1980  3109, -810, 3109, -810, -810, 605, -810, 797, -810, 5149,
1981  872, -810, 9084, 747, -810, 747, 5810, 5810, -810, 8858,
1982  4897, 159, 52, -810, 245, 747, -810, -810, -810, -21,
1983  747, -810, -810, -810, -810, 3109, 8971, 8067, -810, -810,
1984  -810, -21, 875, 752, 953, -810, 762, 5810, 5540, -810,
1985  -810, -810, 753, 757, -810, 663, -810, 767, -810, 768,
1986  767, 5923, 9855, 848, 689, 787, -810, 1386, -810, 622,
1987  -810, -810, 1386, -810, 1533, -810, 1028, -810, -810, 778,
1988  -810, 784, 3109, -810, 3109, 9964, 110, -810, -810, 5810,
1989  -810, -810, 110, -810, -810, 747, 747, -810, 383, -810,
1990  4619, -810, -810, -810, -810, 1274, -810, 785, 875, 672,
1991  -810, -810, 911, 792, 1142, -810, 881, -810, -810, 881,
1992  -810, 881, -810, -810, 820, 689, -810, 10795, -810, -810,
1993  806, 809, -810, 663, 811, -810, 812, 811, -810, 352,
1994  -810, -810, -810, 891, -810, 691, 508, 575, 612, 4619,
1995  -810, 4758, -810, -810, -810, -810, -810, 5810, 747, 4619,
1996  875, 785, 875, 823, -810, -810, 767, 824, 767, 767,
1997  -810, 818, 826, 1386, -810, 1533, -810, -810, 1533, -810,
1998  1533, -810, -810, 1028, -810, 678, 10872, 7615, 10949, 754,
1999  718, 747, -810, 747, 785, 875, -810, 881, -810, -810,
2000  -810, 811, 825, 811, 811, -810, 49, 323, -21, 179,
2001  215, -810, -810, -810, -810, 785, 767, -810, 1533, -810,
2002  -810, -810, 216, -810, 811, -810
2003 };
2004 
2005 /* YYPGOTO[NTERM-NUM]. */
2006 static const yytype_int16 yypgoto[] =
2007 {
2008  -810, -810, -810, -382, -810, 26, -810, -549, -7, -810,
2009  513, -810, 33, -810, -315, -33, -63, -55, -810, -216,
2010  -810, 766, -13, 874, -164, 20, -73, -810, -409, 29,
2011  1882, -309, 882, -54, -810, -5, -810, -810, 6, -810,
2012  1208, -810, 1366, -810, -41, 256, -344, 78, -14, -810,
2013  -384, -205, -4, -304, -15, -810, -810, -810, -810, -810,
2014  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
2015  -810, -810, 64, -810, -810, -810, -810, -810, -810, -810,
2016  -810, -810, -810, -1, -333, -519, -44, -623, -810, -789,
2017  -771, 211, 297, 71, -810, -437, -810, -693, -810, -29,
2018  -810, -810, -810, -810, -810, -810, 237, -810, -810, -810,
2019  -810, -810, -810, -810, -94, -810, -810, -531, -810, -31,
2020  -810, -810, -810, -810, -810, -810, 890, -810, -810, -810,
2021  -810, 701, -810, -810, -810, -810, -810, -810, -810, 940,
2022  -810, -126, -810, -810, -810, -810, -810, -3, -810, 11,
2023  -810, 1400, 1673, 905, 1898, 1689, -810, -810, 65, -451,
2024  -102, -385, -809, -588, -689, -289, 222, 107, -810, -810,
2025  -810, 18, -721, -764, 115, 235, -810, -634, -810, -37,
2026  -627, -810, -810, -810, 114, -388, -810, -324, -810, 623,
2027  -47, -9, -123, -568, -214, 21, -11, -2
2028 };
2029 
2030 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2031  positive, shift that token. If negative, reduce the rule which
2032  number is the opposite. If YYTABLE_NINF, syntax error. */
2033 #define YYTABLE_NINF -620
2034 static const yytype_int16 yytable[] =
2035 {
2036  116, 283, 400, 208, 208, 198, 325, 208, 229, 299,
2037  560, 521, 214, 214, 196, 421, 214, 258, 232, 199,
2038  235, 659, 526, 234, 359, 198, 572, 362, 610, 558,
2039  117, 566, 617, 316, 196, 69, 610, 69, 273, 199,
2040  394, 785, 251, 363, 724, 741, 757, 261, 459, 263,
2041  267, 809, 461, 357, 357, 723, 306, 357, 627, 638,
2042  317, 196, -106, 775, 273, 888, 84, 586, 84, 256,
2043  617, 689, 614, 766, 691, 600, 273, 273, 273, 720,
2044  215, 215, 272, 876, 215, 940, 447, 660, 305, 881,
2045  -518, 558, 840, 566, 212, 222, 845, 971, 223, 314,
2046  196, 937, 3, 312, 313, 569, -106, 432, 895, 695,
2047  -102, 305, 314, 84, 215, 397, -102, 274, -103, 630,
2048  231, 488, 494, 569, 587, -510, 641, -509, 215, -338,
2049  220, 220, 451, -110, 220, 654, 453, -93, 965, 684,
2050  237, -511, 455, 274, 883, 659, -109, 630, 319, 456,
2051  215, 215, 889, 877, 215, 368, 379, 379, 655, 517,
2052  479, 851, 482, 398, 486, 262, 266, 991, 486, -105,
2053  489, 495, 856, -510, -108, -509, -338, -338, 900, 901,
2054  -107, 685, 775, 873, -104, -597, 247, 855, -106, -511,
2055  -106, 302, -105, 303, 289, 860, 251, 431, 466, 433,
2056  321, 940, 316, 315, 971, 449, 659, 231, 881, 227,
2057  291, 208, 414, 208, 208, -97, 315, -597, 414, -93,
2058  214, 1024, 214, 888, 421, 430, 849, -94, -107, -104,
2059  441, 302, 322, 303, 617, 878, 729, 610, 610, 965,
2060  588, 450, -101, 251, 500, 501, 502, 503, 740, 302,
2061  763, 303, -512, 814, 1045, -100, 273, 630, 948, 462,
2062  881, 326, 302, 961, 303, -514, 513, 84, 966, 630,
2063  256, 522, 776, 305, 357, 357, 357, 357, -96, 505,
2064  506, 445, 739, -99, 775, -598, 775, 818, 215, -98,
2065  215, 215, 659, -95, 215, -518, 215, 573, 574, 618,
2066  -512, 84, 422, 620, 425, 984, 312, 313, 623, 273,
2067  997, -519, 84, -514, 84, 575, 251, 515, -105, 881,
2068  -105, -102, 515, 327, 633, -74, 230, 357, 357, 635,
2069  56, 231, 499, 929, 419, 274, 1007, -103, 220, 69,
2070  220, 208, 583, 256, 504, 473, -88, 601, 603, 481,
2071  775, 993, 430, 519, -107, -104, -107, -104, 859, 678,
2072  -110, 564, -96, 473, -513, 293, 678, 473, 295, 1032,
2073  84, 215, 215, 215, 215, 84, 215, 215, 350, 351,
2074  352, 988, 521, 305, 302, 215, 303, 84, 274, 230,
2075  215, 474, 850, 475, 694, 466, 803, 985, 839, 590,
2076  576, -98, 775, 208, 775, 564, 754, 327, -293, 474,
2077  836, 475, -513, 474, 430, 475, -432, -515, 215, 404,
2078  84, -504, 764, 564, 215, 215, 414, 414, -507, 584,
2079  406, -594, 624, 585, 198, 402, -595, 775, 116, 215,
2080  1023, 410, 677, 196, 353, 466, 680, 412, 199, 564,
2081  -96, 458, 411, 273, 415, -293, -293, 208, 456, -598,
2082  348, 349, 350, 351, 352, -515, 215, 215, 430, -504,
2083  1052, -96, -519, 69, -96, -432, -507, 564, -96, 617,
2084  215, 444, 418, 610, 659, 758, 1013, 825, 420, -98,
2085  -504, 354, 355, 231, 833, -507, 438, 887, -103, 473,
2086  890, 416, 417, 273, 84, 688, 688, -109, 473, 688,
2087  -98, -105, 473, -98, 84, 224, 702, -98, 440, -94,
2088  -432, -601, -432, -432, 709, 769, 611, 645, 646, 647,
2089  648, 327, 274, 699, 215, -594, 227, -504, -504, 448,
2090  -595, -594, -507, -507, 703, 474, -595, 475, 476, 442,
2091  -73, 705, 710, 454, 474, 754, 475, 478, 474, 747,
2092  475, 480, 742, 717, 765, 719, 716, 208, 787, 636,
2093  790, 460, 725, 469, 297, 298, 726, 403, 430, 208,
2094  -601, 463, 274, 979, 759, 483, 749, 564, 444, 981,
2095  430, 866, 761, -516, 722, 722, 416, 443, 750, 564,
2096  752, 473, 198, -110, 468, 705, 487, 872, 734, 414,
2097  -107, 196, 490, 964, -109, 967, 199, -104, 496, 858,
2098  470, 471, 273, 466, -101, -601, 493, -601, -601, 649,
2099  116, -597, 705, 497, 84, -100, 84, 473, 868, 650,
2100  -516, -516, 522, 509, 215, 821, 823, 474, 810, 475,
2101  484, 875, 829, 831, 863, 996, 215, 998, 84, 215,
2102  -517, 520, 999, 826, 782, 69, 782, 653, 654, 852,
2103  747, 576, 854, 1038, 464, 465, 811, 498, 707, 812,
2104  799, 273, 813, 474, 815, 475, 491, 578, 688, 215,
2105  650, 655, 862, 582, 630, 619, 84, -284, 621, 357,
2106  622, 274, 357, 806, -105, 628, -88, -517, -517, 750,
2107  515, 632, 838, 841, 1031, 841, 1033, 841, 653, 654,
2108  705, 1034, 637, 848, 769, -96, 645, 646, 647, 648,
2109  579, 705, 842, 839, 679, 760, 933, 681, 1046, -268,
2110  857, 693, 655, 886, -284, -284, 591, 886, 936, 697,
2111  84, 696, 196, 84, 853, 84, -423, 712, 414, 1054,
2112  274, 215, 714, -294, 215, 215, 861, 811, 74, 718,
2113  74, 215, 215, 913, 957, 762, 1016, 580, 581, 922,
2114  945, 947, 74, 74, 273, 950, 74, 952, 953, 767,
2115  778, 780, 811, 592, 593, 783, 215, 784, 885, 215,
2116  84, 786, 788, 782, 782, 789, 992, 909, 84, 357,
2117  -294, -294, 791, -269, 820, 74, 74, 793, 794, 827,
2118  795, 592, 593, 1017, 1018, 839, 44, 45, 867, 708,
2119  74, 869, 918, 892, 896, 917, 874, 897, 921, 925,
2120  926, 899, 923, 928, 924, 798, 828, 645, 646, 647,
2121  648, 799, 74, 74, 932, -107, 74, 902, 904, 934,
2122  810, 650, 886, 894, 906, 810, 907, 810, 908, 910,
2123  942, 943, -104, 722, -270, 931, -98, 273, 84, 903,
2124  905, 919, 651, 782, 954, 915, 938, 944, 652, 653,
2125  654, 946, 215, -95, 1026, 1028, 1029, 1030, 434, 941,
2126  273, 949, 951, 84, 956, 958, 215, 435, 436, 972,
2127  84, 84, 980, 655, 84, 806, 656, 963, -271, 990,
2128  806, 994, 806, 995, 982, 983, 841, 769, 1000, 645,
2129  646, 647, 648, 769, 231, 645, 646, 647, 648, 649,
2130  1003, 84, 84, 1005, 1053, 1008, 1010, 1015, 769, 650,
2131  645, 646, 647, 648, -597, 84, 955, 1025, 1027, 1048,
2132  1014, 782, -598, 634, 770, 366, 810, 834, 810, 74,
2133  651, 810, 1019, 810, 1020, 383, 1042, 653, 654, 975,
2134  1021, 871, 800, 84, 1035, 770, 864, 1022, 1041, 401,
2135  74, 771, 74, 74, 84, 492, 74, 287, 74, 395,
2136  989, 655, 884, 74, 208, 769, 962, 645, 646, 647,
2137  648, 810, 960, 882, 74, 430, 74, 716, 841, 597,
2138  1043, 806, 1044, 806, 564, 0, 806, 0, 806, 705,
2139  0, 1004, 1006, 0, 0, 1009, 0, 1011, 1012, 0,
2140  0, 0, 770, 84, 327, 84, 0, 0, 939, 0,
2141  0, 84, 0, 84, 327, 0, 0, 0, 0, 340,
2142  341, 307, 308, 309, 310, 311, 806, 0, 0, 340,
2143  341, 0, 74, 74, 74, 74, 74, 74, 74, 74,
2144  968, 215, 645, 646, 647, 648, 0, 74, 0, 74,
2145  0, 0, 74, 0, 345, 346, 347, 348, 349, 350,
2146  351, 352, 1047, 1049, 1050, 1051, 347, 348, 349, 350,
2147  351, 352, 0, 0, 0, 0, 0, 0, 0, 0,
2148  74, 0, 74, 0, 0, 1055, 74, 74, 0, 0,
2149  0, 0, 0, 644, 0, 645, 646, 647, 648, 649,
2150  0, 74, 0, 0, 0, 0, 0, 0, -619, 650,
2151  0, 0, 0, 0, 0, 0, -619, -619, -619, 0,
2152  0, -619, -619, -619, 0, -619, 0, 0, 74, 74,
2153  651, 0, 0, 0, -619, -619, 652, 653, 654, 0,
2154  0, 0, 74, 0, 0, -619, -619, 327, -619, -619,
2155  -619, -619, -619, 0, 644, 0, 645, 646, 647, 648,
2156  649, 655, 340, 341, 656, 0, 74, 0, 0, 0,
2157  650, 0, 0, 0, 0, 0, 74, 657, 0, 0,
2158  0, 0, 0, 0, 210, 210, 0, 0, 210, 0,
2159  0, 651, 0, -619, 0, 0, 74, 652, 653, 654,
2160  348, 349, 350, 351, 352, 0, 0, 0, 0, 0,
2161  0, 0, 0, 0, 244, 246, -619, 0, 0, 210,
2162  210, 0, 655, 0, 0, 656, 0, 0, 0, 0,
2163  0, 0, 300, 301, 0, 698, 0, 0, -619, -619,
2164  0, -619, 0, 0, 227, -619, 0, -619, 0, -619,
2165  0, 0, 0, 0, 0, 0, 0, 0, 0, 327,
2166  328, 329, 330, 331, 332, 333, 334, 335, 336, 337,
2167  338, 339, 0, 0, 340, 341, 0, 0, 0, 0,
2168  0, 0, 0, 0, 0, 0, 644, 0, 645, 646,
2169  647, 648, 649, 0, 0, 0, 74, 0, 74, 0,
2170  0, 0, 650, 0, 0, 342, 74, 343, 344, 345,
2171  346, 347, 348, 349, 350, 351, 352, 0, 74, 0,
2172  74, 74, 0, 651, 0, -245, 0, 0, 0, 652,
2173  653, 654, 0, 327, 328, 329, 330, 331, 332, 333,
2174  334, 335, 336, 337, 338, 339, 0, 0, 340, 341,
2175  0, 74, 0, 0, 655, 0, 0, 656, 74, 0,
2176  0, 0, 110, 0, 110, 0, 0, 0, 0, 210,
2177  743, 0, 210, 210, 210, 300, 0, 0, 264, 342,
2178  0, 343, 344, 345, 346, 347, 348, 349, 350, 351,
2179  352, 0, 210, 0, 210, 210, 0, 0, 798, 0,
2180  645, 646, 647, 648, 799, 0, 231, 0, 0, 110,
2181  0, 0, 74, 275, 650, 74, 0, 74, 0, 0,
2182  0, 0, 0, 74, 0, 0, 74, 74, 0, 0,
2183  0, 0, 0, 74, 74, 651, 0, 0, 0, 275,
2184  0, 652, 653, 654, 0, 0, 0, 0, 0, 0,
2185  0, 370, 380, 380, 380, 0, 0, 0, 74, 0,
2186  0, 74, 74, 0, 0, 0, 655, 0, 0, 656,
2187  74, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2188  0, 0, 0, 0, 0, 0, 0, 0, 0, 210,
2189  0, 0, 0, 0, 524, 527, 528, 529, 530, 531,
2190  532, 533, 534, 535, 536, 537, 538, 539, 540, 541,
2191  542, 543, 544, 545, 546, 547, 548, 549, 550, 551,
2192  552, 0, 210, 0, 0, 0, 0, 405, 0, 0,
2193  407, 408, 409, 0, 0, 0, 0, 0, 0, 0,
2194  74, 0, 0, 0, 0, 769, 0, 645, 646, 647,
2195  648, 799, 0, 0, 74, 0, 0, 0, 0, 0,
2196  0, 650, 0, 110, 0, 74, 0, 0, 74, 0,
2197  602, 604, 74, 74, 0, 0, 74, 0, 606, 210,
2198  210, 0, 651, 0, 210, 0, 602, 604, 210, 653,
2199  654, 0, 0, 0, 0, 0, 0, 110, 0, 0,
2200  0, 0, 0, 74, 74, 0, 0, 626, 110, 0,
2201  110, 0, 631, 655, 0, 0, 0, 74, 0, 0,
2202  0, 0, 0, 210, 0, 0, 210, 0, 0, 0,
2203  0, 275, 0, 0, 0, 111, 0, 111, 210, 0,
2204  0, 0, 0, 0, 0, 74, 0, 514, 0, 0,
2205  0, 114, 525, 114, 0, 0, 74, 0, 0, 0,
2206  0, 0, 0, 0, 682, 683, 110, 0, 0, 0,
2207  0, 110, 0, 0, 0, 0, 0, 0, 0, 0,
2208  210, 0, 111, 110, 275, 0, 276, 0, 0, 0,
2209  0, 0, 0, 0, 0, 0, 0, 0, 114, 0,
2210  0, 0, 277, 0, 0, 74, 0, 74, 0, 0,
2211  0, 0, 276, 74, 0, 74, 110, 0, 0, 0,
2212  0, 0, 0, 0, 371, 381, 381, 381, 277, 0,
2213  0, 0, 0, 0, 0, 0, 0, 607, 609, 0,
2214  372, 382, 382, 74, 210, 0, 264, 0, 210, 0,
2215  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2216  210, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2217  0, 0, 0, 0, 0, 0, 210, 0, 0, 0,
2218  0, 609, 0, 0, 264, 0, 0, 0, 0, 210,
2219  210, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2220  110, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2221  110, 0, 0, 0, 0, 0, 0, 210, 0, 0,
2222  0, 0, 0, 0, 0, 0, 0, 0, 275, 0,
2223  0, 0, 0, 0, 0, 0, 111, 0, 692, 0,
2224  0, 0, 0, 0, 81, 0, 81, 0, 0, 0,
2225  0, 0, 114, 0, 0, 0, 0, 0, 0, 0,
2226  113, 210, 113, 0, 0, 606, 819, 0, 822, 824,
2227  111, 0, 0, 0, 0, 830, 832, 0, 275, 0,
2228  0, 111, 210, 111, 0, 0, 114, 0, 0, 0,
2229  0, 81, 0, 0, 0, 0, 0, 114, 0, 114,
2230  0, 0, 525, 0, 276, 0, 0, 113, 0, 0,
2231  0, 0, 0, 0, 0, 0, 0, 0, 0, 865,
2232  277, 0, 0, 822, 824, 0, 830, 832, 0, 0,
2233  110, 0, 110, 367, 753, 210, 0, 0, 0, 111,
2234  0, 0, 0, 0, 111, 0, 0, 609, 264, 0,
2235  0, 0, 0, 0, 110, 114, 111, 276, 0, 0,
2236  114, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2237  0, 0, 114, 277, 0, 768, 0, 0, 0, 0,
2238  0, 0, 0, 0, 210, 0, 0, 0, 912, 111,
2239  0, 0, 110, 0, 0, 0, 914, 275, 0, 0,
2240  0, 0, 0, 0, 0, 114, 0, 0, 0, 0,
2241  0, 0, 0, 0, 0, 0, 0, 210, 0, 817,
2242  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2243  0, 0, 0, 0, 914, 210, 0, 0, 0, 0,
2244  835, 0, 0, 0, 0, 81, 110, 0, 0, 110,
2245  0, 110, 0, 0, 0, 0, 275, 0, 0, 0,
2246  0, 113, 0, 0, 0, 0, 0, 0, 0, 0,
2247  0, 0, 0, 111, 0, 0, 0, 0, 0, 81,
2248  0, 0, 0, 111, 0, 0, 0, 0, 0, 114,
2249  81, 0, 81, 870, 0, 113, 110, 0, 0, 114,
2250  0, 276, 0, 0, 110, 0, 113, 0, 113, 0,
2251  0, 0, 0, 0, 0, 0, 0, 277, 0, 0,
2252  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2253  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2254  0, 0, 911, 0, 0, 0, 0, 0, 81, 0,
2255  0, 276, 0, 81, 0, 0, 0, 0, 0, 380,
2256  0, 0, 0, 0, 113, 81, 0, 277, 523, 113,
2257  0, 0, 0, 0, 110, 927, 0, 0, 0, 0,
2258  0, 113, 0, 0, 0, 210, 0, 0, 0, 0,
2259  0, 0, 0, 264, 0, 0, 0, 0, 81, 110,
2260  0, 0, 0, 111, 0, 111, 110, 110, 0, 0,
2261  110, 0, 0, 0, 113, 0, 0, 0, 0, 114,
2262  0, 114, 0, 0, 0, 0, 0, 111, 0, 0,
2263  0, 0, 0, 0, 0, 0, 0, 110, 110, 0,
2264  0, 0, 0, 114, 0, 0, 0, 0, 0, 0,
2265  0, 110, 380, 0, 0, 0, 0, 0, 0, 0,
2266  0, 0, 0, 0, 0, 111, 0, 0, 0, 0,
2267  276, 0, 0, 0, 0, 976, 0, 0, 0, 110,
2268  0, 114, 81, 0, 0, 0, 277, 0, 0, 0,
2269  110, 0, 81, 0, 0, 0, 0, 0, 113, 0,
2270  0, 0, 0, 0, 0, 0, 0, 0, 113, 0,
2271  0, 0, 0, 0, 0, 0, 0, 0, 0, 111,
2272  0, 0, 111, 0, 111, 797, 751, 0, 0, 276,
2273  0, 0, 0, 0, 0, 114, 0, 0, 114, 110,
2274  114, 110, 0, 0, 0, 277, 0, 110, 0, 110,
2275  327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
2276  337, 338, 339, 0, 0, 340, 341, 0, 0, 111,
2277  0, 0, 0, 0, 0, 0, 0, 111, 0, 0,
2278  0, 0, 0, 0, 0, 114, 0, 0, 0, 0,
2279  0, 0, 0, 114, 0, 0, 342, 0, 343, 344,
2280  345, 346, 347, 348, 349, 350, 351, 352, 0, 0,
2281  0, 0, 81, 0, 81, 0, 0, 0, 0, 0,
2282  0, 0, 0, 0, 0, 0, 0, 0, 113, 0,
2283  113, 0, 381, 0, 0, 0, 81, 0, 0, 0,
2284  0, 0, 0, 0, 0, 0, 0, 111, 382, 0,
2285  0, 0, 113, 0, 0, 0, 0, 0, 0, 0,
2286  0, 0, 0, 114, 0, 0, 0, 0, 0, 0,
2287  0, 0, 111, 0, 81, 0, 0, 0, 0, 111,
2288  111, 0, 0, 111, 0, 0, 0, 0, 114, 0,
2289  113, 0, 0, 0, 0, 114, 114, 0, 0, 114,
2290  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2291  111, 111, 0, 0, 0, 0, 0, 0, 0, 0,
2292  0, 0, 0, 0, 111, 381, 114, 114, 81, 0,
2293  0, 81, 0, 81, 0, 0, 0, 0, 0, 523,
2294  114, 382, 0, 0, 113, 0, 0, 113, 977, 113,
2295  0, 0, 111, 0, 0, 0, 0, 0, 0, 0,
2296  0, 0, 0, 111, 978, 0, 0, 0, 114, 0,
2297  0, 0, 0, 0, 0, 0, 0, 0, 81, 114,
2298  0, 0, 0, 0, 0, 0, 81, 0, 0, 0,
2299  0, 0, 0, 0, 113, 327, -620, -620, -620, -620,
2300  332, 333, 113, 0, -620, -620, 0, 0, 0, 0,
2301  340, 341, 111, 0, 111, 0, 0, 0, 0, 0,
2302  111, 0, 111, 0, 0, 0, 0, 0, 114, 0,
2303  114, 0, 0, 0, 0, 0, 114, 0, 114, 0,
2304  0, 0, 0, 343, 344, 345, 346, 347, 348, 349,
2305  350, 351, 352, 0, 0, 0, 81, 0, 0, 0,
2306  0, 327, 328, 329, 330, 331, 332, 333, 334, 0,
2307  336, 337, 113, 0, 0, 0, 340, 341, 0, 0,
2308  0, 81, 0, 0, 0, 0, 0, 0, 81, 81,
2309  0, 0, 81, 0, 0, 0, 0, 113, 0, 0,
2310  0, 0, 0, 0, 113, 113, 0, 0, 113, 343,
2311  344, 345, 346, 347, 348, 349, 350, 351, 352, 81,
2312  81, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2313  0, 0, 0, 81, 0, 113, 113, 0, 0, 0,
2314  0, 0, 0, 0, 0, 0, 0, 0, 0, 113,
2315  327, 328, 329, 330, 331, 332, 333, 974, 0, 336,
2316  337, 81, 0, 0, 0, 340, 341, 0, 0, 0,
2317  0, 0, 81, 0, 0, 0, 0, 113, 0, 0,
2318  0, 0, 0, 0, 0, 0, 0, 0, 113, 0,
2319  0, 0, 0, 0, 0, 0, 0, 0, 343, 344,
2320  345, 346, 347, 348, 349, 350, 351, 352, 0, 0,
2321  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2322  0, 81, 0, 81, 0, 0, 0, 0, 0, 81,
2323  0, 81, 0, 0, 0, 0, 0, 113, 0, 113,
2324  0, 0, 0, 0, 0, 113, 0, 113, -619, 4,
2325  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2326  11, 0, 0, 0, 12, 0, 13, 14, 15, 16,
2327  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2328  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2329  0, 0, 0, 28, 29, 30, 31, 32, 33, 34,
2330  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2331  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2332  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2333  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2334  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2335  58, 59, 60, 61, 62, -601, 0, 0, 0, 0,
2336  0, 0, 0, -601, -601, -601, 0, 0, -601, -601,
2337  -601, 0, -601, 0, 63, 64, 65, 0, 698, 0,
2338  0, -601, -601, -601, -601, 0, 0, -619, 0, -619,
2339  0, 0, -601, -601, 0, -601, -601, -601, -601, -601,
2340  0, 0, 327, 328, 329, 330, 331, 332, 333, 334,
2341  335, 336, 337, 338, 339, 0, 0, 340, 341, 0,
2342  0, 0, 0, -601, -601, -601, -601, -601, -601, -601,
2343  -601, -601, -601, -601, -601, -601, 0, 0, -601, -601,
2344  -601, 0, 755, -601, 0, 0, 0, 0, 342, -601,
2345  343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
2346  0, 0, 0, -601, 0, 0, -601, 0, -106, -601,
2347  -601, -601, -601, -601, -601, -601, -601, -601, -601, -601,
2348  -601, 0, 0, 0, 0, -601, -601, -601, -601, -601,
2349  -504, 0, -601, -601, -601, 0, -601, 0, -504, -504,
2350  -504, 0, 0, -504, -504, -504, 0, -504, 0, 0,
2351  0, 0, 0, 0, 0, -504, 0, -504, -504, -504,
2352  0, 0, 0, 0, 0, 0, 0, -504, -504, 0,
2353  -504, -504, -504, -504, -504, 0, 0, 327, 328, 329,
2354  330, 331, 332, 333, 334, 335, 336, 337, 338, 339,
2355  0, 0, 340, 341, 0, 0, 0, 0, -504, -504,
2356  -504, -504, -504, -504, -504, -504, -504, -504, -504, -504,
2357  -504, 0, 0, -504, -504, -504, 0, -504, -504, 0,
2358  0, 0, 0, 342, -504, 343, 344, 345, 346, 347,
2359  348, 349, 350, 351, 352, 0, 0, 0, -504, 0,
2360  0, -504, 0, -504, -504, -504, -504, -504, -504, -504,
2361  -504, -504, -504, -504, -504, -504, 0, 0, 0, 0,
2362  0, -504, -504, -504, -504, -507, 0, -504, -504, -504,
2363  0, -504, 0, -507, -507, -507, 0, 0, -507, -507,
2364  -507, 0, -507, 0, 0, 0, 0, 0, 0, 0,
2365  -507, 0, -507, -507, -507, 0, 0, 0, 0, 0,
2366  0, 0, -507, -507, 0, -507, -507, -507, -507, -507,
2367  0, 0, 327, 328, 329, 330, 331, 332, 333, 334,
2368  335, 336, 337, -620, -620, 0, 0, 340, 341, 0,
2369  0, 0, 0, -507, -507, -507, -507, -507, -507, -507,
2370  -507, -507, -507, -507, -507, -507, 0, 0, -507, -507,
2371  -507, 0, -507, -507, 0, 0, 0, 0, 0, -507,
2372  343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
2373  0, 0, 0, -507, 0, 0, -507, 0, -507, -507,
2374  -507, -507, -507, -507, -507, -507, -507, -507, -507, -507,
2375  -507, 0, 0, 0, 0, 0, -507, -507, -507, -507,
2376  -602, 0, -507, -507, -507, 0, -507, 0, -602, -602,
2377  -602, 0, 0, -602, -602, -602, 0, -602, 0, 0,
2378  0, 0, 0, 0, 0, 0, -602, -602, -602, -602,
2379  0, 0, 0, 0, 0, 0, 0, -602, -602, 0,
2380  -602, -602, -602, -602, -602, 0, 0, 0, 0, 0,
2381  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2382  0, 0, 0, 0, 0, 0, 0, 0, -602, -602,
2383  -602, -602, -602, -602, -602, -602, -602, -602, -602, -602,
2384  -602, 0, 0, -602, -602, -602, 0, 0, -602, 0,
2385  0, 0, 0, 0, -602, 0, 0, 0, 0, 0,
2386  0, 0, 0, 0, 0, 0, 0, 0, -602, 0,
2387  0, -602, 0, 0, -602, -602, -602, -602, -602, -602,
2388  -602, -602, -602, -602, -602, -602, 0, 0, 0, 0,
2389  -602, -602, -602, -602, -602, -603, 0, -602, -602, -602,
2390  0, -602, 0, -603, -603, -603, 0, 0, -603, -603,
2391  -603, 0, -603, 0, 0, 0, 0, 0, 0, 0,
2392  0, -603, -603, -603, -603, 0, 0, 0, 0, 0,
2393  0, 0, -603, -603, 0, -603, -603, -603, -603, -603,
2394  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2395  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2396  0, 0, 0, -603, -603, -603, -603, -603, -603, -603,
2397  -603, -603, -603, -603, -603, -603, 0, 0, -603, -603,
2398  -603, 0, 0, -603, 0, 0, 0, 0, 0, -603,
2399  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2400  0, 0, 0, -603, 0, 0, -603, 0, 0, -603,
2401  -603, -603, -603, -603, -603, -603, -603, -603, -603, -603,
2402  -603, 0, 0, 0, 0, -603, -603, -603, -603, -603,
2403  -293, 0, -603, -603, -603, 0, -603, 0, -293, -293,
2404  -293, 0, 0, -293, -293, -293, 0, -293, 0, 0,
2405  0, 0, 0, 0, 0, 0, 0, -293, -293, -293,
2406  0, 0, 0, 0, 0, 0, 0, -293, -293, 0,
2407  -293, -293, -293, -293, -293, 0, 0, 0, 0, 0,
2408  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2409  0, 0, 0, 0, 0, 0, 0, 0, -293, -293,
2410  -293, -293, -293, -293, -293, -293, -293, -293, -293, -293,
2411  -293, 0, 0, -293, -293, -293, 0, 756, -293, 0,
2412  0, 0, 0, 0, -293, 0, 0, 0, 0, 0,
2413  0, 0, 0, 0, 0, 0, 0, 0, -293, 0,
2414  0, -293, 0, -108, -293, -293, -293, -293, -293, -293,
2415  -293, -293, -293, -293, -293, -293, 0, 0, 0, 0,
2416  0, -293, -293, -293, -293, -431, 0, -293, -293, -293,
2417  0, -293, 0, -431, -431, -431, 0, 0, -431, -431,
2418  -431, 0, -431, 0, 0, 0, 0, 0, 0, 0,
2419  0, -431, -431, -431, 0, 0, 0, 0, 0, 0,
2420  0, 0, -431, -431, 0, -431, -431, -431, -431, -431,
2421  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2422  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2423  0, 0, 0, -431, -431, -431, -431, -431, -431, -431,
2424  -431, -431, -431, -431, -431, -431, 0, 0, -431, -431,
2425  -431, 0, 0, -431, 0, 0, 0, 0, 0, -431,
2426  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2427  0, 0, 0, -431, 0, 0, 0, 0, 0, -431,
2428  0, -431, -431, -431, -431, -431, -431, -431, -431, -431,
2429  -431, 0, 0, 0, 0, -431, -431, -431, -431, -431,
2430  -285, 227, -431, -431, -431, 0, -431, 0, -285, -285,
2431  -285, 0, 0, -285, -285, -285, 0, -285, 0, 0,
2432  0, 0, 0, 0, 0, 0, 0, -285, -285, -285,
2433  0, 0, 0, 0, 0, 0, 0, -285, -285, 0,
2434  -285, -285, -285, -285, -285, 0, 0, 0, 0, 0,
2435  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2436  0, 0, 0, 0, 0, 0, 0, 0, -285, -285,
2437  -285, -285, -285, -285, -285, -285, -285, -285, -285, -285,
2438  -285, 0, 0, -285, -285, -285, 0, 0, -285, 0,
2439  0, 0, 0, 0, -285, 0, 0, 0, 0, 0,
2440  0, 0, 0, 0, 0, 0, 0, 0, -285, 0,
2441  0, -285, 0, 0, -285, -285, -285, -285, -285, -285,
2442  -285, -285, -285, -285, -285, -285, 0, 0, 0, 0,
2443  0, -285, -285, -285, -285, -421, 0, -285, -285, -285,
2444  0, -285, 0, -421, -421, -421, 0, 0, -421, -421,
2445  -421, 0, -421, 0, 0, 0, 0, 0, 0, 0,
2446  0, -421, -421, -421, 0, 0, 0, 0, 0, 0,
2447  0, 0, -421, -421, 0, -421, -421, -421, -421, -421,
2448  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2449  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2450  0, 0, 0, -421, -421, -421, -421, -421, -421, -421,
2451  -421, -421, -421, -421, -421, -421, 0, 0, -421, -421,
2452  -421, 0, 0, -421, 0, 0, 0, 0, 0, -421,
2453  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2454  0, 0, 0, -421, 0, 0, 0, 0, 0, -421,
2455  0, -421, -421, -421, -421, -421, -421, -421, -421, -421,
2456  -421, 0, 0, 0, 0, -421, -421, -421, -421, -421,
2457  -300, -421, -421, -421, -421, 0, -421, 0, -300, -300,
2458  -300, 0, 0, -300, -300, -300, 0, -300, 0, 0,
2459  0, 0, 0, 0, 0, 0, 0, -300, -300, 0,
2460  0, 0, 0, 0, 0, 0, 0, -300, -300, 0,
2461  -300, -300, -300, -300, -300, 0, 0, 0, 0, 0,
2462  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2463  0, 0, 0, 0, 0, 0, 0, 0, -300, -300,
2464  -300, -300, -300, -300, -300, -300, -300, -300, -300, -300,
2465  -300, 0, 0, -300, -300, -300, 0, 0, -300, 0,
2466  0, 0, 0, 0, -300, 0, 0, 0, 0, 0,
2467  0, 0, 0, 0, 0, 0, 0, 0, -300, 0,
2468  0, 0, 0, 0, -300, 0, -300, -300, -300, -300,
2469  -300, -300, -300, -300, -300, -300, 0, 0, 0, 0,
2470  0, -300, -300, -300, -300, -601, 224, -300, -300, -300,
2471  0, -300, 0, -601, -601, -601, 0, 0, 0, -601,
2472  -601, 0, -601, 0, 0, 0, 0, 0, 0, 0,
2473  0, -601, 0, 0, 0, 0, 0, 0, 0, 0,
2474  0, 0, -601, -601, 0, -601, -601, -601, -601, -601,
2475  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2476  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2477  0, 0, 0, -601, -601, -601, -601, -601, -601, -601,
2478  -601, -601, -601, -601, -601, -601, 0, 0, -601, -601,
2479  -601, 0, 700, 0, 0, 0, 0, 0, 0, 0,
2480  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2481  0, 0, 0, -601, 0, 0, 0, 0, -106, -601,
2482  0, -601, -601, -601, -601, -601, -601, -601, -601, -601,
2483  -601, 0, 0, 0, 0, -601, -601, -601, -601, -97,
2484  -293, 0, -601, 0, -601, 0, -601, 0, -293, -293,
2485  -293, 0, 0, 0, -293, -293, 0, -293, 0, 0,
2486  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2487  0, 0, 0, 0, 0, 0, 0, -293, -293, 0,
2488  -293, -293, -293, -293, -293, 0, 0, 0, 0, 0,
2489  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2490  0, 0, 0, 0, 0, 0, 0, 0, -293, -293,
2491  -293, -293, -293, -293, -293, -293, -293, -293, -293, -293,
2492  -293, 0, 0, -293, -293, -293, 0, 701, 0, 0,
2493  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2494  0, 0, 0, 0, 0, 0, 0, 0, -293, 0,
2495  0, 0, 0, -108, -293, 0, -293, -293, -293, -293,
2496  -293, -293, -293, -293, -293, -293, 0, 0, 0, 0,
2497  0, -293, -293, -293, -99, 0, 0, -293, 0, -293,
2498  248, -293, 5, 6, 7, 8, 9, -619, -619, -619,
2499  10, 11, 0, 0, -619, 12, 0, 13, 14, 15,
2500  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2501  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2502  0, 0, 0, 0, 28, 29, 249, 31, 32, 33,
2503  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2504  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2505  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2506  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2507  0, 51, 52, 0, 53, 0, 0, 54, 55, 56,
2508  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2509  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2510  0, 0, 0, 0, 0, 63, 64, 65, 0, 0,
2511  0, 0, 0, 0, 0, 0, 0, 0, -619, 248,
2512  -619, 5, 6, 7, 8, 9, 0, 0, -619, 10,
2513  11, 0, -619, -619, 12, 0, 13, 14, 15, 16,
2514  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2515  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2516  0, 0, 0, 28, 29, 249, 31, 32, 33, 34,
2517  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2518  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2519  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2520  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2521  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2522  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2523  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2524  0, 0, 0, 0, 63, 64, 65, 0, 0, 0,
2525  0, 0, 0, 0, 0, 0, 0, -619, 248, -619,
2526  5, 6, 7, 8, 9, 0, 0, -619, 10, 11,
2527  0, 0, -619, 12, -619, 13, 14, 15, 16, 17,
2528  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2529  23, 24, 25, 26, 0, 0, 27, 0, 0, 0,
2530  0, 0, 28, 29, 249, 31, 32, 33, 34, 35,
2531  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2532  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2533  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2534  0, 0, 0, 48, 0, 0, 49, 50, 0, 51,
2535  52, 0, 53, 0, 0, 54, 55, 56, 57, 58,
2536  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
2537  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2538  0, 0, 0, 63, 64, 65, 0, 0, 0, 0,
2539  0, 0, 0, 0, 0, 0, -619, 248, -619, 5,
2540  6, 7, 8, 9, 0, 0, -619, 10, 11, 0,
2541  0, -619, 12, 0, 13, 14, 15, 16, 17, 18,
2542  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2543  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2544  0, 28, 29, 249, 31, 32, 33, 34, 35, 36,
2545  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2546  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2547  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2548  0, 0, 48, 0, 0, 49, 50, 0, 51, 52,
2549  0, 53, 0, 0, 54, 55, 56, 57, 58, 59,
2550  60, 61, 62, 0, 0, 0, 0, 0, 0, 0,
2551  248, 0, 5, 6, 7, 8, 9, 0, -619, -619,
2552  10, 11, 63, 64, 65, 12, 0, 13, 14, 15,
2553  16, 17, 18, 19, 0, -619, 0, -619, 0, 20,
2554  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2555  0, 0, 0, 0, 28, 29, 249, 31, 32, 33,
2556  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2557  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2558  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2559  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2560  0, 51, 52, 0, 53, 0, 0, 54, 55, 56,
2561  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2562  0, 0, 0, 248, 0, 5, 6, 7, 8, 9,
2563  0, 0, 0, 10, 11, 63, 64, 65, 12, 0,
2564  13, 14, 15, 16, 17, 18, 19, 0, -619, 0,
2565  -619, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2566  0, 27, 0, 0, 0, 0, 0, 28, 29, 249,
2567  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2568  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2569  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2570  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2571  0, 250, 50, 0, 51, 52, 0, 53, 0, 0,
2572  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2573  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2574  0, 0, 0, 0, 0, 0, 0, 0, 63, 64,
2575  65, 0, 0, 0, 0, 0, 0, 0, 0, -619,
2576  0, -619, 248, -619, 5, 6, 7, 8, 9, 0,
2577  0, 0, 10, 11, 0, 0, 0, 12, 0, 13,
2578  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2579  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2580  27, 0, 0, 0, 0, 0, 28, 29, 249, 31,
2581  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2582  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2583  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2584  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2585  49, 50, 0, 51, 52, 0, 53, 0, 0, 54,
2586  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2587  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2588  0, 0, 0, 0, 0, 0, 0, 63, 64, 65,
2589  0, 0, 0, 0, 0, 0, 0, 0, -619, 0,
2590  -619, 248, -619, 5, 6, 7, 8, 9, 0, 0,
2591  0, 10, 11, 0, 0, 0, 12, 0, 13, 14,
2592  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2593  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2594  0, 0, 0, 0, 0, 28, 29, 249, 31, 32,
2595  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2596  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2597  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2598  0, 0, 0, 0, 0, 0, 48, 0, 0, 49,
2599  50, 0, 51, 52, 0, 53, 0, 0, 54, 55,
2600  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2601  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2602  0, 0, 0, 0, 0, 0, 63, 64, 65, 0,
2603  0, -619, 4, 0, 5, 6, 7, 8, 9, -619,
2604  0, -619, 10, 11, 0, 0, 0, 12, 0, 13,
2605  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2606  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2607  27, 0, 0, 0, 0, 0, 28, 29, 30, 31,
2608  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2609  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2610  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2611  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2612  49, 50, 0, 51, 52, 0, 53, 0, 0, 54,
2613  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2614  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2615  0, 0, 0, 0, 0, 0, 0, 63, 64, 65,
2616  0, 0, -619, 0, 0, 0, 0, 0, 0, 0,
2617  -619, 248, -619, 5, 6, 7, 8, 9, 0, 0,
2618  -619, 10, 11, 0, 0, 0, 12, 0, 13, 14,
2619  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2620  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2621  0, 0, 0, 0, 0, 28, 29, 249, 31, 32,
2622  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2623  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2624  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2625  0, 0, 0, 0, 0, 0, 48, 0, 0, 49,
2626  50, 0, 51, 52, 0, 53, 0, 0, 54, 55,
2627  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2628  0, 0, 0, 0, 248, 0, 5, 6, 7, 8,
2629  9, 0, 0, 0, 10, 11, 63, 64, 65, 12,
2630  0, 13, 14, 15, 16, 17, 18, 19, 0, -619,
2631  0, -619, 0, 20, 21, 22, 23, 24, 25, 26,
2632  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2633  249, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2634  40, 0, 41, 42, 0, 43, 44, 45, 0, 46,
2635  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2636  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
2637  0, 0, 49, 50, 0, 51, 52, 0, 53, 0,
2638  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2639  0, -619, 0, 0, 0, 0, 0, 0, 0, 5,
2640  6, 7, 0, 9, 0, 0, 0, 10, 11, 63,
2641  64, 65, 12, 0, 13, 14, 15, 16, 17, 18,
2642  19, 0, -619, 0, -619, 0, 20, 21, 22, 23,
2643  24, 25, 26, 0, 0, 200, 0, 0, 0, 0,
2644  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2645  37, 38, 39, 40, 201, 41, 42, 0, 43, 44,
2646  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2647  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2648  0, 0, 202, 0, 0, 203, 50, 0, 51, 52,
2649  0, 204, 205, 206, 54, 55, 56, 57, 58, 59,
2650  60, 61, 62, 0, 0, 0, 0, 0, 0, 0,
2651  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2652  10, 11, 63, 207, 65, 12, 0, 13, 14, 15,
2653  16, 17, 18, 19, 0, 0, 0, 231, 0, 20,
2654  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2655  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2656  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2657  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2658  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2659  0, 0, 0, 0, 0, 202, 0, 0, 203, 50,
2660  0, 51, 52, 0, 0, 0, 0, 54, 55, 56,
2661  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2662  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2663  0, 0, 0, 10, 11, 63, 64, 65, 12, 0,
2664  13, 14, 15, 16, 17, 18, 19, 0, 302, 0,
2665  303, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2666  0, 27, 0, 0, 0, 0, 0, 0, 29, 0,
2667  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2668  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2669  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2670  0, 0, 0, 0, 0, 0, 0, 0, 202, 0,
2671  0, 203, 50, 0, 51, 52, 0, 0, 0, 0,
2672  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2673  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2674  7, 8, 9, 0, 0, 0, 10, 11, 63, 64,
2675  65, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2676  0, 0, 0, 231, 0, 20, 21, 22, 23, 24,
2677  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2678  28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
2679  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2680  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2681  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2682  0, 48, 0, 0, 49, 50, 0, 51, 52, 0,
2683  53, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2684  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2685  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2686  11, 63, 64, 65, 12, 0, 13, 14, 15, 16,
2687  17, 18, 19, 0, 498, 0, 0, 0, 20, 21,
2688  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2689  0, 0, 0, 28, 29, 249, 31, 32, 33, 34,
2690  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2691  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2692  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2693  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2694  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2695  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2696  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2697  0, 0, 0, 0, 63, 64, 65, 0, 0, 0,
2698  0, 0, 0, 0, 0, 0, 0, 498, 118, 119,
2699  120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
2700  130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2701  140, 141, 0, 0, 0, 142, 143, 144, 384, 385,
2702  386, 387, 149, 150, 151, 0, 0, 0, 0, 0,
2703  152, 153, 154, 155, 388, 389, 390, 391, 160, 37,
2704  38, 392, 40, 0, 0, 0, 0, 0, 0, 0,
2705  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
2706  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
2707  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2708  177, 178, 0, 0, 0, 0, 0, 0, 0, 0,
2709  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2710  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
2711  188, 0, 189, 190, 0, 0, 0, 0, 0, 0,
2712  191, 393, 118, 119, 120, 121, 122, 123, 124, 125,
2713  126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
2714  136, 137, 138, 139, 140, 141, 0, 0, 0, 142,
2715  143, 144, 145, 146, 147, 148, 149, 150, 151, 0,
2716  0, 0, 0, 0, 152, 153, 154, 155, 156, 157,
2717  158, 159, 160, 280, 281, 161, 282, 0, 0, 0,
2718  0, 0, 0, 0, 0, 162, 163, 164, 165, 166,
2719  167, 168, 169, 170, 0, 0, 171, 172, 0, 0,
2720  173, 174, 175, 176, 0, 0, 0, 0, 0, 0,
2721  0, 0, 0, 0, 177, 178, 0, 0, 0, 0,
2722  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2723  0, 0, 0, 0, 0, 179, 180, 181, 182, 183,
2724  184, 185, 186, 187, 188, 0, 189, 190, 0, 0,
2725  0, 0, 0, 0, 191, 118, 119, 120, 121, 122,
2726  123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
2727  133, 134, 135, 136, 137, 138, 139, 140, 141, 0,
2728  0, 0, 142, 143, 144, 145, 146, 147, 148, 149,
2729  150, 151, 0, 0, 0, 0, 0, 152, 153, 154,
2730  155, 156, 157, 158, 159, 160, 233, 0, 161, 0,
2731  0, 0, 0, 0, 0, 0, 0, 0, 162, 163,
2732  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
2733  172, 0, 0, 173, 174, 175, 176, 0, 0, 0,
2734  0, 0, 0, 0, 0, 0, 0, 177, 178, 0,
2735  0, 55, 0, 0, 0, 0, 0, 0, 0, 0,
2736  0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
2737  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
2738  190, 0, 0, 0, 0, 0, 0, 191, 118, 119,
2739  120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
2740  130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2741  140, 141, 0, 0, 0, 142, 143, 144, 145, 146,
2742  147, 148, 149, 150, 151, 0, 0, 0, 0, 0,
2743  152, 153, 154, 155, 156, 157, 158, 159, 160, 0,
2744  0, 161, 0, 0, 0, 0, 0, 0, 0, 0,
2745  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
2746  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
2747  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2748  177, 178, 0, 0, 55, 0, 0, 0, 0, 0,
2749  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2750  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
2751  188, 0, 189, 190, 0, 0, 0, 0, 0, 0,
2752  191, 118, 119, 120, 121, 122, 123, 124, 125, 126,
2753  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
2754  137, 138, 139, 140, 141, 0, 0, 0, 142, 143,
2755  144, 145, 146, 147, 148, 149, 150, 151, 0, 0,
2756  0, 0, 0, 152, 153, 154, 155, 156, 157, 158,
2757  159, 160, 0, 0, 161, 0, 0, 0, 0, 0,
2758  0, 0, 0, 0, 162, 163, 164, 165, 166, 167,
2759  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
2760  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
2761  0, 0, 0, 177, 178, 0, 0, 0, 0, 0,
2762  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2763  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
2764  185, 186, 187, 188, 0, 189, 190, 5, 6, 7,
2765  0, 9, 0, 191, 0, 10, 11, 0, 0, 0,
2766  12, 0, 13, 14, 15, 238, 239, 18, 19, 0,
2767  0, 0, 0, 0, 240, 241, 242, 23, 24, 25,
2768  26, 0, 0, 200, 0, 0, 0, 0, 0, 0,
2769  268, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2770  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2771  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2772  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2773  269, 0, 0, 203, 50, 0, 51, 52, 0, 0,
2774  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2775  62, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2776  9, 0, 0, 0, 10, 11, 0, 0, 0, 12,
2777  270, 13, 14, 15, 238, 239, 18, 19, 271, 0,
2778  0, 0, 0, 240, 241, 242, 23, 24, 25, 26,
2779  0, 0, 200, 0, 0, 0, 0, 0, 0, 268,
2780  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2781  40, 0, 41, 42, 0, 43, 44, 45, 0, 0,
2782  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2783  0, 0, 0, 0, 0, 0, 0, 0, 0, 269,
2784  0, 0, 203, 50, 0, 51, 52, 0, 0, 0,
2785  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2786  0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
2787  0, 0, 0, 10, 11, 0, 0, 0, 12, 270,
2788  13, 14, 15, 16, 17, 18, 19, 518, 0, 0,
2789  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2790  0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
2791  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2792  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2793  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2794  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2795  0, 49, 50, 0, 51, 52, 0, 53, 0, 0,
2796  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2797  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2798  7, 0, 9, 0, 0, 0, 10, 11, 63, 64,
2799  65, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2800  0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2801  25, 26, 0, 0, 200, 0, 0, 0, 0, 0,
2802  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2803  38, 39, 40, 201, 41, 42, 0, 43, 44, 45,
2804  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2805  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2806  0, 202, 0, 0, 203, 50, 0, 51, 52, 0,
2807  204, 205, 206, 54, 55, 56, 57, 58, 59, 60,
2808  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2809  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2810  11, 63, 207, 65, 12, 0, 13, 14, 15, 16,
2811  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2812  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2813  0, 0, 0, 28, 29, 0, 31, 32, 33, 34,
2814  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2815  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2816  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2817  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2818  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2819  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2820  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2821  0, 0, 10, 11, 63, 64, 65, 12, 0, 13,
2822  14, 15, 238, 239, 18, 19, 0, 0, 0, 0,
2823  0, 240, 241, 242, 23, 24, 25, 26, 0, 0,
2824  200, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2825  32, 33, 34, 35, 36, 37, 38, 39, 40, 201,
2826  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2827  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2828  0, 0, 0, 0, 0, 0, 0, 202, 0, 0,
2829  203, 50, 0, 51, 52, 0, 608, 205, 206, 54,
2830  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2831  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2832  0, 9, 0, 0, 0, 10, 11, 63, 207, 65,
2833  12, 0, 13, 14, 15, 238, 239, 18, 19, 0,
2834  0, 0, 0, 0, 240, 241, 242, 23, 24, 25,
2835  26, 0, 0, 200, 0, 0, 0, 0, 0, 0,
2836  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2837  39, 40, 201, 41, 42, 0, 43, 44, 45, 0,
2838  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2839  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2840  202, 0, 0, 203, 50, 0, 51, 52, 0, 204,
2841  205, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2842  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2843  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2844  63, 207, 65, 12, 0, 13, 14, 15, 238, 239,
2845  18, 19, 0, 0, 0, 0, 0, 240, 241, 242,
2846  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
2847  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2848  36, 37, 38, 39, 40, 201, 41, 42, 0, 43,
2849  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2850  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2851  0, 0, 0, 202, 0, 0, 203, 50, 0, 51,
2852  52, 0, 0, 205, 206, 54, 55, 56, 57, 58,
2853  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
2854  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2855  0, 10, 11, 63, 207, 65, 12, 0, 13, 14,
2856  15, 238, 239, 18, 19, 0, 0, 0, 0, 0,
2857  240, 241, 242, 23, 24, 25, 26, 0, 0, 200,
2858  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
2859  33, 34, 35, 36, 37, 38, 39, 40, 201, 41,
2860  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2861  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2862  0, 0, 0, 0, 0, 0, 202, 0, 0, 203,
2863  50, 0, 51, 52, 0, 608, 205, 0, 54, 55,
2864  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2865  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2866  9, 0, 0, 0, 10, 11, 63, 207, 65, 12,
2867  0, 13, 14, 15, 238, 239, 18, 19, 0, 0,
2868  0, 0, 0, 240, 241, 242, 23, 24, 25, 26,
2869  0, 0, 200, 0, 0, 0, 0, 0, 0, 29,
2870  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2871  40, 201, 41, 42, 0, 43, 44, 45, 0, 46,
2872  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2873  0, 0, 0, 0, 0, 0, 0, 0, 0, 202,
2874  0, 0, 203, 50, 0, 51, 52, 0, 0, 205,
2875  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2876  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2877  6, 7, 0, 9, 0, 0, 0, 10, 11, 63,
2878  207, 65, 12, 0, 13, 14, 15, 16, 17, 18,
2879  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2880  24, 25, 26, 0, 0, 200, 0, 0, 0, 0,
2881  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2882  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2883  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2884  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2885  0, 0, 202, 0, 0, 203, 50, 0, 51, 52,
2886  0, 512, 0, 0, 54, 55, 56, 57, 58, 59,
2887  60, 61, 62, 0, 0, 0, 0, 0, 0, 0,
2888  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2889  10, 11, 63, 207, 65, 12, 0, 13, 14, 15,
2890  238, 239, 18, 19, 0, 0, 0, 0, 0, 240,
2891  241, 242, 23, 24, 25, 26, 0, 0, 200, 0,
2892  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2893  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2894  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2895  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2896  0, 0, 0, 0, 0, 202, 0, 0, 203, 50,
2897  0, 51, 52, 0, 204, 0, 0, 54, 55, 56,
2898  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2899  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2900  0, 0, 0, 10, 11, 63, 207, 65, 12, 0,
2901  13, 14, 15, 238, 239, 18, 19, 0, 0, 0,
2902  0, 0, 240, 241, 242, 23, 24, 25, 26, 0,
2903  0, 200, 0, 0, 0, 0, 0, 0, 29, 0,
2904  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2905  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2906  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2907  0, 0, 0, 0, 0, 0, 0, 0, 202, 0,
2908  0, 203, 50, 0, 51, 52, 0, 816, 0, 0,
2909  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2910  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2911  7, 0, 9, 0, 0, 0, 10, 11, 63, 207,
2912  65, 12, 0, 13, 14, 15, 238, 239, 18, 19,
2913  0, 0, 0, 0, 0, 240, 241, 242, 23, 24,
2914  25, 26, 0, 0, 200, 0, 0, 0, 0, 0,
2915  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2916  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2917  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2918  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2919  0, 202, 0, 0, 203, 50, 0, 51, 52, 0,
2920  512, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2921  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2922  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2923  11, 63, 207, 65, 12, 0, 13, 14, 15, 238,
2924  239, 18, 19, 0, 0, 0, 0, 0, 240, 241,
2925  242, 23, 24, 25, 26, 0, 0, 200, 0, 0,
2926  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2927  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2928  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2929  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2930  0, 0, 0, 0, 202, 0, 0, 203, 50, 0,
2931  51, 52, 0, 608, 0, 0, 54, 55, 56, 57,
2932  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2933  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2934  0, 0, 10, 11, 63, 207, 65, 12, 0, 13,
2935  14, 15, 238, 239, 18, 19, 0, 0, 0, 0,
2936  0, 240, 241, 242, 23, 24, 25, 26, 0, 0,
2937  200, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2938  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2939  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2940  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2941  0, 0, 0, 0, 0, 0, 0, 202, 0, 0,
2942  203, 50, 0, 51, 52, 0, 0, 0, 0, 54,
2943  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2944  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2945  0, 9, 0, 0, 0, 10, 11, 63, 207, 65,
2946  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2947  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2948  26, 0, 0, 27, 0, 0, 0, 0, 0, 0,
2949  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2950  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2951  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2952  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2953  202, 0, 0, 203, 50, 0, 51, 52, 0, 0,
2954  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2955  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2956  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2957  63, 64, 65, 12, 0, 13, 14, 15, 16, 17,
2958  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2959  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
2960  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2961  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2962  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2963  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2964  0, 0, 0, 202, 0, 0, 203, 50, 0, 51,
2965  52, 0, 0, 0, 0, 54, 55, 56, 57, 58,
2966  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
2967  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2968  0, 10, 11, 63, 207, 65, 12, 0, 13, 14,
2969  15, 238, 239, 18, 19, 0, 0, 0, 0, 0,
2970  240, 241, 242, 23, 24, 25, 26, 0, 0, 200,
2971  0, 0, 0, 0, 0, 0, 268, 0, 0, 32,
2972  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2973  42, 0, 43, 44, 45, 0, 0, 0, 0, 0,
2974  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2975  0, 0, 0, 0, 0, 0, 269, 0, 0, 323,
2976  50, 0, 51, 52, 0, 324, 0, 0, 54, 55,
2977  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2978  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2979  10, 11, 0, 0, 0, 12, 270, 13, 14, 15,
2980  238, 239, 18, 19, 0, 0, 0, 0, 0, 240,
2981  241, 242, 23, 24, 25, 26, 0, 0, 200, 0,
2982  0, 0, 0, 0, 0, 268, 0, 0, 32, 33,
2983  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2984  0, 43, 44, 45, 0, 0, 0, 0, 0, 0,
2985  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2986  0, 0, 0, 0, 0, 365, 0, 0, 49, 50,
2987  0, 51, 52, 0, 53, 0, 0, 54, 55, 56,
2988  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2989  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2990  11, 0, 0, 0, 12, 270, 13, 14, 15, 238,
2991  239, 18, 19, 0, 0, 0, 0, 0, 240, 241,
2992  242, 23, 24, 25, 26, 0, 0, 200, 0, 0,
2993  0, 0, 0, 0, 268, 0, 0, 32, 33, 34,
2994  373, 36, 37, 38, 374, 40, 0, 41, 42, 0,
2995  43, 44, 45, 0, 0, 0, 0, 0, 0, 0,
2996  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2997  0, 375, 0, 0, 376, 0, 0, 203, 50, 0,
2998  51, 52, 0, 0, 0, 0, 54, 55, 56, 57,
2999  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
3000  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
3001  0, 0, 0, 12, 270, 13, 14, 15, 238, 239,
3002  18, 19, 0, 0, 0, 0, 0, 240, 241, 242,
3003  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
3004  0, 0, 0, 268, 0, 0, 32, 33, 34, 373,
3005  36, 37, 38, 374, 40, 0, 41, 42, 0, 43,
3006  44, 45, 0, 0, 0, 0, 0, 0, 0, 0,
3007  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3008  0, 0, 0, 376, 0, 0, 203, 50, 0, 51,
3009  52, 0, 0, 0, 0, 54, 55, 56, 57, 58,
3010  59, 60, 61, 62, 0, 0, 0, 0, 0, 5,
3011  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
3012  0, 0, 12, 270, 13, 14, 15, 238, 239, 18,
3013  19, 0, 0, 0, 0, 0, 240, 241, 242, 23,
3014  24, 25, 26, 0, 0, 200, 0, 0, 0, 0,
3015  0, 0, 268, 0, 0, 32, 33, 34, 35, 36,
3016  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
3017  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3018  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3019  0, 0, 269, 0, 0, 323, 50, 0, 51, 52,
3020  0, 0, 0, 0, 54, 55, 56, 57, 58, 59,
3021  60, 61, 62, 0, 0, 0, 0, 0, 5, 6,
3022  7, 0, 9, 0, 0, 0, 10, 11, 0, 0,
3023  0, 12, 270, 13, 14, 15, 238, 239, 18, 19,
3024  0, 0, 0, 0, 0, 240, 241, 242, 23, 24,
3025  25, 26, 0, 0, 200, 0, 0, 0, 0, 0,
3026  0, 268, 0, 0, 32, 33, 34, 35, 36, 37,
3027  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
3028  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3029  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3030  0, 893, 0, 0, 203, 50, 0, 51, 52, 0,
3031  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
3032  61, 62, 0, 0, 0, 0, 0, 5, 6, 7,
3033  0, 9, 0, 0, 0, 10, 11, 0, 0, 0,
3034  12, 270, 13, 14, 15, 238, 239, 18, 19, 0,
3035  0, 0, 0, 0, 240, 241, 242, 23, 24, 25,
3036  26, 0, 0, 200, 0, 0, 0, 0, 0, 0,
3037  268, 0, 0, 32, 33, 34, 35, 36, 37, 38,
3038  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
3039  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3040  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3041  973, 0, 0, 203, 50, 0, 51, 52, 0, 0,
3042  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
3043  62, 0, 0, 0, 0, 0, 0, 553, 554, 0,
3044  0, 555, 0, 0, 0, 0, 0, 0, 0, 0,
3045  270, 162, 163, 164, 165, 166, 167, 168, 169, 170,
3046  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
3047  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3048  177, 178, 0, 0, 0, 0, 0, 0, 0, 0,
3049  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3050  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
3051  188, 0, 189, 190, 561, 562, 0, 0, 563, 0,
3052  191, 0, 0, 0, 0, 0, 0, 0, 162, 163,
3053  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
3054  172, 0, 0, 173, 174, 175, 176, 0, 0, 0,
3055  0, 0, 0, 0, 0, 0, 0, 177, 178, 0,
3056  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3057  0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
3058  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
3059  190, 598, 562, 0, 0, 599, 0, 191, 0, 0,
3060  0, 0, 0, 0, 0, 162, 163, 164, 165, 166,
3061  167, 168, 169, 170, 0, 0, 171, 172, 0, 0,
3062  173, 174, 175, 176, 0, 0, 0, 0, 0, 0,
3063  0, 0, 0, 0, 177, 178, 0, 0, 0, 0,
3064  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3065  0, 0, 0, 0, 0, 179, 180, 181, 182, 183,
3066  184, 185, 186, 187, 188, 0, 189, 190, 612, 554,
3067  0, 0, 613, 0, 191, 0, 0, 0, 0, 0,
3068  0, 0, 162, 163, 164, 165, 166, 167, 168, 169,
3069  170, 0, 0, 171, 172, 0, 0, 173, 174, 175,
3070  176, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3071  0, 177, 178, 0, 0, 0, 0, 0, 0, 0,
3072  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3073  0, 0, 179, 180, 181, 182, 183, 184, 185, 186,
3074  187, 188, 0, 189, 190, 615, 562, 0, 0, 616,
3075  0, 191, 0, 0, 0, 0, 0, 0, 0, 162,
3076  163, 164, 165, 166, 167, 168, 169, 170, 0, 0,
3077  171, 172, 0, 0, 173, 174, 175, 176, 0, 0,
3078  0, 0, 0, 0, 0, 0, 0, 0, 177, 178,
3079  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3080  0, 0, 0, 0, 0, 0, 0, 0, 0, 179,
3081  180, 181, 182, 183, 184, 185, 186, 187, 188, 0,
3082  189, 190, 639, 554, 0, 0, 640, 0, 191, 0,
3083  0, 0, 0, 0, 0, 0, 162, 163, 164, 165,
3084  166, 167, 168, 169, 170, 0, 0, 171, 172, 0,
3085  0, 173, 174, 175, 176, 0, 0, 0, 0, 0,
3086  0, 0, 0, 0, 0, 177, 178, 0, 0, 0,
3087  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3088  0, 0, 0, 0, 0, 0, 179, 180, 181, 182,
3089  183, 184, 185, 186, 187, 188, 0, 189, 190, 642,
3090  562, 0, 0, 643, 0, 191, 0, 0, 0, 0,
3091  0, 0, 0, 162, 163, 164, 165, 166, 167, 168,
3092  169, 170, 0, 0, 171, 172, 0, 0, 173, 174,
3093  175, 176, 0, 0, 0, 0, 0, 0, 0, 0,
3094  0, 0, 177, 178, 0, 0, 0, 0, 0, 0,
3095  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3096  0, 0, 0, 179, 180, 181, 182, 183, 184, 185,
3097  186, 187, 188, 0, 189, 190, 727, 554, 0, 0,
3098  728, 0, 191, 0, 0, 0, 0, 0, 0, 0,
3099  162, 163, 164, 165, 166, 167, 168, 169, 170, 0,
3100  0, 171, 172, 0, 0, 173, 174, 175, 176, 0,
3101  0, 0, 0, 0, 0, 0, 0, 0, 0, 177,
3102  178, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3103  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3104  179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
3105  0, 189, 190, 730, 562, 0, 0, 731, 0, 191,
3106  0, 0, 0, 0, 0, 0, 0, 162, 163, 164,
3107  165, 166, 167, 168, 169, 170, 0, 0, 171, 172,
3108  0, 0, 173, 174, 175, 176, 0, 0, 0, 0,
3109  0, 0, 0, 0, 0, 0, 177, 178, 0, 0,
3110  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3111  0, 0, 0, 0, 0, 0, 0, 179, 180, 181,
3112  182, 183, 184, 185, 186, 187, 188, 0, 189, 190,
3113  737, 554, 0, 0, 738, 0, 191, 0, 0, 0,
3114  0, 0, 0, 0, 162, 163, 164, 165, 166, 167,
3115  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
3116  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
3117  0, 0, 0, 177, 178, 0, 0, 0, 0, 0,
3118  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3119  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
3120  185, 186, 187, 188, 0, 189, 190, 1001, 554, 0,
3121  0, 1002, 0, 191, 0, 0, 0, 0, 0, 0,
3122  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
3123  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
3124  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3125  177, 178, 0, 0, 0, 0, 0, 0, 0, 0,
3126  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3127  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
3128  188, 0, 189, 190, 1036, 554, 0, 0, 1037, 0,
3129  191, 0, 0, 0, 0, 0, 0, 0, 162, 163,
3130  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
3131  172, 0, 0, 173, 174, 175, 176, 0, 0, 0,
3132  0, 0, 0, 0, 0, 0, 0, 177, 178, 0,
3133  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3134  0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
3135  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
3136  190, 1039, 562, 0, 0, 1040, 0, 191, 0, 0,
3137  0, 0, 0, 0, 0, 162, 163, 164, 165, 166,
3138  167, 168, 169, 170, 0, 0, 171, 172, 0, 0,
3139  173, 174, 175, 176, 0, 0, 0, 0, 0, 0,
3140  0, 0, 0, 0, 177, 178, 0, 0, 0, 0,
3141  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3142  0, 0, 0, 0, 0, 179, 180, 181, 182, 183,
3143  184, 185, 186, 187, 188, 0, 189, 190, 0, 0,
3144  0, 0, 0, 0, 191
3145 };
3146 
3147 #define yypact_value_is_default(yystate) \
3148  ((yystate) == (-810))
3149 
3150 #define yytable_value_is_error(yytable_value) \
3151  ((yytable_value) == (-620))
3152 
3153 static const yytype_int16 yycheck[] =
3154 {
3155  2, 55, 96, 16, 17, 8, 79, 20, 22, 64,
3156  354, 326, 16, 17, 8, 220, 20, 50, 27, 8,
3157  29, 472, 326, 28, 87, 28, 359, 90, 412, 353,
3158  4, 355, 420, 74, 28, 2, 420, 4, 53, 28,
3159  94, 668, 49, 90, 575, 594, 614, 51, 262, 51,
3160  52, 685, 266, 86, 87, 574, 67, 90, 440, 468,
3161  74, 55, 13, 651, 79, 786, 2, 376, 4, 49,
3162  458, 508, 416, 641, 511, 399, 91, 92, 93, 27,
3163  16, 17, 53, 776, 20, 874, 250, 472, 67, 778,
3164  87, 415, 715, 417, 16, 17, 719, 906, 20, 26,
3165  94, 872, 0, 37, 38, 13, 25, 230, 801, 518,
3166  25, 90, 26, 49, 50, 85, 113, 53, 25, 443,
3167  141, 61, 61, 13, 1, 85, 470, 85, 64, 85,
3168  16, 17, 255, 25, 20, 97, 259, 134, 902, 76,
3169  130, 85, 134, 79, 778, 596, 25, 471, 28, 141,
3170  86, 87, 786, 29, 90, 91, 92, 93, 120, 323,
3171  286, 729, 288, 133, 290, 51, 52, 938, 294, 25,
3172  110, 110, 740, 133, 25, 133, 132, 133, 805, 806,
3173  25, 118, 770, 771, 25, 136, 56, 736, 139, 133,
3174  141, 139, 13, 141, 140, 744, 203, 230, 271, 232,
3175  113, 990, 243, 130, 1013, 252, 657, 141, 897, 136,
3176  140, 224, 214, 226, 227, 134, 130, 136, 220, 134,
3177  224, 992, 226, 944, 429, 227, 134, 134, 13, 13,
3178  237, 139, 134, 141, 622, 111, 580, 621, 622, 1003,
3179  117, 252, 134, 250, 307, 308, 309, 310, 592, 139,
3180  632, 141, 85, 690, 1025, 134, 271, 581, 885, 268,
3181  949, 113, 139, 897, 141, 85, 321, 203, 902, 593,
3182  250, 326, 657, 252, 307, 308, 309, 310, 134, 312,
3183  313, 248, 591, 134, 872, 136, 874, 696, 224, 134,
3184  226, 227, 743, 134, 230, 87, 232, 360, 361, 422,
3185  133, 237, 224, 426, 226, 928, 37, 38, 431, 324,
3186  944, 87, 248, 133, 250, 362, 323, 321, 139, 1008,
3187  141, 113, 326, 68, 447, 113, 136, 360, 361, 452,
3188  100, 141, 306, 852, 87, 271, 963, 113, 224, 306,
3189  226, 354, 375, 323, 311, 61, 134, 402, 403, 65,
3190  938, 939, 354, 324, 139, 139, 141, 141, 743, 485,
3191  113, 355, 25, 61, 85, 140, 492, 61, 140, 1003,
3192  306, 307, 308, 309, 310, 311, 312, 313, 123, 124,
3193  125, 930, 697, 362, 139, 321, 141, 323, 324, 136,
3194  326, 107, 725, 109, 517, 468, 685, 928, 15, 378,
3195  17, 25, 990, 416, 992, 399, 611, 68, 85, 107,
3196  714, 109, 133, 107, 416, 109, 26, 85, 354, 134,
3197  356, 85, 636, 417, 360, 361, 428, 429, 85, 52,
3198  56, 26, 437, 56, 437, 87, 26, 1025, 440, 375,
3199  989, 113, 140, 437, 85, 518, 140, 134, 437, 443,
3200  113, 134, 88, 468, 85, 132, 133, 470, 141, 136,
3201  121, 122, 123, 124, 125, 133, 402, 403, 470, 133,
3202  1038, 134, 87, 440, 137, 85, 133, 471, 141, 867,
3203  416, 87, 87, 867, 935, 87, 134, 703, 134, 113,
3204  85, 132, 133, 141, 710, 85, 136, 786, 113, 61,
3205  789, 132, 133, 518, 440, 507, 508, 113, 61, 511,
3206  134, 113, 61, 137, 450, 136, 557, 141, 130, 134,
3207  130, 26, 132, 133, 565, 52, 412, 54, 55, 56,
3208  57, 68, 468, 542, 470, 130, 136, 132, 133, 137,
3209  130, 136, 132, 133, 558, 107, 136, 109, 110, 85,
3210  113, 560, 566, 138, 107, 760, 109, 110, 107, 600,
3211  109, 110, 595, 570, 637, 572, 568, 580, 670, 455,
3212  672, 131, 576, 85, 59, 60, 577, 87, 580, 592,
3213  85, 56, 518, 916, 87, 110, 600, 581, 87, 922,
3214  592, 87, 625, 85, 573, 574, 132, 133, 600, 593,
3215  605, 61, 605, 113, 134, 614, 110, 134, 587, 611,
3216  113, 605, 110, 902, 113, 904, 605, 113, 68, 742,
3217  132, 133, 637, 696, 134, 130, 110, 132, 133, 58,
3218  632, 136, 641, 68, 570, 134, 572, 61, 761, 68,
3219  132, 133, 697, 94, 580, 700, 701, 107, 685, 109,
3220  110, 774, 707, 708, 748, 944, 592, 946, 594, 595,
3221  85, 134, 951, 704, 666, 632, 668, 96, 97, 732,
3222  711, 17, 735, 1017, 59, 60, 685, 139, 87, 686,
3223  58, 696, 689, 107, 691, 109, 110, 56, 690, 625,
3224  68, 120, 746, 25, 1018, 137, 632, 85, 134, 732,
3225  134, 637, 735, 685, 113, 131, 134, 132, 133, 711,
3226  714, 130, 714, 715, 1003, 717, 1005, 719, 96, 97,
3227  729, 1010, 134, 724, 52, 134, 54, 55, 56, 57,
3228  85, 740, 14, 15, 140, 621, 859, 140, 1027, 134,
3229  741, 134, 120, 780, 132, 133, 85, 784, 871, 113,
3230  686, 134, 746, 689, 733, 691, 136, 10, 760, 1048,
3231  696, 697, 8, 85, 700, 701, 745, 776, 2, 13,
3232  4, 707, 708, 828, 85, 131, 85, 132, 133, 842,
3233  882, 883, 16, 17, 799, 887, 20, 889, 890, 113,
3234  134, 134, 801, 132, 133, 52, 732, 134, 780, 735,
3235  736, 134, 52, 805, 806, 134, 134, 814, 744, 842,
3236  132, 133, 52, 134, 115, 49, 50, 54, 55, 138,
3237  57, 132, 133, 132, 133, 15, 63, 64, 134, 87,
3238  64, 131, 839, 113, 118, 837, 134, 134, 840, 846,
3239  847, 134, 843, 850, 845, 52, 87, 54, 55, 56,
3240  57, 58, 86, 87, 855, 113, 90, 134, 134, 860,
3241  897, 68, 899, 799, 139, 902, 10, 904, 131, 10,
3242  877, 878, 113, 852, 134, 854, 134, 892, 814, 808,
3243  809, 9, 89, 885, 891, 88, 134, 134, 95, 96,
3244  97, 134, 828, 134, 996, 997, 998, 999, 54, 137,
3245  915, 134, 134, 839, 56, 118, 842, 63, 64, 131,
3246  846, 847, 919, 120, 850, 897, 123, 899, 134, 134,
3247  902, 10, 904, 131, 925, 926, 928, 52, 108, 54,
3248  55, 56, 57, 52, 141, 54, 55, 56, 57, 58,
3249  134, 877, 878, 134, 1046, 134, 134, 56, 52, 68,
3250  54, 55, 56, 57, 136, 891, 892, 134, 134, 134,
3251  969, 963, 136, 450, 89, 91, 1003, 711, 1005, 203,
3252  89, 1008, 979, 1010, 981, 93, 1020, 96, 97, 915,
3253  987, 770, 685, 919, 1013, 89, 749, 988, 1019, 99,
3254  224, 95, 226, 227, 930, 294, 230, 57, 232, 94,
3255  935, 120, 780, 237, 1017, 52, 899, 54, 55, 56,
3256  57, 1048, 897, 778, 248, 1017, 250, 1019, 1020, 396,
3257  1021, 1003, 1023, 1005, 1018, -1, 1008, -1, 1010, 1038,
3258  -1, 960, 961, -1, -1, 964, -1, 966, 967, -1,
3259  -1, -1, 89, 979, 68, 981, -1, -1, 95, -1,
3260  -1, 987, -1, 989, 68, -1, -1, -1, -1, 83,
3261  84, 40, 41, 42, 43, 44, 1048, -1, -1, 83,
3262  84, -1, 306, 307, 308, 309, 310, 311, 312, 313,
3263  52, 1017, 54, 55, 56, 57, -1, 321, -1, 323,
3264  -1, -1, 326, -1, 118, 119, 120, 121, 122, 123,
3265  124, 125, 1031, 1032, 1033, 1034, 120, 121, 122, 123,
3266  124, 125, -1, -1, -1, -1, -1, -1, -1, -1,
3267  354, -1, 356, -1, -1, 1054, 360, 361, -1, -1,
3268  -1, -1, -1, 52, -1, 54, 55, 56, 57, 58,
3269  -1, 375, -1, -1, -1, -1, -1, -1, 0, 68,
3270  -1, -1, -1, -1, -1, -1, 8, 9, 10, -1,
3271  -1, 13, 14, 15, -1, 17, -1, -1, 402, 403,
3272  89, -1, -1, -1, 26, 27, 95, 96, 97, -1,
3273  -1, -1, 416, -1, -1, 37, 38, 68, 40, 41,
3274  42, 43, 44, -1, 52, -1, 54, 55, 56, 57,
3275  58, 120, 83, 84, 123, -1, 440, -1, -1, -1,
3276  68, -1, -1, -1, -1, -1, 450, 136, -1, -1,
3277  -1, -1, -1, -1, 16, 17, -1, -1, 20, -1,
3278  -1, 89, -1, 85, -1, -1, 470, 95, 96, 97,
3279  121, 122, 123, 124, 125, -1, -1, -1, -1, -1,
3280  -1, -1, -1, -1, 46, 47, 108, -1, -1, 51,
3281  52, -1, 120, -1, -1, 123, -1, -1, -1, -1,
3282  -1, -1, 64, 65, -1, 44, -1, -1, 130, 131,
3283  -1, 133, -1, -1, 136, 137, -1, 139, -1, 141,
3284  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
3285  69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
3286  79, 80, -1, -1, 83, 84, -1, -1, -1, -1,
3287  -1, -1, -1, -1, -1, -1, 52, -1, 54, 55,
3288  56, 57, 58, -1, -1, -1, 570, -1, 572, -1,
3289  -1, -1, 68, -1, -1, 114, 580, 116, 117, 118,
3290  119, 120, 121, 122, 123, 124, 125, -1, 592, -1,
3291  594, 595, -1, 89, -1, 134, -1, -1, -1, 95,
3292  96, 97, -1, 68, 69, 70, 71, 72, 73, 74,
3293  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3294  -1, 625, -1, -1, 120, -1, -1, 123, 632, -1,
3295  -1, -1, 2, -1, 4, -1, -1, -1, -1, 201,
3296  136, -1, 204, 205, 206, 207, -1, -1, 52, 114,
3297  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3298  125, -1, 224, -1, 226, 227, -1, -1, 52, -1,
3299  54, 55, 56, 57, 58, -1, 141, -1, -1, 49,
3300  -1, -1, 686, 53, 68, 689, -1, 691, -1, -1,
3301  -1, -1, -1, 697, -1, -1, 700, 701, -1, -1,
3302  -1, -1, -1, 707, 708, 89, -1, -1, -1, 79,
3303  -1, 95, 96, 97, -1, -1, -1, -1, -1, -1,
3304  -1, 91, 92, 93, 94, -1, -1, -1, 732, -1,
3305  -1, 735, 736, -1, -1, -1, 120, -1, -1, 123,
3306  744, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3307  -1, -1, -1, -1, -1, -1, -1, -1, -1, 321,
3308  -1, -1, -1, -1, 326, 327, 328, 329, 330, 331,
3309  332, 333, 334, 335, 336, 337, 338, 339, 340, 341,
3310  342, 343, 344, 345, 346, 347, 348, 349, 350, 351,
3311  352, -1, 354, -1, -1, -1, -1, 201, -1, -1,
3312  204, 205, 206, -1, -1, -1, -1, -1, -1, -1,
3313  814, -1, -1, -1, -1, 52, -1, 54, 55, 56,
3314  57, 58, -1, -1, 828, -1, -1, -1, -1, -1,
3315  -1, 68, -1, 203, -1, 839, -1, -1, 842, -1,
3316  402, 403, 846, 847, -1, -1, 850, -1, 410, 411,
3317  412, -1, 89, -1, 416, -1, 418, 419, 420, 96,
3318  97, -1, -1, -1, -1, -1, -1, 237, -1, -1,
3319  -1, -1, -1, 877, 878, -1, -1, 439, 248, -1,
3320  250, -1, 444, 120, -1, -1, -1, 891, -1, -1,
3321  -1, -1, -1, 455, -1, -1, 458, -1, -1, -1,
3322  -1, 271, -1, -1, -1, 2, -1, 4, 470, -1,
3323  -1, -1, -1, -1, -1, 919, -1, 321, -1, -1,
3324  -1, 2, 326, 4, -1, -1, 930, -1, -1, -1,
3325  -1, -1, -1, -1, 496, 497, 306, -1, -1, -1,
3326  -1, 311, -1, -1, -1, -1, -1, -1, -1, -1,
3327  512, -1, 49, 323, 324, -1, 53, -1, -1, -1,
3328  -1, -1, -1, -1, -1, -1, -1, -1, 49, -1,
3329  -1, -1, 53, -1, -1, 979, -1, 981, -1, -1,
3330  -1, -1, 79, 987, -1, 989, 356, -1, -1, -1,
3331  -1, -1, -1, -1, 91, 92, 93, 94, 79, -1,
3332  -1, -1, -1, -1, -1, -1, -1, 411, 412, -1,
3333  91, 92, 93, 1017, 576, -1, 420, -1, 580, -1,
3334  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3335  592, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3336  -1, -1, -1, -1, -1, -1, 608, -1, -1, -1,
3337  -1, 455, -1, -1, 458, -1, -1, -1, -1, 621,
3338  622, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3339  440, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3340  450, -1, -1, -1, -1, -1, -1, 649, -1, -1,
3341  -1, -1, -1, -1, -1, -1, -1, -1, 468, -1,
3342  -1, -1, -1, -1, -1, -1, 203, -1, 512, -1,
3343  -1, -1, -1, -1, 2, -1, 4, -1, -1, -1,
3344  -1, -1, 203, -1, -1, -1, -1, -1, -1, -1,
3345  2, 693, 4, -1, -1, 697, 698, -1, 700, 701,
3346  237, -1, -1, -1, -1, 707, 708, -1, 518, -1,
3347  -1, 248, 714, 250, -1, -1, 237, -1, -1, -1,
3348  -1, 49, -1, -1, -1, -1, -1, 248, -1, 250,
3349  -1, -1, 576, -1, 271, -1, -1, 49, -1, -1,
3350  -1, -1, -1, -1, -1, -1, -1, -1, -1, 751,
3351  271, -1, -1, 755, 756, -1, 758, 759, -1, -1,
3352  570, -1, 572, 91, 608, 767, -1, -1, -1, 306,
3353  -1, -1, -1, -1, 311, -1, -1, 621, 622, -1,
3354  -1, -1, -1, -1, 594, 306, 323, 324, -1, -1,
3355  311, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3356  -1, -1, 323, 324, -1, 649, -1, -1, -1, -1,
3357  -1, -1, -1, -1, 816, -1, -1, -1, 820, 356,
3358  -1, -1, 632, -1, -1, -1, 828, 637, -1, -1,
3359  -1, -1, -1, -1, -1, 356, -1, -1, -1, -1,
3360  -1, -1, -1, -1, -1, -1, -1, 849, -1, 693,
3361  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3362  -1, -1, -1, -1, 866, 867, -1, -1, -1, -1,
3363  714, -1, -1, -1, -1, 203, 686, -1, -1, 689,
3364  -1, 691, -1, -1, -1, -1, 696, -1, -1, -1,
3365  -1, 203, -1, -1, -1, -1, -1, -1, -1, -1,
3366  -1, -1, -1, 440, -1, -1, -1, -1, -1, 237,
3367  -1, -1, -1, 450, -1, -1, -1, -1, -1, 440,
3368  248, -1, 250, 767, -1, 237, 736, -1, -1, 450,
3369  -1, 468, -1, -1, 744, -1, 248, -1, 250, -1,
3370  -1, -1, -1, -1, -1, -1, -1, 468, -1, -1,
3371  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3372  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3373  -1, -1, 816, -1, -1, -1, -1, -1, 306, -1,
3374  -1, 518, -1, 311, -1, -1, -1, -1, -1, 799,
3375  -1, -1, -1, -1, 306, 323, -1, 518, 326, 311,
3376  -1, -1, -1, -1, 814, 849, -1, -1, -1, -1,
3377  -1, 323, -1, -1, -1, 1017, -1, -1, -1, -1,
3378  -1, -1, -1, 867, -1, -1, -1, -1, 356, 839,
3379  -1, -1, -1, 570, -1, 572, 846, 847, -1, -1,
3380  850, -1, -1, -1, 356, -1, -1, -1, -1, 570,
3381  -1, 572, -1, -1, -1, -1, -1, 594, -1, -1,
3382  -1, -1, -1, -1, -1, -1, -1, 877, 878, -1,
3383  -1, -1, -1, 594, -1, -1, -1, -1, -1, -1,
3384  -1, 891, 892, -1, -1, -1, -1, -1, -1, -1,
3385  -1, -1, -1, -1, -1, 632, -1, -1, -1, -1,
3386  637, -1, -1, -1, -1, 915, -1, -1, -1, 919,
3387  -1, 632, 440, -1, -1, -1, 637, -1, -1, -1,
3388  930, -1, 450, -1, -1, -1, -1, -1, 440, -1,
3389  -1, -1, -1, -1, -1, -1, -1, -1, 450, -1,
3390  -1, -1, -1, -1, -1, -1, -1, -1, -1, 686,
3391  -1, -1, 689, -1, 691, 676, 44, -1, -1, 696,
3392  -1, -1, -1, -1, -1, 686, -1, -1, 689, 979,
3393  691, 981, -1, -1, -1, 696, -1, 987, -1, 989,
3394  68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
3395  78, 79, 80, -1, -1, 83, 84, -1, -1, 736,
3396  -1, -1, -1, -1, -1, -1, -1, 744, -1, -1,
3397  -1, -1, -1, -1, -1, 736, -1, -1, -1, -1,
3398  -1, -1, -1, 744, -1, -1, 114, -1, 116, 117,
3399  118, 119, 120, 121, 122, 123, 124, 125, -1, -1,
3400  -1, -1, 570, -1, 572, -1, -1, -1, -1, -1,
3401  -1, -1, -1, -1, -1, -1, -1, -1, 570, -1,
3402  572, -1, 799, -1, -1, -1, 594, -1, -1, -1,
3403  -1, -1, -1, -1, -1, -1, -1, 814, 799, -1,
3404  -1, -1, 594, -1, -1, -1, -1, -1, -1, -1,
3405  -1, -1, -1, 814, -1, -1, -1, -1, -1, -1,
3406  -1, -1, 839, -1, 632, -1, -1, -1, -1, 846,
3407  847, -1, -1, 850, -1, -1, -1, -1, 839, -1,
3408  632, -1, -1, -1, -1, 846, 847, -1, -1, 850,
3409  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3410  877, 878, -1, -1, -1, -1, -1, -1, -1, -1,
3411  -1, -1, -1, -1, 891, 892, 877, 878, 686, -1,
3412  -1, 689, -1, 691, -1, -1, -1, -1, -1, 697,
3413  891, 892, -1, -1, 686, -1, -1, 689, 915, 691,
3414  -1, -1, 919, -1, -1, -1, -1, -1, -1, -1,
3415  -1, -1, -1, 930, 915, -1, -1, -1, 919, -1,
3416  -1, -1, -1, -1, -1, -1, -1, -1, 736, 930,
3417  -1, -1, -1, -1, -1, -1, 744, -1, -1, -1,
3418  -1, -1, -1, -1, 736, 68, 69, 70, 71, 72,
3419  73, 74, 744, -1, 77, 78, -1, -1, -1, -1,
3420  83, 84, 979, -1, 981, -1, -1, -1, -1, -1,
3421  987, -1, 989, -1, -1, -1, -1, -1, 979, -1,
3422  981, -1, -1, -1, -1, -1, 987, -1, 989, -1,
3423  -1, -1, -1, 116, 117, 118, 119, 120, 121, 122,
3424  123, 124, 125, -1, -1, -1, 814, -1, -1, -1,
3425  -1, 68, 69, 70, 71, 72, 73, 74, 75, -1,
3426  77, 78, 814, -1, -1, -1, 83, 84, -1, -1,
3427  -1, 839, -1, -1, -1, -1, -1, -1, 846, 847,
3428  -1, -1, 850, -1, -1, -1, -1, 839, -1, -1,
3429  -1, -1, -1, -1, 846, 847, -1, -1, 850, 116,
3430  117, 118, 119, 120, 121, 122, 123, 124, 125, 877,
3431  878, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3432  -1, -1, -1, 891, -1, 877, 878, -1, -1, -1,
3433  -1, -1, -1, -1, -1, -1, -1, -1, -1, 891,
3434  68, 69, 70, 71, 72, 73, 74, 915, -1, 77,
3435  78, 919, -1, -1, -1, 83, 84, -1, -1, -1,
3436  -1, -1, 930, -1, -1, -1, -1, 919, -1, -1,
3437  -1, -1, -1, -1, -1, -1, -1, -1, 930, -1,
3438  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
3439  118, 119, 120, 121, 122, 123, 124, 125, -1, -1,
3440  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3441  -1, 979, -1, 981, -1, -1, -1, -1, -1, 987,
3442  -1, 989, -1, -1, -1, -1, -1, 979, -1, 981,
3443  -1, -1, -1, -1, -1, 987, -1, 989, 0, 1,
3444  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
3445  12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
3446  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3447  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3448  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3449  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3450  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3451  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3452  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3453  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3454  102, 103, 104, 105, 106, 0, -1, -1, -1, -1,
3455  -1, -1, -1, 8, 9, 10, -1, -1, 13, 14,
3456  15, -1, 17, -1, 126, 127, 128, -1, 44, -1,
3457  -1, 26, 27, 28, 29, -1, -1, 139, -1, 141,
3458  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3459  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3460  76, 77, 78, 79, 80, -1, -1, 83, 84, -1,
3461  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3462  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3463  85, -1, 87, 88, -1, -1, -1, -1, 114, 94,
3464  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3465  -1, -1, -1, 108, -1, -1, 111, -1, 113, 114,
3466  115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3467  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3468  0, -1, 137, 138, 139, -1, 141, -1, 8, 9,
3469  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3470  -1, -1, -1, -1, -1, 25, -1, 27, 28, 29,
3471  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3472  40, 41, 42, 43, 44, -1, -1, 68, 69, 70,
3473  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3474  -1, -1, 83, 84, -1, -1, -1, -1, 68, 69,
3475  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3476  80, -1, -1, 83, 84, 85, -1, 87, 88, -1,
3477  -1, -1, -1, 114, 94, 116, 117, 118, 119, 120,
3478  121, 122, 123, 124, 125, -1, -1, -1, 108, -1,
3479  -1, 111, -1, 113, 114, 115, 116, 117, 118, 119,
3480  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3481  -1, 131, 132, 133, 134, 0, -1, 137, 138, 139,
3482  -1, 141, -1, 8, 9, 10, -1, -1, 13, 14,
3483  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3484  25, -1, 27, 28, 29, -1, -1, -1, -1, -1,
3485  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3486  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3487  76, 77, 78, 79, 80, -1, -1, 83, 84, -1,
3488  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3489  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3490  85, -1, 87, 88, -1, -1, -1, -1, -1, 94,
3491  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3492  -1, -1, -1, 108, -1, -1, 111, -1, 113, 114,
3493  115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3494  125, -1, -1, -1, -1, -1, 131, 132, 133, 134,
3495  0, -1, 137, 138, 139, -1, 141, -1, 8, 9,
3496  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3497  -1, -1, -1, -1, -1, -1, 26, 27, 28, 29,
3498  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3499  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3500  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3501  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3502  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3503  80, -1, -1, 83, 84, 85, -1, -1, 88, -1,
3504  -1, -1, -1, -1, 94, -1, -1, -1, -1, -1,
3505  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3506  -1, 111, -1, -1, 114, 115, 116, 117, 118, 119,
3507  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3508  130, 131, 132, 133, 134, 0, -1, 137, 138, 139,
3509  -1, 141, -1, 8, 9, 10, -1, -1, 13, 14,
3510  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3511  -1, 26, 27, 28, 29, -1, -1, -1, -1, -1,
3512  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3513  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3514  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3515  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3516  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3517  85, -1, -1, 88, -1, -1, -1, -1, -1, 94,
3518  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3519  -1, -1, -1, 108, -1, -1, 111, -1, -1, 114,
3520  115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3521  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3522  0, -1, 137, 138, 139, -1, 141, -1, 8, 9,
3523  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3524  -1, -1, -1, -1, -1, -1, -1, 27, 28, 29,
3525  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3526  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3527  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3528  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3529  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3530  80, -1, -1, 83, 84, 85, -1, 87, 88, -1,
3531  -1, -1, -1, -1, 94, -1, -1, -1, -1, -1,
3532  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3533  -1, 111, -1, 113, 114, 115, 116, 117, 118, 119,
3534  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3535  -1, 131, 132, 133, 134, 0, -1, 137, 138, 139,
3536  -1, 141, -1, 8, 9, 10, -1, -1, 13, 14,
3537  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3538  -1, 26, 27, 28, -1, -1, -1, -1, -1, -1,
3539  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3540  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3541  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3542  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3543  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3544  85, -1, -1, 88, -1, -1, -1, -1, -1, 94,
3545  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3546  -1, -1, -1, 108, -1, -1, -1, -1, -1, 114,
3547  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3548  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3549  0, 136, 137, 138, 139, -1, 141, -1, 8, 9,
3550  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3551  -1, -1, -1, -1, -1, -1, -1, 27, 28, 29,
3552  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3553  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3554  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3555  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3556  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3557  80, -1, -1, 83, 84, 85, -1, -1, 88, -1,
3558  -1, -1, -1, -1, 94, -1, -1, -1, -1, -1,
3559  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3560  -1, 111, -1, -1, 114, 115, 116, 117, 118, 119,
3561  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3562  -1, 131, 132, 133, 134, 0, -1, 137, 138, 139,
3563  -1, 141, -1, 8, 9, 10, -1, -1, 13, 14,
3564  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3565  -1, 26, 27, 28, -1, -1, -1, -1, -1, -1,
3566  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3567  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3568  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3569  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3570  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3571  85, -1, -1, 88, -1, -1, -1, -1, -1, 94,
3572  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3573  -1, -1, -1, 108, -1, -1, -1, -1, -1, 114,
3574  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3575  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3576  0, 136, 137, 138, 139, -1, 141, -1, 8, 9,
3577  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3578  -1, -1, -1, -1, -1, -1, -1, 27, 28, -1,
3579  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3580  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3581  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3582  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3583  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3584  80, -1, -1, 83, 84, 85, -1, -1, 88, -1,
3585  -1, -1, -1, -1, 94, -1, -1, -1, -1, -1,
3586  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3587  -1, -1, -1, -1, 114, -1, 116, 117, 118, 119,
3588  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3589  -1, 131, 132, 133, 134, 0, 136, 137, 138, 139,
3590  -1, 141, -1, 8, 9, 10, -1, -1, -1, 14,
3591  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3592  -1, 26, -1, -1, -1, -1, -1, -1, -1, -1,
3593  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3594  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3595  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3596  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3597  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3598  85, -1, 87, -1, -1, -1, -1, -1, -1, -1,
3599  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3600  -1, -1, -1, 108, -1, -1, -1, -1, 113, 114,
3601  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3602  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3603  0, -1, 137, -1, 139, -1, 141, -1, 8, 9,
3604  10, -1, -1, -1, 14, 15, -1, 17, -1, -1,
3605  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3606  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3607  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3608  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3609  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3610  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3611  80, -1, -1, 83, 84, 85, -1, 87, -1, -1,
3612  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3613  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3614  -1, -1, -1, 113, 114, -1, 116, 117, 118, 119,
3615  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3616  -1, 131, 132, 133, 134, -1, -1, 137, -1, 139,
3617  1, 141, 3, 4, 5, 6, 7, 8, 9, 10,
3618  11, 12, -1, -1, 15, 16, -1, 18, 19, 20,
3619  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3620  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3621  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3622  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3623  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3624  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3625  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3626  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
3627  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3628  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3629  -1, -1, -1, -1, -1, 126, 127, 128, -1, -1,
3630  -1, -1, -1, -1, -1, -1, -1, -1, 139, 1,
3631  141, 3, 4, 5, 6, 7, -1, -1, 10, 11,
3632  12, -1, 14, 15, 16, -1, 18, 19, 20, 21,
3633  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3634  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3635  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3636  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3637  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3638  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3639  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3640  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3641  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3642  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3643  -1, -1, -1, -1, 126, 127, 128, -1, -1, -1,
3644  -1, -1, -1, -1, -1, -1, -1, 139, 1, 141,
3645  3, 4, 5, 6, 7, -1, -1, 10, 11, 12,
3646  -1, -1, 15, 16, 17, 18, 19, 20, 21, 22,
3647  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3648  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3649  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3650  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
3651  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3652  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3653  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3654  93, -1, 95, -1, -1, 98, 99, 100, 101, 102,
3655  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
3656  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3657  -1, -1, -1, 126, 127, 128, -1, -1, -1, -1,
3658  -1, -1, -1, -1, -1, -1, 139, 1, 141, 3,
3659  4, 5, 6, 7, -1, -1, 10, 11, 12, -1,
3660  -1, 15, 16, -1, 18, 19, 20, 21, 22, 23,
3661  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3662  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3663  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3664  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3665  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
3666  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3667  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3668  -1, 95, -1, -1, 98, 99, 100, 101, 102, 103,
3669  104, 105, 106, -1, -1, -1, -1, -1, -1, -1,
3670  1, -1, 3, 4, 5, 6, 7, -1, 9, 10,
3671  11, 12, 126, 127, 128, 16, -1, 18, 19, 20,
3672  21, 22, 23, 24, -1, 139, -1, 141, -1, 30,
3673  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3674  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3675  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3676  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3677  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3678  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3679  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
3680  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3681  -1, -1, -1, 1, -1, 3, 4, 5, 6, 7,
3682  -1, -1, -1, 11, 12, 126, 127, 128, 16, -1,
3683  18, 19, 20, 21, 22, 23, 24, -1, 139, -1,
3684  141, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3685  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3686  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3687  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3688  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3689  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3690  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3691  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3692  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3693  -1, -1, -1, -1, -1, -1, -1, -1, 126, 127,
3694  128, -1, -1, -1, -1, -1, -1, -1, -1, 137,
3695  -1, 139, 1, 141, 3, 4, 5, 6, 7, -1,
3696  -1, -1, 11, 12, -1, -1, -1, 16, -1, 18,
3697  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3698  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3699  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3700  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3701  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3702  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3703  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3704  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3705  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3706  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3707  -1, -1, -1, -1, -1, -1, -1, 126, 127, 128,
3708  -1, -1, -1, -1, -1, -1, -1, -1, 137, -1,
3709  139, 1, 141, 3, 4, 5, 6, 7, -1, -1,
3710  -1, 11, 12, -1, -1, -1, 16, -1, 18, 19,
3711  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3712  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3713  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
3714  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3715  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3716  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3717  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3718  90, -1, 92, 93, -1, 95, -1, -1, 98, 99,
3719  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
3720  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3721  -1, -1, -1, -1, -1, -1, 126, 127, 128, -1,
3722  -1, 131, 1, -1, 3, 4, 5, 6, 7, 139,
3723  -1, 141, 11, 12, -1, -1, -1, 16, -1, 18,
3724  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3725  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3726  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3727  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3728  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3729  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3730  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3731  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3732  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3733  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3734  -1, -1, -1, -1, -1, -1, -1, 126, 127, 128,
3735  -1, -1, 131, -1, -1, -1, -1, -1, -1, -1,
3736  139, 1, 141, 3, 4, 5, 6, 7, -1, -1,
3737  10, 11, 12, -1, -1, -1, 16, -1, 18, 19,
3738  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3739  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3740  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
3741  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3742  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3743  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3744  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3745  90, -1, 92, 93, -1, 95, -1, -1, 98, 99,
3746  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
3747  -1, -1, -1, -1, 1, -1, 3, 4, 5, 6,
3748  7, -1, -1, -1, 11, 12, 126, 127, 128, 16,
3749  -1, 18, 19, 20, 21, 22, 23, 24, -1, 139,
3750  -1, 141, -1, 30, 31, 32, 33, 34, 35, 36,
3751  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
3752  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
3753  57, -1, 59, 60, -1, 62, 63, 64, -1, 66,
3754  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3755  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3756  -1, -1, 89, 90, -1, 92, 93, -1, 95, -1,
3757  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3758  -1, 108, -1, -1, -1, -1, -1, -1, -1, 3,
3759  4, 5, -1, 7, -1, -1, -1, 11, 12, 126,
3760  127, 128, 16, -1, 18, 19, 20, 21, 22, 23,
3761  24, -1, 139, -1, 141, -1, 30, 31, 32, 33,
3762  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3763  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3764  54, 55, 56, 57, 58, 59, 60, -1, 62, 63,
3765  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
3766  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3767  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3768  -1, 95, 96, 97, 98, 99, 100, 101, 102, 103,
3769  104, 105, 106, -1, -1, -1, -1, -1, -1, -1,
3770  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3771  11, 12, 126, 127, 128, 16, -1, 18, 19, 20,
3772  21, 22, 23, 24, -1, -1, -1, 141, -1, 30,
3773  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3774  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3775  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3776  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3777  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3778  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3779  -1, 92, 93, -1, -1, -1, -1, 98, 99, 100,
3780  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3781  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
3782  -1, -1, -1, 11, 12, 126, 127, 128, 16, -1,
3783  18, 19, 20, 21, 22, 23, 24, -1, 139, -1,
3784  141, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3785  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3786  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3787  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3788  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3789  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3790  -1, 89, 90, -1, 92, 93, -1, -1, -1, -1,
3791  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3792  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
3793  5, 6, 7, -1, -1, -1, 11, 12, 126, 127,
3794  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3795  -1, -1, -1, 141, -1, 30, 31, 32, 33, 34,
3796  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3797  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3798  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3799  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3800  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3801  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3802  95, -1, -1, 98, 99, 100, 101, 102, 103, 104,
3803  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3804  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
3805  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
3806  22, 23, 24, -1, 139, -1, -1, -1, 30, 31,
3807  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3808  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3809  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3810  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3811  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3812  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3813  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3814  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3815  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3816  -1, -1, -1, -1, 126, 127, 128, -1, -1, -1,
3817  -1, -1, -1, -1, -1, -1, -1, 139, 3, 4,
3818  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3819  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3820  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3821  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
3822  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3823  55, 56, 57, -1, -1, -1, -1, -1, -1, -1,
3824  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3825  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3826  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3827  95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
3828  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3829  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3830  125, -1, 127, 128, -1, -1, -1, -1, -1, -1,
3831  135, 136, 3, 4, 5, 6, 7, 8, 9, 10,
3832  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
3833  21, 22, 23, 24, 25, 26, -1, -1, -1, 30,
3834  31, 32, 33, 34, 35, 36, 37, 38, 39, -1,
3835  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3836  51, 52, 53, 54, 55, 56, 57, -1, -1, -1,
3837  -1, -1, -1, -1, -1, 66, 67, 68, 69, 70,
3838  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
3839  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
3840  -1, -1, -1, -1, 95, 96, -1, -1, -1, -1,
3841  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3842  -1, -1, -1, -1, -1, 116, 117, 118, 119, 120,
3843  121, 122, 123, 124, 125, -1, 127, 128, -1, -1,
3844  -1, -1, -1, -1, 135, 3, 4, 5, 6, 7,
3845  8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
3846  18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
3847  -1, -1, 30, 31, 32, 33, 34, 35, 36, 37,
3848  38, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3849  48, 49, 50, 51, 52, 53, 54, -1, 56, -1,
3850  -1, -1, -1, -1, -1, -1, -1, -1, 66, 67,
3851  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
3852  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
3853  -1, -1, -1, -1, -1, -1, -1, 95, 96, -1,
3854  -1, 99, -1, -1, -1, -1, -1, -1, -1, -1,
3855  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
3856  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
3857  128, -1, -1, -1, -1, -1, -1, 135, 3, 4,
3858  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3859  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3860  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3861  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
3862  45, 46, 47, 48, 49, 50, 51, 52, 53, -1,
3863  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
3864  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3865  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3866  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3867  95, 96, -1, -1, 99, -1, -1, -1, -1, -1,
3868  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3869  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3870  125, -1, 127, 128, -1, -1, -1, -1, -1, -1,
3871  135, 3, 4, 5, 6, 7, 8, 9, 10, 11,
3872  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
3873  22, 23, 24, 25, 26, -1, -1, -1, 30, 31,
3874  32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
3875  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3876  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
3877  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
3878  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
3879  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
3880  -1, -1, -1, 95, 96, -1, -1, -1, -1, -1,
3881  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3882  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
3883  122, 123, 124, 125, -1, 127, 128, 3, 4, 5,
3884  -1, 7, -1, 135, -1, 11, 12, -1, -1, -1,
3885  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3886  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3887  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3888  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3889  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3890  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3891  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3892  86, -1, -1, 89, 90, -1, 92, 93, -1, -1,
3893  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
3894  106, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3895  7, -1, -1, -1, 11, 12, -1, -1, -1, 16,
3896  126, 18, 19, 20, 21, 22, 23, 24, 134, -1,
3897  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3898  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3899  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3900  57, -1, 59, 60, -1, 62, 63, 64, -1, -1,
3901  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3902  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3903  -1, -1, 89, 90, -1, 92, 93, -1, -1, -1,
3904  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3905  -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
3906  -1, -1, -1, 11, 12, -1, -1, -1, 16, 126,
3907  18, 19, 20, 21, 22, 23, 24, 134, -1, -1,
3908  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3909  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3910  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3911  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3912  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3913  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3914  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3915  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3916  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
3917  5, -1, 7, -1, -1, -1, 11, 12, 126, 127,
3918  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3919  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3920  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3921  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3922  55, 56, 57, 58, 59, 60, -1, 62, 63, 64,
3923  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3924  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3925  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3926  95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
3927  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3928  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
3929  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
3930  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3931  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3932  -1, -1, -1, 45, 46, -1, 48, 49, 50, 51,
3933  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3934  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3935  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3936  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3937  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3938  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3939  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3940  -1, -1, 11, 12, 126, 127, 128, 16, -1, 18,
3941  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3942  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3943  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3944  49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
3945  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3946  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3947  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3948  89, 90, -1, 92, 93, -1, 95, 96, 97, 98,
3949  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3950  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3951  -1, 7, -1, -1, -1, 11, 12, 126, 127, 128,
3952  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3953  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3954  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3955  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3956  56, 57, 58, 59, 60, -1, 62, 63, 64, -1,
3957  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3958  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3959  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3960  96, -1, 98, 99, 100, 101, 102, 103, 104, 105,
3961  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3962  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
3963  126, 127, 128, 16, -1, 18, 19, 20, 21, 22,
3964  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3965  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3966  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3967  53, 54, 55, 56, 57, 58, 59, 60, -1, 62,
3968  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3969  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3970  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3971  93, -1, -1, 96, 97, 98, 99, 100, 101, 102,
3972  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
3973  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3974  -1, 11, 12, 126, 127, 128, 16, -1, 18, 19,
3975  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3976  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3977  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3978  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
3979  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3980  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3981  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3982  90, -1, 92, 93, -1, 95, 96, -1, 98, 99,
3983  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
3984  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3985  7, -1, -1, -1, 11, 12, 126, 127, 128, 16,
3986  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3987  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3988  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3989  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3990  57, 58, 59, 60, -1, 62, 63, 64, -1, 66,
3991  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3992  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3993  -1, -1, 89, 90, -1, 92, 93, -1, -1, 96,
3994  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3995  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3996  4, 5, -1, 7, -1, -1, -1, 11, 12, 126,
3997  127, 128, 16, -1, 18, 19, 20, 21, 22, 23,
3998  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3999  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4000  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4001  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
4002  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
4003  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4004  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
4005  -1, 95, -1, -1, 98, 99, 100, 101, 102, 103,
4006  104, 105, 106, -1, -1, -1, -1, -1, -1, -1,
4007  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4008  11, 12, 126, 127, 128, 16, -1, 18, 19, 20,
4009  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4010  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4011  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4012  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4013  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
4014  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4015  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
4016  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
4017  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
4018  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4019  -1, -1, -1, 11, 12, 126, 127, 128, 16, -1,
4020  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4021  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4022  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4023  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4024  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
4025  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4026  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
4027  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
4028  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
4029  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
4030  5, -1, 7, -1, -1, -1, 11, 12, 126, 127,
4031  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
4032  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4033  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4034  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
4035  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
4036  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
4037  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4038  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
4039  95, -1, -1, 98, 99, 100, 101, 102, 103, 104,
4040  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
4041  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4042  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
4043  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4044  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4045  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4046  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
4047  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
4048  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4049  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
4050  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
4051  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
4052  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4053  -1, -1, 11, 12, 126, 127, 128, 16, -1, 18,
4054  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4055  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4056  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4057  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4058  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
4059  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4060  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
4061  89, 90, -1, 92, 93, -1, -1, -1, -1, 98,
4062  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
4063  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4064  -1, 7, -1, -1, -1, 11, 12, 126, 127, 128,
4065  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4066  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4067  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4068  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4069  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
4070  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
4071  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4072  86, -1, -1, 89, 90, -1, 92, 93, -1, -1,
4073  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
4074  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4075  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4076  126, 127, 128, 16, -1, 18, 19, 20, 21, 22,
4077  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4078  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4079  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4080  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
4081  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
4082  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4083  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
4084  93, -1, -1, -1, -1, 98, 99, 100, 101, 102,
4085  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
4086  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4087  -1, 11, 12, 126, 127, 128, 16, -1, 18, 19,
4088  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4089  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4090  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4091  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4092  60, -1, 62, 63, 64, -1, -1, -1, -1, -1,
4093  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4094  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
4095  90, -1, 92, 93, -1, 95, -1, -1, 98, 99,
4096  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
4097  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4098  11, 12, -1, -1, -1, 16, 126, 18, 19, 20,
4099  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4100  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4101  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4102  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4103  -1, 62, 63, 64, -1, -1, -1, -1, -1, -1,
4104  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4105  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
4106  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
4107  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
4108  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4109  12, -1, -1, -1, 16, 126, 18, 19, 20, 21,
4110  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4111  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4112  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4113  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
4114  62, 63, 64, -1, -1, -1, -1, -1, -1, -1,
4115  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4116  -1, 83, -1, -1, 86, -1, -1, 89, 90, -1,
4117  92, 93, -1, -1, -1, -1, 98, 99, 100, 101,
4118  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
4119  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4120  -1, -1, -1, 16, 126, 18, 19, 20, 21, 22,
4121  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4122  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4123  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4124  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
4125  63, 64, -1, -1, -1, -1, -1, -1, -1, -1,
4126  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4127  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
4128  93, -1, -1, -1, -1, 98, 99, 100, 101, 102,
4129  103, 104, 105, 106, -1, -1, -1, -1, -1, 3,
4130  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
4131  -1, -1, 16, 126, 18, 19, 20, 21, 22, 23,
4132  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4133  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4134  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4135  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
4136  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4137  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4138  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
4139  -1, -1, -1, -1, 98, 99, 100, 101, 102, 103,
4140  104, 105, 106, -1, -1, -1, -1, -1, 3, 4,
4141  5, -1, 7, -1, -1, -1, 11, 12, -1, -1,
4142  -1, 16, 126, 18, 19, 20, 21, 22, 23, 24,
4143  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4144  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4145  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
4146  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
4147  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4148  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4149  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
4150  -1, -1, -1, 98, 99, 100, 101, 102, 103, 104,
4151  105, 106, -1, -1, -1, -1, -1, 3, 4, 5,
4152  -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
4153  16, 126, 18, 19, 20, 21, 22, 23, 24, -1,
4154  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4155  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4156  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4157  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
4158  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4159  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4160  86, -1, -1, 89, 90, -1, 92, 93, -1, -1,
4161  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
4162  106, -1, -1, -1, -1, -1, -1, 52, 53, -1,
4163  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
4164  126, 66, 67, 68, 69, 70, 71, 72, 73, 74,
4165  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
4166  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4167  95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
4168  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4169  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
4170  125, -1, 127, 128, 52, 53, -1, -1, 56, -1,
4171  135, -1, -1, -1, -1, -1, -1, -1, 66, 67,
4172  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
4173  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
4174  -1, -1, -1, -1, -1, -1, -1, 95, 96, -1,
4175  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4176  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
4177  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
4178  128, 52, 53, -1, -1, 56, -1, 135, -1, -1,
4179  -1, -1, -1, -1, -1, 66, 67, 68, 69, 70,
4180  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
4181  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
4182  -1, -1, -1, -1, 95, 96, -1, -1, -1, -1,
4183  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4184  -1, -1, -1, -1, -1, 116, 117, 118, 119, 120,
4185  121, 122, 123, 124, 125, -1, 127, 128, 52, 53,
4186  -1, -1, 56, -1, 135, -1, -1, -1, -1, -1,
4187  -1, -1, 66, 67, 68, 69, 70, 71, 72, 73,
4188  74, -1, -1, 77, 78, -1, -1, 81, 82, 83,
4189  84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4190  -1, 95, 96, -1, -1, -1, -1, -1, -1, -1,
4191  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4192  -1, -1, 116, 117, 118, 119, 120, 121, 122, 123,
4193  124, 125, -1, 127, 128, 52, 53, -1, -1, 56,
4194  -1, 135, -1, -1, -1, -1, -1, -1, -1, 66,
4195  67, 68, 69, 70, 71, 72, 73, 74, -1, -1,
4196  77, 78, -1, -1, 81, 82, 83, 84, -1, -1,
4197  -1, -1, -1, -1, -1, -1, -1, -1, 95, 96,
4198  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4199  -1, -1, -1, -1, -1, -1, -1, -1, -1, 116,
4200  117, 118, 119, 120, 121, 122, 123, 124, 125, -1,
4201  127, 128, 52, 53, -1, -1, 56, -1, 135, -1,
4202  -1, -1, -1, -1, -1, -1, 66, 67, 68, 69,
4203  70, 71, 72, 73, 74, -1, -1, 77, 78, -1,
4204  -1, 81, 82, 83, 84, -1, -1, -1, -1, -1,
4205  -1, -1, -1, -1, -1, 95, 96, -1, -1, -1,
4206  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4207  -1, -1, -1, -1, -1, -1, 116, 117, 118, 119,
4208  120, 121, 122, 123, 124, 125, -1, 127, 128, 52,
4209  53, -1, -1, 56, -1, 135, -1, -1, -1, -1,
4210  -1, -1, -1, 66, 67, 68, 69, 70, 71, 72,
4211  73, 74, -1, -1, 77, 78, -1, -1, 81, 82,
4212  83, 84, -1, -1, -1, -1, -1, -1, -1, -1,
4213  -1, -1, 95, 96, -1, -1, -1, -1, -1, -1,
4214  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4215  -1, -1, -1, 116, 117, 118, 119, 120, 121, 122,
4216  123, 124, 125, -1, 127, 128, 52, 53, -1, -1,
4217  56, -1, 135, -1, -1, -1, -1, -1, -1, -1,
4218  66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
4219  -1, 77, 78, -1, -1, 81, 82, 83, 84, -1,
4220  -1, -1, -1, -1, -1, -1, -1, -1, -1, 95,
4221  96, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4222  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4223  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
4224  -1, 127, 128, 52, 53, -1, -1, 56, -1, 135,
4225  -1, -1, -1, -1, -1, -1, -1, 66, 67, 68,
4226  69, 70, 71, 72, 73, 74, -1, -1, 77, 78,
4227  -1, -1, 81, 82, 83, 84, -1, -1, -1, -1,
4228  -1, -1, -1, -1, -1, -1, 95, 96, -1, -1,
4229  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4230  -1, -1, -1, -1, -1, -1, -1, 116, 117, 118,
4231  119, 120, 121, 122, 123, 124, 125, -1, 127, 128,
4232  52, 53, -1, -1, 56, -1, 135, -1, -1, -1,
4233  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
4234  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
4235  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
4236  -1, -1, -1, 95, 96, -1, -1, -1, -1, -1,
4237  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4238  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
4239  122, 123, 124, 125, -1, 127, 128, 52, 53, -1,
4240  -1, 56, -1, 135, -1, -1, -1, -1, -1, -1,
4241  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
4242  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
4243  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4244  95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
4245  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4246  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
4247  125, -1, 127, 128, 52, 53, -1, -1, 56, -1,
4248  135, -1, -1, -1, -1, -1, -1, -1, 66, 67,
4249  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
4250  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
4251  -1, -1, -1, -1, -1, -1, -1, 95, 96, -1,
4252  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4253  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
4254  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
4255  128, 52, 53, -1, -1, 56, -1, 135, -1, -1,
4256  -1, -1, -1, -1, -1, 66, 67, 68, 69, 70,
4257  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
4258  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
4259  -1, -1, -1, -1, 95, 96, -1, -1, -1, -1,
4260  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4261  -1, -1, -1, -1, -1, 116, 117, 118, 119, 120,
4262  121, 122, 123, 124, 125, -1, 127, 128, -1, -1,
4263  -1, -1, -1, -1, 135
4264 };
4265 
4266 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4267  symbol of state STATE-NUM. */
4268 static const yytype_uint16 yystos[] =
4269 {
4270  0, 143, 144, 0, 1, 3, 4, 5, 6, 7,
4271  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4272  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4273  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4274  57, 59, 60, 62, 63, 64, 66, 67, 86, 89,
4275  90, 92, 93, 95, 98, 99, 100, 101, 102, 103,
4276  104, 105, 106, 126, 127, 128, 145, 146, 147, 154,
4277  156, 157, 159, 160, 163, 164, 165, 167, 168, 169,
4278  171, 172, 182, 196, 214, 215, 216, 217, 218, 219,
4279  220, 221, 222, 223, 224, 250, 251, 265, 266, 267,
4280  268, 269, 270, 271, 274, 276, 277, 289, 291, 292,
4281  293, 294, 295, 296, 297, 328, 339, 147, 3, 4,
4282  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
4283  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
4284  25, 26, 30, 31, 32, 33, 34, 35, 36, 37,
4285  38, 39, 45, 46, 47, 48, 49, 50, 51, 52,
4286  53, 56, 66, 67, 68, 69, 70, 71, 72, 73,
4287  74, 77, 78, 81, 82, 83, 84, 95, 96, 116,
4288  117, 118, 119, 120, 121, 122, 123, 124, 125, 127,
4289  128, 135, 175, 176, 177, 178, 180, 181, 289, 291,
4290  39, 58, 86, 89, 95, 96, 97, 127, 164, 172,
4291  182, 184, 189, 192, 194, 214, 293, 294, 296, 297,
4292  326, 327, 189, 189, 136, 190, 191, 136, 186, 190,
4293  136, 141, 333, 54, 177, 333, 148, 130, 21, 22,
4294  30, 31, 32, 163, 182, 214, 182, 56, 1, 47,
4295  89, 150, 151, 152, 154, 166, 167, 339, 157, 198,
4296  185, 194, 326, 339, 184, 325, 326, 339, 46, 86,
4297  126, 134, 171, 196, 214, 293, 294, 297, 242, 243,
4298  54, 55, 57, 175, 281, 290, 280, 281, 282, 140,
4299  272, 140, 278, 140, 275, 140, 279, 59, 60, 159,
4300  182, 182, 139, 141, 332, 337, 338, 40, 41, 42,
4301  43, 44, 37, 38, 26, 130, 186, 190, 256, 28,
4302  248, 113, 134, 89, 95, 168, 113, 68, 69, 70,
4303  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
4304  83, 84, 114, 116, 117, 118, 119, 120, 121, 122,
4305  123, 124, 125, 85, 132, 133, 197, 157, 158, 158,
4306  201, 203, 158, 332, 338, 86, 165, 172, 214, 230,
4307  293, 294, 297, 52, 56, 83, 86, 173, 174, 214,
4308  293, 294, 297, 174, 33, 34, 35, 36, 49, 50,
4309  51, 52, 56, 136, 175, 295, 323, 85, 133, 331,
4310  256, 268, 87, 87, 134, 184, 56, 184, 184, 184,
4311  113, 88, 134, 193, 339, 85, 132, 133, 87, 87,
4312  134, 193, 189, 333, 334, 189, 188, 189, 194, 326,
4313  339, 157, 334, 157, 54, 63, 64, 155, 136, 183,
4314  130, 150, 85, 133, 87, 154, 153, 166, 137, 332,
4315  338, 334, 199, 334, 138, 134, 141, 336, 134, 336,
4316  131, 336, 333, 56, 59, 60, 168, 170, 134, 85,
4317  132, 133, 244, 61, 107, 109, 110, 283, 110, 283,
4318  110, 65, 283, 110, 110, 273, 283, 110, 61, 110,
4319  110, 110, 273, 110, 61, 110, 68, 68, 139, 147,
4320  158, 158, 158, 158, 154, 157, 157, 258, 257, 94,
4321  161, 249, 95, 159, 184, 194, 195, 166, 134, 171,
4322  134, 156, 159, 172, 182, 184, 195, 182, 182, 182,
4323  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
4324  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
4325  182, 182, 182, 52, 53, 56, 180, 255, 329, 330,
4326  188, 52, 53, 56, 180, 254, 329, 149, 150, 13,
4327  226, 337, 226, 158, 158, 332, 17, 259, 56, 85,
4328  132, 133, 25, 157, 52, 56, 173, 1, 117, 298,
4329  337, 85, 132, 133, 210, 324, 211, 331, 52, 56,
4330  329, 159, 182, 159, 182, 179, 182, 184, 95, 184,
4331  192, 326, 52, 56, 188, 52, 56, 327, 334, 137,
4332  334, 134, 134, 334, 177, 200, 182, 145, 131, 329,
4333  329, 182, 130, 334, 152, 334, 326, 134, 170, 52,
4334  56, 188, 52, 56, 52, 54, 55, 56, 57, 58,
4335  68, 89, 95, 96, 97, 120, 123, 136, 246, 301,
4336  303, 304, 305, 306, 307, 308, 311, 312, 313, 314,
4337  317, 318, 319, 320, 321, 285, 284, 140, 283, 140,
4338  140, 140, 182, 182, 76, 118, 237, 238, 339, 237,
4339  162, 237, 184, 134, 334, 170, 134, 113, 44, 333,
4340  87, 87, 186, 190, 253, 333, 335, 87, 87, 186,
4341  190, 252, 10, 225, 8, 261, 339, 150, 13, 150,
4342  27, 227, 337, 227, 259, 194, 225, 52, 56, 188,
4343  52, 56, 205, 208, 337, 299, 207, 52, 56, 173,
4344  188, 149, 157, 136, 300, 303, 212, 186, 187, 190,
4345  339, 44, 177, 184, 193, 87, 87, 335, 87, 87,
4346  326, 157, 131, 145, 336, 168, 335, 113, 184, 52,
4347  89, 95, 231, 232, 233, 305, 303, 245, 134, 302,
4348  134, 322, 339, 52, 134, 322, 134, 302, 52, 134,
4349  302, 52, 286, 54, 55, 57, 288, 297, 52, 58,
4350  234, 236, 239, 307, 309, 310, 313, 315, 316, 319,
4351  321, 333, 150, 150, 237, 150, 95, 184, 170, 182,
4352  115, 159, 182, 159, 182, 161, 186, 138, 87, 159,
4353  182, 159, 182, 161, 187, 184, 195, 262, 339, 15,
4354  229, 339, 14, 228, 229, 229, 202, 204, 225, 134,
4355  226, 335, 158, 337, 158, 149, 335, 225, 334, 303,
4356  149, 337, 175, 256, 248, 182, 87, 134, 334, 131,
4357  184, 233, 134, 305, 134, 334, 239, 29, 111, 247,
4358  301, 306, 317, 319, 308, 313, 321, 307, 314, 319,
4359  307, 287, 113, 86, 214, 239, 118, 134, 235, 134,
4360  322, 322, 134, 235, 134, 235, 139, 10, 131, 150,
4361  10, 184, 182, 159, 182, 88, 263, 339, 150, 9,
4362  264, 339, 158, 225, 225, 150, 150, 184, 150, 227,
4363  209, 337, 225, 334, 225, 213, 334, 232, 134, 95,
4364  231, 137, 150, 150, 134, 302, 134, 302, 322, 134,
4365  302, 134, 302, 302, 150, 214, 56, 85, 118, 234,
4366  316, 319, 309, 313, 307, 315, 319, 307, 52, 240,
4367  241, 304, 131, 86, 172, 214, 293, 294, 297, 226,
4368  150, 226, 225, 225, 229, 259, 260, 206, 149, 300,
4369  134, 232, 134, 305, 10, 131, 307, 319, 307, 307,
4370  108, 52, 56, 134, 235, 134, 235, 322, 134, 235,
4371  134, 235, 235, 134, 333, 56, 85, 132, 133, 150,
4372  150, 150, 225, 149, 232, 134, 302, 134, 302, 302,
4373  302, 307, 319, 307, 307, 241, 52, 56, 188, 52,
4374  56, 261, 228, 225, 225, 232, 307, 235, 134, 235,
4375  235, 235, 335, 302, 307, 235
4376 };
4377 
4378 #define yyerrok (yyerrstatus = 0)
4379 #define yyclearin (yychar = YYEMPTY)
4380 #define YYEMPTY (-2)
4381 #define YYEOF 0
4382 
4383 #define YYACCEPT goto yyacceptlab
4384 #define YYABORT goto yyabortlab
4385 #define YYERROR goto yyerrorlab
4386 
4387 
4388 /* Like YYERROR except do call yyerror. This remains here temporarily
4389  to ease the transition to the new meaning of YYERROR, for GCC.
4390  Once GCC version 2 has supplanted version 1, this can go. However,
4391  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
4392  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
4393  discussed. */
4394 
4395 #define YYFAIL goto yyerrlab
4396 #if defined YYFAIL
4397  /* This is here to suppress warnings from the GCC cpp's
4398  -Wunused-macros. Normally we don't worry about that warning, but
4399  some users do, and we want to make it easy for users to remove
4400  YYFAIL uses, which will produce warnings from Bison 2.5. */
4401 #endif
4402 
4403 #define YYRECOVERING() (!!yyerrstatus)
4404 
4405 #define YYBACKUP(Token, Value) \
4406 do \
4407  if (yychar == YYEMPTY && yylen == 1) \
4408  { \
4409  yychar = (Token); \
4410  yylval = (Value); \
4411  YYPOPSTACK (1); \
4412  goto yybackup; \
4413  } \
4414  else \
4415  { \
4416  parser_yyerror (parser, YY_("syntax error: cannot back up")); \
4417  YYERROR; \
4418  } \
4419 while (YYID (0))
4420 
4421 
4422 #define YYTERROR 1
4423 #define YYERRCODE 256
4424 
4425 
4426 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
4427  If N is 0, then set CURRENT to the empty location which ends
4428  the previous symbol: RHS[0] (always defined). */
4429 
4430 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
4431 #ifndef YYLLOC_DEFAULT
4432 # define YYLLOC_DEFAULT(Current, Rhs, N) \
4433  do \
4434  if (YYID (N)) \
4435  { \
4436  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
4437  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
4438  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
4439  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
4440  } \
4441  else \
4442  { \
4443  (Current).first_line = (Current).last_line = \
4444  YYRHSLOC (Rhs, 0).last_line; \
4445  (Current).first_column = (Current).last_column = \
4446  YYRHSLOC (Rhs, 0).last_column; \
4447  } \
4448  while (YYID (0))
4449 #endif
4450 
4451 
4452 /* This macro is provided for backward compatibility. */
4453 
4454 #ifndef YY_LOCATION_PRINT
4455 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
4456 #endif
4457 
4458 
4459 /* YYLEX -- calling `yylex' with the right arguments. */
4460 
4461 #ifdef YYLEX_PARAM
4462 # define YYLEX yylex (&yylval, YYLEX_PARAM)
4463 #else
4464 # define YYLEX yylex (&yylval, parser)
4465 #endif
4466 
4467 /* Enable debugging if requested. */
4468 #if YYDEBUG
4469 
4470 # ifndef YYFPRINTF
4471 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
4472 # define YYFPRINTF fprintf
4473 # endif
4474 
4475 # define YYDPRINTF(Args) \
4476 do { \
4477  if (yydebug) \
4478  YYFPRINTF Args; \
4479 } while (YYID (0))
4480 
4481 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
4482 do { \
4483  if (yydebug) \
4484  { \
4485  YYFPRINTF (stderr, "%s ", Title); \
4486  yy_symbol_print (stderr, \
4487  Type, Value, parser); \
4488  YYFPRINTF (stderr, "\n"); \
4489  } \
4490 } while (YYID (0))
4491 
4492 
4493 /*--------------------------------.
4494 | Print this symbol on YYOUTPUT. |
4495 `--------------------------------*/
4496 
4497 /*ARGSUSED*/
4498 #if (defined __STDC__ || defined __C99__FUNC__ \
4499  || defined __cplusplus || defined _MSC_VER)
4500 static void
4501 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4502 #else
4503 static void
4504 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
4505  FILE *yyoutput;
4506  int yytype;
4507  YYSTYPE const * const yyvaluep;
4508  struct parser_params *parser;
4509 #endif
4510 {
4511  if (!yyvaluep)
4512  return;
4513  YYUSE (parser);
4514 # ifdef YYPRINT
4515  if (yytype < YYNTOKENS)
4516  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4517 # else
4518  YYUSE (yyoutput);
4519 # endif
4520  switch (yytype)
4521  {
4522  default:
4523  break;
4524  }
4525 }
4526 
4527 
4528 /*--------------------------------.
4529 | Print this symbol on YYOUTPUT. |
4530 `--------------------------------*/
4531 
4532 #if (defined __STDC__ || defined __C99__FUNC__ \
4533  || defined __cplusplus || defined _MSC_VER)
4534 static void
4535 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4536 #else
4537 static void
4538 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
4539  FILE *yyoutput;
4540  int yytype;
4541  YYSTYPE const * const yyvaluep;
4542  struct parser_params *parser;
4543 #endif
4544 {
4545  if (yytype < YYNTOKENS)
4546  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4547  else
4548  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4549 
4550  yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
4551  YYFPRINTF (yyoutput, ")");
4552 }
4553 
4554 /*------------------------------------------------------------------.
4555 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4556 | TOP (included). |
4557 `------------------------------------------------------------------*/
4558 
4559 #if (defined __STDC__ || defined __C99__FUNC__ \
4560  || defined __cplusplus || defined _MSC_VER)
4561 static void
4562 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4563 #else
4564 static void
4565 yy_stack_print (yybottom, yytop)
4566  yytype_int16 *yybottom;
4567  yytype_int16 *yytop;
4568 #endif
4569 {
4570  YYFPRINTF (stderr, "Stack now");
4571  for (; yybottom <= yytop; yybottom++)
4572  {
4573  int yybot = *yybottom;
4574  YYFPRINTF (stderr, " %d", yybot);
4575  }
4576  YYFPRINTF (stderr, "\n");
4577 }
4578 
4579 # define YY_STACK_PRINT(Bottom, Top) \
4580 do { \
4581  if (yydebug) \
4582  yy_stack_print ((Bottom), (Top)); \
4583 } while (YYID (0))
4584 
4585 
4586 /*------------------------------------------------.
4587 | Report that the YYRULE is going to be reduced. |
4588 `------------------------------------------------*/
4589 
4590 #if (defined __STDC__ || defined __C99__FUNC__ \
4591  || defined __cplusplus || defined _MSC_VER)
4592 static void
4593 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
4594 #else
4595 static void
4596 yy_reduce_print (yyvsp, yyrule, parser)
4597  YYSTYPE *yyvsp;
4598  int yyrule;
4599  struct parser_params *parser;
4600 #endif
4601 {
4602  int yynrhs = yyr2[yyrule];
4603  int yyi;
4604  unsigned long int yylno = yyrline[yyrule];
4605  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4606  yyrule - 1, yylno);
4607  /* The symbols being reduced. */
4608  for (yyi = 0; yyi < yynrhs; yyi++)
4609  {
4610  YYFPRINTF (stderr, " $%d = ", yyi + 1);
4611  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4612  &(yyvsp[(yyi + 1) - (yynrhs)])
4613  , parser);
4614  YYFPRINTF (stderr, "\n");
4615  }
4616 }
4617 
4618 # define YY_REDUCE_PRINT(Rule) \
4619 do { \
4620  if (yydebug) \
4621  yy_reduce_print (yyvsp, Rule, parser); \
4622 } while (YYID (0))
4623 
4624 /* Nonzero means print parse trace. It is left uninitialized so that
4625  multiple parsers can coexist. */
4626 #ifndef yydebug
4627 int yydebug;
4628 #endif
4629 #else /* !YYDEBUG */
4630 # define YYDPRINTF(Args)
4631 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4632 # define YY_STACK_PRINT(Bottom, Top)
4633 # define YY_REDUCE_PRINT(Rule)
4634 #endif /* !YYDEBUG */
4635 
4636 
4637 /* YYINITDEPTH -- initial size of the parser's stacks. */
4638 #ifndef YYINITDEPTH
4639 # define YYINITDEPTH 200
4640 #endif
4641 
4642 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4643  if the built-in stack extension method is used).
4644 
4645  Do not make this value too large; the results are undefined if
4646  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4647  evaluated with infinite-precision integer arithmetic. */
4648 
4649 #ifndef YYMAXDEPTH
4650 # define YYMAXDEPTH 10000
4651 #endif
4652 
4653 
4654 #if YYERROR_VERBOSE
4655 
4656 # ifndef yystrlen
4657 # if defined __GLIBC__ && defined _STRING_H
4658 # define yystrlen strlen
4659 # else
4660 /* Return the length of YYSTR. */
4661 #if (defined __STDC__ || defined __C99__FUNC__ \
4662  || defined __cplusplus || defined _MSC_VER)
4663 static YYSIZE_T
4664 yystrlen (const char *yystr)
4665 #else
4666 static YYSIZE_T
4667 yystrlen (yystr)
4668  const char *yystr;
4669 #endif
4670 {
4671  YYSIZE_T yylen;
4672  for (yylen = 0; yystr[yylen]; yylen++)
4673  continue;
4674  return yylen;
4675 }
4676 # endif
4677 # endif
4678 
4679 # ifndef yystpcpy
4680 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4681 # define yystpcpy stpcpy
4682 # else
4683 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4684  YYDEST. */
4685 #if (defined __STDC__ || defined __C99__FUNC__ \
4686  || defined __cplusplus || defined _MSC_VER)
4687 static char *
4688 yystpcpy (char *yydest, const char *yysrc)
4689 #else
4690 static char *
4691 yystpcpy (yydest, yysrc)
4692  char *yydest;
4693  const char *yysrc;
4694 #endif
4695 {
4696  char *yyd = yydest;
4697  const char *yys = yysrc;
4698 
4699  while ((*yyd++ = *yys++) != '\0')
4700  continue;
4701 
4702  return yyd - 1;
4703 }
4704 # endif
4705 # endif
4706 
4707 # ifndef yytnamerr
4708 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4709  quotes and backslashes, so that it's suitable for yyerror. The
4710  heuristic is that double-quoting is unnecessary unless the string
4711  contains an apostrophe, a comma, or backslash (other than
4712  backslash-backslash). YYSTR is taken from yytname. If YYRES is
4713  null, do not copy; instead, return the length of what the result
4714  would have been. */
4715 static YYSIZE_T
4716 yytnamerr (char *yyres, const char *yystr)
4717 {
4718  if (*yystr == '"')
4719  {
4720  YYSIZE_T yyn = 0;
4721  char const *yyp = yystr;
4722 
4723  for (;;)
4724  switch (*++yyp)
4725  {
4726  case '\'':
4727  case ',':
4728  goto do_not_strip_quotes;
4729 
4730  case '\\':
4731  if (*++yyp != '\\')
4732  goto do_not_strip_quotes;
4733  /* Fall through. */
4734  default:
4735  if (yyres)
4736  yyres[yyn] = *yyp;
4737  yyn++;
4738  break;
4739 
4740  case '"':
4741  if (yyres)
4742  yyres[yyn] = '\0';
4743  return yyn;
4744  }
4745  do_not_strip_quotes: ;
4746  }
4747 
4748  if (! yyres)
4749  return yystrlen (yystr);
4750 
4751  return yystpcpy (yyres, yystr) - yyres;
4752 }
4753 # endif
4754 
4755 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
4756  about the unexpected token YYTOKEN for the state stack whose top is
4757  YYSSP.
4758 
4759  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
4760  not large enough to hold the message. In that case, also set
4761  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
4762  required number of bytes is too large to store. */
4763 static int
4764 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
4765  yytype_int16 *yyssp, int yytoken)
4766 {
4767  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
4768  YYSIZE_T yysize = yysize0;
4769  YYSIZE_T yysize1;
4770  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4771  /* Internationalized format string. */
4772  const char *yyformat = 0;
4773  /* Arguments of yyformat. */
4774  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4775  /* Number of reported tokens (one for the "unexpected", one per
4776  "expected"). */
4777  int yycount = 0;
4778 
4779  /* There are many possibilities here to consider:
4780  - Assume YYFAIL is not used. It's too flawed to consider. See
4781  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
4782  for details. YYERROR is fine as it does not invoke this
4783  function.
4784  - If this state is a consistent state with a default action, then
4785  the only way this function was invoked is if the default action
4786  is an error action. In that case, don't check for expected
4787  tokens because there are none.
4788  - The only way there can be no lookahead present (in yychar) is if
4789  this state is a consistent state with a default action. Thus,
4790  detecting the absence of a lookahead is sufficient to determine
4791  that there is no unexpected or expected token to report. In that
4792  case, just report a simple "syntax error".
4793  - Don't assume there isn't a lookahead just because this state is a
4794  consistent state with a default action. There might have been a
4795  previous inconsistent state, consistent state with a non-default
4796  action, or user semantic action that manipulated yychar.
4797  - Of course, the expected token list depends on states to have
4798  correct lookahead information, and it depends on the parser not
4799  to perform extra reductions after fetching a lookahead from the
4800  scanner and before detecting a syntax error. Thus, state merging
4801  (from LALR or IELR) and default reductions corrupt the expected
4802  token list. However, the list is correct for canonical LR with
4803  one exception: it will still contain any token that will not be
4804  accepted due to an error action in a later state.
4805  */
4806  if (yytoken != YYEMPTY)
4807  {
4808  int yyn = yypact[*yyssp];
4809  yyarg[yycount++] = yytname[yytoken];
4810  if (!yypact_value_is_default (yyn))
4811  {
4812  /* Start YYX at -YYN if negative to avoid negative indexes in
4813  YYCHECK. In other words, skip the first -YYN actions for
4814  this state because they are default actions. */
4815  int yyxbegin = yyn < 0 ? -yyn : 0;
4816  /* Stay within bounds of both yycheck and yytname. */
4817  int yychecklim = YYLAST - yyn + 1;
4818  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4819  int yyx;
4820 
4821  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4822  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
4823  && !yytable_value_is_error (yytable[yyx + yyn]))
4824  {
4825  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4826  {
4827  yycount = 1;
4828  yysize = yysize0;
4829  break;
4830  }
4831  yyarg[yycount++] = yytname[yyx];
4832  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4833  if (! (yysize <= yysize1
4834  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4835  return 2;
4836  yysize = yysize1;
4837  }
4838  }
4839  }
4840 
4841  switch (yycount)
4842  {
4843 # define YYCASE_(N, S) \
4844  case N: \
4845  yyformat = S; \
4846  break
4847  YYCASE_(0, YY_("syntax error"));
4848  YYCASE_(1, YY_("syntax error, unexpected %s"));
4849  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
4850  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
4851  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
4852  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
4853 # undef YYCASE_
4854  }
4855 
4856  yysize1 = yysize + yystrlen (yyformat);
4857  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4858  return 2;
4859  yysize = yysize1;
4860 
4861  if (*yymsg_alloc < yysize)
4862  {
4863  *yymsg_alloc = 2 * yysize;
4864  if (! (yysize <= *yymsg_alloc
4865  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
4866  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
4867  return 1;
4868  }
4869 
4870  /* Avoid sprintf, as that infringes on the user's name space.
4871  Don't have undefined behavior even if the translation
4872  produced a string with the wrong number of "%s"s. */
4873  {
4874  char *yyp = *yymsg;
4875  int yyi = 0;
4876  while ((*yyp = *yyformat) != '\0')
4877  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
4878  {
4879  yyp += yytnamerr (yyp, yyarg[yyi++]);
4880  yyformat += 2;
4881  }
4882  else
4883  {
4884  yyp++;
4885  yyformat++;
4886  }
4887  }
4888  return 0;
4889 }
4890 #endif /* YYERROR_VERBOSE */
4891 
4892 /*-----------------------------------------------.
4893 | Release the memory associated to this symbol. |
4894 `-----------------------------------------------*/
4895 
4896 /*ARGSUSED*/
4897 #if (defined __STDC__ || defined __C99__FUNC__ \
4898  || defined __cplusplus || defined _MSC_VER)
4899 static void
4900 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
4901 #else
4902 static void
4903 yydestruct (yymsg, yytype, yyvaluep, parser)
4904  const char *yymsg;
4905  int yytype;
4906  YYSTYPE *yyvaluep;
4907  struct parser_params *parser;
4908 #endif
4909 {
4910  YYUSE (yyvaluep);
4911  YYUSE (parser);
4912 
4913  if (!yymsg)
4914  yymsg = "Deleting";
4915  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4916 
4917  switch (yytype)
4918  {
4919 
4920  default:
4921  break;
4922  }
4923 }
4924 
4925 
4926 /* Prevent warnings from -Wmissing-prototypes. */
4927 #ifdef YYPARSE_PARAM
4928 #if defined __STDC__ || defined __cplusplus
4929 int yyparse (void *YYPARSE_PARAM);
4930 #else
4931 int yyparse ();
4932 #endif
4933 #else /* ! YYPARSE_PARAM */
4934 #if defined __STDC__ || defined __cplusplus
4935 int yyparse (struct parser_params *parser);
4936 #else
4937 int yyparse ();
4938 #endif
4939 #endif /* ! YYPARSE_PARAM */
4940 
4941 
4942 /*----------.
4943 | yyparse. |
4944 `----------*/
4945 
4946 #ifdef YYPARSE_PARAM
4947 #if (defined __STDC__ || defined __C99__FUNC__ \
4948  || defined __cplusplus || defined _MSC_VER)
4949 int
4950 yyparse (void *YYPARSE_PARAM)
4951 #else
4952 int
4953 yyparse (YYPARSE_PARAM)
4954  void *YYPARSE_PARAM;
4955 #endif
4956 #else /* ! YYPARSE_PARAM */
4957 #if (defined __STDC__ || defined __C99__FUNC__ \
4958  || defined __cplusplus || defined _MSC_VER)
4959 int
4960 yyparse (struct parser_params *parser)
4961 #else
4962 int
4963 yyparse (parser)
4964  struct parser_params *parser;
4965 #endif
4966 #endif
4967 {
4968 /* The lookahead symbol. */
4969 int yychar;
4970 
4971 /* The semantic value of the lookahead symbol. */
4972 YYSTYPE yylval;
4973 
4974  /* Number of syntax errors so far. */
4975  int yynerrs;
4976 
4977  int yystate;
4978  /* Number of tokens to shift before error messages enabled. */
4979  int yyerrstatus;
4980 
4981  /* The stacks and their tools:
4982  `yyss': related to states.
4983  `yyvs': related to semantic values.
4984 
4985  Refer to the stacks thru separate pointers, to allow yyoverflow
4986  to reallocate them elsewhere. */
4987 
4988  /* The state stack. */
4989  yytype_int16 yyssa[YYINITDEPTH];
4990  yytype_int16 *yyss;
4991  yytype_int16 *yyssp;
4992 
4993  /* The semantic value stack. */
4994  YYSTYPE yyvsa[YYINITDEPTH];
4995  YYSTYPE *yyvs;
4996  YYSTYPE *yyvsp;
4997 
4998  YYSIZE_T yystacksize;
4999 
5000  int yyn;
5001  int yyresult;
5002  /* Lookahead token as an internal (translated) token number. */
5003  int yytoken;
5004  /* The variables used to return semantic value and location from the
5005  action routines. */
5006  YYSTYPE yyval;
5007 
5008 #if YYERROR_VERBOSE
5009  /* Buffer for error messages, and its allocated size. */
5010  char yymsgbuf[128];
5011  char *yymsg = yymsgbuf;
5012  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
5013 #endif
5014 
5015 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
5016 
5017  /* The number of symbols on the RHS of the reduced rule.
5018  Keep to zero when no symbol should be popped. */
5019  int yylen = 0;
5020 
5021  yytoken = 0;
5022  yyss = yyssa;
5023  yyvs = yyvsa;
5024  yystacksize = YYINITDEPTH;
5025 
5026  YYDPRINTF ((stderr, "Starting parse\n"));
5027 
5028  yystate = 0;
5029  yyerrstatus = 0;
5030  yynerrs = 0;
5031  yychar = YYEMPTY; /* Cause a token to be read. */
5032 
5033  /* Initialize stack pointers.
5034  Waste one element of value and location stack
5035  so that they stay on the same level as the state stack.
5036  The wasted elements are never initialized. */
5037  yyssp = yyss;
5038  yyvsp = yyvs;
5039 
5040  goto yysetstate;
5041 
5042 /*------------------------------------------------------------.
5043 | yynewstate -- Push a new state, which is found in yystate. |
5044 `------------------------------------------------------------*/
5045  yynewstate:
5046  /* In all cases, when you get here, the value and location stacks
5047  have just been pushed. So pushing a state here evens the stacks. */
5048  yyssp++;
5049 
5050  yysetstate:
5051  *yyssp = yystate;
5052 
5053  if (yyss + yystacksize - 1 <= yyssp)
5054  {
5055  /* Get the current used size of the three stacks, in elements. */
5056  YYSIZE_T yysize = yyssp - yyss + 1;
5057 
5058 #ifdef yyoverflow
5059  {
5060  /* Give user a chance to reallocate the stack. Use copies of
5061  these so that the &'s don't force the real ones into
5062  memory. */
5063  YYSTYPE *yyvs1 = yyvs;
5064  yytype_int16 *yyss1 = yyss;
5065 
5066  /* Each stack pointer address is followed by the size of the
5067  data in use in that stack, in bytes. This used to be a
5068  conditional around just the two extra args, but that might
5069  be undefined if yyoverflow is a macro. */
5070  yyoverflow (YY_("memory exhausted"),
5071  &yyss1, yysize * sizeof (*yyssp),
5072  &yyvs1, yysize * sizeof (*yyvsp),
5073  &yystacksize);
5074 
5075  yyss = yyss1;
5076  yyvs = yyvs1;
5077  }
5078 #else /* no yyoverflow */
5079 # ifndef YYSTACK_RELOCATE
5080  goto yyexhaustedlab;
5081 # else
5082  /* Extend the stack our own way. */
5083  if (YYMAXDEPTH <= yystacksize)
5084  goto yyexhaustedlab;
5085  yystacksize *= 2;
5086  if (YYMAXDEPTH < yystacksize)
5087  yystacksize = YYMAXDEPTH;
5088 
5089  {
5090  yytype_int16 *yyss1 = yyss;
5091  union yyalloc *yyptr =
5092  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
5093  if (! yyptr)
5094  goto yyexhaustedlab;
5095  YYSTACK_RELOCATE (yyss_alloc, yyss);
5096  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
5097 # undef YYSTACK_RELOCATE
5098  if (yyss1 != yyssa)
5099  YYSTACK_FREE (yyss1);
5100  }
5101 # endif
5102 #endif /* no yyoverflow */
5103 
5104  yyssp = yyss + yysize - 1;
5105  yyvsp = yyvs + yysize - 1;
5106 
5107  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
5108  (unsigned long int) yystacksize));
5109 
5110  if (yyss + yystacksize - 1 <= yyssp)
5111  YYABORT;
5112  }
5113 
5114  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
5115 
5116  if (yystate == YYFINAL)
5117  YYACCEPT;
5118 
5119  goto yybackup;
5120 
5121 /*-----------.
5122 | yybackup. |
5123 `-----------*/
5124 yybackup:
5125 
5126  /* Do appropriate processing given the current state. Read a
5127  lookahead token if we need one and don't already have one. */
5128 
5129  /* First try to decide what to do without reference to lookahead token. */
5130  yyn = yypact[yystate];
5131  if (yypact_value_is_default (yyn))
5132  goto yydefault;
5133 
5134  /* Not known => get a lookahead token if don't already have one. */
5135 
5136  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5137  if (yychar == YYEMPTY)
5138  {
5139  YYDPRINTF ((stderr, "Reading a token: "));
5140  yychar = YYLEX;
5141  }
5142 
5143  if (yychar <= YYEOF)
5144  {
5145  yychar = yytoken = YYEOF;
5146  YYDPRINTF ((stderr, "Now at end of input.\n"));
5147  }
5148  else
5149  {
5150  yytoken = YYTRANSLATE (yychar);
5151  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
5152  }
5153 
5154  /* If the proper action on seeing token YYTOKEN is to reduce or to
5155  detect an error, take that action. */
5156  yyn += yytoken;
5157  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
5158  goto yydefault;
5159  yyn = yytable[yyn];
5160  if (yyn <= 0)
5161  {
5162  if (yytable_value_is_error (yyn))
5163  goto yyerrlab;
5164  yyn = -yyn;
5165  goto yyreduce;
5166  }
5167 
5168  /* Count tokens shifted since error; after three, turn off error
5169  status. */
5170  if (yyerrstatus)
5171  yyerrstatus--;
5172 
5173  /* Shift the lookahead token. */
5174  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
5175 
5176  /* Discard the shifted token. */
5177  yychar = YYEMPTY;
5178 
5179  yystate = yyn;
5180  *++yyvsp = yylval;
5181 
5182  goto yynewstate;
5183 
5184 
5185 /*-----------------------------------------------------------.
5186 | yydefault -- do the default action for the current state. |
5187 `-----------------------------------------------------------*/
5188 yydefault:
5189  yyn = yydefact[yystate];
5190  if (yyn == 0)
5191  goto yyerrlab;
5192  goto yyreduce;
5193 
5194 
5195 /*-----------------------------.
5196 | yyreduce -- Do a reduction. |
5197 `-----------------------------*/
5198 yyreduce:
5199  /* yyn is the number of a rule to reduce with. */
5200  yylen = yyr2[yyn];
5201 
5202  /* If YYLEN is nonzero, implement the default value of the action:
5203  `$$ = $1'.
5204 
5205  Otherwise, the following line sets YYVAL to garbage.
5206  This behavior is undocumented and Bison
5207  users should not rely upon it. Assigning to YYVAL
5208  unconditionally makes the parser a bit smaller, and it avoids a
5209  GCC warning that YYVAL may be used uninitialized. */
5210  yyval = yyvsp[1-yylen];
5211 
5212 
5213  YY_REDUCE_PRINT (yyn);
5214  switch (yyn)
5215  {
5216  case 2:
5217 
5218 /* Line 1806 of yacc.c */
5219 #line 854 "ripper.y"
5220  {
5221  lex_state = EXPR_BEG;
5222 #if 0
5224 #endif
5225  local_push(0);
5226 
5227  }
5228  break;
5229 
5230  case 3:
5231 
5232 /* Line 1806 of yacc.c */
5233 #line 863 "ripper.y"
5234  {
5235 #if 0
5236  if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
5237  /* last expression should not be void */
5238  if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
5239  else {
5240  NODE *node = (yyvsp[(2) - (2)].val);
5241  while (node->nd_next) {
5242  node = node->nd_next;
5243  }
5244  void_expr(node->nd_head);
5245  }
5246  }
5247  ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val)));
5248 #endif
5249  (yyval.val) = (yyvsp[(2) - (2)].val);
5250  parser->result = dispatch1(program, (yyval.val));
5251 
5252  local_pop();
5253  }
5254  break;
5255 
5256  case 4:
5257 
5258 /* Line 1806 of yacc.c */
5259 #line 886 "ripper.y"
5260  {
5261 #if 0
5262  void_stmts((yyvsp[(1) - (2)].val));
5264 #endif
5265 
5266  (yyval.val) = (yyvsp[(1) - (2)].val);
5267  }
5268  break;
5269 
5270  case 5:
5271 
5272 /* Line 1806 of yacc.c */
5273 #line 897 "ripper.y"
5274  {
5275 #if 0
5276  (yyval.val) = NEW_BEGIN(0);
5277 #endif
5278  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5279  dispatch0(void_stmt));
5280 
5281  }
5282  break;
5283 
5284  case 6:
5285 
5286 /* Line 1806 of yacc.c */
5287 #line 906 "ripper.y"
5288  {
5289 #if 0
5290  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5291 #endif
5292  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5293 
5294  }
5295  break;
5296 
5297  case 7:
5298 
5299 /* Line 1806 of yacc.c */
5300 #line 914 "ripper.y"
5301  {
5302 #if 0
5303  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5304 #endif
5305  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5306 
5307  }
5308  break;
5309 
5310  case 8:
5311 
5312 /* Line 1806 of yacc.c */
5313 #line 922 "ripper.y"
5314  {
5315  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5316  }
5317  break;
5318 
5319  case 10:
5320 
5321 /* Line 1806 of yacc.c */
5322 #line 929 "ripper.y"
5323  {
5324 #if 0
5325  /* local_push(0); */
5326 #endif
5327 
5328  }
5329  break;
5330 
5331  case 11:
5332 
5333 /* Line 1806 of yacc.c */
5334 #line 936 "ripper.y"
5335  {
5336 #if 0
5338  (yyvsp[(4) - (5)].val));
5339  /* NEW_PREEXE($4)); */
5340  /* local_pop(); */
5341  (yyval.val) = NEW_BEGIN(0);
5342 #endif
5343  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5344 
5345  }
5346  break;
5347 
5348  case 12:
5349 
5350 /* Line 1806 of yacc.c */
5351 #line 953 "ripper.y"
5352  {
5353 #if 0
5354  (yyval.val) = (yyvsp[(1) - (4)].val);
5355  if ((yyvsp[(2) - (4)].val)) {
5356  (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
5357  }
5358  else if ((yyvsp[(3) - (4)].val)) {
5359  rb_warn0("else without rescue is useless");
5360  (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val));
5361  }
5362  if ((yyvsp[(4) - (4)].val)) {
5363  if ((yyval.val)) {
5364  (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
5365  }
5366  else {
5367  (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL());
5368  }
5369  }
5370  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5371 #endif
5372  (yyval.val) = dispatch4(bodystmt,
5373  escape_Qundef((yyvsp[(1) - (4)].val)),
5374  escape_Qundef((yyvsp[(2) - (4)].val)),
5375  escape_Qundef((yyvsp[(3) - (4)].val)),
5376  escape_Qundef((yyvsp[(4) - (4)].val)));
5377 
5378  }
5379  break;
5380 
5381  case 13:
5382 
5383 /* Line 1806 of yacc.c */
5384 #line 983 "ripper.y"
5385  {
5386 #if 0
5387  void_stmts((yyvsp[(1) - (2)].val));
5389 #endif
5390 
5391  (yyval.val) = (yyvsp[(1) - (2)].val);
5392  }
5393  break;
5394 
5395  case 14:
5396 
5397 /* Line 1806 of yacc.c */
5398 #line 994 "ripper.y"
5399  {
5400 #if 0
5401  (yyval.val) = NEW_BEGIN(0);
5402 #endif
5403  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5404  dispatch0(void_stmt));
5405 
5406  }
5407  break;
5408 
5409  case 15:
5410 
5411 /* Line 1806 of yacc.c */
5412 #line 1003 "ripper.y"
5413  {
5414 #if 0
5415  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5416 #endif
5417  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5418 
5419  }
5420  break;
5421 
5422  case 16:
5423 
5424 /* Line 1806 of yacc.c */
5425 #line 1011 "ripper.y"
5426  {
5427 #if 0
5428  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5429 #endif
5430  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5431 
5432  }
5433  break;
5434 
5435  case 17:
5436 
5437 /* Line 1806 of yacc.c */
5438 #line 1019 "ripper.y"
5439  {
5440  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5441  }
5442  break;
5443 
5444  case 18:
5445 
5446 /* Line 1806 of yacc.c */
5447 #line 1025 "ripper.y"
5448  {
5449  (yyval.val) = (yyvsp[(1) - (1)].val);
5450  }
5451  break;
5452 
5453  case 19:
5454 
5455 /* Line 1806 of yacc.c */
5456 #line 1029 "ripper.y"
5457  {
5458  yyerror("BEGIN is permitted only at toplevel");
5459 #if 0
5460  /* local_push(0); */
5461 #endif
5462 
5463  }
5464  break;
5465 
5466  case 20:
5467 
5468 /* Line 1806 of yacc.c */
5469 #line 1037 "ripper.y"
5470  {
5471 #if 0
5473  (yyvsp[(4) - (5)].val));
5474  /* NEW_PREEXE($4)); */
5475  /* local_pop(); */
5476  (yyval.val) = NEW_BEGIN(0);
5477 #endif
5478  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5479 
5480  }
5481  break;
5482 
5483  case 21:
5484 
5485 /* Line 1806 of yacc.c */
5486 #line 1049 "ripper.y"
5487  {lex_state = EXPR_FNAME;}
5488  break;
5489 
5490  case 22:
5491 
5492 /* Line 1806 of yacc.c */
5493 #line 1050 "ripper.y"
5494  {
5495 #if 0
5496  (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5497 #endif
5498  (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5499 
5500  }
5501  break;
5502 
5503  case 23:
5504 
5505 /* Line 1806 of yacc.c */
5506 #line 1058 "ripper.y"
5507  {
5508 #if 0
5509  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5510 #endif
5511  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5512 
5513  }
5514  break;
5515 
5516  case 24:
5517 
5518 /* Line 1806 of yacc.c */
5519 #line 1066 "ripper.y"
5520  {
5521 #if 0
5522  char buf[2];
5523  buf[0] = '$';
5524  buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
5525  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
5526 #endif
5527  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5528 
5529  }
5530  break;
5531 
5532  case 25:
5533 
5534 /* Line 1806 of yacc.c */
5535 #line 1077 "ripper.y"
5536  {
5537 #if 0
5538  yyerror("can't make alias for the number variables");
5539  (yyval.val) = NEW_BEGIN(0);
5540 #endif
5541  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5542  (yyval.val) = dispatch1(alias_error, (yyval.val));
5543 
5544  }
5545  break;
5546 
5547  case 26:
5548 
5549 /* Line 1806 of yacc.c */
5550 #line 1087 "ripper.y"
5551  {
5552 #if 0
5553  (yyval.val) = (yyvsp[(2) - (2)].val);
5554 #endif
5555  (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
5556 
5557  }
5558  break;
5559 
5560  case 27:
5561 
5562 /* Line 1806 of yacc.c */
5563 #line 1095 "ripper.y"
5564  {
5565 #if 0
5566  (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5567  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5568 #endif
5569  (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5570 
5571  }
5572  break;
5573 
5574  case 28:
5575 
5576 /* Line 1806 of yacc.c */
5577 #line 1104 "ripper.y"
5578  {
5579 #if 0
5580  (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5581  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5582 #endif
5583  (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5584 
5585  }
5586  break;
5587 
5588  case 29:
5589 
5590 /* Line 1806 of yacc.c */
5591 #line 1113 "ripper.y"
5592  {
5593 #if 0
5594  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5595  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5596  }
5597  else {
5598  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5599  }
5600 #endif
5601  (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5602 
5603  }
5604  break;
5605 
5606  case 30:
5607 
5608 /* Line 1806 of yacc.c */
5609 #line 1126 "ripper.y"
5610  {
5611 #if 0
5612  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5613  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5614  }
5615  else {
5616  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5617  }
5618 #endif
5619  (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5620 
5621  }
5622  break;
5623 
5624  case 31:
5625 
5626 /* Line 1806 of yacc.c */
5627 #line 1139 "ripper.y"
5628  {
5629 #if 0
5630  NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0);
5631  (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0);
5632 #endif
5633  (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5634 
5635  }
5636  break;
5637 
5638  case 32:
5639 
5640 /* Line 1806 of yacc.c */
5641 #line 1148 "ripper.y"
5642  {
5643  if (in_def || in_single) {
5644  rb_warn0("END in method; use at_exit");
5645  }
5646 #if 0
5647  (yyval.val) = NEW_POSTEXE(NEW_NODE(
5648  NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */));
5649 #endif
5650  (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
5651 
5652  }
5653  break;
5654 
5655  case 34:
5656 
5657 /* Line 1806 of yacc.c */
5658 #line 1161 "ripper.y"
5659  {
5660 #if 0
5661  value_expr((yyvsp[(3) - (3)].val));
5662  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5663  (yyval.val) = (yyvsp[(1) - (3)].val);
5664 #endif
5665  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5666 
5667  }
5668  break;
5669 
5670  case 35:
5671 
5672 /* Line 1806 of yacc.c */
5673 #line 1171 "ripper.y"
5674  {
5675  value_expr((yyvsp[(3) - (3)].val));
5676  (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5677  }
5678  break;
5679 
5680  case 36:
5681 
5682 /* Line 1806 of yacc.c */
5683 #line 1176 "ripper.y"
5684  {
5685 #if 0
5686  NODE *args;
5687 
5688  value_expr((yyvsp[(6) - (6)].val));
5689  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
5690  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
5691  if ((yyvsp[(5) - (6)].val) == tOROP) {
5692  (yyvsp[(5) - (6)].val) = 0;
5693  }
5694  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
5695  (yyvsp[(5) - (6)].val) = 1;
5696  }
5697  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
5698  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
5699 #endif
5700  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
5701  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
5702 
5703  }
5704  break;
5705 
5706  case 37:
5707 
5708 /* Line 1806 of yacc.c */
5709 #line 1197 "ripper.y"
5710  {
5711  value_expr((yyvsp[(5) - (5)].val));
5712  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5713  }
5714  break;
5715 
5716  case 38:
5717 
5718 /* Line 1806 of yacc.c */
5719 #line 1202 "ripper.y"
5720  {
5721  value_expr((yyvsp[(5) - (5)].val));
5722  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5723  }
5724  break;
5725 
5726  case 39:
5727 
5728 /* Line 1806 of yacc.c */
5729 #line 1207 "ripper.y"
5730  {
5731 #if 0
5732  (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
5733  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5734 #endif
5735  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
5736  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5737 
5738  }
5739  break;
5740 
5741  case 40:
5742 
5743 /* Line 1806 of yacc.c */
5744 #line 1217 "ripper.y"
5745  {
5746  value_expr((yyvsp[(5) - (5)].val));
5747  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5748  }
5749  break;
5750 
5751  case 41:
5752 
5753 /* Line 1806 of yacc.c */
5754 #line 1222 "ripper.y"
5755  {
5756 #if 0
5757  rb_backref_error((yyvsp[(1) - (3)].val));
5758  (yyval.val) = NEW_BEGIN(0);
5759 #endif
5760  (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
5761  (yyval.val) = dispatch1(assign_error, (yyval.val));
5762 
5763  }
5764  break;
5765 
5766  case 42:
5767 
5768 /* Line 1806 of yacc.c */
5769 #line 1232 "ripper.y"
5770  {
5771 #if 0
5772  value_expr((yyvsp[(3) - (3)].val));
5773  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5774 #endif
5775  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5776 
5777  }
5778  break;
5779 
5780  case 43:
5781 
5782 /* Line 1806 of yacc.c */
5783 #line 1241 "ripper.y"
5784  {
5785 #if 0
5786  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5787  (yyval.val) = (yyvsp[(1) - (3)].val);
5788 #endif
5789  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5790 
5791  }
5792  break;
5793 
5794  case 44:
5795 
5796 /* Line 1806 of yacc.c */
5797 #line 1250 "ripper.y"
5798  {
5799 #if 0
5800  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5801  (yyval.val) = (yyvsp[(1) - (3)].val);
5802 #endif
5803  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5804 
5805  }
5806  break;
5807 
5808  case 46:
5809 
5810 /* Line 1806 of yacc.c */
5811 #line 1262 "ripper.y"
5812  {
5813 #if 0
5814  value_expr((yyvsp[(3) - (3)].val));
5815  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5816 #endif
5817  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5818 
5819  }
5820  break;
5821 
5822  case 47:
5823 
5824 /* Line 1806 of yacc.c */
5825 #line 1271 "ripper.y"
5826  {
5827 #if 0
5828  value_expr((yyvsp[(3) - (3)].val));
5829  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5830 #endif
5831  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5832 
5833  }
5834  break;
5835 
5836  case 49:
5837 
5838 /* Line 1806 of yacc.c */
5839 #line 1284 "ripper.y"
5840  {
5841 #if 0
5842  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5843 #endif
5844  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val));
5845 
5846  }
5847  break;
5848 
5849  case 50:
5850 
5851 /* Line 1806 of yacc.c */
5852 #line 1292 "ripper.y"
5853  {
5854 #if 0
5855  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5856 #endif
5857  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val));
5858 
5859  }
5860  break;
5861 
5862  case 51:
5863 
5864 /* Line 1806 of yacc.c */
5865 #line 1300 "ripper.y"
5866  {
5867 #if 0
5868  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!');
5869 #endif
5870  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val));
5871 
5872  }
5873  break;
5874 
5875  case 52:
5876 
5877 /* Line 1806 of yacc.c */
5878 #line 1308 "ripper.y"
5879  {
5880 #if 0
5881  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
5882 #endif
5883  (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val));
5884 
5885  }
5886  break;
5887 
5888  case 54:
5889 
5890 /* Line 1806 of yacc.c */
5891 #line 1319 "ripper.y"
5892  {
5893 #if 0
5894  value_expr((yyvsp[(1) - (1)].val));
5895  (yyval.val) = (yyvsp[(1) - (1)].val);
5896  if (!(yyval.val)) (yyval.val) = NEW_NIL();
5897 #endif
5898  (yyval.val) = (yyvsp[(1) - (1)].val);
5899 
5900  }
5901  break;
5902 
5903  case 58:
5904 
5905 /* Line 1806 of yacc.c */
5906 #line 1336 "ripper.y"
5907  {
5908 #if 0
5909  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5910 #endif
5911  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
5912  (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
5913 
5914  }
5915  break;
5916 
5917  case 59:
5918 
5919 /* Line 1806 of yacc.c */
5920 #line 1347 "ripper.y"
5921  {
5922  (yyvsp[(1) - (1)].vars) = dyna_push();
5923 #if 0
5924  (yyval.num) = ruby_sourceline;
5925 #endif
5926 
5927  }
5928  break;
5929 
5930  case 60:
5931 
5932 /* Line 1806 of yacc.c */
5933 #line 1357 "ripper.y"
5934  {
5935 #if 0
5936  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
5937  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
5938 #endif
5939  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
5940 
5941  dyna_pop((yyvsp[(1) - (5)].vars));
5942  }
5943  break;
5944 
5945  case 61:
5946 
5947 /* Line 1806 of yacc.c */
5948 #line 1369 "ripper.y"
5949  {
5950 #if 0
5951  (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
5952  nd_set_line((yyval.val), tokline);
5953 #endif
5954 
5955  }
5956  break;
5957 
5958  case 62:
5959 
5960 /* Line 1806 of yacc.c */
5961 #line 1379 "ripper.y"
5962  {
5963 #if 0
5964  (yyval.val) = (yyvsp[(1) - (2)].val);
5965  (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
5966 #endif
5967  (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
5968 
5969  }
5970  break;
5971 
5972  case 63:
5973 
5974 /* Line 1806 of yacc.c */
5975 #line 1388 "ripper.y"
5976  {
5977 #if 0
5978  block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
5979  (yyvsp[(1) - (3)].val)->nd_args = (yyvsp[(2) - (3)].val);
5980  (yyvsp[(3) - (3)].val)->nd_iter = (yyvsp[(1) - (3)].val);
5981  (yyval.val) = (yyvsp[(3) - (3)].val);
5982  fixpos((yyval.val), (yyvsp[(1) - (3)].val));
5983 #endif
5984  (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
5985  (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
5986 
5987  }
5988  break;
5989 
5990  case 64:
5991 
5992 /* Line 1806 of yacc.c */
5993 #line 1401 "ripper.y"
5994  {
5995 #if 0
5996  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5997  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5998 #endif
5999  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6000 
6001  }
6002  break;
6003 
6004  case 65:
6005 
6006 /* Line 1806 of yacc.c */
6007 #line 1410 "ripper.y"
6008  {
6009 #if 0
6010  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
6011  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6012  (yyval.val) = (yyvsp[(5) - (5)].val);
6013  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6014 #endif
6015  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6016  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
6017 
6018  }
6019  break;
6020 
6021  case 66:
6022 
6023 /* Line 1806 of yacc.c */
6024 #line 1422 "ripper.y"
6025  {
6026 #if 0
6027  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6028  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
6029 #endif
6030  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6031 
6032  }
6033  break;
6034 
6035  case 67:
6036 
6037 /* Line 1806 of yacc.c */
6038 #line 1431 "ripper.y"
6039  {
6040 #if 0
6041  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
6042  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6043  (yyval.val) = (yyvsp[(5) - (5)].val);
6044  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6045 #endif
6046  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6047  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
6048 
6049  }
6050  break;
6051 
6052  case 68:
6053 
6054 /* Line 1806 of yacc.c */
6055 #line 1443 "ripper.y"
6056  {
6057 #if 0
6058  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
6059  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
6060 #endif
6061  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
6062 
6063  }
6064  break;
6065 
6066  case 69:
6067 
6068 /* Line 1806 of yacc.c */
6069 #line 1452 "ripper.y"
6070  {
6071 #if 0
6072  (yyval.val) = new_yield((yyvsp[(2) - (2)].val));
6073  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
6074 #endif
6075  (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
6076 
6077  }
6078  break;
6079 
6080  case 70:
6081 
6082 /* Line 1806 of yacc.c */
6083 #line 1461 "ripper.y"
6084  {
6085 #if 0
6086  (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
6087 #endif
6088  (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
6089 
6090  }
6091  break;
6092 
6093  case 71:
6094 
6095 /* Line 1806 of yacc.c */
6096 #line 1469 "ripper.y"
6097  {
6098 #if 0
6099  (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
6100 #endif
6101  (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
6102 
6103  }
6104  break;
6105 
6106  case 72:
6107 
6108 /* Line 1806 of yacc.c */
6109 #line 1477 "ripper.y"
6110  {
6111 #if 0
6112  (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
6113 #endif
6114  (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
6115 
6116  }
6117  break;
6118 
6119  case 74:
6120 
6121 /* Line 1806 of yacc.c */
6122 #line 1488 "ripper.y"
6123  {
6124 #if 0
6125  (yyval.val) = (yyvsp[(2) - (3)].val);
6126 #endif
6127  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6128 
6129  }
6130  break;
6131 
6132  case 76:
6133 
6134 /* Line 1806 of yacc.c */
6135 #line 1499 "ripper.y"
6136  {
6137 #if 0
6138  (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0);
6139 #endif
6140  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6141 
6142  }
6143  break;
6144 
6145  case 77:
6146 
6147 /* Line 1806 of yacc.c */
6148 #line 1509 "ripper.y"
6149  {
6150 #if 0
6151  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
6152 #endif
6153  (yyval.val) = (yyvsp[(1) - (1)].val);
6154 
6155  }
6156  break;
6157 
6158  case 78:
6159 
6160 /* Line 1806 of yacc.c */
6161 #line 1517 "ripper.y"
6162  {
6163 #if 0
6164  (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0);
6165 #endif
6166  (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
6167 
6168  }
6169  break;
6170 
6171  case 79:
6172 
6173 /* Line 1806 of yacc.c */
6174 #line 1525 "ripper.y"
6175  {
6176 #if 0
6177  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6178 #endif
6179  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6180 
6181  }
6182  break;
6183 
6184  case 80:
6185 
6186 /* Line 1806 of yacc.c */
6187 #line 1533 "ripper.y"
6188  {
6189 #if 0
6190  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val)));
6191 #endif
6192  (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6193  (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
6194 
6195  }
6196  break;
6197 
6198  case 81:
6199 
6200 /* Line 1806 of yacc.c */
6201 #line 1542 "ripper.y"
6202  {
6203 #if 0
6204  (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1);
6205 #endif
6206  (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
6207 
6208  }
6209  break;
6210 
6211  case 82:
6212 
6213 /* Line 1806 of yacc.c */
6214 #line 1550 "ripper.y"
6215  {
6216 #if 0
6217  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
6218 #endif
6219  (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
6220  (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6221 
6222  }
6223  break;
6224 
6225  case 83:
6226 
6227 /* Line 1806 of yacc.c */
6228 #line 1559 "ripper.y"
6229  {
6230 #if 0
6231  (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
6232 #endif
6233  (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
6234 
6235  }
6236  break;
6237 
6238  case 84:
6239 
6240 /* Line 1806 of yacc.c */
6241 #line 1567 "ripper.y"
6242  {
6243 #if 0
6244  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
6245 #endif
6246  (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
6247  (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
6248 
6249  }
6250  break;
6251 
6252  case 85:
6253 
6254 /* Line 1806 of yacc.c */
6255 #line 1576 "ripper.y"
6256  {
6257 #if 0
6258  (yyval.val) = NEW_MASGN(0, -1);
6259 #endif
6260  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6261 
6262  }
6263  break;
6264 
6265  case 86:
6266 
6267 /* Line 1806 of yacc.c */
6268 #line 1584 "ripper.y"
6269  {
6270 #if 0
6271  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
6272 #endif
6273  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6274  (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
6275 
6276  }
6277  break;
6278 
6279  case 88:
6280 
6281 /* Line 1806 of yacc.c */
6282 #line 1596 "ripper.y"
6283  {
6284 #if 0
6285  (yyval.val) = (yyvsp[(2) - (3)].val);
6286 #endif
6287  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6288 
6289  }
6290  break;
6291 
6292  case 89:
6293 
6294 /* Line 1806 of yacc.c */
6295 #line 1606 "ripper.y"
6296  {
6297 #if 0
6298  (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
6299 #endif
6300  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
6301 
6302  }
6303  break;
6304 
6305  case 90:
6306 
6307 /* Line 1806 of yacc.c */
6308 #line 1614 "ripper.y"
6309  {
6310 #if 0
6311  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6312 #endif
6313  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6314 
6315  }
6316  break;
6317 
6318  case 91:
6319 
6320 /* Line 1806 of yacc.c */
6321 #line 1624 "ripper.y"
6322  {
6323 #if 0
6324  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
6325 #endif
6326  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
6327 
6328  }
6329  break;
6330 
6331  case 92:
6332 
6333 /* Line 1806 of yacc.c */
6334 #line 1632 "ripper.y"
6335  {
6336 #if 0
6337  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6338 #endif
6339  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6340 
6341  }
6342  break;
6343 
6344  case 93:
6345 
6346 /* Line 1806 of yacc.c */
6347 #line 1642 "ripper.y"
6348  {
6349  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6350  }
6351  break;
6352 
6353  case 94:
6354 
6355 /* Line 1806 of yacc.c */
6356 #line 1646 "ripper.y"
6357  {
6358  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6359  }
6360  break;
6361 
6362  case 95:
6363 
6364 /* Line 1806 of yacc.c */
6365 #line 1650 "ripper.y"
6366  {
6367 #if 0
6368  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6369 #endif
6370  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6371 
6372  }
6373  break;
6374 
6375  case 96:
6376 
6377 /* Line 1806 of yacc.c */
6378 #line 1658 "ripper.y"
6379  {
6380 #if 0
6381  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6382 #endif
6383  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6384 
6385  }
6386  break;
6387 
6388  case 97:
6389 
6390 /* Line 1806 of yacc.c */
6391 #line 1666 "ripper.y"
6392  {
6393 #if 0
6394  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6395 #endif
6396  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6397 
6398  }
6399  break;
6400 
6401  case 98:
6402 
6403 /* Line 1806 of yacc.c */
6404 #line 1674 "ripper.y"
6405  {
6406 #if 0
6407  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6408 #endif
6409  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6410 
6411  }
6412  break;
6413 
6414  case 99:
6415 
6416 /* Line 1806 of yacc.c */
6417 #line 1682 "ripper.y"
6418  {
6419 #if 0
6420  if (in_def || in_single)
6421  yyerror("dynamic constant assignment");
6422  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6423 #endif
6424  if (in_def || in_single)
6425  yyerror("dynamic constant assignment");
6426  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6427 
6428  }
6429  break;
6430 
6431  case 100:
6432 
6433 /* Line 1806 of yacc.c */
6434 #line 1694 "ripper.y"
6435  {
6436 #if 0
6437  if (in_def || in_single)
6438  yyerror("dynamic constant assignment");
6439  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6440 #endif
6441  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6442 
6443  }
6444  break;
6445 
6446  case 101:
6447 
6448 /* Line 1806 of yacc.c */
6449 #line 1704 "ripper.y"
6450  {
6451 #if 0
6452  rb_backref_error((yyvsp[(1) - (1)].val));
6453  (yyval.val) = NEW_BEGIN(0);
6454 #endif
6455  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val));
6456  (yyval.val) = dispatch1(assign_error, (yyval.val));
6457 
6458  }
6459  break;
6460 
6461  case 102:
6462 
6463 /* Line 1806 of yacc.c */
6464 #line 1716 "ripper.y"
6465  {
6466  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6467 #if 0
6468  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6469 #endif
6470  (yyval.val) = dispatch1(var_field, (yyval.val));
6471 
6472  }
6473  break;
6474 
6475  case 103:
6476 
6477 /* Line 1806 of yacc.c */
6478 #line 1725 "ripper.y"
6479  {
6480  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6481 #if 0
6482  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6483 #endif
6484  (yyval.val) = dispatch1(var_field, (yyval.val));
6485 
6486  }
6487  break;
6488 
6489  case 104:
6490 
6491 /* Line 1806 of yacc.c */
6492 #line 1734 "ripper.y"
6493  {
6494 #if 0
6495  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6496 #endif
6497  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6498 
6499  }
6500  break;
6501 
6502  case 105:
6503 
6504 /* Line 1806 of yacc.c */
6505 #line 1742 "ripper.y"
6506  {
6507 #if 0
6508  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6509 #endif
6510  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6511 
6512  }
6513  break;
6514 
6515  case 106:
6516 
6517 /* Line 1806 of yacc.c */
6518 #line 1750 "ripper.y"
6519  {
6520 #if 0
6521  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6522 #endif
6523  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
6524 
6525  }
6526  break;
6527 
6528  case 107:
6529 
6530 /* Line 1806 of yacc.c */
6531 #line 1758 "ripper.y"
6532  {
6533 #if 0
6534  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6535 #endif
6536  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6537 
6538  }
6539  break;
6540 
6541  case 108:
6542 
6543 /* Line 1806 of yacc.c */
6544 #line 1766 "ripper.y"
6545  {
6546 #if 0
6547  if (in_def || in_single)
6548  yyerror("dynamic constant assignment");
6549  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6550 #endif
6551  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6552  if (in_def || in_single) {
6553  (yyval.val) = dispatch1(assign_error, (yyval.val));
6554  }
6555 
6556  }
6557  break;
6558 
6559  case 109:
6560 
6561 /* Line 1806 of yacc.c */
6562 #line 1779 "ripper.y"
6563  {
6564 #if 0
6565  if (in_def || in_single)
6566  yyerror("dynamic constant assignment");
6567  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6568 #endif
6569  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6570  if (in_def || in_single) {
6571  (yyval.val) = dispatch1(assign_error, (yyval.val));
6572  }
6573 
6574  }
6575  break;
6576 
6577  case 110:
6578 
6579 /* Line 1806 of yacc.c */
6580 #line 1792 "ripper.y"
6581  {
6582 #if 0
6583  rb_backref_error((yyvsp[(1) - (1)].val));
6584  (yyval.val) = NEW_BEGIN(0);
6585 #endif
6586  (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val));
6587 
6588  }
6589  break;
6590 
6591  case 111:
6592 
6593 /* Line 1806 of yacc.c */
6594 #line 1803 "ripper.y"
6595  {
6596 #if 0
6597  yyerror("class/module name must be CONSTANT");
6598 #endif
6599  (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
6600 
6601  }
6602  break;
6603 
6604  case 113:
6605 
6606 /* Line 1806 of yacc.c */
6607 #line 1814 "ripper.y"
6608  {
6609 #if 0
6610  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
6611 #endif
6612  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
6613 
6614  }
6615  break;
6616 
6617  case 114:
6618 
6619 /* Line 1806 of yacc.c */
6620 #line 1822 "ripper.y"
6621  {
6622 #if 0
6623  (yyval.val) = NEW_COLON2(0, (yyval.val));
6624 #endif
6625  (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
6626 
6627  }
6628  break;
6629 
6630  case 115:
6631 
6632 /* Line 1806 of yacc.c */
6633 #line 1830 "ripper.y"
6634  {
6635 #if 0
6636  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6637 #endif
6638  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6639 
6640  }
6641  break;
6642 
6643  case 119:
6644 
6645 /* Line 1806 of yacc.c */
6646 #line 1843 "ripper.y"
6647  {
6648  lex_state = EXPR_ENDFN;
6649  (yyval.val) = (yyvsp[(1) - (1)].val);
6650  }
6651  break;
6652 
6653  case 120:
6654 
6655 /* Line 1806 of yacc.c */
6656 #line 1848 "ripper.y"
6657  {
6658  lex_state = EXPR_ENDFN;
6659 #if 0
6660  (yyval.val) = (yyvsp[(1) - (1)].id);
6661 #endif
6662  (yyval.val) = (yyvsp[(1) - (1)].val);
6663 
6664  }
6665  break;
6666 
6667  case 123:
6668 
6669 /* Line 1806 of yacc.c */
6670 #line 1863 "ripper.y"
6671  {
6672 #if 0
6673  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
6674 #endif
6675  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
6676 
6677  }
6678  break;
6679 
6680  case 125:
6681 
6682 /* Line 1806 of yacc.c */
6683 #line 1874 "ripper.y"
6684  {
6685 #if 0
6686  (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
6687 #endif
6688  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
6689 
6690  }
6691  break;
6692 
6693  case 126:
6694 
6695 /* Line 1806 of yacc.c */
6696 #line 1881 "ripper.y"
6697  {lex_state = EXPR_FNAME;}
6698  break;
6699 
6700  case 127:
6701 
6702 /* Line 1806 of yacc.c */
6703 #line 1882 "ripper.y"
6704  {
6705 #if 0
6706  (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
6707 #endif
6708  rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6709 
6710  }
6711  break;
6712 
6713  case 128:
6714 
6715 /* Line 1806 of yacc.c */
6716 #line 1891 "ripper.y"
6717  { ifndef_ripper((yyval.val) = '|'); }
6718  break;
6719 
6720  case 129:
6721 
6722 /* Line 1806 of yacc.c */
6723 #line 1892 "ripper.y"
6724  { ifndef_ripper((yyval.val) = '^'); }
6725  break;
6726 
6727  case 130:
6728 
6729 /* Line 1806 of yacc.c */
6730 #line 1893 "ripper.y"
6731  { ifndef_ripper((yyval.val) = '&'); }
6732  break;
6733 
6734  case 131:
6735 
6736 /* Line 1806 of yacc.c */
6737 #line 1894 "ripper.y"
6738  { ifndef_ripper((yyval.val) = tCMP); }
6739  break;
6740 
6741  case 132:
6742 
6743 /* Line 1806 of yacc.c */
6744 #line 1895 "ripper.y"
6745  { ifndef_ripper((yyval.val) = tEQ); }
6746  break;
6747 
6748  case 133:
6749 
6750 /* Line 1806 of yacc.c */
6751 #line 1896 "ripper.y"
6752  { ifndef_ripper((yyval.val) = tEQQ); }
6753  break;
6754 
6755  case 134:
6756 
6757 /* Line 1806 of yacc.c */
6758 #line 1897 "ripper.y"
6759  { ifndef_ripper((yyval.val) = tMATCH); }
6760  break;
6761 
6762  case 135:
6763 
6764 /* Line 1806 of yacc.c */
6765 #line 1898 "ripper.y"
6766  { ifndef_ripper((yyval.val) = tNMATCH); }
6767  break;
6768 
6769  case 136:
6770 
6771 /* Line 1806 of yacc.c */
6772 #line 1899 "ripper.y"
6773  { ifndef_ripper((yyval.val) = '>'); }
6774  break;
6775 
6776  case 137:
6777 
6778 /* Line 1806 of yacc.c */
6779 #line 1900 "ripper.y"
6780  { ifndef_ripper((yyval.val) = tGEQ); }
6781  break;
6782 
6783  case 138:
6784 
6785 /* Line 1806 of yacc.c */
6786 #line 1901 "ripper.y"
6787  { ifndef_ripper((yyval.val) = '<'); }
6788  break;
6789 
6790  case 139:
6791 
6792 /* Line 1806 of yacc.c */
6793 #line 1902 "ripper.y"
6794  { ifndef_ripper((yyval.val) = tLEQ); }
6795  break;
6796 
6797  case 140:
6798 
6799 /* Line 1806 of yacc.c */
6800 #line 1903 "ripper.y"
6801  { ifndef_ripper((yyval.val) = tNEQ); }
6802  break;
6803 
6804  case 141:
6805 
6806 /* Line 1806 of yacc.c */
6807 #line 1904 "ripper.y"
6808  { ifndef_ripper((yyval.val) = tLSHFT); }
6809  break;
6810 
6811  case 142:
6812 
6813 /* Line 1806 of yacc.c */
6814 #line 1905 "ripper.y"
6815  { ifndef_ripper((yyval.val) = tRSHFT); }
6816  break;
6817 
6818  case 143:
6819 
6820 /* Line 1806 of yacc.c */
6821 #line 1906 "ripper.y"
6822  { ifndef_ripper((yyval.val) = '+'); }
6823  break;
6824 
6825  case 144:
6826 
6827 /* Line 1806 of yacc.c */
6828 #line 1907 "ripper.y"
6829  { ifndef_ripper((yyval.val) = '-'); }
6830  break;
6831 
6832  case 145:
6833 
6834 /* Line 1806 of yacc.c */
6835 #line 1908 "ripper.y"
6836  { ifndef_ripper((yyval.val) = '*'); }
6837  break;
6838 
6839  case 146:
6840 
6841 /* Line 1806 of yacc.c */
6842 #line 1909 "ripper.y"
6843  { ifndef_ripper((yyval.val) = '*'); }
6844  break;
6845 
6846  case 147:
6847 
6848 /* Line 1806 of yacc.c */
6849 #line 1910 "ripper.y"
6850  { ifndef_ripper((yyval.val) = '/'); }
6851  break;
6852 
6853  case 148:
6854 
6855 /* Line 1806 of yacc.c */
6856 #line 1911 "ripper.y"
6857  { ifndef_ripper((yyval.val) = '%'); }
6858  break;
6859 
6860  case 149:
6861 
6862 /* Line 1806 of yacc.c */
6863 #line 1912 "ripper.y"
6864  { ifndef_ripper((yyval.val) = tPOW); }
6865  break;
6866 
6867  case 150:
6868 
6869 /* Line 1806 of yacc.c */
6870 #line 1913 "ripper.y"
6871  { ifndef_ripper((yyval.val) = tDSTAR); }
6872  break;
6873 
6874  case 151:
6875 
6876 /* Line 1806 of yacc.c */
6877 #line 1914 "ripper.y"
6878  { ifndef_ripper((yyval.val) = '!'); }
6879  break;
6880 
6881  case 152:
6882 
6883 /* Line 1806 of yacc.c */
6884 #line 1915 "ripper.y"
6885  { ifndef_ripper((yyval.val) = '~'); }
6886  break;
6887 
6888  case 153:
6889 
6890 /* Line 1806 of yacc.c */
6891 #line 1916 "ripper.y"
6892  { ifndef_ripper((yyval.val) = tUPLUS); }
6893  break;
6894 
6895  case 154:
6896 
6897 /* Line 1806 of yacc.c */
6898 #line 1917 "ripper.y"
6899  { ifndef_ripper((yyval.val) = tUMINUS); }
6900  break;
6901 
6902  case 155:
6903 
6904 /* Line 1806 of yacc.c */
6905 #line 1918 "ripper.y"
6906  { ifndef_ripper((yyval.val) = tAREF); }
6907  break;
6908 
6909  case 156:
6910 
6911 /* Line 1806 of yacc.c */
6912 #line 1919 "ripper.y"
6913  { ifndef_ripper((yyval.val) = tASET); }
6914  break;
6915 
6916  case 157:
6917 
6918 /* Line 1806 of yacc.c */
6919 #line 1920 "ripper.y"
6920  { ifndef_ripper((yyval.val) = '`'); }
6921  break;
6922 
6923  case 199:
6924 
6925 /* Line 1806 of yacc.c */
6926 #line 1938 "ripper.y"
6927  {
6928 #if 0
6929  value_expr((yyvsp[(3) - (3)].val));
6930  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6931 #endif
6932  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6933 
6934  }
6935  break;
6936 
6937  case 200:
6938 
6939 /* Line 1806 of yacc.c */
6940 #line 1947 "ripper.y"
6941  {
6942 #if 0
6943  value_expr((yyvsp[(3) - (5)].val));
6944  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6945  (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6946 #endif
6947  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)));
6948 
6949  }
6950  break;
6951 
6952  case 201:
6953 
6954 /* Line 1806 of yacc.c */
6955 #line 1957 "ripper.y"
6956  {
6957  value_expr((yyvsp[(3) - (3)].val));
6958  (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
6959  }
6960  break;
6961 
6962  case 202:
6963 
6964 /* Line 1806 of yacc.c */
6965 #line 1962 "ripper.y"
6966  {
6967 #if 0
6968  value_expr((yyvsp[(3) - (5)].val));
6969  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6970 #endif
6971  (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
6972 
6973  (yyval.val) = new_op_assign((yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val));
6974  }
6975  break;
6976 
6977  case 203:
6978 
6979 /* Line 1806 of yacc.c */
6980 #line 1972 "ripper.y"
6981  {
6982 #if 0
6983  NODE *args;
6984 
6985  value_expr((yyvsp[(6) - (6)].val));
6986  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
6987  if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
6988  args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6989  }
6990  else {
6991  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6992  }
6993  if ((yyvsp[(5) - (6)].val) == tOROP) {
6994  (yyvsp[(5) - (6)].val) = 0;
6995  }
6996  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
6997  (yyvsp[(5) - (6)].val) = 1;
6998  }
6999  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
7000  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
7001 #endif
7002  (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
7003  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
7004 
7005  }
7006  break;
7007 
7008  case 204:
7009 
7010 /* Line 1806 of yacc.c */
7011 #line 1998 "ripper.y"
7012  {
7013  value_expr((yyvsp[(5) - (5)].val));
7014  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7015  }
7016  break;
7017 
7018  case 205:
7019 
7020 /* Line 1806 of yacc.c */
7021 #line 2003 "ripper.y"
7022  {
7023  value_expr((yyvsp[(5) - (5)].val));
7024  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7025  }
7026  break;
7027 
7028  case 206:
7029 
7030 /* Line 1806 of yacc.c */
7031 #line 2008 "ripper.y"
7032  {
7033  value_expr((yyvsp[(5) - (5)].val));
7034  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7035  }
7036  break;
7037 
7038  case 207:
7039 
7040 /* Line 1806 of yacc.c */
7041 #line 2013 "ripper.y"
7042  {
7043 #if 0
7044  (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
7045  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7046 #endif
7047  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
7048  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7049 
7050  }
7051  break;
7052 
7053  case 208:
7054 
7055 /* Line 1806 of yacc.c */
7056 #line 2023 "ripper.y"
7057  {
7058 #if 0
7059  (yyval.val) = NEW_COLON3((yyvsp[(2) - (4)].val));
7060  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
7061 #endif
7062  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val));
7063  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
7064 
7065  }
7066  break;
7067 
7068  case 209:
7069 
7070 /* Line 1806 of yacc.c */
7071 #line 2033 "ripper.y"
7072  {
7073 #if 0
7074  rb_backref_error((yyvsp[(1) - (3)].val));
7075  (yyval.val) = NEW_BEGIN(0);
7076 #endif
7077  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val));
7078  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
7079  (yyval.val) = dispatch1(assign_error, (yyval.val));
7080 
7081  }
7082  break;
7083 
7084  case 210:
7085 
7086 /* Line 1806 of yacc.c */
7087 #line 2044 "ripper.y"
7088  {
7089 #if 0
7090  value_expr((yyvsp[(1) - (3)].val));
7091  value_expr((yyvsp[(3) - (3)].val));
7092  (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7093  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7094  nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7096  }
7097 #endif
7098  (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7099 
7100  }
7101  break;
7102 
7103  case 211:
7104 
7105 /* Line 1806 of yacc.c */
7106 #line 2058 "ripper.y"
7107  {
7108 #if 0
7109  value_expr((yyvsp[(1) - (3)].val));
7110  value_expr((yyvsp[(3) - (3)].val));
7111  (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7112  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7113  nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7115  }
7116 #endif
7117  (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7118 
7119  }
7120  break;
7121 
7122  case 212:
7123 
7124 /* Line 1806 of yacc.c */
7125 #line 2072 "ripper.y"
7126  {
7127 #if 0
7128  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
7129 #endif
7130  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val));
7131 
7132  }
7133  break;
7134 
7135  case 213:
7136 
7137 /* Line 1806 of yacc.c */
7138 #line 2080 "ripper.y"
7139  {
7140 #if 0
7141  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
7142 #endif
7143  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val));
7144 
7145  }
7146  break;
7147 
7148  case 214:
7149 
7150 /* Line 1806 of yacc.c */
7151 #line 2088 "ripper.y"
7152  {
7153 #if 0
7154  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
7155 #endif
7156  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val));
7157 
7158  }
7159  break;
7160 
7161  case 215:
7162 
7163 /* Line 1806 of yacc.c */
7164 #line 2096 "ripper.y"
7165  {
7166 #if 0
7167  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
7168 #endif
7169  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val));
7170 
7171  }
7172  break;
7173 
7174  case 216:
7175 
7176 /* Line 1806 of yacc.c */
7177 #line 2104 "ripper.y"
7178  {
7179 #if 0
7180  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
7181 #endif
7182  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val));
7183 
7184  }
7185  break;
7186 
7187  case 217:
7188 
7189 /* Line 1806 of yacc.c */
7190 #line 2112 "ripper.y"
7191  {
7192 #if 0
7193  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
7194 #endif
7195  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val));
7196 
7197  }
7198  break;
7199 
7200  case 218:
7201 
7202 /* Line 1806 of yacc.c */
7203 #line 2120 "ripper.y"
7204  {
7205 #if 0
7206  (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
7207 #endif
7208  (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
7209  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
7210 
7211  }
7212  break;
7213 
7214  case 219:
7215 
7216 /* Line 1806 of yacc.c */
7217 #line 2129 "ripper.y"
7218  {
7219 #if 0
7220  (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
7221 #endif
7222  (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
7223  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
7224 
7225  }
7226  break;
7227 
7228  case 220:
7229 
7230 /* Line 1806 of yacc.c */
7231 #line 2138 "ripper.y"
7232  {
7233 #if 0
7234  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
7235 #endif
7236  (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val));
7237 
7238  }
7239  break;
7240 
7241  case 221:
7242 
7243 /* Line 1806 of yacc.c */
7244 #line 2146 "ripper.y"
7245  {
7246 #if 0
7247  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
7248 #endif
7249  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
7250 
7251  }
7252  break;
7253 
7254  case 222:
7255 
7256 /* Line 1806 of yacc.c */
7257 #line 2154 "ripper.y"
7258  {
7259 #if 0
7260  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val));
7261 #endif
7262  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('|'), (yyvsp[(3) - (3)].val));
7263 
7264  }
7265  break;
7266 
7267  case 223:
7268 
7269 /* Line 1806 of yacc.c */
7270 #line 2162 "ripper.y"
7271  {
7272 #if 0
7273  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
7274 #endif
7275  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val));
7276 
7277  }
7278  break;
7279 
7280  case 224:
7281 
7282 /* Line 1806 of yacc.c */
7283 #line 2170 "ripper.y"
7284  {
7285 #if 0
7286  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
7287 #endif
7288  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val));
7289 
7290  }
7291  break;
7292 
7293  case 225:
7294 
7295 /* Line 1806 of yacc.c */
7296 #line 2178 "ripper.y"
7297  {
7298 #if 0
7299  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
7300 #endif
7301  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val));
7302 
7303  }
7304  break;
7305 
7306  case 226:
7307 
7308 /* Line 1806 of yacc.c */
7309 #line 2186 "ripper.y"
7310  {
7311 #if 0
7312  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
7313 #endif
7314  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val));
7315 
7316  }
7317  break;
7318 
7319  case 227:
7320 
7321 /* Line 1806 of yacc.c */
7322 #line 2194 "ripper.y"
7323  {
7324 #if 0
7325  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
7326 #endif
7327  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val));
7328 
7329  }
7330  break;
7331 
7332  case 228:
7333 
7334 /* Line 1806 of yacc.c */
7335 #line 2202 "ripper.y"
7336  {
7337 #if 0
7338  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
7339 #endif
7340  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val));
7341 
7342  }
7343  break;
7344 
7345  case 229:
7346 
7347 /* Line 1806 of yacc.c */
7348 #line 2210 "ripper.y"
7349  {
7350 #if 0
7351  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
7352 #endif
7353  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val));
7354 
7355  }
7356  break;
7357 
7358  case 230:
7359 
7360 /* Line 1806 of yacc.c */
7361 #line 2218 "ripper.y"
7362  {
7363 #if 0
7364  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
7365 #endif
7366  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val));
7367 
7368  }
7369  break;
7370 
7371  case 231:
7372 
7373 /* Line 1806 of yacc.c */
7374 #line 2226 "ripper.y"
7375  {
7376 #if 0
7377  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
7378 #endif
7379  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val));
7380 
7381  }
7382  break;
7383 
7384  case 232:
7385 
7386 /* Line 1806 of yacc.c */
7387 #line 2234 "ripper.y"
7388  {
7389 #if 0
7390  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
7391 #endif
7392  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val));
7393 
7394  }
7395  break;
7396 
7397  case 233:
7398 
7399 /* Line 1806 of yacc.c */
7400 #line 2242 "ripper.y"
7401  {
7402 #if 0
7403  (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7404  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].val)->nd_lit, T_REGEXP)) {
7405  (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val));
7406  }
7407 #endif
7408  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val));
7409 
7410  }
7411  break;
7412 
7413  case 234:
7414 
7415 /* Line 1806 of yacc.c */
7416 #line 2253 "ripper.y"
7417  {
7418 #if 0
7419  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val));
7420 #endif
7421  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!~"), (yyvsp[(3) - (3)].val));
7422 
7423  }
7424  break;
7425 
7426  case 235:
7427 
7428 /* Line 1806 of yacc.c */
7429 #line 2261 "ripper.y"
7430  {
7431 #if 0
7432  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
7433 #endif
7434  (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val));
7435 
7436  }
7437  break;
7438 
7439  case 236:
7440 
7441 /* Line 1806 of yacc.c */
7442 #line 2269 "ripper.y"
7443  {
7444 #if 0
7445  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
7446 #endif
7447  (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val));
7448 
7449  }
7450  break;
7451 
7452  case 237:
7453 
7454 /* Line 1806 of yacc.c */
7455 #line 2277 "ripper.y"
7456  {
7457 #if 0
7458  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val));
7459 #endif
7460  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<<"), (yyvsp[(3) - (3)].val));
7461 
7462  }
7463  break;
7464 
7465  case 238:
7466 
7467 /* Line 1806 of yacc.c */
7468 #line 2285 "ripper.y"
7469  {
7470 #if 0
7471  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val));
7472 #endif
7473  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">>"), (yyvsp[(3) - (3)].val));
7474 
7475  }
7476  break;
7477 
7478  case 239:
7479 
7480 /* Line 1806 of yacc.c */
7481 #line 2293 "ripper.y"
7482  {
7483 #if 0
7484  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7485 #endif
7486  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val));
7487 
7488  }
7489  break;
7490 
7491  case 240:
7492 
7493 /* Line 1806 of yacc.c */
7494 #line 2301 "ripper.y"
7495  {
7496 #if 0
7497  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7498 #endif
7499  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val));
7500 
7501  }
7502  break;
7503 
7504  case 241:
7505 
7506 /* Line 1806 of yacc.c */
7507 #line 2308 "ripper.y"
7508  {in_defined = 1;}
7509  break;
7510 
7511  case 242:
7512 
7513 /* Line 1806 of yacc.c */
7514 #line 2309 "ripper.y"
7515  {
7516 #if 0
7517  in_defined = 0;
7518  (yyval.val) = NEW_DEFINED((yyvsp[(4) - (4)].val));
7519 #endif
7520  in_defined = 0;
7521  (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val));
7522 
7523  }
7524  break;
7525 
7526  case 243:
7527 
7528 /* Line 1806 of yacc.c */
7529 #line 2319 "ripper.y"
7530  {
7531 #if 0
7532  value_expr((yyvsp[(1) - (6)].val));
7533  (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7534  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
7535 #endif
7536  (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7537 
7538  }
7539  break;
7540 
7541  case 244:
7542 
7543 /* Line 1806 of yacc.c */
7544 #line 2329 "ripper.y"
7545  {
7546  (yyval.val) = (yyvsp[(1) - (1)].val);
7547  }
7548  break;
7549 
7550  case 245:
7551 
7552 /* Line 1806 of yacc.c */
7553 #line 2335 "ripper.y"
7554  {
7555 #if 0
7556  value_expr((yyvsp[(1) - (1)].val));
7557  (yyval.val) = (yyvsp[(1) - (1)].val);
7558  if (!(yyval.val)) (yyval.val) = NEW_NIL();
7559 #endif
7560  (yyval.val) = (yyvsp[(1) - (1)].val);
7561 
7562  }
7563  break;
7564 
7565  case 247:
7566 
7567 /* Line 1806 of yacc.c */
7568 #line 2348 "ripper.y"
7569  {
7570  (yyval.val) = (yyvsp[(1) - (2)].val);
7571  }
7572  break;
7573 
7574  case 248:
7575 
7576 /* Line 1806 of yacc.c */
7577 #line 2352 "ripper.y"
7578  {
7579 #if 0
7580  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7581 #endif
7582  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7583 
7584  }
7585  break;
7586 
7587  case 249:
7588 
7589 /* Line 1806 of yacc.c */
7590 #line 2360 "ripper.y"
7591  {
7592 #if 0
7593  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7594 #endif
7595  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7596 
7597  }
7598  break;
7599 
7600  case 250:
7601 
7602 /* Line 1806 of yacc.c */
7603 #line 2370 "ripper.y"
7604  {
7605 #if 0
7606  (yyval.val) = (yyvsp[(2) - (3)].val);
7607 #endif
7608  (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
7609 
7610  }
7611  break;
7612 
7613  case 255:
7614 
7615 /* Line 1806 of yacc.c */
7616 #line 2386 "ripper.y"
7617  {
7618  (yyval.val) = (yyvsp[(1) - (2)].val);
7619  }
7620  break;
7621 
7622  case 256:
7623 
7624 /* Line 1806 of yacc.c */
7625 #line 2390 "ripper.y"
7626  {
7627 #if 0
7628  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7629 #endif
7630  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7631 
7632  }
7633  break;
7634 
7635  case 257:
7636 
7637 /* Line 1806 of yacc.c */
7638 #line 2398 "ripper.y"
7639  {
7640 #if 0
7641  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7642 #endif
7643  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7644 
7645  }
7646  break;
7647 
7648  case 258:
7649 
7650 /* Line 1806 of yacc.c */
7651 #line 2408 "ripper.y"
7652  {
7653 #if 0
7654  value_expr((yyvsp[(1) - (1)].val));
7655  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7656 #endif
7657  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7658 
7659  }
7660  break;
7661 
7662  case 259:
7663 
7664 /* Line 1806 of yacc.c */
7665 #line 2417 "ripper.y"
7666  {
7667 #if 0
7668  (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7669 #endif
7670  (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7671 
7672  }
7673  break;
7674 
7675  case 260:
7676 
7677 /* Line 1806 of yacc.c */
7678 #line 2425 "ripper.y"
7679  {
7680 #if 0
7681  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7682  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
7683 #endif
7684  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7685  (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
7686 
7687  }
7688  break;
7689 
7690  case 261:
7691 
7692 /* Line 1806 of yacc.c */
7693 #line 2435 "ripper.y"
7694  {
7695 #if 0
7696  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7697  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
7698 #endif
7699  (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
7700 
7701  }
7702  break;
7703 
7704  case 262:
7705 
7706 /* Line 1806 of yacc.c */
7707 #line 2446 "ripper.y"
7708  {
7709  (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
7710  }
7711  break;
7712 
7713  case 263:
7714 
7715 /* Line 1806 of yacc.c */
7716 #line 2452 "ripper.y"
7717  {
7718  (yyval.val) = cmdarg_stack;
7719  CMDARG_PUSH(1);
7720  }
7721  break;
7722 
7723  case 264:
7724 
7725 /* Line 1806 of yacc.c */
7726 #line 2457 "ripper.y"
7727  {
7728  /* CMDARG_POP() */
7729  cmdarg_stack = (yyvsp[(1) - (2)].val);
7730  (yyval.val) = (yyvsp[(2) - (2)].val);
7731  }
7732  break;
7733 
7734  case 265:
7735 
7736 /* Line 1806 of yacc.c */
7737 #line 2465 "ripper.y"
7738  {
7739 #if 0
7740  (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
7741 #endif
7742  (yyval.val) = (yyvsp[(2) - (2)].val);
7743 
7744  }
7745  break;
7746 
7747  case 266:
7748 
7749 /* Line 1806 of yacc.c */
7750 #line 2475 "ripper.y"
7751  {
7752  (yyval.val) = (yyvsp[(2) - (2)].val);
7753  }
7754  break;
7755 
7756  case 267:
7757 
7758 /* Line 1806 of yacc.c */
7759 #line 2479 "ripper.y"
7760  {
7761  (yyval.val) = 0;
7762  }
7763  break;
7764 
7765  case 268:
7766 
7767 /* Line 1806 of yacc.c */
7768 #line 2485 "ripper.y"
7769  {
7770 #if 0
7771  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7772 #endif
7773  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7774 
7775  }
7776  break;
7777 
7778  case 269:
7779 
7780 /* Line 1806 of yacc.c */
7781 #line 2493 "ripper.y"
7782  {
7783 #if 0
7784  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7785 #endif
7786  (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
7787 
7788  }
7789  break;
7790 
7791  case 270:
7792 
7793 /* Line 1806 of yacc.c */
7794 #line 2501 "ripper.y"
7795  {
7796 #if 0
7797  NODE *n1;
7798  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7799  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7800  }
7801  else {
7802  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7803  }
7804 #endif
7805  (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7806 
7807  }
7808  break;
7809 
7810  case 271:
7811 
7812 /* Line 1806 of yacc.c */
7813 #line 2515 "ripper.y"
7814  {
7815 #if 0
7816  NODE *n1;
7817  if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7818  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7819  }
7820  else {
7821  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7822  }
7823 #endif
7824  (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7825 
7826  }
7827  break;
7828 
7829  case 272:
7830 
7831 /* Line 1806 of yacc.c */
7832 #line 2531 "ripper.y"
7833  {
7834 #if 0
7835  NODE *n1;
7836  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7837  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7838  }
7839  else {
7840  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7841  }
7842 #endif
7843  (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
7844 
7845  }
7846  break;
7847 
7848  case 273:
7849 
7850 /* Line 1806 of yacc.c */
7851 #line 2545 "ripper.y"
7852  {
7853 #if 0
7854  NODE *n1;
7855  if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
7856  (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7857  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7858  }
7859  else {
7860  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7861  }
7862 #endif
7863  (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
7864 
7865  }
7866  break;
7867 
7868  case 274:
7869 
7870 /* Line 1806 of yacc.c */
7871 #line 2560 "ripper.y"
7872  {
7873 #if 0
7874  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7875 #endif
7876  (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
7877 
7878  }
7879  break;
7880 
7881  case 285:
7882 
7883 /* Line 1806 of yacc.c */
7884 #line 2580 "ripper.y"
7885  {
7886 #if 0
7887  (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
7888 #endif
7889  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
7890 
7891  }
7892  break;
7893 
7894  case 286:
7895 
7896 /* Line 1806 of yacc.c */
7897 #line 2588 "ripper.y"
7898  {
7899  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7900  cmdarg_stack = 0;
7901 #if 0
7902  (yyval.num) = ruby_sourceline;
7903 #endif
7904 
7905  }
7906  break;
7907 
7908  case 287:
7909 
7910 /* Line 1806 of yacc.c */
7911 #line 2598 "ripper.y"
7912  {
7913  cmdarg_stack = (yyvsp[(1) - (4)].val);
7914 #if 0
7915  if ((yyvsp[(3) - (4)].val) == NULL) {
7916  (yyval.val) = NEW_NIL();
7917  }
7918  else {
7919  if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE ||
7920  nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE)
7921  nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
7922  (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val));
7923  }
7924  nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
7925 #endif
7926  (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
7927 
7928  }
7929  break;
7930 
7931  case 288:
7932 
7933 /* Line 1806 of yacc.c */
7934 #line 2615 "ripper.y"
7935  {lex_state = EXPR_ENDARG;}
7936  break;
7937 
7938  case 289:
7939 
7940 /* Line 1806 of yacc.c */
7941 #line 2616 "ripper.y"
7942  {
7943 #if 0
7944  (yyval.val) = 0;
7945 #endif
7946  (yyval.val) = dispatch1(paren, 0);
7947 
7948  }
7949  break;
7950 
7951  case 290:
7952 
7953 /* Line 1806 of yacc.c */
7954 #line 2623 "ripper.y"
7955  {lex_state = EXPR_ENDARG;}
7956  break;
7957 
7958  case 291:
7959 
7960 /* Line 1806 of yacc.c */
7961 #line 2624 "ripper.y"
7962  {
7963 #if 0
7964  (yyval.val) = (yyvsp[(2) - (4)].val);
7965 #endif
7966  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
7967 
7968  }
7969  break;
7970 
7971  case 292:
7972 
7973 /* Line 1806 of yacc.c */
7974 #line 2632 "ripper.y"
7975  {
7976 #if 0
7977  (yyval.val) = (yyvsp[(2) - (3)].val);
7978 #endif
7979  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
7980 
7981  }
7982  break;
7983 
7984  case 293:
7985 
7986 /* Line 1806 of yacc.c */
7987 #line 2640 "ripper.y"
7988  {
7989 #if 0
7990  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7991 #endif
7992  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7993 
7994  }
7995  break;
7996 
7997  case 294:
7998 
7999 /* Line 1806 of yacc.c */
8000 #line 2648 "ripper.y"
8001  {
8002 #if 0
8003  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
8004 #endif
8005  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
8006 
8007  }
8008  break;
8009 
8010  case 295:
8011 
8012 /* Line 1806 of yacc.c */
8013 #line 2656 "ripper.y"
8014  {
8015 #if 0
8016  if ((yyvsp[(2) - (3)].val) == 0) {
8017  (yyval.val) = NEW_ZARRAY(); /* zero length array*/
8018  }
8019  else {
8020  (yyval.val) = (yyvsp[(2) - (3)].val);
8021  }
8022 #endif
8023  (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
8024 
8025  }
8026  break;
8027 
8028  case 296:
8029 
8030 /* Line 1806 of yacc.c */
8031 #line 2669 "ripper.y"
8032  {
8033 #if 0
8034  (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
8035 #endif
8036  (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
8037 
8038  }
8039  break;
8040 
8041  case 297:
8042 
8043 /* Line 1806 of yacc.c */
8044 #line 2677 "ripper.y"
8045  {
8046 #if 0
8047  (yyval.val) = NEW_RETURN(0);
8048 #endif
8049  (yyval.val) = dispatch0(return0);
8050 
8051  }
8052  break;
8053 
8054  case 298:
8055 
8056 /* Line 1806 of yacc.c */
8057 #line 2685 "ripper.y"
8058  {
8059 #if 0
8060  (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
8061 #endif
8062  (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
8063 
8064  }
8065  break;
8066 
8067  case 299:
8068 
8069 /* Line 1806 of yacc.c */
8070 #line 2693 "ripper.y"
8071  {
8072 #if 0
8073  (yyval.val) = NEW_YIELD(0);
8074 #endif
8075  (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
8076 
8077  }
8078  break;
8079 
8080  case 300:
8081 
8082 /* Line 1806 of yacc.c */
8083 #line 2701 "ripper.y"
8084  {
8085 #if 0
8086  (yyval.val) = NEW_YIELD(0);
8087 #endif
8088  (yyval.val) = dispatch0(yield0);
8089 
8090  }
8091  break;
8092 
8093  case 301:
8094 
8095 /* Line 1806 of yacc.c */
8096 #line 2708 "ripper.y"
8097  {in_defined = 1;}
8098  break;
8099 
8100  case 302:
8101 
8102 /* Line 1806 of yacc.c */
8103 #line 2709 "ripper.y"
8104  {
8105 #if 0
8106  in_defined = 0;
8107  (yyval.val) = NEW_DEFINED((yyvsp[(5) - (6)].val));
8108 #endif
8109  in_defined = 0;
8110  (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val));
8111 
8112  }
8113  break;
8114 
8115  case 303:
8116 
8117 /* Line 1806 of yacc.c */
8118 #line 2719 "ripper.y"
8119  {
8120 #if 0
8121  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
8122 #endif
8123  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val));
8124 
8125  }
8126  break;
8127 
8128  case 304:
8129 
8130 /* Line 1806 of yacc.c */
8131 #line 2727 "ripper.y"
8132  {
8133 #if 0
8134  (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
8135 #endif
8136  (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil);
8137 
8138  }
8139  break;
8140 
8141  case 305:
8142 
8143 /* Line 1806 of yacc.c */
8144 #line 2735 "ripper.y"
8145  {
8146 #if 0
8147  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
8148  (yyval.val) = (yyvsp[(2) - (2)].val);
8149 #endif
8150  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
8151  (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
8152 
8153  }
8154  break;
8155 
8156  case 307:
8157 
8158 /* Line 1806 of yacc.c */
8159 #line 2746 "ripper.y"
8160  {
8161 #if 0
8162  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
8163  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
8164  (yyval.val) = (yyvsp[(2) - (2)].val);
8165 #endif
8166  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
8167 
8168  }
8169  break;
8170 
8171  case 308:
8172 
8173 /* Line 1806 of yacc.c */
8174 #line 2756 "ripper.y"
8175  {
8176  (yyval.val) = (yyvsp[(2) - (2)].val);
8177  }
8178  break;
8179 
8180  case 309:
8181 
8182 /* Line 1806 of yacc.c */
8183 #line 2763 "ripper.y"
8184  {
8185 #if 0
8186  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8187  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8188 #endif
8189  (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8190 
8191  }
8192  break;
8193 
8194  case 310:
8195 
8196 /* Line 1806 of yacc.c */
8197 #line 2775 "ripper.y"
8198  {
8199 #if 0
8200  (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8201  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8202 #endif
8203  (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8204 
8205  }
8206  break;
8207 
8208  case 311:
8209 
8210 /* Line 1806 of yacc.c */
8211 #line 2783 "ripper.y"
8212  {COND_PUSH(1);}
8213  break;
8214 
8215  case 312:
8216 
8217 /* Line 1806 of yacc.c */
8218 #line 2783 "ripper.y"
8219  {COND_POP();}
8220  break;
8221 
8222  case 313:
8223 
8224 /* Line 1806 of yacc.c */
8225 #line 2786 "ripper.y"
8226  {
8227 #if 0
8228  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8229  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8230 #endif
8231  (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8232 
8233  }
8234  break;
8235 
8236  case 314:
8237 
8238 /* Line 1806 of yacc.c */
8239 #line 2794 "ripper.y"
8240  {COND_PUSH(1);}
8241  break;
8242 
8243  case 315:
8244 
8245 /* Line 1806 of yacc.c */
8246 #line 2794 "ripper.y"
8247  {COND_POP();}
8248  break;
8249 
8250  case 316:
8251 
8252 /* Line 1806 of yacc.c */
8253 #line 2797 "ripper.y"
8254  {
8255 #if 0
8256  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8257  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8258 #endif
8259  (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8260 
8261  }
8262  break;
8263 
8264  case 317:
8265 
8266 /* Line 1806 of yacc.c */
8267 #line 2808 "ripper.y"
8268  {
8269 #if 0
8270  (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8271  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8272 #endif
8273  (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8274 
8275  }
8276  break;
8277 
8278  case 318:
8279 
8280 /* Line 1806 of yacc.c */
8281 #line 2817 "ripper.y"
8282  {
8283 #if 0
8284  (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
8285 #endif
8286  (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
8287 
8288  }
8289  break;
8290 
8291  case 319:
8292 
8293 /* Line 1806 of yacc.c */
8294 #line 2825 "ripper.y"
8295  {COND_PUSH(1);}
8296  break;
8297 
8298  case 320:
8299 
8300 /* Line 1806 of yacc.c */
8301 #line 2827 "ripper.y"
8302  {COND_POP();}
8303  break;
8304 
8305  case 321:
8306 
8307 /* Line 1806 of yacc.c */
8308 #line 2830 "ripper.y"
8309  {
8310 #if 0
8311  /*
8312  * for a, b, c in e
8313  * #=>
8314  * e.each{|*x| a, b, c = x
8315  *
8316  * for a in e
8317  * #=>
8318  * e.each{|x| a, = x}
8319  */
8320  ID id = internal_id();
8321  ID *tbl = ALLOC_N(ID, 2);
8322  NODE *m = NEW_ARGS_AUX(0, 0);
8323  NODE *args, *scope;
8324 
8325  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) {
8326  /* if args.length == 1 && args[0].kind_of?(Array)
8327  * args = args[0]
8328  * end
8329  */
8330  NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
8331  NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
8332  m->nd_next = block_append(
8333  NEW_IF(
8335  NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
8336  idEq, one),
8337  NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero),
8338  rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
8339  0),
8340  NEW_DASGN_CURR(id,
8341  NEW_CALL(NEW_DVAR(id), idAREF, zero)),
8342  0),
8343  node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id)));
8344 
8345  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8346  }
8347  else {
8348  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN ||
8349  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN ||
8350  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) {
8351  (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id);
8352  m->nd_plen = 1;
8353  m->nd_next = (yyvsp[(2) - (9)].val);
8354  args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
8355  }
8356  else {
8357  m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id));
8358  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8359  }
8360  }
8361  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
8362  tbl[0] = 1; tbl[1] = id;
8363  (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope);
8364  fixpos((yyval.val), (yyvsp[(2) - (9)].val));
8365 #endif
8366  (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
8367 
8368  }
8369  break;
8370 
8371  case 322:
8372 
8373 /* Line 1806 of yacc.c */
8374 #line 2891 "ripper.y"
8375  {
8376  if (in_def || in_single)
8377  yyerror("class definition in method body");
8378  local_push(0);
8379 #if 0
8380  (yyval.num) = ruby_sourceline;
8381 #endif
8382 
8383  }
8384  break;
8385 
8386  case 323:
8387 
8388 /* Line 1806 of yacc.c */
8389 #line 2902 "ripper.y"
8390  {
8391 #if 0
8392  (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
8393  nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
8394 #endif
8395  (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
8396 
8397  local_pop();
8398  }
8399  break;
8400 
8401  case 324:
8402 
8403 /* Line 1806 of yacc.c */
8404 #line 2912 "ripper.y"
8405  {
8406  (yyval.num) = in_def;
8407  in_def = 0;
8408  }
8409  break;
8410 
8411  case 325:
8412 
8413 /* Line 1806 of yacc.c */
8414 #line 2917 "ripper.y"
8415  {
8416  (yyval.num) = in_single;
8417  in_single = 0;
8418  local_push(0);
8419  }
8420  break;
8421 
8422  case 326:
8423 
8424 /* Line 1806 of yacc.c */
8425 #line 2924 "ripper.y"
8426  {
8427 #if 0
8428  (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8429  fixpos((yyval.val), (yyvsp[(3) - (8)].val));
8430 #endif
8431  (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8432 
8433  local_pop();
8434  in_def = (yyvsp[(4) - (8)].num);
8435  in_single = (yyvsp[(6) - (8)].num);
8436  }
8437  break;
8438 
8439  case 327:
8440 
8441 /* Line 1806 of yacc.c */
8442 #line 2936 "ripper.y"
8443  {
8444  if (in_def || in_single)
8445  yyerror("module definition in method body");
8446  local_push(0);
8447 #if 0
8448  (yyval.num) = ruby_sourceline;
8449 #endif
8450 
8451  }
8452  break;
8453 
8454  case 328:
8455 
8456 /* Line 1806 of yacc.c */
8457 #line 2947 "ripper.y"
8458  {
8459 #if 0
8460  (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8461  nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
8462 #endif
8463  (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8464 
8465  local_pop();
8466  }
8467  break;
8468 
8469  case 329:
8470 
8471 /* Line 1806 of yacc.c */
8472 #line 2957 "ripper.y"
8473  {
8474  (yyval.id) = cur_mid;
8475  cur_mid = (yyvsp[(2) - (2)].val);
8476  in_def++;
8477  local_push(0);
8478  }
8479  break;
8480 
8481  case 330:
8482 
8483 /* Line 1806 of yacc.c */
8484 #line 2966 "ripper.y"
8485  {
8486 #if 0
8487  NODE *body = remove_begin((yyvsp[(5) - (6)].val));
8488  reduce_nodes(&body);
8489  (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE);
8490  nd_set_line((yyval.val), (yyvsp[(1) - (6)].num));
8491 #endif
8492  (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8493 
8494  local_pop();
8495  in_def--;
8496  cur_mid = (yyvsp[(3) - (6)].id);
8497  }
8498  break;
8499 
8500  case 331:
8501 
8502 /* Line 1806 of yacc.c */
8503 #line 2979 "ripper.y"
8504  {lex_state = EXPR_FNAME;}
8505  break;
8506 
8507  case 332:
8508 
8509 /* Line 1806 of yacc.c */
8510 #line 2980 "ripper.y"
8511  {
8512  in_single++;
8513  lex_state = EXPR_ENDFN; /* force for args */
8514  local_push(0);
8515  }
8516  break;
8517 
8518  case 333:
8519 
8520 /* Line 1806 of yacc.c */
8521 #line 2988 "ripper.y"
8522  {
8523 #if 0
8524  NODE *body = remove_begin((yyvsp[(8) - (9)].val));
8525  reduce_nodes(&body);
8526  (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
8527  nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
8528 #endif
8529  (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
8530 
8531  local_pop();
8532  in_single--;
8533  }
8534  break;
8535 
8536  case 334:
8537 
8538 /* Line 1806 of yacc.c */
8539 #line 3001 "ripper.y"
8540  {
8541 #if 0
8542  (yyval.val) = NEW_BREAK(0);
8543 #endif
8544  (yyval.val) = dispatch1(break, arg_new());
8545 
8546  }
8547  break;
8548 
8549  case 335:
8550 
8551 /* Line 1806 of yacc.c */
8552 #line 3009 "ripper.y"
8553  {
8554 #if 0
8555  (yyval.val) = NEW_NEXT(0);
8556 #endif
8557  (yyval.val) = dispatch1(next, arg_new());
8558 
8559  }
8560  break;
8561 
8562  case 336:
8563 
8564 /* Line 1806 of yacc.c */
8565 #line 3017 "ripper.y"
8566  {
8567 #if 0
8568  (yyval.val) = NEW_REDO();
8569 #endif
8570  (yyval.val) = dispatch0(redo);
8571 
8572  }
8573  break;
8574 
8575  case 337:
8576 
8577 /* Line 1806 of yacc.c */
8578 #line 3025 "ripper.y"
8579  {
8580 #if 0
8581  (yyval.val) = NEW_RETRY();
8582 #endif
8583  (yyval.val) = dispatch0(retry);
8584 
8585  }
8586  break;
8587 
8588  case 338:
8589 
8590 /* Line 1806 of yacc.c */
8591 #line 3035 "ripper.y"
8592  {
8593 #if 0
8594  value_expr((yyvsp[(1) - (1)].val));
8595  (yyval.val) = (yyvsp[(1) - (1)].val);
8596  if (!(yyval.val)) (yyval.val) = NEW_NIL();
8597 #endif
8598  (yyval.val) = (yyvsp[(1) - (1)].val);
8599 
8600  }
8601  break;
8602 
8603  case 339:
8604 
8605 /* Line 1806 of yacc.c */
8606 #line 3047 "ripper.y"
8607  {
8608  token_info_push("begin");
8609  }
8610  break;
8611 
8612  case 340:
8613 
8614 /* Line 1806 of yacc.c */
8615 #line 3053 "ripper.y"
8616  {
8617  token_info_push("if");
8618  }
8619  break;
8620 
8621  case 341:
8622 
8623 /* Line 1806 of yacc.c */
8624 #line 3059 "ripper.y"
8625  {
8626  token_info_push("unless");
8627  }
8628  break;
8629 
8630  case 342:
8631 
8632 /* Line 1806 of yacc.c */
8633 #line 3065 "ripper.y"
8634  {
8635  token_info_push("while");
8636  }
8637  break;
8638 
8639  case 343:
8640 
8641 /* Line 1806 of yacc.c */
8642 #line 3071 "ripper.y"
8643  {
8644  token_info_push("until");
8645  }
8646  break;
8647 
8648  case 344:
8649 
8650 /* Line 1806 of yacc.c */
8651 #line 3077 "ripper.y"
8652  {
8653  token_info_push("case");
8654  }
8655  break;
8656 
8657  case 345:
8658 
8659 /* Line 1806 of yacc.c */
8660 #line 3083 "ripper.y"
8661  {
8662  token_info_push("for");
8663  }
8664  break;
8665 
8666  case 346:
8667 
8668 /* Line 1806 of yacc.c */
8669 #line 3089 "ripper.y"
8670  {
8671  token_info_push("class");
8672  }
8673  break;
8674 
8675  case 347:
8676 
8677 /* Line 1806 of yacc.c */
8678 #line 3095 "ripper.y"
8679  {
8680  token_info_push("module");
8681  }
8682  break;
8683 
8684  case 348:
8685 
8686 /* Line 1806 of yacc.c */
8687 #line 3101 "ripper.y"
8688  {
8689  token_info_push("def");
8690 #if 0
8691  (yyval.num) = ruby_sourceline;
8692 #endif
8693 
8694  }
8695  break;
8696 
8697  case 349:
8698 
8699 /* Line 1806 of yacc.c */
8700 #line 3111 "ripper.y"
8701  {
8702  token_info_pop("end");
8703  }
8704  break;
8705 
8706  case 350:
8707 
8708 /* Line 1806 of yacc.c */
8709 #line 3119 "ripper.y"
8710  { (yyval.val) = Qnil; }
8711  break;
8712 
8713  case 352:
8714 
8715 /* Line 1806 of yacc.c */
8716 #line 3125 "ripper.y"
8717  { (yyval.val) = (yyvsp[(2) - (2)].val); }
8718  break;
8719 
8720  case 353:
8721 
8722 /* Line 1806 of yacc.c */
8723 #line 3132 "ripper.y"
8724  { (yyval.val) = Qnil; }
8725  break;
8726 
8727  case 356:
8728 
8729 /* Line 1806 of yacc.c */
8730 #line 3141 "ripper.y"
8731  {
8732 #if 0
8733  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
8734  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8735 #endif
8736  (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
8737 
8738  }
8739  break;
8740 
8741  case 358:
8742 
8743 /* Line 1806 of yacc.c */
8744 #line 3153 "ripper.y"
8745  {
8746 #if 0
8747  (yyval.val) = (yyvsp[(2) - (2)].val);
8748 #endif
8749  (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
8750 
8751  }
8752  break;
8753 
8754  case 361:
8755 
8756 /* Line 1806 of yacc.c */
8757 #line 3167 "ripper.y"
8758  {
8759  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
8760 #if 0
8761 #endif
8762  (yyval.val) = dispatch1(mlhs_paren, (yyval.val));
8763 
8764  }
8765  break;
8766 
8767  case 362:
8768 
8769 /* Line 1806 of yacc.c */
8770 #line 3175 "ripper.y"
8771  {
8772 #if 0
8773  (yyval.val) = (yyvsp[(2) - (3)].val);
8774 #endif
8775  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
8776 
8777  }
8778  break;
8779 
8780  case 363:
8781 
8782 /* Line 1806 of yacc.c */
8783 #line 3185 "ripper.y"
8784  {
8785 #if 0
8786  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
8787 #endif
8788  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
8789 
8790  }
8791  break;
8792 
8793  case 364:
8794 
8795 /* Line 1806 of yacc.c */
8796 #line 3193 "ripper.y"
8797  {
8798 #if 0
8799  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8800 #endif
8801  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8802 
8803  }
8804  break;
8805 
8806  case 365:
8807 
8808 /* Line 1806 of yacc.c */
8809 #line 3203 "ripper.y"
8810  {
8811 #if 0
8812  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
8813 #endif
8814  (yyval.val) = (yyvsp[(1) - (1)].val);
8815 
8816  }
8817  break;
8818 
8819  case 366:
8820 
8821 /* Line 1806 of yacc.c */
8822 #line 3211 "ripper.y"
8823  {
8824  (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
8825 #if 0
8826  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val));
8827 #endif
8828  (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
8829 
8830  }
8831  break;
8832 
8833  case 367:
8834 
8835 /* Line 1806 of yacc.c */
8836 #line 3220 "ripper.y"
8837  {
8838  (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
8839 #if 0
8840  (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val)));
8841 #endif
8842  (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
8843 
8844  }
8845  break;
8846 
8847  case 368:
8848 
8849 /* Line 1806 of yacc.c */
8850 #line 3229 "ripper.y"
8851  {
8852 #if 0
8853  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
8854 #endif
8855  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
8856 
8857  }
8858  break;
8859 
8860  case 369:
8861 
8862 /* Line 1806 of yacc.c */
8863 #line 3237 "ripper.y"
8864  {
8865 #if 0
8866  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
8867 #endif
8868  (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
8869 
8870  }
8871  break;
8872 
8873  case 370:
8874 
8875 /* Line 1806 of yacc.c */
8876 #line 3245 "ripper.y"
8877  {
8878  (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
8879 #if 0
8880  (yyval.val) = NEW_MASGN(0, (yyval.val));
8881 #endif
8882  (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
8883 
8884  }
8885  break;
8886 
8887  case 371:
8888 
8889 /* Line 1806 of yacc.c */
8890 #line 3254 "ripper.y"
8891  {
8892  (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
8893 #if 0
8894  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val)));
8895 #endif
8896  #if 0
8897  TODO: Check me
8898  #endif
8899  (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val));
8900 
8901  }
8902  break;
8903 
8904  case 372:
8905 
8906 /* Line 1806 of yacc.c */
8907 #line 3266 "ripper.y"
8908  {
8909 #if 0
8910  (yyval.val) = NEW_MASGN(0, -1);
8911 #endif
8912  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8913 
8914  }
8915  break;
8916 
8917  case 373:
8918 
8919 /* Line 1806 of yacc.c */
8920 #line 3274 "ripper.y"
8921  {
8922 #if 0
8923  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
8924 #endif
8925  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8926 
8927  }
8928  break;
8929 
8930  case 374:
8931 
8932 /* Line 1806 of yacc.c */
8933 #line 3285 "ripper.y"
8934  {
8935  (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
8936  }
8937  break;
8938 
8939  case 375:
8940 
8941 /* Line 1806 of yacc.c */
8942 #line 3289 "ripper.y"
8943  {
8944  (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
8945  }
8946  break;
8947 
8948  case 376:
8949 
8950 /* Line 1806 of yacc.c */
8951 #line 3293 "ripper.y"
8952  {
8953  (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
8954  }
8955  break;
8956 
8957  case 377:
8958 
8959 /* Line 1806 of yacc.c */
8960 #line 3297 "ripper.y"
8961  {
8962  (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
8963  }
8964  break;
8965 
8966  case 378:
8967 
8968 /* Line 1806 of yacc.c */
8969 #line 3303 "ripper.y"
8970  {
8971  (yyval.val) = (yyvsp[(2) - (2)].val);
8972  }
8973  break;
8974 
8975  case 379:
8976 
8977 /* Line 1806 of yacc.c */
8978 #line 3307 "ripper.y"
8979  {
8980  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
8981  }
8982  break;
8983 
8984  case 380:
8985 
8986 /* Line 1806 of yacc.c */
8987 #line 3313 "ripper.y"
8988  {
8989  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
8990  }
8991  break;
8992 
8993  case 381:
8994 
8995 /* Line 1806 of yacc.c */
8996 #line 3317 "ripper.y"
8997  {
8998  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
8999  }
9000  break;
9001 
9002  case 382:
9003 
9004 /* Line 1806 of yacc.c */
9005 #line 3321 "ripper.y"
9006  {
9007  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
9008  }
9009  break;
9010 
9011  case 383:
9012 
9013 /* Line 1806 of yacc.c */
9014 #line 3325 "ripper.y"
9015  {
9016  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9017  }
9018  break;
9019 
9020  case 384:
9021 
9022 /* Line 1806 of yacc.c */
9023 #line 3329 "ripper.y"
9024  {
9025  (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
9026  }
9027  break;
9028 
9029  case 385:
9030 
9031 /* Line 1806 of yacc.c */
9032 #line 3333 "ripper.y"
9033  {
9034  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
9035 #if 0
9036 #endif
9037  dispatch1(excessed_comma, (yyval.val));
9038 
9039  }
9040  break;
9041 
9042  case 386:
9043 
9044 /* Line 1806 of yacc.c */
9045 #line 3341 "ripper.y"
9046  {
9047  (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9048  }
9049  break;
9050 
9051  case 387:
9052 
9053 /* Line 1806 of yacc.c */
9054 #line 3345 "ripper.y"
9055  {
9056  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
9057  }
9058  break;
9059 
9060  case 388:
9061 
9062 /* Line 1806 of yacc.c */
9063 #line 3349 "ripper.y"
9064  {
9065  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
9066  }
9067  break;
9068 
9069  case 389:
9070 
9071 /* Line 1806 of yacc.c */
9072 #line 3353 "ripper.y"
9073  {
9074  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9075  }
9076  break;
9077 
9078  case 390:
9079 
9080 /* Line 1806 of yacc.c */
9081 #line 3357 "ripper.y"
9082  {
9083  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
9084  }
9085  break;
9086 
9087  case 391:
9088 
9089 /* Line 1806 of yacc.c */
9090 #line 3361 "ripper.y"
9091  {
9092  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9093  }
9094  break;
9095 
9096  case 392:
9097 
9098 /* Line 1806 of yacc.c */
9099 #line 3365 "ripper.y"
9100  {
9101  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
9102  }
9103  break;
9104 
9105  case 393:
9106 
9107 /* Line 1806 of yacc.c */
9108 #line 3369 "ripper.y"
9109  {
9110  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9111  }
9112  break;
9113 
9114  case 394:
9115 
9116 /* Line 1806 of yacc.c */
9117 #line 3373 "ripper.y"
9118  {
9119  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
9120  }
9121  break;
9122 
9123  case 396:
9124 
9125 /* Line 1806 of yacc.c */
9126 #line 3380 "ripper.y"
9127  {
9128  command_start = TRUE;
9129  }
9130  break;
9131 
9132  case 397:
9133 
9134 /* Line 1806 of yacc.c */
9135 #line 3386 "ripper.y"
9136  {
9137 #if 0
9138  (yyval.val) = 0;
9139 #endif
9140  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9141  escape_Qundef((yyvsp[(2) - (3)].val)));
9142 
9143  }
9144  break;
9145 
9146  case 398:
9147 
9148 /* Line 1806 of yacc.c */
9149 #line 3395 "ripper.y"
9150  {
9151 #if 0
9152  (yyval.val) = 0;
9153 #endif
9154  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9155  Qnil);
9156 
9157  }
9158  break;
9159 
9160  case 399:
9161 
9162 /* Line 1806 of yacc.c */
9163 #line 3404 "ripper.y"
9164  {
9165 #if 0
9166  (yyval.val) = (yyvsp[(2) - (4)].val);
9167 #endif
9168  (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
9169 
9170  }
9171  break;
9172 
9173  case 400:
9174 
9175 /* Line 1806 of yacc.c */
9176 #line 3415 "ripper.y"
9177  {
9178  (yyval.val) = 0;
9179  }
9180  break;
9181 
9182  case 401:
9183 
9184 /* Line 1806 of yacc.c */
9185 #line 3419 "ripper.y"
9186  {
9187 #if 0
9188  (yyval.val) = 0;
9189 #endif
9190  (yyval.val) = (yyvsp[(3) - (4)].val);
9191 
9192  }
9193  break;
9194 
9195  case 402:
9196 
9197 /* Line 1806 of yacc.c */
9198 #line 3431 "ripper.y"
9199  {
9200  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9201  }
9202  break;
9203 
9204  case 403:
9205 
9206 /* Line 1806 of yacc.c */
9207 #line 3438 "ripper.y"
9208  {
9209  rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
9210  }
9211  break;
9212 
9213  case 404:
9214 
9215 /* Line 1806 of yacc.c */
9216 #line 3445 "ripper.y"
9217  {
9218  new_bv(get_id((yyvsp[(1) - (1)].val)));
9219 #if 0
9220 #endif
9221  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
9222 
9223  }
9224  break;
9225 
9226  case 405:
9227 
9228 /* Line 1806 of yacc.c */
9229 #line 3453 "ripper.y"
9230  {
9231  (yyval.val) = 0;
9232  }
9233  break;
9234 
9235  case 406:
9236 
9237 /* Line 1806 of yacc.c */
9238 #line 3458 "ripper.y"
9239  {
9240  (yyval.vars) = dyna_push();
9241  }
9242  break;
9243 
9244  case 407:
9245 
9246 /* Line 1806 of yacc.c */
9247 #line 3461 "ripper.y"
9248  {
9249  (yyval.num) = lpar_beg;
9250  lpar_beg = ++paren_nest;
9251  }
9252  break;
9253 
9254  case 408:
9255 
9256 /* Line 1806 of yacc.c */
9257 #line 3466 "ripper.y"
9258  {
9259  (yyval.num) = ruby_sourceline;
9260  }
9261  break;
9262 
9263  case 409:
9264 
9265 /* Line 1806 of yacc.c */
9266 #line 3470 "ripper.y"
9267  {
9268  lpar_beg = (yyvsp[(2) - (5)].num);
9269 #if 0
9270  (yyval.val) = NEW_LAMBDA((yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9271  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9272 #endif
9273  (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9274 
9275  dyna_pop((yyvsp[(1) - (5)].vars));
9276  }
9277  break;
9278 
9279  case 410:
9280 
9281 /* Line 1806 of yacc.c */
9282 #line 3483 "ripper.y"
9283  {
9284 #if 0
9285  (yyval.val) = (yyvsp[(2) - (4)].val);
9286 #endif
9287  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
9288 
9289  }
9290  break;
9291 
9292  case 411:
9293 
9294 /* Line 1806 of yacc.c */
9295 #line 3491 "ripper.y"
9296  {
9297 #if 0
9298  (yyval.val) = (yyvsp[(1) - (1)].val);
9299 #endif
9300  (yyval.val) = (yyvsp[(1) - (1)].val);
9301 
9302  }
9303  break;
9304 
9305  case 412:
9306 
9307 /* Line 1806 of yacc.c */
9308 #line 3501 "ripper.y"
9309  {
9310  (yyval.val) = (yyvsp[(2) - (3)].val);
9311  }
9312  break;
9313 
9314  case 413:
9315 
9316 /* Line 1806 of yacc.c */
9317 #line 3505 "ripper.y"
9318  {
9319  (yyval.val) = (yyvsp[(2) - (3)].val);
9320  }
9321  break;
9322 
9323  case 414:
9324 
9325 /* Line 1806 of yacc.c */
9326 #line 3511 "ripper.y"
9327  {
9328  (yyvsp[(1) - (1)].vars) = dyna_push();
9329 #if 0
9330  (yyval.num) = ruby_sourceline;
9331 #endif
9332  }
9333  break;
9334 
9335  case 415:
9336 
9337 /* Line 1806 of yacc.c */
9338 #line 3520 "ripper.y"
9339  {
9340 #if 0
9341  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9342  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9343 #endif
9344  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9345 
9346  dyna_pop((yyvsp[(1) - (5)].vars));
9347  }
9348  break;
9349 
9350  case 416:
9351 
9352 /* Line 1806 of yacc.c */
9353 #line 3532 "ripper.y"
9354  {
9355 #if 0
9356  if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
9357  compile_error(PARSER_ARG "block given to yield");
9358  }
9359  else {
9360  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
9361  }
9362  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
9363  (yyval.val) = (yyvsp[(2) - (2)].val);
9364  fixpos((yyval.val), (yyvsp[(1) - (2)].val));
9365 #endif
9366  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9367 
9368  }
9369  break;
9370 
9371  case 417:
9372 
9373 /* Line 1806 of yacc.c */
9374 #line 3548 "ripper.y"
9375  {
9376 #if 0
9377  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9378 #endif
9379  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
9380  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9381 
9382  }
9383  break;
9384 
9385  case 418:
9386 
9387 /* Line 1806 of yacc.c */
9388 #line 3557 "ripper.y"
9389  {
9390 #if 0
9391  block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9392  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9393  (yyval.val) = (yyvsp[(5) - (5)].val);
9394  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
9395 #endif
9396  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9397  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
9398 
9399  }
9400  break;
9401 
9402  case 419:
9403 
9404 /* Line 1806 of yacc.c */
9405 #line 3569 "ripper.y"
9406  {
9407 #if 0
9408  block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9409  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9410  (yyval.val) = (yyvsp[(5) - (5)].val);
9411  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
9412 #endif
9413  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9414  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
9415 
9416  }
9417  break;
9418 
9419  case 420:
9420 
9421 /* Line 1806 of yacc.c */
9422 #line 3583 "ripper.y"
9423  {
9424 #if 0
9425  (yyval.val) = (yyvsp[(1) - (2)].val);
9426  (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
9427 #endif
9428  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
9429 
9430  }
9431  break;
9432 
9433  case 421:
9434 
9435 /* Line 1806 of yacc.c */
9436 #line 3592 "ripper.y"
9437  {
9438 #if 0
9439  (yyval.num) = ruby_sourceline;
9440 #endif
9441  }
9442  break;
9443 
9444  case 422:
9445 
9446 /* Line 1806 of yacc.c */
9447 #line 3598 "ripper.y"
9448  {
9449 #if 0
9450  (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9451  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9452 #endif
9453  (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
9454  (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
9455 
9456  }
9457  break;
9458 
9459  case 423:
9460 
9461 /* Line 1806 of yacc.c */
9462 #line 3608 "ripper.y"
9463  {
9464 #if 0
9465  (yyval.num) = ruby_sourceline;
9466 #endif
9467  }
9468  break;
9469 
9470  case 424:
9471 
9472 /* Line 1806 of yacc.c */
9473 #line 3614 "ripper.y"
9474  {
9475 #if 0
9476  (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9477  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9478 #endif
9479  (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
9480  (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
9481 
9482  }
9483  break;
9484 
9485  case 425:
9486 
9487 /* Line 1806 of yacc.c */
9488 #line 3624 "ripper.y"
9489  {
9490 #if 0
9491  (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
9492 #endif
9493  (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
9494 
9495  }
9496  break;
9497 
9498  case 426:
9499 
9500 /* Line 1806 of yacc.c */
9501 #line 3632 "ripper.y"
9502  {
9503 #if 0
9504  (yyval.num) = ruby_sourceline;
9505 #endif
9506  }
9507  break;
9508 
9509  case 427:
9510 
9511 /* Line 1806 of yacc.c */
9512 #line 3638 "ripper.y"
9513  {
9514 #if 0
9515  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
9516  nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
9517 #endif
9518  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'),
9519  ripper_intern("call"));
9520  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9521 
9522  }
9523  break;
9524 
9525  case 428:
9526 
9527 /* Line 1806 of yacc.c */
9528 #line 3649 "ripper.y"
9529  {
9530 #if 0
9531  (yyval.num) = ruby_sourceline;
9532 #endif
9533  }
9534  break;
9535 
9536  case 429:
9537 
9538 /* Line 1806 of yacc.c */
9539 #line 3655 "ripper.y"
9540  {
9541 #if 0
9542  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
9543  nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
9544 #endif
9545  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"),
9546  ripper_intern("call"));
9547  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9548 
9549  }
9550  break;
9551 
9552  case 430:
9553 
9554 /* Line 1806 of yacc.c */
9555 #line 3666 "ripper.y"
9556  {
9557 #if 0
9558  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
9559 #endif
9560  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
9561 
9562  }
9563  break;
9564 
9565  case 431:
9566 
9567 /* Line 1806 of yacc.c */
9568 #line 3674 "ripper.y"
9569  {
9570 #if 0
9571  (yyval.val) = NEW_ZSUPER();
9572 #endif
9573  (yyval.val) = dispatch0(zsuper);
9574 
9575  }
9576  break;
9577 
9578  case 432:
9579 
9580 /* Line 1806 of yacc.c */
9581 #line 3682 "ripper.y"
9582  {
9583 #if 0
9584  if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
9585  (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val));
9586  else
9587  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val));
9588  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
9589 #endif
9590  (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
9591 
9592  }
9593  break;
9594 
9595  case 433:
9596 
9597 /* Line 1806 of yacc.c */
9598 #line 3696 "ripper.y"
9599  {
9600  (yyvsp[(1) - (1)].vars) = dyna_push();
9601 #if 0
9602  (yyval.num) = ruby_sourceline;
9603 #endif
9604 
9605  }
9606  break;
9607 
9608  case 434:
9609 
9610 /* Line 1806 of yacc.c */
9611 #line 3705 "ripper.y"
9612  {
9613 #if 0
9614  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9615  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9616 #endif
9617  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9618 
9619  dyna_pop((yyvsp[(1) - (5)].vars));
9620  }
9621  break;
9622 
9623  case 435:
9624 
9625 /* Line 1806 of yacc.c */
9626 #line 3715 "ripper.y"
9627  {
9628  (yyvsp[(1) - (1)].vars) = dyna_push();
9629 #if 0
9630  (yyval.num) = ruby_sourceline;
9631 #endif
9632 
9633  }
9634  break;
9635 
9636  case 436:
9637 
9638 /* Line 1806 of yacc.c */
9639 #line 3724 "ripper.y"
9640  {
9641 #if 0
9642  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9643  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9644 #endif
9645  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9646 
9647  dyna_pop((yyvsp[(1) - (5)].vars));
9648  }
9649  break;
9650 
9651  case 437:
9652 
9653 /* Line 1806 of yacc.c */
9654 #line 3738 "ripper.y"
9655  {
9656 #if 0
9657  (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9658 #endif
9659  (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
9660 
9661  }
9662  break;
9663 
9664  case 440:
9665 
9666 /* Line 1806 of yacc.c */
9667 #line 3754 "ripper.y"
9668  {
9669 #if 0
9670  if ((yyvsp[(3) - (6)].val)) {
9671  (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO());
9672  (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
9673  }
9674  (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9675  fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
9676 #endif
9677  (yyval.val) = dispatch4(rescue,
9678  escape_Qundef((yyvsp[(2) - (6)].val)),
9679  escape_Qundef((yyvsp[(3) - (6)].val)),
9680  escape_Qundef((yyvsp[(5) - (6)].val)),
9681  escape_Qundef((yyvsp[(6) - (6)].val)));
9682 
9683  }
9684  break;
9685 
9686  case 442:
9687 
9688 /* Line 1806 of yacc.c */
9689 #line 3774 "ripper.y"
9690  {
9691 #if 0
9692  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
9693 #endif
9694  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9695 
9696  }
9697  break;
9698 
9699  case 443:
9700 
9701 /* Line 1806 of yacc.c */
9702 #line 3782 "ripper.y"
9703  {
9704 #if 0
9705  if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
9706 #endif
9707  (yyval.val) = (yyvsp[(1) - (1)].val);
9708 
9709  }
9710  break;
9711 
9712  case 445:
9713 
9714 /* Line 1806 of yacc.c */
9715 #line 3793 "ripper.y"
9716  {
9717  (yyval.val) = (yyvsp[(2) - (2)].val);
9718  }
9719  break;
9720 
9721  case 447:
9722 
9723 /* Line 1806 of yacc.c */
9724 #line 3800 "ripper.y"
9725  {
9726 #if 0
9727  (yyval.val) = (yyvsp[(2) - (2)].val);
9728 #endif
9729  (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
9730 
9731  }
9732  break;
9733 
9734  case 450:
9735 
9736 /* Line 1806 of yacc.c */
9737 #line 3812 "ripper.y"
9738  {
9739 #if 0
9740  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
9741 #endif
9742  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
9743 
9744  }
9745  break;
9746 
9747  case 452:
9748 
9749 /* Line 1806 of yacc.c */
9750 #line 3823 "ripper.y"
9751  {
9752 #if 0
9753  NODE *node = (yyvsp[(1) - (1)].val);
9754  if (!node) {
9755  node = NEW_STR(STR_NEW0());
9756  }
9757  else {
9758  node = evstr2dstr(node);
9759  }
9760  (yyval.val) = node;
9761 #endif
9762  (yyval.val) = (yyvsp[(1) - (1)].val);
9763 
9764  }
9765  break;
9766 
9767  case 455:
9768 
9769 /* Line 1806 of yacc.c */
9770 #line 3842 "ripper.y"
9771  {
9772 #if 0
9773  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9774 #endif
9775  (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9776 
9777  }
9778  break;
9779 
9780  case 456:
9781 
9782 /* Line 1806 of yacc.c */
9783 #line 3852 "ripper.y"
9784  {
9785 #if 0
9786  (yyval.val) = (yyvsp[(2) - (3)].val);
9787 #endif
9788  (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val));
9789 
9790  }
9791  break;
9792 
9793  case 457:
9794 
9795 /* Line 1806 of yacc.c */
9796 #line 3862 "ripper.y"
9797  {
9798 #if 0
9799  NODE *node = (yyvsp[(2) - (3)].val);
9800  if (!node) {
9801  node = NEW_XSTR(STR_NEW0());
9802  }
9803  else {
9804  switch (nd_type(node)) {
9805  case NODE_STR:
9806  nd_set_type(node, NODE_XSTR);
9807  break;
9808  case NODE_DSTR:
9809  nd_set_type(node, NODE_DXSTR);
9810  break;
9811  default:
9812  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
9813  break;
9814  }
9815  }
9816  (yyval.val) = node;
9817 #endif
9818  (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val));
9819 
9820  }
9821  break;
9822 
9823  case 458:
9824 
9825 /* Line 1806 of yacc.c */
9826 #line 3889 "ripper.y"
9827  {
9828 #if 0
9829  int options = (yyvsp[(3) - (3)].val);
9830  NODE *node = (yyvsp[(2) - (3)].val);
9831  NODE *list, *prev;
9832  if (!node) {
9833  node = NEW_LIT(reg_compile(STR_NEW0(), options));
9834  }
9835  else switch (nd_type(node)) {
9836  case NODE_STR:
9837  {
9838  VALUE src = node->nd_lit;
9839  nd_set_type(node, NODE_LIT);
9840  node->nd_lit = reg_compile(src, options);
9841  }
9842  break;
9843  default:
9844  node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
9845  case NODE_DSTR:
9846  if (options & RE_OPTION_ONCE) {
9848  }
9849  else {
9850  nd_set_type(node, NODE_DREGX);
9851  }
9852  node->nd_cflag = options & RE_OPTION_MASK;
9853  if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
9854  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
9855  if (nd_type(list->nd_head) == NODE_STR) {
9856  VALUE tail = list->nd_head->nd_lit;
9857  if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
9858  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
9859  if (!literal_concat0(parser, lit, tail)) {
9860  node = 0;
9861  break;
9862  }
9863  rb_str_resize(tail, 0);
9864  prev->nd_next = list->nd_next;
9865  rb_gc_force_recycle((VALUE)list->nd_head);
9866  rb_gc_force_recycle((VALUE)list);
9867  list = prev;
9868  }
9869  else {
9870  prev = list;
9871  }
9872  }
9873  else {
9874  prev = 0;
9875  }
9876  }
9877  if (!node->nd_next) {
9878  VALUE src = node->nd_lit;
9879  nd_set_type(node, NODE_LIT);
9880  node->nd_lit = reg_compile(src, options);
9881  }
9882  break;
9883  }
9884  (yyval.val) = node;
9885 #endif
9886  (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
9887 
9888  }
9889  break;
9890 
9891  case 459:
9892 
9893 /* Line 1806 of yacc.c */
9894 #line 3954 "ripper.y"
9895  {
9896 #if 0
9897  (yyval.val) = NEW_ZARRAY();
9898 #endif
9899  (yyval.val) = dispatch0(words_new);
9900  (yyval.val) = dispatch1(array, (yyval.val));
9901 
9902  }
9903  break;
9904 
9905  case 460:
9906 
9907 /* Line 1806 of yacc.c */
9908 #line 3963 "ripper.y"
9909  {
9910 #if 0
9911  (yyval.val) = (yyvsp[(2) - (3)].val);
9912 #endif
9913  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9914 
9915  }
9916  break;
9917 
9918  case 461:
9919 
9920 /* Line 1806 of yacc.c */
9921 #line 3973 "ripper.y"
9922  {
9923 #if 0
9924  (yyval.val) = 0;
9925 #endif
9926  (yyval.val) = dispatch0(words_new);
9927 
9928  }
9929  break;
9930 
9931  case 462:
9932 
9933 /* Line 1806 of yacc.c */
9934 #line 3981 "ripper.y"
9935  {
9936 #if 0
9937  (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
9938 #endif
9939  (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9940 
9941  }
9942  break;
9943 
9944  case 463:
9945 
9946 /* Line 1806 of yacc.c */
9947 #line 3993 "ripper.y"
9948  {
9949  (yyval.val) = dispatch0(word_new);
9950  (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
9951  }
9952  break;
9953 
9954  case 464:
9955 
9956 /* Line 1806 of yacc.c */
9957 #line 3999 "ripper.y"
9958  {
9959 #if 0
9960  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9961 #endif
9962  (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9963 
9964  }
9965  break;
9966 
9967  case 465:
9968 
9969 /* Line 1806 of yacc.c */
9970 #line 4009 "ripper.y"
9971  {
9972 #if 0
9973  (yyval.val) = NEW_ZARRAY();
9974 #endif
9975  (yyval.val) = dispatch0(symbols_new);
9976  (yyval.val) = dispatch1(array, (yyval.val));
9977 
9978  }
9979  break;
9980 
9981  case 466:
9982 
9983 /* Line 1806 of yacc.c */
9984 #line 4018 "ripper.y"
9985  {
9986 #if 0
9987  (yyval.val) = (yyvsp[(2) - (3)].val);
9988 #endif
9989  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9990 
9991  }
9992  break;
9993 
9994  case 467:
9995 
9996 /* Line 1806 of yacc.c */
9997 #line 4028 "ripper.y"
9998  {
9999 #if 0
10000  (yyval.val) = 0;
10001 #endif
10002  (yyval.val) = dispatch0(symbols_new);
10003 
10004  }
10005  break;
10006 
10007  case 468:
10008 
10009 /* Line 1806 of yacc.c */
10010 #line 4036 "ripper.y"
10011  {
10012 #if 0
10013  (yyvsp[(2) - (3)].val) = evstr2dstr((yyvsp[(2) - (3)].val));
10014  nd_set_type((yyvsp[(2) - (3)].val), NODE_DSYM);
10015  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10016 #endif
10017  (yyval.val) = dispatch2(symbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10018 
10019  }
10020  break;
10021 
10022  case 469:
10023 
10024 /* Line 1806 of yacc.c */
10025 #line 4048 "ripper.y"
10026  {
10027 #if 0
10028  (yyval.val) = NEW_ZARRAY();
10029 #endif
10030  (yyval.val) = dispatch0(qwords_new);
10031  (yyval.val) = dispatch1(array, (yyval.val));
10032 
10033  }
10034  break;
10035 
10036  case 470:
10037 
10038 /* Line 1806 of yacc.c */
10039 #line 4057 "ripper.y"
10040  {
10041 #if 0
10042  (yyval.val) = (yyvsp[(2) - (3)].val);
10043 #endif
10044  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10045 
10046  }
10047  break;
10048 
10049  case 471:
10050 
10051 /* Line 1806 of yacc.c */
10052 #line 4067 "ripper.y"
10053  {
10054 #if 0
10055  (yyval.val) = NEW_ZARRAY();
10056 #endif
10057  (yyval.val) = dispatch0(qsymbols_new);
10058  (yyval.val) = dispatch1(array, (yyval.val));
10059 
10060  }
10061  break;
10062 
10063  case 472:
10064 
10065 /* Line 1806 of yacc.c */
10066 #line 4076 "ripper.y"
10067  {
10068 #if 0
10069  (yyval.val) = (yyvsp[(2) - (3)].val);
10070 #endif
10071  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10072 
10073  }
10074  break;
10075 
10076  case 473:
10077 
10078 /* Line 1806 of yacc.c */
10079 #line 4086 "ripper.y"
10080  {
10081 #if 0
10082  (yyval.val) = 0;
10083 #endif
10084  (yyval.val) = dispatch0(qwords_new);
10085 
10086  }
10087  break;
10088 
10089  case 474:
10090 
10091 /* Line 1806 of yacc.c */
10092 #line 4094 "ripper.y"
10093  {
10094 #if 0
10095  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10096 #endif
10097  (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10098 
10099  }
10100  break;
10101 
10102  case 475:
10103 
10104 /* Line 1806 of yacc.c */
10105 #line 4104 "ripper.y"
10106  {
10107 #if 0
10108  (yyval.val) = 0;
10109 #endif
10110  (yyval.val) = dispatch0(qsymbols_new);
10111 
10112  }
10113  break;
10114 
10115  case 476:
10116 
10117 /* Line 1806 of yacc.c */
10118 #line 4112 "ripper.y"
10119  {
10120 #if 0
10121  VALUE lit;
10122  lit = (yyvsp[(2) - (3)].val)->nd_lit;
10123  (yyvsp[(2) - (3)].val)->nd_lit = ID2SYM(rb_intern_str(lit));
10124  nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
10125  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10126 #endif
10127  (yyval.val) = dispatch2(qsymbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10128 
10129  }
10130  break;
10131 
10132  case 477:
10133 
10134 /* Line 1806 of yacc.c */
10135 #line 4126 "ripper.y"
10136  {
10137 #if 0
10138  (yyval.val) = 0;
10139 #endif
10140  (yyval.val) = dispatch0(string_content);
10141 
10142  }
10143  break;
10144 
10145  case 478:
10146 
10147 /* Line 1806 of yacc.c */
10148 #line 4134 "ripper.y"
10149  {
10150 #if 0
10151  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10152 #endif
10153  (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10154 
10155  }
10156  break;
10157 
10158  case 479:
10159 
10160 /* Line 1806 of yacc.c */
10161 #line 4144 "ripper.y"
10162  {
10163 #if 0
10164  (yyval.val) = 0;
10165 #endif
10166  (yyval.val) = dispatch0(xstring_new);
10167 
10168  }
10169  break;
10170 
10171  case 480:
10172 
10173 /* Line 1806 of yacc.c */
10174 #line 4152 "ripper.y"
10175  {
10176 #if 0
10177  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10178 #endif
10179  (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10180 
10181  }
10182  break;
10183 
10184  case 481:
10185 
10186 /* Line 1806 of yacc.c */
10187 #line 4162 "ripper.y"
10188  {
10189 #if 0
10190  (yyval.val) = 0;
10191 #endif
10192  (yyval.val) = dispatch0(regexp_new);
10193 
10194  }
10195  break;
10196 
10197  case 482:
10198 
10199 /* Line 1806 of yacc.c */
10200 #line 4170 "ripper.y"
10201  {
10202 #if 0
10203  NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
10204  if (!head) {
10205  (yyval.val) = tail;
10206  }
10207  else if (!tail) {
10208  (yyval.val) = head;
10209  }
10210  else {
10211  switch (nd_type(head)) {
10212  case NODE_STR:
10213  nd_set_type(head, NODE_DSTR);
10214  break;
10215  case NODE_DSTR:
10216  break;
10217  default:
10218  head = list_append(NEW_DSTR(Qnil), head);
10219  break;
10220  }
10221  (yyval.val) = list_append(head, tail);
10222  }
10223 #endif
10224  (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10225 
10226  }
10227  break;
10228 
10229  case 484:
10230 
10231 /* Line 1806 of yacc.c */
10232 #line 4200 "ripper.y"
10233  {
10234  (yyval.node) = lex_strterm;
10235  lex_strterm = 0;
10236  lex_state = EXPR_BEG;
10237  }
10238  break;
10239 
10240  case 485:
10241 
10242 /* Line 1806 of yacc.c */
10243 #line 4206 "ripper.y"
10244  {
10245 #if 0
10246  lex_strterm = (yyvsp[(2) - (3)].node);
10247  (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
10248 #endif
10249  lex_strterm = (yyvsp[(2) - (3)].node);
10250  (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
10251 
10252  }
10253  break;
10254 
10255  case 486:
10256 
10257 /* Line 1806 of yacc.c */
10258 #line 4216 "ripper.y"
10259  {
10260  (yyvsp[(1) - (1)].val) = cond_stack;
10261  (yyval.val) = cmdarg_stack;
10262  cond_stack = 0;
10263  cmdarg_stack = 0;
10264  }
10265  break;
10266 
10267  case 487:
10268 
10269 /* Line 1806 of yacc.c */
10270 #line 4222 "ripper.y"
10271  {
10272  (yyval.node) = lex_strterm;
10273  lex_strterm = 0;
10274  lex_state = EXPR_BEG;
10275  }
10276  break;
10277 
10278  case 488:
10279 
10280 /* Line 1806 of yacc.c */
10281 #line 4227 "ripper.y"
10282  {
10283  (yyval.num) = brace_nest;
10284  brace_nest = 0;
10285  }
10286  break;
10287 
10288  case 489:
10289 
10290 /* Line 1806 of yacc.c */
10291 #line 4232 "ripper.y"
10292  {
10293  cond_stack = (yyvsp[(1) - (6)].val);
10294  cmdarg_stack = (yyvsp[(2) - (6)].val);
10295  lex_strterm = (yyvsp[(3) - (6)].node);
10296  brace_nest = (yyvsp[(4) - (6)].num);
10297 #if 0
10298  if ((yyvsp[(5) - (6)].val)) (yyvsp[(5) - (6)].val)->flags &= ~NODE_FL_NEWLINE;
10299  (yyval.val) = new_evstr((yyvsp[(5) - (6)].val));
10300 #endif
10301  (yyval.val) = dispatch1(string_embexpr, (yyvsp[(5) - (6)].val));
10302 
10303  }
10304  break;
10305 
10306  case 490:
10307 
10308 /* Line 1806 of yacc.c */
10309 #line 4247 "ripper.y"
10310  {
10311 #if 0
10312  (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
10313 #endif
10314  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10315 
10316  }
10317  break;
10318 
10319  case 491:
10320 
10321 /* Line 1806 of yacc.c */
10322 #line 4255 "ripper.y"
10323  {
10324 #if 0
10325  (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
10326 #endif
10327  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10328 
10329  }
10330  break;
10331 
10332  case 492:
10333 
10334 /* Line 1806 of yacc.c */
10335 #line 4263 "ripper.y"
10336  {
10337 #if 0
10338  (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
10339 #endif
10340  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10341 
10342  }
10343  break;
10344 
10345  case 494:
10346 
10347 /* Line 1806 of yacc.c */
10348 #line 4274 "ripper.y"
10349  {
10350  lex_state = EXPR_END;
10351 #if 0
10352  (yyval.val) = (yyvsp[(2) - (2)].val);
10353 #endif
10354  (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
10355 
10356  }
10357  break;
10358 
10359  case 499:
10360 
10361 /* Line 1806 of yacc.c */
10362 #line 4291 "ripper.y"
10363  {
10364  lex_state = EXPR_END;
10365 #if 0
10366  (yyval.val) = dsym_node((yyvsp[(2) - (3)].val));
10367 #endif
10368  (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
10369 
10370  }
10371  break;
10372 
10373  case 502:
10374 
10375 /* Line 1806 of yacc.c */
10376 #line 4304 "ripper.y"
10377  {
10378 #if 0
10379  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10380 #endif
10381  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10382 
10383  }
10384  break;
10385 
10386  case 503:
10387 
10388 /* Line 1806 of yacc.c */
10389 #line 4312 "ripper.y"
10390  {
10391 #if 0
10392  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10393 #endif
10394  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10395 
10396  }
10397  break;
10398 
10399  case 509:
10400 
10401 /* Line 1806 of yacc.c */
10402 #line 4328 "ripper.y"
10403  {ifndef_ripper((yyval.val) = keyword_nil);}
10404  break;
10405 
10406  case 510:
10407 
10408 /* Line 1806 of yacc.c */
10409 #line 4329 "ripper.y"
10410  {ifndef_ripper((yyval.val) = keyword_self);}
10411  break;
10412 
10413  case 511:
10414 
10415 /* Line 1806 of yacc.c */
10416 #line 4330 "ripper.y"
10417  {ifndef_ripper((yyval.val) = keyword_true);}
10418  break;
10419 
10420  case 512:
10421 
10422 /* Line 1806 of yacc.c */
10423 #line 4331 "ripper.y"
10424  {ifndef_ripper((yyval.val) = keyword_false);}
10425  break;
10426 
10427  case 513:
10428 
10429 /* Line 1806 of yacc.c */
10430 #line 4332 "ripper.y"
10431  {ifndef_ripper((yyval.val) = keyword__FILE__);}
10432  break;
10433 
10434  case 514:
10435 
10436 /* Line 1806 of yacc.c */
10437 #line 4333 "ripper.y"
10438  {ifndef_ripper((yyval.val) = keyword__LINE__);}
10439  break;
10440 
10441  case 515:
10442 
10443 /* Line 1806 of yacc.c */
10444 #line 4334 "ripper.y"
10445  {ifndef_ripper((yyval.val) = keyword__ENCODING__);}
10446  break;
10447 
10448  case 516:
10449 
10450 /* Line 1806 of yacc.c */
10451 #line 4338 "ripper.y"
10452  {
10453 #if 0
10454  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10455 #endif
10456  if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) {
10457  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10458  }
10459  else {
10460  (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val));
10461  }
10462 
10463  }
10464  break;
10465 
10466  case 517:
10467 
10468 /* Line 1806 of yacc.c */
10469 #line 4351 "ripper.y"
10470  {
10471 #if 0
10472  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10473 #endif
10474  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10475 
10476  }
10477  break;
10478 
10479  case 518:
10480 
10481 /* Line 1806 of yacc.c */
10482 #line 4361 "ripper.y"
10483  {
10484  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10485 #if 0
10486 #endif
10487  (yyval.val) = dispatch1(var_field, (yyval.val));
10488 
10489  }
10490  break;
10491 
10492  case 519:
10493 
10494 /* Line 1806 of yacc.c */
10495 #line 4369 "ripper.y"
10496  {
10497  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10498 #if 0
10499 #endif
10500  (yyval.val) = dispatch1(var_field, (yyval.val));
10501 
10502  }
10503  break;
10504 
10505  case 522:
10506 
10507 /* Line 1806 of yacc.c */
10508 #line 4383 "ripper.y"
10509  {
10510 #if 0
10511  (yyval.val) = 0;
10512 #endif
10513  (yyval.val) = Qnil;
10514 
10515  }
10516  break;
10517 
10518  case 523:
10519 
10520 /* Line 1806 of yacc.c */
10521 #line 4391 "ripper.y"
10522  {
10523  lex_state = EXPR_BEG;
10524  command_start = TRUE;
10525  }
10526  break;
10527 
10528  case 524:
10529 
10530 /* Line 1806 of yacc.c */
10531 #line 4396 "ripper.y"
10532  {
10533  (yyval.val) = (yyvsp[(3) - (4)].val);
10534  }
10535  break;
10536 
10537  case 525:
10538 
10539 /* Line 1806 of yacc.c */
10540 #line 4400 "ripper.y"
10541  {
10542 #if 0
10543  yyerrok;
10544  (yyval.val) = 0;
10545 #endif
10546  yyerrok;
10547  (yyval.val) = Qnil;
10548 
10549  }
10550  break;
10551 
10552  case 526:
10553 
10554 /* Line 1806 of yacc.c */
10555 #line 4412 "ripper.y"
10556  {
10557 #if 0
10558  (yyval.val) = (yyvsp[(2) - (3)].val);
10559 #endif
10560  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
10561 
10562  lex_state = EXPR_BEG;
10563  command_start = TRUE;
10564  }
10565  break;
10566 
10567  case 527:
10568 
10569 /* Line 1806 of yacc.c */
10570 #line 4422 "ripper.y"
10571  {
10572  (yyval.val) = (yyvsp[(1) - (2)].val);
10573  lex_state = EXPR_BEG;
10574  command_start = TRUE;
10575  }
10576  break;
10577 
10578  case 528:
10579 
10580 /* Line 1806 of yacc.c */
10581 #line 4430 "ripper.y"
10582  {
10583  (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10584  }
10585  break;
10586 
10587  case 529:
10588 
10589 /* Line 1806 of yacc.c */
10590 #line 4434 "ripper.y"
10591  {
10592  (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10593  }
10594  break;
10595 
10596  case 530:
10597 
10598 /* Line 1806 of yacc.c */
10599 #line 4438 "ripper.y"
10600  {
10601  (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10602  }
10603  break;
10604 
10605  case 531:
10606 
10607 /* Line 1806 of yacc.c */
10608 #line 4442 "ripper.y"
10609  {
10610  (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
10611  }
10612  break;
10613 
10614  case 532:
10615 
10616 /* Line 1806 of yacc.c */
10617 #line 4448 "ripper.y"
10618  {
10619  (yyval.val) = (yyvsp[(2) - (2)].val);
10620  }
10621  break;
10622 
10623  case 533:
10624 
10625 /* Line 1806 of yacc.c */
10626 #line 4452 "ripper.y"
10627  {
10628  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10629  }
10630  break;
10631 
10632  case 534:
10633 
10634 /* Line 1806 of yacc.c */
10635 #line 4458 "ripper.y"
10636  {
10637  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
10638  }
10639  break;
10640 
10641  case 535:
10642 
10643 /* Line 1806 of yacc.c */
10644 #line 4462 "ripper.y"
10645  {
10646  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10647  }
10648  break;
10649 
10650  case 536:
10651 
10652 /* Line 1806 of yacc.c */
10653 #line 4466 "ripper.y"
10654  {
10655  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
10656  }
10657  break;
10658 
10659  case 537:
10660 
10661 /* Line 1806 of yacc.c */
10662 #line 4470 "ripper.y"
10663  {
10664  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10665  }
10666  break;
10667 
10668  case 538:
10669 
10670 /* Line 1806 of yacc.c */
10671 #line 4474 "ripper.y"
10672  {
10673  (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10674  }
10675  break;
10676 
10677  case 539:
10678 
10679 /* Line 1806 of yacc.c */
10680 #line 4478 "ripper.y"
10681  {
10682  (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10683  }
10684  break;
10685 
10686  case 540:
10687 
10688 /* Line 1806 of yacc.c */
10689 #line 4482 "ripper.y"
10690  {
10691  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
10692  }
10693  break;
10694 
10695  case 541:
10696 
10697 /* Line 1806 of yacc.c */
10698 #line 4486 "ripper.y"
10699  {
10700  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10701  }
10702  break;
10703 
10704  case 542:
10705 
10706 /* Line 1806 of yacc.c */
10707 #line 4490 "ripper.y"
10708  {
10709  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10710  }
10711  break;
10712 
10713  case 543:
10714 
10715 /* Line 1806 of yacc.c */
10716 #line 4494 "ripper.y"
10717  {
10718  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
10719  }
10720  break;
10721 
10722  case 544:
10723 
10724 /* Line 1806 of yacc.c */
10725 #line 4498 "ripper.y"
10726  {
10727  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10728  }
10729  break;
10730 
10731  case 545:
10732 
10733 /* Line 1806 of yacc.c */
10734 #line 4502 "ripper.y"
10735  {
10736  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10737  }
10738  break;
10739 
10740  case 546:
10741 
10742 /* Line 1806 of yacc.c */
10743 #line 4506 "ripper.y"
10744  {
10745  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10746  }
10747  break;
10748 
10749  case 547:
10750 
10751 /* Line 1806 of yacc.c */
10752 #line 4510 "ripper.y"
10753  {
10754  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
10755  }
10756  break;
10757 
10758  case 548:
10759 
10760 /* Line 1806 of yacc.c */
10761 #line 4514 "ripper.y"
10762  {
10763  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10764  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.val));
10765  }
10766  break;
10767 
10768  case 549:
10769 
10770 /* Line 1806 of yacc.c */
10771 #line 4521 "ripper.y"
10772  {
10773 #if 0
10774  yyerror("formal argument cannot be a constant");
10775  (yyval.val) = 0;
10776 #endif
10777  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10778 
10779  }
10780  break;
10781 
10782  case 550:
10783 
10784 /* Line 1806 of yacc.c */
10785 #line 4530 "ripper.y"
10786  {
10787 #if 0
10788  yyerror("formal argument cannot be an instance variable");
10789  (yyval.val) = 0;
10790 #endif
10791  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10792 
10793  }
10794  break;
10795 
10796  case 551:
10797 
10798 /* Line 1806 of yacc.c */
10799 #line 4539 "ripper.y"
10800  {
10801 #if 0
10802  yyerror("formal argument cannot be a global variable");
10803  (yyval.val) = 0;
10804 #endif
10805  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10806 
10807  }
10808  break;
10809 
10810  case 552:
10811 
10812 /* Line 1806 of yacc.c */
10813 #line 4548 "ripper.y"
10814  {
10815 #if 0
10816  yyerror("formal argument cannot be a class variable");
10817  (yyval.val) = 0;
10818 #endif
10819  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10820 
10821  }
10822  break;
10823 
10824  case 554:
10825 
10826 /* Line 1806 of yacc.c */
10827 #line 4560 "ripper.y"
10828  {
10829  formal_argument(get_id((yyvsp[(1) - (1)].val)));
10830  (yyval.val) = (yyvsp[(1) - (1)].val);
10831  }
10832  break;
10833 
10834  case 555:
10835 
10836 /* Line 1806 of yacc.c */
10837 #line 4567 "ripper.y"
10838  {
10839  arg_var(get_id((yyvsp[(1) - (1)].val)));
10840 #if 0
10841  (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10842 #endif
10843  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10844 
10845  }
10846  break;
10847 
10848  case 556:
10849 
10850 /* Line 1806 of yacc.c */
10851 #line 4576 "ripper.y"
10852  {
10853  ID tid = internal_id();
10854  arg_var(tid);
10855 #if 0
10856  if (dyna_in_block()) {
10857  (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10858  }
10859  else {
10860  (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10861  }
10862  (yyval.val) = NEW_ARGS_AUX(tid, 1);
10863  (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10864 #endif
10865  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10866 
10867  }
10868  break;
10869 
10870  case 557:
10871 
10872 /* Line 1806 of yacc.c */
10873 #line 4597 "ripper.y"
10874  {
10875  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10876  }
10877  break;
10878 
10879  case 558:
10880 
10881 /* Line 1806 of yacc.c */
10882 #line 4602 "ripper.y"
10883  {
10884 #if 0
10885  (yyval.val) = (yyvsp[(1) - (3)].val);
10886  (yyval.val)->nd_plen++;
10887  (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10888  rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10889 #endif
10890  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10891 
10892  }
10893  break;
10894 
10895  case 559:
10896 
10897 /* Line 1806 of yacc.c */
10898 #line 4615 "ripper.y"
10899  {
10900  arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val))));
10901  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10902 #if 0
10903  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10904 #endif
10905  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10906 
10907  }
10908  break;
10909 
10910  case 560:
10911 
10912 /* Line 1806 of yacc.c */
10913 #line 4627 "ripper.y"
10914  {
10915  arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val))));
10916  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10917 #if 0
10918  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10919 #endif
10920  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10921 
10922  }
10923  break;
10924 
10925  case 561:
10926 
10927 /* Line 1806 of yacc.c */
10928 #line 4639 "ripper.y"
10929  {
10930 #if 0
10931  (yyval.val) = (yyvsp[(1) - (1)].val);
10932 #endif
10933  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10934 
10935  }
10936  break;
10937 
10938  case 562:
10939 
10940 /* Line 1806 of yacc.c */
10941 #line 4647 "ripper.y"
10942  {
10943 #if 0
10944  NODE *kws = (yyvsp[(1) - (3)].val);
10945 
10946  while (kws->nd_next) {
10947  kws = kws->nd_next;
10948  }
10949  kws->nd_next = (yyvsp[(3) - (3)].val);
10950  (yyval.val) = (yyvsp[(1) - (3)].val);
10951 #endif
10952  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10953 
10954  }
10955  break;
10956 
10957  case 563:
10958 
10959 /* Line 1806 of yacc.c */
10960 #line 4664 "ripper.y"
10961  {
10962 #if 0
10963  (yyval.val) = (yyvsp[(1) - (1)].val);
10964 #endif
10965  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10966 
10967  }
10968  break;
10969 
10970  case 564:
10971 
10972 /* Line 1806 of yacc.c */
10973 #line 4672 "ripper.y"
10974  {
10975 #if 0
10976  NODE *kws = (yyvsp[(1) - (3)].val);
10977 
10978  while (kws->nd_next) {
10979  kws = kws->nd_next;
10980  }
10981  kws->nd_next = (yyvsp[(3) - (3)].val);
10982  (yyval.val) = (yyvsp[(1) - (3)].val);
10983 #endif
10984  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10985 
10986  }
10987  break;
10988 
10989  case 567:
10990 
10991 /* Line 1806 of yacc.c */
10992 #line 4692 "ripper.y"
10993  {
10994  shadowing_lvar(get_id((yyvsp[(2) - (2)].val)));
10995  (yyval.val) = (yyvsp[(2) - (2)].val);
10996  }
10997  break;
10998 
10999  case 568:
11000 
11001 /* Line 1806 of yacc.c */
11002 #line 4697 "ripper.y"
11003  {
11004  (yyval.val) = internal_id();
11005  }
11006  break;
11007 
11008  case 569:
11009 
11010 /* Line 1806 of yacc.c */
11011 #line 4703 "ripper.y"
11012  {
11013  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
11014  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11015 #if 0
11016  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
11017 #endif
11018  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
11019 
11020  }
11021  break;
11022 
11023  case 570:
11024 
11025 /* Line 1806 of yacc.c */
11026 #line 4715 "ripper.y"
11027  {
11028  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
11029  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11030 #if 0
11031  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
11032 #endif
11033  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
11034 
11035  }
11036  break;
11037 
11038  case 571:
11039 
11040 /* Line 1806 of yacc.c */
11041 #line 4727 "ripper.y"
11042  {
11043 #if 0
11044  (yyval.val) = (yyvsp[(1) - (1)].val);
11045 #endif
11046  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11047 
11048  }
11049  break;
11050 
11051  case 572:
11052 
11053 /* Line 1806 of yacc.c */
11054 #line 4735 "ripper.y"
11055  {
11056 #if 0
11057  NODE *opts = (yyvsp[(1) - (3)].val);
11058 
11059  while (opts->nd_next) {
11060  opts = opts->nd_next;
11061  }
11062  opts->nd_next = (yyvsp[(3) - (3)].val);
11063  (yyval.val) = (yyvsp[(1) - (3)].val);
11064 #endif
11065  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11066 
11067  }
11068  break;
11069 
11070  case 573:
11071 
11072 /* Line 1806 of yacc.c */
11073 #line 4751 "ripper.y"
11074  {
11075 #if 0
11076  (yyval.val) = (yyvsp[(1) - (1)].val);
11077 #endif
11078  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11079 
11080  }
11081  break;
11082 
11083  case 574:
11084 
11085 /* Line 1806 of yacc.c */
11086 #line 4759 "ripper.y"
11087  {
11088 #if 0
11089  NODE *opts = (yyvsp[(1) - (3)].val);
11090 
11091  while (opts->nd_next) {
11092  opts = opts->nd_next;
11093  }
11094  opts->nd_next = (yyvsp[(3) - (3)].val);
11095  (yyval.val) = (yyvsp[(1) - (3)].val);
11096 #endif
11097  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11098 
11099  }
11100  break;
11101 
11102  case 577:
11103 
11104 /* Line 1806 of yacc.c */
11105 #line 4779 "ripper.y"
11106  {
11107 #if 0
11108  if (!is_local_id((yyvsp[(2) - (2)].val)))
11109  yyerror("rest argument must be local variable");
11110 #endif
11111  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11112 #if 0
11113  (yyval.val) = (yyvsp[(2) - (2)].val);
11114 #endif
11115  (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
11116 
11117  }
11118  break;
11119 
11120  case 578:
11121 
11122 /* Line 1806 of yacc.c */
11123 #line 4792 "ripper.y"
11124  {
11125 #if 0
11126  (yyval.val) = internal_id();
11127  arg_var((yyval.val));
11128 #endif
11129  (yyval.val) = dispatch1(rest_param, Qnil);
11130 
11131  }
11132  break;
11133 
11134  case 581:
11135 
11136 /* Line 1806 of yacc.c */
11137 #line 4807 "ripper.y"
11138  {
11139 #if 0
11140  if (!is_local_id((yyvsp[(2) - (2)].val)))
11141  yyerror("block argument must be local variable");
11142  else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
11143  yyerror("duplicated block argument name");
11144 #endif
11145  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11146 #if 0
11147  (yyval.val) = (yyvsp[(2) - (2)].val);
11148 #endif
11149  (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
11150 
11151  }
11152  break;
11153 
11154  case 582:
11155 
11156 /* Line 1806 of yacc.c */
11157 #line 4824 "ripper.y"
11158  {
11159  (yyval.val) = (yyvsp[(2) - (2)].val);
11160  }
11161  break;
11162 
11163  case 583:
11164 
11165 /* Line 1806 of yacc.c */
11166 #line 4828 "ripper.y"
11167  {
11168 #if 0
11169  (yyval.val) = 0;
11170 #endif
11171  (yyval.val) = Qundef;
11172 
11173  }
11174  break;
11175 
11176  case 584:
11177 
11178 /* Line 1806 of yacc.c */
11179 #line 4838 "ripper.y"
11180  {
11181 #if 0
11182  value_expr((yyvsp[(1) - (1)].val));
11183  (yyval.val) = (yyvsp[(1) - (1)].val);
11184  if (!(yyval.val)) (yyval.val) = NEW_NIL();
11185 #endif
11186  (yyval.val) = (yyvsp[(1) - (1)].val);
11187 
11188  }
11189  break;
11190 
11191  case 585:
11192 
11193 /* Line 1806 of yacc.c */
11194 #line 4847 "ripper.y"
11195  {lex_state = EXPR_BEG;}
11196  break;
11197 
11198  case 586:
11199 
11200 /* Line 1806 of yacc.c */
11201 #line 4848 "ripper.y"
11202  {
11203 #if 0
11204  if ((yyvsp[(3) - (4)].val) == 0) {
11205  yyerror("can't define singleton method for ().");
11206  }
11207  else {
11208  switch (nd_type((yyvsp[(3) - (4)].val))) {
11209  case NODE_STR:
11210  case NODE_DSTR:
11211  case NODE_XSTR:
11212  case NODE_DXSTR:
11213  case NODE_DREGX:
11214  case NODE_LIT:
11215  case NODE_ARRAY:
11216  case NODE_ZARRAY:
11217  yyerror("can't define singleton method for literals");
11218  default:
11219  value_expr((yyvsp[(3) - (4)].val));
11220  break;
11221  }
11222  }
11223  (yyval.val) = (yyvsp[(3) - (4)].val);
11224 #endif
11225  (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
11226 
11227  }
11228  break;
11229 
11230  case 588:
11231 
11232 /* Line 1806 of yacc.c */
11233 #line 4878 "ripper.y"
11234  {
11235 #if 0
11236  (yyval.val) = (yyvsp[(1) - (2)].val);
11237 #endif
11238  (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
11239 
11240  }
11241  break;
11242 
11243  case 589:
11244 
11245 /* Line 1806 of yacc.c */
11246 #line 4890 "ripper.y"
11247  {
11248  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11249  }
11250  break;
11251 
11252  case 590:
11253 
11254 /* Line 1806 of yacc.c */
11255 #line 4895 "ripper.y"
11256  {
11257 #if 0
11258  (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11259 #endif
11260  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11261 
11262  }
11263  break;
11264 
11265  case 591:
11266 
11267 /* Line 1806 of yacc.c */
11268 #line 4905 "ripper.y"
11269  {
11270 #if 0
11271  (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
11272 #endif
11273  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11274 
11275  }
11276  break;
11277 
11278  case 592:
11279 
11280 /* Line 1806 of yacc.c */
11281 #line 4913 "ripper.y"
11282  {
11283 #if 0
11284  (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
11285 #endif
11286  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
11287 
11288  }
11289  break;
11290 
11291  case 593:
11292 
11293 /* Line 1806 of yacc.c */
11294 #line 4921 "ripper.y"
11295  {
11296 #if 0
11297  (yyval.val) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].val));
11298 #endif
11299  (yyval.val) = dispatch1(assoc_splat, (yyvsp[(2) - (2)].val));
11300 
11301  }
11302  break;
11303 
11304  case 604:
11305 
11306 /* Line 1806 of yacc.c */
11307 #line 4951 "ripper.y"
11308  { (yyval.val) = (yyvsp[(1) - (1)].val); }
11309  break;
11310 
11311  case 605:
11312 
11313 /* Line 1806 of yacc.c */
11314 #line 4956 "ripper.y"
11315  { (yyval.val) = (yyvsp[(1) - (1)].val); }
11316  break;
11317 
11318  case 615:
11319 
11320 /* Line 1806 of yacc.c */
11321 #line 4979 "ripper.y"
11322  {yyerrok;}
11323  break;
11324 
11325  case 618:
11326 
11327 /* Line 1806 of yacc.c */
11328 #line 4984 "ripper.y"
11329  {yyerrok;}
11330  break;
11331 
11332  case 619:
11333 
11334 /* Line 1806 of yacc.c */
11335 #line 4988 "ripper.y"
11336  {
11337 #if 0
11338  (yyval.val) = 0;
11339 #endif
11340  (yyval.val) = Qundef;
11341 
11342  }
11343  break;
11344 
11345 
11346 
11347 /* Line 1806 of yacc.c */
11348 #line 11347 "parse.c"
11349  default: break;
11350  }
11351  /* User semantic actions sometimes alter yychar, and that requires
11352  that yytoken be updated with the new translation. We take the
11353  approach of translating immediately before every use of yytoken.
11354  One alternative is translating here after every semantic action,
11355  but that translation would be missed if the semantic action invokes
11356  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11357  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
11358  incorrect destructor might then be invoked immediately. In the
11359  case of YYERROR or YYBACKUP, subsequent parser actions might lead
11360  to an incorrect destructor call or verbose syntax error message
11361  before the lookahead is translated. */
11362  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11363 
11364  YYPOPSTACK (yylen);
11365  yylen = 0;
11366  YY_STACK_PRINT (yyss, yyssp);
11367 
11368  *++yyvsp = yyval;
11369 
11370  /* Now `shift' the result of the reduction. Determine what state
11371  that goes to, based on the state we popped back to and the rule
11372  number reduced by. */
11373 
11374  yyn = yyr1[yyn];
11375 
11376  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
11377  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
11378  yystate = yytable[yystate];
11379  else
11380  yystate = yydefgoto[yyn - YYNTOKENS];
11381 
11382  goto yynewstate;
11383 
11384 
11385 /*------------------------------------.
11386 | yyerrlab -- here on detecting error |
11387 `------------------------------------*/
11388 yyerrlab:
11389  /* Make sure we have latest lookahead translation. See comments at
11390  user semantic actions for why this is necessary. */
11391  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
11392 
11393  /* If not already recovering from an error, report this error. */
11394  if (!yyerrstatus)
11395  {
11396  ++yynerrs;
11397 #if ! YYERROR_VERBOSE
11398  parser_yyerror (parser, YY_("syntax error"));
11399 #else
11400 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
11401  yyssp, yytoken)
11402  {
11403  char const *yymsgp = YY_("syntax error");
11404  int yysyntax_error_status;
11405  yysyntax_error_status = YYSYNTAX_ERROR;
11406  if (yysyntax_error_status == 0)
11407  yymsgp = yymsg;
11408  else if (yysyntax_error_status == 1)
11409  {
11410  if (yymsg != yymsgbuf)
11411  YYSTACK_FREE (yymsg);
11412  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11413  if (!yymsg)
11414  {
11415  yymsg = yymsgbuf;
11416  yymsg_alloc = sizeof yymsgbuf;
11417  yysyntax_error_status = 2;
11418  }
11419  else
11420  {
11421  yysyntax_error_status = YYSYNTAX_ERROR;
11422  yymsgp = yymsg;
11423  }
11424  }
11425  parser_yyerror (parser, yymsgp);
11426  if (yysyntax_error_status == 2)
11427  goto yyexhaustedlab;
11428  }
11429 # undef YYSYNTAX_ERROR
11430 #endif
11431  }
11432 
11433 
11434 
11435  if (yyerrstatus == 3)
11436  {
11437  /* If just tried and failed to reuse lookahead token after an
11438  error, discard it. */
11439 
11440  if (yychar <= YYEOF)
11441  {
11442  /* Return failure if at end of input. */
11443  if (yychar == YYEOF)
11444  YYABORT;
11445  }
11446  else
11447  {
11448  yydestruct ("Error: discarding",
11449  yytoken, &yylval, parser);
11450  yychar = YYEMPTY;
11451  }
11452  }
11453 
11454  /* Else will try to reuse lookahead token after shifting the error
11455  token. */
11456  goto yyerrlab1;
11457 
11458 
11459 /*---------------------------------------------------.
11460 | yyerrorlab -- error raised explicitly by YYERROR. |
11461 `---------------------------------------------------*/
11462 yyerrorlab:
11463 
11464  /* Pacify compilers like GCC when the user code never invokes
11465  YYERROR and the label yyerrorlab therefore never appears in user
11466  code. */
11467  if (/*CONSTCOND*/ 0)
11468  goto yyerrorlab;
11469 
11470  /* Do not reclaim the symbols of the rule which action triggered
11471  this YYERROR. */
11472  YYPOPSTACK (yylen);
11473  yylen = 0;
11474  YY_STACK_PRINT (yyss, yyssp);
11475  yystate = *yyssp;
11476  goto yyerrlab1;
11477 
11478 
11479 /*-------------------------------------------------------------.
11480 | yyerrlab1 -- common code for both syntax error and YYERROR. |
11481 `-------------------------------------------------------------*/
11482 yyerrlab1:
11483  yyerrstatus = 3; /* Each real token shifted decrements this. */
11484 
11485  for (;;)
11486  {
11487  yyn = yypact[yystate];
11488  if (!yypact_value_is_default (yyn))
11489  {
11490  yyn += YYTERROR;
11491  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11492  {
11493  yyn = yytable[yyn];
11494  if (0 < yyn)
11495  break;
11496  }
11497  }
11498 
11499  /* Pop the current state because it cannot handle the error token. */
11500  if (yyssp == yyss)
11501  YYABORT;
11502 
11503 
11504  yydestruct ("Error: popping",
11505  yystos[yystate], yyvsp, parser);
11506  YYPOPSTACK (1);
11507  yystate = *yyssp;
11508  YY_STACK_PRINT (yyss, yyssp);
11509  }
11510 
11511  *++yyvsp = yylval;
11512 
11513 
11514  /* Shift the error token. */
11515  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11516 
11517  yystate = yyn;
11518  goto yynewstate;
11519 
11520 
11521 /*-------------------------------------.
11522 | yyacceptlab -- YYACCEPT comes here. |
11523 `-------------------------------------*/
11524 yyacceptlab:
11525  yyresult = 0;
11526  goto yyreturn;
11527 
11528 /*-----------------------------------.
11529 | yyabortlab -- YYABORT comes here. |
11530 `-----------------------------------*/
11531 yyabortlab:
11532  yyresult = 1;
11533  goto yyreturn;
11534 
11535 #if !defined(yyoverflow) || YYERROR_VERBOSE
11536 /*-------------------------------------------------.
11537 | yyexhaustedlab -- memory exhaustion comes here. |
11538 `-------------------------------------------------*/
11539 yyexhaustedlab:
11540  parser_yyerror (parser, YY_("memory exhausted"));
11541  yyresult = 2;
11542  /* Fall through. */
11543 #endif
11544 
11545 yyreturn:
11546  if (yychar != YYEMPTY)
11547  {
11548  /* Make sure we have latest lookahead translation. See comments at
11549  user semantic actions for why this is necessary. */
11550  yytoken = YYTRANSLATE (yychar);
11551  yydestruct ("Cleanup: discarding lookahead",
11552  yytoken, &yylval, parser);
11553  }
11554  /* Do not reclaim the symbols of the rule which action triggered
11555  this YYABORT or YYACCEPT. */
11556  YYPOPSTACK (yylen);
11557  YY_STACK_PRINT (yyss, yyssp);
11558  while (yyssp != yyss)
11559  {
11560  yydestruct ("Cleanup: popping",
11561  yystos[*yyssp], yyvsp, parser);
11562  YYPOPSTACK (1);
11563  }
11564 #ifndef yyoverflow
11565  if (yyss != yyssa)
11566  YYSTACK_FREE (yyss);
11567 #endif
11568 #if YYERROR_VERBOSE
11569  if (yymsg != yymsgbuf)
11570  YYSTACK_FREE (yymsg);
11571 #endif
11572  /* Make sure YYID is used. */
11573  return YYID (yyresult);
11574 }
11575 
11576 
11577 
11578 /* Line 2067 of yacc.c */
11579 #line 4996 "ripper.y"
11580 
11581 # undef parser
11582 # undef yylex
11583 # undef yylval
11584 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
11585 
11586 static int parser_regx_options(struct parser_params*);
11587 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11588 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11589 static int parser_parse_string(struct parser_params*,NODE*);
11590 static int parser_here_document(struct parser_params*,NODE*);
11591 
11592 
11593 # define nextc() parser_nextc(parser)
11594 # define pushback(c) parser_pushback(parser, (c))
11595 # define newtok() parser_newtok(parser)
11596 # define tokspace(n) parser_tokspace(parser, (n))
11597 # define tokadd(c) parser_tokadd(parser, (c))
11598 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
11599 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
11600 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
11601 # define regx_options() parser_regx_options(parser)
11602 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11603 # define parse_string(n) parser_parse_string(parser,(n))
11604 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
11605 # define here_document(n) parser_here_document(parser,(n))
11606 # define heredoc_identifier() parser_heredoc_identifier(parser)
11607 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
11608 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
11609 
11610 #ifndef RIPPER
11611 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11612 # define set_yylval_num(x) (yylval.num = (x))
11613 # define set_yylval_id(x) (yylval.id = (x))
11614 # define set_yylval_name(x) (yylval.id = (x))
11615 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11616 # define set_yylval_node(x) (yylval.node = (x))
11617 # define yylval_id() (yylval.id)
11618 #else
11619 static inline VALUE
11620 ripper_yylval_id(ID x)
11621 {
11622  return (VALUE)NEW_LASGN(x, ID2SYM(x));
11623 }
11624 # define set_yylval_str(x) (void)(x)
11625 # define set_yylval_num(x) (void)(x)
11626 # define set_yylval_id(x) (void)(x)
11627 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11628 # define set_yylval_literal(x) (void)(x)
11629 # define set_yylval_node(x) (void)(x)
11630 # define yylval_id() yylval.id
11631 #endif
11632 
11633 #ifndef RIPPER
11634 #define ripper_flush(p) (void)(p)
11635 #else
11636 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11637 
11638 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11639 
11640 static int
11641 ripper_has_scan_event(struct parser_params *parser)
11642 {
11643 
11644  if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11645  return lex_p > parser->tokp;
11646 }
11647 
11648 static VALUE
11649 ripper_scan_event_val(struct parser_params *parser, int t)
11650 {
11651  VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11652  VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11653  ripper_flush(parser);
11654  return rval;
11655 }
11656 
11657 static void
11658 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11659 {
11660  if (!ripper_has_scan_event(parser)) return;
11661  yylval_rval = ripper_scan_event_val(parser, t);
11662 }
11663 
11664 static void
11665 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11666 {
11667  if (!ripper_has_scan_event(parser)) return;
11668  (void)ripper_scan_event_val(parser, t);
11669 }
11670 
11671 static void
11672 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11673 {
11674  int saved_line = ruby_sourceline;
11675  const char *saved_tokp = parser->tokp;
11676 
11677  ruby_sourceline = parser->delayed_line;
11678  parser->tokp = lex_pbeg + parser->delayed_col;
11679  yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11680  parser->delayed = Qnil;
11681  ruby_sourceline = saved_line;
11682  parser->tokp = saved_tokp;
11683 }
11684 #endif /* RIPPER */
11685 
11686 #include "ruby/regex.h"
11687 #include "ruby/util.h"
11688 
11689 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11690  since ours (we hope) works properly with all combinations of
11691  machines, compilers, `char' and `unsigned char' argument types.
11692  (Per Bothner suggested the basic approach.) */
11693 #undef SIGN_EXTEND_CHAR
11694 #if __STDC__
11695 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11696 #else /* not __STDC__ */
11697 /* As in Harbison and Steele. */
11698 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11699 #endif
11700 
11701 #define parser_encoding_name() (current_enc->name)
11702 #define parser_mbclen() mbclen((lex_p-1),lex_pend,current_enc)
11703 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
11704 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11705 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11706 
11707 #define parser_isascii() ISASCII(*(lex_p-1))
11708 
11709 #ifndef RIPPER
11710 static int
11711 token_info_get_column(struct parser_params *parser, const char *token)
11712 {
11713  int column = 1;
11714  const char *p, *pend = lex_p - strlen(token);
11715  for (p = lex_pbeg; p < pend; p++) {
11716  if (*p == '\t') {
11717  column = (((column - 1) / 8) + 1) * 8;
11718  }
11719  column++;
11720  }
11721  return column;
11722 }
11723 
11724 static int
11725 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11726 {
11727  const char *p, *pend = lex_p - strlen(token);
11728  for (p = lex_pbeg; p < pend; p++) {
11729  if (*p != ' ' && *p != '\t') {
11730  return 1;
11731  }
11732  }
11733  return 0;
11734 }
11735 
11736 #undef token_info_push
11737 static void
11738 token_info_push(struct parser_params *parser, const char *token)
11739 {
11740  token_info *ptinfo;
11741 
11742  if (!parser->parser_token_info_enabled) return;
11743  ptinfo = ALLOC(token_info);
11744  ptinfo->token = token;
11745  ptinfo->linenum = ruby_sourceline;
11746  ptinfo->column = token_info_get_column(parser, token);
11747  ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11748  ptinfo->next = parser->parser_token_info;
11749 
11750  parser->parser_token_info = ptinfo;
11751 }
11752 
11753 #undef token_info_pop
11754 static void
11755 token_info_pop(struct parser_params *parser, const char *token)
11756 {
11757  int linenum;
11758  token_info *ptinfo = parser->parser_token_info;
11759 
11760  if (!ptinfo) return;
11761  parser->parser_token_info = ptinfo->next;
11762  if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11763  goto finish;
11764  }
11765  linenum = ruby_sourceline;
11766  if (linenum == ptinfo->linenum) { /* SKIP */
11767  goto finish;
11768  }
11769  if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11770  goto finish;
11771  }
11772  if (parser->parser_token_info_enabled) {
11774  "mismatched indentations at '%s' with '%s' at %d",
11775  token, ptinfo->token, ptinfo->linenum);
11776  }
11777 
11778  finish:
11779  xfree(ptinfo);
11780 }
11781 #endif /* RIPPER */
11782 
11783 static int
11784 parser_yyerror(struct parser_params *parser, const char *msg)
11785 {
11786 #ifndef RIPPER
11787  const int max_line_margin = 30;
11788  const char *p, *pe;
11789  char *buf;
11790  long len;
11791  int i;
11792 
11793  compile_error(PARSER_ARG "%s", msg);
11794  p = lex_p;
11795  while (lex_pbeg <= p) {
11796  if (*p == '\n') break;
11797  p--;
11798  }
11799  p++;
11800 
11801  pe = lex_p;
11802  while (pe < lex_pend) {
11803  if (*pe == '\n') break;
11804  pe++;
11805  }
11806 
11807  len = pe - p;
11808  if (len > 4) {
11809  char *p2;
11810  const char *pre = "", *post = "";
11811 
11812  if (len > max_line_margin * 2 + 10) {
11813  if (lex_p - p > max_line_margin) {
11814  p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11815  pre = "...";
11816  }
11817  if (pe - lex_p > max_line_margin) {
11818  pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11819  post = "...";
11820  }
11821  len = pe - p;
11822  }
11823  buf = ALLOCA_N(char, len+2);
11824  MEMCPY(buf, p, char, len);
11825  buf[len] = '\0';
11826  rb_compile_error_append("%s%s%s", pre, buf, post);
11827 
11828  i = (int)(lex_p - p);
11829  p2 = buf; pe = buf + len;
11830 
11831  while (p2 < pe) {
11832  if (*p2 != '\t') *p2 = ' ';
11833  p2++;
11834  }
11835  buf[i] = '^';
11836  buf[i+1] = '\0';
11837  rb_compile_error_append("%s%s", pre, buf);
11838  }
11839 #else
11840  dispatch1(parse_error, STR_NEW2(msg));
11841 #endif /* !RIPPER */
11842  return 0;
11843 }
11844 
11845 static void parser_prepare(struct parser_params *parser);
11846 
11847 #ifndef RIPPER
11848 static VALUE
11849 debug_lines(const char *f)
11850 {
11851  ID script_lines;
11852  CONST_ID(script_lines, "SCRIPT_LINES__");
11853  if (rb_const_defined_at(rb_cObject, script_lines)) {
11854  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11855  if (RB_TYPE_P(hash, T_HASH)) {
11857  VALUE lines = rb_ary_new();
11858  rb_hash_aset(hash, fname, lines);
11859  return lines;
11860  }
11861  }
11862  return 0;
11863 }
11864 
11865 static VALUE
11866 coverage(const char *f, int n)
11867 {
11868  VALUE coverages = rb_get_coverages();
11869  if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11871  VALUE lines = rb_ary_new2(n);
11872  int i;
11873  RBASIC(lines)->klass = 0;
11874  for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11875  RARRAY(lines)->as.heap.len = n;
11876  rb_hash_aset(coverages, fname, lines);
11877  return lines;
11878  }
11879  return 0;
11880 }
11881 
11882 static int
11884 {
11885  return strcmp(ruby_sourcefile, "-e") == 0;
11886 }
11887 
11888 static VALUE
11890 {
11891  int n;
11892  NODE *tree;
11893  struct parser_params *parser = (struct parser_params *)arg;
11894 
11895  if (!compile_for_eval && rb_safe_level() == 0) {
11897  if (ruby_debug_lines && ruby_sourceline > 0) {
11898  VALUE str = STR_NEW0();
11899  n = ruby_sourceline;
11900  do {
11902  } while (--n);
11903  }
11904 
11905  if (!e_option_supplied(parser)) {
11907  }
11908  }
11909 
11910  parser_prepare(parser);
11911  deferred_nodes = 0;
11912 #ifndef RIPPER
11914 #endif
11915 #ifndef RIPPER
11918  parser->parser_ruby_sourceline);
11919  }
11920 #endif
11921  n = yyparse((void*)parser);
11922 #ifndef RIPPER
11925  parser->parser_ruby_sourceline);
11926  }
11927 #endif
11928  ruby_debug_lines = 0;
11929  ruby_coverage = 0;
11930  compile_for_eval = 0;
11931 
11932  lex_strterm = 0;
11933  lex_p = lex_pbeg = lex_pend = 0;
11934  lex_lastline = lex_nextline = 0;
11935  if (parser->nerr) {
11936  return 0;
11937  }
11938  tree = ruby_eval_tree;
11939  if (!tree) {
11940  tree = NEW_NIL();
11941  }
11942  else if (ruby_eval_tree_begin) {
11943  tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11944  }
11945  return (VALUE)tree;
11946 }
11947 
11948 static NODE*
11949 yycompile(struct parser_params *parser, const char *f, int line)
11950 {
11952  ruby_sourceline = line - 1;
11953  return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
11954 }
11955 #endif /* !RIPPER */
11956 
11957 static rb_encoding *
11959 {
11960  rb_encoding *enc = rb_enc_get(s);
11961  if (!rb_enc_asciicompat(enc)) {
11962  rb_raise(rb_eArgError, "invalid source encoding");
11963  }
11964  return enc;
11965 }
11966 
11967 static VALUE
11968 lex_get_str(struct parser_params *parser, VALUE s)
11969 {
11970  char *beg, *end, *pend;
11972 
11973  beg = RSTRING_PTR(s);
11974  if (lex_gets_ptr) {
11975  if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11976  beg += lex_gets_ptr;
11977  }
11978  pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11979  end = beg;
11980  while (end < pend) {
11981  if (*end++ == '\n') break;
11982  }
11983  lex_gets_ptr = end - RSTRING_PTR(s);
11984  return rb_enc_str_new(beg, end - beg, enc);
11985 }
11986 
11987 static VALUE
11989 {
11990  VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11991  if (NIL_P(line)) return line;
11993 #ifndef RIPPER
11994  if (ruby_debug_lines) {
11997  }
11998  if (ruby_coverage) {
12000  }
12001 #endif
12002  return line;
12003 }
12004 
12005 #ifdef RIPPER
12007 #else
12009 
12010 static NODE*
12011 parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
12012 {
12013  struct parser_params *parser;
12014  NODE *node;
12015 
12016  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12018  lex_gets_ptr = 0;
12019  lex_input = s;
12020  lex_pbeg = lex_p = lex_pend = 0;
12022 
12023  node = yycompile(parser, f, line);
12024  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12025 
12026  return node;
12027 }
12028 
12029 NODE*
12030 rb_compile_string(const char *f, VALUE s, int line)
12031 {
12033  return parser_compile_string(rb_parser_new(), f, s, line);
12034 }
12035 
12036 NODE*
12037 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
12038 {
12040  return parser_compile_string(vparser, f, s, line);
12041 }
12042 
12043 NODE*
12044 rb_compile_cstr(const char *f, const char *s, int len, int line)
12045 {
12046  VALUE str = rb_str_new(s, len);
12047  return parser_compile_string(rb_parser_new(), f, str, line);
12048 }
12049 
12050 NODE*
12051 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
12052 {
12053  VALUE str = rb_str_new(s, len);
12054  return parser_compile_string(vparser, f, str, line);
12055 }
12056 
12057 static VALUE
12058 lex_io_gets(struct parser_params *parser, VALUE io)
12059 {
12060  return rb_io_gets(io);
12061 }
12062 
12063 NODE*
12064 rb_compile_file(const char *f, VALUE file, int start)
12065 {
12066  VALUE volatile vparser = rb_parser_new();
12067 
12068  return rb_parser_compile_file(vparser, f, file, start);
12069 }
12070 
12071 NODE*
12072 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
12073 {
12074  struct parser_params *parser;
12075  NODE *node;
12076 
12077  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12079  lex_input = file;
12080  lex_pbeg = lex_p = lex_pend = 0;
12082 
12083  node = yycompile(parser, f, start);
12084  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12085 
12086  return node;
12087 }
12088 #endif /* !RIPPER */
12089 
12090 #define STR_FUNC_ESCAPE 0x01
12091 #define STR_FUNC_EXPAND 0x02
12092 #define STR_FUNC_REGEXP 0x04
12093 #define STR_FUNC_QWORDS 0x08
12094 #define STR_FUNC_SYMBOL 0x10
12095 #define STR_FUNC_INDENT 0x20
12096 
12098  str_squote = (0),
12106 };
12107 
12108 static VALUE
12109 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
12110 {
12111  VALUE str;
12112 
12113  str = rb_enc_str_new(p, n, enc);
12114  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12116  }
12117  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12119  }
12120  }
12121 
12122  return str;
12123 }
12124 
12125 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
12126 #define lex_eol_p() (lex_p >= lex_pend)
12127 #define peek(c) peek_n((c), 0)
12128 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
12129 
12130 static inline int
12132 {
12133  int c;
12134 
12135  if (lex_p == lex_pend) {
12136  VALUE v = lex_nextline;
12137  lex_nextline = 0;
12138  if (!v) {
12139  if (parser->eofp)
12140  return -1;
12141 
12142  if (!lex_input || NIL_P(v = lex_getline(parser))) {
12143  parser->eofp = Qtrue;
12144  lex_goto_eol(parser);
12145  return -1;
12146  }
12147  }
12148  {
12149 #ifdef RIPPER
12150  if (parser->tokp < lex_pend) {
12151  if (NIL_P(parser->delayed)) {
12152  parser->delayed = rb_str_buf_new(1024);
12153  rb_enc_associate(parser->delayed, current_enc);
12154  rb_str_buf_cat(parser->delayed,
12155  parser->tokp, lex_pend - parser->tokp);
12156  parser->delayed_line = ruby_sourceline;
12157  parser->delayed_col = (int)(parser->tokp - lex_pbeg);
12158  }
12159  else {
12160  rb_str_buf_cat(parser->delayed,
12161  parser->tokp, lex_pend - parser->tokp);
12162  }
12163  }
12164 #endif
12165  if (heredoc_end > 0) {
12167  heredoc_end = 0;
12168  }
12169  ruby_sourceline++;
12170  parser->line_count++;
12171  lex_pbeg = lex_p = RSTRING_PTR(v);
12172  lex_pend = lex_p + RSTRING_LEN(v);
12173  ripper_flush(parser);
12174  lex_lastline = v;
12175  }
12176  }
12177  c = (unsigned char)*lex_p++;
12178  if (c == '\r' && peek('\n')) {
12179  lex_p++;
12180  c = '\n';
12181  }
12182 
12183  return c;
12184 }
12185 
12186 static void
12187 parser_pushback(struct parser_params *parser, int c)
12188 {
12189  if (c == -1) return;
12190  lex_p--;
12191  if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
12192  lex_p--;
12193  }
12194 }
12195 
12196 #define was_bol() (lex_p == lex_pbeg + 1)
12197 
12198 #define tokfix() (tokenbuf[tokidx]='\0')
12199 #define tok() tokenbuf
12200 #define toklen() tokidx
12201 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
12202 
12203 static char*
12205 {
12206  tokidx = 0;
12208  if (!tokenbuf) {
12209  toksiz = 60;
12210  tokenbuf = ALLOC_N(char, 60);
12211  }
12212  if (toksiz > 4096) {
12213  toksiz = 60;
12214  REALLOC_N(tokenbuf, char, 60);
12215  }
12216  return tokenbuf;
12217 }
12218 
12219 static char *
12220 parser_tokspace(struct parser_params *parser, int n)
12221 {
12222  tokidx += n;
12223 
12224  if (tokidx >= toksiz) {
12225  do {toksiz *= 2;} while (toksiz < tokidx);
12226  REALLOC_N(tokenbuf, char, toksiz);
12227  }
12228  return &tokenbuf[tokidx-n];
12229 }
12230 
12231 static void
12232 parser_tokadd(struct parser_params *parser, int c)
12233 {
12234  tokenbuf[tokidx++] = (char)c;
12235  if (tokidx >= toksiz) {
12236  toksiz *= 2;
12237  REALLOC_N(tokenbuf, char, toksiz);
12238  }
12239 }
12240 
12241 static int
12242 parser_tok_hex(struct parser_params *parser, size_t *numlen)
12243 {
12244  int c;
12245 
12246  c = scan_hex(lex_p, 2, numlen);
12247  if (!*numlen) {
12248  yyerror("invalid hex escape");
12249  return 0;
12250  }
12251  lex_p += *numlen;
12252  return c;
12253 }
12254 
12255 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
12256 
12257 /* return value is for ?\u3042 */
12258 static int
12260  int string_literal, int symbol_literal, int regexp_literal)
12261 {
12262  /*
12263  * If string_literal is true, then we allow multiple codepoints
12264  * in \u{}, and add the codepoints to the current token.
12265  * Otherwise we're parsing a character literal and return a single
12266  * codepoint without adding it
12267  */
12268 
12269  int codepoint;
12270  size_t numlen;
12271 
12272  if (regexp_literal) { tokadd('\\'); tokadd('u'); }
12273 
12274  if (peek('{')) { /* handle \u{...} form */
12275  do {
12276  if (regexp_literal) { tokadd(*lex_p); }
12277  nextc();
12278  codepoint = scan_hex(lex_p, 6, &numlen);
12279  if (numlen == 0) {
12280  yyerror("invalid Unicode escape");
12281  return 0;
12282  }
12283  if (codepoint > 0x10ffff) {
12284  yyerror("invalid Unicode codepoint (too large)");
12285  return 0;
12286  }
12287  lex_p += numlen;
12288  if (regexp_literal) {
12289  tokcopy((int)numlen);
12290  }
12291  else if (codepoint >= 0x80) {
12292  *encp = rb_utf8_encoding();
12293  if (string_literal) tokaddmbc(codepoint, *encp);
12294  }
12295  else if (string_literal) {
12296  tokadd(codepoint);
12297  }
12298  } while (string_literal && (peek(' ') || peek('\t')));
12299 
12300  if (!peek('}')) {
12301  yyerror("unterminated Unicode escape");
12302  return 0;
12303  }
12304 
12305  if (regexp_literal) { tokadd('}'); }
12306  nextc();
12307  }
12308  else { /* handle \uxxxx form */
12309  codepoint = scan_hex(lex_p, 4, &numlen);
12310  if (numlen < 4) {
12311  yyerror("invalid Unicode escape");
12312  return 0;
12313  }
12314  lex_p += 4;
12315  if (regexp_literal) {
12316  tokcopy(4);
12317  }
12318  else if (codepoint >= 0x80) {
12319  *encp = rb_utf8_encoding();
12320  if (string_literal) tokaddmbc(codepoint, *encp);
12321  }
12322  else if (string_literal) {
12323  tokadd(codepoint);
12324  }
12325  }
12326 
12327  return codepoint;
12328 }
12329 
12330 #define ESCAPE_CONTROL 1
12331 #define ESCAPE_META 2
12332 
12333 static int
12334 parser_read_escape(struct parser_params *parser, int flags,
12335  rb_encoding **encp)
12336 {
12337  int c;
12338  size_t numlen;
12339 
12340  switch (c = nextc()) {
12341  case '\\': /* Backslash */
12342  return c;
12343 
12344  case 'n': /* newline */
12345  return '\n';
12346 
12347  case 't': /* horizontal tab */
12348  return '\t';
12349 
12350  case 'r': /* carriage-return */
12351  return '\r';
12352 
12353  case 'f': /* form-feed */
12354  return '\f';
12355 
12356  case 'v': /* vertical tab */
12357  return '\13';
12358 
12359  case 'a': /* alarm(bell) */
12360  return '\007';
12361 
12362  case 'e': /* escape */
12363  return 033;
12364 
12365  case '0': case '1': case '2': case '3': /* octal constant */
12366  case '4': case '5': case '6': case '7':
12367  pushback(c);
12368  c = scan_oct(lex_p, 3, &numlen);
12369  lex_p += numlen;
12370  return c;
12371 
12372  case 'x': /* hex constant */
12373  c = tok_hex(&numlen);
12374  if (numlen == 0) return 0;
12375  return c;
12376 
12377  case 'b': /* backspace */
12378  return '\010';
12379 
12380  case 's': /* space */
12381  return ' ';
12382 
12383  case 'M':
12384  if (flags & ESCAPE_META) goto eof;
12385  if ((c = nextc()) != '-') {
12386  pushback(c);
12387  goto eof;
12388  }
12389  if ((c = nextc()) == '\\') {
12390  if (peek('u')) goto eof;
12391  return read_escape(flags|ESCAPE_META, encp) | 0x80;
12392  }
12393  else if (c == -1 || !ISASCII(c)) goto eof;
12394  else {
12395  return ((c & 0xff) | 0x80);
12396  }
12397 
12398  case 'C':
12399  if ((c = nextc()) != '-') {
12400  pushback(c);
12401  goto eof;
12402  }
12403  case 'c':
12404  if (flags & ESCAPE_CONTROL) goto eof;
12405  if ((c = nextc())== '\\') {
12406  if (peek('u')) goto eof;
12407  c = read_escape(flags|ESCAPE_CONTROL, encp);
12408  }
12409  else if (c == '?')
12410  return 0177;
12411  else if (c == -1 || !ISASCII(c)) goto eof;
12412  return c & 0x9f;
12413 
12414  eof:
12415  case -1:
12416  yyerror("Invalid escape character syntax");
12417  return '\0';
12418 
12419  default:
12420  return c;
12421  }
12422 }
12423 
12424 static void
12426 {
12427  int len = rb_enc_codelen(c, enc);
12428  rb_enc_mbcput(c, tokspace(len), enc);
12429 }
12430 
12431 static int
12433 {
12434  int c;
12435  int flags = 0;
12436  size_t numlen;
12437 
12438  first:
12439  switch (c = nextc()) {
12440  case '\n':
12441  return 0; /* just ignore */
12442 
12443  case '0': case '1': case '2': case '3': /* octal constant */
12444  case '4': case '5': case '6': case '7':
12445  {
12446  ruby_scan_oct(--lex_p, 3, &numlen);
12447  if (numlen == 0) goto eof;
12448  lex_p += numlen;
12449  tokcopy((int)numlen + 1);
12450  }
12451  return 0;
12452 
12453  case 'x': /* hex constant */
12454  {
12455  tok_hex(&numlen);
12456  if (numlen == 0) return -1;
12457  tokcopy((int)numlen + 2);
12458  }
12459  return 0;
12460 
12461  case 'M':
12462  if (flags & ESCAPE_META) goto eof;
12463  if ((c = nextc()) != '-') {
12464  pushback(c);
12465  goto eof;
12466  }
12467  tokcopy(3);
12468  flags |= ESCAPE_META;
12469  goto escaped;
12470 
12471  case 'C':
12472  if (flags & ESCAPE_CONTROL) goto eof;
12473  if ((c = nextc()) != '-') {
12474  pushback(c);
12475  goto eof;
12476  }
12477  tokcopy(3);
12478  goto escaped;
12479 
12480  case 'c':
12481  if (flags & ESCAPE_CONTROL) goto eof;
12482  tokcopy(2);
12483  flags |= ESCAPE_CONTROL;
12484  escaped:
12485  if ((c = nextc()) == '\\') {
12486  goto first;
12487  }
12488  else if (c == -1) goto eof;
12489  tokadd(c);
12490  return 0;
12491 
12492  eof:
12493  case -1:
12494  yyerror("Invalid escape character syntax");
12495  return -1;
12496 
12497  default:
12498  tokadd('\\');
12499  tokadd(c);
12500  }
12501  return 0;
12502 }
12503 
12504 static int
12506 {
12507  int kcode = 0;
12508  int kopt = 0;
12509  int options = 0;
12510  int c, opt, kc;
12511 
12512  newtok();
12513  while (c = nextc(), ISALPHA(c)) {
12514  if (c == 'o') {
12515  options |= RE_OPTION_ONCE;
12516  }
12517  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12518  if (kc >= 0) {
12519  if (kc != rb_ascii8bit_encindex()) kcode = c;
12520  kopt = opt;
12521  }
12522  else {
12523  options |= opt;
12524  }
12525  }
12526  else {
12527  tokadd(c);
12528  }
12529  }
12530  options |= kopt;
12531  pushback(c);
12532  if (toklen()) {
12533  tokfix();
12534  compile_error(PARSER_ARG "unknown regexp option%s - %s",
12535  toklen() > 1 ? "s" : "", tok());
12536  }
12537  return options | RE_OPTION_ENCODING(kcode);
12538 }
12539 
12540 static void
12542 {
12543  rb_str_free(str);
12544  rb_gc_force_recycle(str);
12545 }
12546 
12547 static int
12549 {
12550  int len = parser_precise_mbclen();
12551  if (!MBCLEN_CHARFOUND_P(len)) {
12552  compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12553  return -1;
12554  }
12555  tokadd(c);
12556  lex_p += --len;
12557  if (len > 0) tokcopy(len);
12558  return c;
12559 }
12560 
12561 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12562 
12563 static inline int
12565 {
12566  switch (c) {
12567  case '$': case '*': case '+': case '.':
12568  case '?': case '^': case '|':
12569  case ')': case ']': case '}': case '>':
12570  return TRUE;
12571  default:
12572  return FALSE;
12573  }
12574 }
12575 
12576 static int
12578  int func, int term, int paren, long *nest,
12579  rb_encoding **encp)
12580 {
12581  int c;
12582  int has_nonascii = 0;
12583  rb_encoding *enc = *encp;
12584  char *errbuf = 0;
12585  static const char mixed_msg[] = "%s mixed within %s source";
12586 
12587 #define mixed_error(enc1, enc2) if (!errbuf) { \
12588  size_t len = sizeof(mixed_msg) - 4; \
12589  len += strlen(rb_enc_name(enc1)); \
12590  len += strlen(rb_enc_name(enc2)); \
12591  errbuf = ALLOCA_N(char, len); \
12592  snprintf(errbuf, len, mixed_msg, \
12593  rb_enc_name(enc1), \
12594  rb_enc_name(enc2)); \
12595  yyerror(errbuf); \
12596  }
12597 #define mixed_escape(beg, enc1, enc2) do { \
12598  const char *pos = lex_p; \
12599  lex_p = (beg); \
12600  mixed_error((enc1), (enc2)); \
12601  lex_p = pos; \
12602  } while (0)
12603 
12604  while ((c = nextc()) != -1) {
12605  if (paren && c == paren) {
12606  ++*nest;
12607  }
12608  else if (c == term) {
12609  if (!nest || !*nest) {
12610  pushback(c);
12611  break;
12612  }
12613  --*nest;
12614  }
12615  else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12616  int c2 = *lex_p;
12617  if (c2 == '$' || c2 == '@' || c2 == '{') {
12618  pushback(c);
12619  break;
12620  }
12621  }
12622  else if (c == '\\') {
12623  const char *beg = lex_p - 1;
12624  c = nextc();
12625  switch (c) {
12626  case '\n':
12627  if (func & STR_FUNC_QWORDS) break;
12628  if (func & STR_FUNC_EXPAND) continue;
12629  tokadd('\\');
12630  break;
12631 
12632  case '\\':
12633  if (func & STR_FUNC_ESCAPE) tokadd(c);
12634  break;
12635 
12636  case 'u':
12637  if ((func & STR_FUNC_EXPAND) == 0) {
12638  tokadd('\\');
12639  break;
12640  }
12641  parser_tokadd_utf8(parser, &enc, 1,
12642  func & STR_FUNC_SYMBOL,
12643  func & STR_FUNC_REGEXP);
12644  if (has_nonascii && enc != *encp) {
12645  mixed_escape(beg, enc, *encp);
12646  }
12647  continue;
12648 
12649  default:
12650  if (c == -1) return -1;
12651  if (!ISASCII(c)) {
12652  if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12653  goto non_ascii;
12654  }
12655  if (func & STR_FUNC_REGEXP) {
12656  if (c == term && !simple_re_meta(c)) {
12657  tokadd(c);
12658  continue;
12659  }
12660  pushback(c);
12661  if ((c = tokadd_escape(&enc)) < 0)
12662  return -1;
12663  if (has_nonascii && enc != *encp) {
12664  mixed_escape(beg, enc, *encp);
12665  }
12666  continue;
12667  }
12668  else if (func & STR_FUNC_EXPAND) {
12669  pushback(c);
12670  if (func & STR_FUNC_ESCAPE) tokadd('\\');
12671  c = read_escape(0, &enc);
12672  }
12673  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12674  /* ignore backslashed spaces in %w */
12675  }
12676  else if (c != term && !(paren && c == paren)) {
12677  tokadd('\\');
12678  pushback(c);
12679  continue;
12680  }
12681  }
12682  }
12683  else if (!parser_isascii()) {
12684  non_ascii:
12685  has_nonascii = 1;
12686  if (enc != *encp) {
12687  mixed_error(enc, *encp);
12688  continue;
12689  }
12690  if (tokadd_mbchar(c) == -1) return -1;
12691  continue;
12692  }
12693  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12694  pushback(c);
12695  break;
12696  }
12697  if (c & 0x80) {
12698  has_nonascii = 1;
12699  if (enc != *encp) {
12700  mixed_error(enc, *encp);
12701  continue;
12702  }
12703  }
12704  tokadd(c);
12705  }
12706  *encp = enc;
12707  return c;
12708 }
12709 
12710 #define NEW_STRTERM(func, term, paren) \
12711  rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12712 
12713 #ifdef RIPPER
12714 static void
12715 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12716 {
12717  if (!NIL_P(parser->delayed)) {
12718  ptrdiff_t len = lex_p - parser->tokp;
12719  if (len > 0) {
12720  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12721  }
12722  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12723  parser->tokp = lex_p;
12724  }
12725 }
12726 
12727 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12728 #else
12729 #define flush_string_content(enc) ((void)(enc))
12730 #endif
12731 
12732 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12733 /* this can be shared with ripper, since it's independent from struct
12734  * parser_params. */
12735 #ifndef RIPPER
12736 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12737 #define SPECIAL_PUNCT(idx) ( \
12738  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12739  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12740  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12741  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12742  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12743  BIT('0', idx))
12744 const unsigned int ruby_global_name_punct_bits[] = {
12745  SPECIAL_PUNCT(0),
12746  SPECIAL_PUNCT(1),
12747  SPECIAL_PUNCT(2),
12748 };
12749 #undef BIT
12750 #undef SPECIAL_PUNCT
12751 #endif
12752 
12753 static inline int
12755 {
12756  if (c <= 0x20 || 0x7e < c) return 0;
12757  return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12758 }
12759 
12760 static int
12762 {
12763  int c;
12764  const char *p = lex_p;
12765 
12766  if (p + 1 >= lex_pend) return 0;
12767  c = *p++;
12768  switch (c) {
12769  case '$':
12770  if ((c = *p) == '-') {
12771  if (++p >= lex_pend) return 0;
12772  c = *p;
12773  }
12774  else if (is_global_name_punct(c) || ISDIGIT(c)) {
12775  return tSTRING_DVAR;
12776  }
12777  break;
12778  case '@':
12779  if ((c = *p) == '@') {
12780  if (++p >= lex_pend) return 0;
12781  c = *p;
12782  }
12783  break;
12784  case '{':
12785  lex_p = p;
12786  command_start = TRUE;
12787  return tSTRING_DBEG;
12788  default:
12789  return 0;
12790  }
12791  if (!ISASCII(c) || c == '_' || ISALPHA(c))
12792  return tSTRING_DVAR;
12793  return 0;
12794 }
12795 
12796 static int
12797 parser_parse_string(struct parser_params *parser, NODE *quote)
12798 {
12799  int func = (int)quote->nd_func;
12800  int term = nd_term(quote);
12801  int paren = nd_paren(quote);
12802  int c, space = 0;
12804 
12805  if (func == -1) return tSTRING_END;
12806  c = nextc();
12807  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12808  do {c = nextc();} while (ISSPACE(c));
12809  space = 1;
12810  }
12811  if (c == term && !quote->nd_nest) {
12812  if (func & STR_FUNC_QWORDS) {
12813  quote->nd_func = -1;
12814  return ' ';
12815  }
12816  if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12818  return tREGEXP_END;
12819  }
12820  if (space) {
12821  pushback(c);
12822  return ' ';
12823  }
12824  newtok();
12825  if ((func & STR_FUNC_EXPAND) && c == '#') {
12826  int t = parser_peek_variable_name(parser);
12827  if (t) return t;
12828  tokadd('#');
12829  c = nextc();
12830  }
12831  pushback(c);
12832  if (tokadd_string(func, term, paren, &quote->nd_nest,
12833  &enc) == -1) {
12834  ruby_sourceline = nd_line(quote);
12835  if (func & STR_FUNC_REGEXP) {
12836  if (parser->eofp)
12837  compile_error(PARSER_ARG "unterminated regexp meets end of file");
12838  return tREGEXP_END;
12839  }
12840  else {
12841  if (parser->eofp)
12842  compile_error(PARSER_ARG "unterminated string meets end of file");
12843  return tSTRING_END;
12844  }
12845  }
12846 
12847  tokfix();
12848  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12849  flush_string_content(enc);
12850 
12851  return tSTRING_CONTENT;
12852 }
12853 
12854 static int
12856 {
12857  int c = nextc(), term, func = 0;
12858  long len;
12859 
12860  if (c == '-') {
12861  c = nextc();
12862  func = STR_FUNC_INDENT;
12863  }
12864  switch (c) {
12865  case '\'':
12866  func |= str_squote; goto quoted;
12867  case '"':
12868  func |= str_dquote; goto quoted;
12869  case '`':
12870  func |= str_xquote;
12871  quoted:
12872  newtok();
12873  tokadd(func);
12874  term = c;
12875  while ((c = nextc()) != -1 && c != term) {
12876  if (tokadd_mbchar(c) == -1) return 0;
12877  }
12878  if (c == -1) {
12879  compile_error(PARSER_ARG "unterminated here document identifier");
12880  return 0;
12881  }
12882  break;
12883 
12884  default:
12885  if (!parser_is_identchar()) {
12886  pushback(c);
12887  if (func & STR_FUNC_INDENT) {
12888  pushback('-');
12889  }
12890  return 0;
12891  }
12892  newtok();
12893  term = '"';
12894  tokadd(func |= str_dquote);
12895  do {
12896  if (tokadd_mbchar(c) == -1) return 0;
12897  } while ((c = nextc()) != -1 && parser_is_identchar());
12898  pushback(c);
12899  break;
12900  }
12901 
12902  tokfix();
12903 #ifdef RIPPER
12904  ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12905 #endif
12906  len = lex_p - lex_pbeg;
12907  lex_goto_eol(parser);
12909  STR_NEW(tok(), toklen()), /* nd_lit */
12910  len, /* nd_nth */
12911  lex_lastline); /* nd_orig */
12913  ripper_flush(parser);
12914  return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12915 }
12916 
12917 static void
12919 {
12920  VALUE line;
12921 
12922  line = here->nd_orig;
12923  lex_lastline = line;
12924  lex_pbeg = RSTRING_PTR(line);
12925  lex_pend = lex_pbeg + RSTRING_LEN(line);
12926  lex_p = lex_pbeg + here->nd_nth;
12928  ruby_sourceline = nd_line(here);
12929  dispose_string(here->nd_lit);
12930  rb_gc_force_recycle((VALUE)here);
12931  ripper_flush(parser);
12932 }
12933 
12934 static int
12936  const char *eos, long len, int indent)
12937 {
12938  const char *p = lex_pbeg;
12939  long n;
12940 
12941  if (indent) {
12942  while (*p && ISSPACE(*p)) p++;
12943  }
12944  n = lex_pend - (p + len);
12945  if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12946  return strncmp(eos, p, len) == 0;
12947 }
12948 
12949 #ifdef RIPPER
12950 static void
12951 ripper_dispatch_heredoc_end(struct parser_params *parser)
12952 {
12953  if (!NIL_P(parser->delayed))
12954  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12955  lex_goto_eol(parser);
12956  ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12957 }
12958 
12959 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12960 #else
12961 #define dispatch_heredoc_end() ((void)0)
12962 #endif
12963 
12964 static int
12966 {
12967  int c, func, indent = 0;
12968  const char *eos, *p, *pend;
12969  long len;
12970  VALUE str = 0;
12972 
12973  eos = RSTRING_PTR(here->nd_lit);
12974  len = RSTRING_LEN(here->nd_lit) - 1;
12975  indent = (func = *eos++) & STR_FUNC_INDENT;
12976 
12977  if ((c = nextc()) == -1) {
12978  error:
12979  compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12980 #ifdef RIPPER
12981  if (NIL_P(parser->delayed)) {
12982  ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12983  }
12984  else {
12985  if (str ||
12986  ((len = lex_p - parser->tokp) > 0 &&
12987  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12988  rb_str_append(parser->delayed, str);
12989  }
12990  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12991  }
12992  lex_goto_eol(parser);
12993 #endif
12994  restore:
12996  lex_strterm = 0;
12997  return 0;
12998  }
12999  if (was_bol() && whole_match_p(eos, len, indent)) {
13002  return tSTRING_END;
13003  }
13004 
13005  if (!(func & STR_FUNC_EXPAND)) {
13006  do {
13008  pend = lex_pend;
13009  if (pend > p) {
13010  switch (pend[-1]) {
13011  case '\n':
13012  if (--pend == p || pend[-1] != '\r') {
13013  pend++;
13014  break;
13015  }
13016  case '\r':
13017  --pend;
13018  }
13019  }
13020  if (str)
13021  rb_str_cat(str, p, pend - p);
13022  else
13023  str = STR_NEW(p, pend - p);
13024  if (pend < lex_pend) rb_str_cat(str, "\n", 1);
13025  lex_goto_eol(parser);
13026  if (nextc() == -1) {
13027  if (str) dispose_string(str);
13028  goto error;
13029  }
13030  } while (!whole_match_p(eos, len, indent));
13031  }
13032  else {
13033  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
13034  newtok();
13035  if (c == '#') {
13036  int t = parser_peek_variable_name(parser);
13037  if (t) return t;
13038  tokadd('#');
13039  c = nextc();
13040  }
13041  do {
13042  pushback(c);
13043  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
13044  if (parser->eofp) goto error;
13045  goto restore;
13046  }
13047  if (c != '\n') {
13048  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
13049  flush_string_content(enc);
13050  return tSTRING_CONTENT;
13051  }
13052  tokadd(nextc());
13053  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
13054  if ((c = nextc()) == -1) goto error;
13055  } while (!whole_match_p(eos, len, indent));
13056  str = STR_NEW3(tok(), toklen(), enc, func);
13057  }
13060  lex_strterm = NEW_STRTERM(-1, 0, 0);
13061  set_yylval_str(str);
13062  return tSTRING_CONTENT;
13063 }
13064 
13065 #include "lex.c"
13066 
13067 static void
13069 {
13070 #ifndef RIPPER
13071  rb_warning0("ambiguous first argument; put parentheses or even spaces");
13072 #else
13074 #endif
13075 }
13076 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
13077 
13078 static ID
13080 {
13081 #ifndef RIPPER
13082  if (!is_local_id(lhs))
13083  yyerror("formal argument must be local variable");
13084 #endif
13085  shadowing_lvar(lhs);
13086  return lhs;
13087 }
13088 
13089 static int
13090 lvar_defined_gen(struct parser_params *parser, ID id)
13091 {
13092  return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
13093 }
13094 
13095 /* emacsen -*- hack */
13096 static long
13097 parser_encode_length(struct parser_params *parser, const char *name, long len)
13098 {
13099  long nlen;
13100 
13101  if (len > 5 && name[nlen = len - 5] == '-') {
13102  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
13103  return nlen;
13104  }
13105  if (len > 4 && name[nlen = len - 4] == '-') {
13106  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
13107  return nlen;
13108  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
13109  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
13110  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
13111  return nlen;
13112  }
13113  return len;
13114 }
13115 
13116 static void
13117 parser_set_encode(struct parser_params *parser, const char *name)
13118 {
13119  int idx = rb_enc_find_index(name);
13120  rb_encoding *enc;
13121  VALUE excargs[3];
13122 
13123  if (idx < 0) {
13124  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
13125  error:
13126  excargs[0] = rb_eArgError;
13127  excargs[2] = rb_make_backtrace();
13128  rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
13129  rb_exc_raise(rb_make_exception(3, excargs));
13130  }
13131  enc = rb_enc_from_index(idx);
13132  if (!rb_enc_asciicompat(enc)) {
13133  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13134  goto error;
13135  }
13136  parser->enc = enc;
13137 #ifndef RIPPER
13138  if (ruby_debug_lines) {
13139  long i, n = RARRAY_LEN(ruby_debug_lines);
13140  const VALUE *p = RARRAY_PTR(ruby_debug_lines);
13141  for (i = 0; i < n; ++i) {
13142  rb_enc_associate_index(*p, idx);
13143  }
13144  }
13145 #endif
13146 }
13147 
13148 static int
13150 {
13151  const char *p = lex_pbeg, *pend = lex_p - 1;
13152  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13153  while (p < pend) {
13154  if (!ISSPACE(*p)) return 0;
13155  p++;
13156  }
13157  return 1;
13158 }
13159 
13160 #ifndef RIPPER
13161 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13162 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13163 
13164 static void
13165 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13166 {
13167  if (!comment_at_top(parser)) {
13168  return;
13169  }
13170  parser_set_encode(parser, val);
13171 }
13172 
13173 static void
13174 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13175 {
13176  int *p = &parser->parser_token_info_enabled;
13177 
13178  switch (*val) {
13179  case 't': case 'T':
13180  if (strcasecmp(val, "true") == 0) {
13181  *p = TRUE;
13182  return;
13183  }
13184  break;
13185  case 'f': case 'F':
13186  if (strcasecmp(val, "false") == 0) {
13187  *p = FALSE;
13188  return;
13189  }
13190  break;
13191  }
13192  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13193 }
13194 
13196  const char *name;
13199 };
13200 
13201 static const struct magic_comment magic_comments[] = {
13204  {"warn_indent", parser_set_token_info},
13205 };
13206 #endif
13207 
13208 static const char *
13209 magic_comment_marker(const char *str, long len)
13210 {
13211  long i = 2;
13212 
13213  while (i < len) {
13214  switch (str[i]) {
13215  case '-':
13216  if (str[i-1] == '*' && str[i-2] == '-') {
13217  return str + i + 1;
13218  }
13219  i += 2;
13220  break;
13221  case '*':
13222  if (i + 1 >= len) return 0;
13223  if (str[i+1] != '-') {
13224  i += 4;
13225  }
13226  else if (str[i-1] != '-') {
13227  i += 2;
13228  }
13229  else {
13230  return str + i + 2;
13231  }
13232  break;
13233  default:
13234  i += 3;
13235  break;
13236  }
13237  }
13238  return 0;
13239 }
13240 
13241 static int
13242 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13243 {
13244  VALUE name = 0, val = 0;
13245  const char *beg, *end, *vbeg, *vend;
13246 #define str_copy(_s, _p, _n) ((_s) \
13247  ? (void)(rb_str_resize((_s), (_n)), \
13248  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13249  : (void)((_s) = STR_NEW((_p), (_n))))
13250 
13251  if (len <= 7) return FALSE;
13252  if (!(beg = magic_comment_marker(str, len))) return FALSE;
13253  if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13254  str = beg;
13255  len = end - beg - 3;
13256 
13257  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13258  while (len > 0) {
13259 #ifndef RIPPER
13260  const struct magic_comment *p = magic_comments;
13261 #endif
13262  char *s;
13263  int i;
13264  long n = 0;
13265 
13266  for (; len > 0 && *str; str++, --len) {
13267  switch (*str) {
13268  case '\'': case '"': case ':': case ';':
13269  continue;
13270  }
13271  if (!ISSPACE(*str)) break;
13272  }
13273  for (beg = str; len > 0; str++, --len) {
13274  switch (*str) {
13275  case '\'': case '"': case ':': case ';':
13276  break;
13277  default:
13278  if (ISSPACE(*str)) break;
13279  continue;
13280  }
13281  break;
13282  }
13283  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13284  if (!len) break;
13285  if (*str != ':') continue;
13286 
13287  do str++; while (--len > 0 && ISSPACE(*str));
13288  if (!len) break;
13289  if (*str == '"') {
13290  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13291  if (*str == '\\') {
13292  --len;
13293  ++str;
13294  }
13295  }
13296  vend = str;
13297  if (len) {
13298  --len;
13299  ++str;
13300  }
13301  }
13302  else {
13303  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13304  vend = str;
13305  }
13306  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13307 
13308  n = end - beg;
13309  str_copy(name, beg, n);
13310  s = RSTRING_PTR(name);
13311  for (i = 0; i < n; ++i) {
13312  if (s[i] == '-') s[i] = '_';
13313  }
13314 #ifndef RIPPER
13315  do {
13316  if (STRNCASECMP(p->name, s, n) == 0) {
13317  n = vend - vbeg;
13318  if (p->length) {
13319  n = (*p->length)(parser, vbeg, n);
13320  }
13321  str_copy(val, vbeg, n);
13322  (*p->func)(parser, s, RSTRING_PTR(val));
13323  break;
13324  }
13325  } while (++p < magic_comments + numberof(magic_comments));
13326 #else
13327  str_copy(val, vbeg, vend - vbeg);
13328  dispatch2(magic_comment, name, val);
13329 #endif
13330  }
13331 
13332  return TRUE;
13333 }
13334 
13335 static void
13336 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13337 {
13338  int sep = 0;
13339  const char *beg = str;
13340  VALUE s;
13341 
13342  for (;;) {
13343  if (send - str <= 6) return;
13344  switch (str[6]) {
13345  case 'C': case 'c': str += 6; continue;
13346  case 'O': case 'o': str += 5; continue;
13347  case 'D': case 'd': str += 4; continue;
13348  case 'I': case 'i': str += 3; continue;
13349  case 'N': case 'n': str += 2; continue;
13350  case 'G': case 'g': str += 1; continue;
13351  case '=': case ':':
13352  sep = 1;
13353  str += 6;
13354  break;
13355  default:
13356  str += 6;
13357  if (ISSPACE(*str)) break;
13358  continue;
13359  }
13360  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13361  }
13362  for (;;) {
13363  do {
13364  if (++str >= send) return;
13365  } while (ISSPACE(*str));
13366  if (sep) break;
13367  if (*str != '=' && *str != ':') return;
13368  sep = 1;
13369  str++;
13370  }
13371  beg = str;
13372  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13373  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13374  parser_set_encode(parser, RSTRING_PTR(s));
13375  rb_str_resize(s, 0);
13376 }
13377 
13378 static void
13380 {
13381  int c = nextc();
13382  switch (c) {
13383  case '#':
13384  if (peek('!')) parser->has_shebang = 1;
13385  break;
13386  case 0xef: /* UTF-8 BOM marker */
13387  if (lex_pend - lex_p >= 2 &&
13388  (unsigned char)lex_p[0] == 0xbb &&
13389  (unsigned char)lex_p[1] == 0xbf) {
13390  parser->enc = rb_utf8_encoding();
13391  lex_p += 2;
13392  lex_pbeg = lex_p;
13393  return;
13394  }
13395  break;
13396  case EOF:
13397  return;
13398  }
13399  pushback(c);
13400  parser->enc = rb_enc_get(lex_lastline);
13401 }
13402 
13403 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13404 #define IS_END() IS_lex_state(EXPR_END_ANY)
13405 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13406 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13407 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13408 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13409 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13410 
13411 #ifndef RIPPER
13412 #define ambiguous_operator(op, syn) ( \
13413  rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
13414  rb_warning0("even though it seems like "syn""))
13415 #else
13416 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13417 #endif
13418 #define warn_balanced(op, syn) ((void) \
13419  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13420  space_seen && !ISSPACE(c) && \
13421  (ambiguous_operator(op, syn), 0)))
13422 
13423 static int
13425 {
13426  register int c;
13427  int space_seen = 0;
13428  int cmd_state;
13429  enum lex_state_e last_state;
13430  rb_encoding *enc;
13431  int mb;
13432 #ifdef RIPPER
13433  int fallthru = FALSE;
13434 #endif
13435 
13436  if (lex_strterm) {
13437  int token;
13438  if (nd_type(lex_strterm) == NODE_HEREDOC) {
13439  token = here_document(lex_strterm);
13440  if (token == tSTRING_END) {
13441  lex_strterm = 0;
13442  lex_state = EXPR_END;
13443  }
13444  }
13445  else {
13446  token = parse_string(lex_strterm);
13447  if (token == tSTRING_END || token == tREGEXP_END) {
13449  lex_strterm = 0;
13450  lex_state = EXPR_END;
13451  }
13452  }
13453  return token;
13454  }
13455  cmd_state = command_start;
13456  command_start = FALSE;
13457  retry:
13458  last_state = lex_state;
13459  switch (c = nextc()) {
13460  case '\0': /* NUL */
13461  case '\004': /* ^D */
13462  case '\032': /* ^Z */
13463  case -1: /* end of script. */
13464  return 0;
13465 
13466  /* white spaces */
13467  case ' ': case '\t': case '\f': case '\r':
13468  case '\13': /* '\v' */
13469  space_seen = 1;
13470 #ifdef RIPPER
13471  while ((c = nextc())) {
13472  switch (c) {
13473  case ' ': case '\t': case '\f': case '\r':
13474  case '\13': /* '\v' */
13475  break;
13476  default:
13477  goto outofloop;
13478  }
13479  }
13480  outofloop:
13481  pushback(c);
13482  ripper_dispatch_scan_event(parser, tSP);
13483 #endif
13484  goto retry;
13485 
13486  case '#': /* it's a comment */
13487  /* no magic_comment in shebang line */
13488  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13489  if (comment_at_top(parser)) {
13490  set_file_encoding(parser, lex_p, lex_pend);
13491  }
13492  }
13493  lex_p = lex_pend;
13494 #ifdef RIPPER
13495  ripper_dispatch_scan_event(parser, tCOMMENT);
13496  fallthru = TRUE;
13497 #endif
13498  /* fall through */
13499  case '\n':
13500  if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT)) {
13501 #ifdef RIPPER
13502  if (!fallthru) {
13503  ripper_dispatch_scan_event(parser, tIGNORED_NL);
13504  }
13505  fallthru = FALSE;
13506 #endif
13507  goto retry;
13508  }
13509  while ((c = nextc())) {
13510  switch (c) {
13511  case ' ': case '\t': case '\f': case '\r':
13512  case '\13': /* '\v' */
13513  space_seen = 1;
13514  break;
13515  case '.': {
13516  if ((c = nextc()) != '.') {
13517  pushback(c);
13518  pushback('.');
13519  goto retry;
13520  }
13521  }
13522  default:
13523  --ruby_sourceline;
13525  case -1: /* EOF no decrement*/
13526  lex_goto_eol(parser);
13527 #ifdef RIPPER
13528  if (c != -1) {
13529  parser->tokp = lex_p;
13530  }
13531 #endif
13532  goto normal_newline;
13533  }
13534  }
13535  normal_newline:
13536  command_start = TRUE;
13537  lex_state = EXPR_BEG;
13538  return '\n';
13539 
13540  case '*':
13541  if ((c = nextc()) == '*') {
13542  if ((c = nextc()) == '=') {
13544  lex_state = EXPR_BEG;
13545  return tOP_ASGN;
13546  }
13547  pushback(c);
13548  if (IS_SPCARG(c)) {
13549  rb_warning0("`**' interpreted as argument prefix");
13550  c = tDSTAR;
13551  }
13552  else if (IS_BEG()) {
13553  c = tDSTAR;
13554  }
13555  else {
13556  warn_balanced("**", "argument prefix");
13557  c = tPOW;
13558  }
13559  }
13560  else {
13561  if (c == '=') {
13562  set_yylval_id('*');
13563  lex_state = EXPR_BEG;
13564  return tOP_ASGN;
13565  }
13566  pushback(c);
13567  if (IS_SPCARG(c)) {
13568  rb_warning0("`*' interpreted as argument prefix");
13569  c = tSTAR;
13570  }
13571  else if (IS_BEG()) {
13572  c = tSTAR;
13573  }
13574  else {
13575  warn_balanced("*", "argument prefix");
13576  c = '*';
13577  }
13578  }
13579  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13580  return c;
13581 
13582  case '!':
13583  c = nextc();
13584  if (IS_AFTER_OPERATOR()) {
13585  lex_state = EXPR_ARG;
13586  if (c == '@') {
13587  return '!';
13588  }
13589  }
13590  else {
13591  lex_state = EXPR_BEG;
13592  }
13593  if (c == '=') {
13594  return tNEQ;
13595  }
13596  if (c == '~') {
13597  return tNMATCH;
13598  }
13599  pushback(c);
13600  return '!';
13601 
13602  case '=':
13603  if (was_bol()) {
13604  /* skip embedded rd document */
13605  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13606 #ifdef RIPPER
13607  int first_p = TRUE;
13608 
13609  lex_goto_eol(parser);
13610  ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13611 #endif
13612  for (;;) {
13613  lex_goto_eol(parser);
13614 #ifdef RIPPER
13615  if (!first_p) {
13616  ripper_dispatch_scan_event(parser, tEMBDOC);
13617  }
13618  first_p = FALSE;
13619 #endif
13620  c = nextc();
13621  if (c == -1) {
13622  compile_error(PARSER_ARG "embedded document meets end of file");
13623  return 0;
13624  }
13625  if (c != '=') continue;
13626  if (strncmp(lex_p, "end", 3) == 0 &&
13627  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13628  break;
13629  }
13630  }
13631  lex_goto_eol(parser);
13632 #ifdef RIPPER
13633  ripper_dispatch_scan_event(parser, tEMBDOC_END);
13634 #endif
13635  goto retry;
13636  }
13637  }
13638 
13639  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13640  if ((c = nextc()) == '=') {
13641  if ((c = nextc()) == '=') {
13642  return tEQQ;
13643  }
13644  pushback(c);
13645  return tEQ;
13646  }
13647  if (c == '~') {
13648  return tMATCH;
13649  }
13650  else if (c == '>') {
13651  return tASSOC;
13652  }
13653  pushback(c);
13654  return '=';
13655 
13656  case '<':
13657  last_state = lex_state;
13658  c = nextc();
13659  if (c == '<' &&
13660  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13661  !IS_END() &&
13662  (!IS_ARG() || space_seen)) {
13663  int token = heredoc_identifier();
13664  if (token) return token;
13665  }
13666  if (IS_AFTER_OPERATOR()) {
13667  lex_state = EXPR_ARG;
13668  }
13669  else {
13670  if (IS_lex_state(EXPR_CLASS))
13671  command_start = TRUE;
13672  lex_state = EXPR_BEG;
13673  }
13674  if (c == '=') {
13675  if ((c = nextc()) == '>') {
13676  return tCMP;
13677  }
13678  pushback(c);
13679  return tLEQ;
13680  }
13681  if (c == '<') {
13682  if ((c = nextc()) == '=') {
13684  lex_state = EXPR_BEG;
13685  return tOP_ASGN;
13686  }
13687  pushback(c);
13688  warn_balanced("<<", "here document");
13689  return tLSHFT;
13690  }
13691  pushback(c);
13692  return '<';
13693 
13694  case '>':
13695  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13696  if ((c = nextc()) == '=') {
13697  return tGEQ;
13698  }
13699  if (c == '>') {
13700  if ((c = nextc()) == '=') {
13702  lex_state = EXPR_BEG;
13703  return tOP_ASGN;
13704  }
13705  pushback(c);
13706  return tRSHFT;
13707  }
13708  pushback(c);
13709  return '>';
13710 
13711  case '"':
13712  lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13713  return tSTRING_BEG;
13714 
13715  case '`':
13716  if (IS_lex_state(EXPR_FNAME)) {
13717  lex_state = EXPR_ENDFN;
13718  return c;
13719  }
13720  if (IS_lex_state(EXPR_DOT)) {
13721  if (cmd_state)
13722  lex_state = EXPR_CMDARG;
13723  else
13724  lex_state = EXPR_ARG;
13725  return c;
13726  }
13727  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13728  return tXSTRING_BEG;
13729 
13730  case '\'':
13731  lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13732  return tSTRING_BEG;
13733 
13734  case '?':
13735  if (IS_END()) {
13736  lex_state = EXPR_VALUE;
13737  return '?';
13738  }
13739  c = nextc();
13740  if (c == -1) {
13741  compile_error(PARSER_ARG "incomplete character syntax");
13742  return 0;
13743  }
13744  if (rb_enc_isspace(c, current_enc)) {
13745  if (!IS_ARG()) {
13746  int c2 = 0;
13747  switch (c) {
13748  case ' ':
13749  c2 = 's';
13750  break;
13751  case '\n':
13752  c2 = 'n';
13753  break;
13754  case '\t':
13755  c2 = 't';
13756  break;
13757  case '\v':
13758  c2 = 'v';
13759  break;
13760  case '\r':
13761  c2 = 'r';
13762  break;
13763  case '\f':
13764  c2 = 'f';
13765  break;
13766  }
13767  if (c2) {
13768  rb_warnI("invalid character syntax; use ?\\%c", c2);
13769  }
13770  }
13771  ternary:
13772  pushback(c);
13773  lex_state = EXPR_VALUE;
13774  return '?';
13775  }
13776  newtok();
13777  enc = current_enc;
13778  if (!parser_isascii()) {
13779  if (tokadd_mbchar(c) == -1) return 0;
13780  }
13781  else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13783  goto ternary;
13784  }
13785  else if (c == '\\') {
13786  if (peek('u')) {
13787  nextc();
13788  c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13789  if (0x80 <= c) {
13790  tokaddmbc(c, enc);
13791  }
13792  else {
13793  tokadd(c);
13794  }
13795  }
13796  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13797  nextc();
13798  if (tokadd_mbchar(c) == -1) return 0;
13799  }
13800  else {
13801  c = read_escape(0, &enc);
13802  tokadd(c);
13803  }
13804  }
13805  else {
13806  tokadd(c);
13807  }
13808  tokfix();
13809  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13810  lex_state = EXPR_END;
13811  return tCHAR;
13812 
13813  case '&':
13814  if ((c = nextc()) == '&') {
13815  lex_state = EXPR_BEG;
13816  if ((c = nextc()) == '=') {
13818  lex_state = EXPR_BEG;
13819  return tOP_ASGN;
13820  }
13821  pushback(c);
13822  return tANDOP;
13823  }
13824  else if (c == '=') {
13825  set_yylval_id('&');
13826  lex_state = EXPR_BEG;
13827  return tOP_ASGN;
13828  }
13829  pushback(c);
13830  if (IS_SPCARG(c)) {
13831  rb_warning0("`&' interpreted as argument prefix");
13832  c = tAMPER;
13833  }
13834  else if (IS_BEG()) {
13835  c = tAMPER;
13836  }
13837  else {
13838  warn_balanced("&", "argument prefix");
13839  c = '&';
13840  }
13841  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13842  return c;
13843 
13844  case '|':
13845  if ((c = nextc()) == '|') {
13846  lex_state = EXPR_BEG;
13847  if ((c = nextc()) == '=') {
13849  lex_state = EXPR_BEG;
13850  return tOP_ASGN;
13851  }
13852  pushback(c);
13853  return tOROP;
13854  }
13855  if (c == '=') {
13856  set_yylval_id('|');
13857  lex_state = EXPR_BEG;
13858  return tOP_ASGN;
13859  }
13860  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13861  pushback(c);
13862  return '|';
13863 
13864  case '+':
13865  c = nextc();
13866  if (IS_AFTER_OPERATOR()) {
13867  lex_state = EXPR_ARG;
13868  if (c == '@') {
13869  return tUPLUS;
13870  }
13871  pushback(c);
13872  return '+';
13873  }
13874  if (c == '=') {
13875  set_yylval_id('+');
13876  lex_state = EXPR_BEG;
13877  return tOP_ASGN;
13878  }
13879  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13880  lex_state = EXPR_BEG;
13881  pushback(c);
13882  if (c != -1 && ISDIGIT(c)) {
13883  c = '+';
13884  goto start_num;
13885  }
13886  return tUPLUS;
13887  }
13888  lex_state = EXPR_BEG;
13889  pushback(c);
13890  warn_balanced("+", "unary operator");
13891  return '+';
13892 
13893  case '-':
13894  c = nextc();
13895  if (IS_AFTER_OPERATOR()) {
13896  lex_state = EXPR_ARG;
13897  if (c == '@') {
13898  return tUMINUS;
13899  }
13900  pushback(c);
13901  return '-';
13902  }
13903  if (c == '=') {
13904  set_yylval_id('-');
13905  lex_state = EXPR_BEG;
13906  return tOP_ASGN;
13907  }
13908  if (c == '>') {
13909  lex_state = EXPR_ENDFN;
13910  return tLAMBDA;
13911  }
13912  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13913  lex_state = EXPR_BEG;
13914  pushback(c);
13915  if (c != -1 && ISDIGIT(c)) {
13916  return tUMINUS_NUM;
13917  }
13918  return tUMINUS;
13919  }
13920  lex_state = EXPR_BEG;
13921  pushback(c);
13922  warn_balanced("-", "unary operator");
13923  return '-';
13924 
13925  case '.':
13926  lex_state = EXPR_BEG;
13927  if ((c = nextc()) == '.') {
13928  if ((c = nextc()) == '.') {
13929  return tDOT3;
13930  }
13931  pushback(c);
13932  return tDOT2;
13933  }
13934  pushback(c);
13935  if (c != -1 && ISDIGIT(c)) {
13936  yyerror("no .<digit> floating literal anymore; put 0 before dot");
13937  }
13938  lex_state = EXPR_DOT;
13939  return '.';
13940 
13941  start_num:
13942  case '0': case '1': case '2': case '3': case '4':
13943  case '5': case '6': case '7': case '8': case '9':
13944  {
13945  int is_float, seen_point, seen_e, nondigit;
13946 
13947  is_float = seen_point = seen_e = nondigit = 0;
13948  lex_state = EXPR_END;
13949  newtok();
13950  if (c == '-' || c == '+') {
13951  tokadd(c);
13952  c = nextc();
13953  }
13954  if (c == '0') {
13955 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13956  int start = toklen();
13957  c = nextc();
13958  if (c == 'x' || c == 'X') {
13959  /* hexadecimal */
13960  c = nextc();
13961  if (c != -1 && ISXDIGIT(c)) {
13962  do {
13963  if (c == '_') {
13964  if (nondigit) break;
13965  nondigit = c;
13966  continue;
13967  }
13968  if (!ISXDIGIT(c)) break;
13969  nondigit = 0;
13970  tokadd(c);
13971  } while ((c = nextc()) != -1);
13972  }
13973  pushback(c);
13974  tokfix();
13975  if (toklen() == start) {
13976  no_digits();
13977  }
13978  else if (nondigit) goto trailing_uc;
13980  return tINTEGER;
13981  }
13982  if (c == 'b' || c == 'B') {
13983  /* binary */
13984  c = nextc();
13985  if (c == '0' || c == '1') {
13986  do {
13987  if (c == '_') {
13988  if (nondigit) break;
13989  nondigit = c;
13990  continue;
13991  }
13992  if (c != '0' && c != '1') break;
13993  nondigit = 0;
13994  tokadd(c);
13995  } while ((c = nextc()) != -1);
13996  }
13997  pushback(c);
13998  tokfix();
13999  if (toklen() == start) {
14000  no_digits();
14001  }
14002  else if (nondigit) goto trailing_uc;
14004  return tINTEGER;
14005  }
14006  if (c == 'd' || c == 'D') {
14007  /* decimal */
14008  c = nextc();
14009  if (c != -1 && ISDIGIT(c)) {
14010  do {
14011  if (c == '_') {
14012  if (nondigit) break;
14013  nondigit = c;
14014  continue;
14015  }
14016  if (!ISDIGIT(c)) break;
14017  nondigit = 0;
14018  tokadd(c);
14019  } while ((c = nextc()) != -1);
14020  }
14021  pushback(c);
14022  tokfix();
14023  if (toklen() == start) {
14024  no_digits();
14025  }
14026  else if (nondigit) goto trailing_uc;
14028  return tINTEGER;
14029  }
14030  if (c == '_') {
14031  /* 0_0 */
14032  goto octal_number;
14033  }
14034  if (c == 'o' || c == 'O') {
14035  /* prefixed octal */
14036  c = nextc();
14037  if (c == -1 || c == '_' || !ISDIGIT(c)) {
14038  no_digits();
14039  }
14040  }
14041  if (c >= '0' && c <= '7') {
14042  /* octal */
14043  octal_number:
14044  do {
14045  if (c == '_') {
14046  if (nondigit) break;
14047  nondigit = c;
14048  continue;
14049  }
14050  if (c < '0' || c > '9') break;
14051  if (c > '7') goto invalid_octal;
14052  nondigit = 0;
14053  tokadd(c);
14054  } while ((c = nextc()) != -1);
14055  if (toklen() > start) {
14056  pushback(c);
14057  tokfix();
14058  if (nondigit) goto trailing_uc;
14060  return tINTEGER;
14061  }
14062  if (nondigit) {
14063  pushback(c);
14064  goto trailing_uc;
14065  }
14066  }
14067  if (c > '7' && c <= '9') {
14068  invalid_octal:
14069  yyerror("Invalid octal digit");
14070  }
14071  else if (c == '.' || c == 'e' || c == 'E') {
14072  tokadd('0');
14073  }
14074  else {
14075  pushback(c);
14077  return tINTEGER;
14078  }
14079  }
14080 
14081  for (;;) {
14082  switch (c) {
14083  case '0': case '1': case '2': case '3': case '4':
14084  case '5': case '6': case '7': case '8': case '9':
14085  nondigit = 0;
14086  tokadd(c);
14087  break;
14088 
14089  case '.':
14090  if (nondigit) goto trailing_uc;
14091  if (seen_point || seen_e) {
14092  goto decode_num;
14093  }
14094  else {
14095  int c0 = nextc();
14096  if (c0 == -1 || !ISDIGIT(c0)) {
14097  pushback(c0);
14098  goto decode_num;
14099  }
14100  c = c0;
14101  }
14102  tokadd('.');
14103  tokadd(c);
14104  is_float++;
14105  seen_point++;
14106  nondigit = 0;
14107  break;
14108 
14109  case 'e':
14110  case 'E':
14111  if (nondigit) {
14112  pushback(c);
14113  c = nondigit;
14114  goto decode_num;
14115  }
14116  if (seen_e) {
14117  goto decode_num;
14118  }
14119  tokadd(c);
14120  seen_e++;
14121  is_float++;
14122  nondigit = c;
14123  c = nextc();
14124  if (c != '-' && c != '+') continue;
14125  tokadd(c);
14126  nondigit = c;
14127  break;
14128 
14129  case '_': /* `_' in number just ignored */
14130  if (nondigit) goto decode_num;
14131  nondigit = c;
14132  break;
14133 
14134  default:
14135  goto decode_num;
14136  }
14137  c = nextc();
14138  }
14139 
14140  decode_num:
14141  pushback(c);
14142  if (nondigit) {
14143  char tmp[30];
14144  trailing_uc:
14145  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14146  yyerror(tmp);
14147  }
14148  tokfix();
14149  if (is_float) {
14150  double d = strtod(tok(), 0);
14151  if (errno == ERANGE) {
14152  rb_warningS("Float %s out of range", tok());
14153  errno = 0;
14154  }
14156  return tFLOAT;
14157  }
14159  return tINTEGER;
14160  }
14161 
14162  case ')':
14163  case ']':
14164  paren_nest--;
14165  case '}':
14166  COND_LEXPOP();
14167  CMDARG_LEXPOP();
14168  if (c == ')')
14169  lex_state = EXPR_ENDFN;
14170  else
14171  lex_state = EXPR_ENDARG;
14172  if (c == '}') {
14173  if (!brace_nest--) c = tSTRING_DEND;
14174  }
14175  return c;
14176 
14177  case ':':
14178  c = nextc();
14179  if (c == ':') {
14180  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14181  lex_state = EXPR_BEG;
14182  return tCOLON3;
14183  }
14184  lex_state = EXPR_DOT;
14185  return tCOLON2;
14186  }
14187  if (IS_END() || ISSPACE(c)) {
14188  pushback(c);
14189  warn_balanced(":", "symbol literal");
14190  lex_state = EXPR_BEG;
14191  return ':';
14192  }
14193  switch (c) {
14194  case '\'':
14195  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14196  break;
14197  case '"':
14198  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14199  break;
14200  default:
14201  pushback(c);
14202  break;
14203  }
14204  lex_state = EXPR_FNAME;
14205  return tSYMBEG;
14206 
14207  case '/':
14208  if (IS_lex_state(EXPR_BEG_ANY)) {
14209  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14210  return tREGEXP_BEG;
14211  }
14212  if ((c = nextc()) == '=') {
14213  set_yylval_id('/');
14214  lex_state = EXPR_BEG;
14215  return tOP_ASGN;
14216  }
14217  pushback(c);
14218  if (IS_SPCARG(c)) {
14219  (void)arg_ambiguous();
14220  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14221  return tREGEXP_BEG;
14222  }
14223  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14224  warn_balanced("/", "regexp literal");
14225  return '/';
14226 
14227  case '^':
14228  if ((c = nextc()) == '=') {
14229  set_yylval_id('^');
14230  lex_state = EXPR_BEG;
14231  return tOP_ASGN;
14232  }
14233  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14234  pushback(c);
14235  return '^';
14236 
14237  case ';':
14238  lex_state = EXPR_BEG;
14239  command_start = TRUE;
14240  return ';';
14241 
14242  case ',':
14243  lex_state = EXPR_BEG;
14244  return ',';
14245 
14246  case '~':
14247  if (IS_AFTER_OPERATOR()) {
14248  if ((c = nextc()) != '@') {
14249  pushback(c);
14250  }
14251  lex_state = EXPR_ARG;
14252  }
14253  else {
14254  lex_state = EXPR_BEG;
14255  }
14256  return '~';
14257 
14258  case '(':
14259  if (IS_BEG()) {
14260  c = tLPAREN;
14261  }
14262  else if (IS_SPCARG(-1)) {
14263  c = tLPAREN_ARG;
14264  }
14265  paren_nest++;
14266  COND_PUSH(0);
14267  CMDARG_PUSH(0);
14268  lex_state = EXPR_BEG;
14269  return c;
14270 
14271  case '[':
14272  paren_nest++;
14273  if (IS_AFTER_OPERATOR()) {
14274  lex_state = EXPR_ARG;
14275  if ((c = nextc()) == ']') {
14276  if ((c = nextc()) == '=') {
14277  return tASET;
14278  }
14279  pushback(c);
14280  return tAREF;
14281  }
14282  pushback(c);
14283  return '[';
14284  }
14285  else if (IS_BEG()) {
14286  c = tLBRACK;
14287  }
14288  else if (IS_ARG() && space_seen) {
14289  c = tLBRACK;
14290  }
14291  lex_state = EXPR_BEG;
14292  COND_PUSH(0);
14293  CMDARG_PUSH(0);
14294  return c;
14295 
14296  case '{':
14297  ++brace_nest;
14298  if (lpar_beg && lpar_beg == paren_nest) {
14299  lex_state = EXPR_BEG;
14300  lpar_beg = 0;
14301  --paren_nest;
14302  COND_PUSH(0);
14303  CMDARG_PUSH(0);
14304  return tLAMBEG;
14305  }
14306  if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14307  c = '{'; /* block (primary) */
14308  else if (IS_lex_state(EXPR_ENDARG))
14309  c = tLBRACE_ARG; /* block (expr) */
14310  else
14311  c = tLBRACE; /* hash */
14312  COND_PUSH(0);
14313  CMDARG_PUSH(0);
14314  lex_state = EXPR_BEG;
14315  if (c != tLBRACE) command_start = TRUE;
14316  return c;
14317 
14318  case '\\':
14319  c = nextc();
14320  if (c == '\n') {
14321  space_seen = 1;
14322 #ifdef RIPPER
14323  ripper_dispatch_scan_event(parser, tSP);
14324 #endif
14325  goto retry; /* skip \\n */
14326  }
14327  pushback(c);
14328  return '\\';
14329 
14330  case '%':
14331  if (IS_lex_state(EXPR_BEG_ANY)) {
14332  int term;
14333  int paren;
14334 
14335  c = nextc();
14336  quotation:
14337  if (c == -1 || !ISALNUM(c)) {
14338  term = c;
14339  c = 'Q';
14340  }
14341  else {
14342  term = nextc();
14343  if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14344  yyerror("unknown type of %string");
14345  return 0;
14346  }
14347  }
14348  if (c == -1 || term == -1) {
14349  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14350  return 0;
14351  }
14352  paren = term;
14353  if (term == '(') term = ')';
14354  else if (term == '[') term = ']';
14355  else if (term == '{') term = '}';
14356  else if (term == '<') term = '>';
14357  else paren = 0;
14358 
14359  switch (c) {
14360  case 'Q':
14361  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14362  return tSTRING_BEG;
14363 
14364  case 'q':
14365  lex_strterm = NEW_STRTERM(str_squote, term, paren);
14366  return tSTRING_BEG;
14367 
14368  case 'W':
14369  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14370  do {c = nextc();} while (ISSPACE(c));
14371  pushback(c);
14372  return tWORDS_BEG;
14373 
14374  case 'w':
14375  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14376  do {c = nextc();} while (ISSPACE(c));
14377  pushback(c);
14378  return tQWORDS_BEG;
14379 
14380  case 'I':
14381  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14382  do {c = nextc();} while (ISSPACE(c));
14383  pushback(c);
14384  return tSYMBOLS_BEG;
14385 
14386  case 'i':
14387  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14388  do {c = nextc();} while (ISSPACE(c));
14389  pushback(c);
14390  return tQSYMBOLS_BEG;
14391 
14392  case 'x':
14393  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14394  return tXSTRING_BEG;
14395 
14396  case 'r':
14397  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14398  return tREGEXP_BEG;
14399 
14400  case 's':
14401  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14402  lex_state = EXPR_FNAME;
14403  return tSYMBEG;
14404 
14405  default:
14406  yyerror("unknown type of %string");
14407  return 0;
14408  }
14409  }
14410  if ((c = nextc()) == '=') {
14411  set_yylval_id('%');
14412  lex_state = EXPR_BEG;
14413  return tOP_ASGN;
14414  }
14415  if (IS_SPCARG(c)) {
14416  goto quotation;
14417  }
14418  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14419  pushback(c);
14420  warn_balanced("%%", "string literal");
14421  return '%';
14422 
14423  case '$':
14424  lex_state = EXPR_END;
14425  newtok();
14426  c = nextc();
14427  switch (c) {
14428  case '_': /* $_: last read line string */
14429  c = nextc();
14430  if (parser_is_identchar()) {
14431  tokadd('$');
14432  tokadd('_');
14433  break;
14434  }
14435  pushback(c);
14436  c = '_';
14437  /* fall through */
14438  case '~': /* $~: match-data */
14439  case '*': /* $*: argv */
14440  case '$': /* $$: pid */
14441  case '?': /* $?: last status */
14442  case '!': /* $!: error string */
14443  case '@': /* $@: error position */
14444  case '/': /* $/: input record separator */
14445  case '\\': /* $\: output record separator */
14446  case ';': /* $;: field separator */
14447  case ',': /* $,: output field separator */
14448  case '.': /* $.: last read line number */
14449  case '=': /* $=: ignorecase */
14450  case ':': /* $:: load path */
14451  case '<': /* $<: reading filename */
14452  case '>': /* $>: default output handle */
14453  case '\"': /* $": already loaded files */
14454  tokadd('$');
14455  tokadd(c);
14456  tokfix();
14458  return tGVAR;
14459 
14460  case '-':
14461  tokadd('$');
14462  tokadd(c);
14463  c = nextc();
14464  if (parser_is_identchar()) {
14465  if (tokadd_mbchar(c) == -1) return 0;
14466  }
14467  else {
14468  pushback(c);
14469  }
14470  gvar:
14471  tokfix();
14473  return tGVAR;
14474 
14475  case '&': /* $&: last match */
14476  case '`': /* $`: string before last match */
14477  case '\'': /* $': string after last match */
14478  case '+': /* $+: string matches last paren. */
14479  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14480  tokadd('$');
14481  tokadd(c);
14482  goto gvar;
14483  }
14485  return tBACK_REF;
14486 
14487  case '1': case '2': case '3':
14488  case '4': case '5': case '6':
14489  case '7': case '8': case '9':
14490  tokadd('$');
14491  do {
14492  tokadd(c);
14493  c = nextc();
14494  } while (c != -1 && ISDIGIT(c));
14495  pushback(c);
14496  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14497  tokfix();
14498  set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
14499  return tNTH_REF;
14500 
14501  default:
14502  if (!parser_is_identchar()) {
14503  pushback(c);
14504  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14505  return 0;
14506  }
14507  case '0':
14508  tokadd('$');
14509  }
14510  break;
14511 
14512  case '@':
14513  c = nextc();
14514  newtok();
14515  tokadd('@');
14516  if (c == '@') {
14517  tokadd('@');
14518  c = nextc();
14519  }
14520  if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14521  pushback(c);
14522  if (tokidx == 1) {
14523  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14524  }
14525  else {
14526  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14527  }
14528  return 0;
14529  }
14530  break;
14531 
14532  case '_':
14533  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14534  ruby__end__seen = 1;
14535  parser->eofp = Qtrue;
14536 #ifndef RIPPER
14537  return -1;
14538 #else
14539  lex_goto_eol(parser);
14540  ripper_dispatch_scan_event(parser, k__END__);
14541  return 0;
14542 #endif
14543  }
14544  newtok();
14545  break;
14546 
14547  default:
14548  if (!parser_is_identchar()) {
14549  rb_compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14550  goto retry;
14551  }
14552 
14553  newtok();
14554  break;
14555  }
14556 
14557  mb = ENC_CODERANGE_7BIT;
14558  do {
14559  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14560  if (tokadd_mbchar(c) == -1) return 0;
14561  c = nextc();
14562  } while (parser_is_identchar());
14563  switch (tok()[0]) {
14564  case '@': case '$':
14565  pushback(c);
14566  break;
14567  default:
14568  if ((c == '!' || c == '?') && !peek('=')) {
14569  tokadd(c);
14570  }
14571  else {
14572  pushback(c);
14573  }
14574  }
14575  tokfix();
14576 
14577  {
14578  int result = 0;
14579 
14580  last_state = lex_state;
14581  switch (tok()[0]) {
14582  case '$':
14583  lex_state = EXPR_END;
14584  result = tGVAR;
14585  break;
14586  case '@':
14587  lex_state = EXPR_END;
14588  if (tok()[1] == '@')
14589  result = tCVAR;
14590  else
14591  result = tIVAR;
14592  break;
14593 
14594  default:
14595  if (toklast() == '!' || toklast() == '?') {
14596  result = tFID;
14597  }
14598  else {
14599  if (IS_lex_state(EXPR_FNAME)) {
14600  if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14601  (!peek('=') || (peek_n('>', 1)))) {
14602  result = tIDENTIFIER;
14603  tokadd(c);
14604  tokfix();
14605  }
14606  else {
14607  pushback(c);
14608  }
14609  }
14610  if (result == 0 && ISUPPER(tok()[0])) {
14611  result = tCONSTANT;
14612  }
14613  else {
14614  result = tIDENTIFIER;
14615  }
14616  }
14617 
14618  if (IS_LABEL_POSSIBLE()) {
14619  if (IS_LABEL_SUFFIX(0)) {
14620  lex_state = EXPR_BEG;
14621  nextc();
14623  return tLABEL;
14624  }
14625  }
14626  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14627  const struct kwtable *kw;
14628 
14629  /* See if it is a reserved word. */
14630  kw = rb_reserved_word(tok(), toklen());
14631  if (kw) {
14632  enum lex_state_e state = lex_state;
14633  lex_state = kw->state;
14634  if (state == EXPR_FNAME) {
14636  return kw->id[0];
14637  }
14638  if (lex_state == EXPR_BEG) {
14639  command_start = TRUE;
14640  }
14641  if (kw->id[0] == keyword_do) {
14642  if (lpar_beg && lpar_beg == paren_nest) {
14643  lpar_beg = 0;
14644  --paren_nest;
14645  return keyword_do_LAMBDA;
14646  }
14647  if (COND_P()) return keyword_do_cond;
14648  if (CMDARG_P() && state != EXPR_CMDARG)
14649  return keyword_do_block;
14650  if (state & (EXPR_BEG | EXPR_ENDARG))
14651  return keyword_do_block;
14652  return keyword_do;
14653  }
14654  if (state & (EXPR_BEG | EXPR_VALUE))
14655  return kw->id[0];
14656  else {
14657  if (kw->id[0] != kw->id[1])
14658  lex_state = EXPR_BEG;
14659  return kw->id[1];
14660  }
14661  }
14662  }
14663 
14664  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14665  if (cmd_state) {
14666  lex_state = EXPR_CMDARG;
14667  }
14668  else {
14669  lex_state = EXPR_ARG;
14670  }
14671  }
14672  else if (lex_state == EXPR_FNAME) {
14673  lex_state = EXPR_ENDFN;
14674  }
14675  else {
14676  lex_state = EXPR_END;
14677  }
14678  }
14679  {
14680  ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14681 
14682  set_yylval_name(ident);
14683  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14684  is_local_id(ident) && lvar_defined(ident)) {
14685  lex_state = EXPR_END;
14686  }
14687  }
14688  return result;
14689  }
14690 }
14691 
14692 #if YYPURE
14693 static int
14694 yylex(void *lval, void *p)
14695 #else
14696 yylex(void *p)
14697 #endif
14698 {
14699  struct parser_params *parser = (struct parser_params*)p;
14700  int t;
14701 
14702 #if YYPURE
14703  parser->parser_yylval = lval;
14704  parser->parser_yylval->val = Qundef;
14705 #endif
14706  t = parser_yylex(parser);
14707 #ifdef RIPPER
14708  if (!NIL_P(parser->delayed)) {
14709  ripper_dispatch_delayed_token(parser, t);
14710  return t;
14711  }
14712  if (t != 0)
14713  ripper_dispatch_scan_event(parser, t);
14714 #endif
14715 
14716  return t;
14717 }
14718 
14719 #ifndef RIPPER
14720 static NODE*
14721 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14722 {
14723  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14725  return n;
14726 }
14727 
14728 static enum node_type
14729 nodetype(NODE *node) /* for debug */
14730 {
14731  return (enum node_type)nd_type(node);
14732 }
14733 
14734 static int
14736 {
14737  return nd_line(node);
14738 }
14739 
14740 static NODE*
14742 {
14743  if (node) {
14744  node = remove_begin(node);
14745  node->flags |= NODE_FL_NEWLINE;
14746  }
14747  return node;
14748 }
14749 
14750 static void
14751 fixpos(NODE *node, NODE *orig)
14752 {
14753  if (!node) return;
14754  if (!orig) return;
14755  if (orig == (NODE*)1) return;
14756  nd_set_line(node, nd_line(orig));
14757 }
14758 
14759 static void
14760 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14761 {
14762  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14763 }
14764 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14765 
14766 static void
14767 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14768 {
14769  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14770 }
14771 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14772 
14773 static NODE*
14774 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14775 {
14776  NODE *end, *h = head, *nd;
14777 
14778  if (tail == 0) return head;
14779 
14780  if (h == 0) return tail;
14781  switch (nd_type(h)) {
14782  case NODE_LIT:
14783  case NODE_STR:
14784  case NODE_SELF:
14785  case NODE_TRUE:
14786  case NODE_FALSE:
14787  case NODE_NIL:
14788  parser_warning(h, "unused literal ignored");
14789  return tail;
14790  default:
14791  h = end = NEW_BLOCK(head);
14792  end->nd_end = end;
14793  fixpos(end, head);
14794  head = end;
14795  break;
14796  case NODE_BLOCK:
14797  end = h->nd_end;
14798  break;
14799  }
14800 
14801  nd = end->nd_head;
14802  switch (nd_type(nd)) {
14803  case NODE_RETURN:
14804  case NODE_BREAK:
14805  case NODE_NEXT:
14806  case NODE_REDO:
14807  case NODE_RETRY:
14808  if (RTEST(ruby_verbose)) {
14809  parser_warning(tail, "statement not reached");
14810  }
14811  break;
14812 
14813  default:
14814  break;
14815  }
14816 
14817  if (nd_type(tail) != NODE_BLOCK) {
14818  tail = NEW_BLOCK(tail);
14819  tail->nd_end = tail;
14820  }
14821  end->nd_next = tail;
14822  h->nd_end = tail->nd_end;
14823  return head;
14824 }
14825 
14826 /* append item to the list */
14827 static NODE*
14828 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14829 {
14830  NODE *last;
14831 
14832  if (list == 0) return NEW_LIST(item);
14833  if (list->nd_next) {
14834  last = list->nd_next->nd_end;
14835  }
14836  else {
14837  last = list;
14838  }
14839 
14840  list->nd_alen += 1;
14841  last->nd_next = NEW_LIST(item);
14842  list->nd_next->nd_end = last->nd_next;
14843  return list;
14844 }
14845 
14846 /* concat two lists */
14847 static NODE*
14848 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14849 {
14850  NODE *last;
14851 
14852  if (head->nd_next) {
14853  last = head->nd_next->nd_end;
14854  }
14855  else {
14856  last = head;
14857  }
14858 
14859  head->nd_alen += tail->nd_alen;
14860  last->nd_next = tail;
14861  if (tail->nd_next) {
14862  head->nd_next->nd_end = tail->nd_next->nd_end;
14863  }
14864  else {
14865  head->nd_next->nd_end = tail;
14866  }
14867 
14868  return head;
14869 }
14870 
14871 static int
14873 {
14874  if (NIL_P(tail)) return 1;
14875  if (!rb_enc_compatible(head, tail)) {
14876  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14877  rb_enc_name(rb_enc_get(head)),
14878  rb_enc_name(rb_enc_get(tail)));
14879  rb_str_resize(head, 0);
14880  rb_str_resize(tail, 0);
14881  return 0;
14882  }
14883  rb_str_buf_append(head, tail);
14884  return 1;
14885 }
14886 
14887 /* concat two string literals */
14888 static NODE *
14890 {
14891  enum node_type htype;
14892  NODE *headlast;
14893  VALUE lit;
14894 
14895  if (!head) return tail;
14896  if (!tail) return head;
14897 
14898  htype = nd_type(head);
14899  if (htype == NODE_EVSTR) {
14900  NODE *node = NEW_DSTR(Qnil);
14901  head = list_append(node, head);
14902  htype = NODE_DSTR;
14903  }
14904  switch (nd_type(tail)) {
14905  case NODE_STR:
14906  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14907  nd_type(headlast) == NODE_STR) {
14908  htype = NODE_STR;
14909  lit = headlast->nd_lit;
14910  }
14911  else {
14912  lit = head->nd_lit;
14913  }
14914  if (htype == NODE_STR) {
14915  if (!literal_concat0(parser, lit, tail->nd_lit)) {
14916  error:
14917  rb_gc_force_recycle((VALUE)head);
14918  rb_gc_force_recycle((VALUE)tail);
14919  return 0;
14920  }
14921  rb_gc_force_recycle((VALUE)tail);
14922  }
14923  else {
14924  list_append(head, tail);
14925  }
14926  break;
14927 
14928  case NODE_DSTR:
14929  if (htype == NODE_STR) {
14930  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14931  goto error;
14932  tail->nd_lit = head->nd_lit;
14933  rb_gc_force_recycle((VALUE)head);
14934  head = tail;
14935  }
14936  else if (NIL_P(tail->nd_lit)) {
14937  append:
14938  head->nd_alen += tail->nd_alen - 1;
14939  head->nd_next->nd_end->nd_next = tail->nd_next;
14940  head->nd_next->nd_end = tail->nd_next->nd_end;
14941  rb_gc_force_recycle((VALUE)tail);
14942  }
14943  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14944  nd_type(headlast) == NODE_STR) {
14945  lit = headlast->nd_lit;
14946  if (!literal_concat0(parser, lit, tail->nd_lit))
14947  goto error;
14948  tail->nd_lit = Qnil;
14949  goto append;
14950  }
14951  else {
14952  nd_set_type(tail, NODE_ARRAY);
14953  tail->nd_head = NEW_STR(tail->nd_lit);
14954  list_concat(head, tail);
14955  }
14956  break;
14957 
14958  case NODE_EVSTR:
14959  if (htype == NODE_STR) {
14960  nd_set_type(head, NODE_DSTR);
14961  head->nd_alen = 1;
14962  }
14963  list_append(head, tail);
14964  break;
14965  }
14966  return head;
14967 }
14968 
14969 static NODE *
14970 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14971 {
14972  if (nd_type(node) == NODE_EVSTR) {
14973  node = list_append(NEW_DSTR(Qnil), node);
14974  }
14975  return node;
14976 }
14977 
14978 static NODE *
14979 new_evstr_gen(struct parser_params *parser, NODE *node)
14980 {
14981  NODE *head = node;
14982 
14983  if (node) {
14984  switch (nd_type(node)) {
14985  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14986  return node;
14987  }
14988  }
14989  return NEW_EVSTR(head);
14990 }
14991 
14992 static NODE *
14993 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14994 {
14995  value_expr(recv);
14996  value_expr(arg1);
14997  return NEW_CALL(recv, id, NEW_LIST(arg1));
14998 }
14999 
15000 static NODE *
15001 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
15002 {
15003  value_expr(recv);
15004  return NEW_CALL(recv, id, 0);
15005 }
15006 
15007 static NODE*
15008 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15009 {
15010  value_expr(node1);
15011  value_expr(node2);
15012  if (node1) {
15013  switch (nd_type(node1)) {
15014  case NODE_DREGX:
15015  case NODE_DREGX_ONCE:
15016  return NEW_MATCH2(node1, node2);
15017 
15018  case NODE_LIT:
15019  if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
15020  return NEW_MATCH2(node1, node2);
15021  }
15022  }
15023  }
15024 
15025  if (node2) {
15026  switch (nd_type(node2)) {
15027  case NODE_DREGX:
15028  case NODE_DREGX_ONCE:
15029  return NEW_MATCH3(node2, node1);
15030 
15031  case NODE_LIT:
15032  if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
15033  return NEW_MATCH3(node2, node1);
15034  }
15035  }
15036  }
15037 
15038  return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
15039 }
15040 
15041 static NODE*
15042 gettable_gen(struct parser_params *parser, ID id)
15043 {
15044  switch (id) {
15045  case keyword_self:
15046  return NEW_SELF();
15047  case keyword_nil:
15048  return NEW_NIL();
15049  case keyword_true:
15050  return NEW_TRUE();
15051  case keyword_false:
15052  return NEW_FALSE();
15053  case keyword__FILE__:
15056  case keyword__LINE__:
15057  return NEW_LIT(INT2FIX(tokline));
15058  case keyword__ENCODING__:
15060  }
15061  switch (id_type(id)) {
15062  case ID_LOCAL:
15063  if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
15064  if (local_id(id)) return NEW_LVAR(id);
15065  /* method call without arguments */
15066  return NEW_VCALL(id);
15067  case ID_GLOBAL:
15068  return NEW_GVAR(id);
15069  case ID_INSTANCE:
15070  return NEW_IVAR(id);
15071  case ID_CONST:
15072  return NEW_CONST(id);
15073  case ID_CLASS:
15074  return NEW_CVAR(id);
15075  }
15076  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15077  return 0;
15078 }
15079 #else /* !RIPPER */
15080 static int
15081 id_is_var_gen(struct parser_params *parser, ID id)
15082 {
15083  if (is_notop_id(id)) {
15084  switch (id & ID_SCOPE_MASK) {
15085  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
15086  return 1;
15087  case ID_LOCAL:
15088  if (dyna_in_block() && dvar_defined(id)) return 1;
15089  if (local_id(id)) return 1;
15090  /* method call without arguments */
15091  return 0;
15092  }
15093  }
15094  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15095  return 0;
15096 }
15097 #endif /* !RIPPER */
15098 
15099 #if PARSER_DEBUG
15100 static const char *
15101 lex_state_name(enum lex_state_e state)
15102 {
15103  static const char names[][12] = {
15104  "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG",
15105  "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS",
15106  "EXPR_VALUE",
15107  };
15108 
15109  if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
15110  return names[ffs(state)];
15111  return NULL;
15112 }
15113 #endif
15114 
15115 #ifdef RIPPER
15116 static VALUE
15117 assignable_gen(struct parser_params *parser, VALUE lhs)
15118 #else
15119 static NODE*
15120 assignable_gen(struct parser_params *parser, ID id, NODE *val)
15121 #endif
15122 {
15123 #ifdef RIPPER
15124  ID id = get_id(lhs);
15125 # define assignable_result(x) get_value(lhs)
15126 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
15127 #else
15128 # define assignable_result(x) (x)
15129 #endif
15130  if (!id) return assignable_result(0);
15131  switch (id) {
15132  case keyword_self:
15133  yyerror("Can't change the value of self");
15134  goto error;
15135  case keyword_nil:
15136  yyerror("Can't assign to nil");
15137  goto error;
15138  case keyword_true:
15139  yyerror("Can't assign to true");
15140  goto error;
15141  case keyword_false:
15142  yyerror("Can't assign to false");
15143  goto error;
15144  case keyword__FILE__:
15145  yyerror("Can't assign to __FILE__");
15146  goto error;
15147  case keyword__LINE__:
15148  yyerror("Can't assign to __LINE__");
15149  goto error;
15150  case keyword__ENCODING__:
15151  yyerror("Can't assign to __ENCODING__");
15152  goto error;
15153  }
15154  switch (id_type(id)) {
15155  case ID_LOCAL:
15156  if (dyna_in_block()) {
15157  if (dvar_curr(id)) {
15158  return assignable_result(NEW_DASGN_CURR(id, val));
15159  }
15160  else if (dvar_defined(id)) {
15161  return assignable_result(NEW_DASGN(id, val));
15162  }
15163  else if (local_id(id)) {
15164  return assignable_result(NEW_LASGN(id, val));
15165  }
15166  else {
15167  dyna_var(id);
15168  return assignable_result(NEW_DASGN_CURR(id, val));
15169  }
15170  }
15171  else {
15172  if (!local_id(id)) {
15173  local_var(id);
15174  }
15175  return assignable_result(NEW_LASGN(id, val));
15176  }
15177  break;
15178  case ID_GLOBAL:
15179  return assignable_result(NEW_GASGN(id, val));
15180  case ID_INSTANCE:
15181  return assignable_result(NEW_IASGN(id, val));
15182  case ID_CONST:
15183  if (!in_def && !in_single)
15184  return assignable_result(NEW_CDECL(id, val, 0));
15185  yyerror("dynamic constant assignment");
15186  break;
15187  case ID_CLASS:
15188  return assignable_result(NEW_CVASGN(id, val));
15189  default:
15190  compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15191  }
15192  error:
15193  return assignable_result(0);
15194 #undef assignable_result
15195 #undef parser_yyerror
15196 }
15197 
15198 static int
15200 {
15201  VALUE s;
15202  if (name == idUScore) return 1;
15203  if (!is_local_id(name)) return 0;
15204  s = rb_id2str(name);
15205  if (!s) return 0;
15206  return RSTRING_PTR(s)[0] == '_';
15207 }
15208 
15209 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15210 
15211 static ID
15212 shadowing_lvar_gen(struct parser_params *parser, ID name)
15213 {
15214  if (is_private_local_id(name)) return name;
15215  if (dyna_in_block()) {
15216  if (dvar_curr(name)) {
15217  yyerror("duplicated argument name");
15218  }
15219  else if (dvar_defined_get(name) || local_id(name)) {
15220  rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15221  vtable_add(lvtbl->vars, name);
15222  if (lvtbl->used) {
15224  }
15225  }
15226  }
15227  else {
15228  if (local_id(name)) {
15229  yyerror("duplicated argument name");
15230  }
15231  }
15232  return name;
15233 }
15234 
15235 static void
15236 new_bv_gen(struct parser_params *parser, ID name)
15237 {
15238  if (!name) return;
15239  if (!is_local_id(name)) {
15240  compile_error(PARSER_ARG "invalid local variable - %s",
15241  rb_id2name(name));
15242  return;
15243  }
15244  shadowing_lvar(name);
15245  dyna_var(name);
15246 }
15247 
15248 #ifndef RIPPER
15249 static NODE *
15250 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15251 {
15252  if (recv && nd_type(recv) == NODE_SELF)
15253  recv = (NODE *)1;
15254  return NEW_ATTRASGN(recv, tASET, idx);
15255 }
15256 
15257 static void
15258 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15259 {
15260  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15261  compile_error(PARSER_ARG "both block arg and actual block given");
15262  }
15263 }
15264 
15265 static const char id_type_names[][9] = {
15266  "LOCAL",
15267  "INSTANCE",
15268  "", /* INSTANCE2 */
15269  "GLOBAL",
15270  "ATTRSET",
15271  "CONST",
15272  "CLASS",
15273  "JUNK",
15274 };
15275 
15276 ID
15278 {
15279  if (!is_notop_id(id)) {
15280  switch (id) {
15281  case tAREF: case tASET:
15282  return tASET; /* only exception */
15283  }
15284  rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
15285  }
15286  else {
15287  int scope = (int)(id & ID_SCOPE_MASK);
15288  switch (scope) {
15289  case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
15290  case ID_CONST: case ID_CLASS: case ID_JUNK:
15291  break;
15292  case ID_ATTRSET:
15293  return id;
15294  default:
15295  rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset",
15296  id_type_names[scope], ID2SYM(id));
15297 
15298  }
15299  }
15300  id &= ~ID_SCOPE_MASK;
15301  id |= ID_ATTRSET;
15302  return id;
15303 }
15304 
15305 static NODE *
15306 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15307 {
15308  if (recv && nd_type(recv) == NODE_SELF)
15309  recv = (NODE *)1;
15310  return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15311 }
15312 
15313 static void
15315 {
15316  switch (nd_type(node)) {
15317  case NODE_NTH_REF:
15318  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15319  break;
15320  case NODE_BACK_REF:
15321  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15322  break;
15323  }
15324 }
15325 
15326 static NODE *
15327 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15328 {
15329  if (!node2) return node1;
15330  switch (nd_type(node1)) {
15331  case NODE_BLOCK_PASS:
15332  if (node1->nd_head)
15333  node1->nd_head = arg_concat(node1->nd_head, node2);
15334  else
15335  node1->nd_head = NEW_LIST(node2);
15336  return node1;
15337  case NODE_ARGSPUSH:
15338  if (nd_type(node2) != NODE_ARRAY) break;
15339  node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15340  nd_set_type(node1, NODE_ARGSCAT);
15341  return node1;
15342  case NODE_ARGSCAT:
15343  if (nd_type(node2) != NODE_ARRAY ||
15344  nd_type(node1->nd_body) != NODE_ARRAY) break;
15345  node1->nd_body = list_concat(node1->nd_body, node2);
15346  return node1;
15347  }
15348  return NEW_ARGSCAT(node1, node2);
15349 }
15350 
15351 static NODE *
15352 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15353 {
15354  if (!node1) return NEW_LIST(node2);
15355  switch (nd_type(node1)) {
15356  case NODE_ARRAY:
15357  return list_append(node1, node2);
15358  case NODE_BLOCK_PASS:
15359  node1->nd_head = arg_append(node1->nd_head, node2);
15360  return node1;
15361  case NODE_ARGSPUSH:
15362  node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15363  nd_set_type(node1, NODE_ARGSCAT);
15364  return node1;
15365  }
15366  return NEW_ARGSPUSH(node1, node2);
15367 }
15368 
15369 static NODE *
15371 {
15372  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15373  if (nd_type(node) == NODE_ARRAY) return node;
15374  return 0;
15375 }
15376 
15377 static NODE *
15378 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15379 {
15380  if (!lhs) return 0;
15381 
15382  switch (nd_type(lhs)) {
15383  case NODE_GASGN:
15384  case NODE_IASGN:
15385  case NODE_IASGN2:
15386  case NODE_LASGN:
15387  case NODE_DASGN:
15388  case NODE_DASGN_CURR:
15389  case NODE_MASGN:
15390  case NODE_CDECL:
15391  case NODE_CVASGN:
15392  lhs->nd_value = rhs;
15393  break;
15394 
15395  case NODE_ATTRASGN:
15396  case NODE_CALL:
15397  lhs->nd_args = arg_append(lhs->nd_args, rhs);
15398  break;
15399 
15400  default:
15401  /* should not happen */
15402  break;
15403  }
15404 
15405  return lhs;
15406 }
15407 
15408 static int
15409 value_expr_gen(struct parser_params *parser, NODE *node)
15410 {
15411  int cond = 0;
15412 
15413  if (!node) {
15414  rb_warning0("empty expression");
15415  }
15416  while (node) {
15417  switch (nd_type(node)) {
15418  case NODE_DEFN:
15419  case NODE_DEFS:
15420  parser_warning(node, "void value expression");
15421  return FALSE;
15422 
15423  case NODE_RETURN:
15424  case NODE_BREAK:
15425  case NODE_NEXT:
15426  case NODE_REDO:
15427  case NODE_RETRY:
15428  if (!cond) yyerror("void value expression");
15429  /* or "control never reach"? */
15430  return FALSE;
15431 
15432  case NODE_BLOCK:
15433  while (node->nd_next) {
15434  node = node->nd_next;
15435  }
15436  node = node->nd_head;
15437  break;
15438 
15439  case NODE_BEGIN:
15440  node = node->nd_body;
15441  break;
15442 
15443  case NODE_IF:
15444  if (!node->nd_body) {
15445  node = node->nd_else;
15446  break;
15447  }
15448  else if (!node->nd_else) {
15449  node = node->nd_body;
15450  break;
15451  }
15452  if (!value_expr(node->nd_body)) return FALSE;
15453  node = node->nd_else;
15454  break;
15455 
15456  case NODE_AND:
15457  case NODE_OR:
15458  cond = 1;
15459  node = node->nd_2nd;
15460  break;
15461 
15462  default:
15463  return TRUE;
15464  }
15465  }
15466 
15467  return TRUE;
15468 }
15469 
15470 static void
15471 void_expr_gen(struct parser_params *parser, NODE *node)
15472 {
15473  const char *useless = 0;
15474 
15475  if (!RTEST(ruby_verbose)) return;
15476 
15477  if (!node) return;
15478  switch (nd_type(node)) {
15479  case NODE_CALL:
15480  switch (node->nd_mid) {
15481  case '+':
15482  case '-':
15483  case '*':
15484  case '/':
15485  case '%':
15486  case tPOW:
15487  case tUPLUS:
15488  case tUMINUS:
15489  case '|':
15490  case '^':
15491  case '&':
15492  case tCMP:
15493  case '>':
15494  case tGEQ:
15495  case '<':
15496  case tLEQ:
15497  case tEQ:
15498  case tNEQ:
15499  useless = rb_id2name(node->nd_mid);
15500  break;
15501  }
15502  break;
15503 
15504  case NODE_LVAR:
15505  case NODE_DVAR:
15506  case NODE_GVAR:
15507  case NODE_IVAR:
15508  case NODE_CVAR:
15509  case NODE_NTH_REF:
15510  case NODE_BACK_REF:
15511  useless = "a variable";
15512  break;
15513  case NODE_CONST:
15514  useless = "a constant";
15515  break;
15516  case NODE_LIT:
15517  case NODE_STR:
15518  case NODE_DSTR:
15519  case NODE_DREGX:
15520  case NODE_DREGX_ONCE:
15521  useless = "a literal";
15522  break;
15523  case NODE_COLON2:
15524  case NODE_COLON3:
15525  useless = "::";
15526  break;
15527  case NODE_DOT2:
15528  useless = "..";
15529  break;
15530  case NODE_DOT3:
15531  useless = "...";
15532  break;
15533  case NODE_SELF:
15534  useless = "self";
15535  break;
15536  case NODE_NIL:
15537  useless = "nil";
15538  break;
15539  case NODE_TRUE:
15540  useless = "true";
15541  break;
15542  case NODE_FALSE:
15543  useless = "false";
15544  break;
15545  case NODE_DEFINED:
15546  useless = "defined?";
15547  break;
15548  }
15549 
15550  if (useless) {
15551  int line = ruby_sourceline;
15552 
15553  ruby_sourceline = nd_line(node);
15554  rb_warnS("possibly useless use of %s in void context", useless);
15555  ruby_sourceline = line;
15556  }
15557 }
15558 
15559 static void
15560 void_stmts_gen(struct parser_params *parser, NODE *node)
15561 {
15562  if (!RTEST(ruby_verbose)) return;
15563  if (!node) return;
15564  if (nd_type(node) != NODE_BLOCK) return;
15565 
15566  for (;;) {
15567  if (!node->nd_next) return;
15568  void_expr0(node->nd_head);
15569  node = node->nd_next;
15570  }
15571 }
15572 
15573 static NODE *
15575 {
15576  NODE **n = &node, *n1 = node;
15577  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15578  *n = n1 = n1->nd_body;
15579  }
15580  return node;
15581 }
15582 
15583 static void
15584 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15585 {
15586  NODE *node = *body;
15587 
15588  if (!node) {
15589  *body = NEW_NIL();
15590  return;
15591  }
15592 #define subnodes(n1, n2) \
15593  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15594  (!node->n2) ? (body = &node->n1, 1) : \
15595  (reduce_nodes(&node->n1), body = &node->n2, 1))
15596 
15597  while (node) {
15598  int newline = (int)(node->flags & NODE_FL_NEWLINE);
15599  switch (nd_type(node)) {
15600  end:
15601  case NODE_NIL:
15602  *body = 0;
15603  return;
15604  case NODE_RETURN:
15605  *body = node = node->nd_stts;
15606  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15607  continue;
15608  case NODE_BEGIN:
15609  *body = node = node->nd_body;
15610  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15611  continue;
15612  case NODE_BLOCK:
15613  body = &node->nd_end->nd_head;
15614  break;
15615  case NODE_IF:
15616  if (subnodes(nd_body, nd_else)) break;
15617  return;
15618  case NODE_CASE:
15619  body = &node->nd_body;
15620  break;
15621  case NODE_WHEN:
15622  if (!subnodes(nd_body, nd_next)) goto end;
15623  break;
15624  case NODE_ENSURE:
15625  if (!subnodes(nd_head, nd_resq)) goto end;
15626  break;
15627  case NODE_RESCUE:
15628  if (node->nd_else) {
15629  body = &node->nd_resq;
15630  break;
15631  }
15632  if (!subnodes(nd_head, nd_resq)) goto end;
15633  break;
15634  default:
15635  return;
15636  }
15637  node = *body;
15638  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15639  }
15640 
15641 #undef subnodes
15642 }
15643 
15644 static int
15646 {
15647  if (!node) return 1;
15648  switch (nd_type(node)) {
15649  case NODE_HASH:
15650  if (!(node = node->nd_head)) break;
15651  case NODE_ARRAY:
15652  do {
15653  if (!is_static_content(node->nd_head)) return 0;
15654  } while ((node = node->nd_next) != 0);
15655  case NODE_LIT:
15656  case NODE_STR:
15657  case NODE_NIL:
15658  case NODE_TRUE:
15659  case NODE_FALSE:
15660  case NODE_ZARRAY:
15661  break;
15662  default:
15663  return 0;
15664  }
15665  return 1;
15666 }
15667 
15668 static int
15669 assign_in_cond(struct parser_params *parser, NODE *node)
15670 {
15671  switch (nd_type(node)) {
15672  case NODE_MASGN:
15673  yyerror("multiple assignment in conditional");
15674  return 1;
15675 
15676  case NODE_LASGN:
15677  case NODE_DASGN:
15678  case NODE_DASGN_CURR:
15679  case NODE_GASGN:
15680  case NODE_IASGN:
15681  break;
15682 
15683  default:
15684  return 0;
15685  }
15686 
15687  if (!node->nd_value) return 1;
15688  if (is_static_content(node->nd_value)) {
15689  /* reports always */
15690  parser_warn(node->nd_value, "found = in conditional, should be ==");
15691  }
15692  return 1;
15693 }
15694 
15695 static void
15696 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15697 {
15698  if (!e_option_supplied(parser)) parser_warn(node, str);
15699 }
15700 
15701 static void
15702 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15703 {
15704  if (!e_option_supplied(parser)) parser_warning(node, str);
15705 }
15706 
15707 static void
15708 fixup_nodes(NODE **rootnode)
15709 {
15710  NODE *node, *next, *head;
15711 
15712  for (node = *rootnode; node; node = next) {
15713  enum node_type type;
15714  VALUE val;
15715 
15716  next = node->nd_next;
15717  head = node->nd_head;
15718  rb_gc_force_recycle((VALUE)node);
15719  *rootnode = next;
15720  switch (type = nd_type(head)) {
15721  case NODE_DOT2:
15722  case NODE_DOT3:
15723  val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15724  type == NODE_DOT3);
15725  rb_gc_force_recycle((VALUE)head->nd_beg);
15726  rb_gc_force_recycle((VALUE)head->nd_end);
15727  nd_set_type(head, NODE_LIT);
15728  head->nd_lit = val;
15729  break;
15730  default:
15731  break;
15732  }
15733  }
15734 }
15735 
15736 static NODE *cond0(struct parser_params*,NODE*);
15737 
15738 static NODE*
15739 range_op(struct parser_params *parser, NODE *node)
15740 {
15741  enum node_type type;
15742 
15743  if (node == 0) return 0;
15744 
15745  type = nd_type(node);
15746  value_expr(node);
15747  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15748  warn_unless_e_option(parser, node, "integer literal in conditional range");
15749  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15750  }
15751  return cond0(parser, node);
15752 }
15753 
15754 static int
15756 {
15757  if (!node) return 1; /* same as NODE_NIL */
15758  switch (nd_type(node)) {
15759  case NODE_LIT:
15760  case NODE_STR:
15761  case NODE_DSTR:
15762  case NODE_EVSTR:
15763  case NODE_DREGX:
15764  case NODE_DREGX_ONCE:
15765  case NODE_DSYM:
15766  return 2;
15767  case NODE_TRUE:
15768  case NODE_FALSE:
15769  case NODE_NIL:
15770  return 1;
15771  }
15772  return 0;
15773 }
15774 
15775 static NODE*
15776 cond0(struct parser_params *parser, NODE *node)
15777 {
15778  if (node == 0) return 0;
15779  assign_in_cond(parser, node);
15780 
15781  switch (nd_type(node)) {
15782  case NODE_DSTR:
15783  case NODE_EVSTR:
15784  case NODE_STR:
15785  rb_warn0("string literal in condition");
15786  break;
15787 
15788  case NODE_DREGX:
15789  case NODE_DREGX_ONCE:
15790  warning_unless_e_option(parser, node, "regex literal in condition");
15791  return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15792 
15793  case NODE_AND:
15794  case NODE_OR:
15795  node->nd_1st = cond0(parser, node->nd_1st);
15796  node->nd_2nd = cond0(parser, node->nd_2nd);
15797  break;
15798 
15799  case NODE_DOT2:
15800  case NODE_DOT3:
15801  node->nd_beg = range_op(parser, node->nd_beg);
15802  node->nd_end = range_op(parser, node->nd_end);
15803  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15804  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15805  if (!e_option_supplied(parser)) {
15806  int b = literal_node(node->nd_beg);
15807  int e = literal_node(node->nd_end);
15808  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15809  parser_warn(node, "range literal in condition");
15810  }
15811  }
15812  break;
15813 
15814  case NODE_DSYM:
15815  parser_warning(node, "literal in condition");
15816  break;
15817 
15818  case NODE_LIT:
15819  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
15820  warn_unless_e_option(parser, node, "regex literal in condition");
15821  nd_set_type(node, NODE_MATCH);
15822  }
15823  else {
15824  parser_warning(node, "literal in condition");
15825  }
15826  default:
15827  break;
15828  }
15829  return node;
15830 }
15831 
15832 static NODE*
15833 cond_gen(struct parser_params *parser, NODE *node)
15834 {
15835  if (node == 0) return 0;
15836  return cond0(parser, node);
15837 }
15838 
15839 static NODE*
15840 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15841 {
15842  value_expr(left);
15843  if (left && (enum node_type)nd_type(left) == type) {
15844  NODE *node = left, *second;
15845  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15846  node = second;
15847  }
15848  node->nd_2nd = NEW_NODE(type, second, right, 0);
15849  return left;
15850  }
15851  return NEW_NODE(type, left, right, 0);
15852 }
15853 
15854 static void
15855 no_blockarg(struct parser_params *parser, NODE *node)
15856 {
15857  if (node && nd_type(node) == NODE_BLOCK_PASS) {
15858  compile_error(PARSER_ARG "block argument should not be given");
15859  }
15860 }
15861 
15862 static NODE *
15863 ret_args_gen(struct parser_params *parser, NODE *node)
15864 {
15865  if (node) {
15866  no_blockarg(parser, node);
15867  if (nd_type(node) == NODE_ARRAY) {
15868  if (node->nd_next == 0) {
15869  node = node->nd_head;
15870  }
15871  else {
15872  nd_set_type(node, NODE_VALUES);
15873  }
15874  }
15875  }
15876  return node;
15877 }
15878 
15879 static NODE *
15880 new_yield_gen(struct parser_params *parser, NODE *node)
15881 {
15882  if (node) no_blockarg(parser, node);
15883 
15884  return NEW_YIELD(node);
15885 }
15886 
15887 static NODE*
15889 {
15890  switch (TYPE(node->nd_lit)) {
15891  case T_FIXNUM:
15892  node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15893  break;
15894  case T_BIGNUM:
15895  node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15896  break;
15897  case T_FLOAT:
15898 #if USE_FLONUM
15899  if (FLONUM_P(node->nd_lit)) {
15900  node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
15901  }
15902  else {
15903  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15904  }
15905 #else
15906  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15907 #endif
15908  break;
15909  default:
15910  break;
15911  }
15912  return node;
15913 }
15914 
15915 static NODE *
15916 arg_blk_pass(NODE *node1, NODE *node2)
15917 {
15918  if (node2) {
15919  node2->nd_head = node1;
15920  return node2;
15921  }
15922  return node1;
15923 }
15924 
15925 
15926 static NODE*
15927 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
15928 {
15929  int saved_line = ruby_sourceline;
15930  struct rb_args_info *args = tail->nd_ainfo;
15931 
15932  args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0;
15933  args->pre_init = m ? m->nd_next : 0;
15934 
15935  args->post_args_num = p ? rb_long2int(p->nd_plen) : 0;
15936  args->post_init = p ? p->nd_next : 0;
15937  args->first_post_arg = p ? p->nd_pid : 0;
15938 
15939  args->rest_arg = r;
15940 
15941  args->opt_args = o;
15942 
15943  ruby_sourceline = saved_line;
15944 
15945  return tail;
15946 }
15947 
15948 static NODE*
15949 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
15950 {
15951  int saved_line = ruby_sourceline;
15952  struct rb_args_info *args;
15953  NODE *kw_rest_arg = 0;
15954  NODE *node;
15955 
15956  args = ALLOC(struct rb_args_info);
15957  MEMZERO(args, struct rb_args_info, 1);
15958  node = NEW_NODE(NODE_ARGS, 0, 0, args);
15959 
15960  args->block_arg = b;
15961  args->kw_args = k;
15962  if (k && !kr) kr = internal_id();
15963  if (kr) {
15964  arg_var(kr);
15965  kw_rest_arg = NEW_DVAR(kr);
15966  }
15967  args->kw_rest_arg = kw_rest_arg;
15968 
15969  ruby_sourceline = saved_line;
15970  return node;
15971 }
15972 
15973 static NODE*
15974 dsym_node_gen(struct parser_params *parser, NODE *node)
15975 {
15976  VALUE lit;
15977 
15978  if (!node) {
15979  return NEW_LIT(ID2SYM(idNULL));
15980  }
15981 
15982  switch (nd_type(node)) {
15983  case NODE_DSTR:
15984  nd_set_type(node, NODE_DSYM);
15985  break;
15986  case NODE_STR:
15987  lit = node->nd_lit;
15988  node->nd_lit = ID2SYM(rb_intern_str(lit));
15989  nd_set_type(node, NODE_LIT);
15990  break;
15991  default:
15992  node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
15993  break;
15994  }
15995  return node;
15996 }
15997 #endif /* !RIPPER */
15998 
15999 #ifndef RIPPER
16000 static NODE *
16001 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16002 {
16003  NODE *asgn;
16004 
16005  if (lhs) {
16006  ID vid = lhs->nd_vid;
16007  if (op == tOROP) {
16008  lhs->nd_value = rhs;
16009  asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
16010  if (is_asgn_or_id(vid)) {
16011  asgn->nd_aid = vid;
16012  }
16013  }
16014  else if (op == tANDOP) {
16015  lhs->nd_value = rhs;
16016  asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
16017  }
16018  else {
16019  asgn = lhs;
16020  asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
16021  }
16022  }
16023  else {
16024  asgn = NEW_BEGIN(0);
16025  }
16026  return asgn;
16027 }
16028 
16029 static NODE *
16030 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
16031 {
16032  NODE *asgn;
16033 
16034  if (op == tOROP) {
16035  op = 0;
16036  }
16037  else if (op == tANDOP) {
16038  op = 1;
16039  }
16040  asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
16041  fixpos(asgn, lhs);
16042  return asgn;
16043 }
16044 
16045 static NODE *
16046 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16047 {
16048  NODE *asgn;
16049 
16050  if (op == tOROP) {
16051  op = 0;
16052  }
16053  else if (op == tANDOP) {
16054  op = 1;
16055  }
16056  if (lhs) {
16057  asgn = NEW_OP_CDECL(lhs, op, rhs);
16058  }
16059  else {
16060  asgn = NEW_BEGIN(0);
16061  }
16062  fixpos(asgn, lhs);
16063  return asgn;
16064 }
16065 #else
16066 static VALUE
16067 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
16068 {
16069  return dispatch3(opassign, lhs, op, rhs);
16070 }
16071 
16072 static VALUE
16073 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
16074 {
16075  VALUE recv = dispatch3(field, lhs, type, attr);
16076  return dispatch3(opassign, recv, op, rhs);
16077 }
16078 #endif
16079 
16080 static void
16081 warn_unused_var(struct parser_params *parser, struct local_vars *local)
16082 {
16083  int i, cnt;
16084  ID *v, *u;
16085 
16086  if (!local->used) return;
16087  v = local->vars->tbl;
16088  u = local->used->tbl;
16089  cnt = local->used->pos;
16090  if (cnt != local->vars->pos) {
16091  rb_bug("local->used->pos != local->vars->pos");
16092  }
16093  for (i = 0; i < cnt; ++i) {
16094  if (!v[i] || (u[i] & LVAR_USED)) continue;
16095  if (is_private_local_id(v[i])) continue;
16096  rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
16097  }
16098 }
16099 
16100 static void
16101 local_push_gen(struct parser_params *parser, int inherit_dvars)
16102 {
16103  struct local_vars *local;
16104 
16105  local = ALLOC(struct local_vars);
16106  local->prev = lvtbl;
16107  local->args = vtable_alloc(0);
16108  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
16109  local->used = !(inherit_dvars &&
16111  RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
16112  local->cmdargs = cmdarg_stack;
16113  cmdarg_stack = 0;
16114  lvtbl = local;
16115 }
16116 
16117 static void
16119 {
16120  struct local_vars *local = lvtbl->prev;
16121  if (lvtbl->used) {
16122  warn_unused_var(parser, lvtbl);
16123  vtable_free(lvtbl->used);
16124  }
16125  vtable_free(lvtbl->args);
16126  vtable_free(lvtbl->vars);
16127  cmdarg_stack = lvtbl->cmdargs;
16128  xfree(lvtbl);
16129  lvtbl = local;
16130 }
16131 
16132 #ifndef RIPPER
16133 static ID*
16134 vtable_tblcpy(ID *buf, const struct vtable *src)
16135 {
16136  int i, cnt = vtable_size(src);
16137 
16138  if (cnt > 0) {
16139  buf[0] = cnt;
16140  for (i = 0; i < cnt; i++) {
16141  buf[i] = src->tbl[i];
16142  }
16143  return buf;
16144  }
16145  return 0;
16146 }
16147 
16148 static ID*
16150 {
16151  int cnt = vtable_size(lvtbl->args) + vtable_size(lvtbl->vars);
16152  ID *buf;
16153 
16154  if (cnt <= 0) return 0;
16155  buf = ALLOC_N(ID, cnt + 1);
16156  vtable_tblcpy(buf+1, lvtbl->args);
16157  vtable_tblcpy(buf+vtable_size(lvtbl->args)+1, lvtbl->vars);
16158  buf[0] = cnt;
16159  return buf;
16160 }
16161 #endif
16162 
16163 static int
16164 arg_var_gen(struct parser_params *parser, ID id)
16165 {
16166  vtable_add(lvtbl->args, id);
16167  return vtable_size(lvtbl->args) - 1;
16168 }
16169 
16170 static int
16171 local_var_gen(struct parser_params *parser, ID id)
16172 {
16173  vtable_add(lvtbl->vars, id);
16174  if (lvtbl->used) {
16176  }
16177  return vtable_size(lvtbl->vars) - 1;
16178 }
16179 
16180 static int
16181 local_id_gen(struct parser_params *parser, ID id)
16182 {
16183  struct vtable *vars, *args, *used;
16184 
16185  vars = lvtbl->vars;
16186  args = lvtbl->args;
16187  used = lvtbl->used;
16188 
16189  while (vars && POINTER_P(vars->prev)) {
16190  vars = vars->prev;
16191  args = args->prev;
16192  if (used) used = used->prev;
16193  }
16194 
16195  if (vars && vars->prev == DVARS_INHERIT) {
16196  return rb_local_defined(id);
16197  }
16198  else if (vtable_included(args, id)) {
16199  return 1;
16200  }
16201  else {
16202  int i = vtable_included(vars, id);
16203  if (i && used) used->tbl[i-1] |= LVAR_USED;
16204  return i != 0;
16205  }
16206 }
16207 
16208 static const struct vtable *
16210 {
16211  lvtbl->args = vtable_alloc(lvtbl->args);
16212  lvtbl->vars = vtable_alloc(lvtbl->vars);
16213  if (lvtbl->used) {
16214  lvtbl->used = vtable_alloc(lvtbl->used);
16215  }
16216  return lvtbl->args;
16217 }
16218 
16219 static void
16220 dyna_pop_1(struct parser_params *parser)
16221 {
16222  struct vtable *tmp;
16223 
16224  if ((tmp = lvtbl->used) != 0) {
16225  warn_unused_var(parser, lvtbl);
16226  lvtbl->used = lvtbl->used->prev;
16227  vtable_free(tmp);
16228  }
16229  tmp = lvtbl->args;
16230  lvtbl->args = lvtbl->args->prev;
16231  vtable_free(tmp);
16232  tmp = lvtbl->vars;
16233  lvtbl->vars = lvtbl->vars->prev;
16234  vtable_free(tmp);
16235 }
16236 
16237 static void
16238 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16239 {
16240  while (lvtbl->args != lvargs) {
16241  dyna_pop_1(parser);
16242  if (!lvtbl->args) {
16243  struct local_vars *local = lvtbl->prev;
16244  xfree(lvtbl);
16245  lvtbl = local;
16246  }
16247  }
16248  dyna_pop_1(parser);
16249 }
16250 
16251 static int
16253 {
16254  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16255 }
16256 
16257 static int
16258 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16259 {
16260  struct vtable *vars, *args, *used;
16261  int i;
16262 
16263  args = lvtbl->args;
16264  vars = lvtbl->vars;
16265  used = lvtbl->used;
16266 
16267  while (POINTER_P(vars)) {
16268  if (vtable_included(args, id)) {
16269  return 1;
16270  }
16271  if ((i = vtable_included(vars, id)) != 0) {
16272  if (used) used->tbl[i-1] |= LVAR_USED;
16273  return 1;
16274  }
16275  args = args->prev;
16276  vars = vars->prev;
16277  if (get) used = 0;
16278  if (used) used = used->prev;
16279  }
16280 
16281  if (vars == DVARS_INHERIT) {
16282  return rb_dvar_defined(id);
16283  }
16284 
16285  return 0;
16286 }
16287 
16288 static int
16289 dvar_curr_gen(struct parser_params *parser, ID id)
16290 {
16291  return (vtable_included(lvtbl->args, id) ||
16292  vtable_included(lvtbl->vars, id));
16293 }
16294 
16295 #ifndef RIPPER
16296 static void
16298 {
16299  int c = RE_OPTION_ENCODING_IDX(options);
16300 
16301  if (c) {
16302  int opt, idx;
16303  rb_char_to_option_kcode(c, &opt, &idx);
16304  if (idx != ENCODING_GET(str) &&
16306  goto error;
16307  }
16308  ENCODING_SET(str, idx);
16309  }
16310  else if (RE_OPTION_ENCODING_NONE(options)) {
16311  if (!ENCODING_IS_ASCII8BIT(str) &&
16313  c = 'n';
16314  goto error;
16315  }
16317  }
16318  else if (current_enc == rb_usascii_encoding()) {
16320  /* raise in re.c */
16322  }
16323  else {
16325  }
16326  }
16327  return;
16328 
16329  error:
16331  "regexp encoding option '%c' differs from source encoding '%s'",
16332  c, rb_enc_name(rb_enc_get(str)));
16333 }
16334 
16335 static int
16337 {
16338  VALUE err;
16339  reg_fragment_setenc(str, options);
16340  err = rb_reg_check_preprocess(str);
16341  if (err != Qnil) {
16342  err = rb_obj_as_string(err);
16343  compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
16344  RB_GC_GUARD(err);
16345  return 0;
16346  }
16347  return 1;
16348 }
16349 
16350 typedef struct {
16355  int num;
16357 
16358 static int
16360  int back_num, int *back_refs, OnigRegex regex, void *arg0)
16361 {
16363  struct parser_params* parser = arg->parser;
16364  rb_encoding *enc = arg->enc;
16365  long len = name_end - name;
16366  const char *s = (const char *)name;
16367  ID var;
16368 
16369  arg->num++;
16370 
16371  if (arg->succ_block == 0) {
16372  arg->succ_block = NEW_BEGIN(0);
16373  arg->fail_block = NEW_BEGIN(0);
16374  }
16375 
16376  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16377  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16378  !rb_enc_symname2_p(s, len, enc)) {
16379  return ST_CONTINUE;
16380  }
16381  var = rb_intern3(s, len, enc);
16382  if (dvar_defined(var) || local_id(var)) {
16383  rb_warningS("named capture conflicts a local variable - %s",
16384  rb_id2name(var));
16385  }
16386  arg->succ_block = block_append(arg->succ_block,
16388  NEW_CALL(
16389  gettable(rb_intern("$~")),
16390  idAREF,
16391  NEW_LIST(NEW_LIT(ID2SYM(var))))
16392  )));
16393  arg->fail_block = block_append(arg->fail_block,
16395  return ST_CONTINUE;
16396 }
16397 
16398 static NODE *
16400 {
16402 
16403  arg.parser = parser;
16404  arg.enc = rb_enc_get(regexp);
16405  arg.succ_block = 0;
16406  arg.fail_block = 0;
16407  arg.num = 0;
16408  onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
16409 
16410  if (arg.num == 0)
16411  return match;
16412 
16413  return
16414  block_append(
16415  newline_node(match),
16416  NEW_IF(gettable(rb_intern("$~")),
16417  block_append(
16418  newline_node(arg.succ_block),
16419  newline_node(
16420  NEW_CALL(
16421  gettable(rb_intern("$~")),
16422  rb_intern("begin"),
16423  NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16424  block_append(
16425  newline_node(arg.fail_block),
16426  newline_node(
16427  NEW_LIT(Qnil)))));
16428 }
16429 
16430 static VALUE
16431 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16432 {
16433  VALUE re;
16434  VALUE err;
16435 
16436  reg_fragment_setenc(str, options);
16437  err = rb_errinfo();
16439  if (NIL_P(re)) {
16440  ID mesg = rb_intern("mesg");
16441  VALUE m = rb_attr_get(rb_errinfo(), mesg);
16442  rb_set_errinfo(err);
16443  if (!NIL_P(err)) {
16444  rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16445  }
16446  else {
16448  }
16449  return Qnil;
16450  }
16451  return re;
16452 }
16453 
16454 void
16456 {
16457 }
16458 
16459 NODE*
16461 {
16462  NODE *prelude = 0;
16463  NODE *scope = node;
16464  struct parser_params *parser;
16465 
16466  if (!node) return node;
16467 
16468  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16469 
16470  node = node->nd_body;
16471 
16472  if (nd_type(node) == NODE_PRELUDE) {
16473  prelude = node;
16474  node = node->nd_body;
16475  }
16476 
16477  node = block_append(node,
16478  NEW_FCALL(rb_intern("print"),
16479  NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16480  if (prelude) {
16481  prelude->nd_body = node;
16482  scope->nd_body = prelude;
16483  }
16484  else {
16485  scope->nd_body = node;
16486  }
16487 
16488  return scope;
16489 }
16490 
16491 NODE *
16492 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16493 {
16494  NODE *prelude = 0;
16495  NODE *scope = node;
16496  struct parser_params *parser;
16497 
16498  if (!node) return node;
16499 
16500  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16501 
16502  node = node->nd_body;
16503 
16504  if (nd_type(node) == NODE_PRELUDE) {
16505  prelude = node;
16506  node = node->nd_body;
16507  }
16508  if (split) {
16509  node = block_append(NEW_GASGN(rb_intern("$F"),
16510  NEW_CALL(NEW_GVAR(rb_intern("$_")),
16511  rb_intern("split"), 0)),
16512  node);
16513  }
16514  if (chop) {
16515  node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16516  rb_intern("chop!"), 0), node);
16517  }
16518 
16519  node = NEW_OPT_N(node);
16520 
16521  if (prelude) {
16522  prelude->nd_body = node;
16523  scope->nd_body = prelude;
16524  }
16525  else {
16526  scope->nd_body = node;
16527  }
16528 
16529  return scope;
16530 }
16531 
16532 static const struct {
16534  const char *name;
16535 } op_tbl[] = {
16536  {tDOT2, ".."},
16537  {tDOT3, "..."},
16538  {tPOW, "**"},
16539  {tDSTAR, "**"},
16540  {tUPLUS, "+@"},
16541  {tUMINUS, "-@"},
16542  {tCMP, "<=>"},
16543  {tGEQ, ">="},
16544  {tLEQ, "<="},
16545  {tEQ, "=="},
16546  {tEQQ, "==="},
16547  {tNEQ, "!="},
16548  {tMATCH, "=~"},
16549  {tNMATCH, "!~"},
16550  {tAREF, "[]"},
16551  {tASET, "[]="},
16552  {tLSHFT, "<<"},
16553  {tRSHFT, ">>"},
16554  {tCOLON2, "::"},
16555 };
16556 
16557 #define op_tbl_count numberof(op_tbl)
16558 
16559 #ifndef ENABLE_SELECTOR_NAMESPACE
16560 #define ENABLE_SELECTOR_NAMESPACE 0
16561 #endif
16562 
16563 static struct symbols {
16567 #if ENABLE_SELECTOR_NAMESPACE
16568  st_table *ivar2_id;
16569  st_table *id_ivar2;
16570 #endif
16573 
16574 static const struct st_hash_type symhash = {
16576  rb_str_hash,
16577 };
16578 
16579 #if ENABLE_SELECTOR_NAMESPACE
16580 struct ivar2_key {
16581  ID id;
16582  VALUE klass;
16583 };
16584 
16585 static int
16586 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16587 {
16588  if (key1->id == key2->id && key1->klass == key2->klass) {
16589  return 0;
16590  }
16591  return 1;
16592 }
16593 
16594 static int
16595 ivar2_hash(struct ivar2_key *key)
16596 {
16597  return (key->id << 8) ^ (key->klass >> 2);
16598 }
16599 
16600 static const struct st_hash_type ivar2_hash_type = {
16601  ivar2_cmp,
16602  ivar2_hash,
16603 };
16604 #endif
16605 
16606 void
16608 {
16609  global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
16611 #if ENABLE_SELECTOR_NAMESPACE
16612  global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16613  global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16614 #endif
16615 
16616  (void)nodetype;
16617  (void)nodeline;
16618 #if PARSER_DEBUG
16619  (void)lex_state_name(-1);
16620 #endif
16621 
16622  Init_id();
16623 }
16624 
16625 void
16627 {
16631 }
16632 #endif /* !RIPPER */
16633 
16634 static ID
16636 {
16637  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16638  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16639  return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16640 }
16641 
16642 #ifndef RIPPER
16643 static int
16644 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16645 {
16646  int mb = 0;
16647 
16648  if (m >= e) return 0;
16649  if (is_global_name_punct(*m)) {
16650  ++m;
16651  }
16652  else if (*m == '-') {
16653  ++m;
16654  if (m < e && is_identchar(m, e, enc)) {
16655  if (!ISASCII(*m)) mb = 1;
16656  m += rb_enc_mbclen(m, e, enc);
16657  }
16658  }
16659  else {
16660  if (!rb_enc_isdigit(*m, enc)) return 0;
16661  do {
16662  if (!ISASCII(*m)) mb = 1;
16663  ++m;
16664  } while (m < e && rb_enc_isdigit(*m, enc));
16665  }
16666  return m == e ? mb + 1 : 0;
16667 }
16668 
16669 int
16670 rb_symname_p(const char *name)
16671 {
16672  return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16673 }
16674 
16675 int
16676 rb_enc_symname_p(const char *name, rb_encoding *enc)
16677 {
16678  return rb_enc_symname2_p(name, strlen(name), enc);
16679 }
16680 
16681 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
16682 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<(1<<ID_SCOPE_SHIFT)) & ~(1U<<ID_ATTRSET))
16683 
16684 static int
16685 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_atttset)
16686 {
16687  const char *m = name;
16688  const char *e = m + len;
16689  int type = ID_JUNK;
16690 
16691  if (!m || len <= 0) return -1;
16692  switch (*m) {
16693  case '\0':
16694  return -1;
16695 
16696  case '$':
16697  type = ID_GLOBAL;
16698  if (is_special_global_name(++m, e, enc)) return type;
16699  goto id;
16700 
16701  case '@':
16702  type = ID_INSTANCE;
16703  if (*++m == '@') {
16704  ++m;
16705  type = ID_CLASS;
16706  }
16707  goto id;
16708 
16709  case '<':
16710  switch (*++m) {
16711  case '<': ++m; break;
16712  case '=': if (*++m == '>') ++m; break;
16713  default: break;
16714  }
16715  break;
16716 
16717  case '>':
16718  switch (*++m) {
16719  case '>': case '=': ++m; break;
16720  }
16721  break;
16722 
16723  case '=':
16724  switch (*++m) {
16725  case '~': ++m; break;
16726  case '=': if (*++m == '=') ++m; break;
16727  default: return -1;
16728  }
16729  break;
16730 
16731  case '*':
16732  if (*++m == '*') ++m;
16733  break;
16734 
16735  case '+': case '-':
16736  if (*++m == '@') ++m;
16737  break;
16738 
16739  case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16740  ++m;
16741  break;
16742 
16743  case '[':
16744  if (*++m != ']') return -1;
16745  if (*++m == '=') ++m;
16746  break;
16747 
16748  case '!':
16749  if (len == 1) return ID_JUNK;
16750  switch (*++m) {
16751  case '=': case '~': ++m; break;
16752  default: return -1;
16753  }
16754  break;
16755 
16756  default:
16757  type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16758  id:
16759  if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16760  return -1;
16761  while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16762  if (m >= e) break;
16763  switch (*m) {
16764  case '!': case '?':
16765  if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16766  type = ID_JUNK;
16767  ++m;
16768  if (m + 1 < e || *m != '=') break;
16769  /* fall through */
16770  case '=':
16771  if (!(allowed_atttset & (1U << type))) return -1;
16772  type = ID_ATTRSET;
16773  ++m;
16774  break;
16775  }
16776  break;
16777  }
16778  return m == e ? type : -1;
16779 }
16780 
16781 int
16782 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16783 {
16784  return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
16785 }
16786 
16787 static int
16788 rb_str_symname_type(VALUE name, unsigned int allowed_atttset)
16789 {
16790  const char *ptr = StringValuePtr(name);
16791  long len = RSTRING_LEN(name);
16792  int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_atttset);
16793  RB_GC_GUARD(name);
16794  return type;
16795 }
16796 
16797 static ID
16798 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16799 {
16800  VALUE str = rb_enc_str_new(name, len, enc);
16801  return register_symid_str(id, str);
16802 }
16803 
16804 static ID
16806 {
16807  OBJ_FREEZE(str);
16810  return id;
16811 }
16812 
16813 static int
16815 {
16816  if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
16817  switch (rb_enc_str_coderange(str)) {
16818  case ENC_CODERANGE_BROKEN:
16819  rb_raise(rb_eEncodingError, "invalid encoding symbol");
16820  case ENC_CODERANGE_7BIT:
16821  return TRUE;
16822  }
16823  return FALSE;
16824 }
16825 
16826 /*
16827  * _str_ itself will be registered at the global symbol table. _str_
16828  * can be modified before the registration, since the encoding will be
16829  * set to ASCII-8BIT if it is a special global name.
16830  */
16831 static ID intern_str(VALUE str);
16832 
16833 ID
16834 rb_intern3(const char *name, long len, rb_encoding *enc)
16835 {
16836  VALUE str;
16837  st_data_t data;
16838  struct RString fake_str;
16839  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
16840  fake_str.basic.klass = rb_cString;
16841  fake_str.as.heap.len = len;
16842  fake_str.as.heap.ptr = (char *)name;
16843  fake_str.as.heap.aux.capa = len;
16844  str = (VALUE)&fake_str;
16845  rb_enc_associate(str, enc);
16846  OBJ_FREEZE(str);
16847 
16848  if (st_lookup(global_symbols.sym_id, str, &data))
16849  return (ID)data;
16850 
16851  str = rb_enc_str_new(name, len, enc); /* make true string */
16852  return intern_str(str);
16853 }
16854 
16855 static ID
16857 {
16858  const char *name, *m, *e;
16859  long len, last;
16860  rb_encoding *enc, *symenc;
16861  unsigned char c;
16862  ID id;
16863  int mb;
16864 
16865  RSTRING_GETMEM(str, name, len);
16866  m = name;
16867  e = m + len;
16868  enc = rb_enc_get(str);
16869  symenc = enc;
16870 
16871  if (!len || (rb_cString && !rb_enc_asciicompat(enc))) {
16872  junk:
16873  id = ID_JUNK;
16874  goto new_id;
16875  }
16876  last = len-1;
16877  id = 0;
16878  switch (*m) {
16879  case '$':
16880  if (len < 2) goto junk;
16881  id |= ID_GLOBAL;
16882  if ((mb = is_special_global_name(++m, e, enc)) != 0) {
16883  if (!--mb) symenc = rb_usascii_encoding();
16884  goto new_id;
16885  }
16886  break;
16887  case '@':
16888  if (m[1] == '@') {
16889  if (len < 3) goto junk;
16890  m++;
16891  id |= ID_CLASS;
16892  }
16893  else {
16894  if (len < 2) goto junk;
16895  id |= ID_INSTANCE;
16896  }
16897  m++;
16898  break;
16899  default:
16900  c = m[0];
16901  if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
16902  /* operators */
16903  int i;
16904 
16905  if (len == 1) {
16906  id = c;
16907  goto id_register;
16908  }
16909  for (i = 0; i < op_tbl_count; i++) {
16910  if (*op_tbl[i].name == *m &&
16911  strcmp(op_tbl[i].name, m) == 0) {
16912  id = op_tbl[i].token;
16913  goto id_register;
16914  }
16915  }
16916  }
16917  break;
16918  }
16919  if (name[last] == '=') {
16920  /* attribute assignment */
16921  if (last > 1 && name[last-1] == '=')
16922  goto junk;
16923  id = rb_intern3(name, last, enc);
16924  if (id > tLAST_OP_ID && !is_attrset_id(id)) {
16925  enc = rb_enc_get(rb_id2str(id));
16926  id = rb_id_attrset(id);
16927  goto id_register;
16928  }
16929  id = ID_ATTRSET;
16930  }
16931  else if (id == 0) {
16932  if (rb_enc_isupper(m[0], enc)) {
16933  id = ID_CONST;
16934  }
16935  else {
16936  id = ID_LOCAL;
16937  }
16938  }
16939  if (!rb_enc_isdigit(*m, enc)) {
16940  while (m <= name + last && is_identchar(m, e, enc)) {
16941  if (ISASCII(*m)) {
16942  m++;
16943  }
16944  else {
16945  m += rb_enc_mbclen(m, e, enc);
16946  }
16947  }
16948  }
16949  if (id != ID_ATTRSET && m - name < len) id = ID_JUNK;
16950  if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
16951  new_id:
16952  if (symenc != enc) rb_enc_associate(str, symenc);
16954  if (len > 20) {
16955  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
16956  name);
16957  }
16958  else {
16959  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
16960  (int)len, name);
16961  }
16962  }
16964  id_register:
16965  return register_symid_str(id, str);
16966 }
16967 
16968 ID
16969 rb_intern2(const char *name, long len)
16970 {
16971  return rb_intern3(name, len, rb_usascii_encoding());
16972 }
16973 
16974 #undef rb_intern
16975 ID
16976 rb_intern(const char *name)
16977 {
16978  return rb_intern2(name, strlen(name));
16979 }
16980 
16981 ID
16983 {
16984  st_data_t id;
16985 
16986  if (st_lookup(global_symbols.sym_id, str, &id))
16987  return (ID)id;
16988  return intern_str(rb_str_dup(str));
16989 }
16990 
16991 VALUE
16993 {
16994  st_data_t data;
16995 
16996  if (id < tLAST_TOKEN) {
16997  int i = 0;
16998 
16999  if (id < INT_MAX && rb_ispunct((int)id)) {
17000  VALUE str = global_symbols.op_sym[i = (int)id];
17001  if (!str) {
17002  char name[2];
17003  name[0] = (char)id;
17004  name[1] = 0;
17005  str = rb_usascii_str_new(name, 1);
17006  OBJ_FREEZE(str);
17007  global_symbols.op_sym[i] = str;
17008  }
17009  return str;
17010  }
17011  for (i = 0; i < op_tbl_count; i++) {
17012  if (op_tbl[i].token == id) {
17013  VALUE str = global_symbols.op_sym[i];
17014  if (!str) {
17015  str = rb_usascii_str_new2(op_tbl[i].name);
17016  OBJ_FREEZE(str);
17017  global_symbols.op_sym[i] = str;
17018  }
17019  return str;
17020  }
17021  }
17022  }
17023 
17024  if (st_lookup(global_symbols.id_str, id, &data)) {
17025  VALUE str = (VALUE)data;
17026  if (RBASIC(str)->klass == 0)
17027  RBASIC(str)->klass = rb_cString;
17028  return str;
17029  }
17030 
17031  if (is_attrset_id(id)) {
17032  ID id_stem = (id & ~ID_SCOPE_MASK);
17033  VALUE str;
17034 
17035  do {
17036  if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break;
17037  if (!!(str = rb_id2str(id_stem | ID_CONST))) break;
17038  if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break;
17039  if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break;
17040  if (!!(str = rb_id2str(id_stem | ID_CLASS))) break;
17041  if (!!(str = rb_id2str(id_stem | ID_JUNK))) break;
17042  return 0;
17043  } while (0);
17044  str = rb_str_dup(str);
17045  rb_str_cat(str, "=", 1);
17046  register_symid_str(id, str);
17047  if (st_lookup(global_symbols.id_str, id, &data)) {
17048  VALUE str = (VALUE)data;
17049  if (RBASIC(str)->klass == 0)
17050  RBASIC(str)->klass = rb_cString;
17051  return str;
17052  }
17053  }
17054  return 0;
17055 }
17056 
17057 const char *
17059 {
17060  VALUE str = rb_id2str(id);
17061 
17062  if (!str) return 0;
17063  return RSTRING_PTR(str);
17064 }
17065 
17066 static int
17068 {
17069  rb_ary_push(ary, ID2SYM(value));
17070  return ST_CONTINUE;
17071 }
17072 
17073 /*
17074  * call-seq:
17075  * Symbol.all_symbols => array
17076  *
17077  * Returns an array of all the symbols currently in Ruby's symbol
17078  * table.
17079  *
17080  * Symbol.all_symbols.size #=> 903
17081  * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
17082  * :chown, :EOFError, :$;, :String,
17083  * :LOCK_SH, :"setuid?", :$<,
17084  * :default_proc, :compact, :extend,
17085  * :Tms, :getwd, :$=, :ThreadGroup,
17086  * :wait2, :$>]
17087  */
17088 
17089 VALUE
17091 {
17093 
17095  return ary;
17096 }
17097 
17098 int
17100 {
17101  return is_const_id(id);
17102 }
17103 
17104 int
17106 {
17107  return is_class_id(id);
17108 }
17109 
17110 int
17112 {
17113  return is_global_id(id);
17114 }
17115 
17116 int
17118 {
17119  return is_instance_id(id);
17120 }
17121 
17122 int
17124 {
17125  return is_attrset_id(id);
17126 }
17127 
17128 int
17130 {
17131  return is_local_id(id);
17132 }
17133 
17134 int
17136 {
17137  return is_junk_id(id);
17138 }
17139 
17151 ID
17152 rb_check_id(volatile VALUE *namep)
17153 {
17154  st_data_t id;
17155  VALUE tmp;
17156  VALUE name = *namep;
17157 
17158  if (SYMBOL_P(name)) {
17159  return SYM2ID(name);
17160  }
17161  else if (!RB_TYPE_P(name, T_STRING)) {
17162  tmp = rb_check_string_type(name);
17163  if (NIL_P(tmp)) {
17164  tmp = rb_inspect(name);
17165  rb_raise(rb_eTypeError, "%s is not a symbol",
17166  RSTRING_PTR(tmp));
17167  }
17168  name = tmp;
17169  *namep = name;
17170  }
17171 
17172  sym_check_asciionly(name);
17173 
17174  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17175  return (ID)id;
17176 
17177  if (rb_is_attrset_name(name)) {
17178  struct RString fake_str;
17179  const VALUE localname = (VALUE)&fake_str;
17180  /* make local name by chopping '=' */
17181  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17182  fake_str.basic.klass = rb_cString;
17183  fake_str.as.heap.len = RSTRING_LEN(name) - 1;
17184  fake_str.as.heap.ptr = RSTRING_PTR(name);
17185  fake_str.as.heap.aux.capa = fake_str.as.heap.len;
17186  rb_enc_copy(localname, name);
17187  OBJ_FREEZE(localname);
17188 
17189  if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17190  return rb_id_attrset((ID)id);
17191  }
17192  RB_GC_GUARD(name);
17193  }
17194 
17195  return (ID)0;
17196 }
17197 
17198 ID
17199 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
17200 {
17201  st_data_t id;
17202  struct RString fake_str;
17203  const VALUE name = (VALUE)&fake_str;
17204  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17205  fake_str.basic.klass = rb_cString;
17206  fake_str.as.heap.len = len;
17207  fake_str.as.heap.ptr = (char *)ptr;
17208  fake_str.as.heap.aux.capa = len;
17209  rb_enc_associate(name, enc);
17210 
17211  sym_check_asciionly(name);
17212 
17213  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17214  return (ID)id;
17215 
17216  if (rb_is_attrset_name(name)) {
17217  fake_str.as.heap.len = len - 1;
17218  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
17219  return rb_id_attrset((ID)id);
17220  }
17221  }
17222 
17223  return (ID)0;
17224 }
17225 
17226 int
17228 {
17229  return rb_str_symname_type(name, 0) == ID_CONST;
17230 }
17231 
17232 int
17234 {
17235  return rb_str_symname_type(name, 0) == ID_CLASS;
17236 }
17237 
17238 int
17240 {
17241  return rb_str_symname_type(name, 0) == ID_GLOBAL;
17242 }
17243 
17244 int
17246 {
17247  return rb_str_symname_type(name, 0) == ID_INSTANCE;
17248 }
17249 
17250 int
17252 {
17254 }
17255 
17256 int
17258 {
17259  return rb_str_symname_type(name, 0) == ID_LOCAL;
17260 }
17261 
17262 int
17264 {
17265  switch (rb_str_symname_type(name, 0)) {
17266  case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17267  return TRUE;
17268  }
17269  return FALSE;
17270 }
17271 
17272 int
17274 {
17275  return rb_str_symname_type(name, IDSET_ATTRSET_FOR_SYNTAX) == -1;
17276 }
17277 
17278 #endif /* !RIPPER */
17279 
17280 static void
17282 {
17283  parser->eofp = Qfalse;
17284 
17285  parser->parser_lex_strterm = 0;
17286  parser->parser_cond_stack = 0;
17287  parser->parser_cmdarg_stack = 0;
17288  parser->parser_class_nest = 0;
17289  parser->parser_paren_nest = 0;
17290  parser->parser_lpar_beg = 0;
17291  parser->parser_brace_nest = 0;
17292  parser->parser_in_single = 0;
17293  parser->parser_in_def = 0;
17294  parser->parser_in_defined = 0;
17295  parser->parser_compile_for_eval = 0;
17296  parser->parser_cur_mid = 0;
17297  parser->parser_tokenbuf = NULL;
17298  parser->parser_tokidx = 0;
17299  parser->parser_toksiz = 0;
17300  parser->parser_heredoc_end = 0;
17301  parser->parser_command_start = TRUE;
17302  parser->parser_deferred_nodes = 0;
17303  parser->parser_lex_pbeg = 0;
17304  parser->parser_lex_p = 0;
17305  parser->parser_lex_pend = 0;
17306  parser->parser_lvtbl = 0;
17307  parser->parser_ruby__end__seen = 0;
17308  parser->parser_ruby_sourcefile = 0;
17309 #ifndef RIPPER
17310  parser->is_ripper = 0;
17311  parser->parser_eval_tree_begin = 0;
17312  parser->parser_eval_tree = 0;
17313 #else
17314  parser->is_ripper = 1;
17315  parser->parser_ruby_sourcefile_string = Qnil;
17316  parser->delayed = Qnil;
17317 
17318  parser->result = Qnil;
17319  parser->parsing_thread = Qnil;
17320  parser->toplevel_p = TRUE;
17321 #endif
17322 #ifdef YYMALLOC
17323  parser->heap = NULL;
17324 #endif
17325  parser->enc = rb_utf8_encoding();
17326 }
17327 
17328 #ifdef RIPPER
17329 #define parser_mark ripper_parser_mark
17330 #define parser_free ripper_parser_free
17331 #endif
17332 
17333 static void
17335 {
17336  struct parser_params *p = (struct parser_params*)ptr;
17337 
17343 #ifndef RIPPER
17346  rb_gc_mark(p->debug_lines);
17347 #else
17348  rb_gc_mark(p->parser_ruby_sourcefile_string);
17349  rb_gc_mark(p->delayed);
17350  rb_gc_mark(p->value);
17351  rb_gc_mark(p->result);
17352  rb_gc_mark(p->parsing_thread);
17353 #endif
17354 #ifdef YYMALLOC
17355  rb_gc_mark((VALUE)p->heap);
17356 #endif
17357 }
17358 
17359 static void
17360 parser_free(void *ptr)
17361 {
17362  struct parser_params *p = (struct parser_params*)ptr;
17363  struct local_vars *local, *prev;
17364 
17365  if (p->parser_tokenbuf) {
17366  xfree(p->parser_tokenbuf);
17367  }
17368  for (local = p->parser_lvtbl; local; local = prev) {
17369  if (local->vars) xfree(local->vars);
17370  prev = local->prev;
17371  xfree(local);
17372  }
17373 #ifndef RIPPER
17375 #endif
17376  xfree(p);
17377 }
17378 
17379 static size_t
17380 parser_memsize(const void *ptr)
17381 {
17382  struct parser_params *p = (struct parser_params*)ptr;
17383  struct local_vars *local;
17384  size_t size = sizeof(*p);
17385 
17386  if (!ptr) return 0;
17387  size += p->parser_toksiz;
17388  for (local = p->parser_lvtbl; local; local = local->prev) {
17389  size += sizeof(*local);
17390  if (local->vars) size += local->vars->capa * sizeof(ID);
17391  }
17392 #ifndef RIPPER
17393  if (p->parser_ruby_sourcefile) {
17394  size += strlen(p->parser_ruby_sourcefile) + 1;
17395  }
17396 #endif
17397  return size;
17398 }
17399 
17400 static
17401 #ifndef RIPPER
17402 const
17403 #endif
17404 rb_data_type_t parser_data_type = {
17405  "parser",
17406  {
17407  parser_mark,
17408  parser_free,
17410  },
17411 };
17412 
17413 #ifndef RIPPER
17414 #undef rb_reserved_word
17415 
17416 const struct kwtable *
17417 rb_reserved_word(const char *str, unsigned int len)
17418 {
17419  return reserved_word(str, len);
17420 }
17421 
17422 static struct parser_params *
17424 {
17425  struct parser_params *p;
17426 
17427  p = ALLOC_N(struct parser_params, 1);
17428  MEMZERO(p, struct parser_params, 1);
17429  parser_initialize(p);
17430  return p;
17431 }
17432 
17433 VALUE
17435 {
17436  struct parser_params *p = parser_new();
17437 
17438  return TypedData_Wrap_Struct(0, &parser_data_type, p);
17439 }
17440 
17441 /*
17442  * call-seq:
17443  * ripper#end_seen? -> Boolean
17444  *
17445  * Return true if parsed source ended by +\_\_END\_\_+.
17446  */
17447 VALUE
17449 {
17450  struct parser_params *parser;
17451 
17452  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17453  return ruby__end__seen ? Qtrue : Qfalse;
17454 }
17455 
17456 /*
17457  * call-seq:
17458  * ripper#encoding -> encoding
17459  *
17460  * Return encoding of the source.
17461  */
17462 VALUE
17464 {
17465  struct parser_params *parser;
17466 
17467  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17469 }
17470 
17471 /*
17472  * call-seq:
17473  * ripper.yydebug -> true or false
17474  *
17475  * Get yydebug.
17476  */
17477 VALUE
17479 {
17480  struct parser_params *parser;
17481 
17482  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17483  return yydebug ? Qtrue : Qfalse;
17484 }
17485 
17486 /*
17487  * call-seq:
17488  * ripper.yydebug = flag
17489  *
17490  * Set yydebug.
17491  */
17492 VALUE
17494 {
17495  struct parser_params *parser;
17496 
17497  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17498  yydebug = RTEST(flag);
17499  return flag;
17500 }
17501 
17502 #ifdef YYMALLOC
17503 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17504 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17505 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17506  (n)->u3.cnt = (c), (p))
17507 
17508 void *
17509 rb_parser_malloc(struct parser_params *parser, size_t size)
17510 {
17511  size_t cnt = HEAPCNT(1, size);
17512  NODE *n = NEWHEAP();
17513  void *ptr = xmalloc(size);
17514 
17515  return ADD2HEAP(n, cnt, ptr);
17516 }
17517 
17518 void *
17519 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17520 {
17521  size_t cnt = HEAPCNT(nelem, size);
17522  NODE *n = NEWHEAP();
17523  void *ptr = xcalloc(nelem, size);
17524 
17525  return ADD2HEAP(n, cnt, ptr);
17526 }
17527 
17528 void *
17529 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17530 {
17531  NODE *n;
17532  size_t cnt = HEAPCNT(1, size);
17533 
17534  if (ptr && (n = parser->heap) != NULL) {
17535  do {
17536  if (n->u1.node == ptr) {
17537  n->u1.node = ptr = xrealloc(ptr, size);
17538  if (n->u3.cnt) n->u3.cnt = cnt;
17539  return ptr;
17540  }
17541  } while ((n = n->u2.node) != NULL);
17542  }
17543  n = NEWHEAP();
17544  ptr = xrealloc(ptr, size);
17545  return ADD2HEAP(n, cnt, ptr);
17546 }
17547 
17548 void
17549 rb_parser_free(struct parser_params *parser, void *ptr)
17550 {
17551  NODE **prev = &parser->heap, *n;
17552 
17553  while ((n = *prev) != NULL) {
17554  if (n->u1.node == ptr) {
17555  *prev = n->u2.node;
17557  break;
17558  }
17559  prev = &n->u2.node;
17560  }
17561  xfree(ptr);
17562 }
17563 #endif
17564 #endif
17565 
17566 #ifdef RIPPER
17567 #ifdef RIPPER_DEBUG
17568 extern int rb_is_pointer_to_heap(VALUE);
17569 
17570 /* :nodoc: */
17571 static VALUE
17572 ripper_validate_object(VALUE self, VALUE x)
17573 {
17574  if (x == Qfalse) return x;
17575  if (x == Qtrue) return x;
17576  if (x == Qnil) return x;
17577  if (x == Qundef)
17578  rb_raise(rb_eArgError, "Qundef given");
17579  if (FIXNUM_P(x)) return x;
17580  if (SYMBOL_P(x)) return x;
17581  if (!rb_is_pointer_to_heap(x))
17582  rb_raise(rb_eArgError, "invalid pointer: %p", x);
17583  switch (TYPE(x)) {
17584  case T_STRING:
17585  case T_OBJECT:
17586  case T_ARRAY:
17587  case T_BIGNUM:
17588  case T_FLOAT:
17589  return x;
17590  case T_NODE:
17591  if (nd_type(x) != NODE_LASGN) {
17592  rb_raise(rb_eArgError, "NODE given: %p", x);
17593  }
17594  return ((NODE *)x)->nd_rval;
17595  default:
17596  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17597  x, rb_obj_classname(x));
17598  }
17599  return x;
17600 }
17601 #endif
17602 
17603 #define validate(x) ((x) = get_value(x))
17604 
17605 static VALUE
17606 ripper_dispatch0(struct parser_params *parser, ID mid)
17607 {
17608  return rb_funcall(parser->value, mid, 0);
17609 }
17610 
17611 static VALUE
17612 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17613 {
17614  validate(a);
17615  return rb_funcall(parser->value, mid, 1, a);
17616 }
17617 
17618 static VALUE
17619 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17620 {
17621  validate(a);
17622  validate(b);
17623  return rb_funcall(parser->value, mid, 2, a, b);
17624 }
17625 
17626 static VALUE
17627 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17628 {
17629  validate(a);
17630  validate(b);
17631  validate(c);
17632  return rb_funcall(parser->value, mid, 3, a, b, c);
17633 }
17634 
17635 static VALUE
17636 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17637 {
17638  validate(a);
17639  validate(b);
17640  validate(c);
17641  validate(d);
17642  return rb_funcall(parser->value, mid, 4, a, b, c, d);
17643 }
17644 
17645 static VALUE
17646 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17647 {
17648  validate(a);
17649  validate(b);
17650  validate(c);
17651  validate(d);
17652  validate(e);
17653  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17654 }
17655 
17656 static VALUE
17657 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17658 {
17659  validate(a);
17660  validate(b);
17661  validate(c);
17662  validate(d);
17663  validate(e);
17664  validate(f);
17665  validate(g);
17666  return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17667 }
17668 
17669 static const struct kw_assoc {
17670  ID id;
17671  const char *name;
17672 } keyword_to_name[] = {
17673  {keyword_class, "class"},
17674  {keyword_module, "module"},
17675  {keyword_def, "def"},
17676  {keyword_undef, "undef"},
17677  {keyword_begin, "begin"},
17678  {keyword_rescue, "rescue"},
17679  {keyword_ensure, "ensure"},
17680  {keyword_end, "end"},
17681  {keyword_if, "if"},
17682  {keyword_unless, "unless"},
17683  {keyword_then, "then"},
17684  {keyword_elsif, "elsif"},
17685  {keyword_else, "else"},
17686  {keyword_case, "case"},
17687  {keyword_when, "when"},
17688  {keyword_while, "while"},
17689  {keyword_until, "until"},
17690  {keyword_for, "for"},
17691  {keyword_break, "break"},
17692  {keyword_next, "next"},
17693  {keyword_redo, "redo"},
17694  {keyword_retry, "retry"},
17695  {keyword_in, "in"},
17696  {keyword_do, "do"},
17697  {keyword_do_cond, "do"},
17698  {keyword_do_block, "do"},
17699  {keyword_return, "return"},
17700  {keyword_yield, "yield"},
17701  {keyword_super, "super"},
17702  {keyword_self, "self"},
17703  {keyword_nil, "nil"},
17704  {keyword_true, "true"},
17705  {keyword_false, "false"},
17706  {keyword_and, "and"},
17707  {keyword_or, "or"},
17708  {keyword_not, "not"},
17709  {modifier_if, "if"},
17710  {modifier_unless, "unless"},
17711  {modifier_while, "while"},
17712  {modifier_until, "until"},
17713  {modifier_rescue, "rescue"},
17714  {keyword_alias, "alias"},
17715  {keyword_defined, "defined?"},
17716  {keyword_BEGIN, "BEGIN"},
17717  {keyword_END, "END"},
17718  {keyword__LINE__, "__LINE__"},
17719  {keyword__FILE__, "__FILE__"},
17720  {keyword__ENCODING__, "__ENCODING__"},
17721  {0, NULL}
17722 };
17723 
17724 static const char*
17725 keyword_id_to_str(ID id)
17726 {
17727  const struct kw_assoc *a;
17728 
17729  for (a = keyword_to_name; a->id; a++) {
17730  if (a->id == id)
17731  return a->name;
17732  }
17733  return NULL;
17734 }
17735 
17736 #undef ripper_id2sym
17737 static VALUE
17738 ripper_id2sym(ID id)
17739 {
17740  const char *name;
17741  char buf[8];
17742 
17743  if (id <= 256) {
17744  buf[0] = (char)id;
17745  buf[1] = '\0';
17746  return ID2SYM(rb_intern2(buf, 1));
17747  }
17748  if ((name = keyword_id_to_str(id))) {
17749  return ID2SYM(rb_intern(name));
17750  }
17751  switch (id) {
17752  case tOROP:
17753  name = "||";
17754  break;
17755  case tANDOP:
17756  name = "&&";
17757  break;
17758  default:
17759  name = rb_id2name(id);
17760  if (!name) {
17761  rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17762  }
17763  return ID2SYM(id);
17764  }
17765  return ID2SYM(rb_intern(name));
17766 }
17767 
17768 static ID
17769 ripper_get_id(VALUE v)
17770 {
17771  NODE *nd;
17772  if (!RB_TYPE_P(v, T_NODE)) return 0;
17773  nd = (NODE *)v;
17774  if (nd_type(nd) != NODE_LASGN) return 0;
17775  return nd->nd_vid;
17776 }
17777 
17778 static VALUE
17779 ripper_get_value(VALUE v)
17780 {
17781  NODE *nd;
17782  if (v == Qundef) return Qnil;
17783  if (!RB_TYPE_P(v, T_NODE)) return v;
17784  nd = (NODE *)v;
17785  if (nd_type(nd) != NODE_LASGN) return Qnil;
17786  return nd->nd_rval;
17787 }
17788 
17789 static void
17790 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17791 {
17792  VALUE str;
17793  va_list args;
17794 
17795  va_start(args, fmt);
17796  str = rb_vsprintf(fmt, args);
17797  va_end(args);
17798  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17799 }
17800 
17801 static void
17802 ripper_warn0(struct parser_params *parser, const char *fmt)
17803 {
17804  rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
17805 }
17806 
17807 static void
17808 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
17809 {
17810  rb_funcall(parser->value, rb_intern("warn"), 2,
17811  STR_NEW2(fmt), INT2NUM(a));
17812 }
17813 
17814 static void
17815 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
17816 {
17817  rb_funcall(parser->value, rb_intern("warn"), 2,
17818  STR_NEW2(fmt), STR_NEW2(str));
17819 }
17820 
17821 static void
17822 ripper_warning0(struct parser_params *parser, const char *fmt)
17823 {
17824  rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
17825 }
17826 
17827 static void
17828 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
17829 {
17830  rb_funcall(parser->value, rb_intern("warning"), 2,
17831  STR_NEW2(fmt), STR_NEW2(str));
17832 }
17833 
17834 static VALUE
17835 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
17836 {
17837  return rb_io_gets(src);
17838 }
17839 
17840 static VALUE
17841 ripper_s_allocate(VALUE klass)
17842 {
17843  struct parser_params *p;
17844  VALUE self;
17845 
17846  p = ALLOC_N(struct parser_params, 1);
17847  MEMZERO(p, struct parser_params, 1);
17848  self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
17849  p->value = self;
17850  return self;
17851 }
17852 
17853 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
17854 
17855 /*
17856  * call-seq:
17857  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
17858  *
17859  * Create a new Ripper object.
17860  * _src_ must be a String, an IO, or an Object which has #gets method.
17861  *
17862  * This method does not starts parsing.
17863  * See also Ripper#parse and Ripper.parse.
17864  */
17865 static VALUE
17866 ripper_initialize(int argc, VALUE *argv, VALUE self)
17867 {
17868  struct parser_params *parser;
17869  VALUE src, fname, lineno;
17870 
17871  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17872  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
17873  if (RB_TYPE_P(src, T_FILE)) {
17874  parser->parser_lex_gets = ripper_lex_get_generic;
17875  }
17876  else {
17877  StringValue(src);
17878  parser->parser_lex_gets = lex_get_str;
17879  }
17880  parser->parser_lex_input = src;
17881  parser->eofp = Qfalse;
17882  if (NIL_P(fname)) {
17883  fname = STR_NEW2("(ripper)");
17884  }
17885  else {
17886  StringValue(fname);
17887  }
17888  parser_initialize(parser);
17889 
17890  parser->parser_ruby_sourcefile_string = fname;
17891  parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
17892  parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
17893 
17894  return Qnil;
17895 }
17896 
17897 struct ripper_args {
17898  struct parser_params *parser;
17899  int argc;
17900  VALUE *argv;
17901 };
17902 
17903 static VALUE
17904 ripper_parse0(VALUE parser_v)
17905 {
17906  struct parser_params *parser;
17907 
17908  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17909  parser_prepare(parser);
17910  ripper_yyparse((void*)parser);
17911  return parser->result;
17912 }
17913 
17914 static VALUE
17915 ripper_ensure(VALUE parser_v)
17916 {
17917  struct parser_params *parser;
17918 
17919  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17920  parser->parsing_thread = Qnil;
17921  return Qnil;
17922 }
17923 
17924 /*
17925  * call-seq:
17926  * ripper#parse
17927  *
17928  * Start parsing and returns the value of the root action.
17929  */
17930 static VALUE
17931 ripper_parse(VALUE self)
17932 {
17933  struct parser_params *parser;
17934 
17935  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17936  if (!ripper_initialized_p(parser)) {
17937  rb_raise(rb_eArgError, "method called for uninitialized object");
17938  }
17939  if (!NIL_P(parser->parsing_thread)) {
17940  if (parser->parsing_thread == rb_thread_current())
17941  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
17942  else
17943  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
17944  }
17945  parser->parsing_thread = rb_thread_current();
17946  rb_ensure(ripper_parse0, self, ripper_ensure, self);
17947 
17948  return parser->result;
17949 }
17950 
17951 /*
17952  * call-seq:
17953  * ripper#column -> Integer
17954  *
17955  * Return column number of current parsing line.
17956  * This number starts from 0.
17957  */
17958 static VALUE
17959 ripper_column(VALUE self)
17960 {
17961  struct parser_params *parser;
17962  long col;
17963 
17964  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17965  if (!ripper_initialized_p(parser)) {
17966  rb_raise(rb_eArgError, "method called for uninitialized object");
17967  }
17968  if (NIL_P(parser->parsing_thread)) return Qnil;
17969  col = parser->tokp - parser->parser_lex_pbeg;
17970  return LONG2NUM(col);
17971 }
17972 
17973 /*
17974  * call-seq:
17975  * ripper#filename -> String
17976  *
17977  * Return current parsing filename.
17978  */
17979 static VALUE
17980 ripper_filename(VALUE self)
17981 {
17982  struct parser_params *parser;
17983 
17984  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17985  if (!ripper_initialized_p(parser)) {
17986  rb_raise(rb_eArgError, "method called for uninitialized object");
17987  }
17988  return parser->parser_ruby_sourcefile_string;
17989 }
17990 
17991 /*
17992  * call-seq:
17993  * ripper#lineno -> Integer
17994  *
17995  * Return line number of current parsing line.
17996  * This number starts from 1.
17997  */
17998 static VALUE
17999 ripper_lineno(VALUE self)
18000 {
18001  struct parser_params *parser;
18002 
18003  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18004  if (!ripper_initialized_p(parser)) {
18005  rb_raise(rb_eArgError, "method called for uninitialized object");
18006  }
18007  if (NIL_P(parser->parsing_thread)) return Qnil;
18008  return INT2NUM(parser->parser_ruby_sourceline);
18009 }
18010 
18011 #ifdef RIPPER_DEBUG
18012 /* :nodoc: */
18013 static VALUE
18014 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
18015 {
18016  StringValue(msg);
18017  if (obj == Qundef) {
18018  rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
18019  }
18020  return Qnil;
18021 }
18022 
18023 /* :nodoc: */
18024 static VALUE
18025 ripper_value(VALUE self, VALUE obj)
18026 {
18027  return ULONG2NUM(obj);
18028 }
18029 #endif
18030 
18031 
18032 void
18033 Init_ripper(void)
18034 {
18035  parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
18036 
18039  /* ensure existing in symbol table */
18040  (void)rb_intern("||");
18041  (void)rb_intern("&&");
18042 
18043  InitVM(ripper);
18044 }
18045 
18046 void
18047 InitVM_ripper(void)
18048 {
18049  VALUE Ripper;
18050 
18051  Ripper = rb_define_class("Ripper", rb_cObject);
18052  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
18053  rb_define_alloc_func(Ripper, ripper_s_allocate);
18054  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
18055  rb_define_method(Ripper, "parse", ripper_parse, 0);
18056  rb_define_method(Ripper, "column", ripper_column, 0);
18057  rb_define_method(Ripper, "filename", ripper_filename, 0);
18058  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
18059  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
18060  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
18061  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
18062  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
18063 #ifdef RIPPER_DEBUG
18064  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
18065  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
18066  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
18067 #endif
18068 
18071 
18072 # if 0
18073  /* Hack to let RDoc document SCRIPT_LINES__ */
18074 
18075  /*
18076  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
18077  * after the assignment will be added as an Array of lines with the file
18078  * name as the key.
18079  */
18080  rb_define_global_const("SCRIPT_LINES__", Qnil);
18081 #endif
18082 
18083 }
18084 #endif /* RIPPER */
18085 
#define in_defined
Definition: ripper.c:380
static const struct @60 op_tbl[]
#define rb_enc_islower(c, enc)
char * parser_ruby_sourcefile
Definition: ripper.c:327
#define RB_TYPE_P(obj, type)
VALUE val
Definition: parse.h:164
#define local_var(id)
Definition: ripper.c:557
#define cond(node)
Definition: ripper.c:423
#define deferred_nodes
Definition: ripper.c:393
#define nd_next
#define nd_type(n)
#define arg_var(id)
Definition: ripper.c:559
#define NEW_ARGSCAT(a, b)
#define NODE_DREGX_ONCE
#define ret_args(node)
Definition: ripper.c:474
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:1882
#define yyparse
Definition: ripper.c:417
stack_type cmdargs
Definition: ripper.c:193
#define ALLOC(type)
#define NEW_FALSE()
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: ripper.c:4716
enum lex_state_e state
Definition: lex.c:33
struct local_vars * parser_lvtbl
Definition: ripper.c:323
#define NODE_IF
VALUE rb_ary_unshift(VALUE ary, VALUE item)
Definition: array.c:1084
static ID ripper_token2eventid(int tok)
Definition: eventids2.c:273
#define NODE_RESCUE
Definition: lex.c:33
#define IS_LABEL_SUFFIX(n)
Definition: ripper.c:13408
#define new_args_tail(k, kr, b)
Definition: ripper.c:470
#define YYSTACK_ALLOC
Definition: ripper.c:1043
int rb_is_attrset_id(ID id)
Definition: ripper.c:17123
int rb_enc_codelen(int c, rb_encoding *enc)
Definition: encoding.c:954
#define NODE_RETRY
Definition: ripper.y:119
#define NODE_DEFN
static double zero(void)
Definition: isinf.c:51
#define lex_input
Definition: ripper.c:385
#define lex_state
Definition: ripper.c:369
#define subnodes(n1, n2)
#define parser_precise_mbclen()
Definition: ripper.c:11703
static NODE * remove_begin(NODE *)
Definition: ripper.c:15574
#define NEW_STRTERM(func, term, paren)
Definition: ripper.c:12710
static const yytype_int16 yydefgoto[]
Definition: ripper.c:1868
#define list_concat(h, t)
Definition: ripper.c:448
#define NODE_FALSE
#define NEW_DOT3(b, e)
case return tREGEXP_BEG
Definition: ripper.y:7625
static struct parser_params * parser_new(void)
Definition: ripper.c:17423
#define FLONUM_P(x)
#define NODE_OR
int onig_foreach_name(regex_t *reg, int(*func)(const UChar *, const UChar *, int, int *, regex_t *, void *), void *arg)
Definition: regparse.c:537
union YYSTYPE YYSTYPE
st_table * st_init_table_with_size(const struct st_hash_type *, st_index_t)
Definition: st.c:229
#define NEW_IASGN(v, val)
VALUE rb_get_coverages(void)
Definition: thread.c:5182
#define yydebug
Definition: ripper.c:401
static NODE * arg_blk_pass(NODE *, NODE *)
Definition: ripper.c:15916
#define NEW_NTH_REF(n)
static ID internal_id_gen(struct parser_params *)
Definition: ripper.c:16635
Definition: ripper.y:115
void rb_bug(const char *fmt,...)
Definition: error.c:290
#define NEW_DASGN_CURR(v, val)
int num
Definition: parse.h:167
#define IS_END()
Definition: ripper.c:13404
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:15840
static const struct kwtable * reserved_word(const char *, unsigned int)
#define tail
Definition: st.c:108
Definition: ripper.y:108
void rb_mark_tbl(struct st_table *)
Definition: gc.c:2543
int rb_is_class_name(VALUE name)
Definition: ripper.c:17233
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:12072
static int comment_at_top(struct parser_params *parser)
Definition: ripper.c:13149
#define RE_OPTION_ENCODING_IDX(o)
Definition: ripper.c:584
#define rb_gc_mark_locations(start, end)
Definition: gc.c:2348
size_t strlen(const char *)
#define assignable(id, node)
Definition: ripper.c:484
int i
Definition: win32ole.c:784
static size_t parser_memsize(const void *ptr)
Definition: ripper.c:17380
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:12090
#define scan_oct(s, l, e)
Definition: util.h:52
unsigned long VALUE
Definition: ripper.y:104
VALUE stack_type
Definition: ripper.c:164
const char * rb_obj_classname(VALUE)
Definition: variable.c:396
#define IDSET_ATTRSET_FOR_SYNTAX
Definition: ripper.c:16681
#define reg_compile(str, options)
Definition: ripper.c:511
VALUE rb_id2str(ID id)
Definition: ripper.c:16992
static NODE * call_uni_op_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:15001
#define toksiz
Definition: ripper.c:383
#define YY_(msgid)
Definition: ripper.c:975
int parser_ruby__end__seen
Definition: ripper.c:324
#define NODE_DSYM
int parser_command_start
Definition: ripper.c:319
static void fixpos(NODE *, NODE *)
Definition: ripper.c:14751
#define NODE_DEFS
#define YYSTACK_FREE
Definition: ripper.c:1044
#define NEW_CALL(r, m, a)
int st_lookup(st_table *, st_data_t, st_data_t *)
void st_add_direct(st_table *, st_data_t, st_data_t)
Definition: st.c:624
#define nd_body
static void reduce_nodes_gen(struct parser_params *, NODE **)
Definition: ripper.c:15584
#define value_expr(node)
Definition: ripper.c:433
#define nd_paren(node)
Definition: ripper.c:598
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2106
#define NODE_HASH
#define NODE_DOT3
static NODE * call_bin_op_gen(struct parser_params *, NODE *, ID, NODE *)
Definition: ripper.c:14993
const char * name
Definition: lex.c:33
#define tEMBDOC_BEG
Definition: eventids2.c:3
Definition: ripper.y:118
static int parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp, int string_literal, int symbol_literal, int regexp_literal)
Definition: ripper.c:12259
int parser_compile_for_eval
Definition: ripper.c:305
#define get_id(id)
Definition: ripper.c:519
int parser_token_info_enabled
Definition: ripper.c:341
#define NEW_ALIAS(n, o)
#define NEW_OP_CDECL(v, op, val)
int parser_brace_nest
Definition: ripper.c:304
#define YYLEX
Definition: ripper.c:4464
static NODE * new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: ripper.c:16046
Definition: ripper.y:105
#define YYABORT
Definition: ripper.c:4384
static void parser_heredoc_restore(struct parser_params *parser, NODE *here)
Definition: ripper.c:12918
#define lex_eol_p()
Definition: ripper.c:12126
#define rb_usascii_str_new2
#define NEW_TRUE()
static int yysyntax_error(YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
Definition: ripper.c:4764
#define dyna_in_block()
Definition: ripper.c:570
#define nd_resq
#define NODE_NTH_REF
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:2216
static NODE * gettable_gen(struct parser_params *, ID)
Definition: ripper.c:15042
#define str_copy(_s, _p, _n)
void rb_gc_force_recycle(VALUE)
Definition: gc.c:2963
#define NODE_TRUE
#define was_bol()
Definition: ripper.c:12196
#define IS_SPCARG(c)
Definition: ripper.c:13406
#define void_stmts(node)
Definition: ripper.c:437
#define T_NODE
static struct symbols global_symbols
static YYSIZE_T yystrlen(char *yystr) const
Definition: ripper.c:4667
#define rb_enc_name(enc)
VALUE rb_parser_end_seen_p(VALUE vparser)
Definition: ripper.c:17448
const int id
Definition: nkf.c:209
#define current_enc
Definition: ripper.c:400
int line_count
Definition: ripper.c:325
#define YYNTOKENS
Definition: ripper.c:1140
#define NEW_EVSTR(n)
#define NODE_ARGS
#define NEW_NEXT(s)
struct token_info token_info
#define new_op_assign(lhs, op, rhs)
Definition: ripper.c:543
stack_type parser_cmdarg_stack
Definition: ripper.c:298
#define RFLOAT_VALUE(v)
#define new_args(f, o, r, p, t)
Definition: ripper.c:468
#define strcasecmp
Definition: win32.h:200
#define nextc()
Definition: ripper.c:11593
#define rb_warning0(fmt)
Definition: ripper.c:697
VALUE rb_enc_from_encoding(rb_encoding *encoding)
Definition: encoding.c:103
#define NEW_NIL()
#define token_info_push(token)
Definition: ripper.c:736
static VALUE debug_lines(const char *f)
Definition: ripper.c:11849
#define NODE_ENSURE
VALUE rb_eTypeError
Definition: error.c:511
#define rb_enc_isalnum(c, enc)
static int parser_here_document(struct parser_params *, NODE *)
Definition: ripper.c:12965
#define OBJ_FREEZE(x)
NODE * node
Definition: parse.h:165
#define rb_warnS(fmt, a)
Definition: ripper.c:695
#define dsym_node(node)
Definition: ripper.c:479
Definition: ripper.y:120
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
long(* rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len)
Definition: ripper.c:13161
#define NEW_ZARRAY()
st_table * names
Definition: encoding.c:53
#define logop(type, node1, node2)
Definition: ripper.c:425
#define rb_enc_prev_char(s, p, e, enc)
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:822
static void yydestruct(char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser) const
Definition: ripper.c:4903
NODE * kw_args
Definition: ripper.y:517
Definition: ripper.y:99
#define MAX_WORD_LENGTH
Definition: lex.c:43
static NODE * evstr2dstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:14970
VALUE rb_eEncodingError
Definition: error.c:517
static int reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end, int back_num, int *back_refs, OnigRegex regex, void *arg0)
Definition: ripper.c:16359
static void warn_unused_var(struct parser_params *parser, struct local_vars *local)
Definition: ripper.c:16081
#define TYPE(x)
struct RBasic basic
Definition: ripper.y:843
unsigned short int yytype_uint16
Definition: ripper.c:942
#define nd_else
#define parse_string(n)
Definition: ripper.c:11603
yytokentype
Definition: ripper.y:40
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:789
#define NODE_PRELUDE
const struct kwtable * rb_reserved_word(const char *str, unsigned int len)
Definition: ripper.c:17417
#define is_identchar(p, e, enc)
Definition: ripper.c:11704
#define RSTRING_PTR(str)
#define NEW_MATCH2(n1, n2)
VALUE op_sym[tLAST_OP_ID]
Definition: ripper.c:16571
#define COND_PUSH(n)
Definition: ripper.c:171
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2530
#define T_ARRAY
VALUE debug_lines
Definition: ripper.c:337
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
Definition: string.c:439
#define warn_balanced(op, syn)
Definition: ripper.c:13418
#define NEW_LAMBDA(a, b)
ID id
Definition: parse.h:166
#define nd_plen
#define match_op(node1, node2)
Definition: ripper.c:503
#define CMDARG_P()
Definition: ripper.c:179
#define dvar_defined(id)
Definition: ripper.c:573
#define NEW_POSTEXE(b)
#define NEW_STR(s)
#define yyerrok
Definition: ripper.c:4378
#define NODE_EVSTR
#define YYEMPTY
Definition: ripper.c:4380
#define tok()
Definition: ripper.c:12199
#define xfree
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
Definition: vm_eval.c:773
#define Qnil
#define NODE_DXSTR
static void ripper_init_eventids1_table(VALUE self)
Definition: eventids1.c:270
#define reg_fragment_setenc(str, options)
Definition: ripper.c:513
static NODE * match_op_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15008
#define NODE_CASE
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1780
#define rb_warn4S(file, line, fmt, a)
Definition: ripper.c:696
#define rb_warnI(fmt, a)
Definition: ripper.c:694
#define T_HASH
Definition: ripper.y:109
static NODE * node_assign_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15378
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:14774
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: ripper.c:4481
static NODE * newline_node(NODE *)
Definition: ripper.c:14741
ID * tbl
Definition: ripper.c:182
union RString::@63 as
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:172
#define newtok()
Definition: ripper.c:11595
static NODE * range_op(struct parser_params *parser, NODE *node)
Definition: ripper.c:15739
#define reduce_nodes(n)
Definition: ripper.c:439
#define YYPOPSTACK(N)
#define T_FILE
#define dyna_var(id)
Definition: ripper.c:571
int pre_args_num
Definition: ripper.y:509
primary_value operation2 command_args prec tLOWEST
Definition: ripper.y:1401
#define NODE_HEREDOC
Definition: ripper.c:590
#define NEW_CONST(v)
int parser_toksiz
Definition: ripper.c:310
#define POINTER_P(val)
Definition: ripper.c:199
#define STR_FUNC_INDENT
Definition: ripper.c:12095
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
Definition: encoding.c:886
VALUE rb_ary_new3(long n,...)
Definition: array.c:432
static void parser_pushback(struct parser_params *parser, int c)
Definition: ripper.c:12187
NODE * kw_rest_arg
Definition: ripper.y:518
#define NODE_STR
ID last_id
Definition: ripper.c:16564
#define Qnone
Definition: ripper.c:685
#define RFLOAT(obj)
#define NODE_REDO
static int lvar_defined_gen(struct parser_params *, ID)
Definition: ripper.c:13090
#define NODE_NEXT
const char * alias
Definition: nkf.c:1151
#define ruby__end__seen
Definition: ripper.c:397
Definition: ripper.y:112
#define NEW_DVAR(v)
void(* rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13162
#define ruby_debug_lines
Definition: ripper.c:406
#define parser_is_identchar()
Definition: ripper.c:11705
#define local_pop()
Definition: ripper.c:555
#define ID_LOCAL
Definition: ripper.y:82
#define NODE_XSTR
Definition: ripper.y:107
#define NEW_CVASGN(v, val)
static int parser_whole_match_p(struct parser_params *parser, const char *eos, long len, int indent)
Definition: ripper.c:12935
#define NODE_BLOCK_PASS
#define RE_OPTION_ENCODING(e)
Definition: ripper.c:583
#define rb_backref_error(n)
Definition: ripper.c:492
#define ISDIGIT(c)
#define NEW_BREAK(s)
unsigned int last
Definition: nkf.c:4310
#define NEW_OP_ASGN_OR(i, val)
static void parser_initialize(struct parser_params *parser)
Definition: ripper.c:17281
#define NEW_MASGN(l, r)
ID block_arg
Definition: ripper.y:515
#define ENCODING_IS_ASCII8BIT(obj)
static NODE * node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE)
Definition: ripper.c:14721
#define InitVM(ext)
static const yytype_uint16 yyr1[]
Definition: ripper.c:1621
ID rb_check_id(volatile VALUE *namep)
Returns ID for the given name if it is interned already, or 0.
Definition: ripper.c:17152
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
Definition: ripper.c:17199
static NODE * yycompile(struct parser_params *parser, const char *f, int line)
Definition: ripper.c:11949
struct RNode * node
Definition: ripper.y:244
static ID * vtable_tblcpy(ID *buf, const struct vtable *src)
Definition: ripper.c:16134
#define lex_gets_ptr
Definition: ripper.c:394
rb_encoding * rb_utf8_encoding(void)
Definition: encoding.c:1168
#define ID2SYM(x)
#define here_document(n)
Definition: ripper.c:11605
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:13097
#define T_FLOAT
#define is_instance_id(id)
Definition: ripper.c:113
#define NEW_LVAR(v)
#define call_bin_op(recv, id, arg1)
Definition: ripper.c:463
VALUE klass
Definition: ripper.y:701
#define arg_concat(h, t)
Definition: ripper.c:452
#define rb_enc_isdigit(c, enc)
#define T_OBJECT
static enum node_type nodetype(NODE *node)
Definition: ripper.c:14729
#define ENC_CODERANGE_BROKEN
VALUE rb_sym_all_symbols(void)
Definition: ripper.c:17090
static VALUE lex_getline(struct parser_params *parser)
Definition: ripper.c:11988
static NODE * ret_args_gen(struct parser_params *, NODE *)
Definition: ripper.c:15863
Definition: ripper.y:114
#define ID_INTERNAL
#define LONG2NUM(x)
VALUE rb_str_append(VALUE, VALUE)
Definition: string.c:2122
static const yytype_int16 yytable[]
Definition: ripper.c:2034
#define RUBY_DTRACE_PARSE_BEGIN(arg0, arg1)
Definition: probes.h:68
Definition: ripper.y:96
int pos
Definition: ripper.c:183
#define NEW_FOR(v, i, b)
#define YYLAST
Definition: ripper.c:1137
#define NEW_CLASS(n, b, s)
#define YYID(n)
Definition: ripper.c:988
#define NODE_GASGN
int rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:16782
#define NEW_SPLAT(a)
#define ID_SCOPE_SHIFT
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: ripper.c:17493
#define NEW_PRELUDE(p, b)
static int yylex(void *, void *)
Definition: ripper.c:14694
#define NEW_ITER(a, b)
#define head
Definition: st.c:107
#define ruby_sourcefile
Definition: ripper.c:399
#define ENCODING_GET(obj)
int parser_yydebug
Definition: ripper.c:331
#define gettable(id)
Definition: ripper.c:482
st_table * id_str
Definition: ripper.c:16566
NODE * parser_eval_tree
Definition: ripper.c:336
#define list_append(l, i)
Definition: ripper.c:446
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:12564
#define NEW_GVAR(v)
void rb_name_error(ID id, const char *fmt,...)
Definition: error.c:899
command_asgn lhs
Definition: ripper.y:1270
#define STR_NEW0()
Definition: ripper.c:359
Definition: ripper.y:240
static int e_option_supplied(struct parser_params *parser)
Definition: ripper.c:11883
static void block_dup_check_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15258
Definition: parse.h:159
int has_shebang
Definition: ripper.c:326
nd_args
Definition: parse.y:1382
#define NEWHEAP()
Definition: ripper.c:17504
#define NEW_DSTR(s)
Win32OLEIDispatch * p
Definition: win32ole.c:786
#define SPECIAL_PUNCT(idx)
Definition: ripper.c:12737
#define nd_set_type(n, t)
static int vtable_size(const struct vtable *tbl)
Definition: ripper.c:202
static int assign_in_cond(struct parser_params *parser, NODE *node)
Definition: ripper.c:15669
#define ISALPHA(c)
Definition: ruby.h:1636
#define MEMZERO(p, type, n)
void rb_exc_raise(VALUE mesg)
Definition: eval.c:527
#define NEW_UNLESS(c, t, e)
#define STR_FUNC_REGEXP
Definition: ripper.c:12092
#define NEW_MODULE(n, b)
static NODE * list_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14828
int args
Definition: win32ole.c:785
unsigned long st_data_t
Definition: ripper.y:35
#define strtod(s, e)
Definition: util.h:76
VALUE rb_usascii_str_new(const char *, long)
Definition: string.c:431
static rb_encoding * must_be_ascii_compatible(VALUE s)
Definition: ripper.c:11958
struct vtable * prev
Definition: ripper.c:185
int rb_is_const_id(ID id)
Definition: ripper.c:17099
int rb_is_instance_id(ID id)
Definition: ripper.c:17117
#define RUBY_DTRACE_PARSE_END(arg0, arg1)
Definition: probes.h:72
struct RString::@63::@64 heap
static int parser_tokadd_string(struct parser_params *, int, int, int, long *, rb_encoding **)
Definition: ripper.c:12577
#define VTBL_DEBUG
Definition: ripper.c:212
int rb_is_method_name(VALUE name)
Definition: ripper.c:17263
#define arg_append(h, t)
Definition: ripper.c:450
#define assignable_result(x)
#define CMDARG_PUSH(n)
Definition: ripper.c:176
Definition: ripper.y:110
#define RE_OPTION_MASK
Definition: ripper.c:586
Definition: ripper.y:97
#define NEW_OP_ASGN_AND(i, val)
static NODE * arg_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15327
rb_encoding * enc
Definition: ripper.c:329
#define parser_warning(node, mesg)
Definition: ripper.c:14764
#define NODE_LVAR
static int parser_regx_options(struct parser_params *)
Definition: ripper.c:12505
static void yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: ripper.c:4504
enum lex_state_e parser_lex_state
Definition: ripper.c:296
#define whole_match_p(e, l, i)
Definition: ripper.c:11608
#define op_tbl_count
Definition: ripper.c:16557
#define NODE_LASGN
int capa
Definition: ripper.c:184
VALUE parser_lex_lastline
Definition: ripper.c:313
#define lex_nextline
Definition: ripper.c:387
#define YYTERROR
Definition: ripper.c:4422
#define NEW_OPT_N(b)
Definition: ripper.y:113
NODE * rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: ripper.c:12037
#define set_yylval_literal(x)
Definition: ripper.c:11615
#define NEW_KW_ARG(i, v)
static int parser_yylex(struct parser_params *parser)
Definition: ripper.c:13424
static VALUE parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
Definition: ripper.c:12109
#define scan_hex(s, l, e)
Definition: util.h:54
static int dyna_in_block_gen(struct parser_params *)
Definition: ripper.c:16252
#define FIXNUM_P(f)
static const yytype_uint16 yystos[]
Definition: ripper.c:4268
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Definition: re.c:301
static char * parser_tokspace(struct parser_params *parser, int n)
Definition: ripper.c:12220
#define arg_ambiguous()
Definition: ripper.c:13076
#define TypedData_Get_Struct(obj, type, data_type, sval)
void rb_compile_error_append(const char *fmt,...)
Definition: error.c:150
#define evstr2dstr(n)
Definition: ripper.c:459
#define RARRAY_LEN(a)
static void parser_free(void *ptr)
Definition: ripper.c:17360
#define IS_ARG()
Definition: ripper.c:13403
#define PARSER_ARG
Definition: ripper.c:721
#define NODE_WHEN
#define StringValuePtr(v)
#define literal_concat(h, t)
Definition: ripper.c:454
#define val
int rb_ispunct(int c)
Definition: encoding.c:1892
VALUE rb_eRuntimeError
Definition: error.c:510
#define Qtrue
#define compile_error
Definition: ripper.c:720
static int symbols_i(VALUE sym, ID value, VALUE ary)
Definition: ripper.c:17067
const rb_data_type_t * parent
Definition: ripper.y:969
#define NEW_RESCUE(b, res, e)
#define RARRAY(obj)
#define yylval
Definition: ripper.c:11584
static int parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
Definition: ripper.c:12432
static int dvar_curr_gen(struct parser_params *, ID)
Definition: ripper.c:16289
VALUE rb_parser_encoding(VALUE vparser)
Definition: ripper.c:17463
return c
Definition: ripper.y:7591
union RNode::@81 u2
#define ifndef_ripper(x)
Definition: ripper.c:686
static const yytype_uint16 yyrline[]
Definition: ripper.c:1461
struct parser_params * parser
Definition: ripper.c:16351
#define NODE_YIELD
#define NEW_NODE(t, a0, a1, a2)
#define yytable_value_is_error(yytable_value)
Definition: ripper.c:3150
#define NEW_LIST(a)
#define NEW_ENSURE(b, en)
RUBY_EXTERN VALUE rb_mKernel
Definition: ripper.y:1414
#define cur_mid
Definition: ripper.c:379
#define NODE_FLIP2
char * ruby_strdup(const char *)
Definition: util.c:456
#define NODE_BLOCK
#define ID_INSTANCE
NODE * rb_compile_string(const char *f, VALUE s, int line)
Definition: ripper.c:12030
#define NEW_BLOCK(a)
static const yytype_uint16 yyprhs[]
Definition: ripper.c:1199
#define NODE_DASGN_CURR
static NODE * list_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14848
int parser_paren_nest
Definition: ripper.c:300
VALUE rb_ary_new(void)
Definition: array.c:424
#define NODE_AND
int rb_ascii8bit_encindex(void)
Definition: encoding.c:1162
unsigned long ID
Definition: ripper.y:105
static int is_global_name_punct(const char c)
Definition: ripper.c:12754
#define NEW_UNDEF(i)
#define ID_JUNK
#define is_attrset_id(id)
Definition: ripper.c:114
#define set_yylval_name(x)
Definition: ripper.c:11614
void rb_gc_mark(VALUE)
Definition: gc.c:2600
#define IDSET_ATTRSET_FOR_INTERN
Definition: ripper.c:16682
#define ID_GLOBAL
#define tokline
Definition: ripper.c:384
static char * parser_newtok(struct parser_params *parser)
Definition: ripper.c:12204
static int vtable_included(const struct vtable *tbl, ID id)
Definition: ripper.c:254
#define block_dup_check(n1, n2)
Definition: ripper.c:441
#define tokadd(c)
Definition: ripper.c:11597
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:2202
static NODE * arg_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15352
static void local_push_gen(struct parser_params *, int)
Definition: ripper.c:16101
RUBY_EXTERN int ffs(int)
Definition: ffs.c:6
#define NEW_WHEN(c, t, e)
top_stmt escape_Qundef($1)
#define ISASCII(c)
Definition: ruby.h:1629
#define tokenbuf
Definition: ripper.c:381
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:499
static char msg[50]
Definition: strerror.c:8
ID rb_intern(const char *name)
Definition: ripper.c:16976
#define COND_POP()
Definition: ripper.c:172
#define heredoc_identifier()
Definition: ripper.c:11606
#define RSTRING_LEN(str)
static void parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13174
#define INT2FIX(i)
#define YYSYNTAX_ERROR
#define Qfalse
#define new_const_op_assign(lhs, op, rhs)
Definition: ripper.c:500
Definition: ripper.y:135
VALUE value
Definition: ripper.y:246
static void parser_tokadd(struct parser_params *parser, int c)
Definition: ripper.c:12232
#define FIX2LONG(x)
#define k__END__
Definition: eventids2.c:9
static void parser_mark(void *ptr)
Definition: ripper.c:17334
static void yy_reduce_print(YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
Definition: ripper.c:4596
#define ISALNUM(c)
Definition: ruby.h:1635
#define YYDPRINTF(Args)
Definition: ripper.c:4475
rb_atomic_t cnt[RUBY_NSIG]
Definition: signal.c:432
#define T_STRING
#define lex_goto_eol(parser)
Definition: ripper.c:12125
#define MBCLEN_CHARFOUND_P(ret)
static double one(void)
Definition: isinf.c:52
unsigned char OnigUChar
Definition: ripper.y:114
#define NODE_ARGSCAT
#define local_id(id)
Definition: ripper.c:561
#define NODE_COLON2
NODE * rb_parser_append_print(VALUE vparser, NODE *node)
Definition: ripper.c:16460
#define nd_set_line(n, l)
#define xmalloc
#define xrealloc
static void ripper_init_eventids1(void)
Definition: eventids1.c:134
int argc
Definition: ruby.c:130
#define NIL_P(v)
yytype_int16 yyss_alloc
Definition: ripper.c:1081
static void vtable_add(struct vtable *tbl, ID id)
Definition: ripper.c:239
char ary[RSTRING_EMBED_LEN_MAX+1]
Definition: ripper.y:853
#define YYFINAL
Definition: ripper.c:1135
#define dvar_curr(id)
Definition: ripper.c:576
static NODE * parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: ripper.c:12011
#define flush_string_content(enc)
Definition: ripper.c:12729
#define NEW_ARGS_AUX(r, b)
#define TypedData_Wrap_Struct(klass, data_type, sval)
#define RSTRING_NOEMBED
static VALUE coverage(const char *f, int n)
Definition: ripper.c:11866
#define tokadd_string(f, t, p, n, e)
Definition: ripper.c:11602
static NODE * new_yield_gen(struct parser_params *, NODE *)
Definition: ripper.c:15880
#define ripper_flush(p)
Definition: ripper.c:11634
static VALUE lex_get_str(struct parser_params *parser, VALUE s)
Definition: ripper.c:11968
static int rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_atttset)
Definition: ripper.c:16685
#define ISUPPER(c)
Definition: ruby.h:1633
#define RUBY_FUNC_EXPORTED
Definition: defines.h:184
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:345
VALUE rb_enc_associate_index(VALUE obj, int idx)
Definition: encoding.c:748
int rb_parse_in_main(void)
Definition: compile.c:5882
static int parser_nextc(struct parser_params *parser)
Definition: ripper.c:12131
int err
Definition: win32.c:87
#define dyna_pop(node)
Definition: ripper.c:568
arg
Definition: ripper.y:1316
#define YYACCEPT
Definition: ripper.c:4383
const char * parser_lex_pend
Definition: ripper.c:317
#define NEW_DEFINED(e)
static ID formal_argument_gen(struct parser_params *, ID)
Definition: ripper.c:13079
static void void_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15471
#define DBL2NUM(dbl)
#define YYEOF
Definition: ripper.c:4381
#define ALLOCA_N(type, n)
static NODE * dsym_node_gen(struct parser_params *, NODE *)
Definition: ripper.c:15974
#define ENC_CODERANGE_UNKNOWN
void rb_gc_mark_symbols(void)
Definition: ripper.c:16626
long cnt
Definition: ripper.y:262
ID token
Definition: ripper.c:16533
static ID intern_str(VALUE str)
Definition: ripper.c:16856
#define YY_REDUCE_PRINT(Rule)
Definition: ripper.c:4618
Definition: ripper.y:116
NODE * rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
Definition: ripper.c:16492
Definition: util.c:791
NODE * rb_compile_cstr(const char *f, const char *s, int len, int line)
Definition: ripper.c:12044
token_info * parser_token_info
Definition: ripper.c:342
Definition: ripper.y:123
static void magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13165
int column
Definition: ripper.c:273
static char * yystpcpy(char *yydest, const char *yysrc)
Definition: ripper.c:4691
#define IS_lex_state(ls)
Definition: ripper.c:158
#define END(no)
Definition: re.c:26
#define EOF
Definition: vsnprintf.c:207
VALUE rb_str_buf_cat(VALUE, const char *, long)
Definition: string.c:1948
#define ruby_verbose
void * rb_parser_malloc(struct parser_params *parser, size_t size)
Definition: ripper.c:17509
VALUE rb_str_dup(VALUE)
Definition: string.c:946
#define peek_n(c, n)
Definition: ripper.c:12128
#define DEF_EXPR(n)
Definition: ripper.c:141
#define tHEREDOC_END
Definition: eventids2.c:8
#define STR_NEW(p, n)
Definition: ripper.c:358
#define rb_long2int(n)
YYSTYPE yyvs_alloc
Definition: ripper.c:1082
#define ID_CLASS
static int parser_peek_variable_name(struct parser_params *parser)
Definition: ripper.c:12761
#define tokcopy(n)
Definition: ripper.c:12255
#define STR_FUNC_SYMBOL
Definition: ripper.c:12094
#define NEW_LASGN(v, val)
node_type
Definition: ripper.y:23
static VALUE yycompile0(VALUE arg)
Definition: ripper.c:11889
#define mixed_escape(beg, enc1, enc2)
VALUE rb_obj_as_string(VALUE)
Definition: string.c:895
#define set_yylval_num(x)
Definition: ripper.c:11612
static ID register_symid_str(ID, VALUE)
Definition: ripper.c:16805
#define NODE_MEMO
#define NEW_OPT_ARG(i, v)
VALUE rb_hash_aset(VALUE, VALUE, VALUE)
#define STR_FUNC_QWORDS
Definition: ripper.c:12093
#define dyna_push()
Definition: ripper.c:566
#define command_start
Definition: ripper.c:392
string_type
Definition: ripper.c:12097
int rb_dvar_defined(ID id)
Definition: compile.c:5832
static void dispose_string(VALUE str)
Definition: ripper.c:12541
VALUE rb_str_resize(VALUE, long)
Definition: string.c:1854
#define is_notop_id(id)
Definition: ripper.c:110
static NODE * aryset_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15250
int parser_in_single
Definition: ripper.c:302
#define RTEST(v)
lex_state_bits
Definition: ripper.c:125
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
Definition: st.c:1000
#define NEW_SCLASS(r, b)
#define RUBY_DTRACE_PARSE_END_ENABLED()
Definition: probes.h:71
static ID shadowing_lvar_gen(struct parser_params *, ID)
Definition: ripper.c:15212
#define CMDARG_LEXPOP()
Definition: ripper.c:178
ID rest_arg
Definition: ripper.y:514
#define local_push(top)
Definition: ripper.c:553
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:16670
#define new_attr_op_assign(lhs, type, attr, op, rhs)
Definition: ripper.c:498
#define NODE_NIL
VALUE rb_thread_current(void)
Definition: thread.c:2352
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
Definition: ripper.c:4565
#define paren_nest
Definition: ripper.c:373
#define NODE_ATTRASGN
#define token_info_pop(token)
Definition: ripper.c:737
static void dyna_pop_gen(struct parser_params *, const struct vtable *)
Definition: ripper.c:16238
VALUE rb_range_new(VALUE, VALUE, int)
Definition: range.c:67
static NODE * new_evstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:14979
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1270
#define NODE_COLON3
#define StringValue(v)
#define NODE_DEFINED
#define rb_enc_mbcput(c, buf, enc)
#define IS_lex_state_for(x, ls)
Definition: ripper.c:157
#define tokadd_mbchar(c)
Definition: ripper.c:12561
static void reg_fragment_setenc_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16297
#define rb_node_newnode(type, a1, a2, a3)
Definition: ripper.c:420
#define YYMAXDEPTH
Definition: ripper.c:4650
static void set_file_encoding(struct parser_params *parser, const char *str, const char *send)
Definition: ripper.c:13336
#define NEW_DOT2(b, e)
#define NODE_MASGN
#define T_REGEXP
#define const
Definition: strftime.c:102
int rb_is_attrset_name(VALUE name)
Definition: ripper.c:17251
#define NEW_DASGN(v, val)
#define NEW_VALIAS(n, o)
#define RE_OPTION_ONCE
Definition: ripper.c:581
int rb_enc_symname_p(const char *name, rb_encoding *enc)
Definition: ripper.c:16676
#define NEW_POSTARG(i, v)
#define CONST_ID(var, str)
#define tokidx
Definition: ripper.c:382
#define NEW_ERRINFO()
#define malloc
Definition: ripper.c:98
static const struct magic_comment magic_comments[]
Definition: ripper.c:13201
void Init_sym(void)
Definition: ripper.c:16607
const char * name
Definition: ripper.c:16534
#define NODE_CONST
static int parser_parse_string(struct parser_params *, NODE *)
Definition: ripper.c:12797
#define nd_term(node)
Definition: ripper.c:596
#define STR_FUNC_EXPAND
Definition: ripper.c:12091
#define rb_warningS(fmt, a)
Definition: ripper.c:698
static NODE * new_args_tail_gen(struct parser_params *, NODE *, ID, ID)
Definition: ripper.c:15949
static int dvar_defined_gen(struct parser_params *, ID, int)
Definition: ripper.c:16258
int rb_is_local_id(ID id)
Definition: ripper.c:17129
rb_magic_comment_length_t length
Definition: ripper.c:13198
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
#define NEW_SUPER(a)
static int local_id_gen(struct parser_params *, ID)
Definition: ripper.c:16181
#define YYSIZE_T
Definition: ripper.c:961
#define NEW_COLON2(c, i)
#define ESCAPE_META
Definition: ripper.c:12331
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:948
VALUE rb_io_gets(VALUE)
Definition: io.c:3110
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Definition: array.c:545
static void Init_id(void)
Definition: ripper.y:15
long parser_lex_gets_ptr
Definition: ripper.c:321
#define no_digits()
#define NODE_GVAR
#define NODE_CDECL
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1183
#define NEW_HASH(a)
static void rb_backref_error_gen(struct parser_params *, NODE *)
Definition: ripper.c:15314
Definition: ripper.y:94
unsigned char yytype_uint8
Definition: ripper.c:927
#define RARRAY_PTR(a)
union RNode::@82 u3
static const yytype_int16 yyrhs[]
Definition: ripper.c:1266
static void arg_ambiguous_gen(struct parser_params *parser)
Definition: ripper.c:13068
#define heredoc_restore(n)
Definition: ripper.c:11607
static void parser_prepare(struct parser_params *parser)
Definition: ripper.c:13379
static NODE * cond_gen(struct parser_params *, NODE *)
Definition: ripper.c:15833
#define RB_GC_GUARD(v)
#define lex_lastline
Definition: ripper.c:386
#define NODE_LIT
int type
Definition: tcltklib.c:111
int id[2]
Definition: lex.c:33
static int options(unsigned char *cp)
Definition: nkf.c:6355
#define NEW_UNTIL(c, b, n)
static const char *const yytname[]
Definition: ripper.c:1531
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: ripper.c:1101
#define T_FIXNUM
#define NEW_MATCH3(r, n2)
VALUE rb_str_buf_new(long)
Definition: string.c:777
stack_type parser_cond_stack
Definition: ripper.c:297
static VALUE result
Definition: nkf.c:40
NODE * post_init
Definition: ripper.y:507
static void ripper_init_eventids2(void)
Definition: eventids2.c:64
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:2109
int rb_is_junk_id(ID id)
Definition: ripper.c:17135
static void dyna_pop_1(struct parser_params *parser)
Definition: ripper.c:16220
static int parser_read_escape(struct parser_params *parser, int flags, rb_encoding **encp)
Definition: ripper.c:12334
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:12855
Definition: ripper.y:101
ID rb_id_attrset(ID id)
Definition: ripper.c:15277
static int value_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15409
Definition: ripper.y:72
mlhs_head tSTAR
Definition: ripper.y:1542
int post_args_num
Definition: ripper.y:510
#define lex_pend
Definition: ripper.c:390
int rb_is_global_id(ID id)
Definition: ripper.c:17111
static int reg_fragment_check_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16336
static const yytype_int16 yycheck[]
Definition: ripper.c:3153
#define NEW_SELF()
#define YYUSE(e)
Definition: ripper.c:981
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1122
#define lvtbl
Definition: ripper.c:396
#define lex_strterm
Definition: ripper.c:368
#define rb_enc_ispunct(c, enc)
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
Definition: eval.c:804
VALUE flags
Definition: ripper.y:700
#define free
Definition: ripper.c:101
#define NEW_RESBODY(a, ex, n)
static NODE * new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
Definition: ripper.c:16030
#define NEW_RETURN(s)
#define NODE_ARGSPUSH
#define NODE_BACK_REF
#define set_yylval_str(x)
Definition: ripper.c:11611
#define NODE_MATCH
#define cond_stack
Definition: ripper.c:370
short int yytype_int8
Definition: ripper.c:936
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2304
VALUE flags
Definition: ripper.y:241
expr ripper_intern("and")
static int is_static_content(NODE *node)
Definition: ripper.c:15645
const char * token
Definition: ripper.c:271
RUBY_EXTERN VALUE rb_cString
Definition: ripper.y:1456
#define NEW_COLON3(i)
#define RUBY_DTRACE_PARSE_BEGIN_ENABLED()
Definition: probes.h:67
#define NEW_CASE(h, b)
static const yytype_int16 yypgoto[]
Definition: ripper.c:2006
static int arg_var_gen(struct parser_params *, ID)
Definition: ripper.c:16164
#define is_local_id(id)
Definition: ripper.c:111
#define NODE_DASGN
int parser_in_defined
Definition: ripper.c:307
static int literal_concat0(struct parser_params *, VALUE, VALUE)
Definition: ripper.c:14872
static ID * local_tbl_gen(struct parser_params *)
Definition: ripper.c:16149
#define NEW_BACK_REF(n)
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1264
int parser_class_nest
Definition: ripper.c:299
#define T_BIGNUM
#define brace_nest
Definition: ripper.c:375
#define reg_named_capture_assign(regexp, match)
Definition: ripper.c:517
#define MEMCPY(p1, p2, type, n)
Definition: ripper.y:122
static int parser_yyerror(struct parser_params *, const char *)
Definition: ripper.c:11784
#define NEW_IF(c, t, e)
#define HEAPCNT(n, size)
Definition: ripper.c:17503
nd_iter
Definition: parse.y:1392
#define NEW_GASGN(v, val)
static void warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15702
#define NEW_ARGSPUSH(a, b)
int rb_is_const_name(VALUE name)
Definition: ripper.c:17227
#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:12425
static void yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: ripper.c:4538
static NODE * attrset_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:15306
int rb_is_local_name(VALUE name)
Definition: ripper.c:17257
const struct vtable * vars
Definition: parse.h:168
static VALUE reg_compile_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16431
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:1964
#define NEW_XSTR(s)
#define ESCAPE_CONTROL
Definition: ripper.c:12330
Definition: ripper.y:111
#define ENC_CODERANGE_7BIT
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:772
#define NEW_WHILE(c, b, n)
#define NEW_DEFS(r, i, a, d)
#define parser_isascii()
Definition: ripper.c:11707
void rb_gc_mark_parser(void)
Definition: ripper.c:16455
static const yytype_uint8 yytranslate[]
Definition: ripper.c:1156
int nonspc
Definition: ripper.c:274
int size
Definition: encoding.c:52
#define ADD2HEAP(n, c, p)
Definition: ripper.c:17505
#define tokspace(n)
Definition: ripper.c:11596
#define f
#define in_def
Definition: ripper.c:377
static int is_private_local_id(ID name)
Definition: ripper.c:15199
#define SYMBOL_P(x)
#define is_const_id(id)
Definition: ripper.c:115
static void no_blockarg(struct parser_params *parser, NODE *node)
Definition: ripper.c:15855
static void local_pop_gen(struct parser_params *)
Definition: ripper.c:16118
#define NODE_FLIP3
void rb_parser_free(struct parser_params *parser, void *ptr)
Definition: ripper.c:17549
#define Qundef
int parser_tokidx
Definition: ripper.c:309
#define read_escape(flags, e)
Definition: ripper.c:11599
#define NODE_DVAR
#define tok_hex(numlen)
Definition: ripper.c:11598
static NODE * literal_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14889
#define new_evstr(n)
Definition: ripper.c:457
#define parser_warn(node, mesg)
Definition: ripper.c:14771
#define rb_compile_error
Definition: ripper.c:719
ID rb_intern_str(VALUE str)
Definition: ripper.c:16982
Definition: ripper.y:92
Definition: ripper.y:127
VALUE coverage
Definition: ripper.c:338
command_call
Definition: ripper.y:1308
VALUE rb_external_str_new_with_enc(const char *ptr, long len, rb_encoding *)
Definition: string.c:569
void rb_set_errinfo(VALUE err)
Definition: eval.c:1436
#define tokfix()
Definition: ripper.c:12198
return tOP_ASGN
Definition: ripper.y:7647
#define rb_enc_isspace(c, enc)
#define internal_id()
Definition: ripper.c:563
NODE * parser_lex_strterm
Definition: ripper.c:295
const char * name
Definition: ripper.c:13196
top_stmt bodystmt
Definition: ripper.y:925
#define COND_LEXPOP()
Definition: ripper.c:173
#define lex_p
Definition: ripper.c:389
#define NEW_IVAR(v)
top_stmts dispatch0(stmts_new)
#define tSP
Definition: eventids2.c:6
#define NEW_ATTRASGN(r, m, a)
#define NODE_ZARRAY
static int token_info_get_column(struct parser_params *parser, const char *token)
Definition: ripper.c:11711
static const struct st_hash_type symhash
Definition: ripper.c:16574
#define node_assign(node1, node2)
Definition: ripper.c:494
static void void_stmts_gen(struct parser_params *, NODE *)
Definition: ripper.c:15560
#define void_expr(node)
Definition: ripper.c:435
static int local_var_gen(struct parser_params *, ID)
Definition: ripper.c:16171
#define pushback(c)
Definition: ripper.c:11594
#define void_expr0(node)
Definition: ripper.c:434
#define NEW_BEGIN(b)
NODE * pre_init
Definition: ripper.y:506
#define NEW_FCALL(m, a)
#define NODE_CVAR
#define lex_pbeg
Definition: ripper.c:388
#define regx_options()
Definition: ripper.c:11601
#define NEW_SCOPE(a, b)
#define numberof(array)
Definition: ripper.c:92
static int token_info_has_nonspaces(struct parser_params *parser, const char *token)
Definition: ripper.c:11725
st_index_t rb_str_hash(VALUE)
Definition: string.c:2245
#define NEW_OP_ASGN2(r, i, o, val)
#define YYSTACK_ALLOC_MAXIMUM
Definition: ripper.c:1046
#define NODE_BREAK
#define TOK_INTERN(mb)
Definition: ripper.c:363
static const rb_data_type_t parser_data_type
Definition: ripper.c:12008
rb_magic_comment_setter_t func
Definition: ripper.c:13197
int parser_lpar_beg
Definition: ripper.c:301
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:185
st_table * sym_id
Definition: ripper.c:16565
RUBY_EXTERN VALUE rb_cObject
Definition: ripper.y:1426
#define ALLOC_N(type, n)
uint8_t key[16]
Definition: random.c:1370
#define LONG2FIX(i)
#define NODE_FL_NEWLINE
#define RBASIC(obj)
struct local_vars * prev
Definition: ripper.c:192
static const yytype_uint16 yydefact[]
Definition: ripper.c:1757
#define NEW_VCALL(m)
static NODE * new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: ripper.c:16001
#define parser_encoding_name()
Definition: ripper.c:11701
#define tokadd_escape(e)
Definition: ripper.c:11600
struct vtable * vars
Definition: ripper.c:190
static const yytype_int16 yypact[]
Definition: ripper.c:1895
static VALUE lex_io_gets(struct parser_params *parser, VALUE io)
Definition: ripper.c:12058
#define new_yield(node)
Definition: ripper.c:477
#define lvar_defined(id)
Definition: ripper.c:579
#define INT2NUM(x)
#define NODE_DSTR
struct rb_encoding_entry * list
Definition: encoding.c:50
#define lpar_beg
Definition: ripper.c:374
keyword_BEGIN
Definition: ripper.y:1029
#define YYTRANSLATE(YYX)
Definition: ripper.c:1152
#define NEW_RETRY()
void * rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
Definition: ripper.c:17519
#define STRNCASECMP(s1, s2, n)
rb_encoding * rb_filesystem_encoding(void)
Definition: encoding.c:1248
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:772
v
Definition: win32ole.c:798
#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:15236
#define ruby_coverage
Definition: ripper.c:407
int linenum
Definition: ripper.c:272
#define NEW_CVAR(v)
static NODE * negate_lit(NODE *)
Definition: ripper.c:15888
#define tEMBDOC
Definition: eventids2.c:4
Definition: ripper.y:121
#define NODE_BEGIN
#define id_type(id)
Definition: ripper.c:118
static void fixup_nodes(NODE **)
Definition: ripper.c:15708
#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:13209
#define BEG(no)
Definition: re.c:25
#define NEW_OP_ASGN1(p, id, a)
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:13242
int parser_tokline
Definition: ripper.c:311
Definition: ripper.y:79
#define IS_LABEL_POSSIBLE()
Definition: ripper.c:13407
VALUE rb_ary_new2(long capa)
Definition: array.c:417
static const char id_type_names[][9]
Definition: ripper.c:15265
VALUE rb_str_new(const char *, long)
Definition: string.c:425
union RNode::@80 u1
const char * parser_lex_pbeg
Definition: ripper.c:315
int rb_is_class_id(ID id)
Definition: ripper.c:17105
#define DVARS_TOPSCOPE
Definition: ripper.c:197
#define YYCASE_(N, S)
#define rb_safe_level()
Definition: tcltklib.c:94
VALUE rb_parser_new(void)
Definition: ripper.c:17434
#define NODE_CVASGN
Definition: ripper.c:181
static void parser_set_encode(struct parser_params *parser, const char *name)
Definition: ripper.c:13117
#define call_uni_op(recv, id)
Definition: ripper.c:465
#define NEW_CDECL(v, val, path)
static int literal_node(NODE *node)
Definition: ripper.c:15755
#define set_yylval_node(x)
Definition: ripper.c:11616
#define YYSTACK_BYTES(N)
Definition: ripper.c:1090
#define IS_BEG()
Definition: ripper.c:13405
const char * parser_lex_p
Definition: ripper.c:316
#define nd_lit
static int parser_tok_hex(struct parser_params *parser, size_t *numlen)
Definition: ripper.c:12242
#define RE_OPTION_ENCODING_NONE(o)
Definition: ripper.c:585
#define rb_enc_asciicompat(enc)
lex_state_e
Definition: ripper.c:140
#define NUM2INT(x)
#define dvar_defined_get(id)
Definition: ripper.c:574
#define nd_head
int rb_is_instance_name(VALUE name)
Definition: ripper.c:17245
int parser_ruby_sourceline
Definition: ripper.c:328
const char * rb_id2name(ID id)
Definition: ripper.c:17058
#define NODE_CALL
#define ruby_eval_tree_begin
Definition: ripper.c:405
#define rb_errinfo()
Definition: tcltklib.c:89
#define formal_argument(id)
Definition: ripper.c:546
#define rb_enc_isupper(c, enc)
#define PRIsVALUE
static int nodeline(NODE *node)
Definition: ripper.c:14735
#define dispatch_heredoc_end()
Definition: ripper.c:12961
YYSTYPE * parser_yylval
Definition: ripper.c:292
#define ruby_eval_tree
Definition: ripper.c:404
#define toklast()
Definition: ripper.c:12201
#define lex_gets
Definition: ripper.c:395
#define toklen()
Definition: ripper.c:12200
static const yytype_uint8 yyr2[]
Definition: ripper.c:1688
#define xcalloc
#define cmdarg_stack
Definition: ripper.c:371
#define in_single
Definition: ripper.c:376
#define YY_STACK_PRINT(Bottom, Top)
Definition: ripper.c:4579
#define NEW_LIT(l)
#define rb_enc_isascii(c, enc)
int rb_str_hash_cmp(VALUE, VALUE)
Definition: string.c:2255
#define YYFPRINTF
Definition: ripper.c:4472
int is_ripper
Definition: ripper.c:289
static NODE * cond0(struct parser_params *, NODE *)
Definition: ripper.c:15776
rb_encoding * rb_ascii8bit_encoding(void)
Definition: encoding.c:1153
int rb_is_junk_name(VALUE name)
Definition: ripper.c:17273
#define NODE_IVAR
#define peek(c)
Definition: ripper.c:12127
return tSYMBEG
Definition: ripper.y:7621
#define RREGEXP(obj)
int rb_enc_find_index(const char *name)
Definition: encoding.c:635
static NODE * splat_array(NODE *)
Definition: ripper.c:15370
static struct vtable * vtable_alloc(struct vtable *prev)
Definition: ripper.c:215
VALUE eofp
Definition: ripper.c:293
RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e-0x20+31)/32]
Definition: ripper.c:12732
long len
Definition: ripper.y:846
NODE * heap
Definition: ripper.c:290
#define RSTRING_GETMEM(str, ptrvar, lenvar)
ID rb_intern3(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:16834
#define attrset(node, id)
Definition: ripper.c:489
#define NODE_DOT2
#define COND_P()
Definition: ripper.c:174
#define ID_SCOPE_MASK
#define mixed_error(enc1, enc2)
static ID register_symid(ID, const char *, long, rb_encoding *)
Definition: ripper.c:16798
#define NODE_DREGX
#define NODE_IASGN
#define NEW_DEFN(i, a, d, p)
#define NODE_RETURN
#define snprintf
static const struct vtable * dyna_push_gen(struct parser_params *)
Definition: ripper.c:16209
ID first_post_arg
Definition: ripper.y:512
void * rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
Definition: ripper.c:17529
#define NEW_REDO()
#define shadowing_lvar(name)
Definition: ripper.c:548
st_table * st_init_numtable_with_size(st_index_t)
Definition: st.c:278
VALUE rb_cstr_to_inum(const char *str, int base, int badcheck)
Definition: bignum.c:579
#define NODE_ARRAY
#define NODE_SPLAT
#define get_value(val)
Definition: ripper.c:520
#define reg_fragment_check(str, options)
Definition: ripper.c:515
int rb_parse_in_eval(void)
Definition: compile.c:5876
#define ENCODING_SET(obj, i)
#define compile_for_eval
Definition: ripper.c:378
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:80
#define tCOMMENT
Definition: eventids2.c:2
#define NEW_ZSUPER()
#define set_yylval_id(x)
Definition: ripper.c:11613
ID rb_intern2(const char *name, long len)
Definition: ripper.c:16969
NODE * rb_compile_file(const char *f, VALUE file, int start)
Definition: ripper.c:12064
static int is_special_global_name(const char *m, const char *e, rb_encoding *enc)
Definition: ripper.c:16644
#define is_class_id(id)
Definition: ripper.c:116
#define LVAR_USED
Definition: ripper.c:15209
static NODE * assignable_gen(struct parser_params *, ID, NODE *)
Definition: ripper.c:15120
#define nd_line(n)
VALUE rb_parser_get_yydebug(VALUE self)
Definition: ripper.c:17478
VALUE(* parser_lex_gets)(struct parser_params *, VALUE)
Definition: ripper.c:322
#define NULL
Definition: _sdbm.c:103
#define rb_enc_isalpha(c, enc)
#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:12051
static int rb_str_symname_type(VALUE name, unsigned int allowed_atttset)
Definition: ripper.c:16788
VALUE rb_check_string_type(VALUE)
Definition: string.c:1509
#define REALLOC_N(var, type, n)
#define NODE_SCOPE
#define yypact_value_is_default(yystate)
Definition: ripper.c:3147
int rb_enc_str_coderange(VALUE)
Definition: string.c:327
#define ISXDIGIT(c)
Definition: ruby.h:1638
#define rb_warn0(fmt)
Definition: ripper.c:693
int rb_local_defined(ID id)
Definition: compile.c:5857
st_index_t num_entries
Definition: ripper.y:93
NODE * parser_eval_tree_begin
Definition: ripper.c:335
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
#define new_bv(id)
Definition: ripper.c:550
static void warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15696
#define NODE_IASGN2
#define ULONG2NUM(x)
#define NODE_SELF
#define block_append(h, t)
Definition: ripper.c:444
#define SYM2ID(x)
#define ID_CONST
VALUE rb_eArgError
Definition: error.c:512
static void vtable_free(struct vtable *tbl)
Definition: ripper.c:227
#define NEW_ARRAY(a)
Definition: ripper.y:93
void rb_str_free(VALUE)
Definition: string.c:830
#define RTYPEDDATA_TYPE(v)
unsigned long ruby_scan_oct(const char *, size_t, size_t *)
Definition: util.c:28
#define NODE_VALUES
#define heredoc_end
Definition: ripper.c:391
#define ID_ATTRSET
struct vtable * args
Definition: ripper.c:189
#define tokaddmbc(c, enc)
Definition: ripper.c:11604
Definition: ripper.y:136
char ** argv
Definition: ruby.c:131
#define tEMBDOC_END
Definition: eventids2.c:5
char * ptr
Definition: ripper.y:847
static void ripper_init_eventids2_table(VALUE self)
Definition: eventids2table.c:2
#define nd_value
#define NEW_YIELD(a)
#define ISSPACE(c)
Definition: ruby.h:1632
#define STR_NEW2(p)
Definition: ripper.c:360
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:2075
VALUE rb_inspect(VALUE)
Definition: object.c:402
#define YYINITDEPTH
Definition: ripper.c:4639
static int sym_check_asciionly(VALUE str)
Definition: ripper.c:16814
rb_encoding * rb_enc_from_index(int index)
Definition: encoding.c:548
#define aryset(node1, node2)
Definition: ripper.c:487
static NODE * reg_named_capture_assign_gen(struct parser_params *parser, VALUE regexp, NODE *match)
Definition: ripper.c:16399
#define IS_AFTER_OPERATOR()
Definition: ripper.c:13409
#define NEW_BLOCK_PASS(b)
NODE * opt_args
Definition: ripper.y:520
static NODE * new_args_gen(struct parser_params *, NODE *, NODE *, ID, NODE *, NODE *)
Definition: ripper.c:15927
int rb_is_global_name(VALUE name)
Definition: ripper.c:17239
static int parser_tokadd_mbchar(struct parser_params *parser, int c)
Definition: ripper.c:12548