Ruby  1.9.3p551(2014-11-13revision48407)
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 #define YYDEBUG 1
73 #define YYERROR_VERBOSE 1
74 #define YYSTACK_USE_ALLOCA 0
75 
76 #include "ruby/ruby.h"
77 #include "ruby/st.h"
78 #include "ruby/encoding.h"
79 #include "internal.h"
80 #include "node.h"
81 #include "parse.h"
82 #include "id.h"
83 #include "regenc.h"
84 #include <stdio.h>
85 #include <errno.h>
86 #include <ctype.h>
87 
88 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
89 
90 #define YYMALLOC(size) rb_parser_malloc(parser, (size))
91 #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
92 #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
93 #define YYFREE(ptr) rb_parser_free(parser, (ptr))
94 #define malloc YYMALLOC
95 #define realloc YYREALLOC
96 #define calloc YYCALLOC
97 #define free YYFREE
98 
99 #ifndef RIPPER
100 static ID register_symid(ID, const char *, long, rb_encoding *);
101 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
102 #include "id.c"
103 #endif
104 
105 #define is_notop_id(id) ((id)>tLAST_TOKEN)
106 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
107 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
108 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
109 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
110 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
111 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
112 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
113 
114 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
115  (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
116  ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
117  ((id)&ID_SCOPE_MASK) == ID_CLASS))
118 
120  EXPR_BEG, /* ignore newline, +/- is a sign. */
121  EXPR_END, /* newline significant, +/- is an operator. */
122  EXPR_ENDARG, /* ditto, and unbound braces. */
123  EXPR_ENDFN, /* ditto, and unbound braces. */
124  EXPR_ARG, /* newline significant, +/- is an operator. */
125  EXPR_CMDARG, /* newline significant, +/- is an operator. */
126  EXPR_MID, /* newline significant, +/- is an operator. */
127  EXPR_FNAME, /* ignore newline, no reserved words. */
128  EXPR_DOT, /* right after `.' or `::', no reserved words. */
129  EXPR_CLASS, /* immediate after `class', no here document. */
130  EXPR_VALUE, /* alike EXPR_BEG but label is disallowed. */
132 };
133 
135 
136 # define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
137 # define BITSTACK_POP(stack) ((stack) = (stack) >> 1)
138 # define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
139 # define BITSTACK_SET_P(stack) ((stack)&1)
140 
141 #define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n))
142 #define COND_POP() BITSTACK_POP(cond_stack)
143 #define COND_LEXPOP() BITSTACK_LEXPOP(cond_stack)
144 #define COND_P() BITSTACK_SET_P(cond_stack)
145 
146 #define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n))
147 #define CMDARG_POP() BITSTACK_POP(cmdarg_stack)
148 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
149 #define CMDARG_P() BITSTACK_SET_P(cmdarg_stack)
150 
151 struct vtable {
152  ID *tbl;
153  int pos;
154  int capa;
155  struct vtable *prev;
156 };
157 
158 struct local_vars {
159  struct vtable *args;
160  struct vtable *vars;
161  struct vtable *used;
162  struct local_vars *prev;
164 };
165 
166 #define DVARS_INHERIT ((void*)1)
167 #define DVARS_TOPSCOPE NULL
168 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
169 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
170 
171 static int
172 vtable_size(const struct vtable *tbl)
173 {
174  if (POINTER_P(tbl)) {
175  return tbl->pos;
176  }
177  else {
178  return 0;
179  }
180 }
181 
182 #define VTBL_DEBUG 0
183 
184 static struct vtable *
186 {
187  struct vtable *tbl = ALLOC(struct vtable);
188  tbl->pos = 0;
189  tbl->capa = 8;
190  tbl->tbl = ALLOC_N(ID, tbl->capa);
191  tbl->prev = prev;
192  if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
193  return tbl;
194 }
195 
196 static void
198 {
199  if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
200  if (POINTER_P(tbl)) {
201  if (tbl->tbl) {
202  xfree(tbl->tbl);
203  }
204  xfree(tbl);
205  }
206 }
207 
208 static void
209 vtable_add(struct vtable *tbl, ID id)
210 {
211  if (!POINTER_P(tbl)) {
212  rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
213  }
214  if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
215 
216  if (tbl->pos == tbl->capa) {
217  tbl->capa = tbl->capa * 2;
218  REALLOC_N(tbl->tbl, ID, tbl->capa);
219  }
220  tbl->tbl[tbl->pos++] = id;
221 }
222 
223 static int
224 vtable_included(const struct vtable * tbl, ID id)
225 {
226  int i;
227 
228  if (POINTER_P(tbl)) {
229  for (i = 0; i < tbl->pos; i++) {
230  if (tbl->tbl[i] == id) {
231  return i+1;
232  }
233  }
234  }
235  return 0;
236 }
237 
238 
239 #ifndef RIPPER
240 typedef struct token_info {
241  const char *token;
242  int linenum;
243  int column;
244  int nonspc;
245  struct token_info *next;
246 } token_info;
247 #endif
248 
249 /*
250  Structure of Lexer Buffer:
251 
252  lex_pbeg tokp lex_p lex_pend
253  | | | |
254  |-----------+--------------+------------|
255  |<------------>|
256  token
257 */
261 
264 
283  const char *parser_lex_pbeg;
284  const char *parser_lex_p;
285  const char *parser_lex_pend;
295  char *parser_ruby_sourcefile; /* current source file */
296  int parser_ruby_sourceline; /* current line no. */
299 
301 
302 #ifndef RIPPER
303  /* Ruby core only */
308  int nerr;
309 
312 #else
313  /* Ripper only */
314  VALUE parser_ruby_sourcefile_string;
315  const char *tokp;
316  VALUE delayed;
317  int delayed_line;
318  int delayed_col;
319 
320  VALUE value;
321  VALUE result;
322  VALUE parsing_thread;
323  int toplevel_p;
324 #endif
325 };
326 
327 #define UTF8_ENC() (parser->utf8 ? parser->utf8 : \
328  (parser->utf8 = rb_utf8_encoding()))
329 #define STR_NEW(p,n) rb_enc_str_new((p),(n),parser->enc)
330 #define STR_NEW0() rb_enc_str_new(0,0,parser->enc)
331 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),parser->enc)
332 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),parser->enc)
333 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
334 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), parser->enc)
335 
336 static int parser_yyerror(struct parser_params*, const char*);
337 #define yyerror(msg) parser_yyerror(parser, (msg))
338 
339 #define lex_strterm (parser->parser_lex_strterm)
340 #define lex_state (parser->parser_lex_state)
341 #define cond_stack (parser->parser_cond_stack)
342 #define cmdarg_stack (parser->parser_cmdarg_stack)
343 #define class_nest (parser->parser_class_nest)
344 #define paren_nest (parser->parser_paren_nest)
345 #define lpar_beg (parser->parser_lpar_beg)
346 #define in_single (parser->parser_in_single)
347 #define in_def (parser->parser_in_def)
348 #define compile_for_eval (parser->parser_compile_for_eval)
349 #define cur_mid (parser->parser_cur_mid)
350 #define in_defined (parser->parser_in_defined)
351 #define tokenbuf (parser->parser_tokenbuf)
352 #define tokidx (parser->parser_tokidx)
353 #define toksiz (parser->parser_toksiz)
354 #define lex_input (parser->parser_lex_input)
355 #define lex_lastline (parser->parser_lex_lastline)
356 #define lex_nextline (parser->parser_lex_nextline)
357 #define lex_pbeg (parser->parser_lex_pbeg)
358 #define lex_p (parser->parser_lex_p)
359 #define lex_pend (parser->parser_lex_pend)
360 #define heredoc_end (parser->parser_heredoc_end)
361 #define command_start (parser->parser_command_start)
362 #define deferred_nodes (parser->parser_deferred_nodes)
363 #define lex_gets_ptr (parser->parser_lex_gets_ptr)
364 #define lex_gets (parser->parser_lex_gets)
365 #define lvtbl (parser->parser_lvtbl)
366 #define ruby__end__seen (parser->parser_ruby__end__seen)
367 #define ruby_sourceline (parser->parser_ruby_sourceline)
368 #define ruby_sourcefile (parser->parser_ruby_sourcefile)
369 #define current_enc (parser->enc)
370 #define yydebug (parser->parser_yydebug)
371 #ifdef RIPPER
372 #else
373 #define ruby_eval_tree (parser->parser_eval_tree)
374 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin)
375 #define ruby_debug_lines (parser->debug_lines)
376 #define ruby_coverage (parser->coverage)
377 #endif
378 
379 #if YYPURE
380 static int yylex(void*, void*);
381 #else
382 static int yylex(void*);
383 #endif
384 
385 #ifndef RIPPER
386 #define yyparse ruby_yyparse
387 
388 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
389 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
390 
391 static NODE *cond_gen(struct parser_params*,NODE*);
392 #define cond(node) cond_gen(parser, (node))
393 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
394 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
395 
396 static NODE *newline_node(NODE*);
397 static void fixpos(NODE*,NODE*);
398 
399 static int value_expr_gen(struct parser_params*,NODE*);
400 static void void_expr_gen(struct parser_params*,NODE*);
401 static NODE *remove_begin(NODE*);
402 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
403 #define void_expr0(node) void_expr_gen(parser, (node))
404 #define void_expr(node) void_expr0((node) = remove_begin(node))
405 static void void_stmts_gen(struct parser_params*,NODE*);
406 #define void_stmts(node) void_stmts_gen(parser, (node))
407 static void reduce_nodes_gen(struct parser_params*,NODE**);
408 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
409 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
410 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
411 
412 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
413 #define block_append(h,t) block_append_gen(parser,(h),(t))
414 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
415 #define list_append(l,i) list_append_gen(parser,(l),(i))
416 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
417 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
418 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
419 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
420 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
421 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
422 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
423 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
424 static int literal_concat0(struct parser_params *, VALUE, VALUE);
425 static NODE *new_evstr_gen(struct parser_params*,NODE*);
426 #define new_evstr(n) new_evstr_gen(parser,(n))
427 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
428 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
429 static NODE *splat_array(NODE*);
430 
431 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
432 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
433 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
434 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
435 
436 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,ID);
437 #define new_args(f,o,r,p,b) new_args_gen(parser, (f),(o),(r),(p),(b))
438 
439 static NODE *negate_lit(NODE*);
440 static NODE *ret_args_gen(struct parser_params*,NODE*);
441 #define ret_args(node) ret_args_gen(parser, (node))
442 static NODE *arg_blk_pass(NODE*,NODE*);
443 static NODE *new_yield_gen(struct parser_params*,NODE*);
444 #define new_yield(node) new_yield_gen(parser, (node))
445 
446 static NODE *gettable_gen(struct parser_params*,ID);
447 #define gettable(id) gettable_gen(parser,(id))
448 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
449 #define assignable(id,node) assignable_gen(parser, (id), (node))
450 
451 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
452 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
453 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
454 #define attrset(node,id) attrset_gen(parser, (node), (id))
455 
456 static void rb_backref_error_gen(struct parser_params*,NODE*);
457 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
458 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
459 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
460 
461 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
462 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
463 
464 static ID *local_tbl_gen(struct parser_params*);
465 #define local_tbl() local_tbl_gen(parser)
466 
467 static void fixup_nodes(NODE **);
468 
469 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
470 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
471 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
472 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
473 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
474 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
476 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
477 
478 #define get_id(id) (id)
479 #define get_value(val) (val)
480 #else
481 #define remove_begin(node) (node)
482 #define rb_dvar_defined(id) 0
483 #define rb_local_defined(id) 0
484 static ID ripper_get_id(VALUE);
485 #define get_id(id) ripper_get_id(id)
486 static VALUE ripper_get_value(VALUE);
487 #define get_value(val) ripper_get_value(val)
488 static VALUE assignable_gen(struct parser_params*,VALUE);
489 #define assignable(lhs,node) assignable_gen(parser, (lhs))
490 static int id_is_var_gen(struct parser_params *parser, ID id);
491 #define id_is_var(id) id_is_var_gen(parser, (id))
492 #endif /* !RIPPER */
493 
494 static ID formal_argument_gen(struct parser_params*, ID);
495 #define formal_argument(id) formal_argument_gen(parser, (id))
496 static ID shadowing_lvar_gen(struct parser_params*,ID);
497 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
498 static void new_bv_gen(struct parser_params*,ID);
499 #define new_bv(id) new_bv_gen(parser, (id))
500 
501 static void local_push_gen(struct parser_params*,int);
502 #define local_push(top) local_push_gen(parser,(top))
503 static void local_pop_gen(struct parser_params*);
504 #define local_pop() local_pop_gen(parser)
505 static int local_var_gen(struct parser_params*, ID);
506 #define local_var(id) local_var_gen(parser, (id));
507 static int arg_var_gen(struct parser_params*, ID);
508 #define arg_var(id) arg_var_gen(parser, (id))
509 static int local_id_gen(struct parser_params*, ID);
510 #define local_id(id) local_id_gen(parser, (id))
511 static ID internal_id_gen(struct parser_params*);
512 #define internal_id() internal_id_gen(parser)
513 
514 static const struct vtable *dyna_push_gen(struct parser_params *);
515 #define dyna_push() dyna_push_gen(parser)
516 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
517 #define dyna_pop(node) dyna_pop_gen(parser, (node))
518 static int dyna_in_block_gen(struct parser_params*);
519 #define dyna_in_block() dyna_in_block_gen(parser)
520 #define dyna_var(id) local_var(id)
521 static int dvar_defined_gen(struct parser_params*,ID,int);
522 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
523 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
524 static int dvar_curr_gen(struct parser_params*,ID);
525 #define dvar_curr(id) dvar_curr_gen(parser, (id))
526 
527 static int lvar_defined_gen(struct parser_params*, ID);
528 #define lvar_defined(id) lvar_defined_gen(parser, (id))
529 
530 #define RE_OPTION_ONCE (1<<16)
531 #define RE_OPTION_ENCODING_SHIFT 8
532 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
533 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
534 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
535 #define RE_OPTION_MASK 0xff
536 #define RE_OPTION_ARG_ENCODING_NONE 32
537 
538 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
539 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
540 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
541 #define nd_func u1.id
542 #if SIZEOF_SHORT == 2
543 #define nd_term(node) ((signed short)(node)->u2.id)
544 #else
545 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
546 #endif
547 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
548 #define nd_nest u3.cnt
549 
550 /****** Ripper *******/
551 
552 #ifdef RIPPER
553 #define RIPPER_VERSION "0.1.0"
554 
555 #include "eventids1.c"
556 #include "eventids2.c"
557 static ID ripper_id_gets;
558 
559 static VALUE ripper_dispatch0(struct parser_params*,ID);
560 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
561 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
562 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
563 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
564 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
565 
566 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
567 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
568 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
569 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
570 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
571 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
572 
573 #define yyparse ripper_yyparse
574 
575 #define ripper_intern(s) ID2SYM(rb_intern(s))
576 static VALUE ripper_id2sym(ID);
577 #ifdef __GNUC__
578 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
579  ID2SYM(id) : ripper_id2sym(id))
580 #endif
581 
582 #define arg_new() dispatch0(args_new)
583 #define arg_add(l,a) dispatch2(args_add, (l), (a))
584 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
585 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
586 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
587 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
588 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
589 
590 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
591 #define mrhs_new() dispatch0(mrhs_new)
592 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
593 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
594 
595 #define mlhs_new() dispatch0(mlhs_new)
596 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
597 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
598 
599 #define params_new(pars, opts, rest, pars2, blk) \
600  dispatch5(params, (pars), (opts), (rest), (pars2), (blk))
601 
602 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
603 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
604 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
605 
606 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
607 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
608 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
609 
610 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
611 
612 #define FIXME 0
613 
614 #endif /* RIPPER */
615 
616 #ifndef RIPPER
617 # define ifndef_ripper(x) (x)
618 #else
619 # define ifndef_ripper(x)
620 #endif
621 
622 #ifndef RIPPER
623 # define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
624 # define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
625 # define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
626 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
627 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
628 #else
629 # define rb_warn0(fmt) ripper_warn0(parser, (fmt))
630 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))
631 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))
632 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
633 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
634 static void ripper_warn0(struct parser_params*, const char*);
635 static void ripper_warnI(struct parser_params*, const char*, int);
636 #if 0
637 static void ripper_warnS(struct parser_params*, const char*, const char*);
638 #endif
639 static void ripper_warning0(struct parser_params*, const char*);
640 static void ripper_warningS(struct parser_params*, const char*, const char*);
641 #endif
642 
643 #ifdef RIPPER
644 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
645 # define rb_compile_error ripper_compile_error
646 # define compile_error ripper_compile_error
647 # define PARSER_ARG parser,
648 #else
649 # define rb_compile_error rb_compile_error_with_enc
650 # define compile_error parser->nerr++,rb_compile_error_with_enc
651 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
652 #endif
653 
654 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
655  for instance). This is too low for Ruby to parse some files, such as
656  date/format.rb, therefore bump the value up to at least Bison's default. */
657 #ifdef OLD_YACC
658 #ifndef YYMAXDEPTH
659 #define YYMAXDEPTH 10000
660 #endif
661 #endif
662 
663 #ifndef RIPPER
664 static void token_info_push(struct parser_params*, const char *token);
665 static void token_info_pop(struct parser_params*, const char *token);
666 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
667 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
668 #else
669 #define token_info_push(token) /* nothing */
670 #define token_info_pop(token) /* nothing */
671 #endif
672 
673 
674 /* Line 268 of yacc.c */
675 #line 676 "parse.c"
676 
677 /* Enabling traces. */
678 #ifndef YYDEBUG
679 # define YYDEBUG 1
680 #endif
681 
682 /* Enabling verbose error messages. */
683 #ifdef YYERROR_VERBOSE
684 # undef YYERROR_VERBOSE
685 # define YYERROR_VERBOSE 1
686 #else
687 # define YYERROR_VERBOSE 0
688 #endif
689 
690 /* Enabling the token table. */
691 #ifndef YYTOKEN_TABLE
692 # define YYTOKEN_TABLE 0
693 #endif
694 
695 
696 /* Tokens. */
697 #ifndef YYTOKENTYPE
698 # define YYTOKENTYPE
699  /* Put the tokens into the symbol table, so that GDB and other debuggers
700  know about them. */
701  enum yytokentype {
702  keyword_class = 258,
703  keyword_module = 259,
704  keyword_def = 260,
705  keyword_undef = 261,
706  keyword_begin = 262,
707  keyword_rescue = 263,
708  keyword_ensure = 264,
709  keyword_end = 265,
710  keyword_if = 266,
711  keyword_unless = 267,
712  keyword_then = 268,
713  keyword_elsif = 269,
714  keyword_else = 270,
715  keyword_case = 271,
716  keyword_when = 272,
717  keyword_while = 273,
718  keyword_until = 274,
719  keyword_for = 275,
720  keyword_break = 276,
721  keyword_next = 277,
722  keyword_redo = 278,
723  keyword_retry = 279,
724  keyword_in = 280,
725  keyword_do = 281,
726  keyword_do_cond = 282,
727  keyword_do_block = 283,
728  keyword_do_LAMBDA = 284,
729  keyword_return = 285,
730  keyword_yield = 286,
731  keyword_super = 287,
732  keyword_self = 288,
733  keyword_nil = 289,
734  keyword_true = 290,
735  keyword_false = 291,
736  keyword_and = 292,
737  keyword_or = 293,
738  keyword_not = 294,
739  modifier_if = 295,
740  modifier_unless = 296,
741  modifier_while = 297,
742  modifier_until = 298,
743  modifier_rescue = 299,
744  keyword_alias = 300,
745  keyword_defined = 301,
746  keyword_BEGIN = 302,
747  keyword_END = 303,
748  keyword__LINE__ = 304,
749  keyword__FILE__ = 305,
750  keyword__ENCODING__ = 306,
751  tIDENTIFIER = 307,
752  tFID = 308,
753  tGVAR = 309,
754  tIVAR = 310,
755  tCONSTANT = 311,
756  tCVAR = 312,
757  tLABEL = 313,
758  tINTEGER = 314,
759  tFLOAT = 315,
760  tSTRING_CONTENT = 316,
761  tCHAR = 317,
762  tNTH_REF = 318,
763  tBACK_REF = 319,
764  tREGEXP_END = 320,
765  tUPLUS = 321,
766  tUMINUS = 322,
767  tPOW = 323,
768  tCMP = 324,
769  tEQ = 325,
770  tEQQ = 326,
771  tNEQ = 327,
772  tGEQ = 328,
773  tLEQ = 329,
774  tANDOP = 330,
775  tOROP = 331,
776  tMATCH = 332,
777  tNMATCH = 333,
778  tDOT2 = 334,
779  tDOT3 = 335,
780  tAREF = 336,
781  tASET = 337,
782  tLSHFT = 338,
783  tRSHFT = 339,
784  tCOLON2 = 340,
785  tCOLON3 = 341,
786  tOP_ASGN = 342,
787  tASSOC = 343,
788  tLPAREN = 344,
789  tLPAREN_ARG = 345,
790  tRPAREN = 346,
791  tLBRACK = 347,
792  tLBRACE = 348,
793  tLBRACE_ARG = 349,
794  tSTAR = 350,
795  tAMPER = 351,
796  tLAMBDA = 352,
797  tSYMBEG = 353,
798  tSTRING_BEG = 354,
799  tXSTRING_BEG = 355,
800  tREGEXP_BEG = 356,
801  tWORDS_BEG = 357,
802  tQWORDS_BEG = 358,
803  tSTRING_DBEG = 359,
804  tSTRING_DVAR = 360,
805  tSTRING_END = 361,
806  tLAMBEG = 362,
807  tLOWEST = 363,
808  tUMINUS_NUM = 364,
809  idNULL = 365,
810  idRespond_to = 366,
811  idIFUNC = 367,
812  idCFUNC = 368,
815  id_core_undef_method = 371,
816  id_core_define_method = 372,
818  id_core_set_postexe = 374,
819  tLAST_TOKEN = 375
820  };
821 #endif
822 
823 
824 
825 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
826 typedef union YYSTYPE
827 {
828 
829 /* Line 293 of yacc.c */
830 #line 620 "ripper.y"
831 
832  VALUE val;
833  NODE *node;
834  ID id;
835  int num;
836  const struct vtable *vars;
837 
838 
839 
840 /* Line 293 of yacc.c */
841 #line 842 "parse.c"
842 } YYSTYPE;
843 # define YYSTYPE_IS_TRIVIAL 1
844 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
845 # define YYSTYPE_IS_DECLARED 1
846 #endif
847 
848 
849 /* Copy the second part of user declarations. */
850 
851 
852 /* Line 343 of yacc.c */
853 #line 854 "parse.c"
854 
855 #ifdef short
856 # undef short
857 #endif
858 
859 #ifdef YYTYPE_UINT8
860 typedef YYTYPE_UINT8 yytype_uint8;
861 #else
862 typedef unsigned char yytype_uint8;
863 #endif
864 
865 #ifdef YYTYPE_INT8
866 typedef YYTYPE_INT8 yytype_int8;
867 #elif (defined __STDC__ || defined __C99__FUNC__ \
868  || defined __cplusplus || defined _MSC_VER)
869 typedef signed char yytype_int8;
870 #else
871 typedef short int yytype_int8;
872 #endif
873 
874 #ifdef YYTYPE_UINT16
875 typedef YYTYPE_UINT16 yytype_uint16;
876 #else
877 typedef unsigned short int yytype_uint16;
878 #endif
879 
880 #ifdef YYTYPE_INT16
881 typedef YYTYPE_INT16 yytype_int16;
882 #else
883 typedef short int yytype_int16;
884 #endif
885 
886 #ifndef YYSIZE_T
887 # ifdef __SIZE_TYPE__
888 # define YYSIZE_T __SIZE_TYPE__
889 # elif defined size_t
890 # define YYSIZE_T size_t
891 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
892  || defined __cplusplus || defined _MSC_VER)
893 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
894 # define YYSIZE_T size_t
895 # else
896 # define YYSIZE_T unsigned int
897 # endif
898 #endif
899 
900 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
901 
902 #ifndef YY_
903 # if defined YYENABLE_NLS && YYENABLE_NLS
904 # if ENABLE_NLS
905 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
906 # define YY_(msgid) dgettext ("bison-runtime", msgid)
907 # endif
908 # endif
909 # ifndef YY_
910 # define YY_(msgid) msgid
911 # endif
912 #endif
913 
914 /* Suppress unused-variable warnings by "using" E. */
915 #if ! defined lint || defined __GNUC__
916 # define YYUSE(e) ((void) (e))
917 #else
918 # define YYUSE(e) /* empty */
919 #endif
920 
921 /* Identity function, used to suppress warnings about constant conditions. */
922 #ifndef lint
923 # define YYID(n) (n)
924 #else
925 #if (defined __STDC__ || defined __C99__FUNC__ \
926  || defined __cplusplus || defined _MSC_VER)
927 static int
928 YYID (int yyi)
929 #else
930 static int
931 YYID (yyi)
932  int yyi;
933 #endif
934 {
935  return yyi;
936 }
937 #endif
938 
939 #if ! defined yyoverflow || YYERROR_VERBOSE
940 
941 /* The parser invokes alloca or malloc; define the necessary symbols. */
942 
943 # ifdef YYSTACK_USE_ALLOCA
944 # if YYSTACK_USE_ALLOCA
945 # ifdef __GNUC__
946 # define YYSTACK_ALLOC __builtin_alloca
947 # elif defined __BUILTIN_VA_ARG_INCR
948 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
949 # elif defined _AIX
950 # define YYSTACK_ALLOC __alloca
951 # elif defined _MSC_VER
952 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
953 # define alloca _alloca
954 # else
955 # define YYSTACK_ALLOC alloca
956 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
957  || defined __cplusplus || defined _MSC_VER)
958 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
959 # ifndef EXIT_SUCCESS
960 # define EXIT_SUCCESS 0
961 # endif
962 # endif
963 # endif
964 # endif
965 # endif
966 
967 # ifdef YYSTACK_ALLOC
968  /* Pacify GCC's `empty if-body' warning. */
969 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
970 # ifndef YYSTACK_ALLOC_MAXIMUM
971  /* The OS might guarantee only one guard page at the bottom of the stack,
972  and a page size can be as small as 4096 bytes. So we cannot safely
973  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
974  to allow for a few compiler-allocated temporary stack slots. */
975 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
976 # endif
977 # else
978 # define YYSTACK_ALLOC YYMALLOC
979 # define YYSTACK_FREE YYFREE
980 # ifndef YYSTACK_ALLOC_MAXIMUM
981 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
982 # endif
983 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
984  && ! ((defined YYMALLOC || defined malloc) \
985  && (defined YYFREE || defined free)))
986 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
987 # ifndef EXIT_SUCCESS
988 # define EXIT_SUCCESS 0
989 # endif
990 # endif
991 # ifndef YYMALLOC
992 # define YYMALLOC malloc
993 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
994  || defined __cplusplus || defined _MSC_VER)
995 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
996 # endif
997 # endif
998 # ifndef YYFREE
999 # define YYFREE free
1000 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1001  || defined __cplusplus || defined _MSC_VER)
1002 void free (void *); /* INFRINGES ON USER NAME SPACE */
1003 # endif
1004 # endif
1005 # endif
1006 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1007 
1008 
1009 #if (! defined yyoverflow \
1010  && (! defined __cplusplus \
1011  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1012 
1013 /* A type that is properly aligned for any stack member. */
1014 union yyalloc
1015 {
1018 };
1019 
1020 /* The size of the maximum gap between one aligned stack and the next. */
1021 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1022 
1023 /* The size of an array large to enough to hold all stacks, each with
1024  N elements. */
1025 # define YYSTACK_BYTES(N) \
1026  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1027  + YYSTACK_GAP_MAXIMUM)
1028 
1029 # define YYCOPY_NEEDED 1
1030 
1031 /* Relocate STACK from its old location to the new one. The
1032  local variables YYSIZE and YYSTACKSIZE give the old and new number of
1033  elements in the stack, and YYPTR gives the new location of the
1034  stack. Advance YYPTR to a properly aligned location for the next
1035  stack. */
1036 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1037  do \
1038  { \
1039  YYSIZE_T yynewbytes; \
1040  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1041  Stack = &yyptr->Stack_alloc; \
1042  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1043  yyptr += yynewbytes / sizeof (*yyptr); \
1044  } \
1045  while (YYID (0))
1046 
1047 #endif
1048 
1049 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1050 /* Copy COUNT objects from FROM to TO. The source and destination do
1051  not overlap. */
1052 # ifndef YYCOPY
1053 # if defined __GNUC__ && 1 < __GNUC__
1054 # define YYCOPY(To, From, Count) \
1055  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1056 # else
1057 # define YYCOPY(To, From, Count) \
1058  do \
1059  { \
1060  YYSIZE_T yyi; \
1061  for (yyi = 0; yyi < (Count); yyi++) \
1062  (To)[yyi] = (From)[yyi]; \
1063  } \
1064  while (YYID (0))
1065 # endif
1066 # endif
1067 #endif /* !YYCOPY_NEEDED */
1068 
1069 /* YYFINAL -- State number of the termination state. */
1070 #define YYFINAL 3
1071 /* YYLAST -- Last index in YYTABLE. */
1072 #define YYLAST 10748
1073 
1074 /* YYNTOKENS -- Number of terminals. */
1075 #define YYNTOKENS 148
1076 /* YYNNTS -- Number of nonterminals. */
1077 #define YYNNTS 174
1078 /* YYNRULES -- Number of rules. */
1079 #define YYNRULES 573
1080 /* YYNRULES -- Number of states. */
1081 #define YYNSTATES 991
1082 
1083 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1084 #define YYUNDEFTOK 2
1085 #define YYMAXUTOK 375
1086 
1087 #define YYTRANSLATE(YYX) \
1088  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1089 
1090 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1091 static const yytype_uint8 yytranslate[] =
1092 {
1093  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1094  147, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1095  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1096  2, 2, 146, 123, 2, 2, 2, 121, 116, 2,
1097  142, 143, 119, 117, 140, 118, 139, 120, 2, 2,
1098  2, 2, 2, 2, 2, 2, 2, 2, 111, 145,
1099  113, 109, 112, 110, 2, 2, 2, 2, 2, 2,
1100  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1101  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1102  2, 138, 2, 144, 115, 2, 141, 2, 2, 2,
1103  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1104  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1105  2, 2, 2, 136, 114, 137, 124, 2, 2, 2,
1106  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1107  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1108  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1109  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1110  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1111  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1112  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1113  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1114  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1115  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1116  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1117  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1118  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1119  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1120  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1121  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1122  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1123  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1124  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1125  65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1126  75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
1127  85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
1128  95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
1129  105, 106, 107, 108, 122, 125, 126, 127, 128, 129,
1130  130, 131, 132, 133, 134, 135
1131 };
1132 
1133 #if YYDEBUG
1134 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1135  YYRHS. */
1136 static const yytype_uint16 yyprhs[] =
1137 {
1138  0, 0, 3, 4, 7, 10, 12, 14, 18, 21,
1139  23, 24, 30, 35, 38, 40, 42, 46, 49, 50,
1140  55, 59, 63, 67, 70, 74, 78, 82, 86, 90,
1141  95, 97, 101, 105, 112, 118, 124, 130, 136, 140,
1142  144, 148, 152, 154, 158, 162, 164, 168, 172, 176,
1143  179, 181, 183, 185, 187, 189, 194, 199, 200, 206,
1144  209, 213, 218, 224, 229, 235, 238, 241, 244, 247,
1145  250, 252, 256, 258, 262, 264, 267, 271, 277, 280,
1146  285, 288, 293, 295, 299, 301, 305, 308, 312, 314,
1147  318, 320, 322, 327, 331, 335, 339, 343, 346, 348,
1148  350, 352, 357, 361, 365, 369, 373, 376, 378, 380,
1149  382, 385, 387, 391, 393, 395, 397, 399, 401, 403,
1150  405, 407, 409, 411, 412, 417, 419, 421, 423, 425,
1151  427, 429, 431, 433, 435, 437, 439, 441, 443, 445,
1152  447, 449, 451, 453, 455, 457, 459, 461, 463, 465,
1153  467, 469, 471, 473, 475, 477, 479, 481, 483, 485,
1154  487, 489, 491, 493, 495, 497, 499, 501, 503, 505,
1155  507, 509, 511, 513, 515, 517, 519, 521, 523, 525,
1156  527, 529, 531, 533, 535, 537, 539, 541, 543, 545,
1157  547, 549, 551, 553, 555, 557, 561, 567, 571, 577,
1158  584, 590, 596, 602, 608, 613, 617, 621, 625, 629,
1159  633, 637, 641, 645, 649, 654, 659, 662, 665, 669,
1160  673, 677, 681, 685, 689, 693, 697, 701, 705, 709,
1161  713, 717, 720, 723, 727, 731, 735, 739, 740, 745,
1162  752, 754, 756, 758, 761, 766, 769, 773, 775, 777,
1163  779, 781, 784, 789, 792, 794, 797, 800, 805, 807,
1164  808, 811, 814, 817, 819, 821, 824, 828, 833, 837,
1165  842, 845, 847, 849, 851, 853, 855, 857, 859, 861,
1166  863, 864, 869, 870, 875, 879, 883, 886, 890, 894,
1167  896, 901, 905, 907, 908, 915, 920, 924, 927, 929,
1168  932, 935, 942, 949, 950, 951, 959, 960, 961, 969,
1169  975, 980, 981, 982, 992, 993, 1000, 1001, 1002, 1011,
1170  1012, 1018, 1019, 1026, 1027, 1028, 1038, 1040, 1042, 1044,
1171  1046, 1048, 1050, 1052, 1054, 1056, 1058, 1060, 1062, 1064,
1172  1066, 1068, 1070, 1072, 1074, 1077, 1079, 1081, 1083, 1089,
1173  1091, 1094, 1096, 1098, 1100, 1104, 1106, 1110, 1112, 1117,
1174  1124, 1128, 1134, 1137, 1142, 1144, 1148, 1155, 1164, 1169,
1175  1176, 1181, 1184, 1191, 1194, 1199, 1206, 1209, 1214, 1217,
1176  1222, 1224, 1226, 1228, 1232, 1234, 1239, 1241, 1244, 1246,
1177  1250, 1252, 1254, 1255, 1256, 1261, 1266, 1268, 1272, 1276,
1178  1277, 1283, 1286, 1291, 1296, 1299, 1304, 1309, 1313, 1317,
1179  1321, 1324, 1326, 1331, 1332, 1338, 1339, 1345, 1351, 1353,
1180  1355, 1362, 1364, 1366, 1368, 1370, 1373, 1375, 1378, 1380,
1181  1382, 1384, 1386, 1388, 1390, 1392, 1395, 1399, 1403, 1407,
1182  1411, 1415, 1416, 1420, 1422, 1425, 1429, 1433, 1434, 1438,
1183  1439, 1442, 1443, 1446, 1447, 1450, 1452, 1453, 1457, 1458,
1184  1459, 1465, 1467, 1469, 1471, 1473, 1476, 1478, 1480, 1482,
1185  1484, 1488, 1490, 1492, 1495, 1498, 1500, 1502, 1504, 1506,
1186  1508, 1510, 1512, 1514, 1516, 1518, 1520, 1522, 1524, 1526,
1187  1528, 1530, 1532, 1534, 1536, 1537, 1542, 1545, 1549, 1552,
1188  1559, 1568, 1573, 1580, 1585, 1592, 1595, 1600, 1607, 1610,
1189  1615, 1618, 1623, 1625, 1626, 1628, 1630, 1632, 1634, 1636,
1190  1638, 1640, 1644, 1646, 1650, 1654, 1658, 1660, 1664, 1666,
1191  1670, 1672, 1674, 1677, 1679, 1681, 1683, 1686, 1689, 1691,
1192  1693, 1694, 1699, 1701, 1704, 1706, 1710, 1714, 1717, 1719,
1193  1721, 1723, 1725, 1727, 1729, 1731, 1733, 1735, 1737, 1739,
1194  1741, 1742, 1744, 1745, 1747, 1750, 1753, 1754, 1756, 1758,
1195  1760, 1762, 1764, 1767
1196 };
1197 
1198 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1199 static const yytype_int16 yyrhs[] =
1200 {
1201  149, 0, -1, -1, 150, 151, -1, 152, 314, -1,
1202  321, -1, 153, -1, 152, 320, 153, -1, 1, 153,
1203  -1, 158, -1, -1, 47, 154, 136, 151, 137, -1,
1204  156, 256, 231, 259, -1, 157, 314, -1, 321, -1,
1205  158, -1, 157, 320, 158, -1, 1, 158, -1, -1,
1206  45, 180, 159, 180, -1, 45, 54, 54, -1, 45,
1207  54, 64, -1, 45, 54, 63, -1, 6, 181, -1,
1208  158, 40, 162, -1, 158, 41, 162, -1, 158, 42,
1209  162, -1, 158, 43, 162, -1, 158, 44, 158, -1,
1210  48, 136, 156, 137, -1, 160, -1, 168, 109, 163,
1211  -1, 286, 87, 163, -1, 216, 138, 191, 317, 87,
1212  163, -1, 216, 139, 52, 87, 163, -1, 216, 139,
1213  56, 87, 163, -1, 216, 85, 56, 87, 163, -1,
1214  216, 85, 52, 87, 163, -1, 287, 87, 163, -1,
1215  175, 109, 198, -1, 168, 109, 187, -1, 168, 109,
1216  198, -1, 161, -1, 175, 109, 163, -1, 175, 109,
1217  160, -1, 163, -1, 161, 37, 161, -1, 161, 38,
1218  161, -1, 39, 315, 161, -1, 123, 163, -1, 185,
1219  -1, 161, -1, 167, -1, 164, -1, 249, -1, 249,
1220  139, 311, 193, -1, 249, 85, 311, 193, -1, -1,
1221  94, 166, 237, 156, 137, -1, 310, 193, -1, 310,
1222  193, 165, -1, 216, 139, 311, 193, -1, 216, 139,
1223  311, 193, 165, -1, 216, 85, 311, 193, -1, 216,
1224  85, 311, 193, 165, -1, 32, 193, -1, 31, 193,
1225  -1, 30, 192, -1, 21, 192, -1, 22, 192, -1,
1226  170, -1, 89, 169, 316, -1, 170, -1, 89, 169,
1227  316, -1, 172, -1, 172, 171, -1, 172, 95, 174,
1228  -1, 172, 95, 174, 140, 173, -1, 172, 95, -1,
1229  172, 95, 140, 173, -1, 95, 174, -1, 95, 174,
1230  140, 173, -1, 95, -1, 95, 140, 173, -1, 174,
1231  -1, 89, 169, 316, -1, 171, 140, -1, 172, 171,
1232  140, -1, 171, -1, 173, 140, 171, -1, 283, -1,
1233  284, -1, 216, 138, 191, 317, -1, 216, 139, 52,
1234  -1, 216, 85, 52, -1, 216, 139, 56, -1, 216,
1235  85, 56, -1, 86, 56, -1, 287, -1, 283, -1,
1236  284, -1, 216, 138, 191, 317, -1, 216, 139, 52,
1237  -1, 216, 85, 52, -1, 216, 139, 56, -1, 216,
1238  85, 56, -1, 86, 56, -1, 287, -1, 52, -1,
1239  56, -1, 86, 176, -1, 176, -1, 216, 85, 176,
1240  -1, 52, -1, 56, -1, 53, -1, 183, -1, 184,
1241  -1, 178, -1, 279, -1, 179, -1, 281, -1, 180,
1242  -1, -1, 181, 140, 182, 180, -1, 114, -1, 115,
1243  -1, 116, -1, 69, -1, 70, -1, 71, -1, 77,
1244  -1, 78, -1, 112, -1, 73, -1, 113, -1, 74,
1245  -1, 72, -1, 83, -1, 84, -1, 117, -1, 118,
1246  -1, 119, -1, 95, -1, 120, -1, 121, -1, 68,
1247  -1, 123, -1, 124, -1, 66, -1, 67, -1, 81,
1248  -1, 82, -1, 141, -1, 49, -1, 50, -1, 51,
1249  -1, 47, -1, 48, -1, 45, -1, 37, -1, 7,
1250  -1, 21, -1, 16, -1, 3, -1, 5, -1, 46,
1251  -1, 26, -1, 15, -1, 14, -1, 10, -1, 9,
1252  -1, 36, -1, 20, -1, 25, -1, 4, -1, 22,
1253  -1, 34, -1, 39, -1, 38, -1, 23, -1, 8,
1254  -1, 24, -1, 30, -1, 33, -1, 32, -1, 13,
1255  -1, 35, -1, 6, -1, 17, -1, 31, -1, 11,
1256  -1, 12, -1, 18, -1, 19, -1, 175, 109, 185,
1257  -1, 175, 109, 185, 44, 185, -1, 286, 87, 185,
1258  -1, 286, 87, 185, 44, 185, -1, 216, 138, 191,
1259  317, 87, 185, -1, 216, 139, 52, 87, 185, -1,
1260  216, 139, 56, 87, 185, -1, 216, 85, 52, 87,
1261  185, -1, 216, 85, 56, 87, 185, -1, 86, 56,
1262  87, 185, -1, 287, 87, 185, -1, 185, 79, 185,
1263  -1, 185, 80, 185, -1, 185, 117, 185, -1, 185,
1264  118, 185, -1, 185, 119, 185, -1, 185, 120, 185,
1265  -1, 185, 121, 185, -1, 185, 68, 185, -1, 122,
1266  59, 68, 185, -1, 122, 60, 68, 185, -1, 66,
1267  185, -1, 67, 185, -1, 185, 114, 185, -1, 185,
1268  115, 185, -1, 185, 116, 185, -1, 185, 69, 185,
1269  -1, 185, 112, 185, -1, 185, 73, 185, -1, 185,
1270  113, 185, -1, 185, 74, 185, -1, 185, 70, 185,
1271  -1, 185, 71, 185, -1, 185, 72, 185, -1, 185,
1272  77, 185, -1, 185, 78, 185, -1, 123, 185, -1,
1273  124, 185, -1, 185, 83, 185, -1, 185, 84, 185,
1274  -1, 185, 75, 185, -1, 185, 76, 185, -1, -1,
1275  46, 315, 186, 185, -1, 185, 110, 185, 315, 111,
1276  185, -1, 199, -1, 185, -1, 321, -1, 197, 318,
1277  -1, 197, 140, 308, 318, -1, 308, 318, -1, 142,
1278  191, 316, -1, 321, -1, 189, -1, 321, -1, 192,
1279  -1, 197, 140, -1, 197, 140, 308, 140, -1, 308,
1280  140, -1, 167, -1, 197, 196, -1, 308, 196, -1,
1281  197, 140, 308, 196, -1, 195, -1, -1, 194, 192,
1282  -1, 96, 187, -1, 140, 195, -1, 321, -1, 187,
1283  -1, 95, 187, -1, 197, 140, 187, -1, 197, 140,
1284  95, 187, -1, 197, 140, 187, -1, 197, 140, 95,
1285  187, -1, 95, 187, -1, 260, -1, 261, -1, 264,
1286  -1, 265, -1, 266, -1, 269, -1, 285, -1, 287,
1287  -1, 53, -1, -1, 217, 200, 155, 227, -1, -1,
1288  90, 161, 201, 316, -1, 89, 156, 143, -1, 216,
1289  85, 56, -1, 86, 56, -1, 92, 188, 144, -1,
1290  93, 307, 137, -1, 30, -1, 31, 142, 192, 316,
1291  -1, 31, 142, 316, -1, 31, -1, -1, 46, 315,
1292  142, 202, 161, 316, -1, 39, 142, 161, 316, -1,
1293  39, 142, 316, -1, 310, 251, -1, 250, -1, 250,
1294  251, -1, 97, 242, -1, 218, 162, 228, 156, 230,
1295  227, -1, 219, 162, 228, 156, 231, 227, -1, -1,
1296  -1, 220, 203, 162, 229, 204, 156, 227, -1, -1,
1297  -1, 221, 205, 162, 229, 206, 156, 227, -1, 222,
1298  162, 314, 254, 227, -1, 222, 314, 254, 227, -1,
1299  -1, -1, 223, 232, 25, 207, 162, 229, 208, 156,
1300  227, -1, -1, 224, 177, 288, 209, 155, 227, -1,
1301  -1, -1, 224, 83, 161, 210, 319, 211, 155, 227,
1302  -1, -1, 225, 177, 212, 155, 227, -1, -1, 226,
1303  178, 213, 290, 155, 227, -1, -1, -1, 226, 305,
1304  313, 214, 178, 215, 290, 155, 227, -1, 21, -1,
1305  22, -1, 23, -1, 24, -1, 199, -1, 7, -1,
1306  11, -1, 12, -1, 18, -1, 19, -1, 16, -1,
1307  20, -1, 3, -1, 4, -1, 5, -1, 10, -1,
1308  319, -1, 13, -1, 319, 13, -1, 319, -1, 27,
1309  -1, 231, -1, 14, 162, 228, 156, 230, -1, 321,
1310  -1, 15, 156, -1, 175, -1, 168, -1, 293, -1,
1311  89, 235, 316, -1, 233, -1, 234, 140, 233, -1,
1312  234, -1, 234, 140, 95, 293, -1, 234, 140, 95,
1313  293, 140, 234, -1, 234, 140, 95, -1, 234, 140,
1314  95, 140, 234, -1, 95, 293, -1, 95, 293, 140,
1315  234, -1, 95, -1, 95, 140, 234, -1, 295, 140,
1316  298, 140, 301, 304, -1, 295, 140, 298, 140, 301,
1317  140, 295, 304, -1, 295, 140, 298, 304, -1, 295,
1318  140, 298, 140, 295, 304, -1, 295, 140, 301, 304,
1319  -1, 295, 140, -1, 295, 140, 301, 140, 295, 304,
1320  -1, 295, 304, -1, 298, 140, 301, 304, -1, 298,
1321  140, 301, 140, 295, 304, -1, 298, 304, -1, 298,
1322  140, 295, 304, -1, 301, 304, -1, 301, 140, 295,
1323  304, -1, 303, -1, 321, -1, 238, -1, 114, 239,
1324  114, -1, 76, -1, 114, 236, 239, 114, -1, 321,
1325  -1, 145, 240, -1, 241, -1, 240, 140, 241, -1,
1326  52, -1, 292, -1, -1, -1, 243, 244, 245, 246,
1327  -1, 142, 291, 239, 316, -1, 291, -1, 107, 156,
1328  137, -1, 29, 156, 10, -1, -1, 28, 248, 237,
1329  156, 10, -1, 167, 247, -1, 249, 139, 311, 190,
1330  -1, 249, 85, 311, 190, -1, 310, 189, -1, 216,
1331  139, 311, 190, -1, 216, 85, 311, 189, -1, 216,
1332  85, 312, -1, 216, 139, 189, -1, 216, 85, 189,
1333  -1, 32, 189, -1, 32, -1, 216, 138, 191, 317,
1334  -1, -1, 136, 252, 237, 156, 137, -1, -1, 26,
1335  253, 237, 156, 10, -1, 17, 197, 228, 156, 255,
1336  -1, 231, -1, 254, -1, 8, 257, 258, 228, 156,
1337  256, -1, 321, -1, 187, -1, 198, -1, 321, -1,
1338  88, 175, -1, 321, -1, 9, 156, -1, 321, -1,
1339  282, -1, 279, -1, 281, -1, 262, -1, 62, -1,
1340  263, -1, 262, 263, -1, 99, 271, 106, -1, 100,
1341  272, 106, -1, 101, 273, 65, -1, 102, 146, 106,
1342  -1, 102, 267, 106, -1, -1, 267, 268, 146, -1,
1343  274, -1, 268, 274, -1, 103, 146, 106, -1, 103,
1344  270, 106, -1, -1, 270, 61, 146, -1, -1, 271,
1345  274, -1, -1, 272, 274, -1, -1, 273, 274, -1,
1346  61, -1, -1, 105, 275, 278, -1, -1, -1, 104,
1347  276, 277, 156, 137, -1, 54, -1, 55, -1, 57,
1348  -1, 287, -1, 98, 280, -1, 178, -1, 55, -1,
1349  54, -1, 57, -1, 98, 272, 106, -1, 59, -1,
1350  60, -1, 122, 59, -1, 122, 60, -1, 52, -1,
1351  55, -1, 54, -1, 56, -1, 57, -1, 34, -1,
1352  33, -1, 35, -1, 36, -1, 50, -1, 49, -1,
1353  51, -1, 283, -1, 284, -1, 283, -1, 284, -1,
1354  63, -1, 64, -1, 319, -1, -1, 113, 289, 162,
1355  319, -1, 1, 319, -1, 142, 291, 316, -1, 291,
1356  319, -1, 295, 140, 299, 140, 301, 304, -1, 295,
1357  140, 299, 140, 301, 140, 295, 304, -1, 295, 140,
1358  299, 304, -1, 295, 140, 299, 140, 295, 304, -1,
1359  295, 140, 301, 304, -1, 295, 140, 301, 140, 295,
1360  304, -1, 295, 304, -1, 299, 140, 301, 304, -1,
1361  299, 140, 301, 140, 295, 304, -1, 299, 304, -1,
1362  299, 140, 295, 304, -1, 301, 304, -1, 301, 140,
1363  295, 304, -1, 303, -1, -1, 56, -1, 55, -1,
1364  54, -1, 57, -1, 292, -1, 52, -1, 293, -1,
1365  89, 235, 316, -1, 294, -1, 295, 140, 294, -1,
1366  52, 109, 187, -1, 52, 109, 216, -1, 297, -1,
1367  298, 140, 297, -1, 296, -1, 299, 140, 296, -1,
1368  119, -1, 95, -1, 300, 52, -1, 300, -1, 116,
1369  -1, 96, -1, 302, 52, -1, 140, 303, -1, 321,
1370  -1, 285, -1, -1, 142, 306, 161, 316, -1, 321,
1371  -1, 308, 318, -1, 309, -1, 308, 140, 309, -1,
1372  187, 88, 187, -1, 58, 187, -1, 52, -1, 56,
1373  -1, 53, -1, 52, -1, 56, -1, 53, -1, 183,
1374  -1, 52, -1, 53, -1, 183, -1, 139, -1, 85,
1375  -1, -1, 320, -1, -1, 147, -1, 315, 143, -1,
1376  315, 144, -1, -1, 147, -1, 140, -1, 145, -1,
1377  147, -1, 319, -1, 320, 145, -1, -1
1378 };
1379 
1380 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1381 static const yytype_uint16 yyrline[] =
1382 {
1383  0, 786, 786, 786, 817, 828, 837, 845, 853, 859,
1384  861, 860, 884, 917, 928, 937, 945, 953, 959, 959,
1385  967, 975, 986, 996, 1004, 1013, 1022, 1035, 1048, 1057,
1386  1069, 1070, 1080, 1109, 1130, 1147, 1164, 1175, 1192, 1202,
1387  1211, 1220, 1229, 1232, 1241, 1253, 1254, 1262, 1270, 1278,
1388  1286, 1289, 1301, 1302, 1305, 1306, 1315, 1327, 1326, 1348,
1389  1357, 1369, 1378, 1390, 1399, 1411, 1420, 1429, 1437, 1445,
1390  1455, 1456, 1466, 1467, 1477, 1485, 1493, 1501, 1510, 1518,
1391  1527, 1535, 1544, 1552, 1563, 1564, 1574, 1582, 1592, 1600,
1392  1610, 1614, 1618, 1626, 1634, 1642, 1650, 1662, 1672, 1684,
1393  1693, 1702, 1710, 1718, 1726, 1734, 1747, 1760, 1771, 1779,
1394  1782, 1790, 1798, 1808, 1809, 1810, 1811, 1816, 1827, 1828,
1395  1831, 1839, 1842, 1850, 1850, 1860, 1861, 1862, 1863, 1864,
1396  1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874,
1397  1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, 1883, 1884,
1398  1885, 1886, 1887, 1888, 1891, 1891, 1891, 1892, 1892, 1893,
1399  1893, 1893, 1894, 1894, 1894, 1894, 1895, 1895, 1895, 1895,
1400  1896, 1896, 1896, 1897, 1897, 1897, 1897, 1898, 1898, 1898,
1401  1898, 1899, 1899, 1899, 1899, 1900, 1900, 1900, 1900, 1901,
1402  1901, 1901, 1901, 1902, 1902, 1905, 1914, 1924, 1953, 1984,
1403  2010, 2027, 2044, 2061, 2072, 2083, 2094, 2108, 2122, 2130,
1404  2138, 2146, 2154, 2162, 2170, 2179, 2188, 2196, 2204, 2212,
1405  2220, 2228, 2236, 2244, 2252, 2260, 2268, 2276, 2284, 2292,
1406  2303, 2311, 2319, 2327, 2335, 2343, 2351, 2359, 2359, 2369,
1407  2379, 2385, 2397, 2398, 2402, 2410, 2420, 2430, 2431, 2434,
1408  2435, 2436, 2440, 2448, 2458, 2467, 2475, 2485, 2494, 2503,
1409  2503, 2515, 2525, 2529, 2535, 2543, 2551, 2565, 2581, 2595,
1410  2610, 2620, 2621, 2622, 2623, 2624, 2625, 2626, 2627, 2628,
1411  2637, 2636, 2661, 2661, 2670, 2678, 2686, 2694, 2707, 2715,
1412  2723, 2731, 2739, 2747, 2747, 2757, 2765, 2773, 2784, 2785,
1413  2796, 2800, 2812, 2824, 2824, 2824, 2835, 2835, 2835, 2846,
1414  2857, 2866, 2868, 2865, 2932, 2931, 2953, 2958, 2952, 2977,
1415  2976, 2998, 2997, 3020, 3021, 3020, 3041, 3049, 3057, 3065,
1416  3075, 3087, 3093, 3099, 3105, 3111, 3117, 3123, 3129, 3135,
1417  3141, 3151, 3157, 3162, 3163, 3170, 3175, 3178, 3179, 3192,
1418  3193, 3203, 3204, 3207, 3215, 3225, 3233, 3243, 3251, 3260,
1419  3269, 3277, 3285, 3294, 3306, 3314, 3324, 3332, 3340, 3348,
1420  3356, 3364, 3373, 3381, 3389, 3397, 3405, 3413, 3421, 3429,
1421  3437, 3447, 3448, 3454, 3463, 3472, 3483, 3484, 3494, 3501,
1422  3510, 3518, 3524, 3527, 3524, 3545, 3553, 3563, 3567, 3574,
1423  3573, 3594, 3610, 3619, 3630, 3639, 3649, 3659, 3667, 3678,
1424  3689, 3697, 3705, 3720, 3719, 3739, 3738, 3759, 3771, 3772,
1425  3775, 3794, 3797, 3805, 3813, 3816, 3820, 3823, 3831, 3834,
1426  3835, 3843, 3846, 3863, 3864, 3865, 3875, 3885, 3912, 3977,
1427  3986, 3997, 4004, 4014, 4022, 4032, 4041, 4052, 4059, 4070,
1428  4077, 4088, 4095, 4106, 4113, 4142, 4144, 4143, 4160, 4166,
1429  4159, 4185, 4193, 4201, 4209, 4212, 4223, 4224, 4225, 4226,
1430  4229, 4259, 4260, 4261, 4269, 4279, 4280, 4281, 4282, 4283,
1431  4286, 4287, 4288, 4289, 4290, 4291, 4292, 4295, 4308, 4318,
1432  4326, 4336, 4337, 4340, 4349, 4348, 4356, 4368, 4378, 4386,
1433  4394, 4402, 4410, 4418, 4426, 4434, 4442, 4450, 4458, 4466,
1434  4474, 4482, 4490, 4499, 4508, 4517, 4526, 4535, 4546, 4547,
1435  4554, 4563, 4582, 4589, 4602, 4614, 4626, 4634, 4650, 4658,
1436  4674, 4675, 4678, 4691, 4702, 4703, 4706, 4723, 4727, 4737,
1437  4747, 4747, 4776, 4777, 4787, 4794, 4804, 4812, 4822, 4823,
1438  4824, 4827, 4828, 4829, 4830, 4833, 4834, 4835, 4838, 4843,
1439  4850, 4851, 4854, 4855, 4858, 4861, 4864, 4865, 4866, 4869,
1440  4870, 4873, 4874, 4878
1441 };
1442 #endif
1443 
1444 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1445 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1446  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1447 static const char *const yytname[] =
1448 {
1449  "$end", "error", "$undefined", "keyword_class", "keyword_module",
1450  "keyword_def", "keyword_undef", "keyword_begin", "keyword_rescue",
1451  "keyword_ensure", "keyword_end", "keyword_if", "keyword_unless",
1452  "keyword_then", "keyword_elsif", "keyword_else", "keyword_case",
1453  "keyword_when", "keyword_while", "keyword_until", "keyword_for",
1454  "keyword_break", "keyword_next", "keyword_redo", "keyword_retry",
1455  "keyword_in", "keyword_do", "keyword_do_cond", "keyword_do_block",
1456  "keyword_do_LAMBDA", "keyword_return", "keyword_yield", "keyword_super",
1457  "keyword_self", "keyword_nil", "keyword_true", "keyword_false",
1458  "keyword_and", "keyword_or", "keyword_not", "modifier_if",
1459  "modifier_unless", "modifier_while", "modifier_until", "modifier_rescue",
1460  "keyword_alias", "keyword_defined", "keyword_BEGIN", "keyword_END",
1461  "keyword__LINE__", "keyword__FILE__", "keyword__ENCODING__",
1462  "tIDENTIFIER", "tFID", "tGVAR", "tIVAR", "tCONSTANT", "tCVAR", "tLABEL",
1463  "tINTEGER", "tFLOAT", "tSTRING_CONTENT", "tCHAR", "tNTH_REF",
1464  "tBACK_REF", "tREGEXP_END", "tUPLUS", "tUMINUS", "tPOW", "tCMP", "tEQ",
1465  "tEQQ", "tNEQ", "tGEQ", "tLEQ", "tANDOP", "tOROP", "tMATCH", "tNMATCH",
1466  "tDOT2", "tDOT3", "tAREF", "tASET", "tLSHFT", "tRSHFT", "tCOLON2",
1467  "tCOLON3", "tOP_ASGN", "tASSOC", "tLPAREN", "tLPAREN_ARG", "tRPAREN",
1468  "tLBRACK", "tLBRACE", "tLBRACE_ARG", "tSTAR", "tAMPER", "tLAMBDA",
1469  "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG", "tWORDS_BEG",
1470  "tQWORDS_BEG", "tSTRING_DBEG", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
1471  "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
1472  "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "idNULL",
1473  "idRespond_to", "idIFUNC", "idCFUNC", "id_core_set_method_alias",
1474  "id_core_set_variable_alias", "id_core_undef_method",
1475  "id_core_define_method", "id_core_define_singleton_method",
1476  "id_core_set_postexe", "tLAST_TOKEN", "'{'", "'}'", "'['", "'.'", "','",
1477  "'`'", "'('", "')'", "']'", "';'", "' '", "'\\n'", "$accept", "program",
1478  "$@1", "top_compstmt", "top_stmts", "top_stmt", "$@2", "bodystmt",
1479  "compstmt", "stmts", "stmt", "$@3", "command_asgn", "expr", "expr_value",
1480  "command_call", "block_command", "cmd_brace_block", "@4", "command",
1481  "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head",
1482  "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
1483  "fitem", "undef_list", "$@5", "op", "reswords", "arg", "$@6",
1484  "arg_value", "aref_args", "paren_args", "opt_paren_args",
1485  "opt_call_args", "call_args", "command_args", "@7", "block_arg",
1486  "opt_block_arg", "args", "mrhs", "primary", "@8", "$@9", "$@10", "$@11",
1487  "$@12", "$@13", "$@14", "$@15", "$@16", "@17", "@18", "@19", "@20",
1488  "@21", "$@22", "$@23", "primary_value", "k_begin", "k_if", "k_unless",
1489  "k_while", "k_until", "k_case", "k_for", "k_class", "k_module", "k_def",
1490  "k_end", "then", "do", "if_tail", "opt_else", "for_var", "f_marg",
1491  "f_marg_list", "f_margs", "block_param", "opt_block_param",
1492  "block_param_def", "opt_bv_decl", "bv_decls", "bvar", "lambda", "@24",
1493  "@25", "f_larglist", "lambda_body", "do_block", "@26", "block_call",
1494  "method_call", "brace_block", "@27", "@28", "case_body", "cases",
1495  "opt_rescue", "exc_list", "exc_var", "opt_ensure", "literal", "strings",
1496  "string", "string1", "xstring", "regexp", "words", "word_list", "word",
1497  "qwords", "qword_list", "string_contents", "xstring_contents",
1498  "regexp_contents", "string_content", "@29", "@30", "@31", "string_dvar",
1499  "symbol", "sym", "dsym", "numeric", "user_variable", "keyword_variable",
1500  "var_ref", "var_lhs", "backref", "superclass", "$@32", "f_arglist",
1501  "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_opt",
1502  "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
1503  "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
1504  "singleton", "$@33", "assoc_list", "assocs", "assoc", "operation",
1505  "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
1506  "rparen", "rbracket", "trailer", "term", "terms", "none", 0
1507 };
1508 #endif
1509 
1510 # ifdef YYPRINT
1511 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1512  token YYLEX-NUM. */
1513 static const yytype_uint16 yytoknum[] =
1514 {
1515  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1516  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1517  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1518  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1519  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1520  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1521  315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
1522  325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
1523  335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
1524  345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1525  355, 356, 357, 358, 359, 360, 361, 362, 363, 61,
1526  63, 58, 62, 60, 124, 94, 38, 43, 45, 42,
1527  47, 37, 364, 33, 126, 365, 366, 367, 368, 369,
1528  370, 371, 372, 373, 374, 375, 123, 125, 91, 46,
1529  44, 96, 40, 41, 93, 59, 32, 10
1530 };
1531 # endif
1532 
1533 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1534 static const yytype_uint16 yyr1[] =
1535 {
1536  0, 148, 150, 149, 151, 152, 152, 152, 152, 153,
1537  154, 153, 155, 156, 157, 157, 157, 157, 159, 158,
1538  158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
1539  158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
1540  158, 158, 158, 160, 160, 161, 161, 161, 161, 161,
1541  161, 162, 163, 163, 164, 164, 164, 166, 165, 167,
1542  167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
1543  168, 168, 169, 169, 170, 170, 170, 170, 170, 170,
1544  170, 170, 170, 170, 171, 171, 172, 172, 173, 173,
1545  174, 174, 174, 174, 174, 174, 174, 174, 174, 175,
1546  175, 175, 175, 175, 175, 175, 175, 175, 176, 176,
1547  177, 177, 177, 178, 178, 178, 178, 178, 179, 179,
1548  180, 180, 181, 182, 181, 183, 183, 183, 183, 183,
1549  183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
1550  183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
1551  183, 183, 183, 183, 184, 184, 184, 184, 184, 184,
1552  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1553  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1554  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1555  184, 184, 184, 184, 184, 185, 185, 185, 185, 185,
1556  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
1557  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
1558  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
1559  185, 185, 185, 185, 185, 185, 185, 186, 185, 185,
1560  185, 187, 188, 188, 188, 188, 189, 190, 190, 191,
1561  191, 191, 191, 191, 192, 192, 192, 192, 192, 194,
1562  193, 195, 196, 196, 197, 197, 197, 197, 198, 198,
1563  198, 199, 199, 199, 199, 199, 199, 199, 199, 199,
1564  200, 199, 201, 199, 199, 199, 199, 199, 199, 199,
1565  199, 199, 199, 202, 199, 199, 199, 199, 199, 199,
1566  199, 199, 199, 203, 204, 199, 205, 206, 199, 199,
1567  199, 207, 208, 199, 209, 199, 210, 211, 199, 212,
1568  199, 213, 199, 214, 215, 199, 199, 199, 199, 199,
1569  216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1570  226, 227, 228, 228, 228, 229, 229, 230, 230, 231,
1571  231, 232, 232, 233, 233, 234, 234, 235, 235, 235,
1572  235, 235, 235, 235, 235, 235, 236, 236, 236, 236,
1573  236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
1574  236, 237, 237, 238, 238, 238, 239, 239, 240, 240,
1575  241, 241, 243, 244, 242, 245, 245, 246, 246, 248,
1576  247, 249, 249, 249, 250, 250, 250, 250, 250, 250,
1577  250, 250, 250, 252, 251, 253, 251, 254, 255, 255,
1578  256, 256, 257, 257, 257, 258, 258, 259, 259, 260,
1579  260, 260, 261, 262, 262, 262, 263, 264, 265, 266,
1580  266, 267, 267, 268, 268, 269, 269, 270, 270, 271,
1581  271, 272, 272, 273, 273, 274, 275, 274, 276, 277,
1582  274, 278, 278, 278, 278, 279, 280, 280, 280, 280,
1583  281, 282, 282, 282, 282, 283, 283, 283, 283, 283,
1584  284, 284, 284, 284, 284, 284, 284, 285, 285, 286,
1585  286, 287, 287, 288, 289, 288, 288, 290, 290, 291,
1586  291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
1587  291, 291, 291, 291, 292, 292, 292, 292, 293, 293,
1588  294, 294, 295, 295, 296, 297, 298, 298, 299, 299,
1589  300, 300, 301, 301, 302, 302, 303, 304, 304, 305,
1590  306, 305, 307, 307, 308, 308, 309, 309, 310, 310,
1591  310, 311, 311, 311, 311, 312, 312, 312, 313, 313,
1592  314, 314, 315, 315, 316, 317, 318, 318, 318, 319,
1593  319, 320, 320, 321
1594 };
1595 
1596 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1597 static const yytype_uint8 yyr2[] =
1598 {
1599  0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
1600  0, 5, 4, 2, 1, 1, 3, 2, 0, 4,
1601  3, 3, 3, 2, 3, 3, 3, 3, 3, 4,
1602  1, 3, 3, 6, 5, 5, 5, 5, 3, 3,
1603  3, 3, 1, 3, 3, 1, 3, 3, 3, 2,
1604  1, 1, 1, 1, 1, 4, 4, 0, 5, 2,
1605  3, 4, 5, 4, 5, 2, 2, 2, 2, 2,
1606  1, 3, 1, 3, 1, 2, 3, 5, 2, 4,
1607  2, 4, 1, 3, 1, 3, 2, 3, 1, 3,
1608  1, 1, 4, 3, 3, 3, 3, 2, 1, 1,
1609  1, 4, 3, 3, 3, 3, 2, 1, 1, 1,
1610  2, 1, 3, 1, 1, 1, 1, 1, 1, 1,
1611  1, 1, 1, 0, 4, 1, 1, 1, 1, 1,
1612  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1613  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1614  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1615  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1616  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1617  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1618  1, 1, 1, 1, 1, 3, 5, 3, 5, 6,
1619  5, 5, 5, 5, 4, 3, 3, 3, 3, 3,
1620  3, 3, 3, 3, 4, 4, 2, 2, 3, 3,
1621  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1622  3, 2, 2, 3, 3, 3, 3, 0, 4, 6,
1623  1, 1, 1, 2, 4, 2, 3, 1, 1, 1,
1624  1, 2, 4, 2, 1, 2, 2, 4, 1, 0,
1625  2, 2, 2, 1, 1, 2, 3, 4, 3, 4,
1626  2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1627  0, 4, 0, 4, 3, 3, 2, 3, 3, 1,
1628  4, 3, 1, 0, 6, 4, 3, 2, 1, 2,
1629  2, 6, 6, 0, 0, 7, 0, 0, 7, 5,
1630  4, 0, 0, 9, 0, 6, 0, 0, 8, 0,
1631  5, 0, 6, 0, 0, 9, 1, 1, 1, 1,
1632  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1633  1, 1, 1, 1, 2, 1, 1, 1, 5, 1,
1634  2, 1, 1, 1, 3, 1, 3, 1, 4, 6,
1635  3, 5, 2, 4, 1, 3, 6, 8, 4, 6,
1636  4, 2, 6, 2, 4, 6, 2, 4, 2, 4,
1637  1, 1, 1, 3, 1, 4, 1, 2, 1, 3,
1638  1, 1, 0, 0, 4, 4, 1, 3, 3, 0,
1639  5, 2, 4, 4, 2, 4, 4, 3, 3, 3,
1640  2, 1, 4, 0, 5, 0, 5, 5, 1, 1,
1641  6, 1, 1, 1, 1, 2, 1, 2, 1, 1,
1642  1, 1, 1, 1, 1, 2, 3, 3, 3, 3,
1643  3, 0, 3, 1, 2, 3, 3, 0, 3, 0,
1644  2, 0, 2, 0, 2, 1, 0, 3, 0, 0,
1645  5, 1, 1, 1, 1, 2, 1, 1, 1, 1,
1646  3, 1, 1, 2, 2, 1, 1, 1, 1, 1,
1647  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1648  1, 1, 1, 1, 0, 4, 2, 3, 2, 6,
1649  8, 4, 6, 4, 6, 2, 4, 6, 2, 4,
1650  2, 4, 1, 0, 1, 1, 1, 1, 1, 1,
1651  1, 3, 1, 3, 3, 3, 1, 3, 1, 3,
1652  1, 1, 2, 1, 1, 1, 2, 2, 1, 1,
1653  0, 4, 1, 2, 1, 3, 3, 2, 1, 1,
1654  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1655  0, 1, 0, 1, 2, 2, 0, 1, 1, 1,
1656  1, 1, 2, 0
1657 };
1658 
1659 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1660  Performed when YYTABLE doesn't specify something else to do. Zero
1661  means the default is an error. */
1662 static const yytype_uint16 yydefact[] =
1663 {
1664  2, 0, 0, 1, 0, 338, 339, 340, 0, 331,
1665  332, 333, 336, 334, 335, 337, 326, 327, 328, 329,
1666  289, 259, 259, 481, 480, 482, 483, 562, 0, 562,
1667  10, 0, 485, 484, 486, 475, 550, 477, 476, 478,
1668  479, 471, 472, 433, 491, 492, 0, 0, 0, 0,
1669  0, 573, 573, 82, 392, 451, 449, 451, 453, 441,
1670  447, 0, 0, 0, 3, 560, 6, 9, 30, 42,
1671  45, 53, 52, 0, 70, 0, 74, 84, 0, 50,
1672  240, 0, 280, 0, 0, 303, 306, 560, 0, 0,
1673  0, 0, 54, 298, 271, 272, 432, 434, 273, 274,
1674  275, 276, 430, 431, 429, 487, 488, 277, 0, 278,
1675  259, 5, 8, 164, 175, 165, 188, 161, 181, 171,
1676  170, 191, 192, 186, 169, 168, 163, 189, 193, 194,
1677  173, 162, 176, 180, 182, 174, 167, 183, 190, 185,
1678  184, 177, 187, 172, 160, 179, 178, 159, 166, 157,
1679  158, 154, 155, 156, 113, 115, 114, 149, 150, 146,
1680  128, 129, 130, 137, 134, 136, 131, 132, 151, 152,
1681  138, 139, 143, 133, 135, 125, 126, 127, 140, 141,
1682  142, 144, 145, 147, 148, 153, 118, 120, 122, 23,
1683  116, 117, 119, 121, 0, 0, 0, 0, 0, 0,
1684  0, 254, 0, 241, 264, 68, 258, 573, 0, 487,
1685  488, 0, 278, 573, 544, 69, 67, 562, 66, 0,
1686  573, 410, 65, 562, 563, 0, 0, 18, 237, 0,
1687  0, 326, 327, 289, 292, 411, 216, 0, 0, 217,
1688  286, 0, 0, 0, 560, 15, 562, 72, 14, 282,
1689  0, 566, 566, 242, 0, 0, 566, 542, 562, 0,
1690  0, 0, 80, 330, 0, 90, 91, 98, 300, 393,
1691  468, 467, 469, 466, 0, 465, 0, 0, 0, 0,
1692  0, 0, 0, 473, 474, 49, 231, 232, 569, 570,
1693  4, 571, 561, 0, 0, 0, 0, 0, 0, 0,
1694  399, 401, 0, 86, 0, 78, 75, 0, 0, 0,
1695  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1696  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1697  0, 0, 0, 0, 0, 573, 0, 0, 51, 0,
1698  0, 0, 0, 560, 0, 561, 0, 352, 351, 0,
1699  0, 487, 488, 278, 108, 109, 0, 0, 111, 0,
1700  0, 487, 488, 278, 319, 184, 177, 187, 172, 154,
1701  155, 156, 113, 114, 540, 321, 539, 0, 0, 0,
1702  415, 413, 299, 435, 0, 0, 404, 59, 297, 123,
1703  547, 286, 265, 261, 0, 0, 0, 255, 263, 0,
1704  573, 0, 0, 0, 0, 256, 562, 0, 291, 260,
1705  562, 250, 573, 573, 249, 562, 296, 48, 20, 22,
1706  21, 0, 293, 0, 0, 0, 0, 0, 0, 17,
1707  562, 284, 13, 561, 71, 562, 287, 568, 567, 243,
1708  568, 245, 288, 543, 0, 97, 473, 474, 88, 83,
1709  0, 0, 573, 0, 513, 455, 458, 456, 470, 452,
1710  436, 450, 437, 438, 454, 439, 440, 0, 443, 445,
1711  0, 446, 0, 0, 572, 7, 24, 25, 26, 27,
1712  28, 46, 47, 573, 0, 31, 40, 0, 41, 562,
1713  0, 76, 87, 44, 43, 0, 195, 264, 39, 213,
1714  221, 226, 227, 228, 223, 225, 235, 236, 229, 230,
1715  206, 207, 233, 234, 562, 222, 224, 218, 219, 220,
1716  208, 209, 210, 211, 212, 551, 556, 552, 557, 409,
1717  259, 407, 562, 551, 553, 552, 554, 408, 259, 0,
1718  573, 343, 0, 342, 0, 0, 0, 0, 0, 0,
1719  286, 0, 573, 0, 311, 316, 108, 109, 110, 0,
1720  494, 314, 493, 0, 573, 0, 0, 0, 513, 559,
1721  558, 323, 551, 552, 259, 259, 573, 573, 32, 197,
1722  38, 205, 57, 60, 0, 195, 546, 0, 266, 262,
1723  573, 555, 552, 562, 551, 552, 545, 290, 564, 246,
1724  251, 253, 295, 19, 0, 238, 0, 29, 0, 573,
1725  204, 73, 16, 283, 566, 0, 81, 94, 96, 562,
1726  551, 552, 519, 516, 515, 514, 517, 0, 531, 535,
1727  534, 530, 513, 0, 396, 518, 520, 522, 573, 528,
1728  573, 533, 573, 0, 512, 459, 0, 442, 444, 448,
1729  214, 215, 384, 573, 0, 382, 381, 270, 0, 85,
1730  79, 0, 0, 0, 0, 0, 0, 406, 63, 0,
1731  412, 0, 0, 248, 405, 61, 247, 341, 281, 573,
1732  573, 421, 573, 344, 573, 346, 304, 345, 307, 0,
1733  0, 310, 555, 285, 562, 551, 552, 0, 0, 496,
1734  0, 0, 108, 109, 112, 562, 0, 562, 513, 0,
1735  0, 0, 403, 56, 402, 55, 0, 0, 0, 573,
1736  124, 267, 257, 0, 0, 412, 0, 0, 573, 562,
1737  11, 244, 89, 92, 0, 519, 0, 364, 355, 357,
1738  562, 353, 573, 0, 0, 394, 0, 505, 538, 0,
1739  508, 532, 0, 510, 536, 0, 461, 462, 463, 457,
1740  464, 519, 0, 573, 0, 573, 526, 573, 573, 380,
1741  386, 0, 0, 268, 77, 196, 0, 37, 202, 36,
1742  203, 64, 565, 0, 34, 200, 35, 201, 62, 422,
1743  423, 573, 424, 0, 573, 349, 0, 0, 347, 0,
1744  0, 0, 309, 0, 0, 412, 0, 317, 0, 0,
1745  412, 320, 541, 562, 0, 498, 324, 0, 0, 198,
1746  0, 0, 252, 294, 524, 562, 0, 362, 0, 521,
1747  562, 0, 0, 523, 573, 573, 537, 573, 529, 573,
1748  573, 0, 0, 390, 387, 388, 391, 0, 383, 371,
1749  373, 0, 376, 0, 378, 400, 269, 239, 33, 199,
1750  0, 0, 426, 350, 0, 12, 428, 0, 301, 302,
1751  0, 0, 266, 573, 312, 0, 495, 315, 497, 322,
1752  513, 416, 414, 0, 354, 365, 0, 360, 356, 395,
1753  398, 397, 0, 501, 0, 503, 0, 509, 0, 506,
1754  511, 460, 0, 525, 0, 385, 573, 573, 573, 527,
1755  573, 573, 0, 425, 0, 99, 100, 107, 0, 427,
1756  0, 305, 308, 418, 419, 417, 0, 0, 0, 58,
1757  0, 363, 0, 358, 573, 573, 573, 573, 286, 0,
1758  389, 0, 368, 0, 370, 377, 0, 374, 379, 106,
1759  0, 573, 0, 573, 573, 0, 318, 0, 361, 0,
1760  502, 0, 499, 504, 507, 555, 285, 573, 573, 573,
1761  573, 555, 105, 562, 551, 552, 420, 348, 313, 325,
1762  359, 573, 369, 0, 366, 372, 375, 412, 500, 573,
1763  367
1764 };
1765 
1766 /* YYDEFGOTO[NTERM-NUM]. */
1767 static const yytype_int16 yydefgoto[] =
1768 {
1769  -1, 1, 2, 64, 65, 66, 229, 539, 540, 244,
1770  245, 421, 68, 69, 339, 70, 71, 583, 719, 72,
1771  73, 246, 74, 75, 76, 449, 77, 202, 358, 359,
1772  186, 187, 188, 189, 584, 536, 191, 79, 423, 204,
1773  250, 529, 674, 410, 411, 218, 219, 206, 397, 412,
1774  488, 80, 337, 435, 604, 341, 800, 342, 801, 697,
1775  926, 701, 698, 875, 566, 568, 711, 880, 237, 82,
1776  83, 84, 85, 86, 87, 88, 89, 90, 91, 678,
1777  542, 686, 797, 798, 350, 738, 739, 740, 763, 654,
1778  655, 764, 844, 845, 268, 269, 454, 633, 745, 301,
1779  483, 92, 93, 388, 577, 576, 549, 925, 680, 791,
1780  861, 865, 94, 95, 96, 97, 98, 99, 100, 280,
1781  467, 101, 282, 276, 274, 278, 459, 646, 645, 755,
1782  759, 102, 275, 103, 104, 209, 210, 107, 211, 212,
1783  561, 700, 709, 710, 635, 636, 637, 638, 639, 766,
1784  767, 640, 641, 642, 643, 836, 747, 377, 567, 255,
1785  413, 214, 238, 608, 531, 571, 290, 407, 408, 670,
1786  439, 543, 345, 248
1787 };
1788 
1789 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1790  STATE-NUM. */
1791 #define YYPACT_NINF -747
1792 static const yytype_int16 yypact[] =
1793 {
1794  -747, 81, 2552, -747, 7102, -747, -747, -747, 6615, -747,
1795  -747, -747, -747, -747, -747, -747, 7320, 7320, -747, -747,
1796  7320, 3237, 2814, -747, -747, -747, -747, 100, 6476, -31,
1797  -747, -26, -747, -747, -747, 5715, 2955, -747, -747, 5842,
1798  -747, -747, -747, -747, -747, -747, 8519, 8519, 83, 4434,
1799  8628, 7538, 7865, 6878, -747, 6337, -747, -747, -747, -24,
1800  29, 252, 8737, 8519, -747, 193, -747, 1104, -747, 458,
1801  -747, -747, 129, 77, -747, 69, 8846, -747, 139, 2797,
1802  22, 41, -747, 8628, 8628, -747, -747, 5078, 8951, 9056,
1803  9161, 5588, 33, 46, -747, -747, 157, -747, -747, -747,
1804  -747, -747, -747, -747, -747, 25, 58, -747, 179, 613,
1805  51, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1806  -747, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1807  -747, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1808  -747, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1809  -747, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1810  -747, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1811  -747, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1812  -747, -747, -747, -747, -747, -747, -747, -747, -747, 134,
1813  -747, -747, -747, -747, 182, 8519, 279, 4564, 8519, 8519,
1814  8519, -747, 263, 2797, 260, -747, -747, 237, 207, 43,
1815  206, 298, 254, 265, -747, -747, -747, 4969, -747, 7320,
1816  7320, -747, -747, 5208, -747, 8628, 661, -747, 272, 287,
1817  4694, -747, -747, -747, 295, 307, -747, 304, 51, 416,
1818  619, 7211, 4434, 384, 193, 1104, -31, 399, -747, 458,
1819  419, 221, 300, -747, 260, 430, 300, -747, -31, 497,
1820  501, 9266, 442, -747, 351, 366, 383, 409, -747, -747,
1821  -747, -747, -747, -747, 644, -747, 754, 813, 605, 464,
1822  819, 478, 68, 530, 532, -747, -747, -747, -747, -747,
1823  -747, -747, 5317, 8628, 8628, 8628, 8628, 7211, 8628, 8628,
1824  -747, -747, 7974, -747, 4434, 6990, 470, 7974, 8519, 8519,
1825  8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519,
1826  8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519,
1827  8519, 8519, 8519, 8519, 9548, 7320, 9625, 3609, 458, 86,
1828  86, 8628, 8628, 193, 597, 480, 562, -747, -747, 454,
1829  601, 54, 76, 99, 331, 349, 8628, 481, -747, 45,
1830  473, -747, -747, -747, -747, 217, 286, 305, 318, 321,
1831  347, 363, 376, 381, -747, -747, -747, 391, 10549, 10549,
1832  -747, -747, -747, -747, 8737, 8737, -747, 535, -747, -747,
1833  -747, 388, -747, -747, 8519, 8519, 7429, -747, -747, 9702,
1834  7320, 9779, 8519, 8519, 7647, -747, -31, 492, -747, -747,
1835  -31, -747, 506, 539, -747, 106, -747, -747, -747, -747,
1836  -747, 6615, -747, 8519, 4029, 508, 9702, 9779, 8519, 1104,
1837  -31, -747, -747, 5445, 541, -31, -747, 7756, -747, -747,
1838  7865, -747, -747, -747, 272, 510, -747, -747, -747, 543,
1839  9266, 9856, 7320, 9933, 774, -747, -747, -747, -747, -747,
1840  -747, -747, -747, -747, -747, -747, -747, 313, -747, -747,
1841  491, -747, 8519, 8519, -747, -747, -747, -747, -747, -747,
1842  -747, -747, -747, 32, 8519, -747, 545, 546, -747, -31,
1843  9266, 551, -747, -747, -747, 566, 9473, -747, -747, 416,
1844  2184, 2184, 2184, 2184, 781, 781, 2273, 2938, 2184, 2184,
1845  1364, 1364, 662, 662, 2656, 781, 781, 927, 927, 768,
1846  397, 397, 416, 416, 416, 3378, 6083, 3464, 6197, -747,
1847  307, -747, -31, 647, -747, 660, -747, -747, 3096, 650,
1848  688, -747, 3754, 685, 4174, 56, 56, 597, 8083, 650,
1849  112, 10010, 7320, 10087, -747, 458, -747, 510, -747, 193,
1850  -747, -747, -747, 10164, 7320, 10241, 3609, 8628, 1131, -747,
1851  -747, -747, -747, -747, 1739, 1739, 32, 32, -747, 10608,
1852  -747, 2797, -747, -747, 6615, 10627, -747, 8519, 260, -747,
1853  265, 5969, 2673, -31, 490, 500, -747, -747, -747, -747,
1854  7429, 7647, -747, -747, 8628, 2797, 570, -747, 307, 307,
1855  2797, 213, 1104, -747, 300, 9266, 543, 505, 282, -31,
1856  38, 261, 603, -747, -747, -747, -747, 972, -747, -747,
1857  -747, -747, 1223, 66, -747, -747, -747, -747, 580, -747,
1858  583, 683, 589, 687, -747, -747, 893, -747, -747, -747,
1859  416, 416, -747, 576, 4839, -747, -747, 604, 8192, -747,
1860  543, 9266, 8737, 8519, 630, 8737, 8737, -747, 535, 608,
1861  677, 8737, 8737, -747, -747, 535, -747, -747, -747, 8301,
1862  740, -747, 588, -747, 740, -747, -747, -747, -747, 650,
1863  44, -747, 239, 257, -31, 141, 145, 8628, 193, -747,
1864  8628, 3609, 505, 282, -747, -31, 650, 106, 1223, 3609,
1865  193, 6754, -747, -747, -747, -747, 4839, 4694, 8519, 32,
1866  -747, -747, -747, 8519, 8519, 507, 8519, 8519, 636, 106,
1867  -747, -747, -747, 291, 8519, -747, 972, 457, -747, 651,
1868  -31, -747, 639, 4839, 4694, -747, 1223, -747, -747, 1223,
1869  -747, -747, 598, -747, -747, 4694, -747, -747, -747, -747,
1870  -747, 681, 1017, 639, 679, 654, -747, 656, 657, -747,
1871  -747, 789, 8519, 664, 543, 2797, 8519, -747, 2797, -747,
1872  2797, -747, -747, 8737, -747, 2797, -747, 2797, -747, 545,
1873  -747, 713, -747, 4304, 796, -747, 8628, 650, -747, 650,
1874  4839, 4839, -747, 8410, 3899, 189, 56, -747, 193, 650,
1875  -747, -747, -747, -31, 650, -747, -747, 799, 673, 2797,
1876  4694, 8519, 7647, -747, -747, -31, 884, 671, 1079, -747,
1877  -31, 803, 686, -747, 676, 678, -747, 684, -747, 694,
1878  684, 690, 9371, -747, 699, -747, -747, 711, -747, 1251,
1879  -747, 1251, -747, 598, -747, -747, 700, 2797, -747, 2797,
1880  9476, 86, -747, -747, 4839, -747, -747, 86, -747, -747,
1881  650, 650, -747, 365, -747, 3609, -747, -747, -747, -747,
1882  1131, -747, -747, 706, -747, 707, 884, 716, -747, -747,
1883  -747, -747, 1223, -747, 598, -747, 598, -747, 598, -747,
1884  -747, -747, 790, 520, 1017, -747, 708, 715, 684, -747,
1885  717, 684, 797, -747, 523, 366, 383, 409, 3609, -747,
1886  3754, -747, -747, -747, -747, -747, 4839, 650, 3609, -747,
1887  884, 707, 884, 721, 684, 727, 684, 684, -747, 10318,
1888  -747, 1251, -747, 598, -747, -747, 598, -747, -747, 510,
1889  10395, 7320, 10472, 688, 588, 650, -747, 650, 707, 884,
1890  -747, 598, -747, -747, -747, 730, 731, 684, 735, 684,
1891  684, 55, 282, -31, 128, 158, -747, -747, -747, -747,
1892  707, 684, -747, 598, -747, -747, -747, 163, -747, 684,
1893  -747
1894 };
1895 
1896 /* YYPGOTO[NTERM-NUM]. */
1897 static const yytype_int16 yypgoto[] =
1898 {
1899  -747, -747, -747, 452, -747, 28, -747, -545, 277, -747,
1900  39, -747, -293, 184, -58, 71, -747, -169, -747, -7,
1901  791, -142, -13, -37, -747, -396, -29, 1623, -312, 788,
1902  -54, -747, -25, -747, -747, 20, -747, 1066, -747, -45,
1903  -747, 11, 47, -324, 115, 5, -747, -322, -196, 53,
1904  -295, 8, -747, -747, -747, -747, -747, -747, -747, -747,
1905  -747, -747, -747, -747, -747, -747, -747, -747, 2, -747,
1906  -747, -747, -747, -747, -747, -747, -747, -747, -747, 205,
1907  -338, -516, -72, -618, -747, -722, -671, 147, -747, -489,
1908  -747, -600, -747, -12, -747, -747, -747, -747, -747, -747,
1909  -747, -747, -747, 798, -747, -747, -531, -747, -50, -747,
1910  -747, -747, -747, -747, -747, 811, -747, -747, -747, -747,
1911  -747, -747, -747, -747, 856, -747, -140, -747, -747, -747,
1912  -747, 7, -747, 12, -747, 1268, 1605, 823, 1289, 1575,
1913  -747, -747, 35, -387, -697, -568, -690, 273, -696, -746,
1914  72, 181, -747, -526, -747, -449, 270, -747, -747, -747,
1915  97, -360, 758, -276, -747, -747, -56, -4, 278, -585,
1916  -214, 6, -18, -2
1917 };
1918 
1919 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1920  positive, shift that token. If negative, reduce the rule which
1921  number is the opposite. If YYTABLE_NINF, syntax error. */
1922 #define YYTABLE_NINF -574
1923 static const yytype_int16 yytable[] =
1924 {
1925  111, 273, 544, 227, 81, 644, 81, 254, 725, 201,
1926  201, 532, 498, 201, 493, 192, 689, 405, 208, 208,
1927  193, 706, 208, 225, 262, 228, 340, 222, 190, 343,
1928  688, 344, 112, 221, 733, 192, 247, 375, 441, 306,
1929  193, 67, 443, 67, 596, 558, 559, 292, 190, 253,
1930  257, 81, 208, 838, 616, 264, 833, 541, 530, 741,
1931  538, 263, 794, -93, 208, 846, 799, 634, -103, 207,
1932  207, 291, 380, 207, 589, 190, 593, 380, 264, -99,
1933  596, 3, 589, 685, 263, 208, 208, 716, 717, 208,
1934  349, 360, 360, 291, 660, 743, 263, 263, 263, 541,
1935  430, -100, 574, 575, 251, 909, 888, -330, 652, 805,
1936  230, 190, -489, 213, 213, 387, 224, 213, 378, 644,
1937  810, 386, 279, 530, -107, 538, 334, 768, 619, 470,
1938  -489, 205, 215, 285, -99, 216, 461, -106, 464, 240,
1939  468, -102, 830, 298, 299, -490, 653, -93, 252, 256,
1940  390, 609, -99, 392, 393, 885, 809, 300, 560, 833,
1941  -330, -330, 489, 847, 814, -90, -102, -100, 741, 827,
1942  -104, -104, 379, 744, 471, 281, -101, 609, -93, 335,
1943  336, -93, 381, 644, 803, -93, 302, 381, 432, 288,
1944  288, 289, 289, 220, -90, 909, 838, -551, -91, 81,
1945  -103, 288, -103, 289, 769, 398, 833, 846, 888, 303,
1946  201, 398, 201, 201, -101, 931, -91, 405, 414, 208,
1947  835, 208, 208, 839, 448, 208, 433, 208, 694, 247,
1948  820, 288, 81, 289, 249, 476, 477, 478, 479, -98,
1949  705, 596, 223, 81, 81, 742, 221, 224, 307, 386,
1950  291, 704, -97, 224, 444, 923, 56, 486, 741, 644,
1951  741, 958, 497, 264, -103, 774, 384, 338, 338, 263,
1952  207, 338, 207, -102, 389, -102, 491, 609, 589, 589,
1953  429, -93, -105, 545, 546, -95, -95, 547, 980, 609,
1954  874, 247, 399, -490, 81, 208, 208, 208, 208, 81,
1955  208, 208, -481, -104, 208, -104, 81, 264, -101, 208,
1956  -101, 283, 284, 263, 213, -100, 213, -412, 741, 933,
1957  475, 813, -71, 907, 223, 910, 243, 648, 201, -92,
1958  927, 67, 406, 414, 409, 391, 480, 208, 288, 81,
1959  289, 403, 924, 208, 208, 400, 401, 537, 395, 291,
1960  586, 588, 804, -85, 528, 487, -481, -548, 208, 254,
1961  487, 437, 741, -107, 741, 562, 935, -285, 438, 493,
1962  -95, -480, 394, 485, 455, -549, -412, 396, 494, -94,
1963  793, -551, 548, 957, 790, 402, 208, 208, 987, 426,
1964  -482, 741, 588, 201, 722, 254, 603, -96, 414, -552,
1965  731, -95, 208, -483, -95, 404, -485, 415, -95, 417,
1966  398, 398, 537, 448, 422, 968, -475, 456, 457, 528,
1967  -285, -285, 111, 424, -552, -480, 81, -412, 192, -412,
1968  -412, 644, -484, 193, -478, 81, 451, 217, 537, 657,
1969  440, 190, 400, 427, -482, 201, 528, 438, -486, 220,
1970  414, -487, 264, 448, 208, 578, 580, -483, 263, 647,
1971  -485, -475, 596, 67, 537, 308, -478, -548, -488, -475,
1972  -475, 528, 612, -548, 243, 428, 569, 338, 338, 338,
1973  338, 656, 481, 482, 308, -549, -484, -478, -478, 452,
1974  453, -549, 264, 590, -278, 298, 299, -106, 263, 781,
1975  589, 416, -486, 497, -487, -487, 788, 425, -70, 735,
1976  664, 623, 624, 625, 626, -475, 331, 332, 333, 243,
1977  -478, -488, -488, 918, 434, 338, 338, 431, 669, 920,
1978  570, -555, 722, 556, 614, 668, 676, 557, 681, 551,
1979  555, 667, 721, 675, 81, 201, 81, -278, -278, 673,
1980  414, 687, 687, 445, 208, 588, 254, 201, 563, 720,
1981  446, 447, 414, 436, 537, 699, 208, 442, 81, 208,
1982  465, 528, 676, 676, 656, 656, 537, 726, 732, 713,
1983  715, 243, 450, 528, 469, 673, 673, 727, 398, 669,
1984  -555, 192, 552, 553, 821, -286, 193, 826, 472, -102,
1985  473, 690, 796, 793, 190, 939, 208, 676, 950, -104,
1986  492, 564, 565, 773, 548, 669, -101, 264, 550, 667,
1987  673, 712, 714, 263, 448, 474, 554, 973, 761, 582,
1988  623, 624, 625, 626, 789, 598, 748, 649, 748, 806,
1989  748, -555, 808, -555, -555, 607, 600, -551, -286, -286,
1990  735, 770, 623, 624, 625, 626, 81, 816, 564, 565,
1991  677, 951, 952, 264, 208, 627, 455, 208, 208, 263,
1992  463, 628, 629, 208, 208, 662, 609, 792, 795, 601,
1993  795, -85, 795, 615, 597, -264, 658, 627, 599, 824,
1994  669, 661, 630, 602, 629, 631, 679, 728, 683, 208,
1995  385, 669, 208, 81, 807, 455, 428, 730, 611, 456,
1996  457, 81, 734, 613, 630, 418, 815, 656, 81, 81,
1997  746, 762, -107, 749, 419, 420, 398, 856, -106, 752,
1998  308, 190, 487, 494, 671, 751, 777, 779, 867, 754,
1999  770, 776, 784, 786, -265, 81, 81, 672, 456, 457,
2000  458, 707, 782, -98, 691, 793, -102, 81, 872, -97,
2001  110, 770, 110, 748, 783, 748, 748, 659, 735, -104,
2002  623, 624, 625, 626, 110, 110, 822, 254, 110, 329,
2003  330, 331, 332, 333, 762, 208, -101, -93, 729, 862,
2004  842, 828, 866, 848, 849, 81, 851, 853, 208, 855,
2005  -95, 860, 81, 81, -266, 864, 81, 110, 110, 881,
2006  882, 886, 687, 890, 876, 455, 892, -92, 894, 682,
2007  110, 684, 81, 891, 896, 905, 622, 901, 623, 624,
2008  625, 626, 748, 748, 898, 748, 308, 748, 748, 904,
2009  -267, 110, 110, 929, 903, 110, 938, 930, 941, 308,
2010  263, 321, 322, 949, 858, 943, 932, 946, 456, 457,
2011  460, 959, 914, 627, 321, 322, 81, 961, 263, 628,
2012  629, 795, -551, -552, 455, 983, 606, 81, 364, 347,
2013  455, 338, 977, 825, 338, 329, 330, 331, 332, 333,
2014  630, 382, 940, 631, 802, 326, 327, 328, 329, 330,
2015  331, 332, 333, 976, 748, 748, 748, 383, 748, 748,
2016  750, 811, 753, 277, 376, 928, 632, 456, 457, 462,
2017  81, 906, 81, 456, 457, 466, 765, 834, 81, 0,
2018  81, 771, 748, 748, 748, 748, 735, 0, 623, 624,
2019  625, 626, 0, 0, 201, 0, 0, 756, 757, 414,
2020  758, 681, 795, 208, 0, 110, 44, 45, 0, 528,
2021  0, 0, 0, 537, 0, 748, 748, 748, 748, 669,
2022  528, 0, 0, 736, 0, 110, 0, 110, 110, 748,
2023  338, 110, 0, 110, 0, 812, 0, 748, 110, 0,
2024  0, 0, 0, 817, 818, 308, 0, 0, 0, 110,
2025  110, 0, 868, 0, 869, 0, 0, 823, 0, 0,
2026  321, 322, 0, 0, 877, 0, 0, 0, 829, 879,
2027  831, 832, 837, 0, 735, 840, 623, 624, 625, 626,
2028  0, 0, 841, 0, 0, 850, 0, 852, 854, 0,
2029  0, 0, 0, 328, 329, 330, 331, 332, 333, 0,
2030  110, 110, 110, 110, 110, 110, 110, 110, 0, 0,
2031  110, 736, 110, 0, 0, 110, 0, 737, 0, 843,
2032  863, 623, 624, 625, 626, 921, 922, 870, 871, 0,
2033  0, 873, 203, 203, 0, 0, 203, 0, 0, 0,
2034  0, 878, 0, 110, 0, 110, 0, 883, 0, 110,
2035  110, 0, 0, 884, 893, 895, 0, 897, 889, 899,
2036  900, 0, 236, 239, 110, 0, 0, 203, 203, 0,
2037  0, 0, 0, 0, 908, 0, 911, 0, 286, 287,
2038  0, 735, 956, 623, 624, 625, 626, 0, 0, 0,
2039  0, 919, 110, 110, 293, 294, 295, 296, 297, 0,
2040  0, 0, 0, 0, 0, 0, 0, 0, 110, 0,
2041  978, 0, 979, 0, 0, 934, 0, 936, 736, 0,
2042  0, 937, 0, 0, 887, 0, 942, 944, 945, 0,
2043  947, 948, 110, 622, 0, 623, 624, 625, 626, 0,
2044  0, 110, 0, 0, 0, 953, 0, 954, 0, 0,
2045  0, 0, 0, 955, 960, 962, 963, 964, 0, 0,
2046  110, 0, 0, 0, 967, 0, 969, 0, 0, 970,
2047  627, 0, 0, 0, 0, 0, 628, 629, 0, 0,
2048  0, 0, 0, 0, 981, 0, 0, 982, 984, 985,
2049  986, 0, 0, 0, 0, 0, 0, 630, 0, 0,
2050  631, 988, 0, 0, 0, 0, 989, 0, 0, 990,
2051  0, 203, 0, 0, 203, 203, 286, 0, 0, 0,
2052  105, 0, 105, 708, 0, 622, 0, 623, 624, 625,
2053  626, 0, 0, 203, 0, 203, 203, 0, 0, 0,
2054  0, 108, 0, 108, 0, 0, 0, 0, 0, 0,
2055  110, 0, 110, 761, 0, 623, 624, 625, 626, 0,
2056  110, 0, 627, 0, 0, 0, 0, 105, 628, 629,
2057  0, 265, 110, 0, 110, 110, 0, 0, 0, 0,
2058  0, 0, 0, 0, 0, 0, 0, 0, 108, 630,
2059  627, 0, 631, 0, 265, 0, 628, 629, 0, 0,
2060  0, 0, 0, 0, 0, 0, 351, 361, 361, 361,
2061  0, 0, 110, 0, 0, 0, 0, 630, 203, 0,
2062  631, 0, 0, 496, 499, 500, 501, 502, 503, 504,
2063  505, 506, 507, 508, 509, 510, 511, 512, 513, 514,
2064  515, 516, 517, 518, 519, 520, 521, 522, 523, 524,
2065  0, 203, 0, 0, 0, 0, 0, 0, 0, 0,
2066  0, 0, 110, 0, 0, 0, 0, 0, 0, 0,
2067  110, 0, 0, 110, 110, 0, 0, 0, 0, 110,
2068  110, 0, 308, 309, 310, 311, 312, 313, 314, 315,
2069  316, 317, 318, -574, -574, 0, 0, 321, 322, 0,
2070  579, 581, 0, 0, 0, 110, 0, 0, 110, 110,
2071  585, 203, 203, 0, 0, 105, 203, 110, 579, 581,
2072  203, 0, 0, 0, 110, 110, 324, 325, 326, 327,
2073  328, 329, 330, 331, 332, 333, 108, 0, 0, 605,
2074  0, 0, 0, 0, 610, 0, 0, 0, 105, 0,
2075  0, 110, 110, 203, 0, 0, 203, 0, 0, 105,
2076  105, 0, 0, 110, 0, 0, 0, 0, 203, 108,
2077  0, 0, 0, 0, 0, 0, 0, 0, 0, 265,
2078  108, 108, 0, 0, 0, 0, 0, 0, 650, 651,
2079  0, 110, 0, 0, 0, 0, 0, 0, 0, 0,
2080  203, 110, 0, 0, 110, 0, 0, 0, 110, 110,
2081  105, 0, 110, 0, 0, 105, 0, 0, 0, 0,
2082  0, 0, 105, 265, 0, 0, 0, 109, 110, 109,
2083  0, 108, 0, 0, 0, 0, 108, 0, 0, 0,
2084  0, 0, 0, 108, 0, 0, 0, 0, 0, 0,
2085  0, 0, 0, 0, 0, 105, 0, 106, 0, 106,
2086  0, 0, 0, 0, 203, 0, 0, 0, 203, 0,
2087  0, 0, 110, 0, 109, 78, 108, 78, 267, 0,
2088  203, 0, 0, 110, 0, 0, 0, 0, 0, 0,
2089  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2090  0, 267, 0, 203, 106, 0, 0, 0, 266, 0,
2091  0, 0, 0, 353, 363, 363, 203, 203, 0, 0,
2092  0, 0, 78, 0, 0, 0, 110, 0, 110, 0,
2093  0, 266, 0, 0, 110, 0, 110, 0, 0, 0,
2094  0, 0, 105, 352, 362, 362, 362, 0, 0, 0,
2095  0, 105, 0, 0, 0, 0, 0, 0, 0, 110,
2096  0, 348, 0, 108, 0, 0, 0, 0, 265, 0,
2097  0, 0, 108, 0, 203, 0, 0, 0, 585, 775,
2098  0, 778, 780, 0, 0, 0, 0, 785, 787, -573,
2099  0, 0, 0, 0, 0, 203, 0, -573, -573, -573,
2100  0, 0, -573, -573, -573, 0, -573, 0, 265, 0,
2101  0, 0, 0, 0, 0, 0, -573, 0, 0, 0,
2102  0, 0, 109, 0, 0, 0, -573, -573, 0, -573,
2103  -573, -573, -573, -573, 819, 0, 0, 0, 0, 778,
2104  780, 0, 785, 787, 0, 0, 0, 0, 0, 0,
2105  203, 0, 106, 0, 0, 109, 0, 0, 0, 0,
2106  105, 0, 105, 0, 0, 0, 109, 109, 0, 0,
2107  78, 0, 0, 0, -573, 0, 0, 0, 0, 0,
2108  0, 108, 0, 108, 105, 106, 267, 0, 203, 0,
2109  0, 0, 857, 0, 0, 0, 106, 106, 0, 859,
2110  0, 0, 0, 78, 0, 108, 0, 0, 0, 0,
2111  0, 0, 0, 0, 78, 78, 266, 109, 0, 203,
2112  0, 0, 109, 0, 0, 0, -573, 0, -573, 109,
2113  267, 220, -573, 265, -573, 0, -573, 859, 203, 0,
2114  0, 0, 0, 0, 0, 0, 0, 106, 0, 0,
2115  0, 0, 106, 0, 0, 0, 0, 0, 0, 106,
2116  266, 0, 109, 0, 0, 78, 0, 0, 0, 0,
2117  78, 0, 105, 0, 0, 0, 0, 78, 0, 265,
2118  495, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2119  0, 0, 106, 108, 0, 0, 0, 0, 0, 0,
2120  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2121  78, 0, 0, 0, 0, 0, 0, 0, 0, 105,
2122  0, 0, 0, 0, 0, 0, 0, 105, 0, 0,
2123  0, 0, 0, 0, 105, 105, 0, 0, 0, 0,
2124  108, 0, 0, 0, 0, 0, 0, 0, 108, 109,
2125  0, 0, 0, 0, 0, 108, 108, 0, 109, 0,
2126  0, 105, 105, 0, 0, 0, 0, 203, 0, 0,
2127  0, 0, 0, 105, 0, 267, 0, 0, 0, 106,
2128  0, 0, 108, 108, 0, 0, 0, 0, 106, 0,
2129  0, 0, 0, 0, 108, 0, 0, 78, 0, 0,
2130  0, 0, 0, 0, 0, 266, 78, 0, 0, 0,
2131  0, 105, 0, 0, 0, 267, 0, 0, 105, 105,
2132  0, 0, 105, 0, 0, 0, 0, 0, 0, 0,
2133  0, 0, 108, 0, 0, 0, 0, 0, 105, 108,
2134  108, 0, 0, 108, 0, 266, 0, 0, 0, 0,
2135  0, 0, 0, 0, 0, 0, 0, 0, 0, 108,
2136  361, 0, 0, 0, 0, 0, 0, 109, 0, 109,
2137  0, 0, 0, 0, 0, 0, 0, 0, 915, 0,
2138  0, 0, 105, 0, 0, 0, 0, 0, 0, 0,
2139  0, 109, 0, 105, 0, 0, 0, 106, 0, 106,
2140  0, 0, 0, 108, 0, 0, 0, 0, 0, 0,
2141  0, 0, 0, 0, 108, 78, 0, 78, 0, 0,
2142  0, 106, 0, 0, 0, 0, 0, 0, 0, 0,
2143  0, 0, 0, 0, 0, 0, 105, 0, 105, 78,
2144  267, 0, 0, 0, 105, 0, 105, 0, 0, 0,
2145  0, 0, 0, 0, 0, 0, 0, 108, 0, 108,
2146  0, 0, 0, 0, 0, 108, 0, 108, 0, 0,
2147  266, 760, 0, 0, 0, 0, 0, 0, 0, 109,
2148  0, 0, 0, 0, 0, 0, 267, 0, 0, 0,
2149  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2150  0, 0, 308, -574, -574, -574, -574, 313, 314, 106,
2151  0, -574, -574, 0, 0, 0, 266, 321, 322, 0,
2152  0, 0, 0, 0, 0, 0, 109, 78, 0, 0,
2153  0, 0, 0, 0, 109, 495, 0, 0, 0, 0,
2154  0, 109, 109, 0, 0, 0, 324, 325, 326, 327,
2155  328, 329, 330, 331, 332, 333, 106, 0, 0, 0,
2156  0, 0, 0, 0, 106, 0, 0, 0, 109, 109,
2157  0, 106, 106, 0, 78, 0, 0, 0, 0, 0,
2158  109, 0, 78, 0, 0, 0, 0, 0, 0, 78,
2159  78, 308, 309, 310, 311, 312, 313, 314, 106, 106,
2160  317, 318, 0, 0, 0, 0, 321, 322, 0, 0,
2161  106, 0, 0, 0, 0, 0, 78, 78, 109, 0,
2162  0, 0, 0, 0, 0, 109, 109, 0, 78, 109,
2163  0, 0, 0, 0, 0, 324, 325, 326, 327, 328,
2164  329, 330, 331, 332, 333, 109, 0, 0, 106, 0,
2165  0, 0, 0, 0, 0, 106, 106, 0, 0, 106,
2166  0, 0, 0, 0, 0, 0, 78, 363, 0, 0,
2167  0, 0, 0, 78, 78, 106, 0, 78, 0, 0,
2168  0, 0, 0, 0, 0, 917, 0, 0, 0, 109,
2169  0, 0, 0, 78, 0, 0, 0, 362, 0, 0,
2170  109, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2171  0, 0, 0, 0, 0, 916, 0, 0, 0, 106,
2172  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2173  106, 0, 0, 913, 0, 0, 0, 78, 0, 0,
2174  0, 0, 0, 109, 0, 109, 0, 0, 78, 0,
2175  0, 109, 0, 109, 0, 0, 0, 0, 0, 0,
2176  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2177  0, 0, 0, 106, 0, 106, 0, 0, 0, 0,
2178  0, 106, 0, 106, 0, 0, 0, 0, 0, 0,
2179  0, 78, 0, 78, 0, 0, 0, 0, 0, 78,
2180  0, 78, -573, 4, 0, 5, 6, 7, 8, 9,
2181  0, 0, 0, 10, 11, 0, 0, 0, 12, 0,
2182  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2183  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2184  0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
2185  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2186  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2187  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2188  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2189  0, 49, 50, 0, 51, 52, 0, 53, 0, 54,
2190  55, 56, 57, 58, 59, 60, 0, 0, 0, 0,
2191  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2192  0, 0, 0, -285, 61, 62, 63, 0, 0, 0,
2193  0, -285, -285, -285, 0, 0, -285, -285, -285, 0,
2194  -285, 0, 0, 0, 0, 0, 0, -573, 0, -573,
2195  -285, -285, -285, 0, 0, 0, 0, 0, 0, 0,
2196  -285, -285, 0, -285, -285, -285, -285, -285, 0, 0,
2197  0, 0, 0, 0, 308, 309, 310, 311, 312, 313,
2198  314, 315, 316, 317, 318, 319, 320, 0, 0, 321,
2199  322, -285, -285, -285, -285, -285, -285, -285, -285, -285,
2200  -285, -285, -285, -285, 0, 0, -285, -285, -285, 0,
2201  724, -285, 0, 0, 0, 0, 323, -285, 324, 325,
2202  326, 327, 328, 329, 330, 331, 332, 333, 0, 0,
2203  -285, 0, -105, -285, -285, -285, -285, -285, -285, -285,
2204  -285, -285, -285, -285, -285, 0, 0, 0, 0, 0,
2205  0, 0, 0, 224, 0, 0, 0, 0, 0, 0,
2206  -285, -285, -285, -285, -411, 0, -285, -285, -285, 0,
2207  -285, 0, -411, -411, -411, 0, 0, -411, -411, -411,
2208  0, -411, 0, 0, 0, 0, 0, 0, 0, 0,
2209  -411, -411, -411, 0, 0, 0, 0, 0, 0, 0,
2210  0, -411, -411, 0, -411, -411, -411, -411, -411, 0,
2211  0, 0, 0, 0, 0, 308, 309, 310, 311, 312,
2212  313, 314, 315, 316, 317, 318, 319, 320, 0, 0,
2213  321, 322, -411, -411, -411, -411, -411, -411, -411, -411,
2214  -411, -411, -411, -411, -411, 0, 0, -411, -411, -411,
2215  0, 0, -411, 0, 0, 0, 0, 323, -411, 324,
2216  325, 326, 327, 328, 329, 330, 331, 332, 333, 0,
2217  0, 0, 0, 0, -411, 0, -411, -411, -411, -411,
2218  -411, -411, -411, -411, -411, -411, 0, 0, 0, 0,
2219  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2220  -411, -411, -411, -411, -411, -279, 220, -411, -411, -411,
2221  0, -411, 0, -279, -279, -279, 0, 0, -279, -279,
2222  -279, 0, -279, 0, 0, 0, 0, 0, 0, 0,
2223  0, 0, -279, -279, -279, 0, 0, 0, 0, 0,
2224  0, 0, -279, -279, 0, -279, -279, -279, -279, -279,
2225  0, 0, 0, 0, 0, 0, 308, 309, 310, 311,
2226  312, 313, 314, 315, 0, 317, 318, 0, 0, 0,
2227  0, 321, 322, -279, -279, -279, -279, -279, -279, -279,
2228  -279, -279, -279, -279, -279, -279, 0, 0, -279, -279,
2229  -279, 0, 0, -279, 0, 0, 0, 0, 0, -279,
2230  324, 325, 326, 327, 328, 329, 330, 331, 332, 333,
2231  0, 0, -279, 0, 0, -279, -279, -279, -279, -279,
2232  -279, -279, -279, -279, -279, -279, -279, 0, 0, 0,
2233  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2234  0, 0, -279, -279, -279, -279, -573, 0, -279, -279,
2235  -279, 0, -279, 0, -573, -573, -573, 0, 0, -573,
2236  -573, -573, 0, -573, 0, 0, 0, 0, 0, 0,
2237  0, 0, -573, -573, -573, 0, 0, 0, 0, 0,
2238  0, 0, 0, -573, -573, 0, -573, -573, -573, -573,
2239  -573, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2240  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2241  0, 0, 0, 0, -573, -573, -573, -573, -573, -573,
2242  -573, -573, -573, -573, -573, -573, -573, 0, 0, -573,
2243  -573, -573, 0, 0, -573, 0, 0, 0, 0, 0,
2244  -573, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2245  0, 0, 0, 0, 0, 0, -573, 0, -573, -573,
2246  -573, -573, -573, -573, -573, -573, -573, -573, 0, 0,
2247  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2248  0, 0, -573, -573, -573, -573, -573, -292, 220, -573,
2249  -573, -573, 0, -573, 0, -292, -292, -292, 0, 0,
2250  -292, -292, -292, 0, -292, 0, 0, 0, 0, 0,
2251  0, 0, 0, 0, -292, -292, 0, 0, 0, 0,
2252  0, 0, 0, 0, -292, -292, 0, -292, -292, -292,
2253  -292, -292, 0, 0, 0, 0, 0, 0, 0, 0,
2254  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2255  0, 0, 0, 0, 0, -292, -292, -292, -292, -292,
2256  -292, -292, -292, -292, -292, -292, -292, -292, 0, 0,
2257  -292, -292, -292, 0, 0, -292, 0, 0, 0, 0,
2258  0, -292, 0, 0, 0, 0, 0, 0, 0, 0,
2259  0, 0, 0, 0, 0, 0, 0, -292, 0, -292,
2260  -292, -292, -292, -292, -292, -292, -292, -292, -292, 0,
2261  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2262  0, 0, 0, 0, -292, -292, -292, -292, -555, 217,
2263  -292, -292, -292, 0, -292, 0, -555, -555, -555, 0,
2264  0, 0, -555, -555, 0, -555, 0, 0, 0, 0,
2265  0, 0, 0, 0, -555, 0, 0, 0, 0, 0,
2266  0, 0, 0, 0, 0, -555, -555, 0, -555, -555,
2267  -555, -555, -555, 0, 0, 0, 0, 0, 0, 0,
2268  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2269  0, 0, 0, 0, 0, 0, -555, -555, -555, -555,
2270  -555, -555, -555, -555, -555, -555, -555, -555, -555, 0,
2271  0, -555, -555, -555, -285, 665, 0, 0, 0, 0,
2272  0, 0, -285, -285, -285, 0, 0, 0, -285, -285,
2273  0, -285, 0, 0, 0, 0, 0, -103, -555, 0,
2274  -555, -555, -555, -555, -555, -555, -555, -555, -555, -555,
2275  0, -285, -285, 0, -285, -285, -285, -285, -285, 0,
2276  0, 0, 0, 0, -555, -555, -555, -555, -94, 0,
2277  0, -555, 0, -555, 0, -555, 0, 0, 0, 0,
2278  0, 0, -285, -285, -285, -285, -285, -285, -285, -285,
2279  -285, -285, -285, -285, -285, 0, 0, -285, -285, -285,
2280  0, 666, 0, 0, 0, 0, 0, 0, 0, 0,
2281  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2282  0, 0, 0, -105, -285, 0, -285, -285, -285, -285,
2283  -285, -285, -285, -285, -285, -285, 0, 0, 0, 0,
2284  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2285  0, -285, -285, -285, -96, 0, 0, -285, 0, -285,
2286  241, -285, 5, 6, 7, 8, 9, -573, -573, -573,
2287  10, 11, 0, 0, -573, 12, 0, 13, 14, 15,
2288  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2289  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2290  0, 0, 0, 0, 28, 29, 0, 31, 32, 33,
2291  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2292  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2293  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2294  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2295  0, 51, 52, 0, 53, 0, 54, 55, 56, 57,
2296  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2297  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2298  0, 61, 62, 63, 0, 0, 0, 0, 0, 0,
2299  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2300  0, 0, 0, 0, -573, 241, -573, 5, 6, 7,
2301  8, 9, 0, 0, -573, 10, 11, 0, -573, -573,
2302  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2303  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2304  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2305  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2306  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2307  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2308  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2309  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2310  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2311  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2312  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2313  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2314  0, 0, 0, 0, 0, 0, 0, 0, 0, -573,
2315  241, -573, 5, 6, 7, 8, 9, 0, 0, -573,
2316  10, 11, 0, 0, -573, 12, -573, 13, 14, 15,
2317  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2318  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2319  0, 0, 0, 0, 28, 29, 0, 31, 32, 33,
2320  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2321  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2322  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2323  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2324  0, 51, 52, 0, 53, 0, 54, 55, 56, 57,
2325  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2326  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2327  0, 61, 62, 63, 0, 0, 0, 0, 0, 0,
2328  4, 0, 5, 6, 7, 8, 9, 0, 0, 0,
2329  10, 11, 0, 0, -573, 12, -573, 13, 14, 15,
2330  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2331  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2332  0, 0, 0, 0, 28, 29, 30, 31, 32, 33,
2333  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2334  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2335  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2336  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2337  0, 51, 52, 0, 53, 0, 54, 55, 56, 57,
2338  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2339  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2340  0, 61, 62, 63, 0, 0, 0, 0, 0, 0,
2341  0, 0, 0, 0, 0, 0, -573, 0, 0, 0,
2342  0, 0, 0, 0, -573, 241, -573, 5, 6, 7,
2343  8, 9, 0, 0, -573, 10, 11, 0, 0, -573,
2344  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2345  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2346  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2347  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2348  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2349  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2350  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2351  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2352  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2353  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2354  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2355  0, 0, 0, 0, 0, 241, 0, 5, 6, 7,
2356  8, 9, 0, -573, -573, 10, 11, 0, 0, -573,
2357  12, -573, 13, 14, 15, 16, 17, 18, 19, 0,
2358  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2359  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2360  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2361  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2362  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2363  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2364  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2365  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2366  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2367  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2368  0, 0, 0, 0, 0, 241, 0, 5, 6, 7,
2369  8, 9, 0, 0, 0, 10, 11, 0, 0, -573,
2370  12, -573, 13, 14, 15, 16, 17, 18, 19, 0,
2371  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2372  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2373  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2374  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2375  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2376  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2377  48, 0, 0, 242, 50, 0, 51, 52, 0, 53,
2378  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2379  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2380  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2381  0, 0, 0, 0, 0, 241, 0, 5, 6, 7,
2382  8, 9, 0, 0, 0, 10, 11, -573, 0, -573,
2383  12, -573, 13, 14, 15, 16, 17, 18, 19, 0,
2384  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2385  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2386  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2387  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2388  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2389  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2390  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2391  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2392  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2393  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2394  0, 0, 0, 0, 0, 241, 0, 5, 6, 7,
2395  8, 9, 0, 0, 0, 10, 11, -573, 0, -573,
2396  12, -573, 13, 14, 15, 16, 17, 18, 19, 0,
2397  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2398  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2399  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2400  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2401  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2402  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2403  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2404  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2405  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2406  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2407  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2408  0, -573, 0, 0, 0, 0, 0, 0, 0, -573,
2409  241, -573, 5, 6, 7, 8, 9, 0, 0, -573,
2410  10, 11, 0, 0, 0, 12, 0, 13, 14, 15,
2411  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2412  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2413  0, 0, 0, 0, 28, 29, 0, 31, 32, 33,
2414  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2415  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2416  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2417  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2418  0, 51, 52, 0, 53, 0, 54, 55, 56, 57,
2419  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2420  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2421  0, 61, 62, 63, 0, 0, 0, 0, 0, 0,
2422  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2423  10, 11, 0, 0, -573, 12, -573, 13, 14, 15,
2424  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2425  21, 22, 23, 24, 25, 26, 0, 0, 194, 0,
2426  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2427  34, 35, 36, 37, 38, 39, 40, 195, 41, 42,
2428  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2429  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2430  0, 0, 0, 0, 0, 196, 0, 0, 197, 50,
2431  0, 51, 52, 0, 198, 199, 54, 55, 56, 57,
2432  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2433  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2434  11, 61, 200, 63, 12, 0, 13, 14, 15, 16,
2435  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2436  22, 23, 24, 25, 26, 0, 224, 27, 0, 0,
2437  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2438  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2439  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2440  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2441  0, 0, 0, 0, 196, 0, 0, 197, 50, 0,
2442  51, 52, 0, 0, 0, 54, 55, 56, 57, 58,
2443  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2444  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2445  61, 62, 63, 0, 0, 0, 0, 0, 0, 0,
2446  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2447  11, 0, 0, 288, 12, 289, 13, 14, 15, 16,
2448  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2449  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2450  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2451  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2452  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2453  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2454  0, 0, 0, 0, 196, 0, 0, 197, 50, 0,
2455  51, 52, 0, 0, 0, 54, 55, 56, 57, 58,
2456  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2457  5, 6, 7, 8, 9, 0, 0, 0, 10, 11,
2458  61, 62, 63, 12, 0, 13, 14, 15, 16, 17,
2459  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2460  23, 24, 25, 26, 0, 224, 27, 0, 0, 0,
2461  0, 0, 28, 29, 30, 31, 32, 33, 34, 35,
2462  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2463  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2464  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2465  0, 0, 0, 48, 0, 0, 49, 50, 0, 51,
2466  52, 0, 53, 0, 54, 55, 56, 57, 58, 59,
2467  60, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2468  0, 0, 0, 0, 0, 0, 0, 0, 0, 61,
2469  62, 63, 0, 0, 0, 0, 0, 0, 5, 6,
2470  7, 8, 9, 0, 0, 0, 10, 11, 0, 0,
2471  0, 12, 474, 13, 14, 15, 16, 17, 18, 19,
2472  0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2473  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2474  28, 29, 0, 31, 32, 33, 34, 35, 36, 37,
2475  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2476  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2477  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2478  0, 48, 0, 0, 49, 50, 0, 51, 52, 0,
2479  53, 0, 54, 55, 56, 57, 58, 59, 60, 0,
2480  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2481  0, 0, 0, 0, 0, 0, 0, 61, 62, 63,
2482  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2483  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2484  474, 113, 114, 115, 116, 117, 118, 119, 120, 121,
2485  122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
2486  132, 133, 134, 135, 136, 0, 0, 0, 137, 138,
2487  139, 365, 366, 367, 368, 144, 145, 146, 0, 0,
2488  0, 0, 0, 147, 148, 149, 150, 369, 370, 371,
2489  372, 155, 37, 38, 373, 40, 0, 0, 0, 0,
2490  0, 0, 0, 0, 157, 158, 159, 160, 161, 162,
2491  163, 164, 165, 0, 0, 166, 167, 0, 0, 168,
2492  169, 170, 171, 0, 0, 0, 0, 0, 0, 0,
2493  0, 0, 0, 172, 0, 0, 0, 0, 0, 0,
2494  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2495  173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
2496  0, 183, 184, 0, 0, 0, 0, 0, -548, -548,
2497  -548, 0, -548, 0, 0, 0, -548, -548, 0, 185,
2498  374, -548, 0, -548, -548, -548, -548, -548, -548, -548,
2499  0, -548, 0, 0, 0, -548, -548, -548, -548, -548,
2500  -548, -548, 0, 0, -548, 0, 0, 0, 0, 0,
2501  0, -548, 0, 0, -548, -548, -548, -548, -548, -548,
2502  -548, -548, -548, -548, -548, -548, 0, -548, -548, -548,
2503  0, -548, -548, 0, 0, 0, 0, 0, 0, 0,
2504  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2505  0, -548, 0, 0, -548, -548, 0, -548, -548, 0,
2506  -548, -548, -548, -548, -548, -548, -548, -548, -548, 0,
2507  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2508  0, 0, 0, 0, 0, 0, 0, -548, -548, -548,
2509  0, 0, 0, 0, 0, -549, -549, -549, 0, -549,
2510  0, -548, 0, -549, -549, 0, 0, -548, -549, 0,
2511  -549, -549, -549, -549, -549, -549, -549, 0, -549, 0,
2512  0, 0, -549, -549, -549, -549, -549, -549, -549, 0,
2513  0, -549, 0, 0, 0, 0, 0, 0, -549, 0,
2514  0, -549, -549, -549, -549, -549, -549, -549, -549, -549,
2515  -549, -549, -549, 0, -549, -549, -549, 0, -549, -549,
2516  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2517  0, 0, 0, 0, 0, 0, 0, 0, -549, 0,
2518  0, -549, -549, 0, -549, -549, 0, -549, -549, -549,
2519  -549, -549, -549, -549, -549, -549, 0, 0, 0, 0,
2520  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2521  0, 0, 0, 0, -549, -549, -549, 0, 0, 0,
2522  0, 0, -551, -551, -551, 0, -551, 0, -549, 0,
2523  -551, -551, 0, 0, -549, -551, 0, -551, -551, -551,
2524  -551, -551, -551, -551, 0, 0, 0, 0, 0, -551,
2525  -551, -551, -551, -551, -551, -551, 0, 0, -551, 0,
2526  0, 0, 0, 0, 0, -551, 0, 0, -551, -551,
2527  -551, -551, -551, -551, -551, -551, -551, -551, -551, -551,
2528  0, -551, -551, -551, 0, -551, -551, 0, 0, 0,
2529  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2530  0, 0, 0, 0, 0, -551, 723, 0, -551, -551,
2531  0, -551, -551, 0, -551, -551, -551, -551, -551, -551,
2532  -551, -551, -551, 0, 0, 0, 0, 0, -103, 0,
2533  0, 0, 0, 0, 0, 0, -553, -553, -553, 0,
2534  -553, -551, -551, -551, -553, -553, 0, 0, 0, -553,
2535  0, -553, -553, -553, -553, -553, -553, -553, 0, 0,
2536  0, -551, 0, -553, -553, -553, -553, -553, -553, -553,
2537  0, 0, -553, 0, 0, 0, 0, 0, 0, -553,
2538  0, 0, -553, -553, -553, -553, -553, -553, -553, -553,
2539  -553, -553, -553, -553, 0, -553, -553, -553, 0, -553,
2540  -553, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2541  0, 0, 0, 0, 0, 0, 0, 0, 0, -553,
2542  0, 0, -553, -553, 0, -553, -553, 0, -553, -553,
2543  -553, -553, -553, -553, -553, -553, -553, 0, 0, 0,
2544  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2545  -554, -554, -554, 0, -554, -553, -553, -553, -554, -554,
2546  0, 0, 0, -554, 0, -554, -554, -554, -554, -554,
2547  -554, -554, 0, 0, 0, -553, 0, -554, -554, -554,
2548  -554, -554, -554, -554, 0, 0, -554, 0, 0, 0,
2549  0, 0, 0, -554, 0, 0, -554, -554, -554, -554,
2550  -554, -554, -554, -554, -554, -554, -554, -554, 0, -554,
2551  -554, -554, 0, -554, -554, 0, 0, 0, 0, 0,
2552  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2553  0, 0, 0, -554, 0, 0, -554, -554, 0, -554,
2554  -554, 0, -554, -554, -554, -554, -554, -554, -554, -554,
2555  -554, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2556  0, 0, 0, 0, 0, 0, 0, 0, 0, -554,
2557  -554, -554, 0, 0, 0, 0, 0, 0, 0, 0,
2558  0, 0, 0, 0, 0, 0, 0, 0, 0, -554,
2559  113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
2560  123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
2561  133, 134, 135, 136, 0, 0, 0, 137, 138, 139,
2562  140, 141, 142, 143, 144, 145, 146, 0, 0, 0,
2563  0, 0, 147, 148, 149, 150, 151, 152, 153, 154,
2564  155, 270, 271, 156, 272, 0, 0, 0, 0, 0,
2565  0, 0, 0, 157, 158, 159, 160, 161, 162, 163,
2566  164, 165, 0, 0, 166, 167, 0, 0, 168, 169,
2567  170, 171, 0, 0, 0, 0, 0, 0, 0, 0,
2568  0, 0, 172, 0, 0, 0, 0, 0, 0, 0,
2569  0, 0, 0, 0, 0, 0, 0, 0, 0, 173,
2570  174, 175, 176, 177, 178, 179, 180, 181, 182, 0,
2571  183, 184, 0, 0, 0, 0, 0, 0, 0, 0,
2572  0, 0, 0, 0, 0, 0, 0, 0, 185, 113,
2573  114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
2574  124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
2575  134, 135, 136, 0, 0, 0, 137, 138, 139, 140,
2576  141, 142, 143, 144, 145, 146, 0, 0, 0, 0,
2577  0, 147, 148, 149, 150, 151, 152, 153, 154, 155,
2578  226, 0, 156, 0, 0, 0, 0, 0, 0, 0,
2579  0, 0, 157, 158, 159, 160, 161, 162, 163, 164,
2580  165, 0, 0, 166, 167, 0, 0, 168, 169, 170,
2581  171, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2582  0, 172, 0, 0, 55, 0, 0, 0, 0, 0,
2583  0, 0, 0, 0, 0, 0, 0, 0, 173, 174,
2584  175, 176, 177, 178, 179, 180, 181, 182, 0, 183,
2585  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2586  0, 0, 0, 0, 0, 0, 0, 185, 113, 114,
2587  115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
2588  125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
2589  135, 136, 0, 0, 0, 137, 138, 139, 140, 141,
2590  142, 143, 144, 145, 146, 0, 0, 0, 0, 0,
2591  147, 148, 149, 150, 151, 152, 153, 154, 155, 0,
2592  0, 156, 0, 0, 0, 0, 0, 0, 0, 0,
2593  0, 157, 158, 159, 160, 161, 162, 163, 164, 165,
2594  0, 0, 166, 167, 0, 0, 168, 169, 170, 171,
2595  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2596  172, 0, 0, 55, 0, 0, 0, 0, 0, 0,
2597  0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
2598  176, 177, 178, 179, 180, 181, 182, 0, 183, 184,
2599  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2600  0, 0, 0, 0, 0, 0, 185, 113, 114, 115,
2601  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
2602  126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
2603  136, 0, 0, 0, 137, 138, 139, 140, 141, 142,
2604  143, 144, 145, 146, 0, 0, 0, 0, 0, 147,
2605  148, 149, 150, 151, 152, 153, 154, 155, 0, 0,
2606  156, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2607  157, 158, 159, 160, 161, 162, 163, 164, 165, 0,
2608  0, 166, 167, 0, 0, 168, 169, 170, 171, 0,
2609  0, 0, 0, 0, 0, 0, 0, 0, 0, 172,
2610  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2611  0, 0, 0, 0, 0, 0, 173, 174, 175, 176,
2612  177, 178, 179, 180, 181, 182, 0, 183, 184, 0,
2613  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2614  11, 0, 0, 0, 12, 185, 13, 14, 15, 231,
2615  232, 18, 19, 0, 0, 0, 0, 0, 233, 234,
2616  235, 23, 24, 25, 26, 0, 0, 194, 0, 0,
2617  0, 0, 0, 0, 258, 0, 0, 32, 33, 34,
2618  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2619  43, 44, 45, 0, 0, 0, 0, 0, 0, 0,
2620  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2621  0, 0, 0, 0, 259, 0, 0, 197, 50, 0,
2622  51, 52, 0, 0, 0, 54, 55, 56, 57, 58,
2623  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2624  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2625  260, 10, 11, 0, 0, 0, 12, 0, 13, 14,
2626  15, 231, 232, 18, 19, 0, 0, 0, 261, 0,
2627  233, 234, 235, 23, 24, 25, 26, 0, 0, 194,
2628  0, 0, 0, 0, 0, 0, 258, 0, 0, 32,
2629  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2630  42, 0, 43, 44, 45, 0, 0, 0, 0, 0,
2631  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2632  0, 0, 0, 0, 0, 0, 259, 0, 0, 197,
2633  50, 0, 51, 52, 0, 0, 0, 54, 55, 56,
2634  57, 58, 59, 60, 0, 0, 0, 0, 0, 0,
2635  0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
2636  0, 0, 260, 10, 11, 0, 0, 0, 12, 0,
2637  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2638  490, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2639  0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
2640  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2641  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2642  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2643  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2644  0, 49, 50, 0, 51, 52, 0, 53, 0, 54,
2645  55, 56, 57, 58, 59, 60, 0, 0, 0, 0,
2646  0, 0, 0, 0, 5, 6, 7, 8, 9, 0,
2647  0, 0, 10, 11, 61, 62, 63, 12, 0, 13,
2648  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2649  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2650  27, 0, 0, 0, 0, 0, 28, 29, 0, 31,
2651  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2652  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2653  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2654  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2655  49, 50, 0, 51, 52, 0, 53, 0, 54, 55,
2656  56, 57, 58, 59, 60, 0, 0, 0, 0, 0,
2657  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2658  0, 10, 11, 61, 62, 63, 12, 0, 13, 14,
2659  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2660  20, 21, 22, 23, 24, 25, 26, 0, 0, 194,
2661  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
2662  33, 34, 35, 36, 37, 38, 39, 40, 195, 41,
2663  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2664  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2665  0, 0, 0, 0, 0, 0, 196, 0, 0, 197,
2666  50, 0, 51, 52, 0, 198, 199, 54, 55, 56,
2667  57, 58, 59, 60, 0, 0, 0, 0, 0, 0,
2668  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2669  10, 11, 61, 200, 63, 12, 0, 13, 14, 15,
2670  231, 232, 18, 19, 0, 0, 0, 0, 0, 233,
2671  234, 235, 23, 24, 25, 26, 0, 0, 194, 0,
2672  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2673  34, 35, 36, 37, 38, 39, 40, 195, 41, 42,
2674  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2675  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2676  0, 0, 0, 0, 0, 196, 0, 0, 197, 50,
2677  0, 51, 52, 0, 587, 199, 54, 55, 56, 57,
2678  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2679  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2680  11, 61, 200, 63, 12, 0, 13, 14, 15, 231,
2681  232, 18, 19, 0, 0, 0, 0, 0, 233, 234,
2682  235, 23, 24, 25, 26, 0, 0, 194, 0, 0,
2683  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2684  35, 36, 37, 38, 39, 40, 195, 41, 42, 0,
2685  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2686  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2687  0, 0, 0, 0, 196, 0, 0, 197, 50, 0,
2688  51, 52, 0, 198, 0, 54, 55, 56, 57, 58,
2689  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2690  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2691  61, 200, 63, 12, 0, 13, 14, 15, 231, 232,
2692  18, 19, 0, 0, 0, 0, 0, 233, 234, 235,
2693  23, 24, 25, 26, 0, 0, 194, 0, 0, 0,
2694  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2695  36, 37, 38, 39, 40, 195, 41, 42, 0, 43,
2696  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2697  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2698  0, 0, 0, 196, 0, 0, 197, 50, 0, 51,
2699  52, 0, 0, 199, 54, 55, 56, 57, 58, 59,
2700  60, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2701  6, 7, 0, 9, 0, 0, 0, 10, 11, 61,
2702  200, 63, 12, 0, 13, 14, 15, 231, 232, 18,
2703  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2704  24, 25, 26, 0, 0, 194, 0, 0, 0, 0,
2705  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2706  37, 38, 39, 40, 195, 41, 42, 0, 43, 44,
2707  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2708  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2709  0, 0, 196, 0, 0, 197, 50, 0, 51, 52,
2710  0, 587, 0, 54, 55, 56, 57, 58, 59, 60,
2711  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2712  7, 0, 9, 0, 0, 0, 10, 11, 61, 200,
2713  63, 12, 0, 13, 14, 15, 231, 232, 18, 19,
2714  0, 0, 0, 0, 0, 233, 234, 235, 23, 24,
2715  25, 26, 0, 0, 194, 0, 0, 0, 0, 0,
2716  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2717  38, 39, 40, 195, 41, 42, 0, 43, 44, 45,
2718  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2719  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2720  0, 196, 0, 0, 197, 50, 0, 51, 52, 0,
2721  0, 0, 54, 55, 56, 57, 58, 59, 60, 0,
2722  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2723  0, 9, 0, 0, 0, 10, 11, 61, 200, 63,
2724  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2725  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2726  26, 0, 0, 194, 0, 0, 0, 0, 0, 0,
2727  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2728  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2729  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2730  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2731  196, 0, 0, 197, 50, 0, 51, 52, 0, 484,
2732  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2733  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2734  9, 0, 0, 0, 10, 11, 61, 200, 63, 12,
2735  0, 13, 14, 15, 231, 232, 18, 19, 0, 0,
2736  0, 0, 0, 233, 234, 235, 23, 24, 25, 26,
2737  0, 0, 194, 0, 0, 0, 0, 0, 0, 29,
2738  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2739  40, 0, 41, 42, 0, 43, 44, 45, 0, 46,
2740  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2741  0, 0, 0, 0, 0, 0, 0, 0, 0, 196,
2742  0, 0, 197, 50, 0, 51, 52, 0, 198, 0,
2743  54, 55, 56, 57, 58, 59, 60, 0, 0, 0,
2744  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2745  0, 0, 0, 10, 11, 61, 200, 63, 12, 0,
2746  13, 14, 15, 231, 232, 18, 19, 0, 0, 0,
2747  0, 0, 233, 234, 235, 23, 24, 25, 26, 0,
2748  0, 194, 0, 0, 0, 0, 0, 0, 29, 0,
2749  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2750  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2751  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2752  0, 0, 0, 0, 0, 0, 0, 0, 196, 0,
2753  0, 197, 50, 0, 51, 52, 0, 772, 0, 54,
2754  55, 56, 57, 58, 59, 60, 0, 0, 0, 0,
2755  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2756  0, 0, 10, 11, 61, 200, 63, 12, 0, 13,
2757  14, 15, 231, 232, 18, 19, 0, 0, 0, 0,
2758  0, 233, 234, 235, 23, 24, 25, 26, 0, 0,
2759  194, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2760  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2761  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2762  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2763  0, 0, 0, 0, 0, 0, 0, 196, 0, 0,
2764  197, 50, 0, 51, 52, 0, 484, 0, 54, 55,
2765  56, 57, 58, 59, 60, 0, 0, 0, 0, 0,
2766  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2767  0, 10, 11, 61, 200, 63, 12, 0, 13, 14,
2768  15, 231, 232, 18, 19, 0, 0, 0, 0, 0,
2769  233, 234, 235, 23, 24, 25, 26, 0, 0, 194,
2770  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
2771  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2772  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2773  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2774  0, 0, 0, 0, 0, 0, 196, 0, 0, 197,
2775  50, 0, 51, 52, 0, 587, 0, 54, 55, 56,
2776  57, 58, 59, 60, 0, 0, 0, 0, 0, 0,
2777  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2778  10, 11, 61, 200, 63, 12, 0, 13, 14, 15,
2779  231, 232, 18, 19, 0, 0, 0, 0, 0, 233,
2780  234, 235, 23, 24, 25, 26, 0, 0, 194, 0,
2781  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2782  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2783  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2784  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2785  0, 0, 0, 0, 0, 196, 0, 0, 197, 50,
2786  0, 51, 52, 0, 0, 0, 54, 55, 56, 57,
2787  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2788  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2789  11, 61, 200, 63, 12, 0, 13, 14, 15, 16,
2790  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2791  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2792  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2793  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2794  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2795  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2796  0, 0, 0, 0, 196, 0, 0, 197, 50, 0,
2797  51, 52, 0, 0, 0, 54, 55, 56, 57, 58,
2798  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2799  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2800  61, 62, 63, 12, 0, 13, 14, 15, 16, 17,
2801  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2802  23, 24, 25, 26, 0, 0, 194, 0, 0, 0,
2803  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2804  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2805  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2806  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2807  0, 0, 0, 196, 0, 0, 197, 50, 0, 51,
2808  52, 0, 0, 0, 54, 55, 56, 57, 58, 59,
2809  60, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2810  6, 7, 0, 9, 0, 0, 0, 10, 11, 61,
2811  200, 63, 12, 0, 13, 14, 15, 231, 232, 18,
2812  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2813  24, 25, 26, 0, 0, 194, 0, 0, 0, 0,
2814  0, 0, 258, 0, 0, 32, 33, 34, 35, 36,
2815  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2816  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2817  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2818  0, 0, 259, 0, 0, 304, 50, 0, 51, 52,
2819  0, 305, 0, 54, 55, 56, 57, 58, 59, 60,
2820  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2821  0, 0, 10, 11, 0, 0, 0, 12, 260, 13,
2822  14, 15, 231, 232, 18, 19, 0, 0, 0, 0,
2823  0, 233, 234, 235, 23, 24, 25, 26, 0, 0,
2824  194, 0, 0, 0, 0, 0, 0, 258, 0, 0,
2825  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2826  41, 42, 0, 43, 44, 45, 0, 0, 0, 0,
2827  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2828  0, 0, 0, 0, 0, 0, 0, 346, 0, 0,
2829  49, 50, 0, 51, 52, 0, 53, 0, 54, 55,
2830  56, 57, 58, 59, 60, 0, 0, 0, 0, 5,
2831  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
2832  0, 0, 12, 260, 13, 14, 15, 231, 232, 18,
2833  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2834  24, 25, 26, 0, 0, 194, 0, 0, 0, 0,
2835  0, 0, 258, 0, 0, 32, 33, 34, 354, 36,
2836  37, 38, 355, 40, 0, 41, 42, 0, 43, 44,
2837  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2838  0, 0, 0, 0, 0, 0, 0, 0, 0, 356,
2839  0, 0, 357, 0, 0, 197, 50, 0, 51, 52,
2840  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2841  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2842  0, 0, 10, 11, 0, 0, 0, 12, 260, 13,
2843  14, 15, 231, 232, 18, 19, 0, 0, 0, 0,
2844  0, 233, 234, 235, 23, 24, 25, 26, 0, 0,
2845  194, 0, 0, 0, 0, 0, 0, 258, 0, 0,
2846  32, 33, 34, 354, 36, 37, 38, 355, 40, 0,
2847  41, 42, 0, 43, 44, 45, 0, 0, 0, 0,
2848  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2849  0, 0, 0, 0, 0, 0, 0, 357, 0, 0,
2850  197, 50, 0, 51, 52, 0, 0, 0, 54, 55,
2851  56, 57, 58, 59, 60, 0, 0, 0, 0, 5,
2852  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
2853  0, 0, 12, 260, 13, 14, 15, 231, 232, 18,
2854  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2855  24, 25, 26, 0, 0, 194, 0, 0, 0, 0,
2856  0, 0, 258, 0, 0, 32, 33, 34, 35, 36,
2857  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2858  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2859  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2860  0, 0, 259, 0, 0, 304, 50, 0, 51, 52,
2861  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2862  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2863  0, 0, 10, 11, 0, 0, 0, 12, 260, 13,
2864  14, 15, 231, 232, 18, 19, 0, 0, 0, 0,
2865  0, 233, 234, 235, 23, 24, 25, 26, 0, 0,
2866  194, 0, 0, 0, 0, 0, 0, 258, 0, 0,
2867  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2868  41, 42, 0, 43, 44, 45, 0, 0, 0, 0,
2869  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2870  0, 0, 0, 0, 0, 0, 0, 902, 0, 0,
2871  197, 50, 0, 51, 52, 0, 0, 0, 54, 55,
2872  56, 57, 58, 59, 60, 0, 0, 0, 0, 5,
2873  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
2874  0, 0, 12, 260, 13, 14, 15, 231, 232, 18,
2875  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2876  24, 25, 26, 0, 0, 194, 0, 663, 0, 0,
2877  0, 0, 258, 0, 0, 32, 33, 34, 35, 36,
2878  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2879  45, 308, 309, 310, 311, 312, 313, 314, 315, 316,
2880  317, 318, 319, 320, 0, 0, 321, 322, 0, 0,
2881  0, 0, 912, 0, 0, 197, 50, 0, 51, 52,
2882  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2883  0, 0, 0, 323, 0, 324, 325, 326, 327, 328,
2884  329, 330, 331, 332, 333, 0, 0, 0, 260, 0,
2885  525, 526, 0, 0, 527, 0, 0, 0, 0, 0,
2886  0, 0, 0, -241, 157, 158, 159, 160, 161, 162,
2887  163, 164, 165, 0, 0, 166, 167, 0, 0, 168,
2888  169, 170, 171, 0, 0, 0, 0, 0, 0, 0,
2889  0, 0, 0, 172, 0, 0, 0, 0, 0, 0,
2890  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2891  173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
2892  0, 183, 184, 0, 0, 0, 0, 533, 534, 0,
2893  0, 535, 0, 0, 0, 0, 0, 0, 0, 185,
2894  220, 157, 158, 159, 160, 161, 162, 163, 164, 165,
2895  0, 0, 166, 167, 0, 0, 168, 169, 170, 171,
2896  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2897  172, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2898  0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
2899  176, 177, 178, 179, 180, 181, 182, 0, 183, 184,
2900  0, 0, 0, 0, 591, 526, 0, 0, 592, 0,
2901  0, 0, 0, 0, 0, 0, 185, 220, 157, 158,
2902  159, 160, 161, 162, 163, 164, 165, 0, 0, 166,
2903  167, 0, 0, 168, 169, 170, 171, 0, 0, 0,
2904  0, 0, 0, 0, 0, 0, 0, 172, 0, 0,
2905  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2906  0, 0, 0, 0, 173, 174, 175, 176, 177, 178,
2907  179, 180, 181, 182, 0, 183, 184, 0, 0, 0,
2908  0, 594, 534, 0, 0, 595, 0, 0, 0, 0,
2909  0, 0, 0, 185, 220, 157, 158, 159, 160, 161,
2910  162, 163, 164, 165, 0, 0, 166, 167, 0, 0,
2911  168, 169, 170, 171, 0, 0, 0, 0, 0, 0,
2912  0, 0, 0, 0, 172, 0, 0, 0, 0, 0,
2913  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2914  0, 173, 174, 175, 176, 177, 178, 179, 180, 181,
2915  182, 0, 183, 184, 0, 0, 0, 0, 617, 526,
2916  0, 0, 618, 0, 0, 0, 0, 0, 0, 0,
2917  185, 220, 157, 158, 159, 160, 161, 162, 163, 164,
2918  165, 0, 0, 166, 167, 0, 0, 168, 169, 170,
2919  171, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2920  0, 172, 0, 0, 0, 0, 0, 0, 0, 0,
2921  0, 0, 0, 0, 0, 0, 0, 0, 173, 174,
2922  175, 176, 177, 178, 179, 180, 181, 182, 0, 183,
2923  184, 0, 0, 0, 0, 620, 534, 0, 0, 621,
2924  0, 0, 0, 0, 0, 0, 0, 185, 220, 157,
2925  158, 159, 160, 161, 162, 163, 164, 165, 0, 0,
2926  166, 167, 0, 0, 168, 169, 170, 171, 0, 0,
2927  0, 0, 0, 0, 0, 0, 0, 0, 172, 0,
2928  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2929  0, 0, 0, 0, 0, 173, 174, 175, 176, 177,
2930  178, 179, 180, 181, 182, 0, 183, 184, 0, 0,
2931  0, 0, 692, 526, 0, 0, 693, 0, 0, 0,
2932  0, 0, 0, 0, 185, 220, 157, 158, 159, 160,
2933  161, 162, 163, 164, 165, 0, 0, 166, 167, 0,
2934  0, 168, 169, 170, 171, 0, 0, 0, 0, 0,
2935  0, 0, 0, 0, 0, 172, 0, 0, 0, 0,
2936  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2937  0, 0, 173, 174, 175, 176, 177, 178, 179, 180,
2938  181, 182, 0, 183, 184, 0, 0, 0, 0, 695,
2939  534, 0, 0, 696, 0, 0, 0, 0, 0, 0,
2940  0, 185, 220, 157, 158, 159, 160, 161, 162, 163,
2941  164, 165, 0, 0, 166, 167, 0, 0, 168, 169,
2942  170, 171, 0, 0, 0, 0, 0, 0, 0, 0,
2943  0, 0, 172, 0, 0, 0, 0, 0, 0, 0,
2944  0, 0, 0, 0, 0, 0, 0, 0, 0, 173,
2945  174, 175, 176, 177, 178, 179, 180, 181, 182, 0,
2946  183, 184, 0, 0, 0, 0, 702, 526, 0, 0,
2947  703, 0, 0, 0, 0, 0, 0, 0, 185, 220,
2948  157, 158, 159, 160, 161, 162, 163, 164, 165, 0,
2949  0, 166, 167, 0, 0, 168, 169, 170, 171, 0,
2950  0, 0, 0, 0, 0, 0, 0, 0, 0, 172,
2951  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2952  0, 0, 0, 0, 0, 0, 173, 174, 175, 176,
2953  177, 178, 179, 180, 181, 182, 0, 183, 184, 0,
2954  0, 0, 0, 572, 534, 0, 0, 573, 0, 0,
2955  0, 0, 0, 0, 0, 185, 220, 157, 158, 159,
2956  160, 161, 162, 163, 164, 165, 0, 0, 166, 167,
2957  0, 0, 168, 169, 170, 171, 0, 0, 0, 0,
2958  0, 0, 0, 0, 0, 0, 172, 0, 0, 0,
2959  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2960  0, 0, 0, 173, 174, 175, 176, 177, 178, 179,
2961  180, 181, 182, 0, 183, 184, 0, 0, 0, 0,
2962  965, 526, 0, 0, 966, 0, 0, 0, 0, 0,
2963  0, 0, 185, 220, 157, 158, 159, 160, 161, 162,
2964  163, 164, 165, 0, 0, 166, 167, 0, 0, 168,
2965  169, 170, 171, 0, 0, 0, 0, 0, 0, 0,
2966  0, 0, 0, 172, 0, 0, 0, 0, 0, 0,
2967  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2968  173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
2969  0, 183, 184, 0, 0, 0, 0, 971, 526, 0,
2970  0, 972, 0, 0, 0, 0, 0, 0, 0, 185,
2971  220, 157, 158, 159, 160, 161, 162, 163, 164, 165,
2972  0, 0, 166, 167, 0, 0, 168, 169, 170, 171,
2973  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2974  172, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2975  0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
2976  176, 177, 178, 179, 180, 181, 182, 0, 183, 184,
2977  0, 0, 0, 0, 974, 534, 0, 0, 975, 0,
2978  0, 0, 0, 0, 0, 0, 185, 220, 157, 158,
2979  159, 160, 161, 162, 163, 164, 165, 0, 0, 166,
2980  167, 0, 0, 168, 169, 170, 171, 0, 0, 0,
2981  0, 0, 0, 0, 0, 0, 0, 172, 0, 0,
2982  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2983  0, 0, 0, 0, 173, 174, 175, 176, 177, 178,
2984  179, 180, 181, 182, 0, 183, 184, 0, 0, 0,
2985  0, 572, 534, 0, 0, 573, 0, 0, 0, 0,
2986  0, 0, 0, 185, 220, 157, 158, 159, 160, 161,
2987  162, 163, 164, 165, 0, 0, 166, 167, 0, 0,
2988  168, 169, 170, 171, 0, 0, 0, 0, 0, 0,
2989  0, 0, 0, 0, 172, 0, 0, 0, 0, 0,
2990  0, 0, 718, 0, 0, 0, 0, 0, 0, 0,
2991  0, 173, 174, 175, 176, 177, 178, 179, 180, 181,
2992  182, 663, 183, 184, 0, 0, 308, 309, 310, 311,
2993  312, 313, 314, 315, 316, 317, 318, 319, 320, 0,
2994  185, 321, 322, 0, 0, 308, 309, 310, 311, 312,
2995  313, 314, 315, 316, 317, 318, 319, 320, 0, 0,
2996  321, 322, 0, 0, 0, 0, 0, 0, 323, 0,
2997  324, 325, 326, 327, 328, 329, 330, 331, 332, 333,
2998  0, 0, 0, 0, 0, 0, 0, 323, 0, 324,
2999  325, 326, 327, 328, 329, 330, 331, 332, 333
3000 };
3001 
3002 #define yypact_value_is_default(yystate) \
3003  ((yystate) == (-747))
3004 
3005 #define yytable_value_is_error(yytable_value) \
3006  ((yytable_value) == (-574))
3007 
3008 static const yytype_int16 yycheck[] =
3009 {
3010  2, 55, 340, 28, 2, 454, 4, 52, 593, 16,
3011  17, 335, 307, 20, 307, 8, 547, 213, 16, 17,
3012  8, 566, 20, 27, 53, 29, 84, 22, 8, 87,
3013  546, 87, 4, 22, 619, 28, 49, 91, 252, 76,
3014  28, 2, 256, 4, 404, 357, 1, 65, 28, 51,
3015  52, 49, 50, 749, 450, 53, 746, 13, 334, 627,
3016  336, 53, 680, 25, 62, 762, 684, 454, 13, 16,
3017  17, 65, 26, 20, 396, 55, 400, 26, 76, 25,
3018  440, 0, 404, 27, 76, 83, 84, 576, 577, 87,
3019  88, 89, 90, 87, 490, 29, 88, 89, 90, 13,
3020  242, 25, 378, 379, 51, 851, 828, 85, 76, 694,
3021  136, 91, 87, 16, 17, 110, 147, 20, 85, 568,
3022  705, 110, 146, 399, 25, 401, 85, 653, 452, 61,
3023  87, 16, 17, 62, 109, 20, 276, 25, 278, 56,
3024  280, 13, 742, 37, 38, 87, 114, 109, 51, 52,
3025  195, 427, 109, 198, 199, 826, 701, 28, 113, 849,
3026  138, 139, 304, 763, 709, 140, 25, 109, 736, 737,
3027  25, 13, 139, 107, 106, 146, 13, 453, 140, 138,
3028  139, 143, 136, 632, 140, 147, 109, 136, 244, 145,
3029  145, 147, 147, 142, 140, 941, 892, 142, 140, 197,
3030  145, 145, 147, 147, 653, 207, 896, 904, 930, 140,
3031  217, 213, 219, 220, 25, 886, 140, 413, 220, 217,
3032  746, 219, 220, 749, 261, 223, 244, 225, 552, 242,
3033  719, 145, 230, 147, 50, 293, 294, 295, 296, 140,
3034  564, 601, 142, 241, 242, 632, 235, 147, 109, 238,
3035  244, 563, 140, 147, 258, 873, 99, 302, 826, 708,
3036  828, 932, 307, 261, 25, 661, 87, 83, 84, 261,
3037  217, 87, 219, 145, 140, 147, 305, 553, 600, 601,
3038  241, 140, 25, 341, 342, 140, 25, 343, 959, 565,
3039  806, 304, 85, 87, 292, 293, 294, 295, 296, 297,
3040  298, 299, 85, 145, 302, 147, 304, 305, 145, 307,
3041  147, 59, 60, 305, 217, 109, 219, 26, 886, 887,
3042  292, 708, 109, 849, 142, 851, 49, 467, 335, 140,
3043  875, 292, 217, 335, 219, 56, 297, 335, 145, 337,
3044  147, 87, 873, 341, 342, 138, 139, 336, 88, 343,
3045  395, 396, 690, 140, 334, 302, 139, 26, 356, 404,
3046  307, 140, 930, 109, 932, 359, 892, 85, 147, 662,
3047  109, 85, 109, 302, 61, 26, 85, 140, 307, 140,
3048  15, 142, 17, 928, 679, 87, 384, 385, 973, 85,
3049  85, 959, 437, 400, 590, 440, 421, 140, 400, 142,
3050  614, 140, 400, 85, 143, 140, 85, 223, 147, 225,
3051  412, 413, 401, 450, 142, 941, 85, 104, 105, 399,
3052  138, 139, 424, 136, 142, 139, 424, 136, 421, 138,
3053  139, 880, 85, 421, 85, 433, 85, 142, 427, 484,
3054  140, 421, 138, 139, 139, 452, 426, 147, 85, 142,
3055  452, 85, 450, 490, 452, 384, 385, 139, 450, 146,
3056  139, 85, 822, 424, 453, 68, 85, 136, 85, 138,
3057  139, 451, 433, 142, 197, 87, 85, 293, 294, 295,
3058  296, 483, 298, 299, 68, 136, 139, 138, 139, 138,
3059  139, 142, 490, 396, 85, 37, 38, 109, 490, 668,
3060  822, 223, 139, 548, 138, 139, 675, 230, 109, 52,
3061  514, 54, 55, 56, 57, 139, 119, 120, 121, 242,
3062  139, 138, 139, 861, 246, 341, 342, 143, 532, 867,
3063  139, 26, 728, 52, 437, 530, 538, 56, 540, 85,
3064  356, 530, 587, 538, 542, 552, 544, 138, 139, 538,
3065  552, 545, 546, 56, 552, 600, 601, 564, 85, 584,
3066  59, 60, 564, 144, 553, 559, 564, 137, 566, 567,
3067  106, 551, 574, 575, 576, 577, 565, 87, 615, 574,
3068  575, 304, 140, 563, 106, 574, 575, 87, 590, 593,
3069  85, 584, 138, 139, 87, 85, 584, 140, 68, 109,
3070  68, 548, 14, 15, 584, 85, 604, 609, 85, 109,
3071  140, 138, 139, 658, 17, 619, 109, 615, 56, 608,
3072  609, 574, 575, 615, 661, 145, 25, 951, 52, 94,
3073  54, 55, 56, 57, 679, 143, 638, 146, 640, 697,
3074  642, 136, 700, 138, 139, 137, 140, 142, 138, 139,
3075  52, 653, 54, 55, 56, 57, 654, 711, 138, 139,
3076  10, 138, 139, 661, 662, 89, 61, 665, 666, 661,
3077  65, 95, 96, 671, 672, 109, 952, 679, 680, 140,
3078  682, 140, 684, 140, 406, 140, 140, 89, 410, 734,
3079  694, 140, 116, 415, 96, 119, 8, 600, 13, 697,
3080  87, 705, 700, 701, 698, 61, 87, 137, 430, 104,
3081  105, 709, 109, 435, 116, 54, 710, 719, 716, 717,
3082  140, 145, 109, 140, 63, 64, 728, 772, 109, 140,
3083  68, 711, 679, 662, 87, 52, 665, 666, 796, 52,
3084  742, 111, 671, 672, 140, 743, 744, 87, 104, 105,
3085  106, 567, 144, 140, 549, 15, 109, 755, 803, 140,
3086  2, 763, 4, 765, 87, 767, 768, 489, 52, 109,
3087  54, 55, 56, 57, 16, 17, 140, 822, 20, 117,
3088  118, 119, 120, 121, 145, 783, 109, 140, 604, 791,
3089  109, 140, 794, 114, 140, 793, 140, 140, 796, 10,
3090  140, 88, 800, 801, 140, 9, 804, 49, 50, 10,
3091  137, 140, 806, 10, 808, 61, 140, 140, 140, 542,
3092  62, 544, 820, 137, 140, 114, 52, 137, 54, 55,
3093  56, 57, 834, 835, 140, 837, 68, 839, 840, 140,
3094  140, 83, 84, 137, 842, 87, 56, 140, 140, 68,
3095  842, 83, 84, 56, 783, 140, 140, 140, 104, 105,
3096  106, 140, 860, 89, 83, 84, 864, 140, 860, 95,
3097  96, 873, 142, 142, 61, 140, 424, 875, 90, 88,
3098  61, 697, 954, 736, 700, 117, 118, 119, 120, 121,
3099  116, 93, 904, 119, 689, 114, 115, 116, 117, 118,
3100  119, 120, 121, 953, 906, 907, 908, 96, 910, 911,
3101  640, 706, 642, 57, 91, 880, 142, 104, 105, 106,
3102  918, 849, 920, 104, 105, 106, 653, 746, 926, -1,
3103  928, 654, 934, 935, 936, 937, 52, -1, 54, 55,
3104  56, 57, -1, -1, 951, -1, -1, 54, 55, 951,
3105  57, 953, 954, 951, -1, 197, 63, 64, -1, 939,
3106  -1, -1, -1, 952, -1, 967, 968, 969, 970, 973,
3107  950, -1, -1, 89, -1, 217, -1, 219, 220, 981,
3108  796, 223, -1, 225, -1, 707, -1, 989, 230, -1,
3109  -1, -1, -1, 716, 717, 68, -1, -1, -1, 241,
3110  242, -1, 797, -1, 799, -1, -1, 729, -1, -1,
3111  83, 84, -1, -1, 809, -1, -1, -1, 740, 814,
3112  743, 744, 749, -1, 52, 752, 54, 55, 56, 57,
3113  -1, -1, 755, -1, -1, 765, -1, 767, 768, -1,
3114  -1, -1, -1, 116, 117, 118, 119, 120, 121, -1,
3115  292, 293, 294, 295, 296, 297, 298, 299, -1, -1,
3116  302, 89, 304, -1, -1, 307, -1, 95, -1, 52,
3117  793, 54, 55, 56, 57, 870, 871, 800, 801, -1,
3118  -1, 804, 16, 17, -1, -1, 20, -1, -1, -1,
3119  -1, 813, -1, 335, -1, 337, -1, 820, -1, 341,
3120  342, -1, -1, 825, 834, 835, -1, 837, 830, 839,
3121  840, -1, 46, 47, 356, -1, -1, 51, 52, -1,
3122  -1, -1, -1, -1, 851, -1, 853, -1, 62, 63,
3123  -1, 52, 927, 54, 55, 56, 57, -1, -1, -1,
3124  -1, 864, 384, 385, 40, 41, 42, 43, 44, -1,
3125  -1, -1, -1, -1, -1, -1, -1, -1, 400, -1,
3126  955, -1, 957, -1, -1, 892, -1, 894, 89, -1,
3127  -1, 898, -1, -1, 95, -1, 906, 907, 908, -1,
3128  910, 911, 424, 52, -1, 54, 55, 56, 57, -1,
3129  -1, 433, -1, -1, -1, 918, -1, 920, -1, -1,
3130  -1, -1, -1, 926, 934, 935, 936, 937, -1, -1,
3131  452, -1, -1, -1, 941, -1, 943, -1, -1, 946,
3132  89, -1, -1, -1, -1, -1, 95, 96, -1, -1,
3133  -1, -1, -1, -1, 961, -1, -1, 967, 968, 969,
3134  970, -1, -1, -1, -1, -1, -1, 116, -1, -1,
3135  119, 981, -1, -1, -1, -1, 983, -1, -1, 989,
3136  -1, 195, -1, -1, 198, 199, 200, -1, -1, -1,
3137  2, -1, 4, 142, -1, 52, -1, 54, 55, 56,
3138  57, -1, -1, 217, -1, 219, 220, -1, -1, -1,
3139  -1, 2, -1, 4, -1, -1, -1, -1, -1, -1,
3140  542, -1, 544, 52, -1, 54, 55, 56, 57, -1,
3141  552, -1, 89, -1, -1, -1, -1, 49, 95, 96,
3142  -1, 53, 564, -1, 566, 567, -1, -1, -1, -1,
3143  -1, -1, -1, -1, -1, -1, -1, -1, 49, 116,
3144  89, -1, 119, -1, 76, -1, 95, 96, -1, -1,
3145  -1, -1, -1, -1, -1, -1, 88, 89, 90, 91,
3146  -1, -1, 604, -1, -1, -1, -1, 116, 302, -1,
3147  119, -1, -1, 307, 308, 309, 310, 311, 312, 313,
3148  314, 315, 316, 317, 318, 319, 320, 321, 322, 323,
3149  324, 325, 326, 327, 328, 329, 330, 331, 332, 333,
3150  -1, 335, -1, -1, -1, -1, -1, -1, -1, -1,
3151  -1, -1, 654, -1, -1, -1, -1, -1, -1, -1,
3152  662, -1, -1, 665, 666, -1, -1, -1, -1, 671,
3153  672, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3154  76, 77, 78, 79, 80, -1, -1, 83, 84, -1,
3155  384, 385, -1, -1, -1, 697, -1, -1, 700, 701,
3156  394, 395, 396, -1, -1, 197, 400, 709, 402, 403,
3157  404, -1, -1, -1, 716, 717, 112, 113, 114, 115,
3158  116, 117, 118, 119, 120, 121, 197, -1, -1, 423,
3159  -1, -1, -1, -1, 428, -1, -1, -1, 230, -1,
3160  -1, 743, 744, 437, -1, -1, 440, -1, -1, 241,
3161  242, -1, -1, 755, -1, -1, -1, -1, 452, 230,
3162  -1, -1, -1, -1, -1, -1, -1, -1, -1, 261,
3163  241, 242, -1, -1, -1, -1, -1, -1, 472, 473,
3164  -1, 783, -1, -1, -1, -1, -1, -1, -1, -1,
3165  484, 793, -1, -1, 796, -1, -1, -1, 800, 801,
3166  292, -1, 804, -1, -1, 297, -1, -1, -1, -1,
3167  -1, -1, 304, 305, -1, -1, -1, 2, 820, 4,
3168  -1, 292, -1, -1, -1, -1, 297, -1, -1, -1,
3169  -1, -1, -1, 304, -1, -1, -1, -1, -1, -1,
3170  -1, -1, -1, -1, -1, 337, -1, 2, -1, 4,
3171  -1, -1, -1, -1, 548, -1, -1, -1, 552, -1,
3172  -1, -1, 864, -1, 49, 2, 337, 4, 53, -1,
3173  564, -1, -1, 875, -1, -1, -1, -1, -1, -1,
3174  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3175  -1, 76, -1, 587, 49, -1, -1, -1, 53, -1,
3176  -1, -1, -1, 88, 89, 90, 600, 601, -1, -1,
3177  -1, -1, 49, -1, -1, -1, 918, -1, 920, -1,
3178  -1, 76, -1, -1, 926, -1, 928, -1, -1, -1,
3179  -1, -1, 424, 88, 89, 90, 91, -1, -1, -1,
3180  -1, 433, -1, -1, -1, -1, -1, -1, -1, 951,
3181  -1, 88, -1, 424, -1, -1, -1, -1, 450, -1,
3182  -1, -1, 433, -1, 658, -1, -1, -1, 662, 663,
3183  -1, 665, 666, -1, -1, -1, -1, 671, 672, 0,
3184  -1, -1, -1, -1, -1, 679, -1, 8, 9, 10,
3185  -1, -1, 13, 14, 15, -1, 17, -1, 490, -1,
3186  -1, -1, -1, -1, -1, -1, 27, -1, -1, -1,
3187  -1, -1, 197, -1, -1, -1, 37, 38, -1, 40,
3188  41, 42, 43, 44, 718, -1, -1, -1, -1, 723,
3189  724, -1, 726, 727, -1, -1, -1, -1, -1, -1,
3190  734, -1, 197, -1, -1, 230, -1, -1, -1, -1,
3191  542, -1, 544, -1, -1, -1, 241, 242, -1, -1,
3192  197, -1, -1, -1, 85, -1, -1, -1, -1, -1,
3193  -1, 542, -1, 544, 566, 230, 261, -1, 772, -1,
3194  -1, -1, 776, -1, -1, -1, 241, 242, -1, 783,
3195  -1, -1, -1, 230, -1, 566, -1, -1, -1, -1,
3196  -1, -1, -1, -1, 241, 242, 261, 292, -1, 803,
3197  -1, -1, 297, -1, -1, -1, 137, -1, 139, 304,
3198  305, 142, 143, 615, 145, -1, 147, 821, 822, -1,
3199  -1, -1, -1, -1, -1, -1, -1, 292, -1, -1,
3200  -1, -1, 297, -1, -1, -1, -1, -1, -1, 304,
3201  305, -1, 337, -1, -1, 292, -1, -1, -1, -1,
3202  297, -1, 654, -1, -1, -1, -1, 304, -1, 661,
3203  307, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3204  -1, -1, 337, 654, -1, -1, -1, -1, -1, -1,
3205  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3206  337, -1, -1, -1, -1, -1, -1, -1, -1, 701,
3207  -1, -1, -1, -1, -1, -1, -1, 709, -1, -1,
3208  -1, -1, -1, -1, 716, 717, -1, -1, -1, -1,
3209  701, -1, -1, -1, -1, -1, -1, -1, 709, 424,
3210  -1, -1, -1, -1, -1, 716, 717, -1, 433, -1,
3211  -1, 743, 744, -1, -1, -1, -1, 951, -1, -1,
3212  -1, -1, -1, 755, -1, 450, -1, -1, -1, 424,
3213  -1, -1, 743, 744, -1, -1, -1, -1, 433, -1,
3214  -1, -1, -1, -1, 755, -1, -1, 424, -1, -1,
3215  -1, -1, -1, -1, -1, 450, 433, -1, -1, -1,
3216  -1, 793, -1, -1, -1, 490, -1, -1, 800, 801,
3217  -1, -1, 804, -1, -1, -1, -1, -1, -1, -1,
3218  -1, -1, 793, -1, -1, -1, -1, -1, 820, 800,
3219  801, -1, -1, 804, -1, 490, -1, -1, -1, -1,
3220  -1, -1, -1, -1, -1, -1, -1, -1, -1, 820,
3221  842, -1, -1, -1, -1, -1, -1, 542, -1, 544,
3222  -1, -1, -1, -1, -1, -1, -1, -1, 860, -1,
3223  -1, -1, 864, -1, -1, -1, -1, -1, -1, -1,
3224  -1, 566, -1, 875, -1, -1, -1, 542, -1, 544,
3225  -1, -1, -1, 864, -1, -1, -1, -1, -1, -1,
3226  -1, -1, -1, -1, 875, 542, -1, 544, -1, -1,
3227  -1, 566, -1, -1, -1, -1, -1, -1, -1, -1,
3228  -1, -1, -1, -1, -1, -1, 918, -1, 920, 566,
3229  615, -1, -1, -1, 926, -1, 928, -1, -1, -1,
3230  -1, -1, -1, -1, -1, -1, -1, 918, -1, 920,
3231  -1, -1, -1, -1, -1, 926, -1, 928, -1, -1,
3232  615, 646, -1, -1, -1, -1, -1, -1, -1, 654,
3233  -1, -1, -1, -1, -1, -1, 661, -1, -1, -1,
3234  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3235  -1, -1, 68, 69, 70, 71, 72, 73, 74, 654,
3236  -1, 77, 78, -1, -1, -1, 661, 83, 84, -1,
3237  -1, -1, -1, -1, -1, -1, 701, 654, -1, -1,
3238  -1, -1, -1, -1, 709, 662, -1, -1, -1, -1,
3239  -1, 716, 717, -1, -1, -1, 112, 113, 114, 115,
3240  116, 117, 118, 119, 120, 121, 701, -1, -1, -1,
3241  -1, -1, -1, -1, 709, -1, -1, -1, 743, 744,
3242  -1, 716, 717, -1, 701, -1, -1, -1, -1, -1,
3243  755, -1, 709, -1, -1, -1, -1, -1, -1, 716,
3244  717, 68, 69, 70, 71, 72, 73, 74, 743, 744,
3245  77, 78, -1, -1, -1, -1, 83, 84, -1, -1,
3246  755, -1, -1, -1, -1, -1, 743, 744, 793, -1,
3247  -1, -1, -1, -1, -1, 800, 801, -1, 755, 804,
3248  -1, -1, -1, -1, -1, 112, 113, 114, 115, 116,
3249  117, 118, 119, 120, 121, 820, -1, -1, 793, -1,
3250  -1, -1, -1, -1, -1, 800, 801, -1, -1, 804,
3251  -1, -1, -1, -1, -1, -1, 793, 842, -1, -1,
3252  -1, -1, -1, 800, 801, 820, -1, 804, -1, -1,
3253  -1, -1, -1, -1, -1, 860, -1, -1, -1, 864,
3254  -1, -1, -1, 820, -1, -1, -1, 842, -1, -1,
3255  875, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3256  -1, -1, -1, -1, -1, 860, -1, -1, -1, 864,
3257  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3258  875, -1, -1, 860, -1, -1, -1, 864, -1, -1,
3259  -1, -1, -1, 918, -1, 920, -1, -1, 875, -1,
3260  -1, 926, -1, 928, -1, -1, -1, -1, -1, -1,
3261  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3262  -1, -1, -1, 918, -1, 920, -1, -1, -1, -1,
3263  -1, 926, -1, 928, -1, -1, -1, -1, -1, -1,
3264  -1, 918, -1, 920, -1, -1, -1, -1, -1, 926,
3265  -1, 928, 0, 1, -1, 3, 4, 5, 6, 7,
3266  -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
3267  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3268  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3269  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3270  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3271  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3272  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3273  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3274  -1, 89, 90, -1, 92, 93, -1, 95, -1, 97,
3275  98, 99, 100, 101, 102, 103, -1, -1, -1, -1,
3276  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3277  -1, -1, -1, 0, 122, 123, 124, -1, -1, -1,
3278  -1, 8, 9, 10, -1, -1, 13, 14, 15, -1,
3279  17, -1, -1, -1, -1, -1, -1, 145, -1, 147,
3280  27, 28, 29, -1, -1, -1, -1, -1, -1, -1,
3281  37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
3282  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
3283  74, 75, 76, 77, 78, 79, 80, -1, -1, 83,
3284  84, 68, 69, 70, 71, 72, 73, 74, 75, 76,
3285  77, 78, 79, 80, -1, -1, 83, 84, 85, -1,
3286  87, 88, -1, -1, -1, -1, 110, 94, 112, 113,
3287  114, 115, 116, 117, 118, 119, 120, 121, -1, -1,
3288  107, -1, 109, 110, 111, 112, 113, 114, 115, 116,
3289  117, 118, 119, 120, 121, -1, -1, -1, -1, -1,
3290  -1, -1, -1, 147, -1, -1, -1, -1, -1, -1,
3291  137, 138, 139, 140, 0, -1, 143, 144, 145, -1,
3292  147, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3293  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3294  26, 27, 28, -1, -1, -1, -1, -1, -1, -1,
3295  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3296  -1, -1, -1, -1, -1, 68, 69, 70, 71, 72,
3297  73, 74, 75, 76, 77, 78, 79, 80, -1, -1,
3298  83, 84, 68, 69, 70, 71, 72, 73, 74, 75,
3299  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3300  -1, -1, 88, -1, -1, -1, -1, 110, 94, 112,
3301  113, 114, 115, 116, 117, 118, 119, 120, 121, -1,
3302  -1, -1, -1, -1, 110, -1, 112, 113, 114, 115,
3303  116, 117, 118, 119, 120, 121, -1, -1, -1, -1,
3304  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3305  136, 137, 138, 139, 140, 0, 142, 143, 144, 145,
3306  -1, 147, -1, 8, 9, 10, -1, -1, 13, 14,
3307  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3308  -1, -1, 27, 28, 29, -1, -1, -1, -1, -1,
3309  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3310  -1, -1, -1, -1, -1, -1, 68, 69, 70, 71,
3311  72, 73, 74, 75, -1, 77, 78, -1, -1, -1,
3312  -1, 83, 84, 68, 69, 70, 71, 72, 73, 74,
3313  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3314  85, -1, -1, 88, -1, -1, -1, -1, -1, 94,
3315  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
3316  -1, -1, 107, -1, -1, 110, 111, 112, 113, 114,
3317  115, 116, 117, 118, 119, 120, 121, -1, -1, -1,
3318  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3319  -1, -1, 137, 138, 139, 140, 0, -1, 143, 144,
3320  145, -1, 147, -1, 8, 9, 10, -1, -1, 13,
3321  14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
3322  -1, -1, 26, 27, 28, -1, -1, -1, -1, -1,
3323  -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
3324  44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3325  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3326  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
3327  74, 75, 76, 77, 78, 79, 80, -1, -1, 83,
3328  84, 85, -1, -1, 88, -1, -1, -1, -1, -1,
3329  94, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3330  -1, -1, -1, -1, -1, -1, 110, -1, 112, 113,
3331  114, 115, 116, 117, 118, 119, 120, 121, -1, -1,
3332  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3333  -1, -1, 136, 137, 138, 139, 140, 0, 142, 143,
3334  144, 145, -1, 147, -1, 8, 9, 10, -1, -1,
3335  13, 14, 15, -1, 17, -1, -1, -1, -1, -1,
3336  -1, -1, -1, -1, 27, 28, -1, -1, -1, -1,
3337  -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
3338  43, 44, -1, -1, -1, -1, -1, -1, -1, -1,
3339  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3340  -1, -1, -1, -1, -1, 68, 69, 70, 71, 72,
3341  73, 74, 75, 76, 77, 78, 79, 80, -1, -1,
3342  83, 84, 85, -1, -1, 88, -1, -1, -1, -1,
3343  -1, 94, -1, -1, -1, -1, -1, -1, -1, -1,
3344  -1, -1, -1, -1, -1, -1, -1, 110, -1, 112,
3345  113, 114, 115, 116, 117, 118, 119, 120, 121, -1,
3346  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3347  -1, -1, -1, -1, 137, 138, 139, 140, 0, 142,
3348  143, 144, 145, -1, 147, -1, 8, 9, 10, -1,
3349  -1, -1, 14, 15, -1, 17, -1, -1, -1, -1,
3350  -1, -1, -1, -1, 26, -1, -1, -1, -1, -1,
3351  -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
3352  42, 43, 44, -1, -1, -1, -1, -1, -1, -1,
3353  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3354  -1, -1, -1, -1, -1, -1, 68, 69, 70, 71,
3355  72, 73, 74, 75, 76, 77, 78, 79, 80, -1,
3356  -1, 83, 84, 85, 0, 87, -1, -1, -1, -1,
3357  -1, -1, 8, 9, 10, -1, -1, -1, 14, 15,
3358  -1, 17, -1, -1, -1, -1, -1, 109, 110, -1,
3359  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
3360  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3361  -1, -1, -1, -1, 136, 137, 138, 139, 140, -1,
3362  -1, 143, -1, 145, -1, 147, -1, -1, -1, -1,
3363  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3364  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3365  -1, 87, -1, -1, -1, -1, -1, -1, -1, -1,
3366  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3367  -1, -1, -1, 109, 110, -1, 112, 113, 114, 115,
3368  116, 117, 118, 119, 120, 121, -1, -1, -1, -1,
3369  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3370  -1, 137, 138, 139, 140, -1, -1, 143, -1, 145,
3371  1, 147, 3, 4, 5, 6, 7, 8, 9, 10,
3372  11, 12, -1, -1, 15, 16, -1, 18, 19, 20,
3373  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3374  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3375  -1, -1, -1, -1, 45, 46, -1, 48, 49, 50,
3376  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3377  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3378  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3379  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3380  -1, 92, 93, -1, 95, -1, 97, 98, 99, 100,
3381  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3382  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3383  -1, 122, 123, 124, -1, -1, -1, -1, -1, -1,
3384  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3385  -1, -1, -1, -1, 145, 1, 147, 3, 4, 5,
3386  6, 7, -1, -1, 10, 11, 12, -1, 14, 15,
3387  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3388  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3389  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3390  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3391  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3392  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3393  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3394  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3395  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3396  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3397  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3398  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3399  -1, -1, -1, -1, -1, -1, -1, -1, -1, 145,
3400  1, 147, 3, 4, 5, 6, 7, -1, -1, 10,
3401  11, 12, -1, -1, 15, 16, 17, 18, 19, 20,
3402  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3403  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3404  -1, -1, -1, -1, 45, 46, -1, 48, 49, 50,
3405  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3406  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3407  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3408  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3409  -1, 92, 93, -1, 95, -1, 97, 98, 99, 100,
3410  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3411  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3412  -1, 122, 123, 124, -1, -1, -1, -1, -1, -1,
3413  1, -1, 3, 4, 5, 6, 7, -1, -1, -1,
3414  11, 12, -1, -1, 145, 16, 147, 18, 19, 20,
3415  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3416  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3417  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3418  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3419  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3420  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3421  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3422  -1, 92, 93, -1, 95, -1, 97, 98, 99, 100,
3423  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3424  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3425  -1, 122, 123, 124, -1, -1, -1, -1, -1, -1,
3426  -1, -1, -1, -1, -1, -1, 137, -1, -1, -1,
3427  -1, -1, -1, -1, 145, 1, 147, 3, 4, 5,
3428  6, 7, -1, -1, 10, 11, 12, -1, -1, 15,
3429  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3430  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3431  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3432  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3433  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3434  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3435  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3436  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3437  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3438  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3439  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3440  -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
3441  6, 7, -1, 9, 10, 11, 12, -1, -1, 145,
3442  16, 147, 18, 19, 20, 21, 22, 23, 24, -1,
3443  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3444  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3445  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3446  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3447  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3448  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3449  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3450  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3451  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3452  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3453  -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
3454  6, 7, -1, -1, -1, 11, 12, -1, -1, 145,
3455  16, 147, 18, 19, 20, 21, 22, 23, 24, -1,
3456  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3457  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3458  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3459  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3460  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3461  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3462  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3463  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3464  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3465  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3466  -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
3467  6, 7, -1, -1, -1, 11, 12, 143, -1, 145,
3468  16, 147, 18, 19, 20, 21, 22, 23, 24, -1,
3469  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3470  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3471  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3472  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3473  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3474  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3475  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3476  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3477  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3478  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3479  -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
3480  6, 7, -1, -1, -1, 11, 12, 143, -1, 145,
3481  16, 147, 18, 19, 20, 21, 22, 23, 24, -1,
3482  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3483  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3484  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3485  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3486  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3487  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3488  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3489  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3490  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3491  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3492  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3493  -1, 137, -1, -1, -1, -1, -1, -1, -1, 145,
3494  1, 147, 3, 4, 5, 6, 7, -1, -1, 10,
3495  11, 12, -1, -1, -1, 16, -1, 18, 19, 20,
3496  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3497  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3498  -1, -1, -1, -1, 45, 46, -1, 48, 49, 50,
3499  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3500  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3501  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3502  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3503  -1, 92, 93, -1, 95, -1, 97, 98, 99, 100,
3504  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3505  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3506  -1, 122, 123, 124, -1, -1, -1, -1, -1, -1,
3507  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3508  11, 12, -1, -1, 145, 16, 147, 18, 19, 20,
3509  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3510  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3511  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3512  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3513  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3514  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3515  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3516  -1, 92, 93, -1, 95, 96, 97, 98, 99, 100,
3517  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3518  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3519  12, 122, 123, 124, 16, -1, 18, 19, 20, 21,
3520  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3521  32, 33, 34, 35, 36, -1, 147, 39, -1, -1,
3522  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3523  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3524  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3525  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3526  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3527  92, 93, -1, -1, -1, 97, 98, 99, 100, 101,
3528  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3529  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3530  122, 123, 124, -1, -1, -1, -1, -1, -1, -1,
3531  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3532  12, -1, -1, 145, 16, 147, 18, 19, 20, 21,
3533  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3534  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3535  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3536  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3537  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3538  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3539  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3540  92, 93, -1, -1, -1, 97, 98, 99, 100, 101,
3541  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3542  3, 4, 5, 6, 7, -1, -1, -1, 11, 12,
3543  122, 123, 124, 16, -1, 18, 19, 20, 21, 22,
3544  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3545  33, 34, 35, 36, -1, 147, 39, -1, -1, -1,
3546  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3547  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
3548  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3549  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3550  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3551  93, -1, 95, -1, 97, 98, 99, 100, 101, 102,
3552  103, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3553  -1, -1, -1, -1, -1, -1, -1, -1, -1, 122,
3554  123, 124, -1, -1, -1, -1, -1, -1, 3, 4,
3555  5, 6, 7, -1, -1, -1, 11, 12, -1, -1,
3556  -1, 16, 145, 18, 19, 20, 21, 22, 23, 24,
3557  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3558  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3559  45, 46, -1, 48, 49, 50, 51, 52, 53, 54,
3560  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3561  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3562  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3563  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3564  95, -1, 97, 98, 99, 100, 101, 102, 103, -1,
3565  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3566  -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
3567  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3568  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3569  145, 3, 4, 5, 6, 7, 8, 9, 10, 11,
3570  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
3571  22, 23, 24, 25, 26, -1, -1, -1, 30, 31,
3572  32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
3573  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3574  52, 53, 54, 55, 56, 57, -1, -1, -1, -1,
3575  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
3576  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
3577  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
3578  -1, -1, -1, 95, -1, -1, -1, -1, -1, -1,
3579  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3580  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
3581  -1, 123, 124, -1, -1, -1, -1, -1, 3, 4,
3582  5, -1, 7, -1, -1, -1, 11, 12, -1, 141,
3583  142, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3584  -1, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3585  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3586  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3587  55, 56, 57, 58, 59, 60, -1, 62, 63, 64,
3588  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3589  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3590  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3591  95, 96, 97, 98, 99, 100, 101, 102, 103, -1,
3592  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3593  -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
3594  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
3595  -1, 136, -1, 11, 12, -1, -1, 142, 16, -1,
3596  18, 19, 20, 21, 22, 23, 24, -1, 26, -1,
3597  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3598  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3599  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3600  58, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3601  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3602  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3603  -1, 89, 90, -1, 92, 93, -1, 95, 96, 97,
3604  98, 99, 100, 101, 102, 103, -1, -1, -1, -1,
3605  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3606  -1, -1, -1, -1, 122, 123, 124, -1, -1, -1,
3607  -1, -1, 3, 4, 5, -1, 7, -1, 136, -1,
3608  11, 12, -1, -1, 142, 16, -1, 18, 19, 20,
3609  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3610  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3611  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3612  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3613  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3614  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3615  -1, -1, -1, -1, -1, 86, 87, -1, 89, 90,
3616  -1, 92, 93, -1, 95, 96, 97, 98, 99, 100,
3617  101, 102, 103, -1, -1, -1, -1, -1, 109, -1,
3618  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3619  7, 122, 123, 124, 11, 12, -1, -1, -1, 16,
3620  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3621  -1, 142, -1, 30, 31, 32, 33, 34, 35, 36,
3622  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3623  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3624  57, 58, 59, 60, -1, 62, 63, 64, -1, 66,
3625  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3626  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3627  -1, -1, 89, 90, -1, 92, 93, -1, 95, 96,
3628  97, 98, 99, 100, 101, 102, 103, -1, -1, -1,
3629  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3630  3, 4, 5, -1, 7, 122, 123, 124, 11, 12,
3631  -1, -1, -1, 16, -1, 18, 19, 20, 21, 22,
3632  23, 24, -1, -1, -1, 142, -1, 30, 31, 32,
3633  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3634  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3635  53, 54, 55, 56, 57, 58, 59, 60, -1, 62,
3636  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3637  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3638  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3639  93, -1, 95, 96, 97, 98, 99, 100, 101, 102,
3640  103, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3641  -1, -1, -1, -1, -1, -1, -1, -1, -1, 122,
3642  123, 124, -1, -1, -1, -1, -1, -1, -1, -1,
3643  -1, -1, -1, -1, -1, -1, -1, -1, -1, 142,
3644  3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
3645  13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
3646  23, 24, 25, 26, -1, -1, -1, 30, 31, 32,
3647  33, 34, 35, 36, 37, 38, 39, -1, -1, -1,
3648  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3649  53, 54, 55, 56, 57, -1, -1, -1, -1, -1,
3650  -1, -1, -1, 66, 67, 68, 69, 70, 71, 72,
3651  73, 74, -1, -1, 77, 78, -1, -1, 81, 82,
3652  83, 84, -1, -1, -1, -1, -1, -1, -1, -1,
3653  -1, -1, 95, -1, -1, -1, -1, -1, -1, -1,
3654  -1, -1, -1, -1, -1, -1, -1, -1, -1, 112,
3655  113, 114, 115, 116, 117, 118, 119, 120, 121, -1,
3656  123, 124, -1, -1, -1, -1, -1, -1, -1, -1,
3657  -1, -1, -1, -1, -1, -1, -1, -1, 141, 3,
3658  4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3659  14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
3660  24, 25, 26, -1, -1, -1, 30, 31, 32, 33,
3661  34, 35, 36, 37, 38, 39, -1, -1, -1, -1,
3662  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3663  54, -1, 56, -1, -1, -1, -1, -1, -1, -1,
3664  -1, -1, 66, 67, 68, 69, 70, 71, 72, 73,
3665  74, -1, -1, 77, 78, -1, -1, 81, 82, 83,
3666  84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3667  -1, 95, -1, -1, 98, -1, -1, -1, -1, -1,
3668  -1, -1, -1, -1, -1, -1, -1, -1, 112, 113,
3669  114, 115, 116, 117, 118, 119, 120, 121, -1, 123,
3670  124, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3671  -1, -1, -1, -1, -1, -1, -1, 141, 3, 4,
3672  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3673  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3674  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3675  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
3676  45, 46, 47, 48, 49, 50, 51, 52, 53, -1,
3677  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
3678  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3679  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3680  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3681  95, -1, -1, 98, -1, -1, -1, -1, -1, -1,
3682  -1, -1, -1, -1, -1, -1, -1, 112, 113, 114,
3683  115, 116, 117, 118, 119, 120, 121, -1, 123, 124,
3684  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3685  -1, -1, -1, -1, -1, -1, 141, 3, 4, 5,
3686  6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
3687  16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3688  26, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3689  36, 37, 38, 39, -1, -1, -1, -1, -1, 45,
3690  46, 47, 48, 49, 50, 51, 52, 53, -1, -1,
3691  56, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3692  66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
3693  -1, 77, 78, -1, -1, 81, 82, 83, 84, -1,
3694  -1, -1, -1, -1, -1, -1, -1, -1, -1, 95,
3695  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3696  -1, -1, -1, -1, -1, -1, 112, 113, 114, 115,
3697  116, 117, 118, 119, 120, 121, -1, 123, 124, -1,
3698  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3699  12, -1, -1, -1, 16, 141, 18, 19, 20, 21,
3700  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3701  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3702  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3703  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3704  62, 63, 64, -1, -1, -1, -1, -1, -1, -1,
3705  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3706  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3707  92, 93, -1, -1, -1, 97, 98, 99, 100, 101,
3708  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3709  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3710  122, 11, 12, -1, -1, -1, 16, -1, 18, 19,
3711  20, 21, 22, 23, 24, -1, -1, -1, 140, -1,
3712  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3713  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3714  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3715  60, -1, 62, 63, 64, -1, -1, -1, -1, -1,
3716  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3717  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3718  90, -1, 92, 93, -1, -1, -1, 97, 98, 99,
3719  100, 101, 102, 103, -1, -1, -1, -1, -1, -1,
3720  -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
3721  -1, -1, 122, 11, 12, -1, -1, -1, 16, -1,
3722  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3723  140, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3724  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3725  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3726  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3727  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3728  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3729  -1, 89, 90, -1, 92, 93, -1, 95, -1, 97,
3730  98, 99, 100, 101, 102, 103, -1, -1, -1, -1,
3731  -1, -1, -1, -1, 3, 4, 5, 6, 7, -1,
3732  -1, -1, 11, 12, 122, 123, 124, 16, -1, 18,
3733  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3734  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3735  39, -1, -1, -1, -1, -1, 45, 46, -1, 48,
3736  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3737  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3738  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3739  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3740  89, 90, -1, 92, 93, -1, 95, -1, 97, 98,
3741  99, 100, 101, 102, 103, -1, -1, -1, -1, -1,
3742  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3743  -1, 11, 12, 122, 123, 124, 16, -1, 18, 19,
3744  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3745  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3746  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3747  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
3748  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3749  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3750  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3751  90, -1, 92, 93, -1, 95, 96, 97, 98, 99,
3752  100, 101, 102, 103, -1, -1, -1, -1, -1, -1,
3753  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3754  11, 12, 122, 123, 124, 16, -1, 18, 19, 20,
3755  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3756  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3757  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3758  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3759  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3760  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3761  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3762  -1, 92, 93, -1, 95, 96, 97, 98, 99, 100,
3763  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3764  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3765  12, 122, 123, 124, 16, -1, 18, 19, 20, 21,
3766  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3767  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3768  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3769  52, 53, 54, 55, 56, 57, 58, 59, 60, -1,
3770  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3771  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3772  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3773  92, 93, -1, 95, -1, 97, 98, 99, 100, 101,
3774  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3775  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
3776  122, 123, 124, 16, -1, 18, 19, 20, 21, 22,
3777  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3778  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3779  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3780  53, 54, 55, 56, 57, 58, 59, 60, -1, 62,
3781  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3782  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3783  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3784  93, -1, -1, 96, 97, 98, 99, 100, 101, 102,
3785  103, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3786  4, 5, -1, 7, -1, -1, -1, 11, 12, 122,
3787  123, 124, 16, -1, 18, 19, 20, 21, 22, 23,
3788  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3789  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3790  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3791  54, 55, 56, 57, 58, 59, 60, -1, 62, 63,
3792  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
3793  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3794  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3795  -1, 95, -1, 97, 98, 99, 100, 101, 102, 103,
3796  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
3797  5, -1, 7, -1, -1, -1, 11, 12, 122, 123,
3798  124, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3799  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3800  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3801  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3802  55, 56, 57, 58, 59, 60, -1, 62, 63, 64,
3803  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3804  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3805  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3806  -1, -1, 97, 98, 99, 100, 101, 102, 103, -1,
3807  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3808  -1, 7, -1, -1, -1, 11, 12, 122, 123, 124,
3809  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3810  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3811  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3812  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3813  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3814  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3815  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3816  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3817  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3818  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3819  7, -1, -1, -1, 11, 12, 122, 123, 124, 16,
3820  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3821  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3822  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3823  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3824  57, -1, 59, 60, -1, 62, 63, 64, -1, 66,
3825  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3826  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3827  -1, -1, 89, 90, -1, 92, 93, -1, 95, -1,
3828  97, 98, 99, 100, 101, 102, 103, -1, -1, -1,
3829  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
3830  -1, -1, -1, 11, 12, 122, 123, 124, 16, -1,
3831  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3832  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3833  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3834  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3835  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3836  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3837  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3838  -1, 89, 90, -1, 92, 93, -1, 95, -1, 97,
3839  98, 99, 100, 101, 102, 103, -1, -1, -1, -1,
3840  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3841  -1, -1, 11, 12, 122, 123, 124, 16, -1, 18,
3842  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3843  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3844  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3845  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3846  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3847  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3848  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3849  89, 90, -1, 92, 93, -1, 95, -1, 97, 98,
3850  99, 100, 101, 102, 103, -1, -1, -1, -1, -1,
3851  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3852  -1, 11, 12, 122, 123, 124, 16, -1, 18, 19,
3853  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3854  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3855  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3856  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3857  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3858  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3859  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3860  90, -1, 92, 93, -1, 95, -1, 97, 98, 99,
3861  100, 101, 102, 103, -1, -1, -1, -1, -1, -1,
3862  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3863  11, 12, 122, 123, 124, 16, -1, 18, 19, 20,
3864  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3865  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3866  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3867  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3868  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3869  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3870  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3871  -1, 92, 93, -1, -1, -1, 97, 98, 99, 100,
3872  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3873  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3874  12, 122, 123, 124, 16, -1, 18, 19, 20, 21,
3875  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3876  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3877  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3878  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3879  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3880  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3881  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3882  92, 93, -1, -1, -1, 97, 98, 99, 100, 101,
3883  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3884  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
3885  122, 123, 124, 16, -1, 18, 19, 20, 21, 22,
3886  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3887  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3888  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3889  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
3890  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3891  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3892  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3893  93, -1, -1, -1, 97, 98, 99, 100, 101, 102,
3894  103, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3895  4, 5, -1, 7, -1, -1, -1, 11, 12, 122,
3896  123, 124, 16, -1, 18, 19, 20, 21, 22, 23,
3897  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3898  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3899  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3900  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3901  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3902  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3903  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3904  -1, 95, -1, 97, 98, 99, 100, 101, 102, 103,
3905  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3906  -1, -1, 11, 12, -1, -1, -1, 16, 122, 18,
3907  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3908  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3909  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3910  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3911  59, 60, -1, 62, 63, 64, -1, -1, -1, -1,
3912  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3913  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3914  89, 90, -1, 92, 93, -1, 95, -1, 97, 98,
3915  99, 100, 101, 102, 103, -1, -1, -1, -1, 3,
3916  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
3917  -1, -1, 16, 122, 18, 19, 20, 21, 22, 23,
3918  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3919  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3920  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3921  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3922  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3923  -1, -1, -1, -1, -1, -1, -1, -1, -1, 83,
3924  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3925  -1, -1, -1, 97, 98, 99, 100, 101, 102, 103,
3926  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3927  -1, -1, 11, 12, -1, -1, -1, 16, 122, 18,
3928  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3929  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3930  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3931  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3932  59, 60, -1, 62, 63, 64, -1, -1, -1, -1,
3933  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3934  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3935  89, 90, -1, 92, 93, -1, -1, -1, 97, 98,
3936  99, 100, 101, 102, 103, -1, -1, -1, -1, 3,
3937  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
3938  -1, -1, 16, 122, 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, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3942  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3943  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3944  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3945  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3946  -1, -1, -1, 97, 98, 99, 100, 101, 102, 103,
3947  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3948  -1, -1, 11, 12, -1, -1, -1, 16, 122, 18,
3949  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3950  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3951  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3952  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3953  59, 60, -1, 62, 63, 64, -1, -1, -1, -1,
3954  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3955  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3956  89, 90, -1, 92, 93, -1, -1, -1, 97, 98,
3957  99, 100, 101, 102, 103, -1, -1, -1, -1, 3,
3958  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
3959  -1, -1, 16, 122, 18, 19, 20, 21, 22, 23,
3960  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3961  34, 35, 36, -1, -1, 39, -1, 44, -1, -1,
3962  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3963  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3964  64, 68, 69, 70, 71, 72, 73, 74, 75, 76,
3965  77, 78, 79, 80, -1, -1, 83, 84, -1, -1,
3966  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3967  -1, -1, -1, 97, 98, 99, 100, 101, 102, 103,
3968  -1, -1, -1, 110, -1, 112, 113, 114, 115, 116,
3969  117, 118, 119, 120, 121, -1, -1, -1, 122, -1,
3970  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
3971  -1, -1, -1, 140, 66, 67, 68, 69, 70, 71,
3972  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
3973  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
3974  -1, -1, -1, 95, -1, -1, -1, -1, -1, -1,
3975  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3976  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
3977  -1, 123, 124, -1, -1, -1, -1, 52, 53, -1,
3978  -1, 56, -1, -1, -1, -1, -1, -1, -1, 141,
3979  142, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3980  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3981  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3982  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3983  -1, -1, -1, -1, -1, -1, -1, 112, 113, 114,
3984  115, 116, 117, 118, 119, 120, 121, -1, 123, 124,
3985  -1, -1, -1, -1, 52, 53, -1, -1, 56, -1,
3986  -1, -1, -1, -1, -1, -1, 141, 142, 66, 67,
3987  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
3988  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
3989  -1, -1, -1, -1, -1, -1, -1, 95, -1, -1,
3990  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3991  -1, -1, -1, -1, 112, 113, 114, 115, 116, 117,
3992  118, 119, 120, 121, -1, 123, 124, -1, -1, -1,
3993  -1, 52, 53, -1, -1, 56, -1, -1, -1, -1,
3994  -1, -1, -1, 141, 142, 66, 67, 68, 69, 70,
3995  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
3996  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
3997  -1, -1, -1, -1, 95, -1, -1, -1, -1, -1,
3998  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3999  -1, 112, 113, 114, 115, 116, 117, 118, 119, 120,
4000  121, -1, 123, 124, -1, -1, -1, -1, 52, 53,
4001  -1, -1, 56, -1, -1, -1, -1, -1, -1, -1,
4002  141, 142, 66, 67, 68, 69, 70, 71, 72, 73,
4003  74, -1, -1, 77, 78, -1, -1, 81, 82, 83,
4004  84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4005  -1, 95, -1, -1, -1, -1, -1, -1, -1, -1,
4006  -1, -1, -1, -1, -1, -1, -1, -1, 112, 113,
4007  114, 115, 116, 117, 118, 119, 120, 121, -1, 123,
4008  124, -1, -1, -1, -1, 52, 53, -1, -1, 56,
4009  -1, -1, -1, -1, -1, -1, -1, 141, 142, 66,
4010  67, 68, 69, 70, 71, 72, 73, 74, -1, -1,
4011  77, 78, -1, -1, 81, 82, 83, 84, -1, -1,
4012  -1, -1, -1, -1, -1, -1, -1, -1, 95, -1,
4013  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4014  -1, -1, -1, -1, -1, 112, 113, 114, 115, 116,
4015  117, 118, 119, 120, 121, -1, 123, 124, -1, -1,
4016  -1, -1, 52, 53, -1, -1, 56, -1, -1, -1,
4017  -1, -1, -1, -1, 141, 142, 66, 67, 68, 69,
4018  70, 71, 72, 73, 74, -1, -1, 77, 78, -1,
4019  -1, 81, 82, 83, 84, -1, -1, -1, -1, -1,
4020  -1, -1, -1, -1, -1, 95, -1, -1, -1, -1,
4021  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4022  -1, -1, 112, 113, 114, 115, 116, 117, 118, 119,
4023  120, 121, -1, 123, 124, -1, -1, -1, -1, 52,
4024  53, -1, -1, 56, -1, -1, -1, -1, -1, -1,
4025  -1, 141, 142, 66, 67, 68, 69, 70, 71, 72,
4026  73, 74, -1, -1, 77, 78, -1, -1, 81, 82,
4027  83, 84, -1, -1, -1, -1, -1, -1, -1, -1,
4028  -1, -1, 95, -1, -1, -1, -1, -1, -1, -1,
4029  -1, -1, -1, -1, -1, -1, -1, -1, -1, 112,
4030  113, 114, 115, 116, 117, 118, 119, 120, 121, -1,
4031  123, 124, -1, -1, -1, -1, 52, 53, -1, -1,
4032  56, -1, -1, -1, -1, -1, -1, -1, 141, 142,
4033  66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
4034  -1, 77, 78, -1, -1, 81, 82, 83, 84, -1,
4035  -1, -1, -1, -1, -1, -1, -1, -1, -1, 95,
4036  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4037  -1, -1, -1, -1, -1, -1, 112, 113, 114, 115,
4038  116, 117, 118, 119, 120, 121, -1, 123, 124, -1,
4039  -1, -1, -1, 52, 53, -1, -1, 56, -1, -1,
4040  -1, -1, -1, -1, -1, 141, 142, 66, 67, 68,
4041  69, 70, 71, 72, 73, 74, -1, -1, 77, 78,
4042  -1, -1, 81, 82, 83, 84, -1, -1, -1, -1,
4043  -1, -1, -1, -1, -1, -1, 95, -1, -1, -1,
4044  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4045  -1, -1, -1, 112, 113, 114, 115, 116, 117, 118,
4046  119, 120, 121, -1, 123, 124, -1, -1, -1, -1,
4047  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
4048  -1, -1, 141, 142, 66, 67, 68, 69, 70, 71,
4049  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
4050  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
4051  -1, -1, -1, 95, -1, -1, -1, -1, -1, -1,
4052  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4053  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
4054  -1, 123, 124, -1, -1, -1, -1, 52, 53, -1,
4055  -1, 56, -1, -1, -1, -1, -1, -1, -1, 141,
4056  142, 66, 67, 68, 69, 70, 71, 72, 73, 74,
4057  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
4058  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4059  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4060  -1, -1, -1, -1, -1, -1, -1, 112, 113, 114,
4061  115, 116, 117, 118, 119, 120, 121, -1, 123, 124,
4062  -1, -1, -1, -1, 52, 53, -1, -1, 56, -1,
4063  -1, -1, -1, -1, -1, -1, 141, 142, 66, 67,
4064  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
4065  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
4066  -1, -1, -1, -1, -1, -1, -1, 95, -1, -1,
4067  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4068  -1, -1, -1, -1, 112, 113, 114, 115, 116, 117,
4069  118, 119, 120, 121, -1, 123, 124, -1, -1, -1,
4070  -1, 52, 53, -1, -1, 56, -1, -1, -1, -1,
4071  -1, -1, -1, 141, 142, 66, 67, 68, 69, 70,
4072  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
4073  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
4074  -1, -1, -1, -1, 95, -1, -1, -1, -1, -1,
4075  -1, -1, 44, -1, -1, -1, -1, -1, -1, -1,
4076  -1, 112, 113, 114, 115, 116, 117, 118, 119, 120,
4077  121, 44, 123, 124, -1, -1, 68, 69, 70, 71,
4078  72, 73, 74, 75, 76, 77, 78, 79, 80, -1,
4079  141, 83, 84, -1, -1, 68, 69, 70, 71, 72,
4080  73, 74, 75, 76, 77, 78, 79, 80, -1, -1,
4081  83, 84, -1, -1, -1, -1, -1, -1, 110, -1,
4082  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
4083  -1, -1, -1, -1, -1, -1, -1, 110, -1, 112,
4084  113, 114, 115, 116, 117, 118, 119, 120, 121
4085 };
4086 
4087 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4088  symbol of state STATE-NUM. */
4089 static const yytype_uint16 yystos[] =
4090 {
4091  0, 149, 150, 0, 1, 3, 4, 5, 6, 7,
4092  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4093  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4094  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4095  57, 59, 60, 62, 63, 64, 66, 67, 86, 89,
4096  90, 92, 93, 95, 97, 98, 99, 100, 101, 102,
4097  103, 122, 123, 124, 151, 152, 153, 158, 160, 161,
4098  163, 164, 167, 168, 170, 171, 172, 174, 175, 185,
4099  199, 216, 217, 218, 219, 220, 221, 222, 223, 224,
4100  225, 226, 249, 250, 260, 261, 262, 263, 264, 265,
4101  266, 269, 279, 281, 282, 283, 284, 285, 286, 287,
4102  310, 321, 153, 3, 4, 5, 6, 7, 8, 9,
4103  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
4104  20, 21, 22, 23, 24, 25, 26, 30, 31, 32,
4105  33, 34, 35, 36, 37, 38, 39, 45, 46, 47,
4106  48, 49, 50, 51, 52, 53, 56, 66, 67, 68,
4107  69, 70, 71, 72, 73, 74, 77, 78, 81, 82,
4108  83, 84, 95, 112, 113, 114, 115, 116, 117, 118,
4109  119, 120, 121, 123, 124, 141, 178, 179, 180, 181,
4110  183, 184, 279, 281, 39, 58, 86, 89, 95, 96,
4111  123, 167, 175, 185, 187, 192, 195, 197, 216, 283,
4112  284, 286, 287, 308, 309, 192, 192, 142, 193, 194,
4113  142, 189, 193, 142, 147, 315, 54, 180, 315, 154,
4114  136, 21, 22, 30, 31, 32, 185, 216, 310, 185,
4115  56, 1, 89, 156, 157, 158, 169, 170, 321, 161,
4116  188, 197, 308, 321, 187, 307, 308, 321, 46, 86,
4117  122, 140, 174, 199, 216, 283, 284, 287, 242, 243,
4118  54, 55, 57, 178, 272, 280, 271, 272, 273, 146,
4119  267, 146, 270, 59, 60, 163, 185, 185, 145, 147,
4120  314, 319, 320, 40, 41, 42, 43, 44, 37, 38,
4121  28, 247, 109, 140, 89, 95, 171, 109, 68, 69,
4122  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
4123  80, 83, 84, 110, 112, 113, 114, 115, 116, 117,
4124  118, 119, 120, 121, 85, 138, 139, 200, 161, 162,
4125  162, 203, 205, 162, 314, 320, 86, 168, 175, 216,
4126  232, 283, 284, 287, 52, 56, 83, 86, 176, 177,
4127  216, 283, 284, 287, 177, 33, 34, 35, 36, 49,
4128  50, 51, 52, 56, 142, 178, 285, 305, 85, 139,
4129  26, 136, 251, 263, 87, 87, 189, 193, 251, 140,
4130  187, 56, 187, 187, 109, 88, 140, 196, 321, 85,
4131  138, 139, 87, 87, 140, 196, 192, 315, 316, 192,
4132  191, 192, 197, 308, 321, 161, 316, 161, 54, 63,
4133  64, 159, 142, 186, 136, 156, 85, 139, 87, 158,
4134  169, 143, 314, 320, 316, 201, 144, 140, 147, 318,
4135  140, 318, 137, 318, 315, 56, 59, 60, 171, 173,
4136  140, 85, 138, 139, 244, 61, 104, 105, 106, 274,
4137  106, 274, 106, 65, 274, 106, 106, 268, 274, 106,
4138  61, 106, 68, 68, 145, 153, 162, 162, 162, 162,
4139  158, 161, 161, 248, 95, 163, 187, 197, 198, 169,
4140  140, 174, 140, 160, 163, 175, 185, 187, 198, 185,
4141  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
4142  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
4143  185, 185, 185, 185, 185, 52, 53, 56, 183, 189,
4144  311, 312, 191, 52, 53, 56, 183, 189, 311, 155,
4145  156, 13, 228, 319, 228, 162, 162, 314, 17, 254,
4146  56, 85, 138, 139, 25, 161, 52, 56, 176, 1,
4147  113, 288, 319, 85, 138, 139, 212, 306, 213, 85,
4148  139, 313, 52, 56, 311, 311, 253, 252, 163, 185,
4149  163, 185, 94, 165, 182, 185, 187, 95, 187, 195,
4150  308, 52, 56, 191, 52, 56, 309, 316, 143, 316,
4151  140, 140, 316, 180, 202, 185, 151, 137, 311, 311,
4152  185, 316, 158, 316, 308, 140, 173, 52, 56, 191,
4153  52, 56, 52, 54, 55, 56, 57, 89, 95, 96,
4154  116, 119, 142, 245, 291, 292, 293, 294, 295, 296,
4155  299, 300, 301, 302, 303, 276, 275, 146, 274, 146,
4156  185, 185, 76, 114, 237, 238, 321, 187, 140, 316,
4157  173, 140, 109, 44, 315, 87, 87, 189, 193, 315,
4158  317, 87, 87, 189, 190, 193, 321, 10, 227, 8,
4159  256, 321, 156, 13, 156, 27, 229, 319, 229, 254,
4160  197, 227, 52, 56, 191, 52, 56, 207, 210, 319,
4161  289, 209, 52, 56, 176, 191, 155, 161, 142, 290,
4162  291, 214, 190, 193, 190, 193, 237, 237, 44, 166,
4163  180, 187, 196, 87, 87, 317, 87, 87, 308, 161,
4164  137, 318, 171, 317, 109, 52, 89, 95, 233, 234,
4165  235, 293, 291, 29, 107, 246, 140, 304, 321, 140,
4166  304, 52, 140, 304, 52, 277, 54, 55, 57, 278,
4167  287, 52, 145, 236, 239, 295, 297, 298, 301, 303,
4168  321, 156, 95, 187, 173, 185, 111, 163, 185, 163,
4169  185, 165, 144, 87, 163, 185, 163, 185, 165, 187,
4170  198, 257, 321, 15, 231, 321, 14, 230, 231, 231,
4171  204, 206, 227, 140, 228, 317, 162, 319, 162, 155,
4172  317, 227, 316, 291, 155, 319, 178, 156, 156, 185,
4173  237, 87, 140, 316, 187, 235, 140, 293, 140, 316,
4174  239, 156, 156, 294, 299, 301, 303, 295, 296, 301,
4175  295, 156, 109, 52, 240, 241, 292, 239, 114, 140,
4176  304, 140, 304, 140, 304, 10, 187, 185, 163, 185,
4177  88, 258, 321, 156, 9, 259, 321, 162, 227, 227,
4178  156, 156, 187, 156, 229, 211, 319, 227, 316, 227,
4179  215, 10, 137, 156, 316, 234, 140, 95, 233, 316,
4180  10, 137, 140, 304, 140, 304, 140, 304, 140, 304,
4181  304, 137, 86, 216, 140, 114, 298, 301, 295, 297,
4182  301, 295, 86, 175, 216, 283, 284, 287, 228, 156,
4183  228, 227, 227, 231, 254, 255, 208, 155, 290, 137,
4184  140, 234, 140, 293, 295, 301, 295, 295, 56, 85,
4185  241, 140, 304, 140, 304, 304, 140, 304, 304, 56,
4186  85, 138, 139, 156, 156, 156, 227, 155, 234, 140,
4187  304, 140, 304, 304, 304, 52, 56, 295, 301, 295,
4188  295, 52, 56, 191, 52, 56, 256, 230, 227, 227,
4189  234, 295, 304, 140, 304, 304, 304, 317, 304, 295,
4190  304
4191 };
4192 
4193 #define yyerrok (yyerrstatus = 0)
4194 #define yyclearin (yychar = YYEMPTY)
4195 #define YYEMPTY (-2)
4196 #define YYEOF 0
4197 
4198 #define YYACCEPT goto yyacceptlab
4199 #define YYABORT goto yyabortlab
4200 #define YYERROR goto yyerrorlab
4201 
4202 
4203 /* Like YYERROR except do call yyerror. This remains here temporarily
4204  to ease the transition to the new meaning of YYERROR, for GCC.
4205  Once GCC version 2 has supplanted version 1, this can go. However,
4206  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
4207  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
4208  discussed. */
4209 
4210 #define YYFAIL goto yyerrlab
4211 #if defined YYFAIL
4212  /* This is here to suppress warnings from the GCC cpp's
4213  -Wunused-macros. Normally we don't worry about that warning, but
4214  some users do, and we want to make it easy for users to remove
4215  YYFAIL uses, which will produce warnings from Bison 2.5. */
4216 #endif
4217 
4218 #define YYRECOVERING() (!!yyerrstatus)
4219 
4220 #define YYBACKUP(Token, Value) \
4221 do \
4222  if (yychar == YYEMPTY && yylen == 1) \
4223  { \
4224  yychar = (Token); \
4225  yylval = (Value); \
4226  YYPOPSTACK (1); \
4227  goto yybackup; \
4228  } \
4229  else \
4230  { \
4231  parser_yyerror (parser, YY_("syntax error: cannot back up")); \
4232  YYERROR; \
4233  } \
4234 while (YYID (0))
4235 
4236 
4237 #define YYTERROR 1
4238 #define YYERRCODE 256
4239 
4240 
4241 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
4242  If N is 0, then set CURRENT to the empty location which ends
4243  the previous symbol: RHS[0] (always defined). */
4244 
4245 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
4246 #ifndef YYLLOC_DEFAULT
4247 # define YYLLOC_DEFAULT(Current, Rhs, N) \
4248  do \
4249  if (YYID (N)) \
4250  { \
4251  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
4252  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
4253  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
4254  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
4255  } \
4256  else \
4257  { \
4258  (Current).first_line = (Current).last_line = \
4259  YYRHSLOC (Rhs, 0).last_line; \
4260  (Current).first_column = (Current).last_column = \
4261  YYRHSLOC (Rhs, 0).last_column; \
4262  } \
4263  while (YYID (0))
4264 #endif
4265 
4266 
4267 /* This macro is provided for backward compatibility. */
4268 
4269 #ifndef YY_LOCATION_PRINT
4270 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
4271 #endif
4272 
4273 
4274 /* YYLEX -- calling `yylex' with the right arguments. */
4275 
4276 #ifdef YYLEX_PARAM
4277 # define YYLEX yylex (&yylval, YYLEX_PARAM)
4278 #else
4279 # define YYLEX yylex (&yylval, parser)
4280 #endif
4281 
4282 /* Enable debugging if requested. */
4283 #if YYDEBUG
4284 
4285 # ifndef YYFPRINTF
4286 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
4287 # define YYFPRINTF fprintf
4288 # endif
4289 
4290 # define YYDPRINTF(Args) \
4291 do { \
4292  if (yydebug) \
4293  YYFPRINTF Args; \
4294 } while (YYID (0))
4295 
4296 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
4297 do { \
4298  if (yydebug) \
4299  { \
4300  YYFPRINTF (stderr, "%s ", Title); \
4301  yy_symbol_print (stderr, \
4302  Type, Value, parser); \
4303  YYFPRINTF (stderr, "\n"); \
4304  } \
4305 } while (YYID (0))
4306 
4307 
4308 /*--------------------------------.
4309 | Print this symbol on YYOUTPUT. |
4310 `--------------------------------*/
4311 
4312 /*ARGSUSED*/
4313 #if (defined __STDC__ || defined __C99__FUNC__ \
4314  || defined __cplusplus || defined _MSC_VER)
4315 static void
4317 #else
4318 static void
4319 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
4320  FILE *yyoutput;
4321  int yytype;
4322  YYSTYPE const * const yyvaluep;
4323  struct parser_params *parser;
4324 #endif
4325 {
4326  if (!yyvaluep)
4327  return;
4328  YYUSE (parser);
4329 # ifdef YYPRINT
4330  if (yytype < YYNTOKENS)
4331  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4332 # else
4333  YYUSE (yyoutput);
4334 # endif
4335  switch (yytype)
4336  {
4337  default:
4338  break;
4339  }
4340 }
4341 
4342 
4343 /*--------------------------------.
4344 | Print this symbol on YYOUTPUT. |
4345 `--------------------------------*/
4346 
4347 #if (defined __STDC__ || defined __C99__FUNC__ \
4348  || defined __cplusplus || defined _MSC_VER)
4349 static void
4350 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4351 #else
4352 static void
4353 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
4354  FILE *yyoutput;
4355  int yytype;
4356  YYSTYPE const * const yyvaluep;
4357  struct parser_params *parser;
4358 #endif
4359 {
4360  if (yytype < YYNTOKENS)
4361  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4362  else
4363  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4364 
4365  yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
4366  YYFPRINTF (yyoutput, ")");
4367 }
4368 
4369 /*------------------------------------------------------------------.
4370 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4371 | TOP (included). |
4372 `------------------------------------------------------------------*/
4373 
4374 #if (defined __STDC__ || defined __C99__FUNC__ \
4375  || defined __cplusplus || defined _MSC_VER)
4376 static void
4377 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4378 #else
4379 static void
4380 yy_stack_print (yybottom, yytop)
4381  yytype_int16 *yybottom;
4383 #endif
4384 {
4385  YYFPRINTF (stderr, "Stack now");
4386  for (; yybottom <= yytop; yybottom++)
4387  {
4388  int yybot = *yybottom;
4389  YYFPRINTF (stderr, " %d", yybot);
4390  }
4391  YYFPRINTF (stderr, "\n");
4392 }
4393 
4394 # define YY_STACK_PRINT(Bottom, Top) \
4395 do { \
4396  if (yydebug) \
4397  yy_stack_print ((Bottom), (Top)); \
4398 } while (YYID (0))
4399 
4400 
4401 /*------------------------------------------------.
4402 | Report that the YYRULE is going to be reduced. |
4403 `------------------------------------------------*/
4404 
4405 #if (defined __STDC__ || defined __C99__FUNC__ \
4406  || defined __cplusplus || defined _MSC_VER)
4407 static void
4408 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
4409 #else
4410 static void
4411 yy_reduce_print (yyvsp, yyrule, parser)
4412  YYSTYPE *yyvsp;
4413  int yyrule;
4414  struct parser_params *parser;
4415 #endif
4417  int yynrhs = yyr2[yyrule];
4418  int yyi;
4419  unsigned long int yylno = yyrline[yyrule];
4420  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4421  yyrule - 1, yylno);
4422  /* The symbols being reduced. */
4423  for (yyi = 0; yyi < yynrhs; yyi++)
4424  {
4425  YYFPRINTF (stderr, " $%d = ", yyi + 1);
4426  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4427  &(yyvsp[(yyi + 1) - (yynrhs)])
4428  , parser);
4429  YYFPRINTF (stderr, "\n");
4430  }
4431 }
4432 
4433 # define YY_REDUCE_PRINT(Rule) \
4434 do { \
4435  if (yydebug) \
4436  yy_reduce_print (yyvsp, Rule, parser); \
4437 } while (YYID (0))
4438 
4439 /* Nonzero means print parse trace. It is left uninitialized so that
4440  multiple parsers can coexist. */
4441 #ifndef yydebug
4442 int yydebug;
4443 #endif
4444 #else /* !YYDEBUG */
4445 # define YYDPRINTF(Args)
4446 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4447 # define YY_STACK_PRINT(Bottom, Top)
4448 # define YY_REDUCE_PRINT(Rule)
4449 #endif /* !YYDEBUG */
4450 
4451 
4452 /* YYINITDEPTH -- initial size of the parser's stacks. */
4453 #ifndef YYINITDEPTH
4454 # define YYINITDEPTH 200
4455 #endif
4456 
4457 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4458  if the built-in stack extension method is used).
4459 
4460  Do not make this value too large; the results are undefined if
4461  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4462  evaluated with infinite-precision integer arithmetic. */
4463 
4464 #ifndef YYMAXDEPTH
4465 # define YYMAXDEPTH 10000
4466 #endif
4467 
4468 
4469 #if YYERROR_VERBOSE
4470 
4471 # ifndef yystrlen
4472 # if defined __GLIBC__ && defined _STRING_H
4473 # define yystrlen strlen
4474 # else
4475 /* Return the length of YYSTR. */
4476 #if (defined __STDC__ || defined __C99__FUNC__ \
4477  || defined __cplusplus || defined _MSC_VER)
4478 static YYSIZE_T
4479 yystrlen (const char *yystr)
4480 #else
4481 static YYSIZE_T
4482 yystrlen (yystr)
4483  const char *yystr;
4484 #endif
4486  YYSIZE_T yylen;
4487  for (yylen = 0; yystr[yylen]; yylen++)
4488  continue;
4489  return yylen;
4490 }
4491 # endif
4492 # endif
4493 
4494 # ifndef yystpcpy
4495 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4496 # define yystpcpy stpcpy
4497 # else
4498 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4499  YYDEST. */
4500 #if (defined __STDC__ || defined __C99__FUNC__ \
4501  || defined __cplusplus || defined _MSC_VER)
4502 static char *
4503 yystpcpy (char *yydest, const char *yysrc)
4504 #else
4505 static char *
4506 yystpcpy (yydest, yysrc)
4507  char *yydest;
4508  const char *yysrc;
4509 #endif
4510 {
4511  char *yyd = yydest;
4512  const char *yys = yysrc;
4513 
4514  while ((*yyd++ = *yys++) != '\0')
4515  continue;
4516 
4517  return yyd - 1;
4518 }
4519 # endif
4520 # endif
4521 
4522 # ifndef yytnamerr
4523 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4524  quotes and backslashes, so that it's suitable for yyerror. The
4525  heuristic is that double-quoting is unnecessary unless the string
4526  contains an apostrophe, a comma, or backslash (other than
4527  backslash-backslash). YYSTR is taken from yytname. If YYRES is
4528  null, do not copy; instead, return the length of what the result
4529  would have been. */
4530 static YYSIZE_T
4531 yytnamerr (char *yyres, const char *yystr)
4532 {
4533  if (*yystr == '"')
4534  {
4535  YYSIZE_T yyn = 0;
4536  char const *yyp = yystr;
4537 
4538  for (;;)
4539  switch (*++yyp)
4540  {
4541  case '\'':
4542  case ',':
4543  goto do_not_strip_quotes;
4544 
4545  case '\\':
4546  if (*++yyp != '\\')
4547  goto do_not_strip_quotes;
4548  /* Fall through. */
4549  default:
4550  if (yyres)
4551  yyres[yyn] = *yyp;
4552  yyn++;
4553  break;
4554 
4555  case '"':
4556  if (yyres)
4557  yyres[yyn] = '\0';
4558  return yyn;
4559  }
4560  do_not_strip_quotes: ;
4561  }
4562 
4563  if (! yyres)
4564  return yystrlen (yystr);
4565 
4566  return yystpcpy (yyres, yystr) - yyres;
4567 }
4568 # endif
4569 
4570 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
4571  about the unexpected token YYTOKEN for the state stack whose top is
4572  YYSSP.
4573 
4574  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
4575  not large enough to hold the message. In that case, also set
4576  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
4577  required number of bytes is too large to store. */
4578 static int
4580  yytype_int16 *yyssp, int yytoken)
4581 {
4582  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
4583  YYSIZE_T yysize = yysize0;
4584  YYSIZE_T yysize1;
4585  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4586  /* Internationalized format string. */
4587  const char *yyformat = 0;
4588  /* Arguments of yyformat. */
4589  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4590  /* Number of reported tokens (one for the "unexpected", one per
4591  "expected"). */
4592  int yycount = 0;
4593 
4594  /* There are many possibilities here to consider:
4595  - Assume YYFAIL is not used. It's too flawed to consider. See
4596  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
4597  for details. YYERROR is fine as it does not invoke this
4598  function.
4599  - If this state is a consistent state with a default action, then
4600  the only way this function was invoked is if the default action
4601  is an error action. In that case, don't check for expected
4602  tokens because there are none.
4603  - The only way there can be no lookahead present (in yychar) is if
4604  this state is a consistent state with a default action. Thus,
4605  detecting the absence of a lookahead is sufficient to determine
4606  that there is no unexpected or expected token to report. In that
4607  case, just report a simple "syntax error".
4608  - Don't assume there isn't a lookahead just because this state is a
4609  consistent state with a default action. There might have been a
4610  previous inconsistent state, consistent state with a non-default
4611  action, or user semantic action that manipulated yychar.
4612  - Of course, the expected token list depends on states to have
4613  correct lookahead information, and it depends on the parser not
4614  to perform extra reductions after fetching a lookahead from the
4615  scanner and before detecting a syntax error. Thus, state merging
4616  (from LALR or IELR) and default reductions corrupt the expected
4617  token list. However, the list is correct for canonical LR with
4618  one exception: it will still contain any token that will not be
4619  accepted due to an error action in a later state.
4620  */
4621  if (yytoken != YYEMPTY)
4622  {
4623  int yyn = yypact[*yyssp];
4624  yyarg[yycount++] = yytname[yytoken];
4625  if (!yypact_value_is_default (yyn))
4626  {
4627  /* Start YYX at -YYN if negative to avoid negative indexes in
4628  YYCHECK. In other words, skip the first -YYN actions for
4629  this state because they are default actions. */
4630  int yyxbegin = yyn < 0 ? -yyn : 0;
4631  /* Stay within bounds of both yycheck and yytname. */
4632  int yychecklim = YYLAST - yyn + 1;
4633  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4634  int yyx;
4635 
4636  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4637  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
4638  && !yytable_value_is_error (yytable[yyx + yyn]))
4639  {
4640  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4641  {
4642  yycount = 1;
4643  yysize = yysize0;
4644  break;
4645  }
4646  yyarg[yycount++] = yytname[yyx];
4647  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4648  if (! (yysize <= yysize1
4649  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4650  return 2;
4651  yysize = yysize1;
4652  }
4653  }
4654  }
4655 
4656  switch (yycount)
4657  {
4658 # define YYCASE_(N, S) \
4659  case N: \
4660  yyformat = S; \
4661  break
4662  YYCASE_(0, YY_("syntax error"));
4663  YYCASE_(1, YY_("syntax error, unexpected %s"));
4664  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
4665  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
4666  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
4667  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
4668 # undef YYCASE_
4669  }
4670 
4671  yysize1 = yysize + yystrlen (yyformat);
4672  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4673  return 2;
4674  yysize = yysize1;
4675 
4676  if (*yymsg_alloc < yysize)
4677  {
4678  *yymsg_alloc = 2 * yysize;
4679  if (! (yysize <= *yymsg_alloc
4680  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
4681  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
4682  return 1;
4683  }
4684 
4685  /* Avoid sprintf, as that infringes on the user's name space.
4686  Don't have undefined behavior even if the translation
4687  produced a string with the wrong number of "%s"s. */
4688  {
4689  char *yyp = *yymsg;
4690  int yyi = 0;
4691  while ((*yyp = *yyformat) != '\0')
4692  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
4693  {
4694  yyp += yytnamerr (yyp, yyarg[yyi++]);
4695  yyformat += 2;
4696  }
4697  else
4698  {
4699  yyp++;
4700  yyformat++;
4701  }
4702  }
4703  return 0;
4704 }
4705 #endif /* YYERROR_VERBOSE */
4706 
4707 /*-----------------------------------------------.
4708 | Release the memory associated to this symbol. |
4709 `-----------------------------------------------*/
4710 
4711 /*ARGSUSED*/
4712 #if (defined __STDC__ || defined __C99__FUNC__ \
4713  || defined __cplusplus || defined _MSC_VER)
4714 static void
4715 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
4716 #else
4717 static void
4718 yydestruct (yymsg, yytype, yyvaluep, parser)
4719  const char *yymsg;
4720  int yytype;
4721  YYSTYPE *yyvaluep;
4722  struct parser_params *parser;
4723 #endif
4724 {
4725  YYUSE (yyvaluep);
4726  YYUSE (parser);
4727 
4728  if (!yymsg)
4729  yymsg = "Deleting";
4730  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4731 
4732  switch (yytype)
4733  {
4734 
4735  default:
4736  break;
4737  }
4738 }
4739 
4740 
4741 /* Prevent warnings from -Wmissing-prototypes. */
4742 #ifdef YYPARSE_PARAM
4743 #if defined __STDC__ || defined __cplusplus
4744 int yyparse (void *YYPARSE_PARAM);
4745 #else
4746 int yyparse ();
4747 #endif
4748 #else /* ! YYPARSE_PARAM */
4749 #if defined __STDC__ || defined __cplusplus
4750 int yyparse (struct parser_params *parser);
4751 #else
4752 int yyparse ();
4753 #endif
4754 #endif /* ! YYPARSE_PARAM */
4755 
4756 
4757 /*----------.
4758 | yyparse. |
4759 `----------*/
4760 
4761 #ifdef YYPARSE_PARAM
4762 #if (defined __STDC__ || defined __C99__FUNC__ \
4763  || defined __cplusplus || defined _MSC_VER)
4764 int
4765 yyparse (void *YYPARSE_PARAM)
4766 #else
4767 int
4768 yyparse (YYPARSE_PARAM)
4769  void *YYPARSE_PARAM;
4770 #endif
4771 #else /* ! YYPARSE_PARAM */
4772 #if (defined __STDC__ || defined __C99__FUNC__ \
4773  || defined __cplusplus || defined _MSC_VER)
4774 int
4775 yyparse (struct parser_params *parser)
4776 #else
4777 int
4778 yyparse (parser)
4779  struct parser_params *parser;
4780 #endif
4781 #endif
4783 /* The lookahead symbol. */
4784 int yychar;
4785 
4786 /* The semantic value of the lookahead symbol. */
4787 YYSTYPE yylval;
4788 
4789  /* Number of syntax errors so far. */
4790  int yynerrs;
4791 
4792  int yystate;
4793  /* Number of tokens to shift before error messages enabled. */
4795 
4796  /* The stacks and their tools:
4797  `yyss': related to states.
4798  `yyvs': related to semantic values.
4799 
4800  Refer to the stacks thru separate pointers, to allow yyoverflow
4801  to reallocate them elsewhere. */
4802 
4803  /* The state stack. */
4807 
4808  /* The semantic value stack. */
4811  YYSTYPE *yyvsp;
4812 
4814 
4815  int yyn;
4817  /* Lookahead token as an internal (translated) token number. */
4818  int yytoken;
4819  /* The variables used to return semantic value and location from the
4820  action routines. */
4822 
4823 #if YYERROR_VERBOSE
4824  /* Buffer for error messages, and its allocated size. */
4825  char yymsgbuf[128];
4826  char *yymsg = yymsgbuf;
4828 #endif
4829 
4830 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
4831 
4832  /* The number of symbols on the RHS of the reduced rule.
4833  Keep to zero when no symbol should be popped. */
4834  int yylen = 0;
4835 
4836  yytoken = 0;
4837  yyss = yyssa;
4838  yyvs = yyvsa;
4839  yystacksize = YYINITDEPTH;
4840 
4841  YYDPRINTF ((stderr, "Starting parse\n"));
4842 
4843  yystate = 0;
4844  yyerrstatus = 0;
4845  yynerrs = 0;
4846  yychar = YYEMPTY; /* Cause a token to be read. */
4847 
4848  /* Initialize stack pointers.
4849  Waste one element of value and location stack
4850  so that they stay on the same level as the state stack.
4851  The wasted elements are never initialized. */
4852  yyssp = yyss;
4853  yyvsp = yyvs;
4854 
4856 
4857 /*------------------------------------------------------------.
4858 | yynewstate -- Push a new state, which is found in yystate. |
4859 `------------------------------------------------------------*/
4860  yynewstate:
4861  /* In all cases, when you get here, the value and location stacks
4862  have just been pushed. So pushing a state here evens the stacks. */
4863  yyssp++;
4864 
4865  yysetstate:
4866  *yyssp = yystate;
4867 
4868  if (yyss + yystacksize - 1 <= yyssp)
4869  {
4870  /* Get the current used size of the three stacks, in elements. */
4871  YYSIZE_T yysize = yyssp - yyss + 1;
4872 
4873 #ifdef yyoverflow
4874  {
4875  /* Give user a chance to reallocate the stack. Use copies of
4876  these so that the &'s don't force the real ones into
4877  memory. */
4878  YYSTYPE *yyvs1 = yyvs;
4879  yytype_int16 *yyss1 = yyss;
4880 
4881  /* Each stack pointer address is followed by the size of the
4882  data in use in that stack, in bytes. This used to be a
4883  conditional around just the two extra args, but that might
4884  be undefined if yyoverflow is a macro. */
4885  yyoverflow (YY_("memory exhausted"),
4886  &yyss1, yysize * sizeof (*yyssp),
4887  &yyvs1, yysize * sizeof (*yyvsp),
4888  &yystacksize);
4889 
4890  yyss = yyss1;
4891  yyvs = yyvs1;
4892  }
4893 #else /* no yyoverflow */
4894 # ifndef YYSTACK_RELOCATE
4895  goto yyexhaustedlab;
4896 # else
4897  /* Extend the stack our own way. */
4898  if (YYMAXDEPTH <= yystacksize)
4899  goto yyexhaustedlab;
4900  yystacksize *= 2;
4901  if (YYMAXDEPTH < yystacksize)
4902  yystacksize = YYMAXDEPTH;
4903 
4904  {
4905  yytype_int16 *yyss1 = yyss;
4906  union yyalloc *yyptr =
4907  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
4908  if (! yyptr)
4909  goto yyexhaustedlab;
4910  YYSTACK_RELOCATE (yyss_alloc, yyss);
4911  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
4912 # undef YYSTACK_RELOCATE
4913  if (yyss1 != yyssa)
4914  YYSTACK_FREE (yyss1);
4915  }
4916 # endif
4917 #endif /* no yyoverflow */
4918 
4919  yyssp = yyss + yysize - 1;
4920  yyvsp = yyvs + yysize - 1;
4921 
4922  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
4923  (unsigned long int) yystacksize));
4924 
4925  if (yyss + yystacksize - 1 <= yyssp)
4926  YYABORT;
4927  }
4928 
4929  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
4930 
4931  if (yystate == YYFINAL)
4933 
4934  goto yybackup;
4935 
4936 /*-----------.
4937 | yybackup. |
4938 `-----------*/
4939 yybackup:
4940 
4941  /* Do appropriate processing given the current state. Read a
4942  lookahead token if we need one and don't already have one. */
4943 
4944  /* First try to decide what to do without reference to lookahead token. */
4945  yyn = yypact[yystate];
4946  if (yypact_value_is_default (yyn))
4948 
4949  /* Not known => get a lookahead token if don't already have one. */
4950 
4951  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
4952  if (yychar == YYEMPTY)
4953  {
4954  YYDPRINTF ((stderr, "Reading a token: "));
4955  yychar = YYLEX;
4956  }
4957 
4958  if (yychar <= YYEOF)
4959  {
4960  yychar = yytoken = YYEOF;
4961  YYDPRINTF ((stderr, "Now at end of input.\n"));
4962  }
4963  else
4964  {
4965  yytoken = YYTRANSLATE (yychar);
4966  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
4967  }
4968 
4969  /* If the proper action on seeing token YYTOKEN is to reduce or to
4970  detect an error, take that action. */
4971  yyn += yytoken;
4972  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
4973  goto yydefault;
4974  yyn = yytable[yyn];
4975  if (yyn <= 0)
4976  {
4977  if (yytable_value_is_error (yyn))
4978  goto yyerrlab;
4979  yyn = -yyn;
4980  goto yyreduce;
4981  }
4982 
4983  /* Count tokens shifted since error; after three, turn off error
4984  status. */
4985  if (yyerrstatus)
4986  yyerrstatus--;
4987 
4988  /* Shift the lookahead token. */
4989  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
4990 
4991  /* Discard the shifted token. */
4992  yychar = YYEMPTY;
4993 
4994  yystate = yyn;
4995  *++yyvsp = yylval;
4996 
4998 
4999 
5000 /*-----------------------------------------------------------.
5001 | yydefault -- do the default action for the current state. |
5002 `-----------------------------------------------------------*/
5003 yydefault:
5004  yyn = yydefact[yystate];
5005  if (yyn == 0)
5006  goto yyerrlab;
5007  goto yyreduce;
5008 
5009 
5010 /*-----------------------------.
5011 | yyreduce -- Do a reduction. |
5012 `-----------------------------*/
5013 yyreduce:
5014  /* yyn is the number of a rule to reduce with. */
5015  yylen = yyr2[yyn];
5016 
5017  /* If YYLEN is nonzero, implement the default value of the action:
5018  `$$ = $1'.
5019 
5020  Otherwise, the following line sets YYVAL to garbage.
5021  This behavior is undocumented and Bison
5022  users should not rely upon it. Assigning to YYVAL
5023  unconditionally makes the parser a bit smaller, and it avoids a
5024  GCC warning that YYVAL may be used uninitialized. */
5025  yyval = yyvsp[1-yylen];
5026 
5027 
5028  YY_REDUCE_PRINT (yyn);
5029  switch (yyn)
5030  {
5031  case 2:
5032 
5033 /* Line 1806 of yacc.c */
5034 #line 786 "ripper.y"
5035  {
5036  lex_state = EXPR_BEG;
5037 #if 0
5039 #endif
5040  local_push(0);
5041 
5042  }
5043  break;
5044 
5045  case 3:
5046 
5047 /* Line 1806 of yacc.c */
5048 #line 795 "ripper.y"
5049  {
5050 #if 0
5051  if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
5052  /* last expression should not be void */
5053  if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
5054  else {
5055  NODE *node = (yyvsp[(2) - (2)].val);
5056  while (node->nd_next) {
5057  node = node->nd_next;
5058  }
5059  void_expr(node->nd_head);
5060  }
5061  }
5062  ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val)));
5063 #endif
5064  (yyval.val) = (yyvsp[(2) - (2)].val);
5065  parser->result = dispatch1(program, (yyval.val));
5066 
5067  local_pop();
5068  }
5069  break;
5070 
5071  case 4:
5072 
5073 /* Line 1806 of yacc.c */
5074 #line 818 "ripper.y"
5075  {
5076 #if 0
5077  void_stmts((yyvsp[(1) - (2)].val));
5079 #endif
5080 
5081  (yyval.val) = (yyvsp[(1) - (2)].val);
5082  }
5083  break;
5084 
5085  case 5:
5086 
5087 /* Line 1806 of yacc.c */
5088 #line 829 "ripper.y"
5089  {
5090 #if 0
5091  (yyval.val) = NEW_BEGIN(0);
5092 #endif
5093  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5094  dispatch0(void_stmt));
5095 
5096  }
5097  break;
5098 
5099  case 6:
5100 
5101 /* Line 1806 of yacc.c */
5102 #line 838 "ripper.y"
5103  {
5104 #if 0
5105  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5106 #endif
5107  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5108 
5109  }
5110  break;
5111 
5112  case 7:
5113 
5114 /* Line 1806 of yacc.c */
5115 #line 846 "ripper.y"
5116  {
5117 #if 0
5118  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5119 #endif
5120  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5121 
5122  }
5123  break;
5124 
5125  case 8:
5126 
5127 /* Line 1806 of yacc.c */
5128 #line 854 "ripper.y"
5129  {
5130  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5131  }
5132  break;
5133 
5134  case 10:
5135 
5136 /* Line 1806 of yacc.c */
5137 #line 861 "ripper.y"
5138  {
5139  if (in_def || in_single) {
5140  yyerror("BEGIN in method");
5141  }
5142 #if 0
5143  /* local_push(0); */
5144 #endif
5145 
5146  }
5147  break;
5148 
5149  case 11:
5150 
5151 /* Line 1806 of yacc.c */
5152 #line 871 "ripper.y"
5153  {
5154 #if 0
5156  (yyvsp[(4) - (5)].val));
5157  /* NEW_PREEXE($4)); */
5158  /* local_pop(); */
5159  (yyval.val) = NEW_BEGIN(0);
5160 #endif
5161  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5162 
5163  }
5164  break;
5165 
5166  case 12:
5167 
5168 /* Line 1806 of yacc.c */
5169 #line 888 "ripper.y"
5170  {
5171 #if 0
5172  (yyval.val) = (yyvsp[(1) - (4)].val);
5173  if ((yyvsp[(2) - (4)].val)) {
5174  (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
5175  }
5176  else if ((yyvsp[(3) - (4)].val)) {
5177  rb_warn0("else without rescue is useless");
5178  (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val));
5179  }
5180  if ((yyvsp[(4) - (4)].val)) {
5181  if ((yyval.val)) {
5182  (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
5183  }
5184  else {
5185  (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL());
5186  }
5187  }
5188  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5189 #endif
5190  (yyval.val) = dispatch4(bodystmt,
5191  escape_Qundef((yyvsp[(1) - (4)].val)),
5192  escape_Qundef((yyvsp[(2) - (4)].val)),
5193  escape_Qundef((yyvsp[(3) - (4)].val)),
5194  escape_Qundef((yyvsp[(4) - (4)].val)));
5195 
5196  }
5197  break;
5198 
5199  case 13:
5200 
5201 /* Line 1806 of yacc.c */
5202 #line 918 "ripper.y"
5203  {
5204 #if 0
5205  void_stmts((yyvsp[(1) - (2)].val));
5207 #endif
5208 
5209  (yyval.val) = (yyvsp[(1) - (2)].val);
5210  }
5211  break;
5212 
5213  case 14:
5214 
5215 /* Line 1806 of yacc.c */
5216 #line 929 "ripper.y"
5217  {
5218 #if 0
5219  (yyval.val) = NEW_BEGIN(0);
5220 #endif
5221  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5222  dispatch0(void_stmt));
5223 
5224  }
5225  break;
5226 
5227  case 15:
5228 
5229 /* Line 1806 of yacc.c */
5230 #line 938 "ripper.y"
5231  {
5232 #if 0
5233  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5234 #endif
5235  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5236 
5237  }
5238  break;
5239 
5240  case 16:
5241 
5242 /* Line 1806 of yacc.c */
5243 #line 946 "ripper.y"
5244  {
5245 #if 0
5246  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5247 #endif
5248  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5249 
5250  }
5251  break;
5252 
5253  case 17:
5254 
5255 /* Line 1806 of yacc.c */
5256 #line 954 "ripper.y"
5257  {
5258  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5259  }
5260  break;
5261 
5262  case 18:
5263 
5264 /* Line 1806 of yacc.c */
5265 #line 959 "ripper.y"
5266  {lex_state = EXPR_FNAME;}
5267  break;
5268 
5269  case 19:
5270 
5271 /* Line 1806 of yacc.c */
5272 #line 960 "ripper.y"
5273  {
5274 #if 0
5275  (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5276 #endif
5277  (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5278 
5279  }
5280  break;
5281 
5282  case 20:
5283 
5284 /* Line 1806 of yacc.c */
5285 #line 968 "ripper.y"
5286  {
5287 #if 0
5288  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5289 #endif
5290  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5291 
5292  }
5293  break;
5294 
5295  case 21:
5296 
5297 /* Line 1806 of yacc.c */
5298 #line 976 "ripper.y"
5299  {
5300 #if 0
5301  char buf[2];
5302  buf[0] = '$';
5303  buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
5304  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
5305 #endif
5306  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5307 
5308  }
5309  break;
5310 
5311  case 22:
5312 
5313 /* Line 1806 of yacc.c */
5314 #line 987 "ripper.y"
5315  {
5316 #if 0
5317  yyerror("can't make alias for the number variables");
5318  (yyval.val) = NEW_BEGIN(0);
5319 #endif
5320  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5321  (yyval.val) = dispatch1(alias_error, (yyval.val));
5322 
5323  }
5324  break;
5325 
5326  case 23:
5327 
5328 /* Line 1806 of yacc.c */
5329 #line 997 "ripper.y"
5330  {
5331 #if 0
5332  (yyval.val) = (yyvsp[(2) - (2)].val);
5333 #endif
5334  (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
5335 
5336  }
5337  break;
5338 
5339  case 24:
5340 
5341 /* Line 1806 of yacc.c */
5342 #line 1005 "ripper.y"
5343  {
5344 #if 0
5345  (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5346  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5347 #endif
5348  (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5349 
5350  }
5351  break;
5352 
5353  case 25:
5354 
5355 /* Line 1806 of yacc.c */
5356 #line 1014 "ripper.y"
5357  {
5358 #if 0
5359  (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5360  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5361 #endif
5362  (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5363 
5364  }
5365  break;
5366 
5367  case 26:
5368 
5369 /* Line 1806 of yacc.c */
5370 #line 1023 "ripper.y"
5371  {
5372 #if 0
5373  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5374  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5375  }
5376  else {
5377  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5378  }
5379 #endif
5380  (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5381 
5382  }
5383  break;
5384 
5385  case 27:
5386 
5387 /* Line 1806 of yacc.c */
5388 #line 1036 "ripper.y"
5389  {
5390 #if 0
5391  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5392  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5393  }
5394  else {
5395  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5396  }
5397 #endif
5398  (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5399 
5400  }
5401  break;
5402 
5403  case 28:
5404 
5405 /* Line 1806 of yacc.c */
5406 #line 1049 "ripper.y"
5407  {
5408 #if 0
5409  NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0);
5410  (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0);
5411 #endif
5412  (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5413 
5414  }
5415  break;
5416 
5417  case 29:
5418 
5419 /* Line 1806 of yacc.c */
5420 #line 1058 "ripper.y"
5421  {
5422  if (in_def || in_single) {
5423  rb_warn0("END in method; use at_exit");
5424  }
5425 #if 0
5426  (yyval.val) = NEW_POSTEXE(NEW_NODE(
5427  NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */));
5428 #endif
5429  (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
5430 
5431  }
5432  break;
5433 
5434  case 31:
5435 
5436 /* Line 1806 of yacc.c */
5437 #line 1071 "ripper.y"
5438  {
5439 #if 0
5440  value_expr((yyvsp[(3) - (3)].val));
5441  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5442  (yyval.val) = (yyvsp[(1) - (3)].val);
5443 #endif
5444  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5445 
5446  }
5447  break;
5448 
5449  case 32:
5450 
5451 /* Line 1806 of yacc.c */
5452 #line 1081 "ripper.y"
5453  {
5454 #if 0
5455  value_expr((yyvsp[(3) - (3)].val));
5456  if ((yyvsp[(1) - (3)].val)) {
5457  ID vid = (yyvsp[(1) - (3)].val)->nd_vid;
5458  if ((yyvsp[(2) - (3)].val) == tOROP) {
5459  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5460  (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (3)].val));
5461  if (is_asgn_or_id(vid)) {
5462  (yyval.val)->nd_aid = vid;
5463  }
5464  }
5465  else if ((yyvsp[(2) - (3)].val) == tANDOP) {
5466  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5467  (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (3)].val));
5468  }
5469  else {
5470  (yyval.val) = (yyvsp[(1) - (3)].val);
5471  (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (3)].val), NEW_LIST((yyvsp[(3) - (3)].val)));
5472  }
5473  }
5474  else {
5475  (yyval.val) = NEW_BEGIN(0);
5476  }
5477 #endif
5478  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5479 
5480  }
5481  break;
5482 
5483  case 33:
5484 
5485 /* Line 1806 of yacc.c */
5486 #line 1110 "ripper.y"
5487  {
5488 #if 0
5489  NODE *args;
5490 
5491  value_expr((yyvsp[(6) - (6)].val));
5492  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
5493  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
5494  if ((yyvsp[(5) - (6)].val) == tOROP) {
5495  (yyvsp[(5) - (6)].val) = 0;
5496  }
5497  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
5498  (yyvsp[(5) - (6)].val) = 1;
5499  }
5500  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
5501  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
5502 #endif
5503  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
5504  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
5505 
5506  }
5507  break;
5508 
5509  case 34:
5510 
5511 /* Line 1806 of yacc.c */
5512 #line 1131 "ripper.y"
5513  {
5514 #if 0
5515  value_expr((yyvsp[(5) - (5)].val));
5516  if ((yyvsp[(4) - (5)].val) == tOROP) {
5517  (yyvsp[(4) - (5)].val) = 0;
5518  }
5519  else if ((yyvsp[(4) - (5)].val) == tANDOP) {
5520  (yyvsp[(4) - (5)].val) = 1;
5521  }
5522  (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5523  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
5524 #endif
5525  (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
5526  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5527 
5528  }
5529  break;
5530 
5531  case 35:
5532 
5533 /* Line 1806 of yacc.c */
5534 #line 1148 "ripper.y"
5535  {
5536 #if 0
5537  value_expr((yyvsp[(5) - (5)].val));
5538  if ((yyvsp[(4) - (5)].val) == tOROP) {
5539  (yyvsp[(4) - (5)].val) = 0;
5540  }
5541  else if ((yyvsp[(4) - (5)].val) == tANDOP) {
5542  (yyvsp[(4) - (5)].val) = 1;
5543  }
5544  (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5545  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
5546 #endif
5547  (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
5548  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5549 
5550  }
5551  break;
5552 
5553  case 36:
5554 
5555 /* Line 1806 of yacc.c */
5556 #line 1165 "ripper.y"
5557  {
5558 #if 0
5559  yyerror("constant re-assignment");
5560  (yyval.val) = 0;
5561 #endif
5562  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
5563  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5564  (yyval.val) = dispatch1(assign_error, (yyval.val));
5565 
5566  }
5567  break;
5568 
5569  case 37:
5570 
5571 /* Line 1806 of yacc.c */
5572 #line 1176 "ripper.y"
5573  {
5574 #if 0
5575  value_expr((yyvsp[(5) - (5)].val));
5576  if ((yyvsp[(4) - (5)].val) == tOROP) {
5577  (yyvsp[(4) - (5)].val) = 0;
5578  }
5579  else if ((yyvsp[(4) - (5)].val) == tANDOP) {
5580  (yyvsp[(4) - (5)].val) = 1;
5581  }
5582  (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5583  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
5584 #endif
5585  (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val));
5586  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5587 
5588  }
5589  break;
5590 
5591  case 38:
5592 
5593 /* Line 1806 of yacc.c */
5594 #line 1193 "ripper.y"
5595  {
5596 #if 0
5597  rb_backref_error((yyvsp[(1) - (3)].val));
5598  (yyval.val) = NEW_BEGIN(0);
5599 #endif
5600  (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
5601  (yyval.val) = dispatch1(assign_error, (yyval.val));
5602 
5603  }
5604  break;
5605 
5606  case 39:
5607 
5608 /* Line 1806 of yacc.c */
5609 #line 1203 "ripper.y"
5610  {
5611 #if 0
5612  value_expr((yyvsp[(3) - (3)].val));
5613  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5614 #endif
5615  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5616 
5617  }
5618  break;
5619 
5620  case 40:
5621 
5622 /* Line 1806 of yacc.c */
5623 #line 1212 "ripper.y"
5624  {
5625 #if 0
5626  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5627  (yyval.val) = (yyvsp[(1) - (3)].val);
5628 #endif
5629  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5630 
5631  }
5632  break;
5633 
5634  case 41:
5635 
5636 /* Line 1806 of yacc.c */
5637 #line 1221 "ripper.y"
5638  {
5639 #if 0
5640  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5641  (yyval.val) = (yyvsp[(1) - (3)].val);
5642 #endif
5643  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5644 
5645  }
5646  break;
5647 
5648  case 43:
5649 
5650 /* Line 1806 of yacc.c */
5651 #line 1233 "ripper.y"
5652  {
5653 #if 0
5654  value_expr((yyvsp[(3) - (3)].val));
5655  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5656 #endif
5657  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5658 
5659  }
5660  break;
5661 
5662  case 44:
5663 
5664 /* Line 1806 of yacc.c */
5665 #line 1242 "ripper.y"
5666  {
5667 #if 0
5668  value_expr((yyvsp[(3) - (3)].val));
5669  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5670 #endif
5671  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5672 
5673  }
5674  break;
5675 
5676  case 46:
5677 
5678 /* Line 1806 of yacc.c */
5679 #line 1255 "ripper.y"
5680  {
5681 #if 0
5682  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5683 #endif
5684  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val));
5685 
5686  }
5687  break;
5688 
5689  case 47:
5690 
5691 /* Line 1806 of yacc.c */
5692 #line 1263 "ripper.y"
5693  {
5694 #if 0
5695  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5696 #endif
5697  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val));
5698 
5699  }
5700  break;
5701 
5702  case 48:
5703 
5704 /* Line 1806 of yacc.c */
5705 #line 1271 "ripper.y"
5706  {
5707 #if 0
5708  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!');
5709 #endif
5710  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val));
5711 
5712  }
5713  break;
5714 
5715  case 49:
5716 
5717 /* Line 1806 of yacc.c */
5718 #line 1279 "ripper.y"
5719  {
5720 #if 0
5721  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
5722 #endif
5723  (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val));
5724 
5725  }
5726  break;
5727 
5728  case 51:
5729 
5730 /* Line 1806 of yacc.c */
5731 #line 1290 "ripper.y"
5732  {
5733 #if 0
5734  value_expr((yyvsp[(1) - (1)].val));
5735  (yyval.val) = (yyvsp[(1) - (1)].val);
5736  if (!(yyval.val)) (yyval.val) = NEW_NIL();
5737 #endif
5738  (yyval.val) = (yyvsp[(1) - (1)].val);
5739 
5740  }
5741  break;
5742 
5743  case 55:
5744 
5745 /* Line 1806 of yacc.c */
5746 #line 1307 "ripper.y"
5747  {
5748 #if 0
5749  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5750 #endif
5751  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
5752  (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
5753 
5754  }
5755  break;
5756 
5757  case 56:
5758 
5759 /* Line 1806 of yacc.c */
5760 #line 1316 "ripper.y"
5761  {
5762 #if 0
5763  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5764 #endif
5765  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val));
5766  (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
5767 
5768  }
5769  break;
5770 
5771  case 57:
5772 
5773 /* Line 1806 of yacc.c */
5774 #line 1327 "ripper.y"
5775  {
5776  (yyvsp[(1) - (1)].vars) = dyna_push();
5777 #if 0
5778  (yyval.num) = ruby_sourceline;
5779 #endif
5780 
5781  }
5782  break;
5783 
5784  case 58:
5785 
5786 /* Line 1806 of yacc.c */
5787 #line 1337 "ripper.y"
5788  {
5789 #if 0
5790  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
5791  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
5792 #endif
5793  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
5794 
5795  dyna_pop((yyvsp[(1) - (5)].vars));
5796  }
5797  break;
5798 
5799  case 59:
5800 
5801 /* Line 1806 of yacc.c */
5802 #line 1349 "ripper.y"
5803  {
5804 #if 0
5805  (yyval.val) = NEW_FCALL((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
5806  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
5807 #endif
5808  (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
5809 
5810  }
5811  break;
5812 
5813  case 60:
5814 
5815 /* Line 1806 of yacc.c */
5816 #line 1358 "ripper.y"
5817  {
5818 #if 0
5819  block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
5820  (yyvsp[(3) - (3)].val)->nd_iter = NEW_FCALL((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
5821  (yyval.val) = (yyvsp[(3) - (3)].val);
5822  fixpos((yyval.val), (yyvsp[(2) - (3)].val));
5823 #endif
5824  (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
5825  (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
5826 
5827  }
5828  break;
5829 
5830  case 61:
5831 
5832 /* Line 1806 of yacc.c */
5833 #line 1370 "ripper.y"
5834  {
5835 #if 0
5836  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5837  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5838 #endif
5839  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5840 
5841  }
5842  break;
5843 
5844  case 62:
5845 
5846 /* Line 1806 of yacc.c */
5847 #line 1379 "ripper.y"
5848  {
5849 #if 0
5850  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
5851  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
5852  (yyval.val) = (yyvsp[(5) - (5)].val);
5853  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
5854 #endif
5855  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
5856  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
5857 
5858  }
5859  break;
5860 
5861  case 63:
5862 
5863 /* Line 1806 of yacc.c */
5864 #line 1391 "ripper.y"
5865  {
5866 #if 0
5867  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5868  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5869 #endif
5870  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5871 
5872  }
5873  break;
5874 
5875  case 64:
5876 
5877 /* Line 1806 of yacc.c */
5878 #line 1400 "ripper.y"
5879  {
5880 #if 0
5881  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
5882  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
5883  (yyval.val) = (yyvsp[(5) - (5)].val);
5884  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
5885 #endif
5886  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
5887  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
5888 
5889  }
5890  break;
5891 
5892  case 65:
5893 
5894 /* Line 1806 of yacc.c */
5895 #line 1412 "ripper.y"
5896  {
5897 #if 0
5898  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
5899  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
5900 #endif
5901  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
5902 
5903  }
5904  break;
5905 
5906  case 66:
5907 
5908 /* Line 1806 of yacc.c */
5909 #line 1421 "ripper.y"
5910  {
5911 #if 0
5912  (yyval.val) = new_yield((yyvsp[(2) - (2)].val));
5913  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
5914 #endif
5915  (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
5916 
5917  }
5918  break;
5919 
5920  case 67:
5921 
5922 /* Line 1806 of yacc.c */
5923 #line 1430 "ripper.y"
5924  {
5925 #if 0
5926  (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
5927 #endif
5928  (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
5929 
5930  }
5931  break;
5932 
5933  case 68:
5934 
5935 /* Line 1806 of yacc.c */
5936 #line 1438 "ripper.y"
5937  {
5938 #if 0
5939  (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
5940 #endif
5941  (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
5942 
5943  }
5944  break;
5945 
5946  case 69:
5947 
5948 /* Line 1806 of yacc.c */
5949 #line 1446 "ripper.y"
5950  {
5951 #if 0
5952  (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
5953 #endif
5954  (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
5955 
5956  }
5957  break;
5958 
5959  case 71:
5960 
5961 /* Line 1806 of yacc.c */
5962 #line 1457 "ripper.y"
5963  {
5964 #if 0
5965  (yyval.val) = (yyvsp[(2) - (3)].val);
5966 #endif
5967  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
5968 
5969  }
5970  break;
5971 
5972  case 73:
5973 
5974 /* Line 1806 of yacc.c */
5975 #line 1468 "ripper.y"
5976  {
5977 #if 0
5978  (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0);
5979 #endif
5980  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
5981 
5982  }
5983  break;
5984 
5985  case 74:
5986 
5987 /* Line 1806 of yacc.c */
5988 #line 1478 "ripper.y"
5989  {
5990 #if 0
5991  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
5992 #endif
5993  (yyval.val) = (yyvsp[(1) - (1)].val);
5994 
5995  }
5996  break;
5997 
5998  case 75:
5999 
6000 /* Line 1806 of yacc.c */
6001 #line 1486 "ripper.y"
6002  {
6003 #if 0
6004  (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0);
6005 #endif
6006  (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
6007 
6008  }
6009  break;
6010 
6011  case 76:
6012 
6013 /* Line 1806 of yacc.c */
6014 #line 1494 "ripper.y"
6015  {
6016 #if 0
6017  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6018 #endif
6019  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6020 
6021  }
6022  break;
6023 
6024  case 77:
6025 
6026 /* Line 1806 of yacc.c */
6027 #line 1502 "ripper.y"
6028  {
6029 #if 0
6030  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val)));
6031 #endif
6032  (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6033  (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
6034 
6035  }
6036  break;
6037 
6038  case 78:
6039 
6040 /* Line 1806 of yacc.c */
6041 #line 1511 "ripper.y"
6042  {
6043 #if 0
6044  (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1);
6045 #endif
6046  (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
6047 
6048  }
6049  break;
6050 
6051  case 79:
6052 
6053 /* Line 1806 of yacc.c */
6054 #line 1519 "ripper.y"
6055  {
6056 #if 0
6057  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
6058 #endif
6059  (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
6060  (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6061 
6062  }
6063  break;
6064 
6065  case 80:
6066 
6067 /* Line 1806 of yacc.c */
6068 #line 1528 "ripper.y"
6069  {
6070 #if 0
6071  (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
6072 #endif
6073  (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
6074 
6075  }
6076  break;
6077 
6078  case 81:
6079 
6080 /* Line 1806 of yacc.c */
6081 #line 1536 "ripper.y"
6082  {
6083 #if 0
6084  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
6085 #endif
6086  (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
6087  (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
6088 
6089  }
6090  break;
6091 
6092  case 82:
6093 
6094 /* Line 1806 of yacc.c */
6095 #line 1545 "ripper.y"
6096  {
6097 #if 0
6098  (yyval.val) = NEW_MASGN(0, -1);
6099 #endif
6100  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6101 
6102  }
6103  break;
6104 
6105  case 83:
6106 
6107 /* Line 1806 of yacc.c */
6108 #line 1553 "ripper.y"
6109  {
6110 #if 0
6111  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
6112 #endif
6113  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6114  (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
6115 
6116  }
6117  break;
6118 
6119  case 85:
6120 
6121 /* Line 1806 of yacc.c */
6122 #line 1565 "ripper.y"
6123  {
6124 #if 0
6125  (yyval.val) = (yyvsp[(2) - (3)].val);
6126 #endif
6127  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6128 
6129  }
6130  break;
6131 
6132  case 86:
6133 
6134 /* Line 1806 of yacc.c */
6135 #line 1575 "ripper.y"
6136  {
6137 #if 0
6138  (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
6139 #endif
6140  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
6141 
6142  }
6143  break;
6144 
6145  case 87:
6146 
6147 /* Line 1806 of yacc.c */
6148 #line 1583 "ripper.y"
6149  {
6150 #if 0
6151  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6152 #endif
6153  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6154 
6155  }
6156  break;
6157 
6158  case 88:
6159 
6160 /* Line 1806 of yacc.c */
6161 #line 1593 "ripper.y"
6162  {
6163 #if 0
6164  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
6165 #endif
6166  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
6167 
6168  }
6169  break;
6170 
6171  case 89:
6172 
6173 /* Line 1806 of yacc.c */
6174 #line 1601 "ripper.y"
6175  {
6176 #if 0
6177  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6178 #endif
6179  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6180 
6181  }
6182  break;
6183 
6184  case 90:
6185 
6186 /* Line 1806 of yacc.c */
6187 #line 1611 "ripper.y"
6188  {
6189  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6190  }
6191  break;
6192 
6193  case 91:
6194 
6195 /* Line 1806 of yacc.c */
6196 #line 1615 "ripper.y"
6197  {
6198  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6199  }
6200  break;
6201 
6202  case 92:
6203 
6204 /* Line 1806 of yacc.c */
6205 #line 1619 "ripper.y"
6206  {
6207 #if 0
6208  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6209 #endif
6210  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6211 
6212  }
6213  break;
6214 
6215  case 93:
6216 
6217 /* Line 1806 of yacc.c */
6218 #line 1627 "ripper.y"
6219  {
6220 #if 0
6221  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6222 #endif
6223  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6224 
6225  }
6226  break;
6227 
6228  case 94:
6229 
6230 /* Line 1806 of yacc.c */
6231 #line 1635 "ripper.y"
6232  {
6233 #if 0
6234  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6235 #endif
6236  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6237 
6238  }
6239  break;
6240 
6241  case 95:
6242 
6243 /* Line 1806 of yacc.c */
6244 #line 1643 "ripper.y"
6245  {
6246 #if 0
6247  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6248 #endif
6249  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6250 
6251  }
6252  break;
6253 
6254  case 96:
6255 
6256 /* Line 1806 of yacc.c */
6257 #line 1651 "ripper.y"
6258  {
6259 #if 0
6260  if (in_def || in_single)
6261  yyerror("dynamic constant assignment");
6262  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6263 #endif
6264  if (in_def || in_single)
6265  yyerror("dynamic constant assignment");
6266  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6267 
6268  }
6269  break;
6270 
6271  case 97:
6272 
6273 /* Line 1806 of yacc.c */
6274 #line 1663 "ripper.y"
6275  {
6276 #if 0
6277  if (in_def || in_single)
6278  yyerror("dynamic constant assignment");
6279  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6280 #endif
6281  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6282 
6283  }
6284  break;
6285 
6286  case 98:
6287 
6288 /* Line 1806 of yacc.c */
6289 #line 1673 "ripper.y"
6290  {
6291 #if 0
6292  rb_backref_error((yyvsp[(1) - (1)].val));
6293  (yyval.val) = NEW_BEGIN(0);
6294 #endif
6295  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val));
6296  (yyval.val) = dispatch1(assign_error, (yyval.val));
6297 
6298  }
6299  break;
6300 
6301  case 99:
6302 
6303 /* Line 1806 of yacc.c */
6304 #line 1685 "ripper.y"
6305  {
6306  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6307 #if 0
6308  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6309 #endif
6310  (yyval.val) = dispatch1(var_field, (yyval.val));
6311 
6312  }
6313  break;
6314 
6315  case 100:
6316 
6317 /* Line 1806 of yacc.c */
6318 #line 1694 "ripper.y"
6319  {
6320  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6321 #if 0
6322  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6323 #endif
6324  (yyval.val) = dispatch1(var_field, (yyval.val));
6325 
6326  }
6327  break;
6328 
6329  case 101:
6330 
6331 /* Line 1806 of yacc.c */
6332 #line 1703 "ripper.y"
6333  {
6334 #if 0
6335  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6336 #endif
6337  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6338 
6339  }
6340  break;
6341 
6342  case 102:
6343 
6344 /* Line 1806 of yacc.c */
6345 #line 1711 "ripper.y"
6346  {
6347 #if 0
6348  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6349 #endif
6350  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6351 
6352  }
6353  break;
6354 
6355  case 103:
6356 
6357 /* Line 1806 of yacc.c */
6358 #line 1719 "ripper.y"
6359  {
6360 #if 0
6361  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6362 #endif
6363  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
6364 
6365  }
6366  break;
6367 
6368  case 104:
6369 
6370 /* Line 1806 of yacc.c */
6371 #line 1727 "ripper.y"
6372  {
6373 #if 0
6374  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6375 #endif
6376  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6377 
6378  }
6379  break;
6380 
6381  case 105:
6382 
6383 /* Line 1806 of yacc.c */
6384 #line 1735 "ripper.y"
6385  {
6386 #if 0
6387  if (in_def || in_single)
6388  yyerror("dynamic constant assignment");
6389  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6390 #endif
6391  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6392  if (in_def || in_single) {
6393  (yyval.val) = dispatch1(assign_error, (yyval.val));
6394  }
6395 
6396  }
6397  break;
6398 
6399  case 106:
6400 
6401 /* Line 1806 of yacc.c */
6402 #line 1748 "ripper.y"
6403  {
6404 #if 0
6405  if (in_def || in_single)
6406  yyerror("dynamic constant assignment");
6407  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6408 #endif
6409  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6410  if (in_def || in_single) {
6411  (yyval.val) = dispatch1(assign_error, (yyval.val));
6412  }
6413 
6414  }
6415  break;
6416 
6417  case 107:
6418 
6419 /* Line 1806 of yacc.c */
6420 #line 1761 "ripper.y"
6421  {
6422 #if 0
6423  rb_backref_error((yyvsp[(1) - (1)].val));
6424  (yyval.val) = NEW_BEGIN(0);
6425 #endif
6426  (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val));
6427 
6428  }
6429  break;
6430 
6431  case 108:
6432 
6433 /* Line 1806 of yacc.c */
6434 #line 1772 "ripper.y"
6435  {
6436 #if 0
6437  yyerror("class/module name must be CONSTANT");
6438 #endif
6439  (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
6440 
6441  }
6442  break;
6443 
6444  case 110:
6445 
6446 /* Line 1806 of yacc.c */
6447 #line 1783 "ripper.y"
6448  {
6449 #if 0
6450  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
6451 #endif
6452  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
6453 
6454  }
6455  break;
6456 
6457  case 111:
6458 
6459 /* Line 1806 of yacc.c */
6460 #line 1791 "ripper.y"
6461  {
6462 #if 0
6463  (yyval.val) = NEW_COLON2(0, (yyval.val));
6464 #endif
6465  (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
6466 
6467  }
6468  break;
6469 
6470  case 112:
6471 
6472 /* Line 1806 of yacc.c */
6473 #line 1799 "ripper.y"
6474  {
6475 #if 0
6476  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6477 #endif
6478  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6479 
6480  }
6481  break;
6482 
6483  case 116:
6484 
6485 /* Line 1806 of yacc.c */
6486 #line 1812 "ripper.y"
6487  {
6489  (yyval.val) = (yyvsp[(1) - (1)].val);
6490  }
6491  break;
6492 
6493  case 117:
6494 
6495 /* Line 1806 of yacc.c */
6496 #line 1817 "ripper.y"
6497  {
6499 #if 0
6500  (yyval.val) = (yyvsp[(1) - (1)].id);
6501 #endif
6502  (yyval.val) = (yyvsp[(1) - (1)].val);
6503 
6504  }
6505  break;
6506 
6507  case 120:
6508 
6509 /* Line 1806 of yacc.c */
6510 #line 1832 "ripper.y"
6511  {
6512 #if 0
6513  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
6514 #endif
6515  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
6516 
6517  }
6518  break;
6519 
6520  case 122:
6521 
6522 /* Line 1806 of yacc.c */
6523 #line 1843 "ripper.y"
6524  {
6525 #if 0
6526  (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
6527 #endif
6528  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
6529 
6530  }
6531  break;
6532 
6533  case 123:
6534 
6535 /* Line 1806 of yacc.c */
6536 #line 1850 "ripper.y"
6537  {lex_state = EXPR_FNAME;}
6538  break;
6539 
6540  case 124:
6541 
6542 /* Line 1806 of yacc.c */
6543 #line 1851 "ripper.y"
6544  {
6545 #if 0
6546  (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
6547 #endif
6548  rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6549 
6550  }
6551  break;
6552 
6553  case 125:
6554 
6555 /* Line 1806 of yacc.c */
6556 #line 1860 "ripper.y"
6557  { ifndef_ripper((yyval.val) = '|'); }
6558  break;
6559 
6560  case 126:
6561 
6562 /* Line 1806 of yacc.c */
6563 #line 1861 "ripper.y"
6564  { ifndef_ripper((yyval.val) = '^'); }
6565  break;
6566 
6567  case 127:
6568 
6569 /* Line 1806 of yacc.c */
6570 #line 1862 "ripper.y"
6571  { ifndef_ripper((yyval.val) = '&'); }
6572  break;
6573 
6574  case 128:
6575 
6576 /* Line 1806 of yacc.c */
6577 #line 1863 "ripper.y"
6578  { ifndef_ripper((yyval.val) = tCMP); }
6579  break;
6580 
6581  case 129:
6582 
6583 /* Line 1806 of yacc.c */
6584 #line 1864 "ripper.y"
6585  { ifndef_ripper((yyval.val) = tEQ); }
6586  break;
6587 
6588  case 130:
6589 
6590 /* Line 1806 of yacc.c */
6591 #line 1865 "ripper.y"
6592  { ifndef_ripper((yyval.val) = tEQQ); }
6593  break;
6594 
6595  case 131:
6596 
6597 /* Line 1806 of yacc.c */
6598 #line 1866 "ripper.y"
6599  { ifndef_ripper((yyval.val) = tMATCH); }
6600  break;
6601 
6602  case 132:
6603 
6604 /* Line 1806 of yacc.c */
6605 #line 1867 "ripper.y"
6606  { ifndef_ripper((yyval.val) = tNMATCH); }
6607  break;
6608 
6609  case 133:
6610 
6611 /* Line 1806 of yacc.c */
6612 #line 1868 "ripper.y"
6613  { ifndef_ripper((yyval.val) = '>'); }
6614  break;
6615 
6616  case 134:
6617 
6618 /* Line 1806 of yacc.c */
6619 #line 1869 "ripper.y"
6620  { ifndef_ripper((yyval.val) = tGEQ); }
6621  break;
6622 
6623  case 135:
6624 
6625 /* Line 1806 of yacc.c */
6626 #line 1870 "ripper.y"
6627  { ifndef_ripper((yyval.val) = '<'); }
6628  break;
6629 
6630  case 136:
6631 
6632 /* Line 1806 of yacc.c */
6633 #line 1871 "ripper.y"
6634  { ifndef_ripper((yyval.val) = tLEQ); }
6635  break;
6636 
6637  case 137:
6638 
6639 /* Line 1806 of yacc.c */
6640 #line 1872 "ripper.y"
6641  { ifndef_ripper((yyval.val) = tNEQ); }
6642  break;
6643 
6644  case 138:
6645 
6646 /* Line 1806 of yacc.c */
6647 #line 1873 "ripper.y"
6648  { ifndef_ripper((yyval.val) = tLSHFT); }
6649  break;
6650 
6651  case 139:
6652 
6653 /* Line 1806 of yacc.c */
6654 #line 1874 "ripper.y"
6655  { ifndef_ripper((yyval.val) = tRSHFT); }
6656  break;
6657 
6658  case 140:
6659 
6660 /* Line 1806 of yacc.c */
6661 #line 1875 "ripper.y"
6662  { ifndef_ripper((yyval.val) = '+'); }
6663  break;
6664 
6665  case 141:
6666 
6667 /* Line 1806 of yacc.c */
6668 #line 1876 "ripper.y"
6669  { ifndef_ripper((yyval.val) = '-'); }
6670  break;
6671 
6672  case 142:
6673 
6674 /* Line 1806 of yacc.c */
6675 #line 1877 "ripper.y"
6676  { ifndef_ripper((yyval.val) = '*'); }
6677  break;
6678 
6679  case 143:
6680 
6681 /* Line 1806 of yacc.c */
6682 #line 1878 "ripper.y"
6683  { ifndef_ripper((yyval.val) = '*'); }
6684  break;
6685 
6686  case 144:
6687 
6688 /* Line 1806 of yacc.c */
6689 #line 1879 "ripper.y"
6690  { ifndef_ripper((yyval.val) = '/'); }
6691  break;
6692 
6693  case 145:
6694 
6695 /* Line 1806 of yacc.c */
6696 #line 1880 "ripper.y"
6697  { ifndef_ripper((yyval.val) = '%'); }
6698  break;
6699 
6700  case 146:
6701 
6702 /* Line 1806 of yacc.c */
6703 #line 1881 "ripper.y"
6704  { ifndef_ripper((yyval.val) = tPOW); }
6705  break;
6706 
6707  case 147:
6708 
6709 /* Line 1806 of yacc.c */
6710 #line 1882 "ripper.y"
6711  { ifndef_ripper((yyval.val) = '!'); }
6712  break;
6713 
6714  case 148:
6715 
6716 /* Line 1806 of yacc.c */
6717 #line 1883 "ripper.y"
6718  { ifndef_ripper((yyval.val) = '~'); }
6719  break;
6720 
6721  case 149:
6722 
6723 /* Line 1806 of yacc.c */
6724 #line 1884 "ripper.y"
6725  { ifndef_ripper((yyval.val) = tUPLUS); }
6726  break;
6727 
6728  case 150:
6729 
6730 /* Line 1806 of yacc.c */
6731 #line 1885 "ripper.y"
6732  { ifndef_ripper((yyval.val) = tUMINUS); }
6733  break;
6734 
6735  case 151:
6736 
6737 /* Line 1806 of yacc.c */
6738 #line 1886 "ripper.y"
6739  { ifndef_ripper((yyval.val) = tAREF); }
6740  break;
6741 
6742  case 152:
6743 
6744 /* Line 1806 of yacc.c */
6745 #line 1887 "ripper.y"
6746  { ifndef_ripper((yyval.val) = tASET); }
6747  break;
6748 
6749  case 153:
6750 
6751 /* Line 1806 of yacc.c */
6752 #line 1888 "ripper.y"
6753  { ifndef_ripper((yyval.val) = '`'); }
6754  break;
6755 
6756  case 195:
6757 
6758 /* Line 1806 of yacc.c */
6759 #line 1906 "ripper.y"
6760  {
6761 #if 0
6762  value_expr((yyvsp[(3) - (3)].val));
6763  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6764 #endif
6765  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6766 
6767  }
6768  break;
6769 
6770  case 196:
6771 
6772 /* Line 1806 of yacc.c */
6773 #line 1915 "ripper.y"
6774  {
6775 #if 0
6776  value_expr((yyvsp[(3) - (5)].val));
6777  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6778  (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6779 #endif
6780  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)));
6781 
6782  }
6783  break;
6784 
6785  case 197:
6786 
6787 /* Line 1806 of yacc.c */
6788 #line 1925 "ripper.y"
6789  {
6790 #if 0
6791  value_expr((yyvsp[(3) - (3)].val));
6792  if ((yyvsp[(1) - (3)].val)) {
6793  ID vid = (yyvsp[(1) - (3)].val)->nd_vid;
6794  if ((yyvsp[(2) - (3)].val) == tOROP) {
6795  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
6796  (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (3)].val));
6797  if (is_asgn_or_id(vid)) {
6798  (yyval.val)->nd_aid = vid;
6799  }
6800  }
6801  else if ((yyvsp[(2) - (3)].val) == tANDOP) {
6802  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
6803  (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (3)].val));
6804  }
6805  else {
6806  (yyval.val) = (yyvsp[(1) - (3)].val);
6807  (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (3)].val), NEW_LIST((yyvsp[(3) - (3)].val)));
6808  }
6809  }
6810  else {
6811  (yyval.val) = NEW_BEGIN(0);
6812  }
6813 #endif
6814  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
6815 
6816  }
6817  break;
6818 
6819  case 198:
6820 
6821 /* Line 1806 of yacc.c */
6822 #line 1954 "ripper.y"
6823  {
6824 #if 0
6825  value_expr((yyvsp[(3) - (5)].val));
6826  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6827  if ((yyvsp[(1) - (5)].val)) {
6828  ID vid = (yyvsp[(1) - (5)].val)->nd_vid;
6829  if ((yyvsp[(2) - (5)].val) == tOROP) {
6830  (yyvsp[(1) - (5)].val)->nd_value = (yyvsp[(3) - (5)].val);
6831  (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (5)].val));
6832  if (is_asgn_or_id(vid)) {
6833  (yyval.val)->nd_aid = vid;
6834  }
6835  }
6836  else if ((yyvsp[(2) - (5)].val) == tANDOP) {
6837  (yyvsp[(1) - (5)].val)->nd_value = (yyvsp[(3) - (5)].val);
6838  (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (5)].val));
6839  }
6840  else {
6841  (yyval.val) = (yyvsp[(1) - (5)].val);
6842  (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (5)].val), NEW_LIST((yyvsp[(3) - (5)].val)));
6843  }
6844  }
6845  else {
6846  (yyval.val) = NEW_BEGIN(0);
6847  }
6848 #endif
6849  (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
6850  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val));
6851 
6852  }
6853  break;
6854 
6855  case 199:
6856 
6857 /* Line 1806 of yacc.c */
6858 #line 1985 "ripper.y"
6859  {
6860 #if 0
6861  NODE *args;
6862 
6863  value_expr((yyvsp[(6) - (6)].val));
6864  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
6865  if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
6866  args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6867  }
6868  else {
6869  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6870  }
6871  if ((yyvsp[(5) - (6)].val) == tOROP) {
6872  (yyvsp[(5) - (6)].val) = 0;
6873  }
6874  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
6875  (yyvsp[(5) - (6)].val) = 1;
6876  }
6877  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
6878  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
6879 #endif
6880  (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
6881  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
6882 
6883  }
6884  break;
6885 
6886  case 200:
6887 
6888 /* Line 1806 of yacc.c */
6889 #line 2011 "ripper.y"
6890  {
6891 #if 0
6892  value_expr((yyvsp[(5) - (5)].val));
6893  if ((yyvsp[(4) - (5)].val) == tOROP) {
6894  (yyvsp[(4) - (5)].val) = 0;
6895  }
6896  else if ((yyvsp[(4) - (5)].val) == tANDOP) {
6897  (yyvsp[(4) - (5)].val) = 1;
6898  }
6899  (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6900  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6901 #endif
6902  (yyvsp[(1) - (5)].val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
6903  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6904 
6905  }
6906  break;
6907 
6908  case 201:
6909 
6910 /* Line 1806 of yacc.c */
6911 #line 2028 "ripper.y"
6912  {
6913 #if 0
6914  value_expr((yyvsp[(5) - (5)].val));
6915  if ((yyvsp[(4) - (5)].val) == tOROP) {
6916  (yyvsp[(4) - (5)].val) = 0;
6917  }
6918  else if ((yyvsp[(4) - (5)].val) == tANDOP) {
6919  (yyvsp[(4) - (5)].val) = 1;
6920  }
6921  (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6922  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6923 #endif
6924  (yyvsp[(1) - (5)].val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
6925  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6926 
6927  }
6928  break;
6929 
6930  case 202:
6931 
6932 /* Line 1806 of yacc.c */
6933 #line 2045 "ripper.y"
6934  {
6935 #if 0
6936  value_expr((yyvsp[(5) - (5)].val));
6937  if ((yyvsp[(4) - (5)].val) == tOROP) {
6938  (yyvsp[(4) - (5)].val) = 0;
6939  }
6940  else if ((yyvsp[(4) - (5)].val) == tANDOP) {
6941  (yyvsp[(4) - (5)].val) = 1;
6942  }
6943  (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6944  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6945 #endif
6946  (yyvsp[(1) - (5)].val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val));
6947  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6948 
6949  }
6950  break;
6951 
6952  case 203:
6953 
6954 /* Line 1806 of yacc.c */
6955 #line 2062 "ripper.y"
6956  {
6957 #if 0
6958  yyerror("constant re-assignment");
6959  (yyval.val) = NEW_BEGIN(0);
6960 #endif
6961  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6962  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6963  (yyval.val) = dispatch1(assign_error, (yyval.val));
6964 
6965  }
6966  break;
6967 
6968  case 204:
6969 
6970 /* Line 1806 of yacc.c */
6971 #line 2073 "ripper.y"
6972  {
6973 #if 0
6974  yyerror("constant re-assignment");
6975  (yyval.val) = NEW_BEGIN(0);
6976 #endif
6977  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val));
6978  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6979  (yyval.val) = dispatch1(assign_error, (yyval.val));
6980 
6981  }
6982  break;
6983 
6984  case 205:
6985 
6986 /* Line 1806 of yacc.c */
6987 #line 2084 "ripper.y"
6988  {
6989 #if 0
6990  rb_backref_error((yyvsp[(1) - (3)].val));
6991  (yyval.val) = NEW_BEGIN(0);
6992 #endif
6993  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val));
6994  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
6995  (yyval.val) = dispatch1(assign_error, (yyval.val));
6996 
6997  }
6998  break;
6999 
7000  case 206:
7001 
7002 /* Line 1806 of yacc.c */
7003 #line 2095 "ripper.y"
7004  {
7005 #if 0
7006  value_expr((yyvsp[(1) - (3)].val));
7007  value_expr((yyvsp[(3) - (3)].val));
7008  (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7009  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7010  nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7012  }
7013 #endif
7014  (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7015 
7016  }
7017  break;
7018 
7019  case 207:
7020 
7021 /* Line 1806 of yacc.c */
7022 #line 2109 "ripper.y"
7023  {
7024 #if 0
7025  value_expr((yyvsp[(1) - (3)].val));
7026  value_expr((yyvsp[(3) - (3)].val));
7027  (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7028  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7029  nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7031  }
7032 #endif
7033  (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7034 
7035  }
7036  break;
7037 
7038  case 208:
7039 
7040 /* Line 1806 of yacc.c */
7041 #line 2123 "ripper.y"
7042  {
7043 #if 0
7044  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
7045 #endif
7046  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val));
7047 
7048  }
7049  break;
7050 
7051  case 209:
7052 
7053 /* Line 1806 of yacc.c */
7054 #line 2131 "ripper.y"
7055  {
7056 #if 0
7057  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
7058 #endif
7059  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val));
7060 
7061  }
7062  break;
7063 
7064  case 210:
7065 
7066 /* Line 1806 of yacc.c */
7067 #line 2139 "ripper.y"
7068  {
7069 #if 0
7070  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
7071 #endif
7072  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val));
7073 
7074  }
7075  break;
7076 
7077  case 211:
7078 
7079 /* Line 1806 of yacc.c */
7080 #line 2147 "ripper.y"
7081  {
7082 #if 0
7083  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
7084 #endif
7085  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val));
7086 
7087  }
7088  break;
7089 
7090  case 212:
7091 
7092 /* Line 1806 of yacc.c */
7093 #line 2155 "ripper.y"
7094  {
7095 #if 0
7096  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
7097 #endif
7098  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val));
7099 
7100  }
7101  break;
7102 
7103  case 213:
7104 
7105 /* Line 1806 of yacc.c */
7106 #line 2163 "ripper.y"
7107  {
7108 #if 0
7109  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
7110 #endif
7111  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val));
7112 
7113  }
7114  break;
7115 
7116  case 214:
7117 
7118 /* Line 1806 of yacc.c */
7119 #line 2171 "ripper.y"
7120  {
7121 #if 0
7122  (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
7123 #endif
7124  (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
7125  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
7126 
7127  }
7128  break;
7129 
7130  case 215:
7131 
7132 /* Line 1806 of yacc.c */
7133 #line 2180 "ripper.y"
7134  {
7135 #if 0
7136  (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
7137 #endif
7138  (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
7139  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
7140 
7141  }
7142  break;
7143 
7144  case 216:
7145 
7146 /* Line 1806 of yacc.c */
7147 #line 2189 "ripper.y"
7148  {
7149 #if 0
7150  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
7151 #endif
7152  (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val));
7153 
7154  }
7155  break;
7156 
7157  case 217:
7158 
7159 /* Line 1806 of yacc.c */
7160 #line 2197 "ripper.y"
7161  {
7162 #if 0
7163  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
7164 #endif
7165  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
7166 
7167  }
7168  break;
7169 
7170  case 218:
7171 
7172 /* Line 1806 of yacc.c */
7173 #line 2205 "ripper.y"
7174  {
7175 #if 0
7176  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val));
7177 #endif
7178  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('|'), (yyvsp[(3) - (3)].val));
7179 
7180  }
7181  break;
7182 
7183  case 219:
7184 
7185 /* Line 1806 of yacc.c */
7186 #line 2213 "ripper.y"
7187  {
7188 #if 0
7189  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
7190 #endif
7191  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val));
7192 
7193  }
7194  break;
7195 
7196  case 220:
7197 
7198 /* Line 1806 of yacc.c */
7199 #line 2221 "ripper.y"
7200  {
7201 #if 0
7202  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
7203 #endif
7204  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val));
7205 
7206  }
7207  break;
7208 
7209  case 221:
7210 
7211 /* Line 1806 of yacc.c */
7212 #line 2229 "ripper.y"
7213  {
7214 #if 0
7215  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
7216 #endif
7217  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val));
7218 
7219  }
7220  break;
7221 
7222  case 222:
7223 
7224 /* Line 1806 of yacc.c */
7225 #line 2237 "ripper.y"
7226  {
7227 #if 0
7228  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
7229 #endif
7230  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val));
7231 
7232  }
7233  break;
7234 
7235  case 223:
7236 
7237 /* Line 1806 of yacc.c */
7238 #line 2245 "ripper.y"
7239  {
7240 #if 0
7241  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
7242 #endif
7243  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val));
7244 
7245  }
7246  break;
7247 
7248  case 224:
7249 
7250 /* Line 1806 of yacc.c */
7251 #line 2253 "ripper.y"
7252  {
7253 #if 0
7254  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
7255 #endif
7256  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val));
7257 
7258  }
7259  break;
7260 
7261  case 225:
7262 
7263 /* Line 1806 of yacc.c */
7264 #line 2261 "ripper.y"
7265  {
7266 #if 0
7267  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
7268 #endif
7269  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val));
7270 
7271  }
7272  break;
7273 
7274  case 226:
7275 
7276 /* Line 1806 of yacc.c */
7277 #line 2269 "ripper.y"
7278  {
7279 #if 0
7280  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
7281 #endif
7282  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val));
7283 
7284  }
7285  break;
7286 
7287  case 227:
7288 
7289 /* Line 1806 of yacc.c */
7290 #line 2277 "ripper.y"
7291  {
7292 #if 0
7293  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
7294 #endif
7295  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val));
7296 
7297  }
7298  break;
7299 
7300  case 228:
7301 
7302 /* Line 1806 of yacc.c */
7303 #line 2285 "ripper.y"
7304  {
7305 #if 0
7306  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
7307 #endif
7308  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val));
7309 
7310  }
7311  break;
7312 
7313  case 229:
7314 
7315 /* Line 1806 of yacc.c */
7316 #line 2293 "ripper.y"
7317  {
7318 #if 0
7319  (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7320  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && TYPE((yyvsp[(1) - (3)].val)->nd_lit) == T_REGEXP) {
7321  (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val));
7322  }
7323 #endif
7324  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val));
7325 
7326  }
7327  break;
7328 
7329  case 230:
7330 
7331 /* Line 1806 of yacc.c */
7332 #line 2304 "ripper.y"
7333  {
7334 #if 0
7335  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val));
7336 #endif
7337  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!~"), (yyvsp[(3) - (3)].val));
7338 
7339  }
7340  break;
7341 
7342  case 231:
7343 
7344 /* Line 1806 of yacc.c */
7345 #line 2312 "ripper.y"
7346  {
7347 #if 0
7348  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
7349 #endif
7350  (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val));
7351 
7352  }
7353  break;
7354 
7355  case 232:
7356 
7357 /* Line 1806 of yacc.c */
7358 #line 2320 "ripper.y"
7359  {
7360 #if 0
7361  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
7362 #endif
7363  (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val));
7364 
7365  }
7366  break;
7367 
7368  case 233:
7369 
7370 /* Line 1806 of yacc.c */
7371 #line 2328 "ripper.y"
7372  {
7373 #if 0
7374  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val));
7375 #endif
7376  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<<"), (yyvsp[(3) - (3)].val));
7377 
7378  }
7379  break;
7380 
7381  case 234:
7382 
7383 /* Line 1806 of yacc.c */
7384 #line 2336 "ripper.y"
7385  {
7386 #if 0
7387  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val));
7388 #endif
7389  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">>"), (yyvsp[(3) - (3)].val));
7390 
7391  }
7392  break;
7393 
7394  case 235:
7395 
7396 /* Line 1806 of yacc.c */
7397 #line 2344 "ripper.y"
7398  {
7399 #if 0
7400  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7401 #endif
7402  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val));
7403 
7404  }
7405  break;
7406 
7407  case 236:
7408 
7409 /* Line 1806 of yacc.c */
7410 #line 2352 "ripper.y"
7411  {
7412 #if 0
7413  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7414 #endif
7415  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val));
7416 
7417  }
7418  break;
7419 
7420  case 237:
7421 
7422 /* Line 1806 of yacc.c */
7423 #line 2359 "ripper.y"
7424  {in_defined = 1;}
7425  break;
7426 
7427  case 238:
7428 
7429 /* Line 1806 of yacc.c */
7430 #line 2360 "ripper.y"
7431  {
7432 #if 0
7433  in_defined = 0;
7434  (yyval.val) = NEW_DEFINED((yyvsp[(4) - (4)].val));
7435 #endif
7436  in_defined = 0;
7437  (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val));
7438 
7439  }
7440  break;
7441 
7442  case 239:
7443 
7444 /* Line 1806 of yacc.c */
7445 #line 2370 "ripper.y"
7446  {
7447 #if 0
7448  value_expr((yyvsp[(1) - (6)].val));
7449  (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7450  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
7451 #endif
7452  (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7453 
7454  }
7455  break;
7456 
7457  case 240:
7458 
7459 /* Line 1806 of yacc.c */
7460 #line 2380 "ripper.y"
7461  {
7462  (yyval.val) = (yyvsp[(1) - (1)].val);
7463  }
7464  break;
7465 
7466  case 241:
7467 
7468 /* Line 1806 of yacc.c */
7469 #line 2386 "ripper.y"
7470  {
7471 #if 0
7472  value_expr((yyvsp[(1) - (1)].val));
7473  (yyval.val) = (yyvsp[(1) - (1)].val);
7474  if (!(yyval.val)) (yyval.val) = NEW_NIL();
7475 #endif
7476  (yyval.val) = (yyvsp[(1) - (1)].val);
7477 
7478  }
7479  break;
7480 
7481  case 243:
7482 
7483 /* Line 1806 of yacc.c */
7484 #line 2399 "ripper.y"
7485  {
7486  (yyval.val) = (yyvsp[(1) - (2)].val);
7487  }
7488  break;
7489 
7490  case 244:
7491 
7492 /* Line 1806 of yacc.c */
7493 #line 2403 "ripper.y"
7494  {
7495 #if 0
7496  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7497 #endif
7498  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7499 
7500  }
7501  break;
7502 
7503  case 245:
7504 
7505 /* Line 1806 of yacc.c */
7506 #line 2411 "ripper.y"
7507  {
7508 #if 0
7509  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7510 #endif
7511  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7512 
7513  }
7514  break;
7515 
7516  case 246:
7517 
7518 /* Line 1806 of yacc.c */
7519 #line 2421 "ripper.y"
7520  {
7521 #if 0
7522  (yyval.val) = (yyvsp[(2) - (3)].val);
7523 #endif
7524  (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
7525 
7526  }
7527  break;
7528 
7529  case 251:
7530 
7531 /* Line 1806 of yacc.c */
7532 #line 2437 "ripper.y"
7533  {
7534  (yyval.val) = (yyvsp[(1) - (2)].val);
7535  }
7536  break;
7537 
7538  case 252:
7539 
7540 /* Line 1806 of yacc.c */
7541 #line 2441 "ripper.y"
7542  {
7543 #if 0
7544  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7545 #endif
7546  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7547 
7548  }
7549  break;
7550 
7551  case 253:
7552 
7553 /* Line 1806 of yacc.c */
7554 #line 2449 "ripper.y"
7555  {
7556 #if 0
7557  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7558 #endif
7559  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7560 
7561  }
7562  break;
7563 
7564  case 254:
7565 
7566 /* Line 1806 of yacc.c */
7567 #line 2459 "ripper.y"
7568  {
7569 #if 0
7570  value_expr((yyvsp[(1) - (1)].val));
7571  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7572 #endif
7573  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7574 
7575  }
7576  break;
7577 
7578  case 255:
7579 
7580 /* Line 1806 of yacc.c */
7581 #line 2468 "ripper.y"
7582  {
7583 #if 0
7584  (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7585 #endif
7586  (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7587 
7588  }
7589  break;
7590 
7591  case 256:
7592 
7593 /* Line 1806 of yacc.c */
7594 #line 2476 "ripper.y"
7595  {
7596 #if 0
7597  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7598  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
7599 #endif
7600  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7601  (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
7602 
7603  }
7604  break;
7605 
7606  case 257:
7607 
7608 /* Line 1806 of yacc.c */
7609 #line 2486 "ripper.y"
7610  {
7611 #if 0
7612  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7613  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
7614 #endif
7615  (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
7616 
7617  }
7618  break;
7619 
7620  case 258:
7621 
7622 /* Line 1806 of yacc.c */
7623 #line 2497 "ripper.y"
7624  {
7625  (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
7626  }
7627  break;
7628 
7629  case 259:
7630 
7631 /* Line 1806 of yacc.c */
7632 #line 2503 "ripper.y"
7633  {
7634  (yyval.val) = cmdarg_stack;
7635  CMDARG_PUSH(1);
7636  }
7637  break;
7638 
7639  case 260:
7640 
7641 /* Line 1806 of yacc.c */
7642 #line 2508 "ripper.y"
7643  {
7644  /* CMDARG_POP() */
7645  cmdarg_stack = (yyvsp[(1) - (2)].val);
7646  (yyval.val) = (yyvsp[(2) - (2)].val);
7647  }
7648  break;
7649 
7650  case 261:
7651 
7652 /* Line 1806 of yacc.c */
7653 #line 2516 "ripper.y"
7654  {
7655 #if 0
7656  (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
7657 #endif
7658  (yyval.val) = (yyvsp[(2) - (2)].val);
7659 
7660  }
7661  break;
7662 
7663  case 262:
7664 
7665 /* Line 1806 of yacc.c */
7666 #line 2526 "ripper.y"
7667  {
7668  (yyval.val) = (yyvsp[(2) - (2)].val);
7669  }
7670  break;
7671 
7672  case 263:
7673 
7674 /* Line 1806 of yacc.c */
7675 #line 2530 "ripper.y"
7676  {
7677  (yyval.val) = 0;
7678  }
7679  break;
7680 
7681  case 264:
7682 
7683 /* Line 1806 of yacc.c */
7684 #line 2536 "ripper.y"
7685  {
7686 #if 0
7687  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7688 #endif
7689  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7690 
7691  }
7692  break;
7693 
7694  case 265:
7695 
7696 /* Line 1806 of yacc.c */
7697 #line 2544 "ripper.y"
7698  {
7699 #if 0
7700  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7701 #endif
7702  (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
7703 
7704  }
7705  break;
7706 
7707  case 266:
7708 
7709 /* Line 1806 of yacc.c */
7710 #line 2552 "ripper.y"
7711  {
7712 #if 0
7713  NODE *n1;
7714  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7715  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7716  }
7717  else {
7718  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7719  }
7720 #endif
7721  (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7722 
7723  }
7724  break;
7725 
7726  case 267:
7727 
7728 /* Line 1806 of yacc.c */
7729 #line 2566 "ripper.y"
7730  {
7731 #if 0
7732  NODE *n1;
7733  if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7734  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7735  }
7736  else {
7737  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7738  }
7739 #endif
7740  (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7741 
7742  }
7743  break;
7744 
7745  case 268:
7746 
7747 /* Line 1806 of yacc.c */
7748 #line 2582 "ripper.y"
7749  {
7750 #if 0
7751  NODE *n1;
7752  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7753  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7754  }
7755  else {
7756  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7757  }
7758 #endif
7759  (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
7760 
7761  }
7762  break;
7763 
7764  case 269:
7765 
7766 /* Line 1806 of yacc.c */
7767 #line 2596 "ripper.y"
7768  {
7769 #if 0
7770  NODE *n1;
7771  if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
7772  (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7773  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7774  }
7775  else {
7776  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7777  }
7778 #endif
7779  (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
7780 
7781  }
7782  break;
7783 
7784  case 270:
7785 
7786 /* Line 1806 of yacc.c */
7787 #line 2611 "ripper.y"
7788  {
7789 #if 0
7790  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7791 #endif
7792  (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
7793 
7794  }
7795  break;
7796 
7797  case 279:
7798 
7799 /* Line 1806 of yacc.c */
7800 #line 2629 "ripper.y"
7801  {
7802 #if 0
7803  (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
7804 #endif
7805  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
7806 
7807  }
7808  break;
7809 
7810  case 280:
7811 
7812 /* Line 1806 of yacc.c */
7813 #line 2637 "ripper.y"
7814  {
7815 #if 0
7816  (yyval.num) = ruby_sourceline;
7817 #endif
7818 
7819  }
7820  break;
7821 
7822  case 281:
7823 
7824 /* Line 1806 of yacc.c */
7825 #line 2645 "ripper.y"
7826  {
7827 #if 0
7828  if ((yyvsp[(3) - (4)].val) == NULL) {
7829  (yyval.val) = NEW_NIL();
7830  }
7831  else {
7832  if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE ||
7833  nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE)
7834  nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
7835  (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val));
7836  }
7837  nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
7838 #endif
7839  (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
7840 
7841  }
7842  break;
7843 
7844  case 282:
7845 
7846 /* Line 1806 of yacc.c */
7847 #line 2661 "ripper.y"
7848  {lex_state = EXPR_ENDARG;}
7849  break;
7850 
7851  case 283:
7852 
7853 /* Line 1806 of yacc.c */
7854 #line 2662 "ripper.y"
7855  {
7856  rb_warning0("(...) interpreted as grouped expression");
7857 #if 0
7858  (yyval.val) = (yyvsp[(2) - (4)].val);
7859 #endif
7860  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
7861 
7862  }
7863  break;
7864 
7865  case 284:
7866 
7867 /* Line 1806 of yacc.c */
7868 #line 2671 "ripper.y"
7869  {
7870 #if 0
7871  (yyval.val) = (yyvsp[(2) - (3)].val);
7872 #endif
7873  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
7874 
7875  }
7876  break;
7877 
7878  case 285:
7879 
7880 /* Line 1806 of yacc.c */
7881 #line 2679 "ripper.y"
7882  {
7883 #if 0
7884  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7885 #endif
7886  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7887 
7888  }
7889  break;
7890 
7891  case 286:
7892 
7893 /* Line 1806 of yacc.c */
7894 #line 2687 "ripper.y"
7895  {
7896 #if 0
7897  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
7898 #endif
7899  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
7900 
7901  }
7902  break;
7903 
7904  case 287:
7905 
7906 /* Line 1806 of yacc.c */
7907 #line 2695 "ripper.y"
7908  {
7909 #if 0
7910  if ((yyvsp[(2) - (3)].val) == 0) {
7911  (yyval.val) = NEW_ZARRAY(); /* zero length array*/
7912  }
7913  else {
7914  (yyval.val) = (yyvsp[(2) - (3)].val);
7915  }
7916 #endif
7917  (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
7918 
7919  }
7920  break;
7921 
7922  case 288:
7923 
7924 /* Line 1806 of yacc.c */
7925 #line 2708 "ripper.y"
7926  {
7927 #if 0
7928  (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
7929 #endif
7930  (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
7931 
7932  }
7933  break;
7934 
7935  case 289:
7936 
7937 /* Line 1806 of yacc.c */
7938 #line 2716 "ripper.y"
7939  {
7940 #if 0
7941  (yyval.val) = NEW_RETURN(0);
7942 #endif
7943  (yyval.val) = dispatch0(return0);
7944 
7945  }
7946  break;
7947 
7948  case 290:
7949 
7950 /* Line 1806 of yacc.c */
7951 #line 2724 "ripper.y"
7952  {
7953 #if 0
7954  (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
7955 #endif
7956  (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
7957 
7958  }
7959  break;
7960 
7961  case 291:
7962 
7963 /* Line 1806 of yacc.c */
7964 #line 2732 "ripper.y"
7965  {
7966 #if 0
7967  (yyval.val) = NEW_YIELD(0, Qfalse);
7968 #endif
7969  (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
7970 
7971  }
7972  break;
7973 
7974  case 292:
7975 
7976 /* Line 1806 of yacc.c */
7977 #line 2740 "ripper.y"
7978  {
7979 #if 0
7980  (yyval.val) = NEW_YIELD(0, Qfalse);
7981 #endif
7982  (yyval.val) = dispatch0(yield0);
7983 
7984  }
7985  break;
7986 
7987  case 293:
7988 
7989 /* Line 1806 of yacc.c */
7990 #line 2747 "ripper.y"
7991  {in_defined = 1;}
7992  break;
7993 
7994  case 294:
7995 
7996 /* Line 1806 of yacc.c */
7997 #line 2748 "ripper.y"
7998  {
7999 #if 0
8000  in_defined = 0;
8001  (yyval.val) = NEW_DEFINED((yyvsp[(5) - (6)].val));
8002 #endif
8003  in_defined = 0;
8004  (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val));
8005 
8006  }
8007  break;
8008 
8009  case 295:
8010 
8011 /* Line 1806 of yacc.c */
8012 #line 2758 "ripper.y"
8013  {
8014 #if 0
8015  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
8016 #endif
8017  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val));
8018 
8019  }
8020  break;
8021 
8022  case 296:
8023 
8024 /* Line 1806 of yacc.c */
8025 #line 2766 "ripper.y"
8026  {
8027 #if 0
8028  (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
8029 #endif
8030  (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil);
8031 
8032  }
8033  break;
8034 
8035  case 297:
8036 
8037 /* Line 1806 of yacc.c */
8038 #line 2774 "ripper.y"
8039  {
8040 #if 0
8041  (yyvsp[(2) - (2)].val)->nd_iter = NEW_FCALL((yyvsp[(1) - (2)].val), 0);
8042  (yyval.val) = (yyvsp[(2) - (2)].val);
8043  fixpos((yyvsp[(2) - (2)].val)->nd_iter, (yyvsp[(2) - (2)].val));
8044 #endif
8045  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
8046  (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
8047 
8048  }
8049  break;
8050 
8051  case 299:
8052 
8053 /* Line 1806 of yacc.c */
8054 #line 2786 "ripper.y"
8055  {
8056 #if 0
8057  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
8058  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
8059  (yyval.val) = (yyvsp[(2) - (2)].val);
8060  fixpos((yyval.val), (yyvsp[(1) - (2)].val));
8061 #endif
8062  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
8063 
8064  }
8065  break;
8066 
8067  case 300:
8068 
8069 /* Line 1806 of yacc.c */
8070 #line 2797 "ripper.y"
8071  {
8072  (yyval.val) = (yyvsp[(2) - (2)].val);
8073  }
8074  break;
8075 
8076  case 301:
8077 
8078 /* Line 1806 of yacc.c */
8079 #line 2804 "ripper.y"
8080  {
8081 #if 0
8082  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8083  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8084 #endif
8085  (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8086 
8087  }
8088  break;
8089 
8090  case 302:
8091 
8092 /* Line 1806 of yacc.c */
8093 #line 2816 "ripper.y"
8094  {
8095 #if 0
8096  (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8097  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8098 #endif
8099  (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8100 
8101  }
8102  break;
8103 
8104  case 303:
8105 
8106 /* Line 1806 of yacc.c */
8107 #line 2824 "ripper.y"
8108  {COND_PUSH(1);}
8109  break;
8110 
8111  case 304:
8112 
8113 /* Line 1806 of yacc.c */
8114 #line 2824 "ripper.y"
8115  {COND_POP();}
8116  break;
8117 
8118  case 305:
8119 
8120 /* Line 1806 of yacc.c */
8121 #line 2827 "ripper.y"
8122  {
8123 #if 0
8124  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8125  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8126 #endif
8127  (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8128 
8129  }
8130  break;
8131 
8132  case 306:
8133 
8134 /* Line 1806 of yacc.c */
8135 #line 2835 "ripper.y"
8136  {COND_PUSH(1);}
8137  break;
8138 
8139  case 307:
8140 
8141 /* Line 1806 of yacc.c */
8142 #line 2835 "ripper.y"
8143  {COND_POP();}
8144  break;
8145 
8146  case 308:
8147 
8148 /* Line 1806 of yacc.c */
8149 #line 2838 "ripper.y"
8150  {
8151 #if 0
8152  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8153  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8154 #endif
8155  (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8156 
8157  }
8158  break;
8159 
8160  case 309:
8161 
8162 /* Line 1806 of yacc.c */
8163 #line 2849 "ripper.y"
8164  {
8165 #if 0
8166  (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8167  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8168 #endif
8169  (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8170 
8171  }
8172  break;
8173 
8174  case 310:
8175 
8176 /* Line 1806 of yacc.c */
8177 #line 2858 "ripper.y"
8178  {
8179 #if 0
8180  (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
8181 #endif
8182  (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
8183 
8184  }
8185  break;
8186 
8187  case 311:
8188 
8189 /* Line 1806 of yacc.c */
8190 #line 2866 "ripper.y"
8191  {COND_PUSH(1);}
8192  break;
8193 
8194  case 312:
8195 
8196 /* Line 1806 of yacc.c */
8197 #line 2868 "ripper.y"
8198  {COND_POP();}
8199  break;
8200 
8201  case 313:
8202 
8203 /* Line 1806 of yacc.c */
8204 #line 2871 "ripper.y"
8205  {
8206 #if 0
8207  /*
8208  * for a, b, c in e
8209  * #=>
8210  * e.each{|*x| a, b, c = x
8211  *
8212  * for a in e
8213  * #=>
8214  * e.each{|x| a, = x}
8215  */
8216  ID id = internal_id();
8217  ID *tbl = ALLOC_N(ID, 2);
8218  NODE *m = NEW_ARGS_AUX(0, 0);
8219  NODE *args, *scope;
8220 
8221  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) {
8222  /* if args.length == 1 && args[0].kind_of?(Array)
8223  * args = args[0]
8224  * end
8225  */
8226  NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
8227  NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
8228  m->nd_next = block_append(
8229  NEW_IF(
8231  NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("length"), 0),
8232  rb_intern("=="), one),
8233  NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero),
8234  rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
8235  0),
8236  NEW_DASGN_CURR(id,
8237  NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero)),
8238  0),
8239  node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id)));
8240 
8241  args = new_args(m, 0, id, 0, 0);
8242  }
8243  else {
8244  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN ||
8245  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN ||
8246  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) {
8247  (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id);
8248  m->nd_plen = 1;
8249  m->nd_next = (yyvsp[(2) - (9)].val);
8250  args = new_args(m, 0, 0, 0, 0);
8251  }
8252  else {
8253  m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id));
8254  args = new_args(m, 0, id, 0, 0);
8255  }
8256  }
8257  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
8258  tbl[0] = 1; tbl[1] = id;
8259  (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope);
8260  fixpos((yyval.val), (yyvsp[(2) - (9)].val));
8261 #endif
8262  (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
8263 
8264  }
8265  break;
8266 
8267  case 314:
8268 
8269 /* Line 1806 of yacc.c */
8270 #line 2932 "ripper.y"
8271  {
8272  if (in_def || in_single)
8273  yyerror("class definition in method body");
8274  local_push(0);
8275 #if 0
8276  (yyval.num) = ruby_sourceline;
8277 #endif
8278 
8279  }
8280  break;
8281 
8282  case 315:
8283 
8284 /* Line 1806 of yacc.c */
8285 #line 2943 "ripper.y"
8286  {
8287 #if 0
8288  (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
8289  nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
8290 #endif
8291  (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
8292 
8293  local_pop();
8294  }
8295  break;
8296 
8297  case 316:
8298 
8299 /* Line 1806 of yacc.c */
8300 #line 2953 "ripper.y"
8301  {
8302  (yyval.num) = in_def;
8303  in_def = 0;
8304  }
8305  break;
8306 
8307  case 317:
8308 
8309 /* Line 1806 of yacc.c */
8310 #line 2958 "ripper.y"
8311  {
8312  (yyval.num) = in_single;
8313  in_single = 0;
8314  local_push(0);
8315  }
8316  break;
8317 
8318  case 318:
8319 
8320 /* Line 1806 of yacc.c */
8321 #line 2965 "ripper.y"
8322  {
8323 #if 0
8324  (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8325  fixpos((yyval.val), (yyvsp[(3) - (8)].val));
8326 #endif
8327  (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8328 
8329  local_pop();
8330  in_def = (yyvsp[(4) - (8)].num);
8331  in_single = (yyvsp[(6) - (8)].num);
8332  }
8333  break;
8334 
8335  case 319:
8336 
8337 /* Line 1806 of yacc.c */
8338 #line 2977 "ripper.y"
8339  {
8340  if (in_def || in_single)
8341  yyerror("module definition in method body");
8342  local_push(0);
8343 #if 0
8344  (yyval.num) = ruby_sourceline;
8345 #endif
8346 
8347  }
8348  break;
8349 
8350  case 320:
8351 
8352 /* Line 1806 of yacc.c */
8353 #line 2988 "ripper.y"
8354  {
8355 #if 0
8356  (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8357  nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
8358 #endif
8359  (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8360 
8361  local_pop();
8362  }
8363  break;
8364 
8365  case 321:
8366 
8367 /* Line 1806 of yacc.c */
8368 #line 2998 "ripper.y"
8369  {
8370  (yyval.id) = cur_mid;
8371  cur_mid = (yyvsp[(2) - (2)].val);
8372  in_def++;
8373  local_push(0);
8374  }
8375  break;
8376 
8377  case 322:
8378 
8379 /* Line 1806 of yacc.c */
8380 #line 3007 "ripper.y"
8381  {
8382 #if 0
8383  NODE *body = remove_begin((yyvsp[(5) - (6)].val));
8384  reduce_nodes(&body);
8385  (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE);
8386  nd_set_line((yyval.val), (yyvsp[(1) - (6)].num));
8387 #endif
8388  (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8389 
8390  local_pop();
8391  in_def--;
8392  cur_mid = (yyvsp[(3) - (6)].id);
8393  }
8394  break;
8395 
8396  case 323:
8397 
8398 /* Line 1806 of yacc.c */
8399 #line 3020 "ripper.y"
8400  {lex_state = EXPR_FNAME;}
8401  break;
8402 
8403  case 324:
8404 
8405 /* Line 1806 of yacc.c */
8406 #line 3021 "ripper.y"
8407  {
8408  in_single++;
8409  lex_state = EXPR_ENDFN; /* force for args */
8410  local_push(0);
8411  }
8412  break;
8413 
8414  case 325:
8415 
8416 /* Line 1806 of yacc.c */
8417 #line 3029 "ripper.y"
8418  {
8419 #if 0
8420  NODE *body = remove_begin((yyvsp[(8) - (9)].val));
8421  reduce_nodes(&body);
8422  (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
8423  nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
8424 #endif
8425  (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
8426 
8427  local_pop();
8428  in_single--;
8429  }
8430  break;
8431 
8432  case 326:
8433 
8434 /* Line 1806 of yacc.c */
8435 #line 3042 "ripper.y"
8436  {
8437 #if 0
8438  (yyval.val) = NEW_BREAK(0);
8439 #endif
8440  (yyval.val) = dispatch1(break, arg_new());
8441 
8442  }
8443  break;
8444 
8445  case 327:
8446 
8447 /* Line 1806 of yacc.c */
8448 #line 3050 "ripper.y"
8449  {
8450 #if 0
8451  (yyval.val) = NEW_NEXT(0);
8452 #endif
8453  (yyval.val) = dispatch1(next, arg_new());
8454 
8455  }
8456  break;
8457 
8458  case 328:
8459 
8460 /* Line 1806 of yacc.c */
8461 #line 3058 "ripper.y"
8462  {
8463 #if 0
8464  (yyval.val) = NEW_REDO();
8465 #endif
8466  (yyval.val) = dispatch0(redo);
8467 
8468  }
8469  break;
8470 
8471  case 329:
8472 
8473 /* Line 1806 of yacc.c */
8474 #line 3066 "ripper.y"
8475  {
8476 #if 0
8477  (yyval.val) = NEW_RETRY();
8478 #endif
8479  (yyval.val) = dispatch0(retry);
8480 
8481  }
8482  break;
8483 
8484  case 330:
8485 
8486 /* Line 1806 of yacc.c */
8487 #line 3076 "ripper.y"
8488  {
8489 #if 0
8490  value_expr((yyvsp[(1) - (1)].val));
8491  (yyval.val) = (yyvsp[(1) - (1)].val);
8492  if (!(yyval.val)) (yyval.val) = NEW_NIL();
8493 #endif
8494  (yyval.val) = (yyvsp[(1) - (1)].val);
8495 
8496  }
8497  break;
8498 
8499  case 331:
8500 
8501 /* Line 1806 of yacc.c */
8502 #line 3088 "ripper.y"
8503  {
8504  token_info_push("begin");
8505  }
8506  break;
8507 
8508  case 332:
8509 
8510 /* Line 1806 of yacc.c */
8511 #line 3094 "ripper.y"
8512  {
8513  token_info_push("if");
8514  }
8515  break;
8516 
8517  case 333:
8518 
8519 /* Line 1806 of yacc.c */
8520 #line 3100 "ripper.y"
8521  {
8522  token_info_push("unless");
8523  }
8524  break;
8525 
8526  case 334:
8527 
8528 /* Line 1806 of yacc.c */
8529 #line 3106 "ripper.y"
8530  {
8531  token_info_push("while");
8532  }
8533  break;
8534 
8535  case 335:
8536 
8537 /* Line 1806 of yacc.c */
8538 #line 3112 "ripper.y"
8539  {
8540  token_info_push("until");
8541  }
8542  break;
8543 
8544  case 336:
8545 
8546 /* Line 1806 of yacc.c */
8547 #line 3118 "ripper.y"
8548  {
8549  token_info_push("case");
8550  }
8551  break;
8552 
8553  case 337:
8554 
8555 /* Line 1806 of yacc.c */
8556 #line 3124 "ripper.y"
8557  {
8558  token_info_push("for");
8559  }
8560  break;
8561 
8562  case 338:
8563 
8564 /* Line 1806 of yacc.c */
8565 #line 3130 "ripper.y"
8566  {
8567  token_info_push("class");
8568  }
8569  break;
8570 
8571  case 339:
8572 
8573 /* Line 1806 of yacc.c */
8574 #line 3136 "ripper.y"
8575  {
8576  token_info_push("module");
8577  }
8578  break;
8579 
8580  case 340:
8581 
8582 /* Line 1806 of yacc.c */
8583 #line 3142 "ripper.y"
8584  {
8585  token_info_push("def");
8586 #if 0
8587  (yyval.num) = ruby_sourceline;
8588 #endif
8589 
8590  }
8591  break;
8592 
8593  case 341:
8594 
8595 /* Line 1806 of yacc.c */
8596 #line 3152 "ripper.y"
8597  {
8598  token_info_pop("end");
8599  }
8600  break;
8601 
8602  case 342:
8603 
8604 /* Line 1806 of yacc.c */
8605 #line 3160 "ripper.y"
8606  { (yyval.val) = Qnil; }
8607  break;
8608 
8609  case 344:
8610 
8611 /* Line 1806 of yacc.c */
8612 #line 3166 "ripper.y"
8613  { (yyval.val) = (yyvsp[(2) - (2)].val); }
8614  break;
8615 
8616  case 345:
8617 
8618 /* Line 1806 of yacc.c */
8619 #line 3173 "ripper.y"
8620  { (yyval.val) = Qnil; }
8621  break;
8622 
8623  case 348:
8624 
8625 /* Line 1806 of yacc.c */
8626 #line 3182 "ripper.y"
8627  {
8628 #if 0
8629  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
8630  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8631 #endif
8632  (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
8633 
8634  }
8635  break;
8636 
8637  case 350:
8638 
8639 /* Line 1806 of yacc.c */
8640 #line 3194 "ripper.y"
8641  {
8642 #if 0
8643  (yyval.val) = (yyvsp[(2) - (2)].val);
8644 #endif
8645  (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
8646 
8647  }
8648  break;
8649 
8650  case 353:
8651 
8652 /* Line 1806 of yacc.c */
8653 #line 3208 "ripper.y"
8654  {
8655  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
8656 #if 0
8657 #endif
8658  (yyval.val) = dispatch1(mlhs_paren, (yyval.val));
8659 
8660  }
8661  break;
8662 
8663  case 354:
8664 
8665 /* Line 1806 of yacc.c */
8666 #line 3216 "ripper.y"
8667  {
8668 #if 0
8669  (yyval.val) = (yyvsp[(2) - (3)].val);
8670 #endif
8671  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
8672 
8673  }
8674  break;
8675 
8676  case 355:
8677 
8678 /* Line 1806 of yacc.c */
8679 #line 3226 "ripper.y"
8680  {
8681 #if 0
8682  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
8683 #endif
8684  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
8685 
8686  }
8687  break;
8688 
8689  case 356:
8690 
8691 /* Line 1806 of yacc.c */
8692 #line 3234 "ripper.y"
8693  {
8694 #if 0
8695  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8696 #endif
8697  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8698 
8699  }
8700  break;
8701 
8702  case 357:
8703 
8704 /* Line 1806 of yacc.c */
8705 #line 3244 "ripper.y"
8706  {
8707 #if 0
8708  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
8709 #endif
8710  (yyval.val) = (yyvsp[(1) - (1)].val);
8711 
8712  }
8713  break;
8714 
8715  case 358:
8716 
8717 /* Line 1806 of yacc.c */
8718 #line 3252 "ripper.y"
8719  {
8720  (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
8721 #if 0
8722  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val));
8723 #endif
8724  (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
8725 
8726  }
8727  break;
8728 
8729  case 359:
8730 
8731 /* Line 1806 of yacc.c */
8732 #line 3261 "ripper.y"
8733  {
8734  (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
8735 #if 0
8736  (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val)));
8737 #endif
8738  (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
8739 
8740  }
8741  break;
8742 
8743  case 360:
8744 
8745 /* Line 1806 of yacc.c */
8746 #line 3270 "ripper.y"
8747  {
8748 #if 0
8749  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
8750 #endif
8751  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
8752 
8753  }
8754  break;
8755 
8756  case 361:
8757 
8758 /* Line 1806 of yacc.c */
8759 #line 3278 "ripper.y"
8760  {
8761 #if 0
8762  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
8763 #endif
8764  (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
8765 
8766  }
8767  break;
8768 
8769  case 362:
8770 
8771 /* Line 1806 of yacc.c */
8772 #line 3286 "ripper.y"
8773  {
8774  (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
8775 #if 0
8776  (yyval.val) = NEW_MASGN(0, (yyval.val));
8777 #endif
8778  (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
8779 
8780  }
8781  break;
8782 
8783  case 363:
8784 
8785 /* Line 1806 of yacc.c */
8786 #line 3295 "ripper.y"
8787  {
8788  (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
8789 #if 0
8790  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val)));
8791 #endif
8792  #if 0
8793  TODO: Check me
8794  #endif
8795  (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val));
8796 
8797  }
8798  break;
8799 
8800  case 364:
8801 
8802 /* Line 1806 of yacc.c */
8803 #line 3307 "ripper.y"
8804  {
8805 #if 0
8806  (yyval.val) = NEW_MASGN(0, -1);
8807 #endif
8808  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8809 
8810  }
8811  break;
8812 
8813  case 365:
8814 
8815 /* Line 1806 of yacc.c */
8816 #line 3315 "ripper.y"
8817  {
8818 #if 0
8819  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
8820 #endif
8821  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8822 
8823  }
8824  break;
8825 
8826  case 366:
8827 
8828 /* Line 1806 of yacc.c */
8829 #line 3325 "ripper.y"
8830  {
8831 #if 0
8832  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), 0, (yyvsp[(6) - (6)].val));
8833 #endif
8834  (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnil, escape_Qundef((yyvsp[(6) - (6)].val)));
8835 
8836  }
8837  break;
8838 
8839  case 367:
8840 
8841 /* Line 1806 of yacc.c */
8842 #line 3333 "ripper.y"
8843  {
8844 #if 0
8845  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
8846 #endif
8847  (yyval.val) = params_new((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), escape_Qundef((yyvsp[(8) - (8)].val)));
8848 
8849  }
8850  break;
8851 
8852  case 368:
8853 
8854 /* Line 1806 of yacc.c */
8855 #line 3341 "ripper.y"
8856  {
8857 #if 0
8858  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, 0, (yyvsp[(4) - (4)].val));
8859 #endif
8860  (yyval.val) = params_new((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
8861 
8862  }
8863  break;
8864 
8865  case 369:
8866 
8867 /* Line 1806 of yacc.c */
8868 #line 3349 "ripper.y"
8869  {
8870 #if 0
8871  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), 0, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8872 #endif
8873  (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnil, (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
8874 
8875  }
8876  break;
8877 
8878  case 370:
8879 
8880 /* Line 1806 of yacc.c */
8881 #line 3357 "ripper.y"
8882  {
8883 #if 0
8884  (yyval.val) = new_args((yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
8885 #endif
8886  (yyval.val) = params_new((yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
8887 
8888  }
8889  break;
8890 
8891  case 371:
8892 
8893 /* Line 1806 of yacc.c */
8894 #line 3365 "ripper.y"
8895  {
8896 #if 0
8897  (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 1, 0, 0);
8898 #endif
8899  (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil, Qnil, Qnil, Qnil);
8900  dispatch1(excessed_comma, (yyval.val));
8901 
8902  }
8903  break;
8904 
8905  case 372:
8906 
8907 /* Line 1806 of yacc.c */
8908 #line 3374 "ripper.y"
8909  {
8910 #if 0
8911  (yyval.val) = new_args((yyvsp[(1) - (6)].val), 0, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8912 #endif
8913  (yyval.val) = params_new((yyvsp[(1) - (6)].val), Qnil, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
8914 
8915  }
8916  break;
8917 
8918  case 373:
8919 
8920 /* Line 1806 of yacc.c */
8921 #line 3382 "ripper.y"
8922  {
8923 #if 0
8924  (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 0, 0, (yyvsp[(2) - (2)].val));
8925 #endif
8926  (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil,Qnil, Qnil, escape_Qundef((yyvsp[(2) - (2)].val)));
8927 
8928  }
8929  break;
8930 
8931  case 374:
8932 
8933 /* Line 1806 of yacc.c */
8934 #line 3390 "ripper.y"
8935  {
8936 #if 0
8937  (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
8938 #endif
8939  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
8940 
8941  }
8942  break;
8943 
8944  case 375:
8945 
8946 /* Line 1806 of yacc.c */
8947 #line 3398 "ripper.y"
8948  {
8949 #if 0
8950  (yyval.val) = new_args(0, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8951 #endif
8952  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
8953 
8954  }
8955  break;
8956 
8957  case 376:
8958 
8959 /* Line 1806 of yacc.c */
8960 #line 3406 "ripper.y"
8961  {
8962 #if 0
8963  (yyval.val) = new_args(0, (yyvsp[(1) - (2)].val), 0, 0, (yyvsp[(2) - (2)].val));
8964 #endif
8965  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (2)].val), Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
8966 
8967  }
8968  break;
8969 
8970  case 377:
8971 
8972 /* Line 1806 of yacc.c */
8973 #line 3414 "ripper.y"
8974  {
8975 #if 0
8976  (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
8977 #endif
8978  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
8979 
8980  }
8981  break;
8982 
8983  case 378:
8984 
8985 /* Line 1806 of yacc.c */
8986 #line 3422 "ripper.y"
8987  {
8988 #if 0
8989  (yyval.val) = new_args(0, 0, (yyvsp[(1) - (2)].val), 0, (yyvsp[(2) - (2)].val));
8990 #endif
8991  (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (2)].val), Qnil, escape_Qundef((yyvsp[(2) - (2)].val)));
8992 
8993  }
8994  break;
8995 
8996  case 379:
8997 
8998 /* Line 1806 of yacc.c */
8999 #line 3430 "ripper.y"
9000  {
9001 #if 0
9002  (yyval.val) = new_args(0, 0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9003 #endif
9004  (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
9005 
9006  }
9007  break;
9008 
9009  case 380:
9010 
9011 /* Line 1806 of yacc.c */
9012 #line 3438 "ripper.y"
9013  {
9014 #if 0
9015  (yyval.val) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].val));
9016 #endif
9017  (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, (yyvsp[(1) - (1)].val));
9018 
9019  }
9020  break;
9021 
9022  case 382:
9023 
9024 /* Line 1806 of yacc.c */
9025 #line 3449 "ripper.y"
9026  {
9027  command_start = TRUE;
9028  }
9029  break;
9030 
9031  case 383:
9032 
9033 /* Line 1806 of yacc.c */
9034 #line 3455 "ripper.y"
9035  {
9036 #if 0
9037  (yyval.val) = 0;
9038 #endif
9039  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
9040  escape_Qundef((yyvsp[(2) - (3)].val)));
9041 
9042  }
9043  break;
9044 
9045  case 384:
9046 
9047 /* Line 1806 of yacc.c */
9048 #line 3464 "ripper.y"
9049  {
9050 #if 0
9051  (yyval.val) = 0;
9052 #endif
9053  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
9054  Qnil);
9055 
9056  }
9057  break;
9058 
9059  case 385:
9060 
9061 /* Line 1806 of yacc.c */
9062 #line 3473 "ripper.y"
9063  {
9064 #if 0
9065  (yyval.val) = (yyvsp[(2) - (4)].val);
9066 #endif
9067  (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
9068 
9069  }
9070  break;
9071 
9072  case 387:
9073 
9074 /* Line 1806 of yacc.c */
9075 #line 3485 "ripper.y"
9076  {
9077 #if 0
9078  (yyval.val) = 0;
9079 #endif
9080  (yyval.val) = (yyvsp[(2) - (2)].val);
9081 
9082  }
9083  break;
9084 
9085  case 388:
9086 
9087 /* Line 1806 of yacc.c */
9088 #line 3497 "ripper.y"
9089  {
9090  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9091  }
9092  break;
9093 
9094  case 389:
9095 
9096 /* Line 1806 of yacc.c */
9097 #line 3504 "ripper.y"
9098  {
9099  rb_ary_push((yyval.val), (yyvsp[(3) - (3)].val));
9100  }
9101  break;
9102 
9103  case 390:
9104 
9105 /* Line 1806 of yacc.c */
9106 #line 3511 "ripper.y"
9107  {
9108  new_bv(get_id((yyvsp[(1) - (1)].val)));
9109 #if 0
9110 #endif
9111  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
9112 
9113  }
9114  break;
9115 
9116  case 391:
9117 
9118 /* Line 1806 of yacc.c */
9119 #line 3519 "ripper.y"
9120  {
9121  (yyval.val) = 0;
9122  }
9123  break;
9124 
9125  case 392:
9126 
9127 /* Line 1806 of yacc.c */
9128 #line 3524 "ripper.y"
9129  {
9130  (yyval.vars) = dyna_push();
9131  }
9132  break;
9133 
9134  case 393:
9135 
9136 /* Line 1806 of yacc.c */
9137 #line 3527 "ripper.y"
9138  {
9139  (yyval.num) = lpar_beg;
9140  lpar_beg = ++paren_nest;
9141  }
9142  break;
9143 
9144  case 394:
9145 
9146 /* Line 1806 of yacc.c */
9147 #line 3533 "ripper.y"
9148  {
9149  lpar_beg = (yyvsp[(2) - (4)].num);
9150 #if 0
9151  (yyval.val) = (yyvsp[(3) - (4)].val);
9152  (yyval.val)->nd_body = NEW_SCOPE((yyvsp[(3) - (4)].val)->nd_head, (yyvsp[(4) - (4)].val));
9153 #endif
9154  (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9155 
9156  dyna_pop((yyvsp[(1) - (4)].vars));
9157  }
9158  break;
9159 
9160  case 395:
9161 
9162 /* Line 1806 of yacc.c */
9163 #line 3546 "ripper.y"
9164  {
9165 #if 0
9166  (yyval.val) = NEW_LAMBDA((yyvsp[(2) - (4)].val));
9167 #endif
9168  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
9169 
9170  }
9171  break;
9172 
9173  case 396:
9174 
9175 /* Line 1806 of yacc.c */
9176 #line 3554 "ripper.y"
9177  {
9178 #if 0
9179  (yyval.val) = NEW_LAMBDA((yyvsp[(1) - (1)].val));
9180 #endif
9181  (yyval.val) = (yyvsp[(1) - (1)].val);
9182 
9183  }
9184  break;
9185 
9186  case 397:
9187 
9188 /* Line 1806 of yacc.c */
9189 #line 3564 "ripper.y"
9190  {
9191  (yyval.val) = (yyvsp[(2) - (3)].val);
9192  }
9193  break;
9194 
9195  case 398:
9196 
9197 /* Line 1806 of yacc.c */
9198 #line 3568 "ripper.y"
9199  {
9200  (yyval.val) = (yyvsp[(2) - (3)].val);
9201  }
9202  break;
9203 
9204  case 399:
9205 
9206 /* Line 1806 of yacc.c */
9207 #line 3574 "ripper.y"
9208  {
9209  (yyvsp[(1) - (1)].vars) = dyna_push();
9210 #if 0
9211  (yyval.num) = ruby_sourceline;
9212 #endif
9213  }
9214  break;
9215 
9216  case 400:
9217 
9218 /* Line 1806 of yacc.c */
9219 #line 3583 "ripper.y"
9220  {
9221 #if 0
9222  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9223  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9224 #endif
9225  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9226 
9227  dyna_pop((yyvsp[(1) - (5)].vars));
9228  }
9229  break;
9230 
9231  case 401:
9232 
9233 /* Line 1806 of yacc.c */
9234 #line 3595 "ripper.y"
9235  {
9236 #if 0
9237  if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
9238  compile_error(PARSER_ARG "block given to yield");
9239  }
9240  else {
9241  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
9242  }
9243  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
9244  (yyval.val) = (yyvsp[(2) - (2)].val);
9245  fixpos((yyval.val), (yyvsp[(1) - (2)].val));
9246 #endif
9247  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9248 
9249  }
9250  break;
9251 
9252  case 402:
9253 
9254 /* Line 1806 of yacc.c */
9255 #line 3611 "ripper.y"
9256  {
9257 #if 0
9258  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9259 #endif
9260  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
9261  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9262 
9263  }
9264  break;
9265 
9266  case 403:
9267 
9268 /* Line 1806 of yacc.c */
9269 #line 3620 "ripper.y"
9270  {
9271 #if 0
9272  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9273 #endif
9274  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val));
9275  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9276 
9277  }
9278  break;
9279 
9280  case 404:
9281 
9282 /* Line 1806 of yacc.c */
9283 #line 3631 "ripper.y"
9284  {
9285 #if 0
9286  (yyval.val) = NEW_FCALL((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9287  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
9288 #endif
9289  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
9290 
9291  }
9292  break;
9293 
9294  case 405:
9295 
9296 /* Line 1806 of yacc.c */
9297 #line 3640 "ripper.y"
9298  {
9299 #if 0
9300  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9301  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
9302 #endif
9303  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
9304  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9305 
9306  }
9307  break;
9308 
9309  case 406:
9310 
9311 /* Line 1806 of yacc.c */
9312 #line 3650 "ripper.y"
9313  {
9314 #if 0
9315  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9316  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
9317 #endif
9318  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
9319  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9320 
9321  }
9322  break;
9323 
9324  case 407:
9325 
9326 /* Line 1806 of yacc.c */
9327 #line 3660 "ripper.y"
9328  {
9329 #if 0
9330  (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
9331 #endif
9332  (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
9333 
9334  }
9335  break;
9336 
9337  case 408:
9338 
9339 /* Line 1806 of yacc.c */
9340 #line 3668 "ripper.y"
9341  {
9342 #if 0
9343  (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), rb_intern("call"), (yyvsp[(3) - (3)].val));
9344  fixpos((yyval.val), (yyvsp[(1) - (3)].val));
9345 #endif
9346  (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_id2sym('.'),
9347  ripper_intern("call"));
9348  (yyval.val) = method_optarg((yyval.val), (yyvsp[(3) - (3)].val));
9349 
9350  }
9351  break;
9352 
9353  case 409:
9354 
9355 /* Line 1806 of yacc.c */
9356 #line 3679 "ripper.y"
9357  {
9358 #if 0
9359  (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), rb_intern("call"), (yyvsp[(3) - (3)].val));
9360  fixpos((yyval.val), (yyvsp[(1) - (3)].val));
9361 #endif
9362  (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"),
9363  ripper_intern("call"));
9364  (yyval.val) = method_optarg((yyval.val), (yyvsp[(3) - (3)].val));
9365 
9366  }
9367  break;
9368 
9369  case 410:
9370 
9371 /* Line 1806 of yacc.c */
9372 #line 3690 "ripper.y"
9373  {
9374 #if 0
9375  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
9376 #endif
9377  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
9378 
9379  }
9380  break;
9381 
9382  case 411:
9383 
9384 /* Line 1806 of yacc.c */
9385 #line 3698 "ripper.y"
9386  {
9387 #if 0
9388  (yyval.val) = NEW_ZSUPER();
9389 #endif
9390  (yyval.val) = dispatch0(zsuper);
9391 
9392  }
9393  break;
9394 
9395  case 412:
9396 
9397 /* Line 1806 of yacc.c */
9398 #line 3706 "ripper.y"
9399  {
9400 #if 0
9401  if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
9402  (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val));
9403  else
9404  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val));
9405  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
9406 #endif
9407  (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
9408 
9409  }
9410  break;
9411 
9412  case 413:
9413 
9414 /* Line 1806 of yacc.c */
9415 #line 3720 "ripper.y"
9416  {
9417  (yyvsp[(1) - (1)].vars) = dyna_push();
9418 #if 0
9419  (yyval.num) = ruby_sourceline;
9420 #endif
9421 
9422  }
9423  break;
9424 
9425  case 414:
9426 
9427 /* Line 1806 of yacc.c */
9428 #line 3729 "ripper.y"
9429  {
9430 #if 0
9431  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9432  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9433 #endif
9434  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9435 
9436  dyna_pop((yyvsp[(1) - (5)].vars));
9437  }
9438  break;
9439 
9440  case 415:
9441 
9442 /* Line 1806 of yacc.c */
9443 #line 3739 "ripper.y"
9444  {
9445  (yyvsp[(1) - (1)].vars) = dyna_push();
9446 #if 0
9447  (yyval.num) = ruby_sourceline;
9448 #endif
9449 
9450  }
9451  break;
9452 
9453  case 416:
9454 
9455 /* Line 1806 of yacc.c */
9456 #line 3748 "ripper.y"
9457  {
9458 #if 0
9459  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9460  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9461 #endif
9462  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9463 
9464  dyna_pop((yyvsp[(1) - (5)].vars));
9465  }
9466  break;
9467 
9468  case 417:
9469 
9470 /* Line 1806 of yacc.c */
9471 #line 3762 "ripper.y"
9472  {
9473 #if 0
9474  (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9475 #endif
9476  (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
9477 
9478  }
9479  break;
9480 
9481  case 420:
9482 
9483 /* Line 1806 of yacc.c */
9484 #line 3778 "ripper.y"
9485  {
9486 #if 0
9487  if ((yyvsp[(3) - (6)].val)) {
9488  (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO());
9489  (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
9490  }
9491  (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9492  fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
9493 #endif
9494  (yyval.val) = dispatch4(rescue,
9495  escape_Qundef((yyvsp[(2) - (6)].val)),
9496  escape_Qundef((yyvsp[(3) - (6)].val)),
9497  escape_Qundef((yyvsp[(5) - (6)].val)),
9498  escape_Qundef((yyvsp[(6) - (6)].val)));
9499 
9500  }
9501  break;
9502 
9503  case 422:
9504 
9505 /* Line 1806 of yacc.c */
9506 #line 3798 "ripper.y"
9507  {
9508 #if 0
9509  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
9510 #endif
9511  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9512 
9513  }
9514  break;
9515 
9516  case 423:
9517 
9518 /* Line 1806 of yacc.c */
9519 #line 3806 "ripper.y"
9520  {
9521 #if 0
9522  if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
9523 #endif
9524  (yyval.val) = (yyvsp[(1) - (1)].val);
9525 
9526  }
9527  break;
9528 
9529  case 425:
9530 
9531 /* Line 1806 of yacc.c */
9532 #line 3817 "ripper.y"
9533  {
9534  (yyval.val) = (yyvsp[(2) - (2)].val);
9535  }
9536  break;
9537 
9538  case 427:
9539 
9540 /* Line 1806 of yacc.c */
9541 #line 3824 "ripper.y"
9542  {
9543 #if 0
9544  (yyval.val) = (yyvsp[(2) - (2)].val);
9545 #endif
9546  (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
9547 
9548  }
9549  break;
9550 
9551  case 430:
9552 
9553 /* Line 1806 of yacc.c */
9554 #line 3836 "ripper.y"
9555  {
9556 #if 0
9557  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
9558 #endif
9559  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
9560 
9561  }
9562  break;
9563 
9564  case 432:
9565 
9566 /* Line 1806 of yacc.c */
9567 #line 3847 "ripper.y"
9568  {
9569 #if 0
9570  NODE *node = (yyvsp[(1) - (1)].val);
9571  if (!node) {
9572  node = NEW_STR(STR_NEW0());
9573  }
9574  else {
9575  node = evstr2dstr(node);
9576  }
9577  (yyval.val) = node;
9578 #endif
9579  (yyval.val) = (yyvsp[(1) - (1)].val);
9580 
9581  }
9582  break;
9583 
9584  case 435:
9585 
9586 /* Line 1806 of yacc.c */
9587 #line 3866 "ripper.y"
9588  {
9589 #if 0
9590  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9591 #endif
9592  (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9593 
9594  }
9595  break;
9596 
9597  case 436:
9598 
9599 /* Line 1806 of yacc.c */
9600 #line 3876 "ripper.y"
9601  {
9602 #if 0
9603  (yyval.val) = (yyvsp[(2) - (3)].val);
9604 #endif
9605  (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val));
9606 
9607  }
9608  break;
9609 
9610  case 437:
9611 
9612 /* Line 1806 of yacc.c */
9613 #line 3886 "ripper.y"
9614  {
9615 #if 0
9616  NODE *node = (yyvsp[(2) - (3)].val);
9617  if (!node) {
9618  node = NEW_XSTR(STR_NEW0());
9619  }
9620  else {
9621  switch (nd_type(node)) {
9622  case NODE_STR:
9623  nd_set_type(node, NODE_XSTR);
9624  break;
9625  case NODE_DSTR:
9626  nd_set_type(node, NODE_DXSTR);
9627  break;
9628  default:
9629  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
9630  break;
9631  }
9632  }
9633  (yyval.val) = node;
9634 #endif
9635  (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val));
9636 
9637  }
9638  break;
9639 
9640  case 438:
9641 
9642 /* Line 1806 of yacc.c */
9643 #line 3913 "ripper.y"
9644  {
9645 #if 0
9646  int options = (yyvsp[(3) - (3)].val);
9647  NODE *node = (yyvsp[(2) - (3)].val);
9648  NODE *list, *prev;
9649  if (!node) {
9650  node = NEW_LIT(reg_compile(STR_NEW0(), options));
9651  }
9652  else switch (nd_type(node)) {
9653  case NODE_STR:
9654  {
9655  VALUE src = node->nd_lit;
9656  nd_set_type(node, NODE_LIT);
9657  node->nd_lit = reg_compile(src, options);
9658  }
9659  break;
9660  default:
9661  node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
9662  case NODE_DSTR:
9663  if (options & RE_OPTION_ONCE) {
9665  }
9666  else {
9667  nd_set_type(node, NODE_DREGX);
9668  }
9669  node->nd_cflag = options & RE_OPTION_MASK;
9670  if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
9671  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
9672  if (nd_type(list->nd_head) == NODE_STR) {
9673  VALUE tail = list->nd_head->nd_lit;
9674  if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
9675  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
9676  if (!literal_concat0(parser, lit, tail)) {
9677  node = 0;
9678  break;
9679  }
9680  rb_str_resize(tail, 0);
9681  prev->nd_next = list->nd_next;
9682  rb_gc_force_recycle((VALUE)list->nd_head);
9683  rb_gc_force_recycle((VALUE)list);
9684  list = prev;
9685  }
9686  else {
9687  prev = list;
9688  }
9689  }
9690  else {
9691  prev = 0;
9692  }
9693  }
9694  if (!node->nd_next) {
9695  VALUE src = node->nd_lit;
9696  nd_set_type(node, NODE_LIT);
9697  node->nd_lit = reg_compile(src, options);
9698  }
9699  break;
9700  }
9701  (yyval.val) = node;
9702 #endif
9703  (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
9704 
9705  }
9706  break;
9707 
9708  case 439:
9709 
9710 /* Line 1806 of yacc.c */
9711 #line 3978 "ripper.y"
9712  {
9713 #if 0
9714  (yyval.val) = NEW_ZARRAY();
9715 #endif
9716  (yyval.val) = dispatch0(words_new);
9717  (yyval.val) = dispatch1(array, (yyval.val));
9718 
9719  }
9720  break;
9721 
9722  case 440:
9723 
9724 /* Line 1806 of yacc.c */
9725 #line 3987 "ripper.y"
9726  {
9727 #if 0
9728  (yyval.val) = (yyvsp[(2) - (3)].val);
9729 #endif
9730  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9731 
9732  }
9733  break;
9734 
9735  case 441:
9736 
9737 /* Line 1806 of yacc.c */
9738 #line 3997 "ripper.y"
9739  {
9740 #if 0
9741  (yyval.val) = 0;
9742 #endif
9743  (yyval.val) = dispatch0(words_new);
9744 
9745  }
9746  break;
9747 
9748  case 442:
9749 
9750 /* Line 1806 of yacc.c */
9751 #line 4005 "ripper.y"
9752  {
9753 #if 0
9754  (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
9755 #endif
9756  (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9757 
9758  }
9759  break;
9760 
9761  case 443:
9762 
9763 /* Line 1806 of yacc.c */
9764 #line 4017 "ripper.y"
9765  {
9766  (yyval.val) = dispatch0(word_new);
9767  (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
9768  }
9769  break;
9770 
9771  case 444:
9772 
9773 /* Line 1806 of yacc.c */
9774 #line 4023 "ripper.y"
9775  {
9776 #if 0
9777  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9778 #endif
9779  (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9780 
9781  }
9782  break;
9783 
9784  case 445:
9785 
9786 /* Line 1806 of yacc.c */
9787 #line 4033 "ripper.y"
9788  {
9789 #if 0
9790  (yyval.val) = NEW_ZARRAY();
9791 #endif
9792  (yyval.val) = dispatch0(qwords_new);
9793  (yyval.val) = dispatch1(array, (yyval.val));
9794 
9795  }
9796  break;
9797 
9798  case 446:
9799 
9800 /* Line 1806 of yacc.c */
9801 #line 4042 "ripper.y"
9802  {
9803 #if 0
9804  (yyval.val) = (yyvsp[(2) - (3)].val);
9805 #endif
9806  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9807 
9808  }
9809  break;
9810 
9811  case 447:
9812 
9813 /* Line 1806 of yacc.c */
9814 #line 4052 "ripper.y"
9815  {
9816 #if 0
9817  (yyval.val) = 0;
9818 #endif
9819  (yyval.val) = dispatch0(qwords_new);
9820 
9821  }
9822  break;
9823 
9824  case 448:
9825 
9826 /* Line 1806 of yacc.c */
9827 #line 4060 "ripper.y"
9828  {
9829 #if 0
9830  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9831 #endif
9832  (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9833 
9834  }
9835  break;
9836 
9837  case 449:
9838 
9839 /* Line 1806 of yacc.c */
9840 #line 4070 "ripper.y"
9841  {
9842 #if 0
9843  (yyval.val) = 0;
9844 #endif
9845  (yyval.val) = dispatch0(string_content);
9846 
9847  }
9848  break;
9849 
9850  case 450:
9851 
9852 /* Line 1806 of yacc.c */
9853 #line 4078 "ripper.y"
9854  {
9855 #if 0
9856  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9857 #endif
9858  (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9859 
9860  }
9861  break;
9862 
9863  case 451:
9864 
9865 /* Line 1806 of yacc.c */
9866 #line 4088 "ripper.y"
9867  {
9868 #if 0
9869  (yyval.val) = 0;
9870 #endif
9871  (yyval.val) = dispatch0(xstring_new);
9872 
9873  }
9874  break;
9875 
9876  case 452:
9877 
9878 /* Line 1806 of yacc.c */
9879 #line 4096 "ripper.y"
9880  {
9881 #if 0
9882  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9883 #endif
9884  (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9885 
9886  }
9887  break;
9888 
9889  case 453:
9890 
9891 /* Line 1806 of yacc.c */
9892 #line 4106 "ripper.y"
9893  {
9894 #if 0
9895  (yyval.val) = 0;
9896 #endif
9897  (yyval.val) = dispatch0(regexp_new);
9898 
9899  }
9900  break;
9901 
9902  case 454:
9903 
9904 /* Line 1806 of yacc.c */
9905 #line 4114 "ripper.y"
9906  {
9907 #if 0
9908  NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
9909  if (!head) {
9910  (yyval.val) = tail;
9911  }
9912  else if (!tail) {
9913  (yyval.val) = head;
9914  }
9915  else {
9916  switch (nd_type(head)) {
9917  case NODE_STR:
9918  nd_set_type(head, NODE_DSTR);
9919  break;
9920  case NODE_DSTR:
9921  break;
9922  default:
9923  head = list_append(NEW_DSTR(Qnil), head);
9924  break;
9925  }
9926  (yyval.val) = list_append(head, tail);
9927  }
9928 #endif
9929  (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9930 
9931  }
9932  break;
9933 
9934  case 456:
9935 
9936 /* Line 1806 of yacc.c */
9937 #line 4144 "ripper.y"
9938  {
9939  (yyval.node) = lex_strterm;
9940  lex_strterm = 0;
9941  lex_state = EXPR_BEG;
9942  }
9943  break;
9944 
9945  case 457:
9946 
9947 /* Line 1806 of yacc.c */
9948 #line 4150 "ripper.y"
9949  {
9950 #if 0
9951  lex_strterm = (yyvsp[(2) - (3)].node);
9952  (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
9953 #endif
9954  lex_strterm = (yyvsp[(2) - (3)].node);
9955  (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
9956 
9957  }
9958  break;
9959 
9960  case 458:
9961 
9962 /* Line 1806 of yacc.c */
9963 #line 4160 "ripper.y"
9964  {
9965  (yyvsp[(1) - (1)].val) = cond_stack;
9966  (yyval.val) = cmdarg_stack;
9967  cond_stack = 0;
9968  cmdarg_stack = 0;
9969  }
9970  break;
9971 
9972  case 459:
9973 
9974 /* Line 1806 of yacc.c */
9975 #line 4166 "ripper.y"
9976  {
9977  (yyval.node) = lex_strterm;
9978  lex_strterm = 0;
9979  lex_state = EXPR_BEG;
9980  }
9981  break;
9982 
9983  case 460:
9984 
9985 /* Line 1806 of yacc.c */
9986 #line 4172 "ripper.y"
9987  {
9988  cond_stack = (yyvsp[(1) - (5)].val);
9989  cmdarg_stack = (yyvsp[(2) - (5)].val);
9990  lex_strterm = (yyvsp[(3) - (5)].node);
9991 #if 0
9992  if ((yyvsp[(4) - (5)].val)) (yyvsp[(4) - (5)].val)->flags &= ~NODE_FL_NEWLINE;
9993  (yyval.val) = new_evstr((yyvsp[(4) - (5)].val));
9994 #endif
9995  (yyval.val) = dispatch1(string_embexpr, (yyvsp[(4) - (5)].val));
9996 
9997  }
9998  break;
9999 
10000  case 461:
10001 
10002 /* Line 1806 of yacc.c */
10003 #line 4186 "ripper.y"
10004  {
10005 #if 0
10006  (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
10007 #endif
10008  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10009 
10010  }
10011  break;
10012 
10013  case 462:
10014 
10015 /* Line 1806 of yacc.c */
10016 #line 4194 "ripper.y"
10017  {
10018 #if 0
10019  (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
10020 #endif
10021  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10022 
10023  }
10024  break;
10025 
10026  case 463:
10027 
10028 /* Line 1806 of yacc.c */
10029 #line 4202 "ripper.y"
10030  {
10031 #if 0
10032  (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
10033 #endif
10034  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10035 
10036  }
10037  break;
10038 
10039  case 465:
10040 
10041 /* Line 1806 of yacc.c */
10042 #line 4213 "ripper.y"
10043  {
10044  lex_state = EXPR_END;
10045 #if 0
10046  (yyval.val) = (yyvsp[(2) - (2)].val);
10047 #endif
10048  (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
10049 
10050  }
10051  break;
10052 
10053  case 470:
10054 
10055 /* Line 1806 of yacc.c */
10056 #line 4230 "ripper.y"
10057  {
10058  lex_state = EXPR_END;
10059 #if 0
10060  if (!((yyval.val) = (yyvsp[(2) - (3)].val))) {
10061  (yyval.val) = NEW_LIT(ID2SYM(rb_intern("")));
10062  }
10063  else {
10064  VALUE lit;
10065 
10066  switch (nd_type((yyval.val))) {
10067  case NODE_DSTR:
10068  nd_set_type((yyval.val), NODE_DSYM);
10069  break;
10070  case NODE_STR:
10071  lit = (yyval.val)->nd_lit;
10072  (yyval.val)->nd_lit = ID2SYM(rb_intern_str(lit));
10073  nd_set_type((yyval.val), NODE_LIT);
10074  break;
10075  default:
10076  (yyval.val) = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST((yyval.val)));
10077  break;
10078  }
10079  }
10080 #endif
10081  (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
10082 
10083  }
10084  break;
10085 
10086  case 473:
10087 
10088 /* Line 1806 of yacc.c */
10089 #line 4262 "ripper.y"
10090  {
10091 #if 0
10092  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10093 #endif
10094  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10095 
10096  }
10097  break;
10098 
10099  case 474:
10100 
10101 /* Line 1806 of yacc.c */
10102 #line 4270 "ripper.y"
10103  {
10104 #if 0
10105  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10106 #endif
10107  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10108 
10109  }
10110  break;
10111 
10112  case 480:
10113 
10114 /* Line 1806 of yacc.c */
10115 #line 4286 "ripper.y"
10116  {ifndef_ripper((yyval.val) = keyword_nil);}
10117  break;
10118 
10119  case 481:
10120 
10121 /* Line 1806 of yacc.c */
10122 #line 4287 "ripper.y"
10123  {ifndef_ripper((yyval.val) = keyword_self);}
10124  break;
10125 
10126  case 482:
10127 
10128 /* Line 1806 of yacc.c */
10129 #line 4288 "ripper.y"
10130  {ifndef_ripper((yyval.val) = keyword_true);}
10131  break;
10132 
10133  case 483:
10134 
10135 /* Line 1806 of yacc.c */
10136 #line 4289 "ripper.y"
10137  {ifndef_ripper((yyval.val) = keyword_false);}
10138  break;
10139 
10140  case 484:
10141 
10142 /* Line 1806 of yacc.c */
10143 #line 4290 "ripper.y"
10144  {ifndef_ripper((yyval.val) = keyword__FILE__);}
10145  break;
10146 
10147  case 485:
10148 
10149 /* Line 1806 of yacc.c */
10150 #line 4291 "ripper.y"
10151  {ifndef_ripper((yyval.val) = keyword__LINE__);}
10152  break;
10153 
10154  case 486:
10155 
10156 /* Line 1806 of yacc.c */
10157 #line 4292 "ripper.y"
10158  {ifndef_ripper((yyval.val) = keyword__ENCODING__);}
10159  break;
10160 
10161  case 487:
10162 
10163 /* Line 1806 of yacc.c */
10164 #line 4296 "ripper.y"
10165  {
10166 #if 0
10167  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10168 #endif
10169  if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) {
10170  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10171  }
10172  else {
10173  (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val));
10174  }
10175 
10176  }
10177  break;
10178 
10179  case 488:
10180 
10181 /* Line 1806 of yacc.c */
10182 #line 4309 "ripper.y"
10183  {
10184 #if 0
10185  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10186 #endif
10187  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10188 
10189  }
10190  break;
10191 
10192  case 489:
10193 
10194 /* Line 1806 of yacc.c */
10195 #line 4319 "ripper.y"
10196  {
10197  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10198 #if 0
10199 #endif
10200  (yyval.val) = dispatch1(var_field, (yyval.val));
10201 
10202  }
10203  break;
10204 
10205  case 490:
10206 
10207 /* Line 1806 of yacc.c */
10208 #line 4327 "ripper.y"
10209  {
10210  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10211 #if 0
10212 #endif
10213  (yyval.val) = dispatch1(var_field, (yyval.val));
10214 
10215  }
10216  break;
10217 
10218  case 493:
10219 
10220 /* Line 1806 of yacc.c */
10221 #line 4341 "ripper.y"
10222  {
10223 #if 0
10224  (yyval.val) = 0;
10225 #endif
10226  (yyval.val) = Qnil;
10227 
10228  }
10229  break;
10230 
10231  case 494:
10232 
10233 /* Line 1806 of yacc.c */
10234 #line 4349 "ripper.y"
10235  {
10236  lex_state = EXPR_BEG;
10237  }
10238  break;
10239 
10240  case 495:
10241 
10242 /* Line 1806 of yacc.c */
10243 #line 4353 "ripper.y"
10244  {
10245  (yyval.val) = (yyvsp[(3) - (4)].val);
10246  }
10247  break;
10248 
10249  case 496:
10250 
10251 /* Line 1806 of yacc.c */
10252 #line 4357 "ripper.y"
10253  {
10254 #if 0
10255  yyerrok;
10256  (yyval.val) = 0;
10257 #endif
10258  yyerrok;
10259  (yyval.val) = Qnil;
10260 
10261  }
10262  break;
10263 
10264  case 497:
10265 
10266 /* Line 1806 of yacc.c */
10267 #line 4369 "ripper.y"
10268  {
10269 #if 0
10270  (yyval.val) = (yyvsp[(2) - (3)].val);
10271 #endif
10272  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
10273 
10274  lex_state = EXPR_BEG;
10275  command_start = TRUE;
10276  }
10277  break;
10278 
10279  case 498:
10280 
10281 /* Line 1806 of yacc.c */
10282 #line 4379 "ripper.y"
10283  {
10284  (yyval.val) = (yyvsp[(1) - (2)].val);
10285  lex_state = EXPR_BEG;
10286  command_start = TRUE;
10287  }
10288  break;
10289 
10290  case 499:
10291 
10292 /* Line 1806 of yacc.c */
10293 #line 4387 "ripper.y"
10294  {
10295 #if 0
10296  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), 0, (yyvsp[(6) - (6)].val));
10297 #endif
10298  (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnil, escape_Qundef((yyvsp[(6) - (6)].val)));
10299 
10300  }
10301  break;
10302 
10303  case 500:
10304 
10305 /* Line 1806 of yacc.c */
10306 #line 4395 "ripper.y"
10307  {
10308 #if 0
10309  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10310 #endif
10311  (yyval.val) = params_new((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), escape_Qundef((yyvsp[(8) - (8)].val)));
10312 
10313  }
10314  break;
10315 
10316  case 501:
10317 
10318 /* Line 1806 of yacc.c */
10319 #line 4403 "ripper.y"
10320  {
10321 #if 0
10322  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, 0, (yyvsp[(4) - (4)].val));
10323 #endif
10324  (yyval.val) = params_new((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
10325 
10326  }
10327  break;
10328 
10329  case 502:
10330 
10331 /* Line 1806 of yacc.c */
10332 #line 4411 "ripper.y"
10333  {
10334 #if 0
10335  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), 0, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10336 #endif
10337  (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnil, (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
10338 
10339  }
10340  break;
10341 
10342  case 503:
10343 
10344 /* Line 1806 of yacc.c */
10345 #line 4419 "ripper.y"
10346  {
10347 #if 0
10348  (yyval.val) = new_args((yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
10349 #endif
10350  (yyval.val) = params_new((yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
10351 
10352  }
10353  break;
10354 
10355  case 504:
10356 
10357 /* Line 1806 of yacc.c */
10358 #line 4427 "ripper.y"
10359  {
10360 #if 0
10361  (yyval.val) = new_args((yyvsp[(1) - (6)].val), 0, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10362 #endif
10363  (yyval.val) = params_new((yyvsp[(1) - (6)].val), Qnil, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
10364 
10365  }
10366  break;
10367 
10368  case 505:
10369 
10370 /* Line 1806 of yacc.c */
10371 #line 4435 "ripper.y"
10372  {
10373 #if 0
10374  (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 0, 0, (yyvsp[(2) - (2)].val));
10375 #endif
10376  (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil, Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10377 
10378  }
10379  break;
10380 
10381  case 506:
10382 
10383 /* Line 1806 of yacc.c */
10384 #line 4443 "ripper.y"
10385  {
10386 #if 0
10387  (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
10388 #endif
10389  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
10390 
10391  }
10392  break;
10393 
10394  case 507:
10395 
10396 /* Line 1806 of yacc.c */
10397 #line 4451 "ripper.y"
10398  {
10399 #if 0
10400  (yyval.val) = new_args(0, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10401 #endif
10402  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
10403 
10404  }
10405  break;
10406 
10407  case 508:
10408 
10409 /* Line 1806 of yacc.c */
10410 #line 4459 "ripper.y"
10411  {
10412 #if 0
10413  (yyval.val) = new_args(0, (yyvsp[(1) - (2)].val), 0, 0, (yyvsp[(2) - (2)].val));
10414 #endif
10415  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (2)].val), Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10416 
10417  }
10418  break;
10419 
10420  case 509:
10421 
10422 /* Line 1806 of yacc.c */
10423 #line 4467 "ripper.y"
10424  {
10425 #if 0
10426  (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10427 #endif
10428  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
10429 
10430  }
10431  break;
10432 
10433  case 510:
10434 
10435 /* Line 1806 of yacc.c */
10436 #line 4475 "ripper.y"
10437  {
10438 #if 0
10439  (yyval.val) = new_args(0, 0, (yyvsp[(1) - (2)].val), 0, (yyvsp[(2) - (2)].val));
10440 #endif
10441  (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (2)].val), Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10442 
10443  }
10444  break;
10445 
10446  case 511:
10447 
10448 /* Line 1806 of yacc.c */
10449 #line 4483 "ripper.y"
10450  {
10451 #if 0
10452  (yyval.val) = new_args(0, 0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10453 #endif
10454  (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
10455 
10456  }
10457  break;
10458 
10459  case 512:
10460 
10461 /* Line 1806 of yacc.c */
10462 #line 4491 "ripper.y"
10463  {
10464 #if 0
10465  (yyval.val) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].val));
10466 #endif
10467  (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, (yyvsp[(1) - (1)].val));
10468 
10469  }
10470  break;
10471 
10472  case 513:
10473 
10474 /* Line 1806 of yacc.c */
10475 #line 4499 "ripper.y"
10476  {
10477 #if 0
10478  (yyval.val) = new_args(0, 0, 0, 0, 0);
10479 #endif
10480  (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, Qnil);
10481 
10482  }
10483  break;
10484 
10485  case 514:
10486 
10487 /* Line 1806 of yacc.c */
10488 #line 4509 "ripper.y"
10489  {
10490 #if 0
10491  yyerror("formal argument cannot be a constant");
10492  (yyval.val) = 0;
10493 #endif
10494  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10495 
10496  }
10497  break;
10498 
10499  case 515:
10500 
10501 /* Line 1806 of yacc.c */
10502 #line 4518 "ripper.y"
10503  {
10504 #if 0
10505  yyerror("formal argument cannot be an instance variable");
10506  (yyval.val) = 0;
10507 #endif
10508  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10509 
10510  }
10511  break;
10512 
10513  case 516:
10514 
10515 /* Line 1806 of yacc.c */
10516 #line 4527 "ripper.y"
10517  {
10518 #if 0
10519  yyerror("formal argument cannot be a global variable");
10520  (yyval.val) = 0;
10521 #endif
10522  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10523 
10524  }
10525  break;
10526 
10527  case 517:
10528 
10529 /* Line 1806 of yacc.c */
10530 #line 4536 "ripper.y"
10531  {
10532 #if 0
10533  yyerror("formal argument cannot be a class variable");
10534  (yyval.val) = 0;
10535 #endif
10536  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10537 
10538  }
10539  break;
10540 
10541  case 519:
10542 
10543 /* Line 1806 of yacc.c */
10544 #line 4548 "ripper.y"
10545  {
10546  formal_argument(get_id((yyvsp[(1) - (1)].val)));
10547  (yyval.val) = (yyvsp[(1) - (1)].val);
10548  }
10549  break;
10550 
10551  case 520:
10552 
10553 /* Line 1806 of yacc.c */
10554 #line 4555 "ripper.y"
10555  {
10556  arg_var(get_id((yyvsp[(1) - (1)].val)));
10557 #if 0
10558  (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10559 #endif
10560  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10561 
10562  }
10563  break;
10564 
10565  case 521:
10566 
10567 /* Line 1806 of yacc.c */
10568 #line 4564 "ripper.y"
10569  {
10570  ID tid = internal_id();
10571  arg_var(tid);
10572 #if 0
10573  if (dyna_in_block()) {
10574  (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10575  }
10576  else {
10577  (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10578  }
10579  (yyval.val) = NEW_ARGS_AUX(tid, 1);
10580  (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10581 #endif
10582  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10583 
10584  }
10585  break;
10586 
10587  case 522:
10588 
10589 /* Line 1806 of yacc.c */
10590 #line 4585 "ripper.y"
10591  {
10592  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10593  }
10594  break;
10595 
10596  case 523:
10597 
10598 /* Line 1806 of yacc.c */
10599 #line 4590 "ripper.y"
10600  {
10601 #if 0
10602  (yyval.val) = (yyvsp[(1) - (3)].val);
10603  (yyval.val)->nd_plen++;
10604  (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10605  rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10606 #endif
10607  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10608 
10609  }
10610  break;
10611 
10612  case 524:
10613 
10614 /* Line 1806 of yacc.c */
10615 #line 4603 "ripper.y"
10616  {
10617  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10618  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10619 #if 0
10620  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10621 #endif
10622  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10623 
10624  }
10625  break;
10626 
10627  case 525:
10628 
10629 /* Line 1806 of yacc.c */
10630 #line 4615 "ripper.y"
10631  {
10632  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10633  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10634 #if 0
10635  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10636 #endif
10637  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10638 
10639  }
10640  break;
10641 
10642  case 526:
10643 
10644 /* Line 1806 of yacc.c */
10645 #line 4627 "ripper.y"
10646  {
10647 #if 0
10648  (yyval.val) = (yyvsp[(1) - (1)].val);
10649 #endif
10650  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10651 
10652  }
10653  break;
10654 
10655  case 527:
10656 
10657 /* Line 1806 of yacc.c */
10658 #line 4635 "ripper.y"
10659  {
10660 #if 0
10661  NODE *opts = (yyvsp[(1) - (3)].val);
10662 
10663  while (opts->nd_next) {
10664  opts = opts->nd_next;
10665  }
10666  opts->nd_next = (yyvsp[(3) - (3)].val);
10667  (yyval.val) = (yyvsp[(1) - (3)].val);
10668 #endif
10669  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10670 
10671  }
10672  break;
10673 
10674  case 528:
10675 
10676 /* Line 1806 of yacc.c */
10677 #line 4651 "ripper.y"
10678  {
10679 #if 0
10680  (yyval.val) = (yyvsp[(1) - (1)].val);
10681 #endif
10682  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10683 
10684  }
10685  break;
10686 
10687  case 529:
10688 
10689 /* Line 1806 of yacc.c */
10690 #line 4659 "ripper.y"
10691  {
10692 #if 0
10693  NODE *opts = (yyvsp[(1) - (3)].val);
10694 
10695  while (opts->nd_next) {
10696  opts = opts->nd_next;
10697  }
10698  opts->nd_next = (yyvsp[(3) - (3)].val);
10699  (yyval.val) = (yyvsp[(1) - (3)].val);
10700 #endif
10701  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10702 
10703  }
10704  break;
10705 
10706  case 532:
10707 
10708 /* Line 1806 of yacc.c */
10709 #line 4679 "ripper.y"
10710  {
10711 #if 0
10712  if (!is_local_id((yyvsp[(2) - (2)].val)))
10713  yyerror("rest argument must be local variable");
10714 #endif
10715  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10716 #if 0
10717  (yyval.val) = (yyvsp[(2) - (2)].val);
10718 #endif
10719  (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
10720 
10721  }
10722  break;
10723 
10724  case 533:
10725 
10726 /* Line 1806 of yacc.c */
10727 #line 4692 "ripper.y"
10728  {
10729 #if 0
10730  (yyval.val) = internal_id();
10731  arg_var((yyval.val));
10732 #endif
10733  (yyval.val) = dispatch1(rest_param, Qnil);
10734 
10735  }
10736  break;
10737 
10738  case 536:
10739 
10740 /* Line 1806 of yacc.c */
10741 #line 4707 "ripper.y"
10742  {
10743 #if 0
10744  if (!is_local_id((yyvsp[(2) - (2)].val)))
10745  yyerror("block argument must be local variable");
10746  else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
10747  yyerror("duplicated block argument name");
10748 #endif
10749  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10750 #if 0
10751  (yyval.val) = (yyvsp[(2) - (2)].val);
10752 #endif
10753  (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
10754 
10755  }
10756  break;
10757 
10758  case 537:
10759 
10760 /* Line 1806 of yacc.c */
10761 #line 4724 "ripper.y"
10762  {
10763  (yyval.val) = (yyvsp[(2) - (2)].val);
10764  }
10765  break;
10766 
10767  case 538:
10768 
10769 /* Line 1806 of yacc.c */
10770 #line 4728 "ripper.y"
10771  {
10772 #if 0
10773  (yyval.val) = 0;
10774 #endif
10775  (yyval.val) = Qundef;
10776 
10777  }
10778  break;
10779 
10780  case 539:
10781 
10782 /* Line 1806 of yacc.c */
10783 #line 4738 "ripper.y"
10784  {
10785 #if 0
10786  value_expr((yyvsp[(1) - (1)].val));
10787  (yyval.val) = (yyvsp[(1) - (1)].val);
10788  if (!(yyval.val)) (yyval.val) = NEW_NIL();
10789 #endif
10790  (yyval.val) = (yyvsp[(1) - (1)].val);
10791 
10792  }
10793  break;
10794 
10795  case 540:
10796 
10797 /* Line 1806 of yacc.c */
10798 #line 4747 "ripper.y"
10799  {lex_state = EXPR_BEG;}
10800  break;
10801 
10802  case 541:
10803 
10804 /* Line 1806 of yacc.c */
10805 #line 4748 "ripper.y"
10806  {
10807 #if 0
10808  if ((yyvsp[(3) - (4)].val) == 0) {
10809  yyerror("can't define singleton method for ().");
10810  }
10811  else {
10812  switch (nd_type((yyvsp[(3) - (4)].val))) {
10813  case NODE_STR:
10814  case NODE_DSTR:
10815  case NODE_XSTR:
10816  case NODE_DXSTR:
10817  case NODE_DREGX:
10818  case NODE_LIT:
10819  case NODE_ARRAY:
10820  case NODE_ZARRAY:
10821  yyerror("can't define singleton method for literals");
10822  default:
10823  value_expr((yyvsp[(3) - (4)].val));
10824  break;
10825  }
10826  }
10827  (yyval.val) = (yyvsp[(3) - (4)].val);
10828 #endif
10829  (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
10830 
10831  }
10832  break;
10833 
10834  case 543:
10835 
10836 /* Line 1806 of yacc.c */
10837 #line 4778 "ripper.y"
10838  {
10839 #if 0
10840  (yyval.val) = (yyvsp[(1) - (2)].val);
10841 #endif
10842  (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
10843 
10844  }
10845  break;
10846 
10847  case 544:
10848 
10849 /* Line 1806 of yacc.c */
10850 #line 4790 "ripper.y"
10851  {
10852  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10853  }
10854  break;
10855 
10856  case 545:
10857 
10858 /* Line 1806 of yacc.c */
10859 #line 4795 "ripper.y"
10860  {
10861 #if 0
10862  (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10863 #endif
10864  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10865 
10866  }
10867  break;
10868 
10869  case 546:
10870 
10871 /* Line 1806 of yacc.c */
10872 #line 4805 "ripper.y"
10873  {
10874 #if 0
10875  (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
10876 #endif
10877  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10878 
10879  }
10880  break;
10881 
10882  case 547:
10883 
10884 /* Line 1806 of yacc.c */
10885 #line 4813 "ripper.y"
10886  {
10887 #if 0
10888  (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
10889 #endif
10890  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10891 
10892  }
10893  break;
10894 
10895  case 558:
10896 
10897 /* Line 1806 of yacc.c */
10898 #line 4841 "ripper.y"
10899  { (yyval.val) = (yyvsp[(1) - (1)].val); }
10900  break;
10901 
10902  case 559:
10903 
10904 /* Line 1806 of yacc.c */
10905 #line 4846 "ripper.y"
10906  { (yyval.val) = (yyvsp[(1) - (1)].val); }
10907  break;
10908 
10909  case 569:
10910 
10911 /* Line 1806 of yacc.c */
10912 #line 4869 "ripper.y"
10913  {yyerrok;}
10914  break;
10915 
10916  case 572:
10917 
10918 /* Line 1806 of yacc.c */
10919 #line 4874 "ripper.y"
10920  {yyerrok;}
10921  break;
10922 
10923  case 573:
10924 
10925 /* Line 1806 of yacc.c */
10926 #line 4878 "ripper.y"
10927  {
10928 #if 0
10929  (yyval.val) = 0;
10930 #endif
10931  (yyval.val) = Qundef;
10932 
10933  }
10934  break;
10935 
10936 
10937 
10938 /* Line 1806 of yacc.c */
10939 #line 10938 "parse.c"
10940  default: break;
10941  }
10942  /* User semantic actions sometimes alter yychar, and that requires
10943  that yytoken be updated with the new translation. We take the
10944  approach of translating immediately before every use of yytoken.
10945  One alternative is translating here after every semantic action,
10946  but that translation would be missed if the semantic action invokes
10947  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
10948  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
10949  incorrect destructor might then be invoked immediately. In the
10950  case of YYERROR or YYBACKUP, subsequent parser actions might lead
10951  to an incorrect destructor call or verbose syntax error message
10952  before the lookahead is translated. */
10953  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
10954 
10955  YYPOPSTACK (yylen);
10956  yylen = 0;
10957  YY_STACK_PRINT (yyss, yyssp);
10958 
10959  *++yyvsp = yyval;
10960 
10961  /* Now `shift' the result of the reduction. Determine what state
10962  that goes to, based on the state we popped back to and the rule
10963  number reduced by. */
10964 
10965  yyn = yyr1[yyn];
10966 
10967  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
10968  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
10969  yystate = yytable[yystate];
10970  else
10971  yystate = yydefgoto[yyn - YYNTOKENS];
10972 
10973  goto yynewstate;
10974 
10975 
10976 /*------------------------------------.
10977 | yyerrlab -- here on detecting error |
10978 `------------------------------------*/
10979 yyerrlab:
10980  /* Make sure we have latest lookahead translation. See comments at
10981  user semantic actions for why this is necessary. */
10982  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
10983 
10984  /* If not already recovering from an error, report this error. */
10985  if (!yyerrstatus)
10986  {
10987  ++yynerrs;
10988 #if ! YYERROR_VERBOSE
10989  parser_yyerror (parser, YY_("syntax error"));
10990 #else
10991 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
10992  yyssp, yytoken)
10993  {
10994  char const *yymsgp = YY_("syntax error");
10995  int yysyntax_error_status;
10996  yysyntax_error_status = YYSYNTAX_ERROR;
10997  if (yysyntax_error_status == 0)
10998  yymsgp = yymsg;
10999  else if (yysyntax_error_status == 1)
11000  {
11001  if (yymsg != yymsgbuf)
11002  YYSTACK_FREE (yymsg);
11003  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11004  if (!yymsg)
11005  {
11006  yymsg = yymsgbuf;
11007  yymsg_alloc = sizeof yymsgbuf;
11008  yysyntax_error_status = 2;
11009  }
11010  else
11011  {
11012  yysyntax_error_status = YYSYNTAX_ERROR;
11013  yymsgp = yymsg;
11014  }
11015  }
11016  parser_yyerror (parser, yymsgp);
11017  if (yysyntax_error_status == 2)
11018  goto yyexhaustedlab;
11019  }
11020 # undef YYSYNTAX_ERROR
11021 #endif
11022  }
11023 
11024 
11025 
11026  if (yyerrstatus == 3)
11027  {
11028  /* If just tried and failed to reuse lookahead token after an
11029  error, discard it. */
11030 
11031  if (yychar <= YYEOF)
11032  {
11033  /* Return failure if at end of input. */
11034  if (yychar == YYEOF)
11035  YYABORT;
11036  }
11037  else
11038  {
11039  yydestruct ("Error: discarding",
11040  yytoken, &yylval, parser);
11041  yychar = YYEMPTY;
11042  }
11043  }
11044 
11045  /* Else will try to reuse lookahead token after shifting the error
11046  token. */
11048 
11049 
11050 /*---------------------------------------------------.
11051 | yyerrorlab -- error raised explicitly by YYERROR. |
11052 `---------------------------------------------------*/
11053 yyerrorlab:
11054 
11055  /* Pacify compilers like GCC when the user code never invokes
11056  YYERROR and the label yyerrorlab therefore never appears in user
11057  code. */
11058  if (/*CONSTCOND*/ 0)
11059  goto yyerrorlab;
11060 
11061  /* Do not reclaim the symbols of the rule which action triggered
11062  this YYERROR. */
11063  YYPOPSTACK (yylen);
11064  yylen = 0;
11065  YY_STACK_PRINT (yyss, yyssp);
11066  yystate = *yyssp;
11067  goto yyerrlab1;
11068 
11069 
11070 /*-------------------------------------------------------------.
11071 | yyerrlab1 -- common code for both syntax error and YYERROR. |
11072 `-------------------------------------------------------------*/
11073 yyerrlab1:
11074  yyerrstatus = 3; /* Each real token shifted decrements this. */
11075 
11076  for (;;)
11077  {
11078  yyn = yypact[yystate];
11079  if (!yypact_value_is_default (yyn))
11080  {
11081  yyn += YYTERROR;
11082  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11083  {
11084  yyn = yytable[yyn];
11085  if (0 < yyn)
11086  break;
11087  }
11088  }
11089 
11090  /* Pop the current state because it cannot handle the error token. */
11091  if (yyssp == yyss)
11092  YYABORT;
11093 
11094 
11095  yydestruct ("Error: popping",
11096  yystos[yystate], yyvsp, parser);
11097  YYPOPSTACK (1);
11098  yystate = *yyssp;
11099  YY_STACK_PRINT (yyss, yyssp);
11100  }
11101 
11102  *++yyvsp = yylval;
11103 
11104 
11105  /* Shift the error token. */
11106  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11107 
11108  yystate = yyn;
11109  goto yynewstate;
11110 
11111 
11112 /*-------------------------------------.
11113 | yyacceptlab -- YYACCEPT comes here. |
11114 `-------------------------------------*/
11115 yyacceptlab:
11116  yyresult = 0;
11117  goto yyreturn;
11118 
11119 /*-----------------------------------.
11120 | yyabortlab -- YYABORT comes here. |
11121 `-----------------------------------*/
11122 yyabortlab:
11123  yyresult = 1;
11124  goto yyreturn;
11125 
11126 #if !defined(yyoverflow) || YYERROR_VERBOSE
11127 /*-------------------------------------------------.
11128 | yyexhaustedlab -- memory exhaustion comes here. |
11129 `-------------------------------------------------*/
11130 yyexhaustedlab:
11131  parser_yyerror (parser, YY_("memory exhausted"));
11132  yyresult = 2;
11133  /* Fall through. */
11134 #endif
11135 
11136 yyreturn:
11137  if (yychar != YYEMPTY)
11138  {
11139  /* Make sure we have latest lookahead translation. See comments at
11140  user semantic actions for why this is necessary. */
11141  yytoken = YYTRANSLATE (yychar);
11142  yydestruct ("Cleanup: discarding lookahead",
11143  yytoken, &yylval, parser);
11144  }
11145  /* Do not reclaim the symbols of the rule which action triggered
11146  this YYABORT or YYACCEPT. */
11147  YYPOPSTACK (yylen);
11148  YY_STACK_PRINT (yyss, yyssp);
11149  while (yyssp != yyss)
11150  {
11151  yydestruct ("Cleanup: popping",
11152  yystos[*yyssp], yyvsp, parser);
11153  YYPOPSTACK (1);
11154  }
11155 #ifndef yyoverflow
11156  if (yyss != yyssa)
11157  YYSTACK_FREE (yyss);
11158 #endif
11159 #if YYERROR_VERBOSE
11160  if (yymsg != yymsgbuf)
11161  YYSTACK_FREE (yymsg);
11162 #endif
11163  /* Make sure YYID is used. */
11164  return YYID (yyresult);
11165 }
11166 
11167 
11168 
11169 /* Line 2067 of yacc.c */
11170 #line 4886 "ripper.y"
11171 
11172 # undef parser
11173 # undef yylex
11174 # undef yylval
11175 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
11176 
11177 static int parser_regx_options(struct parser_params*);
11178 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11179 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11180 static int parser_parse_string(struct parser_params*,NODE*);
11181 static int parser_here_document(struct parser_params*,NODE*);
11182 
11183 
11184 # define nextc() parser_nextc(parser)
11185 # define pushback(c) parser_pushback(parser, (c))
11186 # define newtok() parser_newtok(parser)
11187 # define tokspace(n) parser_tokspace(parser, (n))
11188 # define tokadd(c) parser_tokadd(parser, (c))
11189 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
11190 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
11191 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
11192 # define regx_options() parser_regx_options(parser)
11193 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11194 # define parse_string(n) parser_parse_string(parser,(n))
11195 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
11196 # define here_document(n) parser_here_document(parser,(n))
11197 # define heredoc_identifier() parser_heredoc_identifier(parser)
11198 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
11199 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
11200 
11201 #ifndef RIPPER
11202 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11203 # define set_yylval_num(x) (yylval.num = (x))
11204 # define set_yylval_id(x) (yylval.id = (x))
11205 # define set_yylval_name(x) (yylval.id = (x))
11206 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11207 # define set_yylval_node(x) (yylval.node = (x))
11208 # define yylval_id() (yylval.id)
11209 #else
11210 static inline VALUE
11211 ripper_yylval_id(ID x)
11212 {
11213  return (VALUE)NEW_LASGN(x, ID2SYM(x));
11214 }
11215 # define set_yylval_str(x) (void)(x)
11216 # define set_yylval_num(x) (void)(x)
11217 # define set_yylval_id(x) (void)(x)
11218 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11219 # define set_yylval_literal(x) (void)(x)
11220 # define set_yylval_node(x) (void)(x)
11221 # define yylval_id() yylval.id
11222 #endif
11223 
11224 #ifndef RIPPER
11225 #define ripper_flush(p) (void)(p)
11226 #else
11227 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11228 
11229 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11230 
11231 static int
11232 ripper_has_scan_event(struct parser_params *parser)
11233 {
11234 
11235  if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11236  return lex_p > parser->tokp;
11237 }
11238 
11239 static VALUE
11240 ripper_scan_event_val(struct parser_params *parser, int t)
11241 {
11242  VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11243  VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11244  ripper_flush(parser);
11245  return rval;
11246 }
11247 
11248 static void
11249 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11250 {
11251  if (!ripper_has_scan_event(parser)) return;
11252  yylval_rval = ripper_scan_event_val(parser, t);
11253 }
11254 
11255 static void
11256 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11257 {
11258  if (!ripper_has_scan_event(parser)) return;
11259  (void)ripper_scan_event_val(parser, t);
11260 }
11261 
11262 static void
11263 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11264 {
11265  int saved_line = ruby_sourceline;
11266  const char *saved_tokp = parser->tokp;
11267 
11268  ruby_sourceline = parser->delayed_line;
11269  parser->tokp = lex_pbeg + parser->delayed_col;
11270  yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11271  parser->delayed = Qnil;
11272  ruby_sourceline = saved_line;
11273  parser->tokp = saved_tokp;
11274 }
11275 #endif /* RIPPER */
11276 
11277 #include "ruby/regex.h"
11278 #include "ruby/util.h"
11279 
11280 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11281  since ours (we hope) works properly with all combinations of
11282  machines, compilers, `char' and `unsigned char' argument types.
11283  (Per Bothner suggested the basic approach.) */
11284 #undef SIGN_EXTEND_CHAR
11285 #if __STDC__
11286 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11287 #else /* not __STDC__ */
11288 /* As in Harbison and Steele. */
11289 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11290 #endif
11291 
11292 #define parser_encoding_name() (parser->enc->name)
11293 #define parser_mbclen() mbclen((lex_p-1),lex_pend,parser->enc)
11294 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,parser->enc)
11295 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11296 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,parser->enc))
11297 
11298 #define parser_isascii() ISASCII(*(lex_p-1))
11299 
11300 #ifndef RIPPER
11301 static int
11302 token_info_get_column(struct parser_params *parser, const char *token)
11303 {
11304  int column = 1;
11305  const char *p, *pend = lex_p - strlen(token);
11306  for (p = lex_pbeg; p < pend; p++) {
11307  if (*p == '\t') {
11308  column = (((column - 1) / 8) + 1) * 8;
11309  }
11310  column++;
11311  }
11312  return column;
11313 }
11314 
11315 static int
11316 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11317 {
11318  const char *p, *pend = lex_p - strlen(token);
11319  for (p = lex_pbeg; p < pend; p++) {
11320  if (*p != ' ' && *p != '\t') {
11321  return 1;
11322  }
11323  }
11324  return 0;
11325 }
11326 
11327 #undef token_info_push
11328 static void
11329 token_info_push(struct parser_params *parser, const char *token)
11330 {
11331  token_info *ptinfo;
11332 
11333  if (!parser->parser_token_info_enabled) return;
11334  ptinfo = ALLOC(token_info);
11335  ptinfo->token = token;
11336  ptinfo->linenum = ruby_sourceline;
11337  ptinfo->column = token_info_get_column(parser, token);
11338  ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11339  ptinfo->next = parser->parser_token_info;
11340 
11341  parser->parser_token_info = ptinfo;
11342 }
11343 
11344 #undef token_info_pop
11345 static void
11346 token_info_pop(struct parser_params *parser, const char *token)
11347 {
11348  int linenum;
11349  token_info *ptinfo = parser->parser_token_info;
11350 
11351  if (!ptinfo) return;
11352  parser->parser_token_info = ptinfo->next;
11353  if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11354  goto finish;
11355  }
11356  linenum = ruby_sourceline;
11357  if (linenum == ptinfo->linenum) { /* SKIP */
11358  goto finish;
11359  }
11360  if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11361  goto finish;
11362  }
11363  if (parser->parser_token_info_enabled) {
11365  "mismatched indentations at '%s' with '%s' at %d",
11366  token, ptinfo->token, ptinfo->linenum);
11367  }
11368 
11369  finish:
11370  xfree(ptinfo);
11371 }
11372 #endif /* RIPPER */
11373 
11374 static int
11375 parser_yyerror(struct parser_params *parser, const char *msg)
11376 {
11377 #ifndef RIPPER
11378  const int max_line_margin = 30;
11379  const char *p, *pe;
11380  char *buf;
11381  long len;
11382  int i;
11383 
11384  compile_error(PARSER_ARG "%s", msg);
11385  p = lex_p;
11386  while (lex_pbeg <= p) {
11387  if (*p == '\n') break;
11388  p--;
11389  }
11390  p++;
11391 
11392  pe = lex_p;
11393  while (pe < lex_pend) {
11394  if (*pe == '\n') break;
11395  pe++;
11396  }
11397 
11398  len = pe - p;
11399  if (len > 4) {
11400  char *p2;
11401  const char *pre = "", *post = "";
11402 
11403  if (len > max_line_margin * 2 + 10) {
11404  if (lex_p - p > max_line_margin) {
11405  p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11406  pre = "...";
11407  }
11408  if (pe - lex_p > max_line_margin) {
11409  pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11410  post = "...";
11411  }
11412  len = pe - p;
11413  }
11414  buf = ALLOCA_N(char, len+2);
11415  MEMCPY(buf, p, char, len);
11416  buf[len] = '\0';
11417  rb_compile_error_append("%s%s%s", pre, buf, post);
11418 
11419  i = (int)(lex_p - p);
11420  p2 = buf; pe = buf + len;
11421 
11422  while (p2 < pe) {
11423  if (*p2 != '\t') *p2 = ' ';
11424  p2++;
11425  }
11426  buf[i] = '^';
11427  buf[i+1] = '\0';
11428  rb_compile_error_append("%s%s", pre, buf);
11429  }
11430 #else
11431  dispatch1(parse_error, STR_NEW2(msg));
11432 #endif /* !RIPPER */
11433  return 0;
11434 }
11435 
11436 static void parser_prepare(struct parser_params *parser);
11437 
11438 #ifndef RIPPER
11439 static VALUE
11440 debug_lines(const char *f)
11441 {
11442  ID script_lines;
11443  CONST_ID(script_lines, "SCRIPT_LINES__");
11444  if (rb_const_defined_at(rb_cObject, script_lines)) {
11445  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11446  if (TYPE(hash) == T_HASH) {
11448  VALUE lines = rb_ary_new();
11449  rb_hash_aset(hash, fname, lines);
11450  return lines;
11451  }
11452  }
11453  return 0;
11454 }
11455 
11456 static VALUE
11457 coverage(const char *f, int n)
11458 {
11459  VALUE coverages = rb_get_coverages();
11460  if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11462  VALUE lines = rb_ary_new2(n);
11463  int i;
11464  RBASIC(lines)->klass = 0;
11465  for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11466  RARRAY(lines)->as.heap.len = n;
11467  rb_hash_aset(coverages, fname, lines);
11468  return lines;
11469  }
11470  return 0;
11471 }
11472 
11473 static int
11475 {
11476  return strcmp(ruby_sourcefile, "-e") == 0;
11477 }
11478 
11479 static VALUE
11480 yycompile0(VALUE arg, int tracing)
11481 {
11482  int n;
11483  NODE *tree;
11484  struct parser_params *parser = (struct parser_params *)arg;
11485 
11486  if (!compile_for_eval && rb_safe_level() == 0) {
11488  if (ruby_debug_lines && ruby_sourceline > 0) {
11489  VALUE str = STR_NEW0();
11490  n = ruby_sourceline;
11491  do {
11493  } while (--n);
11494  }
11495 
11496  if (!e_option_supplied(parser)) {
11498  }
11499  }
11500 
11501  parser_prepare(parser);
11502  deferred_nodes = 0;
11503 #ifndef RIPPER
11505 #endif
11506  n = yyparse((void*)parser);
11507  ruby_debug_lines = 0;
11508  ruby_coverage = 0;
11509  compile_for_eval = 0;
11510 
11511  lex_strterm = 0;
11512  lex_p = lex_pbeg = lex_pend = 0;
11513  lex_lastline = lex_nextline = 0;
11514  if (parser->nerr) {
11515  return 0;
11516  }
11517  tree = ruby_eval_tree;
11518  if (!tree) {
11519  tree = NEW_NIL();
11520  }
11521  else if (ruby_eval_tree_begin) {
11522  tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11523  }
11524  return (VALUE)tree;
11525 }
11526 
11527 static NODE*
11528 yycompile(struct parser_params *parser, const char *f, int line)
11529 {
11531  ruby_sourceline = line - 1;
11532  return (NODE *)ruby_suppress_tracing(yycompile0, (VALUE)parser, TRUE);
11533 }
11534 #endif /* !RIPPER */
11535 
11536 static rb_encoding *
11538 {
11539  rb_encoding *enc = rb_enc_get(s);
11540  if (!rb_enc_asciicompat(enc)) {
11541  rb_raise(rb_eArgError, "invalid source encoding");
11542  }
11543  return enc;
11544 }
11545 
11546 static VALUE
11548 {
11549  char *beg, *end, *pend;
11551 
11552  beg = RSTRING_PTR(s);
11553  if (lex_gets_ptr) {
11554  if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11555  beg += lex_gets_ptr;
11556  }
11557  pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11558  end = beg;
11559  while (end < pend) {
11560  if (*end++ == '\n') break;
11561  }
11562  lex_gets_ptr = end - RSTRING_PTR(s);
11563  return rb_enc_str_new(beg, end - beg, enc);
11564 }
11565 
11566 static VALUE
11568 {
11569  VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11570  if (NIL_P(line)) return line;
11572 #ifndef RIPPER
11573  if (ruby_debug_lines) {
11574  rb_enc_associate(line, parser->enc);
11576  }
11577  if (ruby_coverage) {
11579  }
11580 #endif
11581  return line;
11582 }
11583 
11584 #ifdef RIPPER
11586 #else
11588 
11589 static NODE*
11590 parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11591 {
11592  struct parser_params *parser;
11593  NODE *node;
11594  volatile VALUE tmp;
11595 
11596  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11598  lex_gets_ptr = 0;
11599  lex_input = s;
11600  lex_pbeg = lex_p = lex_pend = 0;
11602 
11603  node = yycompile(parser, f, line);
11604  tmp = vparser; /* prohibit tail call optimization */
11605 
11606  return node;
11607 }
11608 
11609 NODE*
11610 rb_compile_string(const char *f, VALUE s, int line)
11611 {
11613  return parser_compile_string(rb_parser_new(), f, s, line);
11614 }
11615 
11616 NODE*
11617 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11618 {
11620  return parser_compile_string(vparser, f, s, line);
11621 }
11622 
11623 NODE*
11624 rb_compile_cstr(const char *f, const char *s, int len, int line)
11625 {
11626  VALUE str = rb_str_new(s, len);
11627  return parser_compile_string(rb_parser_new(), f, str, line);
11628 }
11629 
11630 NODE*
11631 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
11632 {
11633  VALUE str = rb_str_new(s, len);
11634  return parser_compile_string(vparser, f, str, line);
11635 }
11636 
11637 static VALUE
11639 {
11640  return rb_io_gets(io);
11641 }
11642 
11643 NODE*
11644 rb_compile_file(const char *f, VALUE file, int start)
11645 {
11646  VALUE volatile vparser = rb_parser_new();
11647 
11648  return rb_parser_compile_file(vparser, f, file, start);
11649 }
11650 
11651 NODE*
11652 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
11653 {
11654  struct parser_params *parser;
11655  volatile VALUE tmp;
11656  NODE *node;
11657 
11658  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11660  lex_input = file;
11661  lex_pbeg = lex_p = lex_pend = 0;
11663 
11664  node = yycompile(parser, f, start);
11665  tmp = vparser; /* prohibit tail call optimization */
11666 
11667  return node;
11668 }
11669 #endif /* !RIPPER */
11670 
11671 #define STR_FUNC_ESCAPE 0x01
11672 #define STR_FUNC_EXPAND 0x02
11673 #define STR_FUNC_REGEXP 0x04
11674 #define STR_FUNC_QWORDS 0x08
11675 #define STR_FUNC_SYMBOL 0x10
11676 #define STR_FUNC_INDENT 0x20
11677 
11679  str_squote = (0),
11687 };
11688 
11689 static VALUE
11690 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
11691 {
11692  VALUE str;
11693 
11694  str = rb_enc_str_new(p, n, enc);
11695  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
11697  }
11698  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
11700  }
11701  }
11702 
11703  return str;
11704 }
11705 
11706 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
11707 #define lex_eol_p() (lex_p >= lex_pend)
11708 #define peek(c) peek_n((c), 0)
11709 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
11710 
11711 static inline int
11713 {
11714  int c;
11715 
11716  if (lex_p == lex_pend) {
11717  VALUE v = lex_nextline;
11718  lex_nextline = 0;
11719  if (!v) {
11720  if (parser->eofp)
11721  return -1;
11722 
11723  if (!lex_input || NIL_P(v = lex_getline(parser))) {
11724  parser->eofp = Qtrue;
11725  lex_goto_eol(parser);
11726  return -1;
11727  }
11728  }
11729  {
11730 #ifdef RIPPER
11731  if (parser->tokp < lex_pend) {
11732  if (NIL_P(parser->delayed)) {
11733  parser->delayed = rb_str_buf_new(1024);
11734  rb_enc_associate(parser->delayed, parser->enc);
11735  rb_str_buf_cat(parser->delayed,
11736  parser->tokp, lex_pend - parser->tokp);
11737  parser->delayed_line = ruby_sourceline;
11738  parser->delayed_col = (int)(parser->tokp - lex_pbeg);
11739  }
11740  else {
11741  rb_str_buf_cat(parser->delayed,
11742  parser->tokp, lex_pend - parser->tokp);
11743  }
11744  }
11745 #endif
11746  if (heredoc_end > 0) {
11748  heredoc_end = 0;
11749  }
11750  ruby_sourceline++;
11751  parser->line_count++;
11752  lex_pbeg = lex_p = RSTRING_PTR(v);
11753  lex_pend = lex_p + RSTRING_LEN(v);
11754  ripper_flush(parser);
11755  lex_lastline = v;
11756  }
11757  }
11758  c = (unsigned char)*lex_p++;
11759  if (c == '\r' && peek('\n')) {
11760  lex_p++;
11761  c = '\n';
11762  }
11763 
11764  return c;
11765 }
11766 
11767 static void
11768 parser_pushback(struct parser_params *parser, int c)
11769 {
11770  if (c == -1) return;
11771  lex_p--;
11772  if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
11773  lex_p--;
11774  }
11775 }
11776 
11777 #define was_bol() (lex_p == lex_pbeg + 1)
11778 
11779 #define tokfix() (tokenbuf[tokidx]='\0')
11780 #define tok() tokenbuf
11781 #define toklen() tokidx
11782 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
11783 
11784 static char*
11786 {
11787  tokidx = 0;
11788  if (!tokenbuf) {
11789  toksiz = 60;
11790  tokenbuf = ALLOC_N(char, 60);
11791  }
11792  if (toksiz > 4096) {
11793  toksiz = 60;
11794  REALLOC_N(tokenbuf, char, 60);
11795  }
11796  return tokenbuf;
11797 }
11798 
11799 static char *
11800 parser_tokspace(struct parser_params *parser, int n)
11801 {
11802  tokidx += n;
11803 
11804  if (tokidx >= toksiz) {
11805  do {toksiz *= 2;} while (toksiz < tokidx);
11806  REALLOC_N(tokenbuf, char, toksiz);
11807  }
11808  return &tokenbuf[tokidx-n];
11809 }
11810 
11811 static void
11812 parser_tokadd(struct parser_params *parser, int c)
11813 {
11814  tokenbuf[tokidx++] = (char)c;
11815  if (tokidx >= toksiz) {
11816  toksiz *= 2;
11817  REALLOC_N(tokenbuf, char, toksiz);
11818  }
11819 }
11820 
11821 static int
11822 parser_tok_hex(struct parser_params *parser, size_t *numlen)
11823 {
11824  int c;
11825 
11826  c = scan_hex(lex_p, 2, numlen);
11827  if (!*numlen) {
11828  yyerror("invalid hex escape");
11829  return 0;
11830  }
11831  lex_p += *numlen;
11832  return c;
11833 }
11834 
11835 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
11836 
11837 static int
11839  int string_literal, int symbol_literal, int regexp_literal)
11840 {
11841  /*
11842  * If string_literal is true, then we allow multiple codepoints
11843  * in \u{}, and add the codepoints to the current token.
11844  * Otherwise we're parsing a character literal and return a single
11845  * codepoint without adding it
11846  */
11847 
11848  int codepoint;
11849  size_t numlen;
11850 
11851  if (regexp_literal) { tokadd('\\'); tokadd('u'); }
11852 
11853  if (peek('{')) { /* handle \u{...} form */
11854  do {
11855  if (regexp_literal) { tokadd(*lex_p); }
11856  nextc();
11857  codepoint = scan_hex(lex_p, 6, &numlen);
11858  if (numlen == 0) {
11859  yyerror("invalid Unicode escape");
11860  return 0;
11861  }
11862  if (codepoint > 0x10ffff) {
11863  yyerror("invalid Unicode codepoint (too large)");
11864  return 0;
11865  }
11866  lex_p += numlen;
11867  if (regexp_literal) {
11868  tokcopy((int)numlen);
11869  }
11870  else if (codepoint >= 0x80) {
11871  *encp = UTF8_ENC();
11872  if (string_literal) tokaddmbc(codepoint, *encp);
11873  }
11874  else if (string_literal) {
11875  tokadd(codepoint);
11876  }
11877  } while (string_literal && (peek(' ') || peek('\t')));
11878 
11879  if (!peek('}')) {
11880  yyerror("unterminated Unicode escape");
11881  return 0;
11882  }
11883 
11884  if (regexp_literal) { tokadd('}'); }
11885  nextc();
11886  }
11887  else { /* handle \uxxxx form */
11888  codepoint = scan_hex(lex_p, 4, &numlen);
11889  if (numlen < 4) {
11890  yyerror("invalid Unicode escape");
11891  return 0;
11892  }
11893  lex_p += 4;
11894  if (regexp_literal) {
11895  tokcopy(4);
11896  }
11897  else if (codepoint >= 0x80) {
11898  *encp = UTF8_ENC();
11899  if (string_literal) tokaddmbc(codepoint, *encp);
11900  }
11901  else if (string_literal) {
11902  tokadd(codepoint);
11903  }
11904  }
11905 
11906  return codepoint;
11907 }
11908 
11909 #define ESCAPE_CONTROL 1
11910 #define ESCAPE_META 2
11911 
11912 static int
11914  rb_encoding **encp)
11915 {
11916  int c;
11917  size_t numlen;
11918 
11919  switch (c = nextc()) {
11920  case '\\': /* Backslash */
11921  return c;
11922 
11923  case 'n': /* newline */
11924  return '\n';
11925 
11926  case 't': /* horizontal tab */
11927  return '\t';
11928 
11929  case 'r': /* carriage-return */
11930  return '\r';
11931 
11932  case 'f': /* form-feed */
11933  return '\f';
11934 
11935  case 'v': /* vertical tab */
11936  return '\13';
11937 
11938  case 'a': /* alarm(bell) */
11939  return '\007';
11940 
11941  case 'e': /* escape */
11942  return 033;
11943 
11944  case '0': case '1': case '2': case '3': /* octal constant */
11945  case '4': case '5': case '6': case '7':
11946  pushback(c);
11947  c = scan_oct(lex_p, 3, &numlen);
11948  lex_p += numlen;
11949  return c;
11950 
11951  case 'x': /* hex constant */
11952  c = tok_hex(&numlen);
11953  if (numlen == 0) return 0;
11954  return c;
11955 
11956  case 'b': /* backspace */
11957  return '\010';
11958 
11959  case 's': /* space */
11960  return ' ';
11961 
11962  case 'M':
11963  if (flags & ESCAPE_META) goto eof;
11964  if ((c = nextc()) != '-') {
11965  pushback(c);
11966  goto eof;
11967  }
11968  if ((c = nextc()) == '\\') {
11969  if (peek('u')) goto eof;
11970  return read_escape(flags|ESCAPE_META, encp) | 0x80;
11971  }
11972  else if (c == -1 || !ISASCII(c)) goto eof;
11973  else {
11974  return ((c & 0xff) | 0x80);
11975  }
11976 
11977  case 'C':
11978  if ((c = nextc()) != '-') {
11979  pushback(c);
11980  goto eof;
11981  }
11982  case 'c':
11983  if (flags & ESCAPE_CONTROL) goto eof;
11984  if ((c = nextc())== '\\') {
11985  if (peek('u')) goto eof;
11986  c = read_escape(flags|ESCAPE_CONTROL, encp);
11987  }
11988  else if (c == '?')
11989  return 0177;
11990  else if (c == -1 || !ISASCII(c)) goto eof;
11991  return c & 0x9f;
11992 
11993  eof:
11994  case -1:
11995  yyerror("Invalid escape character syntax");
11996  return '\0';
11997 
11998  default:
11999  return c;
12000  }
12001 }
12002 
12003 static void
12005 {
12006  int len = rb_enc_codelen(c, enc);
12007  rb_enc_mbcput(c, tokspace(len), enc);
12008 }
12009 
12010 static int
12012 {
12013  int c;
12014  int flags = 0;
12015  size_t numlen;
12016 
12017  first:
12018  switch (c = nextc()) {
12019  case '\n':
12020  return 0; /* just ignore */
12021 
12022  case '0': case '1': case '2': case '3': /* octal constant */
12023  case '4': case '5': case '6': case '7':
12024  {
12025  ruby_scan_oct(--lex_p, 3, &numlen);
12026  if (numlen == 0) goto eof;
12027  lex_p += numlen;
12028  tokcopy((int)numlen + 1);
12029  }
12030  return 0;
12031 
12032  case 'x': /* hex constant */
12033  {
12034  tok_hex(&numlen);
12035  if (numlen == 0) return -1;
12036  tokcopy((int)numlen + 2);
12037  }
12038  return 0;
12039 
12040  case 'M':
12041  if (flags & ESCAPE_META) goto eof;
12042  if ((c = nextc()) != '-') {
12043  pushback(c);
12044  goto eof;
12045  }
12046  tokcopy(3);
12047  flags |= ESCAPE_META;
12048  goto escaped;
12049 
12050  case 'C':
12051  if (flags & ESCAPE_CONTROL) goto eof;
12052  if ((c = nextc()) != '-') {
12053  pushback(c);
12054  goto eof;
12055  }
12056  tokcopy(3);
12057  goto escaped;
12058 
12059  case 'c':
12060  if (flags & ESCAPE_CONTROL) goto eof;
12061  tokcopy(2);
12062  flags |= ESCAPE_CONTROL;
12063  escaped:
12064  if ((c = nextc()) == '\\') {
12065  goto first;
12066  }
12067  else if (c == -1) goto eof;
12068  tokadd(c);
12069  return 0;
12070 
12071  eof:
12072  case -1:
12073  yyerror("Invalid escape character syntax");
12074  return -1;
12075 
12076  default:
12077  tokadd('\\');
12078  tokadd(c);
12079  }
12080  return 0;
12081 }
12082 
12083 static int
12085 {
12086  int kcode = 0;
12087  int kopt = 0;
12088  int options = 0;
12089  int c, opt, kc;
12090 
12091  newtok();
12092  while (c = nextc(), ISALPHA(c)) {
12093  if (c == 'o') {
12094  options |= RE_OPTION_ONCE;
12095  }
12096  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12097  if (kc >= 0) {
12098  if (kc != rb_ascii8bit_encindex()) kcode = c;
12099  kopt = opt;
12100  }
12101  else {
12102  options |= opt;
12103  }
12104  }
12105  else {
12106  tokadd(c);
12107  }
12108  }
12109  options |= kopt;
12110  pushback(c);
12111  if (toklen()) {
12112  tokfix();
12113  compile_error(PARSER_ARG "unknown regexp option%s - %s",
12114  toklen() > 1 ? "s" : "", tok());
12115  }
12116  return options | RE_OPTION_ENCODING(kcode);
12117 }
12118 
12119 static void
12121 {
12122  /* TODO: should use another API? */
12123  if (RBASIC(str)->flags & RSTRING_NOEMBED)
12124  xfree(RSTRING_PTR(str));
12125  rb_gc_force_recycle(str);
12126 }
12127 
12128 static int
12130 {
12131  int len = parser_precise_mbclen();
12132  if (!MBCLEN_CHARFOUND_P(len)) {
12133  compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12134  return -1;
12135  }
12136  tokadd(c);
12137  lex_p += --len;
12138  if (len > 0) tokcopy(len);
12139  return c;
12140 }
12141 
12142 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12143 
12144 static int
12146  int func, int term, int paren, long *nest,
12147  rb_encoding **encp)
12148 {
12149  int c;
12150  int has_nonascii = 0;
12151  rb_encoding *enc = *encp;
12152  char *errbuf = 0;
12153  static const char mixed_msg[] = "%s mixed within %s source";
12154 
12155 #define mixed_error(enc1, enc2) if (!errbuf) { \
12156  size_t len = sizeof(mixed_msg) - 4; \
12157  len += strlen(rb_enc_name(enc1)); \
12158  len += strlen(rb_enc_name(enc2)); \
12159  errbuf = ALLOCA_N(char, len); \
12160  snprintf(errbuf, len, mixed_msg, \
12161  rb_enc_name(enc1), \
12162  rb_enc_name(enc2)); \
12163  yyerror(errbuf); \
12164  }
12165 #define mixed_escape(beg, enc1, enc2) do { \
12166  const char *pos = lex_p; \
12167  lex_p = (beg); \
12168  mixed_error((enc1), (enc2)); \
12169  lex_p = pos; \
12170  } while (0)
12171 
12172  while ((c = nextc()) != -1) {
12173  if (paren && c == paren) {
12174  ++*nest;
12175  }
12176  else if (c == term) {
12177  if (!nest || !*nest) {
12178  pushback(c);
12179  break;
12180  }
12181  --*nest;
12182  }
12183  else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12184  int c2 = *lex_p;
12185  if (c2 == '$' || c2 == '@' || c2 == '{') {
12186  pushback(c);
12187  break;
12188  }
12189  }
12190  else if (c == '\\') {
12191  const char *beg = lex_p - 1;
12192  c = nextc();
12193  switch (c) {
12194  case '\n':
12195  if (func & STR_FUNC_QWORDS) break;
12196  if (func & STR_FUNC_EXPAND) continue;
12197  tokadd('\\');
12198  break;
12199 
12200  case '\\':
12201  if (func & STR_FUNC_ESCAPE) tokadd(c);
12202  break;
12203 
12204  case 'u':
12205  if ((func & STR_FUNC_EXPAND) == 0) {
12206  tokadd('\\');
12207  break;
12208  }
12209  parser_tokadd_utf8(parser, &enc, 1,
12210  func & STR_FUNC_SYMBOL,
12211  func & STR_FUNC_REGEXP);
12212  if (has_nonascii && enc != *encp) {
12213  mixed_escape(beg, enc, *encp);
12214  }
12215  continue;
12216 
12217  default:
12218  if (c == -1) return -1;
12219  if (!ISASCII(c)) {
12220  if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12221  goto non_ascii;
12222  }
12223  if (func & STR_FUNC_REGEXP) {
12224  pushback(c);
12225  if ((c = tokadd_escape(&enc)) < 0)
12226  return -1;
12227  if (has_nonascii && enc != *encp) {
12228  mixed_escape(beg, enc, *encp);
12229  }
12230  continue;
12231  }
12232  else if (func & STR_FUNC_EXPAND) {
12233  pushback(c);
12234  if (func & STR_FUNC_ESCAPE) tokadd('\\');
12235  c = read_escape(0, &enc);
12236  }
12237  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12238  /* ignore backslashed spaces in %w */
12239  }
12240  else if (c != term && !(paren && c == paren)) {
12241  tokadd('\\');
12242  pushback(c);
12243  continue;
12244  }
12245  }
12246  }
12247  else if (!parser_isascii()) {
12248  non_ascii:
12249  has_nonascii = 1;
12250  if (enc != *encp) {
12251  mixed_error(enc, *encp);
12252  continue;
12253  }
12254  if (tokadd_mbchar(c) == -1) return -1;
12255  continue;
12256  }
12257  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12258  pushback(c);
12259  break;
12260  }
12261  if (c & 0x80) {
12262  has_nonascii = 1;
12263  if (enc != *encp) {
12264  mixed_error(enc, *encp);
12265  continue;
12266  }
12267  }
12268  tokadd(c);
12269  }
12270  *encp = enc;
12271  return c;
12272 }
12273 
12274 #define NEW_STRTERM(func, term, paren) \
12275  rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12276 
12277 #ifdef RIPPER
12278 static void
12279 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12280 {
12281  if (!NIL_P(parser->delayed)) {
12282  ptrdiff_t len = lex_p - parser->tokp;
12283  if (len > 0) {
12284  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12285  }
12286  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12287  parser->tokp = lex_p;
12288  }
12289 }
12290 
12291 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12292 #else
12293 #define flush_string_content(enc) ((void)(enc))
12294 #endif
12295 
12296 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12297 /* this can be shared with ripper, since it's independent from struct
12298  * parser_params. */
12299 #ifndef RIPPER
12300 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12301 #define SPECIAL_PUNCT(idx) ( \
12302  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12303  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12304  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12305  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12306  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12307  BIT('0', idx))
12308 const unsigned int ruby_global_name_punct_bits[] = {
12309  SPECIAL_PUNCT(0),
12310  SPECIAL_PUNCT(1),
12311  SPECIAL_PUNCT(2),
12312 };
12313 #undef BIT
12314 #undef SPECIAL_PUNCT
12315 #endif
12316 
12317 static inline int
12319 {
12320  if (c <= 0x20 || 0x7e < c) return 0;
12321  return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12322 }
12323 
12324 static int
12326 {
12327  int c;
12328  const char *p = lex_p;
12329 
12330  if (p + 1 >= lex_pend) return 0;
12331  c = *p++;
12332  switch (c) {
12333  case '$':
12334  if ((c = *p) == '-') {
12335  if (++p >= lex_pend) return 0;
12336  c = *p;
12337  }
12338  else if (is_global_name_punct(c) || ISDIGIT(c)) {
12339  return tSTRING_DVAR;
12340  }
12341  break;
12342  case '@':
12343  if ((c = *p) == '@') {
12344  if (++p >= lex_pend) return 0;
12345  c = *p;
12346  }
12347  break;
12348  case '{':
12349  lex_p = p;
12350  command_start = TRUE;
12351  return tSTRING_DBEG;
12352  default:
12353  return 0;
12354  }
12355  if (!ISASCII(c) || c == '_' || ISALPHA(c))
12356  return tSTRING_DVAR;
12357  return 0;
12358 }
12359 
12360 static int
12361 parser_parse_string(struct parser_params *parser, NODE *quote)
12362 {
12363  int func = (int)quote->nd_func;
12364  int term = nd_term(quote);
12365  int paren = nd_paren(quote);
12366  int c, space = 0;
12367  rb_encoding *enc = parser->enc;
12368 
12369  if (func == -1) return tSTRING_END;
12370  c = nextc();
12371  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12372  do {c = nextc();} while (ISSPACE(c));
12373  space = 1;
12374  }
12375  if (c == term && !quote->nd_nest) {
12376  if (func & STR_FUNC_QWORDS) {
12377  quote->nd_func = -1;
12378  return ' ';
12379  }
12380  if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12382  return tREGEXP_END;
12383  }
12384  if (space) {
12385  pushback(c);
12386  return ' ';
12387  }
12388  newtok();
12389  if ((func & STR_FUNC_EXPAND) && c == '#') {
12390  int t = parser_peek_variable_name(parser);
12391  if (t) return t;
12392  tokadd('#');
12393  c = nextc();
12394  }
12395  pushback(c);
12396  if (tokadd_string(func, term, paren, &quote->nd_nest,
12397  &enc) == -1) {
12398  ruby_sourceline = nd_line(quote);
12399  if (func & STR_FUNC_REGEXP) {
12400  if (parser->eofp)
12401  compile_error(PARSER_ARG "unterminated regexp meets end of file");
12402  return tREGEXP_END;
12403  }
12404  else {
12405  if (parser->eofp)
12406  compile_error(PARSER_ARG "unterminated string meets end of file");
12407  return tSTRING_END;
12408  }
12409  }
12410 
12411  tokfix();
12412  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12413  flush_string_content(enc);
12414 
12415  return tSTRING_CONTENT;
12416 }
12417 
12418 static int
12420 {
12421  int c = nextc(), term, func = 0;
12422  long len;
12423 
12424  if (c == '-') {
12425  c = nextc();
12426  func = STR_FUNC_INDENT;
12427  }
12428  switch (c) {
12429  case '\'':
12430  func |= str_squote; goto quoted;
12431  case '"':
12432  func |= str_dquote; goto quoted;
12433  case '`':
12434  func |= str_xquote;
12435  quoted:
12436  newtok();
12437  tokadd(func);
12438  term = c;
12439  while ((c = nextc()) != -1 && c != term) {
12440  if (tokadd_mbchar(c) == -1) return 0;
12441  }
12442  if (c == -1) {
12443  compile_error(PARSER_ARG "unterminated here document identifier");
12444  return 0;
12445  }
12446  break;
12447 
12448  default:
12449  if (!parser_is_identchar()) {
12450  pushback(c);
12451  if (func & STR_FUNC_INDENT) {
12452  pushback('-');
12453  }
12454  return 0;
12455  }
12456  newtok();
12457  term = '"';
12458  tokadd(func |= str_dquote);
12459  do {
12460  if (tokadd_mbchar(c) == -1) return 0;
12461  } while ((c = nextc()) != -1 && parser_is_identchar());
12462  pushback(c);
12463  break;
12464  }
12465 
12466  tokfix();
12467 #ifdef RIPPER
12468  ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12469 #endif
12470  len = lex_p - lex_pbeg;
12471  lex_goto_eol(parser);
12473  STR_NEW(tok(), toklen()), /* nd_lit */
12474  len, /* nd_nth */
12475  lex_lastline); /* nd_orig */
12477  ripper_flush(parser);
12478  return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12479 }
12480 
12481 static void
12483 {
12484  VALUE line;
12485 
12486  line = here->nd_orig;
12487  lex_lastline = line;
12488  lex_pbeg = RSTRING_PTR(line);
12489  lex_pend = lex_pbeg + RSTRING_LEN(line);
12490  lex_p = lex_pbeg + here->nd_nth;
12492  ruby_sourceline = nd_line(here);
12493  dispose_string(here->nd_lit);
12494  rb_gc_force_recycle((VALUE)here);
12495  ripper_flush(parser);
12496 }
12497 
12498 static int
12500  const char *eos, long len, int indent)
12501 {
12502  const char *p = lex_pbeg;
12503  long n;
12504 
12505  if (indent) {
12506  while (*p && ISSPACE(*p)) p++;
12507  }
12508  n = lex_pend - (p + len);
12509  if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12510  return strncmp(eos, p, len) == 0;
12511 }
12512 
12513 #ifdef RIPPER
12514 static void
12515 ripper_dispatch_heredoc_end(struct parser_params *parser)
12516 {
12517  if (!NIL_P(parser->delayed))
12518  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12519  lex_goto_eol(parser);
12520  ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12521 }
12522 
12523 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12524 #else
12525 #define dispatch_heredoc_end() ((void)0)
12526 #endif
12527 
12528 static int
12530 {
12531  int c, func, indent = 0;
12532  const char *eos, *p, *pend;
12533  long len;
12534  VALUE str = 0;
12535  rb_encoding *enc = parser->enc;
12536 
12537  eos = RSTRING_PTR(here->nd_lit);
12538  len = RSTRING_LEN(here->nd_lit) - 1;
12539  indent = (func = *eos++) & STR_FUNC_INDENT;
12540 
12541  if ((c = nextc()) == -1) {
12542  error:
12543  compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12544 #ifdef RIPPER
12545  if (NIL_P(parser->delayed)) {
12546  ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12547  }
12548  else {
12549  if (str ||
12550  ((len = lex_p - parser->tokp) > 0 &&
12551  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12552  rb_str_append(parser->delayed, str);
12553  }
12554  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12555  }
12556  lex_goto_eol(parser);
12557 #endif
12558  restore:
12560  lex_strterm = 0;
12561  return 0;
12562  }
12563  if (was_bol() && whole_match_p(eos, len, indent)) {
12566  return tSTRING_END;
12567  }
12568 
12569  if (!(func & STR_FUNC_EXPAND)) {
12570  do {
12572  pend = lex_pend;
12573  if (pend > p) {
12574  switch (pend[-1]) {
12575  case '\n':
12576  if (--pend == p || pend[-1] != '\r') {
12577  pend++;
12578  break;
12579  }
12580  case '\r':
12581  --pend;
12582  }
12583  }
12584  if (str)
12585  rb_str_cat(str, p, pend - p);
12586  else
12587  str = STR_NEW(p, pend - p);
12588  if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12589  lex_goto_eol(parser);
12590  if (nextc() == -1) {
12591  if (str) dispose_string(str);
12592  goto error;
12593  }
12594  } while (!whole_match_p(eos, len, indent));
12595  }
12596  else {
12597  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12598  newtok();
12599  if (c == '#') {
12600  int t = parser_peek_variable_name(parser);
12601  if (t) return t;
12602  tokadd('#');
12603  c = nextc();
12604  }
12605  do {
12606  pushback(c);
12607  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
12608  if (parser->eofp) goto error;
12609  goto restore;
12610  }
12611  if (c != '\n') {
12612  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12613  flush_string_content(enc);
12614  return tSTRING_CONTENT;
12615  }
12616  tokadd(nextc());
12617  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
12618  if ((c = nextc()) == -1) goto error;
12619  } while (!whole_match_p(eos, len, indent));
12620  str = STR_NEW3(tok(), toklen(), enc, func);
12621  }
12624  lex_strterm = NEW_STRTERM(-1, 0, 0);
12625  set_yylval_str(str);
12626  return tSTRING_CONTENT;
12627 }
12628 
12629 #include "lex.c"
12630 
12631 static void
12633 {
12634 #ifndef RIPPER
12635  rb_warning0("ambiguous first argument; put parentheses or even spaces");
12636 #else
12638 #endif
12639 }
12640 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
12641 
12642 static ID
12644 {
12645 #ifndef RIPPER
12646  if (!is_local_id(lhs))
12647  yyerror("formal argument must be local variable");
12648 #endif
12649  shadowing_lvar(lhs);
12650  return lhs;
12651 }
12652 
12653 static int
12654 lvar_defined_gen(struct parser_params *parser, ID id)
12655 {
12656  return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
12657 }
12658 
12659 /* emacsen -*- hack */
12660 static long
12661 parser_encode_length(struct parser_params *parser, const char *name, long len)
12662 {
12663  long nlen;
12664 
12665  if (len > 5 && name[nlen = len - 5] == '-') {
12666  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
12667  return nlen;
12668  }
12669  if (len > 4 && name[nlen = len - 4] == '-') {
12670  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
12671  return nlen;
12672  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
12673  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
12674  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
12675  return nlen;
12676  }
12677  return len;
12678 }
12679 
12680 static void
12681 parser_set_encode(struct parser_params *parser, const char *name)
12682 {
12683  int idx = rb_enc_find_index(name);
12684  rb_encoding *enc;
12685  VALUE excargs[3];
12686 
12687  if (idx < 0) {
12688  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
12689  error:
12690  excargs[0] = rb_eArgError;
12691  excargs[2] = rb_make_backtrace();
12692  rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
12693  rb_exc_raise(rb_make_exception(3, excargs));
12694  }
12695  enc = rb_enc_from_index(idx);
12696  if (!rb_enc_asciicompat(enc)) {
12697  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
12698  goto error;
12699  }
12700  parser->enc = enc;
12701 #ifndef RIPPER
12702  if (ruby_debug_lines) {
12703  long i, n = RARRAY_LEN(ruby_debug_lines);
12704  const VALUE *p = RARRAY_PTR(ruby_debug_lines);
12705  for (i = 0; i < n; ++i) {
12706  rb_enc_associate_index(*p, idx);
12707  }
12708  }
12709 #endif
12710 }
12711 
12712 static int
12714 {
12715  const char *p = lex_pbeg, *pend = lex_p - 1;
12716  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
12717  while (p < pend) {
12718  if (!ISSPACE(*p)) return 0;
12719  p++;
12720  }
12721  return 1;
12722 }
12723 
12724 #ifndef RIPPER
12725 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
12726 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
12727 
12728 static void
12729 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
12730 {
12731  if (!comment_at_top(parser)) {
12732  return;
12733  }
12734  parser_set_encode(parser, val);
12735 }
12736 
12737 static void
12738 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
12739 {
12740  int *p = &parser->parser_token_info_enabled;
12741 
12742  switch (*val) {
12743  case 't': case 'T':
12744  if (strcasecmp(val, "true") == 0) {
12745  *p = TRUE;
12746  return;
12747  }
12748  break;
12749  case 'f': case 'F':
12750  if (strcasecmp(val, "false") == 0) {
12751  *p = FALSE;
12752  return;
12753  }
12754  break;
12755  }
12756  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
12757 }
12758 
12760  const char *name;
12763 };
12764 
12765 static const struct magic_comment magic_comments[] = {
12768  {"warn_indent", parser_set_token_info},
12769 };
12770 #endif
12771 
12772 static const char *
12773 magic_comment_marker(const char *str, long len)
12774 {
12775  long i = 2;
12776 
12777  while (i < len) {
12778  switch (str[i]) {
12779  case '-':
12780  if (str[i-1] == '*' && str[i-2] == '-') {
12781  return str + i + 1;
12782  }
12783  i += 2;
12784  break;
12785  case '*':
12786  if (i + 1 >= len) return 0;
12787  if (str[i+1] != '-') {
12788  i += 4;
12789  }
12790  else if (str[i-1] != '-') {
12791  i += 2;
12792  }
12793  else {
12794  return str + i + 2;
12795  }
12796  break;
12797  default:
12798  i += 3;
12799  break;
12800  }
12801  }
12802  return 0;
12803 }
12804 
12805 static int
12806 parser_magic_comment(struct parser_params *parser, const char *str, long len)
12807 {
12808  VALUE name = 0, val = 0;
12809  const char *beg, *end, *vbeg, *vend;
12810 #define str_copy(_s, _p, _n) ((_s) \
12811  ? (void)(rb_str_resize((_s), (_n)), \
12812  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
12813  : (void)((_s) = STR_NEW((_p), (_n))))
12814 
12815  if (len <= 7) return FALSE;
12816  if (!(beg = magic_comment_marker(str, len))) return FALSE;
12817  if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
12818  str = beg;
12819  len = end - beg - 3;
12820 
12821  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
12822  while (len > 0) {
12823 #ifndef RIPPER
12824  const struct magic_comment *p = magic_comments;
12825 #endif
12826  char *s;
12827  int i;
12828  long n = 0;
12829 
12830  for (; len > 0 && *str; str++, --len) {
12831  switch (*str) {
12832  case '\'': case '"': case ':': case ';':
12833  continue;
12834  }
12835  if (!ISSPACE(*str)) break;
12836  }
12837  for (beg = str; len > 0; str++, --len) {
12838  switch (*str) {
12839  case '\'': case '"': case ':': case ';':
12840  break;
12841  default:
12842  if (ISSPACE(*str)) break;
12843  continue;
12844  }
12845  break;
12846  }
12847  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
12848  if (!len) break;
12849  if (*str != ':') continue;
12850 
12851  do str++; while (--len > 0 && ISSPACE(*str));
12852  if (!len) break;
12853  if (*str == '"') {
12854  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
12855  if (*str == '\\') {
12856  --len;
12857  ++str;
12858  }
12859  }
12860  vend = str;
12861  if (len) {
12862  --len;
12863  ++str;
12864  }
12865  }
12866  else {
12867  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
12868  vend = str;
12869  }
12870  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
12871 
12872  n = end - beg;
12873  str_copy(name, beg, n);
12874  s = RSTRING_PTR(name);
12875  for (i = 0; i < n; ++i) {
12876  if (s[i] == '-') s[i] = '_';
12877  }
12878 #ifndef RIPPER
12879  do {
12880  if (STRNCASECMP(p->name, s, n) == 0) {
12881  n = vend - vbeg;
12882  if (p->length) {
12883  n = (*p->length)(parser, vbeg, n);
12884  }
12885  str_copy(val, vbeg, n);
12886  (*p->func)(parser, s, RSTRING_PTR(val));
12887  break;
12888  }
12889  } while (++p < magic_comments + numberof(magic_comments));
12890 #else
12891  str_copy(val, vbeg, vend - vbeg);
12892  dispatch2(magic_comment, name, val);
12893 #endif
12894  }
12895 
12896  return TRUE;
12897 }
12898 
12899 static void
12900 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
12901 {
12902  int sep = 0;
12903  const char *beg = str;
12904  VALUE s;
12905 
12906  for (;;) {
12907  if (send - str <= 6) return;
12908  switch (str[6]) {
12909  case 'C': case 'c': str += 6; continue;
12910  case 'O': case 'o': str += 5; continue;
12911  case 'D': case 'd': str += 4; continue;
12912  case 'I': case 'i': str += 3; continue;
12913  case 'N': case 'n': str += 2; continue;
12914  case 'G': case 'g': str += 1; continue;
12915  case '=': case ':':
12916  sep = 1;
12917  str += 6;
12918  break;
12919  default:
12920  str += 6;
12921  if (ISSPACE(*str)) break;
12922  continue;
12923  }
12924  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
12925  }
12926  for (;;) {
12927  do {
12928  if (++str >= send) return;
12929  } while (ISSPACE(*str));
12930  if (sep) break;
12931  if (*str != '=' && *str != ':') return;
12932  sep = 1;
12933  str++;
12934  }
12935  beg = str;
12936  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
12937  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
12938  parser_set_encode(parser, RSTRING_PTR(s));
12939  rb_str_resize(s, 0);
12940 }
12941 
12942 static void
12944 {
12945  int c = nextc();
12946  switch (c) {
12947  case '#':
12948  if (peek('!')) parser->has_shebang = 1;
12949  break;
12950  case 0xef: /* UTF-8 BOM marker */
12951  if (lex_pend - lex_p >= 2 &&
12952  (unsigned char)lex_p[0] == 0xbb &&
12953  (unsigned char)lex_p[1] == 0xbf) {
12954  parser->enc = rb_utf8_encoding();
12955  lex_p += 2;
12956  lex_pbeg = lex_p;
12957  return;
12958  }
12959  break;
12960  case EOF:
12961  return;
12962  }
12963  pushback(c);
12964  parser->enc = rb_enc_get(lex_lastline);
12965 }
12966 
12967 #define IS_ARG() (lex_state == EXPR_ARG || lex_state == EXPR_CMDARG)
12968 #define IS_END() (lex_state == EXPR_END || lex_state == EXPR_ENDARG || lex_state == EXPR_ENDFN)
12969 #define IS_BEG() (lex_state == EXPR_BEG || lex_state == EXPR_MID || lex_state == EXPR_VALUE || lex_state == EXPR_CLASS)
12970 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
12971 #define IS_LABEL_POSSIBLE() ((lex_state == EXPR_BEG && !cmd_state) || IS_ARG())
12972 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
12973 
12974 #ifndef RIPPER
12975 #define ambiguous_operator(op, syn) ( \
12976  rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
12977  rb_warning0("even though it seems like "syn""))
12978 #else
12979 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
12980 #endif
12981 #define warn_balanced(op, syn) ((void) \
12982  (last_state != EXPR_CLASS && last_state != EXPR_DOT && \
12983  last_state != EXPR_FNAME && last_state != EXPR_ENDFN && \
12984  last_state != EXPR_ENDARG && \
12985  space_seen && !ISSPACE(c) && \
12986  (ambiguous_operator(op, syn), 0)))
12987 
12988 static int
12990 {
12991  register int c;
12992  int space_seen = 0;
12993  int cmd_state;
12994  enum lex_state_e last_state;
12995  rb_encoding *enc;
12996  int mb;
12997 #ifdef RIPPER
12998  int fallthru = FALSE;
12999 #endif
13000 
13001  if (lex_strterm) {
13002  int token;
13003  if (nd_type(lex_strterm) == NODE_HEREDOC) {
13004  token = here_document(lex_strterm);
13005  if (token == tSTRING_END) {
13006  lex_strterm = 0;
13007  lex_state = EXPR_END;
13008  }
13009  }
13010  else {
13011  token = parse_string(lex_strterm);
13012  if (token == tSTRING_END || token == tREGEXP_END) {
13014  lex_strterm = 0;
13015  lex_state = EXPR_END;
13016  }
13017  }
13018  return token;
13019  }
13020  cmd_state = command_start;
13021  command_start = FALSE;
13022  retry:
13023  last_state = lex_state;
13024  switch (c = nextc()) {
13025  case '\0': /* NUL */
13026  case '\004': /* ^D */
13027  case '\032': /* ^Z */
13028  case -1: /* end of script. */
13029  return 0;
13030 
13031  /* white spaces */
13032  case ' ': case '\t': case '\f': case '\r':
13033  case '\13': /* '\v' */
13034  space_seen = 1;
13035 #ifdef RIPPER
13036  while ((c = nextc())) {
13037  switch (c) {
13038  case ' ': case '\t': case '\f': case '\r':
13039  case '\13': /* '\v' */
13040  break;
13041  default:
13042  goto outofloop;
13043  }
13044  }
13045  outofloop:
13046  pushback(c);
13047  ripper_dispatch_scan_event(parser, tSP);
13048 #endif
13049  goto retry;
13050 
13051  case '#': /* it's a comment */
13052  /* no magic_comment in shebang line */
13053  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13054  if (comment_at_top(parser)) {
13055  set_file_encoding(parser, lex_p, lex_pend);
13056  }
13057  }
13058  lex_p = lex_pend;
13059 #ifdef RIPPER
13060  ripper_dispatch_scan_event(parser, tCOMMENT);
13061  fallthru = TRUE;
13062 #endif
13063  /* fall through */
13064  case '\n':
13065  switch (lex_state) {
13066  case EXPR_BEG:
13067  case EXPR_FNAME:
13068  case EXPR_DOT:
13069  case EXPR_CLASS:
13070  case EXPR_VALUE:
13071 #ifdef RIPPER
13072  if (!fallthru) {
13073  ripper_dispatch_scan_event(parser, tIGNORED_NL);
13074  }
13075  fallthru = FALSE;
13076 #endif
13077  goto retry;
13078  default:
13079  break;
13080  }
13081  while ((c = nextc())) {
13082  switch (c) {
13083  case ' ': case '\t': case '\f': case '\r':
13084  case '\13': /* '\v' */
13085  space_seen = 1;
13086  break;
13087  case '.': {
13088  if ((c = nextc()) != '.') {
13089  pushback(c);
13090  pushback('.');
13091  goto retry;
13092  }
13093  }
13094  default:
13095  --ruby_sourceline;
13097  case -1: /* EOF no decrement*/
13098  lex_goto_eol(parser);
13099 #ifdef RIPPER
13100  if (c != -1) {
13101  parser->tokp = lex_p;
13102  }
13103 #endif
13104  goto normal_newline;
13105  }
13106  }
13107  normal_newline:
13108  command_start = TRUE;
13109  lex_state = EXPR_BEG;
13110  return '\n';
13111 
13112  case '*':
13113  if ((c = nextc()) == '*') {
13114  if ((c = nextc()) == '=') {
13116  lex_state = EXPR_BEG;
13117  return tOP_ASGN;
13118  }
13119  pushback(c);
13120  c = tPOW;
13121  }
13122  else {
13123  if (c == '=') {
13124  set_yylval_id('*');
13125  lex_state = EXPR_BEG;
13126  return tOP_ASGN;
13127  }
13128  pushback(c);
13129  if (IS_SPCARG(c)) {
13130  rb_warning0("`*' interpreted as argument prefix");
13131  c = tSTAR;
13132  }
13133  else if (IS_BEG()) {
13134  c = tSTAR;
13135  }
13136  else {
13137  warn_balanced("*", "argument prefix");
13138  c = '*';
13139  }
13140  }
13141  switch (lex_state) {
13142  case EXPR_FNAME: case EXPR_DOT:
13143  lex_state = EXPR_ARG; break;
13144  default:
13145  lex_state = EXPR_BEG; break;
13146  }
13147  return c;
13148 
13149  case '!':
13150  c = nextc();
13151  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13152  lex_state = EXPR_ARG;
13153  if (c == '@') {
13154  return '!';
13155  }
13156  }
13157  else {
13158  lex_state = EXPR_BEG;
13159  }
13160  if (c == '=') {
13161  return tNEQ;
13162  }
13163  if (c == '~') {
13164  return tNMATCH;
13165  }
13166  pushback(c);
13167  return '!';
13168 
13169  case '=':
13170  if (was_bol()) {
13171  /* skip embedded rd document */
13172  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13173 #ifdef RIPPER
13174  int first_p = TRUE;
13175 
13176  lex_goto_eol(parser);
13177  ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13178 #endif
13179  for (;;) {
13180  lex_goto_eol(parser);
13181 #ifdef RIPPER
13182  if (!first_p) {
13183  ripper_dispatch_scan_event(parser, tEMBDOC);
13184  }
13185  first_p = FALSE;
13186 #endif
13187  c = nextc();
13188  if (c == -1) {
13189  compile_error(PARSER_ARG "embedded document meets end of file");
13190  return 0;
13191  }
13192  if (c != '=') continue;
13193  if (strncmp(lex_p, "end", 3) == 0 &&
13194  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13195  break;
13196  }
13197  }
13198  lex_goto_eol(parser);
13199 #ifdef RIPPER
13200  ripper_dispatch_scan_event(parser, tEMBDOC_END);
13201 #endif
13202  goto retry;
13203  }
13204  }
13205 
13206  switch (lex_state) {
13207  case EXPR_FNAME: case EXPR_DOT:
13208  lex_state = EXPR_ARG; break;
13209  default:
13210  lex_state = EXPR_BEG; break;
13211  }
13212  if ((c = nextc()) == '=') {
13213  if ((c = nextc()) == '=') {
13214  return tEQQ;
13215  }
13216  pushback(c);
13217  return tEQ;
13218  }
13219  if (c == '~') {
13220  return tMATCH;
13221  }
13222  else if (c == '>') {
13223  return tASSOC;
13224  }
13225  pushback(c);
13226  return '=';
13227 
13228  case '<':
13229  last_state = lex_state;
13230  c = nextc();
13231  if (c == '<' &&
13232  lex_state != EXPR_DOT &&
13233  lex_state != EXPR_CLASS &&
13234  !IS_END() &&
13235  (!IS_ARG() || space_seen)) {
13236  int token = heredoc_identifier();
13237  if (token) return token;
13238  }
13239  switch (lex_state) {
13240  case EXPR_FNAME: case EXPR_DOT:
13241  lex_state = EXPR_ARG; break;
13242  default:
13243  lex_state = EXPR_BEG; break;
13244  }
13245  if (c == '=') {
13246  if ((c = nextc()) == '>') {
13247  return tCMP;
13248  }
13249  pushback(c);
13250  return tLEQ;
13251  }
13252  if (c == '<') {
13253  if ((c = nextc()) == '=') {
13255  lex_state = EXPR_BEG;
13256  return tOP_ASGN;
13257  }
13258  pushback(c);
13259  warn_balanced("<<", "here document");
13260  return tLSHFT;
13261  }
13262  pushback(c);
13263  return '<';
13264 
13265  case '>':
13266  switch (lex_state) {
13267  case EXPR_FNAME: case EXPR_DOT:
13268  lex_state = EXPR_ARG; break;
13269  default:
13270  lex_state = EXPR_BEG; break;
13271  }
13272  if ((c = nextc()) == '=') {
13273  return tGEQ;
13274  }
13275  if (c == '>') {
13276  if ((c = nextc()) == '=') {
13278  lex_state = EXPR_BEG;
13279  return tOP_ASGN;
13280  }
13281  pushback(c);
13282  return tRSHFT;
13283  }
13284  pushback(c);
13285  return '>';
13286 
13287  case '"':
13288  lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13289  return tSTRING_BEG;
13290 
13291  case '`':
13292  if (lex_state == EXPR_FNAME) {
13294  return c;
13295  }
13296  if (lex_state == EXPR_DOT) {
13297  if (cmd_state)
13299  else
13300  lex_state = EXPR_ARG;
13301  return c;
13302  }
13303  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13304  return tXSTRING_BEG;
13305 
13306  case '\'':
13307  lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13308  return tSTRING_BEG;
13309 
13310  case '?':
13311  if (IS_END()) {
13313  return '?';
13314  }
13315  c = nextc();
13316  if (c == -1) {
13317  compile_error(PARSER_ARG "incomplete character syntax");
13318  return 0;
13319  }
13320  if (rb_enc_isspace(c, parser->enc)) {
13321  if (!IS_ARG()) {
13322  int c2 = 0;
13323  switch (c) {
13324  case ' ':
13325  c2 = 's';
13326  break;
13327  case '\n':
13328  c2 = 'n';
13329  break;
13330  case '\t':
13331  c2 = 't';
13332  break;
13333  case '\v':
13334  c2 = 'v';
13335  break;
13336  case '\r':
13337  c2 = 'r';
13338  break;
13339  case '\f':
13340  c2 = 'f';
13341  break;
13342  }
13343  if (c2) {
13344  rb_warnI("invalid character syntax; use ?\\%c", c2);
13345  }
13346  }
13347  ternary:
13348  pushback(c);
13350  return '?';
13351  }
13352  newtok();
13353  enc = parser->enc;
13354  if (!parser_isascii()) {
13355  if (tokadd_mbchar(c) == -1) return 0;
13356  }
13357  else if ((rb_enc_isalnum(c, parser->enc) || c == '_') &&
13358  lex_p < lex_pend && is_identchar(lex_p, lex_pend, parser->enc)) {
13359  goto ternary;
13360  }
13361  else if (c == '\\') {
13362  if (peek('u')) {
13363  nextc();
13364  c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13365  if (0x80 <= c) {
13366  tokaddmbc(c, enc);
13367  }
13368  else {
13369  tokadd(c);
13370  }
13371  }
13372  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13373  nextc();
13374  if (tokadd_mbchar(c) == -1) return 0;
13375  }
13376  else {
13377  c = read_escape(0, &enc);
13378  tokadd(c);
13379  }
13380  }
13381  else {
13382  tokadd(c);
13383  }
13384  tokfix();
13385  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13386  lex_state = EXPR_END;
13387  return tCHAR;
13388 
13389  case '&':
13390  if ((c = nextc()) == '&') {
13391  lex_state = EXPR_BEG;
13392  if ((c = nextc()) == '=') {
13394  lex_state = EXPR_BEG;
13395  return tOP_ASGN;
13396  }
13397  pushback(c);
13398  return tANDOP;
13399  }
13400  else if (c == '=') {
13401  set_yylval_id('&');
13402  lex_state = EXPR_BEG;
13403  return tOP_ASGN;
13404  }
13405  pushback(c);
13406  if (IS_SPCARG(c)) {
13407  rb_warning0("`&' interpreted as argument prefix");
13408  c = tAMPER;
13409  }
13410  else if (IS_BEG()) {
13411  c = tAMPER;
13412  }
13413  else {
13414  warn_balanced("&", "argument prefix");
13415  c = '&';
13416  }
13417  switch (lex_state) {
13418  case EXPR_FNAME: case EXPR_DOT:
13419  lex_state = EXPR_ARG; break;
13420  default:
13421  lex_state = EXPR_BEG;
13422  }
13423  return c;
13424 
13425  case '|':
13426  if ((c = nextc()) == '|') {
13427  lex_state = EXPR_BEG;
13428  if ((c = nextc()) == '=') {
13430  lex_state = EXPR_BEG;
13431  return tOP_ASGN;
13432  }
13433  pushback(c);
13434  return tOROP;
13435  }
13436  if (c == '=') {
13437  set_yylval_id('|');
13438  lex_state = EXPR_BEG;
13439  return tOP_ASGN;
13440  }
13441  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13442  lex_state = EXPR_ARG;
13443  }
13444  else {
13445  lex_state = EXPR_BEG;
13446  }
13447  pushback(c);
13448  return '|';
13449 
13450  case '+':
13451  c = nextc();
13452  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13453  lex_state = EXPR_ARG;
13454  if (c == '@') {
13455  return tUPLUS;
13456  }
13457  pushback(c);
13458  return '+';
13459  }
13460  if (c == '=') {
13461  set_yylval_id('+');
13462  lex_state = EXPR_BEG;
13463  return tOP_ASGN;
13464  }
13465  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13466  lex_state = EXPR_BEG;
13467  pushback(c);
13468  if (c != -1 && ISDIGIT(c)) {
13469  c = '+';
13470  goto start_num;
13471  }
13472  return tUPLUS;
13473  }
13474  lex_state = EXPR_BEG;
13475  pushback(c);
13476  warn_balanced("+", "unary operator");
13477  return '+';
13478 
13479  case '-':
13480  c = nextc();
13481  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13482  lex_state = EXPR_ARG;
13483  if (c == '@') {
13484  return tUMINUS;
13485  }
13486  pushback(c);
13487  return '-';
13488  }
13489  if (c == '=') {
13490  set_yylval_id('-');
13491  lex_state = EXPR_BEG;
13492  return tOP_ASGN;
13493  }
13494  if (c == '>') {
13495  lex_state = EXPR_ARG;
13496  return tLAMBDA;
13497  }
13498  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13499  lex_state = EXPR_BEG;
13500  pushback(c);
13501  if (c != -1 && ISDIGIT(c)) {
13502  return tUMINUS_NUM;
13503  }
13504  return tUMINUS;
13505  }
13506  lex_state = EXPR_BEG;
13507  pushback(c);
13508  warn_balanced("-", "unary operator");
13509  return '-';
13510 
13511  case '.':
13512  lex_state = EXPR_BEG;
13513  if ((c = nextc()) == '.') {
13514  if ((c = nextc()) == '.') {
13515  return tDOT3;
13516  }
13517  pushback(c);
13518  return tDOT2;
13519  }
13520  pushback(c);
13521  if (c != -1 && ISDIGIT(c)) {
13522  yyerror("no .<digit> floating literal anymore; put 0 before dot");
13523  }
13524  lex_state = EXPR_DOT;
13525  return '.';
13526 
13527  start_num:
13528  case '0': case '1': case '2': case '3': case '4':
13529  case '5': case '6': case '7': case '8': case '9':
13530  {
13531  int is_float, seen_point, seen_e, nondigit;
13532 
13533  is_float = seen_point = seen_e = nondigit = 0;
13534  lex_state = EXPR_END;
13535  newtok();
13536  if (c == '-' || c == '+') {
13537  tokadd(c);
13538  c = nextc();
13539  }
13540  if (c == '0') {
13541 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13542  int start = toklen();
13543  c = nextc();
13544  if (c == 'x' || c == 'X') {
13545  /* hexadecimal */
13546  c = nextc();
13547  if (c != -1 && ISXDIGIT(c)) {
13548  do {
13549  if (c == '_') {
13550  if (nondigit) break;
13551  nondigit = c;
13552  continue;
13553  }
13554  if (!ISXDIGIT(c)) break;
13555  nondigit = 0;
13556  tokadd(c);
13557  } while ((c = nextc()) != -1);
13558  }
13559  pushback(c);
13560  tokfix();
13561  if (toklen() == start) {
13562  no_digits();
13563  }
13564  else if (nondigit) goto trailing_uc;
13566  return tINTEGER;
13567  }
13568  if (c == 'b' || c == 'B') {
13569  /* binary */
13570  c = nextc();
13571  if (c == '0' || c == '1') {
13572  do {
13573  if (c == '_') {
13574  if (nondigit) break;
13575  nondigit = c;
13576  continue;
13577  }
13578  if (c != '0' && c != '1') break;
13579  nondigit = 0;
13580  tokadd(c);
13581  } while ((c = nextc()) != -1);
13582  }
13583  pushback(c);
13584  tokfix();
13585  if (toklen() == start) {
13586  no_digits();
13587  }
13588  else if (nondigit) goto trailing_uc;
13590  return tINTEGER;
13591  }
13592  if (c == 'd' || c == 'D') {
13593  /* decimal */
13594  c = nextc();
13595  if (c != -1 && ISDIGIT(c)) {
13596  do {
13597  if (c == '_') {
13598  if (nondigit) break;
13599  nondigit = c;
13600  continue;
13601  }
13602  if (!ISDIGIT(c)) break;
13603  nondigit = 0;
13604  tokadd(c);
13605  } while ((c = nextc()) != -1);
13606  }
13607  pushback(c);
13608  tokfix();
13609  if (toklen() == start) {
13610  no_digits();
13611  }
13612  else if (nondigit) goto trailing_uc;
13614  return tINTEGER;
13615  }
13616  if (c == '_') {
13617  /* 0_0 */
13618  goto octal_number;
13619  }
13620  if (c == 'o' || c == 'O') {
13621  /* prefixed octal */
13622  c = nextc();
13623  if (c == -1 || c == '_' || !ISDIGIT(c)) {
13624  no_digits();
13625  }
13626  }
13627  if (c >= '0' && c <= '7') {
13628  /* octal */
13629  octal_number:
13630  do {
13631  if (c == '_') {
13632  if (nondigit) break;
13633  nondigit = c;
13634  continue;
13635  }
13636  if (c < '0' || c > '9') break;
13637  if (c > '7') goto invalid_octal;
13638  nondigit = 0;
13639  tokadd(c);
13640  } while ((c = nextc()) != -1);
13641  if (toklen() > start) {
13642  pushback(c);
13643  tokfix();
13644  if (nondigit) goto trailing_uc;
13646  return tINTEGER;
13647  }
13648  if (nondigit) {
13649  pushback(c);
13650  goto trailing_uc;
13651  }
13652  }
13653  if (c > '7' && c <= '9') {
13654  invalid_octal:
13655  yyerror("Invalid octal digit");
13656  }
13657  else if (c == '.' || c == 'e' || c == 'E') {
13658  tokadd('0');
13659  }
13660  else {
13661  pushback(c);
13663  return tINTEGER;
13664  }
13665  }
13666 
13667  for (;;) {
13668  switch (c) {
13669  case '0': case '1': case '2': case '3': case '4':
13670  case '5': case '6': case '7': case '8': case '9':
13671  nondigit = 0;
13672  tokadd(c);
13673  break;
13674 
13675  case '.':
13676  if (nondigit) goto trailing_uc;
13677  if (seen_point || seen_e) {
13678  goto decode_num;
13679  }
13680  else {
13681  int c0 = nextc();
13682  if (c0 == -1 || !ISDIGIT(c0)) {
13683  pushback(c0);
13684  goto decode_num;
13685  }
13686  c = c0;
13687  }
13688  tokadd('.');
13689  tokadd(c);
13690  is_float++;
13691  seen_point++;
13692  nondigit = 0;
13693  break;
13694 
13695  case 'e':
13696  case 'E':
13697  if (nondigit) {
13698  pushback(c);
13699  c = nondigit;
13700  goto decode_num;
13701  }
13702  if (seen_e) {
13703  goto decode_num;
13704  }
13705  tokadd(c);
13706  seen_e++;
13707  is_float++;
13708  nondigit = c;
13709  c = nextc();
13710  if (c != '-' && c != '+') continue;
13711  tokadd(c);
13712  nondigit = c;
13713  break;
13714 
13715  case '_': /* `_' in number just ignored */
13716  if (nondigit) goto decode_num;
13717  nondigit = c;
13718  break;
13719 
13720  default:
13721  goto decode_num;
13722  }
13723  c = nextc();
13724  }
13725 
13726  decode_num:
13727  pushback(c);
13728  if (nondigit) {
13729  char tmp[30];
13730  trailing_uc:
13731  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
13732  yyerror(tmp);
13733  }
13734  tokfix();
13735  if (is_float) {
13736  double d = strtod(tok(), 0);
13737  if (errno == ERANGE) {
13738  rb_warningS("Float %s out of range", tok());
13739  errno = 0;
13740  }
13742  return tFLOAT;
13743  }
13745  return tINTEGER;
13746  }
13747 
13748  case ')':
13749  case ']':
13750  paren_nest--;
13751  case '}':
13752  COND_LEXPOP();
13753  CMDARG_LEXPOP();
13754  if (c == ')')
13756  else
13758  return c;
13759 
13760  case ':':
13761  c = nextc();
13762  if (c == ':') {
13763  if (IS_BEG() || lex_state == EXPR_CLASS || IS_SPCARG(-1)) {
13764  lex_state = EXPR_BEG;
13765  return tCOLON3;
13766  }
13767  lex_state = EXPR_DOT;
13768  return tCOLON2;
13769  }
13770  if (IS_END() || ISSPACE(c)) {
13771  pushback(c);
13772  warn_balanced(":", "symbol literal");
13773  lex_state = EXPR_BEG;
13774  return ':';
13775  }
13776  switch (c) {
13777  case '\'':
13778  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
13779  break;
13780  case '"':
13781  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
13782  break;
13783  default:
13784  pushback(c);
13785  break;
13786  }
13788  return tSYMBEG;
13789 
13790  case '/':
13791  if (IS_BEG()) {
13792  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13793  return tREGEXP_BEG;
13794  }
13795  if ((c = nextc()) == '=') {
13796  set_yylval_id('/');
13797  lex_state = EXPR_BEG;
13798  return tOP_ASGN;
13799  }
13800  pushback(c);
13801  if (IS_SPCARG(c)) {
13802  (void)arg_ambiguous();
13803  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13804  return tREGEXP_BEG;
13805  }
13806  switch (lex_state) {
13807  case EXPR_FNAME: case EXPR_DOT:
13808  lex_state = EXPR_ARG; break;
13809  default:
13810  lex_state = EXPR_BEG; break;
13811  }
13812  warn_balanced("/", "regexp literal");
13813  return '/';
13814 
13815  case '^':
13816  if ((c = nextc()) == '=') {
13817  set_yylval_id('^');
13818  lex_state = EXPR_BEG;
13819  return tOP_ASGN;
13820  }
13821  switch (lex_state) {
13822  case EXPR_FNAME: case EXPR_DOT:
13823  lex_state = EXPR_ARG; break;
13824  default:
13825  lex_state = EXPR_BEG; break;
13826  }
13827  pushback(c);
13828  return '^';
13829 
13830  case ';':
13831  lex_state = EXPR_BEG;
13832  command_start = TRUE;
13833  return ';';
13834 
13835  case ',':
13836  lex_state = EXPR_BEG;
13837  return ',';
13838 
13839  case '~':
13840  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13841  if ((c = nextc()) != '@') {
13842  pushback(c);
13843  }
13844  lex_state = EXPR_ARG;
13845  }
13846  else {
13847  lex_state = EXPR_BEG;
13848  }
13849  return '~';
13850 
13851  case '(':
13852  if (IS_BEG()) {
13853  c = tLPAREN;
13854  }
13855  else if (IS_SPCARG(-1)) {
13856  c = tLPAREN_ARG;
13857  }
13858  paren_nest++;
13859  COND_PUSH(0);
13860  CMDARG_PUSH(0);
13861  lex_state = EXPR_BEG;
13862  return c;
13863 
13864  case '[':
13865  paren_nest++;
13866  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13867  lex_state = EXPR_ARG;
13868  if ((c = nextc()) == ']') {
13869  if ((c = nextc()) == '=') {
13870  return tASET;
13871  }
13872  pushback(c);
13873  return tAREF;
13874  }
13875  pushback(c);
13876  return '[';
13877  }
13878  else if (IS_BEG()) {
13879  c = tLBRACK;
13880  }
13881  else if (IS_ARG() && space_seen) {
13882  c = tLBRACK;
13883  }
13884  lex_state = EXPR_BEG;
13885  COND_PUSH(0);
13886  CMDARG_PUSH(0);
13887  return c;
13888 
13889  case '{':
13890  if (lpar_beg && lpar_beg == paren_nest) {
13891  lex_state = EXPR_BEG;
13892  lpar_beg = 0;
13893  --paren_nest;
13894  COND_PUSH(0);
13895  CMDARG_PUSH(0);
13896  return tLAMBEG;
13897  }
13898  if (IS_ARG() || lex_state == EXPR_END || lex_state == EXPR_ENDFN)
13899  c = '{'; /* block (primary) */
13900  else if (lex_state == EXPR_ENDARG)
13901  c = tLBRACE_ARG; /* block (expr) */
13902  else
13903  c = tLBRACE; /* hash */
13904  COND_PUSH(0);
13905  CMDARG_PUSH(0);
13906  lex_state = EXPR_BEG;
13907  if (c != tLBRACE) command_start = TRUE;
13908  return c;
13909 
13910  case '\\':
13911  c = nextc();
13912  if (c == '\n') {
13913  space_seen = 1;
13914 #ifdef RIPPER
13915  ripper_dispatch_scan_event(parser, tSP);
13916 #endif
13917  goto retry; /* skip \\n */
13918  }
13919  pushback(c);
13920  return '\\';
13921 
13922  case '%':
13923  if (IS_BEG()) {
13924  int term;
13925  int paren;
13926 
13927  c = nextc();
13928  quotation:
13929  if (c == -1 || !ISALNUM(c)) {
13930  term = c;
13931  c = 'Q';
13932  }
13933  else {
13934  term = nextc();
13935  if (rb_enc_isalnum(term, parser->enc) || !parser_isascii()) {
13936  yyerror("unknown type of %string");
13937  return 0;
13938  }
13939  }
13940  if (c == -1 || term == -1) {
13941  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
13942  return 0;
13943  }
13944  paren = term;
13945  if (term == '(') term = ')';
13946  else if (term == '[') term = ']';
13947  else if (term == '{') term = '}';
13948  else if (term == '<') term = '>';
13949  else paren = 0;
13950 
13951  switch (c) {
13952  case 'Q':
13953  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
13954  return tSTRING_BEG;
13955 
13956  case 'q':
13957  lex_strterm = NEW_STRTERM(str_squote, term, paren);
13958  return tSTRING_BEG;
13959 
13960  case 'W':
13961  lex_strterm = NEW_STRTERM(str_dword, term, paren);
13962  do {c = nextc();} while (ISSPACE(c));
13963  pushback(c);
13964  return tWORDS_BEG;
13965 
13966  case 'w':
13967  lex_strterm = NEW_STRTERM(str_sword, term, paren);
13968  do {c = nextc();} while (ISSPACE(c));
13969  pushback(c);
13970  return tQWORDS_BEG;
13971 
13972  case 'x':
13973  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
13974  return tXSTRING_BEG;
13975 
13976  case 'r':
13977  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
13978  return tREGEXP_BEG;
13979 
13980  case 's':
13981  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
13983  return tSYMBEG;
13984 
13985  default:
13986  yyerror("unknown type of %string");
13987  return 0;
13988  }
13989  }
13990  if ((c = nextc()) == '=') {
13991  set_yylval_id('%');
13992  lex_state = EXPR_BEG;
13993  return tOP_ASGN;
13994  }
13995  if (IS_SPCARG(c)) {
13996  goto quotation;
13997  }
13998  switch (lex_state) {
13999  case EXPR_FNAME: case EXPR_DOT:
14000  lex_state = EXPR_ARG; break;
14001  default:
14002  lex_state = EXPR_BEG; break;
14003  }
14004  pushback(c);
14005  warn_balanced("%%", "string literal");
14006  return '%';
14007 
14008  case '$':
14009  lex_state = EXPR_END;
14010  newtok();
14011  c = nextc();
14012  switch (c) {
14013  case '_': /* $_: last read line string */
14014  c = nextc();
14015  if (parser_is_identchar()) {
14016  tokadd('$');
14017  tokadd('_');
14018  break;
14019  }
14020  pushback(c);
14021  c = '_';
14022  /* fall through */
14023  case '~': /* $~: match-data */
14024  case '*': /* $*: argv */
14025  case '$': /* $$: pid */
14026  case '?': /* $?: last status */
14027  case '!': /* $!: error string */
14028  case '@': /* $@: error position */
14029  case '/': /* $/: input record separator */
14030  case '\\': /* $\: output record separator */
14031  case ';': /* $;: field separator */
14032  case ',': /* $,: output field separator */
14033  case '.': /* $.: last read line number */
14034  case '=': /* $=: ignorecase */
14035  case ':': /* $:: load path */
14036  case '<': /* $<: reading filename */
14037  case '>': /* $>: default output handle */
14038  case '\"': /* $": already loaded files */
14039  tokadd('$');
14040  tokadd(c);
14041  tokfix();
14043  return tGVAR;
14044 
14045  case '-':
14046  tokadd('$');
14047  tokadd(c);
14048  c = nextc();
14049  if (parser_is_identchar()) {
14050  if (tokadd_mbchar(c) == -1) return 0;
14051  }
14052  else {
14053  pushback(c);
14054  }
14055  gvar:
14056  tokfix();
14058  return tGVAR;
14059 
14060  case '&': /* $&: last match */
14061  case '`': /* $`: string before last match */
14062  case '\'': /* $': string after last match */
14063  case '+': /* $+: string matches last paren. */
14064  if (last_state == EXPR_FNAME) {
14065  tokadd('$');
14066  tokadd(c);
14067  goto gvar;
14068  }
14070  return tBACK_REF;
14071 
14072  case '1': case '2': case '3':
14073  case '4': case '5': case '6':
14074  case '7': case '8': case '9':
14075  tokadd('$');
14076  do {
14077  tokadd(c);
14078  c = nextc();
14079  } while (c != -1 && ISDIGIT(c));
14080  pushback(c);
14081  if (last_state == EXPR_FNAME) goto gvar;
14082  tokfix();
14083  set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
14084  return tNTH_REF;
14085 
14086  default:
14087  if (!parser_is_identchar()) {
14088  pushback(c);
14089  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14090  return 0;
14091  }
14092  case '0':
14093  tokadd('$');
14094  }
14095  break;
14096 
14097  case '@':
14098  c = nextc();
14099  newtok();
14100  tokadd('@');
14101  if (c == '@') {
14102  tokadd('@');
14103  c = nextc();
14104  }
14105  if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14106  pushback(c);
14107  if (tokidx == 1) {
14108  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14109  }
14110  else {
14111  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14112  }
14113  return 0;
14114  }
14115  break;
14116 
14117  case '_':
14118  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14119  ruby__end__seen = 1;
14120  parser->eofp = Qtrue;
14121 #ifndef RIPPER
14122  return -1;
14123 #else
14124  lex_goto_eol(parser);
14125  ripper_dispatch_scan_event(parser, k__END__);
14126  return 0;
14127 #endif
14128  }
14129  newtok();
14130  break;
14131 
14132  default:
14133  if (!parser_is_identchar()) {
14134  rb_compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14135  goto retry;
14136  }
14137 
14138  newtok();
14139  break;
14140  }
14141 
14142  mb = ENC_CODERANGE_7BIT;
14143  do {
14144  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14145  if (tokadd_mbchar(c) == -1) return 0;
14146  c = nextc();
14147  } while (parser_is_identchar());
14148  switch (tok()[0]) {
14149  case '@': case '$':
14150  pushback(c);
14151  break;
14152  default:
14153  if ((c == '!' || c == '?') && !peek('=')) {
14154  tokadd(c);
14155  }
14156  else {
14157  pushback(c);
14158  }
14159  }
14160  tokfix();
14161 
14162  {
14163  int result = 0;
14164 
14165  last_state = lex_state;
14166  switch (tok()[0]) {
14167  case '$':
14168  lex_state = EXPR_END;
14169  result = tGVAR;
14170  break;
14171  case '@':
14172  lex_state = EXPR_END;
14173  if (tok()[1] == '@')
14174  result = tCVAR;
14175  else
14176  result = tIVAR;
14177  break;
14178 
14179  default:
14180  if (toklast() == '!' || toklast() == '?') {
14181  result = tFID;
14182  }
14183  else {
14184  if (lex_state == EXPR_FNAME) {
14185  if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14186  (!peek('=') || (peek_n('>', 1)))) {
14187  result = tIDENTIFIER;
14188  tokadd(c);
14189  tokfix();
14190  }
14191  else {
14192  pushback(c);
14193  }
14194  }
14195  if (result == 0 && ISUPPER(tok()[0])) {
14196  result = tCONSTANT;
14197  }
14198  else {
14199  result = tIDENTIFIER;
14200  }
14201  }
14202 
14203  if (IS_LABEL_POSSIBLE()) {
14204  if (IS_LABEL_SUFFIX(0)) {
14205  lex_state = EXPR_BEG;
14206  nextc();
14208  return tLABEL;
14209  }
14210  }
14211  if (mb == ENC_CODERANGE_7BIT && lex_state != EXPR_DOT) {
14212  const struct kwtable *kw;
14213 
14214  /* See if it is a reserved word. */
14215  kw = rb_reserved_word(tok(), toklen());
14216  if (kw) {
14217  enum lex_state_e state = lex_state;
14218  lex_state = kw->state;
14219  if (state == EXPR_FNAME) {
14221  return kw->id[0];
14222  }
14223  if (kw->id[0] == keyword_do) {
14224  command_start = TRUE;
14225  if (lpar_beg && lpar_beg == paren_nest) {
14226  lpar_beg = 0;
14227  --paren_nest;
14228  return keyword_do_LAMBDA;
14229  }
14230  if (COND_P()) return keyword_do_cond;
14231  if (CMDARG_P() && state != EXPR_CMDARG)
14232  return keyword_do_block;
14233  if (state == EXPR_ENDARG || state == EXPR_BEG)
14234  return keyword_do_block;
14235  return keyword_do;
14236  }
14237  if (state == EXPR_BEG || state == EXPR_VALUE)
14238  return kw->id[0];
14239  else {
14240  if (kw->id[0] != kw->id[1])
14241  lex_state = EXPR_BEG;
14242  return kw->id[1];
14243  }
14244  }
14245  }
14246 
14247  if (IS_BEG() ||
14248  lex_state == EXPR_DOT ||
14249  IS_ARG()) {
14250  if (cmd_state) {
14252  }
14253  else {
14254  lex_state = EXPR_ARG;
14255  }
14256  }
14257  else if (lex_state == EXPR_FNAME) {
14259  }
14260  else {
14261  lex_state = EXPR_END;
14262  }
14263  }
14264  {
14265  ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14266 
14267  set_yylval_name(ident);
14268  if (last_state != EXPR_DOT && last_state != EXPR_FNAME &&
14269  is_local_id(ident) && lvar_defined(ident)) {
14270  lex_state = EXPR_END;
14271  }
14272  }
14273  return result;
14274  }
14275 }
14276 
14277 #if YYPURE
14278 static int
14279 yylex(void *lval, void *p)
14280 #else
14281 yylex(void *p)
14282 #endif
14284  struct parser_params *parser = (struct parser_params*)p;
14285  int t;
14286 
14287 #if YYPURE
14288  parser->parser_yylval = lval;
14290 #endif
14291  t = parser_yylex(parser);
14292 #ifdef RIPPER
14293  if (!NIL_P(parser->delayed)) {
14294  ripper_dispatch_delayed_token(parser, t);
14295  return t;
14296  }
14297  if (t != 0)
14298  ripper_dispatch_scan_event(parser, t);
14299 #endif
14300 
14301  return t;
14302 }
14303 
14304 #ifndef RIPPER
14305 static NODE*
14306 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14307 {
14308  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14310  return n;
14311 }
14312 
14313 enum node_type
14314 nodetype(NODE *node) /* for debug */
14315 {
14316  return (enum node_type)nd_type(node);
14317 }
14318 
14319 int
14321 {
14322  return nd_line(node);
14323 }
14324 
14325 static NODE*
14327 {
14328  if (node) {
14329  node = remove_begin(node);
14330  node->flags |= NODE_FL_NEWLINE;
14331  }
14332  return node;
14333 }
14334 
14335 static void
14336 fixpos(NODE *node, NODE *orig)
14337 {
14338  if (!node) return;
14339  if (!orig) return;
14340  if (orig == (NODE*)1) return;
14341  nd_set_line(node, nd_line(orig));
14342 }
14343 
14344 static void
14345 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14346 {
14347  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14348 }
14349 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14350 
14351 static void
14352 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14353 {
14354  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14355 }
14356 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14357 
14358 static NODE*
14359 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14360 {
14361  NODE *end, *h = head, *nd;
14362 
14363  if (tail == 0) return head;
14364 
14365  if (h == 0) return tail;
14366  switch (nd_type(h)) {
14367  case NODE_LIT:
14368  case NODE_STR:
14369  case NODE_SELF:
14370  case NODE_TRUE:
14371  case NODE_FALSE:
14372  case NODE_NIL:
14373  parser_warning(h, "unused literal ignored");
14374  return tail;
14375  default:
14376  h = end = NEW_BLOCK(head);
14377  end->nd_end = end;
14378  fixpos(end, head);
14379  head = end;
14380  break;
14381  case NODE_BLOCK:
14382  end = h->nd_end;
14383  break;
14384  }
14385 
14386  nd = end->nd_head;
14387  switch (nd_type(nd)) {
14388  case NODE_RETURN:
14389  case NODE_BREAK:
14390  case NODE_NEXT:
14391  case NODE_REDO:
14392  case NODE_RETRY:
14393  if (RTEST(ruby_verbose)) {
14394  parser_warning(nd, "statement not reached");
14395  }
14396  break;
14397 
14398  default:
14399  break;
14400  }
14401 
14402  if (nd_type(tail) != NODE_BLOCK) {
14403  tail = NEW_BLOCK(tail);
14404  tail->nd_end = tail;
14405  }
14406  end->nd_next = tail;
14407  h->nd_end = tail->nd_end;
14408  return head;
14409 }
14410 
14411 /* append item to the list */
14412 static NODE*
14413 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14414 {
14415  NODE *last;
14416 
14417  if (list == 0) return NEW_LIST(item);
14418  if (list->nd_next) {
14419  last = list->nd_next->nd_end;
14420  }
14421  else {
14422  last = list;
14423  }
14424 
14425  list->nd_alen += 1;
14426  last->nd_next = NEW_LIST(item);
14427  list->nd_next->nd_end = last->nd_next;
14428  return list;
14429 }
14430 
14431 /* concat two lists */
14432 static NODE*
14433 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14434 {
14435  NODE *last;
14436 
14437  if (head->nd_next) {
14438  last = head->nd_next->nd_end;
14439  }
14440  else {
14441  last = head;
14442  }
14443 
14444  head->nd_alen += tail->nd_alen;
14445  last->nd_next = tail;
14446  if (tail->nd_next) {
14447  head->nd_next->nd_end = tail->nd_next->nd_end;
14448  }
14449  else {
14450  head->nd_next->nd_end = tail;
14451  }
14452 
14453  return head;
14454 }
14455 
14456 static int
14457 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
14458 {
14459  if (NIL_P(tail)) return 1;
14460  if (!rb_enc_compatible(head, tail)) {
14461  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14462  rb_enc_name(rb_enc_get(head)),
14463  rb_enc_name(rb_enc_get(tail)));
14464  rb_str_resize(head, 0);
14465  rb_str_resize(tail, 0);
14466  return 0;
14467  }
14468  rb_str_buf_append(head, tail);
14469  return 1;
14470 }
14471 
14472 /* concat two string literals */
14473 static NODE *
14474 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14475 {
14476  enum node_type htype;
14477 
14478  if (!head) return tail;
14479  if (!tail) return head;
14480 
14481  htype = nd_type(head);
14482  if (htype == NODE_EVSTR) {
14483  NODE *node = NEW_DSTR(Qnil);
14484  head = list_append(node, head);
14485  }
14486  switch (nd_type(tail)) {
14487  case NODE_STR:
14488  if (htype == NODE_STR) {
14489  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit)) {
14490  error:
14491  rb_gc_force_recycle((VALUE)head);
14492  rb_gc_force_recycle((VALUE)tail);
14493  return 0;
14494  }
14495  rb_gc_force_recycle((VALUE)tail);
14496  }
14497  else {
14498  list_append(head, tail);
14499  }
14500  break;
14501 
14502  case NODE_DSTR:
14503  if (htype == NODE_STR) {
14504  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14505  goto error;
14506  tail->nd_lit = head->nd_lit;
14507  rb_gc_force_recycle((VALUE)head);
14508  head = tail;
14509  }
14510  else if (NIL_P(tail->nd_lit)) {
14511  head->nd_alen += tail->nd_alen - 1;
14512  head->nd_next->nd_end->nd_next = tail->nd_next;
14513  head->nd_next->nd_end = tail->nd_next->nd_end;
14514  rb_gc_force_recycle((VALUE)tail);
14515  }
14516  else {
14517  nd_set_type(tail, NODE_ARRAY);
14518  tail->nd_head = NEW_STR(tail->nd_lit);
14519  list_concat(head, tail);
14520  }
14521  break;
14522 
14523  case NODE_EVSTR:
14524  if (htype == NODE_STR) {
14525  nd_set_type(head, NODE_DSTR);
14526  head->nd_alen = 1;
14527  }
14528  list_append(head, tail);
14529  break;
14530  }
14531  return head;
14532 }
14533 
14534 static NODE *
14535 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14536 {
14537  if (nd_type(node) == NODE_EVSTR) {
14538  node = list_append(NEW_DSTR(Qnil), node);
14539  }
14540  return node;
14541 }
14542 
14543 static NODE *
14544 new_evstr_gen(struct parser_params *parser, NODE *node)
14545 {
14546  NODE *head = node;
14547 
14548  if (node) {
14549  switch (nd_type(node)) {
14550  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14551  return node;
14552  }
14553  }
14554  return NEW_EVSTR(head);
14555 }
14556 
14557 static NODE *
14558 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14559 {
14560  value_expr(recv);
14561  value_expr(arg1);
14562  return NEW_CALL(recv, id, NEW_LIST(arg1));
14563 }
14564 
14565 static NODE *
14566 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
14567 {
14568  value_expr(recv);
14569  return NEW_CALL(recv, id, 0);
14570 }
14571 
14572 static NODE*
14573 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14574 {
14575  value_expr(node1);
14576  value_expr(node2);
14577  if (node1) {
14578  switch (nd_type(node1)) {
14579  case NODE_DREGX:
14580  case NODE_DREGX_ONCE:
14581  return NEW_MATCH2(node1, node2);
14582 
14583  case NODE_LIT:
14584  if (TYPE(node1->nd_lit) == T_REGEXP) {
14585  return NEW_MATCH2(node1, node2);
14586  }
14587  }
14588  }
14589 
14590  if (node2) {
14591  switch (nd_type(node2)) {
14592  case NODE_DREGX:
14593  case NODE_DREGX_ONCE:
14594  return NEW_MATCH3(node2, node1);
14595 
14596  case NODE_LIT:
14597  if (TYPE(node2->nd_lit) == T_REGEXP) {
14598  return NEW_MATCH3(node2, node1);
14599  }
14600  }
14601  }
14602 
14603  return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
14604 }
14605 
14606 static NODE*
14607 gettable_gen(struct parser_params *parser, ID id)
14608 {
14609  if (id == keyword_self) {
14610  return NEW_SELF();
14611  }
14612  else if (id == keyword_nil) {
14613  return NEW_NIL();
14614  }
14615  else if (id == keyword_true) {
14616  return NEW_TRUE();
14617  }
14618  else if (id == keyword_false) {
14619  return NEW_FALSE();
14620  }
14621  else if (id == keyword__FILE__) {
14624  }
14625  else if (id == keyword__LINE__) {
14626  return NEW_LIT(INT2FIX(ruby_sourceline));
14627  }
14628  else if (id == keyword__ENCODING__) {
14629  return NEW_LIT(rb_enc_from_encoding(parser->enc));
14630  }
14631  else if (is_local_id(id)) {
14632  if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
14633  if (local_id(id)) return NEW_LVAR(id);
14634  /* method call without arguments */
14635  return NEW_VCALL(id);
14636  }
14637  else if (is_global_id(id)) {
14638  return NEW_GVAR(id);
14639  }
14640  else if (is_instance_id(id)) {
14641  return NEW_IVAR(id);
14642  }
14643  else if (is_const_id(id)) {
14644  return NEW_CONST(id);
14645  }
14646  else if (is_class_id(id)) {
14647  return NEW_CVAR(id);
14648  }
14649  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14650  return 0;
14651 }
14652 #else /* !RIPPER */
14653 static int
14654 id_is_var_gen(struct parser_params *parser, ID id)
14655 {
14656  if (is_notop_id(id)) {
14657  switch (id & ID_SCOPE_MASK) {
14658  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
14659  return 1;
14660  case ID_LOCAL:
14661  if (dyna_in_block() && dvar_defined(id)) return 1;
14662  if (local_id(id)) return 1;
14663  /* method call without arguments */
14664  return 0;
14665  }
14666  }
14667  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14668  return 0;
14669 }
14670 #endif /* !RIPPER */
14671 
14672 #ifdef RIPPER
14673 static VALUE
14674 assignable_gen(struct parser_params *parser, VALUE lhs)
14675 #else
14676 static NODE*
14677 assignable_gen(struct parser_params *parser, ID id, NODE *val)
14678 #endif
14679 {
14680 #ifdef RIPPER
14681  ID id = get_id(lhs);
14682 # define assignable_result(x) get_value(lhs)
14683 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
14684 #else
14685 # define assignable_result(x) (x)
14686 #endif
14687  if (!id) return assignable_result(0);
14688  if (id == keyword_self) {
14689  yyerror("Can't change the value of self");
14690  }
14691  else if (id == keyword_nil) {
14692  yyerror("Can't assign to nil");
14693  }
14694  else if (id == keyword_true) {
14695  yyerror("Can't assign to true");
14696  }
14697  else if (id == keyword_false) {
14698  yyerror("Can't assign to false");
14699  }
14700  else if (id == keyword__FILE__) {
14701  yyerror("Can't assign to __FILE__");
14702  }
14703  else if (id == keyword__LINE__) {
14704  yyerror("Can't assign to __LINE__");
14705  }
14706  else if (id == keyword__ENCODING__) {
14707  yyerror("Can't assign to __ENCODING__");
14708  }
14709  else if (is_local_id(id)) {
14710  if (dyna_in_block()) {
14711  if (dvar_curr(id)) {
14712  return assignable_result(NEW_DASGN_CURR(id, val));
14713  }
14714  else if (dvar_defined(id)) {
14715  return assignable_result(NEW_DASGN(id, val));
14716  }
14717  else if (local_id(id)) {
14718  return assignable_result(NEW_LASGN(id, val));
14719  }
14720  else {
14721  dyna_var(id);
14722  return assignable_result(NEW_DASGN_CURR(id, val));
14723  }
14724  }
14725  else {
14726  if (!local_id(id)) {
14727  local_var(id);
14728  }
14729  return assignable_result(NEW_LASGN(id, val));
14730  }
14731  }
14732  else if (is_global_id(id)) {
14733  return assignable_result(NEW_GASGN(id, val));
14734  }
14735  else if (is_instance_id(id)) {
14736  return assignable_result(NEW_IASGN(id, val));
14737  }
14738  else if (is_const_id(id)) {
14739  if (!in_def && !in_single)
14740  return assignable_result(NEW_CDECL(id, val, 0));
14741  yyerror("dynamic constant assignment");
14742  }
14743  else if (is_class_id(id)) {
14744  return assignable_result(NEW_CVASGN(id, val));
14745  }
14746  else {
14747  compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
14748  }
14749  return assignable_result(0);
14750 #undef assignable_result
14751 #undef parser_yyerror
14752 }
14753 
14754 #define LVAR_USED ((int)1 << (sizeof(int) * CHAR_BIT - 1))
14755 
14756 static ID
14757 shadowing_lvar_gen(struct parser_params *parser, ID name)
14758 {
14759  if (idUScore == name) return name;
14760  if (dyna_in_block()) {
14761  if (dvar_curr(name)) {
14762  yyerror("duplicated argument name");
14763  }
14764  else if (dvar_defined_get(name) || local_id(name)) {
14765  rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
14766  vtable_add(lvtbl->vars, name);
14767  if (lvtbl->used) {
14769  }
14770  }
14771  }
14772  else {
14773  if (local_id(name)) {
14774  yyerror("duplicated argument name");
14775  }
14776  }
14777  return name;
14778 }
14779 
14780 static void
14781 new_bv_gen(struct parser_params *parser, ID name)
14782 {
14783  if (!name) return;
14784  if (!is_local_id(name)) {
14785  compile_error(PARSER_ARG "invalid local variable - %s",
14786  rb_id2name(name));
14787  return;
14788  }
14789  shadowing_lvar(name);
14790  dyna_var(name);
14791 }
14792 
14793 #ifndef RIPPER
14794 static NODE *
14795 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
14796 {
14797  if (recv && nd_type(recv) == NODE_SELF)
14798  recv = (NODE *)1;
14799  return NEW_ATTRASGN(recv, tASET, idx);
14800 }
14801 
14802 static void
14803 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14804 {
14805  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
14806  compile_error(PARSER_ARG "both block arg and actual block given");
14807  }
14808 }
14809 
14810 ID
14812 {
14813  id &= ~ID_SCOPE_MASK;
14814  id |= ID_ATTRSET;
14815  return id;
14816 }
14817 
14818 static NODE *
14819 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
14820 {
14821  if (recv && nd_type(recv) == NODE_SELF)
14822  recv = (NODE *)1;
14823  return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
14824 }
14825 
14826 static void
14828 {
14829  switch (nd_type(node)) {
14830  case NODE_NTH_REF:
14831  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
14832  break;
14833  case NODE_BACK_REF:
14834  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
14835  break;
14836  }
14837 }
14838 
14839 static NODE *
14840 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14841 {
14842  if (!node2) return node1;
14843  switch (nd_type(node1)) {
14844  case NODE_BLOCK_PASS:
14845  if (node1->nd_head)
14846  node1->nd_head = arg_concat(node1->nd_head, node2);
14847  else
14848  node1->nd_head = NEW_LIST(node2);
14849  return node1;
14850  case NODE_ARGSPUSH:
14851  if (nd_type(node2) != NODE_ARRAY) break;
14852  node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
14853  nd_set_type(node1, NODE_ARGSCAT);
14854  return node1;
14855  case NODE_ARGSCAT:
14856  if (nd_type(node2) != NODE_ARRAY ||
14857  nd_type(node1->nd_body) != NODE_ARRAY) break;
14858  node1->nd_body = list_concat(node1->nd_body, node2);
14859  return node1;
14860  }
14861  return NEW_ARGSCAT(node1, node2);
14862 }
14863 
14864 static NODE *
14865 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14866 {
14867  if (!node1) return NEW_LIST(node2);
14868  switch (nd_type(node1)) {
14869  case NODE_ARRAY:
14870  return list_append(node1, node2);
14871  case NODE_BLOCK_PASS:
14872  node1->nd_head = arg_append(node1->nd_head, node2);
14873  return node1;
14874  case NODE_ARGSPUSH:
14875  node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
14876  nd_set_type(node1, NODE_ARGSCAT);
14877  return node1;
14878  }
14879  return NEW_ARGSPUSH(node1, node2);
14880 }
14881 
14882 static NODE *
14884 {
14885  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
14886  if (nd_type(node) == NODE_ARRAY) return node;
14887  return 0;
14888 }
14889 
14890 static NODE *
14891 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
14892 {
14893  if (!lhs) return 0;
14894 
14895  switch (nd_type(lhs)) {
14896  case NODE_GASGN:
14897  case NODE_IASGN:
14898  case NODE_IASGN2:
14899  case NODE_LASGN:
14900  case NODE_DASGN:
14901  case NODE_DASGN_CURR:
14902  case NODE_MASGN:
14903  case NODE_CDECL:
14904  case NODE_CVASGN:
14905  lhs->nd_value = rhs;
14906  break;
14907 
14908  case NODE_ATTRASGN:
14909  case NODE_CALL:
14910  lhs->nd_args = arg_append(lhs->nd_args, rhs);
14911  break;
14912 
14913  default:
14914  /* should not happen */
14915  break;
14916  }
14917 
14918  return lhs;
14919 }
14920 
14921 static int
14922 value_expr_gen(struct parser_params *parser, NODE *node)
14923 {
14924  int cond = 0;
14925 
14926  if (!node) {
14927  rb_warning0("empty expression");
14928  }
14929  while (node) {
14930  switch (nd_type(node)) {
14931  case NODE_DEFN:
14932  case NODE_DEFS:
14933  parser_warning(node, "void value expression");
14934  return FALSE;
14935 
14936  case NODE_RETURN:
14937  case NODE_BREAK:
14938  case NODE_NEXT:
14939  case NODE_REDO:
14940  case NODE_RETRY:
14941  if (!cond) yyerror("void value expression");
14942  /* or "control never reach"? */
14943  return FALSE;
14944 
14945  case NODE_BLOCK:
14946  while (node->nd_next) {
14947  node = node->nd_next;
14948  }
14949  node = node->nd_head;
14950  break;
14951 
14952  case NODE_BEGIN:
14953  node = node->nd_body;
14954  break;
14955 
14956  case NODE_IF:
14957  if (!node->nd_body) {
14958  node = node->nd_else;
14959  break;
14960  }
14961  else if (!node->nd_else) {
14962  node = node->nd_body;
14963  break;
14964  }
14965  if (!value_expr(node->nd_body)) return FALSE;
14966  node = node->nd_else;
14967  break;
14968 
14969  case NODE_AND:
14970  case NODE_OR:
14971  cond = 1;
14972  node = node->nd_2nd;
14973  break;
14974 
14975  default:
14976  return TRUE;
14977  }
14978  }
14979 
14980  return TRUE;
14981 }
14982 
14983 static void
14984 void_expr_gen(struct parser_params *parser, NODE *node)
14985 {
14986  const char *useless = 0;
14987 
14988  if (!RTEST(ruby_verbose)) return;
14989 
14990  if (!node) return;
14991  switch (nd_type(node)) {
14992  case NODE_CALL:
14993  switch (node->nd_mid) {
14994  case '+':
14995  case '-':
14996  case '*':
14997  case '/':
14998  case '%':
14999  case tPOW:
15000  case tUPLUS:
15001  case tUMINUS:
15002  case '|':
15003  case '^':
15004  case '&':
15005  case tCMP:
15006  case '>':
15007  case tGEQ:
15008  case '<':
15009  case tLEQ:
15010  case tEQ:
15011  case tNEQ:
15012  useless = rb_id2name(node->nd_mid);
15013  break;
15014  }
15015  break;
15016 
15017  case NODE_LVAR:
15018  case NODE_DVAR:
15019  case NODE_GVAR:
15020  case NODE_IVAR:
15021  case NODE_CVAR:
15022  case NODE_NTH_REF:
15023  case NODE_BACK_REF:
15024  useless = "a variable";
15025  break;
15026  case NODE_CONST:
15027  useless = "a constant";
15028  break;
15029  case NODE_LIT:
15030  case NODE_STR:
15031  case NODE_DSTR:
15032  case NODE_DREGX:
15033  case NODE_DREGX_ONCE:
15034  useless = "a literal";
15035  break;
15036  case NODE_COLON2:
15037  case NODE_COLON3:
15038  useless = "::";
15039  break;
15040  case NODE_DOT2:
15041  useless = "..";
15042  break;
15043  case NODE_DOT3:
15044  useless = "...";
15045  break;
15046  case NODE_SELF:
15047  useless = "self";
15048  break;
15049  case NODE_NIL:
15050  useless = "nil";
15051  break;
15052  case NODE_TRUE:
15053  useless = "true";
15054  break;
15055  case NODE_FALSE:
15056  useless = "false";
15057  break;
15058  case NODE_DEFINED:
15059  useless = "defined?";
15060  break;
15061  }
15062 
15063  if (useless) {
15064  int line = ruby_sourceline;
15065 
15066  ruby_sourceline = nd_line(node);
15067  rb_warnS("possibly useless use of %s in void context", useless);
15068  ruby_sourceline = line;
15069  }
15070 }
15071 
15072 static void
15073 void_stmts_gen(struct parser_params *parser, NODE *node)
15074 {
15075  if (!RTEST(ruby_verbose)) return;
15076  if (!node) return;
15077  if (nd_type(node) != NODE_BLOCK) return;
15078 
15079  for (;;) {
15080  if (!node->nd_next) return;
15081  void_expr0(node->nd_head);
15082  node = node->nd_next;
15083  }
15084 }
15085 
15086 static NODE *
15088 {
15089  NODE **n = &node, *n1 = node;
15090  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15091  *n = n1 = n1->nd_body;
15092  }
15093  return node;
15094 }
15095 
15096 static void
15097 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15098 {
15099  NODE *node = *body;
15100 
15101  if (!node) {
15102  *body = NEW_NIL();
15103  return;
15104  }
15105 #define subnodes(n1, n2) \
15106  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15107  (!node->n2) ? (body = &node->n1, 1) : \
15108  (reduce_nodes(&node->n1), body = &node->n2, 1))
15109 
15110  while (node) {
15111  int newline = (int)(node->flags & NODE_FL_NEWLINE);
15112  switch (nd_type(node)) {
15113  end:
15114  case NODE_NIL:
15115  *body = 0;
15116  return;
15117  case NODE_RETURN:
15118  *body = node = node->nd_stts;
15119  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15120  continue;
15121  case NODE_BEGIN:
15122  *body = node = node->nd_body;
15123  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15124  continue;
15125  case NODE_BLOCK:
15126  body = &node->nd_end->nd_head;
15127  break;
15128  case NODE_IF:
15129  if (subnodes(nd_body, nd_else)) break;
15130  return;
15131  case NODE_CASE:
15132  body = &node->nd_body;
15133  break;
15134  case NODE_WHEN:
15135  if (!subnodes(nd_body, nd_next)) goto end;
15136  break;
15137  case NODE_ENSURE:
15138  if (!subnodes(nd_head, nd_resq)) goto end;
15139  break;
15140  case NODE_RESCUE:
15141  if (node->nd_else) {
15142  body = &node->nd_resq;
15143  break;
15144  }
15145  if (!subnodes(nd_head, nd_resq)) goto end;
15146  break;
15147  default:
15148  return;
15149  }
15150  node = *body;
15151  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15152  }
15153 
15154 #undef subnodes
15155 }
15156 
15157 static int
15158 assign_in_cond(struct parser_params *parser, NODE *node)
15159 {
15160  switch (nd_type(node)) {
15161  case NODE_MASGN:
15162  yyerror("multiple assignment in conditional");
15163  return 1;
15164 
15165  case NODE_LASGN:
15166  case NODE_DASGN:
15167  case NODE_DASGN_CURR:
15168  case NODE_GASGN:
15169  case NODE_IASGN:
15170  break;
15171 
15172  default:
15173  return 0;
15174  }
15175 
15176  if (!node->nd_value) return 1;
15177  switch (nd_type(node->nd_value)) {
15178  case NODE_LIT:
15179  case NODE_STR:
15180  case NODE_NIL:
15181  case NODE_TRUE:
15182  case NODE_FALSE:
15183  /* reports always */
15184  parser_warn(node->nd_value, "found = in conditional, should be ==");
15185  return 1;
15186 
15187  case NODE_DSTR:
15188  case NODE_XSTR:
15189  case NODE_DXSTR:
15190  case NODE_EVSTR:
15191  case NODE_DREGX:
15192  default:
15193  break;
15194  }
15195  return 1;
15196 }
15197 
15198 static void
15199 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15200 {
15201  if (!e_option_supplied(parser)) parser_warn(node, str);
15202 }
15203 
15204 static void
15205 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15206 {
15207  if (!e_option_supplied(parser)) parser_warning(node, str);
15208 }
15209 
15210 static void
15211 fixup_nodes(NODE **rootnode)
15212 {
15213  NODE *node, *next, *head;
15214 
15215  for (node = *rootnode; node; node = next) {
15216  enum node_type type;
15217  VALUE val;
15218 
15219  next = node->nd_next;
15220  head = node->nd_head;
15221  rb_gc_force_recycle((VALUE)node);
15222  *rootnode = next;
15223  switch (type = nd_type(head)) {
15224  case NODE_DOT2:
15225  case NODE_DOT3:
15226  val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15227  type == NODE_DOT3);
15228  rb_gc_force_recycle((VALUE)head->nd_beg);
15229  rb_gc_force_recycle((VALUE)head->nd_end);
15230  nd_set_type(head, NODE_LIT);
15231  head->nd_lit = val;
15232  break;
15233  default:
15234  break;
15235  }
15236  }
15237 }
15238 
15239 static NODE *cond0(struct parser_params*,NODE*);
15240 
15241 static NODE*
15242 range_op(struct parser_params *parser, NODE *node)
15243 {
15244  enum node_type type;
15245 
15246  if (node == 0) return 0;
15247 
15248  type = nd_type(node);
15249  value_expr(node);
15250  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15251  warn_unless_e_option(parser, node, "integer literal in conditional range");
15252  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15253  }
15254  return cond0(parser, node);
15255 }
15256 
15257 static int
15259 {
15260  if (!node) return 1; /* same as NODE_NIL */
15261  switch (nd_type(node)) {
15262  case NODE_LIT:
15263  case NODE_STR:
15264  case NODE_DSTR:
15265  case NODE_EVSTR:
15266  case NODE_DREGX:
15267  case NODE_DREGX_ONCE:
15268  case NODE_DSYM:
15269  return 2;
15270  case NODE_TRUE:
15271  case NODE_FALSE:
15272  case NODE_NIL:
15273  return 1;
15274  }
15275  return 0;
15276 }
15277 
15278 static NODE*
15279 cond0(struct parser_params *parser, NODE *node)
15280 {
15281  if (node == 0) return 0;
15282  assign_in_cond(parser, node);
15283 
15284  switch (nd_type(node)) {
15285  case NODE_DSTR:
15286  case NODE_EVSTR:
15287  case NODE_STR:
15288  rb_warn0("string literal in condition");
15289  break;
15290 
15291  case NODE_DREGX:
15292  case NODE_DREGX_ONCE:
15293  warning_unless_e_option(parser, node, "regex literal in condition");
15294  return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15295 
15296  case NODE_AND:
15297  case NODE_OR:
15298  node->nd_1st = cond0(parser, node->nd_1st);
15299  node->nd_2nd = cond0(parser, node->nd_2nd);
15300  break;
15301 
15302  case NODE_DOT2:
15303  case NODE_DOT3:
15304  node->nd_beg = range_op(parser, node->nd_beg);
15305  node->nd_end = range_op(parser, node->nd_end);
15306  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15307  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15308  if (!e_option_supplied(parser)) {
15309  int b = literal_node(node->nd_beg);
15310  int e = literal_node(node->nd_end);
15311  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15312  parser_warn(node, "range literal in condition");
15313  }
15314  }
15315  break;
15316 
15317  case NODE_DSYM:
15318  parser_warning(node, "literal in condition");
15319  break;
15320 
15321  case NODE_LIT:
15322  if (TYPE(node->nd_lit) == T_REGEXP) {
15323  warn_unless_e_option(parser, node, "regex literal in condition");
15324  nd_set_type(node, NODE_MATCH);
15325  }
15326  else {
15327  parser_warning(node, "literal in condition");
15328  }
15329  default:
15330  break;
15331  }
15332  return node;
15333 }
15334 
15335 static NODE*
15336 cond_gen(struct parser_params *parser, NODE *node)
15337 {
15338  if (node == 0) return 0;
15339  return cond0(parser, node);
15340 }
15341 
15342 static NODE*
15343 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15344 {
15345  value_expr(left);
15346  if (left && (enum node_type)nd_type(left) == type) {
15347  NODE *node = left, *second;
15348  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15349  node = second;
15350  }
15351  node->nd_2nd = NEW_NODE(type, second, right, 0);
15352  return left;
15353  }
15354  return NEW_NODE(type, left, right, 0);
15355 }
15356 
15357 static void
15358 no_blockarg(struct parser_params *parser, NODE *node)
15359 {
15360  if (node && nd_type(node) == NODE_BLOCK_PASS) {
15361  compile_error(PARSER_ARG "block argument should not be given");
15362  }
15363 }
15364 
15365 static NODE *
15366 ret_args_gen(struct parser_params *parser, NODE *node)
15367 {
15368  if (node) {
15369  no_blockarg(parser, node);
15370  if (nd_type(node) == NODE_ARRAY) {
15371  if (node->nd_next == 0) {
15372  node = node->nd_head;
15373  }
15374  else {
15375  nd_set_type(node, NODE_VALUES);
15376  }
15377  }
15378  }
15379  return node;
15380 }
15381 
15382 static NODE *
15383 new_yield_gen(struct parser_params *parser, NODE *node)
15384 {
15385  long state = Qtrue;
15386 
15387  if (node) {
15388  no_blockarg(parser, node);
15389  if (node && nd_type(node) == NODE_SPLAT) {
15390  state = Qtrue;
15391  }
15392  }
15393  else {
15394  state = Qfalse;
15395  }
15396  return NEW_YIELD(node, state);
15397 }
15398 
15399 static NODE*
15401 {
15402  switch (TYPE(node->nd_lit)) {
15403  case T_FIXNUM:
15404  node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15405  break;
15406  case T_BIGNUM:
15407  node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15408  break;
15409  case T_FLOAT:
15410  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15411  break;
15412  default:
15413  break;
15414  }
15415  return node;
15416 }
15417 
15418 static NODE *
15419 arg_blk_pass(NODE *node1, NODE *node2)
15420 {
15421  if (node2) {
15422  node2->nd_head = node1;
15423  return node2;
15424  }
15425  return node1;
15426 }
15427 
15428 static NODE*
15429 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, ID b)
15430 {
15431  int saved_line = ruby_sourceline;
15432  NODE *node;
15433  NODE *i1, *i2 = 0;
15434 
15435  node = NEW_ARGS(m ? m->nd_plen : 0, o);
15436  i1 = m ? m->nd_next : 0;
15437  node->nd_next = NEW_ARGS_AUX(r, b);
15438 
15439  if (p) {
15440  i2 = p->nd_next;
15441  node->nd_next->nd_next = NEW_ARGS_AUX(p->nd_pid, p->nd_plen);
15442  }
15443  else if (i1) {
15444  node->nd_next->nd_next = NEW_ARGS_AUX(0, 0);
15445  }
15446  if (i1 || i2) {
15447  node->nd_next->nd_next->nd_next = NEW_NODE(NODE_AND, i1, i2, 0);
15448  }
15449  ruby_sourceline = saved_line;
15450  return node;
15451 }
15452 #endif /* !RIPPER */
15453 
15454 static void
15455 warn_unused_var(struct parser_params *parser, struct local_vars *local)
15456 {
15457  int i, cnt;
15458  ID *v, *u;
15459 
15460  if (!local->used) return;
15461  v = local->vars->tbl;
15462  u = local->used->tbl;
15463  cnt = local->used->pos;
15464  if (cnt != local->vars->pos) {
15465  rb_bug("local->used->pos != local->vars->pos");
15466  }
15467  for (i = 0; i < cnt; ++i) {
15468  if (!v[i] || (u[i] & LVAR_USED)) continue;
15469  if (idUScore == v[i]) continue;
15470  rb_compile_warn(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
15471  }
15472 }
15473 
15474 static void
15475 local_push_gen(struct parser_params *parser, int inherit_dvars)
15476 {
15477  struct local_vars *local;
15478 
15479  local = ALLOC(struct local_vars);
15480  local->prev = lvtbl;
15481  local->args = vtable_alloc(0);
15482  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
15483  local->used = !inherit_dvars && RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
15484  local->cmdargs = cmdarg_stack;
15485  cmdarg_stack = 0;
15486  lvtbl = local;
15487 }
15488 
15489 static void
15491 {
15492  struct local_vars *local = lvtbl->prev;
15493  if (lvtbl->used) {
15494  warn_unused_var(parser, lvtbl);
15495  vtable_free(lvtbl->used);
15496  }
15497  vtable_free(lvtbl->args);
15498  vtable_free(lvtbl->vars);
15499  cmdarg_stack = lvtbl->cmdargs;
15500  xfree(lvtbl);
15501  lvtbl = local;
15502 }
15503 
15504 #ifndef RIPPER
15505 static ID*
15506 vtable_tblcpy(ID *buf, const struct vtable *src)
15507 {
15508  int i, cnt = vtable_size(src);
15509 
15510  if (cnt > 0) {
15511  buf[0] = cnt;
15512  for (i = 0; i < cnt; i++) {
15513  buf[i] = src->tbl[i];
15514  }
15515  return buf;
15516  }
15517  return 0;
15518 }
15519 
15520 static ID*
15522 {
15523  int cnt = vtable_size(lvtbl->args) + vtable_size(lvtbl->vars);
15524  ID *buf;
15525 
15526  if (cnt <= 0) return 0;
15527  buf = ALLOC_N(ID, cnt + 1);
15528  vtable_tblcpy(buf+1, lvtbl->args);
15529  vtable_tblcpy(buf+vtable_size(lvtbl->args)+1, lvtbl->vars);
15530  buf[0] = cnt;
15531  return buf;
15532 }
15533 #endif
15534 
15535 static int
15536 arg_var_gen(struct parser_params *parser, ID id)
15537 {
15538  vtable_add(lvtbl->args, id);
15539  return vtable_size(lvtbl->args) - 1;
15540 }
15541 
15542 static int
15543 local_var_gen(struct parser_params *parser, ID id)
15544 {
15545  vtable_add(lvtbl->vars, id);
15546  if (lvtbl->used) {
15548  }
15549  return vtable_size(lvtbl->vars) - 1;
15550 }
15551 
15552 static int
15553 local_id_gen(struct parser_params *parser, ID id)
15554 {
15555  struct vtable *vars, *args, *used;
15556 
15557  vars = lvtbl->vars;
15558  args = lvtbl->args;
15559  used = lvtbl->used;
15560 
15561  while (vars && POINTER_P(vars->prev)) {
15562  vars = vars->prev;
15563  args = args->prev;
15564  if (used) used = used->prev;
15565  }
15566 
15567  if (vars && vars->prev == DVARS_INHERIT) {
15568  return rb_local_defined(id);
15569  }
15570  else if (vtable_included(args, id)) {
15571  return 1;
15572  }
15573  else {
15574  int i = vtable_included(vars, id);
15575  if (i && used) used->tbl[i-1] |= LVAR_USED;
15576  return i != 0;
15577  }
15578 }
15579 
15580 static const struct vtable *
15582 {
15583  lvtbl->args = vtable_alloc(lvtbl->args);
15584  lvtbl->vars = vtable_alloc(lvtbl->vars);
15585  if (lvtbl->used) {
15586  lvtbl->used = vtable_alloc(lvtbl->used);
15587  }
15588  return lvtbl->args;
15589 }
15590 
15591 static void
15592 dyna_pop_1(struct parser_params *parser)
15593 {
15594  struct vtable *tmp;
15595 
15596  if ((tmp = lvtbl->used) != 0) {
15597  warn_unused_var(parser, lvtbl);
15598  lvtbl->used = lvtbl->used->prev;
15599  vtable_free(tmp);
15600  }
15601  tmp = lvtbl->args;
15602  lvtbl->args = lvtbl->args->prev;
15603  vtable_free(tmp);
15604  tmp = lvtbl->vars;
15605  lvtbl->vars = lvtbl->vars->prev;
15606  vtable_free(tmp);
15607 }
15608 
15609 static void
15610 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
15611 {
15612  while (lvtbl->args != lvargs) {
15613  dyna_pop_1(parser);
15614  if (!lvtbl->args) {
15615  struct local_vars *local = lvtbl->prev;
15616  xfree(lvtbl);
15617  lvtbl = local;
15618  }
15619  }
15620  dyna_pop_1(parser);
15621 }
15622 
15623 static int
15625 {
15626  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
15627 }
15628 
15629 static int
15630 dvar_defined_gen(struct parser_params *parser, ID id, int get)
15631 {
15632  struct vtable *vars, *args, *used;
15633  int i;
15634 
15635  args = lvtbl->args;
15636  vars = lvtbl->vars;
15637  used = lvtbl->used;
15638 
15639  while (POINTER_P(vars)) {
15640  if (vtable_included(args, id)) {
15641  return 1;
15642  }
15643  if ((i = vtable_included(vars, id)) != 0) {
15644  if (used) used->tbl[i-1] |= LVAR_USED;
15645  return 1;
15646  }
15647  args = args->prev;
15648  vars = vars->prev;
15649  if (get) used = 0;
15650  if (used) used = used->prev;
15651  }
15652 
15653  if (vars == DVARS_INHERIT) {
15654  return rb_dvar_defined(id);
15655  }
15656 
15657  return 0;
15658 }
15659 
15660 static int
15661 dvar_curr_gen(struct parser_params *parser, ID id)
15662 {
15663  return (vtable_included(lvtbl->args, id) ||
15664  vtable_included(lvtbl->vars, id));
15665 }
15666 
15667 #ifndef RIPPER
15668 static void
15670 {
15671  int c = RE_OPTION_ENCODING_IDX(options);
15672 
15673  if (c) {
15674  int opt, idx;
15675  rb_char_to_option_kcode(c, &opt, &idx);
15676  if (idx != ENCODING_GET(str) &&
15678  goto error;
15679  }
15680  ENCODING_SET(str, idx);
15681  }
15682  else if (RE_OPTION_ENCODING_NONE(options)) {
15683  if (!ENCODING_IS_ASCII8BIT(str) &&
15685  c = 'n';
15686  goto error;
15687  }
15689  }
15690  else if (parser->enc == rb_usascii_encoding()) {
15692  /* raise in re.c */
15694  }
15695  else {
15697  }
15698  }
15699  return;
15700 
15701  error:
15703  "regexp encoding option '%c' differs from source encoding '%s'",
15704  c, rb_enc_name(rb_enc_get(str)));
15705 }
15706 
15707 static int
15709 {
15710  VALUE err;
15711  reg_fragment_setenc(str, options);
15712  err = rb_reg_check_preprocess(str);
15713  if (err != Qnil) {
15714  err = rb_obj_as_string(err);
15715  compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
15716  RB_GC_GUARD(err);
15717  return 0;
15718  }
15719  return 1;
15720 }
15721 
15722 typedef struct {
15727  int num;
15729 
15730 static int
15732  int back_num, int *back_refs, OnigRegex regex, void *arg0)
15733 {
15735  struct parser_params* parser = arg->parser;
15736  rb_encoding *enc = arg->enc;
15737  long len = name_end - name;
15738  const char *s = (const char *)name;
15739  ID var;
15740 
15741  arg->num++;
15742 
15743  if (arg->succ_block == 0) {
15744  arg->succ_block = NEW_BEGIN(0);
15745  arg->fail_block = NEW_BEGIN(0);
15746  }
15747 
15748  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
15749  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
15750  !rb_enc_symname2_p(s, len, enc)) {
15751  return ST_CONTINUE;
15752  }
15753  var = rb_intern3(s, len, enc);
15754  if (dvar_defined(var) || local_id(var)) {
15755  rb_warningS("named capture conflicts a local variable - %s",
15756  rb_id2name(var));
15757  }
15758  arg->succ_block = block_append(arg->succ_block,
15760  NEW_CALL(
15761  gettable(rb_intern("$~")),
15762  idAREF,
15763  NEW_LIST(NEW_LIT(ID2SYM(var))))
15764  )));
15765  arg->fail_block = block_append(arg->fail_block,
15767  return ST_CONTINUE;
15768 }
15769 
15770 static NODE *
15772 {
15774 
15775  arg.parser = parser;
15776  arg.enc = rb_enc_get(regexp);
15777  arg.succ_block = 0;
15778  arg.fail_block = 0;
15779  arg.num = 0;
15781 
15782  if (arg.num == 0)
15783  return match;
15784 
15785  return
15786  block_append(
15787  newline_node(match),
15788  NEW_IF(gettable(rb_intern("$~")),
15789  block_append(
15790  newline_node(arg.succ_block),
15791  newline_node(
15792  NEW_CALL(
15793  gettable(rb_intern("$~")),
15794  rb_intern("begin"),
15795  NEW_LIST(NEW_LIT(INT2FIX(0)))))),
15796  block_append(
15797  newline_node(arg.fail_block),
15798  newline_node(
15799  NEW_LIT(Qnil)))));
15800 }
15801 
15802 static VALUE
15803 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
15804 {
15805  VALUE re;
15806  VALUE err;
15807 
15808  reg_fragment_setenc(str, options);
15809  err = rb_errinfo();
15811  if (NIL_P(re)) {
15812  ID mesg = rb_intern("mesg");
15813  VALUE m = rb_attr_get(rb_errinfo(), mesg);
15814  rb_set_errinfo(err);
15815  if (!NIL_P(err)) {
15816  rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
15817  }
15818  else {
15820  }
15821  return Qnil;
15822  }
15823  return re;
15824 }
15825 
15826 void
15828 {
15829 }
15830 
15831 NODE*
15833 {
15834  NODE *prelude = 0;
15835  NODE *scope = node;
15836  struct parser_params *parser;
15837 
15838  if (!node) return node;
15839 
15840  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15841 
15842  node = node->nd_body;
15843 
15844  if (nd_type(node) == NODE_PRELUDE) {
15845  prelude = node;
15846  node = node->nd_body;
15847  }
15848 
15849  node = block_append(node,
15850  NEW_FCALL(rb_intern("print"),
15851  NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
15852  if (prelude) {
15853  prelude->nd_body = node;
15854  scope->nd_body = prelude;
15855  }
15856  else {
15857  scope->nd_body = node;
15858  }
15859 
15860  return scope;
15861 }
15862 
15863 NODE *
15864 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
15865 {
15866  NODE *prelude = 0;
15867  NODE *scope = node;
15868  struct parser_params *parser;
15869 
15870  if (!node) return node;
15871 
15872  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15873 
15874  node = node->nd_body;
15875 
15876  if (nd_type(node) == NODE_PRELUDE) {
15877  prelude = node;
15878  node = node->nd_body;
15879  }
15880  if (split) {
15881  node = block_append(NEW_GASGN(rb_intern("$F"),
15882  NEW_CALL(NEW_GVAR(rb_intern("$_")),
15883  rb_intern("split"), 0)),
15884  node);
15885  }
15886  if (chop) {
15887  node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
15888  rb_intern("chop!"), 0), node);
15889  }
15890 
15891  node = NEW_OPT_N(node);
15892 
15893  if (prelude) {
15894  prelude->nd_body = node;
15895  scope->nd_body = prelude;
15896  }
15897  else {
15898  scope->nd_body = node;
15899  }
15900 
15901  return scope;
15902 }
15903 
15904 static const struct {
15906  const char *name;
15907 } op_tbl[] = {
15908  {tDOT2, ".."},
15909  {tDOT3, "..."},
15910  {tPOW, "**"},
15911  {tUPLUS, "+@"},
15912  {tUMINUS, "-@"},
15913  {tCMP, "<=>"},
15914  {tGEQ, ">="},
15915  {tLEQ, "<="},
15916  {tEQ, "=="},
15917  {tEQQ, "==="},
15918  {tNEQ, "!="},
15919  {tMATCH, "=~"},
15920  {tNMATCH, "!~"},
15921  {tAREF, "[]"},
15922  {tASET, "[]="},
15923  {tLSHFT, "<<"},
15924  {tRSHFT, ">>"},
15925  {tCOLON2, "::"},
15926 };
15927 
15928 #define op_tbl_count numberof(op_tbl)
15929 
15930 #ifndef ENABLE_SELECTOR_NAMESPACE
15931 #define ENABLE_SELECTOR_NAMESPACE 0
15932 #endif
15933 
15934 static struct symbols {
15938 #if ENABLE_SELECTOR_NAMESPACE
15939  st_table *ivar2_id;
15940  st_table *id_ivar2;
15941 #endif
15943 } global_symbols = {tLAST_ID};
15944 
15945 static const struct st_hash_type symhash = {
15947  rb_str_hash,
15948 };
15949 
15950 #if ENABLE_SELECTOR_NAMESPACE
15951 struct ivar2_key {
15952  ID id;
15953  VALUE klass;
15954 };
15955 
15956 static int
15957 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
15958 {
15959  if (key1->id == key2->id && key1->klass == key2->klass) {
15960  return 0;
15961  }
15962  return 1;
15963 }
15964 
15965 static int
15966 ivar2_hash(struct ivar2_key *key)
15967 {
15968  return (key->id << 8) ^ (key->klass >> 2);
15969 }
15970 
15971 static const struct st_hash_type ivar2_hash_type = {
15972  ivar2_cmp,
15973  ivar2_hash,
15974 };
15975 #endif
15976 
15977 void
15979 {
15980  global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
15982 #if ENABLE_SELECTOR_NAMESPACE
15983  global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
15984  global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
15985 #endif
15986 
15987  Init_id();
15988 }
15989 
15990 void
15992 {
15996 }
15997 #endif /* !RIPPER */
15998 
15999 static ID
16001 {
16002  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16003  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16004  return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16005 }
16006 
16007 #ifndef RIPPER
16008 static int
16009 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16010 {
16011  int mb = 0;
16012 
16013  if (m >= e) return 0;
16014  if (is_global_name_punct(*m)) {
16015  ++m;
16016  }
16017  else if (*m == '-') {
16018  ++m;
16019  if (m < e && is_identchar(m, e, enc)) {
16020  if (!ISASCII(*m)) mb = 1;
16021  m += rb_enc_mbclen(m, e, enc);
16022  }
16023  }
16024  else {
16025  if (!rb_enc_isdigit(*m, enc)) return 0;
16026  do {
16027  if (!ISASCII(*m)) mb = 1;
16028  ++m;
16029  } while (m < e && rb_enc_isdigit(*m, enc));
16030  }
16031  return m == e ? mb + 1 : 0;
16032 }
16033 
16034 int
16035 rb_symname_p(const char *name)
16036 {
16037  return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16038 }
16039 
16040 int
16041 rb_enc_symname_p(const char *name, rb_encoding *enc)
16042 {
16043  return rb_enc_symname2_p(name, strlen(name), enc);
16044 }
16045 
16046 int
16047 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16048 {
16049  const char *m = name;
16050  const char *e = m + len;
16051  int localid = FALSE;
16052 
16053  if (!m || len <= 0) return FALSE;
16054  switch (*m) {
16055  case '\0':
16056  return FALSE;
16057 
16058  case '$':
16059  if (is_special_global_name(++m, e, enc)) return TRUE;
16060  goto id;
16061 
16062  case '@':
16063  if (*++m == '@') ++m;
16064  goto id;
16065 
16066  case '<':
16067  switch (*++m) {
16068  case '<': ++m; break;
16069  case '=': if (*++m == '>') ++m; break;
16070  default: break;
16071  }
16072  break;
16073 
16074  case '>':
16075  switch (*++m) {
16076  case '>': case '=': ++m; break;
16077  }
16078  break;
16079 
16080  case '=':
16081  switch (*++m) {
16082  case '~': ++m; break;
16083  case '=': if (*++m == '=') ++m; break;
16084  default: return FALSE;
16085  }
16086  break;
16087 
16088  case '*':
16089  if (*++m == '*') ++m;
16090  break;
16091 
16092  case '+': case '-':
16093  if (*++m == '@') ++m;
16094  break;
16095 
16096  case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16097  ++m;
16098  break;
16099 
16100  case '[':
16101  if (*++m != ']') return FALSE;
16102  if (*++m == '=') ++m;
16103  break;
16104 
16105  case '!':
16106  if (len == 1) return TRUE;
16107  switch (*++m) {
16108  case '=': case '~': ++m; break;
16109  default: return FALSE;
16110  }
16111  break;
16112 
16113  default:
16114  localid = !rb_enc_isupper(*m, enc);
16115  id:
16116  if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16117  return FALSE;
16118  while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16119  if (localid) {
16120  switch (*m) {
16121  case '!': case '?': case '=': ++m;
16122  }
16123  }
16124  break;
16125  }
16126  return m == e;
16127 }
16128 
16129 static ID
16130 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16131 {
16132  VALUE str = rb_enc_str_new(name, len, enc);
16133  OBJ_FREEZE(str);
16136  return id;
16137 }
16138 
16139 ID
16140 rb_intern3(const char *name, long len, rb_encoding *enc)
16141 {
16142  const char *m = name;
16143  const char *e = m + len;
16144  unsigned char c;
16145  VALUE str;
16146  ID id;
16147  long last;
16148  int mb;
16149  st_data_t data;
16150  struct RString fake_str;
16151  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
16152  fake_str.basic.klass = rb_cString;
16153  fake_str.as.heap.len = len;
16154  fake_str.as.heap.ptr = (char *)name;
16155  fake_str.as.heap.aux.capa = len;
16156  str = (VALUE)&fake_str;
16157  rb_enc_associate(str, enc);
16158  OBJ_FREEZE(str);
16159 
16161  rb_raise(rb_eEncodingError, "invalid encoding symbol");
16162  }
16163 
16164  if (st_lookup(global_symbols.sym_id, str, &data))
16165  return (ID)data;
16166 
16167  if (rb_cString && !rb_enc_asciicompat(enc)) {
16168  id = ID_JUNK;
16169  goto new_id;
16170  }
16171  last = len-1;
16172  id = 0;
16173  switch (*m) {
16174  case '$':
16175  id |= ID_GLOBAL;
16176  if ((mb = is_special_global_name(++m, e, enc)) != 0) {
16177  if (!--mb) enc = rb_ascii8bit_encoding();
16178  goto new_id;
16179  }
16180  break;
16181  case '@':
16182  if (m[1] == '@') {
16183  m++;
16184  id |= ID_CLASS;
16185  }
16186  else {
16187  id |= ID_INSTANCE;
16188  }
16189  m++;
16190  break;
16191  default:
16192  c = m[0];
16193  if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
16194  /* operators */
16195  int i;
16196 
16197  if (len == 1) {
16198  id = c;
16199  goto id_register;
16200  }
16201  for (i = 0; i < op_tbl_count; i++) {
16202  if (*op_tbl[i].name == *m &&
16203  strcmp(op_tbl[i].name, m) == 0) {
16204  id = op_tbl[i].token;
16205  goto id_register;
16206  }
16207  }
16208  }
16209 
16210  if (m[last] == '=') {
16211  /* attribute assignment */
16212  id = rb_intern3(name, last, enc);
16213  if (id > tLAST_TOKEN && !is_attrset_id(id)) {
16214  enc = rb_enc_get(rb_id2str(id));
16215  id = rb_id_attrset(id);
16216  goto id_register;
16217  }
16218  id = ID_ATTRSET;
16219  }
16220  else if (rb_enc_isupper(m[0], enc)) {
16221  id = ID_CONST;
16222  }
16223  else {
16224  id = ID_LOCAL;
16225  }
16226  break;
16227  }
16228  mb = 0;
16229  if (!rb_enc_isdigit(*m, enc)) {
16230  while (m <= name + last && is_identchar(m, e, enc)) {
16231  if (ISASCII(*m)) {
16232  m++;
16233  }
16234  else {
16235  mb = 1;
16236  m += rb_enc_mbclen(m, e, enc);
16237  }
16238  }
16239  }
16240  if (m - name < len) id = ID_JUNK;
16241  if (enc != rb_usascii_encoding()) {
16242  /*
16243  * this clause makes sense only when called from other than
16244  * rb_intern_str() taking care of code-range.
16245  */
16246  if (!mb) {
16247  for (; m <= name + len; ++m) {
16248  if (!ISASCII(*m)) goto mbstr;
16249  }
16250  enc = rb_usascii_encoding();
16251  }
16252  mbstr:;
16253  }
16254  new_id:
16256  if (len > 20) {
16257  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
16258  name);
16259  }
16260  else {
16261  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
16262  (int)len, name);
16263  }
16264  }
16266  id_register:
16267  return register_symid(id, name, len, enc);
16268 }
16269 
16270 ID
16271 rb_intern2(const char *name, long len)
16272 {
16273  return rb_intern3(name, len, rb_usascii_encoding());
16274 }
16275 
16276 #undef rb_intern
16277 ID
16278 rb_intern(const char *name)
16279 {
16280  return rb_intern2(name, strlen(name));
16281 }
16282 
16283 ID
16285 {
16286  rb_encoding *enc;
16287  ID id;
16288 
16290  enc = rb_usascii_encoding();
16291  }
16292  else {
16293  enc = rb_enc_get(str);
16294  }
16295  id = rb_intern3(RSTRING_PTR(str), RSTRING_LEN(str), enc);
16296  RB_GC_GUARD(str);
16297  return id;
16298 }
16299 
16300 VALUE
16302 {
16303  st_data_t data;
16304 
16305  if (id < tLAST_TOKEN) {
16306  int i = 0;
16307 
16308  if (id < INT_MAX && rb_ispunct((int)id)) {
16309  VALUE str = global_symbols.op_sym[i = (int)id];
16310  if (!str) {
16311  char name[2];
16312  name[0] = (char)id;
16313  name[1] = 0;
16314  str = rb_usascii_str_new(name, 1);
16315  OBJ_FREEZE(str);
16317  }
16318  return str;
16319  }
16320  for (i = 0; i < op_tbl_count; i++) {
16321  if (op_tbl[i].token == id) {
16322  VALUE str = global_symbols.op_sym[i];
16323  if (!str) {
16324  str = rb_usascii_str_new2(op_tbl[i].name);
16325  OBJ_FREEZE(str);
16327  }
16328  return str;
16329  }
16330  }
16331  }
16332 
16333  if (st_lookup(global_symbols.id_str, id, &data)) {
16334  VALUE str = (VALUE)data;
16335  if (RBASIC(str)->klass == 0)
16336  RBASIC(str)->klass = rb_cString;
16337  return str;
16338  }
16339 
16340  if (is_attrset_id(id)) {
16341  ID id2 = (id & ~ID_SCOPE_MASK) | ID_LOCAL;
16342  VALUE str;
16343 
16344  while (!(str = rb_id2str(id2))) {
16345  if (!is_local_id(id2)) return 0;
16346  id2 = (id & ~ID_SCOPE_MASK) | ID_CONST;
16347  }
16348  str = rb_str_dup(str);
16349  rb_str_cat(str, "=", 1);
16350  rb_intern_str(str);
16351  if (st_lookup(global_symbols.id_str, id, &data)) {
16352  VALUE str = (VALUE)data;
16353  if (RBASIC(str)->klass == 0)
16354  RBASIC(str)->klass = rb_cString;
16355  return str;
16356  }
16357  }
16358  return 0;
16359 }
16360 
16361 const char *
16363 {
16364  VALUE str = rb_id2str(id);
16365 
16366  if (!str) return 0;
16367  return RSTRING_PTR(str);
16368 }
16369 
16370 static int
16372 {
16373  rb_ary_push(ary, ID2SYM(value));
16374  return ST_CONTINUE;
16375 }
16376 
16377 /*
16378  * call-seq:
16379  * Symbol.all_symbols => array
16380  *
16381  * Returns an array of all the symbols currently in Ruby's symbol
16382  * table.
16383  *
16384  * Symbol.all_symbols.size #=> 903
16385  * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
16386  * :chown, :EOFError, :$;, :String,
16387  * :LOCK_SH, :"setuid?", :$<,
16388  * :default_proc, :compact, :extend,
16389  * :Tms, :getwd, :$=, :ThreadGroup,
16390  * :wait2, :$>]
16391  */
16392 
16393 VALUE
16395 {
16397 
16399  return ary;
16400 }
16401 
16402 int
16404 {
16405  return is_const_id(id);
16406 }
16407 
16408 int
16410 {
16411  return is_class_id(id);
16412 }
16413 
16414 int
16416 {
16417  return is_instance_id(id);
16418 }
16419 
16420 int
16422 {
16423  return is_local_id(id);
16424 }
16425 
16426 int
16428 {
16429  return is_junk_id(id);
16430 }
16431 
16432 #endif /* !RIPPER */
16433 
16434 static void
16436 {
16437  parser->eofp = Qfalse;
16438 
16439  parser->parser_lex_strterm = 0;
16440  parser->parser_cond_stack = 0;
16441  parser->parser_cmdarg_stack = 0;
16442  parser->parser_class_nest = 0;
16443  parser->parser_paren_nest = 0;
16444  parser->parser_lpar_beg = 0;
16445  parser->parser_in_single = 0;
16446  parser->parser_in_def = 0;
16447  parser->parser_in_defined = 0;
16448  parser->parser_compile_for_eval = 0;
16449  parser->parser_cur_mid = 0;
16450  parser->parser_tokenbuf = NULL;
16451  parser->parser_tokidx = 0;
16452  parser->parser_toksiz = 0;
16453  parser->parser_heredoc_end = 0;
16454  parser->parser_command_start = TRUE;
16455  parser->parser_deferred_nodes = 0;
16456  parser->parser_lex_pbeg = 0;
16457  parser->parser_lex_p = 0;
16458  parser->parser_lex_pend = 0;
16459  parser->parser_lvtbl = 0;
16460  parser->parser_ruby__end__seen = 0;
16461  parser->parser_ruby_sourcefile = 0;
16462 #ifndef RIPPER
16463  parser->is_ripper = 0;
16464  parser->parser_eval_tree_begin = 0;
16465  parser->parser_eval_tree = 0;
16466 #else
16467  parser->is_ripper = 1;
16468  parser->parser_ruby_sourcefile_string = Qnil;
16469  parser->delayed = Qnil;
16470 
16471  parser->result = Qnil;
16472  parser->parsing_thread = Qnil;
16473  parser->toplevel_p = TRUE;
16474 #endif
16475 #ifdef YYMALLOC
16476  parser->heap = NULL;
16477 #endif
16478  parser->enc = rb_usascii_encoding();
16479 }
16480 
16481 #ifdef RIPPER
16482 #define parser_mark ripper_parser_mark
16483 #define parser_free ripper_parser_free
16484 #endif
16485 
16486 static void
16488 {
16489  struct parser_params *p = (struct parser_params*)ptr;
16490 
16496 #ifndef RIPPER
16499  rb_gc_mark(p->debug_lines);
16500 #else
16501  rb_gc_mark(p->parser_ruby_sourcefile_string);
16502  rb_gc_mark(p->delayed);
16503  rb_gc_mark(p->value);
16504  rb_gc_mark(p->result);
16505  rb_gc_mark(p->parsing_thread);
16506 #endif
16507 #ifdef YYMALLOC
16508  rb_gc_mark((VALUE)p->heap);
16509 #endif
16510 }
16511 
16512 static void
16514 {
16515  struct parser_params *p = (struct parser_params*)ptr;
16516  struct local_vars *local, *prev;
16517 
16518  if (p->parser_tokenbuf) {
16519  xfree(p->parser_tokenbuf);
16520  }
16521  for (local = p->parser_lvtbl; local; local = prev) {
16522  if (local->vars) xfree(local->vars);
16523  prev = local->prev;
16524  xfree(local);
16525  }
16526 #ifndef RIPPER
16528 #endif
16529  xfree(p);
16530 }
16531 
16532 static size_t
16533 parser_memsize(const void *ptr)
16534 {
16535  struct parser_params *p = (struct parser_params*)ptr;
16536  struct local_vars *local;
16537  size_t size = sizeof(*p);
16538 
16539  if (!ptr) return 0;
16540  size += p->parser_toksiz;
16541  for (local = p->parser_lvtbl; local; local = local->prev) {
16542  size += sizeof(*local);
16543  if (local->vars) size += local->vars->capa * sizeof(ID);
16544  }
16545 #ifndef RIPPER
16546  if (p->parser_ruby_sourcefile) {
16547  size += strlen(p->parser_ruby_sourcefile) + 1;
16548  }
16549 #endif
16550  return size;
16551 }
16552 
16553 static
16554 #ifndef RIPPER
16555 const
16556 #endif
16557 rb_data_type_t parser_data_type = {
16558  "parser",
16559  {
16560  parser_mark,
16561  parser_free,
16563  },
16564 };
16565 
16566 #ifndef RIPPER
16567 #undef rb_reserved_word
16568 
16569 const struct kwtable *
16570 rb_reserved_word(const char *str, unsigned int len)
16571 {
16572  return reserved_word(str, len);
16573 }
16574 
16575 static struct parser_params *
16577 {
16578  struct parser_params *p;
16579 
16580  p = ALLOC_N(struct parser_params, 1);
16581  MEMZERO(p, struct parser_params, 1);
16582  parser_initialize(p);
16583  return p;
16584 }
16585 
16586 VALUE
16588 {
16589  struct parser_params *p = parser_new();
16590 
16591  return TypedData_Wrap_Struct(0, &parser_data_type, p);
16592 }
16593 
16594 /*
16595  * call-seq:
16596  * ripper#end_seen? -> Boolean
16597  *
16598  * Return true if parsed source ended by +\_\_END\_\_+.
16599  */
16600 VALUE
16602 {
16603  struct parser_params *parser;
16604 
16605  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16606  return ruby__end__seen ? Qtrue : Qfalse;
16607 }
16608 
16609 /*
16610  * call-seq:
16611  * ripper#encoding -> encoding
16612  *
16613  * Return encoding of the source.
16614  */
16615 VALUE
16617 {
16618  struct parser_params *parser;
16619 
16620  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16621  return rb_enc_from_encoding(parser->enc);
16622 }
16623 
16624 /*
16625  * call-seq:
16626  * ripper.yydebug -> true or false
16627  *
16628  * Get yydebug.
16629  */
16630 VALUE
16632 {
16633  struct parser_params *parser;
16634 
16635  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16636  return yydebug ? Qtrue : Qfalse;
16637 }
16638 
16639 /*
16640  * call-seq:
16641  * ripper.yydebug = flag
16642  *
16643  * Set yydebug.
16644  */
16645 VALUE
16647 {
16648  struct parser_params *parser;
16649 
16650  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16651  yydebug = RTEST(flag);
16652  return flag;
16653 }
16654 
16655 #ifdef YYMALLOC
16656 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
16657 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
16658 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
16659  (n)->u3.cnt = (c), (p))
16660 
16661 void *
16662 rb_parser_malloc(struct parser_params *parser, size_t size)
16663 {
16664  size_t cnt = HEAPCNT(1, size);
16665  NODE *n = NEWHEAP();
16666  void *ptr = xmalloc(size);
16667 
16668  return ADD2HEAP(n, cnt, ptr);
16669 }
16670 
16671 void *
16672 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
16673 {
16674  size_t cnt = HEAPCNT(nelem, size);
16675  NODE *n = NEWHEAP();
16676  void *ptr = xcalloc(nelem, size);
16677 
16678  return ADD2HEAP(n, cnt, ptr);
16679 }
16680 
16681 void *
16682 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
16683 {
16684  NODE *n;
16685  size_t cnt = HEAPCNT(1, size);
16686 
16687  if (ptr && (n = parser->heap) != NULL) {
16688  do {
16689  if (n->u1.node == ptr) {
16690  n->u1.node = ptr = xrealloc(ptr, size);
16691  if (n->u3.cnt) n->u3.cnt = cnt;
16692  return ptr;
16693  }
16694  } while ((n = n->u2.node) != NULL);
16695  }
16696  n = NEWHEAP();
16697  ptr = xrealloc(ptr, size);
16698  return ADD2HEAP(n, cnt, ptr);
16699 }
16700 
16701 void
16702 rb_parser_free(struct parser_params *parser, void *ptr)
16703 {
16704  NODE **prev = &parser->heap, *n;
16705 
16706  while ((n = *prev) != NULL) {
16707  if (n->u1.node == ptr) {
16708  *prev = n->u2.node;
16710  break;
16711  }
16712  prev = &n->u2.node;
16713  }
16714  xfree(ptr);
16715 }
16716 #endif
16717 #endif
16718 
16719 #ifdef RIPPER
16720 #ifdef RIPPER_DEBUG
16721 extern int rb_is_pointer_to_heap(VALUE);
16722 
16723 /* :nodoc: */
16724 static VALUE
16725 ripper_validate_object(VALUE self, VALUE x)
16726 {
16727  if (x == Qfalse) return x;
16728  if (x == Qtrue) return x;
16729  if (x == Qnil) return x;
16730  if (x == Qundef)
16731  rb_raise(rb_eArgError, "Qundef given");
16732  if (FIXNUM_P(x)) return x;
16733  if (SYMBOL_P(x)) return x;
16734  if (!rb_is_pointer_to_heap(x))
16735  rb_raise(rb_eArgError, "invalid pointer: %p", x);
16736  switch (TYPE(x)) {
16737  case T_STRING:
16738  case T_OBJECT:
16739  case T_ARRAY:
16740  case T_BIGNUM:
16741  case T_FLOAT:
16742  return x;
16743  case T_NODE:
16744  if (nd_type(x) != NODE_LASGN) {
16745  rb_raise(rb_eArgError, "NODE given: %p", x);
16746  }
16747  return ((NODE *)x)->nd_rval;
16748  default:
16749  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
16750  x, rb_obj_classname(x));
16751  }
16752  return x;
16753 }
16754 #endif
16755 
16756 #define validate(x) ((x) = get_value(x))
16757 
16758 static VALUE
16759 ripper_dispatch0(struct parser_params *parser, ID mid)
16760 {
16761  return rb_funcall(parser->value, mid, 0);
16762 }
16763 
16764 static VALUE
16765 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
16766 {
16767  validate(a);
16768  return rb_funcall(parser->value, mid, 1, a);
16769 }
16770 
16771 static VALUE
16772 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
16773 {
16774  validate(a);
16775  validate(b);
16776  return rb_funcall(parser->value, mid, 2, a, b);
16777 }
16778 
16779 static VALUE
16780 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
16781 {
16782  validate(a);
16783  validate(b);
16784  validate(c);
16785  return rb_funcall(parser->value, mid, 3, a, b, c);
16786 }
16787 
16788 static VALUE
16789 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
16790 {
16791  validate(a);
16792  validate(b);
16793  validate(c);
16794  validate(d);
16795  return rb_funcall(parser->value, mid, 4, a, b, c, d);
16796 }
16797 
16798 static VALUE
16799 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
16800 {
16801  validate(a);
16802  validate(b);
16803  validate(c);
16804  validate(d);
16805  validate(e);
16806  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
16807 }
16808 
16809 static const struct kw_assoc {
16810  ID id;
16811  const char *name;
16812 } keyword_to_name[] = {
16813  {keyword_class, "class"},
16814  {keyword_module, "module"},
16815  {keyword_def, "def"},
16816  {keyword_undef, "undef"},
16817  {keyword_begin, "begin"},
16818  {keyword_rescue, "rescue"},
16819  {keyword_ensure, "ensure"},
16820  {keyword_end, "end"},
16821  {keyword_if, "if"},
16822  {keyword_unless, "unless"},
16823  {keyword_then, "then"},
16824  {keyword_elsif, "elsif"},
16825  {keyword_else, "else"},
16826  {keyword_case, "case"},
16827  {keyword_when, "when"},
16828  {keyword_while, "while"},
16829  {keyword_until, "until"},
16830  {keyword_for, "for"},
16831  {keyword_break, "break"},
16832  {keyword_next, "next"},
16833  {keyword_redo, "redo"},
16834  {keyword_retry, "retry"},
16835  {keyword_in, "in"},
16836  {keyword_do, "do"},
16837  {keyword_do_cond, "do"},
16838  {keyword_do_block, "do"},
16839  {keyword_return, "return"},
16840  {keyword_yield, "yield"},
16841  {keyword_super, "super"},
16842  {keyword_self, "self"},
16843  {keyword_nil, "nil"},
16844  {keyword_true, "true"},
16845  {keyword_false, "false"},
16846  {keyword_and, "and"},
16847  {keyword_or, "or"},
16848  {keyword_not, "not"},
16849  {modifier_if, "if"},
16850  {modifier_unless, "unless"},
16851  {modifier_while, "while"},
16852  {modifier_until, "until"},
16853  {modifier_rescue, "rescue"},
16854  {keyword_alias, "alias"},
16855  {keyword_defined, "defined?"},
16856  {keyword_BEGIN, "BEGIN"},
16857  {keyword_END, "END"},
16858  {keyword__LINE__, "__LINE__"},
16859  {keyword__FILE__, "__FILE__"},
16860  {keyword__ENCODING__, "__ENCODING__"},
16861  {0, NULL}
16862 };
16863 
16864 static const char*
16865 keyword_id_to_str(ID id)
16866 {
16867  const struct kw_assoc *a;
16868 
16869  for (a = keyword_to_name; a->id; a++) {
16870  if (a->id == id)
16871  return a->name;
16872  }
16873  return NULL;
16874 }
16875 
16876 #undef ripper_id2sym
16877 static VALUE
16878 ripper_id2sym(ID id)
16879 {
16880  const char *name;
16881  char buf[8];
16882 
16883  if (id <= 256) {
16884  buf[0] = (char)id;
16885  buf[1] = '\0';
16886  return ID2SYM(rb_intern2(buf, 1));
16887  }
16888  if ((name = keyword_id_to_str(id))) {
16889  return ID2SYM(rb_intern(name));
16890  }
16891  switch (id) {
16892  case tOROP:
16893  name = "||";
16894  break;
16895  case tANDOP:
16896  name = "&&";
16897  break;
16898  default:
16899  name = rb_id2name(id);
16900  if (!name) {
16901  rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
16902  }
16903  return ID2SYM(id);
16904  }
16905  return ID2SYM(rb_intern(name));
16906 }
16907 
16908 static ID
16909 ripper_get_id(VALUE v)
16910 {
16911  NODE *nd;
16912  if (!RB_TYPE_P(v, T_NODE)) return 0;
16913  nd = (NODE *)v;
16914  if (nd_type(nd) != NODE_LASGN) return 0;
16915  return nd->nd_vid;
16916 }
16917 
16918 static VALUE
16919 ripper_get_value(VALUE v)
16920 {
16921  NODE *nd;
16922  if (v == Qundef) return Qnil;
16923  if (!RB_TYPE_P(v, T_NODE)) return v;
16924  nd = (NODE *)v;
16925  if (nd_type(nd) != NODE_LASGN) return Qnil;
16926  return nd->nd_rval;
16927 }
16928 
16929 static void
16930 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
16931 {
16932  VALUE str;
16933  va_list args;
16934 
16935  va_start(args, fmt);
16936  str = rb_vsprintf(fmt, args);
16937  va_end(args);
16938  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
16939 }
16940 
16941 static void
16942 ripper_warn0(struct parser_params *parser, const char *fmt)
16943 {
16944  rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
16945 }
16946 
16947 static void
16948 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
16949 {
16950  rb_funcall(parser->value, rb_intern("warn"), 2,
16951  STR_NEW2(fmt), INT2NUM(a));
16952 }
16953 
16954 #if 0
16955 static void
16956 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
16957 {
16958  rb_funcall(parser->value, rb_intern("warn"), 2,
16959  STR_NEW2(fmt), STR_NEW2(str));
16960 }
16961 #endif
16962 
16963 static void
16964 ripper_warning0(struct parser_params *parser, const char *fmt)
16965 {
16966  rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
16967 }
16968 
16969 static void
16970 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
16971 {
16972  rb_funcall(parser->value, rb_intern("warning"), 2,
16973  STR_NEW2(fmt), STR_NEW2(str));
16974 }
16975 
16976 static VALUE
16977 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
16978 {
16979  return rb_funcall(src, ripper_id_gets, 0);
16980 }
16981 
16982 static VALUE
16983 ripper_s_allocate(VALUE klass)
16984 {
16985  struct parser_params *p;
16986  VALUE self;
16987 
16988  p = ALLOC_N(struct parser_params, 1);
16989  MEMZERO(p, struct parser_params, 1);
16990  self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
16991  p->value = self;
16992  return self;
16993 }
16994 
16995 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
16996 
16997 /*
16998  * call-seq:
16999  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
17000  *
17001  * Create a new Ripper object.
17002  * _src_ must be a String, an IO, or an Object which has #gets method.
17003  *
17004  * This method does not starts parsing.
17005  * See also Ripper#parse and Ripper.parse.
17006  */
17007 static VALUE
17008 ripper_initialize(int argc, VALUE *argv, VALUE self)
17009 {
17010  struct parser_params *parser;
17011  VALUE src, fname, lineno;
17012 
17013  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17014  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
17015  if (rb_obj_respond_to(src, ripper_id_gets, 0)) {
17016  parser->parser_lex_gets = ripper_lex_get_generic;
17017  }
17018  else {
17019  StringValue(src);
17020  parser->parser_lex_gets = lex_get_str;
17021  }
17022  parser->parser_lex_input = src;
17023  parser->eofp = Qfalse;
17024  if (NIL_P(fname)) {
17025  fname = STR_NEW2("(ripper)");
17026  }
17027  else {
17028  StringValue(fname);
17029  }
17030  parser_initialize(parser);
17031 
17032  parser->parser_ruby_sourcefile_string = fname;
17033  parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
17034  parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
17035 
17036  return Qnil;
17037 }
17038 
17039 struct ripper_args {
17040  struct parser_params *parser;
17041  int argc;
17042  VALUE *argv;
17043 };
17044 
17045 static VALUE
17046 ripper_parse0(VALUE parser_v)
17047 {
17048  struct parser_params *parser;
17049 
17050  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17051  parser_prepare(parser);
17052  ripper_yyparse((void*)parser);
17053  return parser->result;
17054 }
17055 
17056 static VALUE
17057 ripper_ensure(VALUE parser_v)
17058 {
17059  struct parser_params *parser;
17060 
17061  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17062  parser->parsing_thread = Qnil;
17063  return Qnil;
17064 }
17065 
17066 /*
17067  * call-seq:
17068  * ripper#parse
17069  *
17070  * Start parsing and returns the value of the root action.
17071  */
17072 static VALUE
17073 ripper_parse(VALUE self)
17074 {
17075  struct parser_params *parser;
17076 
17077  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17078  if (!ripper_initialized_p(parser)) {
17079  rb_raise(rb_eArgError, "method called for uninitialized object");
17080  }
17081  if (!NIL_P(parser->parsing_thread)) {
17082  if (parser->parsing_thread == rb_thread_current())
17083  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
17084  else
17085  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
17086  }
17087  parser->parsing_thread = rb_thread_current();
17088  rb_ensure(ripper_parse0, self, ripper_ensure, self);
17089 
17090  return parser->result;
17091 }
17092 
17093 /*
17094  * call-seq:
17095  * ripper#column -> Integer
17096  *
17097  * Return column number of current parsing line.
17098  * This number starts from 0.
17099  */
17100 static VALUE
17101 ripper_column(VALUE self)
17102 {
17103  struct parser_params *parser;
17104  long col;
17105 
17106  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17107  if (!ripper_initialized_p(parser)) {
17108  rb_raise(rb_eArgError, "method called for uninitialized object");
17109  }
17110  if (NIL_P(parser->parsing_thread)) return Qnil;
17111  col = parser->tokp - parser->parser_lex_pbeg;
17112  return LONG2NUM(col);
17113 }
17114 
17115 /*
17116  * call-seq:
17117  * ripper#filename -> String
17118  *
17119  * Return current parsing filename.
17120  */
17121 static VALUE
17122 ripper_filename(VALUE self)
17123 {
17124  struct parser_params *parser;
17125 
17126  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17127  if (!ripper_initialized_p(parser)) {
17128  rb_raise(rb_eArgError, "method called for uninitialized object");
17129  }
17130  return parser->parser_ruby_sourcefile_string;
17131 }
17132 
17133 /*
17134  * call-seq:
17135  * ripper#lineno -> Integer
17136  *
17137  * Return line number of current parsing line.
17138  * This number starts from 1.
17139  */
17140 static VALUE
17141 ripper_lineno(VALUE self)
17142 {
17143  struct parser_params *parser;
17144 
17145  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17146  if (!ripper_initialized_p(parser)) {
17147  rb_raise(rb_eArgError, "method called for uninitialized object");
17148  }
17149  if (NIL_P(parser->parsing_thread)) return Qnil;
17150  return INT2NUM(parser->parser_ruby_sourceline);
17151 }
17152 
17153 #ifdef RIPPER_DEBUG
17154 /* :nodoc: */
17155 static VALUE
17156 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
17157 {
17158  StringValue(msg);
17159  if (obj == Qundef) {
17160  rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
17161  }
17162  return Qnil;
17163 }
17164 
17165 /* :nodoc: */
17166 static VALUE
17167 ripper_value(VALUE self, VALUE obj)
17168 {
17169  return ULONG2NUM(obj);
17170 }
17171 #endif
17172 
17173 
17174 void
17175 InitVM_ripper(void)
17176 {
17177  parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
17178 }
17179 
17180 void
17181 Init_ripper(void)
17182 {
17183  VALUE Ripper;
17184 
17185  InitVM(ripper);
17186  Ripper = rb_define_class("Ripper", rb_cObject);
17187  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
17188  rb_define_alloc_func(Ripper, ripper_s_allocate);
17189  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
17190  rb_define_method(Ripper, "parse", ripper_parse, 0);
17191  rb_define_method(Ripper, "column", ripper_column, 0);
17192  rb_define_method(Ripper, "filename", ripper_filename, 0);
17193  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
17194  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
17195  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
17196  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
17197  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
17198 #ifdef RIPPER_DEBUG
17199  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
17200  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
17201  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
17202 #endif
17203 
17204  ripper_id_gets = rb_intern("gets");
17205  ripper_init_eventids1(Ripper);
17206  ripper_init_eventids2(Ripper);
17207  /* ensure existing in symbol table */
17208  (void)rb_intern("||");
17209  (void)rb_intern("&&");
17210 
17211 # if 0
17212  /* Hack to let RDoc document SCRIPT_LINES__ */
17213 
17214  /*
17215  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
17216  * after the assignment will be added as an Array of lines with the file
17217  * name as the key.
17218  */
17219  rb_define_global_const("SCRIPT_LINES__", Qnil);
17220 #endif
17221 
17222 }
17223 #endif /* RIPPER */
17224 
#define STRNCASECMP(s1, s2, n)
Definition: ruby.h:1467
RUBY_EXTERN VALUE rb_cString
Definition: ruby.h:1276
#define in_defined
Definition: ripper.c:350
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:1937
#define UTF8_ENC()
Definition: ripper.c:327
char * parser_ruby_sourcefile
Definition: ripper.c:295
VALUE val
Definition: ripper.y:170
#define local_var(id)
Definition: ripper.c:506
#define RSTRING_LEN(string)
Definition: generator.h:45
#define NEW_YIELD(a, s)
#define cond(node)
Definition: ripper.c:392
#define deferred_nodes
Definition: ripper.c:362
#define nd_next
#define nd_type(n)
#define arg_var(id)
Definition: ripper.c:508
#define NEW_ARGSCAT(a, b)
RARRAY_PTR(q->result)[0]
#define NODE_DREGX_ONCE
#define ret_args(node)
Definition: ripper.c:441
#define yyparse
Definition: ripper.c:386
#define T_OBJECT
Definition: ruby.h:413
stack_type cmdargs
Definition: ripper.c:163
#define NEW_FALSE()
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: ripper.c:4531
enum lex_state_e state
Definition: lex.c:33
struct local_vars * parser_lvtbl
Definition: ripper.c:291
#define NODE_IF
VALUE rb_ary_unshift(VALUE ary, VALUE item)
Definition: array.c:939
static ID ripper_token2eventid(int tok)
Definition: eventids2.c:267
#define NODE_RESCUE
Definition: lex.c:33
#define IS_LABEL_SUFFIX(n)
Definition: ripper.c:12972
#define YYSTACK_ALLOC
Definition: ripper.c:978
int rb_enc_codelen(int c, rb_encoding *enc)
Definition: encoding.c:916
#define NODE_RETRY
Definition: ripper.y:118
#define NODE_DEFN
static double zero(void)
Definition: isinf.c:51
#define lex_input
Definition: ripper.c:354
#define lex_state
Definition: ripper.c:340
#define subnodes(n1, n2)
#define parser_precise_mbclen()
Definition: ripper.c:11294
static NODE * remove_begin(NODE *)
Definition: ripper.c:15087
ssize_t n
Definition: bigdecimal.c:5519
#define MBCLEN_CHARFOUND_P(ret)
Definition: encoding.h:135
#define NEW_STRTERM(func, term, paren)
Definition: ripper.c:12274
VALUE sym
Definition: tkutil.c:1298
struct RString::@31::@32 heap
static const yytype_int16 yydefgoto[]
Definition: ripper.c:1767
volatile VALUE ary
Definition: tcltklib.c:9700
#define list_concat(h, t)
Definition: ripper.c:417
#define NODE_FALSE
#define NEW_DOT3(b, e)
static struct parser_params * parser_new(void)
Definition: ripper.c:16576
VP_EXPORT int
Definition: bigdecimal.c:4911
#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:530
#define NEW_IASGN(v, val)
VALUE rb_get_coverages(void)
Definition: thread.c:4886
#define yydebug
Definition: ripper.c:370
static char *char * yydest
Definition: ripper.c:4507
static NODE * arg_blk_pass(NODE *, NODE *)
Definition: ripper.c:15419
#define NEW_NTH_REF(n)
static ID internal_id_gen(struct parser_params *)
Definition: ripper.c:16000
Definition: ripper.y:114
void rb_bug(const char *fmt,...)
Definition: error.c:265
#define NEW_DASGN_CURR(v, val)
int num
Definition: ripper.y:173
#define IS_END()
Definition: ripper.c:12968
struct token_info * next
Definition: ripper.c:245
#define ENC_SINGLE(cr)
Definition: ripper.c:333
#define FALSE
Definition: nkf.h:185
static NODE * logop_gen(struct parser_params *, enum node_type, NODE *, NODE *)
Definition: ripper.c:15343
Definition: ripper.y:107
struct vtable * used
Definition: ripper.c:161
int idx
Definition: tcltklib.c:9703
#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:11652
static int comment_at_top(struct parser_params *parser)
Definition: ripper.c:12713
#define RE_OPTION_ENCODING_IDX(o)
Definition: ripper.c:533
#define rb_gc_mark_locations(start, end)
Definition: gc.c:1571
size_t strlen(const char *)
#define assignable(id, node)
Definition: ripper.c:449
yytype_int16 yyssa[YYINITDEPTH]
Definition: ripper.c:4804
static size_t parser_memsize(const void *ptr)
Definition: ripper.c:16533
VALUE parser_lex_nextline
Definition: ripper.c:282
VALUE rb_make_exception(int argc, VALUE *argv)
Definition: eval.c:574
keyword_alias tGVAR tBACK_REF
Definition: ripper.y:976
#define STR_FUNC_ESCAPE
Definition: ripper.c:11671
#define scan_oct(s, l, e)
Definition: util.h:52
#define T_FIXNUM
Definition: ruby.h:425
Definition: st.h:77
VALUE stack_type
Definition: ripper.c:134
#define reg_compile(str, options)
Definition: ripper.c:470
VALUE rb_id2str(ID id)
Definition: ripper.c:16301
static NODE * call_uni_op_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:14566
#define toksiz
Definition: ripper.c:353
#define YY_(msgid)
Definition: ripper.c:910
int parser_ruby__end__seen
Definition: ripper.c:292
static void ripper_init_eventids2(VALUE self)
Definition: eventids2.c:62
#define NODE_DSYM
int parser_command_start
Definition: ripper.c:287
static void fixpos(NODE *, NODE *)
Definition: ripper.c:14336
VALUE rb_range_new(VALUE, VALUE, int)
Definition: range.c:61
#define NODE_DEFS
#define NUM2INT(x)
Definition: ruby.h:536
#define YYSTACK_FREE
Definition: ripper.c:979
#define NEW_CALL(r, m, a)
#define nd_body
static void reduce_nodes_gen(struct parser_params *, NODE **)
Definition: ripper.c:15097
#define value_expr(node)
Definition: ripper.c:402
parser parser_yylval val
Definition: ripper.c:14289
#define nd_paren(node)
Definition: ripper.c:547
#define NODE_DOT3
static NODE * call_bin_op_gen(struct parser_params *, NODE *, ID, NODE *)
Definition: ripper.c:14558
const char * name
Definition: lex.c:33
#define tEMBDOC_BEG
Definition: eventids2.c:3
Definition: ripper.y:117
static int parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp, int string_literal, int symbol_literal, int regexp_literal)
Definition: ripper.c:11838
int parser_compile_for_eval
Definition: ripper.c:274
#define get_id(id)
Definition: ripper.c:478
int parser_token_info_enabled
Definition: ripper.c:310
#define NEW_ALIAS(n, o)
VALUE op_sym[tLAST_TOKEN]
Definition: ripper.c:15942
#define YYLEX
Definition: ripper.c:4279
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:1889
Definition: ripper.y:104
#define YYABORT
Definition: ripper.c:4199
#define st_foreach
Definition: regint.h:150
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:104
static void parser_heredoc_restore(struct parser_params *parser, NODE *here)
Definition: ripper.c:12482
#define lex_eol_p()
Definition: ripper.c:11707
#define LONG2NUM(i)
Definition: cparse.c:72
char * finish
Definition: yaml2byte.c:128
#define NEW_TRUE()
rb_hash_aset(CALLBACK_TABLE, id_num, cmd)
static int yysyntax_error(YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
Definition: ripper.c:4579
#define dyna_in_block()
Definition: ripper.c:519
#define nd_resq
#define NODE_NTH_REF
#define CMDARG_LEXPOP()
Definition: ripper.c:148
static NODE * gettable_gen(struct parser_params *, ID)
Definition: ripper.c:14607
#define str_copy(_s, _p, _n)
#define RFLOAT_VALUE(val)
Definition: generator.h:32
#define NODE_TRUE
#define was_bol()
Definition: ripper.c:11777
#define TypedData_Wrap_Struct(klass, data_type, sval)
Definition: ruby.h:826
#define IS_SPCARG(c)
Definition: ripper.c:12970
#define YYPARSE_PARAM
Definition: gram.c:103
#define void_stmts(node)
Definition: ripper.c:406
#define END
Definition: escape.c:171
static struct symbols global_symbols
VALUE rb_parser_end_seen_p(VALUE vparser)
Definition: ripper.c:16601
#define TypedData_Get_Struct(obj, type, data_type, sval)
Definition: ruby.h:840
int line_count
Definition: ripper.c:293
#define YYNTOKENS
Definition: ripper.c:1075
#define NEW_EVSTR(n)
#define NEW_NEXT(s)
struct token_info token_info
stack_type parser_cmdarg_stack
Definition: ripper.c:268
int yyresult
Definition: ripper.c:4816
yytype_int16 * yyssp
Definition: ripper.c:4806
VALUE rb_external_str_new_with_enc(const char *ptr, long len, rb_encoding *)
Definition: string.c:534
#define strcasecmp
Definition: win32.h:208
#define nextc()
Definition: ripper.c:11184
#define rb_warning0(fmt)
Definition: ripper.c:626
SYMID SyckParser * p
Definition: yaml2byte.c:119
VALUE rb_enc_from_encoding(rb_encoding *encoding)
Definition: encoding.c:102
static YYSIZE_T const char * yystr
Definition: ripper.c:4483
#define NEW_NIL()
#define token_info_push(token)
Definition: ripper.c:666
return ST_CONTINUE
Definition: tkutil.c:1273
static VALUE debug_lines(const char *f)
Definition: ripper.c:11440
#define NODE_ENSURE
static int parser_here_document(struct parser_params *, NODE *)
Definition: ripper.c:12529
#define rb_warnS(fmt, a)
Definition: ripper.c:625
Definition: ripper.y:119
long(* rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len)
Definition: ripper.c:12725
#define NEW_ZARRAY()
#define logop(type, node1, node2)
Definition: ripper.c:394
unsigned long VALUE
Definition: ruby.h:88
VALUE enc
Definition: tcltklib.c:10402
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:740
Definition: ripper.y:98
unsigned long int yylno
Definition: ripper.c:4419
static NODE * evstr2dstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:14535
VALUE rb_eEncodingError
Definition: error.c:473
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:15731
static void warn_unused_var(struct parser_params *parser, struct local_vars *local)
Definition: ripper.c:15455
return yyd
Definition: ripper.c:4517
struct RBasic basic
Definition: ruby.h:653
unsigned short int yytype_uint16
Definition: ripper.c:877
#define nd_else
#define parse_string(n)
Definition: ripper.c:11194
yytokentype
Definition: ripper.y:40
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:750
#define NODE_PRELUDE
static VALUE INT2NUM(int v)
Definition: ruby.h:981
rb_encoding * utf8
Definition: ripper.c:298
#define is_identchar(p, e, enc)
Definition: ripper.c:11295
yytype_int16 * yyss
Definition: ripper.c:4805
#define NEW_MATCH2(n1, n2)
#define COND_PUSH(n)
Definition: ripper.c:141
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2516
VALUE debug_lines
Definition: ripper.c:306
#define warn_balanced(op, syn)
Definition: ripper.c:12981
ID id
Definition: ripper.y:172
#define nd_plen
#define match_op(node1, node2)
Definition: ripper.c:462
static void VALUE * p2
Definition: array.c:1848
#define CMDARG_P()
Definition: ripper.c:149
#define dvar_defined(id)
Definition: ripper.c:522
#define NEW_POSTEXE(b)
#define NEW_STR(s)
VALUE var
Definition: tcltklib.c:5506
keyword_alias tGVAR tNTH_REF
Definition: ripper.y:987
#define yyerrok
Definition: ripper.c:4193
#define NODE_EVSTR
#define RSTRING_PTR(string)
Definition: generator.h:42
#define YYEMPTY
Definition: ripper.c:4195
#define tok()
Definition: ripper.c:11780
int rb_enc_str_coderange(VALUE)
Definition: string.c:324
#define NODE_DXSTR
#define reg_fragment_setenc(str, options)
Definition: ripper.c:472
static NODE * match_op_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14573
#define NODE_CASE
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1574
#define rb_warnI(fmt, a)
Definition: ripper.c:624
Definition: ripper.y:108
return Qtrue
Definition: tcltklib.c:9597
Definition: ripper.y:148
static NODE * node_assign_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14891
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
Definition: encoding.c:727
static NODE * block_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14359
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: ripper.c:4296
static NODE * newline_node(NODE *)
Definition: ripper.c:14326
ID * tbl
Definition: ripper.c:152
#define new_args(f, o, r, p, b)
Definition: ripper.c:437
#define MAX_WORD_LENGTH
Definition: name2ctype.h:22187
const rb_data_type_t * parent
Definition: ruby.h:779
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:153
#define newtok()
Definition: ripper.c:11186
static NODE * range_op(struct parser_params *parser, NODE *node)
Definition: ripper.c:15242
#define reduce_nodes(n)
Definition: ripper.c:408
#define YYPOPSTACK(N)
Definition: ripper.c:4830
#define dyna_var(id)
Definition: ripper.c:520
primary_value operation2 command_args prec tLOWEST
Definition: ripper.y:1370
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
#define NODE_HEREDOC
Definition: ripper.c:539
#define T_HASH
Definition: ruby.h:421
#define NEW_CONST(v)
int parser_toksiz
Definition: ripper.c:279
#define POINTER_P(val)
Definition: ripper.c:169
#define STR_FUNC_INDENT
Definition: ripper.c:11676
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
Definition: encoding.c:847
st_index_t rb_str_hash(VALUE)
Definition: string.c:2170
#define RARRAY_LEN(ARRAY)
Definition: generator.h:39
VALUE rb_ary_new3(long n,...)
Definition: array.c:347
static void parser_pushback(struct parser_params *parser, int c)
Definition: ripper.c:11768
return str
Definition: ruby.c:1183
#define NODE_STR
ID last_id
Definition: ripper.c:15935
nd_set_line($$,$< num >2)
#define NODE_REDO
static int lvar_defined_gen(struct parser_params *, ID)
Definition: ripper.c:12654
#define NODE_NEXT
const char * alias
Definition: nkf.c:1127
#define ruby__end__seen
Definition: ripper.c:366
Definition: ripper.y:111
#define NEW_DVAR(v)
void(* rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:12726
#define T_ARRAY
Definition: ruby.h:420
r
Definition: bigdecimal.c:1154
#define ruby_debug_lines
Definition: ripper.c:375
#define st_lookup
Definition: regint.h:149
#define parser_is_identchar()
Definition: ripper.c:11296
#define rb_enc_islower(c, enc)
Definition: encoding.h:173
#define local_pop()
Definition: ripper.c:504
#define ID_LOCAL
#define ruby_sourcefile
Definition: compile.c:426
#define NODE_XSTR
Definition: ripper.y:106
#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:12499
#define NODE_BLOCK_PASS
#define RE_OPTION_ENCODING(e)
Definition: ripper.c:532
#define rb_backref_error(n)
Definition: ripper.c:457
#define ISDIGIT(c)
#define NEW_BREAK(s)
unsigned int last
Definition: nkf.c:3915
#define NEW_OP_ASGN_OR(i, val)
static void parser_initialize(struct parser_params *parser)
Definition: ripper.c:16435
#define NEW_MASGN(l, r)
static NODE * node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE)
Definition: ripper.c:14306
static const yytype_uint16 yyr1[]
Definition: ripper.c:1534
int yytoken
Definition: ripper.c:4818
int yystate
Definition: ripper.c:4792
static NODE * yycompile(struct parser_params *parser, const char *f, int line)
Definition: ripper.c:11528
struct RNode * node
Definition: ripper.y:240
static ID * vtable_tblcpy(ID *buf, const struct vtable *src)
Definition: ripper.c:15506
#define FIXNUM_P(f)
Definition: ruby.h:338
#define lex_gets_ptr
Definition: ripper.c:363
rb_encoding * rb_utf8_encoding(void)
Definition: encoding.c:1125
#define here_document(n)
Definition: ripper.c:11196
VALUE parser_lex_input
Definition: ripper.c:280
#define nd_aid
static long parser_encode_length(struct parser_params *parser, const char *name, long len)
Definition: ripper.c:12661
VALUE tbl
Definition: tkutil.c:1279
#define is_instance_id(id)
Definition: ripper.c:108
#define NEW_LVAR(v)
#define call_bin_op(recv, id, arg1)
Definition: ripper.c:432
VALUE VALUE args
Definition: tcltklib.c:2550
VALUE klass
Definition: ruby.h:598
#define arg_concat(h, t)
Definition: ripper.c:421
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2031
VALUE rb_sym_all_symbols(void)
Definition: ripper.c:16394
static VALUE lex_getline(struct parser_params *parser)
Definition: ripper.c:11567
#define ID2SYM(i)
Definition: cparse.c:63
static NODE * ret_args_gen(struct parser_params *, NODE *)
Definition: ripper.c:15366
Definition: ripper.y:113
#define ID_INTERNAL
static const yytype_int16 yytable[]
Definition: ripper.c:1923
Definition: ripper.y:95
int pos
Definition: ripper.c:153
#define NEW_FOR(v, i, b)
#define YYLAST
Definition: ripper.c:1072
#define NEW_CLASS(n, b, s)
#define YYID(n)
Definition: ripper.c:923
#define NODE_GASGN
int rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:16047
#define NEW_SPLAT(a)
#define ID_SCOPE_SHIFT
flag
Definition: tcltklib.c:2039
#define st_init_numtable_with_size
Definition: regint.h:143
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: ripper.c:16646
#define ENC_CODERANGE_7BIT
Definition: encoding.h:58
#define NEW_PRELUDE(p, b)
const char * rb_obj_classname(VALUE)
Definition: variable.c:318
d
Definition: strlcat.c:58
void rb_gc_force_recycle(VALUE p)
Definition: gc.c:2345
static int yylex(void *, void *)
gz lineno
Definition: zlib.c:2031
bodystmt escape_Qundef($1)
#define NEW_ITER(a, b)
const char * fmt
Definition: tcltklib.c:837
unsigned char OnigUChar
Definition: oniguruma.h:110
int parser_yydebug
Definition: ripper.c:300
#define gettable(id)
Definition: ripper.c:447
st_table * id_str
Definition: ripper.c:15937
NODE * parser_eval_tree
Definition: ripper.c:305
#define list_append(l, i)
Definition: ripper.c:415
NODE * parser_deferred_nodes
Definition: ripper.c:288
#define NEW_GVAR(v)
VALUE rb_str_buf_cat(VALUE, const char *, long)
Definition: string.c:1873
#define tLAST_TOKEN
Definition: ripper.y:37
int yyi
Definition: ripper.c:4416
command_asgn lhs
Definition: ripper.y:1241
#define STR_NEW0()
Definition: ripper.c:330
Definition: ripper.y:236
static int e_option_supplied(struct parser_params *parser)
Definition: ripper.c:11474
static void block_dup_check_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14803
int has_shebang
Definition: ripper.c:294
#define NEWHEAP()
Definition: ripper.c:16657
#define NEW_DSTR(s)
#define SPECIAL_PUNCT(idx)
Definition: ripper.c:12301
#define nd_set_type(n, t)
Real * b
Definition: bigdecimal.c:1140
static int vtable_size(const struct vtable *tbl)
Definition: ripper.c:172
static int assign_in_cond(struct parser_params *parser, NODE *node)
Definition: ripper.c:15158
#define ISALPHA(c)
Definition: ruby.h:1457
void rb_exc_raise(VALUE mesg)
Definition: eval.c:460
#define NEW_UNLESS(c, t, e)
block_command ripper_id2sym('.')
#define STR_FUNC_REGEXP
Definition: ripper.c:11673
#define NEW_MODULE(n, b)
#define Qnil
Definition: ruby.h:367
static NODE * list_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14413
#define strtod(s, e)
Definition: util.h:76
static rb_encoding * must_be_ascii_compatible(VALUE s)
Definition: ripper.c:11537
struct vtable * prev
Definition: ripper.c:155
int rb_is_const_id(ID id)
Definition: ripper.c:16403
int rb_is_instance_id(ID id)
Definition: ripper.c:16415
#define RB_TYPE_P(obj, type)
Definition: ruby.h:1353
return rb_str_append(rb_str_new2(cmd_id_head), id_num)
static int parser_tokadd_string(struct parser_params *, int, int, int, long *, rb_encoding **)
Definition: ripper.c:12145
#define VTBL_DEBUG
Definition: ripper.c:182
VALUE hash
Definition: tkutil.c:267
#define arg_append(h, t)
Definition: ripper.c:419
#define assignable_result(x)
#define CMDARG_PUSH(n)
Definition: ripper.c:146
YYSTYPE yyval
Definition: ripper.c:4821
#define MEMZERO(p, type, n)
Definition: ruby.h:1052
Definition: ripper.y:109
Definition: ruby.h:652
#define RE_OPTION_MASK
Definition: ripper.c:535
Definition: ripper.y:96
#define NEW_OP_ASGN_AND(i, val)
static NODE * arg_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14840
rb_encoding * enc
Definition: ripper.c:297
#define parser_warning(node, mesg)
Definition: ripper.c:14349
#define nd_args
#define NODE_LVAR
static int parser_regx_options(struct parser_params *)
Definition: ripper.c:12084
n NULL
Definition: yaml2byte.c:134
enum lex_state_e parser_lex_state
Definition: ripper.c:266
#define whole_match_p(e, l, i)
Definition: ripper.c:11199
#define op_tbl_count
Definition: ripper.c:15928
#define NODE_LASGN
int capa
Definition: ripper.c:154
VALUE parser_lex_lastline
Definition: ripper.c:281
#define lex_nextline
Definition: ripper.c:356
#define YYTERROR
Definition: ripper.c:4237
#define NEW_OPT_N(b)
Definition: ripper.y:112
void * data
Definition: yaml2byte.c:131
NODE * rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: ripper.c:11617
#define set_yylval_literal(x)
Definition: ripper.c:11206
BDIGIT m
Definition: bigdecimal.c:4946
static int parser_yylex(struct parser_params *parser)
Definition: ripper.c:12989
static VALUE parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
Definition: ripper.c:11690
#define scan_hex(s, l, e)
Definition: util.h:54
static int dyna_in_block_gen(struct parser_params *)
Definition: ripper.c:15624
return Qfalse
Definition: tcltklib.c:6768
static const yytype_uint16 yystos[]
Definition: ripper.c:4089
static char * parser_tokspace(struct parser_params *parser, int n)
Definition: ripper.c:11800
#define RARRAY(obj)
Definition: ruby.h:911
#define arg_ambiguous()
Definition: ripper.c:12640
#define ALLOC_N(type, n)
Definition: ruby.h:1034
void rb_compile_error_append(const char *fmt,...)
Definition: error.c:129
#define evstr2dstr(n)
Definition: ripper.c:428
static void parser_free(void *ptr)
Definition: ripper.c:16513
#define IS_ARG()
Definition: ripper.c:12967
#define PARSER_ARG
Definition: ripper.c:651
#define NODE_WHEN
#define literal_concat(h, t)
Definition: ripper.c:423
int rb_ispunct(int c)
Definition: encoding.c:1646
RUBY_EXTERN VALUE rb_cObject
Definition: ruby.h:1246
VALUE rb_eRuntimeError
Definition: error.c:466
#define compile_error
Definition: ripper.c:650
static int symbols_i(VALUE sym, ID value, VALUE ary)
Definition: ripper.c:16371
#define NEW_RESCUE(b, res, e)
#define yylval
Definition: ripper.c:11175
static int parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
Definition: ripper.c:12011
#define rb_enc_isascii(c, enc)
Definition: encoding.h:171
static int dvar_curr_gen(struct parser_params *, ID)
Definition: ripper.c:15661
VALUE rb_parser_encoding(VALUE vparser)
Definition: ripper.c:16616
#define st_init_table_with_size
Definition: regint.h:141
#define ifndef_ripper(x)
Definition: ripper.c:617
static const yytype_uint16 yyrline[]
Definition: ripper.c:1381
struct parser_params * parser
Definition: ripper.c:15723
#define NODE_YIELD
#define NEW_NODE(t, a0, a1, a2)
#define yytable_value_is_error(yytable_value)
Definition: ripper.c:3005
#define NEW_LIST(a)
#define NEW_ENSURE(b, en)
#define cur_mid
Definition: ripper.c:349
#define NODE_FLIP2
char * ruby_strdup(const char *)
Definition: util.c:425
#define nd_vid
#define NODE_BLOCK
#define ID_INSTANCE
NODE * rb_compile_string(const char *f, VALUE s, int line)
Definition: ripper.c:11610
#define NEW_BLOCK(a)
static const yytype_uint16 yyprhs[]
Definition: ripper.c:1136
int yyrule
Definition: ripper.c:4413
VALUE rb_obj_as_string(VALUE)
Definition: string.c:854
#define NODE_DASGN_CURR
static NODE * list_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14433
int parser_paren_nest
Definition: ripper.c:270
VALUE rb_ary_new(void)
Definition: array.c:339
#define NODE_AND
int rb_ascii8bit_encindex(void)
Definition: encoding.c:1119
int flags
Definition: tcltklib.c:3012
static int is_global_name_punct(const char c)
Definition: ripper.c:12318
#define NEW_UNDEF(i)
#define ID_JUNK
#define is_attrset_id(id)
Definition: ripper.c:109
#define set_yylval_name(x)
Definition: ripper.c:11205
va_end(args)
#define ID_GLOBAL
static char * parser_newtok(struct parser_params *parser)
Definition: ripper.c:11785
YYSIZE_T yymsg_alloc
Definition: ripper.c:4827
RUBY_EXTERN VALUE rb_mKernel
Definition: ruby.h:1234
#define snprintf
Definition: subst.h:6
VALUE rb_thread_current(void)
Definition: thread.c:1742
static int vtable_included(const struct vtable *tbl, ID id)
Definition: ripper.c:224
#define block_dup_check(n1, n2)
Definition: ripper.c:410
#define tokadd(c)
Definition: ripper.c:11188
static NODE * arg_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14865
static void local_push_gen(struct parser_params *, int)
Definition: ripper.c:15475
#define NIL_P(v)
Definition: ruby.h:374
#define NEW_WHEN(c, t, e)
static void const char * yymsg
Definition: ripper.c:4719
#define ISASCII(c)
Definition: ruby.h:1450
#define tokenbuf
Definition: ripper.c:351
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:469
#define COND_POP()
Definition: ripper.c:142
#define heredoc_identifier()
Definition: ripper.c:11197
static VALUE VALUE obj
Definition: tcltklib.c:3147
static void parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:12738
static struct st_hash_type symhash
Definition: ripper.c:15945
#define YYSYNTAX_ERROR
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:1923
static void parser_tokadd(struct parser_params *parser, int c)
Definition: ripper.c:11812
#define k__END__
Definition: eventids2.c:9
static void parser_mark(void *ptr)
Definition: ripper.c:16487
#define ISALNUM(c)
Definition: ruby.h:1456
#define YYDPRINTF(Args)
Definition: ripper.c:4290
return yylen
Definition: ripper.c:4489
#define RFLOAT(obj)
Definition: ruby.h:908
#define lex_goto_eol(parser)
Definition: ripper.c:11706
static double one(void)
Definition: isinf.c:52
int yyn
Definition: ripper.c:4815
enum node_type nodetype(NODE *node)
Definition: ripper.c:14314
#define NODE_ARGSCAT
#define local_id(id)
Definition: ripper.c:510
#define NODE_COLON2
#define T_FLOAT
Definition: ruby.h:417
NODE * rb_parser_append_print(VALUE vparser, NODE *node)
Definition: ripper.c:15832
#define TYPE(x)
Definition: ruby.h:441
yytype_int16 yyss_alloc
Definition: ripper.c:1016
static void vtable_add(struct vtable *tbl, ID id)
Definition: ripper.c:209
#define YYFINAL
Definition: ripper.c:1070
#define dvar_curr(id)
Definition: ripper.c:525
static NODE * parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: ripper.c:11590
#define ALLOCA_N(type, n)
Definition: ruby.h:1038
#define flush_string_content(enc)
Definition: ripper.c:12293
#define NEW_ARGS_AUX(r, b)
#define T_BIGNUM
Definition: ruby.h:423
static struct @13 op_tbl[]
static VALUE coverage(const char *f, int n)
Definition: ripper.c:11457
#define ENC_CODERANGE_UNKNOWN
Definition: encoding.h:57
#define tokadd_string(f, t, p, n, e)
Definition: ripper.c:11193
keyword_END
Definition: ripper.y:1057
static NODE * new_yield_gen(struct parser_params *, NODE *)
Definition: ripper.c:15383
#define ripper_flush(p)
Definition: ripper.c:11225
static VALUE lex_get_str(struct parser_params *parser, VALUE s)
Definition: ripper.c:11547
#define ISUPPER(c)
Definition: ruby.h:1454
#define RUBY_FUNC_EXPORTED
Definition: defines.h:254
#define MEMCPY(p1, p2, type, n)
Definition: ruby.h:1053
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:3913
#define T_NODE
Definition: ruby.h:434
#define ENC_CODERANGE_BROKEN
Definition: encoding.h:60
#define rb_enc_isupper(c, enc)
Definition: encoding.h:174
VALUE rb_enc_associate_index(VALUE obj, int idx)
Definition: encoding.c:709
int rb_parse_in_main(void)
Definition: compile.c:5576
static int parser_nextc(struct parser_params *parser)
Definition: ripper.c:11712
#define NEW_ARGS(m, o)
int err
Definition: win32.c:78
#define dyna_pop(node)
Definition: ripper.c:517
#define OBJ_FREEZE(x)
Definition: ruby.h:970
#define YYACCEPT
Definition: ripper.c:4198
const char * parser_lex_pend
Definition: ripper.c:285
#define NEW_DEFINED(e)
static ID formal_argument_gen(struct parser_params *, ID)
Definition: ripper.c:12643
static void void_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:14984
#define YYEOF
Definition: ripper.c:4196
void rb_gc_mark_symbols(void)
Definition: ripper.c:15991
long cnt
Definition: ripper.y:257
ID token
Definition: ripper.c:15905
static int VALUE key
Definition: tkutil.c:265
#define YY_REDUCE_PRINT(Rule)
Definition: ripper.c:4433
YYSTYPE yyvsa[YYINITDEPTH]
Definition: ripper.c:4809
Definition: ripper.y:115
NODE * rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
Definition: ripper.c:15864
NODE * rb_compile_cstr(const char *f, const char *s, int len, int line)
Definition: ripper.c:11624
token_info * parser_token_info
Definition: ripper.c:311
Definition: ripper.y:122
static void magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:12729
int column
Definition: ripper.c:243
VALUE rb_make_backtrace(void)
Definition: vm_eval.c:1657
#define ALLOC(type)
Definition: ruby.h:1035
#define EOF
Definition: vsnprintf.c:206
int yyerrstatus
Definition: ripper.c:4794
void * rb_parser_malloc(struct parser_params *parser, size_t size)
Definition: ripper.c:16662
#define peek_n(c, n)
Definition: ripper.c:11709
VALUE rb_str_resize(VALUE, long)
Definition: string.c:1779
#define tHEREDOC_END
Definition: eventids2.c:8
#define STR_NEW(p, n)
Definition: ripper.c:329
YYSTYPE yyvs_alloc
Definition: ripper.c:1017
#define ID_CLASS
static int parser_peek_variable_name(struct parser_params *parser)
Definition: ripper.c:12325
#define tokcopy(n)
Definition: ripper.c:11835
#define STR_FUNC_SYMBOL
Definition: ripper.c:11675
#define NEW_LAMBDA(a)
#define NEW_LASGN(v, val)
node_type
Definition: ripper.y:23
#define mixed_escape(beg, enc1, enc2)
int rb_str_hash_cmp(VALUE, VALUE)
Definition: string.c:2180
#define set_yylval_num(x)
Definition: ripper.c:11203
VALUE * argv
Definition: tcltklib.c:1962
goto yysetstate
Definition: ripper.c:4855
#define NEW_OPT_ARG(i, v)
#define STR_FUNC_QWORDS
Definition: ripper.c:11674
#define dyna_push()
Definition: ripper.c:515
#define command_start
Definition: ripper.c:361
string_type
Definition: ripper.c:11678
int rb_dvar_defined(ID id)
Definition: compile.c:5526
static void dispose_string(VALUE str)
Definition: ripper.c:12120
#define is_notop_id(id)
Definition: ripper.c:105
static NODE * aryset_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14795
int parser_in_single
Definition: ripper.c:272
const int id
Definition: nkf.c:209
#define NEW_SCLASS(r, b)
static ID shadowing_lvar_gen(struct parser_params *, ID)
Definition: ripper.c:14757
#define REALLOC_N(var, type, n)
Definition: ruby.h:1036
#define local_push(top)
Definition: ripper.c:502
int errno
#define TRUE
Definition: nkf.h:186
int rb_symname_p(const char *name)
Definition: ripper.c:16035
q result
Definition: tcltklib.c:7059
#define NODE_NIL
VALUE rb_io_gets(VALUE)
Definition: io.c:2892
#define paren_nest
Definition: ripper.c:344
#define NODE_ATTRASGN
#define token_info_pop(token)
Definition: ripper.c:667
static void dyna_pop_gen(struct parser_params *, const struct vtable *)
Definition: ripper.c:15610
static NODE * new_evstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:14544
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1203
volatile VALUE value
Definition: tcltklib.c:9429
#define NODE_COLON3
#define NODE_DEFINED
#define tokadd_mbchar(c)
Definition: ripper.c:12142
static void reg_fragment_setenc_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:15669
#define rb_enc_isspace(c, enc)
Definition: encoding.h:178
#define rb_node_newnode(type, a1, a2, a3)
Definition: ripper.c:389
#define YYMAXDEPTH
Definition: ripper.c:4465
goto yynewstate
Definition: ripper.c:4997
int rb_obj_respond_to(VALUE, ID, int)
Definition: vm_method.c:1218
union RNode::@15 u2
static void set_file_encoding(struct parser_params *parser, const char *str, const char *send)
Definition: ripper.c:12900
#define NEW_DOT2(b, e)
#define NODE_MASGN
#define RB_GC_GUARD(object)
Definition: generator.h:50
#define const
Definition: strftime.c:101
#define rb_enc_name(enc)
Definition: encoding.h:121
#define NEW_DASGN(v, val)
register char * s
Definition: os2.c:56
#define NEW_VALIAS(n, o)
#define RE_OPTION_ONCE
Definition: ripper.c:530
int rb_enc_symname_p(const char *name, rb_encoding *enc)
Definition: ripper.c:16041
#define NEW_POSTARG(i, v)
#define tokidx
Definition: ripper.c:352
#define NEW_ERRINFO()
#define malloc
Definition: ripper.c:94
void Init_sym(void)
Definition: ripper.c:15978
#define NODE_CONST
static int parser_parse_string(struct parser_params *, NODE *)
Definition: ripper.c:12361
#define nd_term(node)
Definition: ripper.c:545
#define STR_FUNC_EXPAND
Definition: ripper.c:11672
VP_EXPORT void
Definition: bigdecimal.c:4944
#define rb_warningS(fmt, a)
Definition: ripper.c:627
static int dvar_defined_gen(struct parser_params *, ID, int)
Definition: ripper.c:15630
int rb_is_local_id(ID id)
Definition: ripper.c:16421
rb_magic_comment_length_t length
Definition: ripper.c:12762
int parser_in_def
Definition: ripper.c:273
#define is_global_id(id)
Definition: ripper.c:107
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1416
#define NEW_SUPER(a)
static int local_id_gen(struct parser_params *, ID)
Definition: ripper.c:15553
#define YYSIZE_T
Definition: ripper.c:896
#define NEW_COLON2(c, i)
#define ESCAPE_META
Definition: ripper.c:11910
VALUE parser_cur_mid
Definition: ripper.c:275
short int yytype_int16
Definition: ripper.c:883
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Definition: array.c:460
static void Init_id(void)
Definition: ripper.y:17
long parser_lex_gets_ptr
Definition: ripper.c:289
#define no_digits()
goto yyreturn
Definition: ripper.c:11117
unsigned long ID
Definition: ruby.h:89
#define NODE_GVAR
#define NODE_CDECL
NODE * node
Definition: ripper.y:171
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1140
#define NEW_HASH(a)
#define rb_enc_isalnum(c, enc)
Definition: encoding.h:176
static void rb_backref_error_gen(struct parser_params *, NODE *)
Definition: ripper.c:14827
#define rb_enc_isdigit(c, enc)
Definition: encoding.h:179
Definition: ripper.y:93
unsigned char yytype_uint8
Definition: ripper.c:862
static VALUE yycompile0(VALUE arg, int tracing)
Definition: ripper.c:11480
static const yytype_int16 yyrhs[]
Definition: ripper.c:1199
static void arg_ambiguous_gen(struct parser_params *parser)
Definition: ripper.c:12632
#define heredoc_restore(n)
Definition: ripper.c:11198
static void parser_prepare(struct parser_params *parser)
Definition: ripper.c:12943
static NODE * cond_gen(struct parser_params *, NODE *)
Definition: ripper.c:15336
#define lex_lastline
Definition: ripper.c:355
#define NODE_LIT
#define rb_reserved_word(str, len)
Definition: lex.c:37
int type
Definition: tcltklib.c:107
int id[2]
Definition: lex.c:33
#define NEW_UNTIL(c, b, n)
static const char *const yytname[]
Definition: ripper.c:1447
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: ripper.c:1036
#define NEW_MATCH3(r, n2)
int argc
Definition: tcltklib.c:1961
stack_type parser_cond_stack
Definition: ripper.c:267
static void FILE * yyoutput
Definition: ripper.c:4320
#define RBASIC(obj)
Definition: ruby.h:904
int rb_is_junk_id(ID id)
Definition: ripper.c:16427
static void dyna_pop_1(struct parser_params *parser)
Definition: ripper.c:15592
static int parser_read_escape(struct parser_params *parser, int flags, rb_encoding **encp)
Definition: ripper.c:11913
int parser_heredoc_end
Definition: ripper.c:286
#define ruby_sourceline
Definition: ripper.c:367
static int parser_heredoc_identifier(struct parser_params *parser)
Definition: ripper.c:12419
Definition: ripper.y:100
#define rb_enc_ispunct(c, enc)
Definition: encoding.h:175
static void ripper_init_eventids1(VALUE self)
Definition: eventids1.c:129
ID rb_id_attrset(ID id)
Definition: ripper.c:14811
static int value_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:14922
void rb_mark_tbl(st_table *tbl)
Definition: gc.c:1735
mlhs_head tSTAR
Definition: ripper.y:1511
#define lex_pend
Definition: ripper.c:359
static int reg_fragment_check_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:15708
register unsigned int len
Definition: name2ctype.h:22210
static const yytype_int16 yycheck[]
Definition: ripper.c:3008
#define NEW_SELF()
#define YYUSE(e)
Definition: ripper.c:916
#define xfree
Definition: defines.h:69
#define lvtbl
Definition: ripper.c:365
#define lex_strterm
Definition: ripper.c:339
#define rb_enc_asciicompat(enc)
Definition: encoding.h:181
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
Definition: eval.c:737
VALUE flags
Definition: ruby.h:597
#define NEW_RESBODY(a, ex, n)
#define NEW_RETURN(s)
#define NODE_ARGSPUSH
#define NODE_BACK_REF
#define set_yylval_str(x)
Definition: ripper.c:11202
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Definition: re.c:285
#define NODE_MATCH
union YYSTYPE YYSTYPE
struct vtable * vars
Definition: ripper.y:174
#define cond_stack
Definition: ripper.c:341
short int yytype_int8
Definition: ripper.c:871
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2289
static NODE * assignable_gen(struct parser_params *, ID, NODE *)
VALUE flags
Definition: ripper.y:237
expr ripper_intern("and")
yytype_int16 * yytop
Definition: ripper.c:4382
const char * token
Definition: ripper.c:241
ruby_verbose
Definition: tcltklib.c:5807
#define ENCODING_IS_ASCII8BIT(obj)
Definition: encoding.h:52
#define NEW_COLON3(i)
VALUE rb_str_dup(VALUE)
Definition: string.c:905
#define NEW_CASE(h, b)
static const yytype_int16 yypgoto[]
Definition: ripper.c:1897
static int arg_var_gen(struct parser_params *, ID)
Definition: ripper.c:15536
return ptr
Definition: tcltklib.c:780
#define free(x)
Definition: dln.c:50
#define rb_enc_isalpha(c, enc)
Definition: encoding.h:172
VpDivd * c
Definition: bigdecimal.c:1163
goto yyerrlab1
Definition: ripper.c:11047
#define is_local_id(id)
Definition: ripper.c:106
long st_data_t
Definition: syck.h:69
state
Definition: gb18030.c:213
#define NODE_DASGN
int parser_in_defined
Definition: ripper.c:276
VALUE msg
Definition: tcltklib.c:842
static int literal_concat0(struct parser_params *, VALUE, VALUE)
Definition: ripper.c:14457
static ID * local_tbl_gen(struct parser_params *)
Definition: ripper.c:15521
#define NEW_BACK_REF(n)
int parser_class_nest
Definition: ripper.c:269
#define reg_named_capture_assign(regexp, match)
Definition: ripper.c:476
static NODE * new_args_gen(struct parser_params *, NODE *, NODE *, ID, NODE *, ID)
Definition: ripper.c:15429
Definition: ripper.y:121
static int parser_yyerror(struct parser_params *, const char *)
Definition: ripper.c:11375
gz end
Definition: zlib.c:2033
goto yydefault
Definition: ripper.c:4947
#define NEW_IF(c, t, e)
#define HEAPCNT(n, size)
Definition: ripper.c:16656
nd_iter
Definition: parse.y:1361
#define NEW_GASGN(v, val)
yydestruct("Cleanup: discarding lookahead", yytoken,&yylval, parser)
YYSIZE_T yystacksize
Definition: ripper.c:4813
static void warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15205
#define NEW_ARGSPUSH(a, b)
static void yytype_int16 * yybottom
Definition: ripper.c:4381
#define is_asgn_or_id(id)
Definition: ripper.c:114
static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
Definition: ripper.c:12004
static NODE * attrset_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:14819
#define SYMBOL_P(v)
Definition: cparse.c:69
arg
Definition: ripper.y:1287
static struct vtable * dyna_push_gen(struct parser_params *)
Definition: ripper.c:15581
VALUE rb_usascii_str_new2(const char *)
VALUE src
Definition: tcltklib.c:7940
yy_symbol_value_print(yyoutput, yytype, yyvaluep, parser)
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:1853
static VALUE reg_compile_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:15803
#define NEW_XSTR(s)
#define ENCODING_GET(obj)
Definition: encoding.h:47
#define ESCAPE_CONTROL
Definition: ripper.c:11909
Definition: ripper.y:110
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:733
#define NEW_WHILE(c, b, n)
#define NEW_DEFS(r, i, a, d)
#define parser_isascii()
Definition: ripper.c:11298
void rb_gc_mark_parser(void)
Definition: ripper.c:15827
static const yytype_uint8 yytranslate[]
Definition: ripper.c:1091
int nonspc
Definition: ripper.c:244
int size
Definition: encoding.c:51
#define yynerrs
Definition: gram.c:56
#define ADD2HEAP(n, c, p)
Definition: ripper.c:16658
#define tokspace(n)
Definition: ripper.c:11187
#define in_def
Definition: ripper.c:347
#define INT2FIX(i)
Definition: ruby.h:225
#define is_const_id(id)
Definition: ripper.c:110
char yymsgbuf[128]
Definition: ripper.c:4825
static void no_blockarg(struct parser_params *parser, NODE *node)
Definition: ripper.c:15358
static void local_pop_gen(struct parser_params *)
Definition: ripper.c:15490
#define NODE_FLIP3
void rb_parser_free(struct parser_params *parser, void *ptr)
Definition: ripper.c:16702
int parser_tokidx
Definition: ripper.c:278
#define read_escape(flags, e)
Definition: ripper.c:11190
#define NODE_DVAR
static VALUE ULONG2NUM(unsigned long v)
Definition: ruby.h:1015
#define tok_hex(numlen)
Definition: ripper.c:11189
static NODE * literal_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14474
static struct magic_comment magic_comments[]
Definition: ripper.c:12765
#define new_evstr(n)
Definition: ripper.c:426
#define xmalloc
Definition: defines.h:64
#define parser_warn(node, mesg)
Definition: ripper.c:14356
#define rb_compile_error
Definition: ripper.c:649
ID rb_intern_str(VALUE str)
Definition: ripper.c:16284
Definition: ripper.y:91
Definition: ripper.y:126
VALUE coverage
Definition: ripper.c:307
command_call
Definition: ripper.y:1279
int t
Definition: ripper.c:14285
void rb_set_errinfo(VALUE err)
Definition: eval.c:1065
#define tokfix()
Definition: ripper.c:11779
#define internal_id()
Definition: ripper.c:512
NODE * parser_lex_strterm
Definition: ripper.c:265
const char * name
Definition: ripper.c:12760
#define COND_LEXPOP()
Definition: ripper.c:143
#define lex_p
Definition: ripper.c:358
#define NEW_IVAR(v)
top_stmts dispatch0(stmts_new)
#define tSP
Definition: eventids2.c:6
#define NEW_ATTRASGN(r, m, a)
#define NODE_ZARRAY
static int token_info_get_column(struct parser_params *parser, const char *token)
Definition: ripper.c:11302
#define node_assign(node1, node2)
Definition: ripper.c:459
static void void_stmts_gen(struct parser_params *, NODE *)
Definition: ripper.c:15073
const char * yys
Definition: ripper.c:4512
#define void_expr(node)
Definition: ripper.c:404
static int local_var_gen(struct parser_params *, ID)
Definition: ripper.c:15543
char * start
Definition: yaml2byte.c:126
#define void_expr0(node)
Definition: ripper.c:403
#define NEW_BEGIN(b)
#define NEW_FCALL(m, a)
#define NODE_CVAR
#define lex_pbeg
Definition: ripper.c:357
#define regx_options()
Definition: ripper.c:11192
#define NEW_SCOPE(a, b)
#define numberof(array)
Definition: ripper.c:88
static int token_info_has_nonspaces(struct parser_params *parser, const char *token)
Definition: ripper.c:11316
#define NEW_OP_ASGN2(r, i, o, val)
#define YYSTACK_ALLOC_MAXIMUM
Definition: ripper.c:981
#define NODE_BREAK
#define TOK_INTERN(mb)
Definition: ripper.c:334
static const rb_data_type_t parser_data_type
Definition: ripper.c:11587
rb_magic_comment_setter_t func
Definition: ripper.c:12761
int parser_lpar_beg
Definition: ripper.c:271
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:169
st_table * sym_id
Definition: ripper.c:15936
#define NODE_FL_NEWLINE
struct local_vars * prev
Definition: ripper.c:162
static const yytype_uint16 yydefact[]
Definition: ripper.c:1662
#define NEW_VCALL(m)
#define LONG2FIX(i)
Definition: ruby.h:226
#define parser_encoding_name()
Definition: ripper.c:11292
#define tokadd_escape(e)
Definition: ripper.c:11191
struct vtable * vars
Definition: ripper.c:160
#define RTEST(v)
Definition: ruby.h:373
#define T_STRING
Definition: ruby.h:418
static const yytype_int16 yypact[]
Definition: ripper.c:1792
static VALUE lex_io_gets(struct parser_params *parser, VALUE io)
Definition: ripper.c:11638
#define new_yield(node)
Definition: ripper.c:444
#define lvar_defined(id)
Definition: ripper.c:528
klass
Definition: tcltklib.c:3493
#define RREGEXP(obj)
Definition: ruby.h:910
goto yybackup
Definition: ripper.c:4934
#define NODE_DSTR
struct rb_encoding_entry * list
Definition: encoding.c:49
#define lpar_beg
Definition: ripper.c:345
#define YYTRANSLATE(YYX)
Definition: ripper.c:1087
#define NEW_RETRY()
void * rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
Definition: ripper.c:16672
rb_encoding * rb_filesystem_encoding(void)
Definition: encoding.c:1205
#define st_add_direct
Definition: regint.h:151
#define yyerror(msg)
Definition: ripper.c:337
#define is_junk_id(id)
Definition: ripper.c:112
static void new_bv_gen(struct parser_params *, ID)
Definition: ripper.c:14781
#define ruby_coverage
Definition: ripper.c:376
int linenum
Definition: ripper.c:242
#define NEW_CVAR(v)
static NODE * negate_lit(NODE *)
Definition: ripper.c:15400
#define tEMBDOC
Definition: eventids2.c:4
Definition: ripper.y:120
#define NODE_BEGIN
gz io
Definition: zlib.c:2024
static void fixup_nodes(NODE **)
Definition: ripper.c:15211
#define DVARS_INHERIT
Definition: ripper.c:166
#define STR_NEW3(p, n, e, func)
Definition: ripper.c:332
char * parser_tokenbuf
Definition: ripper.c:277
VALUE rb_cArray
Definition: array.c:27
static const char * magic_comment_marker(const char *str, long len)
Definition: ripper.c:12773
#define NEW_OP_ASGN1(p, id, a)
union RNode::@14 u1
keyword_alias tGVAR tGVAR
Definition: ripper.y:968
static int parser_magic_comment(struct parser_params *parser, const char *str, long len)
Definition: ripper.c:12806
Definition: ripper.y:97
#define IS_LABEL_POSSIBLE()
Definition: ripper.c:12971
VALUE rb_ary_new2(long capa)
Definition: array.c:332
const char * parser_lex_pbeg
Definition: ripper.c:283
int rb_is_class_id(ID id)
Definition: ripper.c:16409
#define DVARS_TOPSCOPE
Definition: ripper.c:167
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
Definition: string.c:424
#define YYCASE_(N, S)
#define rb_safe_level()
Definition: tcltklib.c:90
VALUE rb_parser_new(void)
Definition: ripper.c:16587
struct parser_params * parser
Definition: ripper.c:4323
#define NODE_CVASGN
Definition: ripper.c:151
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:1641
#define yychar
Definition: gram.c:54
static void parser_set_encode(struct parser_params *parser, const char *name)
Definition: ripper.c:12681
#define call_uni_op(recv, id)
Definition: ripper.c:434
#define NEW_CDECL(v, val, path)
static int literal_node(NODE *node)
Definition: ripper.c:15258
union RNode::@16 u3
#define set_yylval_node(x)
Definition: ripper.c:11207
static void YYSTYPE * yyvsp
Definition: ripper.c:4412
#define YYSTACK_BYTES(N)
Definition: ripper.c:1025
#define IS_BEG()
Definition: ripper.c:12969
const char * parser_lex_p
Definition: ripper.c:284
#define nd_lit
static int parser_tok_hex(struct parser_params *parser, size_t *numlen)
Definition: ripper.c:11822
#define xrealloc
Definition: defines.h:67
#define RE_OPTION_ENCODING_NONE(o)
Definition: ripper.c:534
lex_state_e
Definition: ripper.c:119
#define dvar_defined_get(id)
Definition: ripper.c:523
#define nd_head
int parser_ruby_sourceline
Definition: ripper.c:296
const char * rb_id2name(ID id)
Definition: ripper.c:16362
#define NODE_CALL
#define ruby_eval_tree_begin
Definition: ripper.c:374
#define rb_errinfo()
Definition: tcltklib.c:85
return rb_funcall(q->proc, ID_call, 0)
#define formal_argument(id)
Definition: ripper.c:495
int cnt
Definition: tcltklib.c:6138
#define dispatch_heredoc_end()
Definition: ripper.c:12525
YYSTYPE * parser_yylval
Definition: ripper.c:262
#define ruby_eval_tree
Definition: ripper.c:373
#define toklast()
Definition: ripper.c:11782
#define lex_gets
Definition: ripper.c:364
#define toklen()
Definition: ripper.c:11781
static const yytype_uint8 yyr2[]
Definition: ripper.c:1597
BDIGIT e
Definition: bigdecimal.c:4946
#define cmdarg_stack
Definition: ripper.c:342
#define in_single
Definition: ripper.c:346
#define YY_STACK_PRINT(Bottom, Top)
Definition: ripper.c:4394
#define NEW_LIT(l)
#define YYFPRINTF
Definition: ripper.c:4287
VALUE opts
Definition: tcltklib.c:6135
int is_ripper
Definition: ripper.c:259
static NODE * cond0(struct parser_params *, NODE *)
Definition: ripper.c:15279
options
Definition: tcltklib.c:4470
rb_encoding * rb_ascii8bit_encoding(void)
Definition: encoding.c:1110
#define NODE_IVAR
#define peek(c)
Definition: ripper.c:11708
int rb_enc_find_index(const char *name)
Definition: encoding.c:596
static NODE * splat_array(NODE *)
Definition: ripper.c:14883
static struct vtable * vtable_alloc(struct vtable *prev)
Definition: ripper.c:185
VALUE eofp
Definition: ripper.c:263
RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e-0x20+31)/32]
Definition: ripper.c:12296
YYSTYPE * yyvs
Definition: ripper.c:4810
goto yyreduce
Definition: ripper.c:5007
#define CONST_ID(var, str)
Definition: ruby.h:1127
NODE * heap
Definition: ripper.c:260
ID rb_intern3(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:16140
#define attrset(node, id)
Definition: ripper.c:454
#define NODE_DOT2
encp
Definition: crypt.c:564
#define COND_P()
Definition: ripper.c:144
#define ID_SCOPE_MASK
#define mixed_error(enc1, enc2)
int nodeline(NODE *node)
Definition: ripper.c:14320
static ID register_symid(ID, const char *, long, rb_encoding *)
Definition: ripper.c:16130
#define NODE_DREGX
#define NODE_IASGN
#define NEW_DEFN(i, a, d, p)
#define NODE_RETURN
#define long
Definition: name2ctype.h:37
ssize_t i
Definition: bigdecimal.c:5519
void * rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
Definition: ripper.c:16682
#define NEW_REDO()
#define shadowing_lvar(name)
Definition: ripper.c:497
VALUE rb_cstr_to_inum(const char *str, int base, int badcheck)
Definition: bignum.c:567
#define NODE_ARRAY
#define NODE_SPLAT
#define get_value(val)
Definition: ripper.c:479
#define rb_enc_mbcput(c, buf, enc)
Definition: encoding.h:158
#define rb_intern(str)
#define reg_fragment_check(str, options)
Definition: ripper.c:474
int rb_parse_in_eval(void)
Definition: compile.c:5570
YYSTYPE const *const yyvaluep
Definition: ripper.c:4322
BDIGIT v
Definition: bigdecimal.c:5520
VALUE rb_str_buf_new(long)
Definition: string.c:736
VALUE rb_usascii_str_new(const char *, long)
Definition: string.c:416
#define compile_for_eval
Definition: ripper.c:348
#define tCOMMENT
Definition: eventids2.c:2
#define NEW_ZSUPER()
#define set_yylval_id(x)
Definition: ripper.c:11204
ID rb_intern2(const char *name, long len)
Definition: ripper.c:16271
rb_gc_mark(ptr->aliases)
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1197
NODE * rb_compile_file(const char *f, VALUE file, int start)
Definition: ripper.c:11644
static int is_special_global_name(const char *m, const char *e, rb_encoding *enc)
Definition: ripper.c:16009
#define is_class_id(id)
Definition: ripper.c:111
#define LVAR_USED
Definition: ripper.c:14754
#define nd_line(n)
VALUE rb_parser_get_yydebug(VALUE self)
Definition: ripper.c:16631
VALUE(* parser_lex_gets)(struct parser_params *, VALUE)
Definition: ripper.c:290
const char * name
Definition: nkf.c:208
#define RTYPEDDATA_TYPE(v)
Definition: ruby.h:798
#define FIX2LONG(x)
Definition: ruby.h:336
#define Qundef
Definition: ruby.h:368
#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:11631
#define NODE_SCOPE
#define yypact_value_is_default(yystate)
Definition: ripper.c:3002
static struct kwtable * reserved_word(const char *, unsigned int)
#define ISXDIGIT(c)
Definition: ruby.h:1459
#define rb_warn0(fmt)
Definition: ripper.c:623
#define ENCODING_SET(obj, i)
Definition: encoding.h:37
int rb_local_defined(ID id)
Definition: compile.c:5551
st_index_t num_entries
Definition: st.h:93
NODE * parser_eval_tree_begin
Definition: ripper.c:304
Real * a
Definition: bigdecimal.c:1140
static int match(VALUE str, VALUE pat, VALUE hash, int(*cb)(VALUE, VALUE))
Definition: date_parse.c:245
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1210
#define new_bv(id)
Definition: ripper.c:499
static void warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15199
#define NODE_IASGN2
#define NODE_SELF
#define RSTRING_NOEMBED
Definition: ruby.h:666
goto yyerrlab
Definition: ripper.c:5006
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:80
#define block_append(h, t)
Definition: ripper.c:413
#define ID_CONST
VALUE rb_eArgError
Definition: error.c:468
static void vtable_free(struct vtable *tbl)
Definition: ripper.c:197
#define rb_enc_prev_char(s, p, e, enc)
Definition: encoding.h:161
#define NEW_ARRAY(a)
#define T_REGEXP
Definition: ruby.h:419
unsigned long ruby_scan_oct(const char *, size_t, size_t *)
Definition: util.c:28
#define NODE_VALUES
#define heredoc_end
Definition: ripper.c:360
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1032
#define ID_ATTRSET
struct vtable * args
Definition: ripper.c:159
#define tokaddmbc(c, enc)
Definition: ripper.c:11195
VALUE ruby_suppress_tracing(VALUE(*func)(VALUE, int), VALUE arg, int always)
Definition: thread.c:4603
Definition: ripper.y:134
#define tEMBDOC_END
Definition: eventids2.c:5
int yytype
Definition: ripper.c:4321
#define DBL2NUM(dbl)
Definition: ruby.h:647
#define nd_value
#define ISSPACE(c)
Definition: ruby.h:1453
#define StringValue(v)
Definition: ruby.h:466
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:2000
union RString::@31 as
#define pushback(c)
Definition: ripper.c:11185
#define STR_NEW2(p)
Definition: ripper.c:331
const char * yysrc
Definition: ripper.c:4508
#define YYINITDEPTH
Definition: ripper.c:4454
rb_encoding * rb_enc_from_index(int index)
Definition: encoding.c:512
#define aryset(node1, node2)
Definition: ripper.c:452
static NODE * reg_named_capture_assign_gen(struct parser_params *parser, VALUE regexp, NODE *match)
Definition: ripper.c:15771
#define InitVM(ext)
Definition: console.c:89
VALUE rb_str_new(const char *, long)
Definition: string.c:410
#define NEW_BLOCK_PASS(b)
#define xcalloc
Definition: defines.h:66
static int parser_tokadd_mbchar(struct parser_params *parser, int c)
Definition: ripper.c:12129