Ruby  2.1.10p492(2016-04-01revision54464)
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 YYMALLOC(size) rb_parser_malloc(parser, (size))
93 #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
94 #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
95 #define YYFREE(ptr) rb_parser_free(parser, (ptr))
96 #define malloc YYMALLOC
97 #define realloc YYREALLOC
98 #define calloc YYCALLOC
99 #define free YYFREE
100 
101 #ifndef RIPPER
102 static ID register_symid(ID, const char *, long, rb_encoding *);
103 static ID register_symid_str(ID, VALUE);
104 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
105 #include "id.c"
106 #endif
107 
108 #define is_notop_id(id) ((id)>tLAST_OP_ID)
109 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
110 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
111 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
112 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
113 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
114 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
115 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
116 #define id_type(id) (is_notop_id(id) ? (int)((id)&ID_SCOPE_MASK) : -1)
117 
118 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
119  (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
120  ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
121  ((id)&ID_SCOPE_MASK) == ID_CLASS))
122 
124  EXPR_BEG_bit, /* ignore newline, +/- is a sign. */
125  EXPR_END_bit, /* newline significant, +/- is an operator. */
126  EXPR_ENDARG_bit, /* ditto, and unbound braces. */
127  EXPR_ENDFN_bit, /* ditto, and unbound braces. */
128  EXPR_ARG_bit, /* newline significant, +/- is an operator. */
129  EXPR_CMDARG_bit, /* newline significant, +/- is an operator. */
130  EXPR_MID_bit, /* newline significant, +/- is an operator. */
131  EXPR_FNAME_bit, /* ignore newline, no reserved words. */
132  EXPR_DOT_bit, /* right after `.' or `::', no reserved words. */
133  EXPR_CLASS_bit, /* immediate after `class', no here document. */
134  EXPR_VALUE_bit, /* alike EXPR_BEG but label is disallowed. */
135  EXPR_LABELARG_bit, /* ignore significant, +/- is a sign. */
137 };
138 /* examine combinations */
140 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
142  DEF_EXPR(END),
143  DEF_EXPR(ENDARG),
144  DEF_EXPR(ENDFN),
145  DEF_EXPR(ARG),
146  DEF_EXPR(CMDARG),
147  DEF_EXPR(MID),
148  DEF_EXPR(FNAME),
149  DEF_EXPR(DOT),
150  DEF_EXPR(CLASS),
151  DEF_EXPR(VALUE),
152  DEF_EXPR(LABELARG),
153  EXPR_BEG_ANY = (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS | EXPR_LABELARG),
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;
316  const char *parser_lex_pbeg;
317  const char *parser_lex_p;
318  const char *parser_lex_pend;
328  char *parser_ruby_sourcefile; /* current source file */
329  int parser_ruby_sourceline; /* current line no. */
332 
334 
336 
337 #ifndef RIPPER
338  /* Ruby core only */
343  int nerr;
344 
347 #else
348  /* Ripper only */
349  const char *tokp;
350  VALUE delayed;
351  int delayed_line;
352  int delayed_col;
353 
354  VALUE value;
355  VALUE result;
356  VALUE parsing_thread;
357  int toplevel_p;
358 #endif
359 };
360 
361 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)
362 #define STR_NEW0() rb_enc_str_new(0,0,current_enc)
363 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)
364 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)
365 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
366 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc)
367 
368 static int parser_yyerror(struct parser_params*, const char*);
369 #define yyerror(msg) parser_yyerror(parser, (msg))
370 
371 #define lex_strterm (parser->parser_lex_strterm)
372 #define lex_state (parser->parser_lex_state)
373 #define cond_stack (parser->parser_cond_stack)
374 #define cmdarg_stack (parser->parser_cmdarg_stack)
375 #define class_nest (parser->parser_class_nest)
376 #define paren_nest (parser->parser_paren_nest)
377 #define lpar_beg (parser->parser_lpar_beg)
378 #define brace_nest (parser->parser_brace_nest)
379 #define in_single (parser->parser_in_single)
380 #define in_def (parser->parser_in_def)
381 #define compile_for_eval (parser->parser_compile_for_eval)
382 #define cur_mid (parser->parser_cur_mid)
383 #define in_defined (parser->parser_in_defined)
384 #define tokenbuf (parser->parser_tokenbuf)
385 #define tokidx (parser->parser_tokidx)
386 #define toksiz (parser->parser_toksiz)
387 #define tokline (parser->parser_tokline)
388 #define lex_input (parser->parser_lex_input)
389 #define lex_lastline (parser->parser_lex_lastline)
390 #define lex_nextline (parser->parser_lex_nextline)
391 #define lex_pbeg (parser->parser_lex_pbeg)
392 #define lex_p (parser->parser_lex_p)
393 #define lex_pend (parser->parser_lex_pend)
394 #define heredoc_end (parser->parser_heredoc_end)
395 #define command_start (parser->parser_command_start)
396 #define deferred_nodes (parser->parser_deferred_nodes)
397 #define lex_gets_ptr (parser->parser_lex_gets_ptr)
398 #define lex_gets (parser->parser_lex_gets)
399 #define lvtbl (parser->parser_lvtbl)
400 #define ruby__end__seen (parser->parser_ruby__end__seen)
401 #define ruby_sourceline (parser->parser_ruby_sourceline)
402 #define ruby_sourcefile (parser->parser_ruby_sourcefile)
403 #define ruby_sourcefile_string (parser->parser_ruby_sourcefile_string)
404 #define current_enc (parser->enc)
405 #define yydebug (parser->parser_yydebug)
406 #ifdef RIPPER
407 #else
408 #define ruby_eval_tree (parser->parser_eval_tree)
409 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin)
410 #define ruby_debug_lines (parser->debug_lines)
411 #define ruby_coverage (parser->coverage)
412 #endif
413 
414 #if YYPURE
415 static int yylex(void*, void*);
416 #else
417 static int yylex(void*);
418 #endif
419 
420 #ifndef RIPPER
421 #define yyparse ruby_yyparse
422 
423 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
424 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
425 
426 static NODE *cond_gen(struct parser_params*,NODE*);
427 #define cond(node) cond_gen(parser, (node))
428 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
429 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
430 
431 static NODE *newline_node(NODE*);
432 static void fixpos(NODE*,NODE*);
433 
434 static int value_expr_gen(struct parser_params*,NODE*);
435 static void void_expr_gen(struct parser_params*,NODE*);
436 static NODE *remove_begin(NODE*);
437 static NODE *remove_begin_all(NODE*);
438 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
439 #define void_expr0(node) void_expr_gen(parser, (node))
440 #define void_expr(node) void_expr0((node) = remove_begin(node))
441 static void void_stmts_gen(struct parser_params*,NODE*);
442 #define void_stmts(node) void_stmts_gen(parser, (node))
443 static void reduce_nodes_gen(struct parser_params*,NODE**);
444 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
445 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
446 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
447 
448 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
449 #define block_append(h,t) block_append_gen(parser,(h),(t))
450 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
451 #define list_append(l,i) list_append_gen(parser,(l),(i))
452 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
453 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
454 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
455 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
456 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
457 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
458 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
459 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
460 static int literal_concat0(struct parser_params *, VALUE, VALUE);
461 static NODE *new_evstr_gen(struct parser_params*,NODE*);
462 #define new_evstr(n) new_evstr_gen(parser,(n))
463 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
464 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
465 static NODE *splat_array(NODE*);
466 
467 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
468 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
469 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
470 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
471 
472 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
473 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
474 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);
475 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
476 
477 static NODE *negate_lit(NODE*);
478 static NODE *ret_args_gen(struct parser_params*,NODE*);
479 #define ret_args(node) ret_args_gen(parser, (node))
480 static NODE *arg_blk_pass(NODE*,NODE*);
481 static NODE *new_yield_gen(struct parser_params*,NODE*);
482 #define new_yield(node) new_yield_gen(parser, (node))
483 static NODE *dsym_node_gen(struct parser_params*,NODE*);
484 #define dsym_node(node) dsym_node_gen(parser, (node))
485 
486 static NODE *gettable_gen(struct parser_params*,ID);
487 #define gettable(id) gettable_gen(parser,(id))
488 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
489 #define assignable(id,node) assignable_gen(parser, (id), (node))
490 
491 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
492 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
493 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
494 #define attrset(node,id) attrset_gen(parser, (node), (id))
495 
496 static void rb_backref_error_gen(struct parser_params*,NODE*);
497 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
498 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
499 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
500 
501 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
502 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
503 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
504 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
505 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
506 
507 #define new_defined(expr) NEW_DEFINED(remove_begin_all(expr))
508 
509 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
510 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
511 
512 static ID *local_tbl_gen(struct parser_params*);
513 #define local_tbl() local_tbl_gen(parser)
514 
515 static void fixup_nodes(NODE **);
516 
517 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
518 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
519 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
520 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
521 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
522 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
524 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
525 
526 #define get_id(id) (id)
527 #define get_value(val) (val)
528 #else
529 #define value_expr(node) ((void)(node))
530 #define remove_begin(node) (node)
531 #define rb_dvar_defined(id) 0
532 #define rb_local_defined(id) 0
533 static ID ripper_get_id(VALUE);
534 #define get_id(id) ripper_get_id(id)
535 static VALUE ripper_get_value(VALUE);
536 #define get_value(val) ripper_get_value(val)
537 static VALUE assignable_gen(struct parser_params*,VALUE);
538 #define assignable(lhs,node) assignable_gen(parser, (lhs))
539 static int id_is_var_gen(struct parser_params *parser, ID id);
540 #define id_is_var(id) id_is_var_gen(parser, (id))
541 
542 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2))
543 
544 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
546 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
547 
548 #endif /* !RIPPER */
549 
550 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
551 
552 static ID formal_argument_gen(struct parser_params*, ID);
553 #define formal_argument(id) formal_argument_gen(parser, (id))
554 static ID shadowing_lvar_gen(struct parser_params*,ID);
555 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
556 static void new_bv_gen(struct parser_params*,ID);
557 #define new_bv(id) new_bv_gen(parser, (id))
558 
559 static void local_push_gen(struct parser_params*,int);
560 #define local_push(top) local_push_gen(parser,(top))
561 static void local_pop_gen(struct parser_params*);
562 #define local_pop() local_pop_gen(parser)
563 static int local_var_gen(struct parser_params*, ID);
564 #define local_var(id) local_var_gen(parser, (id))
565 static int arg_var_gen(struct parser_params*, ID);
566 #define arg_var(id) arg_var_gen(parser, (id))
567 static int local_id_gen(struct parser_params*, ID);
568 #define local_id(id) local_id_gen(parser, (id))
569 static ID internal_id_gen(struct parser_params*);
570 #define internal_id() internal_id_gen(parser)
571 
572 static const struct vtable *dyna_push_gen(struct parser_params *);
573 #define dyna_push() dyna_push_gen(parser)
574 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
575 #define dyna_pop(node) dyna_pop_gen(parser, (node))
576 static int dyna_in_block_gen(struct parser_params*);
577 #define dyna_in_block() dyna_in_block_gen(parser)
578 #define dyna_var(id) local_var(id)
579 static int dvar_defined_gen(struct parser_params*,ID,int);
580 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
581 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
582 static int dvar_curr_gen(struct parser_params*,ID);
583 #define dvar_curr(id) dvar_curr_gen(parser, (id))
584 
585 static int lvar_defined_gen(struct parser_params*, ID);
586 #define lvar_defined(id) lvar_defined_gen(parser, (id))
587 
588 #define RE_OPTION_ONCE (1<<16)
589 #define RE_OPTION_ENCODING_SHIFT 8
590 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
591 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
592 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
593 #define RE_OPTION_MASK 0xff
594 #define RE_OPTION_ARG_ENCODING_NONE 32
595 
596 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
597 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
598 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
599 #define nd_func u1.id
600 #if SIZEOF_SHORT == 2
601 #define nd_term(node) ((signed short)(node)->u2.id)
602 #else
603 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
604 #endif
605 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
606 #define nd_nest u3.cnt
607 
608 /****** Ripper *******/
609 
610 #ifdef RIPPER
611 #define RIPPER_VERSION "0.1.0"
612 
613 #include "eventids1.c"
614 #include "eventids2.c"
615 
616 static VALUE ripper_dispatch0(struct parser_params*,ID);
617 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
618 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
619 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
620 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
621 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
622 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
623 
624 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
625 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
626 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
627 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
628 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
629 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
630 #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))
631 
632 #define yyparse ripper_yyparse
633 
634 #define ripper_intern(s) ID2SYM(rb_intern(s))
635 static VALUE ripper_id2sym(ID);
636 #ifdef __GNUC__
637 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
638  ID2SYM(id) : ripper_id2sym(id))
639 #endif
640 
641 #define arg_new() dispatch0(args_new)
642 #define arg_add(l,a) dispatch2(args_add, (l), (a))
643 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
644 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
645 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
646 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
647 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
648 
649 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
650 #define mrhs_new() dispatch0(mrhs_new)
651 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
652 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
653 
654 #define mlhs_new() dispatch0(mlhs_new)
655 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
656 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
657 
658 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
659  dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
660 
661 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
662 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
663 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
664 
665 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
666 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
667 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
668 
669 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
670 
671 static inline VALUE
673 {
674  NODE *t = (NODE *)tail;
675  VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
676  return params_new(f, o, r, p, k, kr, escape_Qundef(b));
677 }
678 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
679 
680 static inline VALUE
681 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
682 {
683  return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);
684 }
685 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
686 
687 #define new_defined(expr) dispatch1(defined, (expr))
688 
689 #define FIXME 0
690 
691 #endif /* RIPPER */
692 
693 #ifndef RIPPER
694 # define Qnone 0
695 # define ifndef_ripper(x) (x)
696 #else
697 # define Qnone Qnil
698 # define ifndef_ripper(x)
699 #endif
700 
701 #ifndef RIPPER
702 # define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
703 # define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
704 # define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
705 # define rb_warn4S(file,line,fmt,a) rb_compile_warn((file), (line), (fmt), (a))
706 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
707 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
708 #else
709 # define rb_warn0(fmt) ripper_warn0(parser, (fmt))
710 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))
711 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))
712 # define rb_warn4S(file,line,fmt,a) ripper_warnS(parser, (fmt), (a))
713 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
714 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
715 static void ripper_warn0(struct parser_params*, const char*);
716 static void ripper_warnI(struct parser_params*, const char*, int);
717 static void ripper_warnS(struct parser_params*, const char*, const char*);
718 static void ripper_warning0(struct parser_params*, const char*);
719 static void ripper_warningS(struct parser_params*, const char*, const char*);
720 #endif
721 
722 #ifdef RIPPER
723 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
724 # define rb_compile_error ripper_compile_error
725 # define compile_error ripper_compile_error
726 # define PARSER_ARG parser,
727 #else
728 # define rb_compile_error rb_compile_error_with_enc
729 # define compile_error parser->nerr++,rb_compile_error_with_enc
730 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
731 #endif
732 
733 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
734  for instance). This is too low for Ruby to parse some files, such as
735  date/format.rb, therefore bump the value up to at least Bison's default. */
736 #ifdef OLD_YACC
737 #ifndef YYMAXDEPTH
738 #define YYMAXDEPTH 10000
739 #endif
740 #endif
741 
742 #ifndef RIPPER
743 static void token_info_push(struct parser_params*, const char *token);
744 static void token_info_pop(struct parser_params*, const char *token);
745 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
746 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
747 #else
748 #define token_info_push(token) /* nothing */
749 #define token_info_pop(token) /* nothing */
750 #endif
751 
752 
753 /* Line 268 of yacc.c */
754 #line 755 "parse.c"
755 
756 /* Enabling traces. */
757 #ifndef YYDEBUG
758 # define YYDEBUG 1
759 #endif
760 
761 /* Enabling verbose error messages. */
762 #ifdef YYERROR_VERBOSE
763 # undef YYERROR_VERBOSE
764 # define YYERROR_VERBOSE 1
765 #else
766 # define YYERROR_VERBOSE 0
767 #endif
768 
769 /* Enabling the token table. */
770 #ifndef YYTOKEN_TABLE
771 # define YYTOKEN_TABLE 0
772 #endif
773 
774 
775 /* Tokens. */
776 #ifndef YYTOKENTYPE
777 # define YYTOKENTYPE
778  /* Put the tokens into the symbol table, so that GDB and other debuggers
779  know about them. */
780  enum yytokentype {
781  END_OF_INPUT = 0,
782  keyword_class = 258,
783  keyword_module = 259,
784  keyword_def = 260,
785  keyword_undef = 261,
786  keyword_begin = 262,
787  keyword_rescue = 263,
788  keyword_ensure = 264,
789  keyword_end = 265,
790  keyword_if = 266,
791  keyword_unless = 267,
792  keyword_then = 268,
793  keyword_elsif = 269,
794  keyword_else = 270,
795  keyword_case = 271,
796  keyword_when = 272,
797  keyword_while = 273,
798  keyword_until = 274,
799  keyword_for = 275,
800  keyword_break = 276,
801  keyword_next = 277,
802  keyword_redo = 278,
803  keyword_retry = 279,
804  keyword_in = 280,
805  keyword_do = 281,
806  keyword_do_cond = 282,
807  keyword_do_block = 283,
808  keyword_do_LAMBDA = 284,
809  keyword_return = 285,
810  keyword_yield = 286,
811  keyword_super = 287,
812  keyword_self = 288,
813  keyword_nil = 289,
814  keyword_true = 290,
815  keyword_false = 291,
816  keyword_and = 292,
817  keyword_or = 293,
818  keyword_not = 294,
819  modifier_if = 295,
820  modifier_unless = 296,
821  modifier_while = 297,
822  modifier_until = 298,
823  modifier_rescue = 299,
824  keyword_alias = 300,
825  keyword_defined = 301,
826  keyword_BEGIN = 302,
827  keyword_END = 303,
828  keyword__LINE__ = 304,
829  keyword__FILE__ = 305,
830  keyword__ENCODING__ = 306,
831  tIDENTIFIER = 307,
832  tFID = 308,
833  tGVAR = 309,
834  tIVAR = 310,
835  tCONSTANT = 311,
836  tCVAR = 312,
837  tLABEL = 313,
838  tINTEGER = 314,
839  tFLOAT = 315,
840  tRATIONAL = 316,
841  tIMAGINARY = 317,
842  tSTRING_CONTENT = 318,
843  tCHAR = 319,
844  tNTH_REF = 320,
845  tBACK_REF = 321,
846  tREGEXP_END = 322,
847  tUPLUS = 130,
848  tUMINUS = 131,
849  tPOW = 132,
850  tCMP = 134,
851  tEQ = 139,
852  tEQQ = 140,
853  tNEQ = 141,
854  tGEQ = 138,
855  tLEQ = 137,
856  tANDOP = 323,
857  tOROP = 324,
858  tMATCH = 142,
859  tNMATCH = 143,
860  tDOT2 = 128,
861  tDOT3 = 129,
862  tAREF = 144,
863  tASET = 145,
864  tLSHFT = 135,
865  tRSHFT = 136,
866  tCOLON2 = 325,
867  tCOLON3 = 326,
868  tOP_ASGN = 327,
869  tASSOC = 328,
870  tLPAREN = 329,
871  tLPAREN_ARG = 330,
872  tRPAREN = 331,
873  tLBRACK = 332,
874  tLBRACE = 333,
875  tLBRACE_ARG = 334,
876  tSTAR = 335,
877  tDSTAR = 336,
878  tAMPER = 337,
879  tLAMBDA = 338,
880  tSYMBEG = 339,
881  tSTRING_BEG = 340,
882  tXSTRING_BEG = 341,
883  tREGEXP_BEG = 342,
884  tWORDS_BEG = 343,
885  tQWORDS_BEG = 344,
886  tSYMBOLS_BEG = 345,
887  tQSYMBOLS_BEG = 346,
888  tSTRING_DBEG = 347,
889  tSTRING_DEND = 348,
890  tSTRING_DVAR = 349,
891  tSTRING_END = 350,
892  tLAMBEG = 351,
893  tLOWEST = 352,
894  tUMINUS_NUM = 353,
895  tLAST_TOKEN = 354
896  };
897 #endif
898 
899 
900 
901 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
902 typedef union YYSTYPE
903 {
904 
905 /* Line 293 of yacc.c */
906 #line 699 "ripper.y"
907 
908  VALUE val;
909  NODE *node;
910  ID id;
911  int num;
912  const struct vtable *vars;
913 
914 
915 
916 /* Line 293 of yacc.c */
917 #line 918 "parse.c"
918 } YYSTYPE;
919 # define YYSTYPE_IS_TRIVIAL 1
920 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
921 # define YYSTYPE_IS_DECLARED 1
922 #endif
923 
924 
925 /* Copy the second part of user declarations. */
926 
927 
928 /* Line 343 of yacc.c */
929 #line 930 "parse.c"
930 
931 #ifdef short
932 # undef short
933 #endif
934 
935 #ifdef YYTYPE_UINT8
936 typedef YYTYPE_UINT8 yytype_uint8;
937 #else
938 typedef unsigned char yytype_uint8;
939 #endif
940 
941 #ifdef YYTYPE_INT8
942 typedef YYTYPE_INT8 yytype_int8;
943 #elif (defined __STDC__ || defined __C99__FUNC__ \
944  || defined __cplusplus || defined _MSC_VER)
945 typedef signed char yytype_int8;
946 #else
947 typedef short int yytype_int8;
948 #endif
949 
950 #ifdef YYTYPE_UINT16
951 typedef YYTYPE_UINT16 yytype_uint16;
952 #else
953 typedef unsigned short int yytype_uint16;
954 #endif
955 
956 #ifdef YYTYPE_INT16
957 typedef YYTYPE_INT16 yytype_int16;
958 #else
959 typedef short int yytype_int16;
960 #endif
961 
962 #ifndef YYSIZE_T
963 # ifdef __SIZE_TYPE__
964 # define YYSIZE_T __SIZE_TYPE__
965 # elif defined size_t
966 # define YYSIZE_T size_t
967 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
968  || defined __cplusplus || defined _MSC_VER)
969 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
970 # define YYSIZE_T size_t
971 # else
972 # define YYSIZE_T unsigned int
973 # endif
974 #endif
975 
976 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
977 
978 #ifndef YY_
979 # if defined YYENABLE_NLS && YYENABLE_NLS
980 # if ENABLE_NLS
981 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
982 # define YY_(msgid) dgettext ("bison-runtime", msgid)
983 # endif
984 # endif
985 # ifndef YY_
986 # define YY_(msgid) msgid
987 # endif
988 #endif
989 
990 /* Suppress unused-variable warnings by "using" E. */
991 #if ! defined lint || defined __GNUC__
992 # define YYUSE(e) ((void) (e))
993 #else
994 # define YYUSE(e) /* empty */
995 #endif
996 
997 /* Identity function, used to suppress warnings about constant conditions. */
998 #ifndef lint
999 # define YYID(n) (n)
1000 #else
1001 #if (defined __STDC__ || defined __C99__FUNC__ \
1002  || defined __cplusplus || defined _MSC_VER)
1003 static int
1004 YYID (int yyi)
1005 #else
1006 static int
1007 YYID (yyi)
1008  int yyi;
1009 #endif
1010 {
1011  return yyi;
1012 }
1013 #endif
1014 
1015 #if ! defined yyoverflow || YYERROR_VERBOSE
1016 
1017 /* The parser invokes alloca or malloc; define the necessary symbols. */
1018 
1019 # ifdef YYSTACK_USE_ALLOCA
1020 # if YYSTACK_USE_ALLOCA
1021 # ifdef __GNUC__
1022 # define YYSTACK_ALLOC __builtin_alloca
1023 # elif defined __BUILTIN_VA_ARG_INCR
1024 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1025 # elif defined _AIX
1026 # define YYSTACK_ALLOC __alloca
1027 # elif defined _MSC_VER
1028 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1029 # define alloca _alloca
1030 # else
1031 # define YYSTACK_ALLOC alloca
1032 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1033  || defined __cplusplus || defined _MSC_VER)
1034 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1035 # ifndef EXIT_SUCCESS
1036 # define EXIT_SUCCESS 0
1037 # endif
1038 # endif
1039 # endif
1040 # endif
1041 # endif
1042 
1043 # ifdef YYSTACK_ALLOC
1044  /* Pacify GCC's `empty if-body' warning. */
1045 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1046 # ifndef YYSTACK_ALLOC_MAXIMUM
1047  /* The OS might guarantee only one guard page at the bottom of the stack,
1048  and a page size can be as small as 4096 bytes. So we cannot safely
1049  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1050  to allow for a few compiler-allocated temporary stack slots. */
1051 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1052 # endif
1053 # else
1054 # define YYSTACK_ALLOC YYMALLOC
1055 # define YYSTACK_FREE YYFREE
1056 # ifndef YYSTACK_ALLOC_MAXIMUM
1057 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1058 # endif
1059 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
1060  && ! ((defined YYMALLOC || defined malloc) \
1061  && (defined YYFREE || defined free)))
1062 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1063 # ifndef EXIT_SUCCESS
1064 # define EXIT_SUCCESS 0
1065 # endif
1066 # endif
1067 # ifndef YYMALLOC
1068 # define YYMALLOC malloc
1069 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1070  || defined __cplusplus || defined _MSC_VER)
1071 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1072 # endif
1073 # endif
1074 # ifndef YYFREE
1075 # define YYFREE free
1076 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1077  || defined __cplusplus || defined _MSC_VER)
1078 void free (void *); /* INFRINGES ON USER NAME SPACE */
1079 # endif
1080 # endif
1081 # endif
1082 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1083 
1084 
1085 #if (! defined yyoverflow \
1086  && (! defined __cplusplus \
1087  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1088 
1089 /* A type that is properly aligned for any stack member. */
1090 union yyalloc
1091 {
1092  yytype_int16 yyss_alloc;
1094 };
1095 
1096 /* The size of the maximum gap between one aligned stack and the next. */
1097 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1098 
1099 /* The size of an array large to enough to hold all stacks, each with
1100  N elements. */
1101 # define YYSTACK_BYTES(N) \
1102  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1103  + YYSTACK_GAP_MAXIMUM)
1104 
1105 # define YYCOPY_NEEDED 1
1106 
1107 /* Relocate STACK from its old location to the new one. The
1108  local variables YYSIZE and YYSTACKSIZE give the old and new number of
1109  elements in the stack, and YYPTR gives the new location of the
1110  stack. Advance YYPTR to a properly aligned location for the next
1111  stack. */
1112 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1113  do \
1114  { \
1115  YYSIZE_T yynewbytes; \
1116  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1117  Stack = &yyptr->Stack_alloc; \
1118  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1119  yyptr += yynewbytes / sizeof (*yyptr); \
1120  } \
1121  while (YYID (0))
1122 
1123 #endif
1124 
1125 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1126 /* Copy COUNT objects from FROM to TO. The source and destination do
1127  not overlap. */
1128 # ifndef YYCOPY
1129 # if defined __GNUC__ && 1 < __GNUC__
1130 # define YYCOPY(To, From, Count) \
1131  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1132 # else
1133 # define YYCOPY(To, From, Count) \
1134  do \
1135  { \
1136  YYSIZE_T yyi; \
1137  for (yyi = 0; yyi < (Count); yyi++) \
1138  (To)[yyi] = (From)[yyi]; \
1139  } \
1140  while (YYID (0))
1141 # endif
1142 # endif
1143 #endif /* !YYCOPY_NEEDED */
1144 
1145 /* YYFINAL -- State number of the termination state. */
1146 #define YYFINAL 3
1147 /* YYLAST -- Last index in YYTABLE. */
1148 #define YYLAST 11083
1149 
1150 /* YYNTOKENS -- Number of terminals. */
1151 #define YYNTOKENS 144
1152 /* YYNNTS -- Number of nonterminals. */
1153 #define YYNNTS 204
1154 /* YYNRULES -- Number of rules. */
1155 #define YYNRULES 627
1156 /* YYNRULES -- Number of states. */
1157 #define YYNSTATES 1060
1158 
1159 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1160 #define YYUNDEFTOK 2
1161 #define YYMAXUTOK 354
1162 
1163 #define YYTRANSLATE(YYX) \
1164  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1165 
1166 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1167 static const yytype_uint8 yytranslate[] =
1168 {
1169  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1170  143, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1171  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1172  2, 2, 142, 129, 2, 2, 2, 127, 122, 2,
1173  138, 139, 125, 123, 136, 124, 135, 126, 2, 2,
1174  2, 2, 2, 2, 2, 2, 2, 2, 117, 141,
1175  119, 115, 118, 116, 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, 134, 2, 140, 121, 2, 137, 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, 132, 120, 133, 130, 2, 81, 82,
1182  68, 69, 70, 2, 71, 85, 86, 76, 75, 72,
1183  73, 74, 79, 80, 83, 84, 2, 2, 2, 2,
1184  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1185  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1186  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1187  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1188  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1189  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1190  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1191  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1192  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1193  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1194  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1195  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1196  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1197  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1198  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1199  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1200  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1201  65, 66, 67, 77, 78, 87, 88, 89, 90, 91,
1202  92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
1203  102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
1204  112, 113, 114, 128, 131
1205 };
1206 
1207 #if YYDEBUG
1208 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1209  YYRHS. */
1210 static const yytype_uint16 yyprhs[] =
1211 {
1212  0, 0, 3, 4, 7, 10, 12, 14, 18, 21,
1213  23, 24, 30, 35, 38, 40, 42, 46, 49, 51,
1214  52, 58, 59, 64, 68, 72, 76, 79, 83, 87,
1215  91, 95, 99, 104, 106, 110, 114, 121, 127, 133,
1216  139, 145, 149, 153, 157, 159, 163, 167, 169, 173,
1217  177, 181, 184, 186, 188, 190, 192, 194, 199, 200,
1218  206, 208, 211, 215, 220, 226, 231, 237, 240, 243,
1219  246, 249, 252, 254, 258, 260, 264, 266, 269, 273,
1220  279, 282, 287, 290, 295, 297, 301, 303, 307, 310,
1221  314, 316, 320, 322, 324, 329, 333, 337, 341, 345,
1222  348, 350, 352, 354, 359, 363, 367, 371, 375, 378,
1223  380, 382, 384, 387, 389, 393, 395, 397, 399, 401,
1224  403, 405, 407, 409, 411, 413, 414, 419, 421, 423,
1225  425, 427, 429, 431, 433, 435, 437, 439, 441, 443,
1226  445, 447, 449, 451, 453, 455, 457, 459, 461, 463,
1227  465, 467, 469, 471, 473, 475, 477, 479, 481, 483,
1228  485, 487, 489, 491, 493, 495, 497, 499, 501, 503,
1229  505, 507, 509, 511, 513, 515, 517, 519, 521, 523,
1230  525, 527, 529, 531, 533, 535, 537, 539, 541, 543,
1231  545, 547, 549, 551, 553, 555, 557, 559, 561, 565,
1232  571, 575, 581, 588, 594, 600, 606, 612, 617, 621,
1233  625, 629, 633, 637, 641, 645, 649, 653, 658, 661,
1234  664, 668, 672, 676, 680, 684, 688, 692, 696, 700,
1235  704, 708, 712, 716, 719, 722, 726, 730, 734, 738,
1236  739, 744, 751, 753, 755, 757, 760, 765, 768, 772,
1237  774, 776, 778, 780, 783, 788, 791, 793, 796, 799,
1238  804, 806, 807, 810, 813, 816, 818, 820, 823, 827,
1239  832, 834, 836, 840, 845, 848, 850, 852, 854, 856,
1240  858, 860, 862, 864, 866, 868, 870, 871, 876, 877,
1241  881, 882, 883, 889, 893, 897, 900, 904, 908, 910,
1242  915, 919, 921, 922, 929, 934, 938, 941, 943, 946,
1243  949, 956, 963, 964, 965, 973, 974, 975, 983, 989,
1244  994, 995, 996, 1006, 1007, 1014, 1015, 1016, 1025, 1026,
1245  1032, 1033, 1040, 1041, 1042, 1052, 1054, 1056, 1058, 1060,
1246  1062, 1064, 1066, 1068, 1070, 1072, 1074, 1076, 1078, 1080,
1247  1082, 1084, 1086, 1088, 1091, 1093, 1095, 1097, 1103, 1105,
1248  1108, 1110, 1112, 1114, 1118, 1120, 1124, 1126, 1131, 1138,
1249  1142, 1148, 1151, 1156, 1158, 1162, 1167, 1170, 1173, 1175,
1250  1178, 1179, 1186, 1195, 1200, 1207, 1212, 1215, 1222, 1225,
1251  1230, 1237, 1240, 1245, 1248, 1253, 1255, 1257, 1259, 1263,
1252  1265, 1270, 1272, 1277, 1279, 1283, 1285, 1287, 1288, 1289,
1253  1290, 1291, 1298, 1303, 1305, 1309, 1313, 1314, 1320, 1323,
1254  1328, 1334, 1340, 1343, 1344, 1350, 1351, 1357, 1361, 1362,
1255  1367, 1368, 1373, 1376, 1378, 1383, 1384, 1390, 1391, 1397,
1256  1403, 1405, 1407, 1414, 1416, 1418, 1420, 1422, 1425, 1427,
1257  1430, 1432, 1434, 1436, 1438, 1440, 1442, 1444, 1447, 1451,
1258  1455, 1459, 1463, 1467, 1468, 1472, 1474, 1477, 1481, 1485,
1259  1486, 1490, 1494, 1498, 1502, 1506, 1507, 1511, 1512, 1516,
1260  1517, 1520, 1521, 1524, 1525, 1528, 1530, 1531, 1535, 1536,
1261  1537, 1538, 1545, 1547, 1549, 1551, 1553, 1556, 1558, 1560,
1262  1562, 1564, 1568, 1570, 1573, 1575, 1577, 1579, 1581, 1583,
1263  1585, 1587, 1589, 1591, 1593, 1595, 1597, 1599, 1601, 1603,
1264  1605, 1607, 1609, 1611, 1613, 1615, 1617, 1619, 1620, 1625,
1265  1628, 1632, 1633, 1637, 1642, 1645, 1648, 1650, 1653, 1654,
1266  1661, 1670, 1675, 1682, 1687, 1694, 1697, 1702, 1709, 1712,
1267  1717, 1720, 1725, 1727, 1728, 1730, 1732, 1734, 1736, 1738,
1268  1740, 1742, 1746, 1748, 1752, 1754, 1757, 1759, 1762, 1764,
1269  1766, 1770, 1772, 1776, 1778, 1780, 1783, 1785, 1789, 1793,
1270  1795, 1799, 1801, 1805, 1807, 1809, 1812, 1814, 1816, 1818,
1271  1821, 1824, 1826, 1828, 1829, 1834, 1836, 1839, 1841, 1845,
1272  1849, 1852, 1855, 1857, 1859, 1861, 1863, 1865, 1867, 1869,
1273  1871, 1873, 1875, 1877, 1879, 1880, 1882, 1883, 1885, 1888,
1274  1891, 1892, 1894, 1896, 1898, 1900, 1902, 1905
1275 };
1276 
1277 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1278 static const yytype_int16 yyrhs[] =
1279 {
1280  145, 0, -1, -1, 146, 147, -1, 148, 340, -1,
1281  347, -1, 149, -1, 148, 346, 149, -1, 1, 149,
1282  -1, 156, -1, -1, 47, 150, 132, 147, 133, -1,
1283  152, 266, 233, 269, -1, 153, 340, -1, 347, -1,
1284  154, -1, 153, 346, 154, -1, 1, 156, -1, 156,
1285  -1, -1, 47, 155, 132, 147, 133, -1, -1, 45,
1286  179, 157, 179, -1, 45, 54, 54, -1, 45, 54,
1287  66, -1, 45, 54, 65, -1, 6, 180, -1, 156,
1288  40, 160, -1, 156, 41, 160, -1, 156, 42, 160,
1289  -1, 156, 43, 160, -1, 156, 44, 156, -1, 48,
1290  132, 152, 133, -1, 158, -1, 167, 115, 161, -1,
1291  302, 89, 161, -1, 218, 134, 190, 343, 89, 161,
1292  -1, 218, 135, 52, 89, 161, -1, 218, 135, 56,
1293  89, 161, -1, 218, 87, 56, 89, 161, -1, 218,
1294  87, 52, 89, 161, -1, 303, 89, 161, -1, 174,
1295  115, 198, -1, 167, 115, 197, -1, 159, -1, 174,
1296  115, 161, -1, 174, 115, 158, -1, 161, -1, 159,
1297  37, 159, -1, 159, 38, 159, -1, 39, 341, 159,
1298  -1, 129, 161, -1, 184, -1, 159, -1, 166, -1,
1299  162, -1, 255, -1, 255, 339, 337, 192, -1, -1,
1300  96, 164, 241, 152, 133, -1, 336, -1, 165, 192,
1301  -1, 165, 192, 163, -1, 218, 135, 337, 192, -1,
1302  218, 135, 337, 192, 163, -1, 218, 87, 337, 192,
1303  -1, 218, 87, 337, 192, 163, -1, 32, 192, -1,
1304  31, 192, -1, 30, 191, -1, 21, 191, -1, 22,
1305  191, -1, 169, -1, 91, 168, 342, -1, 169, -1,
1306  91, 168, 342, -1, 171, -1, 171, 170, -1, 171,
1307  97, 173, -1, 171, 97, 173, 136, 172, -1, 171,
1308  97, -1, 171, 97, 136, 172, -1, 97, 173, -1,
1309  97, 173, 136, 172, -1, 97, -1, 97, 136, 172,
1310  -1, 173, -1, 91, 168, 342, -1, 170, 136, -1,
1311  171, 170, 136, -1, 170, -1, 172, 136, 170, -1,
1312  299, -1, 300, -1, 218, 134, 190, 343, -1, 218,
1313  135, 52, -1, 218, 87, 52, -1, 218, 135, 56,
1314  -1, 218, 87, 56, -1, 88, 56, -1, 303, -1,
1315  299, -1, 300, -1, 218, 134, 190, 343, -1, 218,
1316  135, 52, -1, 218, 87, 52, -1, 218, 135, 56,
1317  -1, 218, 87, 56, -1, 88, 56, -1, 303, -1,
1318  52, -1, 56, -1, 88, 175, -1, 175, -1, 218,
1319  87, 175, -1, 52, -1, 56, -1, 53, -1, 182,
1320  -1, 183, -1, 177, -1, 294, -1, 178, -1, 296,
1321  -1, 179, -1, -1, 180, 136, 181, 179, -1, 120,
1322  -1, 121, -1, 122, -1, 71, -1, 72, -1, 73,
1323  -1, 79, -1, 80, -1, 118, -1, 75, -1, 119,
1324  -1, 76, -1, 74, -1, 85, -1, 86, -1, 123,
1325  -1, 124, -1, 125, -1, 97, -1, 126, -1, 127,
1326  -1, 70, -1, 98, -1, 129, -1, 130, -1, 68,
1327  -1, 69, -1, 83, -1, 84, -1, 137, -1, 49,
1328  -1, 50, -1, 51, -1, 47, -1, 48, -1, 45,
1329  -1, 37, -1, 7, -1, 21, -1, 16, -1, 3,
1330  -1, 5, -1, 46, -1, 26, -1, 15, -1, 14,
1331  -1, 10, -1, 9, -1, 36, -1, 20, -1, 25,
1332  -1, 4, -1, 22, -1, 34, -1, 39, -1, 38,
1333  -1, 23, -1, 8, -1, 24, -1, 30, -1, 33,
1334  -1, 32, -1, 13, -1, 35, -1, 6, -1, 17,
1335  -1, 31, -1, 11, -1, 12, -1, 18, -1, 19,
1336  -1, 174, 115, 184, -1, 174, 115, 184, 44, 184,
1337  -1, 302, 89, 184, -1, 302, 89, 184, 44, 184,
1338  -1, 218, 134, 190, 343, 89, 184, -1, 218, 135,
1339  52, 89, 184, -1, 218, 135, 56, 89, 184, -1,
1340  218, 87, 52, 89, 184, -1, 218, 87, 56, 89,
1341  184, -1, 88, 56, 89, 184, -1, 303, 89, 184,
1342  -1, 184, 81, 184, -1, 184, 82, 184, -1, 184,
1343  123, 184, -1, 184, 124, 184, -1, 184, 125, 184,
1344  -1, 184, 126, 184, -1, 184, 127, 184, -1, 184,
1345  70, 184, -1, 128, 298, 70, 184, -1, 68, 184,
1346  -1, 69, 184, -1, 184, 120, 184, -1, 184, 121,
1347  184, -1, 184, 122, 184, -1, 184, 71, 184, -1,
1348  184, 118, 184, -1, 184, 75, 184, -1, 184, 119,
1349  184, -1, 184, 76, 184, -1, 184, 72, 184, -1,
1350  184, 73, 184, -1, 184, 74, 184, -1, 184, 79,
1351  184, -1, 184, 80, 184, -1, 129, 184, -1, 130,
1352  184, -1, 184, 85, 184, -1, 184, 86, 184, -1,
1353  184, 77, 184, -1, 184, 78, 184, -1, -1, 46,
1354  341, 185, 184, -1, 184, 116, 184, 341, 117, 184,
1355  -1, 199, -1, 184, -1, 347, -1, 196, 344, -1,
1356  196, 136, 334, 344, -1, 334, 344, -1, 138, 190,
1357  342, -1, 347, -1, 188, -1, 347, -1, 191, -1,
1358  196, 136, -1, 196, 136, 334, 136, -1, 334, 136,
1359  -1, 166, -1, 196, 195, -1, 334, 195, -1, 196,
1360  136, 334, 195, -1, 194, -1, -1, 193, 191, -1,
1361  99, 186, -1, 136, 194, -1, 347, -1, 186, -1,
1362  97, 186, -1, 196, 136, 186, -1, 196, 136, 97,
1363  186, -1, 198, -1, 186, -1, 196, 136, 186, -1,
1364  196, 136, 97, 186, -1, 97, 186, -1, 270, -1,
1365  271, -1, 274, -1, 275, -1, 276, -1, 281, -1,
1366  279, -1, 282, -1, 301, -1, 303, -1, 53, -1,
1367  -1, 219, 200, 151, 229, -1, -1, 92, 201, 342,
1368  -1, -1, -1, 92, 202, 159, 203, 342, -1, 91,
1369  152, 139, -1, 218, 87, 56, -1, 88, 56, -1,
1370  94, 187, 140, -1, 95, 333, 133, -1, 30, -1,
1371  31, 138, 191, 342, -1, 31, 138, 342, -1, 31,
1372  -1, -1, 46, 341, 138, 204, 159, 342, -1, 39,
1373  138, 159, 342, -1, 39, 138, 342, -1, 165, 261,
1374  -1, 256, -1, 256, 261, -1, 100, 246, -1, 220,
1375  160, 230, 152, 232, 229, -1, 221, 160, 230, 152,
1376  233, 229, -1, -1, -1, 222, 205, 160, 231, 206,
1377  152, 229, -1, -1, -1, 223, 207, 160, 231, 208,
1378  152, 229, -1, 224, 160, 340, 264, 229, -1, 224,
1379  340, 264, 229, -1, -1, -1, 225, 234, 25, 209,
1380  160, 231, 210, 152, 229, -1, -1, 226, 176, 304,
1381  211, 151, 229, -1, -1, -1, 226, 85, 159, 212,
1382  345, 213, 151, 229, -1, -1, 227, 176, 214, 151,
1383  229, -1, -1, 228, 177, 215, 306, 151, 229, -1,
1384  -1, -1, 228, 331, 339, 216, 177, 217, 306, 151,
1385  229, -1, 21, -1, 22, -1, 23, -1, 24, -1,
1386  199, -1, 7, -1, 11, -1, 12, -1, 18, -1,
1387  19, -1, 16, -1, 20, -1, 3, -1, 4, -1,
1388  5, -1, 10, -1, 345, -1, 13, -1, 345, 13,
1389  -1, 345, -1, 27, -1, 233, -1, 14, 160, 230,
1390  152, 232, -1, 347, -1, 15, 152, -1, 174, -1,
1391  167, -1, 312, -1, 91, 237, 342, -1, 235, -1,
1392  236, 136, 235, -1, 236, -1, 236, 136, 97, 312,
1393  -1, 236, 136, 97, 312, 136, 236, -1, 236, 136,
1394  97, -1, 236, 136, 97, 136, 236, -1, 97, 312,
1395  -1, 97, 312, 136, 236, -1, 97, -1, 97, 136,
1396  236, -1, 318, 136, 321, 330, -1, 318, 330, -1,
1397  321, 330, -1, 329, -1, 136, 238, -1, -1, 314,
1398  136, 324, 136, 327, 239, -1, 314, 136, 324, 136,
1399  327, 136, 314, 239, -1, 314, 136, 324, 239, -1,
1400  314, 136, 324, 136, 314, 239, -1, 314, 136, 327,
1401  239, -1, 314, 136, -1, 314, 136, 327, 136, 314,
1402  239, -1, 314, 239, -1, 324, 136, 327, 239, -1,
1403  324, 136, 327, 136, 314, 239, -1, 324, 239, -1,
1404  324, 136, 314, 239, -1, 327, 239, -1, 327, 136,
1405  314, 239, -1, 238, -1, 347, -1, 242, -1, 120,
1406  243, 120, -1, 78, -1, 120, 240, 243, 120, -1,
1407  341, -1, 341, 141, 244, 341, -1, 245, -1, 244,
1408  136, 245, -1, 52, -1, 311, -1, -1, -1, -1,
1409  -1, 247, 248, 251, 249, 250, 252, -1, 138, 310,
1410  243, 139, -1, 310, -1, 113, 152, 133, -1, 29,
1411  152, 10, -1, -1, 28, 254, 241, 152, 10, -1,
1412  166, 253, -1, 255, 339, 337, 189, -1, 255, 339,
1413  337, 189, 261, -1, 255, 339, 337, 192, 253, -1,
1414  165, 188, -1, -1, 218, 135, 337, 257, 189, -1,
1415  -1, 218, 87, 337, 258, 188, -1, 218, 87, 338,
1416  -1, -1, 218, 135, 259, 188, -1, -1, 218, 87,
1417  260, 188, -1, 32, 188, -1, 32, -1, 218, 134,
1418  190, 343, -1, -1, 132, 262, 241, 152, 133, -1,
1419  -1, 26, 263, 241, 152, 10, -1, 17, 196, 230,
1420  152, 265, -1, 233, -1, 264, -1, 8, 267, 268,
1421  230, 152, 266, -1, 347, -1, 186, -1, 198, -1,
1422  347, -1, 90, 174, -1, 347, -1, 9, 152, -1,
1423  347, -1, 297, -1, 294, -1, 296, -1, 272, -1,
1424  64, -1, 273, -1, 272, 273, -1, 102, 285, 112,
1425  -1, 103, 286, 112, -1, 104, 287, 67, -1, 105,
1426  142, 112, -1, 105, 277, 112, -1, -1, 277, 278,
1427  142, -1, 288, -1, 278, 288, -1, 107, 142, 112,
1428  -1, 107, 280, 112, -1, -1, 280, 278, 142, -1,
1429  106, 142, 112, -1, 106, 283, 112, -1, 108, 142,
1430  112, -1, 108, 284, 112, -1, -1, 283, 63, 142,
1431  -1, -1, 284, 63, 142, -1, -1, 285, 288, -1,
1432  -1, 286, 288, -1, -1, 287, 288, -1, 63, -1,
1433  -1, 111, 289, 293, -1, -1, -1, -1, 109, 290,
1434  291, 292, 152, 110, -1, 54, -1, 55, -1, 57,
1435  -1, 303, -1, 101, 295, -1, 177, -1, 55, -1,
1436  54, -1, 57, -1, 101, 286, 112, -1, 298, -1,
1437  128, 298, -1, 59, -1, 60, -1, 61, -1, 62,
1438  -1, 52, -1, 55, -1, 54, -1, 56, -1, 57,
1439  -1, 34, -1, 33, -1, 35, -1, 36, -1, 50,
1440  -1, 49, -1, 51, -1, 299, -1, 300, -1, 299,
1441  -1, 300, -1, 65, -1, 66, -1, 345, -1, -1,
1442  119, 305, 160, 345, -1, 1, 345, -1, 138, 310,
1443  342, -1, -1, 307, 310, 345, -1, 319, 136, 321,
1444  330, -1, 319, 330, -1, 321, 330, -1, 329, -1,
1445  136, 308, -1, -1, 314, 136, 325, 136, 327, 309,
1446  -1, 314, 136, 325, 136, 327, 136, 314, 309, -1,
1447  314, 136, 325, 309, -1, 314, 136, 325, 136, 314,
1448  309, -1, 314, 136, 327, 309, -1, 314, 136, 327,
1449  136, 314, 309, -1, 314, 309, -1, 325, 136, 327,
1450  309, -1, 325, 136, 327, 136, 314, 309, -1, 325,
1451  309, -1, 325, 136, 314, 309, -1, 327, 309, -1,
1452  327, 136, 314, 309, -1, 308, -1, -1, 56, -1,
1453  55, -1, 54, -1, 57, -1, 311, -1, 52, -1,
1454  312, -1, 91, 237, 342, -1, 313, -1, 314, 136,
1455  313, -1, 58, -1, 315, 186, -1, 315, -1, 315,
1456  218, -1, 315, -1, 317, -1, 318, 136, 317, -1,
1457  316, -1, 319, 136, 316, -1, 70, -1, 98, -1,
1458  320, 52, -1, 320, -1, 312, 115, 186, -1, 312,
1459  115, 218, -1, 323, -1, 324, 136, 323, -1, 322,
1460  -1, 325, 136, 322, -1, 125, -1, 97, -1, 326,
1461  52, -1, 326, -1, 122, -1, 99, -1, 328, 52,
1462  -1, 136, 329, -1, 347, -1, 301, -1, -1, 138,
1463  332, 159, 342, -1, 347, -1, 334, 344, -1, 335,
1464  -1, 334, 136, 335, -1, 186, 90, 186, -1, 58,
1465  186, -1, 98, 186, -1, 52, -1, 56, -1, 53,
1466  -1, 52, -1, 56, -1, 53, -1, 182, -1, 52,
1467  -1, 53, -1, 182, -1, 135, -1, 87, -1, -1,
1468  346, -1, -1, 143, -1, 341, 139, -1, 341, 140,
1469  -1, -1, 143, -1, 136, -1, 141, -1, 143, -1,
1470  345, -1, 346, 141, -1, -1
1471 };
1472 
1473 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1474 static const yytype_uint16 yyrline[] =
1475 {
1476  0, 863, 863, 863, 894, 905, 914, 922, 930, 936,
1477  938, 937, 958, 991, 1002, 1011, 1019, 1027, 1033, 1038,
1478  1037, 1058, 1058, 1066, 1074, 1085, 1095, 1103, 1112, 1121,
1479  1134, 1147, 1156, 1168, 1169, 1179, 1184, 1205, 1210, 1215,
1480  1225, 1230, 1240, 1249, 1258, 1261, 1270, 1282, 1283, 1291,
1481  1299, 1307, 1315, 1318, 1330, 1331, 1334, 1335, 1347, 1346,
1482  1368, 1378, 1387, 1400, 1409, 1421, 1430, 1442, 1451, 1460,
1483  1468, 1476, 1486, 1487, 1497, 1498, 1508, 1516, 1524, 1532,
1484  1541, 1549, 1558, 1566, 1575, 1583, 1594, 1595, 1605, 1613,
1485  1623, 1631, 1641, 1645, 1649, 1657, 1665, 1673, 1681, 1693,
1486  1703, 1715, 1724, 1733, 1741, 1749, 1757, 1765, 1778, 1791,
1487  1802, 1810, 1813, 1821, 1829, 1839, 1840, 1841, 1842, 1847,
1488  1858, 1859, 1862, 1870, 1873, 1881, 1881, 1891, 1892, 1893,
1489  1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1903,
1490  1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913,
1491  1914, 1915, 1916, 1917, 1918, 1919, 1920, 1923, 1923, 1923,
1492  1924, 1924, 1925, 1925, 1925, 1926, 1926, 1926, 1926, 1927,
1493  1927, 1927, 1927, 1928, 1928, 1928, 1929, 1929, 1929, 1929,
1494  1930, 1930, 1930, 1930, 1931, 1931, 1931, 1931, 1932, 1932,
1495  1932, 1932, 1933, 1933, 1933, 1933, 1934, 1934, 1937, 1946,
1496  1956, 1961, 1971, 1997, 2002, 2007, 2012, 2022, 2032, 2043,
1497  2057, 2071, 2079, 2087, 2095, 2103, 2111, 2119, 2128, 2136,
1498  2144, 2152, 2160, 2168, 2176, 2184, 2192, 2200, 2208, 2216,
1499  2224, 2232, 2243, 2251, 2259, 2267, 2275, 2283, 2291, 2299,
1500  2299, 2309, 2319, 2325, 2337, 2338, 2342, 2350, 2360, 2370,
1501  2371, 2374, 2375, 2376, 2380, 2388, 2398, 2407, 2415, 2425,
1502  2434, 2443, 2443, 2455, 2465, 2469, 2475, 2483, 2491, 2505,
1503  2521, 2522, 2525, 2539, 2554, 2564, 2565, 2566, 2567, 2568,
1504  2569, 2570, 2571, 2572, 2573, 2574, 2583, 2582, 2610, 2610,
1505  2619, 2623, 2618, 2632, 2640, 2648, 2656, 2669, 2677, 2685,
1506  2693, 2701, 2709, 2709, 2719, 2727, 2735, 2745, 2746, 2756,
1507  2760, 2772, 2784, 2784, 2784, 2795, 2795, 2795, 2806, 2817,
1508  2826, 2828, 2825, 2892, 2891, 2913, 2918, 2912, 2937, 2936,
1509  2958, 2957, 2980, 2981, 2980, 3001, 3009, 3017, 3025, 3035,
1510  3047, 3053, 3059, 3065, 3071, 3077, 3083, 3089, 3095, 3101,
1511  3111, 3117, 3122, 3123, 3130, 3135, 3138, 3139, 3152, 3153,
1512  3163, 3164, 3167, 3175, 3185, 3193, 3203, 3211, 3220, 3229,
1513  3237, 3245, 3254, 3266, 3274, 3285, 3289, 3293, 3297, 3303,
1514  3308, 3313, 3317, 3321, 3325, 3329, 3333, 3341, 3345, 3349,
1515  3353, 3357, 3361, 3365, 3369, 3373, 3379, 3380, 3386, 3395,
1516  3404, 3415, 3419, 3429, 3436, 3445, 3453, 3459, 3462, 3467,
1517  3470, 3459, 3489, 3497, 3503, 3507, 3514, 3513, 3534, 3550,
1518  3559, 3571, 3585, 3595, 3594, 3611, 3610, 3626, 3635, 3634,
1519  3652, 3651, 3668, 3676, 3684, 3699, 3698, 3718, 3717, 3738,
1520  3750, 3751, 3754, 3773, 3776, 3784, 3792, 3795, 3799, 3802,
1521  3810, 3813, 3814, 3822, 3825, 3842, 3843, 3844, 3854, 3864,
1522  3891, 3956, 3965, 3976, 3983, 3993, 4001, 4011, 4020, 4031,
1523  4038, 4056, 4065, 4075, 4084, 4095, 4102, 4113, 4120, 4135,
1524  4142, 4153, 4160, 4171, 4178, 4207, 4209, 4208, 4225, 4231,
1525  4236, 4224, 4255, 4263, 4271, 4279, 4282, 4293, 4294, 4295,
1526  4296, 4299, 4310, 4311, 4321, 4322, 4323, 4324, 4327, 4328,
1527  4329, 4330, 4331, 4334, 4335, 4336, 4337, 4338, 4339, 4340,
1528  4343, 4356, 4366, 4374, 4384, 4385, 4388, 4397, 4396, 4405,
1529  4417, 4427, 4427, 4440, 4444, 4448, 4452, 4458, 4463, 4468,
1530  4472, 4476, 4480, 4484, 4488, 4492, 4496, 4500, 4504, 4508,
1531  4512, 4516, 4520, 4525, 4531, 4540, 4549, 4558, 4569, 4570,
1532  4577, 4586, 4605, 4612, 4626, 4633, 4642, 4653, 4662, 4673,
1533  4681, 4698, 4706, 4722, 4723, 4726, 4731, 4737, 4749, 4761,
1534  4769, 4785, 4793, 4809, 4810, 4813, 4826, 4837, 4838, 4841,
1535  4858, 4862, 4872, 4882, 4882, 4911, 4912, 4922, 4929, 4939,
1536  4951, 4959, 4971, 4972, 4973, 4976, 4977, 4978, 4979, 4982,
1537  4983, 4984, 4987, 4992, 4999, 5000, 5003, 5004, 5007, 5010,
1538  5013, 5014, 5015, 5018, 5019, 5022, 5023, 5027
1539 };
1540 #endif
1541 
1542 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1543 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1544  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1545 static const char *const yytname[] =
1546 {
1547  "\"end-of-input\"", "error", "$undefined", "keyword_class",
1548  "keyword_module", "keyword_def", "keyword_undef", "keyword_begin",
1549  "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if",
1550  "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else",
1551  "keyword_case", "keyword_when", "keyword_while", "keyword_until",
1552  "keyword_for", "keyword_break", "keyword_next", "keyword_redo",
1553  "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond",
1554  "keyword_do_block", "keyword_do_LAMBDA", "keyword_return",
1555  "keyword_yield", "keyword_super", "keyword_self", "keyword_nil",
1556  "keyword_true", "keyword_false", "keyword_and", "keyword_or",
1557  "keyword_not", "modifier_if", "modifier_unless", "modifier_while",
1558  "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined",
1559  "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__",
1560  "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR",
1561  "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tRATIONAL",
1562  "tIMAGINARY", "tSTRING_CONTENT", "tCHAR", "tNTH_REF", "tBACK_REF",
1563  "tREGEXP_END", "\"unary+\"", "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"",
1564  "\"===\"", "\"!=\"", "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"",
1565  "\"!~\"", "\"..\"", "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"",
1566  "\"::\"", "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"",
1567  "\"( arg\"", "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"",
1568  "\"**arg\"", "\"&\"", "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG",
1569  "tREGEXP_BEG", "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG",
1570  "tQSYMBOLS_BEG", "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR",
1571  "tSTRING_END", "tLAMBEG", "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'",
1572  "'|'", "'^'", "'&'", "'+'", "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM",
1573  "'!'", "'~'", "tLAST_TOKEN", "'{'", "'}'", "'['", "'.'", "','", "'`'",
1574  "'('", "')'", "']'", "';'", "' '", "'\\n'", "$accept", "program", "$@1",
1575  "top_compstmt", "top_stmts", "top_stmt", "$@2", "bodystmt", "compstmt",
1576  "stmts", "stmt_or_begin", "$@3", "stmt", "$@4", "command_asgn", "expr",
1577  "expr_value", "command_call", "block_command", "cmd_brace_block", "@5",
1578  "fcall", "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item",
1579  "mlhs_head", "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname",
1580  "fsym", "fitem", "undef_list", "$@6", "op", "reswords", "arg", "$@7",
1581  "arg_value", "aref_args", "paren_args", "opt_paren_args",
1582  "opt_call_args", "call_args", "command_args", "@8", "block_arg",
1583  "opt_block_arg", "args", "mrhs_arg", "mrhs", "primary", "@9", "$@10",
1584  "$@11", "$@12", "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "$@19",
1585  "@20", "@21", "@22", "@23", "@24", "$@25", "$@26", "primary_value",
1586  "k_begin", "k_if", "k_unless", "k_while", "k_until", "k_case", "k_for",
1587  "k_class", "k_module", "k_def", "k_end", "then", "do", "if_tail",
1588  "opt_else", "for_var", "f_marg", "f_marg_list", "f_margs",
1589  "block_args_tail", "opt_block_args_tail", "block_param",
1590  "opt_block_param", "block_param_def", "opt_bv_decl", "bv_decls", "bvar",
1591  "lambda", "@27", "@28", "@29", "@30", "f_larglist", "lambda_body",
1592  "do_block", "@31", "block_call", "method_call", "@32", "@33", "@34",
1593  "@35", "brace_block", "@36", "@37", "case_body", "cases", "opt_rescue",
1594  "exc_list", "exc_var", "opt_ensure", "literal", "strings", "string",
1595  "string1", "xstring", "regexp", "words", "word_list", "word", "symbols",
1596  "symbol_list", "qwords", "qsymbols", "qword_list", "qsym_list",
1597  "string_contents", "xstring_contents", "regexp_contents",
1598  "string_content", "@38", "@39", "@40", "@41", "string_dvar", "symbol",
1599  "sym", "dsym", "numeric", "simple_numeric", "user_variable",
1600  "keyword_variable", "var_ref", "var_lhs", "backref", "superclass",
1601  "$@42", "f_arglist", "@43", "args_tail", "opt_args_tail", "f_args",
1602  "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_label", "f_kw",
1603  "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest",
1604  "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
1605  "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
1606  "singleton", "$@44", "assoc_list", "assocs", "assoc", "operation",
1607  "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
1608  "rparen", "rbracket", "trailer", "term", "terms", "none", 0
1609 };
1610 #endif
1611 
1612 # ifdef YYPRINT
1613 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1614  token YYLEX-NUM. */
1615 static const yytype_uint16 yytoknum[] =
1616 {
1617  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1618  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1619  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1620  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1621  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1622  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1623  315, 316, 317, 318, 319, 320, 321, 322, 130, 131,
1624  132, 134, 139, 140, 141, 138, 137, 323, 324, 142,
1625  143, 128, 129, 144, 145, 135, 136, 325, 326, 327,
1626  328, 329, 330, 331, 332, 333, 334, 335, 336, 337,
1627  338, 339, 340, 341, 342, 343, 344, 345, 346, 347,
1628  348, 349, 350, 351, 352, 61, 63, 58, 62, 60,
1629  124, 94, 38, 43, 45, 42, 47, 37, 353, 33,
1630  126, 354, 123, 125, 91, 46, 44, 96, 40, 41,
1631  93, 59, 32, 10
1632 };
1633 # endif
1634 
1635 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1636 static const yytype_uint16 yyr1[] =
1637 {
1638  0, 144, 146, 145, 147, 148, 148, 148, 148, 149,
1639  150, 149, 151, 152, 153, 153, 153, 153, 154, 155,
1640  154, 157, 156, 156, 156, 156, 156, 156, 156, 156,
1641  156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
1642  156, 156, 156, 156, 156, 158, 158, 159, 159, 159,
1643  159, 159, 159, 160, 161, 161, 162, 162, 164, 163,
1644  165, 166, 166, 166, 166, 166, 166, 166, 166, 166,
1645  166, 166, 167, 167, 168, 168, 169, 169, 169, 169,
1646  169, 169, 169, 169, 169, 169, 170, 170, 171, 171,
1647  172, 172, 173, 173, 173, 173, 173, 173, 173, 173,
1648  173, 174, 174, 174, 174, 174, 174, 174, 174, 174,
1649  175, 175, 176, 176, 176, 177, 177, 177, 177, 177,
1650  178, 178, 179, 179, 180, 181, 180, 182, 182, 182,
1651  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1652  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1653  182, 182, 182, 182, 182, 182, 182, 183, 183, 183,
1654  183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
1655  183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
1656  183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
1657  183, 183, 183, 183, 183, 183, 183, 183, 184, 184,
1658  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1659  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1660  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1661  184, 184, 184, 184, 184, 184, 184, 184, 184, 185,
1662  184, 184, 184, 186, 187, 187, 187, 187, 188, 189,
1663  189, 190, 190, 190, 190, 190, 191, 191, 191, 191,
1664  191, 193, 192, 194, 195, 195, 196, 196, 196, 196,
1665  197, 197, 198, 198, 198, 199, 199, 199, 199, 199,
1666  199, 199, 199, 199, 199, 199, 200, 199, 201, 199,
1667  202, 203, 199, 199, 199, 199, 199, 199, 199, 199,
1668  199, 199, 204, 199, 199, 199, 199, 199, 199, 199,
1669  199, 199, 205, 206, 199, 207, 208, 199, 199, 199,
1670  209, 210, 199, 211, 199, 212, 213, 199, 214, 199,
1671  215, 199, 216, 217, 199, 199, 199, 199, 199, 218,
1672  219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
1673  229, 230, 230, 230, 231, 231, 232, 232, 233, 233,
1674  234, 234, 235, 235, 236, 236, 237, 237, 237, 237,
1675  237, 237, 237, 237, 237, 238, 238, 238, 238, 239,
1676  239, 240, 240, 240, 240, 240, 240, 240, 240, 240,
1677  240, 240, 240, 240, 240, 240, 241, 241, 242, 242,
1678  242, 243, 243, 244, 244, 245, 245, 247, 248, 249,
1679  250, 246, 251, 251, 252, 252, 254, 253, 255, 255,
1680  255, 255, 256, 257, 256, 258, 256, 256, 259, 256,
1681  260, 256, 256, 256, 256, 262, 261, 263, 261, 264,
1682  265, 265, 266, 266, 267, 267, 267, 268, 268, 269,
1683  269, 270, 270, 270, 271, 272, 272, 272, 273, 274,
1684  275, 276, 276, 277, 277, 278, 278, 279, 279, 280,
1685  280, 281, 281, 282, 282, 283, 283, 284, 284, 285,
1686  285, 286, 286, 287, 287, 288, 289, 288, 290, 291,
1687  292, 288, 293, 293, 293, 293, 294, 295, 295, 295,
1688  295, 296, 297, 297, 298, 298, 298, 298, 299, 299,
1689  299, 299, 299, 300, 300, 300, 300, 300, 300, 300,
1690  301, 301, 302, 302, 303, 303, 304, 305, 304, 304,
1691  306, 307, 306, 308, 308, 308, 308, 309, 309, 310,
1692  310, 310, 310, 310, 310, 310, 310, 310, 310, 310,
1693  310, 310, 310, 310, 311, 311, 311, 311, 312, 312,
1694  313, 313, 314, 314, 315, 316, 316, 317, 317, 318,
1695  318, 319, 319, 320, 320, 321, 321, 322, 323, 324,
1696  324, 325, 325, 326, 326, 327, 327, 328, 328, 329,
1697  330, 330, 331, 332, 331, 333, 333, 334, 334, 335,
1698  335, 335, 336, 336, 336, 337, 337, 337, 337, 338,
1699  338, 338, 339, 339, 340, 340, 341, 341, 342, 343,
1700  344, 344, 344, 345, 345, 346, 346, 347
1701 };
1702 
1703 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1704 static const yytype_uint8 yyr2[] =
1705 {
1706  0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
1707  0, 5, 4, 2, 1, 1, 3, 2, 1, 0,
1708  5, 0, 4, 3, 3, 3, 2, 3, 3, 3,
1709  3, 3, 4, 1, 3, 3, 6, 5, 5, 5,
1710  5, 3, 3, 3, 1, 3, 3, 1, 3, 3,
1711  3, 2, 1, 1, 1, 1, 1, 4, 0, 5,
1712  1, 2, 3, 4, 5, 4, 5, 2, 2, 2,
1713  2, 2, 1, 3, 1, 3, 1, 2, 3, 5,
1714  2, 4, 2, 4, 1, 3, 1, 3, 2, 3,
1715  1, 3, 1, 1, 4, 3, 3, 3, 3, 2,
1716  1, 1, 1, 4, 3, 3, 3, 3, 2, 1,
1717  1, 1, 2, 1, 3, 1, 1, 1, 1, 1,
1718  1, 1, 1, 1, 1, 0, 4, 1, 1, 1,
1719  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1720  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1721  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1722  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1723  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1724  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1725  1, 1, 1, 1, 1, 1, 1, 1, 3, 5,
1726  3, 5, 6, 5, 5, 5, 5, 4, 3, 3,
1727  3, 3, 3, 3, 3, 3, 3, 4, 2, 2,
1728  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1729  3, 3, 3, 2, 2, 3, 3, 3, 3, 0,
1730  4, 6, 1, 1, 1, 2, 4, 2, 3, 1,
1731  1, 1, 1, 2, 4, 2, 1, 2, 2, 4,
1732  1, 0, 2, 2, 2, 1, 1, 2, 3, 4,
1733  1, 1, 3, 4, 2, 1, 1, 1, 1, 1,
1734  1, 1, 1, 1, 1, 1, 0, 4, 0, 3,
1735  0, 0, 5, 3, 3, 2, 3, 3, 1, 4,
1736  3, 1, 0, 6, 4, 3, 2, 1, 2, 2,
1737  6, 6, 0, 0, 7, 0, 0, 7, 5, 4,
1738  0, 0, 9, 0, 6, 0, 0, 8, 0, 5,
1739  0, 6, 0, 0, 9, 1, 1, 1, 1, 1,
1740  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1741  1, 1, 1, 2, 1, 1, 1, 5, 1, 2,
1742  1, 1, 1, 3, 1, 3, 1, 4, 6, 3,
1743  5, 2, 4, 1, 3, 4, 2, 2, 1, 2,
1744  0, 6, 8, 4, 6, 4, 2, 6, 2, 4,
1745  6, 2, 4, 2, 4, 1, 1, 1, 3, 1,
1746  4, 1, 4, 1, 3, 1, 1, 0, 0, 0,
1747  0, 6, 4, 1, 3, 3, 0, 5, 2, 4,
1748  5, 5, 2, 0, 5, 0, 5, 3, 0, 4,
1749  0, 4, 2, 1, 4, 0, 5, 0, 5, 5,
1750  1, 1, 6, 1, 1, 1, 1, 2, 1, 2,
1751  1, 1, 1, 1, 1, 1, 1, 2, 3, 3,
1752  3, 3, 3, 0, 3, 1, 2, 3, 3, 0,
1753  3, 3, 3, 3, 3, 0, 3, 0, 3, 0,
1754  2, 0, 2, 0, 2, 1, 0, 3, 0, 0,
1755  0, 6, 1, 1, 1, 1, 2, 1, 1, 1,
1756  1, 3, 1, 2, 1, 1, 1, 1, 1, 1,
1757  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1758  1, 1, 1, 1, 1, 1, 1, 0, 4, 2,
1759  3, 0, 3, 4, 2, 2, 1, 2, 0, 6,
1760  8, 4, 6, 4, 6, 2, 4, 6, 2, 4,
1761  2, 4, 1, 0, 1, 1, 1, 1, 1, 1,
1762  1, 3, 1, 3, 1, 2, 1, 2, 1, 1,
1763  3, 1, 3, 1, 1, 2, 1, 3, 3, 1,
1764  3, 1, 3, 1, 1, 2, 1, 1, 1, 2,
1765  2, 1, 1, 0, 4, 1, 2, 1, 3, 3,
1766  2, 2, 1, 1, 1, 1, 1, 1, 1, 1,
1767  1, 1, 1, 1, 0, 1, 0, 1, 2, 2,
1768  0, 1, 1, 1, 1, 1, 2, 0
1769 };
1770 
1771 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1772  Performed when YYTABLE doesn't specify something else to do. Zero
1773  means the default is an error. */
1774 static const yytype_uint16 yydefact[] =
1775 {
1776  2, 0, 0, 1, 0, 347, 348, 349, 0, 340,
1777  341, 342, 345, 343, 344, 346, 335, 336, 337, 338,
1778  298, 261, 261, 514, 513, 515, 516, 616, 0, 616,
1779  10, 0, 518, 517, 519, 602, 604, 510, 509, 603,
1780  512, 504, 505, 506, 507, 455, 524, 525, 0, 0,
1781  0, 0, 290, 627, 627, 84, 407, 481, 479, 481,
1782  483, 463, 475, 469, 477, 0, 0, 0, 3, 614,
1783  6, 9, 33, 44, 47, 55, 261, 54, 0, 72,
1784  0, 76, 86, 0, 52, 242, 0, 286, 0, 0,
1785  312, 315, 614, 0, 0, 0, 0, 56, 307, 275,
1786  276, 454, 456, 277, 278, 279, 281, 280, 282, 452,
1787  453, 451, 502, 520, 521, 283, 0, 284, 60, 5,
1788  8, 167, 178, 168, 191, 164, 184, 174, 173, 194,
1789  195, 189, 172, 171, 166, 192, 196, 197, 176, 165,
1790  179, 183, 185, 177, 170, 186, 193, 188, 187, 180,
1791  190, 175, 163, 182, 181, 162, 169, 160, 161, 157,
1792  158, 159, 115, 117, 116, 152, 153, 148, 130, 131,
1793  132, 139, 136, 138, 133, 134, 154, 155, 140, 141,
1794  145, 149, 135, 137, 127, 128, 129, 142, 143, 144,
1795  146, 147, 150, 151, 156, 120, 122, 124, 26, 118,
1796  119, 121, 123, 0, 0, 0, 0, 0, 0, 0,
1797  0, 256, 0, 243, 266, 70, 260, 627, 0, 520,
1798  521, 0, 284, 627, 597, 71, 69, 616, 68, 0,
1799  627, 432, 67, 616, 617, 0, 0, 21, 239, 0,
1800  0, 335, 336, 298, 301, 433, 0, 218, 0, 219,
1801  295, 0, 19, 0, 0, 614, 15, 18, 616, 74,
1802  14, 616, 0, 0, 620, 620, 244, 0, 0, 620,
1803  595, 616, 0, 0, 0, 82, 339, 0, 92, 93,
1804  100, 309, 408, 499, 498, 500, 497, 0, 496, 0,
1805  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1806  503, 51, 233, 234, 623, 624, 4, 625, 615, 0,
1807  0, 0, 0, 0, 0, 0, 437, 435, 422, 61,
1808  306, 416, 418, 0, 88, 0, 80, 77, 0, 0,
1809  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1810  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1811  0, 0, 0, 0, 0, 430, 627, 428, 0, 53,
1812  0, 0, 0, 0, 614, 0, 615, 0, 361, 360,
1813  0, 0, 520, 521, 284, 110, 111, 0, 0, 113,
1814  0, 0, 520, 521, 284, 328, 187, 180, 190, 175,
1815  157, 158, 159, 115, 116, 593, 330, 592, 0, 613,
1816  612, 0, 308, 457, 0, 0, 125, 600, 295, 267,
1817  601, 263, 0, 0, 0, 257, 265, 430, 627, 428,
1818  0, 0, 0, 258, 616, 0, 300, 262, 616, 252,
1819  627, 627, 251, 616, 305, 50, 23, 25, 24, 0,
1820  302, 0, 0, 0, 430, 428, 0, 17, 0, 616,
1821  293, 13, 615, 73, 289, 291, 296, 622, 621, 245,
1822  622, 247, 297, 596, 0, 99, 503, 90, 85, 0,
1823  430, 627, 428, 553, 485, 488, 486, 501, 482, 458,
1824  480, 459, 460, 484, 461, 462, 0, 465, 471, 0,
1825  472, 467, 468, 0, 473, 0, 474, 0, 626, 7,
1826  27, 28, 29, 30, 31, 48, 49, 627, 627, 58,
1827  62, 627, 0, 34, 271, 0, 43, 270, 616, 0,
1828  78, 89, 46, 45, 0, 198, 266, 42, 216, 223,
1829  228, 229, 230, 225, 227, 237, 238, 231, 232, 209,
1830  210, 235, 236, 616, 224, 226, 220, 221, 222, 211,
1831  212, 213, 214, 215, 605, 607, 606, 608, 0, 261,
1832  427, 616, 605, 607, 606, 608, 0, 261, 0, 627,
1833  352, 0, 351, 0, 0, 0, 0, 0, 0, 295,
1834  430, 627, 428, 320, 325, 110, 111, 112, 0, 527,
1835  323, 526, 430, 627, 428, 0, 0, 531, 332, 605,
1836  606, 261, 35, 200, 41, 208, 0, 198, 599, 0,
1837  268, 264, 627, 605, 606, 616, 605, 606, 598, 299,
1838  618, 248, 253, 255, 304, 22, 0, 240, 0, 32,
1839  425, 423, 207, 0, 75, 16, 616, 620, 0, 83,
1840  96, 98, 616, 605, 606, 559, 556, 555, 554, 557,
1841  564, 573, 0, 584, 574, 588, 587, 583, 553, 409,
1842  552, 413, 558, 560, 562, 538, 566, 571, 627, 576,
1843  627, 581, 538, 586, 538, 0, 536, 489, 0, 464,
1844  466, 476, 470, 478, 217, 399, 616, 0, 397, 396,
1845  0, 627, 0, 274, 0, 87, 81, 0, 0, 0,
1846  0, 0, 0, 431, 65, 0, 0, 434, 0, 0,
1847  429, 63, 627, 350, 287, 627, 627, 443, 627, 353,
1848  627, 355, 313, 354, 316, 0, 0, 319, 609, 294,
1849  616, 605, 606, 0, 0, 529, 0, 0, 110, 111,
1850  114, 616, 0, 616, 553, 0, 553, 0, 250, 419,
1851  57, 249, 0, 126, 269, 259, 0, 0, 434, 0,
1852  0, 627, 616, 11, 0, 292, 246, 91, 94, 0,
1853  373, 364, 366, 616, 362, 616, 410, 0, 0, 545,
1854  565, 0, 534, 591, 575, 0, 535, 0, 548, 585,
1855  0, 550, 589, 490, 492, 493, 494, 487, 495, 395,
1856  616, 0, 560, 380, 568, 569, 627, 627, 579, 380,
1857  380, 378, 401, 0, 0, 0, 0, 0, 272, 79,
1858  199, 0, 40, 205, 39, 206, 66, 426, 619, 0,
1859  37, 203, 38, 204, 64, 424, 444, 445, 627, 446,
1860  0, 627, 358, 0, 0, 356, 0, 0, 0, 318,
1861  0, 0, 434, 0, 326, 0, 0, 434, 329, 594,
1862  616, 0, 0, 333, 420, 421, 201, 0, 254, 303,
1863  20, 616, 0, 371, 0, 561, 0, 0, 577, 537,
1864  563, 538, 538, 572, 627, 590, 538, 582, 538, 560,
1865  538, 0, 0, 398, 0, 386, 388, 0, 567, 0,
1866  376, 377, 0, 391, 0, 393, 0, 438, 436, 0,
1867  417, 273, 241, 36, 202, 0, 0, 448, 359, 0,
1868  12, 450, 0, 310, 311, 0, 0, 268, 627, 321,
1869  0, 528, 324, 530, 331, 532, 531, 363, 374, 0,
1870  369, 365, 412, 0, 0, 411, 0, 541, 0, 543,
1871  533, 0, 549, 0, 546, 551, 0, 400, 578, 379,
1872  380, 380, 295, 430, 570, 627, 380, 580, 380, 380,
1873  405, 616, 403, 406, 59, 0, 447, 0, 101, 102,
1874  109, 0, 449, 0, 314, 317, 440, 441, 439, 0,
1875  0, 0, 0, 372, 0, 367, 0, 0, 538, 538,
1876  538, 538, 491, 0, 383, 0, 385, 609, 294, 375,
1877  0, 392, 0, 389, 394, 0, 402, 108, 430, 627,
1878  428, 627, 627, 0, 327, 0, 370, 0, 415, 414,
1879  542, 0, 539, 544, 547, 380, 380, 380, 380, 404,
1880  609, 107, 616, 605, 606, 442, 357, 322, 334, 368,
1881  538, 384, 0, 381, 387, 390, 434, 540, 380, 382
1882 };
1883 
1884 /* YYDEFGOTO[NTERM-NUM]. */
1885 static const yytype_int16 yydefgoto[] =
1886 {
1887  -1, 1, 2, 68, 69, 70, 239, 568, 569, 255,
1888  256, 448, 257, 439, 72, 73, 360, 74, 75, 510,
1889  691, 246, 77, 78, 258, 79, 80, 81, 468, 82,
1890  212, 379, 380, 195, 196, 197, 198, 606, 557, 200,
1891  84, 441, 214, 263, 231, 749, 428, 429, 228, 229,
1892  216, 415, 430, 516, 517, 85, 358, 261, 262, 636,
1893  626, 362, 847, 363, 848, 733, 989, 737, 734, 930,
1894  595, 597, 747, 936, 248, 87, 88, 89, 90, 91,
1895  92, 93, 94, 95, 96, 714, 571, 722, 844, 845,
1896  371, 771, 772, 773, 959, 896, 800, 687, 688, 801,
1897  971, 972, 281, 282, 473, 776, 877, 659, 945, 322,
1898  511, 97, 98, 712, 705, 566, 558, 320, 508, 507,
1899  578, 988, 716, 838, 916, 920, 99, 100, 101, 102,
1900  103, 104, 105, 293, 486, 106, 297, 107, 108, 295,
1901  299, 289, 287, 291, 478, 678, 677, 793, 891, 797,
1902  109, 288, 110, 111, 112, 219, 220, 115, 221, 222,
1903  590, 736, 745, 746, 879, 779, 661, 662, 889, 664,
1904  665, 666, 667, 805, 806, 668, 669, 670, 671, 808,
1905  809, 672, 673, 674, 675, 676, 782, 398, 596, 268,
1906  431, 224, 118, 630, 560, 401, 306, 425, 426, 707,
1907  459, 572, 366, 260
1908 };
1909 
1910 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1911  STATE-NUM. */
1912 #define YYPACT_NINF -813
1913 static const yytype_int16 yypact[] =
1914 {
1915  -813, 111, 2847, -813, 7396, -813, -813, -813, 6911, -813,
1916  -813, -813, -813, -813, -813, -813, 7511, 7511, -813, -813,
1917  7511, 4052, 3641, -813, -813, -813, -813, -21, 6776, -35,
1918  -813, -12, -813, -813, -813, 2956, 3778, -813, -813, 3093,
1919  -813, -813, -813, -813, -813, -813, -813, -813, 8891, 8891,
1920  72, 5120, 30, 7856, 8201, 7174, -813, 6641, -813, -813,
1921  -813, 41, 84, 95, 136, 1005, 9006, 8891, -813, 230,
1922  -813, 1060, -813, 324, -813, -813, 142, 104, 168, -813,
1923  192, 9236, -813, 201, 3209, 40, 271, -813, 9121, 9121,
1924  -813, -813, 6021, 9347, 9458, 9569, 6505, 22, 97, -813,
1925  -813, 56, -813, -813, -813, -813, -813, -813, -813, -813,
1926  -813, -813, -813, 27, 472, -813, 243, 651, -813, -813,
1927  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1928  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1929  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1930  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1931  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1932  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1933  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1934  -813, -813, -813, -813, -813, -813, -813, -813, 207, -813,
1935  -813, -813, -813, 219, 8891, 330, 5261, 8891, 8891, 8891,
1936  8891, -813, 285, 3209, 343, -813, -813, 278, 301, 14,
1937  233, 348, 244, 284, -813, -813, -813, 5906, -813, 7511,
1938  7511, -813, -813, 6136, -813, 9121, 775, -813, 314, 354,
1939  5402, -813, -813, -813, 342, 364, 142, -813, 435, 422,
1940  687, 7626, -813, 5120, 369, 230, -813, 1060, -35, 408,
1941  -813, -35, 9121, 403, 329, 331, -813, 343, 420, 331,
1942  -813, -35, 510, 1005, 9680, 432, -813, 520, 565, 590,
1943  604, -813, -813, -813, -813, -813, -813, 502, -813, 513,
1944  523, 416, 465, 658, 469, 33, 476, 685, 488, 44,
1945  514, -813, -813, -813, -813, -813, -813, -813, 6251, 9121,
1946  9121, 9121, 9121, 7626, 9121, 9121, -813, -813, -813, 522,
1947  -813, -813, -813, 8316, -813, 5120, 7285, 528, 8316, 8891,
1948  8891, 8891, 8891, 8891, 8891, 8891, 8891, 8891, 8891, 8891,
1949  8891, 8891, 8891, 8891, 8891, 8891, 8891, 8891, 8891, 8891,
1950  8891, 8891, 8891, 8891, 8891, 9963, 7511, 10042, 4467, 324,
1951  112, 112, 9121, 9121, 230, 642, 530, 618, -813, -813,
1952  620, 655, 94, 108, 121, 312, 495, 9121, 139, -813,
1953  212, 644, -813, -813, -813, -813, 26, 292, 384, 458,
1954  467, 532, 562, 570, 582, -813, -813, -813, 22, -813,
1955  -813, 10121, -813, -813, 9006, 9006, -813, -813, 286, -813,
1956  -813, -813, 8891, 8891, 7741, -813, -813, 10200, 7511, 10279,
1957  8891, 8891, 7971, -813, -35, 544, -813, -813, -35, -813,
1958  550, 551, -813, 93, -813, -813, -813, -813, -813, 6911,
1959  -813, 8891, 5535, 576, 10200, 10279, 8891, 1060, 558, -35,
1960  -813, -813, 6366, 559, -813, 324, -813, 8086, -813, -813,
1961  8201, -813, -813, -813, 314, 648, -813, -813, 597, 9680,
1962  10358, 7511, 10437, 1164, -813, -813, -813, -813, -813, -813,
1963  -813, -813, -813, -813, -813, -813, 346, -813, -813, 556,
1964  -813, -813, -813, 347, -813, 584, -813, 8891, -813, -813,
1965  -813, -813, -813, -813, -813, -813, -813, 19, 19, -813,
1966  -813, 19, 8891, -813, 607, 608, -813, -813, -35, 9680,
1967  610, -813, -813, -813, 636, 2008, -813, -813, 422, 2309,
1968  2309, 2309, 2309, 1315, 1315, 2621, 1681, 2309, 2309, 3346,
1969  3346, 425, 425, 10940, 1315, 1315, 795, 795, 887, 337,
1970  337, 422, 422, 422, 4189, 3230, 4326, 3367, 364, 623,
1971  -813, -35, 688, -813, 706, -813, 364, 3915, 755, 763,
1972  -813, 4608, 771, 4890, 65, 65, 642, 8431, 755, 135,
1973  10516, 7511, 10595, -813, 324, -813, 648, -813, 230, -813,
1974  -813, -813, 10674, 7511, 10121, 4467, 9121, 647, -813, -813,
1975  -813, 1256, -813, 2935, -813, 3209, 6911, 3072, -813, 8891,
1976  343, -813, 284, 2529, 3504, -35, 381, 526, -813, -813,
1977  -813, -813, 7741, 7971, -813, -813, 9121, 3209, 657, -813,
1978  -813, -813, 3209, 5535, 262, -813, -35, 331, 9680, 597,
1979  505, 394, -35, 276, 351, -813, -813, -813, -813, -813,
1980  -813, -813, 950, -813, -813, -813, -813, -813, 1220, -813,
1981  -813, -813, -813, 678, -813, 674, 8891, -813, 676, 768,
1982  692, -813, 701, 786, 707, 800, -813, -813, 885, -813,
1983  -813, -813, -813, -813, 422, -813, 1115, 5676, -813, -813,
1984  5402, 19, 5676, 718, 8546, -813, 597, 9680, 9006, 8891,
1985  739, 9006, 9006, -813, 522, 364, 721, 717, 9006, 9006,
1986  -813, 522, 364, -813, -813, 8661, 842, -813, 664, -813,
1987  842, -813, -813, -813, -813, 755, 71, -813, 66, 80,
1988  -35, 141, 162, 9121, 230, -813, 9121, 4467, 505, 394,
1989  -813, -35, 755, 93, 1220, 4467, 1220, 7046, -813, 97,
1990  104, -813, 8891, -813, -813, -813, 8891, 8891, 557, 8891,
1991  8891, 728, 93, -813, 733, -813, -813, -813, 366, 950,
1992  459, -813, 732, -35, -813, -35, -813, 8891, 1220, -813,
1993  -813, 586, -813, -813, -813, 42, -813, 1220, -813, -813,
1994  1307, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1995  -35, 751, 757, 737, 9791, -813, 740, 692, -813, 742,
1996  747, -813, 734, 877, 758, 5402, 878, 8891, 761, 597,
1997  3209, 8891, -813, 3209, -813, 3209, -813, -813, -813, 9006,
1998  -813, 3209, -813, 3209, -813, -813, 607, -813, 804, -813,
1999  5005, 890, -813, 9121, 755, -813, 755, 5676, 5676, -813,
2000  8776, 4749, 288, 65, -813, 230, 755, -813, -813, -813,
2001  -35, 755, 230, -813, -813, -813, 3209, 8891, 7971, -813,
2002  -813, -35, 873, 769, 1000, -813, 765, 73, -813, -813,
2003  -813, 772, 773, -813, 692, -813, 776, -813, 777, -813,
2004  776, 5791, 787, -813, 9791, 1220, -813, 855, 673, 586,
2005  -813, -813, 1220, -813, 1307, -813, 1016, -813, -813, 783,
2006  -813, 788, 3209, -813, 3209, 9902, 112, -813, -813, 5676,
2007  -813, -813, 112, -813, -813, 755, 755, -813, 542, -813,
2008  4467, -813, -813, -813, -813, -813, 647, -813, 796, 873,
2009  484, -813, -813, 5676, 5402, -813, 1220, -813, 1307, -813,
2010  -813, 1307, -813, 1307, -813, -813, 813, -813, 673, -813,
2011  799, 801, -813, 10753, -813, 692, 802, -813, 808, 802,
2012  -813, 367, -813, -813, -813, 875, -813, 681, 565, 590,
2013  604, 4467, -813, 4608, -813, -813, -813, -813, -813, 5676,
2014  755, 4467, 873, 796, 873, 811, 923, 815, 776, 817,
2015  776, 776, -813, 1220, -813, 1307, -813, 818, 820, -813,
2016  1307, -813, 1307, -813, -813, 1016, -813, 648, 10832, 7511,
2017  10911, 763, 664, 755, -813, 755, 796, 873, -813, -813,
2018  -813, 1307, -813, -813, -813, 802, 819, 802, 802, -813,
2019  169, 394, -35, 127, 146, -813, -813, -813, -813, 796,
2020  776, -813, 1307, -813, -813, -813, 180, -813, 802, -813
2021 };
2022 
2023 /* YYPGOTO[NTERM-NUM]. */
2024 static const yytype_int16 yypgoto[] =
2025 {
2026  -813, -813, -813, -361, -813, 29, -813, -540, -29, -813,
2027  515, -813, 43, -813, -301, -63, -71, 21, -813, -174,
2028  -813, 797, -10, 869, -158, 16, -76, -813, -395, 8,
2029  1783, -325, 870, -53, -813, -5, -813, -813, 3, -813,
2030  1127, -813, -19, -813, -67, 257, -317, 118, -3, -813,
2031  -390, -181, -4, -813, -313, -15, -813, -813, -813, -813,
2032  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
2033  -813, -813, -813, -813, 55, -813, -813, -813, -813, -813,
2034  -813, -813, -813, -813, -813, -541, -344, -527, -45, -631,
2035  -813, -770, -784, 210, 290, 172, -813, -425, -813, -663,
2036  -813, -31, -813, -813, -813, -813, -813, -813, -813, 236,
2037  -813, -813, -813, -813, -813, -813, -813, -96, -813, -813,
2038  -556, -813, -34, -813, -813, -813, -813, -813, -813, 889,
2039  -813, -813, -813, -813, 691, -813, -813, -813, -813, -813,
2040  -813, -813, 933, -813, -97, -813, -813, -813, -813, -813,
2041  0, -813, 6, -813, -11, 1321, 1524, 897, 1945, 1604,
2042  -813, -813, 58, -813, -404, -154, -323, -812, 123, -717,
2043  87, 76, 215, 101, -813, -813, -813, -69, -711, -629,
2044  106, 237, -813, -616, -813, -44, -626, -813, -813, -813,
2045  98, -392, -813, -319, -813, 624, -46, -26, -168, -565,
2046  -207, -28, -13, -2
2047 };
2048 
2049 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2050  positive, shift that token. If negative, reduce the rule which
2051  number is the opposite. If YYTABLE_NINF, syntax error. */
2052 #define YYTABLE_NINF -628
2053 static const yytype_int16 yytable[] =
2054 {
2055  119, 235, 402, 238, 286, 327, 211, 211, 201, 318,
2056  211, 199, 217, 217, 202, 527, 217, 573, 361, 232,
2057  725, 364, 254, 237, 611, 359, 359, 522, 201, 359,
2058  618, 199, 611, 120, 202, 267, 559, 727, 567, 561,
2059  276, 307, 423, 396, 786, 71, 365, 71, 724, 264,
2060  758, 266, 270, 587, 300, 742, 308, 86, 461, 86,
2061  199, 880, 463, 275, 307, 434, 276, 259, 618, 660,
2062  810, 218, 218, 319, 639, 218, 887, 768, 276, 276,
2063  276, 628, 601, 690, 570, 841, 692, 301, 938, 846,
2064  453, -105, 721, 454, 973, 449, 489, 685, 559, 199,
2065  567, 615, 943, -522, 941, -107, 86, 495, 234, 399,
2066  277, 3, 876, -514, 223, 223, -522, 233, 223, -101,
2067  240, 218, 234, 316, 696, 570, 631, -339, 250, -101,
2068  314, 315, 321, -102, 215, 225, 277, 892, 226, 686,
2069  -104, 655, -101, 218, 218, 490, -109, 218, 370, 381,
2070  381, 265, 269, 631, 642, 993, 496, 400, 58, -106,
2071  -108, -514, 882, -92, 656, 852, -104, 518, 316, -288,
2072  433, 888, 435, -288, -339, -339, 857, 254, 880, 318,
2073  900, 901, -105, 292, 849, 407, 944, -106, 409, 410,
2074  411, 585, 480, -103, 483, 586, 487, 856, 467, 455,
2075  487, 858, -96, 973, -605, 861, 304, 850, 305, 451,
2076  1026, 443, 304, 588, 305, 416, -98, 211, -606, 211,
2077  211, 416, 941, 217, 254, 217, 294, 307, 432, 317,
2078  -92, 618, 611, 611, 880, 887, 234, 296, 500, 501,
2079  502, 503, 452, 1049, -93, 464, 359, 359, 359, 359,
2080  423, 505, 506, 304, 660, 305, 619, -100, 950, 276,
2081  621, 86, 466, 631, 730, 624, 815, 740, -104, 259,
2082  -104, -99, 764, 967, 317, 631, 741, -95, 298, 961,
2083  230, 634, 218, 323, 218, 218, 968, -106, 218, -106,
2084  218, 574, 575, 880, 447, 86, 254, 986, -97, 359,
2085  359, -95, 819, 923, 514, 924, 86, -605, 86, 526,
2086  -105, 276, -105, -103, 584, 932, 328, 218, 576, 515,
2087  934, -103, -523, -103, 515, 223, 929, 223, 324, 277,
2088  999, 589, 404, 421, 520, 775, 307, 499, -602, 1009,
2089  660, 259, 660, 406, 513, 424, 211, 427, -102, 523,
2090  695, 71, 591, 304, 432, 305, 504, 233, 355, -109,
2091  565, 314, 315, 86, 218, 218, 218, 218, 86, 218,
2092  218, 304, 987, 305, 967, 446, -97, -73, 218, -513,
2093  86, 277, 851, 218, 984, 985, 408, 1036, 417, 680,
2094  990, -95, -434, 467, 608, 610, 680, 522, -87, -508,
2095  412, -108, 837, 267, 565, 356, 357, 329, 211, 474,
2096  474, 218, -95, 86, 414, -95, 432, 218, 218, -95,
2097  422, 860, 565, 862, -94, 602, 604, -513, 416, 416,
2098  766, 755, 218, 413, 625, 418, 419, 420, 610, 201,
2099  119, 267, 199, 467, -602, 202, -508, -508, 565, 1024,
2100  -602, 1025, 440, -434, 276, 475, 475, 476, 476, 218,
2101  218, 211, 352, 353, 354, 457, -97, 460, 765, 432,
2102  759, -515, 458, 218, 458, 565, 618, 1056, 611, 474,
2103  227, -294, 1047, 482, 1048, 71, 442, -97, 679, 682,
2104  -97, 703, 329, 693, -97, 329, -104, 86, -434, 710,
2105  -434, -434, 230, 1015, 276, 689, 689, 86, 450, 689,
2106  234, 645, 612, 646, 647, 648, 649, 700, 788, -515,
2107  791, -603, 444, -72, 277, 475, 218, 476, -294, -294,
2108  826, -609, -606, 743, 748, 706, 645, 834, 646, 647,
2109  648, 649, 718, 456, 720, -516, 723, 723, 350, 351,
2110  352, 353, 354, 462, -518, 637, 704, 840, 526, 577,
2111  735, -523, 767, 762, 711, 474, 465, 717, 469, 418,
2112  445, 211, 981, 726, 277, 859, 474, 484, 983, 432,
2113  755, 488, -511, 211, 497, 565, 474, -102, 491, 706,
2114  754, 432, -609, -516, 869, 872, 663, 565, 750, 751,
2115  494, 753, -518, 610, 267, 875, 201, 470, -93, 199,
2116  416, 475, 202, 476, 477, 760, 706, 807, 509, -517,
2117  994, 467, 475, 276, 476, 479, 86, -603, 86, -511,
2118  -511, 119, 475, -603, 476, 481, 218, -609, 827, -609,
2119  -609, -106, 811, -605, 650, 748, 867, 780, 218, -519,
2120  86, 218, -520, 864, 471, 472, 651, -508, 813, 577,
2121  812, 814, 853, 816, 521, 855, 783, -517, 783, -511,
2122  359, 498, -103, 359, 579, 818, 71, -521, 843, 840,
2123  583, 218, 276, 620, 654, 655, 622, 623, 86, 689,
2124  633, -284, 933, 277, 863, -87, 836, -519, 681, -520,
2125  -520, 631, 1042, 937, 706, -508, 854, 580, 656, 629,
2126  751, 515, 884, 839, 842, 706, 842, -511, 842, 523,
2127  761, 474, 822, 824, -521, -521, 683, 947, 949, 830,
2128  832, 592, 952, 638, 954, -295, 955, 885, -284, -284,
2129  405, 885, 86, -266, 694, 86, 697, 86, 474, 812,
2130  199, 698, 277, 218, 581, 582, 218, 218, 878, 416,
2131  963, -425, 804, 218, 218, 713, -109, 475, 1018, 476,
2132  485, 715, 922, 803, 812, 774, 446, 708, 593, 594,
2133  359, 663, -295, -295, 719, 744, 909, -100, 218, 276,
2134  763, 218, 86, 777, 475, 709, 476, 492, 911, 76,
2135  86, 76, -108, -104, 783, 783, 829, 593, 594, 802,
2136  778, 918, 781, 76, 76, 1019, 1020, 76, 925, 926,
2137  784, -106, 928, -99, -95, 723, 807, 931, 785, 436,
2138  965, 927, -103, 807, 935, 807, 917, 787, 789, 921,
2139  437, 438, -97, 790, 1030, 1032, 1033, 1034, 76, 267,
2140  913, 811, 792, -94, -267, 885, 821, 840, 811, 898,
2141  811, 828, 956, 76, 868, 329, 870, 663, 874, 663,
2142  86, 893, 894, 895, 886, 906, 899, 890, 902, 276,
2143  342, 343, 783, 904, 218, 76, 76, 907, 910, 76,
2144  982, 908, 774, 873, 915, 86, 1057, -268, 218, 919,
2145  276, 663, 86, 86, 942, 939, 86, 957, 946, 948,
2146  663, 962, 951, 953, 996, 997, 974, 349, 350, 351,
2147  352, 353, 354, 1002, -269, 645, 842, 646, 647, 648,
2148  649, 1017, 992, 1028, 807, 1003, 807, 1005, 1010, 794,
2149  795, 807, 796, 807, 1012, 1016, 86, 1027, 1029, 958,
2150  46, 47, 1021, 1031, 1022, 1052, -605, 329, -606, 811,
2151  1023, 811, 368, 783, 769, 385, 811, 635, 811, 835,
2152  977, 804, 342, 343, 86, 804, 799, 1046, 804, 871,
2153  804, 903, 905, 807, 1039, 86, 865, 1045, 493, 966,
2154  403, 969, 290, 397, 991, 774, 883, 774, 86, 86,
2155  964, 960, 645, 76, 646, 647, 648, 649, 811, 211,
2156  350, 351, 352, 353, 354, 881, 706, 432, 802, 717,
2157  842, 0, 598, 565, 76, 802, 76, 76, 0, 0,
2158  76, 0, 76, 998, 0, 1000, 86, 76, 86, 0,
2159  1001, 769, 0, 0, 86, 0, 86, 770, 76, 0,
2160  76, 0, 645, 0, 646, 647, 648, 649, 0, 76,
2161  0, 0, 774, 995, 41, 42, 43, 44, 970, 663,
2162  646, 647, 648, 649, 218, 0, 0, 0, 0, 804,
2163  0, 804, 0, 0, 0, 0, 804, 0, 804, 0,
2164  1035, 769, 1037, 0, 0, 0, 0, 940, 0, 1038,
2165  309, 310, 311, 312, 313, 76, 76, 76, 76, 76,
2166  76, 76, 76, 0, 0, 774, 0, 774, 1050, 0,
2167  76, 0, 76, 0, 0, 76, 802, 0, 804, 0,
2168  0, 0, 1004, 1006, 0, 0, 0, 0, 1011, 1058,
2169  1013, 1014, 0, 213, 213, 0, 0, 213, 0, 0,
2170  774, 0, 0, 76, 0, 76, 0, 0, 0, 76,
2171  76, 0, 0, 0, 0, 0, 0, 645, 0, 646,
2172  647, 648, 649, 650, 76, 247, 249, 0, 0, 0,
2173  213, 213, 0, 0, 0, 651, 0, 0, 0, 0,
2174  0, 0, 0, 302, 303, 0, 0, 0, 0, 0,
2175  0, 76, 76, 0, 0, 0, 652, 1051, 1053, 1054,
2176  1055, 0, 653, 654, 655, 76, 645, 0, 646, 647,
2177  648, 649, 650, 0, 0, 0, 0, 0, 0, 0,
2178  1059, 0, 0, 0, 651, 0, 0, 656, 0, 76,
2179  657, 0, 0, 0, 0, 0, 0, 0, 0, 76,
2180  0, 0, 0, 0, 0, 652, -627, 0, 234, 0,
2181  0, 653, 654, 655, -627, -627, -627, 0, 76, -627,
2182  -627, -627, 645, -627, 646, 647, 648, 649, 650, 0,
2183  0, 0, -627, -627, 0, 0, 656, 0, 0, 657,
2184  651, 0, 0, -627, -627, 0, -627, -627, -627, -627,
2185  -627, 0, 658, 0, 0, 0, 0, 0, 0, 0,
2186  0, 652, 0, 0, 0, 0, 0, 653, 654, 655,
2187  0, 0, 0, 113, 0, 113, 0, 0, 0, 0,
2188  0, 213, 0, 0, 213, 213, 213, 302, 0, 0,
2189  0, 0, 656, -627, 0, 657, 0, 0, 0, 0,
2190  0, 0, 0, 0, 213, 0, 213, 213, 0, 645,
2191  0, 646, 647, 648, 649, 650, -627, 0, 76, 0,
2192  76, 0, 113, 0, 0, 0, 278, 651, 76, 0,
2193  0, 0, 0, 0, 0, 329, 0, 0, -627, -627,
2194  76, -627, 76, 76, 230, -627, 0, -627, 652, -627,
2195  342, 343, 278, 0, 0, 654, 655, 0, 0, 0,
2196  0, 0, 0, 0, 372, 382, 382, 382, 0, 0,
2197  0, 0, 0, 76, 0, 0, 0, 0, 0, 656,
2198  76, 0, 0, 0, 0, 347, 348, 349, 350, 351,
2199  352, 353, 354, 0, 0, 0, 0, 0, 0, 0,
2200  213, 0, 0, 0, 0, 525, 528, 529, 530, 531,
2201  532, 533, 534, 535, 536, 537, 538, 539, 540, 541,
2202  542, 543, 544, 545, 546, 547, 548, 549, 550, 551,
2203  552, 553, 0, 213, 76, 0, 0, 76, 0, 76,
2204  0, 0, 0, 0, 0, 76, 0, 0, 76, 76,
2205  0, 0, 0, 0, 0, 76, 76, 0, 0, 0,
2206  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2207  0, 0, 0, 0, 0, 0, 114, 113, 114, 0,
2208  76, 603, 605, 76, 76, 0, 0, 0, 0, 607,
2209  213, 213, 76, 0, 0, 213, 0, 603, 605, 213,
2210  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2211  0, 113, 0, 0, 0, 0, 0, 0, 627, 0,
2212  0, 0, 113, 632, 113, 114, 0, 0, 0, 279,
2213  0, 0, 0, 0, 213, 0, 0, 213, 0, 0,
2214  0, 0, 0, 0, 0, 278, 0, 0, 213, 0,
2215  0, 0, 0, 0, 0, 279, 117, 0, 117, 0,
2216  0, 0, 76, 0, 0, 0, 0, 373, 383, 383,
2217  383, 0, 0, 0, 684, 0, 76, 0, 0, 113,
2218  0, 0, 0, 0, 113, 0, 0, 76, 0, 213,
2219  76, 0, 0, 0, 76, 76, 113, 278, 76, 0,
2220  0, 0, 0, 0, 0, 117, 0, 0, 0, 280,
2221  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2222  0, 0, 0, 0, 0, 0, 0, 0, 0, 113,
2223  0, 0, 0, 0, 0, 280, 0, 0, 76, 0,
2224  0, 0, 0, 0, 0, 0, 0, 374, 384, 384,
2225  0, 0, 0, 0, 213, 0, 0, 0, 213, 0,
2226  0, 0, 0, 0, 0, 0, 76, 0, 0, 0,
2227  213, 0, 0, 0, 0, 0, 0, 76, 0, 0,
2228  114, 0, 0, 0, 0, 0, 213, 0, 0, 0,
2229  76, 76, 0, 0, 0, 0, 0, 0, 0, 213,
2230  213, 329, 330, 331, 332, 333, 334, 335, 336, 0,
2231  338, 339, 0, 113, 114, 0, 342, 343, 0, 0,
2232  0, 0, 0, 113, 0, 114, 0, 114, 76, 0,
2233  76, 0, 0, 0, 0, 83, 76, 83, 76, 0,
2234  278, 0, 0, 213, 0, 0, 0, 0, 279, 345,
2235  346, 347, 348, 349, 350, 351, 352, 353, 354, 0,
2236  117, 0, 0, 0, 0, 0, 76, 0, 0, 0,
2237  0, 213, 0, 0, 0, 607, 820, 0, 823, 825,
2238  0, 0, 114, 0, 83, 831, 833, 114, 0, 0,
2239  278, 0, 213, 0, 117, 0, 0, 0, 0, 114,
2240  279, 0, 0, 0, 0, 117, 0, 117, 0, 0,
2241  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2242  0, 0, 0, 0, 0, 0, 369, 0, 280, 866,
2243  0, 0, 114, 823, 825, 0, 831, 833, 0, 0,
2244  0, 0, 113, 0, 113, 0, 0, 0, 0, 0,
2245  0, 0, 0, 0, 213, 0, 0, 0, 0, 0,
2246  0, 0, 117, 0, 0, 0, 113, 117, 0, 0,
2247  0, 0, 0, 0, 0, 0, 0, 0, 0, 117,
2248  280, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2249  0, 0, 0, 0, 213, 0, 0, 116, 912, 116,
2250  0, 0, 0, 0, 113, 0, 914, 0, 0, 278,
2251  0, 0, 117, 0, 0, 0, 114, 0, 0, 0,
2252  0, 0, 0, 0, 0, 0, 114, 213, 0, 0,
2253  0, 0, 0, 0, 0, 0, 0, 0, 0, 83,
2254  0, 0, 0, 279, 914, 213, 116, 0, 0, 0,
2255  0, 0, 0, 0, 0, 0, 0, 0, 113, 0,
2256  0, 113, 0, 113, 0, 0, 0, 0, 278, 0,
2257  0, 0, 0, 83, 0, 0, 0, 0, 0, 0,
2258  0, 0, 0, 0, 83, 0, 83, 0, 0, 0,
2259  0, 0, 0, 279, 0, 0, 117, 0, 0, 0,
2260  0, 0, 699, 0, 0, 0, 117, 0, 113, 0,
2261  0, 0, 0, 0, 0, 0, 113, 0, 0, 0,
2262  0, 0, 0, 280, 0, 0, 0, 0, 329, 330,
2263  331, 332, 333, 334, 335, 336, 337, 338, 339, 340,
2264  341, 83, 0, 342, 343, 114, 83, 114, 0, 0,
2265  0, 0, 0, 0, 0, 0, 0, 0, 83, 0,
2266  0, 524, 0, 0, 0, 0, 0, 0, 0, 114,
2267  0, 0, 0, 280, 344, 382, 345, 346, 347, 348,
2268  349, 350, 351, 352, 353, 354, 113, 0, 0, 0,
2269  0, 83, 0, 0, -243, 0, 213, 0, 0, 0,
2270  0, 116, 0, 0, 0, 0, 0, 114, 0, 0,
2271  0, 113, 279, 0, 0, 0, 0, 0, 113, 113,
2272  0, 0, 113, 0, 0, 117, 0, 117, 0, 0,
2273  0, 0, 0, 0, 0, 116, 0, 0, 0, 0,
2274  0, 0, 0, 0, 0, 0, 116, 0, 116, 117,
2275  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2276  0, 114, 113, 0, 114, 382, 114, 0, 0, 0,
2277  0, 279, 0, 0, 0, 83, 0, 0, 0, 0,
2278  0, 0, 0, 0, 0, 83, 978, 117, 0, 0,
2279  113, 0, 280, 0, 0, 0, 0, 0, 0, 0,
2280  0, 113, 0, 116, 0, 0, 0, 0, 116, 0,
2281  0, 114, 0, 0, 113, 113, 0, 0, 0, 114,
2282  116, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2283  0, 0, 798, 0, 0, 0, 0, 0, 0, 0,
2284  0, 117, 0, 0, 117, 0, 117, 0, 0, 0,
2285  0, 280, 113, 116, 113, 0, 0, 0, 0, 0,
2286  113, 0, 113, 0, 0, 0, 0, 0, 0, 0,
2287  0, 0, 0, 0, 0, 0, 0, 0, 383, 0,
2288  0, 0, 0, 0, 0, 0, 0, 0, 0, 114,
2289  0, 117, 0, 0, 0, 0, 0, 0, 0, 117,
2290  0, 0, 0, 0, 83, 0, 83, 0, 0, 0,
2291  0, 0, 0, 0, 114, 0, 0, 0, 0, 0,
2292  0, 114, 114, 0, 0, 114, 0, 0, 83, 329,
2293  -628, -628, -628, -628, 334, 335, 0, 116, -628, -628,
2294  0, 0, 0, 0, 342, 343, 0, 116, 0, 0,
2295  0, 0, 0, 0, 0, 0, 0, 0, 384, 0,
2296  0, 0, 0, 0, 0, 114, 83, 0, 383, 117,
2297  0, 0, 0, 0, 0, 0, 0, 345, 346, 347,
2298  348, 349, 350, 351, 352, 353, 354, 0, 0, 979,
2299  0, 0, 0, 114, 117, 0, 0, 0, 0, 0,
2300  0, 117, 117, 0, 114, 117, 0, 0, 0, 0,
2301  0, 0, 0, 0, 0, 0, 0, 114, 114, 0,
2302  83, 0, 0, 83, 0, 83, 0, 0, 0, 0,
2303  0, 524, 0, 0, 0, 0, 0, 0, 0, 0,
2304  0, 0, 0, 0, 0, 117, 0, 0, 384, 0,
2305  0, 0, 0, 0, 0, 114, 0, 114, 0, 0,
2306  0, 0, 0, 114, 0, 114, 116, 0, 116, 980,
2307  83, 0, 0, 117, 0, 0, 0, 0, 83, -609,
2308  0, 0, 0, 0, 117, 0, 0, -609, -609, -609,
2309  116, 0, -609, -609, -609, 0, -609, 117, 117, 0,
2310  0, 0, 0, 0, 0, -609, -609, -609, -609, 0,
2311  0, 0, 0, 0, 0, 0, -609, -609, 0, -609,
2312  -609, -609, -609, -609, 0, 0, 0, 0, 116, 0,
2313  0, 0, 0, 0, 0, 117, 0, 117, 0, 0,
2314  0, 0, 0, 117, 0, 117, 0, 0, 83, -609,
2315  -609, -609, -609, -609, -609, -609, -609, -609, -609, -609,
2316  -609, -609, 0, 0, -609, -609, -609, 0, 756, -609,
2317  0, 0, 0, 83, 0, -609, 0, 0, 0, 0,
2318  83, 83, 116, 0, 83, 116, 0, 116, 0, -609,
2319  0, 0, -609, 0, -105, -609, -609, -609, -609, -609,
2320  -609, -609, -609, -609, -609, -609, -609, 0, 0, 0,
2321  0, -609, -609, -609, -609, -609, 0, 0, -609, -609,
2322  -609, 0, -609, 0, 83, 0, 0, 0, 0, 0,
2323  0, 0, 116, 0, 0, 0, 0, 0, 0, 0,
2324  116, 329, 330, 331, 332, 333, 334, 335, 976, 0,
2325  338, 339, 83, 0, 0, 0, 342, 343, 0, 0,
2326  0, 0, 0, 83, 0, 0, 0, 0, 0, 0,
2327  0, 0, 0, 0, 0, 0, 83, 83, 0, 0,
2328  0, 0, 0, 0, 0, 0, 0, 0, 0, 345,
2329  346, 347, 348, 349, 350, 351, 352, 353, 354, 0,
2330  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2331  116, 0, 0, 0, 83, 0, 83, 0, 0, 0,
2332  0, 0, 83, 0, 83, 0, 0, 0, 0, 0,
2333  0, 0, 0, 0, 0, 116, 0, 0, 0, 0,
2334  0, 0, 116, 116, 0, 0, 116, 0, 0, 0,
2335  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2336  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2337  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2338  0, 0, 0, 0, 0, 0, 116, 0, 0, 0,
2339  0, 0, 0, 0, 0, 0, 0, -627, 4, 0,
2340  5, 6, 7, 8, 9, 0, 0, 0, 10, 11,
2341  0, 0, 0, 12, 116, 13, 14, 15, 16, 17,
2342  18, 19, 0, 0, 0, 116, 0, 20, 21, 22,
2343  23, 24, 25, 26, 0, 0, 27, 0, 116, 116,
2344  0, 0, 28, 29, 30, 31, 32, 33, 34, 35,
2345  36, 37, 38, 39, 40, 0, 41, 42, 43, 44,
2346  0, 45, 46, 47, 0, 48, 49, 0, 0, 0,
2347  0, 0, 0, 0, 0, 0, 116, 0, 116, 0,
2348  0, 0, 0, 0, 116, 50, 116, 0, 51, 52,
2349  0, 53, 54, 0, 55, 0, 0, 56, 57, 58,
2350  59, 60, 61, 62, 63, 64, -508, 0, 0, 0,
2351  0, 0, 0, 0, -508, -508, -508, 0, 0, -508,
2352  -508, -508, 0, -508, 0, 65, 66, 67, 0, 752,
2353  0, -508, 0, -508, -508, -508, 0, 0, -627, 0,
2354  -627, 0, 0, -508, -508, 0, -508, -508, -508, -508,
2355  -508, 0, 0, 0, 0, 329, 330, 331, 332, 333,
2356  334, 335, 336, 337, 338, 339, 340, 341, 0, 0,
2357  342, 343, 0, 0, 0, 0, -508, -508, -508, -508,
2358  -508, -508, -508, -508, -508, -508, -508, -508, -508, 0,
2359  0, -508, -508, -508, 0, -508, -508, 0, 0, 0,
2360  0, 344, -508, 345, 346, 347, 348, 349, 350, 351,
2361  352, 353, 354, 0, 0, 0, -508, 0, 0, -508,
2362  0, -508, -508, -508, -508, -508, -508, -508, -508, -508,
2363  -508, -508, -508, -508, 0, 0, 0, 0, 0, -508,
2364  -508, -508, -508, -511, 0, -508, -508, -508, 0, -508,
2365  0, -511, -511, -511, 0, 0, -511, -511, -511, 0,
2366  -511, 0, 0, 0, 0, 0, 699, 0, -511, 0,
2367  -511, -511, -511, 0, 0, 0, 0, 0, 0, 0,
2368  -511, -511, 0, -511, -511, -511, -511, -511, 0, 0,
2369  0, 0, 329, 330, 331, 332, 333, 334, 335, 336,
2370  337, 338, 339, 340, 341, 0, 0, 342, 343, 0,
2371  0, 0, 0, -511, -511, -511, -511, -511, -511, -511,
2372  -511, -511, -511, -511, -511, -511, 0, 0, -511, -511,
2373  -511, 0, -511, -511, 0, 0, 0, 0, 344, -511,
2374  345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
2375  0, 0, 0, -511, 0, 0, -511, 0, -511, -511,
2376  -511, -511, -511, -511, -511, -511, -511, -511, -511, -511,
2377  -511, 0, 0, 0, 0, 0, -511, -511, -511, -511,
2378  -610, 0, -511, -511, -511, 0, -511, 0, -610, -610,
2379  -610, 0, 0, -610, -610, -610, 0, -610, 0, 0,
2380  0, 0, 0, 0, 0, 0, -610, -610, -610, -610,
2381  0, 0, 0, 0, 0, 0, 0, -610, -610, 0,
2382  -610, -610, -610, -610, -610, 0, 0, 0, 0, 329,
2383  330, 331, 332, 333, 334, 335, 336, 337, 338, 339,
2384  340, 341, 0, 0, 342, 343, 0, 0, 0, 0,
2385  -610, -610, -610, -610, -610, -610, -610, -610, -610, -610,
2386  -610, -610, -610, 0, 0, -610, -610, -610, 0, 0,
2387  -610, 0, 0, 0, 0, 344, -610, 345, 346, 347,
2388  348, 349, 350, 351, 352, 353, 354, 0, 0, 0,
2389  -610, 0, 0, -610, 0, 0, -610, -610, -610, -610,
2390  -610, -610, -610, -610, -610, -610, -610, -610, 0, 0,
2391  0, 0, -610, -610, -610, -610, -610, -611, 0, -610,
2392  -610, -610, 0, -610, 0, -611, -611, -611, 0, 0,
2393  -611, -611, -611, 0, -611, 0, 0, 0, 0, 0,
2394  0, 0, 0, -611, -611, -611, -611, 0, 0, 0,
2395  0, 0, 0, 0, -611, -611, 0, -611, -611, -611,
2396  -611, -611, 0, 0, 0, 0, 329, 330, 331, 332,
2397  333, 334, 335, 336, 337, 338, 339, -628, -628, 0,
2398  0, 342, 343, 0, 0, 0, 0, -611, -611, -611,
2399  -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
2400  0, 0, -611, -611, -611, 0, 0, -611, 0, 0,
2401  0, 0, 0, -611, 345, 346, 347, 348, 349, 350,
2402  351, 352, 353, 354, 0, 0, 0, -611, 0, 0,
2403  -611, 0, 0, -611, -611, -611, -611, -611, -611, -611,
2404  -611, -611, -611, -611, -611, 0, 0, 0, 0, -611,
2405  -611, -611, -611, -611, -294, 0, -611, -611, -611, 0,
2406  -611, 0, -294, -294, -294, 0, 0, -294, -294, -294,
2407  0, -294, 0, 0, 0, 0, 0, 0, 0, 0,
2408  0, -294, -294, -294, 0, 0, 0, 0, 0, 0,
2409  0, -294, -294, 0, -294, -294, -294, -294, -294, 0,
2410  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2411  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2412  0, 0, 0, 0, -294, -294, -294, -294, -294, -294,
2413  -294, -294, -294, -294, -294, -294, -294, 0, 0, -294,
2414  -294, -294, 0, 757, -294, 0, 0, 0, 0, 0,
2415  -294, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2416  0, 0, 0, 0, -294, 0, 0, -294, 0, -107,
2417  -294, -294, -294, -294, -294, -294, -294, -294, -294, -294,
2418  -294, -294, 0, 0, 0, 0, 0, -294, -294, -294,
2419  -294, -433, 0, -294, -294, -294, 0, -294, 0, -433,
2420  -433, -433, 0, 0, -433, -433, -433, 0, -433, 0,
2421  0, 0, 0, 0, 0, 0, 0, -433, -433, -433,
2422  0, 0, 0, 0, 0, 0, 0, 0, -433, -433,
2423  0, -433, -433, -433, -433, -433, 0, 0, 0, 0,
2424  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2425  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2426  0, -433, -433, -433, -433, -433, -433, -433, -433, -433,
2427  -433, -433, -433, -433, 0, 0, -433, -433, -433, 0,
2428  0, -433, 0, 0, 0, 0, 0, -433, 0, 0,
2429  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2430  0, -433, 0, 0, 0, 0, 0, -433, 0, -433,
2431  -433, -433, -433, -433, -433, -433, -433, -433, -433, 0,
2432  0, 0, 0, -433, -433, -433, -433, -433, -285, 230,
2433  -433, -433, -433, 0, -433, 0, -285, -285, -285, 0,
2434  0, -285, -285, -285, 0, -285, 0, 0, 0, 0,
2435  0, 0, 0, 0, 0, -285, -285, -285, 0, 0,
2436  0, 0, 0, 0, 0, -285, -285, 0, -285, -285,
2437  -285, -285, -285, 0, 0, 0, 0, 0, 0, 0,
2438  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2439  0, 0, 0, 0, 0, 0, 0, 0, -285, -285,
2440  -285, -285, -285, -285, -285, -285, -285, -285, -285, -285,
2441  -285, 0, 0, -285, -285, -285, 0, 0, -285, 0,
2442  0, 0, 0, 0, -285, 0, 0, 0, 0, 0,
2443  0, 0, 0, 0, 0, 0, 0, 0, -285, 0,
2444  0, -285, 0, 0, -285, -285, -285, -285, -285, -285,
2445  -285, -285, -285, -285, -285, -285, 0, 0, 0, 0,
2446  0, -285, -285, -285, -285, -423, 0, -285, -285, -285,
2447  0, -285, 0, -423, -423, -423, 0, 0, -423, -423,
2448  -423, 0, -423, 0, 0, 0, 0, 0, 0, 0,
2449  0, -423, -423, -423, 0, 0, 0, 0, 0, 0,
2450  0, 0, -423, -423, 0, -423, -423, -423, -423, -423,
2451  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2452  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2453  0, 0, 0, 0, 0, -423, -423, -423, -423, -423,
2454  -423, -423, -423, -423, -423, -423, -423, -423, 0, 0,
2455  -423, -423, -423, 0, 0, -423, 0, 0, 0, 0,
2456  0, -423, 0, 0, 0, 0, 0, 0, 0, 0,
2457  0, 0, 0, 0, 0, -423, 0, 0, 0, 0,
2458  0, -423, 0, -423, -423, -423, -423, -423, -423, -423,
2459  -423, -423, -423, 0, 0, 0, 0, -423, -423, -423,
2460  -423, -423, -301, -423, -423, -423, -423, 0, -423, 0,
2461  -301, -301, -301, 0, 0, -301, -301, -301, 0, -301,
2462  0, 0, 0, 0, 0, 0, 0, 0, 0, -301,
2463  -301, 0, 0, 0, 0, 0, 0, 0, 0, -301,
2464  -301, 0, -301, -301, -301, -301, -301, 0, 0, 0,
2465  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2466  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2467  0, 0, -301, -301, -301, -301, -301, -301, -301, -301,
2468  -301, -301, -301, -301, -301, 0, 0, -301, -301, -301,
2469  0, 0, -301, 0, 0, 0, 0, 0, -301, 0,
2470  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2471  0, 0, -301, 0, 0, 0, 0, 0, -301, 0,
2472  -301, -301, -301, -301, -301, -301, -301, -301, -301, -301,
2473  0, 0, 0, 0, 0, -301, -301, -301, -301, -609,
2474  227, -301, -301, -301, 0, -301, 0, -609, -609, -609,
2475  0, 0, 0, -609, -609, 0, -609, 0, 0, 0,
2476  0, 0, 0, 0, 0, -609, 0, 0, 0, 0,
2477  0, 0, 0, 0, 0, 0, -609, -609, 0, -609,
2478  -609, -609, -609, -609, 0, 0, 0, 0, 0, 0,
2479  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2480  0, 0, 0, 0, 0, 0, 0, 0, 0, -609,
2481  -609, -609, -609, -609, -609, -609, -609, -609, -609, -609,
2482  -609, -609, 0, 0, -609, -609, -609, 0, 701, 0,
2483  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2484  0, 0, 0, 0, 0, 0, 0, 0, 0, -609,
2485  0, 0, 0, 0, -105, -609, 0, -609, -609, -609,
2486  -609, -609, -609, -609, -609, -609, -609, 0, 0, 0,
2487  0, -609, -609, -609, -609, -96, -294, 0, -609, 0,
2488  -609, 0, -609, 0, -294, -294, -294, 0, 0, 0,
2489  -294, -294, 0, -294, 0, 0, 0, 0, 0, 0,
2490  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2491  0, 0, 0, -294, -294, 0, -294, -294, -294, -294,
2492  -294, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2493  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2494  0, 0, 0, 0, 0, 0, -294, -294, -294, -294,
2495  -294, -294, -294, -294, -294, -294, -294, -294, -294, 0,
2496  0, -294, -294, -294, 0, 702, 0, 0, 0, 0,
2497  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2498  0, 0, 0, 0, 0, 0, -294, 0, 0, 0,
2499  0, -107, -294, 0, -294, -294, -294, -294, -294, -294,
2500  -294, -294, -294, -294, 0, 0, 0, 0, 0, -294,
2501  -294, -294, -98, 0, 0, -294, 0, -294, 251, -294,
2502  5, 6, 7, 8, 9, -627, -627, -627, 10, 11,
2503  0, 0, -627, 12, 0, 13, 14, 15, 16, 17,
2504  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2505  23, 24, 25, 26, 0, 0, 27, 0, 0, 0,
2506  0, 0, 28, 29, 252, 31, 32, 33, 34, 35,
2507  36, 37, 38, 39, 40, 0, 41, 42, 43, 44,
2508  0, 45, 46, 47, 0, 48, 49, 0, 0, 0,
2509  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2510  0, 0, 0, 0, 0, 50, 0, 0, 51, 52,
2511  0, 53, 54, 0, 55, 0, 0, 56, 57, 58,
2512  59, 60, 61, 62, 63, 64, 0, 0, 0, 0,
2513  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2514  0, 0, 0, 0, 0, 65, 66, 67, 0, 0,
2515  0, 0, 0, 0, 0, 0, 0, 0, -627, 251,
2516  -627, 5, 6, 7, 8, 9, 0, 0, -627, 10,
2517  11, 0, -627, -627, 12, 0, 13, 14, 15, 16,
2518  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2519  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2520  0, 0, 0, 28, 29, 252, 31, 32, 33, 34,
2521  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
2522  44, 0, 45, 46, 47, 0, 48, 49, 0, 0,
2523  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2524  0, 0, 0, 0, 0, 0, 50, 0, 0, 51,
2525  52, 0, 53, 54, 0, 55, 0, 0, 56, 57,
2526  58, 59, 60, 61, 62, 63, 64, 0, 0, 0,
2527  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2528  0, 0, 0, 0, 0, 0, 65, 66, 67, 0,
2529  0, 0, 0, 0, 0, 0, 0, 0, 0, -627,
2530  251, -627, 5, 6, 7, 8, 9, 0, 0, -627,
2531  10, 11, 0, 0, -627, 12, -627, 13, 14, 15,
2532  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2533  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2534  0, 0, 0, 0, 28, 29, 252, 31, 32, 33,
2535  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2536  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2537  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2538  0, 0, 0, 0, 0, 0, 0, 50, 0, 0,
2539  51, 52, 0, 53, 54, 0, 55, 0, 0, 56,
2540  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2541  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2542  0, 0, 0, 0, 0, 0, 0, 65, 66, 67,
2543  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2544  -627, 251, -627, 5, 6, 7, 8, 9, 0, 0,
2545  -627, 10, 11, 0, 0, -627, 12, 0, 13, 14,
2546  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2547  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2548  0, 0, 0, 0, 0, 28, 29, 252, 31, 32,
2549  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2550  42, 43, 44, 0, 45, 46, 47, 0, 48, 49,
2551  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2552  0, 0, 0, 0, 0, 0, 0, 0, 50, 0,
2553  0, 51, 52, 0, 53, 54, 0, 55, 0, 0,
2554  56, 57, 58, 59, 60, 61, 62, 63, 64, 0,
2555  0, 0, 0, 0, 0, 0, 251, 0, 5, 6,
2556  7, 8, 9, 0, -627, -627, 10, 11, 65, 66,
2557  67, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2558  0, -627, 0, -627, 0, 20, 21, 22, 23, 24,
2559  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2560  28, 29, 252, 31, 32, 33, 34, 35, 36, 37,
2561  38, 39, 40, 0, 41, 42, 43, 44, 0, 45,
2562  46, 47, 0, 48, 49, 0, 0, 0, 0, 0,
2563  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2564  0, 0, 0, 50, 0, 0, 51, 52, 0, 53,
2565  54, 0, 55, 0, 0, 56, 57, 58, 59, 60,
2566  61, 62, 63, 64, 0, 0, 0, 0, 0, 0,
2567  0, 251, 0, 5, 6, 7, 8, 9, 0, 0,
2568  0, 10, 11, 65, 66, 67, 12, 0, 13, 14,
2569  15, 16, 17, 18, 19, 0, -627, 0, -627, 0,
2570  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2571  0, 0, 0, 0, 0, 28, 29, 252, 31, 32,
2572  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2573  42, 43, 44, 0, 45, 46, 47, 0, 48, 49,
2574  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2575  0, 0, 0, 0, 0, 0, 0, 0, 50, 0,
2576  0, 253, 52, 0, 53, 54, 0, 55, 0, 0,
2577  56, 57, 58, 59, 60, 61, 62, 63, 64, 0,
2578  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2579  0, 0, 0, 0, 0, 0, 0, 0, 65, 66,
2580  67, 0, 0, 0, 0, 0, 0, 0, 0, -627,
2581  0, -627, 251, -627, 5, 6, 7, 8, 9, 0,
2582  0, 0, 10, 11, 0, 0, 0, 12, 0, 13,
2583  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2584  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2585  27, 0, 0, 0, 0, 0, 28, 29, 252, 31,
2586  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2587  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2588  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2589  0, 0, 0, 0, 0, 0, 0, 0, 0, 50,
2590  0, 0, 51, 52, 0, 53, 54, 0, 55, 0,
2591  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2592  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2593  0, 0, 0, 0, 0, 0, 0, 0, 0, 65,
2594  66, 67, 0, 0, 0, 0, 0, 0, 0, 0,
2595  -627, 0, -627, 251, -627, 5, 6, 7, 8, 9,
2596  0, 0, 0, 10, 11, 0, 0, 0, 12, 0,
2597  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2598  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2599  0, 27, 0, 0, 0, 0, 0, 28, 29, 252,
2600  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2601  0, 41, 42, 43, 44, 0, 45, 46, 47, 0,
2602  48, 49, 0, 0, 0, 0, 0, 0, 0, 0,
2603  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2604  50, 0, 0, 51, 52, 0, 53, 54, 0, 55,
2605  0, 0, 56, 57, 58, 59, 60, 61, 62, 63,
2606  64, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2607  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2608  65, 66, 67, 0, 0, -627, 4, 0, 5, 6,
2609  7, 8, 9, -627, 0, -627, 10, 11, 0, 0,
2610  0, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2611  0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2612  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2613  28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
2614  38, 39, 40, 0, 41, 42, 43, 44, 0, 45,
2615  46, 47, 0, 48, 49, 0, 0, 0, 0, 0,
2616  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2617  0, 0, 0, 50, 0, 0, 51, 52, 0, 53,
2618  54, 0, 55, 0, 0, 56, 57, 58, 59, 60,
2619  61, 62, 63, 64, 0, 0, 0, 0, 0, 0,
2620  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2621  0, 0, 0, 65, 66, 67, 0, 0, -627, 0,
2622  0, 0, 0, 0, 0, 0, -627, 251, -627, 5,
2623  6, 7, 8, 9, 0, 0, -627, 10, 11, 0,
2624  0, 0, 12, 0, 13, 14, 15, 16, 17, 18,
2625  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2626  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2627  0, 28, 29, 252, 31, 32, 33, 34, 35, 36,
2628  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2629  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2630  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2631  0, 0, 0, 0, 50, 0, 0, 51, 52, 0,
2632  53, 54, 0, 55, 0, 0, 56, 57, 58, 59,
2633  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2634  0, 0, 251, 0, 5, 6, 7, 8, 9, 0,
2635  0, 0, 10, 11, 65, 66, 67, 12, 0, 13,
2636  14, 15, 16, 17, 18, 19, 0, -627, 0, -627,
2637  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2638  27, 0, 0, 0, 0, 0, 28, 29, 252, 31,
2639  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2640  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2641  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2642  0, 0, 0, 0, 0, 0, 0, 0, 0, 50,
2643  0, 0, 51, 52, 0, 53, 54, 0, 55, 0,
2644  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2645  0, -627, 0, 0, 0, 0, 0, 0, 0, 5,
2646  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2647  66, 67, 12, 0, 13, 14, 15, 16, 17, 18,
2648  19, 0, -627, 0, -627, 0, 20, 21, 22, 23,
2649  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2650  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2651  37, 38, 39, 40, 204, 41, 42, 43, 44, 0,
2652  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2653  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2654  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2655  53, 54, 0, 207, 208, 209, 56, 57, 58, 59,
2656  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2657  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2658  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2659  14, 15, 16, 17, 18, 19, 0, 0, 0, 234,
2660  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2661  27, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2662  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2663  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2664  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2665  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2666  0, 0, 206, 52, 0, 53, 54, 0, 0, 0,
2667  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2668  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2669  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2670  66, 67, 12, 0, 13, 14, 15, 16, 17, 18,
2671  19, 0, 304, 0, 305, 0, 20, 21, 22, 23,
2672  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2673  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2674  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2675  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2676  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2677  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2678  53, 54, 0, 0, 0, 0, 56, 57, 58, 59,
2679  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2680  0, 0, 0, 0, 5, 6, 7, 8, 9, 0,
2681  0, 0, 10, 11, 65, 66, 67, 12, 0, 13,
2682  14, 15, 16, 17, 18, 19, 0, 0, 0, 234,
2683  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2684  27, 0, 0, 0, 0, 0, 28, 29, 30, 31,
2685  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2686  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2687  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2688  0, 0, 0, 0, 0, 0, 0, 0, 0, 50,
2689  0, 0, 51, 52, 0, 53, 54, 0, 55, 0,
2690  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2691  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2692  6, 7, 8, 9, 0, 0, 0, 10, 11, 65,
2693  66, 67, 12, 0, 13, 14, 15, 16, 17, 18,
2694  19, 0, 498, 0, 0, 0, 20, 21, 22, 23,
2695  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2696  0, 28, 29, 252, 31, 32, 33, 34, 35, 36,
2697  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2698  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2699  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2700  0, 0, 0, 0, 50, 0, 0, 51, 52, 0,
2701  53, 54, 0, 55, 0, 0, 56, 57, 58, 59,
2702  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2703  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2704  0, 0, 0, 0, 65, 66, 67, 0, 0, 0,
2705  0, 0, 0, 0, 0, 0, 0, 498, 121, 122,
2706  123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
2707  133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
2708  143, 144, 0, 0, 0, 145, 146, 147, 386, 387,
2709  388, 389, 152, 153, 154, 0, 0, 0, 0, 0,
2710  155, 156, 157, 158, 390, 391, 392, 393, 163, 37,
2711  38, 394, 40, 0, 0, 0, 0, 0, 0, 0,
2712  0, 0, 0, 165, 166, 167, 168, 169, 170, 171,
2713  172, 173, 0, 0, 174, 175, 0, 0, 176, 177,
2714  178, 179, 0, 0, 0, 0, 0, 0, 0, 0,
2715  0, 0, 180, 181, 0, 0, 0, 0, 0, 0,
2716  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2717  0, 0, 0, 182, 183, 184, 185, 186, 187, 188,
2718  189, 190, 191, 0, 192, 193, 0, 0, 0, 0,
2719  0, 0, 194, 395, 121, 122, 123, 124, 125, 126,
2720  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
2721  137, 138, 139, 140, 141, 142, 143, 144, 0, 0,
2722  0, 145, 146, 147, 148, 149, 150, 151, 152, 153,
2723  154, 0, 0, 0, 0, 0, 155, 156, 157, 158,
2724  159, 160, 161, 162, 163, 283, 284, 164, 285, 0,
2725  0, 0, 0, 0, 0, 0, 0, 0, 0, 165,
2726  166, 167, 168, 169, 170, 171, 172, 173, 0, 0,
2727  174, 175, 0, 0, 176, 177, 178, 179, 0, 0,
2728  0, 0, 0, 0, 0, 0, 0, 0, 180, 181,
2729  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2730  0, 0, 0, 0, 0, 0, 0, 0, 0, 182,
2731  183, 184, 185, 186, 187, 188, 189, 190, 191, 0,
2732  192, 193, 0, 0, 0, 0, 0, 0, 194, 121,
2733  122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
2734  132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
2735  142, 143, 144, 0, 0, 0, 145, 146, 147, 148,
2736  149, 150, 151, 152, 153, 154, 0, 0, 0, 0,
2737  0, 155, 156, 157, 158, 159, 160, 161, 162, 163,
2738  236, 0, 164, 0, 0, 0, 0, 0, 0, 0,
2739  0, 0, 0, 0, 165, 166, 167, 168, 169, 170,
2740  171, 172, 173, 0, 0, 174, 175, 0, 0, 176,
2741  177, 178, 179, 0, 0, 0, 0, 0, 0, 0,
2742  0, 0, 0, 180, 181, 0, 0, 57, 0, 0,
2743  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2744  0, 0, 0, 0, 182, 183, 184, 185, 186, 187,
2745  188, 189, 190, 191, 0, 192, 193, 0, 0, 0,
2746  0, 0, 0, 194, 121, 122, 123, 124, 125, 126,
2747  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
2748  137, 138, 139, 140, 141, 142, 143, 144, 0, 0,
2749  0, 145, 146, 147, 148, 149, 150, 151, 152, 153,
2750  154, 0, 0, 0, 0, 0, 155, 156, 157, 158,
2751  159, 160, 161, 162, 163, 0, 0, 164, 0, 0,
2752  0, 0, 0, 0, 0, 0, 0, 0, 0, 165,
2753  166, 167, 168, 169, 170, 171, 172, 173, 0, 0,
2754  174, 175, 0, 0, 176, 177, 178, 179, 0, 0,
2755  0, 0, 0, 0, 0, 0, 0, 0, 180, 181,
2756  0, 0, 57, 0, 0, 0, 0, 0, 0, 0,
2757  0, 0, 0, 0, 0, 0, 0, 0, 0, 182,
2758  183, 184, 185, 186, 187, 188, 189, 190, 191, 0,
2759  192, 193, 0, 0, 0, 0, 0, 0, 194, 121,
2760  122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
2761  132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
2762  142, 143, 144, 0, 0, 0, 145, 146, 147, 148,
2763  149, 150, 151, 152, 153, 154, 0, 0, 0, 0,
2764  0, 155, 156, 157, 158, 159, 160, 161, 162, 163,
2765  0, 0, 164, 0, 0, 0, 0, 0, 0, 0,
2766  0, 0, 0, 0, 165, 166, 167, 168, 169, 170,
2767  171, 172, 173, 0, 0, 174, 175, 0, 0, 176,
2768  177, 178, 179, 0, 0, 0, 0, 0, 0, 0,
2769  0, 0, 0, 180, 181, 0, 0, 0, 0, 0,
2770  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2771  0, 0, 0, 0, 182, 183, 184, 185, 186, 187,
2772  188, 189, 190, 191, 0, 192, 193, 5, 6, 7,
2773  0, 9, 0, 194, 0, 10, 11, 0, 0, 0,
2774  12, 0, 13, 14, 15, 241, 242, 18, 19, 0,
2775  0, 0, 0, 0, 243, 244, 245, 23, 24, 25,
2776  26, 0, 0, 203, 0, 0, 0, 0, 0, 0,
2777  271, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2778  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2779  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2780  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2781  0, 0, 272, 0, 0, 206, 52, 0, 53, 54,
2782  0, 0, 0, 0, 56, 57, 58, 59, 60, 61,
2783  62, 63, 64, 0, 0, 0, 0, 0, 5, 6,
2784  7, 0, 9, 0, 0, 0, 10, 11, 0, 0,
2785  0, 12, 273, 13, 14, 15, 241, 242, 18, 19,
2786  274, 0, 0, 0, 0, 243, 244, 245, 23, 24,
2787  25, 26, 0, 0, 203, 0, 0, 0, 0, 0,
2788  0, 271, 0, 0, 32, 33, 34, 35, 36, 37,
2789  38, 39, 40, 0, 41, 42, 43, 44, 0, 45,
2790  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2791  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2792  0, 0, 0, 272, 0, 0, 206, 52, 0, 53,
2793  54, 0, 0, 0, 0, 56, 57, 58, 59, 60,
2794  61, 62, 63, 64, 0, 0, 0, 0, 0, 5,
2795  6, 7, 8, 9, 0, 0, 0, 10, 11, 0,
2796  0, 0, 12, 273, 13, 14, 15, 16, 17, 18,
2797  19, 519, 0, 0, 0, 0, 20, 21, 22, 23,
2798  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2799  0, 28, 29, 30, 31, 32, 33, 34, 35, 36,
2800  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2801  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2802  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2803  0, 0, 0, 0, 50, 0, 0, 51, 52, 0,
2804  53, 54, 0, 55, 0, 0, 56, 57, 58, 59,
2805  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2806  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2807  0, 0, 10, 11, 65, 66, 67, 12, 0, 13,
2808  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2809  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2810  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2811  32, 33, 34, 35, 36, 37, 38, 39, 40, 204,
2812  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2813  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2814  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2815  0, 0, 206, 52, 0, 53, 54, 0, 207, 208,
2816  209, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2817  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2818  6, 7, 8, 9, 0, 0, 0, 10, 11, 65,
2819  210, 67, 12, 0, 13, 14, 15, 16, 17, 18,
2820  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2821  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2822  0, 28, 29, 0, 31, 32, 33, 34, 35, 36,
2823  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2824  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2825  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2826  0, 0, 0, 0, 50, 0, 0, 51, 52, 0,
2827  53, 54, 0, 55, 0, 0, 56, 57, 58, 59,
2828  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2829  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2830  0, 0, 10, 11, 65, 66, 67, 12, 0, 13,
2831  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
2832  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
2833  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2834  32, 33, 34, 35, 36, 37, 38, 39, 40, 204,
2835  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2836  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2837  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2838  0, 0, 206, 52, 0, 53, 54, 0, 609, 208,
2839  209, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2840  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2841  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2842  210, 67, 12, 0, 13, 14, 15, 241, 242, 18,
2843  19, 0, 0, 0, 0, 0, 243, 244, 245, 23,
2844  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2845  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2846  37, 38, 39, 40, 204, 41, 42, 43, 44, 0,
2847  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2848  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2849  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2850  53, 54, 0, 207, 208, 0, 56, 57, 58, 59,
2851  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2852  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2853  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2854  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
2855  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
2856  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2857  32, 33, 34, 35, 36, 37, 38, 39, 40, 204,
2858  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2859  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2860  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2861  0, 0, 206, 52, 0, 53, 54, 0, 0, 208,
2862  209, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2863  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2864  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2865  210, 67, 12, 0, 13, 14, 15, 241, 242, 18,
2866  19, 0, 0, 0, 0, 0, 243, 244, 245, 23,
2867  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2868  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2869  37, 38, 39, 40, 204, 41, 42, 43, 44, 0,
2870  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2871  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2872  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2873  53, 54, 0, 609, 208, 0, 56, 57, 58, 59,
2874  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2875  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2876  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2877  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
2878  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
2879  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2880  32, 33, 34, 35, 36, 37, 38, 39, 40, 204,
2881  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2882  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2883  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2884  0, 0, 206, 52, 0, 53, 54, 0, 0, 208,
2885  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2886  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2887  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2888  210, 67, 12, 0, 13, 14, 15, 16, 17, 18,
2889  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2890  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2891  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2892  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2893  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2894  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2895  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2896  53, 54, 0, 512, 0, 0, 56, 57, 58, 59,
2897  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2898  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2899  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2900  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
2901  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
2902  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2903  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2904  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2905  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2906  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2907  0, 0, 206, 52, 0, 53, 54, 0, 207, 0,
2908  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2909  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2910  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2911  210, 67, 12, 0, 13, 14, 15, 241, 242, 18,
2912  19, 0, 0, 0, 0, 0, 243, 244, 245, 23,
2913  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2914  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2915  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2916  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2917  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2918  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2919  53, 54, 0, 817, 0, 0, 56, 57, 58, 59,
2920  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2921  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2922  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2923  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
2924  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
2925  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2926  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2927  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2928  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2929  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2930  0, 0, 206, 52, 0, 53, 54, 0, 512, 0,
2931  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2932  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2933  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2934  210, 67, 12, 0, 13, 14, 15, 241, 242, 18,
2935  19, 0, 0, 0, 0, 0, 243, 244, 245, 23,
2936  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2937  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2938  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2939  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2940  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2941  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2942  53, 54, 0, 609, 0, 0, 56, 57, 58, 59,
2943  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2944  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2945  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2946  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
2947  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
2948  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2949  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2950  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2951  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2952  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2953  0, 0, 206, 52, 0, 53, 54, 0, 0, 0,
2954  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2955  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2956  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2957  210, 67, 12, 0, 13, 14, 15, 16, 17, 18,
2958  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2959  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2960  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2961  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2962  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2963  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2964  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2965  53, 54, 0, 0, 0, 0, 56, 57, 58, 59,
2966  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2967  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2968  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2969  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2970  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2971  27, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2972  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2973  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2974  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2975  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2976  0, 0, 206, 52, 0, 53, 54, 0, 0, 0,
2977  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2978  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2979  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2980  66, 67, 12, 0, 13, 14, 15, 241, 242, 18,
2981  19, 0, 0, 0, 0, 0, 243, 244, 245, 23,
2982  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2983  0, 0, 271, 0, 0, 32, 33, 34, 35, 36,
2984  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2985  45, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2986  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2987  0, 0, 0, 0, 272, 0, 0, 325, 52, 0,
2988  53, 54, 0, 326, 0, 0, 56, 57, 58, 59,
2989  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2990  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2991  0, 0, 0, 12, 273, 13, 14, 15, 241, 242,
2992  18, 19, 0, 0, 0, 0, 0, 243, 244, 245,
2993  23, 24, 25, 26, 0, 0, 203, 0, 0, 0,
2994  0, 0, 0, 271, 0, 0, 32, 33, 34, 35,
2995  36, 37, 38, 39, 40, 0, 41, 42, 43, 44,
2996  0, 45, 46, 47, 0, 0, 0, 0, 0, 0,
2997  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2998  0, 0, 0, 0, 0, 367, 0, 0, 51, 52,
2999  0, 53, 54, 0, 55, 0, 0, 56, 57, 58,
3000  59, 60, 61, 62, 63, 64, 0, 0, 0, 0,
3001  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
3002  11, 0, 0, 0, 12, 273, 13, 14, 15, 241,
3003  242, 18, 19, 0, 0, 0, 0, 0, 243, 244,
3004  245, 23, 24, 25, 26, 0, 0, 203, 0, 0,
3005  0, 0, 0, 0, 271, 0, 0, 32, 33, 34,
3006  375, 36, 37, 38, 376, 40, 0, 41, 42, 43,
3007  44, 0, 45, 46, 47, 0, 0, 0, 0, 0,
3008  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3009  0, 0, 0, 377, 0, 0, 378, 0, 0, 206,
3010  52, 0, 53, 54, 0, 0, 0, 0, 56, 57,
3011  58, 59, 60, 61, 62, 63, 64, 0, 0, 0,
3012  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
3013  10, 11, 0, 0, 0, 12, 273, 13, 14, 15,
3014  241, 242, 18, 19, 0, 0, 0, 0, 0, 243,
3015  244, 245, 23, 24, 25, 26, 0, 0, 203, 0,
3016  0, 0, 0, 0, 0, 271, 0, 0, 32, 33,
3017  34, 375, 36, 37, 38, 376, 40, 0, 41, 42,
3018  43, 44, 0, 45, 46, 47, 0, 0, 0, 0,
3019  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3020  0, 0, 0, 0, 0, 0, 0, 378, 0, 0,
3021  206, 52, 0, 53, 54, 0, 0, 0, 0, 56,
3022  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
3023  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3024  0, 10, 11, 0, 0, 0, 12, 273, 13, 14,
3025  15, 241, 242, 18, 19, 0, 0, 0, 0, 0,
3026  243, 244, 245, 23, 24, 25, 26, 0, 0, 203,
3027  0, 0, 0, 0, 0, 0, 271, 0, 0, 32,
3028  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
3029  42, 43, 44, 0, 45, 46, 47, 0, 0, 0,
3030  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3031  0, 0, 0, 0, 0, 0, 0, 0, 272, 0,
3032  0, 325, 52, 0, 53, 54, 0, 0, 0, 0,
3033  56, 57, 58, 59, 60, 61, 62, 63, 64, 0,
3034  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
3035  0, 0, 10, 11, 0, 0, 0, 12, 273, 13,
3036  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
3037  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
3038  203, 0, 0, 0, 0, 0, 0, 271, 0, 0,
3039  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
3040  41, 42, 43, 44, 0, 45, 46, 47, 0, 0,
3041  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3042  0, 0, 0, 0, 0, 0, 0, 0, 0, 897,
3043  0, 0, 206, 52, 0, 53, 54, 0, 0, 0,
3044  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
3045  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
3046  0, 0, 0, 10, 11, 0, 0, 0, 12, 273,
3047  13, 14, 15, 241, 242, 18, 19, 0, 0, 0,
3048  0, 0, 243, 244, 245, 23, 24, 25, 26, 0,
3049  0, 203, 0, 0, 0, 0, 0, 0, 271, 0,
3050  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3051  0, 41, 42, 43, 44, 0, 45, 46, 47, 0,
3052  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3053  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3054  975, 0, 0, 206, 52, 0, 53, 54, 0, 0,
3055  0, 0, 56, 57, 58, 59, 60, 61, 62, 63,
3056  64, 0, 0, 0, 0, 554, 555, 0, 0, 556,
3057  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3058  273, 165, 166, 167, 168, 169, 170, 171, 172, 173,
3059  0, 0, 174, 175, 0, 0, 176, 177, 178, 179,
3060  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3061  180, 181, 0, 0, 0, 0, 0, 0, 0, 0,
3062  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3063  0, 182, 183, 184, 185, 186, 187, 188, 189, 190,
3064  191, 0, 192, 193, 562, 563, 0, 0, 564, 0,
3065  194, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3066  165, 166, 167, 168, 169, 170, 171, 172, 173, 0,
3067  0, 174, 175, 0, 0, 176, 177, 178, 179, 0,
3068  0, 0, 0, 0, 0, 0, 0, 0, 0, 180,
3069  181, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3070  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3071  182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
3072  0, 192, 193, 599, 563, 0, 0, 600, 0, 194,
3073  0, 0, 0, 0, 0, 0, 0, 0, 0, 165,
3074  166, 167, 168, 169, 170, 171, 172, 173, 0, 0,
3075  174, 175, 0, 0, 176, 177, 178, 179, 0, 0,
3076  0, 0, 0, 0, 0, 0, 0, 0, 180, 181,
3077  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3078  0, 0, 0, 0, 0, 0, 0, 0, 0, 182,
3079  183, 184, 185, 186, 187, 188, 189, 190, 191, 0,
3080  192, 193, 613, 555, 0, 0, 614, 0, 194, 0,
3081  0, 0, 0, 0, 0, 0, 0, 0, 165, 166,
3082  167, 168, 169, 170, 171, 172, 173, 0, 0, 174,
3083  175, 0, 0, 176, 177, 178, 179, 0, 0, 0,
3084  0, 0, 0, 0, 0, 0, 0, 180, 181, 0,
3085  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3086  0, 0, 0, 0, 0, 0, 0, 0, 182, 183,
3087  184, 185, 186, 187, 188, 189, 190, 191, 0, 192,
3088  193, 616, 563, 0, 0, 617, 0, 194, 0, 0,
3089  0, 0, 0, 0, 0, 0, 0, 165, 166, 167,
3090  168, 169, 170, 171, 172, 173, 0, 0, 174, 175,
3091  0, 0, 176, 177, 178, 179, 0, 0, 0, 0,
3092  0, 0, 0, 0, 0, 0, 180, 181, 0, 0,
3093  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3094  0, 0, 0, 0, 0, 0, 0, 182, 183, 184,
3095  185, 186, 187, 188, 189, 190, 191, 0, 192, 193,
3096  640, 555, 0, 0, 641, 0, 194, 0, 0, 0,
3097  0, 0, 0, 0, 0, 0, 165, 166, 167, 168,
3098  169, 170, 171, 172, 173, 0, 0, 174, 175, 0,
3099  0, 176, 177, 178, 179, 0, 0, 0, 0, 0,
3100  0, 0, 0, 0, 0, 180, 181, 0, 0, 0,
3101  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3102  0, 0, 0, 0, 0, 0, 182, 183, 184, 185,
3103  186, 187, 188, 189, 190, 191, 0, 192, 193, 643,
3104  563, 0, 0, 644, 0, 194, 0, 0, 0, 0,
3105  0, 0, 0, 0, 0, 165, 166, 167, 168, 169,
3106  170, 171, 172, 173, 0, 0, 174, 175, 0, 0,
3107  176, 177, 178, 179, 0, 0, 0, 0, 0, 0,
3108  0, 0, 0, 0, 180, 181, 0, 0, 0, 0,
3109  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3110  0, 0, 0, 0, 0, 182, 183, 184, 185, 186,
3111  187, 188, 189, 190, 191, 0, 192, 193, 728, 555,
3112  0, 0, 729, 0, 194, 0, 0, 0, 0, 0,
3113  0, 0, 0, 0, 165, 166, 167, 168, 169, 170,
3114  171, 172, 173, 0, 0, 174, 175, 0, 0, 176,
3115  177, 178, 179, 0, 0, 0, 0, 0, 0, 0,
3116  0, 0, 0, 180, 181, 0, 0, 0, 0, 0,
3117  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3118  0, 0, 0, 0, 182, 183, 184, 185, 186, 187,
3119  188, 189, 190, 191, 0, 192, 193, 731, 563, 0,
3120  0, 732, 0, 194, 0, 0, 0, 0, 0, 0,
3121  0, 0, 0, 165, 166, 167, 168, 169, 170, 171,
3122  172, 173, 0, 0, 174, 175, 0, 0, 176, 177,
3123  178, 179, 0, 0, 0, 0, 0, 0, 0, 0,
3124  0, 0, 180, 181, 0, 0, 0, 0, 0, 0,
3125  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3126  0, 0, 0, 182, 183, 184, 185, 186, 187, 188,
3127  189, 190, 191, 0, 192, 193, 738, 555, 0, 0,
3128  739, 0, 194, 0, 0, 0, 0, 0, 0, 0,
3129  0, 0, 165, 166, 167, 168, 169, 170, 171, 172,
3130  173, 0, 0, 174, 175, 0, 0, 176, 177, 178,
3131  179, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3132  0, 180, 181, 0, 0, 0, 0, 0, 0, 0,
3133  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3134  0, 0, 182, 183, 184, 185, 186, 187, 188, 189,
3135  190, 191, 0, 192, 193, 1007, 555, 0, 0, 1008,
3136  0, 194, 0, 0, 0, 0, 0, 0, 0, 0,
3137  0, 165, 166, 167, 168, 169, 170, 171, 172, 173,
3138  0, 0, 174, 175, 0, 0, 176, 177, 178, 179,
3139  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3140  180, 181, 0, 0, 0, 0, 0, 0, 0, 0,
3141  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3142  0, 182, 183, 184, 185, 186, 187, 188, 189, 190,
3143  191, 0, 192, 193, 1040, 555, 0, 0, 1041, 0,
3144  194, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3145  165, 166, 167, 168, 169, 170, 171, 172, 173, 0,
3146  0, 174, 175, 0, 0, 176, 177, 178, 179, 0,
3147  0, 0, 0, 0, 0, 0, 0, 0, 0, 180,
3148  181, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3149  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3150  182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
3151  0, 192, 193, 1043, 563, 0, 0, 1044, 0, 194,
3152  0, 0, 0, 0, 0, 0, 0, 0, 0, 165,
3153  166, 167, 168, 169, 170, 171, 172, 173, 0, 0,
3154  174, 175, 0, 0, 176, 177, 178, 179, 0, 0,
3155  0, 0, 0, 0, 0, 0, 0, 0, 180, 181,
3156  329, 330, 331, 332, 333, 334, 335, 336, 337, 338,
3157  339, 340, 341, 0, 0, 342, 343, 0, 0, 182,
3158  183, 184, 185, 186, 187, 188, 189, 190, 191, 0,
3159  192, 193, 0, 0, 0, 0, 0, 0, 194, 0,
3160  0, 0, 0, 0, 0, 0, 344, 0, 345, 346,
3161  347, 348, 349, 350, 351, 352, 353, 354, 0, 0,
3162  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3163  0, 0, 0, 234
3164 };
3165 
3166 #define yypact_value_is_default(yystate) \
3167  ((yystate) == (-813))
3168 
3169 #define yytable_value_is_error(yytable_value) \
3170  ((yytable_value) == (-628))
3171 
3172 static const yytype_int16 yycheck[] =
3173 {
3174  2, 27, 98, 29, 57, 81, 16, 17, 8, 76,
3175  20, 8, 16, 17, 8, 328, 20, 361, 89, 22,
3176  576, 92, 51, 28, 414, 88, 89, 328, 28, 92,
3177  422, 28, 422, 4, 28, 54, 355, 578, 357, 356,
3178  55, 69, 223, 96, 670, 2, 92, 4, 575, 53,
3179  615, 53, 54, 378, 65, 595, 69, 2, 265, 4,
3180  57, 778, 269, 55, 92, 233, 81, 51, 460, 473,
3181  686, 16, 17, 76, 469, 20, 787, 642, 93, 94,
3182  95, 442, 401, 508, 13, 716, 511, 66, 872, 720,
3183  258, 25, 27, 261, 906, 253, 63, 78, 417, 96,
3184  419, 418, 29, 89, 874, 25, 51, 63, 143, 87,
3185  55, 0, 775, 87, 16, 17, 89, 138, 20, 25,
3186  132, 66, 143, 26, 519, 13, 445, 87, 56, 115,
3187  37, 38, 28, 25, 16, 17, 81, 800, 20, 120,
3188  13, 99, 115, 88, 89, 112, 25, 92, 93, 94,
3189  95, 53, 54, 472, 471, 939, 112, 135, 102, 13,
3190  25, 135, 778, 136, 122, 730, 25, 325, 26, 139,
3191  233, 787, 235, 143, 134, 135, 741, 206, 895, 246,
3192  806, 807, 13, 142, 725, 204, 113, 25, 207, 208,
3193  209, 52, 289, 13, 291, 56, 293, 737, 274, 262,
3194  297, 742, 136, 1015, 138, 745, 141, 136, 143, 255,
3195  994, 240, 141, 1, 143, 217, 136, 227, 138, 229,
3196  230, 223, 992, 227, 253, 229, 142, 255, 230, 132,
3197  136, 623, 622, 623, 951, 946, 143, 142, 309, 310,
3198  311, 312, 255, 1027, 136, 271, 309, 310, 311, 312,
3199  431, 314, 315, 141, 658, 143, 424, 136, 884, 274,
3200  428, 206, 273, 582, 581, 433, 691, 592, 141, 253,
3201  143, 136, 633, 902, 132, 594, 593, 136, 142, 895,
3202  138, 449, 227, 115, 229, 230, 902, 141, 233, 143,
3203  235, 362, 363, 1010, 251, 240, 325, 928, 136, 362,
3204  363, 25, 697, 844, 323, 846, 251, 138, 253, 328,
3205  141, 326, 143, 25, 377, 856, 115, 262, 364, 323,
3206  861, 141, 89, 143, 328, 227, 853, 229, 136, 274,
3207  946, 119, 89, 89, 326, 658, 364, 308, 26, 965,
3208  744, 325, 746, 136, 323, 227, 356, 229, 115, 328,
3209  518, 308, 380, 141, 356, 143, 313, 138, 87, 115,
3210  357, 37, 38, 308, 309, 310, 311, 312, 313, 314,
3211  315, 141, 928, 143, 1003, 89, 25, 115, 323, 87,
3212  325, 326, 726, 328, 925, 926, 56, 1003, 87, 486,
3213  930, 115, 26, 469, 413, 414, 493, 698, 136, 87,
3214  115, 115, 715, 422, 401, 134, 135, 70, 418, 63,
3215  63, 356, 136, 358, 136, 139, 418, 362, 363, 143,
3216  136, 744, 419, 746, 136, 404, 405, 135, 430, 431,
3217  637, 612, 377, 90, 439, 134, 135, 89, 457, 439,
3218  442, 460, 439, 519, 132, 439, 134, 135, 445, 990,
3219  138, 991, 138, 87, 469, 109, 109, 111, 111, 404,
3220  405, 471, 125, 126, 127, 136, 115, 136, 636, 471,
3221  89, 87, 143, 418, 143, 472, 868, 1042, 868, 63,
3222  138, 87, 1023, 67, 1025, 442, 132, 136, 142, 142,
3223  139, 558, 70, 512, 143, 70, 115, 442, 132, 566,
3224  134, 135, 138, 136, 519, 507, 508, 452, 139, 511,
3225  143, 52, 414, 54, 55, 56, 57, 543, 672, 135,
3226  674, 26, 87, 115, 469, 109, 471, 111, 134, 135,
3227  704, 26, 138, 596, 601, 561, 52, 711, 54, 55,
3228  56, 57, 571, 140, 573, 87, 574, 575, 123, 124,
3229  125, 126, 127, 133, 87, 457, 559, 15, 577, 17,
3230  588, 89, 638, 626, 567, 63, 56, 569, 136, 134,
3231  135, 581, 916, 577, 519, 743, 63, 112, 922, 581,
3232  761, 112, 87, 593, 70, 582, 63, 115, 112, 615,
3233  609, 593, 87, 135, 762, 136, 473, 594, 601, 601,
3234  112, 606, 135, 622, 623, 773, 606, 87, 136, 606,
3235  612, 109, 606, 111, 112, 89, 642, 686, 96, 87,
3236  136, 697, 109, 638, 111, 112, 571, 132, 573, 134,
3237  135, 633, 109, 138, 111, 112, 581, 132, 705, 134,
3238  135, 115, 686, 138, 58, 712, 89, 666, 593, 87,
3239  595, 596, 87, 749, 134, 135, 70, 87, 687, 17,
3240  686, 690, 733, 692, 136, 736, 668, 135, 670, 87,
3241  733, 141, 115, 736, 56, 694, 633, 87, 14, 15,
3242  25, 626, 697, 139, 98, 99, 136, 136, 633, 691,
3243  132, 87, 860, 638, 747, 136, 715, 135, 142, 134,
3244  135, 1020, 1019, 871, 730, 135, 734, 87, 122, 133,
3245  712, 715, 781, 715, 716, 741, 718, 135, 720, 698,
3246  622, 63, 701, 702, 134, 135, 142, 881, 882, 708,
3247  709, 87, 886, 136, 888, 87, 890, 781, 134, 135,
3248  89, 785, 687, 136, 136, 690, 136, 692, 63, 775,
3249  747, 115, 697, 698, 134, 135, 701, 702, 777, 761,
3250  87, 138, 686, 708, 709, 10, 115, 109, 87, 111,
3251  112, 8, 843, 686, 800, 652, 89, 89, 134, 135,
3252  843, 658, 134, 135, 13, 138, 815, 136, 733, 804,
3253  133, 736, 737, 115, 109, 89, 111, 112, 817, 2,
3254  745, 4, 115, 115, 806, 807, 89, 134, 135, 686,
3255  136, 840, 136, 16, 17, 134, 135, 20, 847, 848,
3256  52, 115, 851, 136, 136, 853, 895, 855, 136, 54,
3257  899, 850, 115, 902, 862, 904, 838, 136, 52, 841,
3258  65, 66, 136, 136, 998, 999, 1000, 1001, 51, 868,
3259  829, 895, 52, 136, 136, 899, 117, 15, 902, 804,
3260  904, 140, 891, 66, 136, 70, 133, 744, 136, 746,
3261  815, 120, 115, 136, 787, 141, 136, 790, 136, 894,
3262  85, 86, 884, 136, 829, 88, 89, 10, 10, 92,
3263  919, 133, 769, 770, 90, 840, 1050, 136, 843, 9,
3264  915, 778, 847, 848, 139, 136, 851, 120, 136, 136,
3265  787, 56, 136, 136, 943, 944, 133, 122, 123, 124,
3266  125, 126, 127, 110, 136, 52, 928, 54, 55, 56,
3267  57, 56, 136, 10, 1003, 136, 1005, 136, 136, 54,
3268  55, 1010, 57, 1012, 136, 971, 891, 136, 133, 894,
3269  65, 66, 981, 136, 983, 136, 138, 70, 138, 1003,
3270  989, 1005, 93, 965, 91, 95, 1010, 452, 1012, 712,
3271  915, 895, 85, 86, 919, 899, 686, 1022, 902, 769,
3272  904, 809, 810, 1052, 1015, 930, 750, 1021, 297, 902,
3273  101, 904, 59, 96, 936, 872, 781, 874, 943, 944,
3274  899, 895, 52, 206, 54, 55, 56, 57, 1052, 1019,
3275  123, 124, 125, 126, 127, 778, 1042, 1019, 895, 1021,
3276  1022, -1, 398, 1020, 227, 902, 229, 230, -1, -1,
3277  233, -1, 235, 946, -1, 948, 981, 240, 983, -1,
3278  953, 91, -1, -1, 989, -1, 991, 97, 251, -1,
3279  253, -1, 52, -1, 54, 55, 56, 57, -1, 262,
3280  -1, -1, 939, 940, 59, 60, 61, 62, 52, 946,
3281  54, 55, 56, 57, 1019, -1, -1, -1, -1, 1003,
3282  -1, 1005, -1, -1, -1, -1, 1010, -1, 1012, -1,
3283  1003, 91, 1005, -1, -1, -1, -1, 97, -1, 1012,
3284  40, 41, 42, 43, 44, 308, 309, 310, 311, 312,
3285  313, 314, 315, -1, -1, 992, -1, 994, 1031, -1,
3286  323, -1, 325, -1, -1, 328, 1003, -1, 1052, -1,
3287  -1, -1, 960, 961, -1, -1, -1, -1, 966, 1052,
3288  968, 969, -1, 16, 17, -1, -1, 20, -1, -1,
3289  1027, -1, -1, 356, -1, 358, -1, -1, -1, 362,
3290  363, -1, -1, -1, -1, -1, -1, 52, -1, 54,
3291  55, 56, 57, 58, 377, 48, 49, -1, -1, -1,
3292  53, 54, -1, -1, -1, 70, -1, -1, -1, -1,
3293  -1, -1, -1, 66, 67, -1, -1, -1, -1, -1,
3294  -1, 404, 405, -1, -1, -1, 91, 1035, 1036, 1037,
3295  1038, -1, 97, 98, 99, 418, 52, -1, 54, 55,
3296  56, 57, 58, -1, -1, -1, -1, -1, -1, -1,
3297  1058, -1, -1, -1, 70, -1, -1, 122, -1, 442,
3298  125, -1, -1, -1, -1, -1, -1, -1, -1, 452,
3299  -1, -1, -1, -1, -1, 91, 0, -1, 143, -1,
3300  -1, 97, 98, 99, 8, 9, 10, -1, 471, 13,
3301  14, 15, 52, 17, 54, 55, 56, 57, 58, -1,
3302  -1, -1, 26, 27, -1, -1, 122, -1, -1, 125,
3303  70, -1, -1, 37, 38, -1, 40, 41, 42, 43,
3304  44, -1, 138, -1, -1, -1, -1, -1, -1, -1,
3305  -1, 91, -1, -1, -1, -1, -1, 97, 98, 99,
3306  -1, -1, -1, 2, -1, 4, -1, -1, -1, -1,
3307  -1, 204, -1, -1, 207, 208, 209, 210, -1, -1,
3308  -1, -1, 122, 87, -1, 125, -1, -1, -1, -1,
3309  -1, -1, -1, -1, 227, -1, 229, 230, -1, 52,
3310  -1, 54, 55, 56, 57, 58, 110, -1, 571, -1,
3311  573, -1, 51, -1, -1, -1, 55, 70, 581, -1,
3312  -1, -1, -1, -1, -1, 70, -1, -1, 132, 133,
3313  593, 135, 595, 596, 138, 139, -1, 141, 91, 143,
3314  85, 86, 81, -1, -1, 98, 99, -1, -1, -1,
3315  -1, -1, -1, -1, 93, 94, 95, 96, -1, -1,
3316  -1, -1, -1, 626, -1, -1, -1, -1, -1, 122,
3317  633, -1, -1, -1, -1, 120, 121, 122, 123, 124,
3318  125, 126, 127, -1, -1, -1, -1, -1, -1, -1,
3319  323, -1, -1, -1, -1, 328, 329, 330, 331, 332,
3320  333, 334, 335, 336, 337, 338, 339, 340, 341, 342,
3321  343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
3322  353, 354, -1, 356, 687, -1, -1, 690, -1, 692,
3323  -1, -1, -1, -1, -1, 698, -1, -1, 701, 702,
3324  -1, -1, -1, -1, -1, 708, 709, -1, -1, -1,
3325  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3326  -1, -1, -1, -1, -1, -1, 2, 206, 4, -1,
3327  733, 404, 405, 736, 737, -1, -1, -1, -1, 412,
3328  413, 414, 745, -1, -1, 418, -1, 420, 421, 422,
3329  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3330  -1, 240, -1, -1, -1, -1, -1, -1, 441, -1,
3331  -1, -1, 251, 446, 253, 51, -1, -1, -1, 55,
3332  -1, -1, -1, -1, 457, -1, -1, 460, -1, -1,
3333  -1, -1, -1, -1, -1, 274, -1, -1, 471, -1,
3334  -1, -1, -1, -1, -1, 81, 2, -1, 4, -1,
3335  -1, -1, 815, -1, -1, -1, -1, 93, 94, 95,
3336  96, -1, -1, -1, 497, -1, 829, -1, -1, 308,
3337  -1, -1, -1, -1, 313, -1, -1, 840, -1, 512,
3338  843, -1, -1, -1, 847, 848, 325, 326, 851, -1,
3339  -1, -1, -1, -1, -1, 51, -1, -1, -1, 55,
3340  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3341  -1, -1, -1, -1, -1, -1, -1, -1, -1, 358,
3342  -1, -1, -1, -1, -1, 81, -1, -1, 891, -1,
3343  -1, -1, -1, -1, -1, -1, -1, 93, 94, 95,
3344  -1, -1, -1, -1, 577, -1, -1, -1, 581, -1,
3345  -1, -1, -1, -1, -1, -1, 919, -1, -1, -1,
3346  593, -1, -1, -1, -1, -1, -1, 930, -1, -1,
3347  206, -1, -1, -1, -1, -1, 609, -1, -1, -1,
3348  943, 944, -1, -1, -1, -1, -1, -1, -1, 622,
3349  623, 70, 71, 72, 73, 74, 75, 76, 77, -1,
3350  79, 80, -1, 442, 240, -1, 85, 86, -1, -1,
3351  -1, -1, -1, 452, -1, 251, -1, 253, 981, -1,
3352  983, -1, -1, -1, -1, 2, 989, 4, 991, -1,
3353  469, -1, -1, 666, -1, -1, -1, -1, 274, 118,
3354  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
3355  206, -1, -1, -1, -1, -1, 1019, -1, -1, -1,
3356  -1, 694, -1, -1, -1, 698, 699, -1, 701, 702,
3357  -1, -1, 308, -1, 51, 708, 709, 313, -1, -1,
3358  519, -1, 715, -1, 240, -1, -1, -1, -1, 325,
3359  326, -1, -1, -1, -1, 251, -1, 253, -1, -1,
3360  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3361  -1, -1, -1, -1, -1, -1, 93, -1, 274, 752,
3362  -1, -1, 358, 756, 757, -1, 759, 760, -1, -1,
3363  -1, -1, 571, -1, 573, -1, -1, -1, -1, -1,
3364  -1, -1, -1, -1, 777, -1, -1, -1, -1, -1,
3365  -1, -1, 308, -1, -1, -1, 595, 313, -1, -1,
3366  -1, -1, -1, -1, -1, -1, -1, -1, -1, 325,
3367  326, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3368  -1, -1, -1, -1, 817, -1, -1, 2, 821, 4,
3369  -1, -1, -1, -1, 633, -1, 829, -1, -1, 638,
3370  -1, -1, 358, -1, -1, -1, 442, -1, -1, -1,
3371  -1, -1, -1, -1, -1, -1, 452, 850, -1, -1,
3372  -1, -1, -1, -1, -1, -1, -1, -1, -1, 206,
3373  -1, -1, -1, 469, 867, 868, 51, -1, -1, -1,
3374  -1, -1, -1, -1, -1, -1, -1, -1, 687, -1,
3375  -1, 690, -1, 692, -1, -1, -1, -1, 697, -1,
3376  -1, -1, -1, 240, -1, -1, -1, -1, -1, -1,
3377  -1, -1, -1, -1, 251, -1, 253, -1, -1, -1,
3378  -1, -1, -1, 519, -1, -1, 442, -1, -1, -1,
3379  -1, -1, 44, -1, -1, -1, 452, -1, 737, -1,
3380  -1, -1, -1, -1, -1, -1, 745, -1, -1, -1,
3381  -1, -1, -1, 469, -1, -1, -1, -1, 70, 71,
3382  72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
3383  82, 308, -1, 85, 86, 571, 313, 573, -1, -1,
3384  -1, -1, -1, -1, -1, -1, -1, -1, 325, -1,
3385  -1, 328, -1, -1, -1, -1, -1, -1, -1, 595,
3386  -1, -1, -1, 519, 116, 804, 118, 119, 120, 121,
3387  122, 123, 124, 125, 126, 127, 815, -1, -1, -1,
3388  -1, 358, -1, -1, 136, -1, 1019, -1, -1, -1,
3389  -1, 206, -1, -1, -1, -1, -1, 633, -1, -1,
3390  -1, 840, 638, -1, -1, -1, -1, -1, 847, 848,
3391  -1, -1, 851, -1, -1, 571, -1, 573, -1, -1,
3392  -1, -1, -1, -1, -1, 240, -1, -1, -1, -1,
3393  -1, -1, -1, -1, -1, -1, 251, -1, 253, 595,
3394  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3395  -1, 687, 891, -1, 690, 894, 692, -1, -1, -1,
3396  -1, 697, -1, -1, -1, 442, -1, -1, -1, -1,
3397  -1, -1, -1, -1, -1, 452, 915, 633, -1, -1,
3398  919, -1, 638, -1, -1, -1, -1, -1, -1, -1,
3399  -1, 930, -1, 308, -1, -1, -1, -1, 313, -1,
3400  -1, 737, -1, -1, 943, 944, -1, -1, -1, 745,
3401  325, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3402  -1, -1, 678, -1, -1, -1, -1, -1, -1, -1,
3403  -1, 687, -1, -1, 690, -1, 692, -1, -1, -1,
3404  -1, 697, 981, 358, 983, -1, -1, -1, -1, -1,
3405  989, -1, 991, -1, -1, -1, -1, -1, -1, -1,
3406  -1, -1, -1, -1, -1, -1, -1, -1, 804, -1,
3407  -1, -1, -1, -1, -1, -1, -1, -1, -1, 815,
3408  -1, 737, -1, -1, -1, -1, -1, -1, -1, 745,
3409  -1, -1, -1, -1, 571, -1, 573, -1, -1, -1,
3410  -1, -1, -1, -1, 840, -1, -1, -1, -1, -1,
3411  -1, 847, 848, -1, -1, 851, -1, -1, 595, 70,
3412  71, 72, 73, 74, 75, 76, -1, 442, 79, 80,
3413  -1, -1, -1, -1, 85, 86, -1, 452, -1, -1,
3414  -1, -1, -1, -1, -1, -1, -1, -1, 804, -1,
3415  -1, -1, -1, -1, -1, 891, 633, -1, 894, 815,
3416  -1, -1, -1, -1, -1, -1, -1, 118, 119, 120,
3417  121, 122, 123, 124, 125, 126, 127, -1, -1, 915,
3418  -1, -1, -1, 919, 840, -1, -1, -1, -1, -1,
3419  -1, 847, 848, -1, 930, 851, -1, -1, -1, -1,
3420  -1, -1, -1, -1, -1, -1, -1, 943, 944, -1,
3421  687, -1, -1, 690, -1, 692, -1, -1, -1, -1,
3422  -1, 698, -1, -1, -1, -1, -1, -1, -1, -1,
3423  -1, -1, -1, -1, -1, 891, -1, -1, 894, -1,
3424  -1, -1, -1, -1, -1, 981, -1, 983, -1, -1,
3425  -1, -1, -1, 989, -1, 991, 571, -1, 573, 915,
3426  737, -1, -1, 919, -1, -1, -1, -1, 745, 0,
3427  -1, -1, -1, -1, 930, -1, -1, 8, 9, 10,
3428  595, -1, 13, 14, 15, -1, 17, 943, 944, -1,
3429  -1, -1, -1, -1, -1, 26, 27, 28, 29, -1,
3430  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3431  41, 42, 43, 44, -1, -1, -1, -1, 633, -1,
3432  -1, -1, -1, -1, -1, 981, -1, 983, -1, -1,
3433  -1, -1, -1, 989, -1, 991, -1, -1, 815, 70,
3434  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3435  81, 82, -1, -1, 85, 86, 87, -1, 89, 90,
3436  -1, -1, -1, 840, -1, 96, -1, -1, -1, -1,
3437  847, 848, 687, -1, 851, 690, -1, 692, -1, 110,
3438  -1, -1, 113, -1, 115, 116, 117, 118, 119, 120,
3439  121, 122, 123, 124, 125, 126, 127, -1, -1, -1,
3440  -1, 132, 133, 134, 135, 136, -1, -1, 139, 140,
3441  141, -1, 143, -1, 891, -1, -1, -1, -1, -1,
3442  -1, -1, 737, -1, -1, -1, -1, -1, -1, -1,
3443  745, 70, 71, 72, 73, 74, 75, 76, 915, -1,
3444  79, 80, 919, -1, -1, -1, 85, 86, -1, -1,
3445  -1, -1, -1, 930, -1, -1, -1, -1, -1, -1,
3446  -1, -1, -1, -1, -1, -1, 943, 944, -1, -1,
3447  -1, -1, -1, -1, -1, -1, -1, -1, -1, 118,
3448  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
3449  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3450  815, -1, -1, -1, 981, -1, 983, -1, -1, -1,
3451  -1, -1, 989, -1, 991, -1, -1, -1, -1, -1,
3452  -1, -1, -1, -1, -1, 840, -1, -1, -1, -1,
3453  -1, -1, 847, 848, -1, -1, 851, -1, -1, -1,
3454  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3455  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3456  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3457  -1, -1, -1, -1, -1, -1, 891, -1, -1, -1,
3458  -1, -1, -1, -1, -1, -1, -1, 0, 1, -1,
3459  3, 4, 5, 6, 7, -1, -1, -1, 11, 12,
3460  -1, -1, -1, 16, 919, 18, 19, 20, 21, 22,
3461  23, 24, -1, -1, -1, 930, -1, 30, 31, 32,
3462  33, 34, 35, 36, -1, -1, 39, -1, 943, 944,
3463  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3464  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
3465  -1, 64, 65, 66, -1, 68, 69, -1, -1, -1,
3466  -1, -1, -1, -1, -1, -1, 981, -1, 983, -1,
3467  -1, -1, -1, -1, 989, 88, 991, -1, 91, 92,
3468  -1, 94, 95, -1, 97, -1, -1, 100, 101, 102,
3469  103, 104, 105, 106, 107, 108, 0, -1, -1, -1,
3470  -1, -1, -1, -1, 8, 9, 10, -1, -1, 13,
3471  14, 15, -1, 17, -1, 128, 129, 130, -1, 44,
3472  -1, 25, -1, 27, 28, 29, -1, -1, 141, -1,
3473  143, -1, -1, 37, 38, -1, 40, 41, 42, 43,
3474  44, -1, -1, -1, -1, 70, 71, 72, 73, 74,
3475  75, 76, 77, 78, 79, 80, 81, 82, -1, -1,
3476  85, 86, -1, -1, -1, -1, 70, 71, 72, 73,
3477  74, 75, 76, 77, 78, 79, 80, 81, 82, -1,
3478  -1, 85, 86, 87, -1, 89, 90, -1, -1, -1,
3479  -1, 116, 96, 118, 119, 120, 121, 122, 123, 124,
3480  125, 126, 127, -1, -1, -1, 110, -1, -1, 113,
3481  -1, 115, 116, 117, 118, 119, 120, 121, 122, 123,
3482  124, 125, 126, 127, -1, -1, -1, -1, -1, 133,
3483  134, 135, 136, 0, -1, 139, 140, 141, -1, 143,
3484  -1, 8, 9, 10, -1, -1, 13, 14, 15, -1,
3485  17, -1, -1, -1, -1, -1, 44, -1, 25, -1,
3486  27, 28, 29, -1, -1, -1, -1, -1, -1, -1,
3487  37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
3488  -1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
3489  78, 79, 80, 81, 82, -1, -1, 85, 86, -1,
3490  -1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
3491  77, 78, 79, 80, 81, 82, -1, -1, 85, 86,
3492  87, -1, 89, 90, -1, -1, -1, -1, 116, 96,
3493  118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
3494  -1, -1, -1, 110, -1, -1, 113, -1, 115, 116,
3495  117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
3496  127, -1, -1, -1, -1, -1, 133, 134, 135, 136,
3497  0, -1, 139, 140, 141, -1, 143, -1, 8, 9,
3498  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3499  -1, -1, -1, -1, -1, -1, 26, 27, 28, 29,
3500  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3501  40, 41, 42, 43, 44, -1, -1, -1, -1, 70,
3502  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3503  81, 82, -1, -1, 85, 86, -1, -1, -1, -1,
3504  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3505  80, 81, 82, -1, -1, 85, 86, 87, -1, -1,
3506  90, -1, -1, -1, -1, 116, 96, 118, 119, 120,
3507  121, 122, 123, 124, 125, 126, 127, -1, -1, -1,
3508  110, -1, -1, 113, -1, -1, 116, 117, 118, 119,
3509  120, 121, 122, 123, 124, 125, 126, 127, -1, -1,
3510  -1, -1, 132, 133, 134, 135, 136, 0, -1, 139,
3511  140, 141, -1, 143, -1, 8, 9, 10, -1, -1,
3512  13, 14, 15, -1, 17, -1, -1, -1, -1, -1,
3513  -1, -1, -1, 26, 27, 28, 29, -1, -1, -1,
3514  -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
3515  43, 44, -1, -1, -1, -1, 70, 71, 72, 73,
3516  74, 75, 76, 77, 78, 79, 80, 81, 82, -1,
3517  -1, 85, 86, -1, -1, -1, -1, 70, 71, 72,
3518  73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
3519  -1, -1, 85, 86, 87, -1, -1, 90, -1, -1,
3520  -1, -1, -1, 96, 118, 119, 120, 121, 122, 123,
3521  124, 125, 126, 127, -1, -1, -1, 110, -1, -1,
3522  113, -1, -1, 116, 117, 118, 119, 120, 121, 122,
3523  123, 124, 125, 126, 127, -1, -1, -1, -1, 132,
3524  133, 134, 135, 136, 0, -1, 139, 140, 141, -1,
3525  143, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3526  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3527  -1, 27, 28, 29, -1, -1, -1, -1, -1, -1,
3528  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3529  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3530  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3531  -1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
3532  76, 77, 78, 79, 80, 81, 82, -1, -1, 85,
3533  86, 87, -1, 89, 90, -1, -1, -1, -1, -1,
3534  96, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3535  -1, -1, -1, -1, 110, -1, -1, 113, -1, 115,
3536  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3537  126, 127, -1, -1, -1, -1, -1, 133, 134, 135,
3538  136, 0, -1, 139, 140, 141, -1, 143, -1, 8,
3539  9, 10, -1, -1, 13, 14, 15, -1, 17, -1,
3540  -1, -1, -1, -1, -1, -1, -1, 26, 27, 28,
3541  -1, -1, -1, -1, -1, -1, -1, -1, 37, 38,
3542  -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
3543  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3544  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3545  -1, 70, 71, 72, 73, 74, 75, 76, 77, 78,
3546  79, 80, 81, 82, -1, -1, 85, 86, 87, -1,
3547  -1, 90, -1, -1, -1, -1, -1, 96, -1, -1,
3548  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3549  -1, 110, -1, -1, -1, -1, -1, 116, -1, 118,
3550  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
3551  -1, -1, -1, 132, 133, 134, 135, 136, 0, 138,
3552  139, 140, 141, -1, 143, -1, 8, 9, 10, -1,
3553  -1, 13, 14, 15, -1, 17, -1, -1, -1, -1,
3554  -1, -1, -1, -1, -1, 27, 28, 29, -1, -1,
3555  -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
3556  42, 43, 44, -1, -1, -1, -1, -1, -1, -1,
3557  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3558  -1, -1, -1, -1, -1, -1, -1, -1, 70, 71,
3559  72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
3560  82, -1, -1, 85, 86, 87, -1, -1, 90, -1,
3561  -1, -1, -1, -1, 96, -1, -1, -1, -1, -1,
3562  -1, -1, -1, -1, -1, -1, -1, -1, 110, -1,
3563  -1, 113, -1, -1, 116, 117, 118, 119, 120, 121,
3564  122, 123, 124, 125, 126, 127, -1, -1, -1, -1,
3565  -1, 133, 134, 135, 136, 0, -1, 139, 140, 141,
3566  -1, 143, -1, 8, 9, 10, -1, -1, 13, 14,
3567  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3568  -1, 26, 27, 28, -1, -1, -1, -1, -1, -1,
3569  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3570  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3571  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3572  -1, -1, -1, -1, -1, 70, 71, 72, 73, 74,
3573  75, 76, 77, 78, 79, 80, 81, 82, -1, -1,
3574  85, 86, 87, -1, -1, 90, -1, -1, -1, -1,
3575  -1, 96, -1, -1, -1, -1, -1, -1, -1, -1,
3576  -1, -1, -1, -1, -1, 110, -1, -1, -1, -1,
3577  -1, 116, -1, 118, 119, 120, 121, 122, 123, 124,
3578  125, 126, 127, -1, -1, -1, -1, 132, 133, 134,
3579  135, 136, 0, 138, 139, 140, 141, -1, 143, -1,
3580  8, 9, 10, -1, -1, 13, 14, 15, -1, 17,
3581  -1, -1, -1, -1, -1, -1, -1, -1, -1, 27,
3582  28, -1, -1, -1, -1, -1, -1, -1, -1, 37,
3583  38, -1, 40, 41, 42, 43, 44, -1, -1, -1,
3584  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3585  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3586  -1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
3587  78, 79, 80, 81, 82, -1, -1, 85, 86, 87,
3588  -1, -1, 90, -1, -1, -1, -1, -1, 96, -1,
3589  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3590  -1, -1, 110, -1, -1, -1, -1, -1, 116, -1,
3591  118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
3592  -1, -1, -1, -1, -1, 133, 134, 135, 136, 0,
3593  138, 139, 140, 141, -1, 143, -1, 8, 9, 10,
3594  -1, -1, -1, 14, 15, -1, 17, -1, -1, -1,
3595  -1, -1, -1, -1, -1, 26, -1, -1, -1, -1,
3596  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3597  41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
3598  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3599  -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
3600  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3601  81, 82, -1, -1, 85, 86, 87, -1, 89, -1,
3602  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3603  -1, -1, -1, -1, -1, -1, -1, -1, -1, 110,
3604  -1, -1, -1, -1, 115, 116, -1, 118, 119, 120,
3605  121, 122, 123, 124, 125, 126, 127, -1, -1, -1,
3606  -1, 132, 133, 134, 135, 136, 0, -1, 139, -1,
3607  141, -1, 143, -1, 8, 9, 10, -1, -1, -1,
3608  14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
3609  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3610  -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
3611  44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3612  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3613  -1, -1, -1, -1, -1, -1, 70, 71, 72, 73,
3614  74, 75, 76, 77, 78, 79, 80, 81, 82, -1,
3615  -1, 85, 86, 87, -1, 89, -1, -1, -1, -1,
3616  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3617  -1, -1, -1, -1, -1, -1, 110, -1, -1, -1,
3618  -1, 115, 116, -1, 118, 119, 120, 121, 122, 123,
3619  124, 125, 126, 127, -1, -1, -1, -1, -1, 133,
3620  134, 135, 136, -1, -1, 139, -1, 141, 1, 143,
3621  3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
3622  -1, -1, 15, 16, -1, 18, 19, 20, 21, 22,
3623  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3624  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3625  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3626  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
3627  -1, 64, 65, 66, -1, 68, 69, -1, -1, -1,
3628  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3629  -1, -1, -1, -1, -1, 88, -1, -1, 91, 92,
3630  -1, 94, 95, -1, 97, -1, -1, 100, 101, 102,
3631  103, 104, 105, 106, 107, 108, -1, -1, -1, -1,
3632  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3633  -1, -1, -1, -1, -1, 128, 129, 130, -1, -1,
3634  -1, -1, -1, -1, -1, -1, -1, -1, 141, 1,
3635  143, 3, 4, 5, 6, 7, -1, -1, 10, 11,
3636  12, -1, 14, 15, 16, -1, 18, 19, 20, 21,
3637  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3638  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3639  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3640  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
3641  62, -1, 64, 65, 66, -1, 68, 69, -1, -1,
3642  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3643  -1, -1, -1, -1, -1, -1, 88, -1, -1, 91,
3644  92, -1, 94, 95, -1, 97, -1, -1, 100, 101,
3645  102, 103, 104, 105, 106, 107, 108, -1, -1, -1,
3646  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3647  -1, -1, -1, -1, -1, -1, 128, 129, 130, -1,
3648  -1, -1, -1, -1, -1, -1, -1, -1, -1, 141,
3649  1, 143, 3, 4, 5, 6, 7, -1, -1, 10,
3650  11, 12, -1, -1, 15, 16, 17, 18, 19, 20,
3651  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3652  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3653  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3654  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3655  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
3656  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3657  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
3658  91, 92, -1, 94, 95, -1, 97, -1, -1, 100,
3659  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
3660  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3661  -1, -1, -1, -1, -1, -1, -1, 128, 129, 130,
3662  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3663  141, 1, 143, 3, 4, 5, 6, 7, -1, -1,
3664  10, 11, 12, -1, -1, 15, 16, -1, 18, 19,
3665  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3666  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3667  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
3668  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3669  60, 61, 62, -1, 64, 65, 66, -1, 68, 69,
3670  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3671  -1, -1, -1, -1, -1, -1, -1, -1, 88, -1,
3672  -1, 91, 92, -1, 94, 95, -1, 97, -1, -1,
3673  100, 101, 102, 103, 104, 105, 106, 107, 108, -1,
3674  -1, -1, -1, -1, -1, -1, 1, -1, 3, 4,
3675  5, 6, 7, -1, 9, 10, 11, 12, 128, 129,
3676  130, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3677  -1, 141, -1, 143, -1, 30, 31, 32, 33, 34,
3678  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3679  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3680  55, 56, 57, -1, 59, 60, 61, 62, -1, 64,
3681  65, 66, -1, 68, 69, -1, -1, -1, -1, -1,
3682  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3683  -1, -1, -1, 88, -1, -1, 91, 92, -1, 94,
3684  95, -1, 97, -1, -1, 100, 101, 102, 103, 104,
3685  105, 106, 107, 108, -1, -1, -1, -1, -1, -1,
3686  -1, 1, -1, 3, 4, 5, 6, 7, -1, -1,
3687  -1, 11, 12, 128, 129, 130, 16, -1, 18, 19,
3688  20, 21, 22, 23, 24, -1, 141, -1, 143, -1,
3689  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3690  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
3691  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3692  60, 61, 62, -1, 64, 65, 66, -1, 68, 69,
3693  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3694  -1, -1, -1, -1, -1, -1, -1, -1, 88, -1,
3695  -1, 91, 92, -1, 94, 95, -1, 97, -1, -1,
3696  100, 101, 102, 103, 104, 105, 106, 107, 108, -1,
3697  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3698  -1, -1, -1, -1, -1, -1, -1, -1, 128, 129,
3699  130, -1, -1, -1, -1, -1, -1, -1, -1, 139,
3700  -1, 141, 1, 143, 3, 4, 5, 6, 7, -1,
3701  -1, -1, 11, 12, -1, -1, -1, 16, -1, 18,
3702  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3703  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3704  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3705  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3706  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3707  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3708  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3709  -1, -1, 91, 92, -1, 94, 95, -1, 97, -1,
3710  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3711  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3712  -1, -1, -1, -1, -1, -1, -1, -1, -1, 128,
3713  129, 130, -1, -1, -1, -1, -1, -1, -1, -1,
3714  139, -1, 141, 1, 143, 3, 4, 5, 6, 7,
3715  -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
3716  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3717  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3718  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3719  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3720  -1, 59, 60, 61, 62, -1, 64, 65, 66, -1,
3721  68, 69, -1, -1, -1, -1, -1, -1, -1, -1,
3722  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3723  88, -1, -1, 91, 92, -1, 94, 95, -1, 97,
3724  -1, -1, 100, 101, 102, 103, 104, 105, 106, 107,
3725  108, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3726  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3727  128, 129, 130, -1, -1, 133, 1, -1, 3, 4,
3728  5, 6, 7, 141, -1, 143, 11, 12, -1, -1,
3729  -1, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3730  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3731  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3732  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3733  55, 56, 57, -1, 59, 60, 61, 62, -1, 64,
3734  65, 66, -1, 68, 69, -1, -1, -1, -1, -1,
3735  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3736  -1, -1, -1, 88, -1, -1, 91, 92, -1, 94,
3737  95, -1, 97, -1, -1, 100, 101, 102, 103, 104,
3738  105, 106, 107, 108, -1, -1, -1, -1, -1, -1,
3739  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3740  -1, -1, -1, 128, 129, 130, -1, -1, 133, -1,
3741  -1, -1, -1, -1, -1, -1, 141, 1, 143, 3,
3742  4, 5, 6, 7, -1, -1, 10, 11, 12, -1,
3743  -1, -1, 16, -1, 18, 19, 20, 21, 22, 23,
3744  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3745  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3746  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3747  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
3748  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3749  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3750  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3751  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
3752  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3753  -1, -1, 1, -1, 3, 4, 5, 6, 7, -1,
3754  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3755  19, 20, 21, 22, 23, 24, -1, 141, -1, 143,
3756  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3757  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3758  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3759  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3760  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3761  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3762  -1, -1, 91, 92, -1, 94, 95, -1, 97, -1,
3763  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3764  -1, 110, -1, -1, -1, -1, -1, -1, -1, 3,
3765  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
3766  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
3767  24, -1, 141, -1, 143, -1, 30, 31, 32, 33,
3768  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3769  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3770  54, 55, 56, 57, 58, 59, 60, 61, 62, -1,
3771  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3772  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3773  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3774  94, 95, -1, 97, 98, 99, 100, 101, 102, 103,
3775  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3776  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3777  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3778  19, 20, 21, 22, 23, 24, -1, -1, -1, 143,
3779  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3780  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3781  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3782  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3783  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3784  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3785  -1, -1, 91, 92, -1, 94, 95, -1, -1, -1,
3786  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3787  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3788  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
3789  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
3790  24, -1, 141, -1, 143, -1, 30, 31, 32, 33,
3791  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3792  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3793  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
3794  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3795  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3796  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3797  94, 95, -1, -1, -1, -1, 100, 101, 102, 103,
3798  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3799  -1, -1, -1, -1, 3, 4, 5, 6, 7, -1,
3800  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3801  19, 20, 21, 22, 23, 24, -1, -1, -1, 143,
3802  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3803  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3804  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3805  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3806  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3807  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3808  -1, -1, 91, 92, -1, 94, 95, -1, 97, -1,
3809  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3810  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3811  4, 5, 6, 7, -1, -1, -1, 11, 12, 128,
3812  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
3813  24, -1, 141, -1, -1, -1, 30, 31, 32, 33,
3814  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3815  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3816  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
3817  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3818  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3819  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3820  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
3821  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3822  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3823  -1, -1, -1, -1, 128, 129, 130, -1, -1, -1,
3824  -1, -1, -1, -1, -1, -1, -1, 141, 3, 4,
3825  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3826  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3827  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3828  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
3829  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3830  55, 56, 57, -1, -1, -1, -1, -1, -1, -1,
3831  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3832  75, 76, -1, -1, 79, 80, -1, -1, 83, 84,
3833  85, 86, -1, -1, -1, -1, -1, -1, -1, -1,
3834  -1, -1, 97, 98, -1, -1, -1, -1, -1, -1,
3835  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3836  -1, -1, -1, 118, 119, 120, 121, 122, 123, 124,
3837  125, 126, 127, -1, 129, 130, -1, -1, -1, -1,
3838  -1, -1, 137, 138, 3, 4, 5, 6, 7, 8,
3839  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
3840  19, 20, 21, 22, 23, 24, 25, 26, -1, -1,
3841  -1, 30, 31, 32, 33, 34, 35, 36, 37, 38,
3842  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3843  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3844  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
3845  69, 70, 71, 72, 73, 74, 75, 76, -1, -1,
3846  79, 80, -1, -1, 83, 84, 85, 86, -1, -1,
3847  -1, -1, -1, -1, -1, -1, -1, -1, 97, 98,
3848  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3849  -1, -1, -1, -1, -1, -1, -1, -1, -1, 118,
3850  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
3851  129, 130, -1, -1, -1, -1, -1, -1, 137, 3,
3852  4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3853  14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
3854  24, 25, 26, -1, -1, -1, 30, 31, 32, 33,
3855  34, 35, 36, 37, 38, 39, -1, -1, -1, -1,
3856  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3857  54, -1, 56, -1, -1, -1, -1, -1, -1, -1,
3858  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
3859  74, 75, 76, -1, -1, 79, 80, -1, -1, 83,
3860  84, 85, 86, -1, -1, -1, -1, -1, -1, -1,
3861  -1, -1, -1, 97, 98, -1, -1, 101, -1, -1,
3862  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3863  -1, -1, -1, -1, 118, 119, 120, 121, 122, 123,
3864  124, 125, 126, 127, -1, 129, 130, -1, -1, -1,
3865  -1, -1, -1, 137, 3, 4, 5, 6, 7, 8,
3866  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
3867  19, 20, 21, 22, 23, 24, 25, 26, -1, -1,
3868  -1, 30, 31, 32, 33, 34, 35, 36, 37, 38,
3869  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3870  49, 50, 51, 52, 53, -1, -1, 56, -1, -1,
3871  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
3872  69, 70, 71, 72, 73, 74, 75, 76, -1, -1,
3873  79, 80, -1, -1, 83, 84, 85, 86, -1, -1,
3874  -1, -1, -1, -1, -1, -1, -1, -1, 97, 98,
3875  -1, -1, 101, -1, -1, -1, -1, -1, -1, -1,
3876  -1, -1, -1, -1, -1, -1, -1, -1, -1, 118,
3877  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
3878  129, 130, -1, -1, -1, -1, -1, -1, 137, 3,
3879  4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3880  14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
3881  24, 25, 26, -1, -1, -1, 30, 31, 32, 33,
3882  34, 35, 36, 37, 38, 39, -1, -1, -1, -1,
3883  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3884  -1, -1, 56, -1, -1, -1, -1, -1, -1, -1,
3885  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
3886  74, 75, 76, -1, -1, 79, 80, -1, -1, 83,
3887  84, 85, 86, -1, -1, -1, -1, -1, -1, -1,
3888  -1, -1, -1, 97, 98, -1, -1, -1, -1, -1,
3889  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3890  -1, -1, -1, -1, 118, 119, 120, 121, 122, 123,
3891  124, 125, 126, 127, -1, 129, 130, 3, 4, 5,
3892  -1, 7, -1, 137, -1, 11, 12, -1, -1, -1,
3893  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3894  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3895  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3896  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3897  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
3898  66, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3899  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3900  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
3901  -1, -1, -1, -1, 100, 101, 102, 103, 104, 105,
3902  106, 107, 108, -1, -1, -1, -1, -1, 3, 4,
3903  5, -1, 7, -1, -1, -1, 11, 12, -1, -1,
3904  -1, 16, 128, 18, 19, 20, 21, 22, 23, 24,
3905  136, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3906  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3907  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3908  55, 56, 57, -1, 59, 60, 61, 62, -1, 64,
3909  65, 66, -1, -1, -1, -1, -1, -1, -1, -1,
3910  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3911  -1, -1, -1, 88, -1, -1, 91, 92, -1, 94,
3912  95, -1, -1, -1, -1, 100, 101, 102, 103, 104,
3913  105, 106, 107, 108, -1, -1, -1, -1, -1, 3,
3914  4, 5, 6, 7, -1, -1, -1, 11, 12, -1,
3915  -1, -1, 16, 128, 18, 19, 20, 21, 22, 23,
3916  24, 136, -1, -1, -1, -1, 30, 31, 32, 33,
3917  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3918  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3919  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
3920  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3921  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3922  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3923  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
3924  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3925  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3926  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3927  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3928  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3929  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3930  49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
3931  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3932  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3933  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3934  -1, -1, 91, 92, -1, 94, 95, -1, 97, 98,
3935  99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3936  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3937  4, 5, 6, 7, -1, -1, -1, 11, 12, 128,
3938  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
3939  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3940  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3941  -1, 45, 46, -1, 48, 49, 50, 51, 52, 53,
3942  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
3943  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3944  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3945  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3946  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
3947  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3948  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3949  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3950  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3951  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3952  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3953  49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
3954  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3955  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3956  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3957  -1, -1, 91, 92, -1, 94, 95, -1, 97, 98,
3958  99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3959  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3960  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
3961  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
3962  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3963  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3964  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3965  54, 55, 56, 57, 58, 59, 60, 61, 62, -1,
3966  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3967  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3968  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3969  94, 95, -1, 97, 98, -1, 100, 101, 102, 103,
3970  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3971  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3972  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3973  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3974  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3975  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3976  49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
3977  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3978  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3979  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3980  -1, -1, 91, 92, -1, 94, 95, -1, -1, 98,
3981  99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3982  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3983  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
3984  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
3985  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3986  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3987  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3988  54, 55, 56, 57, 58, 59, 60, 61, 62, -1,
3989  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3990  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3991  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3992  94, 95, -1, 97, 98, -1, 100, 101, 102, 103,
3993  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3994  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3995  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3996  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3997  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3998  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3999  49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
4000  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4001  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4002  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
4003  -1, -1, 91, 92, -1, 94, 95, -1, -1, 98,
4004  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
4005  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4006  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
4007  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
4008  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4009  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4010  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4011  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4012  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
4013  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4014  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
4015  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
4016  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
4017  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4018  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
4019  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4020  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4021  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4022  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4023  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4024  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4025  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
4026  -1, -1, 91, 92, -1, 94, 95, -1, 97, -1,
4027  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
4028  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4029  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
4030  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
4031  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4032  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4033  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4034  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4035  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
4036  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4037  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
4038  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
4039  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
4040  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4041  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
4042  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4043  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4044  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4045  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4046  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4047  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4048  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
4049  -1, -1, 91, 92, -1, 94, 95, -1, 97, -1,
4050  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
4051  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4052  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
4053  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
4054  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4055  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4056  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4057  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4058  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
4059  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4060  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
4061  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
4062  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
4063  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4064  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
4065  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4066  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4067  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4068  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4069  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4070  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4071  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
4072  -1, -1, 91, 92, -1, 94, 95, -1, -1, -1,
4073  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
4074  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4075  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
4076  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
4077  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4078  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4079  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4080  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4081  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
4082  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4083  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
4084  94, 95, -1, -1, -1, -1, 100, 101, 102, 103,
4085  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
4086  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4087  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
4088  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4089  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4090  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4091  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4092  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4093  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4094  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
4095  -1, -1, 91, 92, -1, 94, 95, -1, -1, -1,
4096  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
4097  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4098  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
4099  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
4100  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4101  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4102  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4103  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4104  64, 65, 66, -1, -1, -1, -1, -1, -1, -1,
4105  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4106  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
4107  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
4108  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
4109  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4110  -1, -1, -1, 16, 128, 18, 19, 20, 21, 22,
4111  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4112  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4113  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4114  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
4115  -1, 64, 65, 66, -1, -1, -1, -1, -1, -1,
4116  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4117  -1, -1, -1, -1, -1, 88, -1, -1, 91, 92,
4118  -1, 94, 95, -1, 97, -1, -1, 100, 101, 102,
4119  103, 104, 105, 106, 107, 108, -1, -1, -1, -1,
4120  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4121  12, -1, -1, -1, 16, 128, 18, 19, 20, 21,
4122  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4123  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4124  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4125  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4126  62, -1, 64, 65, 66, -1, -1, -1, -1, -1,
4127  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4128  -1, -1, -1, 85, -1, -1, 88, -1, -1, 91,
4129  92, -1, 94, 95, -1, -1, -1, -1, 100, 101,
4130  102, 103, 104, 105, 106, 107, 108, -1, -1, -1,
4131  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4132  11, 12, -1, -1, -1, 16, 128, 18, 19, 20,
4133  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4134  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4135  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4136  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4137  61, 62, -1, 64, 65, 66, -1, -1, -1, -1,
4138  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4139  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
4140  91, 92, -1, 94, 95, -1, -1, -1, -1, 100,
4141  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
4142  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4143  -1, 11, 12, -1, -1, -1, 16, 128, 18, 19,
4144  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4145  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4146  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4147  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4148  60, 61, 62, -1, 64, 65, 66, -1, -1, -1,
4149  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4150  -1, -1, -1, -1, -1, -1, -1, -1, 88, -1,
4151  -1, 91, 92, -1, 94, 95, -1, -1, -1, -1,
4152  100, 101, 102, 103, 104, 105, 106, 107, 108, -1,
4153  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4154  -1, -1, 11, 12, -1, -1, -1, 16, 128, 18,
4155  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4156  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4157  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4158  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4159  59, 60, 61, 62, -1, 64, 65, 66, -1, -1,
4160  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4161  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
4162  -1, -1, 91, 92, -1, 94, 95, -1, -1, -1,
4163  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
4164  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4165  -1, -1, -1, 11, 12, -1, -1, -1, 16, 128,
4166  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4167  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4168  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4169  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4170  -1, 59, 60, 61, 62, -1, 64, 65, 66, -1,
4171  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4172  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4173  88, -1, -1, 91, 92, -1, 94, 95, -1, -1,
4174  -1, -1, 100, 101, 102, 103, 104, 105, 106, 107,
4175  108, -1, -1, -1, -1, 52, 53, -1, -1, 56,
4176  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4177  128, 68, 69, 70, 71, 72, 73, 74, 75, 76,
4178  -1, -1, 79, 80, -1, -1, 83, 84, 85, 86,
4179  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4180  97, 98, -1, -1, -1, -1, -1, -1, -1, -1,
4181  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4182  -1, 118, 119, 120, 121, 122, 123, 124, 125, 126,
4183  127, -1, 129, 130, 52, 53, -1, -1, 56, -1,
4184  137, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4185  68, 69, 70, 71, 72, 73, 74, 75, 76, -1,
4186  -1, 79, 80, -1, -1, 83, 84, 85, 86, -1,
4187  -1, -1, -1, -1, -1, -1, -1, -1, -1, 97,
4188  98, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4189  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4190  118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
4191  -1, 129, 130, 52, 53, -1, -1, 56, -1, 137,
4192  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
4193  69, 70, 71, 72, 73, 74, 75, 76, -1, -1,
4194  79, 80, -1, -1, 83, 84, 85, 86, -1, -1,
4195  -1, -1, -1, -1, -1, -1, -1, -1, 97, 98,
4196  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4197  -1, -1, -1, -1, -1, -1, -1, -1, -1, 118,
4198  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
4199  129, 130, 52, 53, -1, -1, 56, -1, 137, -1,
4200  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
4201  70, 71, 72, 73, 74, 75, 76, -1, -1, 79,
4202  80, -1, -1, 83, 84, 85, 86, -1, -1, -1,
4203  -1, -1, -1, -1, -1, -1, -1, 97, 98, -1,
4204  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4205  -1, -1, -1, -1, -1, -1, -1, -1, 118, 119,
4206  120, 121, 122, 123, 124, 125, 126, 127, -1, 129,
4207  130, 52, 53, -1, -1, 56, -1, 137, -1, -1,
4208  -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
4209  71, 72, 73, 74, 75, 76, -1, -1, 79, 80,
4210  -1, -1, 83, 84, 85, 86, -1, -1, -1, -1,
4211  -1, -1, -1, -1, -1, -1, 97, 98, -1, -1,
4212  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4213  -1, -1, -1, -1, -1, -1, -1, 118, 119, 120,
4214  121, 122, 123, 124, 125, 126, 127, -1, 129, 130,
4215  52, 53, -1, -1, 56, -1, 137, -1, -1, -1,
4216  -1, -1, -1, -1, -1, -1, 68, 69, 70, 71,
4217  72, 73, 74, 75, 76, -1, -1, 79, 80, -1,
4218  -1, 83, 84, 85, 86, -1, -1, -1, -1, -1,
4219  -1, -1, -1, -1, -1, 97, 98, -1, -1, -1,
4220  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4221  -1, -1, -1, -1, -1, -1, 118, 119, 120, 121,
4222  122, 123, 124, 125, 126, 127, -1, 129, 130, 52,
4223  53, -1, -1, 56, -1, 137, -1, -1, -1, -1,
4224  -1, -1, -1, -1, -1, 68, 69, 70, 71, 72,
4225  73, 74, 75, 76, -1, -1, 79, 80, -1, -1,
4226  83, 84, 85, 86, -1, -1, -1, -1, -1, -1,
4227  -1, -1, -1, -1, 97, 98, -1, -1, -1, -1,
4228  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4229  -1, -1, -1, -1, -1, 118, 119, 120, 121, 122,
4230  123, 124, 125, 126, 127, -1, 129, 130, 52, 53,
4231  -1, -1, 56, -1, 137, -1, -1, -1, -1, -1,
4232  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
4233  74, 75, 76, -1, -1, 79, 80, -1, -1, 83,
4234  84, 85, 86, -1, -1, -1, -1, -1, -1, -1,
4235  -1, -1, -1, 97, 98, -1, -1, -1, -1, -1,
4236  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4237  -1, -1, -1, -1, 118, 119, 120, 121, 122, 123,
4238  124, 125, 126, 127, -1, 129, 130, 52, 53, -1,
4239  -1, 56, -1, 137, -1, -1, -1, -1, -1, -1,
4240  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
4241  75, 76, -1, -1, 79, 80, -1, -1, 83, 84,
4242  85, 86, -1, -1, -1, -1, -1, -1, -1, -1,
4243  -1, -1, 97, 98, -1, -1, -1, -1, -1, -1,
4244  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4245  -1, -1, -1, 118, 119, 120, 121, 122, 123, 124,
4246  125, 126, 127, -1, 129, 130, 52, 53, -1, -1,
4247  56, -1, 137, -1, -1, -1, -1, -1, -1, -1,
4248  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
4249  76, -1, -1, 79, 80, -1, -1, 83, 84, 85,
4250  86, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4251  -1, 97, 98, -1, -1, -1, -1, -1, -1, -1,
4252  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4253  -1, -1, 118, 119, 120, 121, 122, 123, 124, 125,
4254  126, 127, -1, 129, 130, 52, 53, -1, -1, 56,
4255  -1, 137, -1, -1, -1, -1, -1, -1, -1, -1,
4256  -1, 68, 69, 70, 71, 72, 73, 74, 75, 76,
4257  -1, -1, 79, 80, -1, -1, 83, 84, 85, 86,
4258  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4259  97, 98, -1, -1, -1, -1, -1, -1, -1, -1,
4260  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4261  -1, 118, 119, 120, 121, 122, 123, 124, 125, 126,
4262  127, -1, 129, 130, 52, 53, -1, -1, 56, -1,
4263  137, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4264  68, 69, 70, 71, 72, 73, 74, 75, 76, -1,
4265  -1, 79, 80, -1, -1, 83, 84, 85, 86, -1,
4266  -1, -1, -1, -1, -1, -1, -1, -1, -1, 97,
4267  98, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4268  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4269  118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
4270  -1, 129, 130, 52, 53, -1, -1, 56, -1, 137,
4271  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
4272  69, 70, 71, 72, 73, 74, 75, 76, -1, -1,
4273  79, 80, -1, -1, 83, 84, 85, 86, -1, -1,
4274  -1, -1, -1, -1, -1, -1, -1, -1, 97, 98,
4275  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
4276  80, 81, 82, -1, -1, 85, 86, -1, -1, 118,
4277  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
4278  129, 130, -1, -1, -1, -1, -1, -1, 137, -1,
4279  -1, -1, -1, -1, -1, -1, 116, -1, 118, 119,
4280  120, 121, 122, 123, 124, 125, 126, 127, -1, -1,
4281  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4282  -1, -1, -1, 143
4283 };
4284 
4285 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4286  symbol of state STATE-NUM. */
4287 static const yytype_uint16 yystos[] =
4288 {
4289  0, 145, 146, 0, 1, 3, 4, 5, 6, 7,
4290  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4291  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4292  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4293  57, 59, 60, 61, 62, 64, 65, 66, 68, 69,
4294  88, 91, 92, 94, 95, 97, 100, 101, 102, 103,
4295  104, 105, 106, 107, 108, 128, 129, 130, 147, 148,
4296  149, 156, 158, 159, 161, 162, 165, 166, 167, 169,
4297  170, 171, 173, 174, 184, 199, 218, 219, 220, 221,
4298  222, 223, 224, 225, 226, 227, 228, 255, 256, 270,
4299  271, 272, 273, 274, 275, 276, 279, 281, 282, 294,
4300  296, 297, 298, 299, 300, 301, 302, 303, 336, 347,
4301  149, 3, 4, 5, 6, 7, 8, 9, 10, 11,
4302  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
4303  22, 23, 24, 25, 26, 30, 31, 32, 33, 34,
4304  35, 36, 37, 38, 39, 45, 46, 47, 48, 49,
4305  50, 51, 52, 53, 56, 68, 69, 70, 71, 72,
4306  73, 74, 75, 76, 79, 80, 83, 84, 85, 86,
4307  97, 98, 118, 119, 120, 121, 122, 123, 124, 125,
4308  126, 127, 129, 130, 137, 177, 178, 179, 180, 182,
4309  183, 294, 296, 39, 58, 88, 91, 97, 98, 99,
4310  129, 166, 174, 184, 186, 191, 194, 196, 218, 299,
4311  300, 302, 303, 334, 335, 191, 191, 138, 192, 193,
4312  138, 188, 192, 138, 143, 341, 54, 179, 341, 150,
4313  132, 21, 22, 30, 31, 32, 165, 184, 218, 184,
4314  56, 1, 47, 91, 152, 153, 154, 156, 168, 169,
4315  347, 201, 202, 187, 196, 334, 347, 186, 333, 334,
4316  347, 46, 88, 128, 136, 173, 199, 218, 299, 300,
4317  303, 246, 247, 54, 55, 57, 177, 286, 295, 285,
4318  286, 287, 142, 277, 142, 283, 142, 280, 142, 284,
4319  298, 161, 184, 184, 141, 143, 340, 345, 346, 40,
4320  41, 42, 43, 44, 37, 38, 26, 132, 188, 192,
4321  261, 28, 253, 115, 136, 91, 97, 170, 115, 70,
4322  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
4323  81, 82, 85, 86, 116, 118, 119, 120, 121, 122,
4324  123, 124, 125, 126, 127, 87, 134, 135, 200, 159,
4325  160, 160, 205, 207, 160, 340, 346, 88, 167, 174,
4326  218, 234, 299, 300, 303, 52, 56, 85, 88, 175,
4327  176, 218, 299, 300, 303, 176, 33, 34, 35, 36,
4328  49, 50, 51, 52, 56, 138, 177, 301, 331, 87,
4329  135, 339, 261, 273, 89, 89, 136, 186, 56, 186,
4330  186, 186, 115, 90, 136, 195, 347, 87, 134, 135,
4331  89, 89, 136, 195, 191, 341, 342, 191, 190, 191,
4332  196, 334, 347, 159, 342, 159, 54, 65, 66, 157,
4333  138, 185, 132, 152, 87, 135, 89, 156, 155, 168,
4334  139, 340, 346, 342, 342, 159, 140, 136, 143, 344,
4335  136, 344, 133, 344, 341, 56, 298, 170, 172, 136,
4336  87, 134, 135, 248, 63, 109, 111, 112, 288, 112,
4337  288, 112, 67, 288, 112, 112, 278, 288, 112, 63,
4338  112, 112, 112, 278, 112, 63, 112, 70, 141, 149,
4339  160, 160, 160, 160, 156, 159, 159, 263, 262, 96,
4340  163, 254, 97, 161, 186, 196, 197, 198, 168, 136,
4341  173, 136, 158, 161, 174, 184, 186, 198, 184, 184,
4342  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
4343  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
4344  184, 184, 184, 184, 52, 53, 56, 182, 260, 337,
4345  338, 190, 52, 53, 56, 182, 259, 337, 151, 152,
4346  13, 230, 345, 230, 160, 160, 340, 17, 264, 56,
4347  87, 134, 135, 25, 159, 52, 56, 175, 1, 119,
4348  304, 345, 87, 134, 135, 214, 332, 215, 339, 52,
4349  56, 337, 161, 184, 161, 184, 181, 184, 186, 97,
4350  186, 194, 334, 52, 56, 190, 52, 56, 335, 342,
4351  139, 342, 136, 136, 342, 179, 204, 184, 147, 133,
4352  337, 337, 184, 132, 342, 154, 203, 334, 136, 172,
4353  52, 56, 190, 52, 56, 52, 54, 55, 56, 57,
4354  58, 70, 91, 97, 98, 99, 122, 125, 138, 251,
4355  308, 310, 311, 312, 313, 314, 315, 316, 319, 320,
4356  321, 322, 325, 326, 327, 328, 329, 290, 289, 142,
4357  288, 142, 142, 142, 184, 78, 120, 241, 242, 347,
4358  241, 164, 241, 186, 136, 342, 172, 136, 115, 44,
4359  341, 89, 89, 188, 192, 258, 341, 343, 89, 89,
4360  188, 192, 257, 10, 229, 8, 266, 347, 152, 13,
4361  152, 27, 231, 345, 231, 264, 196, 229, 52, 56,
4362  190, 52, 56, 209, 212, 345, 305, 211, 52, 56,
4363  175, 190, 151, 159, 138, 306, 307, 216, 188, 189,
4364  192, 347, 44, 179, 186, 195, 89, 89, 343, 89,
4365  89, 334, 159, 133, 147, 342, 344, 170, 343, 91,
4366  97, 235, 236, 237, 312, 310, 249, 115, 136, 309,
4367  186, 136, 330, 347, 52, 136, 330, 136, 309, 52,
4368  136, 309, 52, 291, 54, 55, 57, 293, 303, 238,
4369  240, 243, 312, 314, 315, 317, 318, 321, 323, 324,
4370  327, 329, 341, 152, 152, 241, 152, 97, 186, 172,
4371  184, 117, 161, 184, 161, 184, 163, 188, 140, 89,
4372  161, 184, 161, 184, 163, 189, 186, 198, 267, 347,
4373  15, 233, 347, 14, 232, 233, 233, 206, 208, 229,
4374  136, 230, 343, 160, 345, 160, 151, 343, 229, 342,
4375  310, 151, 310, 177, 261, 253, 184, 89, 136, 342,
4376  133, 237, 136, 312, 136, 342, 243, 250, 186, 308,
4377  313, 325, 327, 316, 321, 329, 314, 322, 327, 312,
4378  314, 292, 243, 120, 115, 136, 239, 88, 218, 136,
4379  330, 330, 136, 239, 136, 239, 141, 10, 133, 152,
4380  10, 186, 184, 161, 184, 90, 268, 347, 152, 9,
4381  269, 347, 160, 229, 229, 152, 152, 186, 152, 231,
4382  213, 345, 229, 342, 229, 345, 217, 342, 236, 136,
4383  97, 235, 139, 29, 113, 252, 136, 309, 136, 309,
4384  330, 136, 309, 136, 309, 309, 152, 120, 218, 238,
4385  324, 327, 56, 87, 317, 321, 314, 323, 327, 314,
4386  52, 244, 245, 311, 133, 88, 174, 218, 299, 300,
4387  303, 230, 152, 230, 229, 229, 233, 264, 265, 210,
4388  151, 306, 136, 236, 136, 312, 152, 152, 314, 327,
4389  314, 314, 110, 136, 239, 136, 239, 52, 56, 330,
4390  136, 239, 136, 239, 239, 136, 341, 56, 87, 134,
4391  135, 152, 152, 152, 229, 151, 236, 136, 10, 133,
4392  309, 136, 309, 309, 309, 314, 327, 314, 314, 245,
4393  52, 56, 190, 52, 56, 266, 232, 229, 229, 236,
4394  314, 239, 136, 239, 239, 239, 343, 309, 314, 239
4395 };
4396 
4397 #define yyerrok (yyerrstatus = 0)
4398 #define yyclearin (yychar = YYEMPTY)
4399 #define YYEMPTY (-2)
4400 #define YYEOF 0
4401 
4402 #define YYACCEPT goto yyacceptlab
4403 #define YYABORT goto yyabortlab
4404 #define YYERROR goto yyerrorlab
4405 
4406 
4407 /* Like YYERROR except do call yyerror. This remains here temporarily
4408  to ease the transition to the new meaning of YYERROR, for GCC.
4409  Once GCC version 2 has supplanted version 1, this can go. However,
4410  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
4411  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
4412  discussed. */
4413 
4414 #define YYFAIL goto yyerrlab
4415 #if defined YYFAIL
4416  /* This is here to suppress warnings from the GCC cpp's
4417  -Wunused-macros. Normally we don't worry about that warning, but
4418  some users do, and we want to make it easy for users to remove
4419  YYFAIL uses, which will produce warnings from Bison 2.5. */
4420 #endif
4421 
4422 #define YYRECOVERING() (!!yyerrstatus)
4423 
4424 #define YYBACKUP(Token, Value) \
4425 do \
4426  if (yychar == YYEMPTY && yylen == 1) \
4427  { \
4428  yychar = (Token); \
4429  yylval = (Value); \
4430  YYPOPSTACK (1); \
4431  goto yybackup; \
4432  } \
4433  else \
4434  { \
4435  parser_yyerror (parser, YY_("syntax error: cannot back up")); \
4436  YYERROR; \
4437  } \
4438 while (YYID (0))
4439 
4440 
4441 #define YYTERROR 1
4442 #define YYERRCODE 256
4443 
4444 
4445 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
4446  If N is 0, then set CURRENT to the empty location which ends
4447  the previous symbol: RHS[0] (always defined). */
4448 
4449 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
4450 #ifndef YYLLOC_DEFAULT
4451 # define YYLLOC_DEFAULT(Current, Rhs, N) \
4452  do \
4453  if (YYID (N)) \
4454  { \
4455  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
4456  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
4457  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
4458  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
4459  } \
4460  else \
4461  { \
4462  (Current).first_line = (Current).last_line = \
4463  YYRHSLOC (Rhs, 0).last_line; \
4464  (Current).first_column = (Current).last_column = \
4465  YYRHSLOC (Rhs, 0).last_column; \
4466  } \
4467  while (YYID (0))
4468 #endif
4469 
4470 
4471 /* This macro is provided for backward compatibility. */
4472 
4473 #ifndef YY_LOCATION_PRINT
4474 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
4475 #endif
4476 
4477 
4478 /* YYLEX -- calling `yylex' with the right arguments. */
4479 
4480 #ifdef YYLEX_PARAM
4481 # define YYLEX yylex (&yylval, YYLEX_PARAM)
4482 #else
4483 # define YYLEX yylex (&yylval, parser)
4484 #endif
4485 
4486 /* Enable debugging if requested. */
4487 #if YYDEBUG
4488 
4489 # ifndef YYFPRINTF
4490 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
4491 # define YYFPRINTF fprintf
4492 # endif
4493 
4494 # define YYDPRINTF(Args) \
4495 do { \
4496  if (yydebug) \
4497  YYFPRINTF Args; \
4498 } while (YYID (0))
4499 
4500 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
4501 do { \
4502  if (yydebug) \
4503  { \
4504  YYFPRINTF (stderr, "%s ", Title); \
4505  yy_symbol_print (stderr, \
4506  Type, Value, parser); \
4507  YYFPRINTF (stderr, "\n"); \
4508  } \
4509 } while (YYID (0))
4510 
4511 
4512 /*--------------------------------.
4513 | Print this symbol on YYOUTPUT. |
4514 `--------------------------------*/
4515 
4516 /*ARGSUSED*/
4517 #if (defined __STDC__ || defined __C99__FUNC__ \
4518  || defined __cplusplus || defined _MSC_VER)
4519 static void
4520 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4521 #else
4522 static void
4523 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
4524  FILE *yyoutput;
4525  int yytype;
4526  YYSTYPE const * const yyvaluep;
4527  struct parser_params *parser;
4528 #endif
4529 {
4530  if (!yyvaluep)
4531  return;
4532  YYUSE (parser);
4533 # ifdef YYPRINT
4534  if (yytype < YYNTOKENS)
4535  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4536 # else
4537  YYUSE (yyoutput);
4538 # endif
4539  switch (yytype)
4540  {
4541  default:
4542  break;
4543  }
4544 }
4545 
4546 
4547 /*--------------------------------.
4548 | Print this symbol on YYOUTPUT. |
4549 `--------------------------------*/
4550 
4551 #if (defined __STDC__ || defined __C99__FUNC__ \
4552  || defined __cplusplus || defined _MSC_VER)
4553 static void
4554 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4555 #else
4556 static void
4557 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
4558  FILE *yyoutput;
4559  int yytype;
4560  YYSTYPE const * const yyvaluep;
4561  struct parser_params *parser;
4562 #endif
4563 {
4564  if (yytype < YYNTOKENS)
4565  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4566  else
4567  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4568 
4569  yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
4570  YYFPRINTF (yyoutput, ")");
4571 }
4572 
4573 /*------------------------------------------------------------------.
4574 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4575 | TOP (included). |
4576 `------------------------------------------------------------------*/
4577 
4578 #if (defined __STDC__ || defined __C99__FUNC__ \
4579  || defined __cplusplus || defined _MSC_VER)
4580 static void
4581 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4582 #else
4583 static void
4584 yy_stack_print (yybottom, yytop)
4585  yytype_int16 *yybottom;
4586  yytype_int16 *yytop;
4587 #endif
4588 {
4589  YYFPRINTF (stderr, "Stack now");
4590  for (; yybottom <= yytop; yybottom++)
4591  {
4592  int yybot = *yybottom;
4593  YYFPRINTF (stderr, " %d", yybot);
4594  }
4595  YYFPRINTF (stderr, "\n");
4596 }
4597 
4598 # define YY_STACK_PRINT(Bottom, Top) \
4599 do { \
4600  if (yydebug) \
4601  yy_stack_print ((Bottom), (Top)); \
4602 } while (YYID (0))
4603 
4604 
4605 /*------------------------------------------------.
4606 | Report that the YYRULE is going to be reduced. |
4607 `------------------------------------------------*/
4608 
4609 #if (defined __STDC__ || defined __C99__FUNC__ \
4610  || defined __cplusplus || defined _MSC_VER)
4611 static void
4612 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
4613 #else
4614 static void
4615 yy_reduce_print (yyvsp, yyrule, parser)
4616  YYSTYPE *yyvsp;
4617  int yyrule;
4618  struct parser_params *parser;
4619 #endif
4621  int yynrhs = yyr2[yyrule];
4622  int yyi;
4623  unsigned long int yylno = yyrline[yyrule];
4624  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4625  yyrule - 1, yylno);
4626  /* The symbols being reduced. */
4627  for (yyi = 0; yyi < yynrhs; yyi++)
4628  {
4629  YYFPRINTF (stderr, " $%d = ", yyi + 1);
4630  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4631  &(yyvsp[(yyi + 1) - (yynrhs)])
4632  , parser);
4633  YYFPRINTF (stderr, "\n");
4634  }
4635 }
4636 
4637 # define YY_REDUCE_PRINT(Rule) \
4638 do { \
4639  if (yydebug) \
4640  yy_reduce_print (yyvsp, Rule, parser); \
4641 } while (YYID (0))
4642 
4643 /* Nonzero means print parse trace. It is left uninitialized so that
4644  multiple parsers can coexist. */
4645 #ifndef yydebug
4646 int yydebug;
4647 #endif
4648 #else /* !YYDEBUG */
4649 # define YYDPRINTF(Args)
4650 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4651 # define YY_STACK_PRINT(Bottom, Top)
4652 # define YY_REDUCE_PRINT(Rule)
4653 #endif /* !YYDEBUG */
4654 
4655 
4656 /* YYINITDEPTH -- initial size of the parser's stacks. */
4657 #ifndef YYINITDEPTH
4658 # define YYINITDEPTH 200
4659 #endif
4660 
4661 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4662  if the built-in stack extension method is used).
4663 
4664  Do not make this value too large; the results are undefined if
4665  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4666  evaluated with infinite-precision integer arithmetic. */
4667 
4668 #ifndef YYMAXDEPTH
4669 # define YYMAXDEPTH 10000
4670 #endif
4671 
4672 
4673 #if YYERROR_VERBOSE
4674 
4675 # ifndef yystrlen
4676 # if defined __GLIBC__ && defined _STRING_H
4677 # define yystrlen strlen
4678 # else
4679 /* Return the length of YYSTR. */
4680 #if (defined __STDC__ || defined __C99__FUNC__ \
4681  || defined __cplusplus || defined _MSC_VER)
4682 static YYSIZE_T
4683 yystrlen (const char *yystr)
4684 #else
4685 static YYSIZE_T
4686 yystrlen (yystr)
4687  const char *yystr;
4688 #endif
4690  YYSIZE_T yylen;
4691  for (yylen = 0; yystr[yylen]; yylen++)
4692  continue;
4693  return yylen;
4694 }
4695 # endif
4696 # endif
4697 
4698 # ifndef yystpcpy
4699 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4700 # define yystpcpy stpcpy
4701 # else
4702 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4703  YYDEST. */
4704 #if (defined __STDC__ || defined __C99__FUNC__ \
4705  || defined __cplusplus || defined _MSC_VER)
4706 static char *
4707 yystpcpy (char *yydest, const char *yysrc)
4708 #else
4709 static char *
4710 yystpcpy (yydest, yysrc)
4711  char *yydest;
4712  const char *yysrc;
4713 #endif
4714 {
4715  char *yyd = yydest;
4716  const char *yys = yysrc;
4717 
4718  while ((*yyd++ = *yys++) != '\0')
4719  continue;
4720 
4721  return yyd - 1;
4722 }
4723 # endif
4724 # endif
4725 
4726 # ifndef yytnamerr
4727 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4728  quotes and backslashes, so that it's suitable for yyerror. The
4729  heuristic is that double-quoting is unnecessary unless the string
4730  contains an apostrophe, a comma, or backslash (other than
4731  backslash-backslash). YYSTR is taken from yytname. If YYRES is
4732  null, do not copy; instead, return the length of what the result
4733  would have been. */
4734 static YYSIZE_T
4735 yytnamerr (char *yyres, const char *yystr)
4736 {
4737  if (*yystr == '"')
4738  {
4739  YYSIZE_T yyn = 0;
4740  char const *yyp = yystr;
4741 
4742  for (;;)
4743  switch (*++yyp)
4744  {
4745  case '\'':
4746  case ',':
4747  goto do_not_strip_quotes;
4748 
4749  case '\\':
4750  if (*++yyp != '\\')
4751  goto do_not_strip_quotes;
4752  /* Fall through. */
4753  default:
4754  if (yyres)
4755  yyres[yyn] = *yyp;
4756  yyn++;
4757  break;
4758 
4759  case '"':
4760  if (yyres)
4761  yyres[yyn] = '\0';
4762  return yyn;
4763  }
4764  do_not_strip_quotes: ;
4765  }
4766 
4767  if (! yyres)
4768  return yystrlen (yystr);
4769 
4770  return yystpcpy (yyres, yystr) - yyres;
4771 }
4772 # endif
4773 
4774 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
4775  about the unexpected token YYTOKEN for the state stack whose top is
4776  YYSSP.
4777 
4778  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
4779  not large enough to hold the message. In that case, also set
4780  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
4781  required number of bytes is too large to store. */
4782 static int
4784  yytype_int16 *yyssp, int yytoken)
4785 {
4786  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
4787  YYSIZE_T yysize = yysize0;
4788  YYSIZE_T yysize1;
4789  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4790  /* Internationalized format string. */
4791  const char *yyformat = 0;
4792  /* Arguments of yyformat. */
4793  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4794  /* Number of reported tokens (one for the "unexpected", one per
4795  "expected"). */
4796  int yycount = 0;
4797 
4798  /* There are many possibilities here to consider:
4799  - Assume YYFAIL is not used. It's too flawed to consider. See
4800  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
4801  for details. YYERROR is fine as it does not invoke this
4802  function.
4803  - If this state is a consistent state with a default action, then
4804  the only way this function was invoked is if the default action
4805  is an error action. In that case, don't check for expected
4806  tokens because there are none.
4807  - The only way there can be no lookahead present (in yychar) is if
4808  this state is a consistent state with a default action. Thus,
4809  detecting the absence of a lookahead is sufficient to determine
4810  that there is no unexpected or expected token to report. In that
4811  case, just report a simple "syntax error".
4812  - Don't assume there isn't a lookahead just because this state is a
4813  consistent state with a default action. There might have been a
4814  previous inconsistent state, consistent state with a non-default
4815  action, or user semantic action that manipulated yychar.
4816  - Of course, the expected token list depends on states to have
4817  correct lookahead information, and it depends on the parser not
4818  to perform extra reductions after fetching a lookahead from the
4819  scanner and before detecting a syntax error. Thus, state merging
4820  (from LALR or IELR) and default reductions corrupt the expected
4821  token list. However, the list is correct for canonical LR with
4822  one exception: it will still contain any token that will not be
4823  accepted due to an error action in a later state.
4824  */
4825  if (yytoken != YYEMPTY)
4826  {
4827  int yyn = yypact[*yyssp];
4828  yyarg[yycount++] = yytname[yytoken];
4829  if (!yypact_value_is_default (yyn))
4830  {
4831  /* Start YYX at -YYN if negative to avoid negative indexes in
4832  YYCHECK. In other words, skip the first -YYN actions for
4833  this state because they are default actions. */
4834  int yyxbegin = yyn < 0 ? -yyn : 0;
4835  /* Stay within bounds of both yycheck and yytname. */
4836  int yychecklim = YYLAST - yyn + 1;
4837  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4838  int yyx;
4839 
4840  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4841  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
4842  && !yytable_value_is_error (yytable[yyx + yyn]))
4843  {
4844  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4845  {
4846  yycount = 1;
4847  yysize = yysize0;
4848  break;
4849  }
4850  yyarg[yycount++] = yytname[yyx];
4851  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4852  if (! (yysize <= yysize1
4853  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4854  return 2;
4855  yysize = yysize1;
4856  }
4857  }
4858  }
4859 
4860  switch (yycount)
4861  {
4862 # define YYCASE_(N, S) \
4863  case N: \
4864  yyformat = S; \
4865  break
4866  YYCASE_(0, YY_("syntax error"));
4867  YYCASE_(1, YY_("syntax error, unexpected %s"));
4868  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
4869  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
4870  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
4871  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
4872 # undef YYCASE_
4873  }
4874 
4875  yysize1 = yysize + yystrlen (yyformat);
4876  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4877  return 2;
4878  yysize = yysize1;
4879 
4880  if (*yymsg_alloc < yysize)
4881  {
4882  *yymsg_alloc = 2 * yysize;
4883  if (! (yysize <= *yymsg_alloc
4884  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
4885  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
4886  return 1;
4887  }
4888 
4889  /* Avoid sprintf, as that infringes on the user's name space.
4890  Don't have undefined behavior even if the translation
4891  produced a string with the wrong number of "%s"s. */
4892  {
4893  char *yyp = *yymsg;
4894  int yyi = 0;
4895  while ((*yyp = *yyformat) != '\0')
4896  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
4897  {
4898  yyp += yytnamerr (yyp, yyarg[yyi++]);
4899  yyformat += 2;
4900  }
4901  else
4902  {
4903  yyp++;
4904  yyformat++;
4905  }
4906  }
4907  return 0;
4908 }
4909 #endif /* YYERROR_VERBOSE */
4910 
4911 /*-----------------------------------------------.
4912 | Release the memory associated to this symbol. |
4913 `-----------------------------------------------*/
4914 
4915 /*ARGSUSED*/
4916 #if (defined __STDC__ || defined __C99__FUNC__ \
4917  || defined __cplusplus || defined _MSC_VER)
4918 static void
4919 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
4920 #else
4921 static void
4922 yydestruct (yymsg, yytype, yyvaluep, parser)
4923  const char *yymsg;
4924  int yytype;
4925  YYSTYPE *yyvaluep;
4926  struct parser_params *parser;
4927 #endif
4928 {
4929  YYUSE (yyvaluep);
4930  YYUSE (parser);
4931 
4932  if (!yymsg)
4933  yymsg = "Deleting";
4934  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4935 
4936  switch (yytype)
4937  {
4938 
4939  default:
4940  break;
4941  }
4942 }
4943 
4944 
4945 /* Prevent warnings from -Wmissing-prototypes. */
4946 #ifdef YYPARSE_PARAM
4947 #if defined __STDC__ || defined __cplusplus
4948 int yyparse (void *YYPARSE_PARAM);
4949 #else
4950 int yyparse ();
4951 #endif
4952 #else /* ! YYPARSE_PARAM */
4953 #if defined __STDC__ || defined __cplusplus
4954 int yyparse (struct parser_params *parser);
4955 #else
4956 int yyparse ();
4957 #endif
4958 #endif /* ! YYPARSE_PARAM */
4959 
4960 
4961 /*----------.
4962 | yyparse. |
4963 `----------*/
4964 
4965 #ifdef YYPARSE_PARAM
4966 #if (defined __STDC__ || defined __C99__FUNC__ \
4967  || defined __cplusplus || defined _MSC_VER)
4968 int
4969 yyparse (void *YYPARSE_PARAM)
4970 #else
4971 int
4972 yyparse (YYPARSE_PARAM)
4973  void *YYPARSE_PARAM;
4974 #endif
4975 #else /* ! YYPARSE_PARAM */
4976 #if (defined __STDC__ || defined __C99__FUNC__ \
4977  || defined __cplusplus || defined _MSC_VER)
4978 int
4979 yyparse (struct parser_params *parser)
4980 #else
4981 int
4982 yyparse (parser)
4983  struct parser_params *parser;
4984 #endif
4985 #endif
4987 /* The lookahead symbol. */
4988 int yychar;
4989 
4990 /* The semantic value of the lookahead symbol. */
4991 YYSTYPE yylval;
4992 
4993  /* Number of syntax errors so far. */
4994  int yynerrs;
4995 
4996  int yystate;
4997  /* Number of tokens to shift before error messages enabled. */
4999 
5000  /* The stacks and their tools:
5001  `yyss': related to states.
5002  `yyvs': related to semantic values.
5003 
5004  Refer to the stacks thru separate pointers, to allow yyoverflow
5005  to reallocate them elsewhere. */
5006 
5007  /* The state stack. */
5008  yytype_int16 yyssa[YYINITDEPTH];
5009  yytype_int16 *yyss;
5010  yytype_int16 *yyssp;
5011 
5012  /* The semantic value stack. */
5015  YYSTYPE *yyvsp;
5016 
5018 
5019  int yyn;
5021  /* Lookahead token as an internal (translated) token number. */
5022  int yytoken;
5023  /* The variables used to return semantic value and location from the
5024  action routines. */
5026 
5027 #if YYERROR_VERBOSE
5028  /* Buffer for error messages, and its allocated size. */
5029  char yymsgbuf[128];
5030  char *yymsg = yymsgbuf;
5032 #endif
5033 
5034 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
5035 
5036  /* The number of symbols on the RHS of the reduced rule.
5037  Keep to zero when no symbol should be popped. */
5038  int yylen = 0;
5039 
5040  yytoken = 0;
5041  yyss = yyssa;
5042  yyvs = yyvsa;
5043  yystacksize = YYINITDEPTH;
5044 
5045  YYDPRINTF ((stderr, "Starting parse\n"));
5046 
5047  yystate = 0;
5048  yyerrstatus = 0;
5049  yynerrs = 0;
5050  yychar = YYEMPTY; /* Cause a token to be read. */
5051 
5052  /* Initialize stack pointers.
5053  Waste one element of value and location stack
5054  so that they stay on the same level as the state stack.
5055  The wasted elements are never initialized. */
5056  yyssp = yyss;
5057  yyvsp = yyvs;
5058 
5060 
5061 /*------------------------------------------------------------.
5062 | yynewstate -- Push a new state, which is found in yystate. |
5063 `------------------------------------------------------------*/
5064  yynewstate:
5065  /* In all cases, when you get here, the value and location stacks
5066  have just been pushed. So pushing a state here evens the stacks. */
5067  yyssp++;
5068 
5069  yysetstate:
5070  *yyssp = yystate;
5071 
5072  if (yyss + yystacksize - 1 <= yyssp)
5073  {
5074  /* Get the current used size of the three stacks, in elements. */
5075  YYSIZE_T yysize = yyssp - yyss + 1;
5076 
5077 #ifdef yyoverflow
5078  {
5079  /* Give user a chance to reallocate the stack. Use copies of
5080  these so that the &'s don't force the real ones into
5081  memory. */
5082  YYSTYPE *yyvs1 = yyvs;
5083  yytype_int16 *yyss1 = yyss;
5084 
5085  /* Each stack pointer address is followed by the size of the
5086  data in use in that stack, in bytes. This used to be a
5087  conditional around just the two extra args, but that might
5088  be undefined if yyoverflow is a macro. */
5089  yyoverflow (YY_("memory exhausted"),
5090  &yyss1, yysize * sizeof (*yyssp),
5091  &yyvs1, yysize * sizeof (*yyvsp),
5092  &yystacksize);
5093 
5094  yyss = yyss1;
5095  yyvs = yyvs1;
5096  }
5097 #else /* no yyoverflow */
5098 # ifndef YYSTACK_RELOCATE
5099  goto yyexhaustedlab;
5100 # else
5101  /* Extend the stack our own way. */
5102  if (YYMAXDEPTH <= yystacksize)
5103  goto yyexhaustedlab;
5104  yystacksize *= 2;
5105  if (YYMAXDEPTH < yystacksize)
5106  yystacksize = YYMAXDEPTH;
5107 
5108  {
5109  yytype_int16 *yyss1 = yyss;
5110  union yyalloc *yyptr =
5111  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
5112  if (! yyptr)
5113  goto yyexhaustedlab;
5114  YYSTACK_RELOCATE (yyss_alloc, yyss);
5115  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
5116 # undef YYSTACK_RELOCATE
5117  if (yyss1 != yyssa)
5118  YYSTACK_FREE (yyss1);
5119  }
5120 # endif
5121 #endif /* no yyoverflow */
5122 
5123  yyssp = yyss + yysize - 1;
5124  yyvsp = yyvs + yysize - 1;
5125 
5126  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
5127  (unsigned long int) yystacksize));
5128 
5129  if (yyss + yystacksize - 1 <= yyssp)
5130  YYABORT;
5131  }
5132 
5133  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
5134 
5135  if (yystate == YYFINAL)
5137 
5138  goto yybackup;
5139 
5140 /*-----------.
5141 | yybackup. |
5142 `-----------*/
5143 yybackup:
5144 
5145  /* Do appropriate processing given the current state. Read a
5146  lookahead token if we need one and don't already have one. */
5147 
5148  /* First try to decide what to do without reference to lookahead token. */
5149  yyn = yypact[yystate];
5150  if (yypact_value_is_default (yyn))
5152 
5153  /* Not known => get a lookahead token if don't already have one. */
5154 
5155  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5156  if (yychar == YYEMPTY)
5157  {
5158  YYDPRINTF ((stderr, "Reading a token: "));
5159  yychar = YYLEX;
5160  }
5161 
5162  if (yychar <= YYEOF)
5163  {
5164  yychar = yytoken = YYEOF;
5165  YYDPRINTF ((stderr, "Now at end of input.\n"));
5166  }
5167  else
5168  {
5169  yytoken = YYTRANSLATE (yychar);
5170  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
5171  }
5172 
5173  /* If the proper action on seeing token YYTOKEN is to reduce or to
5174  detect an error, take that action. */
5175  yyn += yytoken;
5176  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
5177  goto yydefault;
5178  yyn = yytable[yyn];
5179  if (yyn <= 0)
5180  {
5181  if (yytable_value_is_error (yyn))
5182  goto yyerrlab;
5183  yyn = -yyn;
5184  goto yyreduce;
5185  }
5186 
5187  /* Count tokens shifted since error; after three, turn off error
5188  status. */
5189  if (yyerrstatus)
5190  yyerrstatus--;
5191 
5192  /* Shift the lookahead token. */
5193  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
5194 
5195  /* Discard the shifted token. */
5196  yychar = YYEMPTY;
5197 
5198  yystate = yyn;
5199  *++yyvsp = yylval;
5200 
5202 
5203 
5204 /*-----------------------------------------------------------.
5205 | yydefault -- do the default action for the current state. |
5206 `-----------------------------------------------------------*/
5207 yydefault:
5208  yyn = yydefact[yystate];
5209  if (yyn == 0)
5210  goto yyerrlab;
5211  goto yyreduce;
5212 
5213 
5214 /*-----------------------------.
5215 | yyreduce -- Do a reduction. |
5216 `-----------------------------*/
5217 yyreduce:
5218  /* yyn is the number of a rule to reduce with. */
5219  yylen = yyr2[yyn];
5220 
5221  /* If YYLEN is nonzero, implement the default value of the action:
5222  `$$ = $1'.
5223 
5224  Otherwise, the following line sets YYVAL to garbage.
5225  This behavior is undocumented and Bison
5226  users should not rely upon it. Assigning to YYVAL
5227  unconditionally makes the parser a bit smaller, and it avoids a
5228  GCC warning that YYVAL may be used uninitialized. */
5229  yyval = yyvsp[1-yylen];
5230 
5231 
5232  YY_REDUCE_PRINT (yyn);
5233  switch (yyn)
5234  {
5235  case 2:
5236 
5237 /* Line 1806 of yacc.c */
5238 #line 863 "ripper.y"
5239  {
5240  lex_state = EXPR_BEG;
5241 #if 0
5243 #endif
5244  local_push(0);
5245 
5246  }
5247  break;
5248 
5249  case 3:
5250 
5251 /* Line 1806 of yacc.c */
5252 #line 872 "ripper.y"
5253  {
5254 #if 0
5255  if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
5256  /* last expression should not be void */
5257  if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
5258  else {
5259  NODE *node = (yyvsp[(2) - (2)].val);
5260  while (node->nd_next) {
5261  node = node->nd_next;
5262  }
5263  void_expr(node->nd_head);
5264  }
5265  }
5266  ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val)));
5267 #endif
5268  (yyval.val) = (yyvsp[(2) - (2)].val);
5269  parser->result = dispatch1(program, (yyval.val));
5270 
5271  local_pop();
5272  }
5273  break;
5274 
5275  case 4:
5276 
5277 /* Line 1806 of yacc.c */
5278 #line 895 "ripper.y"
5279  {
5280 #if 0
5281  void_stmts((yyvsp[(1) - (2)].val));
5283 #endif
5284 
5285  (yyval.val) = (yyvsp[(1) - (2)].val);
5286  }
5287  break;
5288 
5289  case 5:
5290 
5291 /* Line 1806 of yacc.c */
5292 #line 906 "ripper.y"
5293  {
5294 #if 0
5295  (yyval.val) = NEW_BEGIN(0);
5296 #endif
5297  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5298  dispatch0(void_stmt));
5299 
5300  }
5301  break;
5302 
5303  case 6:
5304 
5305 /* Line 1806 of yacc.c */
5306 #line 915 "ripper.y"
5307  {
5308 #if 0
5309  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5310 #endif
5311  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5312 
5313  }
5314  break;
5315 
5316  case 7:
5317 
5318 /* Line 1806 of yacc.c */
5319 #line 923 "ripper.y"
5320  {
5321 #if 0
5322  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5323 #endif
5324  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5325 
5326  }
5327  break;
5328 
5329  case 8:
5330 
5331 /* Line 1806 of yacc.c */
5332 #line 931 "ripper.y"
5333  {
5334  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5335  }
5336  break;
5337 
5338  case 10:
5339 
5340 /* Line 1806 of yacc.c */
5341 #line 938 "ripper.y"
5342  {
5343 #if 0
5344  /* local_push(0); */
5345 #endif
5346 
5347  }
5348  break;
5349 
5350  case 11:
5351 
5352 /* Line 1806 of yacc.c */
5353 #line 945 "ripper.y"
5354  {
5355 #if 0
5357  (yyvsp[(4) - (5)].val));
5358  /* NEW_PREEXE($4)); */
5359  /* local_pop(); */
5360  (yyval.val) = NEW_BEGIN(0);
5361 #endif
5362  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5363 
5364  }
5365  break;
5366 
5367  case 12:
5368 
5369 /* Line 1806 of yacc.c */
5370 #line 962 "ripper.y"
5371  {
5372 #if 0
5373  (yyval.val) = (yyvsp[(1) - (4)].val);
5374  if ((yyvsp[(2) - (4)].val)) {
5375  (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
5376  }
5377  else if ((yyvsp[(3) - (4)].val)) {
5378  rb_warn0("else without rescue is useless");
5379  (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val));
5380  }
5381  if ((yyvsp[(4) - (4)].val)) {
5382  if ((yyval.val)) {
5383  (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
5384  }
5385  else {
5386  (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL());
5387  }
5388  }
5389  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5390 #endif
5391  (yyval.val) = dispatch4(bodystmt,
5392  escape_Qundef((yyvsp[(1) - (4)].val)),
5393  escape_Qundef((yyvsp[(2) - (4)].val)),
5394  escape_Qundef((yyvsp[(3) - (4)].val)),
5395  escape_Qundef((yyvsp[(4) - (4)].val)));
5396 
5397  }
5398  break;
5399 
5400  case 13:
5401 
5402 /* Line 1806 of yacc.c */
5403 #line 992 "ripper.y"
5404  {
5405 #if 0
5406  void_stmts((yyvsp[(1) - (2)].val));
5408 #endif
5409 
5410  (yyval.val) = (yyvsp[(1) - (2)].val);
5411  }
5412  break;
5413 
5414  case 14:
5415 
5416 /* Line 1806 of yacc.c */
5417 #line 1003 "ripper.y"
5418  {
5419 #if 0
5420  (yyval.val) = NEW_BEGIN(0);
5421 #endif
5422  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5423  dispatch0(void_stmt));
5424 
5425  }
5426  break;
5427 
5428  case 15:
5429 
5430 /* Line 1806 of yacc.c */
5431 #line 1012 "ripper.y"
5432  {
5433 #if 0
5434  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5435 #endif
5436  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5437 
5438  }
5439  break;
5440 
5441  case 16:
5442 
5443 /* Line 1806 of yacc.c */
5444 #line 1020 "ripper.y"
5445  {
5446 #if 0
5447  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5448 #endif
5449  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5450 
5451  }
5452  break;
5453 
5454  case 17:
5455 
5456 /* Line 1806 of yacc.c */
5457 #line 1028 "ripper.y"
5458  {
5459  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5460  }
5461  break;
5462 
5463  case 18:
5464 
5465 /* Line 1806 of yacc.c */
5466 #line 1034 "ripper.y"
5467  {
5468  (yyval.val) = (yyvsp[(1) - (1)].val);
5469  }
5470  break;
5471 
5472  case 19:
5473 
5474 /* Line 1806 of yacc.c */
5475 #line 1038 "ripper.y"
5476  {
5477  yyerror("BEGIN is permitted only at toplevel");
5478 #if 0
5479  /* local_push(0); */
5480 #endif
5481 
5482  }
5483  break;
5484 
5485  case 20:
5486 
5487 /* Line 1806 of yacc.c */
5488 #line 1046 "ripper.y"
5489  {
5490 #if 0
5492  (yyvsp[(4) - (5)].val));
5493  /* NEW_PREEXE($4)); */
5494  /* local_pop(); */
5495  (yyval.val) = NEW_BEGIN(0);
5496 #endif
5497  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5498 
5499  }
5500  break;
5501 
5502  case 21:
5503 
5504 /* Line 1806 of yacc.c */
5505 #line 1058 "ripper.y"
5506  {lex_state = EXPR_FNAME;}
5507  break;
5508 
5509  case 22:
5510 
5511 /* Line 1806 of yacc.c */
5512 #line 1059 "ripper.y"
5513  {
5514 #if 0
5515  (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5516 #endif
5517  (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5518 
5519  }
5520  break;
5521 
5522  case 23:
5523 
5524 /* Line 1806 of yacc.c */
5525 #line 1067 "ripper.y"
5526  {
5527 #if 0
5528  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5529 #endif
5530  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5531 
5532  }
5533  break;
5534 
5535  case 24:
5536 
5537 /* Line 1806 of yacc.c */
5538 #line 1075 "ripper.y"
5539  {
5540 #if 0
5541  char buf[2];
5542  buf[0] = '$';
5543  buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
5544  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
5545 #endif
5546  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5547 
5548  }
5549  break;
5550 
5551  case 25:
5552 
5553 /* Line 1806 of yacc.c */
5554 #line 1086 "ripper.y"
5555  {
5556 #if 0
5557  yyerror("can't make alias for the number variables");
5558  (yyval.val) = NEW_BEGIN(0);
5559 #endif
5560  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5561  (yyval.val) = dispatch1(alias_error, (yyval.val));
5562 
5563  }
5564  break;
5565 
5566  case 26:
5567 
5568 /* Line 1806 of yacc.c */
5569 #line 1096 "ripper.y"
5570  {
5571 #if 0
5572  (yyval.val) = (yyvsp[(2) - (2)].val);
5573 #endif
5574  (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
5575 
5576  }
5577  break;
5578 
5579  case 27:
5580 
5581 /* Line 1806 of yacc.c */
5582 #line 1104 "ripper.y"
5583  {
5584 #if 0
5585  (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5586  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5587 #endif
5588  (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5589 
5590  }
5591  break;
5592 
5593  case 28:
5594 
5595 /* Line 1806 of yacc.c */
5596 #line 1113 "ripper.y"
5597  {
5598 #if 0
5599  (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5600  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5601 #endif
5602  (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5603 
5604  }
5605  break;
5606 
5607  case 29:
5608 
5609 /* Line 1806 of yacc.c */
5610 #line 1122 "ripper.y"
5611  {
5612 #if 0
5613  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5614  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5615  }
5616  else {
5617  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5618  }
5619 #endif
5620  (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5621 
5622  }
5623  break;
5624 
5625  case 30:
5626 
5627 /* Line 1806 of yacc.c */
5628 #line 1135 "ripper.y"
5629  {
5630 #if 0
5631  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5632  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5633  }
5634  else {
5635  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5636  }
5637 #endif
5638  (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5639 
5640  }
5641  break;
5642 
5643  case 31:
5644 
5645 /* Line 1806 of yacc.c */
5646 #line 1148 "ripper.y"
5647  {
5648 #if 0
5649  NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0);
5650  (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0);
5651 #endif
5652  (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5653 
5654  }
5655  break;
5656 
5657  case 32:
5658 
5659 /* Line 1806 of yacc.c */
5660 #line 1157 "ripper.y"
5661  {
5662  if (in_def || in_single) {
5663  rb_warn0("END in method; use at_exit");
5664  }
5665 #if 0
5666  (yyval.val) = NEW_POSTEXE(NEW_NODE(
5667  NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */));
5668 #endif
5669  (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
5670 
5671  }
5672  break;
5673 
5674  case 34:
5675 
5676 /* Line 1806 of yacc.c */
5677 #line 1170 "ripper.y"
5678  {
5679 #if 0
5680  value_expr((yyvsp[(3) - (3)].val));
5681  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5682  (yyval.val) = (yyvsp[(1) - (3)].val);
5683 #endif
5684  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5685 
5686  }
5687  break;
5688 
5689  case 35:
5690 
5691 /* Line 1806 of yacc.c */
5692 #line 1180 "ripper.y"
5693  {
5694  value_expr((yyvsp[(3) - (3)].val));
5695  (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5696  }
5697  break;
5698 
5699  case 36:
5700 
5701 /* Line 1806 of yacc.c */
5702 #line 1185 "ripper.y"
5703  {
5704 #if 0
5705  NODE *args;
5706 
5707  value_expr((yyvsp[(6) - (6)].val));
5708  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
5709  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
5710  if ((yyvsp[(5) - (6)].val) == tOROP) {
5711  (yyvsp[(5) - (6)].val) = 0;
5712  }
5713  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
5714  (yyvsp[(5) - (6)].val) = 1;
5715  }
5716  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
5717  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
5718 #endif
5719  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
5720  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
5721 
5722  }
5723  break;
5724 
5725  case 37:
5726 
5727 /* Line 1806 of yacc.c */
5728 #line 1206 "ripper.y"
5729  {
5730  value_expr((yyvsp[(5) - (5)].val));
5731  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5732  }
5733  break;
5734 
5735  case 38:
5736 
5737 /* Line 1806 of yacc.c */
5738 #line 1211 "ripper.y"
5739  {
5740  value_expr((yyvsp[(5) - (5)].val));
5741  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5742  }
5743  break;
5744 
5745  case 39:
5746 
5747 /* Line 1806 of yacc.c */
5748 #line 1216 "ripper.y"
5749  {
5750 #if 0
5751  (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
5752  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5753 #endif
5754  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
5755  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5756 
5757  }
5758  break;
5759 
5760  case 40:
5761 
5762 /* Line 1806 of yacc.c */
5763 #line 1226 "ripper.y"
5764  {
5765  value_expr((yyvsp[(5) - (5)].val));
5766  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5767  }
5768  break;
5769 
5770  case 41:
5771 
5772 /* Line 1806 of yacc.c */
5773 #line 1231 "ripper.y"
5774  {
5775 #if 0
5776  rb_backref_error((yyvsp[(1) - (3)].val));
5777  (yyval.val) = NEW_BEGIN(0);
5778 #endif
5779  (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
5780  (yyval.val) = dispatch1(assign_error, (yyval.val));
5781 
5782  }
5783  break;
5784 
5785  case 42:
5786 
5787 /* Line 1806 of yacc.c */
5788 #line 1241 "ripper.y"
5789  {
5790 #if 0
5791  value_expr((yyvsp[(3) - (3)].val));
5792  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5793 #endif
5794  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5795 
5796  }
5797  break;
5798 
5799  case 43:
5800 
5801 /* Line 1806 of yacc.c */
5802 #line 1250 "ripper.y"
5803  {
5804 #if 0
5805  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5806  (yyval.val) = (yyvsp[(1) - (3)].val);
5807 #endif
5808  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5809 
5810  }
5811  break;
5812 
5813  case 45:
5814 
5815 /* Line 1806 of yacc.c */
5816 #line 1262 "ripper.y"
5817  {
5818 #if 0
5819  value_expr((yyvsp[(3) - (3)].val));
5820  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5821 #endif
5822  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5823 
5824  }
5825  break;
5826 
5827  case 46:
5828 
5829 /* Line 1806 of yacc.c */
5830 #line 1271 "ripper.y"
5831  {
5832 #if 0
5833  value_expr((yyvsp[(3) - (3)].val));
5834  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5835 #endif
5836  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5837 
5838  }
5839  break;
5840 
5841  case 48:
5842 
5843 /* Line 1806 of yacc.c */
5844 #line 1284 "ripper.y"
5845  {
5846 #if 0
5847  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5848 #endif
5849  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val));
5850 
5851  }
5852  break;
5853 
5854  case 49:
5855 
5856 /* Line 1806 of yacc.c */
5857 #line 1292 "ripper.y"
5858  {
5859 #if 0
5860  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5861 #endif
5862  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val));
5863 
5864  }
5865  break;
5866 
5867  case 50:
5868 
5869 /* Line 1806 of yacc.c */
5870 #line 1300 "ripper.y"
5871  {
5872 #if 0
5873  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!');
5874 #endif
5875  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val));
5876 
5877  }
5878  break;
5879 
5880  case 51:
5881 
5882 /* Line 1806 of yacc.c */
5883 #line 1308 "ripper.y"
5884  {
5885 #if 0
5886  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
5887 #endif
5888  (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val));
5889 
5890  }
5891  break;
5892 
5893  case 53:
5894 
5895 /* Line 1806 of yacc.c */
5896 #line 1319 "ripper.y"
5897  {
5898 #if 0
5899  value_expr((yyvsp[(1) - (1)].val));
5900  (yyval.val) = (yyvsp[(1) - (1)].val);
5901  if (!(yyval.val)) (yyval.val) = NEW_NIL();
5902 #endif
5903  (yyval.val) = (yyvsp[(1) - (1)].val);
5904 
5905  }
5906  break;
5907 
5908  case 57:
5909 
5910 /* Line 1806 of yacc.c */
5911 #line 1336 "ripper.y"
5912  {
5913 #if 0
5914  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5915 #endif
5916  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
5917  (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
5918 
5919  }
5920  break;
5921 
5922  case 58:
5923 
5924 /* Line 1806 of yacc.c */
5925 #line 1347 "ripper.y"
5926  {
5927  (yyvsp[(1) - (1)].vars) = dyna_push();
5928 #if 0
5929  (yyval.num) = ruby_sourceline;
5930 #endif
5931 
5932  }
5933  break;
5934 
5935  case 59:
5936 
5937 /* Line 1806 of yacc.c */
5938 #line 1357 "ripper.y"
5939  {
5940 #if 0
5941  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
5942  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
5943 #endif
5944  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
5945 
5946  dyna_pop((yyvsp[(1) - (5)].vars));
5947  }
5948  break;
5949 
5950  case 60:
5951 
5952 /* Line 1806 of yacc.c */
5953 #line 1369 "ripper.y"
5954  {
5955 #if 0
5956  (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
5957  nd_set_line((yyval.val), tokline);
5958 #endif
5959 
5960  }
5961  break;
5962 
5963  case 61:
5964 
5965 /* Line 1806 of yacc.c */
5966 #line 1379 "ripper.y"
5967  {
5968 #if 0
5969  (yyval.val) = (yyvsp[(1) - (2)].val);
5970  (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
5971 #endif
5972  (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
5973 
5974  }
5975  break;
5976 
5977  case 62:
5978 
5979 /* Line 1806 of yacc.c */
5980 #line 1388 "ripper.y"
5981  {
5982 #if 0
5983  block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
5984  (yyvsp[(1) - (3)].val)->nd_args = (yyvsp[(2) - (3)].val);
5985  (yyvsp[(3) - (3)].val)->nd_iter = (yyvsp[(1) - (3)].val);
5986  (yyval.val) = (yyvsp[(3) - (3)].val);
5987  fixpos((yyval.val), (yyvsp[(1) - (3)].val));
5988 #endif
5989  (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
5990  (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
5991 
5992  }
5993  break;
5994 
5995  case 63:
5996 
5997 /* Line 1806 of yacc.c */
5998 #line 1401 "ripper.y"
5999  {
6000 #if 0
6001  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6002  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
6003 #endif
6004  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6005 
6006  }
6007  break;
6008 
6009  case 64:
6010 
6011 /* Line 1806 of yacc.c */
6012 #line 1410 "ripper.y"
6013  {
6014 #if 0
6015  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
6016  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6017  (yyval.val) = (yyvsp[(5) - (5)].val);
6018  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6019 #endif
6020  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6021  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
6022 
6023  }
6024  break;
6025 
6026  case 65:
6027 
6028 /* Line 1806 of yacc.c */
6029 #line 1422 "ripper.y"
6030  {
6031 #if 0
6032  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6033  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
6034 #endif
6035  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6036 
6037  }
6038  break;
6039 
6040  case 66:
6041 
6042 /* Line 1806 of yacc.c */
6043 #line 1431 "ripper.y"
6044  {
6045 #if 0
6046  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
6047  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6048  (yyval.val) = (yyvsp[(5) - (5)].val);
6049  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6050 #endif
6051  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6052  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
6053 
6054  }
6055  break;
6056 
6057  case 67:
6058 
6059 /* Line 1806 of yacc.c */
6060 #line 1443 "ripper.y"
6061  {
6062 #if 0
6063  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
6064  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
6065 #endif
6066  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
6067 
6068  }
6069  break;
6070 
6071  case 68:
6072 
6073 /* Line 1806 of yacc.c */
6074 #line 1452 "ripper.y"
6075  {
6076 #if 0
6077  (yyval.val) = new_yield((yyvsp[(2) - (2)].val));
6078  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
6079 #endif
6080  (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
6081 
6082  }
6083  break;
6084 
6085  case 69:
6086 
6087 /* Line 1806 of yacc.c */
6088 #line 1461 "ripper.y"
6089  {
6090 #if 0
6091  (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
6092 #endif
6093  (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
6094 
6095  }
6096  break;
6097 
6098  case 70:
6099 
6100 /* Line 1806 of yacc.c */
6101 #line 1469 "ripper.y"
6102  {
6103 #if 0
6104  (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
6105 #endif
6106  (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
6107 
6108  }
6109  break;
6110 
6111  case 71:
6112 
6113 /* Line 1806 of yacc.c */
6114 #line 1477 "ripper.y"
6115  {
6116 #if 0
6117  (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
6118 #endif
6119  (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
6120 
6121  }
6122  break;
6123 
6124  case 73:
6125 
6126 /* Line 1806 of yacc.c */
6127 #line 1488 "ripper.y"
6128  {
6129 #if 0
6130  (yyval.val) = (yyvsp[(2) - (3)].val);
6131 #endif
6132  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6133 
6134  }
6135  break;
6136 
6137  case 75:
6138 
6139 /* Line 1806 of yacc.c */
6140 #line 1499 "ripper.y"
6141  {
6142 #if 0
6143  (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0);
6144 #endif
6145  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6146 
6147  }
6148  break;
6149 
6150  case 76:
6151 
6152 /* Line 1806 of yacc.c */
6153 #line 1509 "ripper.y"
6154  {
6155 #if 0
6156  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
6157 #endif
6158  (yyval.val) = (yyvsp[(1) - (1)].val);
6159 
6160  }
6161  break;
6162 
6163  case 77:
6164 
6165 /* Line 1806 of yacc.c */
6166 #line 1517 "ripper.y"
6167  {
6168 #if 0
6169  (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0);
6170 #endif
6171  (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
6172 
6173  }
6174  break;
6175 
6176  case 78:
6177 
6178 /* Line 1806 of yacc.c */
6179 #line 1525 "ripper.y"
6180  {
6181 #if 0
6182  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6183 #endif
6184  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6185 
6186  }
6187  break;
6188 
6189  case 79:
6190 
6191 /* Line 1806 of yacc.c */
6192 #line 1533 "ripper.y"
6193  {
6194 #if 0
6195  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val)));
6196 #endif
6197  (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6198  (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
6199 
6200  }
6201  break;
6202 
6203  case 80:
6204 
6205 /* Line 1806 of yacc.c */
6206 #line 1542 "ripper.y"
6207  {
6208 #if 0
6209  (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1);
6210 #endif
6211  (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
6212 
6213  }
6214  break;
6215 
6216  case 81:
6217 
6218 /* Line 1806 of yacc.c */
6219 #line 1550 "ripper.y"
6220  {
6221 #if 0
6222  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
6223 #endif
6224  (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
6225  (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6226 
6227  }
6228  break;
6229 
6230  case 82:
6231 
6232 /* Line 1806 of yacc.c */
6233 #line 1559 "ripper.y"
6234  {
6235 #if 0
6236  (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
6237 #endif
6238  (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
6239 
6240  }
6241  break;
6242 
6243  case 83:
6244 
6245 /* Line 1806 of yacc.c */
6246 #line 1567 "ripper.y"
6247  {
6248 #if 0
6249  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
6250 #endif
6251  (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
6252  (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
6253 
6254  }
6255  break;
6256 
6257  case 84:
6258 
6259 /* Line 1806 of yacc.c */
6260 #line 1576 "ripper.y"
6261  {
6262 #if 0
6263  (yyval.val) = NEW_MASGN(0, -1);
6264 #endif
6265  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6266 
6267  }
6268  break;
6269 
6270  case 85:
6271 
6272 /* Line 1806 of yacc.c */
6273 #line 1584 "ripper.y"
6274  {
6275 #if 0
6276  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
6277 #endif
6278  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6279  (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
6280 
6281  }
6282  break;
6283 
6284  case 87:
6285 
6286 /* Line 1806 of yacc.c */
6287 #line 1596 "ripper.y"
6288  {
6289 #if 0
6290  (yyval.val) = (yyvsp[(2) - (3)].val);
6291 #endif
6292  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6293 
6294  }
6295  break;
6296 
6297  case 88:
6298 
6299 /* Line 1806 of yacc.c */
6300 #line 1606 "ripper.y"
6301  {
6302 #if 0
6303  (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
6304 #endif
6305  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
6306 
6307  }
6308  break;
6309 
6310  case 89:
6311 
6312 /* Line 1806 of yacc.c */
6313 #line 1614 "ripper.y"
6314  {
6315 #if 0
6316  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6317 #endif
6318  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6319 
6320  }
6321  break;
6322 
6323  case 90:
6324 
6325 /* Line 1806 of yacc.c */
6326 #line 1624 "ripper.y"
6327  {
6328 #if 0
6329  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
6330 #endif
6331  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
6332 
6333  }
6334  break;
6335 
6336  case 91:
6337 
6338 /* Line 1806 of yacc.c */
6339 #line 1632 "ripper.y"
6340  {
6341 #if 0
6342  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6343 #endif
6344  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6345 
6346  }
6347  break;
6348 
6349  case 92:
6350 
6351 /* Line 1806 of yacc.c */
6352 #line 1642 "ripper.y"
6353  {
6354  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6355  }
6356  break;
6357 
6358  case 93:
6359 
6360 /* Line 1806 of yacc.c */
6361 #line 1646 "ripper.y"
6362  {
6363  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6364  }
6365  break;
6366 
6367  case 94:
6368 
6369 /* Line 1806 of yacc.c */
6370 #line 1650 "ripper.y"
6371  {
6372 #if 0
6373  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6374 #endif
6375  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6376 
6377  }
6378  break;
6379 
6380  case 95:
6381 
6382 /* Line 1806 of yacc.c */
6383 #line 1658 "ripper.y"
6384  {
6385 #if 0
6386  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6387 #endif
6388  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6389 
6390  }
6391  break;
6392 
6393  case 96:
6394 
6395 /* Line 1806 of yacc.c */
6396 #line 1666 "ripper.y"
6397  {
6398 #if 0
6399  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6400 #endif
6401  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6402 
6403  }
6404  break;
6405 
6406  case 97:
6407 
6408 /* Line 1806 of yacc.c */
6409 #line 1674 "ripper.y"
6410  {
6411 #if 0
6412  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6413 #endif
6414  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6415 
6416  }
6417  break;
6418 
6419  case 98:
6420 
6421 /* Line 1806 of yacc.c */
6422 #line 1682 "ripper.y"
6423  {
6424 #if 0
6425  if (in_def || in_single)
6426  yyerror("dynamic constant assignment");
6427  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6428 #endif
6429  if (in_def || in_single)
6430  yyerror("dynamic constant assignment");
6431  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6432 
6433  }
6434  break;
6435 
6436  case 99:
6437 
6438 /* Line 1806 of yacc.c */
6439 #line 1694 "ripper.y"
6440  {
6441 #if 0
6442  if (in_def || in_single)
6443  yyerror("dynamic constant assignment");
6444  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6445 #endif
6446  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6447 
6448  }
6449  break;
6450 
6451  case 100:
6452 
6453 /* Line 1806 of yacc.c */
6454 #line 1704 "ripper.y"
6455  {
6456 #if 0
6457  rb_backref_error((yyvsp[(1) - (1)].val));
6458  (yyval.val) = NEW_BEGIN(0);
6459 #endif
6460  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val));
6461  (yyval.val) = dispatch1(assign_error, (yyval.val));
6462 
6463  }
6464  break;
6465 
6466  case 101:
6467 
6468 /* Line 1806 of yacc.c */
6469 #line 1716 "ripper.y"
6470  {
6471  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6472 #if 0
6473  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6474 #endif
6475  (yyval.val) = dispatch1(var_field, (yyval.val));
6476 
6477  }
6478  break;
6479 
6480  case 102:
6481 
6482 /* Line 1806 of yacc.c */
6483 #line 1725 "ripper.y"
6484  {
6485  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6486 #if 0
6487  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6488 #endif
6489  (yyval.val) = dispatch1(var_field, (yyval.val));
6490 
6491  }
6492  break;
6493 
6494  case 103:
6495 
6496 /* Line 1806 of yacc.c */
6497 #line 1734 "ripper.y"
6498  {
6499 #if 0
6500  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6501 #endif
6502  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6503 
6504  }
6505  break;
6506 
6507  case 104:
6508 
6509 /* Line 1806 of yacc.c */
6510 #line 1742 "ripper.y"
6511  {
6512 #if 0
6513  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6514 #endif
6515  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6516 
6517  }
6518  break;
6519 
6520  case 105:
6521 
6522 /* Line 1806 of yacc.c */
6523 #line 1750 "ripper.y"
6524  {
6525 #if 0
6526  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6527 #endif
6528  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
6529 
6530  }
6531  break;
6532 
6533  case 106:
6534 
6535 /* Line 1806 of yacc.c */
6536 #line 1758 "ripper.y"
6537  {
6538 #if 0
6539  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6540 #endif
6541  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6542 
6543  }
6544  break;
6545 
6546  case 107:
6547 
6548 /* Line 1806 of yacc.c */
6549 #line 1766 "ripper.y"
6550  {
6551 #if 0
6552  if (in_def || in_single)
6553  yyerror("dynamic constant assignment");
6554  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6555 #endif
6556  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6557  if (in_def || in_single) {
6558  (yyval.val) = dispatch1(assign_error, (yyval.val));
6559  }
6560 
6561  }
6562  break;
6563 
6564  case 108:
6565 
6566 /* Line 1806 of yacc.c */
6567 #line 1779 "ripper.y"
6568  {
6569 #if 0
6570  if (in_def || in_single)
6571  yyerror("dynamic constant assignment");
6572  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6573 #endif
6574  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6575  if (in_def || in_single) {
6576  (yyval.val) = dispatch1(assign_error, (yyval.val));
6577  }
6578 
6579  }
6580  break;
6581 
6582  case 109:
6583 
6584 /* Line 1806 of yacc.c */
6585 #line 1792 "ripper.y"
6586  {
6587 #if 0
6588  rb_backref_error((yyvsp[(1) - (1)].val));
6589  (yyval.val) = NEW_BEGIN(0);
6590 #endif
6591  (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val));
6592 
6593  }
6594  break;
6595 
6596  case 110:
6597 
6598 /* Line 1806 of yacc.c */
6599 #line 1803 "ripper.y"
6600  {
6601 #if 0
6602  yyerror("class/module name must be CONSTANT");
6603 #endif
6604  (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
6605 
6606  }
6607  break;
6608 
6609  case 112:
6610 
6611 /* Line 1806 of yacc.c */
6612 #line 1814 "ripper.y"
6613  {
6614 #if 0
6615  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
6616 #endif
6617  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
6618 
6619  }
6620  break;
6621 
6622  case 113:
6623 
6624 /* Line 1806 of yacc.c */
6625 #line 1822 "ripper.y"
6626  {
6627 #if 0
6628  (yyval.val) = NEW_COLON2(0, (yyval.val));
6629 #endif
6630  (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
6631 
6632  }
6633  break;
6634 
6635  case 114:
6636 
6637 /* Line 1806 of yacc.c */
6638 #line 1830 "ripper.y"
6639  {
6640 #if 0
6641  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6642 #endif
6643  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6644 
6645  }
6646  break;
6647 
6648  case 118:
6649 
6650 /* Line 1806 of yacc.c */
6651 #line 1843 "ripper.y"
6652  {
6653  lex_state = EXPR_ENDFN;
6654  (yyval.val) = (yyvsp[(1) - (1)].val);
6655  }
6656  break;
6657 
6658  case 119:
6659 
6660 /* Line 1806 of yacc.c */
6661 #line 1848 "ripper.y"
6662  {
6663  lex_state = EXPR_ENDFN;
6664 #if 0
6665  (yyval.val) = (yyvsp[(1) - (1)].id);
6666 #endif
6667  (yyval.val) = (yyvsp[(1) - (1)].val);
6668 
6669  }
6670  break;
6671 
6672  case 122:
6673 
6674 /* Line 1806 of yacc.c */
6675 #line 1863 "ripper.y"
6676  {
6677 #if 0
6678  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
6679 #endif
6680  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
6681 
6682  }
6683  break;
6684 
6685  case 124:
6686 
6687 /* Line 1806 of yacc.c */
6688 #line 1874 "ripper.y"
6689  {
6690 #if 0
6691  (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
6692 #endif
6693  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
6694 
6695  }
6696  break;
6697 
6698  case 125:
6699 
6700 /* Line 1806 of yacc.c */
6701 #line 1881 "ripper.y"
6702  {lex_state = EXPR_FNAME;}
6703  break;
6704 
6705  case 126:
6706 
6707 /* Line 1806 of yacc.c */
6708 #line 1882 "ripper.y"
6709  {
6710 #if 0
6711  (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
6712 #endif
6713  rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6714 
6715  }
6716  break;
6717 
6718  case 127:
6719 
6720 /* Line 1806 of yacc.c */
6721 #line 1891 "ripper.y"
6722  { ifndef_ripper((yyval.val) = '|'); }
6723  break;
6724 
6725  case 128:
6726 
6727 /* Line 1806 of yacc.c */
6728 #line 1892 "ripper.y"
6729  { ifndef_ripper((yyval.val) = '^'); }
6730  break;
6731 
6732  case 129:
6733 
6734 /* Line 1806 of yacc.c */
6735 #line 1893 "ripper.y"
6736  { ifndef_ripper((yyval.val) = '&'); }
6737  break;
6738 
6739  case 130:
6740 
6741 /* Line 1806 of yacc.c */
6742 #line 1894 "ripper.y"
6743  { ifndef_ripper((yyval.val) = tCMP); }
6744  break;
6745 
6746  case 131:
6747 
6748 /* Line 1806 of yacc.c */
6749 #line 1895 "ripper.y"
6750  { ifndef_ripper((yyval.val) = tEQ); }
6751  break;
6752 
6753  case 132:
6754 
6755 /* Line 1806 of yacc.c */
6756 #line 1896 "ripper.y"
6757  { ifndef_ripper((yyval.val) = tEQQ); }
6758  break;
6759 
6760  case 133:
6761 
6762 /* Line 1806 of yacc.c */
6763 #line 1897 "ripper.y"
6764  { ifndef_ripper((yyval.val) = tMATCH); }
6765  break;
6766 
6767  case 134:
6768 
6769 /* Line 1806 of yacc.c */
6770 #line 1898 "ripper.y"
6771  { ifndef_ripper((yyval.val) = tNMATCH); }
6772  break;
6773 
6774  case 135:
6775 
6776 /* Line 1806 of yacc.c */
6777 #line 1899 "ripper.y"
6778  { ifndef_ripper((yyval.val) = '>'); }
6779  break;
6780 
6781  case 136:
6782 
6783 /* Line 1806 of yacc.c */
6784 #line 1900 "ripper.y"
6785  { ifndef_ripper((yyval.val) = tGEQ); }
6786  break;
6787 
6788  case 137:
6789 
6790 /* Line 1806 of yacc.c */
6791 #line 1901 "ripper.y"
6792  { ifndef_ripper((yyval.val) = '<'); }
6793  break;
6794 
6795  case 138:
6796 
6797 /* Line 1806 of yacc.c */
6798 #line 1902 "ripper.y"
6799  { ifndef_ripper((yyval.val) = tLEQ); }
6800  break;
6801 
6802  case 139:
6803 
6804 /* Line 1806 of yacc.c */
6805 #line 1903 "ripper.y"
6806  { ifndef_ripper((yyval.val) = tNEQ); }
6807  break;
6808 
6809  case 140:
6810 
6811 /* Line 1806 of yacc.c */
6812 #line 1904 "ripper.y"
6813  { ifndef_ripper((yyval.val) = tLSHFT); }
6814  break;
6815 
6816  case 141:
6817 
6818 /* Line 1806 of yacc.c */
6819 #line 1905 "ripper.y"
6820  { ifndef_ripper((yyval.val) = tRSHFT); }
6821  break;
6822 
6823  case 142:
6824 
6825 /* Line 1806 of yacc.c */
6826 #line 1906 "ripper.y"
6827  { ifndef_ripper((yyval.val) = '+'); }
6828  break;
6829 
6830  case 143:
6831 
6832 /* Line 1806 of yacc.c */
6833 #line 1907 "ripper.y"
6834  { ifndef_ripper((yyval.val) = '-'); }
6835  break;
6836 
6837  case 144:
6838 
6839 /* Line 1806 of yacc.c */
6840 #line 1908 "ripper.y"
6841  { ifndef_ripper((yyval.val) = '*'); }
6842  break;
6843 
6844  case 145:
6845 
6846 /* Line 1806 of yacc.c */
6847 #line 1909 "ripper.y"
6848  { ifndef_ripper((yyval.val) = '*'); }
6849  break;
6850 
6851  case 146:
6852 
6853 /* Line 1806 of yacc.c */
6854 #line 1910 "ripper.y"
6855  { ifndef_ripper((yyval.val) = '/'); }
6856  break;
6857 
6858  case 147:
6859 
6860 /* Line 1806 of yacc.c */
6861 #line 1911 "ripper.y"
6862  { ifndef_ripper((yyval.val) = '%'); }
6863  break;
6864 
6865  case 148:
6866 
6867 /* Line 1806 of yacc.c */
6868 #line 1912 "ripper.y"
6869  { ifndef_ripper((yyval.val) = tPOW); }
6870  break;
6871 
6872  case 149:
6873 
6874 /* Line 1806 of yacc.c */
6875 #line 1913 "ripper.y"
6876  { ifndef_ripper((yyval.val) = tDSTAR); }
6877  break;
6878 
6879  case 150:
6880 
6881 /* Line 1806 of yacc.c */
6882 #line 1914 "ripper.y"
6883  { ifndef_ripper((yyval.val) = '!'); }
6884  break;
6885 
6886  case 151:
6887 
6888 /* Line 1806 of yacc.c */
6889 #line 1915 "ripper.y"
6890  { ifndef_ripper((yyval.val) = '~'); }
6891  break;
6892 
6893  case 152:
6894 
6895 /* Line 1806 of yacc.c */
6896 #line 1916 "ripper.y"
6897  { ifndef_ripper((yyval.val) = tUPLUS); }
6898  break;
6899 
6900  case 153:
6901 
6902 /* Line 1806 of yacc.c */
6903 #line 1917 "ripper.y"
6904  { ifndef_ripper((yyval.val) = tUMINUS); }
6905  break;
6906 
6907  case 154:
6908 
6909 /* Line 1806 of yacc.c */
6910 #line 1918 "ripper.y"
6911  { ifndef_ripper((yyval.val) = tAREF); }
6912  break;
6913 
6914  case 155:
6915 
6916 /* Line 1806 of yacc.c */
6917 #line 1919 "ripper.y"
6918  { ifndef_ripper((yyval.val) = tASET); }
6919  break;
6920 
6921  case 156:
6922 
6923 /* Line 1806 of yacc.c */
6924 #line 1920 "ripper.y"
6925  { ifndef_ripper((yyval.val) = '`'); }
6926  break;
6927 
6928  case 198:
6929 
6930 /* Line 1806 of yacc.c */
6931 #line 1938 "ripper.y"
6932  {
6933 #if 0
6934  value_expr((yyvsp[(3) - (3)].val));
6935  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6936 #endif
6937  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6938 
6939  }
6940  break;
6941 
6942  case 199:
6943 
6944 /* Line 1806 of yacc.c */
6945 #line 1947 "ripper.y"
6946  {
6947 #if 0
6948  value_expr((yyvsp[(3) - (5)].val));
6949  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6950  (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6951 #endif
6952  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)));
6953 
6954  }
6955  break;
6956 
6957  case 200:
6958 
6959 /* Line 1806 of yacc.c */
6960 #line 1957 "ripper.y"
6961  {
6962  value_expr((yyvsp[(3) - (3)].val));
6963  (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
6964  }
6965  break;
6966 
6967  case 201:
6968 
6969 /* Line 1806 of yacc.c */
6970 #line 1962 "ripper.y"
6971  {
6972 #if 0
6973  value_expr((yyvsp[(3) - (5)].val));
6974  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6975 #endif
6976  (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
6977 
6978  (yyval.val) = new_op_assign((yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val));
6979  }
6980  break;
6981 
6982  case 202:
6983 
6984 /* Line 1806 of yacc.c */
6985 #line 1972 "ripper.y"
6986  {
6987 #if 0
6988  NODE *args;
6989 
6990  value_expr((yyvsp[(6) - (6)].val));
6991  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
6992  if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
6993  args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6994  }
6995  else {
6996  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6997  }
6998  if ((yyvsp[(5) - (6)].val) == tOROP) {
6999  (yyvsp[(5) - (6)].val) = 0;
7000  }
7001  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
7002  (yyvsp[(5) - (6)].val) = 1;
7003  }
7004  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
7005  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
7006 #endif
7007  (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
7008  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
7009 
7010  }
7011  break;
7012 
7013  case 203:
7014 
7015 /* Line 1806 of yacc.c */
7016 #line 1998 "ripper.y"
7017  {
7018  value_expr((yyvsp[(5) - (5)].val));
7019  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7020  }
7021  break;
7022 
7023  case 204:
7024 
7025 /* Line 1806 of yacc.c */
7026 #line 2003 "ripper.y"
7027  {
7028  value_expr((yyvsp[(5) - (5)].val));
7029  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7030  }
7031  break;
7032 
7033  case 205:
7034 
7035 /* Line 1806 of yacc.c */
7036 #line 2008 "ripper.y"
7037  {
7038  value_expr((yyvsp[(5) - (5)].val));
7039  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7040  }
7041  break;
7042 
7043  case 206:
7044 
7045 /* Line 1806 of yacc.c */
7046 #line 2013 "ripper.y"
7047  {
7048 #if 0
7049  (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
7050  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7051 #endif
7052  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
7053  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7054 
7055  }
7056  break;
7057 
7058  case 207:
7059 
7060 /* Line 1806 of yacc.c */
7061 #line 2023 "ripper.y"
7062  {
7063 #if 0
7064  (yyval.val) = NEW_COLON3((yyvsp[(2) - (4)].val));
7065  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
7066 #endif
7067  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val));
7068  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
7069 
7070  }
7071  break;
7072 
7073  case 208:
7074 
7075 /* Line 1806 of yacc.c */
7076 #line 2033 "ripper.y"
7077  {
7078 #if 0
7079  rb_backref_error((yyvsp[(1) - (3)].val));
7080  (yyval.val) = NEW_BEGIN(0);
7081 #endif
7082  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val));
7083  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
7084  (yyval.val) = dispatch1(assign_error, (yyval.val));
7085 
7086  }
7087  break;
7088 
7089  case 209:
7090 
7091 /* Line 1806 of yacc.c */
7092 #line 2044 "ripper.y"
7093  {
7094 #if 0
7095  value_expr((yyvsp[(1) - (3)].val));
7096  value_expr((yyvsp[(3) - (3)].val));
7097  (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7098  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7099  (yyvsp[(3) - (3)].val) && nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7101  }
7102 #endif
7103  (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7104 
7105  }
7106  break;
7107 
7108  case 210:
7109 
7110 /* Line 1806 of yacc.c */
7111 #line 2058 "ripper.y"
7112  {
7113 #if 0
7114  value_expr((yyvsp[(1) - (3)].val));
7115  value_expr((yyvsp[(3) - (3)].val));
7116  (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7117  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7118  (yyvsp[(3) - (3)].val) && nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7120  }
7121 #endif
7122  (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7123 
7124  }
7125  break;
7126 
7127  case 211:
7128 
7129 /* Line 1806 of yacc.c */
7130 #line 2072 "ripper.y"
7131  {
7132 #if 0
7133  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
7134 #endif
7135  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val));
7136 
7137  }
7138  break;
7139 
7140  case 212:
7141 
7142 /* Line 1806 of yacc.c */
7143 #line 2080 "ripper.y"
7144  {
7145 #if 0
7146  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
7147 #endif
7148  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val));
7149 
7150  }
7151  break;
7152 
7153  case 213:
7154 
7155 /* Line 1806 of yacc.c */
7156 #line 2088 "ripper.y"
7157  {
7158 #if 0
7159  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
7160 #endif
7161  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val));
7162 
7163  }
7164  break;
7165 
7166  case 214:
7167 
7168 /* Line 1806 of yacc.c */
7169 #line 2096 "ripper.y"
7170  {
7171 #if 0
7172  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
7173 #endif
7174  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val));
7175 
7176  }
7177  break;
7178 
7179  case 215:
7180 
7181 /* Line 1806 of yacc.c */
7182 #line 2104 "ripper.y"
7183  {
7184 #if 0
7185  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
7186 #endif
7187  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val));
7188 
7189  }
7190  break;
7191 
7192  case 216:
7193 
7194 /* Line 1806 of yacc.c */
7195 #line 2112 "ripper.y"
7196  {
7197 #if 0
7198  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
7199 #endif
7200  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val));
7201 
7202  }
7203  break;
7204 
7205  case 217:
7206 
7207 /* Line 1806 of yacc.c */
7208 #line 2120 "ripper.y"
7209  {
7210 #if 0
7211  (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
7212 #endif
7213  (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
7214  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
7215 
7216  }
7217  break;
7218 
7219  case 218:
7220 
7221 /* Line 1806 of yacc.c */
7222 #line 2129 "ripper.y"
7223  {
7224 #if 0
7225  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
7226 #endif
7227  (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val));
7228 
7229  }
7230  break;
7231 
7232  case 219:
7233 
7234 /* Line 1806 of yacc.c */
7235 #line 2137 "ripper.y"
7236  {
7237 #if 0
7238  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
7239 #endif
7240  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
7241 
7242  }
7243  break;
7244 
7245  case 220:
7246 
7247 /* Line 1806 of yacc.c */
7248 #line 2145 "ripper.y"
7249  {
7250 #if 0
7251  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val));
7252 #endif
7253  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('|'), (yyvsp[(3) - (3)].val));
7254 
7255  }
7256  break;
7257 
7258  case 221:
7259 
7260 /* Line 1806 of yacc.c */
7261 #line 2153 "ripper.y"
7262  {
7263 #if 0
7264  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
7265 #endif
7266  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val));
7267 
7268  }
7269  break;
7270 
7271  case 222:
7272 
7273 /* Line 1806 of yacc.c */
7274 #line 2161 "ripper.y"
7275  {
7276 #if 0
7277  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
7278 #endif
7279  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val));
7280 
7281  }
7282  break;
7283 
7284  case 223:
7285 
7286 /* Line 1806 of yacc.c */
7287 #line 2169 "ripper.y"
7288  {
7289 #if 0
7290  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
7291 #endif
7292  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val));
7293 
7294  }
7295  break;
7296 
7297  case 224:
7298 
7299 /* Line 1806 of yacc.c */
7300 #line 2177 "ripper.y"
7301  {
7302 #if 0
7303  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
7304 #endif
7305  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val));
7306 
7307  }
7308  break;
7309 
7310  case 225:
7311 
7312 /* Line 1806 of yacc.c */
7313 #line 2185 "ripper.y"
7314  {
7315 #if 0
7316  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
7317 #endif
7318  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val));
7319 
7320  }
7321  break;
7322 
7323  case 226:
7324 
7325 /* Line 1806 of yacc.c */
7326 #line 2193 "ripper.y"
7327  {
7328 #if 0
7329  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
7330 #endif
7331  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val));
7332 
7333  }
7334  break;
7335 
7336  case 227:
7337 
7338 /* Line 1806 of yacc.c */
7339 #line 2201 "ripper.y"
7340  {
7341 #if 0
7342  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
7343 #endif
7344  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val));
7345 
7346  }
7347  break;
7348 
7349  case 228:
7350 
7351 /* Line 1806 of yacc.c */
7352 #line 2209 "ripper.y"
7353  {
7354 #if 0
7355  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
7356 #endif
7357  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val));
7358 
7359  }
7360  break;
7361 
7362  case 229:
7363 
7364 /* Line 1806 of yacc.c */
7365 #line 2217 "ripper.y"
7366  {
7367 #if 0
7368  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
7369 #endif
7370  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val));
7371 
7372  }
7373  break;
7374 
7375  case 230:
7376 
7377 /* Line 1806 of yacc.c */
7378 #line 2225 "ripper.y"
7379  {
7380 #if 0
7381  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
7382 #endif
7383  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val));
7384 
7385  }
7386  break;
7387 
7388  case 231:
7389 
7390 /* Line 1806 of yacc.c */
7391 #line 2233 "ripper.y"
7392  {
7393 #if 0
7394  (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7395  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].val)->nd_lit, T_REGEXP)) {
7396  (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val));
7397  }
7398 #endif
7399  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val));
7400 
7401  }
7402  break;
7403 
7404  case 232:
7405 
7406 /* Line 1806 of yacc.c */
7407 #line 2244 "ripper.y"
7408  {
7409 #if 0
7410  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val));
7411 #endif
7412  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!~"), (yyvsp[(3) - (3)].val));
7413 
7414  }
7415  break;
7416 
7417  case 233:
7418 
7419 /* Line 1806 of yacc.c */
7420 #line 2252 "ripper.y"
7421  {
7422 #if 0
7423  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
7424 #endif
7425  (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val));
7426 
7427  }
7428  break;
7429 
7430  case 234:
7431 
7432 /* Line 1806 of yacc.c */
7433 #line 2260 "ripper.y"
7434  {
7435 #if 0
7436  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
7437 #endif
7438  (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val));
7439 
7440  }
7441  break;
7442 
7443  case 235:
7444 
7445 /* Line 1806 of yacc.c */
7446 #line 2268 "ripper.y"
7447  {
7448 #if 0
7449  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val));
7450 #endif
7451  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<<"), (yyvsp[(3) - (3)].val));
7452 
7453  }
7454  break;
7455 
7456  case 236:
7457 
7458 /* Line 1806 of yacc.c */
7459 #line 2276 "ripper.y"
7460  {
7461 #if 0
7462  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val));
7463 #endif
7464  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">>"), (yyvsp[(3) - (3)].val));
7465 
7466  }
7467  break;
7468 
7469  case 237:
7470 
7471 /* Line 1806 of yacc.c */
7472 #line 2284 "ripper.y"
7473  {
7474 #if 0
7475  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7476 #endif
7477  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val));
7478 
7479  }
7480  break;
7481 
7482  case 238:
7483 
7484 /* Line 1806 of yacc.c */
7485 #line 2292 "ripper.y"
7486  {
7487 #if 0
7488  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7489 #endif
7490  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val));
7491 
7492  }
7493  break;
7494 
7495  case 239:
7496 
7497 /* Line 1806 of yacc.c */
7498 #line 2299 "ripper.y"
7499  {in_defined = 1;}
7500  break;
7501 
7502  case 240:
7503 
7504 /* Line 1806 of yacc.c */
7505 #line 2300 "ripper.y"
7506  {
7507 #if 0
7508  in_defined = 0;
7509  (yyval.val) = new_defined((yyvsp[(4) - (4)].val));
7510 #endif
7511  in_defined = 0;
7512  (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val));
7513 
7514  }
7515  break;
7516 
7517  case 241:
7518 
7519 /* Line 1806 of yacc.c */
7520 #line 2310 "ripper.y"
7521  {
7522 #if 0
7523  value_expr((yyvsp[(1) - (6)].val));
7524  (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7525  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
7526 #endif
7527  (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7528 
7529  }
7530  break;
7531 
7532  case 242:
7533 
7534 /* Line 1806 of yacc.c */
7535 #line 2320 "ripper.y"
7536  {
7537  (yyval.val) = (yyvsp[(1) - (1)].val);
7538  }
7539  break;
7540 
7541  case 243:
7542 
7543 /* Line 1806 of yacc.c */
7544 #line 2326 "ripper.y"
7545  {
7546 #if 0
7547  value_expr((yyvsp[(1) - (1)].val));
7548  (yyval.val) = (yyvsp[(1) - (1)].val);
7549  if (!(yyval.val)) (yyval.val) = NEW_NIL();
7550 #endif
7551  (yyval.val) = (yyvsp[(1) - (1)].val);
7552 
7553  }
7554  break;
7555 
7556  case 245:
7557 
7558 /* Line 1806 of yacc.c */
7559 #line 2339 "ripper.y"
7560  {
7561  (yyval.val) = (yyvsp[(1) - (2)].val);
7562  }
7563  break;
7564 
7565  case 246:
7566 
7567 /* Line 1806 of yacc.c */
7568 #line 2343 "ripper.y"
7569  {
7570 #if 0
7571  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7572 #endif
7573  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7574 
7575  }
7576  break;
7577 
7578  case 247:
7579 
7580 /* Line 1806 of yacc.c */
7581 #line 2351 "ripper.y"
7582  {
7583 #if 0
7584  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7585 #endif
7586  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7587 
7588  }
7589  break;
7590 
7591  case 248:
7592 
7593 /* Line 1806 of yacc.c */
7594 #line 2361 "ripper.y"
7595  {
7596 #if 0
7597  (yyval.val) = (yyvsp[(2) - (3)].val);
7598 #endif
7599  (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
7600 
7601  }
7602  break;
7603 
7604  case 253:
7605 
7606 /* Line 1806 of yacc.c */
7607 #line 2377 "ripper.y"
7608  {
7609  (yyval.val) = (yyvsp[(1) - (2)].val);
7610  }
7611  break;
7612 
7613  case 254:
7614 
7615 /* Line 1806 of yacc.c */
7616 #line 2381 "ripper.y"
7617  {
7618 #if 0
7619  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7620 #endif
7621  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7622 
7623  }
7624  break;
7625 
7626  case 255:
7627 
7628 /* Line 1806 of yacc.c */
7629 #line 2389 "ripper.y"
7630  {
7631 #if 0
7632  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7633 #endif
7634  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7635 
7636  }
7637  break;
7638 
7639  case 256:
7640 
7641 /* Line 1806 of yacc.c */
7642 #line 2399 "ripper.y"
7643  {
7644 #if 0
7645  value_expr((yyvsp[(1) - (1)].val));
7646  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7647 #endif
7648  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7649 
7650  }
7651  break;
7652 
7653  case 257:
7654 
7655 /* Line 1806 of yacc.c */
7656 #line 2408 "ripper.y"
7657  {
7658 #if 0
7659  (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7660 #endif
7661  (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7662 
7663  }
7664  break;
7665 
7666  case 258:
7667 
7668 /* Line 1806 of yacc.c */
7669 #line 2416 "ripper.y"
7670  {
7671 #if 0
7672  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7673  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
7674 #endif
7675  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7676  (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
7677 
7678  }
7679  break;
7680 
7681  case 259:
7682 
7683 /* Line 1806 of yacc.c */
7684 #line 2426 "ripper.y"
7685  {
7686 #if 0
7687  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7688  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
7689 #endif
7690  (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
7691 
7692  }
7693  break;
7694 
7695  case 260:
7696 
7697 /* Line 1806 of yacc.c */
7698 #line 2437 "ripper.y"
7699  {
7700  (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
7701  }
7702  break;
7703 
7704  case 261:
7705 
7706 /* Line 1806 of yacc.c */
7707 #line 2443 "ripper.y"
7708  {
7709  (yyval.val) = cmdarg_stack;
7710  CMDARG_PUSH(1);
7711  }
7712  break;
7713 
7714  case 262:
7715 
7716 /* Line 1806 of yacc.c */
7717 #line 2448 "ripper.y"
7718  {
7719  /* CMDARG_POP() */
7720  cmdarg_stack = (yyvsp[(1) - (2)].val);
7721  (yyval.val) = (yyvsp[(2) - (2)].val);
7722  }
7723  break;
7724 
7725  case 263:
7726 
7727 /* Line 1806 of yacc.c */
7728 #line 2456 "ripper.y"
7729  {
7730 #if 0
7731  (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
7732 #endif
7733  (yyval.val) = (yyvsp[(2) - (2)].val);
7734 
7735  }
7736  break;
7737 
7738  case 264:
7739 
7740 /* Line 1806 of yacc.c */
7741 #line 2466 "ripper.y"
7742  {
7743  (yyval.val) = (yyvsp[(2) - (2)].val);
7744  }
7745  break;
7746 
7747  case 265:
7748 
7749 /* Line 1806 of yacc.c */
7750 #line 2470 "ripper.y"
7751  {
7752  (yyval.val) = 0;
7753  }
7754  break;
7755 
7756  case 266:
7757 
7758 /* Line 1806 of yacc.c */
7759 #line 2476 "ripper.y"
7760  {
7761 #if 0
7762  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7763 #endif
7764  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7765 
7766  }
7767  break;
7768 
7769  case 267:
7770 
7771 /* Line 1806 of yacc.c */
7772 #line 2484 "ripper.y"
7773  {
7774 #if 0
7775  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7776 #endif
7777  (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
7778 
7779  }
7780  break;
7781 
7782  case 268:
7783 
7784 /* Line 1806 of yacc.c */
7785 #line 2492 "ripper.y"
7786  {
7787 #if 0
7788  NODE *n1;
7789  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7790  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7791  }
7792  else {
7793  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7794  }
7795 #endif
7796  (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7797 
7798  }
7799  break;
7800 
7801  case 269:
7802 
7803 /* Line 1806 of yacc.c */
7804 #line 2506 "ripper.y"
7805  {
7806 #if 0
7807  NODE *n1;
7808  if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7809  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7810  }
7811  else {
7812  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7813  }
7814 #endif
7815  (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7816 
7817  }
7818  break;
7819 
7820  case 272:
7821 
7822 /* Line 1806 of yacc.c */
7823 #line 2526 "ripper.y"
7824  {
7825 #if 0
7826  NODE *n1;
7827  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7828  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7829  }
7830  else {
7831  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7832  }
7833 #endif
7834  (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
7835 
7836  }
7837  break;
7838 
7839  case 273:
7840 
7841 /* Line 1806 of yacc.c */
7842 #line 2540 "ripper.y"
7843  {
7844 #if 0
7845  NODE *n1;
7846  if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
7847  (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7848  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7849  }
7850  else {
7851  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7852  }
7853 #endif
7854  (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
7855 
7856  }
7857  break;
7858 
7859  case 274:
7860 
7861 /* Line 1806 of yacc.c */
7862 #line 2555 "ripper.y"
7863  {
7864 #if 0
7865  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7866 #endif
7867  (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
7868 
7869  }
7870  break;
7871 
7872  case 285:
7873 
7874 /* Line 1806 of yacc.c */
7875 #line 2575 "ripper.y"
7876  {
7877 #if 0
7878  (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
7879 #endif
7880  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
7881 
7882  }
7883  break;
7884 
7885  case 286:
7886 
7887 /* Line 1806 of yacc.c */
7888 #line 2583 "ripper.y"
7889  {
7890  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7891  cmdarg_stack = 0;
7892 #if 0
7893  (yyval.num) = ruby_sourceline;
7894 #endif
7895 
7896  }
7897  break;
7898 
7899  case 287:
7900 
7901 /* Line 1806 of yacc.c */
7902 #line 2593 "ripper.y"
7903  {
7904  cmdarg_stack = (yyvsp[(1) - (4)].val);
7905 #if 0
7906  if ((yyvsp[(3) - (4)].val) == NULL) {
7907  (yyval.val) = NEW_NIL();
7908  }
7909  else {
7910  if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE ||
7911  nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE)
7912  nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
7913  (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val));
7914  }
7915  nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
7916 #endif
7917  (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
7918 
7919  }
7920  break;
7921 
7922  case 288:
7923 
7924 /* Line 1806 of yacc.c */
7925 #line 2610 "ripper.y"
7926  {lex_state = EXPR_ENDARG;}
7927  break;
7928 
7929  case 289:
7930 
7931 /* Line 1806 of yacc.c */
7932 #line 2611 "ripper.y"
7933  {
7934 #if 0
7935  (yyval.val) = 0;
7936 #endif
7937  (yyval.val) = dispatch1(paren, 0);
7938 
7939  }
7940  break;
7941 
7942  case 290:
7943 
7944 /* Line 1806 of yacc.c */
7945 #line 2619 "ripper.y"
7946  {
7947  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7948  cmdarg_stack = 0;
7949  }
7950  break;
7951 
7952  case 291:
7953 
7954 /* Line 1806 of yacc.c */
7955 #line 2623 "ripper.y"
7956  {lex_state = EXPR_ENDARG;}
7957  break;
7958 
7959  case 292:
7960 
7961 /* Line 1806 of yacc.c */
7962 #line 2624 "ripper.y"
7963  {
7964  cmdarg_stack = (yyvsp[(1) - (5)].val);
7965 #if 0
7966  (yyval.val) = (yyvsp[(3) - (5)].val);
7967 #endif
7968  (yyval.val) = dispatch1(paren, (yyvsp[(3) - (5)].val));
7969 
7970  }
7971  break;
7972 
7973  case 293:
7974 
7975 /* Line 1806 of yacc.c */
7976 #line 2633 "ripper.y"
7977  {
7978 #if 0
7979  (yyval.val) = (yyvsp[(2) - (3)].val);
7980 #endif
7981  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
7982 
7983  }
7984  break;
7985 
7986  case 294:
7987 
7988 /* Line 1806 of yacc.c */
7989 #line 2641 "ripper.y"
7990  {
7991 #if 0
7992  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7993 #endif
7994  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7995 
7996  }
7997  break;
7998 
7999  case 295:
8000 
8001 /* Line 1806 of yacc.c */
8002 #line 2649 "ripper.y"
8003  {
8004 #if 0
8005  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
8006 #endif
8007  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
8008 
8009  }
8010  break;
8011 
8012  case 296:
8013 
8014 /* Line 1806 of yacc.c */
8015 #line 2657 "ripper.y"
8016  {
8017 #if 0
8018  if ((yyvsp[(2) - (3)].val) == 0) {
8019  (yyval.val) = NEW_ZARRAY(); /* zero length array*/
8020  }
8021  else {
8022  (yyval.val) = (yyvsp[(2) - (3)].val);
8023  }
8024 #endif
8025  (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
8026 
8027  }
8028  break;
8029 
8030  case 297:
8031 
8032 /* Line 1806 of yacc.c */
8033 #line 2670 "ripper.y"
8034  {
8035 #if 0
8036  (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
8037 #endif
8038  (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
8039 
8040  }
8041  break;
8042 
8043  case 298:
8044 
8045 /* Line 1806 of yacc.c */
8046 #line 2678 "ripper.y"
8047  {
8048 #if 0
8049  (yyval.val) = NEW_RETURN(0);
8050 #endif
8051  (yyval.val) = dispatch0(return0);
8052 
8053  }
8054  break;
8055 
8056  case 299:
8057 
8058 /* Line 1806 of yacc.c */
8059 #line 2686 "ripper.y"
8060  {
8061 #if 0
8062  (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
8063 #endif
8064  (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
8065 
8066  }
8067  break;
8068 
8069  case 300:
8070 
8071 /* Line 1806 of yacc.c */
8072 #line 2694 "ripper.y"
8073  {
8074 #if 0
8075  (yyval.val) = NEW_YIELD(0);
8076 #endif
8077  (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
8078 
8079  }
8080  break;
8081 
8082  case 301:
8083 
8084 /* Line 1806 of yacc.c */
8085 #line 2702 "ripper.y"
8086  {
8087 #if 0
8088  (yyval.val) = NEW_YIELD(0);
8089 #endif
8090  (yyval.val) = dispatch0(yield0);
8091 
8092  }
8093  break;
8094 
8095  case 302:
8096 
8097 /* Line 1806 of yacc.c */
8098 #line 2709 "ripper.y"
8099  {in_defined = 1;}
8100  break;
8101 
8102  case 303:
8103 
8104 /* Line 1806 of yacc.c */
8105 #line 2710 "ripper.y"
8106  {
8107 #if 0
8108  in_defined = 0;
8109  (yyval.val) = new_defined((yyvsp[(5) - (6)].val));
8110 #endif
8111  in_defined = 0;
8112  (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val));
8113 
8114  }
8115  break;
8116 
8117  case 304:
8118 
8119 /* Line 1806 of yacc.c */
8120 #line 2720 "ripper.y"
8121  {
8122 #if 0
8123  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
8124 #endif
8125  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val));
8126 
8127  }
8128  break;
8129 
8130  case 305:
8131 
8132 /* Line 1806 of yacc.c */
8133 #line 2728 "ripper.y"
8134  {
8135 #if 0
8136  (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
8137 #endif
8138  (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil);
8139 
8140  }
8141  break;
8142 
8143  case 306:
8144 
8145 /* Line 1806 of yacc.c */
8146 #line 2736 "ripper.y"
8147  {
8148 #if 0
8149  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
8150  (yyval.val) = (yyvsp[(2) - (2)].val);
8151 #endif
8152  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
8153  (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
8154 
8155  }
8156  break;
8157 
8158  case 308:
8159 
8160 /* Line 1806 of yacc.c */
8161 #line 2747 "ripper.y"
8162  {
8163 #if 0
8164  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
8165  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
8166  (yyval.val) = (yyvsp[(2) - (2)].val);
8167 #endif
8168  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
8169 
8170  }
8171  break;
8172 
8173  case 309:
8174 
8175 /* Line 1806 of yacc.c */
8176 #line 2757 "ripper.y"
8177  {
8178  (yyval.val) = (yyvsp[(2) - (2)].val);
8179  }
8180  break;
8181 
8182  case 310:
8183 
8184 /* Line 1806 of yacc.c */
8185 #line 2764 "ripper.y"
8186  {
8187 #if 0
8188  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8189  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8190 #endif
8191  (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8192 
8193  }
8194  break;
8195 
8196  case 311:
8197 
8198 /* Line 1806 of yacc.c */
8199 #line 2776 "ripper.y"
8200  {
8201 #if 0
8202  (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8203  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8204 #endif
8205  (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8206 
8207  }
8208  break;
8209 
8210  case 312:
8211 
8212 /* Line 1806 of yacc.c */
8213 #line 2784 "ripper.y"
8214  {COND_PUSH(1);}
8215  break;
8216 
8217  case 313:
8218 
8219 /* Line 1806 of yacc.c */
8220 #line 2784 "ripper.y"
8221  {COND_POP();}
8222  break;
8223 
8224  case 314:
8225 
8226 /* Line 1806 of yacc.c */
8227 #line 2787 "ripper.y"
8228  {
8229 #if 0
8230  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8231  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8232 #endif
8233  (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8234 
8235  }
8236  break;
8237 
8238  case 315:
8239 
8240 /* Line 1806 of yacc.c */
8241 #line 2795 "ripper.y"
8242  {COND_PUSH(1);}
8243  break;
8244 
8245  case 316:
8246 
8247 /* Line 1806 of yacc.c */
8248 #line 2795 "ripper.y"
8249  {COND_POP();}
8250  break;
8251 
8252  case 317:
8253 
8254 /* Line 1806 of yacc.c */
8255 #line 2798 "ripper.y"
8256  {
8257 #if 0
8258  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8259  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8260 #endif
8261  (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8262 
8263  }
8264  break;
8265 
8266  case 318:
8267 
8268 /* Line 1806 of yacc.c */
8269 #line 2809 "ripper.y"
8270  {
8271 #if 0
8272  (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8273  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8274 #endif
8275  (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8276 
8277  }
8278  break;
8279 
8280  case 319:
8281 
8282 /* Line 1806 of yacc.c */
8283 #line 2818 "ripper.y"
8284  {
8285 #if 0
8286  (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
8287 #endif
8288  (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
8289 
8290  }
8291  break;
8292 
8293  case 320:
8294 
8295 /* Line 1806 of yacc.c */
8296 #line 2826 "ripper.y"
8297  {COND_PUSH(1);}
8298  break;
8299 
8300  case 321:
8301 
8302 /* Line 1806 of yacc.c */
8303 #line 2828 "ripper.y"
8304  {COND_POP();}
8305  break;
8306 
8307  case 322:
8308 
8309 /* Line 1806 of yacc.c */
8310 #line 2831 "ripper.y"
8311  {
8312 #if 0
8313  /*
8314  * for a, b, c in e
8315  * #=>
8316  * e.each{|*x| a, b, c = x
8317  *
8318  * for a in e
8319  * #=>
8320  * e.each{|x| a, = x}
8321  */
8322  ID id = internal_id();
8323  ID *tbl = ALLOC_N(ID, 2);
8324  NODE *m = NEW_ARGS_AUX(0, 0);
8325  NODE *args, *scope;
8326 
8327  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) {
8328  /* if args.length == 1 && args[0].kind_of?(Array)
8329  * args = args[0]
8330  * end
8331  */
8332  NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
8333  NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
8334  m->nd_next = block_append(
8335  NEW_IF(
8337  NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
8338  idEq, one),
8339  NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero),
8340  rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
8341  0),
8342  NEW_DASGN_CURR(id,
8343  NEW_CALL(NEW_DVAR(id), idAREF, zero)),
8344  0),
8345  node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id)));
8346 
8347  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8348  }
8349  else {
8350  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN ||
8351  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN ||
8352  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) {
8353  (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id);
8354  m->nd_plen = 1;
8355  m->nd_next = (yyvsp[(2) - (9)].val);
8356  args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
8357  }
8358  else {
8359  m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id));
8360  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8361  }
8362  }
8363  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
8364  tbl[0] = 1; tbl[1] = id;
8365  (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope);
8366  fixpos((yyval.val), (yyvsp[(2) - (9)].val));
8367 #endif
8368  (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
8369 
8370  }
8371  break;
8372 
8373  case 323:
8374 
8375 /* Line 1806 of yacc.c */
8376 #line 2892 "ripper.y"
8377  {
8378  if (in_def || in_single)
8379  yyerror("class definition in method body");
8380  local_push(0);
8381 #if 0
8382  (yyval.num) = ruby_sourceline;
8383 #endif
8384 
8385  }
8386  break;
8387 
8388  case 324:
8389 
8390 /* Line 1806 of yacc.c */
8391 #line 2903 "ripper.y"
8392  {
8393 #if 0
8394  (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
8395  nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
8396 #endif
8397  (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
8398 
8399  local_pop();
8400  }
8401  break;
8402 
8403  case 325:
8404 
8405 /* Line 1806 of yacc.c */
8406 #line 2913 "ripper.y"
8407  {
8408  (yyval.num) = in_def;
8409  in_def = 0;
8410  }
8411  break;
8412 
8413  case 326:
8414 
8415 /* Line 1806 of yacc.c */
8416 #line 2918 "ripper.y"
8417  {
8418  (yyval.num) = in_single;
8419  in_single = 0;
8420  local_push(0);
8421  }
8422  break;
8423 
8424  case 327:
8425 
8426 /* Line 1806 of yacc.c */
8427 #line 2925 "ripper.y"
8428  {
8429 #if 0
8430  (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8431  fixpos((yyval.val), (yyvsp[(3) - (8)].val));
8432 #endif
8433  (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8434 
8435  local_pop();
8436  in_def = (yyvsp[(4) - (8)].num);
8437  in_single = (yyvsp[(6) - (8)].num);
8438  }
8439  break;
8440 
8441  case 328:
8442 
8443 /* Line 1806 of yacc.c */
8444 #line 2937 "ripper.y"
8445  {
8446  if (in_def || in_single)
8447  yyerror("module definition in method body");
8448  local_push(0);
8449 #if 0
8450  (yyval.num) = ruby_sourceline;
8451 #endif
8452 
8453  }
8454  break;
8455 
8456  case 329:
8457 
8458 /* Line 1806 of yacc.c */
8459 #line 2948 "ripper.y"
8460  {
8461 #if 0
8462  (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8463  nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
8464 #endif
8465  (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8466 
8467  local_pop();
8468  }
8469  break;
8470 
8471  case 330:
8472 
8473 /* Line 1806 of yacc.c */
8474 #line 2958 "ripper.y"
8475  {
8476  (yyval.id) = cur_mid;
8477  cur_mid = (yyvsp[(2) - (2)].val);
8478  in_def++;
8479  local_push(0);
8480  }
8481  break;
8482 
8483  case 331:
8484 
8485 /* Line 1806 of yacc.c */
8486 #line 2967 "ripper.y"
8487  {
8488 #if 0
8489  NODE *body = remove_begin((yyvsp[(5) - (6)].val));
8490  reduce_nodes(&body);
8491  (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE);
8492  nd_set_line((yyval.val), (yyvsp[(1) - (6)].num));
8493 #endif
8494  (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8495 
8496  local_pop();
8497  in_def--;
8498  cur_mid = (yyvsp[(3) - (6)].id);
8499  }
8500  break;
8501 
8502  case 332:
8503 
8504 /* Line 1806 of yacc.c */
8505 #line 2980 "ripper.y"
8506  {lex_state = EXPR_FNAME;}
8507  break;
8508 
8509  case 333:
8510 
8511 /* Line 1806 of yacc.c */
8512 #line 2981 "ripper.y"
8513  {
8514  in_single++;
8515  lex_state = EXPR_ENDFN; /* force for args */
8516  local_push(0);
8517  }
8518  break;
8519 
8520  case 334:
8521 
8522 /* Line 1806 of yacc.c */
8523 #line 2989 "ripper.y"
8524  {
8525 #if 0
8526  NODE *body = remove_begin((yyvsp[(8) - (9)].val));
8527  reduce_nodes(&body);
8528  (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
8529  nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
8530 #endif
8531  (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
8532 
8533  local_pop();
8534  in_single--;
8535  }
8536  break;
8537 
8538  case 335:
8539 
8540 /* Line 1806 of yacc.c */
8541 #line 3002 "ripper.y"
8542  {
8543 #if 0
8544  (yyval.val) = NEW_BREAK(0);
8545 #endif
8546  (yyval.val) = dispatch1(break, arg_new());
8547 
8548  }
8549  break;
8550 
8551  case 336:
8552 
8553 /* Line 1806 of yacc.c */
8554 #line 3010 "ripper.y"
8555  {
8556 #if 0
8557  (yyval.val) = NEW_NEXT(0);
8558 #endif
8559  (yyval.val) = dispatch1(next, arg_new());
8560 
8561  }
8562  break;
8563 
8564  case 337:
8565 
8566 /* Line 1806 of yacc.c */
8567 #line 3018 "ripper.y"
8568  {
8569 #if 0
8570  (yyval.val) = NEW_REDO();
8571 #endif
8572  (yyval.val) = dispatch0(redo);
8573 
8574  }
8575  break;
8576 
8577  case 338:
8578 
8579 /* Line 1806 of yacc.c */
8580 #line 3026 "ripper.y"
8581  {
8582 #if 0
8583  (yyval.val) = NEW_RETRY();
8584 #endif
8585  (yyval.val) = dispatch0(retry);
8586 
8587  }
8588  break;
8589 
8590  case 339:
8591 
8592 /* Line 1806 of yacc.c */
8593 #line 3036 "ripper.y"
8594  {
8595 #if 0
8596  value_expr((yyvsp[(1) - (1)].val));
8597  (yyval.val) = (yyvsp[(1) - (1)].val);
8598  if (!(yyval.val)) (yyval.val) = NEW_NIL();
8599 #endif
8600  (yyval.val) = (yyvsp[(1) - (1)].val);
8601 
8602  }
8603  break;
8604 
8605  case 340:
8606 
8607 /* Line 1806 of yacc.c */
8608 #line 3048 "ripper.y"
8609  {
8610  token_info_push("begin");
8611  }
8612  break;
8613 
8614  case 341:
8615 
8616 /* Line 1806 of yacc.c */
8617 #line 3054 "ripper.y"
8618  {
8619  token_info_push("if");
8620  }
8621  break;
8622 
8623  case 342:
8624 
8625 /* Line 1806 of yacc.c */
8626 #line 3060 "ripper.y"
8627  {
8628  token_info_push("unless");
8629  }
8630  break;
8631 
8632  case 343:
8633 
8634 /* Line 1806 of yacc.c */
8635 #line 3066 "ripper.y"
8636  {
8637  token_info_push("while");
8638  }
8639  break;
8640 
8641  case 344:
8642 
8643 /* Line 1806 of yacc.c */
8644 #line 3072 "ripper.y"
8645  {
8646  token_info_push("until");
8647  }
8648  break;
8649 
8650  case 345:
8651 
8652 /* Line 1806 of yacc.c */
8653 #line 3078 "ripper.y"
8654  {
8655  token_info_push("case");
8656  }
8657  break;
8658 
8659  case 346:
8660 
8661 /* Line 1806 of yacc.c */
8662 #line 3084 "ripper.y"
8663  {
8664  token_info_push("for");
8665  }
8666  break;
8667 
8668  case 347:
8669 
8670 /* Line 1806 of yacc.c */
8671 #line 3090 "ripper.y"
8672  {
8673  token_info_push("class");
8674  }
8675  break;
8676 
8677  case 348:
8678 
8679 /* Line 1806 of yacc.c */
8680 #line 3096 "ripper.y"
8681  {
8682  token_info_push("module");
8683  }
8684  break;
8685 
8686  case 349:
8687 
8688 /* Line 1806 of yacc.c */
8689 #line 3102 "ripper.y"
8690  {
8691  token_info_push("def");
8692 #if 0
8693  (yyval.num) = ruby_sourceline;
8694 #endif
8695 
8696  }
8697  break;
8698 
8699  case 350:
8700 
8701 /* Line 1806 of yacc.c */
8702 #line 3112 "ripper.y"
8703  {
8704  token_info_pop("end");
8705  }
8706  break;
8707 
8708  case 351:
8709 
8710 /* Line 1806 of yacc.c */
8711 #line 3120 "ripper.y"
8712  { (yyval.val) = Qnil; }
8713  break;
8714 
8715  case 353:
8716 
8717 /* Line 1806 of yacc.c */
8718 #line 3126 "ripper.y"
8719  { (yyval.val) = (yyvsp[(2) - (2)].val); }
8720  break;
8721 
8722  case 354:
8723 
8724 /* Line 1806 of yacc.c */
8725 #line 3133 "ripper.y"
8726  { (yyval.val) = Qnil; }
8727  break;
8728 
8729  case 357:
8730 
8731 /* Line 1806 of yacc.c */
8732 #line 3142 "ripper.y"
8733  {
8734 #if 0
8735  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
8736  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8737 #endif
8738  (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
8739 
8740  }
8741  break;
8742 
8743  case 359:
8744 
8745 /* Line 1806 of yacc.c */
8746 #line 3154 "ripper.y"
8747  {
8748 #if 0
8749  (yyval.val) = (yyvsp[(2) - (2)].val);
8750 #endif
8751  (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
8752 
8753  }
8754  break;
8755 
8756  case 362:
8757 
8758 /* Line 1806 of yacc.c */
8759 #line 3168 "ripper.y"
8760  {
8761  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
8762 #if 0
8763 #endif
8764  (yyval.val) = dispatch1(mlhs_paren, (yyval.val));
8765 
8766  }
8767  break;
8768 
8769  case 363:
8770 
8771 /* Line 1806 of yacc.c */
8772 #line 3176 "ripper.y"
8773  {
8774 #if 0
8775  (yyval.val) = (yyvsp[(2) - (3)].val);
8776 #endif
8777  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
8778 
8779  }
8780  break;
8781 
8782  case 364:
8783 
8784 /* Line 1806 of yacc.c */
8785 #line 3186 "ripper.y"
8786  {
8787 #if 0
8788  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
8789 #endif
8790  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
8791 
8792  }
8793  break;
8794 
8795  case 365:
8796 
8797 /* Line 1806 of yacc.c */
8798 #line 3194 "ripper.y"
8799  {
8800 #if 0
8801  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8802 #endif
8803  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8804 
8805  }
8806  break;
8807 
8808  case 366:
8809 
8810 /* Line 1806 of yacc.c */
8811 #line 3204 "ripper.y"
8812  {
8813 #if 0
8814  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
8815 #endif
8816  (yyval.val) = (yyvsp[(1) - (1)].val);
8817 
8818  }
8819  break;
8820 
8821  case 367:
8822 
8823 /* Line 1806 of yacc.c */
8824 #line 3212 "ripper.y"
8825  {
8826  (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
8827 #if 0
8828  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val));
8829 #endif
8830  (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
8831 
8832  }
8833  break;
8834 
8835  case 368:
8836 
8837 /* Line 1806 of yacc.c */
8838 #line 3221 "ripper.y"
8839  {
8840  (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
8841 #if 0
8842  (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val)));
8843 #endif
8844  (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
8845 
8846  }
8847  break;
8848 
8849  case 369:
8850 
8851 /* Line 1806 of yacc.c */
8852 #line 3230 "ripper.y"
8853  {
8854 #if 0
8855  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
8856 #endif
8857  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
8858 
8859  }
8860  break;
8861 
8862  case 370:
8863 
8864 /* Line 1806 of yacc.c */
8865 #line 3238 "ripper.y"
8866  {
8867 #if 0
8868  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
8869 #endif
8870  (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
8871 
8872  }
8873  break;
8874 
8875  case 371:
8876 
8877 /* Line 1806 of yacc.c */
8878 #line 3246 "ripper.y"
8879  {
8880  (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
8881 #if 0
8882  (yyval.val) = NEW_MASGN(0, (yyval.val));
8883 #endif
8884  (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
8885 
8886  }
8887  break;
8888 
8889  case 372:
8890 
8891 /* Line 1806 of yacc.c */
8892 #line 3255 "ripper.y"
8893  {
8894  (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
8895 #if 0
8896  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val)));
8897 #endif
8898  #if 0
8899  TODO: Check me
8900  #endif
8901  (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val));
8902 
8903  }
8904  break;
8905 
8906  case 373:
8907 
8908 /* Line 1806 of yacc.c */
8909 #line 3267 "ripper.y"
8910  {
8911 #if 0
8912  (yyval.val) = NEW_MASGN(0, -1);
8913 #endif
8914  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8915 
8916  }
8917  break;
8918 
8919  case 374:
8920 
8921 /* Line 1806 of yacc.c */
8922 #line 3275 "ripper.y"
8923  {
8924 #if 0
8925  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
8926 #endif
8927  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8928 
8929  }
8930  break;
8931 
8932  case 375:
8933 
8934 /* Line 1806 of yacc.c */
8935 #line 3286 "ripper.y"
8936  {
8937  (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
8938  }
8939  break;
8940 
8941  case 376:
8942 
8943 /* Line 1806 of yacc.c */
8944 #line 3290 "ripper.y"
8945  {
8946  (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
8947  }
8948  break;
8949 
8950  case 377:
8951 
8952 /* Line 1806 of yacc.c */
8953 #line 3294 "ripper.y"
8954  {
8955  (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
8956  }
8957  break;
8958 
8959  case 378:
8960 
8961 /* Line 1806 of yacc.c */
8962 #line 3298 "ripper.y"
8963  {
8964  (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
8965  }
8966  break;
8967 
8968  case 379:
8969 
8970 /* Line 1806 of yacc.c */
8971 #line 3304 "ripper.y"
8972  {
8973  (yyval.val) = (yyvsp[(2) - (2)].val);
8974  }
8975  break;
8976 
8977  case 380:
8978 
8979 /* Line 1806 of yacc.c */
8980 #line 3308 "ripper.y"
8981  {
8982  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
8983  }
8984  break;
8985 
8986  case 381:
8987 
8988 /* Line 1806 of yacc.c */
8989 #line 3314 "ripper.y"
8990  {
8991  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
8992  }
8993  break;
8994 
8995  case 382:
8996 
8997 /* Line 1806 of yacc.c */
8998 #line 3318 "ripper.y"
8999  {
9000  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
9001  }
9002  break;
9003 
9004  case 383:
9005 
9006 /* Line 1806 of yacc.c */
9007 #line 3322 "ripper.y"
9008  {
9009  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
9010  }
9011  break;
9012 
9013  case 384:
9014 
9015 /* Line 1806 of yacc.c */
9016 #line 3326 "ripper.y"
9017  {
9018  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9019  }
9020  break;
9021 
9022  case 385:
9023 
9024 /* Line 1806 of yacc.c */
9025 #line 3330 "ripper.y"
9026  {
9027  (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
9028  }
9029  break;
9030 
9031  case 386:
9032 
9033 /* Line 1806 of yacc.c */
9034 #line 3334 "ripper.y"
9035  {
9036  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
9037 #if 0
9038 #endif
9039  dispatch1(excessed_comma, (yyval.val));
9040 
9041  }
9042  break;
9043 
9044  case 387:
9045 
9046 /* Line 1806 of yacc.c */
9047 #line 3342 "ripper.y"
9048  {
9049  (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9050  }
9051  break;
9052 
9053  case 388:
9054 
9055 /* Line 1806 of yacc.c */
9056 #line 3346 "ripper.y"
9057  {
9058  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
9059  }
9060  break;
9061 
9062  case 389:
9063 
9064 /* Line 1806 of yacc.c */
9065 #line 3350 "ripper.y"
9066  {
9067  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
9068  }
9069  break;
9070 
9071  case 390:
9072 
9073 /* Line 1806 of yacc.c */
9074 #line 3354 "ripper.y"
9075  {
9076  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9077  }
9078  break;
9079 
9080  case 391:
9081 
9082 /* Line 1806 of yacc.c */
9083 #line 3358 "ripper.y"
9084  {
9085  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
9086  }
9087  break;
9088 
9089  case 392:
9090 
9091 /* Line 1806 of yacc.c */
9092 #line 3362 "ripper.y"
9093  {
9094  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9095  }
9096  break;
9097 
9098  case 393:
9099 
9100 /* Line 1806 of yacc.c */
9101 #line 3366 "ripper.y"
9102  {
9103  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
9104  }
9105  break;
9106 
9107  case 394:
9108 
9109 /* Line 1806 of yacc.c */
9110 #line 3370 "ripper.y"
9111  {
9112  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9113  }
9114  break;
9115 
9116  case 395:
9117 
9118 /* Line 1806 of yacc.c */
9119 #line 3374 "ripper.y"
9120  {
9121  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
9122  }
9123  break;
9124 
9125  case 397:
9126 
9127 /* Line 1806 of yacc.c */
9128 #line 3381 "ripper.y"
9129  {
9130  command_start = TRUE;
9131  }
9132  break;
9133 
9134  case 398:
9135 
9136 /* Line 1806 of yacc.c */
9137 #line 3387 "ripper.y"
9138  {
9139 #if 0
9140  (yyval.val) = 0;
9141 #endif
9142  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9143  escape_Qundef((yyvsp[(2) - (3)].val)));
9144 
9145  }
9146  break;
9147 
9148  case 399:
9149 
9150 /* Line 1806 of yacc.c */
9151 #line 3396 "ripper.y"
9152  {
9153 #if 0
9154  (yyval.val) = 0;
9155 #endif
9156  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9157  Qnil);
9158 
9159  }
9160  break;
9161 
9162  case 400:
9163 
9164 /* Line 1806 of yacc.c */
9165 #line 3405 "ripper.y"
9166  {
9167 #if 0
9168  (yyval.val) = (yyvsp[(2) - (4)].val);
9169 #endif
9170  (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
9171 
9172  }
9173  break;
9174 
9175  case 401:
9176 
9177 /* Line 1806 of yacc.c */
9178 #line 3416 "ripper.y"
9179  {
9180  (yyval.val) = 0;
9181  }
9182  break;
9183 
9184  case 402:
9185 
9186 /* Line 1806 of yacc.c */
9187 #line 3420 "ripper.y"
9188  {
9189 #if 0
9190  (yyval.val) = 0;
9191 #endif
9192  (yyval.val) = (yyvsp[(3) - (4)].val);
9193 
9194  }
9195  break;
9196 
9197  case 403:
9198 
9199 /* Line 1806 of yacc.c */
9200 #line 3432 "ripper.y"
9201  {
9202  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9203  }
9204  break;
9205 
9206  case 404:
9207 
9208 /* Line 1806 of yacc.c */
9209 #line 3439 "ripper.y"
9210  {
9211  rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
9212  }
9213  break;
9214 
9215  case 405:
9216 
9217 /* Line 1806 of yacc.c */
9218 #line 3446 "ripper.y"
9219  {
9220  new_bv(get_id((yyvsp[(1) - (1)].val)));
9221 #if 0
9222 #endif
9223  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
9224 
9225  }
9226  break;
9227 
9228  case 406:
9229 
9230 /* Line 1806 of yacc.c */
9231 #line 3454 "ripper.y"
9232  {
9233  (yyval.val) = 0;
9234  }
9235  break;
9236 
9237  case 407:
9238 
9239 /* Line 1806 of yacc.c */
9240 #line 3459 "ripper.y"
9241  {
9242  (yyval.vars) = dyna_push();
9243  }
9244  break;
9245 
9246  case 408:
9247 
9248 /* Line 1806 of yacc.c */
9249 #line 3462 "ripper.y"
9250  {
9251  (yyval.num) = lpar_beg;
9252  lpar_beg = ++paren_nest;
9253  }
9254  break;
9255 
9256  case 409:
9257 
9258 /* Line 1806 of yacc.c */
9259 #line 3467 "ripper.y"
9260  {
9261  (yyval.num) = ruby_sourceline;
9262  }
9263  break;
9264 
9265  case 410:
9266 
9267 /* Line 1806 of yacc.c */
9268 #line 3470 "ripper.y"
9269  {
9270  (yyval.val) = cmdarg_stack;
9271  cmdarg_stack = 0;
9272  }
9273  break;
9274 
9275  case 411:
9276 
9277 /* Line 1806 of yacc.c */
9278 #line 3475 "ripper.y"
9279  {
9280  lpar_beg = (yyvsp[(2) - (6)].num);
9281  cmdarg_stack = (yyvsp[(5) - (6)].val);
9282  CMDARG_LEXPOP();
9283 #if 0
9284  (yyval.val) = NEW_LAMBDA((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
9285  nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
9286 #endif
9287  (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
9288 
9289  dyna_pop((yyvsp[(1) - (6)].vars));
9290  }
9291  break;
9292 
9293  case 412:
9294 
9295 /* Line 1806 of yacc.c */
9296 #line 3490 "ripper.y"
9297  {
9298 #if 0
9299  (yyval.val) = (yyvsp[(2) - (4)].val);
9300 #endif
9301  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
9302 
9303  }
9304  break;
9305 
9306  case 413:
9307 
9308 /* Line 1806 of yacc.c */
9309 #line 3498 "ripper.y"
9310  {
9311  (yyval.val) = (yyvsp[(1) - (1)].val);
9312  }
9313  break;
9314 
9315  case 414:
9316 
9317 /* Line 1806 of yacc.c */
9318 #line 3504 "ripper.y"
9319  {
9320  (yyval.val) = (yyvsp[(2) - (3)].val);
9321  }
9322  break;
9323 
9324  case 415:
9325 
9326 /* Line 1806 of yacc.c */
9327 #line 3508 "ripper.y"
9328  {
9329  (yyval.val) = (yyvsp[(2) - (3)].val);
9330  }
9331  break;
9332 
9333  case 416:
9334 
9335 /* Line 1806 of yacc.c */
9336 #line 3514 "ripper.y"
9337  {
9338  (yyvsp[(1) - (1)].vars) = dyna_push();
9339 #if 0
9340  (yyval.num) = ruby_sourceline;
9341 #endif
9342  }
9343  break;
9344 
9345  case 417:
9346 
9347 /* Line 1806 of yacc.c */
9348 #line 3523 "ripper.y"
9349  {
9350 #if 0
9351  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9352  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9353 #endif
9354  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9355 
9356  dyna_pop((yyvsp[(1) - (5)].vars));
9357  }
9358  break;
9359 
9360  case 418:
9361 
9362 /* Line 1806 of yacc.c */
9363 #line 3535 "ripper.y"
9364  {
9365 #if 0
9366  if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
9367  compile_error(PARSER_ARG "block given to yield");
9368  }
9369  else {
9370  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
9371  }
9372  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
9373  (yyval.val) = (yyvsp[(2) - (2)].val);
9374  fixpos((yyval.val), (yyvsp[(1) - (2)].val));
9375 #endif
9376  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9377 
9378  }
9379  break;
9380 
9381  case 419:
9382 
9383 /* Line 1806 of yacc.c */
9384 #line 3551 "ripper.y"
9385  {
9386 #if 0
9387  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9388 #endif
9389  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
9390  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9391 
9392  }
9393  break;
9394 
9395  case 420:
9396 
9397 /* Line 1806 of yacc.c */
9398 #line 3560 "ripper.y"
9399  {
9400 #if 0
9401  block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9402  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9403  (yyval.val) = (yyvsp[(5) - (5)].val);
9404  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
9405 #endif
9406  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9407  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
9408 
9409  }
9410  break;
9411 
9412  case 421:
9413 
9414 /* Line 1806 of yacc.c */
9415 #line 3572 "ripper.y"
9416  {
9417 #if 0
9418  block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9419  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9420  (yyval.val) = (yyvsp[(5) - (5)].val);
9421  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
9422 #endif
9423  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9424  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
9425 
9426  }
9427  break;
9428 
9429  case 422:
9430 
9431 /* Line 1806 of yacc.c */
9432 #line 3586 "ripper.y"
9433  {
9434 #if 0
9435  (yyval.val) = (yyvsp[(1) - (2)].val);
9436  (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
9437 #endif
9438  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
9439 
9440  }
9441  break;
9442 
9443  case 423:
9444 
9445 /* Line 1806 of yacc.c */
9446 #line 3595 "ripper.y"
9447  {
9448 #if 0
9449  (yyval.num) = ruby_sourceline;
9450 #endif
9451  }
9452  break;
9453 
9454  case 424:
9455 
9456 /* Line 1806 of yacc.c */
9457 #line 3601 "ripper.y"
9458  {
9459 #if 0
9460  (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9461  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9462 #endif
9463  (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
9464  (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
9465 
9466  }
9467  break;
9468 
9469  case 425:
9470 
9471 /* Line 1806 of yacc.c */
9472 #line 3611 "ripper.y"
9473  {
9474 #if 0
9475  (yyval.num) = ruby_sourceline;
9476 #endif
9477  }
9478  break;
9479 
9480  case 426:
9481 
9482 /* Line 1806 of yacc.c */
9483 #line 3617 "ripper.y"
9484  {
9485 #if 0
9486  (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9487  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9488 #endif
9489  (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
9490  (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
9491 
9492  }
9493  break;
9494 
9495  case 427:
9496 
9497 /* Line 1806 of yacc.c */
9498 #line 3627 "ripper.y"
9499  {
9500 #if 0
9501  (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
9502 #endif
9503  (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
9504 
9505  }
9506  break;
9507 
9508  case 428:
9509 
9510 /* Line 1806 of yacc.c */
9511 #line 3635 "ripper.y"
9512  {
9513 #if 0
9514  (yyval.num) = ruby_sourceline;
9515 #endif
9516  }
9517  break;
9518 
9519  case 429:
9520 
9521 /* Line 1806 of yacc.c */
9522 #line 3641 "ripper.y"
9523  {
9524 #if 0
9525  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
9526  nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
9527 #endif
9528  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'),
9529  ripper_intern("call"));
9530  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9531 
9532  }
9533  break;
9534 
9535  case 430:
9536 
9537 /* Line 1806 of yacc.c */
9538 #line 3652 "ripper.y"
9539  {
9540 #if 0
9541  (yyval.num) = ruby_sourceline;
9542 #endif
9543  }
9544  break;
9545 
9546  case 431:
9547 
9548 /* Line 1806 of yacc.c */
9549 #line 3658 "ripper.y"
9550  {
9551 #if 0
9552  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
9553  nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
9554 #endif
9555  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"),
9556  ripper_intern("call"));
9557  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9558 
9559  }
9560  break;
9561 
9562  case 432:
9563 
9564 /* Line 1806 of yacc.c */
9565 #line 3669 "ripper.y"
9566  {
9567 #if 0
9568  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
9569 #endif
9570  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
9571 
9572  }
9573  break;
9574 
9575  case 433:
9576 
9577 /* Line 1806 of yacc.c */
9578 #line 3677 "ripper.y"
9579  {
9580 #if 0
9581  (yyval.val) = NEW_ZSUPER();
9582 #endif
9583  (yyval.val) = dispatch0(zsuper);
9584 
9585  }
9586  break;
9587 
9588  case 434:
9589 
9590 /* Line 1806 of yacc.c */
9591 #line 3685 "ripper.y"
9592  {
9593 #if 0
9594  if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
9595  (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val));
9596  else
9597  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val));
9598  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
9599 #endif
9600  (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
9601 
9602  }
9603  break;
9604 
9605  case 435:
9606 
9607 /* Line 1806 of yacc.c */
9608 #line 3699 "ripper.y"
9609  {
9610  (yyvsp[(1) - (1)].vars) = dyna_push();
9611 #if 0
9612  (yyval.num) = ruby_sourceline;
9613 #endif
9614 
9615  }
9616  break;
9617 
9618  case 436:
9619 
9620 /* Line 1806 of yacc.c */
9621 #line 3708 "ripper.y"
9622  {
9623 #if 0
9624  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9625  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9626 #endif
9627  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9628 
9629  dyna_pop((yyvsp[(1) - (5)].vars));
9630  }
9631  break;
9632 
9633  case 437:
9634 
9635 /* Line 1806 of yacc.c */
9636 #line 3718 "ripper.y"
9637  {
9638  (yyvsp[(1) - (1)].vars) = dyna_push();
9639 #if 0
9640  (yyval.num) = ruby_sourceline;
9641 #endif
9642 
9643  }
9644  break;
9645 
9646  case 438:
9647 
9648 /* Line 1806 of yacc.c */
9649 #line 3727 "ripper.y"
9650  {
9651 #if 0
9652  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9653  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9654 #endif
9655  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9656 
9657  dyna_pop((yyvsp[(1) - (5)].vars));
9658  }
9659  break;
9660 
9661  case 439:
9662 
9663 /* Line 1806 of yacc.c */
9664 #line 3741 "ripper.y"
9665  {
9666 #if 0
9667  (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9668 #endif
9669  (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
9670 
9671  }
9672  break;
9673 
9674  case 442:
9675 
9676 /* Line 1806 of yacc.c */
9677 #line 3757 "ripper.y"
9678  {
9679 #if 0
9680  if ((yyvsp[(3) - (6)].val)) {
9681  (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO());
9682  (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
9683  }
9684  (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9685  fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
9686 #endif
9687  (yyval.val) = dispatch4(rescue,
9688  escape_Qundef((yyvsp[(2) - (6)].val)),
9689  escape_Qundef((yyvsp[(3) - (6)].val)),
9690  escape_Qundef((yyvsp[(5) - (6)].val)),
9691  escape_Qundef((yyvsp[(6) - (6)].val)));
9692 
9693  }
9694  break;
9695 
9696  case 444:
9697 
9698 /* Line 1806 of yacc.c */
9699 #line 3777 "ripper.y"
9700  {
9701 #if 0
9702  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
9703 #endif
9704  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9705 
9706  }
9707  break;
9708 
9709  case 445:
9710 
9711 /* Line 1806 of yacc.c */
9712 #line 3785 "ripper.y"
9713  {
9714 #if 0
9715  if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
9716 #endif
9717  (yyval.val) = (yyvsp[(1) - (1)].val);
9718 
9719  }
9720  break;
9721 
9722  case 447:
9723 
9724 /* Line 1806 of yacc.c */
9725 #line 3796 "ripper.y"
9726  {
9727  (yyval.val) = (yyvsp[(2) - (2)].val);
9728  }
9729  break;
9730 
9731  case 449:
9732 
9733 /* Line 1806 of yacc.c */
9734 #line 3803 "ripper.y"
9735  {
9736 #if 0
9737  (yyval.val) = (yyvsp[(2) - (2)].val);
9738 #endif
9739  (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
9740 
9741  }
9742  break;
9743 
9744  case 452:
9745 
9746 /* Line 1806 of yacc.c */
9747 #line 3815 "ripper.y"
9748  {
9749 #if 0
9750  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
9751 #endif
9752  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
9753 
9754  }
9755  break;
9756 
9757  case 454:
9758 
9759 /* Line 1806 of yacc.c */
9760 #line 3826 "ripper.y"
9761  {
9762 #if 0
9763  NODE *node = (yyvsp[(1) - (1)].val);
9764  if (!node) {
9765  node = NEW_STR(STR_NEW0());
9766  }
9767  else {
9768  node = evstr2dstr(node);
9769  }
9770  (yyval.val) = node;
9771 #endif
9772  (yyval.val) = (yyvsp[(1) - (1)].val);
9773 
9774  }
9775  break;
9776 
9777  case 457:
9778 
9779 /* Line 1806 of yacc.c */
9780 #line 3845 "ripper.y"
9781  {
9782 #if 0
9783  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9784 #endif
9785  (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9786 
9787  }
9788  break;
9789 
9790  case 458:
9791 
9792 /* Line 1806 of yacc.c */
9793 #line 3855 "ripper.y"
9794  {
9795 #if 0
9796  (yyval.val) = (yyvsp[(2) - (3)].val);
9797 #endif
9798  (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val));
9799 
9800  }
9801  break;
9802 
9803  case 459:
9804 
9805 /* Line 1806 of yacc.c */
9806 #line 3865 "ripper.y"
9807  {
9808 #if 0
9809  NODE *node = (yyvsp[(2) - (3)].val);
9810  if (!node) {
9811  node = NEW_XSTR(STR_NEW0());
9812  }
9813  else {
9814  switch (nd_type(node)) {
9815  case NODE_STR:
9816  nd_set_type(node, NODE_XSTR);
9817  break;
9818  case NODE_DSTR:
9819  nd_set_type(node, NODE_DXSTR);
9820  break;
9821  default:
9822  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
9823  break;
9824  }
9825  }
9826  (yyval.val) = node;
9827 #endif
9828  (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val));
9829 
9830  }
9831  break;
9832 
9833  case 460:
9834 
9835 /* Line 1806 of yacc.c */
9836 #line 3892 "ripper.y"
9837  {
9838 #if 0
9839  int options = (yyvsp[(3) - (3)].val);
9840  NODE *node = (yyvsp[(2) - (3)].val);
9841  NODE *list, *prev;
9842  if (!node) {
9843  node = NEW_LIT(reg_compile(STR_NEW0(), options));
9844  }
9845  else switch (nd_type(node)) {
9846  case NODE_STR:
9847  {
9848  VALUE src = node->nd_lit;
9849  nd_set_type(node, NODE_LIT);
9850  node->nd_lit = reg_compile(src, options);
9851  }
9852  break;
9853  default:
9854  node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
9855  case NODE_DSTR:
9856  if (options & RE_OPTION_ONCE) {
9858  }
9859  else {
9860  nd_set_type(node, NODE_DREGX);
9861  }
9862  node->nd_cflag = options & RE_OPTION_MASK;
9863  if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
9864  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
9865  if (nd_type(list->nd_head) == NODE_STR) {
9866  VALUE tail = list->nd_head->nd_lit;
9867  if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
9868  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
9869  if (!literal_concat0(parser, lit, tail)) {
9870  node = 0;
9871  break;
9872  }
9873  rb_str_resize(tail, 0);
9874  prev->nd_next = list->nd_next;
9875  rb_gc_force_recycle((VALUE)list->nd_head);
9876  rb_gc_force_recycle((VALUE)list);
9877  list = prev;
9878  }
9879  else {
9880  prev = list;
9881  }
9882  }
9883  else {
9884  prev = 0;
9885  }
9886  }
9887  if (!node->nd_next) {
9888  VALUE src = node->nd_lit;
9889  nd_set_type(node, NODE_LIT);
9890  node->nd_lit = reg_compile(src, options);
9891  }
9892  break;
9893  }
9894  (yyval.val) = node;
9895 #endif
9896  (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
9897 
9898  }
9899  break;
9900 
9901  case 461:
9902 
9903 /* Line 1806 of yacc.c */
9904 #line 3957 "ripper.y"
9905  {
9906 #if 0
9907  (yyval.val) = NEW_ZARRAY();
9908 #endif
9909  (yyval.val) = dispatch0(words_new);
9910  (yyval.val) = dispatch1(array, (yyval.val));
9911 
9912  }
9913  break;
9914 
9915  case 462:
9916 
9917 /* Line 1806 of yacc.c */
9918 #line 3966 "ripper.y"
9919  {
9920 #if 0
9921  (yyval.val) = (yyvsp[(2) - (3)].val);
9922 #endif
9923  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9924 
9925  }
9926  break;
9927 
9928  case 463:
9929 
9930 /* Line 1806 of yacc.c */
9931 #line 3976 "ripper.y"
9932  {
9933 #if 0
9934  (yyval.val) = 0;
9935 #endif
9936  (yyval.val) = dispatch0(words_new);
9937 
9938  }
9939  break;
9940 
9941  case 464:
9942 
9943 /* Line 1806 of yacc.c */
9944 #line 3984 "ripper.y"
9945  {
9946 #if 0
9947  (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
9948 #endif
9949  (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9950 
9951  }
9952  break;
9953 
9954  case 465:
9955 
9956 /* Line 1806 of yacc.c */
9957 #line 3996 "ripper.y"
9958  {
9959  (yyval.val) = dispatch0(word_new);
9960  (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
9961  }
9962  break;
9963 
9964  case 466:
9965 
9966 /* Line 1806 of yacc.c */
9967 #line 4002 "ripper.y"
9968  {
9969 #if 0
9970  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9971 #endif
9972  (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9973 
9974  }
9975  break;
9976 
9977  case 467:
9978 
9979 /* Line 1806 of yacc.c */
9980 #line 4012 "ripper.y"
9981  {
9982 #if 0
9983  (yyval.val) = NEW_ZARRAY();
9984 #endif
9985  (yyval.val) = dispatch0(symbols_new);
9986  (yyval.val) = dispatch1(array, (yyval.val));
9987 
9988  }
9989  break;
9990 
9991  case 468:
9992 
9993 /* Line 1806 of yacc.c */
9994 #line 4021 "ripper.y"
9995  {
9996 #if 0
9997  (yyval.val) = (yyvsp[(2) - (3)].val);
9998 #endif
9999  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10000 
10001  }
10002  break;
10003 
10004  case 469:
10005 
10006 /* Line 1806 of yacc.c */
10007 #line 4031 "ripper.y"
10008  {
10009 #if 0
10010  (yyval.val) = 0;
10011 #endif
10012  (yyval.val) = dispatch0(symbols_new);
10013 
10014  }
10015  break;
10016 
10017  case 470:
10018 
10019 /* Line 1806 of yacc.c */
10020 #line 4039 "ripper.y"
10021  {
10022 #if 0
10023  (yyvsp[(2) - (3)].val) = evstr2dstr((yyvsp[(2) - (3)].val));
10024  if (nd_type((yyvsp[(2) - (3)].val)) == NODE_DSTR) {
10025  nd_set_type((yyvsp[(2) - (3)].val), NODE_DSYM);
10026  }
10027  else {
10028  nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
10029  (yyvsp[(2) - (3)].val)->nd_lit = rb_str_intern((yyvsp[(2) - (3)].val)->nd_lit);
10030  }
10031  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10032 #endif
10033  (yyval.val) = dispatch2(symbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10034 
10035  }
10036  break;
10037 
10038  case 471:
10039 
10040 /* Line 1806 of yacc.c */
10041 #line 4057 "ripper.y"
10042  {
10043 #if 0
10044  (yyval.val) = NEW_ZARRAY();
10045 #endif
10046  (yyval.val) = dispatch0(qwords_new);
10047  (yyval.val) = dispatch1(array, (yyval.val));
10048 
10049  }
10050  break;
10051 
10052  case 472:
10053 
10054 /* Line 1806 of yacc.c */
10055 #line 4066 "ripper.y"
10056  {
10057 #if 0
10058  (yyval.val) = (yyvsp[(2) - (3)].val);
10059 #endif
10060  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10061 
10062  }
10063  break;
10064 
10065  case 473:
10066 
10067 /* Line 1806 of yacc.c */
10068 #line 4076 "ripper.y"
10069  {
10070 #if 0
10071  (yyval.val) = NEW_ZARRAY();
10072 #endif
10073  (yyval.val) = dispatch0(qsymbols_new);
10074  (yyval.val) = dispatch1(array, (yyval.val));
10075 
10076  }
10077  break;
10078 
10079  case 474:
10080 
10081 /* Line 1806 of yacc.c */
10082 #line 4085 "ripper.y"
10083  {
10084 #if 0
10085  (yyval.val) = (yyvsp[(2) - (3)].val);
10086 #endif
10087  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10088 
10089  }
10090  break;
10091 
10092  case 475:
10093 
10094 /* Line 1806 of yacc.c */
10095 #line 4095 "ripper.y"
10096  {
10097 #if 0
10098  (yyval.val) = 0;
10099 #endif
10100  (yyval.val) = dispatch0(qwords_new);
10101 
10102  }
10103  break;
10104 
10105  case 476:
10106 
10107 /* Line 1806 of yacc.c */
10108 #line 4103 "ripper.y"
10109  {
10110 #if 0
10111  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10112 #endif
10113  (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10114 
10115  }
10116  break;
10117 
10118  case 477:
10119 
10120 /* Line 1806 of yacc.c */
10121 #line 4113 "ripper.y"
10122  {
10123 #if 0
10124  (yyval.val) = 0;
10125 #endif
10126  (yyval.val) = dispatch0(qsymbols_new);
10127 
10128  }
10129  break;
10130 
10131  case 478:
10132 
10133 /* Line 1806 of yacc.c */
10134 #line 4121 "ripper.y"
10135  {
10136 #if 0
10137  VALUE lit;
10138  lit = (yyvsp[(2) - (3)].val)->nd_lit;
10139  (yyvsp[(2) - (3)].val)->nd_lit = ID2SYM(rb_intern_str(lit));
10140  nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
10141  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10142 #endif
10143  (yyval.val) = dispatch2(qsymbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10144 
10145  }
10146  break;
10147 
10148  case 479:
10149 
10150 /* Line 1806 of yacc.c */
10151 #line 4135 "ripper.y"
10152  {
10153 #if 0
10154  (yyval.val) = 0;
10155 #endif
10156  (yyval.val) = dispatch0(string_content);
10157 
10158  }
10159  break;
10160 
10161  case 480:
10162 
10163 /* Line 1806 of yacc.c */
10164 #line 4143 "ripper.y"
10165  {
10166 #if 0
10167  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10168 #endif
10169  (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10170 
10171  }
10172  break;
10173 
10174  case 481:
10175 
10176 /* Line 1806 of yacc.c */
10177 #line 4153 "ripper.y"
10178  {
10179 #if 0
10180  (yyval.val) = 0;
10181 #endif
10182  (yyval.val) = dispatch0(xstring_new);
10183 
10184  }
10185  break;
10186 
10187  case 482:
10188 
10189 /* Line 1806 of yacc.c */
10190 #line 4161 "ripper.y"
10191  {
10192 #if 0
10193  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10194 #endif
10195  (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10196 
10197  }
10198  break;
10199 
10200  case 483:
10201 
10202 /* Line 1806 of yacc.c */
10203 #line 4171 "ripper.y"
10204  {
10205 #if 0
10206  (yyval.val) = 0;
10207 #endif
10208  (yyval.val) = dispatch0(regexp_new);
10209 
10210  }
10211  break;
10212 
10213  case 484:
10214 
10215 /* Line 1806 of yacc.c */
10216 #line 4179 "ripper.y"
10217  {
10218 #if 0
10219  NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
10220  if (!head) {
10221  (yyval.val) = tail;
10222  }
10223  else if (!tail) {
10224  (yyval.val) = head;
10225  }
10226  else {
10227  switch (nd_type(head)) {
10228  case NODE_STR:
10229  nd_set_type(head, NODE_DSTR);
10230  break;
10231  case NODE_DSTR:
10232  break;
10233  default:
10234  head = list_append(NEW_DSTR(Qnil), head);
10235  break;
10236  }
10237  (yyval.val) = list_append(head, tail);
10238  }
10239 #endif
10240  (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10241 
10242  }
10243  break;
10244 
10245  case 486:
10246 
10247 /* Line 1806 of yacc.c */
10248 #line 4209 "ripper.y"
10249  {
10250  (yyval.node) = lex_strterm;
10251  lex_strterm = 0;
10252  lex_state = EXPR_BEG;
10253  }
10254  break;
10255 
10256  case 487:
10257 
10258 /* Line 1806 of yacc.c */
10259 #line 4215 "ripper.y"
10260  {
10261 #if 0
10262  lex_strterm = (yyvsp[(2) - (3)].node);
10263  (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
10264 #endif
10265  lex_strterm = (yyvsp[(2) - (3)].node);
10266  (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
10267 
10268  }
10269  break;
10270 
10271  case 488:
10272 
10273 /* Line 1806 of yacc.c */
10274 #line 4225 "ripper.y"
10275  {
10276  (yyvsp[(1) - (1)].val) = cond_stack;
10277  (yyval.val) = cmdarg_stack;
10278  cond_stack = 0;
10279  cmdarg_stack = 0;
10280  }
10281  break;
10282 
10283  case 489:
10284 
10285 /* Line 1806 of yacc.c */
10286 #line 4231 "ripper.y"
10287  {
10288  (yyval.node) = lex_strterm;
10289  lex_strterm = 0;
10290  lex_state = EXPR_BEG;
10291  }
10292  break;
10293 
10294  case 490:
10295 
10296 /* Line 1806 of yacc.c */
10297 #line 4236 "ripper.y"
10298  {
10299  (yyval.num) = brace_nest;
10300  brace_nest = 0;
10301  }
10302  break;
10303 
10304  case 491:
10305 
10306 /* Line 1806 of yacc.c */
10307 #line 4241 "ripper.y"
10308  {
10309  cond_stack = (yyvsp[(1) - (6)].val);
10310  cmdarg_stack = (yyvsp[(2) - (6)].val);
10311  lex_strterm = (yyvsp[(3) - (6)].node);
10312  brace_nest = (yyvsp[(4) - (6)].num);
10313 #if 0
10314  if ((yyvsp[(5) - (6)].val)) (yyvsp[(5) - (6)].val)->flags &= ~NODE_FL_NEWLINE;
10315  (yyval.val) = new_evstr((yyvsp[(5) - (6)].val));
10316 #endif
10317  (yyval.val) = dispatch1(string_embexpr, (yyvsp[(5) - (6)].val));
10318 
10319  }
10320  break;
10321 
10322  case 492:
10323 
10324 /* Line 1806 of yacc.c */
10325 #line 4256 "ripper.y"
10326  {
10327 #if 0
10328  (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
10329 #endif
10330  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10331 
10332  }
10333  break;
10334 
10335  case 493:
10336 
10337 /* Line 1806 of yacc.c */
10338 #line 4264 "ripper.y"
10339  {
10340 #if 0
10341  (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
10342 #endif
10343  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10344 
10345  }
10346  break;
10347 
10348  case 494:
10349 
10350 /* Line 1806 of yacc.c */
10351 #line 4272 "ripper.y"
10352  {
10353 #if 0
10354  (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
10355 #endif
10356  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10357 
10358  }
10359  break;
10360 
10361  case 496:
10362 
10363 /* Line 1806 of yacc.c */
10364 #line 4283 "ripper.y"
10365  {
10366  lex_state = EXPR_END;
10367 #if 0
10368  (yyval.val) = (yyvsp[(2) - (2)].val);
10369 #endif
10370  (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
10371 
10372  }
10373  break;
10374 
10375  case 501:
10376 
10377 /* Line 1806 of yacc.c */
10378 #line 4300 "ripper.y"
10379  {
10380  lex_state = EXPR_END;
10381 #if 0
10382  (yyval.val) = dsym_node((yyvsp[(2) - (3)].val));
10383 #endif
10384  (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
10385 
10386  }
10387  break;
10388 
10389  case 503:
10390 
10391 /* Line 1806 of yacc.c */
10392 #line 4312 "ripper.y"
10393  {
10394 #if 0
10395  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10396 #endif
10397  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10398 
10399  }
10400  break;
10401 
10402  case 513:
10403 
10404 /* Line 1806 of yacc.c */
10405 #line 4334 "ripper.y"
10406  {ifndef_ripper((yyval.val) = keyword_nil);}
10407  break;
10408 
10409  case 514:
10410 
10411 /* Line 1806 of yacc.c */
10412 #line 4335 "ripper.y"
10413  {ifndef_ripper((yyval.val) = keyword_self);}
10414  break;
10415 
10416  case 515:
10417 
10418 /* Line 1806 of yacc.c */
10419 #line 4336 "ripper.y"
10420  {ifndef_ripper((yyval.val) = keyword_true);}
10421  break;
10422 
10423  case 516:
10424 
10425 /* Line 1806 of yacc.c */
10426 #line 4337 "ripper.y"
10427  {ifndef_ripper((yyval.val) = keyword_false);}
10428  break;
10429 
10430  case 517:
10431 
10432 /* Line 1806 of yacc.c */
10433 #line 4338 "ripper.y"
10434  {ifndef_ripper((yyval.val) = keyword__FILE__);}
10435  break;
10436 
10437  case 518:
10438 
10439 /* Line 1806 of yacc.c */
10440 #line 4339 "ripper.y"
10441  {ifndef_ripper((yyval.val) = keyword__LINE__);}
10442  break;
10443 
10444  case 519:
10445 
10446 /* Line 1806 of yacc.c */
10447 #line 4340 "ripper.y"
10448  {ifndef_ripper((yyval.val) = keyword__ENCODING__);}
10449  break;
10450 
10451  case 520:
10452 
10453 /* Line 1806 of yacc.c */
10454 #line 4344 "ripper.y"
10455  {
10456 #if 0
10457  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10458 #endif
10459  if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) {
10460  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10461  }
10462  else {
10463  (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val));
10464  }
10465 
10466  }
10467  break;
10468 
10469  case 521:
10470 
10471 /* Line 1806 of yacc.c */
10472 #line 4357 "ripper.y"
10473  {
10474 #if 0
10475  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10476 #endif
10477  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10478 
10479  }
10480  break;
10481 
10482  case 522:
10483 
10484 /* Line 1806 of yacc.c */
10485 #line 4367 "ripper.y"
10486  {
10487  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10488 #if 0
10489 #endif
10490  (yyval.val) = dispatch1(var_field, (yyval.val));
10491 
10492  }
10493  break;
10494 
10495  case 523:
10496 
10497 /* Line 1806 of yacc.c */
10498 #line 4375 "ripper.y"
10499  {
10500  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10501 #if 0
10502 #endif
10503  (yyval.val) = dispatch1(var_field, (yyval.val));
10504 
10505  }
10506  break;
10507 
10508  case 526:
10509 
10510 /* Line 1806 of yacc.c */
10511 #line 4389 "ripper.y"
10512  {
10513 #if 0
10514  (yyval.val) = 0;
10515 #endif
10516  (yyval.val) = Qnil;
10517 
10518  }
10519  break;
10520 
10521  case 527:
10522 
10523 /* Line 1806 of yacc.c */
10524 #line 4397 "ripper.y"
10525  {
10526  lex_state = EXPR_BEG;
10527  command_start = TRUE;
10528  }
10529  break;
10530 
10531  case 528:
10532 
10533 /* Line 1806 of yacc.c */
10534 #line 4402 "ripper.y"
10535  {
10536  (yyval.val) = (yyvsp[(3) - (4)].val);
10537  }
10538  break;
10539 
10540  case 529:
10541 
10542 /* Line 1806 of yacc.c */
10543 #line 4406 "ripper.y"
10544  {
10545 #if 0
10546  yyerrok;
10547  (yyval.val) = 0;
10548 #endif
10549  yyerrok;
10550  (yyval.val) = Qnil;
10551 
10552  }
10553  break;
10554 
10555  case 530:
10556 
10557 /* Line 1806 of yacc.c */
10558 #line 4418 "ripper.y"
10559  {
10560 #if 0
10561  (yyval.val) = (yyvsp[(2) - (3)].val);
10562 #endif
10563  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
10564 
10565  lex_state = EXPR_BEG;
10566  command_start = TRUE;
10567  }
10568  break;
10569 
10570  case 531:
10571 
10572 /* Line 1806 of yacc.c */
10573 #line 4427 "ripper.y"
10574  {
10575  (yyval.num) = parser->parser_in_kwarg;
10576  parser->parser_in_kwarg = 1;
10577  }
10578  break;
10579 
10580  case 532:
10581 
10582 /* Line 1806 of yacc.c */
10583 #line 4432 "ripper.y"
10584  {
10585  parser->parser_in_kwarg = (yyvsp[(1) - (3)].num);
10586  (yyval.val) = (yyvsp[(2) - (3)].val);
10587  lex_state = EXPR_BEG;
10588  command_start = TRUE;
10589  }
10590  break;
10591 
10592  case 533:
10593 
10594 /* Line 1806 of yacc.c */
10595 #line 4441 "ripper.y"
10596  {
10597  (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10598  }
10599  break;
10600 
10601  case 534:
10602 
10603 /* Line 1806 of yacc.c */
10604 #line 4445 "ripper.y"
10605  {
10606  (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10607  }
10608  break;
10609 
10610  case 535:
10611 
10612 /* Line 1806 of yacc.c */
10613 #line 4449 "ripper.y"
10614  {
10615  (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10616  }
10617  break;
10618 
10619  case 536:
10620 
10621 /* Line 1806 of yacc.c */
10622 #line 4453 "ripper.y"
10623  {
10624  (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
10625  }
10626  break;
10627 
10628  case 537:
10629 
10630 /* Line 1806 of yacc.c */
10631 #line 4459 "ripper.y"
10632  {
10633  (yyval.val) = (yyvsp[(2) - (2)].val);
10634  }
10635  break;
10636 
10637  case 538:
10638 
10639 /* Line 1806 of yacc.c */
10640 #line 4463 "ripper.y"
10641  {
10642  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10643  }
10644  break;
10645 
10646  case 539:
10647 
10648 /* Line 1806 of yacc.c */
10649 #line 4469 "ripper.y"
10650  {
10651  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
10652  }
10653  break;
10654 
10655  case 540:
10656 
10657 /* Line 1806 of yacc.c */
10658 #line 4473 "ripper.y"
10659  {
10660  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10661  }
10662  break;
10663 
10664  case 541:
10665 
10666 /* Line 1806 of yacc.c */
10667 #line 4477 "ripper.y"
10668  {
10669  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
10670  }
10671  break;
10672 
10673  case 542:
10674 
10675 /* Line 1806 of yacc.c */
10676 #line 4481 "ripper.y"
10677  {
10678  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10679  }
10680  break;
10681 
10682  case 543:
10683 
10684 /* Line 1806 of yacc.c */
10685 #line 4485 "ripper.y"
10686  {
10687  (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10688  }
10689  break;
10690 
10691  case 544:
10692 
10693 /* Line 1806 of yacc.c */
10694 #line 4489 "ripper.y"
10695  {
10696  (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10697  }
10698  break;
10699 
10700  case 545:
10701 
10702 /* Line 1806 of yacc.c */
10703 #line 4493 "ripper.y"
10704  {
10705  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
10706  }
10707  break;
10708 
10709  case 546:
10710 
10711 /* Line 1806 of yacc.c */
10712 #line 4497 "ripper.y"
10713  {
10714  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10715  }
10716  break;
10717 
10718  case 547:
10719 
10720 /* Line 1806 of yacc.c */
10721 #line 4501 "ripper.y"
10722  {
10723  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10724  }
10725  break;
10726 
10727  case 548:
10728 
10729 /* Line 1806 of yacc.c */
10730 #line 4505 "ripper.y"
10731  {
10732  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
10733  }
10734  break;
10735 
10736  case 549:
10737 
10738 /* Line 1806 of yacc.c */
10739 #line 4509 "ripper.y"
10740  {
10741  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10742  }
10743  break;
10744 
10745  case 550:
10746 
10747 /* Line 1806 of yacc.c */
10748 #line 4513 "ripper.y"
10749  {
10750  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10751  }
10752  break;
10753 
10754  case 551:
10755 
10756 /* Line 1806 of yacc.c */
10757 #line 4517 "ripper.y"
10758  {
10759  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10760  }
10761  break;
10762 
10763  case 552:
10764 
10765 /* Line 1806 of yacc.c */
10766 #line 4521 "ripper.y"
10767  {
10768  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
10769  }
10770  break;
10771 
10772  case 553:
10773 
10774 /* Line 1806 of yacc.c */
10775 #line 4525 "ripper.y"
10776  {
10777  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10778  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.val));
10779  }
10780  break;
10781 
10782  case 554:
10783 
10784 /* Line 1806 of yacc.c */
10785 #line 4532 "ripper.y"
10786  {
10787 #if 0
10788  yyerror("formal argument cannot be a constant");
10789  (yyval.val) = 0;
10790 #endif
10791  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10792 
10793  }
10794  break;
10795 
10796  case 555:
10797 
10798 /* Line 1806 of yacc.c */
10799 #line 4541 "ripper.y"
10800  {
10801 #if 0
10802  yyerror("formal argument cannot be an instance variable");
10803  (yyval.val) = 0;
10804 #endif
10805  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10806 
10807  }
10808  break;
10809 
10810  case 556:
10811 
10812 /* Line 1806 of yacc.c */
10813 #line 4550 "ripper.y"
10814  {
10815 #if 0
10816  yyerror("formal argument cannot be a global variable");
10817  (yyval.val) = 0;
10818 #endif
10819  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10820 
10821  }
10822  break;
10823 
10824  case 557:
10825 
10826 /* Line 1806 of yacc.c */
10827 #line 4559 "ripper.y"
10828  {
10829 #if 0
10830  yyerror("formal argument cannot be a class variable");
10831  (yyval.val) = 0;
10832 #endif
10833  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10834 
10835  }
10836  break;
10837 
10838  case 559:
10839 
10840 /* Line 1806 of yacc.c */
10841 #line 4571 "ripper.y"
10842  {
10843  formal_argument(get_id((yyvsp[(1) - (1)].val)));
10844  (yyval.val) = (yyvsp[(1) - (1)].val);
10845  }
10846  break;
10847 
10848  case 560:
10849 
10850 /* Line 1806 of yacc.c */
10851 #line 4578 "ripper.y"
10852  {
10853  arg_var(get_id((yyvsp[(1) - (1)].val)));
10854 #if 0
10855  (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10856 #endif
10857  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10858 
10859  }
10860  break;
10861 
10862  case 561:
10863 
10864 /* Line 1806 of yacc.c */
10865 #line 4587 "ripper.y"
10866  {
10867  ID tid = internal_id();
10868  arg_var(tid);
10869 #if 0
10870  if (dyna_in_block()) {
10871  (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10872  }
10873  else {
10874  (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10875  }
10876  (yyval.val) = NEW_ARGS_AUX(tid, 1);
10877  (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10878 #endif
10879  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10880 
10881  }
10882  break;
10883 
10884  case 562:
10885 
10886 /* Line 1806 of yacc.c */
10887 #line 4608 "ripper.y"
10888  {
10889  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10890  }
10891  break;
10892 
10893  case 563:
10894 
10895 /* Line 1806 of yacc.c */
10896 #line 4613 "ripper.y"
10897  {
10898 #if 0
10899  (yyval.val) = (yyvsp[(1) - (3)].val);
10900  (yyval.val)->nd_plen++;
10901  (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10902  rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10903 #endif
10904  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10905 
10906  }
10907  break;
10908 
10909  case 564:
10910 
10911 /* Line 1806 of yacc.c */
10912 #line 4627 "ripper.y"
10913  {
10914  arg_var(formal_argument(get_id((yyvsp[(1) - (1)].val))));
10915  (yyval.val) = (yyvsp[(1) - (1)].val);
10916  }
10917  break;
10918 
10919  case 565:
10920 
10921 /* Line 1806 of yacc.c */
10922 #line 4634 "ripper.y"
10923  {
10924  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10925 #if 0
10926  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10927 #endif
10928  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10929 
10930  }
10931  break;
10932 
10933  case 566:
10934 
10935 /* Line 1806 of yacc.c */
10936 #line 4643 "ripper.y"
10937  {
10938  (yyval.val) = assignable((yyvsp[(1) - (1)].val), (NODE *)-1);
10939 #if 0
10940  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10941 #endif
10942  (yyval.val) = rb_assoc_new((yyval.val), 0);
10943 
10944  }
10945  break;
10946 
10947  case 567:
10948 
10949 /* Line 1806 of yacc.c */
10950 #line 4654 "ripper.y"
10951  {
10952  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10953 #if 0
10954  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10955 #endif
10956  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10957 
10958  }
10959  break;
10960 
10961  case 568:
10962 
10963 /* Line 1806 of yacc.c */
10964 #line 4663 "ripper.y"
10965  {
10966  (yyval.val) = assignable((yyvsp[(1) - (1)].val), (NODE *)-1);
10967 #if 0
10968  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10969 #endif
10970  (yyval.val) = rb_assoc_new((yyval.val), 0);
10971 
10972  }
10973  break;
10974 
10975  case 569:
10976 
10977 /* Line 1806 of yacc.c */
10978 #line 4674 "ripper.y"
10979  {
10980 #if 0
10981  (yyval.val) = (yyvsp[(1) - (1)].val);
10982 #endif
10983  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10984 
10985  }
10986  break;
10987 
10988  case 570:
10989 
10990 /* Line 1806 of yacc.c */
10991 #line 4682 "ripper.y"
10992  {
10993 #if 0
10994  NODE *kws = (yyvsp[(1) - (3)].val);
10995 
10996  while (kws->nd_next) {
10997  kws = kws->nd_next;
10998  }
10999  kws->nd_next = (yyvsp[(3) - (3)].val);
11000  (yyval.val) = (yyvsp[(1) - (3)].val);
11001 #endif
11002  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11003 
11004  }
11005  break;
11006 
11007  case 571:
11008 
11009 /* Line 1806 of yacc.c */
11010 #line 4699 "ripper.y"
11011  {
11012 #if 0
11013  (yyval.val) = (yyvsp[(1) - (1)].val);
11014 #endif
11015  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11016 
11017  }
11018  break;
11019 
11020  case 572:
11021 
11022 /* Line 1806 of yacc.c */
11023 #line 4707 "ripper.y"
11024  {
11025 #if 0
11026  NODE *kws = (yyvsp[(1) - (3)].val);
11027 
11028  while (kws->nd_next) {
11029  kws = kws->nd_next;
11030  }
11031  kws->nd_next = (yyvsp[(3) - (3)].val);
11032  (yyval.val) = (yyvsp[(1) - (3)].val);
11033 #endif
11034  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11035 
11036  }
11037  break;
11038 
11039  case 575:
11040 
11041 /* Line 1806 of yacc.c */
11042 #line 4727 "ripper.y"
11043  {
11044  shadowing_lvar(get_id((yyvsp[(2) - (2)].val)));
11045  (yyval.val) = (yyvsp[(2) - (2)].val);
11046  }
11047  break;
11048 
11049  case 576:
11050 
11051 /* Line 1806 of yacc.c */
11052 #line 4732 "ripper.y"
11053  {
11054  (yyval.val) = internal_id();
11055  }
11056  break;
11057 
11058  case 577:
11059 
11060 /* Line 1806 of yacc.c */
11061 #line 4738 "ripper.y"
11062  {
11063  arg_var(get_id((yyvsp[(1) - (3)].val)));
11064  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11065 #if 0
11066  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
11067 #endif
11068  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
11069 
11070  }
11071  break;
11072 
11073  case 578:
11074 
11075 /* Line 1806 of yacc.c */
11076 #line 4750 "ripper.y"
11077  {
11078  arg_var(get_id((yyvsp[(1) - (3)].val)));
11079  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11080 #if 0
11081  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
11082 #endif
11083  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
11084 
11085  }
11086  break;
11087 
11088  case 579:
11089 
11090 /* Line 1806 of yacc.c */
11091 #line 4762 "ripper.y"
11092  {
11093 #if 0
11094  (yyval.val) = (yyvsp[(1) - (1)].val);
11095 #endif
11096  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11097 
11098  }
11099  break;
11100 
11101  case 580:
11102 
11103 /* Line 1806 of yacc.c */
11104 #line 4770 "ripper.y"
11105  {
11106 #if 0
11107  NODE *opts = (yyvsp[(1) - (3)].val);
11108 
11109  while (opts->nd_next) {
11110  opts = opts->nd_next;
11111  }
11112  opts->nd_next = (yyvsp[(3) - (3)].val);
11113  (yyval.val) = (yyvsp[(1) - (3)].val);
11114 #endif
11115  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11116 
11117  }
11118  break;
11119 
11120  case 581:
11121 
11122 /* Line 1806 of yacc.c */
11123 #line 4786 "ripper.y"
11124  {
11125 #if 0
11126  (yyval.val) = (yyvsp[(1) - (1)].val);
11127 #endif
11128  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11129 
11130  }
11131  break;
11132 
11133  case 582:
11134 
11135 /* Line 1806 of yacc.c */
11136 #line 4794 "ripper.y"
11137  {
11138 #if 0
11139  NODE *opts = (yyvsp[(1) - (3)].val);
11140 
11141  while (opts->nd_next) {
11142  opts = opts->nd_next;
11143  }
11144  opts->nd_next = (yyvsp[(3) - (3)].val);
11145  (yyval.val) = (yyvsp[(1) - (3)].val);
11146 #endif
11147  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11148 
11149  }
11150  break;
11151 
11152  case 585:
11153 
11154 /* Line 1806 of yacc.c */
11155 #line 4814 "ripper.y"
11156  {
11157 #if 0
11158  if (!is_local_id((yyvsp[(2) - (2)].val)))
11159  yyerror("rest argument must be local variable");
11160 #endif
11161  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11162 #if 0
11163  (yyval.val) = (yyvsp[(2) - (2)].val);
11164 #endif
11165  (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
11166 
11167  }
11168  break;
11169 
11170  case 586:
11171 
11172 /* Line 1806 of yacc.c */
11173 #line 4827 "ripper.y"
11174  {
11175 #if 0
11176  (yyval.val) = internal_id();
11177  arg_var((yyval.val));
11178 #endif
11179  (yyval.val) = dispatch1(rest_param, Qnil);
11180 
11181  }
11182  break;
11183 
11184  case 589:
11185 
11186 /* Line 1806 of yacc.c */
11187 #line 4842 "ripper.y"
11188  {
11189 #if 0
11190  if (!is_local_id((yyvsp[(2) - (2)].val)))
11191  yyerror("block argument must be local variable");
11192  else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
11193  yyerror("duplicated block argument name");
11194 #endif
11195  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11196 #if 0
11197  (yyval.val) = (yyvsp[(2) - (2)].val);
11198 #endif
11199  (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
11200 
11201  }
11202  break;
11203 
11204  case 590:
11205 
11206 /* Line 1806 of yacc.c */
11207 #line 4859 "ripper.y"
11208  {
11209  (yyval.val) = (yyvsp[(2) - (2)].val);
11210  }
11211  break;
11212 
11213  case 591:
11214 
11215 /* Line 1806 of yacc.c */
11216 #line 4863 "ripper.y"
11217  {
11218 #if 0
11219  (yyval.val) = 0;
11220 #endif
11221  (yyval.val) = Qundef;
11222 
11223  }
11224  break;
11225 
11226  case 592:
11227 
11228 /* Line 1806 of yacc.c */
11229 #line 4873 "ripper.y"
11230  {
11231 #if 0
11232  value_expr((yyvsp[(1) - (1)].val));
11233  (yyval.val) = (yyvsp[(1) - (1)].val);
11234  if (!(yyval.val)) (yyval.val) = NEW_NIL();
11235 #endif
11236  (yyval.val) = (yyvsp[(1) - (1)].val);
11237 
11238  }
11239  break;
11240 
11241  case 593:
11242 
11243 /* Line 1806 of yacc.c */
11244 #line 4882 "ripper.y"
11245  {lex_state = EXPR_BEG;}
11246  break;
11247 
11248  case 594:
11249 
11250 /* Line 1806 of yacc.c */
11251 #line 4883 "ripper.y"
11252  {
11253 #if 0
11254  if ((yyvsp[(3) - (4)].val) == 0) {
11255  yyerror("can't define singleton method for ().");
11256  }
11257  else {
11258  switch (nd_type((yyvsp[(3) - (4)].val))) {
11259  case NODE_STR:
11260  case NODE_DSTR:
11261  case NODE_XSTR:
11262  case NODE_DXSTR:
11263  case NODE_DREGX:
11264  case NODE_LIT:
11265  case NODE_ARRAY:
11266  case NODE_ZARRAY:
11267  yyerror("can't define singleton method for literals");
11268  default:
11269  value_expr((yyvsp[(3) - (4)].val));
11270  break;
11271  }
11272  }
11273  (yyval.val) = (yyvsp[(3) - (4)].val);
11274 #endif
11275  (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
11276 
11277  }
11278  break;
11279 
11280  case 596:
11281 
11282 /* Line 1806 of yacc.c */
11283 #line 4913 "ripper.y"
11284  {
11285 #if 0
11286  (yyval.val) = (yyvsp[(1) - (2)].val);
11287 #endif
11288  (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
11289 
11290  }
11291  break;
11292 
11293  case 597:
11294 
11295 /* Line 1806 of yacc.c */
11296 #line 4925 "ripper.y"
11297  {
11298  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11299  }
11300  break;
11301 
11302  case 598:
11303 
11304 /* Line 1806 of yacc.c */
11305 #line 4930 "ripper.y"
11306  {
11307 #if 0
11308  (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11309 #endif
11310  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11311 
11312  }
11313  break;
11314 
11315  case 599:
11316 
11317 /* Line 1806 of yacc.c */
11318 #line 4940 "ripper.y"
11319  {
11320 #if 0
11321  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_STR) {
11322  nd_set_type((yyvsp[(1) - (3)].val), NODE_LIT);
11323  (yyvsp[(1) - (3)].val)->nd_lit = rb_fstring((yyvsp[(1) - (3)].val)->nd_lit);
11324  }
11325  (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
11326 #endif
11327  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11328 
11329  }
11330  break;
11331 
11332  case 600:
11333 
11334 /* Line 1806 of yacc.c */
11335 #line 4952 "ripper.y"
11336  {
11337 #if 0
11338  (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
11339 #endif
11340  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
11341 
11342  }
11343  break;
11344 
11345  case 601:
11346 
11347 /* Line 1806 of yacc.c */
11348 #line 4960 "ripper.y"
11349  {
11350 #if 0
11351  (yyval.val) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].val));
11352 #endif
11353  (yyval.val) = dispatch1(assoc_splat, (yyvsp[(2) - (2)].val));
11354 
11355  }
11356  break;
11357 
11358  case 612:
11359 
11360 /* Line 1806 of yacc.c */
11361 #line 4990 "ripper.y"
11362  { (yyval.val) = (yyvsp[(1) - (1)].val); }
11363  break;
11364 
11365  case 613:
11366 
11367 /* Line 1806 of yacc.c */
11368 #line 4995 "ripper.y"
11369  { (yyval.val) = (yyvsp[(1) - (1)].val); }
11370  break;
11371 
11372  case 623:
11373 
11374 /* Line 1806 of yacc.c */
11375 #line 5018 "ripper.y"
11376  {yyerrok;}
11377  break;
11378 
11379  case 626:
11380 
11381 /* Line 1806 of yacc.c */
11382 #line 5023 "ripper.y"
11383  {yyerrok;}
11384  break;
11385 
11386  case 627:
11387 
11388 /* Line 1806 of yacc.c */
11389 #line 5027 "ripper.y"
11390  {
11391 #if 0
11392  (yyval.val) = 0;
11393 #endif
11394  (yyval.val) = Qundef;
11395 
11396  }
11397  break;
11398 
11399 
11400 
11401 /* Line 1806 of yacc.c */
11402 #line 11401 "parse.c"
11403  default: break;
11404  }
11405  /* User semantic actions sometimes alter yychar, and that requires
11406  that yytoken be updated with the new translation. We take the
11407  approach of translating immediately before every use of yytoken.
11408  One alternative is translating here after every semantic action,
11409  but that translation would be missed if the semantic action invokes
11410  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11411  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
11412  incorrect destructor might then be invoked immediately. In the
11413  case of YYERROR or YYBACKUP, subsequent parser actions might lead
11414  to an incorrect destructor call or verbose syntax error message
11415  before the lookahead is translated. */
11416  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11417 
11418  YYPOPSTACK (yylen);
11419  yylen = 0;
11420  YY_STACK_PRINT (yyss, yyssp);
11421 
11422  *++yyvsp = yyval;
11423 
11424  /* Now `shift' the result of the reduction. Determine what state
11425  that goes to, based on the state we popped back to and the rule
11426  number reduced by. */
11427 
11428  yyn = yyr1[yyn];
11429 
11430  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
11431  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
11432  yystate = yytable[yystate];
11433  else
11434  yystate = yydefgoto[yyn - YYNTOKENS];
11435 
11436  goto yynewstate;
11437 
11438 
11439 /*------------------------------------.
11440 | yyerrlab -- here on detecting error |
11441 `------------------------------------*/
11442 yyerrlab:
11443  /* Make sure we have latest lookahead translation. See comments at
11444  user semantic actions for why this is necessary. */
11445  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
11446 
11447  /* If not already recovering from an error, report this error. */
11448  if (!yyerrstatus)
11449  {
11450  ++yynerrs;
11451 #if ! YYERROR_VERBOSE
11452  parser_yyerror (parser, YY_("syntax error"));
11453 #else
11454 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
11455  yyssp, yytoken)
11456  {
11457  char const *yymsgp = YY_("syntax error");
11458  int yysyntax_error_status;
11459  yysyntax_error_status = YYSYNTAX_ERROR;
11460  if (yysyntax_error_status == 0)
11461  yymsgp = yymsg;
11462  else if (yysyntax_error_status == 1)
11463  {
11464  if (yymsg != yymsgbuf)
11465  YYSTACK_FREE (yymsg);
11466  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11467  if (!yymsg)
11468  {
11469  yymsg = yymsgbuf;
11470  yymsg_alloc = sizeof yymsgbuf;
11471  yysyntax_error_status = 2;
11472  }
11473  else
11474  {
11475  yysyntax_error_status = YYSYNTAX_ERROR;
11476  yymsgp = yymsg;
11477  }
11478  }
11479  parser_yyerror (parser, yymsgp);
11480  if (yysyntax_error_status == 2)
11481  goto yyexhaustedlab;
11482  }
11483 # undef YYSYNTAX_ERROR
11484 #endif
11485  }
11486 
11487 
11488 
11489  if (yyerrstatus == 3)
11490  {
11491  /* If just tried and failed to reuse lookahead token after an
11492  error, discard it. */
11493 
11494  if (yychar <= YYEOF)
11495  {
11496  /* Return failure if at end of input. */
11497  if (yychar == YYEOF)
11498  YYABORT;
11499  }
11500  else
11501  {
11502  yydestruct ("Error: discarding",
11503  yytoken, &yylval, parser);
11504  yychar = YYEMPTY;
11505  }
11506  }
11507 
11508  /* Else will try to reuse lookahead token after shifting the error
11509  token. */
11511 
11512 
11513 /*---------------------------------------------------.
11514 | yyerrorlab -- error raised explicitly by YYERROR. |
11515 `---------------------------------------------------*/
11516 yyerrorlab:
11517 
11518  /* Pacify compilers like GCC when the user code never invokes
11519  YYERROR and the label yyerrorlab therefore never appears in user
11520  code. */
11521  if (/*CONSTCOND*/ 0)
11522  goto yyerrorlab;
11523 
11524  /* Do not reclaim the symbols of the rule which action triggered
11525  this YYERROR. */
11526  YYPOPSTACK (yylen);
11527  yylen = 0;
11528  YY_STACK_PRINT (yyss, yyssp);
11529  yystate = *yyssp;
11530  goto yyerrlab1;
11531 
11532 
11533 /*-------------------------------------------------------------.
11534 | yyerrlab1 -- common code for both syntax error and YYERROR. |
11535 `-------------------------------------------------------------*/
11536 yyerrlab1:
11537  yyerrstatus = 3; /* Each real token shifted decrements this. */
11538 
11539  for (;;)
11540  {
11541  yyn = yypact[yystate];
11542  if (!yypact_value_is_default (yyn))
11543  {
11544  yyn += YYTERROR;
11545  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11546  {
11547  yyn = yytable[yyn];
11548  if (0 < yyn)
11549  break;
11550  }
11551  }
11552 
11553  /* Pop the current state because it cannot handle the error token. */
11554  if (yyssp == yyss)
11555  YYABORT;
11556 
11557 
11558  yydestruct ("Error: popping",
11559  yystos[yystate], yyvsp, parser);
11560  YYPOPSTACK (1);
11561  yystate = *yyssp;
11562  YY_STACK_PRINT (yyss, yyssp);
11563  }
11564 
11565  *++yyvsp = yylval;
11566 
11567 
11568  /* Shift the error token. */
11569  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11570 
11571  yystate = yyn;
11572  goto yynewstate;
11573 
11574 
11575 /*-------------------------------------.
11576 | yyacceptlab -- YYACCEPT comes here. |
11577 `-------------------------------------*/
11578 yyacceptlab:
11579  yyresult = 0;
11580  goto yyreturn;
11581 
11582 /*-----------------------------------.
11583 | yyabortlab -- YYABORT comes here. |
11584 `-----------------------------------*/
11585 yyabortlab:
11586  yyresult = 1;
11587  goto yyreturn;
11588 
11589 #if !defined(yyoverflow) || YYERROR_VERBOSE
11590 /*-------------------------------------------------.
11591 | yyexhaustedlab -- memory exhaustion comes here. |
11592 `-------------------------------------------------*/
11593 yyexhaustedlab:
11594  parser_yyerror (parser, YY_("memory exhausted"));
11595  yyresult = 2;
11596  /* Fall through. */
11597 #endif
11598 
11599 yyreturn:
11600  if (yychar != YYEMPTY)
11601  {
11602  /* Make sure we have latest lookahead translation. See comments at
11603  user semantic actions for why this is necessary. */
11604  yytoken = YYTRANSLATE (yychar);
11605  yydestruct ("Cleanup: discarding lookahead",
11606  yytoken, &yylval, parser);
11607  }
11608  /* Do not reclaim the symbols of the rule which action triggered
11609  this YYABORT or YYACCEPT. */
11610  YYPOPSTACK (yylen);
11611  YY_STACK_PRINT (yyss, yyssp);
11612  while (yyssp != yyss)
11613  {
11614  yydestruct ("Cleanup: popping",
11615  yystos[*yyssp], yyvsp, parser);
11616  YYPOPSTACK (1);
11617  }
11618 #ifndef yyoverflow
11619  if (yyss != yyssa)
11620  YYSTACK_FREE (yyss);
11621 #endif
11622 #if YYERROR_VERBOSE
11623  if (yymsg != yymsgbuf)
11624  YYSTACK_FREE (yymsg);
11625 #endif
11626  /* Make sure YYID is used. */
11627  return YYID (yyresult);
11628 }
11629 
11630 
11631 
11632 /* Line 2067 of yacc.c */
11633 #line 5035 "ripper.y"
11634 
11635 # undef parser
11636 # undef yylex
11637 # undef yylval
11638 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
11639 
11640 static int parser_regx_options(struct parser_params*);
11641 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11642 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11643 static int parser_parse_string(struct parser_params*,NODE*);
11644 static int parser_here_document(struct parser_params*,NODE*);
11645 
11646 
11647 # define nextc() parser_nextc(parser)
11648 # define pushback(c) parser_pushback(parser, (c))
11649 # define newtok() parser_newtok(parser)
11650 # define tokspace(n) parser_tokspace(parser, (n))
11651 # define tokadd(c) parser_tokadd(parser, (c))
11652 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
11653 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
11654 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
11655 # define regx_options() parser_regx_options(parser)
11656 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11657 # define parse_string(n) parser_parse_string(parser,(n))
11658 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
11659 # define here_document(n) parser_here_document(parser,(n))
11660 # define heredoc_identifier() parser_heredoc_identifier(parser)
11661 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
11662 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
11663 # define number_literal_suffix(f) parser_number_literal_suffix(parser, (f))
11664 # define set_number_literal(v, t, f) parser_set_number_literal(parser, (v), (t), (f))
11665 # define set_integer_literal(v, f) parser_set_integer_literal(parser, (v), (f))
11666 
11667 #ifndef RIPPER
11668 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11669 # define set_yylval_num(x) (yylval.num = (x))
11670 # define set_yylval_id(x) (yylval.id = (x))
11671 # define set_yylval_name(x) (yylval.id = (x))
11672 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11673 # define set_yylval_node(x) (yylval.node = (x))
11674 # define yylval_id() (yylval.id)
11675 #else
11676 static inline VALUE
11677 ripper_yylval_id(ID x)
11678 {
11679  return (VALUE)NEW_LASGN(x, ID2SYM(x));
11680 }
11681 # define set_yylval_str(x) (void)(x)
11682 # define set_yylval_num(x) (void)(x)
11683 # define set_yylval_id(x) (void)(x)
11684 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11685 # define set_yylval_literal(x) (void)(x)
11686 # define set_yylval_node(x) (void)(x)
11687 # define yylval_id() yylval.id
11688 #endif
11689 
11690 #ifndef RIPPER
11691 #define ripper_flush(p) (void)(p)
11692 #else
11693 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11694 
11695 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11696 
11697 static int
11698 ripper_has_scan_event(struct parser_params *parser)
11699 {
11700 
11701  if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11702  return lex_p > parser->tokp;
11703 }
11704 
11705 static VALUE
11706 ripper_scan_event_val(struct parser_params *parser, int t)
11707 {
11708  VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11709  VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11710  ripper_flush(parser);
11711  return rval;
11712 }
11713 
11714 static void
11715 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11716 {
11717  if (!ripper_has_scan_event(parser)) return;
11718  yylval_rval = ripper_scan_event_val(parser, t);
11719 }
11720 
11721 static void
11722 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11723 {
11724  if (!ripper_has_scan_event(parser)) return;
11725  (void)ripper_scan_event_val(parser, t);
11726 }
11727 
11728 static void
11729 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11730 {
11731  int saved_line = ruby_sourceline;
11732  const char *saved_tokp = parser->tokp;
11733 
11734  ruby_sourceline = parser->delayed_line;
11735  parser->tokp = lex_pbeg + parser->delayed_col;
11736  yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11737  parser->delayed = Qnil;
11738  ruby_sourceline = saved_line;
11739  parser->tokp = saved_tokp;
11740 }
11741 #endif /* RIPPER */
11742 
11743 #include "ruby/regex.h"
11744 #include "ruby/util.h"
11745 
11746 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11747  since ours (we hope) works properly with all combinations of
11748  machines, compilers, `char' and `unsigned char' argument types.
11749  (Per Bothner suggested the basic approach.) */
11750 #undef SIGN_EXTEND_CHAR
11751 #if __STDC__
11752 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11753 #else /* not __STDC__ */
11754 /* As in Harbison and Steele. */
11755 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11756 #endif
11757 
11758 #define parser_encoding_name() (current_enc->name)
11759 #define parser_mbclen() mbclen((lex_p-1),lex_pend,current_enc)
11760 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
11761 #define is_identchar(p,e,enc) (rb_enc_isalnum((unsigned char)(*(p)),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11762 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11763 
11764 #define parser_isascii() ISASCII(*(lex_p-1))
11765 
11766 #ifndef RIPPER
11767 static int
11768 token_info_get_column(struct parser_params *parser, const char *token)
11769 {
11770  int column = 1;
11771  const char *p, *pend = lex_p - strlen(token);
11772  for (p = lex_pbeg; p < pend; p++) {
11773  if (*p == '\t') {
11774  column = (((column - 1) / 8) + 1) * 8;
11775  }
11776  column++;
11777  }
11778  return column;
11779 }
11780 
11781 static int
11782 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11783 {
11784  const char *p, *pend = lex_p - strlen(token);
11785  for (p = lex_pbeg; p < pend; p++) {
11786  if (*p != ' ' && *p != '\t') {
11787  return 1;
11788  }
11789  }
11790  return 0;
11791 }
11792 
11793 #undef token_info_push
11794 static void
11795 token_info_push(struct parser_params *parser, const char *token)
11796 {
11797  token_info *ptinfo;
11798 
11799  if (!parser->parser_token_info_enabled) return;
11800  ptinfo = ALLOC(token_info);
11801  ptinfo->token = token;
11802  ptinfo->linenum = ruby_sourceline;
11803  ptinfo->column = token_info_get_column(parser, token);
11804  ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11805  ptinfo->next = parser->parser_token_info;
11806 
11807  parser->parser_token_info = ptinfo;
11808 }
11809 
11810 #undef token_info_pop
11811 static void
11812 token_info_pop(struct parser_params *parser, const char *token)
11813 {
11814  int linenum;
11815  token_info *ptinfo = parser->parser_token_info;
11816 
11817  if (!ptinfo) return;
11818  parser->parser_token_info = ptinfo->next;
11819  if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11820  goto finish;
11821  }
11822  linenum = ruby_sourceline;
11823  if (linenum == ptinfo->linenum) { /* SKIP */
11824  goto finish;
11825  }
11826  if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11827  goto finish;
11828  }
11829  if (parser->parser_token_info_enabled) {
11831  "mismatched indentations at '%s' with '%s' at %d",
11832  token, ptinfo->token, ptinfo->linenum);
11833  }
11834 
11835  finish:
11836  xfree(ptinfo);
11837 }
11838 #endif /* RIPPER */
11839 
11840 static int
11841 parser_yyerror(struct parser_params *parser, const char *msg)
11842 {
11843 #ifndef RIPPER
11844  const int max_line_margin = 30;
11845  const char *p, *pe;
11846  char *buf;
11847  long len;
11848  int i;
11849 
11850  compile_error(PARSER_ARG "%s", msg);
11851  p = lex_p;
11852  while (lex_pbeg <= p) {
11853  if (*p == '\n') break;
11854  p--;
11855  }
11856  p++;
11857 
11858  pe = lex_p;
11859  while (pe < lex_pend) {
11860  if (*pe == '\n') break;
11861  pe++;
11862  }
11863 
11864  len = pe - p;
11865  if (len > 4) {
11866  char *p2;
11867  const char *pre = "", *post = "";
11868 
11869  if (len > max_line_margin * 2 + 10) {
11870  if (lex_p - p > max_line_margin) {
11871  p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11872  pre = "...";
11873  }
11874  if (pe - lex_p > max_line_margin) {
11875  pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11876  post = "...";
11877  }
11878  len = pe - p;
11879  }
11880  buf = ALLOCA_N(char, len+2);
11881  MEMCPY(buf, p, char, len);
11882  buf[len] = '\0';
11883  rb_compile_error_with_enc(NULL, 0, (void *)current_enc, "%s%s%s", pre, buf, post);
11884 
11885  i = (int)(lex_p - p);
11886  p2 = buf; pe = buf + len;
11887 
11888  while (p2 < pe) {
11889  if (*p2 != '\t') *p2 = ' ';
11890  p2++;
11891  }
11892  buf[i] = '^';
11893  buf[i+1] = '\0';
11894  rb_compile_error_append("%s%s", pre, buf);
11895  }
11896 #else
11897  dispatch1(parse_error, STR_NEW2(msg));
11898 #endif /* !RIPPER */
11899  return 0;
11900 }
11901 
11902 static void parser_prepare(struct parser_params *parser);
11903 
11904 #ifndef RIPPER
11905 static VALUE
11907 {
11908  ID script_lines;
11909  CONST_ID(script_lines, "SCRIPT_LINES__");
11910  if (rb_const_defined_at(rb_cObject, script_lines)) {
11911  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11912  if (RB_TYPE_P(hash, T_HASH)) {
11913  VALUE lines = rb_ary_new();
11914  rb_hash_aset(hash, fname, lines);
11915  return lines;
11916  }
11917  }
11918  return 0;
11919 }
11920 
11921 static VALUE
11922 coverage(VALUE fname, int n)
11923 {
11924  VALUE coverages = rb_get_coverages();
11925  if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11926  VALUE lines = rb_ary_new2(n);
11927  int i;
11928  RBASIC_CLEAR_CLASS(lines);
11929  for (i = 0; i < n; i++) RARRAY_ASET(lines, i, Qnil);
11930  RARRAY(lines)->as.heap.len = n;
11931  rb_hash_aset(coverages, fname, lines);
11932  return lines;
11933  }
11934  return 0;
11935 }
11936 
11937 static int
11939 {
11940  return strcmp(ruby_sourcefile, "-e") == 0;
11941 }
11942 
11943 static VALUE
11945 {
11946  int n;
11947  NODE *tree;
11948  struct parser_params *parser = (struct parser_params *)arg;
11949 
11950  if (!compile_for_eval && rb_safe_level() == 0) {
11952  if (ruby_debug_lines && ruby_sourceline > 0) {
11953  VALUE str = STR_NEW0();
11954  n = ruby_sourceline;
11955  do {
11957  } while (--n);
11958  }
11959 
11960  if (!e_option_supplied(parser)) {
11962  }
11963  }
11964  parser->last_cr_line = ruby_sourceline - 1;
11965 
11966  parser_prepare(parser);
11967  deferred_nodes = 0;
11968 #ifndef RIPPER
11970 #endif
11971 #ifndef RIPPER
11974  parser->parser_ruby_sourceline);
11975  }
11976 #endif
11977  n = yyparse((void*)parser);
11978 #ifndef RIPPER
11981  parser->parser_ruby_sourceline);
11982  }
11983 #endif
11984  ruby_debug_lines = 0;
11985  ruby_coverage = 0;
11986  compile_for_eval = 0;
11987 
11988  lex_strterm = 0;
11989  lex_p = lex_pbeg = lex_pend = 0;
11990  lex_lastline = lex_nextline = 0;
11991  if (parser->nerr) {
11992  return 0;
11993  }
11994  tree = ruby_eval_tree;
11995  if (!tree) {
11996  tree = NEW_NIL();
11997  }
11998  else if (ruby_eval_tree_begin) {
11999  tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
12000  }
12001  return (VALUE)tree;
12002 }
12003 
12004 static NODE*
12005 yycompile(struct parser_params *parser, VALUE fname, int line)
12006 {
12008  ruby_sourcefile = RSTRING_PTR(fname);
12009  ruby_sourceline = line - 1;
12010  return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
12011 }
12012 #endif /* !RIPPER */
12013 
12014 static rb_encoding *
12016 {
12017  rb_encoding *enc = rb_enc_get(s);
12018  if (!rb_enc_asciicompat(enc)) {
12019  rb_raise(rb_eArgError, "invalid source encoding");
12020  }
12021  return enc;
12022 }
12023 
12024 static VALUE
12026 {
12027  char *beg, *end, *pend;
12029 
12030  beg = RSTRING_PTR(s);
12031  if (lex_gets_ptr) {
12032  if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
12033  beg += lex_gets_ptr;
12034  }
12035  pend = RSTRING_PTR(s) + RSTRING_LEN(s);
12036  end = beg;
12037  while (end < pend) {
12038  if (*end++ == '\n') break;
12039  }
12040  lex_gets_ptr = end - RSTRING_PTR(s);
12041  return rb_enc_str_new(beg, end - beg, enc);
12042 }
12043 
12044 static VALUE
12046 {
12047  VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
12048  if (NIL_P(line)) return line;
12050 #ifndef RIPPER
12051  if (ruby_debug_lines) {
12054  }
12055  if (ruby_coverage) {
12057  }
12058 #endif
12059  return line;
12060 }
12061 
12062 #ifdef RIPPER
12064 #else
12066 
12067 static NODE*
12068 parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
12069 {
12070  struct parser_params *parser;
12071  NODE *node;
12072 
12073  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12075  lex_gets_ptr = 0;
12076  lex_input = s;
12077  lex_pbeg = lex_p = lex_pend = 0;
12079 
12080  node = yycompile(parser, fname, line);
12081  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12082 
12083  return node;
12084 }
12085 
12086 NODE*
12087 rb_compile_string(const char *f, VALUE s, int line)
12088 {
12091 }
12092 
12093 NODE*
12094 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
12095 {
12096  return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
12097 }
12098 
12099 NODE*
12100 rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
12101 {
12103  return parser_compile_string(vparser, f, s, line);
12104 }
12105 
12106 NODE*
12107 rb_compile_cstr(const char *f, const char *s, int len, int line)
12108 {
12109  VALUE str = rb_str_new(s, len);
12111 }
12112 
12113 NODE*
12114 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
12115 {
12116  VALUE str = rb_str_new(s, len);
12117  return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line);
12118 }
12119 
12120 static VALUE
12122 {
12123  return rb_io_gets(io);
12124 }
12125 
12126 NODE*
12127 rb_compile_file(const char *f, VALUE file, int start)
12128 {
12129  VALUE volatile vparser = rb_parser_new();
12130 
12131  return rb_parser_compile_file(vparser, f, file, start);
12132 }
12133 
12134 NODE*
12135 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
12136 {
12137  return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start);
12138 }
12139 
12140 NODE*
12141 rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
12142 {
12143  struct parser_params *parser;
12144  NODE *node;
12145 
12146  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12148  lex_input = file;
12149  lex_pbeg = lex_p = lex_pend = 0;
12151 
12152  node = yycompile(parser, fname, start);
12153  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12154 
12155  return node;
12156 }
12157 #endif /* !RIPPER */
12158 
12159 #define STR_FUNC_ESCAPE 0x01
12160 #define STR_FUNC_EXPAND 0x02
12161 #define STR_FUNC_REGEXP 0x04
12162 #define STR_FUNC_QWORDS 0x08
12163 #define STR_FUNC_SYMBOL 0x10
12164 #define STR_FUNC_INDENT 0x20
12165 
12167  str_squote = (0),
12175 };
12176 
12177 static VALUE
12178 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
12179 {
12180  VALUE str;
12181 
12182  str = rb_enc_str_new(p, n, enc);
12183  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12185  }
12186  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12188  }
12189  }
12190 
12191  return str;
12192 }
12193 
12194 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
12195 #define lex_eol_p() (lex_p >= lex_pend)
12196 #define peek(c) peek_n((c), 0)
12197 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
12198 
12199 static inline int
12201 {
12202  int c;
12203 
12204  if (lex_p == lex_pend) {
12205  VALUE v = lex_nextline;
12206  lex_nextline = 0;
12207  if (!v) {
12208  if (parser->eofp)
12209  return -1;
12210 
12211  if (!lex_input || NIL_P(v = lex_getline(parser))) {
12212  parser->eofp = Qtrue;
12213  lex_goto_eol(parser);
12214  return -1;
12215  }
12216  }
12217  {
12218 #ifdef RIPPER
12219  if (parser->tokp < lex_pend) {
12220  if (NIL_P(parser->delayed)) {
12221  parser->delayed = rb_str_buf_new(1024);
12222  rb_enc_associate(parser->delayed, current_enc);
12223  rb_str_buf_cat(parser->delayed,
12224  parser->tokp, lex_pend - parser->tokp);
12225  parser->delayed_line = ruby_sourceline;
12226  parser->delayed_col = (int)(parser->tokp - lex_pbeg);
12227  }
12228  else {
12229  rb_str_buf_cat(parser->delayed,
12230  parser->tokp, lex_pend - parser->tokp);
12231  }
12232  }
12233 #endif
12234  if (heredoc_end > 0) {
12236  heredoc_end = 0;
12237  }
12238  ruby_sourceline++;
12239  parser->line_count++;
12240  lex_pbeg = lex_p = RSTRING_PTR(v);
12241  lex_pend = lex_p + RSTRING_LEN(v);
12242  ripper_flush(parser);
12243  lex_lastline = v;
12244  }
12245  }
12246  c = (unsigned char)*lex_p++;
12247  if (c == '\r') {
12248  if (peek('\n')) {
12249  lex_p++;
12250  c = '\n';
12251  }
12252  else if (ruby_sourceline > parser->last_cr_line) {
12253  parser->last_cr_line = ruby_sourceline;
12254  rb_compile_warn(ruby_sourcefile, ruby_sourceline, "encountered \\r in middle of line, treated as a mere space");
12255  }
12256  }
12257 
12258  return c;
12259 }
12260 
12261 static void
12262 parser_pushback(struct parser_params *parser, int c)
12263 {
12264  if (c == -1) return;
12265  lex_p--;
12266  if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
12267  lex_p--;
12268  }
12269 }
12270 
12271 #define was_bol() (lex_p == lex_pbeg + 1)
12272 
12273 #define tokfix() (tokenbuf[tokidx]='\0')
12274 #define tok() tokenbuf
12275 #define toklen() tokidx
12276 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
12277 
12278 static char*
12280 {
12281  tokidx = 0;
12283  if (!tokenbuf) {
12284  toksiz = 60;
12285  tokenbuf = ALLOC_N(char, 60);
12286  }
12287  if (toksiz > 4096) {
12288  toksiz = 60;
12289  REALLOC_N(tokenbuf, char, 60);
12290  }
12291  return tokenbuf;
12292 }
12293 
12294 static char *
12295 parser_tokspace(struct parser_params *parser, int n)
12296 {
12297  tokidx += n;
12298 
12299  if (tokidx >= toksiz) {
12300  do {toksiz *= 2;} while (toksiz < tokidx);
12301  REALLOC_N(tokenbuf, char, toksiz);
12302  }
12303  return &tokenbuf[tokidx-n];
12304 }
12305 
12306 static void
12307 parser_tokadd(struct parser_params *parser, int c)
12308 {
12309  tokenbuf[tokidx++] = (char)c;
12310  if (tokidx >= toksiz) {
12311  toksiz *= 2;
12312  REALLOC_N(tokenbuf, char, toksiz);
12313  }
12314 }
12315 
12316 static int
12317 parser_tok_hex(struct parser_params *parser, size_t *numlen)
12318 {
12319  int c;
12320 
12321  c = scan_hex(lex_p, 2, numlen);
12322  if (!*numlen) {
12323  yyerror("invalid hex escape");
12324  return 0;
12325  }
12326  lex_p += *numlen;
12327  return c;
12328 }
12329 
12330 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
12331 
12332 /* return value is for ?\u3042 */
12333 static int
12335  int string_literal, int symbol_literal, int regexp_literal)
12336 {
12337  /*
12338  * If string_literal is true, then we allow multiple codepoints
12339  * in \u{}, and add the codepoints to the current token.
12340  * Otherwise we're parsing a character literal and return a single
12341  * codepoint without adding it
12342  */
12343 
12344  int codepoint;
12345  size_t numlen;
12346 
12347  if (regexp_literal) { tokadd('\\'); tokadd('u'); }
12348 
12349  if (peek('{')) { /* handle \u{...} form */
12350  do {
12351  if (regexp_literal) { tokadd(*lex_p); }
12352  nextc();
12353  codepoint = scan_hex(lex_p, 6, &numlen);
12354  if (numlen == 0) {
12355  yyerror("invalid Unicode escape");
12356  return 0;
12357  }
12358  if (codepoint > 0x10ffff) {
12359  yyerror("invalid Unicode codepoint (too large)");
12360  return 0;
12361  }
12362  lex_p += numlen;
12363  if (regexp_literal) {
12364  tokcopy((int)numlen);
12365  }
12366  else if (codepoint >= 0x80) {
12367  *encp = rb_utf8_encoding();
12368  if (string_literal) tokaddmbc(codepoint, *encp);
12369  }
12370  else if (string_literal) {
12371  tokadd(codepoint);
12372  }
12373  } while (string_literal && (peek(' ') || peek('\t')));
12374 
12375  if (!peek('}')) {
12376  yyerror("unterminated Unicode escape");
12377  return 0;
12378  }
12379 
12380  if (regexp_literal) { tokadd('}'); }
12381  nextc();
12382  }
12383  else { /* handle \uxxxx form */
12384  codepoint = scan_hex(lex_p, 4, &numlen);
12385  if (numlen < 4) {
12386  yyerror("invalid Unicode escape");
12387  return 0;
12388  }
12389  lex_p += 4;
12390  if (regexp_literal) {
12391  tokcopy(4);
12392  }
12393  else if (codepoint >= 0x80) {
12394  *encp = rb_utf8_encoding();
12395  if (string_literal) tokaddmbc(codepoint, *encp);
12396  }
12397  else if (string_literal) {
12398  tokadd(codepoint);
12399  }
12400  }
12401 
12402  return codepoint;
12403 }
12404 
12405 #define ESCAPE_CONTROL 1
12406 #define ESCAPE_META 2
12407 
12408 static int
12410  rb_encoding **encp)
12411 {
12412  int c;
12413  size_t numlen;
12414 
12415  switch (c = nextc()) {
12416  case '\\': /* Backslash */
12417  return c;
12418 
12419  case 'n': /* newline */
12420  return '\n';
12421 
12422  case 't': /* horizontal tab */
12423  return '\t';
12424 
12425  case 'r': /* carriage-return */
12426  return '\r';
12427 
12428  case 'f': /* form-feed */
12429  return '\f';
12430 
12431  case 'v': /* vertical tab */
12432  return '\13';
12433 
12434  case 'a': /* alarm(bell) */
12435  return '\007';
12436 
12437  case 'e': /* escape */
12438  return 033;
12439 
12440  case '0': case '1': case '2': case '3': /* octal constant */
12441  case '4': case '5': case '6': case '7':
12442  pushback(c);
12443  c = scan_oct(lex_p, 3, &numlen);
12444  lex_p += numlen;
12445  return c;
12446 
12447  case 'x': /* hex constant */
12448  c = tok_hex(&numlen);
12449  if (numlen == 0) return 0;
12450  return c;
12451 
12452  case 'b': /* backspace */
12453  return '\010';
12454 
12455  case 's': /* space */
12456  return ' ';
12457 
12458  case 'M':
12459  if (flags & ESCAPE_META) goto eof;
12460  if ((c = nextc()) != '-') {
12461  pushback(c);
12462  goto eof;
12463  }
12464  if ((c = nextc()) == '\\') {
12465  if (peek('u')) goto eof;
12466  return read_escape(flags|ESCAPE_META, encp) | 0x80;
12467  }
12468  else if (c == -1 || !ISASCII(c)) goto eof;
12469  else {
12470  return ((c & 0xff) | 0x80);
12471  }
12472 
12473  case 'C':
12474  if ((c = nextc()) != '-') {
12475  pushback(c);
12476  goto eof;
12477  }
12478  case 'c':
12479  if (flags & ESCAPE_CONTROL) goto eof;
12480  if ((c = nextc())== '\\') {
12481  if (peek('u')) goto eof;
12482  c = read_escape(flags|ESCAPE_CONTROL, encp);
12483  }
12484  else if (c == '?')
12485  return 0177;
12486  else if (c == -1 || !ISASCII(c)) goto eof;
12487  return c & 0x9f;
12488 
12489  eof:
12490  case -1:
12491  yyerror("Invalid escape character syntax");
12492  return '\0';
12493 
12494  default:
12495  return c;
12496  }
12497 }
12498 
12499 static void
12501 {
12502  int len = rb_enc_codelen(c, enc);
12503  rb_enc_mbcput(c, tokspace(len), enc);
12504 }
12505 
12506 static int
12508 {
12509  int c;
12510  int flags = 0;
12511  size_t numlen;
12512 
12513  first:
12514  switch (c = nextc()) {
12515  case '\n':
12516  return 0; /* just ignore */
12517 
12518  case '0': case '1': case '2': case '3': /* octal constant */
12519  case '4': case '5': case '6': case '7':
12520  {
12521  ruby_scan_oct(--lex_p, 3, &numlen);
12522  if (numlen == 0) goto eof;
12523  lex_p += numlen;
12524  tokcopy((int)numlen + 1);
12525  }
12526  return 0;
12527 
12528  case 'x': /* hex constant */
12529  {
12530  tok_hex(&numlen);
12531  if (numlen == 0) return -1;
12532  tokcopy((int)numlen + 2);
12533  }
12534  return 0;
12535 
12536  case 'M':
12537  if (flags & ESCAPE_META) goto eof;
12538  if ((c = nextc()) != '-') {
12539  pushback(c);
12540  goto eof;
12541  }
12542  tokcopy(3);
12543  flags |= ESCAPE_META;
12544  goto escaped;
12545 
12546  case 'C':
12547  if (flags & ESCAPE_CONTROL) goto eof;
12548  if ((c = nextc()) != '-') {
12549  pushback(c);
12550  goto eof;
12551  }
12552  tokcopy(3);
12553  goto escaped;
12554 
12555  case 'c':
12556  if (flags & ESCAPE_CONTROL) goto eof;
12557  tokcopy(2);
12558  flags |= ESCAPE_CONTROL;
12559  escaped:
12560  if ((c = nextc()) == '\\') {
12561  goto first;
12562  }
12563  else if (c == -1) goto eof;
12564  tokadd(c);
12565  return 0;
12566 
12567  eof:
12568  case -1:
12569  yyerror("Invalid escape character syntax");
12570  return -1;
12571 
12572  default:
12573  tokadd('\\');
12574  tokadd(c);
12575  }
12576  return 0;
12577 }
12578 
12579 static int
12581 {
12582  int kcode = 0;
12583  int kopt = 0;
12584  int options = 0;
12585  int c, opt, kc;
12586 
12587  newtok();
12588  while (c = nextc(), ISALPHA(c)) {
12589  if (c == 'o') {
12590  options |= RE_OPTION_ONCE;
12591  }
12592  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12593  if (kc >= 0) {
12594  if (kc != rb_ascii8bit_encindex()) kcode = c;
12595  kopt = opt;
12596  }
12597  else {
12598  options |= opt;
12599  }
12600  }
12601  else {
12602  tokadd(c);
12603  }
12604  }
12605  options |= kopt;
12606  pushback(c);
12607  if (toklen()) {
12608  tokfix();
12609  compile_error(PARSER_ARG "unknown regexp option%s - %s",
12610  toklen() > 1 ? "s" : "", tok());
12611  }
12612  return options | RE_OPTION_ENCODING(kcode);
12613 }
12614 
12615 static void
12617 {
12618  rb_str_free(str);
12619  rb_gc_force_recycle(str);
12620 }
12621 
12622 static int
12624 {
12625  int len = parser_precise_mbclen();
12626  if (!MBCLEN_CHARFOUND_P(len)) {
12627  compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12628  return -1;
12629  }
12630  tokadd(c);
12631  lex_p += --len;
12632  if (len > 0) tokcopy(len);
12633  return c;
12634 }
12635 
12636 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12637 
12638 static inline int
12640 {
12641  switch (c) {
12642  case '$': case '*': case '+': case '.':
12643  case '?': case '^': case '|':
12644  case ')': case ']': case '}': case '>':
12645  return TRUE;
12646  default:
12647  return FALSE;
12648  }
12649 }
12650 
12651 static int
12653  int func, int term, int paren, long *nest,
12654  rb_encoding **encp)
12655 {
12656  int c;
12657  int has_nonascii = 0;
12658  rb_encoding *enc = *encp;
12659  char *errbuf = 0;
12660  static const char mixed_msg[] = "%s mixed within %s source";
12661 
12662 #define mixed_error(enc1, enc2) if (!errbuf) { \
12663  size_t len = sizeof(mixed_msg) - 4; \
12664  len += strlen(rb_enc_name(enc1)); \
12665  len += strlen(rb_enc_name(enc2)); \
12666  errbuf = ALLOCA_N(char, len); \
12667  snprintf(errbuf, len, mixed_msg, \
12668  rb_enc_name(enc1), \
12669  rb_enc_name(enc2)); \
12670  yyerror(errbuf); \
12671  }
12672 #define mixed_escape(beg, enc1, enc2) do { \
12673  const char *pos = lex_p; \
12674  lex_p = (beg); \
12675  mixed_error((enc1), (enc2)); \
12676  lex_p = pos; \
12677  } while (0)
12678 
12679  while ((c = nextc()) != -1) {
12680  if (paren && c == paren) {
12681  ++*nest;
12682  }
12683  else if (c == term) {
12684  if (!nest || !*nest) {
12685  pushback(c);
12686  break;
12687  }
12688  --*nest;
12689  }
12690  else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12691  int c2 = *lex_p;
12692  if (c2 == '$' || c2 == '@' || c2 == '{') {
12693  pushback(c);
12694  break;
12695  }
12696  }
12697  else if (c == '\\') {
12698  const char *beg = lex_p - 1;
12699  c = nextc();
12700  switch (c) {
12701  case '\n':
12702  if (func & STR_FUNC_QWORDS) break;
12703  if (func & STR_FUNC_EXPAND) continue;
12704  tokadd('\\');
12705  break;
12706 
12707  case '\\':
12708  if (func & STR_FUNC_ESCAPE) tokadd(c);
12709  break;
12710 
12711  case 'u':
12712  if ((func & STR_FUNC_EXPAND) == 0) {
12713  tokadd('\\');
12714  break;
12715  }
12716  parser_tokadd_utf8(parser, &enc, 1,
12717  func & STR_FUNC_SYMBOL,
12718  func & STR_FUNC_REGEXP);
12719  if (has_nonascii && enc != *encp) {
12720  mixed_escape(beg, enc, *encp);
12721  }
12722  continue;
12723 
12724  default:
12725  if (c == -1) return -1;
12726  if (!ISASCII(c)) {
12727  if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12728  goto non_ascii;
12729  }
12730  if (func & STR_FUNC_REGEXP) {
12731  if (c == term && !simple_re_meta(c)) {
12732  tokadd(c);
12733  continue;
12734  }
12735  pushback(c);
12736  if ((c = tokadd_escape(&enc)) < 0)
12737  return -1;
12738  if (has_nonascii && enc != *encp) {
12739  mixed_escape(beg, enc, *encp);
12740  }
12741  continue;
12742  }
12743  else if (func & STR_FUNC_EXPAND) {
12744  pushback(c);
12745  if (func & STR_FUNC_ESCAPE) tokadd('\\');
12746  c = read_escape(0, &enc);
12747  }
12748  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12749  /* ignore backslashed spaces in %w */
12750  }
12751  else if (c != term && !(paren && c == paren)) {
12752  tokadd('\\');
12753  pushback(c);
12754  continue;
12755  }
12756  }
12757  }
12758  else if (!parser_isascii()) {
12759  non_ascii:
12760  has_nonascii = 1;
12761  if (enc != *encp) {
12762  mixed_error(enc, *encp);
12763  continue;
12764  }
12765  if (tokadd_mbchar(c) == -1) return -1;
12766  continue;
12767  }
12768  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12769  pushback(c);
12770  break;
12771  }
12772  if (c & 0x80) {
12773  has_nonascii = 1;
12774  if (enc != *encp) {
12775  mixed_error(enc, *encp);
12776  continue;
12777  }
12778  }
12779  tokadd(c);
12780  }
12781  *encp = enc;
12782  return c;
12783 }
12784 
12785 #define NEW_STRTERM(func, term, paren) \
12786  rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12787 
12788 #ifdef RIPPER
12789 static void
12790 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12791 {
12792  if (!NIL_P(parser->delayed)) {
12793  ptrdiff_t len = lex_p - parser->tokp;
12794  if (len > 0) {
12795  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12796  }
12797  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12798  parser->tokp = lex_p;
12799  }
12800 }
12801 
12802 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12803 #else
12804 #define flush_string_content(enc) ((void)(enc))
12805 #endif
12806 
12807 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12808 /* this can be shared with ripper, since it's independent from struct
12809  * parser_params. */
12810 #ifndef RIPPER
12811 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12812 #define SPECIAL_PUNCT(idx) ( \
12813  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12814  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12815  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12816  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12817  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12818  BIT('0', idx))
12819 const unsigned int ruby_global_name_punct_bits[] = {
12820  SPECIAL_PUNCT(0),
12821  SPECIAL_PUNCT(1),
12822  SPECIAL_PUNCT(2),
12823 };
12824 #undef BIT
12825 #undef SPECIAL_PUNCT
12826 #endif
12827 
12828 static inline int
12830 {
12831  if (c <= 0x20 || 0x7e < c) return 0;
12832  return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12833 }
12834 
12835 static int
12837 {
12838  int c;
12839  const char *p = lex_p;
12840 
12841  if (p + 1 >= lex_pend) return 0;
12842  c = *p++;
12843  switch (c) {
12844  case '$':
12845  if ((c = *p) == '-') {
12846  if (++p >= lex_pend) return 0;
12847  c = *p;
12848  }
12849  else if (is_global_name_punct(c) || ISDIGIT(c)) {
12850  return tSTRING_DVAR;
12851  }
12852  break;
12853  case '@':
12854  if ((c = *p) == '@') {
12855  if (++p >= lex_pend) return 0;
12856  c = *p;
12857  }
12858  break;
12859  case '{':
12860  lex_p = p;
12861  command_start = TRUE;
12862  return tSTRING_DBEG;
12863  default:
12864  return 0;
12865  }
12866  if (!ISASCII(c) || c == '_' || ISALPHA(c))
12867  return tSTRING_DVAR;
12868  return 0;
12869 }
12870 
12871 static int
12872 parser_parse_string(struct parser_params *parser, NODE *quote)
12873 {
12874  int func = (int)quote->nd_func;
12875  int term = nd_term(quote);
12876  int paren = nd_paren(quote);
12877  int c, space = 0;
12879 
12880  if (func == -1) return tSTRING_END;
12881  c = nextc();
12882  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12883  do {c = nextc();} while (ISSPACE(c));
12884  space = 1;
12885  }
12886  if (c == term && !quote->nd_nest) {
12887  if (func & STR_FUNC_QWORDS) {
12888  quote->nd_func = -1;
12889  return ' ';
12890  }
12891  if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12893  return tREGEXP_END;
12894  }
12895  if (space) {
12896  pushback(c);
12897  return ' ';
12898  }
12899  newtok();
12900  if ((func & STR_FUNC_EXPAND) && c == '#') {
12901  int t = parser_peek_variable_name(parser);
12902  if (t) return t;
12903  tokadd('#');
12904  c = nextc();
12905  }
12906  pushback(c);
12907  if (tokadd_string(func, term, paren, &quote->nd_nest,
12908  &enc) == -1) {
12909  ruby_sourceline = nd_line(quote);
12910  if (func & STR_FUNC_REGEXP) {
12911  if (parser->eofp)
12912  compile_error(PARSER_ARG "unterminated regexp meets end of file");
12913  return tREGEXP_END;
12914  }
12915  else {
12916  if (parser->eofp)
12917  compile_error(PARSER_ARG "unterminated string meets end of file");
12918  return tSTRING_END;
12919  }
12920  }
12921 
12922  tokfix();
12923  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12924  flush_string_content(enc);
12925 
12926  return tSTRING_CONTENT;
12927 }
12928 
12929 static int
12931 {
12932  int c = nextc(), term, func = 0;
12933  long len;
12934 
12935  if (c == '-') {
12936  c = nextc();
12937  func = STR_FUNC_INDENT;
12938  }
12939  switch (c) {
12940  case '\'':
12941  func |= str_squote; goto quoted;
12942  case '"':
12943  func |= str_dquote; goto quoted;
12944  case '`':
12945  func |= str_xquote;
12946  quoted:
12947  newtok();
12948  tokadd(func);
12949  term = c;
12950  while ((c = nextc()) != -1 && c != term) {
12951  if (tokadd_mbchar(c) == -1) return 0;
12952  }
12953  if (c == -1) {
12954  compile_error(PARSER_ARG "unterminated here document identifier");
12955  return 0;
12956  }
12957  break;
12958 
12959  default:
12960  if (!parser_is_identchar()) {
12961  pushback(c);
12962  if (func & STR_FUNC_INDENT) {
12963  pushback('-');
12964  }
12965  return 0;
12966  }
12967  newtok();
12968  term = '"';
12969  tokadd(func |= str_dquote);
12970  do {
12971  if (tokadd_mbchar(c) == -1) return 0;
12972  } while ((c = nextc()) != -1 && parser_is_identchar());
12973  pushback(c);
12974  break;
12975  }
12976 
12977  tokfix();
12978 #ifdef RIPPER
12979  ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12980 #endif
12981  len = lex_p - lex_pbeg;
12982  lex_goto_eol(parser);
12984  STR_NEW(tok(), toklen()), /* nd_lit */
12985  len, /* nd_nth */
12986  lex_lastline); /* nd_orig */
12988  ripper_flush(parser);
12989  return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12990 }
12991 
12992 static void
12994 {
12995  VALUE line;
12996 
12997  lex_strterm = 0;
12998  line = here->nd_orig;
12999  lex_lastline = line;
13000  lex_pbeg = RSTRING_PTR(line);
13001  lex_pend = lex_pbeg + RSTRING_LEN(line);
13002  lex_p = lex_pbeg + here->nd_nth;
13004  ruby_sourceline = nd_line(here);
13005  dispose_string(here->nd_lit);
13006  rb_gc_force_recycle((VALUE)here);
13007  ripper_flush(parser);
13008 }
13009 
13010 static int
13012  const char *eos, long len, int indent)
13013 {
13014  const char *p = lex_pbeg;
13015  long n;
13016 
13017  if (indent) {
13018  while (*p && ISSPACE(*p)) p++;
13019  }
13020  n = lex_pend - (p + len);
13021  if (n < 0) return FALSE;
13022  if (n > 0 && p[len] != '\n') {
13023  if (p[len] != '\r') return FALSE;
13024  if (n <= 1 || p[len+1] != '\n') return FALSE;
13025  }
13026  return strncmp(eos, p, len) == 0;
13027 }
13028 
13029 #define NUM_SUFFIX_R (1<<0)
13030 #define NUM_SUFFIX_I (1<<1)
13031 #define NUM_SUFFIX_ALL 3
13032 
13033 static int
13035 {
13036  int c, result = 0;
13037  const char *lastp = lex_p;
13038 
13039  while ((c = nextc()) != -1) {
13040  if ((mask & NUM_SUFFIX_I) && c == 'i') {
13041  result |= (mask & NUM_SUFFIX_I);
13042  mask &= ~NUM_SUFFIX_I;
13043  /* r after i, rational of complex is disallowed */
13044  mask &= ~NUM_SUFFIX_R;
13045  continue;
13046  }
13047  if ((mask & NUM_SUFFIX_R) && c == 'r') {
13048  result |= (mask & NUM_SUFFIX_R);
13049  mask &= ~NUM_SUFFIX_R;
13050  continue;
13051  }
13052  if (!ISASCII(c) || ISALPHA(c) || c == '_') {
13053  lex_p = lastp;
13054  return 0;
13055  }
13056  pushback(c);
13057  break;
13058  }
13059  return result;
13060 }
13061 
13062 static int
13063 parser_set_number_literal(struct parser_params *parser, VALUE v, int type, int suffix)
13064 {
13065  if (suffix & NUM_SUFFIX_I) {
13066  v = rb_complex_raw(INT2FIX(0), v);
13067  type = tIMAGINARY;
13068  }
13069  set_yylval_literal(v);
13070  return type;
13071 }
13072 
13073 static int
13074 parser_set_integer_literal(struct parser_params *parser, VALUE v, int suffix)
13075 {
13076  int type = tINTEGER;
13077  if (suffix & NUM_SUFFIX_R) {
13078  v = rb_rational_raw1(v);
13079  type = tRATIONAL;
13080  }
13081  return set_number_literal(v, type, suffix);
13082 }
13083 
13084 #ifdef RIPPER
13085 static void
13086 ripper_dispatch_heredoc_end(struct parser_params *parser)
13087 {
13088  if (!NIL_P(parser->delayed))
13089  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
13090  lex_goto_eol(parser);
13091  ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
13092 }
13093 
13094 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
13095 #else
13096 #define dispatch_heredoc_end() ((void)0)
13097 #endif
13098 
13099 static int
13101 {
13102  int c, func, indent = 0;
13103  const char *eos, *p, *pend;
13104  long len;
13105  VALUE str = 0;
13107 
13108  eos = RSTRING_PTR(here->nd_lit);
13109  len = RSTRING_LEN(here->nd_lit) - 1;
13110  indent = (func = *eos++) & STR_FUNC_INDENT;
13111 
13112  if ((c = nextc()) == -1) {
13113  error:
13114  compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
13115 #ifdef RIPPER
13116  if (NIL_P(parser->delayed)) {
13117  ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
13118  }
13119  else {
13120  if (str ||
13121  ((len = lex_p - parser->tokp) > 0 &&
13122  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
13123  rb_str_append(parser->delayed, str);
13124  }
13125  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
13126  }
13127  lex_goto_eol(parser);
13128 #endif
13129  restore:
13131  return 0;
13132  }
13133  if (was_bol() && whole_match_p(eos, len, indent)) {
13136  return tSTRING_END;
13137  }
13138 
13139  if (!(func & STR_FUNC_EXPAND)) {
13140  do {
13142  pend = lex_pend;
13143  if (pend > p) {
13144  switch (pend[-1]) {
13145  case '\n':
13146  if (--pend == p || pend[-1] != '\r') {
13147  pend++;
13148  break;
13149  }
13150  case '\r':
13151  --pend;
13152  }
13153  }
13154  if (str)
13155  rb_str_cat(str, p, pend - p);
13156  else
13157  str = STR_NEW(p, pend - p);
13158  if (pend < lex_pend) rb_str_cat(str, "\n", 1);
13159  lex_goto_eol(parser);
13160  if (nextc() == -1) {
13161  if (str) {
13162  dispose_string(str);
13163  str = 0;
13164  }
13165  goto error;
13166  }
13167  } while (!whole_match_p(eos, len, indent));
13168  }
13169  else {
13170  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
13171  newtok();
13172  if (c == '#') {
13173  int t = parser_peek_variable_name(parser);
13174  if (t) return t;
13175  tokadd('#');
13176  c = nextc();
13177  }
13178  do {
13179  pushback(c);
13180  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
13181  if (parser->eofp) goto error;
13182  goto restore;
13183  }
13184  if (c != '\n') {
13185  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
13186  flush_string_content(enc);
13187  return tSTRING_CONTENT;
13188  }
13189  tokadd(nextc());
13190  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
13191  if ((c = nextc()) == -1) goto error;
13192  } while (!whole_match_p(eos, len, indent));
13193  str = STR_NEW3(tok(), toklen(), enc, func);
13194  }
13197  lex_strterm = NEW_STRTERM(-1, 0, 0);
13198  set_yylval_str(str);
13199  return tSTRING_CONTENT;
13200 }
13201 
13202 #include "lex.c"
13203 
13204 static void
13206 {
13207 #ifndef RIPPER
13208  rb_warning0("ambiguous first argument; put parentheses or even spaces");
13209 #else
13211 #endif
13212 }
13213 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
13214 
13215 static ID
13217 {
13218 #ifndef RIPPER
13219  if (!is_local_id(lhs))
13220  yyerror("formal argument must be local variable");
13221 #endif
13222  shadowing_lvar(lhs);
13223  return lhs;
13224 }
13225 
13226 static int
13227 lvar_defined_gen(struct parser_params *parser, ID id)
13228 {
13229  return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
13230 }
13231 
13232 /* emacsen -*- hack */
13233 static long
13234 parser_encode_length(struct parser_params *parser, const char *name, long len)
13235 {
13236  long nlen;
13237 
13238  if (len > 5 && name[nlen = len - 5] == '-') {
13239  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
13240  return nlen;
13241  }
13242  if (len > 4 && name[nlen = len - 4] == '-') {
13243  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
13244  return nlen;
13245  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
13246  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
13247  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
13248  return nlen;
13249  }
13250  return len;
13251 }
13252 
13253 static void
13254 parser_set_encode(struct parser_params *parser, const char *name)
13255 {
13256  int idx = rb_enc_find_index(name);
13257  rb_encoding *enc;
13258  VALUE excargs[3];
13259 
13260  if (idx < 0) {
13261  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
13262  error:
13263  excargs[0] = rb_eArgError;
13264  excargs[2] = rb_make_backtrace();
13265  rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
13266  rb_exc_raise(rb_make_exception(3, excargs));
13267  }
13268  enc = rb_enc_from_index(idx);
13269  if (!rb_enc_asciicompat(enc)) {
13270  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13271  goto error;
13272  }
13273  parser->enc = enc;
13274 #ifndef RIPPER
13275  if (ruby_debug_lines) {
13276  VALUE lines = ruby_debug_lines;
13277  long i, n = RARRAY_LEN(lines);
13278  for (i = 0; i < n; ++i) {
13279  rb_enc_associate_index(RARRAY_AREF(lines, i), idx);
13280  }
13281  }
13282 #endif
13283 }
13284 
13285 static int
13287 {
13288  const char *p = lex_pbeg, *pend = lex_p - 1;
13289  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13290  while (p < pend) {
13291  if (!ISSPACE(*p)) return 0;
13292  p++;
13293  }
13294  return 1;
13295 }
13296 
13297 #ifndef RIPPER
13298 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13299 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13300 
13301 static void
13302 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13303 {
13304  if (!comment_at_top(parser)) {
13305  return;
13306  }
13307  parser_set_encode(parser, val);
13308 }
13309 
13310 static void
13311 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13312 {
13313  int *p = &parser->parser_token_info_enabled;
13314 
13315  switch (*val) {
13316  case 't': case 'T':
13317  if (strcasecmp(val, "true") == 0) {
13318  *p = TRUE;
13319  return;
13320  }
13321  break;
13322  case 'f': case 'F':
13323  if (strcasecmp(val, "false") == 0) {
13324  *p = FALSE;
13325  return;
13326  }
13327  break;
13328  }
13329  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13330 }
13331 
13333  const char *name;
13336 };
13337 
13338 static const struct magic_comment magic_comments[] = {
13341  {"warn_indent", parser_set_token_info},
13342 };
13343 #endif
13344 
13345 static const char *
13346 magic_comment_marker(const char *str, long len)
13347 {
13348  long i = 2;
13349 
13350  while (i < len) {
13351  switch (str[i]) {
13352  case '-':
13353  if (str[i-1] == '*' && str[i-2] == '-') {
13354  return str + i + 1;
13355  }
13356  i += 2;
13357  break;
13358  case '*':
13359  if (i + 1 >= len) return 0;
13360  if (str[i+1] != '-') {
13361  i += 4;
13362  }
13363  else if (str[i-1] != '-') {
13364  i += 2;
13365  }
13366  else {
13367  return str + i + 2;
13368  }
13369  break;
13370  default:
13371  i += 3;
13372  break;
13373  }
13374  }
13375  return 0;
13376 }
13377 
13378 static int
13379 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13380 {
13381  VALUE name = 0, val = 0;
13382  const char *beg, *end, *vbeg, *vend;
13383 #define str_copy(_s, _p, _n) ((_s) \
13384  ? (void)(rb_str_resize((_s), (_n)), \
13385  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13386  : (void)((_s) = STR_NEW((_p), (_n))))
13387 
13388  if (len <= 7) return FALSE;
13389  if (!(beg = magic_comment_marker(str, len))) return FALSE;
13390  if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13391  str = beg;
13392  len = end - beg - 3;
13393 
13394  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13395  while (len > 0) {
13396 #ifndef RIPPER
13397  const struct magic_comment *p = magic_comments;
13398 #endif
13399  char *s;
13400  int i;
13401  long n = 0;
13402 
13403  for (; len > 0 && *str; str++, --len) {
13404  switch (*str) {
13405  case '\'': case '"': case ':': case ';':
13406  continue;
13407  }
13408  if (!ISSPACE(*str)) break;
13409  }
13410  for (beg = str; len > 0; str++, --len) {
13411  switch (*str) {
13412  case '\'': case '"': case ':': case ';':
13413  break;
13414  default:
13415  if (ISSPACE(*str)) break;
13416  continue;
13417  }
13418  break;
13419  }
13420  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13421  if (!len) break;
13422  if (*str != ':') continue;
13423 
13424  do str++; while (--len > 0 && ISSPACE(*str));
13425  if (!len) break;
13426  if (*str == '"') {
13427  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13428  if (*str == '\\') {
13429  --len;
13430  ++str;
13431  }
13432  }
13433  vend = str;
13434  if (len) {
13435  --len;
13436  ++str;
13437  }
13438  }
13439  else {
13440  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13441  vend = str;
13442  }
13443  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13444 
13445  n = end - beg;
13446  str_copy(name, beg, n);
13447  s = RSTRING_PTR(name);
13448  for (i = 0; i < n; ++i) {
13449  if (s[i] == '-') s[i] = '_';
13450  }
13451 #ifndef RIPPER
13452  do {
13453  if (STRNCASECMP(p->name, s, n) == 0) {
13454  n = vend - vbeg;
13455  if (p->length) {
13456  n = (*p->length)(parser, vbeg, n);
13457  }
13458  str_copy(val, vbeg, n);
13459  (*p->func)(parser, s, RSTRING_PTR(val));
13460  break;
13461  }
13462  } while (++p < magic_comments + numberof(magic_comments));
13463 #else
13464  str_copy(val, vbeg, vend - vbeg);
13465  dispatch2(magic_comment, name, val);
13466 #endif
13467  }
13468 
13469  return TRUE;
13470 }
13471 
13472 static void
13473 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13474 {
13475  int sep = 0;
13476  const char *beg = str;
13477  VALUE s;
13478 
13479  for (;;) {
13480  if (send - str <= 6) return;
13481  switch (str[6]) {
13482  case 'C': case 'c': str += 6; continue;
13483  case 'O': case 'o': str += 5; continue;
13484  case 'D': case 'd': str += 4; continue;
13485  case 'I': case 'i': str += 3; continue;
13486  case 'N': case 'n': str += 2; continue;
13487  case 'G': case 'g': str += 1; continue;
13488  case '=': case ':':
13489  sep = 1;
13490  str += 6;
13491  break;
13492  default:
13493  str += 6;
13494  if (ISSPACE(*str)) break;
13495  continue;
13496  }
13497  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13498  }
13499  for (;;) {
13500  do {
13501  if (++str >= send) return;
13502  } while (ISSPACE(*str));
13503  if (sep) break;
13504  if (*str != '=' && *str != ':') return;
13505  sep = 1;
13506  str++;
13507  }
13508  beg = str;
13509  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13510  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13511  parser_set_encode(parser, RSTRING_PTR(s));
13512  rb_str_resize(s, 0);
13513 }
13514 
13515 static void
13517 {
13518  int c = nextc();
13519  switch (c) {
13520  case '#':
13521  if (peek('!')) parser->has_shebang = 1;
13522  break;
13523  case 0xef: /* UTF-8 BOM marker */
13524  if (lex_pend - lex_p >= 2 &&
13525  (unsigned char)lex_p[0] == 0xbb &&
13526  (unsigned char)lex_p[1] == 0xbf) {
13527  parser->enc = rb_utf8_encoding();
13528  lex_p += 2;
13529  lex_pbeg = lex_p;
13530  return;
13531  }
13532  break;
13533  case EOF:
13534  return;
13535  }
13536  pushback(c);
13537  parser->enc = rb_enc_get(lex_lastline);
13538 }
13539 
13540 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13541 #define IS_END() IS_lex_state(EXPR_END_ANY)
13542 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13543 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13544 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13545 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13546 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13547 
13548 #ifndef RIPPER
13549 #define ambiguous_operator(op, syn) ( \
13550  rb_warning0("`"op"' after local variable or literal is interpreted as binary operator"), \
13551  rb_warning0("even though it seems like "syn""))
13552 #else
13553 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13554 #endif
13555 #define warn_balanced(op, syn) ((void) \
13556  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13557  space_seen && !ISSPACE(c) && \
13558  (ambiguous_operator(op, syn), 0)))
13559 
13560 static int
13562 {
13563  size_t len;
13564  int overflow;
13565  unsigned long n = ruby_scan_digits(tok()+1, toklen()-1, 10, &len, &overflow);
13566  const unsigned long nth_ref_max =
13567  ((FIXNUM_MAX < INT_MAX) ? FIXNUM_MAX : INT_MAX) >> 1;
13568  /* NTH_REF is left-shifted to be ORed with back-ref flag and
13569  * turned into a Fixnum, in compile.c */
13570 
13571  if (overflow || n > nth_ref_max) {
13572  /* compile_error()? */
13573  rb_warnS("`%s' is too big for a number variable, always nil", tok());
13574  return 0; /* $0 is $PROGRAM_NAME, not NTH_REF */
13575  }
13576  else {
13577  return (int)n;
13578  }
13579 }
13580 
13581 static int
13583 {
13584  register int c;
13585  int space_seen = 0;
13586  int cmd_state;
13587  enum lex_state_e last_state;
13588  rb_encoding *enc;
13589  int mb;
13590 #ifdef RIPPER
13591  int fallthru = FALSE;
13592 #endif
13593 
13594  if (lex_strterm) {
13595  int token;
13596  if (nd_type(lex_strterm) == NODE_HEREDOC) {
13597  token = here_document(lex_strterm);
13598  if (token == tSTRING_END) {
13599  lex_strterm = 0;
13600  lex_state = EXPR_END;
13601  }
13602  }
13603  else {
13604  token = parse_string(lex_strterm);
13605  if (token == tSTRING_END || token == tREGEXP_END) {
13607  lex_strterm = 0;
13608  lex_state = EXPR_END;
13609  }
13610  }
13611  return token;
13612  }
13613  cmd_state = command_start;
13614  command_start = FALSE;
13615  retry:
13616  last_state = lex_state;
13617  switch (c = nextc()) {
13618  case '\0': /* NUL */
13619  case '\004': /* ^D */
13620  case '\032': /* ^Z */
13621  case -1: /* end of script. */
13622  return 0;
13623 
13624  /* white spaces */
13625  case ' ': case '\t': case '\f': case '\r':
13626  case '\13': /* '\v' */
13627  space_seen = 1;
13628 #ifdef RIPPER
13629  while ((c = nextc())) {
13630  switch (c) {
13631  case ' ': case '\t': case '\f': case '\r':
13632  case '\13': /* '\v' */
13633  break;
13634  default:
13635  goto outofloop;
13636  }
13637  }
13638  outofloop:
13639  pushback(c);
13640  ripper_dispatch_scan_event(parser, tSP);
13641 #endif
13642  goto retry;
13643 
13644  case '#': /* it's a comment */
13645  /* no magic_comment in shebang line */
13646  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13647  if (comment_at_top(parser)) {
13648  set_file_encoding(parser, lex_p, lex_pend);
13649  }
13650  }
13651  lex_p = lex_pend;
13652 #ifdef RIPPER
13653  ripper_dispatch_scan_event(parser, tCOMMENT);
13654  fallthru = TRUE;
13655 #endif
13656  /* fall through */
13657  case '\n':
13658  if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT | EXPR_LABELARG)) {
13659 #ifdef RIPPER
13660  if (!fallthru) {
13661  ripper_dispatch_scan_event(parser, tIGNORED_NL);
13662  }
13663  fallthru = FALSE;
13664 #endif
13665  if (IS_lex_state(EXPR_LABELARG) && parser->parser_in_kwarg) {
13666  goto normal_newline;
13667  }
13668  goto retry;
13669  }
13670  while ((c = nextc())) {
13671  switch (c) {
13672  case ' ': case '\t': case '\f': case '\r':
13673  case '\13': /* '\v' */
13674  space_seen = 1;
13675  break;
13676  case '.': {
13677  if ((c = nextc()) != '.') {
13678  pushback(c);
13679  pushback('.');
13680  goto retry;
13681  }
13682  }
13683  default:
13684  --ruby_sourceline;
13686  case -1: /* EOF no decrement*/
13687  lex_goto_eol(parser);
13688 #ifdef RIPPER
13689  if (c != -1) {
13690  parser->tokp = lex_p;
13691  }
13692 #endif
13693  goto normal_newline;
13694  }
13695  }
13696  normal_newline:
13697  command_start = TRUE;
13698  lex_state = EXPR_BEG;
13699  return '\n';
13700 
13701  case '*':
13702  if ((c = nextc()) == '*') {
13703  if ((c = nextc()) == '=') {
13705  lex_state = EXPR_BEG;
13706  return tOP_ASGN;
13707  }
13708  pushback(c);
13709  if (IS_SPCARG(c)) {
13710  rb_warning0("`**' interpreted as argument prefix");
13711  c = tDSTAR;
13712  }
13713  else if (IS_BEG()) {
13714  c = tDSTAR;
13715  }
13716  else {
13717  warn_balanced("**", "argument prefix");
13718  c = tPOW;
13719  }
13720  }
13721  else {
13722  if (c == '=') {
13723  set_yylval_id('*');
13724  lex_state = EXPR_BEG;
13725  return tOP_ASGN;
13726  }
13727  pushback(c);
13728  if (IS_SPCARG(c)) {
13729  rb_warning0("`*' interpreted as argument prefix");
13730  c = tSTAR;
13731  }
13732  else if (IS_BEG()) {
13733  c = tSTAR;
13734  }
13735  else {
13736  warn_balanced("*", "argument prefix");
13737  c = '*';
13738  }
13739  }
13740  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13741  return c;
13742 
13743  case '!':
13744  c = nextc();
13745  if (IS_AFTER_OPERATOR()) {
13746  lex_state = EXPR_ARG;
13747  if (c == '@') {
13748  return '!';
13749  }
13750  }
13751  else {
13752  lex_state = EXPR_BEG;
13753  }
13754  if (c == '=') {
13755  return tNEQ;
13756  }
13757  if (c == '~') {
13758  return tNMATCH;
13759  }
13760  pushback(c);
13761  return '!';
13762 
13763  case '=':
13764  if (was_bol()) {
13765  /* skip embedded rd document */
13766  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13767 #ifdef RIPPER
13768  int first_p = TRUE;
13769 
13770  lex_goto_eol(parser);
13771  ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13772 #endif
13773  for (;;) {
13774  lex_goto_eol(parser);
13775 #ifdef RIPPER
13776  if (!first_p) {
13777  ripper_dispatch_scan_event(parser, tEMBDOC);
13778  }
13779  first_p = FALSE;
13780 #endif
13781  c = nextc();
13782  if (c == -1) {
13783  compile_error(PARSER_ARG "embedded document meets end of file");
13784  return 0;
13785  }
13786  if (c != '=') continue;
13787  if (strncmp(lex_p, "end", 3) == 0 &&
13788  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13789  break;
13790  }
13791  }
13792  lex_goto_eol(parser);
13793 #ifdef RIPPER
13794  ripper_dispatch_scan_event(parser, tEMBDOC_END);
13795 #endif
13796  goto retry;
13797  }
13798  }
13799 
13800  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13801  if ((c = nextc()) == '=') {
13802  if ((c = nextc()) == '=') {
13803  return tEQQ;
13804  }
13805  pushback(c);
13806  return tEQ;
13807  }
13808  if (c == '~') {
13809  return tMATCH;
13810  }
13811  else if (c == '>') {
13812  return tASSOC;
13813  }
13814  pushback(c);
13815  return '=';
13816 
13817  case '<':
13818  last_state = lex_state;
13819  c = nextc();
13820  if (c == '<' &&
13821  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13822  !IS_END() &&
13823  (!IS_ARG() || space_seen)) {
13824  int token = heredoc_identifier();
13825  if (token) return token;
13826  }
13827  if (IS_AFTER_OPERATOR()) {
13828  lex_state = EXPR_ARG;
13829  }
13830  else {
13831  if (IS_lex_state(EXPR_CLASS))
13832  command_start = TRUE;
13833  lex_state = EXPR_BEG;
13834  }
13835  if (c == '=') {
13836  if ((c = nextc()) == '>') {
13837  return tCMP;
13838  }
13839  pushback(c);
13840  return tLEQ;
13841  }
13842  if (c == '<') {
13843  if ((c = nextc()) == '=') {
13845  lex_state = EXPR_BEG;
13846  return tOP_ASGN;
13847  }
13848  pushback(c);
13849  warn_balanced("<<", "here document");
13850  return tLSHFT;
13851  }
13852  pushback(c);
13853  return '<';
13854 
13855  case '>':
13856  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13857  if ((c = nextc()) == '=') {
13858  return tGEQ;
13859  }
13860  if (c == '>') {
13861  if ((c = nextc()) == '=') {
13863  lex_state = EXPR_BEG;
13864  return tOP_ASGN;
13865  }
13866  pushback(c);
13867  return tRSHFT;
13868  }
13869  pushback(c);
13870  return '>';
13871 
13872  case '"':
13873  lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13874  return tSTRING_BEG;
13875 
13876  case '`':
13877  if (IS_lex_state(EXPR_FNAME)) {
13878  lex_state = EXPR_ENDFN;
13879  return c;
13880  }
13881  if (IS_lex_state(EXPR_DOT)) {
13882  if (cmd_state)
13883  lex_state = EXPR_CMDARG;
13884  else
13885  lex_state = EXPR_ARG;
13886  return c;
13887  }
13888  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13889  return tXSTRING_BEG;
13890 
13891  case '\'':
13892  lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13893  return tSTRING_BEG;
13894 
13895  case '?':
13896  if (IS_END()) {
13897  lex_state = EXPR_VALUE;
13898  return '?';
13899  }
13900  c = nextc();
13901  if (c == -1) {
13902  compile_error(PARSER_ARG "incomplete character syntax");
13903  return 0;
13904  }
13905  if (rb_enc_isspace(c, current_enc)) {
13906  if (!IS_ARG()) {
13907  int c2 = 0;
13908  switch (c) {
13909  case ' ':
13910  c2 = 's';
13911  break;
13912  case '\n':
13913  c2 = 'n';
13914  break;
13915  case '\t':
13916  c2 = 't';
13917  break;
13918  case '\v':
13919  c2 = 'v';
13920  break;
13921  case '\r':
13922  c2 = 'r';
13923  break;
13924  case '\f':
13925  c2 = 'f';
13926  break;
13927  }
13928  if (c2) {
13929  rb_warnI("invalid character syntax; use ?\\%c", c2);
13930  }
13931  }
13932  ternary:
13933  pushback(c);
13934  lex_state = EXPR_VALUE;
13935  return '?';
13936  }
13937  newtok();
13938  enc = current_enc;
13939  if (!parser_isascii()) {
13940  if (tokadd_mbchar(c) == -1) return 0;
13941  }
13942  else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13944  goto ternary;
13945  }
13946  else if (c == '\\') {
13947  if (peek('u')) {
13948  nextc();
13949  c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13950  if (0x80 <= c) {
13951  tokaddmbc(c, enc);
13952  }
13953  else {
13954  tokadd(c);
13955  }
13956  }
13957  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13958  nextc();
13959  if (tokadd_mbchar(c) == -1) return 0;
13960  }
13961  else {
13962  c = read_escape(0, &enc);
13963  tokadd(c);
13964  }
13965  }
13966  else {
13967  tokadd(c);
13968  }
13969  tokfix();
13970  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13971  lex_state = EXPR_END;
13972  return tCHAR;
13973 
13974  case '&':
13975  if ((c = nextc()) == '&') {
13976  lex_state = EXPR_BEG;
13977  if ((c = nextc()) == '=') {
13979  lex_state = EXPR_BEG;
13980  return tOP_ASGN;
13981  }
13982  pushback(c);
13983  return tANDOP;
13984  }
13985  else if (c == '=') {
13986  set_yylval_id('&');
13987  lex_state = EXPR_BEG;
13988  return tOP_ASGN;
13989  }
13990  pushback(c);
13991  if (IS_SPCARG(c)) {
13992  rb_warning0("`&' interpreted as argument prefix");
13993  c = tAMPER;
13994  }
13995  else if (IS_BEG()) {
13996  c = tAMPER;
13997  }
13998  else {
13999  warn_balanced("&", "argument prefix");
14000  c = '&';
14001  }
14002  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14003  return c;
14004 
14005  case '|':
14006  if ((c = nextc()) == '|') {
14007  lex_state = EXPR_BEG;
14008  if ((c = nextc()) == '=') {
14010  lex_state = EXPR_BEG;
14011  return tOP_ASGN;
14012  }
14013  pushback(c);
14014  return tOROP;
14015  }
14016  if (c == '=') {
14017  set_yylval_id('|');
14018  lex_state = EXPR_BEG;
14019  return tOP_ASGN;
14020  }
14021  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14022  pushback(c);
14023  return '|';
14024 
14025  case '+':
14026  c = nextc();
14027  if (IS_AFTER_OPERATOR()) {
14028  lex_state = EXPR_ARG;
14029  if (c == '@') {
14030  return tUPLUS;
14031  }
14032  pushback(c);
14033  return '+';
14034  }
14035  if (c == '=') {
14036  set_yylval_id('+');
14037  lex_state = EXPR_BEG;
14038  return tOP_ASGN;
14039  }
14040  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
14041  lex_state = EXPR_BEG;
14042  pushback(c);
14043  if (c != -1 && ISDIGIT(c)) {
14044  c = '+';
14045  goto start_num;
14046  }
14047  return tUPLUS;
14048  }
14049  lex_state = EXPR_BEG;
14050  pushback(c);
14051  warn_balanced("+", "unary operator");
14052  return '+';
14053 
14054  case '-':
14055  c = nextc();
14056  if (IS_AFTER_OPERATOR()) {
14057  lex_state = EXPR_ARG;
14058  if (c == '@') {
14059  return tUMINUS;
14060  }
14061  pushback(c);
14062  return '-';
14063  }
14064  if (c == '=') {
14065  set_yylval_id('-');
14066  lex_state = EXPR_BEG;
14067  return tOP_ASGN;
14068  }
14069  if (c == '>') {
14070  lex_state = EXPR_ENDFN;
14071  return tLAMBDA;
14072  }
14073  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
14074  lex_state = EXPR_BEG;
14075  pushback(c);
14076  if (c != -1 && ISDIGIT(c)) {
14077  return tUMINUS_NUM;
14078  }
14079  return tUMINUS;
14080  }
14081  lex_state = EXPR_BEG;
14082  pushback(c);
14083  warn_balanced("-", "unary operator");
14084  return '-';
14085 
14086  case '.':
14087  lex_state = EXPR_BEG;
14088  if ((c = nextc()) == '.') {
14089  if ((c = nextc()) == '.') {
14090  return tDOT3;
14091  }
14092  pushback(c);
14093  return tDOT2;
14094  }
14095  pushback(c);
14096  if (c != -1 && ISDIGIT(c)) {
14097  yyerror("no .<digit> floating literal anymore; put 0 before dot");
14098  }
14099  lex_state = EXPR_DOT;
14100  return '.';
14101 
14102  start_num:
14103  case '0': case '1': case '2': case '3': case '4':
14104  case '5': case '6': case '7': case '8': case '9':
14105  {
14106  int is_float, seen_point, seen_e, nondigit;
14107  int suffix;
14108 
14109  is_float = seen_point = seen_e = nondigit = 0;
14110  lex_state = EXPR_END;
14111  newtok();
14112  if (c == '-' || c == '+') {
14113  tokadd(c);
14114  c = nextc();
14115  }
14116  if (c == '0') {
14117 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
14118  int start = toklen();
14119  c = nextc();
14120  if (c == 'x' || c == 'X') {
14121  /* hexadecimal */
14122  c = nextc();
14123  if (c != -1 && ISXDIGIT(c)) {
14124  do {
14125  if (c == '_') {
14126  if (nondigit) break;
14127  nondigit = c;
14128  continue;
14129  }
14130  if (!ISXDIGIT(c)) break;
14131  nondigit = 0;
14132  tokadd(c);
14133  } while ((c = nextc()) != -1);
14134  }
14135  pushback(c);
14136  tokfix();
14137  if (toklen() == start) {
14138  no_digits();
14139  }
14140  else if (nondigit) goto trailing_uc;
14142  return set_integer_literal(rb_cstr_to_inum(tok(), 16, FALSE), suffix);
14143  }
14144  if (c == 'b' || c == 'B') {
14145  /* binary */
14146  c = nextc();
14147  if (c == '0' || c == '1') {
14148  do {
14149  if (c == '_') {
14150  if (nondigit) break;
14151  nondigit = c;
14152  continue;
14153  }
14154  if (c != '0' && c != '1') break;
14155  nondigit = 0;
14156  tokadd(c);
14157  } while ((c = nextc()) != -1);
14158  }
14159  pushback(c);
14160  tokfix();
14161  if (toklen() == start) {
14162  no_digits();
14163  }
14164  else if (nondigit) goto trailing_uc;
14166  return set_integer_literal(rb_cstr_to_inum(tok(), 2, FALSE), suffix);
14167  }
14168  if (c == 'd' || c == 'D') {
14169  /* decimal */
14170  c = nextc();
14171  if (c != -1 && ISDIGIT(c)) {
14172  do {
14173  if (c == '_') {
14174  if (nondigit) break;
14175  nondigit = c;
14176  continue;
14177  }
14178  if (!ISDIGIT(c)) break;
14179  nondigit = 0;
14180  tokadd(c);
14181  } while ((c = nextc()) != -1);
14182  }
14183  pushback(c);
14184  tokfix();
14185  if (toklen() == start) {
14186  no_digits();
14187  }
14188  else if (nondigit) goto trailing_uc;
14190  return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
14191  }
14192  if (c == '_') {
14193  /* 0_0 */
14194  goto octal_number;
14195  }
14196  if (c == 'o' || c == 'O') {
14197  /* prefixed octal */
14198  c = nextc();
14199  if (c == -1 || c == '_' || !ISDIGIT(c)) {
14200  no_digits();
14201  }
14202  }
14203  if (c >= '0' && c <= '7') {
14204  /* octal */
14205  octal_number:
14206  do {
14207  if (c == '_') {
14208  if (nondigit) break;
14209  nondigit = c;
14210  continue;
14211  }
14212  if (c < '0' || c > '9') break;
14213  if (c > '7') goto invalid_octal;
14214  nondigit = 0;
14215  tokadd(c);
14216  } while ((c = nextc()) != -1);
14217  if (toklen() > start) {
14218  pushback(c);
14219  tokfix();
14220  if (nondigit) goto trailing_uc;
14222  return set_integer_literal(rb_cstr_to_inum(tok(), 8, FALSE), suffix);
14223  }
14224  if (nondigit) {
14225  pushback(c);
14226  goto trailing_uc;
14227  }
14228  }
14229  if (c > '7' && c <= '9') {
14230  invalid_octal:
14231  yyerror("Invalid octal digit");
14232  }
14233  else if (c == '.' || c == 'e' || c == 'E') {
14234  tokadd('0');
14235  }
14236  else {
14237  pushback(c);
14239  return set_integer_literal(INT2FIX(0), suffix);
14240  }
14241  }
14242 
14243  for (;;) {
14244  switch (c) {
14245  case '0': case '1': case '2': case '3': case '4':
14246  case '5': case '6': case '7': case '8': case '9':
14247  nondigit = 0;
14248  tokadd(c);
14249  break;
14250 
14251  case '.':
14252  if (nondigit) goto trailing_uc;
14253  if (seen_point || seen_e) {
14254  goto decode_num;
14255  }
14256  else {
14257  int c0 = nextc();
14258  if (c0 == -1 || !ISDIGIT(c0)) {
14259  pushback(c0);
14260  goto decode_num;
14261  }
14262  c = c0;
14263  }
14264  seen_point = toklen();
14265  tokadd('.');
14266  tokadd(c);
14267  is_float++;
14268  nondigit = 0;
14269  break;
14270 
14271  case 'e':
14272  case 'E':
14273  if (nondigit) {
14274  pushback(c);
14275  c = nondigit;
14276  goto decode_num;
14277  }
14278  if (seen_e) {
14279  goto decode_num;
14280  }
14281  nondigit = c;
14282  c = nextc();
14283  if (c != '-' && c != '+' && !ISDIGIT(c)) {
14284  pushback(c);
14285  nondigit = 0;
14286  goto decode_num;
14287  }
14288  tokadd(nondigit);
14289  seen_e++;
14290  is_float++;
14291  tokadd(c);
14292  nondigit = (c == '-' || c == '+') ? c : 0;
14293  break;
14294 
14295  case '_': /* `_' in number just ignored */
14296  if (nondigit) goto decode_num;
14297  nondigit = c;
14298  break;
14299 
14300  default:
14301  goto decode_num;
14302  }
14303  c = nextc();
14304  }
14305 
14306  decode_num:
14307  pushback(c);
14308  if (nondigit) {
14309  char tmp[30];
14310  trailing_uc:
14311  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14312  yyerror(tmp);
14313  }
14314  tokfix();
14315  if (is_float) {
14316  int type = tFLOAT;
14317  VALUE v;
14318 
14319  suffix = number_literal_suffix(seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
14320  if (suffix & NUM_SUFFIX_R) {
14321  char *point = &tok()[seen_point];
14322  size_t fraclen = toklen()-seen_point-1;
14323  type = tRATIONAL;
14324  memmove(point, point+1, fraclen+1);
14325  v = rb_cstr_to_inum(tok(), 10, FALSE);
14326  v = rb_rational_new(v, rb_int_positive_pow(10, fraclen));
14327  }
14328  else {
14329  double d = strtod(tok(), 0);
14330  if (errno == ERANGE) {
14331  rb_warningS("Float %s out of range", tok());
14332  errno = 0;
14333  }
14334  v = DBL2NUM(d);
14335  }
14336  return set_number_literal(v, type, suffix);
14337  }
14339  return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
14340  }
14341 
14342  case ')':
14343  case ']':
14344  paren_nest--;
14345  case '}':
14346  COND_LEXPOP();
14347  CMDARG_LEXPOP();
14348  if (c == ')')
14349  lex_state = EXPR_ENDFN;
14350  else
14351  lex_state = EXPR_ENDARG;
14352  if (c == '}') {
14353  if (!brace_nest--) c = tSTRING_DEND;
14354  }
14355  return c;
14356 
14357  case ':':
14358  c = nextc();
14359  if (c == ':') {
14360  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14361  lex_state = EXPR_BEG;
14362  return tCOLON3;
14363  }
14364  lex_state = EXPR_DOT;
14365  return tCOLON2;
14366  }
14367  if (IS_END() || ISSPACE(c)) {
14368  pushback(c);
14369  warn_balanced(":", "symbol literal");
14370  lex_state = EXPR_BEG;
14371  return ':';
14372  }
14373  switch (c) {
14374  case '\'':
14375  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14376  break;
14377  case '"':
14378  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14379  break;
14380  default:
14381  pushback(c);
14382  break;
14383  }
14384  lex_state = EXPR_FNAME;
14385  return tSYMBEG;
14386 
14387  case '/':
14388  if (IS_lex_state(EXPR_BEG_ANY)) {
14389  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14390  return tREGEXP_BEG;
14391  }
14392  if ((c = nextc()) == '=') {
14393  set_yylval_id('/');
14394  lex_state = EXPR_BEG;
14395  return tOP_ASGN;
14396  }
14397  pushback(c);
14398  if (IS_SPCARG(c)) {
14399  (void)arg_ambiguous();
14400  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14401  return tREGEXP_BEG;
14402  }
14403  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14404  warn_balanced("/", "regexp literal");
14405  return '/';
14406 
14407  case '^':
14408  if ((c = nextc()) == '=') {
14409  set_yylval_id('^');
14410  lex_state = EXPR_BEG;
14411  return tOP_ASGN;
14412  }
14413  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14414  pushback(c);
14415  return '^';
14416 
14417  case ';':
14418  lex_state = EXPR_BEG;
14419  command_start = TRUE;
14420  return ';';
14421 
14422  case ',':
14423  lex_state = EXPR_BEG;
14424  return ',';
14425 
14426  case '~':
14427  if (IS_AFTER_OPERATOR()) {
14428  if ((c = nextc()) != '@') {
14429  pushback(c);
14430  }
14431  lex_state = EXPR_ARG;
14432  }
14433  else {
14434  lex_state = EXPR_BEG;
14435  }
14436  return '~';
14437 
14438  case '(':
14439  if (IS_BEG()) {
14440  c = tLPAREN;
14441  }
14442  else if (IS_SPCARG(-1)) {
14443  c = tLPAREN_ARG;
14444  }
14445  paren_nest++;
14446  COND_PUSH(0);
14447  CMDARG_PUSH(0);
14448  lex_state = EXPR_BEG;
14449  return c;
14450 
14451  case '[':
14452  paren_nest++;
14453  if (IS_AFTER_OPERATOR()) {
14454  lex_state = EXPR_ARG;
14455  if ((c = nextc()) == ']') {
14456  if ((c = nextc()) == '=') {
14457  return tASET;
14458  }
14459  pushback(c);
14460  return tAREF;
14461  }
14462  pushback(c);
14463  return '[';
14464  }
14465  else if (IS_BEG()) {
14466  c = tLBRACK;
14467  }
14468  else if (IS_ARG() && space_seen) {
14469  c = tLBRACK;
14470  }
14471  lex_state = EXPR_BEG;
14472  COND_PUSH(0);
14473  CMDARG_PUSH(0);
14474  return c;
14475 
14476  case '{':
14477  ++brace_nest;
14478  if (lpar_beg && lpar_beg == paren_nest) {
14479  lex_state = EXPR_BEG;
14480  lpar_beg = 0;
14481  --paren_nest;
14482  COND_PUSH(0);
14483  CMDARG_PUSH(0);
14484  return tLAMBEG;
14485  }
14486  if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14487  c = '{'; /* block (primary) */
14488  else if (IS_lex_state(EXPR_ENDARG))
14489  c = tLBRACE_ARG; /* block (expr) */
14490  else
14491  c = tLBRACE; /* hash */
14492  COND_PUSH(0);
14493  CMDARG_PUSH(0);
14494  lex_state = EXPR_BEG;
14495  if (c != tLBRACE) command_start = TRUE;
14496  return c;
14497 
14498  case '\\':
14499  c = nextc();
14500  if (c == '\n') {
14501  space_seen = 1;
14502 #ifdef RIPPER
14503  ripper_dispatch_scan_event(parser, tSP);
14504 #endif
14505  goto retry; /* skip \\n */
14506  }
14507  pushback(c);
14508  return '\\';
14509 
14510  case '%':
14511  if (IS_lex_state(EXPR_BEG_ANY)) {
14512  int term;
14513  int paren;
14514 
14515  c = nextc();
14516  quotation:
14517  if (c == -1 || !ISALNUM(c)) {
14518  term = c;
14519  c = 'Q';
14520  }
14521  else {
14522  term = nextc();
14523  if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14524  yyerror("unknown type of %string");
14525  return 0;
14526  }
14527  }
14528  if (c == -1 || term == -1) {
14529  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14530  return 0;
14531  }
14532  paren = term;
14533  if (term == '(') term = ')';
14534  else if (term == '[') term = ']';
14535  else if (term == '{') term = '}';
14536  else if (term == '<') term = '>';
14537  else paren = 0;
14538 
14539  switch (c) {
14540  case 'Q':
14541  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14542  return tSTRING_BEG;
14543 
14544  case 'q':
14545  lex_strterm = NEW_STRTERM(str_squote, term, paren);
14546  return tSTRING_BEG;
14547 
14548  case 'W':
14549  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14550  do {c = nextc();} while (ISSPACE(c));
14551  pushback(c);
14552  return tWORDS_BEG;
14553 
14554  case 'w':
14555  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14556  do {c = nextc();} while (ISSPACE(c));
14557  pushback(c);
14558  return tQWORDS_BEG;
14559 
14560  case 'I':
14561  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14562  do {c = nextc();} while (ISSPACE(c));
14563  pushback(c);
14564  return tSYMBOLS_BEG;
14565 
14566  case 'i':
14567  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14568  do {c = nextc();} while (ISSPACE(c));
14569  pushback(c);
14570  return tQSYMBOLS_BEG;
14571 
14572  case 'x':
14573  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14574  return tXSTRING_BEG;
14575 
14576  case 'r':
14577  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14578  return tREGEXP_BEG;
14579 
14580  case 's':
14581  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14582  lex_state = EXPR_FNAME;
14583  return tSYMBEG;
14584 
14585  default:
14586  yyerror("unknown type of %string");
14587  return 0;
14588  }
14589  }
14590  if ((c = nextc()) == '=') {
14591  set_yylval_id('%');
14592  lex_state = EXPR_BEG;
14593  return tOP_ASGN;
14594  }
14595  if (IS_SPCARG(c)) {
14596  goto quotation;
14597  }
14598  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14599  pushback(c);
14600  warn_balanced("%%", "string literal");
14601  return '%';
14602 
14603  case '$':
14604  lex_state = EXPR_END;
14605  newtok();
14606  c = nextc();
14607  switch (c) {
14608  case '_': /* $_: last read line string */
14609  c = nextc();
14610  if (parser_is_identchar()) {
14611  tokadd('$');
14612  tokadd('_');
14613  break;
14614  }
14615  pushback(c);
14616  c = '_';
14617  /* fall through */
14618  case '~': /* $~: match-data */
14619  case '*': /* $*: argv */
14620  case '$': /* $$: pid */
14621  case '?': /* $?: last status */
14622  case '!': /* $!: error string */
14623  case '@': /* $@: error position */
14624  case '/': /* $/: input record separator */
14625  case '\\': /* $\: output record separator */
14626  case ';': /* $;: field separator */
14627  case ',': /* $,: output field separator */
14628  case '.': /* $.: last read line number */
14629  case '=': /* $=: ignorecase */
14630  case ':': /* $:: load path */
14631  case '<': /* $<: reading filename */
14632  case '>': /* $>: default output handle */
14633  case '\"': /* $": already loaded files */
14634  tokadd('$');
14635  tokadd(c);
14636  goto gvar;
14637 
14638  case '-':
14639  tokadd('$');
14640  tokadd(c);
14641  c = nextc();
14642  if (parser_is_identchar()) {
14643  if (tokadd_mbchar(c) == -1) return 0;
14644  }
14645  else {
14646  pushback(c);
14647  pushback('-');
14648  return '$';
14649  }
14650  gvar:
14652  return tGVAR;
14653 
14654  case '&': /* $&: last match */
14655  case '`': /* $`: string before last match */
14656  case '\'': /* $': string after last match */
14657  case '+': /* $+: string matches last paren. */
14658  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14659  tokadd('$');
14660  tokadd(c);
14661  goto gvar;
14662  }
14664  return tBACK_REF;
14665 
14666  case '1': case '2': case '3':
14667  case '4': case '5': case '6':
14668  case '7': case '8': case '9':
14669  tokadd('$');
14670  do {
14671  tokadd(c);
14672  c = nextc();
14673  } while (c != -1 && ISDIGIT(c));
14674  pushback(c);
14675  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14676  tokfix();
14678  return tNTH_REF;
14679 
14680  default:
14681  if (!parser_is_identchar()) {
14682  pushback(c);
14683  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14684  return 0;
14685  }
14686  case '0':
14687  tokadd('$');
14688  }
14689  break;
14690 
14691  case '@':
14692  c = nextc();
14693  newtok();
14694  tokadd('@');
14695  if (c == '@') {
14696  tokadd('@');
14697  c = nextc();
14698  }
14699  if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14700  pushback(c);
14701  if (tokidx == 1) {
14702  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14703  }
14704  else {
14705  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14706  }
14707  return 0;
14708  }
14709  break;
14710 
14711  case '_':
14712  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14713  ruby__end__seen = 1;
14714  parser->eofp = Qtrue;
14715 #ifndef RIPPER
14716  return -1;
14717 #else
14718  lex_goto_eol(parser);
14719  ripper_dispatch_scan_event(parser, k__END__);
14720  return 0;
14721 #endif
14722  }
14723  newtok();
14724  break;
14725 
14726  default:
14727  if (!parser_is_identchar()) {
14728  compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14729  goto retry;
14730  }
14731 
14732  newtok();
14733  break;
14734  }
14735 
14736  mb = ENC_CODERANGE_7BIT;
14737  do {
14738  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14739  if (tokadd_mbchar(c) == -1) return 0;
14740  c = nextc();
14741  } while (parser_is_identchar());
14742  switch (tok()[0]) {
14743  case '@': case '$':
14744  pushback(c);
14745  break;
14746  default:
14747  if ((c == '!' || c == '?') && !peek('=')) {
14748  tokadd(c);
14749  }
14750  else {
14751  pushback(c);
14752  }
14753  }
14754  tokfix();
14755 
14756  {
14757  int result = 0;
14758 
14759  last_state = lex_state;
14760  switch (tok()[0]) {
14761  case '$':
14762  lex_state = EXPR_END;
14763  result = tGVAR;
14764  break;
14765  case '@':
14766  lex_state = EXPR_END;
14767  if (tok()[1] == '@')
14768  result = tCVAR;
14769  else
14770  result = tIVAR;
14771  break;
14772 
14773  default:
14774  if (toklast() == '!' || toklast() == '?') {
14775  result = tFID;
14776  }
14777  else {
14778  if (IS_lex_state(EXPR_FNAME)) {
14779  if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14780  (!peek('=') || (peek_n('>', 1)))) {
14781  result = tIDENTIFIER;
14782  tokadd(c);
14783  tokfix();
14784  }
14785  else {
14786  pushback(c);
14787  }
14788  }
14789  if (result == 0 && ISUPPER(tok()[0])) {
14790  result = tCONSTANT;
14791  }
14792  else {
14793  result = tIDENTIFIER;
14794  }
14795  }
14796 
14797  if (IS_LABEL_POSSIBLE()) {
14798  if (IS_LABEL_SUFFIX(0)) {
14799  lex_state = EXPR_LABELARG;
14800  nextc();
14802  return tLABEL;
14803  }
14804  }
14805  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14806  const struct kwtable *kw;
14807 
14808  /* See if it is a reserved word. */
14809  kw = rb_reserved_word(tok(), toklen());
14810  if (kw) {
14811  enum lex_state_e state = lex_state;
14812  lex_state = kw->state;
14813  if (IS_lex_state_for(state, EXPR_FNAME)) {
14815  return kw->id[0];
14816  }
14817  if (IS_lex_state(EXPR_BEG)) {
14818  command_start = TRUE;
14819  }
14820  if (kw->id[0] == keyword_do) {
14821  if (lpar_beg && lpar_beg == paren_nest) {
14822  lpar_beg = 0;
14823  --paren_nest;
14824  return keyword_do_LAMBDA;
14825  }
14826  if (COND_P()) return keyword_do_cond;
14827  if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG))
14828  return keyword_do_block;
14829  if (IS_lex_state_for(state, (EXPR_BEG | EXPR_ENDARG)))
14830  return keyword_do_block;
14831  return keyword_do;
14832  }
14833  if (IS_lex_state_for(state, (EXPR_BEG | EXPR_VALUE | EXPR_LABELARG)))
14834  return kw->id[0];
14835  else {
14836  if (kw->id[0] != kw->id[1])
14837  lex_state = EXPR_BEG;
14838  return kw->id[1];
14839  }
14840  }
14841  }
14842 
14843  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14844  if (cmd_state) {
14845  lex_state = EXPR_CMDARG;
14846  }
14847  else {
14848  lex_state = EXPR_ARG;
14849  }
14850  }
14851  else if (lex_state == EXPR_FNAME) {
14852  lex_state = EXPR_ENDFN;
14853  }
14854  else {
14855  lex_state = EXPR_END;
14856  }
14857  }
14858  {
14859  ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14860 
14861  set_yylval_name(ident);
14862  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14863  is_local_id(ident) && lvar_defined(ident)) {
14864  lex_state = EXPR_END;
14865  }
14866  }
14867  return result;
14868  }
14869 }
14870 
14871 #if YYPURE
14872 static int
14873 yylex(void *lval, void *p)
14874 #else
14875 yylex(void *p)
14876 #endif
14878  struct parser_params *parser = (struct parser_params*)p;
14879  int t;
14880 
14881 #if YYPURE
14882  parser->parser_yylval = lval;
14884 #endif
14885  t = parser_yylex(parser);
14886 #ifdef RIPPER
14887  if (!NIL_P(parser->delayed)) {
14888  ripper_dispatch_delayed_token(parser, t);
14889  return t;
14890  }
14891  if (t != 0)
14892  ripper_dispatch_scan_event(parser, t);
14893 #endif
14894 
14895  return t;
14896 }
14897 
14898 #ifndef RIPPER
14899 static NODE*
14900 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14901 {
14902  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14904  return n;
14905 }
14906 
14907 static enum node_type
14908 nodetype(NODE *node) /* for debug */
14909 {
14910  return (enum node_type)nd_type(node);
14911 }
14912 
14913 static int
14915 {
14916  return nd_line(node);
14917 }
14918 
14919 static NODE*
14921 {
14922  if (node) {
14923  node = remove_begin(node);
14924  node->flags |= NODE_FL_NEWLINE;
14925  }
14926  return node;
14927 }
14928 
14929 static void
14930 fixpos(NODE *node, NODE *orig)
14931 {
14932  if (!node) return;
14933  if (!orig) return;
14934  if (orig == (NODE*)1) return;
14935  nd_set_line(node, nd_line(orig));
14936 }
14937 
14938 static void
14939 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14940 {
14941  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14942 }
14943 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14944 
14945 static void
14946 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14947 {
14948  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14949 }
14950 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14951 
14952 static NODE*
14953 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14954 {
14955  NODE *end, *h = head, *nd;
14956 
14957  if (tail == 0) return head;
14958 
14959  if (h == 0) return tail;
14960  switch (nd_type(h)) {
14961  case NODE_LIT:
14962  case NODE_STR:
14963  case NODE_SELF:
14964  case NODE_TRUE:
14965  case NODE_FALSE:
14966  case NODE_NIL:
14967  parser_warning(h, "unused literal ignored");
14968  return tail;
14969  default:
14970  h = end = NEW_BLOCK(head);
14971  end->nd_end = end;
14972  fixpos(end, head);
14973  head = end;
14974  break;
14975  case NODE_BLOCK:
14976  end = h->nd_end;
14977  break;
14978  }
14979 
14980  nd = end->nd_head;
14981  switch (nd_type(nd)) {
14982  case NODE_RETURN:
14983  case NODE_BREAK:
14984  case NODE_NEXT:
14985  case NODE_REDO:
14986  case NODE_RETRY:
14987  if (RTEST(ruby_verbose)) {
14988  parser_warning(tail, "statement not reached");
14989  }
14990  break;
14991 
14992  default:
14993  break;
14994  }
14995 
14996  if (nd_type(tail) != NODE_BLOCK) {
14997  tail = NEW_BLOCK(tail);
14998  tail->nd_end = tail;
14999  }
15000  end->nd_next = tail;
15001  h->nd_end = tail->nd_end;
15002  return head;
15003 }
15004 
15005 /* append item to the list */
15006 static NODE*
15007 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
15008 {
15009  NODE *last;
15010 
15011  if (list == 0) return NEW_LIST(item);
15012  if (list->nd_next) {
15013  last = list->nd_next->nd_end;
15014  }
15015  else {
15016  last = list;
15017  }
15018 
15019  list->nd_alen += 1;
15020  last->nd_next = NEW_LIST(item);
15021  list->nd_next->nd_end = last->nd_next;
15022  return list;
15023 }
15024 
15025 /* concat two lists */
15026 static NODE*
15027 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
15028 {
15029  NODE *last;
15030 
15031  if (head->nd_next) {
15032  last = head->nd_next->nd_end;
15033  }
15034  else {
15035  last = head;
15036  }
15037 
15038  head->nd_alen += tail->nd_alen;
15039  last->nd_next = tail;
15040  if (tail->nd_next) {
15041  head->nd_next->nd_end = tail->nd_next->nd_end;
15042  }
15043  else {
15044  head->nd_next->nd_end = tail;
15045  }
15046 
15047  return head;
15048 }
15049 
15050 static int
15052 {
15053  if (NIL_P(tail)) return 1;
15054  if (!rb_enc_compatible(head, tail)) {
15055  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
15056  rb_enc_name(rb_enc_get(head)),
15057  rb_enc_name(rb_enc_get(tail)));
15058  rb_str_resize(head, 0);
15059  rb_str_resize(tail, 0);
15060  return 0;
15061  }
15062  rb_str_buf_append(head, tail);
15063  return 1;
15064 }
15065 
15066 /* concat two string literals */
15067 static NODE *
15069 {
15070  enum node_type htype;
15071  NODE *headlast;
15072  VALUE lit;
15073 
15074  if (!head) return tail;
15075  if (!tail) return head;
15076 
15077  htype = nd_type(head);
15078  if (htype == NODE_EVSTR) {
15079  NODE *node = NEW_DSTR(STR_NEW0());
15080  head = list_append(node, head);
15081  htype = NODE_DSTR;
15082  }
15083  switch (nd_type(tail)) {
15084  case NODE_STR:
15085  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
15086  nd_type(headlast) == NODE_STR) {
15087  htype = NODE_STR;
15088  lit = headlast->nd_lit;
15089  }
15090  else {
15091  lit = head->nd_lit;
15092  }
15093  if (htype == NODE_STR) {
15094  if (!literal_concat0(parser, lit, tail->nd_lit)) {
15095  error:
15096  rb_gc_force_recycle((VALUE)head);
15097  rb_gc_force_recycle((VALUE)tail);
15098  return 0;
15099  }
15100  rb_gc_force_recycle((VALUE)tail);
15101  }
15102  else {
15103  list_append(head, tail);
15104  }
15105  break;
15106 
15107  case NODE_DSTR:
15108  if (htype == NODE_STR) {
15109  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
15110  goto error;
15111  tail->nd_lit = head->nd_lit;
15112  rb_gc_force_recycle((VALUE)head);
15113  head = tail;
15114  }
15115  else if (NIL_P(tail->nd_lit)) {
15116  append:
15117  head->nd_alen += tail->nd_alen - 1;
15118  head->nd_next->nd_end->nd_next = tail->nd_next;
15119  head->nd_next->nd_end = tail->nd_next->nd_end;
15120  rb_gc_force_recycle((VALUE)tail);
15121  }
15122  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
15123  nd_type(headlast) == NODE_STR) {
15124  lit = headlast->nd_lit;
15125  if (!literal_concat0(parser, lit, tail->nd_lit))
15126  goto error;
15127  tail->nd_lit = Qnil;
15128  goto append;
15129  }
15130  else {
15131  nd_set_type(tail, NODE_ARRAY);
15132  tail->nd_head = NEW_STR(tail->nd_lit);
15133  list_concat(head, tail);
15134  }
15135  break;
15136 
15137  case NODE_EVSTR:
15138  if (htype == NODE_STR) {
15139  nd_set_type(head, NODE_DSTR);
15140  head->nd_alen = 1;
15141  }
15142  list_append(head, tail);
15143  break;
15144  }
15145  return head;
15146 }
15147 
15148 static NODE *
15149 evstr2dstr_gen(struct parser_params *parser, NODE *node)
15150 {
15151  if (nd_type(node) == NODE_EVSTR) {
15152  node = list_append(NEW_DSTR(STR_NEW0()), node);
15153  }
15154  return node;
15155 }
15156 
15157 static NODE *
15158 new_evstr_gen(struct parser_params *parser, NODE *node)
15159 {
15160  NODE *head = node;
15161 
15162  if (node) {
15163  switch (nd_type(node)) {
15164  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
15165  return node;
15166  }
15167  }
15168  return NEW_EVSTR(head);
15169 }
15170 
15171 static NODE *
15172 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
15173 {
15174  value_expr(recv);
15175  value_expr(arg1);
15176  return NEW_CALL(recv, id, NEW_LIST(arg1));
15177 }
15178 
15179 static NODE *
15180 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
15181 {
15182  value_expr(recv);
15183  return NEW_CALL(recv, id, 0);
15184 }
15185 
15186 static NODE*
15187 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15188 {
15189  value_expr(node1);
15190  value_expr(node2);
15191  if (node1) {
15192  switch (nd_type(node1)) {
15193  case NODE_DREGX:
15194  case NODE_DREGX_ONCE:
15195  return NEW_MATCH2(node1, node2);
15196 
15197  case NODE_LIT:
15198  if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
15199  return NEW_MATCH2(node1, node2);
15200  }
15201  }
15202  }
15203 
15204  if (node2) {
15205  switch (nd_type(node2)) {
15206  case NODE_DREGX:
15207  case NODE_DREGX_ONCE:
15208  return NEW_MATCH3(node2, node1);
15209 
15210  case NODE_LIT:
15211  if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
15212  return NEW_MATCH3(node2, node1);
15213  }
15214  }
15215  }
15216 
15217  return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
15218 }
15219 
15220 static NODE*
15221 gettable_gen(struct parser_params *parser, ID id)
15222 {
15223  switch (id) {
15224  case keyword_self:
15225  return NEW_SELF();
15226  case keyword_nil:
15227  return NEW_NIL();
15228  case keyword_true:
15229  return NEW_TRUE();
15230  case keyword_false:
15231  return NEW_FALSE();
15232  case keyword__FILE__:
15234  case keyword__LINE__:
15235  return NEW_LIT(INT2FIX(tokline));
15236  case keyword__ENCODING__:
15238  }
15239  switch (id_type(id)) {
15240  case ID_LOCAL:
15241  if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
15242  if (local_id(id)) return NEW_LVAR(id);
15243  /* method call without arguments */
15244  return NEW_VCALL(id);
15245  case ID_GLOBAL:
15246  return NEW_GVAR(id);
15247  case ID_INSTANCE:
15248  return NEW_IVAR(id);
15249  case ID_CONST:
15250  return NEW_CONST(id);
15251  case ID_CLASS:
15252  return NEW_CVAR(id);
15253  }
15254  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15255  return 0;
15256 }
15257 #else /* !RIPPER */
15258 static int
15259 id_is_var_gen(struct parser_params *parser, ID id)
15260 {
15261  if (is_notop_id(id)) {
15262  switch (id & ID_SCOPE_MASK) {
15263  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
15264  return 1;
15265  case ID_LOCAL:
15266  if (dyna_in_block() && dvar_defined(id)) return 1;
15267  if (local_id(id)) return 1;
15268  /* method call without arguments */
15269  return 0;
15270  }
15271  }
15272  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15273  return 0;
15274 }
15275 #endif /* !RIPPER */
15276 
15277 #if PARSER_DEBUG
15278 static const char *
15279 lex_state_name(enum lex_state_e state)
15280 {
15281  static const char names[][12] = {
15282  "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG",
15283  "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS",
15284  "EXPR_VALUE",
15285  };
15286 
15287  if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
15288  return names[ffs(state)];
15289  return NULL;
15290 }
15291 #endif
15292 
15293 #ifdef RIPPER
15294 static VALUE
15295 assignable_gen(struct parser_params *parser, VALUE lhs)
15296 #else
15297 static NODE*
15298 assignable_gen(struct parser_params *parser, ID id, NODE *val)
15299 #endif
15300 {
15301 #ifdef RIPPER
15302  ID id = get_id(lhs);
15303 # define assignable_result(x) get_value(lhs)
15304 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
15305 #else
15306 # define assignable_result(x) (x)
15307 #endif
15308  if (!id) return assignable_result(0);
15309  switch (id) {
15310  case keyword_self:
15311  yyerror("Can't change the value of self");
15312  goto error;
15313  case keyword_nil:
15314  yyerror("Can't assign to nil");
15315  goto error;
15316  case keyword_true:
15317  yyerror("Can't assign to true");
15318  goto error;
15319  case keyword_false:
15320  yyerror("Can't assign to false");
15321  goto error;
15322  case keyword__FILE__:
15323  yyerror("Can't assign to __FILE__");
15324  goto error;
15325  case keyword__LINE__:
15326  yyerror("Can't assign to __LINE__");
15327  goto error;
15328  case keyword__ENCODING__:
15329  yyerror("Can't assign to __ENCODING__");
15330  goto error;
15331  }
15332  switch (id_type(id)) {
15333  case ID_LOCAL:
15334  if (dyna_in_block()) {
15335  if (dvar_curr(id)) {
15336  return assignable_result(NEW_DASGN_CURR(id, val));
15337  }
15338  else if (dvar_defined(id)) {
15339  return assignable_result(NEW_DASGN(id, val));
15340  }
15341  else if (local_id(id)) {
15342  return assignable_result(NEW_LASGN(id, val));
15343  }
15344  else {
15345  dyna_var(id);
15346  return assignable_result(NEW_DASGN_CURR(id, val));
15347  }
15348  }
15349  else {
15350  if (!local_id(id)) {
15351  local_var(id);
15352  }
15353  return assignable_result(NEW_LASGN(id, val));
15354  }
15355  break;
15356  case ID_GLOBAL:
15357  return assignable_result(NEW_GASGN(id, val));
15358  case ID_INSTANCE:
15359  return assignable_result(NEW_IASGN(id, val));
15360  case ID_CONST:
15361  if (!in_def && !in_single)
15362  return assignable_result(NEW_CDECL(id, val, 0));
15363  yyerror("dynamic constant assignment");
15364  break;
15365  case ID_CLASS:
15366  return assignable_result(NEW_CVASGN(id, val));
15367  default:
15368  compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15369  }
15370  error:
15372 #undef assignable_result
15373 #undef parser_yyerror
15374 }
15375 
15376 static int
15378 {
15379  VALUE s;
15380  if (name == idUScore) return 1;
15381  if (!is_local_id(name)) return 0;
15382  s = rb_id2str(name);
15383  if (!s) return 0;
15384  return RSTRING_PTR(s)[0] == '_';
15385 }
15386 
15387 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15388 
15389 static int
15390 shadowing_lvar_0(struct parser_params *parser, ID name)
15391 {
15392  if (is_private_local_id(name)) return 1;
15393  if (dyna_in_block()) {
15394  if (dvar_curr(name)) {
15395  yyerror("duplicated argument name");
15396  }
15397  else if (dvar_defined_get(name) || local_id(name)) {
15398  rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15399  vtable_add(lvtbl->vars, name);
15400  if (lvtbl->used) {
15402  }
15403  return 0;
15404  }
15405  }
15406  else {
15407  if (local_id(name)) {
15408  yyerror("duplicated argument name");
15409  }
15410  }
15411  return 1;
15412 }
15413 
15414 static ID
15415 shadowing_lvar_gen(struct parser_params *parser, ID name)
15416 {
15417  shadowing_lvar_0(parser, name);
15418  return name;
15419 }
15420 
15421 static void
15422 new_bv_gen(struct parser_params *parser, ID name)
15423 {
15424  if (!name) return;
15425  if (!is_local_id(name)) {
15426  compile_error(PARSER_ARG "invalid local variable - %s",
15427  rb_id2name(name));
15428  return;
15429  }
15430  if (!shadowing_lvar_0(parser, name)) return;
15431  dyna_var(name);
15432 }
15433 
15434 #ifndef RIPPER
15435 static NODE *
15436 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15437 {
15438  if (recv && nd_type(recv) == NODE_SELF)
15439  recv = (NODE *)1;
15440  return NEW_ATTRASGN(recv, tASET, idx);
15441 }
15442 
15443 static void
15444 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15445 {
15446  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15447  compile_error(PARSER_ARG "both block arg and actual block given");
15448  }
15449 }
15450 
15451 static const char id_type_names[][9] = {
15452  "LOCAL",
15453  "INSTANCE",
15454  "", /* INSTANCE2 */
15455  "GLOBAL",
15456  "ATTRSET",
15457  "CONST",
15458  "CLASS",
15459  "JUNK",
15460 };
15461 
15462 ID
15464 {
15465  if (!is_notop_id(id)) {
15466  switch (id) {
15467  case tAREF: case tASET:
15468  return tASET; /* only exception */
15469  }
15470  rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
15471  }
15472  else {
15473  int scope = (int)(id & ID_SCOPE_MASK);
15474  switch (scope) {
15475  case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
15476  case ID_CONST: case ID_CLASS: case ID_JUNK:
15477  break;
15478  case ID_ATTRSET:
15479  return id;
15480  default:
15481  rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset",
15482  id_type_names[scope], ID2SYM(id));
15483 
15484  }
15485  }
15486  id &= ~ID_SCOPE_MASK;
15487  id |= ID_ATTRSET;
15488  return id;
15489 }
15490 
15491 static NODE *
15492 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15493 {
15494  if (recv && nd_type(recv) == NODE_SELF)
15495  recv = (NODE *)1;
15496  return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15497 }
15498 
15499 static void
15501 {
15502  switch (nd_type(node)) {
15503  case NODE_NTH_REF:
15504  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15505  break;
15506  case NODE_BACK_REF:
15507  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15508  break;
15509  }
15510 }
15511 
15512 static NODE *
15513 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15514 {
15515  if (!node2) return node1;
15516  switch (nd_type(node1)) {
15517  case NODE_BLOCK_PASS:
15518  if (node1->nd_head)
15519  node1->nd_head = arg_concat(node1->nd_head, node2);
15520  else
15521  node1->nd_head = NEW_LIST(node2);
15522  return node1;
15523  case NODE_ARGSPUSH:
15524  if (nd_type(node2) != NODE_ARRAY) break;
15525  node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15526  nd_set_type(node1, NODE_ARGSCAT);
15527  return node1;
15528  case NODE_ARGSCAT:
15529  if (nd_type(node2) != NODE_ARRAY ||
15530  nd_type(node1->nd_body) != NODE_ARRAY) break;
15531  node1->nd_body = list_concat(node1->nd_body, node2);
15532  return node1;
15533  }
15534  return NEW_ARGSCAT(node1, node2);
15535 }
15536 
15537 static NODE *
15538 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15539 {
15540  if (!node1) return NEW_LIST(node2);
15541  switch (nd_type(node1)) {
15542  case NODE_ARRAY:
15543  return list_append(node1, node2);
15544  case NODE_BLOCK_PASS:
15545  node1->nd_head = arg_append(node1->nd_head, node2);
15546  return node1;
15547  case NODE_ARGSPUSH:
15548  node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15549  nd_set_type(node1, NODE_ARGSCAT);
15550  return node1;
15551  }
15552  return NEW_ARGSPUSH(node1, node2);
15553 }
15554 
15555 static NODE *
15557 {
15558  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15559  if (nd_type(node) == NODE_ARRAY) return node;
15560  return 0;
15561 }
15562 
15563 static NODE *
15564 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15565 {
15566  if (!lhs) return 0;
15567 
15568  switch (nd_type(lhs)) {
15569  case NODE_GASGN:
15570  case NODE_IASGN:
15571  case NODE_IASGN2:
15572  case NODE_LASGN:
15573  case NODE_DASGN:
15574  case NODE_DASGN_CURR:
15575  case NODE_MASGN:
15576  case NODE_CDECL:
15577  case NODE_CVASGN:
15578  lhs->nd_value = rhs;
15579  break;
15580 
15581  case NODE_ATTRASGN:
15582  case NODE_CALL:
15583  lhs->nd_args = arg_append(lhs->nd_args, rhs);
15584  break;
15585 
15586  default:
15587  /* should not happen */
15588  break;
15589  }
15590 
15591  return lhs;
15592 }
15593 
15594 static int
15595 value_expr_gen(struct parser_params *parser, NODE *node)
15596 {
15597  int cond = 0;
15598 
15599  if (!node) {
15600  rb_warning0("empty expression");
15601  }
15602  while (node) {
15603  switch (nd_type(node)) {
15604  case NODE_RETURN:
15605  case NODE_BREAK:
15606  case NODE_NEXT:
15607  case NODE_REDO:
15608  case NODE_RETRY:
15609  if (!cond) yyerror("void value expression");
15610  /* or "control never reach"? */
15611  return FALSE;
15612 
15613  case NODE_BLOCK:
15614  while (node->nd_next) {
15615  node = node->nd_next;
15616  }
15617  node = node->nd_head;
15618  break;
15619 
15620  case NODE_BEGIN:
15621  node = node->nd_body;
15622  break;
15623 
15624  case NODE_IF:
15625  if (!node->nd_body) {
15626  node = node->nd_else;
15627  break;
15628  }
15629  else if (!node->nd_else) {
15630  node = node->nd_body;
15631  break;
15632  }
15633  if (!value_expr(node->nd_body)) return FALSE;
15634  node = node->nd_else;
15635  break;
15636 
15637  case NODE_AND:
15638  case NODE_OR:
15639  cond = 1;
15640  node = node->nd_2nd;
15641  break;
15642 
15643  default:
15644  return TRUE;
15645  }
15646  }
15647 
15648  return TRUE;
15649 }
15650 
15651 static void
15652 void_expr_gen(struct parser_params *parser, NODE *node)
15653 {
15654  const char *useless = 0;
15655 
15656  if (!RTEST(ruby_verbose)) return;
15657 
15658  if (!node) return;
15659  switch (nd_type(node)) {
15660  case NODE_CALL:
15661  switch (node->nd_mid) {
15662  case '+':
15663  case '-':
15664  case '*':
15665  case '/':
15666  case '%':
15667  case tPOW:
15668  case tUPLUS:
15669  case tUMINUS:
15670  case '|':
15671  case '^':
15672  case '&':
15673  case tCMP:
15674  case '>':
15675  case tGEQ:
15676  case '<':
15677  case tLEQ:
15678  case tEQ:
15679  case tNEQ:
15680  useless = rb_id2name(node->nd_mid);
15681  break;
15682  }
15683  break;
15684 
15685  case NODE_LVAR:
15686  case NODE_DVAR:
15687  case NODE_GVAR:
15688  case NODE_IVAR:
15689  case NODE_CVAR:
15690  case NODE_NTH_REF:
15691  case NODE_BACK_REF:
15692  useless = "a variable";
15693  break;
15694  case NODE_CONST:
15695  useless = "a constant";
15696  break;
15697  case NODE_LIT:
15698  case NODE_STR:
15699  case NODE_DSTR:
15700  case NODE_DREGX:
15701  case NODE_DREGX_ONCE:
15702  useless = "a literal";
15703  break;
15704  case NODE_COLON2:
15705  case NODE_COLON3:
15706  useless = "::";
15707  break;
15708  case NODE_DOT2:
15709  useless = "..";
15710  break;
15711  case NODE_DOT3:
15712  useless = "...";
15713  break;
15714  case NODE_SELF:
15715  useless = "self";
15716  break;
15717  case NODE_NIL:
15718  useless = "nil";
15719  break;
15720  case NODE_TRUE:
15721  useless = "true";
15722  break;
15723  case NODE_FALSE:
15724  useless = "false";
15725  break;
15726  case NODE_DEFINED:
15727  useless = "defined?";
15728  break;
15729  }
15730 
15731  if (useless) {
15732  int line = ruby_sourceline;
15733 
15734  ruby_sourceline = nd_line(node);
15735  rb_warnS("possibly useless use of %s in void context", useless);
15736  ruby_sourceline = line;
15737  }
15738 }
15739 
15740 static void
15741 void_stmts_gen(struct parser_params *parser, NODE *node)
15742 {
15743  if (!RTEST(ruby_verbose)) return;
15744  if (!node) return;
15745  if (nd_type(node) != NODE_BLOCK) return;
15746 
15747  for (;;) {
15748  if (!node->nd_next) return;
15749  void_expr0(node->nd_head);
15750  node = node->nd_next;
15751  }
15752 }
15753 
15754 static NODE *
15756 {
15757  NODE **n = &node, *n1 = node;
15758  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15759  *n = n1 = n1->nd_body;
15760  }
15761  return node;
15762 }
15763 
15764 static NODE *
15766 {
15767  NODE **n = &node, *n1 = node;
15768  while (n1 && nd_type(n1) == NODE_BEGIN) {
15769  *n = n1 = n1->nd_body;
15770  }
15771  return node;
15772 }
15773 
15774 static void
15775 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15776 {
15777  NODE *node = *body;
15778 
15779  if (!node) {
15780  *body = NEW_NIL();
15781  return;
15782  }
15783 #define subnodes(n1, n2) \
15784  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15785  (!node->n2) ? (body = &node->n1, 1) : \
15786  (reduce_nodes(&node->n1), body = &node->n2, 1))
15787 
15788  while (node) {
15789  int newline = (int)(node->flags & NODE_FL_NEWLINE);
15790  switch (nd_type(node)) {
15791  end:
15792  case NODE_NIL:
15793  *body = 0;
15794  return;
15795  case NODE_RETURN:
15796  *body = node = node->nd_stts;
15797  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15798  continue;
15799  case NODE_BEGIN:
15800  *body = node = node->nd_body;
15801  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15802  continue;
15803  case NODE_BLOCK:
15804  body = &node->nd_end->nd_head;
15805  break;
15806  case NODE_IF:
15807  if (subnodes(nd_body, nd_else)) break;
15808  return;
15809  case NODE_CASE:
15810  body = &node->nd_body;
15811  break;
15812  case NODE_WHEN:
15813  if (!subnodes(nd_body, nd_next)) goto end;
15814  break;
15815  case NODE_ENSURE:
15816  if (!subnodes(nd_head, nd_resq)) goto end;
15817  break;
15818  case NODE_RESCUE:
15819  if (node->nd_else) {
15820  body = &node->nd_resq;
15821  break;
15822  }
15823  if (!subnodes(nd_head, nd_resq)) goto end;
15824  break;
15825  default:
15826  return;
15827  }
15828  node = *body;
15829  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15830  }
15831 
15832 #undef subnodes
15833 }
15834 
15835 static int
15837 {
15838  if (!node) return 1;
15839  switch (nd_type(node)) {
15840  case NODE_HASH:
15841  if (!(node = node->nd_head)) break;
15842  case NODE_ARRAY:
15843  do {
15844  if (!is_static_content(node->nd_head)) return 0;
15845  } while ((node = node->nd_next) != 0);
15846  case NODE_LIT:
15847  case NODE_STR:
15848  case NODE_NIL:
15849  case NODE_TRUE:
15850  case NODE_FALSE:
15851  case NODE_ZARRAY:
15852  break;
15853  default:
15854  return 0;
15855  }
15856  return 1;
15857 }
15858 
15859 static int
15860 assign_in_cond(struct parser_params *parser, NODE *node)
15861 {
15862  switch (nd_type(node)) {
15863  case NODE_MASGN:
15864  yyerror("multiple assignment in conditional");
15865  return 1;
15866 
15867  case NODE_LASGN:
15868  case NODE_DASGN:
15869  case NODE_DASGN_CURR:
15870  case NODE_GASGN:
15871  case NODE_IASGN:
15872  break;
15873 
15874  default:
15875  return 0;
15876  }
15877 
15878  if (!node->nd_value) return 1;
15879  if (is_static_content(node->nd_value)) {
15880  /* reports always */
15881  parser_warn(node->nd_value, "found = in conditional, should be ==");
15882  }
15883  return 1;
15884 }
15885 
15886 static void
15887 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15888 {
15889  if (!e_option_supplied(parser)) parser_warn(node, str);
15890 }
15891 
15892 static void
15893 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15894 {
15895  if (!e_option_supplied(parser)) parser_warning(node, str);
15896 }
15897 
15898 static void
15899 fixup_nodes(NODE **rootnode)
15900 {
15901  NODE *node, *next, *head;
15902 
15903  for (node = *rootnode; node; node = next) {
15904  enum node_type type;
15905  VALUE val;
15906 
15907  next = node->nd_next;
15908  head = node->nd_head;
15909  rb_gc_force_recycle((VALUE)node);
15910  *rootnode = next;
15911  switch (type = nd_type(head)) {
15912  case NODE_DOT2:
15913  case NODE_DOT3:
15914  val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15915  type == NODE_DOT3);
15916  rb_gc_force_recycle((VALUE)head->nd_beg);
15917  rb_gc_force_recycle((VALUE)head->nd_end);
15918  nd_set_type(head, NODE_LIT);
15919  head->nd_lit = val;
15920  break;
15921  default:
15922  break;
15923  }
15924  }
15925 }
15926 
15927 static NODE *cond0(struct parser_params*,NODE*);
15928 
15929 static NODE*
15930 range_op(struct parser_params *parser, NODE *node)
15931 {
15932  enum node_type type;
15933 
15934  if (node == 0) return 0;
15935 
15936  type = nd_type(node);
15937  value_expr(node);
15938  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15939  warn_unless_e_option(parser, node, "integer literal in conditional range");
15940  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15941  }
15942  return cond0(parser, node);
15943 }
15944 
15945 static int
15947 {
15948  if (!node) return 1; /* same as NODE_NIL */
15949  switch (nd_type(node)) {
15950  case NODE_LIT:
15951  case NODE_STR:
15952  case NODE_DSTR:
15953  case NODE_EVSTR:
15954  case NODE_DREGX:
15955  case NODE_DREGX_ONCE:
15956  case NODE_DSYM:
15957  return 2;
15958  case NODE_TRUE:
15959  case NODE_FALSE:
15960  case NODE_NIL:
15961  return 1;
15962  }
15963  return 0;
15964 }
15965 
15966 static NODE*
15967 cond0(struct parser_params *parser, NODE *node)
15968 {
15969  if (node == 0) return 0;
15970  assign_in_cond(parser, node);
15971 
15972  switch (nd_type(node)) {
15973  case NODE_DSTR:
15974  case NODE_EVSTR:
15975  case NODE_STR:
15976  rb_warn0("string literal in condition");
15977  break;
15978 
15979  case NODE_DREGX:
15980  case NODE_DREGX_ONCE:
15981  warning_unless_e_option(parser, node, "regex literal in condition");
15982  return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15983 
15984  case NODE_AND:
15985  case NODE_OR:
15986  node->nd_1st = cond0(parser, node->nd_1st);
15987  node->nd_2nd = cond0(parser, node->nd_2nd);
15988  break;
15989 
15990  case NODE_DOT2:
15991  case NODE_DOT3:
15992  node->nd_beg = range_op(parser, node->nd_beg);
15993  node->nd_end = range_op(parser, node->nd_end);
15994  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15995  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15996  if (!e_option_supplied(parser)) {
15997  int b = literal_node(node->nd_beg);
15998  int e = literal_node(node->nd_end);
15999  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
16000  parser_warn(node, "range literal in condition");
16001  }
16002  }
16003  break;
16004 
16005  case NODE_DSYM:
16006  parser_warning(node, "literal in condition");
16007  break;
16008 
16009  case NODE_LIT:
16010  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
16011  warn_unless_e_option(parser, node, "regex literal in condition");
16012  nd_set_type(node, NODE_MATCH);
16013  }
16014  else {
16015  parser_warning(node, "literal in condition");
16016  }
16017  default:
16018  break;
16019  }
16020  return node;
16021 }
16022 
16023 static NODE*
16024 cond_gen(struct parser_params *parser, NODE *node)
16025 {
16026  if (node == 0) return 0;
16027  return cond0(parser, node);
16028 }
16029 
16030 static NODE*
16031 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
16032 {
16033  value_expr(left);
16034  if (left && (enum node_type)nd_type(left) == type) {
16035  NODE *node = left, *second;
16036  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
16037  node = second;
16038  }
16039  node->nd_2nd = NEW_NODE(type, second, right, 0);
16040  return left;
16041  }
16042  return NEW_NODE(type, left, right, 0);
16043 }
16044 
16045 static void
16046 no_blockarg(struct parser_params *parser, NODE *node)
16047 {
16048  if (node && nd_type(node) == NODE_BLOCK_PASS) {
16049  compile_error(PARSER_ARG "block argument should not be given");
16050  }
16051 }
16052 
16053 static NODE *
16054 ret_args_gen(struct parser_params *parser, NODE *node)
16055 {
16056  if (node) {
16057  no_blockarg(parser, node);
16058  if (nd_type(node) == NODE_ARRAY) {
16059  if (node->nd_next == 0) {
16060  node = node->nd_head;
16061  }
16062  else {
16063  nd_set_type(node, NODE_VALUES);
16064  }
16065  }
16066  }
16067  return node;
16068 }
16069 
16070 static NODE *
16071 new_yield_gen(struct parser_params *parser, NODE *node)
16072 {
16073  if (node) no_blockarg(parser, node);
16074 
16075  return NEW_YIELD(node);
16076 }
16077 
16078 static NODE*
16080 {
16081  switch (TYPE(node->nd_lit)) {
16082  case T_FIXNUM:
16083  node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
16084  break;
16085  case T_BIGNUM:
16086  case T_RATIONAL:
16087  case T_COMPLEX:
16088  node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
16089  break;
16090  case T_FLOAT:
16091 #if USE_FLONUM
16092  if (FLONUM_P(node->nd_lit)) {
16093  node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
16094  }
16095  else {
16096  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
16097  }
16098 #else
16099  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
16100 #endif
16101  break;
16102  default:
16103  rb_bug("unknown literal type passed to negate_lit");
16104  break;
16105  }
16106  return node;
16107 }
16108 
16109 static NODE *
16110 arg_blk_pass(NODE *node1, NODE *node2)
16111 {
16112  if (node2) {
16113  node2->nd_head = node1;
16114  return node2;
16115  }
16116  return node1;
16117 }
16118 
16119 
16120 static NODE*
16121 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
16122 {
16123  int saved_line = ruby_sourceline;
16124  struct rb_args_info *args = tail->nd_ainfo;
16125 
16126  args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0;
16127  args->pre_init = m ? m->nd_next : 0;
16128 
16129  args->post_args_num = p ? rb_long2int(p->nd_plen) : 0;
16130  args->post_init = p ? p->nd_next : 0;
16131  args->first_post_arg = p ? p->nd_pid : 0;
16132 
16133  args->rest_arg = r;
16134 
16135  args->opt_args = o;
16136 
16137  ruby_sourceline = saved_line;
16138 
16139  return tail;
16140 }
16141 
16142 static NODE*
16143 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
16144 {
16145  int saved_line = ruby_sourceline;
16146  struct rb_args_info *args;
16147  NODE *kw_rest_arg = 0;
16148  NODE *node;
16149  int check = 0;
16150 
16151  args = ALLOC(struct rb_args_info);
16152  MEMZERO(args, struct rb_args_info, 1);
16153  node = NEW_NODE(NODE_ARGS, 0, 0, args);
16154 
16155  args->block_arg = b;
16156  args->kw_args = k;
16157  if (k && !kr) {
16158  check = 1;
16159  kr = internal_id();
16160  }
16161  if (kr) {
16162  arg_var(kr);
16163  kw_rest_arg = NEW_DVAR(kr);
16164  kw_rest_arg->nd_cflag = check;
16165  }
16166  args->kw_rest_arg = kw_rest_arg;
16167 
16168  ruby_sourceline = saved_line;
16169  return node;
16170 }
16171 
16172 static NODE*
16173 dsym_node_gen(struct parser_params *parser, NODE *node)
16174 {
16175  VALUE lit;
16176 
16177  if (!node) {
16178  return NEW_LIT(ID2SYM(idNULL));
16179  }
16180 
16181  switch (nd_type(node)) {
16182  case NODE_DSTR:
16183  nd_set_type(node, NODE_DSYM);
16184  break;
16185  case NODE_STR:
16186  lit = node->nd_lit;
16187  node->nd_lit = ID2SYM(rb_intern_str(lit));
16188  nd_set_type(node, NODE_LIT);
16189  break;
16190  default:
16191  node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
16192  break;
16193  }
16194  return node;
16195 }
16196 #endif /* !RIPPER */
16197 
16198 #ifndef RIPPER
16199 static NODE *
16200 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16201 {
16202  NODE *asgn;
16203 
16204  if (lhs) {
16205  ID vid = lhs->nd_vid;
16206  if (op == tOROP) {
16207  lhs->nd_value = rhs;
16208  asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
16209  if (is_asgn_or_id(vid)) {
16210  asgn->nd_aid = vid;
16211  }
16212  }
16213  else if (op == tANDOP) {
16214  lhs->nd_value = rhs;
16215  asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
16216  }
16217  else {
16218  asgn = lhs;
16219  asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
16220  }
16221  }
16222  else {
16223  asgn = NEW_BEGIN(0);
16224  }
16225  return asgn;
16226 }
16227 
16228 static NODE *
16229 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
16230 {
16231  NODE *asgn;
16232 
16233  if (op == tOROP) {
16234  op = 0;
16235  }
16236  else if (op == tANDOP) {
16237  op = 1;
16238  }
16239  asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
16240  fixpos(asgn, lhs);
16241  return asgn;
16242 }
16243 
16244 static NODE *
16245 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16246 {
16247  NODE *asgn;
16248 
16249  if (op == tOROP) {
16250  op = 0;
16251  }
16252  else if (op == tANDOP) {
16253  op = 1;
16254  }
16255  if (lhs) {
16256  asgn = NEW_OP_CDECL(lhs, op, rhs);
16257  }
16258  else {
16259  asgn = NEW_BEGIN(0);
16260  }
16261  fixpos(asgn, lhs);
16262  return asgn;
16263 }
16264 #else
16265 static VALUE
16266 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
16267 {
16268  return dispatch3(opassign, lhs, op, rhs);
16269 }
16270 
16271 static VALUE
16272 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
16273 {
16274  VALUE recv = dispatch3(field, lhs, type, attr);
16275  return dispatch3(opassign, recv, op, rhs);
16276 }
16277 #endif
16278 
16279 static void
16280 warn_unused_var(struct parser_params *parser, struct local_vars *local)
16281 {
16282  int i, cnt;
16283  ID *v, *u;
16284 
16285  if (!local->used) return;
16286  v = local->vars->tbl;
16287  u = local->used->tbl;
16288  cnt = local->used->pos;
16289  if (cnt != local->vars->pos) {
16290  rb_bug("local->used->pos != local->vars->pos");
16291  }
16292  for (i = 0; i < cnt; ++i) {
16293  if (!v[i] || (u[i] & LVAR_USED)) continue;
16294  if (is_private_local_id(v[i])) continue;
16295  rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
16296  }
16297 }
16298 
16299 static void
16300 local_push_gen(struct parser_params *parser, int inherit_dvars)
16301 {
16302  struct local_vars *local;
16303 
16304  local = ALLOC(struct local_vars);
16305  local->prev = lvtbl;
16306  local->args = vtable_alloc(0);
16307  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
16308  local->used = !(inherit_dvars &&
16310  RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
16311  local->cmdargs = cmdarg_stack;
16312  cmdarg_stack = 0;
16313  lvtbl = local;
16314 }
16315 
16316 static void
16318 {
16319  struct local_vars *local = lvtbl->prev;
16320  if (lvtbl->used) {
16321  warn_unused_var(parser, lvtbl);
16322  vtable_free(lvtbl->used);
16323  }
16324  vtable_free(lvtbl->args);
16325  vtable_free(lvtbl->vars);
16326  cmdarg_stack = lvtbl->cmdargs;
16327  xfree(lvtbl);
16328  lvtbl = local;
16329 }
16330 
16331 #ifndef RIPPER
16332 static ID*
16334 {
16335  int cnt_args = vtable_size(lvtbl->args);
16336  int cnt_vars = vtable_size(lvtbl->vars);
16337  int cnt = cnt_args + cnt_vars;
16338  int i, j;
16339  ID *buf;
16340 
16341  if (cnt <= 0) return 0;
16342  buf = ALLOC_N(ID, cnt + 1);
16343  MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args);
16344  /* remove IDs duplicated to warn shadowing */
16345  for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
16346  ID id = lvtbl->vars->tbl[i];
16347  if (!vtable_included(lvtbl->args, id)) {
16348  buf[j++] = id;
16349  }
16350  }
16351  if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1);
16352  buf[0] = cnt;
16353  return buf;
16354 }
16355 #endif
16356 
16357 static int
16358 arg_var_gen(struct parser_params *parser, ID id)
16359 {
16360  vtable_add(lvtbl->args, id);
16361  return vtable_size(lvtbl->args) - 1;
16362 }
16363 
16364 static int
16365 local_var_gen(struct parser_params *parser, ID id)
16366 {
16367  vtable_add(lvtbl->vars, id);
16368  if (lvtbl->used) {
16370  }
16371  return vtable_size(lvtbl->vars) - 1;
16372 }
16373 
16374 static int
16375 local_id_gen(struct parser_params *parser, ID id)
16376 {
16377  struct vtable *vars, *args, *used;
16378 
16379  vars = lvtbl->vars;
16380  args = lvtbl->args;
16381  used = lvtbl->used;
16382 
16383  while (vars && POINTER_P(vars->prev)) {
16384  vars = vars->prev;
16385  args = args->prev;
16386  if (used) used = used->prev;
16387  }
16388 
16389  if (vars && vars->prev == DVARS_INHERIT) {
16390  return rb_local_defined(id);
16391  }
16392  else if (vtable_included(args, id)) {
16393  return 1;
16394  }
16395  else {
16396  int i = vtable_included(vars, id);
16397  if (i && used) used->tbl[i-1] |= LVAR_USED;
16398  return i != 0;
16399  }
16400 }
16401 
16402 static const struct vtable *
16404 {
16405  lvtbl->args = vtable_alloc(lvtbl->args);
16406  lvtbl->vars = vtable_alloc(lvtbl->vars);
16407  if (lvtbl->used) {
16408  lvtbl->used = vtable_alloc(lvtbl->used);
16409  }
16410  return lvtbl->args;
16411 }
16412 
16413 static void
16414 dyna_pop_1(struct parser_params *parser)
16415 {
16416  struct vtable *tmp;
16417 
16418  if ((tmp = lvtbl->used) != 0) {
16419  warn_unused_var(parser, lvtbl);
16420  lvtbl->used = lvtbl->used->prev;
16421  vtable_free(tmp);
16422  }
16423  tmp = lvtbl->args;
16424  lvtbl->args = lvtbl->args->prev;
16425  vtable_free(tmp);
16426  tmp = lvtbl->vars;
16427  lvtbl->vars = lvtbl->vars->prev;
16428  vtable_free(tmp);
16429 }
16430 
16431 static void
16432 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16433 {
16434  while (lvtbl->args != lvargs) {
16435  dyna_pop_1(parser);
16436  if (!lvtbl->args) {
16437  struct local_vars *local = lvtbl->prev;
16438  xfree(lvtbl);
16439  lvtbl = local;
16440  }
16441  }
16442  dyna_pop_1(parser);
16443 }
16444 
16445 static int
16447 {
16448  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16449 }
16450 
16451 static int
16452 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16453 {
16454  struct vtable *vars, *args, *used;
16455  int i;
16456 
16457  args = lvtbl->args;
16458  vars = lvtbl->vars;
16459  used = lvtbl->used;
16460 
16461  while (POINTER_P(vars)) {
16462  if (vtable_included(args, id)) {
16463  return 1;
16464  }
16465  if ((i = vtable_included(vars, id)) != 0) {
16466  if (used) used->tbl[i-1] |= LVAR_USED;
16467  return 1;
16468  }
16469  args = args->prev;
16470  vars = vars->prev;
16471  if (get) used = 0;
16472  if (used) used = used->prev;
16473  }
16474 
16475  if (vars == DVARS_INHERIT) {
16476  return rb_dvar_defined(id);
16477  }
16478 
16479  return 0;
16480 }
16481 
16482 static int
16483 dvar_curr_gen(struct parser_params *parser, ID id)
16484 {
16485  return (vtable_included(lvtbl->args, id) ||
16486  vtable_included(lvtbl->vars, id));
16487 }
16488 
16489 #ifndef RIPPER
16490 static void
16492 {
16493  int c = RE_OPTION_ENCODING_IDX(options);
16494 
16495  if (c) {
16496  int opt, idx;
16497  rb_char_to_option_kcode(c, &opt, &idx);
16498  if (idx != ENCODING_GET(str) &&
16500  goto error;
16501  }
16502  ENCODING_SET(str, idx);
16503  }
16504  else if (RE_OPTION_ENCODING_NONE(options)) {
16505  if (!ENCODING_IS_ASCII8BIT(str) &&
16507  c = 'n';
16508  goto error;
16509  }
16511  }
16512  else if (current_enc == rb_usascii_encoding()) {
16514  /* raise in re.c */
16516  }
16517  else {
16519  }
16520  }
16521  return;
16522 
16523  error:
16525  "regexp encoding option '%c' differs from source encoding '%s'",
16526  c, rb_enc_name(rb_enc_get(str)));
16527 }
16528 
16529 static int
16531 {
16532  VALUE err;
16533  reg_fragment_setenc(str, options);
16534  err = rb_reg_check_preprocess(str);
16535  if (err != Qnil) {
16536  err = rb_obj_as_string(err);
16538  return 0;
16539  }
16540  return 1;
16541 }
16542 
16543 typedef struct {
16548  int num;
16550 
16551 static int
16553  int back_num, int *back_refs, OnigRegex regex, void *arg0)
16554 {
16556  struct parser_params* parser = arg->parser;
16557  rb_encoding *enc = arg->enc;
16558  long len = name_end - name;
16559  const char *s = (const char *)name;
16560  ID var;
16561 
16562  arg->num++;
16563 
16564  if (arg->succ_block == 0) {
16565  arg->succ_block = NEW_BEGIN(0);
16566  arg->fail_block = NEW_BEGIN(0);
16567  }
16568 
16569  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16570  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16571  !rb_enc_symname2_p(s, len, enc)) {
16572  return ST_CONTINUE;
16573  }
16574  var = rb_intern3(s, len, enc);
16575  if (dvar_defined(var) || local_id(var)) {
16576  rb_warningS("named capture conflicts a local variable - %s",
16577  rb_id2name(var));
16578  }
16579  arg->succ_block = block_append(arg->succ_block,
16581  NEW_CALL(
16582  gettable(rb_intern("$~")),
16583  idAREF,
16584  NEW_LIST(NEW_LIT(ID2SYM(var))))
16585  )));
16586  arg->fail_block = block_append(arg->fail_block,
16588  return ST_CONTINUE;
16589 }
16590 
16591 static NODE *
16593 {
16595 
16596  arg.parser = parser;
16597  arg.enc = rb_enc_get(regexp);
16598  arg.succ_block = 0;
16599  arg.fail_block = 0;
16600  arg.num = 0;
16602 
16603  if (arg.num == 0)
16604  return match;
16605 
16606  return
16607  block_append(
16608  newline_node(match),
16609  NEW_IF(gettable(rb_intern("$~")),
16610  block_append(
16611  newline_node(arg.succ_block),
16612  newline_node(
16613  NEW_CALL(
16614  gettable(rb_intern("$~")),
16615  rb_intern("begin"),
16616  NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16617  block_append(
16618  newline_node(arg.fail_block),
16619  newline_node(
16620  NEW_LIT(Qnil)))));
16621 }
16622 
16623 static VALUE
16624 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16625 {
16626  VALUE re;
16627  VALUE err;
16628 
16629  reg_fragment_setenc(str, options);
16630  err = rb_errinfo();
16632  if (NIL_P(re)) {
16633  ID mesg = rb_intern("mesg");
16634  VALUE m = rb_attr_get(rb_errinfo(), mesg);
16635  rb_set_errinfo(err);
16636  if (!NIL_P(err)) {
16637  rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16638  }
16639  else {
16641  }
16642  return Qnil;
16643  }
16644  return re;
16645 }
16646 
16647 void
16649 {
16650 }
16651 
16652 NODE*
16654 {
16655  NODE *prelude = 0;
16656  NODE *scope = node;
16657  struct parser_params *parser;
16658 
16659  if (!node) return node;
16660 
16661  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16662 
16663  node = node->nd_body;
16664 
16665  if (nd_type(node) == NODE_PRELUDE) {
16666  prelude = node;
16667  node = node->nd_body;
16668  }
16669 
16670  node = block_append(node,
16671  NEW_FCALL(rb_intern("print"),
16672  NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16673  if (prelude) {
16674  prelude->nd_body = node;
16675  scope->nd_body = prelude;
16676  }
16677  else {
16678  scope->nd_body = node;
16679  }
16680 
16681  return scope;
16682 }
16683 
16684 NODE *
16685 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16686 {
16687  NODE *prelude = 0;
16688  NODE *scope = node;
16689  struct parser_params *parser;
16690 
16691  if (!node) return node;
16692 
16693  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16694 
16695  node = node->nd_body;
16696 
16697  if (nd_type(node) == NODE_PRELUDE) {
16698  prelude = node;
16699  node = node->nd_body;
16700  }
16701  if (split) {
16702  node = block_append(NEW_GASGN(rb_intern("$F"),
16703  NEW_CALL(NEW_GVAR(rb_intern("$_")),
16704  rb_intern("split"), 0)),
16705  node);
16706  }
16707  if (chop) {
16708  node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16709  rb_intern("chop!"), 0), node);
16710  }
16711 
16712  node = NEW_OPT_N(node);
16713 
16714  if (prelude) {
16715  prelude->nd_body = node;
16716  scope->nd_body = prelude;
16717  }
16718  else {
16719  scope->nd_body = node;
16720  }
16721 
16722  return scope;
16723 }
16724 
16725 static const struct {
16727  const char *name;
16728 } op_tbl[] = {
16729  {tDOT2, ".."},
16730  {tDOT3, "..."},
16731  {tPOW, "**"},
16732  {tDSTAR, "**"},
16733  {tUPLUS, "+@"},
16734  {tUMINUS, "-@"},
16735  {tCMP, "<=>"},
16736  {tGEQ, ">="},
16737  {tLEQ, "<="},
16738  {tEQ, "=="},
16739  {tEQQ, "==="},
16740  {tNEQ, "!="},
16741  {tMATCH, "=~"},
16742  {tNMATCH, "!~"},
16743  {tAREF, "[]"},
16744  {tASET, "[]="},
16745  {tLSHFT, "<<"},
16746  {tRSHFT, ">>"},
16747  {tCOLON2, "::"},
16748 };
16749 
16750 #define op_tbl_count numberof(op_tbl)
16751 
16752 #ifndef ENABLE_SELECTOR_NAMESPACE
16753 #define ENABLE_SELECTOR_NAMESPACE 0
16754 #endif
16755 
16756 static struct symbols {
16760 #if ENABLE_SELECTOR_NAMESPACE
16761  st_table *ivar2_id;
16762  st_table *id_ivar2;
16763 #endif
16767 
16768 static const struct st_hash_type symhash = {
16770  rb_str_hash,
16771 };
16772 
16773 #if ENABLE_SELECTOR_NAMESPACE
16774 struct ivar2_key {
16775  ID id;
16776  VALUE klass;
16777 };
16778 
16779 static int
16780 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16781 {
16782  if (key1->id == key2->id && key1->klass == key2->klass) {
16783  return 0;
16784  }
16785  return 1;
16786 }
16787 
16788 static int
16789 ivar2_hash(struct ivar2_key *key)
16790 {
16791  return (key->id << 8) ^ (key->klass >> 2);
16792 }
16793 
16794 static const struct st_hash_type ivar2_hash_type = {
16795  ivar2_cmp,
16796  ivar2_hash,
16797 };
16798 #endif
16799 
16800 void
16802 {
16803  global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
16805 #if ENABLE_SELECTOR_NAMESPACE
16806  global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16807  global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16808 #endif
16809 
16810  (void)nodetype;
16811  (void)nodeline;
16812 #if PARSER_DEBUG
16813  (void)lex_state_name(-1);
16814 #endif
16815 
16816  Init_id();
16817 }
16818 
16819 void
16820 rb_gc_mark_symbols(int full_mark)
16821 {
16822  if (full_mark || global_symbols.minor_marked == 0) {
16826 
16827  if (!full_mark) global_symbols.minor_marked = 1;
16828  }
16829 }
16830 #endif /* !RIPPER */
16831 
16832 static ID
16834 {
16835  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16836  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16837  return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16838 }
16839 
16840 #ifndef RIPPER
16841 static int
16842 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16843 {
16844  int mb = 0;
16845 
16846  if (m >= e) return 0;
16847  if (is_global_name_punct(*m)) {
16848  ++m;
16849  }
16850  else if (*m == '-') {
16851  if (++m >= e) return 0;
16852  if (is_identchar(m, e, enc)) {
16853  if (!ISASCII(*m)) mb = 1;
16854  m += rb_enc_mbclen(m, e, enc);
16855  }
16856  }
16857  else {
16858  if (!rb_enc_isdigit(*m, enc)) return 0;
16859  do {
16860  if (!ISASCII(*m)) mb = 1;
16861  ++m;
16862  } while (m < e && rb_enc_isdigit(*m, enc));
16863  }
16864  return m == e ? mb + 1 : 0;
16865 }
16866 
16867 int
16868 rb_symname_p(const char *name)
16869 {
16870  return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16871 }
16872 
16873 int
16874 rb_enc_symname_p(const char *name, rb_encoding *enc)
16875 {
16876  return rb_enc_symname2_p(name, strlen(name), enc);
16877 }
16878 
16879 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
16880 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<ID_SCOPE_MASK) & ~(1U<<ID_ATTRSET))
16881 
16882 static int
16883 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset)
16884 {
16885  const char *m = name;
16886  const char *e = m + len;
16887  int type = ID_JUNK;
16888 
16889  if (!m || len <= 0) return -1;
16890  switch (*m) {
16891  case '\0':
16892  return -1;
16893 
16894  case '$':
16895  type = ID_GLOBAL;
16896  if (is_special_global_name(++m, e, enc)) return type;
16897  goto id;
16898 
16899  case '@':
16900  type = ID_INSTANCE;
16901  if (*++m == '@') {
16902  ++m;
16903  type = ID_CLASS;
16904  }
16905  goto id;
16906 
16907  case '<':
16908  switch (*++m) {
16909  case '<': ++m; break;
16910  case '=': if (*++m == '>') ++m; break;
16911  default: break;
16912  }
16913  break;
16914 
16915  case '>':
16916  switch (*++m) {
16917  case '>': case '=': ++m; break;
16918  }
16919  break;
16920 
16921  case '=':
16922  switch (*++m) {
16923  case '~': ++m; break;
16924  case '=': if (*++m == '=') ++m; break;
16925  default: return -1;
16926  }
16927  break;
16928 
16929  case '*':
16930  if (*++m == '*') ++m;
16931  break;
16932 
16933  case '+': case '-':
16934  if (*++m == '@') ++m;
16935  break;
16936 
16937  case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16938  ++m;
16939  break;
16940 
16941  case '[':
16942  if (*++m != ']') return -1;
16943  if (*++m == '=') ++m;
16944  break;
16945 
16946  case '!':
16947  if (len == 1) return ID_JUNK;
16948  switch (*++m) {
16949  case '=': case '~': ++m; break;
16950  default: return -1;
16951  }
16952  break;
16953 
16954  default:
16955  type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16956  id:
16957  if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16958  return -1;
16959  while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16960  if (m >= e) break;
16961  switch (*m) {
16962  case '!': case '?':
16963  if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16964  type = ID_JUNK;
16965  ++m;
16966  break;
16967  case '=':
16968  if (!(allowed_attrset & (1U << type))) return -1;
16969  type = ID_ATTRSET;
16970  ++m;
16971  break;
16972  }
16973  break;
16974  }
16975  return m == e ? type : -1;
16976 }
16977 
16978 int
16979 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16980 {
16981  return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
16982 }
16983 
16984 static int
16985 rb_str_symname_type(VALUE name, unsigned int allowed_attrset)
16986 {
16987  const char *ptr = StringValuePtr(name);
16988  long len = RSTRING_LEN(name);
16989  int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_attrset);
16990  RB_GC_GUARD(name);
16991  return type;
16992 }
16993 
16994 static ID
16995 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16996 {
16997  VALUE str = rb_enc_str_new(name, len, enc);
16998  return register_symid_str(id, str);
16999 }
17000 
17001 static ID
17003 {
17004  OBJ_FREEZE(str);
17005  str = rb_fstring(str);
17006 
17009  }
17010 
17014  return id;
17015 }
17016 
17017 static int
17019 {
17020  if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
17021  switch (rb_enc_str_coderange(str)) {
17022  case ENC_CODERANGE_BROKEN:
17023  rb_raise(rb_eEncodingError, "invalid encoding symbol");
17024  case ENC_CODERANGE_7BIT:
17025  return TRUE;
17026  }
17027  return FALSE;
17028 }
17029 
17030 /*
17031  * _str_ itself will be registered at the global symbol table. _str_
17032  * can be modified before the registration, since the encoding will be
17033  * set to ASCII-8BIT if it is a special global name.
17034  */
17035 static ID intern_str(VALUE str);
17036 
17037 static VALUE
17038 setup_fake_str(struct RString *fake_str, const char *name, long len)
17039 {
17040  fake_str->basic.flags = T_STRING|RSTRING_NOEMBED;
17042  fake_str->as.heap.len = len;
17043  fake_str->as.heap.ptr = (char *)name;
17044  fake_str->as.heap.aux.capa = len;
17045  return (VALUE)fake_str;
17046 }
17047 
17048 ID
17049 rb_intern3(const char *name, long len, rb_encoding *enc)
17050 {
17051  st_data_t data;
17052  struct RString fake_str;
17053  VALUE str = setup_fake_str(&fake_str, name, len);
17054  rb_enc_associate(str, enc);
17055  OBJ_FREEZE(str);
17056 
17057  if (st_lookup(global_symbols.sym_id, str, &data))
17058  return (ID)data;
17059 
17060  str = rb_enc_str_new(name, len, enc); /* make true string */
17061  return intern_str(str);
17062 }
17063 
17064 static ID
17066 {
17067  const char *name, *m, *e;
17068  long len, last;
17069  rb_encoding *enc, *symenc;
17070  unsigned char c;
17071  ID id;
17072  int mb;
17073 
17074  RSTRING_GETMEM(str, name, len);
17075  m = name;
17076  e = m + len;
17077  enc = rb_enc_get(str);
17078  symenc = enc;
17079 
17080  if (!len || (rb_cString && !rb_enc_asciicompat(enc))) {
17081  junk:
17082  id = ID_JUNK;
17083  goto new_id;
17084  }
17085  last = len-1;
17086  id = 0;
17087  switch (*m) {
17088  case '$':
17089  if (len < 2) goto junk;
17090  id |= ID_GLOBAL;
17091  if ((mb = is_special_global_name(++m, e, enc)) != 0) {
17092  if (!--mb) symenc = rb_usascii_encoding();
17093  goto new_id;
17094  }
17095  break;
17096  case '@':
17097  if (m[1] == '@') {
17098  if (len < 3) goto junk;
17099  m++;
17100  id |= ID_CLASS;
17101  }
17102  else {
17103  if (len < 2) goto junk;
17104  id |= ID_INSTANCE;
17105  }
17106  m++;
17107  break;
17108  default:
17109  c = m[0];
17110  if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
17111  /* operators */
17112  int i;
17113 
17114  if (len == 1) {
17115  id = c;
17116  goto id_register;
17117  }
17118  for (i = 0; i < op_tbl_count; i++) {
17119  if (*op_tbl[i].name == *m &&
17120  strcmp(op_tbl[i].name, m) == 0) {
17121  id = op_tbl[i].token;
17122  goto id_register;
17123  }
17124  }
17125  }
17126  break;
17127  }
17128  if (name[last] == '=') {
17129  /* attribute assignment */
17130  if (last > 1 && name[last-1] == '=')
17131  goto junk;
17132  id = rb_intern3(name, last, enc);
17133  if (id > tLAST_OP_ID && !is_attrset_id(id)) {
17134  enc = rb_enc_get(rb_id2str(id));
17135  id = rb_id_attrset(id);
17136  goto id_register;
17137  }
17138  id = ID_ATTRSET;
17139  }
17140  else if (id == 0) {
17141  if (rb_enc_isupper(m[0], enc)) {
17142  id = ID_CONST;
17143  }
17144  else {
17145  id = ID_LOCAL;
17146  }
17147  }
17148  if (!rb_enc_isdigit(*m, enc)) {
17149  while (m <= name + last && is_identchar(m, e, enc)) {
17150  if (ISASCII(*m)) {
17151  m++;
17152  }
17153  else {
17154  m += rb_enc_mbclen(m, e, enc);
17155  }
17156  }
17157  }
17158  if (id != ID_ATTRSET && m - name < len) id = ID_JUNK;
17159  if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
17160  new_id:
17161  if (symenc != enc) rb_enc_associate(str, symenc);
17163  if (len > 20) {
17164  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
17165  name);
17166  }
17167  else {
17168  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
17169  (int)len, name);
17170  }
17171  }
17173  id_register:
17174  return register_symid_str(id, str);
17175 }
17176 
17177 ID
17178 rb_intern2(const char *name, long len)
17179 {
17180  return rb_intern3(name, len, rb_usascii_encoding());
17181 }
17182 
17183 #undef rb_intern
17184 ID
17185 rb_intern(const char *name)
17186 {
17187  return rb_intern2(name, strlen(name));
17188 }
17189 
17190 ID
17192 {
17193  st_data_t id;
17194 
17195  if (st_lookup(global_symbols.sym_id, str, &id))
17196  return (ID)id;
17197  return intern_str(rb_str_dup(str));
17198 }
17199 
17200 VALUE
17202 {
17203  st_data_t data;
17204 
17205  if (id < tLAST_TOKEN) {
17206  int i = 0;
17207 
17208  if (id < INT_MAX && rb_ispunct((int)id)) {
17209  VALUE str = global_symbols.op_sym[i = (int)id];
17210  if (!str) {
17211  char name[2];
17212  name[0] = (char)id;
17213  name[1] = 0;
17214  str = rb_usascii_str_new(name, 1);
17215  OBJ_FREEZE(str);
17216  str = rb_fstring(str);
17219  }
17220  return str;
17221  }
17222  for (i = 0; i < op_tbl_count; i++) {
17223  if (op_tbl[i].token == id) {
17224  VALUE str = global_symbols.op_sym[i];
17225  if (!str) {
17226  str = rb_usascii_str_new2(op_tbl[i].name);
17227  OBJ_FREEZE(str);
17228  str = rb_fstring(str);
17231  }
17232  return str;
17233  }
17234  }
17235  }
17236 
17237  if (st_lookup(global_symbols.id_str, id, &data)) {
17238  VALUE str = (VALUE)data;
17239  if (RBASIC(str)->klass == 0)
17241  return str;
17242  }
17243 
17244  if (is_attrset_id(id)) {
17245  ID id_stem = (id & ~ID_SCOPE_MASK);
17246  VALUE str;
17247 
17248  do {
17249  if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break;
17250  if (!!(str = rb_id2str(id_stem | ID_CONST))) break;
17251  if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break;
17252  if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break;
17253  if (!!(str = rb_id2str(id_stem | ID_CLASS))) break;
17254  if (!!(str = rb_id2str(id_stem | ID_JUNK))) break;
17255  return 0;
17256  } while (0);
17257  str = rb_str_dup(str);
17258  rb_str_cat(str, "=", 1);
17259  register_symid_str(id, str);
17260  if (st_lookup(global_symbols.id_str, id, &data)) {
17261  VALUE str = (VALUE)data;
17262  if (RBASIC(str)->klass == 0)
17264  return str;
17265  }
17266  }
17267  return 0;
17268 }
17269 
17270 const char *
17272 {
17273  VALUE str = rb_id2str(id);
17274 
17275  if (!str) return 0;
17276  return RSTRING_PTR(str);
17277 }
17278 
17279 static int
17281 {
17282  rb_ary_push(ary, ID2SYM(value));
17283  return ST_CONTINUE;
17284 }
17285 
17286 /*
17287  * call-seq:
17288  * Symbol.all_symbols => array
17289  *
17290  * Returns an array of all the symbols currently in Ruby's symbol
17291  * table.
17292  *
17293  * Symbol.all_symbols.size #=> 903
17294  * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
17295  * :chown, :EOFError, :$;, :String,
17296  * :LOCK_SH, :"setuid?", :$<,
17297  * :default_proc, :compact, :extend,
17298  * :Tms, :getwd, :$=, :ThreadGroup,
17299  * :wait2, :$>]
17300  */
17301 
17302 VALUE
17304 {
17306 
17308  return ary;
17309 }
17310 
17311 int
17313 {
17314  return is_const_id(id);
17315 }
17316 
17317 int
17319 {
17320  return is_class_id(id);
17321 }
17322 
17323 int
17325 {
17326  return is_global_id(id);
17327 }
17328 
17329 int
17331 {
17332  return is_instance_id(id);
17333 }
17334 
17335 int
17337 {
17338  return is_attrset_id(id);
17339 }
17340 
17341 int
17343 {
17344  return is_local_id(id);
17345 }
17346 
17347 int
17349 {
17350  return is_junk_id(id);
17351 }
17352 
17364 ID
17365 rb_check_id(volatile VALUE *namep)
17366 {
17367  st_data_t id;
17368  VALUE tmp;
17369  VALUE name = *namep;
17370 
17371  if (SYMBOL_P(name)) {
17372  return SYM2ID(name);
17373  }
17374  else if (!RB_TYPE_P(name, T_STRING)) {
17375  tmp = rb_check_string_type(name);
17376  if (NIL_P(tmp)) {
17377  tmp = rb_inspect(name);
17378  rb_raise(rb_eTypeError, "%s is not a symbol",
17379  RSTRING_PTR(tmp));
17380  }
17381  name = tmp;
17382  *namep = name;
17383  }
17384 
17385  sym_check_asciionly(name);
17386 
17387  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17388  return (ID)id;
17389 
17390  if (rb_is_attrset_name(name)) {
17391  struct RString fake_str;
17392  /* make local name by chopping '=' */
17393  const VALUE localname = setup_fake_str(&fake_str, RSTRING_PTR(name), RSTRING_LEN(name) - 1);
17394  rb_enc_copy(localname, name);
17395  OBJ_FREEZE(localname);
17396 
17397  if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17398  return rb_id_attrset((ID)id);
17399  }
17400  RB_GC_GUARD(name);
17401  }
17402 
17403  return (ID)0;
17404 }
17405 
17406 ID
17408 {
17409  st_data_t id;
17410  struct RString fake_str;
17411  const VALUE name = setup_fake_str(&fake_str, ptr, len);
17412  rb_enc_associate(name, enc);
17413 
17414  sym_check_asciionly(name);
17415 
17416  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17417  return (ID)id;
17418 
17419  if (rb_is_attrset_name(name)) {
17420  fake_str.as.heap.len = len - 1;
17421  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
17422  return rb_id_attrset((ID)id);
17423  }
17424  }
17425 
17426  return (ID)0;
17427 }
17428 
17429 int
17431 {
17432  return rb_str_symname_type(name, 0) == ID_CONST;
17433 }
17434 
17435 int
17437 {
17438  return rb_str_symname_type(name, 0) == ID_CLASS;
17439 }
17440 
17441 int
17443 {
17444  return rb_str_symname_type(name, 0) == ID_GLOBAL;
17445 }
17446 
17447 int
17449 {
17450  return rb_str_symname_type(name, 0) == ID_INSTANCE;
17451 }
17452 
17453 int
17455 {
17457 }
17458 
17459 int
17461 {
17462  return rb_str_symname_type(name, 0) == ID_LOCAL;
17463 }
17464 
17465 int
17467 {
17468  switch (rb_str_symname_type(name, 0)) {
17469  case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17470  return TRUE;
17471  }
17472  return FALSE;
17473 }
17474 
17475 int
17477 {
17478  return rb_str_symname_type(name, IDSET_ATTRSET_FOR_SYNTAX) == -1;
17479 }
17480 
17481 #endif /* !RIPPER */
17482 
17483 static void
17485 {
17486  parser->eofp = Qfalse;
17487 
17488  parser->parser_lex_strterm = 0;
17489  parser->parser_cond_stack = 0;
17490  parser->parser_cmdarg_stack = 0;
17491  parser->parser_class_nest = 0;
17492  parser->parser_paren_nest = 0;
17493  parser->parser_lpar_beg = 0;
17494  parser->parser_brace_nest = 0;
17495  parser->parser_in_single = 0;
17496  parser->parser_in_def = 0;
17497  parser->parser_in_defined = 0;
17498  parser->parser_in_kwarg = 0;
17499  parser->parser_compile_for_eval = 0;
17500  parser->parser_cur_mid = 0;
17501  parser->parser_tokenbuf = NULL;
17502  parser->parser_tokidx = 0;
17503  parser->parser_toksiz = 0;
17504  parser->parser_heredoc_end = 0;
17505  parser->parser_command_start = TRUE;
17506  parser->parser_deferred_nodes = 0;
17507  parser->parser_lex_pbeg = 0;
17508  parser->parser_lex_p = 0;
17509  parser->parser_lex_pend = 0;
17510  parser->parser_lvtbl = 0;
17511  parser->parser_ruby__end__seen = 0;
17512  parser->parser_ruby_sourcefile = 0;
17514 #ifndef RIPPER
17515  parser->is_ripper = 0;
17516  parser->parser_eval_tree_begin = 0;
17517  parser->parser_eval_tree = 0;
17518 #else
17519  parser->is_ripper = 1;
17520  parser->delayed = Qnil;
17521 
17522  parser->result = Qnil;
17523  parser->parsing_thread = Qnil;
17524  parser->toplevel_p = TRUE;
17525 #endif
17526 #ifdef YYMALLOC
17527  parser->heap = NULL;
17528 #endif
17529  parser->enc = rb_utf8_encoding();
17530 }
17531 
17532 #ifdef RIPPER
17533 #define parser_mark ripper_parser_mark
17534 #define parser_free ripper_parser_free
17535 #endif
17536 
17537 static void
17539 {
17540  struct parser_params *p = (struct parser_params*)ptr;
17541 
17548 #ifndef RIPPER
17551  rb_gc_mark(p->debug_lines);
17552 #else
17553  rb_gc_mark(p->delayed);
17554  rb_gc_mark(p->value);
17555  rb_gc_mark(p->result);
17556  rb_gc_mark(p->parsing_thread);
17557 #endif
17558 #ifdef YYMALLOC
17559  rb_gc_mark((VALUE)p->heap);
17560 #endif
17561 }
17562 
17563 static void
17565 {
17566  struct parser_params *p = (struct parser_params*)ptr;
17567  struct local_vars *local, *prev;
17568 
17569  if (p->parser_tokenbuf) {
17570  xfree(p->parser_tokenbuf);
17571  }
17572  for (local = p->parser_lvtbl; local; local = prev) {
17573  if (local->vars) xfree(local->vars);
17574  prev = local->prev;
17575  xfree(local);
17576  }
17577  xfree(p);
17578 }
17579 
17580 static size_t
17581 parser_memsize(const void *ptr)
17582 {
17583  struct parser_params *p = (struct parser_params*)ptr;
17584  struct local_vars *local;
17585  size_t size = sizeof(*p);
17586 
17587  if (!ptr) return 0;
17588  size += p->parser_toksiz;
17589  for (local = p->parser_lvtbl; local; local = local->prev) {
17590  size += sizeof(*local);
17591  if (local->vars) size += local->vars->capa * sizeof(ID);
17592  }
17593  return size;
17594 }
17595 
17596 static
17597 #ifndef RIPPER
17598 const
17599 #endif
17600 rb_data_type_t parser_data_type = {
17601  "parser",
17602  {
17603  parser_mark,
17604  parser_free,
17606  },
17608 };
17609 
17610 #ifndef RIPPER
17611 #undef rb_reserved_word
17612 
17613 const struct kwtable *
17614 rb_reserved_word(const char *str, unsigned int len)
17615 {
17616  return reserved_word(str, len);
17617 }
17618 
17619 static struct parser_params *
17621 {
17622  struct parser_params *p;
17623 
17624  p = ALLOC_N(struct parser_params, 1);
17625  MEMZERO(p, struct parser_params, 1);
17626  parser_initialize(p);
17627  return p;
17628 }
17629 
17630 VALUE
17632 {
17633  struct parser_params *p = parser_new();
17634 
17635  return TypedData_Wrap_Struct(0, &parser_data_type, p);
17636 }
17637 
17638 /*
17639  * call-seq:
17640  * ripper#end_seen? -> Boolean
17641  *
17642  * Return true if parsed source ended by +\_\_END\_\_+.
17643  */
17644 VALUE
17646 {
17647  struct parser_params *parser;
17648 
17649  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17650  return ruby__end__seen ? Qtrue : Qfalse;
17651 }
17652 
17653 /*
17654  * call-seq:
17655  * ripper#encoding -> encoding
17656  *
17657  * Return encoding of the source.
17658  */
17659 VALUE
17661 {
17662  struct parser_params *parser;
17663 
17664  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17666 }
17667 
17668 /*
17669  * call-seq:
17670  * ripper.yydebug -> true or false
17671  *
17672  * Get yydebug.
17673  */
17674 VALUE
17676 {
17677  struct parser_params *parser;
17678 
17679  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17680  return yydebug ? Qtrue : Qfalse;
17681 }
17682 
17683 /*
17684  * call-seq:
17685  * ripper.yydebug = flag
17686  *
17687  * Set yydebug.
17688  */
17689 VALUE
17691 {
17692  struct parser_params *parser;
17693 
17694  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17695  yydebug = RTEST(flag);
17696  return flag;
17697 }
17698 
17699 #ifdef YYMALLOC
17700 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17701 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17702 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17703  (n)->u3.cnt = (c), (p))
17704 
17705 void *
17706 rb_parser_malloc(struct parser_params *parser, size_t size)
17707 {
17708  size_t cnt = HEAPCNT(1, size);
17709  NODE *n = NEWHEAP();
17710  void *ptr = xmalloc(size);
17711 
17712  return ADD2HEAP(n, cnt, ptr);
17713 }
17714 
17715 void *
17716 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17717 {
17718  size_t cnt = HEAPCNT(nelem, size);
17719  NODE *n = NEWHEAP();
17720  void *ptr = xcalloc(nelem, size);
17721 
17722  return ADD2HEAP(n, cnt, ptr);
17723 }
17724 
17725 void *
17726 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17727 {
17728  NODE *n;
17729  size_t cnt = HEAPCNT(1, size);
17730 
17731  if (ptr && (n = parser->heap) != NULL) {
17732  do {
17733  if (n->u1.node == ptr) {
17734  n->u1.node = ptr = xrealloc(ptr, size);
17735  if (n->u3.cnt) n->u3.cnt = cnt;
17736  return ptr;
17737  }
17738  } while ((n = n->u2.node) != NULL);
17739  }
17740  n = NEWHEAP();
17741  ptr = xrealloc(ptr, size);
17742  return ADD2HEAP(n, cnt, ptr);
17743 }
17744 
17745 void
17746 rb_parser_free(struct parser_params *parser, void *ptr)
17747 {
17748  NODE **prev = &parser->heap, *n;
17749 
17750  while ((n = *prev) != NULL) {
17751  if (n->u1.node == ptr) {
17752  *prev = n->u2.node;
17754  break;
17755  }
17756  prev = &n->u2.node;
17757  }
17758  xfree(ptr);
17759 }
17760 #endif
17761 #endif
17762 
17763 #ifdef RIPPER
17764 #ifdef RIPPER_DEBUG
17765 extern int rb_is_pointer_to_heap(VALUE);
17766 
17767 /* :nodoc: */
17768 static VALUE
17769 ripper_validate_object(VALUE self, VALUE x)
17770 {
17771  if (x == Qfalse) return x;
17772  if (x == Qtrue) return x;
17773  if (x == Qnil) return x;
17774  if (x == Qundef)
17775  rb_raise(rb_eArgError, "Qundef given");
17776  if (FIXNUM_P(x)) return x;
17777  if (SYMBOL_P(x)) return x;
17778  if (!rb_is_pointer_to_heap(x))
17779  rb_raise(rb_eArgError, "invalid pointer: %p", x);
17780  switch (BUILTIN_TYPE(x)) {
17781  case T_STRING:
17782  case T_OBJECT:
17783  case T_ARRAY:
17784  case T_BIGNUM:
17785  case T_FLOAT:
17786  case T_COMPLEX:
17787  case T_RATIONAL:
17788  return x;
17789  case T_NODE:
17790  if (nd_type(x) != NODE_LASGN) {
17791  rb_raise(rb_eArgError, "NODE given: %p", x);
17792  }
17793  return ((NODE *)x)->nd_rval;
17794  default:
17795  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17796  x, rb_obj_classname(x));
17797  }
17798  return x;
17799 }
17800 #endif
17801 
17802 #define validate(x) ((x) = get_value(x))
17803 
17804 static VALUE
17805 ripper_dispatch0(struct parser_params *parser, ID mid)
17806 {
17807  return rb_funcall(parser->value, mid, 0);
17808 }
17809 
17810 static VALUE
17811 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17812 {
17813  validate(a);
17814  return rb_funcall(parser->value, mid, 1, a);
17815 }
17816 
17817 static VALUE
17818 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17819 {
17820  validate(a);
17821  validate(b);
17822  return rb_funcall(parser->value, mid, 2, a, b);
17823 }
17824 
17825 static VALUE
17826 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17827 {
17828  validate(a);
17829  validate(b);
17830  validate(c);
17831  return rb_funcall(parser->value, mid, 3, a, b, c);
17832 }
17833 
17834 static VALUE
17835 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17836 {
17837  validate(a);
17838  validate(b);
17839  validate(c);
17840  validate(d);
17841  return rb_funcall(parser->value, mid, 4, a, b, c, d);
17842 }
17843 
17844 static VALUE
17845 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17846 {
17847  validate(a);
17848  validate(b);
17849  validate(c);
17850  validate(d);
17851  validate(e);
17852  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17853 }
17854 
17855 static VALUE
17856 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17857 {
17858  validate(a);
17859  validate(b);
17860  validate(c);
17861  validate(d);
17862  validate(e);
17863  validate(f);
17864  validate(g);
17865  return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17866 }
17867 
17868 static const struct kw_assoc {
17869  ID id;
17870  const char *name;
17871 } keyword_to_name[] = {
17872  {keyword_class, "class"},
17873  {keyword_module, "module"},
17874  {keyword_def, "def"},
17875  {keyword_undef, "undef"},
17876  {keyword_begin, "begin"},
17877  {keyword_rescue, "rescue"},
17878  {keyword_ensure, "ensure"},
17879  {keyword_end, "end"},
17880  {keyword_if, "if"},
17881  {keyword_unless, "unless"},
17882  {keyword_then, "then"},
17883  {keyword_elsif, "elsif"},
17884  {keyword_else, "else"},
17885  {keyword_case, "case"},
17886  {keyword_when, "when"},
17887  {keyword_while, "while"},
17888  {keyword_until, "until"},
17889  {keyword_for, "for"},
17890  {keyword_break, "break"},
17891  {keyword_next, "next"},
17892  {keyword_redo, "redo"},
17893  {keyword_retry, "retry"},
17894  {keyword_in, "in"},
17895  {keyword_do, "do"},
17896  {keyword_do_cond, "do"},
17897  {keyword_do_block, "do"},
17898  {keyword_return, "return"},
17899  {keyword_yield, "yield"},
17900  {keyword_super, "super"},
17901  {keyword_self, "self"},
17902  {keyword_nil, "nil"},
17903  {keyword_true, "true"},
17904  {keyword_false, "false"},
17905  {keyword_and, "and"},
17906  {keyword_or, "or"},
17907  {keyword_not, "not"},
17908  {modifier_if, "if"},
17909  {modifier_unless, "unless"},
17910  {modifier_while, "while"},
17911  {modifier_until, "until"},
17912  {modifier_rescue, "rescue"},
17913  {keyword_alias, "alias"},
17914  {keyword_defined, "defined?"},
17915  {keyword_BEGIN, "BEGIN"},
17916  {keyword_END, "END"},
17917  {keyword__LINE__, "__LINE__"},
17918  {keyword__FILE__, "__FILE__"},
17919  {keyword__ENCODING__, "__ENCODING__"},
17920  {0, NULL}
17921 };
17922 
17923 static const char*
17924 keyword_id_to_str(ID id)
17925 {
17926  const struct kw_assoc *a;
17927 
17928  for (a = keyword_to_name; a->id; a++) {
17929  if (a->id == id)
17930  return a->name;
17931  }
17932  return NULL;
17933 }
17934 
17935 #undef ripper_id2sym
17936 static VALUE
17937 ripper_id2sym(ID id)
17938 {
17939  const char *name;
17940  char buf[8];
17941 
17942  if (id <= 256) {
17943  buf[0] = (char)id;
17944  buf[1] = '\0';
17945  return ID2SYM(rb_intern2(buf, 1));
17946  }
17947  if ((name = keyword_id_to_str(id))) {
17948  return ID2SYM(rb_intern(name));
17949  }
17950  switch (id) {
17951  case tOROP:
17952  name = "||";
17953  break;
17954  case tANDOP:
17955  name = "&&";
17956  break;
17957  default:
17958  name = rb_id2name(id);
17959  if (!name) {
17960  rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17961  }
17962  return ID2SYM(id);
17963  }
17964  return ID2SYM(rb_intern(name));
17965 }
17966 
17967 static ID
17968 ripper_get_id(VALUE v)
17969 {
17970  NODE *nd;
17971  if (!RB_TYPE_P(v, T_NODE)) return 0;
17972  nd = (NODE *)v;
17973  if (nd_type(nd) != NODE_LASGN) return 0;
17974  return nd->nd_vid;
17975 }
17976 
17977 static VALUE
17978 ripper_get_value(VALUE v)
17979 {
17980  NODE *nd;
17981  if (v == Qundef) return Qnil;
17982  if (!RB_TYPE_P(v, T_NODE)) return v;
17983  nd = (NODE *)v;
17984  if (nd_type(nd) != NODE_LASGN) return Qnil;
17985  return nd->nd_rval;
17986 }
17987 
17988 static void
17989 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17990 {
17991  VALUE str;
17992  va_list args;
17993 
17994  va_start(args, fmt);
17995  str = rb_vsprintf(fmt, args);
17996  va_end(args);
17997  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17998 }
17999 
18000 static void
18001 ripper_warn0(struct parser_params *parser, const char *fmt)
18002 {
18003  rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
18004 }
18005 
18006 static void
18007 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
18008 {
18009  rb_funcall(parser->value, rb_intern("warn"), 2,
18010  STR_NEW2(fmt), INT2NUM(a));
18011 }
18012 
18013 static void
18014 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
18015 {
18016  rb_funcall(parser->value, rb_intern("warn"), 2,
18017  STR_NEW2(fmt), STR_NEW2(str));
18018 }
18019 
18020 static void
18021 ripper_warning0(struct parser_params *parser, const char *fmt)
18022 {
18023  rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
18024 }
18025 
18026 static void
18027 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
18028 {
18029  rb_funcall(parser->value, rb_intern("warning"), 2,
18030  STR_NEW2(fmt), STR_NEW2(str));
18031 }
18032 
18033 static VALUE
18034 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
18035 {
18036  return rb_io_gets(src);
18037 }
18038 
18039 static VALUE
18040 ripper_s_allocate(VALUE klass)
18041 {
18042  struct parser_params *p;
18043  VALUE self;
18044 
18045  p = ALLOC_N(struct parser_params, 1);
18046  MEMZERO(p, struct parser_params, 1);
18047  self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
18048  p->value = self;
18049  return self;
18050 }
18051 
18052 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
18053 
18054 /*
18055  * call-seq:
18056  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
18057  *
18058  * Create a new Ripper object.
18059  * _src_ must be a String, an IO, or an Object which has #gets method.
18060  *
18061  * This method does not starts parsing.
18062  * See also Ripper#parse and Ripper.parse.
18063  */
18064 static VALUE
18065 ripper_initialize(int argc, VALUE *argv, VALUE self)
18066 {
18067  struct parser_params *parser;
18068  VALUE src, fname, lineno;
18069 
18070  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18071  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
18072  if (RB_TYPE_P(src, T_FILE)) {
18073  parser->parser_lex_gets = ripper_lex_get_generic;
18074  }
18075  else {
18076  StringValue(src);
18077  parser->parser_lex_gets = lex_get_str;
18078  }
18079  parser->parser_lex_input = src;
18080  parser->eofp = Qfalse;
18081  if (NIL_P(fname)) {
18082  fname = STR_NEW2("(ripper)");
18083  }
18084  else {
18085  StringValue(fname);
18086  }
18087  parser_initialize(parser);
18088 
18089  parser->parser_ruby_sourcefile_string = fname;
18090  parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
18091  parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
18092 
18093  return Qnil;
18094 }
18095 
18096 struct ripper_args {
18097  struct parser_params *parser;
18098  int argc;
18099  VALUE *argv;
18100 };
18101 
18102 static VALUE
18103 ripper_parse0(VALUE parser_v)
18104 {
18105  struct parser_params *parser;
18106 
18107  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
18108  parser_prepare(parser);
18109  ripper_yyparse((void*)parser);
18110  return parser->result;
18111 }
18112 
18113 static VALUE
18114 ripper_ensure(VALUE parser_v)
18115 {
18116  struct parser_params *parser;
18117 
18118  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
18119  parser->parsing_thread = Qnil;
18120  return Qnil;
18121 }
18122 
18123 /*
18124  * call-seq:
18125  * ripper#parse
18126  *
18127  * Start parsing and returns the value of the root action.
18128  */
18129 static VALUE
18130 ripper_parse(VALUE self)
18131 {
18132  struct parser_params *parser;
18133 
18134  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18135  if (!ripper_initialized_p(parser)) {
18136  rb_raise(rb_eArgError, "method called for uninitialized object");
18137  }
18138  if (!NIL_P(parser->parsing_thread)) {
18139  if (parser->parsing_thread == rb_thread_current())
18140  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
18141  else
18142  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
18143  }
18144  parser->parsing_thread = rb_thread_current();
18145  rb_ensure(ripper_parse0, self, ripper_ensure, self);
18146 
18147  return parser->result;
18148 }
18149 
18150 /*
18151  * call-seq:
18152  * ripper#column -> Integer
18153  *
18154  * Return column number of current parsing line.
18155  * This number starts from 0.
18156  */
18157 static VALUE
18158 ripper_column(VALUE self)
18159 {
18160  struct parser_params *parser;
18161  long col;
18162 
18163  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18164  if (!ripper_initialized_p(parser)) {
18165  rb_raise(rb_eArgError, "method called for uninitialized object");
18166  }
18167  if (NIL_P(parser->parsing_thread)) return Qnil;
18168  col = parser->tokp - parser->parser_lex_pbeg;
18169  return LONG2NUM(col);
18170 }
18171 
18172 /*
18173  * call-seq:
18174  * ripper#filename -> String
18175  *
18176  * Return current parsing filename.
18177  */
18178 static VALUE
18179 ripper_filename(VALUE self)
18180 {
18181  struct parser_params *parser;
18182 
18183  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18184  if (!ripper_initialized_p(parser)) {
18185  rb_raise(rb_eArgError, "method called for uninitialized object");
18186  }
18187  return parser->parser_ruby_sourcefile_string;
18188 }
18189 
18190 /*
18191  * call-seq:
18192  * ripper#lineno -> Integer
18193  *
18194  * Return line number of current parsing line.
18195  * This number starts from 1.
18196  */
18197 static VALUE
18198 ripper_lineno(VALUE self)
18199 {
18200  struct parser_params *parser;
18201 
18202  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18203  if (!ripper_initialized_p(parser)) {
18204  rb_raise(rb_eArgError, "method called for uninitialized object");
18205  }
18206  if (NIL_P(parser->parsing_thread)) return Qnil;
18207  return INT2NUM(parser->parser_ruby_sourceline);
18208 }
18209 
18210 #ifdef RIPPER_DEBUG
18211 /* :nodoc: */
18212 static VALUE
18213 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
18214 {
18215  StringValue(msg);
18216  if (obj == Qundef) {
18217  rb_raise(rb_eArgError, "%"PRIsVALUE, msg);
18218  }
18219  return Qnil;
18220 }
18221 
18222 /* :nodoc: */
18223 static VALUE
18224 ripper_value(VALUE self, VALUE obj)
18225 {
18226  return ULONG2NUM(obj);
18227 }
18228 #endif
18229 
18230 
18231 void
18232 Init_ripper(void)
18233 {
18234  parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
18235 
18238  /* ensure existing in symbol table */
18239  (void)rb_intern("||");
18240  (void)rb_intern("&&");
18241 
18242  InitVM(ripper);
18243 }
18244 
18245 void
18246 InitVM_ripper(void)
18247 {
18248  VALUE Ripper;
18249 
18250  Ripper = rb_define_class("Ripper", rb_cObject);
18251  /* version of Ripper */
18252  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
18253  rb_define_alloc_func(Ripper, ripper_s_allocate);
18254  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
18255  rb_define_method(Ripper, "parse", ripper_parse, 0);
18256  rb_define_method(Ripper, "column", ripper_column, 0);
18257  rb_define_method(Ripper, "filename", ripper_filename, 0);
18258  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
18259  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
18260  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
18261  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
18262  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
18263 #ifdef RIPPER_DEBUG
18264  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
18265  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
18266  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
18267 #endif
18268 
18271 
18272 # if 0
18273  /* Hack to let RDoc document SCRIPT_LINES__ */
18274 
18275  /*
18276  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
18277  * after the assignment will be added as an Array of lines with the file
18278  * name as the key.
18279  */
18280  rb_define_global_const("SCRIPT_LINES__", Qnil);
18281 #endif
18282 
18283 }
18284 #endif /* RIPPER */
18285 
VALUE data
Definition: tcltklib.c:3360
#define in_defined
Definition: ripper.c:383
#define rb_enc_islower(c, enc)
char * parser_ruby_sourcefile
Definition: ripper.c:328
#define RB_TYPE_P(obj, type)
VALUE val
Definition: parse.h:166
#define local_var(id)
Definition: ripper.c:564
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
Definition: ripper.y:20
#define cond(node)
Definition: ripper.c:427
#define deferred_nodes
Definition: ripper.c:396
#define nd_next
#define nd_type(n)
#define arg_var(id)
Definition: ripper.c:566
#define NEW_ARGSCAT(a, b)
#define NODE_DREGX_ONCE
#define ret_args(node)
Definition: ripper.c:479
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:1886
#define yyparse
Definition: ripper.c:421
stack_type cmdargs
Definition: ripper.c:193
#define ALLOC(type)
#define NEW_FALSE()
#define ISDIGIT(c)
Definition: ruby.h:1783
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: ripper.c:4735
enum lex_state_e state
Definition: lex.c:33
struct local_vars * parser_lvtbl
Definition: ripper.c:324
#define NODE_IF
VALUE rb_ary_unshift(VALUE ary, VALUE item)
Definition: array.c:1161
static ID ripper_token2eventid(int tok)
Definition: eventids2.c:279
#define NODE_RESCUE
Definition: lex.c:33
#define IS_LABEL_SUFFIX(n)
Definition: ripper.c:13545
union RString::@95 as
#define new_args_tail(k, kr, b)
Definition: ripper.c:475
#define YYSTACK_ALLOC
Definition: ripper.c:1054
int rb_is_attrset_id(ID id)
Definition: ripper.c:17336
int rb_enc_codelen(int c, rb_encoding *enc)
Definition: encoding.c:1014
#define NODE_RETRY
Definition: ripper.y:121
static double zero(void)
Definition: isinf.c:51
#define lex_input
Definition: ripper.c:388
#define lex_state
Definition: ripper.c:372
#define subnodes(n1, n2)
#define parser_precise_mbclen()
Definition: ripper.c:11760
static NODE * remove_begin(NODE *)
Definition: ripper.c:15755
#define NEW_STRTERM(func, term, paren)
Definition: ripper.c:12785
VALUE sym
Definition: tkutil.c:1299
static const yytype_int16 yydefgoto[]
Definition: ripper.c:1885
#define list_concat(h, t)
Definition: ripper.c:453
#define NODE_FALSE
#define NEW_DOT3(b, e)
case return tREGEXP_BEG
Definition: ripper.y:7790
static struct parser_params * parser_new(void)
Definition: ripper.c:17620
#define FLONUM_P(x)
VP_EXPORT int
Definition: bigdecimal.c:5172
#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:5297
#define yydebug
Definition: ripper.c:405
static char *char * yydest
Definition: ripper.c:4711
static NODE * arg_blk_pass(NODE *, NODE *)
Definition: ripper.c:16110
#define NEW_NTH_REF(n)
static ID internal_id_gen(struct parser_params *)
Definition: ripper.c:16833
Definition: ripper.y:117
void rb_bug(const char *fmt,...)
Definition: error.c:327
#define NEW_DASGN_CURR(v, val)
int num
Definition: parse.h:169
#define IS_END()
Definition: ripper.c:13541
struct token_info * next
Definition: ripper.c:275
#define ENC_SINGLE(cr)
Definition: ripper.c:365
void rb_enc_copy(VALUE obj1, VALUE obj2)
Definition: encoding.c:916
#define FALSE
Definition: nkf.h:174
static NODE * logop_gen(struct parser_params *, enum node_type, NODE *, NODE *)
Definition: ripper.c:16031
#define tail
Definition: st.c:108
Definition: ripper.y:110
void rb_mark_tbl(struct st_table *)
Definition: gc.c:3522
int minor_marked
Definition: ripper.c:16765
int rb_is_class_name(VALUE name)
Definition: ripper.c:17436
memo u1 value
Definition: enum.c:587
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:12135
static int comment_at_top(struct parser_params *parser)
Definition: ripper.c:13286
#define RE_OPTION_ENCODING_IDX(o)
Definition: ripper.c:591
#define rb_gc_mark_locations(start, end)
Definition: gc.c:3319
size_t strlen(const char *)
#define assignable(id, node)
Definition: ripper.c:489
yytype_int16 yyssa[YYINITDEPTH]
Definition: ripper.c:5008
static size_t parser_memsize(const void *ptr)
Definition: ripper.c:17581
VALUE parser_lex_nextline
Definition: ripper.c:315
VALUE rb_make_exception(int argc, VALUE *argv)
Definition: eval.c:682
#define STR_FUNC_ESCAPE
Definition: ripper.c:12159
#define scan_oct(s, l, e)
Definition: util.h:50
VALUE stack_type
Definition: ripper.c:164
const char * rb_obj_classname(VALUE)
Definition: variable.c:406
#define IDSET_ATTRSET_FOR_SYNTAX
Definition: ripper.c:16879
#define reg_compile(str, options)
Definition: ripper.c:518
VALUE rb_id2str(ID id)
Definition: ripper.c:17201
static NODE * call_uni_op_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:15180
#define toksiz
Definition: ripper.c:386
#define YY_(msgid)
Definition: ripper.c:986
int parser_ruby__end__seen
Definition: ripper.c:325
#define NODE_DSYM
int parser_command_start
Definition: ripper.c:320
static void fixpos(NODE *, NODE *)
Definition: ripper.c:14930
#define YYSTACK_FREE
Definition: ripper.c:1055
#define NEW_CALL(r, m, a)
int st_lookup(st_table *, st_data_t, st_data_t *)
void st_add_direct(st_table *, st_data_t, st_data_t)
Definition: st.c:629
#define nd_body
static void reduce_nodes_gen(struct parser_params *, NODE **)
Definition: ripper.c:15775
#define value_expr(node)
Definition: ripper.c:438
#define nd_paren(node)
Definition: ripper.c:605
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2281
#define NODE_HASH
struct RString::@95::@96 heap
#define NODE_DOT3
static NODE * call_bin_op_gen(struct parser_params *, NODE *, ID, NODE *)
Definition: ripper.c:15172
const char * name
Definition: lex.c:33
#define tEMBDOC_BEG
Definition: eventids2.c:3
Definition: ripper.y:120
static int parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp, int string_literal, int symbol_literal, int regexp_literal)
Definition: ripper.c:12334
int parser_compile_for_eval
Definition: ripper.c:305
#define get_id(id)
Definition: ripper.c:526
int parser_token_info_enabled
Definition: ripper.c:345
#define NEW_ALIAS(n, o)
#define NEW_OP_CDECL(v, op, val)
int parser_brace_nest
Definition: ripper.c:304
VALUE rb_rational_new(VALUE, VALUE)
Definition: rational.c:1762
#define YYLEX
Definition: ripper.c:4483
static NODE * new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: ripper.c:16245
Definition: ripper.y:107
#define YYABORT
Definition: ripper.c:4403
rb_funcall(memo->yielder, id_lshift, 1, rb_assoc_new(memo->prev_value, memo->prev_elts))
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:113
static void parser_heredoc_restore(struct parser_params *parser, NODE *here)
Definition: ripper.c:12993
#define lex_eol_p()
Definition: ripper.c:12195
#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:4783
#define dyna_in_block()
Definition: ripper.c:577
#define nd_resq
#define NODE_NTH_REF
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:2239
static NODE * gettable_gen(struct parser_params *, ID)
Definition: ripper.c:15221
#define str_copy(_s, _p, _n)
void rb_gc_force_recycle(VALUE)
Definition: gc.c:4900
#define NODE_TRUE
#define was_bol()
Definition: ripper.c:12271
#define IS_SPCARG(c)
Definition: ripper.c:13543
#define void_stmts(node)
Definition: ripper.c:442
#define T_NODE
RUBY_EXTERN void * memmove(void *, const void *, size_t)
Definition: memmove.c:7
static struct symbols global_symbols
#define rb_enc_name(enc)
VALUE rb_parser_end_seen_p(VALUE vparser)
Definition: ripper.c:17645
int parser_in_kwarg
Definition: ripper.c:307
#define current_enc
Definition: ripper.c:404
int line_count
Definition: ripper.c:326
#define YYNTOKENS
Definition: ripper.c:1151
#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:550
stack_type parser_cmdarg_stack
Definition: ripper.c:298
#define RFLOAT_VALUE(v)
int yyresult
Definition: ripper.c:5020
static NODE * parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
Definition: ripper.c:12068
#define new_args(f, o, r, p, t)
Definition: ripper.c:473
yytype_int16 * yyssp
Definition: ripper.c:5010
#define strcasecmp
Definition: win32.h:220
#define nextc()
Definition: ripper.c:11647
#define rb_warning0(fmt)
Definition: ripper.c:706
VALUE rb_enc_from_encoding(rb_encoding *encoding)
Definition: encoding.c:102
static YYSIZE_T const char * yystr
Definition: ripper.c:4687
#define NEW_NIL()
#define token_info_push(token)
Definition: ripper.c:745
#define NUM_SUFFIX_R
Definition: ripper.c:13029
Real * a
Definition: bigdecimal.c:1198
#define NODE_ENSURE
VALUE rb_eTypeError
Definition: error.c:548
#define rb_enc_isalnum(c, enc)
static int parser_here_document(struct parser_params *, NODE *)
Definition: ripper.c:13100
#define OBJ_FREEZE(x)
NODE * node
Definition: parse.h:167
#define rb_warnS(fmt, a)
Definition: ripper.c:704
#define dsym_node(node)
Definition: ripper.c:484
Definition: ripper.y:122
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
RB_GC_GUARD(args)
long(* rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len)
Definition: ripper.c:13298
#define NEW_ZARRAY()
st_table * names
Definition: encoding.c:50
#define logop(type, node1, node2)
Definition: ripper.c:429
#define rb_enc_prev_char(s, p, e, enc)
VALUE enc
Definition: tcltklib.c:10318
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:900
NODE * kw_args
Definition: ripper.y:523
Definition: ripper.y:99
unsigned long int yylno
Definition: ripper.c:4623
#define MAX_WORD_LENGTH
Definition: lex.c:43
static NODE * evstr2dstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15149
VALUE rb_eEncodingError
Definition: error.c:554
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:16552
static void warn_unused_var(struct parser_params *parser, struct local_vars *local)
Definition: ripper.c:16280
return yyd
Definition: ripper.c:4721
#define TYPE(x)
struct RBasic basic
Definition: ripper.y:821
unsigned short int yytype_uint16
Definition: ripper.c:953
#define nd_else
#define parse_string(n)
Definition: ripper.c:11657
yytokentype
Definition: ripper.y:40
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:849
#define NODE_PRELUDE
rb_str_append(str, i)
#define is_identchar(p, e, enc)
Definition: ripper.c:11761
#define RSTRING_PTR(str)
yytype_int16 * yyss
Definition: ripper.c:5009
#define NEW_MATCH2(n1, n2)
VALUE op_sym[tLAST_OP_ID]
Definition: ripper.c:16764
#define COND_PUSH(n)
Definition: ripper.c:171
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2580
NIL_P(eventloop_thread)
Definition: tcltklib.c:4056
#define T_ARRAY
VALUE debug_lines
Definition: ripper.c:341
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
Definition: string.c:548
#define warn_balanced(op, syn)
Definition: ripper.c:13555
#define NEW_LAMBDA(a, b)
ID id
Definition: parse.h:168
#define nd_plen
#define match_op(node1, node2)
Definition: ripper.c:510
#define CMDARG_P()
Definition: ripper.c:179
#define dvar_defined(id)
Definition: ripper.c:580
#define NEW_POSTEXE(b)
#define NEW_STR(s)
VALUE var
Definition: tcltklib.c:5495
#define yyerrok
Definition: ripper.c:4397
#define NODE_EVSTR
#define YYEMPTY
Definition: ripper.c:4399
#define tok()
Definition: ripper.c:12274
#define xfree
#define NODE_DXSTR
static void ripper_init_eventids1_table(VALUE self)
Definition: eventids1.c:270
#define reg_fragment_setenc(str, options)
Definition: ripper.c:520
static NODE * match_op_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15187
#define NODE_CASE
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1857
#define rb_warn4S(file, line, fmt, a)
Definition: ripper.c:705
#define rb_warnI(fmt, a)
Definition: ripper.c:703
#define T_HASH
Definition: ripper.y:111
return Qtrue
Definition: tcltklib.c:9618
static NODE * node_assign_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15564
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
Definition: encoding.c:826
static NODE * block_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14953
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: ripper.c:4500
static NODE * newline_node(NODE *)
Definition: ripper.c:14920
ID * tbl
Definition: ripper.c:182
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:179
#define newtok()
Definition: ripper.c:11649
static NODE * range_op(struct parser_params *parser, NODE *node)
Definition: ripper.c:15930
#define reduce_nodes(n)
Definition: ripper.c:444
#define YYPOPSTACK(N)
Definition: ripper.c:5034
#define T_FILE
#define dyna_var(id)
Definition: ripper.c:578
int pre_args_num
Definition: ripper.y:515
primary_value operation2 command_args prec tLOWEST
Definition: ripper.y:1401
#define NODE_HEREDOC
Definition: ripper.c:597
#define NEW_CONST(v)
int parser_toksiz
Definition: ripper.c:311
#define POINTER_P(val)
Definition: ripper.c:199
static NODE * remove_begin_all(NODE *)
Definition: ripper.c:15765
#define STR_FUNC_INDENT
Definition: ripper.c:12164
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
Definition: encoding.c:946
static void parser_pushback(struct parser_params *parser, int c)
Definition: ripper.c:12262
NODE * kw_rest_arg
Definition: ripper.y:524
#define NODE_STR
ID last_id
Definition: ripper.c:16757
#define Qnone
Definition: ripper.c:694
#define RFLOAT(obj)
#define NODE_REDO
static int lvar_defined_gen(struct parser_params *, ID)
Definition: ripper.c:13227
#define NODE_NEXT
const char * alias
Definition: nkf.c:1151
#define ruby__end__seen
Definition: ripper.c:400
Definition: ripper.y:114
#define NEW_DVAR(v)
void(* rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13299
r
Definition: bigdecimal.c:1212
tmp
Definition: enum.c:447
#define ruby_debug_lines
Definition: ripper.c:410
#define parser_is_identchar()
Definition: ripper.c:11762
#define local_pop()
Definition: ripper.c:562
#define ID_LOCAL
#define ruby_sourcefile
Definition: compile.c:422
Definition: ripper.y:95
#define NODE_XSTR
Definition: ripper.y:109
#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:13011
#define NODE_BLOCK_PASS
#define RE_OPTION_ENCODING(e)
Definition: ripper.c:590
#define rb_backref_error(n)
Definition: ripper.c:497
int size
Definition: encoding.c:49
VALUE rb_int_positive_pow(long x, unsigned long y)
Definition: numeric.c:3056
#define NEW_BREAK(s)
#define NEW_OP_ASGN_OR(i, val)
static void parser_initialize(struct parser_params *parser)
Definition: ripper.c:17484
#define NEW_MASGN(l, r)
ID block_arg
Definition: ripper.y:521
#define ENCODING_IS_ASCII8BIT(obj)
static NODE * node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE)
Definition: ripper.c:14900
#define InitVM(ext)
static const yytype_uint16 yyr1[]
Definition: ripper.c:1636
int yytoken
Definition: ripper.c:5022
ID rb_check_id(volatile VALUE *namep)
Returns ID for the given name if it is interned already, or 0.
Definition: ripper.c:17365
int yystate
Definition: ripper.c:4996
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
Definition: ripper.c:17407
struct RNode * node
Definition: ripper.y:244
#define lex_gets_ptr
Definition: ripper.c:397
rb_encoding * rb_utf8_encoding(void)
Definition: encoding.c:1257
#define ID2SYM(x)
#define here_document(n)
Definition: ripper.c:11659
VALUE parser_lex_input
Definition: ripper.c:313
static long parser_encode_length(struct parser_params *parser, const char *name, long len)
Definition: ripper.c:13234
#define T_FLOAT
VALUE tbl
Definition: tkutil.c:1280
#define is_instance_id(id)
Definition: ripper.c:111
#define NEW_LVAR(v)
#define call_bin_op(recv, id, arg1)
Definition: ripper.c:468
#define arg_concat(h, t)
Definition: ripper.c:457
#define rb_enc_isdigit(c, enc)
memo state
Definition: enum.c:2432
#define T_OBJECT
static enum node_type nodetype(NODE *node)
Definition: ripper.c:14908
#define ENC_CODERANGE_BROKEN
VALUE rb_sym_all_symbols(void)
Definition: ripper.c:17303
static VALUE lex_getline(struct parser_params *parser)
Definition: ripper.c:12045
#define rb_ary_new2
static NODE * ret_args_gen(struct parser_params *, NODE *)
Definition: ripper.c:16054
Definition: ripper.y:116
#define ID_INTERNAL
#define LONG2NUM(x)
static const yytype_int16 yytable[]
Definition: ripper.c:2053
VALUE rb_str_new_frozen(VALUE)
Definition: string.c:833
#define RUBY_DTRACE_PARSE_BEGIN(arg0, arg1)
Definition: probes.h:55
Definition: ripper.y:96
int pos
Definition: ripper.c:183
VALUE parser_ruby_sourcefile_string
Definition: ripper.c:330
#define NEW_FOR(v, i, b)
#define YYLAST
Definition: ripper.c:1148
#define NEW_CLASS(n, b, s)
#define YYID(n)
Definition: ripper.c:999
#define NODE_GASGN
int rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:16979
static NODE * yycompile(struct parser_params *parser, VALUE fname, int line)
Definition: ripper.c:12005
#define NEW_SPLAT(a)
#define ID_SCOPE_SHIFT
flag
Definition: tcltklib.c:2046
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: ripper.c:17690
#define NEW_PRELUDE(p, b)
d
Definition: strlcat.c:58
static int yylex(void *, void *)
gz lineno
Definition: zlib.c:2270
i
Definition: enum.c:446
#define NEW_ITER(a, b)
VALUE ary
Definition: enum.c:674
#define head
Definition: st.c:107
const char * fmt
Definition: tcltklib.c:846
#define ENCODING_GET(obj)
int parser_yydebug
Definition: ripper.c:333
#define gettable(id)
Definition: ripper.c:487
st_table * id_str
Definition: ripper.c:16759
NODE * parser_eval_tree
Definition: ripper.c:340
#define list_append(l, i)
Definition: ripper.c:451
NODE * parser_deferred_nodes
Definition: ripper.c:321
static int simple_re_meta(int c)
Definition: ripper.c:12639
#define NEW_GVAR(v)
int yyi
Definition: ripper.c:4620
int yynerrs
Definition: ripper.c:4994
void rb_name_error(ID id, const char *fmt,...)
Definition: error.c:967
command_asgn lhs
Definition: ripper.y:1270
#define STR_NEW0()
Definition: ripper.c:362
Definition: ripper.y:240
static int e_option_supplied(struct parser_params *parser)
Definition: ripper.c:11938
static void block_dup_check_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15444
Definition: parse.h:161
int has_shebang
Definition: ripper.c:327
#define NUM_SUFFIX_I
Definition: ripper.c:13030
nd_args
Definition: parse.y:1382
#define NEWHEAP()
Definition: ripper.c:17701
#define NEW_DSTR(s)
#define SPECIAL_PUNCT(idx)
Definition: ripper.c:12812
#define nd_set_type(n, t)
static int vtable_size(const struct vtable *tbl)
Definition: ripper.c:202
#define T_COMPLEX
static int assign_in_cond(struct parser_params *parser, NODE *node)
Definition: ripper.c:15860
#define ISALPHA(c)
Definition: ruby.h:1782
#define MEMZERO(p, type, n)
void rb_exc_raise(VALUE mesg)
Definition: eval.c:567
#define NEW_UNLESS(c, t, e)
#define STR_FUNC_REGEXP
Definition: ripper.c:12161
#define NEW_MODULE(n, b)
static NODE * list_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15007
#define strtod(s, e)
Definition: util.h:74
VALUE rb_usascii_str_new(const char *, long)
Definition: string.c:540
static rb_encoding * must_be_ascii_compatible(VALUE s)
Definition: ripper.c:12015
struct vtable * prev
Definition: ripper.c:185
int rb_is_const_id(ID id)
Definition: ripper.c:17312
int rb_is_instance_id(ID id)
Definition: ripper.c:17330
#define RUBY_DTRACE_PARSE_END(arg0, arg1)
Definition: probes.h:58
static int parser_number_literal_suffix(struct parser_params *parser, int mask)
Definition: ripper.c:13034
static int parser_tokadd_string(struct parser_params *, int, int, int, long *, rb_encoding **)
Definition: ripper.c:12652
#define VTBL_DEBUG
Definition: ripper.c:212
VALUE hash
Definition: tkutil.c:267
int rb_is_method_name(VALUE name)
Definition: ripper.c:17466
#define arg_append(h, t)
Definition: ripper.c:455
#define assignable_result(x)
#define CMDARG_PUSH(n)
Definition: ripper.c:176
YYSTYPE yyval
Definition: ripper.c:5025
Definition: ripper.y:112
static VALUE coverage(VALUE fname, int n)
Definition: ripper.c:11922
#define RE_OPTION_MASK
Definition: ripper.c:593
Definition: ripper.y:97
#define NEW_OP_ASGN_AND(i, val)
static NODE * arg_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15513
rb_encoding * enc
Definition: ripper.c:331
#define parser_warning(node, mesg)
Definition: ripper.c:14943
#define NODE_LVAR
static int parser_regx_options(struct parser_params *)
Definition: ripper.c:12580
enum lex_state_e parser_lex_state
Definition: ripper.c:296
#define whole_match_p(e, l, i)
Definition: ripper.c:11662
#define op_tbl_count
Definition: ripper.c:16750
#define NODE_LASGN
int capa
Definition: ripper.c:184
VALUE parser_lex_lastline
Definition: ripper.c:314
#define lex_nextline
Definition: ripper.c:390
#define YYTERROR
Definition: ripper.c:4441
#define NEW_OPT_N(b)
Definition: ripper.y:115
NODE * rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: ripper.c:12094
#define set_yylval_literal(x)
Definition: ripper.c:11672
#define NEW_KW_ARG(i, v)
BDIGIT m
Definition: bigdecimal.c:5209
static int parser_yylex(struct parser_params *parser)
Definition: ripper.c:13582
static VALUE parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
Definition: ripper.c:12178
#define scan_hex(s, l, e)
Definition: util.h:52
static int dyna_in_block_gen(struct parser_params *)
Definition: ripper.c:16446
return Qfalse
Definition: tcltklib.c:6790
#define FIXNUM_P(f)
#define rb_intern_str(string)
Definition: generator.h:17
static const yytype_uint16 yystos[]
Definition: ripper.c:4287
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Definition: re.c:333
static char * parser_tokspace(struct parser_params *parser, int n)
Definition: ripper.c:12295
#define arg_ambiguous()
Definition: ripper.c:13213
#define TypedData_Get_Struct(obj, type, data_type, sval)
void rb_compile_error_append(const char *fmt,...)
Definition: error.c:157
void rb_compile_error_with_enc(const char *file, int line, void *enc, const char *fmt,...)
Definition: error.c:133
#define evstr2dstr(n)
Definition: ripper.c:464
#define RARRAY_LEN(a)
static void parser_free(void *ptr)
Definition: ripper.c:17564
#define IS_ARG()
Definition: ripper.c:13540
static int parse_numvar(struct parser_params *parser)
Definition: ripper.c:13561
#define PARSER_ARG
Definition: ripper.c:730
#define NODE_WHEN
#define Qnil
Definition: enum.c:67
#define StringValuePtr(v)
#define literal_concat(h, t)
Definition: ripper.c:459
#define val
Definition: tcltklib.c:1935
int rb_ispunct(int c)
Definition: encoding.c:1946
VALUE rb_eRuntimeError
Definition: error.c:547
#define compile_error
Definition: ripper.c:729
static int symbols_i(VALUE sym, ID value, VALUE ary)
Definition: ripper.c:17280
const rb_data_type_t * parent
Definition: ripper.y:975
#define NEW_RESCUE(b, res, e)
#define RARRAY(obj)
#define yylval
Definition: ripper.c:11638
static int parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
Definition: ripper.c:12507
static int dvar_curr_gen(struct parser_params *, ID)
Definition: ripper.c:16483
VALUE rb_parser_encoding(VALUE vparser)
Definition: ripper.c:17660
#define ifndef_ripper(x)
Definition: ripper.c:695
static const yytype_uint16 yyrline[]
Definition: ripper.c:1474
struct parser_params * parser
Definition: ripper.c:16544
#define NODE_YIELD
#define NEW_NODE(t, a0, a1, a2)
#define yytable_value_is_error(yytable_value)
Definition: ripper.c:3169
#define NEW_LIST(a)
#define NEW_ENSURE(b, en)
RUBY_EXTERN VALUE rb_mKernel
Definition: ripper.y:1549
#define cur_mid
Definition: ripper.c:382
static VALUE char * str
Definition: tcltklib.c:3539
#define NODE_FLIP2
#define NODE_BLOCK
#define ID_INSTANCE
NODE * rb_compile_string(const char *f, VALUE s, int line)
Definition: ripper.c:12087
#define NEW_BLOCK(a)
static const yytype_uint16 yyprhs[]
Definition: ripper.c:1210
int yyrule
Definition: ripper.c:4617
#define RARRAY_AREF(a, i)
#define NODE_DASGN_CURR
static NODE * list_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15027
int parser_paren_nest
Definition: ripper.c:300
VALUE rb_ary_new(void)
Definition: array.c:499
#define NODE_AND
int flags
Definition: tcltklib.c:3015
unsigned long ID
Definition: ripper.y:89
#define NEW_UNDEF(i)
#define ID_JUNK
#define is_attrset_id(id)
Definition: ripper.c:112
#define set_yylval_name(x)
Definition: ripper.c:11671
va_end(args)
#define T_RATIONAL
void rb_gc_mark(VALUE)
Definition: gc.c:3607
#define IDSET_ATTRSET_FOR_INTERN
Definition: ripper.c:16880
#define ID_GLOBAL
#define tokline
Definition: ripper.c:387
static char * parser_newtok(struct parser_params *parser)
Definition: ripper.c:12279
YYSIZE_T yymsg_alloc
Definition: ripper.c:5031
static int vtable_included(const struct vtable *tbl, ID id)
Definition: ripper.c:254
#define block_dup_check(n1, n2)
Definition: ripper.c:446
#define tokadd(c)
Definition: ripper.c:11651
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:2228
static NODE * arg_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15538
static void local_push_gen(struct parser_params *, int)
Definition: ripper.c:16300
RUBY_EXTERN int ffs(int)
Definition: ffs.c:6
#define NEW_WHEN(c, t, e)
top_stmt escape_Qundef($1)
static void const char * yymsg
Definition: ripper.c:4923
#define ISASCII(c)
Definition: ruby.h:1774
#define tokenbuf
Definition: ripper.c:384
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:611
#define COND_POP()
Definition: ripper.c:172
#define heredoc_identifier()
Definition: ripper.c:11660
static VALUE VALUE obj
Definition: tcltklib.c:3150
#define RSTRING_LEN(str)
static void parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13311
static struct st_hash_type symhash
Definition: ripper.c:16768
#define INT2FIX(i)
#define YYSYNTAX_ERROR
struct vtable * vars
Definition: parse.h:170
#define new_const_op_assign(lhs, op, rhs)
Definition: ripper.c:505
Definition: ripper.y:137
VALUE value
Definition: ripper.y:246
static void parser_tokadd(struct parser_params *parser, int c)
Definition: ripper.c:12307
#define FIX2LONG(x)
#define k__END__
Definition: eventids2.c:9
static void parser_mark(void *ptr)
Definition: ripper.c:17538
#define ISALNUM(c)
Definition: ruby.h:1781
#define YYDPRINTF(Args)
Definition: ripper.c:4494
return yylen
Definition: ripper.c:4693
#define T_STRING
#define lex_goto_eol(parser)
Definition: ripper.c:12194
#define MBCLEN_CHARFOUND_P(ret)
static double one(void)
Definition: isinf.c:52
int yyn
Definition: ripper.c:5019
unsigned char OnigUChar
Definition: ripper.y:112
#define NODE_ARGSCAT
#define local_id(id)
Definition: ripper.c:568
#define NODE_COLON2
NODE * rb_parser_append_print(VALUE vparser, NODE *node)
Definition: ripper.c:16653
#define nd_set_line(n, l)
#define xmalloc
#define xrealloc
static void ripper_init_eventids1(void)
Definition: eventids1.c:134
yytype_int16 yyss_alloc
Definition: ripper.c:1092
static void vtable_add(struct vtable *tbl, ID id)
Definition: ripper.c:239
#define YYFINAL
Definition: ripper.c:1146
#define dvar_curr(id)
Definition: ripper.c:583
#define rb_sourcefile()
Definition: tcltklib.c:98
#define flush_string_content(enc)
Definition: ripper.c:12804
#define NEW_ARGS_AUX(r, b)
#define TypedData_Wrap_Struct(klass, data_type, sval)
#define RSTRING_NOEMBED
#define tokadd_string(f, t, p, n, e)
Definition: ripper.c:11656
static NODE * new_yield_gen(struct parser_params *, NODE *)
Definition: ripper.c:16071
#define ripper_flush(p)
Definition: ripper.c:11691
static VALUE lex_get_str(struct parser_params *parser, VALUE s)
Definition: ripper.c:12025
#define ISUPPER(c)
Definition: ruby.h:1779
#define RUBY_FUNC_EXPORTED
Definition: defines.h:246
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4308
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:390
VALUE rb_enc_associate_index(VALUE obj, int idx)
Definition: encoding.c:798
int rb_parse_in_main(void)
Definition: compile.c:6020
static int parser_nextc(struct parser_params *parser)
Definition: ripper.c:12200
int err
Definition: win32.c:114
#define dyna_pop(node)
Definition: ripper.c:575
#define YYACCEPT
Definition: ripper.c:4402
const char * parser_lex_pend
Definition: ripper.c:318
static ID formal_argument_gen(struct parser_params *, ID)
Definition: ripper.c:13216
static void void_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15652
#define DBL2NUM(dbl)
#define YYEOF
Definition: ripper.c:4400
#define ALLOCA_N(type, n)
static NODE * dsym_node_gen(struct parser_params *, NODE *)
Definition: ripper.c:16173
#define set_integer_literal(v, f)
Definition: ripper.c:11665
#define NUM_SUFFIX_ALL
Definition: ripper.c:13031
#define ENC_CODERANGE_UNKNOWN
long cnt
Definition: ripper.y:262
ID token
Definition: ripper.c:16726
static int VALUE key
Definition: tkutil.c:265
static ID intern_str(VALUE str)
Definition: ripper.c:17065
int len
Definition: enumerator.c:1332
#define YY_REDUCE_PRINT(Rule)
Definition: ripper.c:4637
YYSTYPE yyvsa[YYINITDEPTH]
Definition: ripper.c:5013
Definition: ripper.y:118
NODE * rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
Definition: ripper.c:16685
Definition: util.c:796
NODE * rb_compile_cstr(const char *f, const char *s, int len, int line)
Definition: ripper.c:12107
token_info * parser_token_info
Definition: ripper.c:346
Definition: ripper.y:125
static void magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13302
int column
Definition: ripper.c:273
#define numberof(array)
Definition: etc.c:602
#define IS_lex_state(ls)
Definition: ripper.c:158
VALUE arg
Definition: enum.c:2427
#define END(no)
Definition: re.c:26
#define EOF
Definition: vsnprintf.c:207
int yyerrstatus
Definition: ripper.c:4998
VALUE rb_str_buf_cat(VALUE, const char *, long)
Definition: string.c:2123
void * rb_parser_malloc(struct parser_params *parser, size_t size)
Definition: ripper.c:17706
VALUE rb_str_dup(VALUE)
Definition: string.c:1062
static VALUE setup_fake_str(struct RString *fake_str, const char *name, long len)
Definition: ripper.c:17038
#define peek_n(c, n)
Definition: ripper.c:12197
#define DEF_EXPR(n)
Definition: ripper.c:140
#define tHEREDOC_END
Definition: eventids2.c:8
#define STR_NEW(p, n)
Definition: ripper.c:361
#define rb_long2int(n)
YYSTYPE yyvs_alloc
Definition: ripper.c:1093
#define ID_CLASS
static int parser_peek_variable_name(struct parser_params *parser)
Definition: ripper.c:12836
#define tokcopy(n)
Definition: ripper.c:12330
#define STR_FUNC_SYMBOL
Definition: ripper.c:12163
#define NEW_LASGN(v, val)
node_type
Definition: ripper.y:23
static VALUE yycompile0(VALUE arg)
Definition: ripper.c:11944
#define mixed_escape(beg, enc1, enc2)
VALUE rb_obj_as_string(VALUE)
Definition: string.c:1011
#define set_yylval_num(x)
Definition: ripper.c:11669
static ID register_symid_str(ID, VALUE)
Definition: ripper.c:17002
VALUE * argv
Definition: tcltklib.c:1969
goto yysetstate
Definition: ripper.c:5059
#define NODE_MEMO
#define NEW_OPT_ARG(i, v)
#define STR_FUNC_QWORDS
Definition: ripper.c:12162
#define dyna_push()
Definition: ripper.c:573
#define command_start
Definition: ripper.c:395
string_type
Definition: ripper.c:12166
int rb_dvar_defined(ID id)
Definition: compile.c:5970
static void dispose_string(VALUE str)
Definition: ripper.c:12616
VALUE rb_str_resize(VALUE, long)
Definition: string.c:2024
#define is_notop_id(id)
Definition: ripper.c:108
static NODE * aryset_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15436
int parser_in_single
Definition: ripper.c:302
#define RTEST(v)
lex_state_bits
Definition: ripper.c:123
const int id
Definition: nkf.c:209
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
Definition: st.c:1034
#define NEW_SCLASS(r, b)
#define RUBY_DTRACE_PARSE_END_ENABLED()
Definition: probes.h:57
static ID shadowing_lvar_gen(struct parser_params *, ID)
Definition: ripper.c:15415
#define set_number_literal(v, t, f)
Definition: ripper.c:11664
#define CMDARG_LEXPOP()
Definition: ripper.c:178
ID rest_arg
Definition: ripper.y:520
#define local_push(top)
Definition: ripper.c:560
int errno
#define TRUE
Definition: nkf.h:175
#define rb_rational_raw1(x)
int rb_symname_p(const char *name)
Definition: ripper.c:16868
#define new_attr_op_assign(lhs, type, attr, op, rhs)
Definition: ripper.c:503
#define NODE_NIL
VALUE rb_thread_current(void)
Definition: thread.c:2405
static int shadowing_lvar_0(struct parser_params *parser, ID name)
Definition: ripper.c:15390
#define paren_nest
Definition: ripper.c:376
#define NODE_ATTRASGN
#define token_info_pop(token)
Definition: ripper.c:746
static void dyna_pop_gen(struct parser_params *, const struct vtable *)
Definition: ripper.c:16432
#define rb_ascii8bit_encindex()
VALUE rb_range_new(VALUE, VALUE, int)
Definition: range.c:70
static NODE * new_evstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15158
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1250
#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
memo u3 cnt
Definition: enum.c:128
#define tokadd_mbchar(c)
Definition: ripper.c:12636
static void reg_fragment_setenc_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16491
#define rb_node_newnode(type, a1, a2, a3)
Definition: ripper.c:424
#define YYMAXDEPTH
Definition: ripper.c:4669
goto yynewstate
Definition: ripper.c:5201
VALUE v
Definition: enum.c:845
#define RUBY_TYPED_FREE_IMMEDIATELY
static void set_file_encoding(struct parser_params *parser, const char *str, const char *send)
Definition: ripper.c:13473
#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:17454
#define NEW_DASGN(v, val)
register char * s
Definition: os2.c:56
#define NEW_VALIAS(n, o)
int check
Definition: tcltklib.c:2793
#define RE_OPTION_ONCE
Definition: ripper.c:588
int rb_enc_symname_p(const char *name, rb_encoding *enc)
Definition: ripper.c:16874
#define NEW_POSTARG(i, v)
#define CONST_ID(var, str)
#define tokidx
Definition: ripper.c:385
#define NEW_ERRINFO()
#define malloc
Definition: ripper.c:96
void Init_sym(void)
Definition: ripper.c:16801
#define NODE_CONST
static int parser_parse_string(struct parser_params *, NODE *)
Definition: ripper.c:12872
#define nd_term(node)
Definition: ripper.c:603
#define STR_FUNC_EXPAND
Definition: ripper.c:12160
VP_EXPORT void
Definition: bigdecimal.c:5207
#define rb_warningS(fmt, a)
Definition: ripper.c:707
static NODE * new_args_tail_gen(struct parser_params *, NODE *, ID, ID)
Definition: ripper.c:16143
static int dvar_defined_gen(struct parser_params *, ID, int)
Definition: ripper.c:16452
int rb_is_local_id(ID id)
Definition: ripper.c:17342
rb_magic_comment_length_t length
Definition: ripper.c:13335
int parser_in_def
Definition: ripper.c:303
#define is_global_id(id)
Definition: ripper.c:110
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1719
#define NEW_SUPER(a)
static int local_id_gen(struct parser_params *, ID)
Definition: ripper.c:16375
#define YYSIZE_T
Definition: ripper.c:972
#define NEW_COLON2(c, i)
#define ESCAPE_META
Definition: ripper.c:12406
VALUE parser_cur_mid
Definition: ripper.c:306
short int yytype_int16
Definition: ripper.c:959
VALUE rb_io_gets(VALUE)
Definition: io.c:3189
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Definition: array.c:620
static void Init_id(void)
Definition: ripper.y:15
long parser_lex_gets_ptr
Definition: ripper.c:322
#define no_digits()
goto yyreturn
Definition: ripper.c:11580
#define NODE_GVAR
#define NODE_CDECL
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1272
#define NEW_HASH(a)
static void rb_backref_error_gen(struct parser_params *, NODE *)
Definition: ripper.c:15500
Definition: ripper.y:94
unsigned char yytype_uint8
Definition: ripper.c:938
void rb_gc_mark_symbols(int full_mark)
Definition: ripper.c:16820
static const yytype_int16 yyrhs[]
Definition: ripper.c:1278
static void arg_ambiguous_gen(struct parser_params *parser)
Definition: ripper.c:13205
#define RBASIC_SET_CLASS_RAW(obj, cls)
#define heredoc_restore(n)
Definition: ripper.c:11661
static void parser_prepare(struct parser_params *parser)
Definition: ripper.c:13516
union RNode::@114 u3
static NODE * cond_gen(struct parser_params *, NODE *)
Definition: ripper.c:16024
static int rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset)
Definition: ripper.c:16883
#define lex_lastline
Definition: ripper.c:389
#define NODE_LIT
#define rb_reserved_word(str, len)
Definition: lex.c:37
int type
Definition: tcltklib.c:112
int id[2]
Definition: lex.c:33
#define NEW_UNTIL(c, b, n)
static const char *const yytname[]
Definition: ripper.c:1545
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: ripper.c:1112
#define T_FIXNUM
#define NEW_MATCH3(r, n2)
int argc
Definition: tcltklib.c:1968
VALUE rb_str_buf_new(long)
Definition: string.c:891
stack_type parser_cond_stack
Definition: ripper.c:297
NODE * post_init
Definition: ripper.y:513
static void FILE * yyoutput
Definition: ripper.c:4524
static void ripper_init_eventids2(void)
Definition: eventids2.c:66
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:2133
int rb_is_junk_id(ID id)
Definition: ripper.c:17348
static void dyna_pop_1(struct parser_params *parser)
Definition: ripper.c:16414
static int parser_read_escape(struct parser_params *parser, int flags, rb_encoding **encp)
Definition: ripper.c:12409
int parser_heredoc_end
Definition: ripper.c:319
#define ruby_sourceline
Definition: ripper.c:401
static int parser_heredoc_identifier(struct parser_params *parser)
Definition: ripper.c:12930
Definition: ripper.y:103
ID rb_id_attrset(ID id)
Definition: ripper.c:15463
static int value_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15595
rb_hash_aset(hash, RARRAY_AREF(key_value_pair, 0), RARRAY_AREF(key_value_pair, 1))
Definition: ripper.y:85
mlhs_head tSTAR
Definition: ripper.y:1542
int post_args_num
Definition: ripper.y:516
#define lex_pend
Definition: ripper.c:393
static int rb_str_symname_type(VALUE name, unsigned int allowed_attrset)
Definition: ripper.c:16985
int rb_is_global_id(ID id)
Definition: ripper.c:17324
VALUE rb_fstring(VALUE)
Definition: string.c:201
static int reg_fragment_check_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16530
static const yytype_int16 yycheck[]
Definition: ripper.c:3172
#define NEW_SELF()
#define YYUSE(e)
Definition: ripper.c:992
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1127
#define lvtbl
Definition: ripper.c:399
#define lex_strterm
Definition: ripper.c:371
#define rb_enc_ispunct(c, enc)
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
Definition: eval.c:839
VALUE flags
Definition: ripper.y:748
#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:16229
#define NEW_RETURN(s)
#define NODE_ARGSPUSH
#define NODE_BACK_REF
#define set_yylval_str(x)
Definition: ripper.c:11668
static struct @92 op_tbl[]
#define NODE_MATCH
#define cond_stack
Definition: ripper.c:373
short int yytype_int8
Definition: ripper.c:947
int rb_sourceline(void)
Definition: vm.c:1001
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2357
static NODE * assignable_gen(struct parser_params *, ID, NODE *)
VALUE flags
Definition: ripper.y:241
VALUE idx
Definition: enumerator.c:499
expr ripper_intern("and")
static int is_static_content(NODE *node)
Definition: ripper.c:15836
yytype_int16 * yytop
Definition: ripper.c:4586
const char * token
Definition: ripper.c:271
ruby_verbose
Definition: tcltklib.c:5796
RUBY_EXTERN VALUE rb_cString
Definition: ripper.y:1591
Real * b
Definition: bigdecimal.c:1198
#define NEW_COLON3(i)
#define RUBY_DTRACE_PARSE_BEGIN_ENABLED()
Definition: probes.h:54
#define NEW_CASE(h, b)
static const yytype_int16 yypgoto[]
Definition: ripper.c:2024
static int arg_var_gen(struct parser_params *, ID)
Definition: ripper.c:16358
return ptr
Definition: tcltklib.c:789
#define free(x)
Definition: dln.c:50
VpDivd * c
Definition: bigdecimal.c:1223
goto yyerrlab1
Definition: ripper.c:11510
#define is_local_id(id)
Definition: ripper.c:109
#define NODE_DASGN
int parser_in_defined
Definition: ripper.c:308
VALUE msg
Definition: tcltklib.c:851
static int literal_concat0(struct parser_params *, VALUE, VALUE)
Definition: ripper.c:15051
static ID * local_tbl_gen(struct parser_params *)
Definition: ripper.c:16333
static int is_global_name_punct(const int c)
Definition: ripper.c:12829
#define NEW_BACK_REF(n)
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1244
int parser_class_nest
Definition: ripper.c:299
#define T_BIGNUM
#define brace_nest
Definition: ripper.c:378
#define reg_named_capture_assign(regexp, match)
Definition: ripper.c:524
#define MEMCPY(p1, p2, type, n)
Definition: ripper.y:124
static int parser_yyerror(struct parser_params *, const char *)
Definition: ripper.c:11841
gz end
Definition: zlib.c:2272
goto yydefault
Definition: ripper.c:5151
#define NEW_IF(c, t, e)
#define HEAPCNT(n, size)
Definition: ripper.c:17700
nd_iter
Definition: parse.y:1392
#define NEW_GASGN(v, val)
yydestruct("Cleanup: discarding lookahead", yytoken,&yylval, parser)
YYSIZE_T yystacksize
Definition: ripper.c:5017
static void warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15893
#define NEW_ARGSPUSH(a, b)
int rb_is_const_name(VALUE name)
Definition: ripper.c:17430
static void yytype_int16 * yybottom
Definition: ripper.c:4585
#define is_asgn_or_id(id)
Definition: ripper.c:118
static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
Definition: ripper.c:12500
static NODE * attrset_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:15492
int rb_is_local_name(VALUE name)
Definition: ripper.c:17460
memo last
Definition: enum.c:1356
static struct vtable * dyna_push_gen(struct parser_params *)
Definition: ripper.c:16403
unsigned long ruby_scan_digits(const char *str, ssize_t len, int base, size_t *retlen, int *overflow)
Definition: util.c:79
VALUE src
Definition: tcltklib.c:7943
yy_symbol_value_print(yyoutput, yytype, yyvaluep, parser)
static VALUE reg_compile_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16624
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:2139
#define NEW_XSTR(s)
#define ESCAPE_CONTROL
Definition: ripper.c:12405
Definition: ripper.y:113
#define ENC_CODERANGE_7BIT
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:832
#define NEW_WHILE(c, b, n)
#define NEW_DEFS(r, i, a, d)
#define parser_isascii()
Definition: ripper.c:11764
void rb_gc_mark_parser(void)
Definition: ripper.c:16648
static const yytype_uint8 yytranslate[]
Definition: ripper.c:1167
int nonspc
Definition: ripper.c:274
#define ADD2HEAP(n, c, p)
Definition: ripper.c:17702
#define tokspace(n)
Definition: ripper.c:11650
#define f
#define in_def
Definition: ripper.c:380
static int is_private_local_id(ID name)
Definition: ripper.c:15377
#define SYMBOL_P(x)
#define is_const_id(id)
Definition: ripper.c:113
char yymsgbuf[128]
Definition: ripper.c:5029
static void no_blockarg(struct parser_params *parser, NODE *node)
Definition: ripper.c:16046
static void local_pop_gen(struct parser_params *)
Definition: ripper.c:16317
#define NODE_FLIP3
void rb_parser_free(struct parser_params *parser, void *ptr)
Definition: ripper.c:17746
#define Qundef
int parser_tokidx
Definition: ripper.c:310
#define read_escape(flags, e)
Definition: ripper.c:11653
#define NODE_DVAR
#define tok_hex(numlen)
Definition: ripper.c:11652
static NODE * literal_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15068
static struct magic_comment magic_comments[]
Definition: ripper.c:13338
#define new_evstr(n)
Definition: ripper.c:462
#define parser_warn(node, mesg)
Definition: ripper.c:14950
VALUE name
Definition: enum.c:572
Definition: ripper.y:92
Definition: ripper.y:129
VALUE coverage
Definition: ripper.c:342
command_call
Definition: ripper.y:1308
int t
Definition: ripper.c:14879
void rb_set_errinfo(VALUE err)
Definition: eval.c:1517
#define tokfix()
Definition: ripper.c:12273
return tOP_ASGN
Definition: ripper.y:7812
#define rb_enc_isspace(c, enc)
#define internal_id()
Definition: ripper.c:570
NODE * parser_lex_strterm
Definition: ripper.c:295
const char * name
Definition: ripper.c:13333
top_stmt bodystmt
Definition: ripper.y:934
#define COND_LEXPOP()
Definition: ripper.c:173
#define lex_p
Definition: ripper.c:392
#define NEW_IVAR(v)
top_stmts dispatch0(stmts_new)
#define RUBY_DTRACE_SYMBOL_CREATE_ENABLED()
Definition: probes.h:51
#define tSP
Definition: eventids2.c:6
#define NEW_ATTRASGN(r, m, a)
VALUE rb_complex_raw(VALUE x, VALUE y)
Definition: complex.c:1319
#define NODE_ZARRAY
static int token_info_get_column(struct parser_params *parser, const char *token)
Definition: ripper.c:11768
#define node_assign(node1, node2)
Definition: ripper.c:499
static void void_stmts_gen(struct parser_params *, NODE *)
Definition: ripper.c:15741
const char * yys
Definition: ripper.c:4716
#define void_expr(node)
Definition: ripper.c:440
static int local_var_gen(struct parser_params *, ID)
Definition: ripper.c:16365
#define pushback(c)
Definition: ripper.c:11648
#define void_expr0(node)
Definition: ripper.c:439
#define NEW_BEGIN(b)
NODE * pre_init
Definition: ripper.y:512
#define NEW_FCALL(m, a)
#define NODE_CVAR
#define lex_pbeg
Definition: ripper.c:391
args[0]
Definition: enum.c:585
#define regx_options()
Definition: ripper.c:11655
#define NEW_SCOPE(a, b)
static int token_info_has_nonspaces(struct parser_params *parser, const char *token)
Definition: ripper.c:11782
st_index_t rb_str_hash(VALUE)
Definition: string.c:2421
#define NEW_OP_ASGN2(r, i, o, val)
#define YYSTACK_ALLOC_MAXIMUM
Definition: ripper.c:1057
#define NODE_BREAK
#define TOK_INTERN(mb)
Definition: ripper.c:366
#define new_defined(expr)
Definition: ripper.c:507
static const rb_data_type_t parser_data_type
Definition: ripper.c:12065
rb_magic_comment_setter_t func
Definition: ripper.c:13334
int parser_lpar_beg
Definition: ripper.c:301
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:192
st_table * sym_id
Definition: ripper.c:16758
RUBY_EXTERN VALUE rb_cObject
Definition: ripper.y:1561
#define ALLOC_N(type, n)
#define LONG2FIX(i)
#define NODE_FL_NEWLINE
#define RBASIC(obj)
struct local_vars * prev
Definition: ripper.c:192
static const yytype_uint16 yydefact[]
Definition: ripper.c:1774
#define NEW_VCALL(m)
static NODE * new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: ripper.c:16200
#define parser_encoding_name()
Definition: ripper.c:11758
#define tokadd_escape(e)
Definition: ripper.c:11654
struct vtable * vars
Definition: ripper.c:190
static int parser_set_integer_literal(struct parser_params *parser, VALUE v, int suffix)
Definition: ripper.c:13074
static const yytype_int16 yypact[]
Definition: ripper.c:1913
static VALUE lex_io_gets(struct parser_params *parser, VALUE io)
Definition: ripper.c:12121
#define new_yield(node)
Definition: ripper.c:482
#define lvar_defined(id)
Definition: ripper.c:586
klass
Definition: tcltklib.c:3496
#define INT2NUM(x)
goto yybackup
Definition: ripper.c:5138
#define NODE_DSTR
struct rb_encoding_entry * list
Definition: encoding.c:47
#define lpar_beg
Definition: ripper.c:377
keyword_BEGIN
Definition: ripper.y:1038
#define YYTRANSLATE(YYX)
Definition: ripper.c:1163
#define NEW_RETRY()
void * rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
Definition: ripper.c:17716
#define STRNCASECMP(s1, s2, n)
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:817
#define yyerror(msg)
Definition: ripper.c:369
#define is_junk_id(id)
Definition: ripper.c:115
static void new_bv_gen(struct parser_params *, ID)
Definition: ripper.c:15422
#define ruby_coverage
Definition: ripper.c:411
int linenum
Definition: ripper.c:272
#define NEW_CVAR(v)
static NODE * negate_lit(NODE *)
Definition: ripper.c:16079
#define tEMBDOC
Definition: eventids2.c:4
Definition: ripper.y:123
#define NODE_BEGIN
gz io
Definition: zlib.c:2263
#define id_type(id)
Definition: ripper.c:116
#define number_literal_suffix(f)
Definition: ripper.c:11663
static void fixup_nodes(NODE **)
Definition: ripper.c:15899
#define DVARS_INHERIT
Definition: ripper.c:196
#define STR_NEW3(p, n, e, func)
Definition: ripper.c:364
char * parser_tokenbuf
Definition: ripper.c:309
VALUE rb_cArray
Definition: array.c:27
static const char * magic_comment_marker(const char *str, long len)
Definition: ripper.c:13346
#define BEG(no)
Definition: re.c:25
#define NEW_OP_ASGN1(p, id, a)
register C_block * p
Definition: crypt.c:309
static int parser_magic_comment(struct parser_params *parser, const char *str, long len)
Definition: ripper.c:13379
int parser_tokline
Definition: ripper.c:312
#define RUBY_DTRACE_SYMBOL_CREATE(arg0, arg1, arg2)
Definition: probes.h:52
Definition: ripper.y:92
#define IS_LABEL_POSSIBLE()
Definition: ripper.c:13544
union RNode::@113 u2
static const char id_type_names[][9]
Definition: ripper.c:15451
VALUE rb_str_new(const char *, long)
Definition: string.c:534
const char * parser_lex_pbeg
Definition: ripper.c:316
int rb_is_class_id(ID id)
Definition: ripper.c:17318
#define DVARS_TOPSCOPE
Definition: ripper.c:197
#define YYCASE_(N, S)
#define rb_safe_level()
Definition: tcltklib.c:95
VALUE rb_parser_new(void)
Definition: ripper.c:17631
struct parser_params * parser
Definition: ripper.c:4527
#define NODE_CVASGN
Definition: ripper.c:181
data n
Definition: enum.c:860
#define rb_ary_new3
static void parser_set_encode(struct parser_params *parser, const char *name)
Definition: ripper.c:13254
#define call_uni_op(recv, id)
Definition: ripper.c:470
#define NEW_CDECL(v, val, path)
static int literal_node(NODE *node)
Definition: ripper.c:15946
#define set_yylval_node(x)
Definition: ripper.c:11673
static void YYSTYPE * yyvsp
Definition: ripper.c:4616
#define YYSTACK_BYTES(N)
Definition: ripper.c:1101
#define IS_BEG()
Definition: ripper.c:13542
const char * parser_lex_p
Definition: ripper.c:317
#define nd_lit
static int parser_tok_hex(struct parser_params *parser, size_t *numlen)
Definition: ripper.c:12317
#define RE_OPTION_ENCODING_NONE(o)
Definition: ripper.c:592
#define rb_enc_asciicompat(enc)
lex_state_e
Definition: ripper.c:139
#define NUM2INT(x)
#define dvar_defined_get(id)
Definition: ripper.c:581
#define nd_head
int rb_is_instance_name(VALUE name)
Definition: ripper.c:17448
int parser_ruby_sourceline
Definition: ripper.c:329
const char * rb_id2name(ID id)
Definition: ripper.c:17271
#define NODE_CALL
#define ruby_eval_tree_begin
Definition: ripper.c:409
#define rb_errinfo()
Definition: tcltklib.c:90
VALUE rb_str_intern(VALUE)
Definition: string.c:7467
#define ruby_sourcefile_string
Definition: ripper.c:403
#define formal_argument(id)
Definition: ripper.c:553
#define rb_enc_isupper(c, enc)
#define BUILTIN_TYPE(x)
#define PRIsVALUE
static int nodeline(NODE *node)
Definition: ripper.c:14914
#define dispatch_heredoc_end()
Definition: ripper.c:13096
YYSTYPE * parser_yylval
Definition: ripper.c:292
#define ruby_eval_tree
Definition: ripper.c:408
#define toklast()
Definition: ripper.c:12276
#define lex_gets
Definition: ripper.c:398
#define toklen()
Definition: ripper.c:12275
static const yytype_uint8 yyr2[]
Definition: ripper.c:1704
#define RBASIC_CLEAR_CLASS(obj)
#define xcalloc
BDIGIT e
Definition: bigdecimal.c:5209
#define cmdarg_stack
Definition: ripper.c:374
yychar
Definition: ripper.c:5050
#define in_single
Definition: ripper.c:379
#define YY_STACK_PRINT(Bottom, Top)
Definition: ripper.c:4598
#define NEW_LIT(l)
#define rb_enc_isascii(c, enc)
int rb_str_hash_cmp(VALUE, VALUE)
Definition: string.c:2431
#define YYFPRINTF
Definition: ripper.c:4491
NODE * rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
Definition: ripper.c:12100
VALUE opts
Definition: tcltklib.c:6160
int is_ripper
Definition: ripper.c:289
unsigned long VALUE
Definition: ripper.y:88
static NODE * cond0(struct parser_params *, NODE *)
Definition: ripper.c:15967
options
Definition: tcltklib.c:4471
rb_encoding * rb_ascii8bit_encoding(void)
Definition: encoding.c:1242
int rb_is_junk_name(VALUE name)
Definition: ripper.c:17476
#define NODE_IVAR
#define peek(c)
Definition: ripper.c:12196
return tSYMBEG
Definition: ripper.y:7786
#define RREGEXP(obj)
int rb_enc_find_index(const char *name)
Definition: encoding.c:684
static NODE * splat_array(NODE *)
Definition: ripper.c:15556
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:12807
YYSTYPE * yyvs
Definition: ripper.c:5014
goto yyreduce
Definition: ripper.c:5211
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:17049
#define attrset(node, id)
Definition: ripper.c:494
#define NODE_DOT2
encp
Definition: crypt.c:564
#define COND_P()
Definition: ripper.c:174
#define ID_SCOPE_MASK
#define mixed_error(enc1, enc2)
static ID register_symid(ID, const char *, long, rb_encoding *)
Definition: ripper.c:16995
#define NODE_DREGX
#define NODE_IASGN
#define NEW_DEFN(i, a, d, p)
#define NODE_RETURN
#define snprintf
#define RARRAY_ASET(a, i, v)
ID first_post_arg
Definition: ripper.y:518
void * rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
Definition: ripper.c:17726
#define NEW_REDO()
#define shadowing_lvar(name)
Definition: ripper.c:555
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:3963
#define NODE_ARRAY
#define NODE_SPLAT
#define get_value(val)
Definition: ripper.c:527
static int parser_set_number_literal(struct parser_params *parser, VALUE v, int type, int suffix)
Definition: ripper.c:13063
#define rb_intern(str)
#define reg_fragment_check(str, options)
Definition: ripper.c:522
int rb_parse_in_eval(void)
Definition: compile.c:6014
YYSTYPE const *const yyvaluep
Definition: ripper.c:4526
#define ENCODING_SET(obj, i)
#define compile_for_eval
Definition: ripper.c:381
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:80
#define tCOMMENT
Definition: eventids2.c:2
int last_cr_line
Definition: ripper.c:335
#define NEW_ZSUPER()
#define set_yylval_id(x)
Definition: ripper.c:11670
VALUE rb_filesystem_str_new_cstr(const char *)
Definition: string.c:737
ID rb_intern2(const char *name, long len)
Definition: ripper.c:17178
NODE * rb_compile_file(const char *f, VALUE file, int start)
Definition: ripper.c:12127
VALUE j
Definition: enum.c:1347
static int is_special_global_name(const char *m, const char *e, rb_encoding *enc)
Definition: ripper.c:16842
#define is_class_id(id)
Definition: ripper.c:114
#define LVAR_USED
Definition: ripper.c:15387
#define nd_line(n)
VALUE rb_parser_get_yydebug(VALUE self)
Definition: ripper.c:17675
VALUE(* parser_lex_gets)(struct parser_params *, VALUE)
Definition: ripper.c:323
#define NULL
Definition: _sdbm.c:102
#define rb_enc_isalpha(c, enc)
static VALUE debug_lines(VALUE fname)
Definition: ripper.c:11906
union RNode::@112 u1
#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:12114
VALUE rb_check_string_type(VALUE)
Definition: string.c:1678
#define REALLOC_N(var, type, n)
#define NODE_SCOPE
#define yypact_value_is_default(yystate)
Definition: ripper.c:3166
static struct kwtable * reserved_word(const char *, unsigned int)
int rb_enc_str_coderange(VALUE)
Definition: string.c:435
#define ISXDIGIT(c)
Definition: ruby.h:1784
#define rb_warn0(fmt)
Definition: ripper.c:702
int rb_local_defined(ID id)
Definition: compile.c:5995
st_index_t num_entries
Definition: ripper.y:85
volatile VALUE result
Definition: enum.c:1989
NODE * parser_eval_tree_begin
Definition: ripper.c:339
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:1479
int retry
Definition: tcltklib.c:10158
#define new_bv(id)
Definition: ripper.c:557
static void warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15887
#define NODE_IASGN2
#define ULONG2NUM(x)
#define NODE_SELF
goto yyerrlab
Definition: ripper.c:5210
#define block_append(h, t)
Definition: ripper.c:449
#define SYM2ID(x)
#define ID_CONST
NODE * rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
Definition: ripper.c:12141
VALUE rb_eArgError
Definition: error.c:549
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:941
#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:394
#define ID_ATTRSET
struct vtable * args
Definition: ripper.c:189
#define tokaddmbc(c, enc)
Definition: ripper.c:11658
Definition: ripper.y:138
#define tEMBDOC_END
Definition: eventids2.c:5
int yytype
Definition: ripper.c:4525
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:1778
#define STR_NEW2(p)
Definition: ripper.c:363
const char * yysrc
Definition: ripper.c:4712
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:2250
VALUE rb_inspect(VALUE)
Definition: object.c:470
#define YYINITDEPTH
Definition: ripper.c:4658
static int sym_check_asciionly(VALUE str)
Definition: ripper.c:17018
rb_encoding * rb_enc_from_index(int index)
Definition: encoding.c:590
#define aryset(node1, node2)
Definition: ripper.c:492
static NODE * reg_named_capture_assign_gen(struct parser_params *parser, VALUE regexp, NODE *match)
Definition: ripper.c:16592
#define IS_AFTER_OPERATOR()
Definition: ripper.c:13546
#define NEW_BLOCK_PASS(b)
NODE * opt_args
Definition: ripper.y:526
static NODE * new_args_gen(struct parser_params *, NODE *, NODE *, ID, NODE *, NODE *)
Definition: ripper.c:16121
int rb_is_global_name(VALUE name)
Definition: ripper.c:17442
static int parser_tokadd_mbchar(struct parser_params *parser, int c)
Definition: ripper.c:12623