Ruby  1.9.3p484(2013-11-22revision43786)
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;
163 };
164 
165 #define DVARS_INHERIT ((void*)1)
166 #define DVARS_TOPSCOPE NULL
167 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
168 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
169 
170 static int
171 vtable_size(const struct vtable *tbl)
172 {
173  if (POINTER_P(tbl)) {
174  return tbl->pos;
175  }
176  else {
177  return 0;
178  }
179 }
180 
181 #define VTBL_DEBUG 0
182 
183 static struct vtable *
185 {
186  struct vtable *tbl = ALLOC(struct vtable);
187  tbl->pos = 0;
188  tbl->capa = 8;
189  tbl->tbl = ALLOC_N(ID, tbl->capa);
190  tbl->prev = prev;
191  if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
192  return tbl;
193 }
194 
195 static void
197 {
198  if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
199  if (POINTER_P(tbl)) {
200  if (tbl->tbl) {
201  xfree(tbl->tbl);
202  }
203  xfree(tbl);
204  }
205 }
206 
207 static void
208 vtable_add(struct vtable *tbl, ID id)
209 {
210  if (!POINTER_P(tbl)) {
211  rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
212  }
213  if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
214 
215  if (tbl->pos == tbl->capa) {
216  tbl->capa = tbl->capa * 2;
217  REALLOC_N(tbl->tbl, ID, tbl->capa);
218  }
219  tbl->tbl[tbl->pos++] = id;
220 }
221 
222 static int
223 vtable_included(const struct vtable * tbl, ID id)
224 {
225  int i;
226 
227  if (POINTER_P(tbl)) {
228  for (i = 0; i < tbl->pos; i++) {
229  if (tbl->tbl[i] == id) {
230  return i+1;
231  }
232  }
233  }
234  return 0;
235 }
236 
237 
238 #ifndef RIPPER
239 typedef struct token_info {
240  const char *token;
241  int linenum;
242  int column;
243  int nonspc;
244  struct token_info *next;
245 } token_info;
246 #endif
247 
248 /*
249  Structure of Lexer Buffer:
250 
251  lex_pbeg tokp lex_p lex_pend
252  | | | |
253  |-----------+--------------+------------|
254  |<------------>|
255  token
256 */
260 
263 
282  const char *parser_lex_pbeg;
283  const char *parser_lex_p;
284  const char *parser_lex_pend;
294  char *parser_ruby_sourcefile; /* current source file */
295  int parser_ruby_sourceline; /* current line no. */
298 
300 
301 #ifndef RIPPER
302  /* Ruby core only */
307  int nerr;
308 
311 #else
312  /* Ripper only */
313  VALUE parser_ruby_sourcefile_string;
314  const char *tokp;
315  VALUE delayed;
316  int delayed_line;
317  int delayed_col;
318 
319  VALUE value;
320  VALUE result;
321  VALUE parsing_thread;
322  int toplevel_p;
323 #endif
324 };
325 
326 #define UTF8_ENC() (parser->utf8 ? parser->utf8 : \
327  (parser->utf8 = rb_utf8_encoding()))
328 #define STR_NEW(p,n) rb_enc_str_new((p),(n),parser->enc)
329 #define STR_NEW0() rb_enc_str_new(0,0,parser->enc)
330 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),parser->enc)
331 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),parser->enc)
332 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
333 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), parser->enc)
334 
335 static int parser_yyerror(struct parser_params*, const char*);
336 #define yyerror(msg) parser_yyerror(parser, (msg))
337 
338 #define lex_strterm (parser->parser_lex_strterm)
339 #define lex_state (parser->parser_lex_state)
340 #define cond_stack (parser->parser_cond_stack)
341 #define cmdarg_stack (parser->parser_cmdarg_stack)
342 #define class_nest (parser->parser_class_nest)
343 #define paren_nest (parser->parser_paren_nest)
344 #define lpar_beg (parser->parser_lpar_beg)
345 #define in_single (parser->parser_in_single)
346 #define in_def (parser->parser_in_def)
347 #define compile_for_eval (parser->parser_compile_for_eval)
348 #define cur_mid (parser->parser_cur_mid)
349 #define in_defined (parser->parser_in_defined)
350 #define tokenbuf (parser->parser_tokenbuf)
351 #define tokidx (parser->parser_tokidx)
352 #define toksiz (parser->parser_toksiz)
353 #define lex_input (parser->parser_lex_input)
354 #define lex_lastline (parser->parser_lex_lastline)
355 #define lex_nextline (parser->parser_lex_nextline)
356 #define lex_pbeg (parser->parser_lex_pbeg)
357 #define lex_p (parser->parser_lex_p)
358 #define lex_pend (parser->parser_lex_pend)
359 #define heredoc_end (parser->parser_heredoc_end)
360 #define command_start (parser->parser_command_start)
361 #define deferred_nodes (parser->parser_deferred_nodes)
362 #define lex_gets_ptr (parser->parser_lex_gets_ptr)
363 #define lex_gets (parser->parser_lex_gets)
364 #define lvtbl (parser->parser_lvtbl)
365 #define ruby__end__seen (parser->parser_ruby__end__seen)
366 #define ruby_sourceline (parser->parser_ruby_sourceline)
367 #define ruby_sourcefile (parser->parser_ruby_sourcefile)
368 #define current_enc (parser->enc)
369 #define yydebug (parser->parser_yydebug)
370 #ifdef RIPPER
371 #else
372 #define ruby_eval_tree (parser->parser_eval_tree)
373 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin)
374 #define ruby_debug_lines (parser->debug_lines)
375 #define ruby_coverage (parser->coverage)
376 #endif
377 
378 #if YYPURE
379 static int yylex(void*, void*);
380 #else
381 static int yylex(void*);
382 #endif
383 
384 #ifndef RIPPER
385 #define yyparse ruby_yyparse
386 
387 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
388 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
389 
390 static NODE *cond_gen(struct parser_params*,NODE*);
391 #define cond(node) cond_gen(parser, (node))
392 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
393 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
394 
395 static NODE *newline_node(NODE*);
396 static void fixpos(NODE*,NODE*);
397 
398 static int value_expr_gen(struct parser_params*,NODE*);
399 static void void_expr_gen(struct parser_params*,NODE*);
400 static NODE *remove_begin(NODE*);
401 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
402 #define void_expr0(node) void_expr_gen(parser, (node))
403 #define void_expr(node) void_expr0((node) = remove_begin(node))
404 static void void_stmts_gen(struct parser_params*,NODE*);
405 #define void_stmts(node) void_stmts_gen(parser, (node))
406 static void reduce_nodes_gen(struct parser_params*,NODE**);
407 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
408 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
409 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
410 
411 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
412 #define block_append(h,t) block_append_gen(parser,(h),(t))
413 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
414 #define list_append(l,i) list_append_gen(parser,(l),(i))
415 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
416 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
417 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
418 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
419 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
420 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
421 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
422 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
423 static int literal_concat0(struct parser_params *, VALUE, VALUE);
424 static NODE *new_evstr_gen(struct parser_params*,NODE*);
425 #define new_evstr(n) new_evstr_gen(parser,(n))
426 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
427 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
428 static NODE *splat_array(NODE*);
429 
430 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
431 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
432 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
433 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
434 
435 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,ID);
436 #define new_args(f,o,r,p,b) new_args_gen(parser, (f),(o),(r),(p),(b))
437 
438 static NODE *negate_lit(NODE*);
439 static NODE *ret_args_gen(struct parser_params*,NODE*);
440 #define ret_args(node) ret_args_gen(parser, (node))
441 static NODE *arg_blk_pass(NODE*,NODE*);
442 static NODE *new_yield_gen(struct parser_params*,NODE*);
443 #define new_yield(node) new_yield_gen(parser, (node))
444 
445 static NODE *gettable_gen(struct parser_params*,ID);
446 #define gettable(id) gettable_gen(parser,(id))
447 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
448 #define assignable(id,node) assignable_gen(parser, (id), (node))
449 
450 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
451 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
452 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
453 #define attrset(node,id) attrset_gen(parser, (node), (id))
454 
455 static void rb_backref_error_gen(struct parser_params*,NODE*);
456 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
457 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
458 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
459 
460 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
461 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
462 
463 static ID *local_tbl_gen(struct parser_params*);
464 #define local_tbl() local_tbl_gen(parser)
465 
466 static void fixup_nodes(NODE **);
467 
468 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
469 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
470 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
471 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
472 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
473 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
474 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
475 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
476 
477 #define get_id(id) (id)
478 #define get_value(val) (val)
479 #else
480 #define remove_begin(node) (node)
481 #define rb_dvar_defined(id) 0
482 #define rb_local_defined(id) 0
483 static ID ripper_get_id(VALUE);
484 #define get_id(id) ripper_get_id(id)
485 static VALUE ripper_get_value(VALUE);
486 #define get_value(val) ripper_get_value(val)
487 static VALUE assignable_gen(struct parser_params*,VALUE);
488 #define assignable(lhs,node) assignable_gen(parser, (lhs))
489 static int id_is_var_gen(struct parser_params *parser, ID id);
490 #define id_is_var(id) id_is_var_gen(parser, (id))
491 #endif /* !RIPPER */
492 
493 static ID formal_argument_gen(struct parser_params*, ID);
494 #define formal_argument(id) formal_argument_gen(parser, (id))
495 static ID shadowing_lvar_gen(struct parser_params*,ID);
496 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
497 static void new_bv_gen(struct parser_params*,ID);
498 #define new_bv(id) new_bv_gen(parser, (id))
499 
500 static void local_push_gen(struct parser_params*,int);
501 #define local_push(top) local_push_gen(parser,(top))
502 static void local_pop_gen(struct parser_params*);
503 #define local_pop() local_pop_gen(parser)
504 static int local_var_gen(struct parser_params*, ID);
505 #define local_var(id) local_var_gen(parser, (id));
506 static int arg_var_gen(struct parser_params*, ID);
507 #define arg_var(id) arg_var_gen(parser, (id))
508 static int local_id_gen(struct parser_params*, ID);
509 #define local_id(id) local_id_gen(parser, (id))
510 static ID internal_id_gen(struct parser_params*);
511 #define internal_id() internal_id_gen(parser)
512 
513 static const struct vtable *dyna_push_gen(struct parser_params *);
514 #define dyna_push() dyna_push_gen(parser)
515 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
516 #define dyna_pop(node) dyna_pop_gen(parser, (node))
517 static int dyna_in_block_gen(struct parser_params*);
518 #define dyna_in_block() dyna_in_block_gen(parser)
519 #define dyna_var(id) local_var(id)
520 static int dvar_defined_gen(struct parser_params*,ID,int);
521 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
522 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
523 static int dvar_curr_gen(struct parser_params*,ID);
524 #define dvar_curr(id) dvar_curr_gen(parser, (id))
525 
526 static int lvar_defined_gen(struct parser_params*, ID);
527 #define lvar_defined(id) lvar_defined_gen(parser, (id))
528 
529 #define RE_OPTION_ONCE (1<<16)
530 #define RE_OPTION_ENCODING_SHIFT 8
531 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
532 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
533 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
534 #define RE_OPTION_MASK 0xff
535 #define RE_OPTION_ARG_ENCODING_NONE 32
536 
537 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
538 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
539 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
540 #define nd_func u1.id
541 #if SIZEOF_SHORT == 2
542 #define nd_term(node) ((signed short)(node)->u2.id)
543 #else
544 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
545 #endif
546 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
547 #define nd_nest u3.cnt
548 
549 /****** Ripper *******/
550 
551 #ifdef RIPPER
552 #define RIPPER_VERSION "0.1.0"
553 
554 #include "eventids1.c"
555 #include "eventids2.c"
556 static ID ripper_id_gets;
557 
558 static VALUE ripper_dispatch0(struct parser_params*,ID);
559 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
560 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
561 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
562 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
563 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
564 
565 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
566 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
567 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
568 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
569 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
570 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
571 
572 #define yyparse ripper_yyparse
573 
574 #define ripper_intern(s) ID2SYM(rb_intern(s))
575 static VALUE ripper_id2sym(ID);
576 #ifdef __GNUC__
577 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
578  ID2SYM(id) : ripper_id2sym(id))
579 #endif
580 
581 #define arg_new() dispatch0(args_new)
582 #define arg_add(l,a) dispatch2(args_add, (l), (a))
583 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
584 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
585 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
586 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
587 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
588 
589 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
590 #define mrhs_new() dispatch0(mrhs_new)
591 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
592 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
593 
594 #define mlhs_new() dispatch0(mlhs_new)
595 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
596 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
597 
598 #define params_new(pars, opts, rest, pars2, blk) \
599  dispatch5(params, (pars), (opts), (rest), (pars2), (blk))
600 
601 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
602 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
603 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
604 
605 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
606 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
607 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
608 
609 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
610 
611 #define FIXME 0
612 
613 #endif /* RIPPER */
614 
615 #ifndef RIPPER
616 # define ifndef_ripper(x) (x)
617 #else
618 # define ifndef_ripper(x)
619 #endif
620 
621 #ifndef RIPPER
622 # define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
623 # define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
624 # define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
625 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
626 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
627 #else
628 # define rb_warn0(fmt) ripper_warn0(parser, (fmt))
629 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))
630 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))
631 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
632 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
633 static void ripper_warn0(struct parser_params*, const char*);
634 static void ripper_warnI(struct parser_params*, const char*, int);
635 #if 0
636 static void ripper_warnS(struct parser_params*, const char*, const char*);
637 #endif
638 static void ripper_warning0(struct parser_params*, const char*);
639 static void ripper_warningS(struct parser_params*, const char*, const char*);
640 #endif
641 
642 #ifdef RIPPER
643 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
644 # define rb_compile_error ripper_compile_error
645 # define compile_error ripper_compile_error
646 # define PARSER_ARG parser,
647 #else
648 # define rb_compile_error rb_compile_error_with_enc
649 # define compile_error parser->nerr++,rb_compile_error_with_enc
650 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
651 #endif
652 
653 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
654  for instance). This is too low for Ruby to parse some files, such as
655  date/format.rb, therefore bump the value up to at least Bison's default. */
656 #ifdef OLD_YACC
657 #ifndef YYMAXDEPTH
658 #define YYMAXDEPTH 10000
659 #endif
660 #endif
661 
662 #ifndef RIPPER
663 static void token_info_push(struct parser_params*, const char *token);
664 static void token_info_pop(struct parser_params*, const char *token);
665 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
666 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
667 #else
668 #define token_info_push(token) /* nothing */
669 #define token_info_pop(token) /* nothing */
670 #endif
671 
672 
673 /* Line 268 of yacc.c */
674 #line 675 "parse.c"
675 
676 /* Enabling traces. */
677 #ifndef YYDEBUG
678 # define YYDEBUG 1
679 #endif
680 
681 /* Enabling verbose error messages. */
682 #ifdef YYERROR_VERBOSE
683 # undef YYERROR_VERBOSE
684 # define YYERROR_VERBOSE 1
685 #else
686 # define YYERROR_VERBOSE 0
687 #endif
688 
689 /* Enabling the token table. */
690 #ifndef YYTOKEN_TABLE
691 # define YYTOKEN_TABLE 0
692 #endif
693 
694 
695 /* Tokens. */
696 #ifndef YYTOKENTYPE
697 # define YYTOKENTYPE
698  /* Put the tokens into the symbol table, so that GDB and other debuggers
699  know about them. */
700  enum yytokentype {
701  keyword_class = 258,
702  keyword_module = 259,
703  keyword_def = 260,
704  keyword_undef = 261,
705  keyword_begin = 262,
706  keyword_rescue = 263,
707  keyword_ensure = 264,
708  keyword_end = 265,
709  keyword_if = 266,
710  keyword_unless = 267,
711  keyword_then = 268,
712  keyword_elsif = 269,
713  keyword_else = 270,
714  keyword_case = 271,
715  keyword_when = 272,
716  keyword_while = 273,
717  keyword_until = 274,
718  keyword_for = 275,
719  keyword_break = 276,
720  keyword_next = 277,
721  keyword_redo = 278,
722  keyword_retry = 279,
723  keyword_in = 280,
724  keyword_do = 281,
725  keyword_do_cond = 282,
726  keyword_do_block = 283,
727  keyword_do_LAMBDA = 284,
728  keyword_return = 285,
729  keyword_yield = 286,
730  keyword_super = 287,
731  keyword_self = 288,
732  keyword_nil = 289,
733  keyword_true = 290,
734  keyword_false = 291,
735  keyword_and = 292,
736  keyword_or = 293,
737  keyword_not = 294,
738  modifier_if = 295,
739  modifier_unless = 296,
740  modifier_while = 297,
741  modifier_until = 298,
742  modifier_rescue = 299,
743  keyword_alias = 300,
744  keyword_defined = 301,
745  keyword_BEGIN = 302,
746  keyword_END = 303,
747  keyword__LINE__ = 304,
748  keyword__FILE__ = 305,
749  keyword__ENCODING__ = 306,
750  tIDENTIFIER = 307,
751  tFID = 308,
752  tGVAR = 309,
753  tIVAR = 310,
754  tCONSTANT = 311,
755  tCVAR = 312,
756  tLABEL = 313,
757  tINTEGER = 314,
758  tFLOAT = 315,
759  tSTRING_CONTENT = 316,
760  tCHAR = 317,
761  tNTH_REF = 318,
762  tBACK_REF = 319,
763  tREGEXP_END = 320,
764  tUPLUS = 321,
765  tUMINUS = 322,
766  tPOW = 323,
767  tCMP = 324,
768  tEQ = 325,
769  tEQQ = 326,
770  tNEQ = 327,
771  tGEQ = 328,
772  tLEQ = 329,
773  tANDOP = 330,
774  tOROP = 331,
775  tMATCH = 332,
776  tNMATCH = 333,
777  tDOT2 = 334,
778  tDOT3 = 335,
779  tAREF = 336,
780  tASET = 337,
781  tLSHFT = 338,
782  tRSHFT = 339,
783  tCOLON2 = 340,
784  tCOLON3 = 341,
785  tOP_ASGN = 342,
786  tASSOC = 343,
787  tLPAREN = 344,
788  tLPAREN_ARG = 345,
789  tRPAREN = 346,
790  tLBRACK = 347,
791  tLBRACE = 348,
792  tLBRACE_ARG = 349,
793  tSTAR = 350,
794  tAMPER = 351,
795  tLAMBDA = 352,
796  tSYMBEG = 353,
797  tSTRING_BEG = 354,
798  tXSTRING_BEG = 355,
799  tREGEXP_BEG = 356,
800  tWORDS_BEG = 357,
801  tQWORDS_BEG = 358,
802  tSTRING_DBEG = 359,
803  tSTRING_DVAR = 360,
804  tSTRING_END = 361,
805  tLAMBEG = 362,
806  tLOWEST = 363,
807  tUMINUS_NUM = 364,
808  idNULL = 365,
809  idRespond_to = 366,
810  idIFUNC = 367,
811  idCFUNC = 368,
814  id_core_undef_method = 371,
815  id_core_define_method = 372,
817  id_core_set_postexe = 374,
818  tLAST_TOKEN = 375
819  };
820 #endif
821 
822 
823 
824 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
825 typedef union YYSTYPE
826 {
827 
828 /* Line 293 of yacc.c */
829 #line 619 "ripper.y"
830 
831  VALUE val;
832  NODE *node;
833  ID id;
834  int num;
835  const struct vtable *vars;
836 
837 
838 
839 /* Line 293 of yacc.c */
840 #line 841 "parse.c"
841 } YYSTYPE;
842 # define YYSTYPE_IS_TRIVIAL 1
843 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
844 # define YYSTYPE_IS_DECLARED 1
845 #endif
846 
847 
848 /* Copy the second part of user declarations. */
849 
850 
851 /* Line 343 of yacc.c */
852 #line 853 "parse.c"
853 
854 #ifdef short
855 # undef short
856 #endif
857 
858 #ifdef YYTYPE_UINT8
859 typedef YYTYPE_UINT8 yytype_uint8;
860 #else
861 typedef unsigned char yytype_uint8;
862 #endif
863 
864 #ifdef YYTYPE_INT8
865 typedef YYTYPE_INT8 yytype_int8;
866 #elif (defined __STDC__ || defined __C99__FUNC__ \
867  || defined __cplusplus || defined _MSC_VER)
868 typedef signed char yytype_int8;
869 #else
870 typedef short int yytype_int8;
871 #endif
872 
873 #ifdef YYTYPE_UINT16
874 typedef YYTYPE_UINT16 yytype_uint16;
875 #else
876 typedef unsigned short int yytype_uint16;
877 #endif
878 
879 #ifdef YYTYPE_INT16
880 typedef YYTYPE_INT16 yytype_int16;
881 #else
882 typedef short int yytype_int16;
883 #endif
884 
885 #ifndef YYSIZE_T
886 # ifdef __SIZE_TYPE__
887 # define YYSIZE_T __SIZE_TYPE__
888 # elif defined size_t
889 # define YYSIZE_T size_t
890 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
891  || defined __cplusplus || defined _MSC_VER)
892 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
893 # define YYSIZE_T size_t
894 # else
895 # define YYSIZE_T unsigned int
896 # endif
897 #endif
898 
899 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
900 
901 #ifndef YY_
902 # if defined YYENABLE_NLS && YYENABLE_NLS
903 # if ENABLE_NLS
904 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
905 # define YY_(msgid) dgettext ("bison-runtime", msgid)
906 # endif
907 # endif
908 # ifndef YY_
909 # define YY_(msgid) msgid
910 # endif
911 #endif
912 
913 /* Suppress unused-variable warnings by "using" E. */
914 #if ! defined lint || defined __GNUC__
915 # define YYUSE(e) ((void) (e))
916 #else
917 # define YYUSE(e) /* empty */
918 #endif
919 
920 /* Identity function, used to suppress warnings about constant conditions. */
921 #ifndef lint
922 # define YYID(n) (n)
923 #else
924 #if (defined __STDC__ || defined __C99__FUNC__ \
925  || defined __cplusplus || defined _MSC_VER)
926 static int
927 YYID (int yyi)
928 #else
929 static int
930 YYID (yyi)
931  int yyi;
932 #endif
933 {
934  return yyi;
935 }
936 #endif
937 
938 #if ! defined yyoverflow || YYERROR_VERBOSE
939 
940 /* The parser invokes alloca or malloc; define the necessary symbols. */
941 
942 # ifdef YYSTACK_USE_ALLOCA
943 # if YYSTACK_USE_ALLOCA
944 # ifdef __GNUC__
945 # define YYSTACK_ALLOC __builtin_alloca
946 # elif defined __BUILTIN_VA_ARG_INCR
947 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
948 # elif defined _AIX
949 # define YYSTACK_ALLOC __alloca
950 # elif defined _MSC_VER
951 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
952 # define alloca _alloca
953 # else
954 # define YYSTACK_ALLOC alloca
955 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
956  || defined __cplusplus || defined _MSC_VER)
957 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
958 # ifndef EXIT_SUCCESS
959 # define EXIT_SUCCESS 0
960 # endif
961 # endif
962 # endif
963 # endif
964 # endif
965 
966 # ifdef YYSTACK_ALLOC
967  /* Pacify GCC's `empty if-body' warning. */
968 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
969 # ifndef YYSTACK_ALLOC_MAXIMUM
970  /* The OS might guarantee only one guard page at the bottom of the stack,
971  and a page size can be as small as 4096 bytes. So we cannot safely
972  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
973  to allow for a few compiler-allocated temporary stack slots. */
974 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
975 # endif
976 # else
977 # define YYSTACK_ALLOC YYMALLOC
978 # define YYSTACK_FREE YYFREE
979 # ifndef YYSTACK_ALLOC_MAXIMUM
980 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
981 # endif
982 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
983  && ! ((defined YYMALLOC || defined malloc) \
984  && (defined YYFREE || defined free)))
985 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
986 # ifndef EXIT_SUCCESS
987 # define EXIT_SUCCESS 0
988 # endif
989 # endif
990 # ifndef YYMALLOC
991 # define YYMALLOC malloc
992 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
993  || defined __cplusplus || defined _MSC_VER)
994 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
995 # endif
996 # endif
997 # ifndef YYFREE
998 # define YYFREE free
999 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1000  || defined __cplusplus || defined _MSC_VER)
1001 void free (void *); /* INFRINGES ON USER NAME SPACE */
1002 # endif
1003 # endif
1004 # endif
1005 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1006 
1007 
1008 #if (! defined yyoverflow \
1009  && (! defined __cplusplus \
1010  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1011 
1012 /* A type that is properly aligned for any stack member. */
1013 union yyalloc
1014 {
1017 };
1018 
1019 /* The size of the maximum gap between one aligned stack and the next. */
1020 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1021 
1022 /* The size of an array large to enough to hold all stacks, each with
1023  N elements. */
1024 # define YYSTACK_BYTES(N) \
1025  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1026  + YYSTACK_GAP_MAXIMUM)
1027 
1028 # define YYCOPY_NEEDED 1
1029 
1030 /* Relocate STACK from its old location to the new one. The
1031  local variables YYSIZE and YYSTACKSIZE give the old and new number of
1032  elements in the stack, and YYPTR gives the new location of the
1033  stack. Advance YYPTR to a properly aligned location for the next
1034  stack. */
1035 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1036  do \
1037  { \
1038  YYSIZE_T yynewbytes; \
1039  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1040  Stack = &yyptr->Stack_alloc; \
1041  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1042  yyptr += yynewbytes / sizeof (*yyptr); \
1043  } \
1044  while (YYID (0))
1045 
1046 #endif
1047 
1048 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1049 /* Copy COUNT objects from FROM to TO. The source and destination do
1050  not overlap. */
1051 # ifndef YYCOPY
1052 # if defined __GNUC__ && 1 < __GNUC__
1053 # define YYCOPY(To, From, Count) \
1054  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1055 # else
1056 # define YYCOPY(To, From, Count) \
1057  do \
1058  { \
1059  YYSIZE_T yyi; \
1060  for (yyi = 0; yyi < (Count); yyi++) \
1061  (To)[yyi] = (From)[yyi]; \
1062  } \
1063  while (YYID (0))
1064 # endif
1065 # endif
1066 #endif /* !YYCOPY_NEEDED */
1067 
1068 /* YYFINAL -- State number of the termination state. */
1069 #define YYFINAL 3
1070 /* YYLAST -- Last index in YYTABLE. */
1071 #define YYLAST 10748
1072 
1073 /* YYNTOKENS -- Number of terminals. */
1074 #define YYNTOKENS 148
1075 /* YYNNTS -- Number of nonterminals. */
1076 #define YYNNTS 174
1077 /* YYNRULES -- Number of rules. */
1078 #define YYNRULES 573
1079 /* YYNRULES -- Number of states. */
1080 #define YYNSTATES 991
1081 
1082 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1083 #define YYUNDEFTOK 2
1084 #define YYMAXUTOK 375
1085 
1086 #define YYTRANSLATE(YYX) \
1087  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1088 
1089 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1090 static const yytype_uint8 yytranslate[] =
1091 {
1092  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1093  147, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1094  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1095  2, 2, 146, 123, 2, 2, 2, 121, 116, 2,
1096  142, 143, 119, 117, 140, 118, 139, 120, 2, 2,
1097  2, 2, 2, 2, 2, 2, 2, 2, 111, 145,
1098  113, 109, 112, 110, 2, 2, 2, 2, 2, 2,
1099  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1100  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1101  2, 138, 2, 144, 115, 2, 141, 2, 2, 2,
1102  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1103  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1104  2, 2, 2, 136, 114, 137, 124, 2, 2, 2,
1105  2, 2, 2, 2, 2, 2, 2, 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, 1, 2, 3, 4,
1118  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1119  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1120  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1121  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1122  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1123  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1124  65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1125  75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
1126  85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
1127  95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
1128  105, 106, 107, 108, 122, 125, 126, 127, 128, 129,
1129  130, 131, 132, 133, 134, 135
1130 };
1131 
1132 #if YYDEBUG
1133 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1134  YYRHS. */
1135 static const yytype_uint16 yyprhs[] =
1136 {
1137  0, 0, 3, 4, 7, 10, 12, 14, 18, 21,
1138  23, 24, 30, 35, 38, 40, 42, 46, 49, 50,
1139  55, 59, 63, 67, 70, 74, 78, 82, 86, 90,
1140  95, 97, 101, 105, 112, 118, 124, 130, 136, 140,
1141  144, 148, 152, 154, 158, 162, 164, 168, 172, 176,
1142  179, 181, 183, 185, 187, 189, 194, 199, 200, 206,
1143  209, 213, 218, 224, 229, 235, 238, 241, 244, 247,
1144  250, 252, 256, 258, 262, 264, 267, 271, 277, 280,
1145  285, 288, 293, 295, 299, 301, 305, 308, 312, 314,
1146  318, 320, 322, 327, 331, 335, 339, 343, 346, 348,
1147  350, 352, 357, 361, 365, 369, 373, 376, 378, 380,
1148  382, 385, 387, 391, 393, 395, 397, 399, 401, 403,
1149  405, 407, 409, 411, 412, 417, 419, 421, 423, 425,
1150  427, 429, 431, 433, 435, 437, 439, 441, 443, 445,
1151  447, 449, 451, 453, 455, 457, 459, 461, 463, 465,
1152  467, 469, 471, 473, 475, 477, 479, 481, 483, 485,
1153  487, 489, 491, 493, 495, 497, 499, 501, 503, 505,
1154  507, 509, 511, 513, 515, 517, 519, 521, 523, 525,
1155  527, 529, 531, 533, 535, 537, 539, 541, 543, 545,
1156  547, 549, 551, 553, 555, 557, 561, 567, 571, 577,
1157  584, 590, 596, 602, 608, 613, 617, 621, 625, 629,
1158  633, 637, 641, 645, 649, 654, 659, 662, 665, 669,
1159  673, 677, 681, 685, 689, 693, 697, 701, 705, 709,
1160  713, 717, 720, 723, 727, 731, 735, 739, 740, 745,
1161  752, 754, 756, 758, 761, 766, 769, 773, 775, 777,
1162  779, 781, 784, 789, 792, 794, 797, 800, 805, 807,
1163  808, 811, 814, 817, 819, 821, 824, 828, 833, 837,
1164  842, 845, 847, 849, 851, 853, 855, 857, 859, 861,
1165  863, 864, 869, 870, 875, 879, 883, 886, 890, 894,
1166  896, 901, 905, 907, 908, 915, 920, 924, 927, 929,
1167  932, 935, 942, 949, 950, 951, 959, 960, 961, 969,
1168  975, 980, 981, 982, 992, 993, 1000, 1001, 1002, 1011,
1169  1012, 1018, 1019, 1026, 1027, 1028, 1038, 1040, 1042, 1044,
1170  1046, 1048, 1050, 1052, 1054, 1056, 1058, 1060, 1062, 1064,
1171  1066, 1068, 1070, 1072, 1074, 1077, 1079, 1081, 1083, 1089,
1172  1091, 1094, 1096, 1098, 1100, 1104, 1106, 1110, 1112, 1117,
1173  1124, 1128, 1134, 1137, 1142, 1144, 1148, 1155, 1164, 1169,
1174  1176, 1181, 1184, 1191, 1194, 1199, 1206, 1209, 1214, 1217,
1175  1222, 1224, 1226, 1228, 1232, 1234, 1239, 1241, 1244, 1246,
1176  1250, 1252, 1254, 1255, 1256, 1261, 1266, 1268, 1272, 1276,
1177  1277, 1283, 1286, 1291, 1296, 1299, 1304, 1309, 1313, 1317,
1178  1321, 1324, 1326, 1331, 1332, 1338, 1339, 1345, 1351, 1353,
1179  1355, 1362, 1364, 1366, 1368, 1370, 1373, 1375, 1378, 1380,
1180  1382, 1384, 1386, 1388, 1390, 1392, 1395, 1399, 1403, 1407,
1181  1411, 1415, 1416, 1420, 1422, 1425, 1429, 1433, 1434, 1438,
1182  1439, 1442, 1443, 1446, 1447, 1450, 1452, 1453, 1457, 1458,
1183  1459, 1465, 1467, 1469, 1471, 1473, 1476, 1478, 1480, 1482,
1184  1484, 1488, 1490, 1492, 1495, 1498, 1500, 1502, 1504, 1506,
1185  1508, 1510, 1512, 1514, 1516, 1518, 1520, 1522, 1524, 1526,
1186  1528, 1530, 1532, 1534, 1536, 1537, 1542, 1545, 1549, 1552,
1187  1559, 1568, 1573, 1580, 1585, 1592, 1595, 1600, 1607, 1610,
1188  1615, 1618, 1623, 1625, 1626, 1628, 1630, 1632, 1634, 1636,
1189  1638, 1640, 1644, 1646, 1650, 1654, 1658, 1660, 1664, 1666,
1190  1670, 1672, 1674, 1677, 1679, 1681, 1683, 1686, 1689, 1691,
1191  1693, 1694, 1699, 1701, 1704, 1706, 1710, 1714, 1717, 1719,
1192  1721, 1723, 1725, 1727, 1729, 1731, 1733, 1735, 1737, 1739,
1193  1741, 1742, 1744, 1745, 1747, 1750, 1753, 1754, 1756, 1758,
1194  1760, 1762, 1764, 1767
1195 };
1196 
1197 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1198 static const yytype_int16 yyrhs[] =
1199 {
1200  149, 0, -1, -1, 150, 151, -1, 152, 314, -1,
1201  321, -1, 153, -1, 152, 320, 153, -1, 1, 153,
1202  -1, 158, -1, -1, 47, 154, 136, 151, 137, -1,
1203  156, 256, 231, 259, -1, 157, 314, -1, 321, -1,
1204  158, -1, 157, 320, 158, -1, 1, 158, -1, -1,
1205  45, 180, 159, 180, -1, 45, 54, 54, -1, 45,
1206  54, 64, -1, 45, 54, 63, -1, 6, 181, -1,
1207  158, 40, 162, -1, 158, 41, 162, -1, 158, 42,
1208  162, -1, 158, 43, 162, -1, 158, 44, 158, -1,
1209  48, 136, 156, 137, -1, 160, -1, 168, 109, 163,
1210  -1, 286, 87, 163, -1, 216, 138, 191, 317, 87,
1211  163, -1, 216, 139, 52, 87, 163, -1, 216, 139,
1212  56, 87, 163, -1, 216, 85, 56, 87, 163, -1,
1213  216, 85, 52, 87, 163, -1, 287, 87, 163, -1,
1214  175, 109, 198, -1, 168, 109, 187, -1, 168, 109,
1215  198, -1, 161, -1, 175, 109, 163, -1, 175, 109,
1216  160, -1, 163, -1, 161, 37, 161, -1, 161, 38,
1217  161, -1, 39, 315, 161, -1, 123, 163, -1, 185,
1218  -1, 161, -1, 167, -1, 164, -1, 249, -1, 249,
1219  139, 311, 193, -1, 249, 85, 311, 193, -1, -1,
1220  94, 166, 237, 156, 137, -1, 310, 193, -1, 310,
1221  193, 165, -1, 216, 139, 311, 193, -1, 216, 139,
1222  311, 193, 165, -1, 216, 85, 311, 193, -1, 216,
1223  85, 311, 193, 165, -1, 32, 193, -1, 31, 193,
1224  -1, 30, 192, -1, 21, 192, -1, 22, 192, -1,
1225  170, -1, 89, 169, 316, -1, 170, -1, 89, 169,
1226  316, -1, 172, -1, 172, 171, -1, 172, 95, 174,
1227  -1, 172, 95, 174, 140, 173, -1, 172, 95, -1,
1228  172, 95, 140, 173, -1, 95, 174, -1, 95, 174,
1229  140, 173, -1, 95, -1, 95, 140, 173, -1, 174,
1230  -1, 89, 169, 316, -1, 171, 140, -1, 172, 171,
1231  140, -1, 171, -1, 173, 140, 171, -1, 283, -1,
1232  284, -1, 216, 138, 191, 317, -1, 216, 139, 52,
1233  -1, 216, 85, 52, -1, 216, 139, 56, -1, 216,
1234  85, 56, -1, 86, 56, -1, 287, -1, 283, -1,
1235  284, -1, 216, 138, 191, 317, -1, 216, 139, 52,
1236  -1, 216, 85, 52, -1, 216, 139, 56, -1, 216,
1237  85, 56, -1, 86, 56, -1, 287, -1, 52, -1,
1238  56, -1, 86, 176, -1, 176, -1, 216, 85, 176,
1239  -1, 52, -1, 56, -1, 53, -1, 183, -1, 184,
1240  -1, 178, -1, 279, -1, 179, -1, 281, -1, 180,
1241  -1, -1, 181, 140, 182, 180, -1, 114, -1, 115,
1242  -1, 116, -1, 69, -1, 70, -1, 71, -1, 77,
1243  -1, 78, -1, 112, -1, 73, -1, 113, -1, 74,
1244  -1, 72, -1, 83, -1, 84, -1, 117, -1, 118,
1245  -1, 119, -1, 95, -1, 120, -1, 121, -1, 68,
1246  -1, 123, -1, 124, -1, 66, -1, 67, -1, 81,
1247  -1, 82, -1, 141, -1, 49, -1, 50, -1, 51,
1248  -1, 47, -1, 48, -1, 45, -1, 37, -1, 7,
1249  -1, 21, -1, 16, -1, 3, -1, 5, -1, 46,
1250  -1, 26, -1, 15, -1, 14, -1, 10, -1, 9,
1251  -1, 36, -1, 20, -1, 25, -1, 4, -1, 22,
1252  -1, 34, -1, 39, -1, 38, -1, 23, -1, 8,
1253  -1, 24, -1, 30, -1, 33, -1, 32, -1, 13,
1254  -1, 35, -1, 6, -1, 17, -1, 31, -1, 11,
1255  -1, 12, -1, 18, -1, 19, -1, 175, 109, 185,
1256  -1, 175, 109, 185, 44, 185, -1, 286, 87, 185,
1257  -1, 286, 87, 185, 44, 185, -1, 216, 138, 191,
1258  317, 87, 185, -1, 216, 139, 52, 87, 185, -1,
1259  216, 139, 56, 87, 185, -1, 216, 85, 52, 87,
1260  185, -1, 216, 85, 56, 87, 185, -1, 86, 56,
1261  87, 185, -1, 287, 87, 185, -1, 185, 79, 185,
1262  -1, 185, 80, 185, -1, 185, 117, 185, -1, 185,
1263  118, 185, -1, 185, 119, 185, -1, 185, 120, 185,
1264  -1, 185, 121, 185, -1, 185, 68, 185, -1, 122,
1265  59, 68, 185, -1, 122, 60, 68, 185, -1, 66,
1266  185, -1, 67, 185, -1, 185, 114, 185, -1, 185,
1267  115, 185, -1, 185, 116, 185, -1, 185, 69, 185,
1268  -1, 185, 112, 185, -1, 185, 73, 185, -1, 185,
1269  113, 185, -1, 185, 74, 185, -1, 185, 70, 185,
1270  -1, 185, 71, 185, -1, 185, 72, 185, -1, 185,
1271  77, 185, -1, 185, 78, 185, -1, 123, 185, -1,
1272  124, 185, -1, 185, 83, 185, -1, 185, 84, 185,
1273  -1, 185, 75, 185, -1, 185, 76, 185, -1, -1,
1274  46, 315, 186, 185, -1, 185, 110, 185, 315, 111,
1275  185, -1, 199, -1, 185, -1, 321, -1, 197, 318,
1276  -1, 197, 140, 308, 318, -1, 308, 318, -1, 142,
1277  191, 316, -1, 321, -1, 189, -1, 321, -1, 192,
1278  -1, 197, 140, -1, 197, 140, 308, 140, -1, 308,
1279  140, -1, 167, -1, 197, 196, -1, 308, 196, -1,
1280  197, 140, 308, 196, -1, 195, -1, -1, 194, 192,
1281  -1, 96, 187, -1, 140, 195, -1, 321, -1, 187,
1282  -1, 95, 187, -1, 197, 140, 187, -1, 197, 140,
1283  95, 187, -1, 197, 140, 187, -1, 197, 140, 95,
1284  187, -1, 95, 187, -1, 260, -1, 261, -1, 264,
1285  -1, 265, -1, 266, -1, 269, -1, 285, -1, 287,
1286  -1, 53, -1, -1, 217, 200, 155, 227, -1, -1,
1287  90, 161, 201, 316, -1, 89, 156, 143, -1, 216,
1288  85, 56, -1, 86, 56, -1, 92, 188, 144, -1,
1289  93, 307, 137, -1, 30, -1, 31, 142, 192, 316,
1290  -1, 31, 142, 316, -1, 31, -1, -1, 46, 315,
1291  142, 202, 161, 316, -1, 39, 142, 161, 316, -1,
1292  39, 142, 316, -1, 310, 251, -1, 250, -1, 250,
1293  251, -1, 97, 242, -1, 218, 162, 228, 156, 230,
1294  227, -1, 219, 162, 228, 156, 231, 227, -1, -1,
1295  -1, 220, 203, 162, 229, 204, 156, 227, -1, -1,
1296  -1, 221, 205, 162, 229, 206, 156, 227, -1, 222,
1297  162, 314, 254, 227, -1, 222, 314, 254, 227, -1,
1298  -1, -1, 223, 232, 25, 207, 162, 229, 208, 156,
1299  227, -1, -1, 224, 177, 288, 209, 155, 227, -1,
1300  -1, -1, 224, 83, 161, 210, 319, 211, 155, 227,
1301  -1, -1, 225, 177, 212, 155, 227, -1, -1, 226,
1302  178, 213, 290, 155, 227, -1, -1, -1, 226, 305,
1303  313, 214, 178, 215, 290, 155, 227, -1, 21, -1,
1304  22, -1, 23, -1, 24, -1, 199, -1, 7, -1,
1305  11, -1, 12, -1, 18, -1, 19, -1, 16, -1,
1306  20, -1, 3, -1, 4, -1, 5, -1, 10, -1,
1307  319, -1, 13, -1, 319, 13, -1, 319, -1, 27,
1308  -1, 231, -1, 14, 162, 228, 156, 230, -1, 321,
1309  -1, 15, 156, -1, 175, -1, 168, -1, 293, -1,
1310  89, 235, 316, -1, 233, -1, 234, 140, 233, -1,
1311  234, -1, 234, 140, 95, 293, -1, 234, 140, 95,
1312  293, 140, 234, -1, 234, 140, 95, -1, 234, 140,
1313  95, 140, 234, -1, 95, 293, -1, 95, 293, 140,
1314  234, -1, 95, -1, 95, 140, 234, -1, 295, 140,
1315  298, 140, 301, 304, -1, 295, 140, 298, 140, 301,
1316  140, 295, 304, -1, 295, 140, 298, 304, -1, 295,
1317  140, 298, 140, 295, 304, -1, 295, 140, 301, 304,
1318  -1, 295, 140, -1, 295, 140, 301, 140, 295, 304,
1319  -1, 295, 304, -1, 298, 140, 301, 304, -1, 298,
1320  140, 301, 140, 295, 304, -1, 298, 304, -1, 298,
1321  140, 295, 304, -1, 301, 304, -1, 301, 140, 295,
1322  304, -1, 303, -1, 321, -1, 238, -1, 114, 239,
1323  114, -1, 76, -1, 114, 236, 239, 114, -1, 321,
1324  -1, 145, 240, -1, 241, -1, 240, 140, 241, -1,
1325  52, -1, 292, -1, -1, -1, 243, 244, 245, 246,
1326  -1, 142, 291, 239, 316, -1, 291, -1, 107, 156,
1327  137, -1, 29, 156, 10, -1, -1, 28, 248, 237,
1328  156, 10, -1, 167, 247, -1, 249, 139, 311, 190,
1329  -1, 249, 85, 311, 190, -1, 310, 189, -1, 216,
1330  139, 311, 190, -1, 216, 85, 311, 189, -1, 216,
1331  85, 312, -1, 216, 139, 189, -1, 216, 85, 189,
1332  -1, 32, 189, -1, 32, -1, 216, 138, 191, 317,
1333  -1, -1, 136, 252, 237, 156, 137, -1, -1, 26,
1334  253, 237, 156, 10, -1, 17, 197, 228, 156, 255,
1335  -1, 231, -1, 254, -1, 8, 257, 258, 228, 156,
1336  256, -1, 321, -1, 187, -1, 198, -1, 321, -1,
1337  88, 175, -1, 321, -1, 9, 156, -1, 321, -1,
1338  282, -1, 279, -1, 281, -1, 262, -1, 62, -1,
1339  263, -1, 262, 263, -1, 99, 271, 106, -1, 100,
1340  272, 106, -1, 101, 273, 65, -1, 102, 146, 106,
1341  -1, 102, 267, 106, -1, -1, 267, 268, 146, -1,
1342  274, -1, 268, 274, -1, 103, 146, 106, -1, 103,
1343  270, 106, -1, -1, 270, 61, 146, -1, -1, 271,
1344  274, -1, -1, 272, 274, -1, -1, 273, 274, -1,
1345  61, -1, -1, 105, 275, 278, -1, -1, -1, 104,
1346  276, 277, 156, 137, -1, 54, -1, 55, -1, 57,
1347  -1, 287, -1, 98, 280, -1, 178, -1, 55, -1,
1348  54, -1, 57, -1, 98, 272, 106, -1, 59, -1,
1349  60, -1, 122, 59, -1, 122, 60, -1, 52, -1,
1350  55, -1, 54, -1, 56, -1, 57, -1, 34, -1,
1351  33, -1, 35, -1, 36, -1, 50, -1, 49, -1,
1352  51, -1, 283, -1, 284, -1, 283, -1, 284, -1,
1353  63, -1, 64, -1, 319, -1, -1, 113, 289, 162,
1354  319, -1, 1, 319, -1, 142, 291, 316, -1, 291,
1355  319, -1, 295, 140, 299, 140, 301, 304, -1, 295,
1356  140, 299, 140, 301, 140, 295, 304, -1, 295, 140,
1357  299, 304, -1, 295, 140, 299, 140, 295, 304, -1,
1358  295, 140, 301, 304, -1, 295, 140, 301, 140, 295,
1359  304, -1, 295, 304, -1, 299, 140, 301, 304, -1,
1360  299, 140, 301, 140, 295, 304, -1, 299, 304, -1,
1361  299, 140, 295, 304, -1, 301, 304, -1, 301, 140,
1362  295, 304, -1, 303, -1, -1, 56, -1, 55, -1,
1363  54, -1, 57, -1, 292, -1, 52, -1, 293, -1,
1364  89, 235, 316, -1, 294, -1, 295, 140, 294, -1,
1365  52, 109, 187, -1, 52, 109, 216, -1, 297, -1,
1366  298, 140, 297, -1, 296, -1, 299, 140, 296, -1,
1367  119, -1, 95, -1, 300, 52, -1, 300, -1, 116,
1368  -1, 96, -1, 302, 52, -1, 140, 303, -1, 321,
1369  -1, 285, -1, -1, 142, 306, 161, 316, -1, 321,
1370  -1, 308, 318, -1, 309, -1, 308, 140, 309, -1,
1371  187, 88, 187, -1, 58, 187, -1, 52, -1, 56,
1372  -1, 53, -1, 52, -1, 56, -1, 53, -1, 183,
1373  -1, 52, -1, 53, -1, 183, -1, 139, -1, 85,
1374  -1, -1, 320, -1, -1, 147, -1, 315, 143, -1,
1375  315, 144, -1, -1, 147, -1, 140, -1, 145, -1,
1376  147, -1, 319, -1, 320, 145, -1, -1
1377 };
1378 
1379 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1380 static const yytype_uint16 yyrline[] =
1381 {
1382  0, 785, 785, 785, 816, 827, 836, 844, 852, 858,
1383  860, 859, 883, 916, 927, 936, 944, 952, 958, 958,
1384  966, 974, 985, 995, 1003, 1012, 1021, 1034, 1047, 1056,
1385  1068, 1069, 1079, 1108, 1129, 1146, 1163, 1174, 1191, 1201,
1386  1210, 1219, 1228, 1231, 1240, 1252, 1253, 1261, 1269, 1277,
1387  1285, 1288, 1300, 1301, 1304, 1305, 1314, 1326, 1325, 1347,
1388  1356, 1368, 1377, 1389, 1398, 1410, 1419, 1428, 1436, 1444,
1389  1454, 1455, 1465, 1466, 1476, 1484, 1492, 1500, 1509, 1517,
1390  1526, 1534, 1543, 1551, 1562, 1563, 1573, 1581, 1591, 1599,
1391  1609, 1613, 1617, 1625, 1633, 1641, 1649, 1661, 1671, 1683,
1392  1692, 1701, 1709, 1717, 1725, 1733, 1746, 1759, 1770, 1778,
1393  1781, 1789, 1797, 1807, 1808, 1809, 1810, 1815, 1826, 1827,
1394  1830, 1838, 1841, 1849, 1849, 1859, 1860, 1861, 1862, 1863,
1395  1864, 1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, 1873,
1396  1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, 1883,
1397  1884, 1885, 1886, 1887, 1890, 1890, 1890, 1891, 1891, 1892,
1398  1892, 1892, 1893, 1893, 1893, 1893, 1894, 1894, 1894, 1894,
1399  1895, 1895, 1895, 1896, 1896, 1896, 1896, 1897, 1897, 1897,
1400  1897, 1898, 1898, 1898, 1898, 1899, 1899, 1899, 1899, 1900,
1401  1900, 1900, 1900, 1901, 1901, 1904, 1913, 1923, 1952, 1983,
1402  2009, 2026, 2043, 2060, 2071, 2082, 2093, 2107, 2121, 2129,
1403  2137, 2145, 2153, 2161, 2169, 2178, 2187, 2195, 2203, 2211,
1404  2219, 2227, 2235, 2243, 2251, 2259, 2267, 2275, 2283, 2291,
1405  2302, 2310, 2318, 2326, 2334, 2342, 2350, 2358, 2358, 2368,
1406  2378, 2384, 2396, 2397, 2401, 2409, 2419, 2429, 2430, 2433,
1407  2434, 2435, 2439, 2447, 2457, 2466, 2474, 2484, 2493, 2502,
1408  2502, 2514, 2524, 2528, 2534, 2542, 2550, 2564, 2580, 2594,
1409  2609, 2619, 2620, 2621, 2622, 2623, 2624, 2625, 2626, 2627,
1410  2636, 2635, 2660, 2660, 2669, 2677, 2685, 2693, 2706, 2714,
1411  2722, 2730, 2738, 2746, 2746, 2756, 2764, 2772, 2783, 2784,
1412  2795, 2799, 2811, 2823, 2823, 2823, 2834, 2834, 2834, 2845,
1413  2856, 2865, 2867, 2864, 2931, 2930, 2952, 2957, 2951, 2976,
1414  2975, 2997, 2996, 3019, 3020, 3019, 3040, 3048, 3056, 3064,
1415  3074, 3086, 3092, 3098, 3104, 3110, 3116, 3122, 3128, 3134,
1416  3140, 3150, 3156, 3161, 3162, 3169, 3174, 3177, 3178, 3191,
1417  3192, 3202, 3203, 3206, 3214, 3224, 3232, 3242, 3250, 3259,
1418  3268, 3276, 3284, 3293, 3305, 3313, 3323, 3331, 3339, 3347,
1419  3355, 3363, 3372, 3380, 3388, 3396, 3404, 3412, 3420, 3428,
1420  3436, 3446, 3447, 3453, 3462, 3471, 3482, 3483, 3493, 3500,
1421  3509, 3517, 3523, 3526, 3523, 3544, 3552, 3562, 3566, 3573,
1422  3572, 3593, 3609, 3618, 3629, 3638, 3648, 3658, 3666, 3677,
1423  3688, 3696, 3704, 3719, 3718, 3738, 3737, 3758, 3770, 3771,
1424  3774, 3793, 3796, 3804, 3812, 3815, 3819, 3822, 3830, 3833,
1425  3834, 3842, 3845, 3862, 3863, 3864, 3874, 3884, 3911, 3976,
1426  3985, 3996, 4003, 4013, 4021, 4031, 4040, 4051, 4058, 4069,
1427  4076, 4087, 4094, 4105, 4112, 4141, 4143, 4142, 4159, 4165,
1428  4158, 4184, 4192, 4200, 4208, 4211, 4222, 4223, 4224, 4225,
1429  4228, 4258, 4259, 4260, 4268, 4278, 4279, 4280, 4281, 4282,
1430  4285, 4286, 4287, 4288, 4289, 4290, 4291, 4294, 4307, 4317,
1431  4325, 4335, 4336, 4339, 4348, 4347, 4355, 4367, 4377, 4385,
1432  4393, 4401, 4409, 4417, 4425, 4433, 4441, 4449, 4457, 4465,
1433  4473, 4481, 4489, 4498, 4507, 4516, 4525, 4534, 4545, 4546,
1434  4553, 4562, 4581, 4588, 4601, 4613, 4625, 4633, 4649, 4657,
1435  4673, 4674, 4677, 4690, 4701, 4702, 4705, 4722, 4726, 4736,
1436  4746, 4746, 4775, 4776, 4786, 4793, 4803, 4811, 4821, 4822,
1437  4823, 4826, 4827, 4828, 4829, 4832, 4833, 4834, 4837, 4842,
1438  4849, 4850, 4853, 4854, 4857, 4860, 4863, 4864, 4865, 4868,
1439  4869, 4872, 4873, 4877
1440 };
1441 #endif
1442 
1443 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1444 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1445  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1446 static const char *const yytname[] =
1447 {
1448  "$end", "error", "$undefined", "keyword_class", "keyword_module",
1449  "keyword_def", "keyword_undef", "keyword_begin", "keyword_rescue",
1450  "keyword_ensure", "keyword_end", "keyword_if", "keyword_unless",
1451  "keyword_then", "keyword_elsif", "keyword_else", "keyword_case",
1452  "keyword_when", "keyword_while", "keyword_until", "keyword_for",
1453  "keyword_break", "keyword_next", "keyword_redo", "keyword_retry",
1454  "keyword_in", "keyword_do", "keyword_do_cond", "keyword_do_block",
1455  "keyword_do_LAMBDA", "keyword_return", "keyword_yield", "keyword_super",
1456  "keyword_self", "keyword_nil", "keyword_true", "keyword_false",
1457  "keyword_and", "keyword_or", "keyword_not", "modifier_if",
1458  "modifier_unless", "modifier_while", "modifier_until", "modifier_rescue",
1459  "keyword_alias", "keyword_defined", "keyword_BEGIN", "keyword_END",
1460  "keyword__LINE__", "keyword__FILE__", "keyword__ENCODING__",
1461  "tIDENTIFIER", "tFID", "tGVAR", "tIVAR", "tCONSTANT", "tCVAR", "tLABEL",
1462  "tINTEGER", "tFLOAT", "tSTRING_CONTENT", "tCHAR", "tNTH_REF",
1463  "tBACK_REF", "tREGEXP_END", "tUPLUS", "tUMINUS", "tPOW", "tCMP", "tEQ",
1464  "tEQQ", "tNEQ", "tGEQ", "tLEQ", "tANDOP", "tOROP", "tMATCH", "tNMATCH",
1465  "tDOT2", "tDOT3", "tAREF", "tASET", "tLSHFT", "tRSHFT", "tCOLON2",
1466  "tCOLON3", "tOP_ASGN", "tASSOC", "tLPAREN", "tLPAREN_ARG", "tRPAREN",
1467  "tLBRACK", "tLBRACE", "tLBRACE_ARG", "tSTAR", "tAMPER", "tLAMBDA",
1468  "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG", "tWORDS_BEG",
1469  "tQWORDS_BEG", "tSTRING_DBEG", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
1470  "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
1471  "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "idNULL",
1472  "idRespond_to", "idIFUNC", "idCFUNC", "id_core_set_method_alias",
1473  "id_core_set_variable_alias", "id_core_undef_method",
1474  "id_core_define_method", "id_core_define_singleton_method",
1475  "id_core_set_postexe", "tLAST_TOKEN", "'{'", "'}'", "'['", "'.'", "','",
1476  "'`'", "'('", "')'", "']'", "';'", "' '", "'\\n'", "$accept", "program",
1477  "$@1", "top_compstmt", "top_stmts", "top_stmt", "$@2", "bodystmt",
1478  "compstmt", "stmts", "stmt", "$@3", "command_asgn", "expr", "expr_value",
1479  "command_call", "block_command", "cmd_brace_block", "@4", "command",
1480  "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head",
1481  "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
1482  "fitem", "undef_list", "$@5", "op", "reswords", "arg", "$@6",
1483  "arg_value", "aref_args", "paren_args", "opt_paren_args",
1484  "opt_call_args", "call_args", "command_args", "@7", "block_arg",
1485  "opt_block_arg", "args", "mrhs", "primary", "@8", "$@9", "$@10", "$@11",
1486  "$@12", "$@13", "$@14", "$@15", "$@16", "@17", "@18", "@19", "@20",
1487  "@21", "$@22", "$@23", "primary_value", "k_begin", "k_if", "k_unless",
1488  "k_while", "k_until", "k_case", "k_for", "k_class", "k_module", "k_def",
1489  "k_end", "then", "do", "if_tail", "opt_else", "for_var", "f_marg",
1490  "f_marg_list", "f_margs", "block_param", "opt_block_param",
1491  "block_param_def", "opt_bv_decl", "bv_decls", "bvar", "lambda", "@24",
1492  "@25", "f_larglist", "lambda_body", "do_block", "@26", "block_call",
1493  "method_call", "brace_block", "@27", "@28", "case_body", "cases",
1494  "opt_rescue", "exc_list", "exc_var", "opt_ensure", "literal", "strings",
1495  "string", "string1", "xstring", "regexp", "words", "word_list", "word",
1496  "qwords", "qword_list", "string_contents", "xstring_contents",
1497  "regexp_contents", "string_content", "@29", "@30", "@31", "string_dvar",
1498  "symbol", "sym", "dsym", "numeric", "user_variable", "keyword_variable",
1499  "var_ref", "var_lhs", "backref", "superclass", "$@32", "f_arglist",
1500  "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_opt",
1501  "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
1502  "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
1503  "singleton", "$@33", "assoc_list", "assocs", "assoc", "operation",
1504  "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
1505  "rparen", "rbracket", "trailer", "term", "terms", "none", 0
1506 };
1507 #endif
1508 
1509 # ifdef YYPRINT
1510 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1511  token YYLEX-NUM. */
1512 static const yytype_uint16 yytoknum[] =
1513 {
1514  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1515  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1516  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1517  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1518  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1519  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1520  315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
1521  325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
1522  335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
1523  345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1524  355, 356, 357, 358, 359, 360, 361, 362, 363, 61,
1525  63, 58, 62, 60, 124, 94, 38, 43, 45, 42,
1526  47, 37, 364, 33, 126, 365, 366, 367, 368, 369,
1527  370, 371, 372, 373, 374, 375, 123, 125, 91, 46,
1528  44, 96, 40, 41, 93, 59, 32, 10
1529 };
1530 # endif
1531 
1532 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1533 static const yytype_uint16 yyr1[] =
1534 {
1535  0, 148, 150, 149, 151, 152, 152, 152, 152, 153,
1536  154, 153, 155, 156, 157, 157, 157, 157, 159, 158,
1537  158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
1538  158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
1539  158, 158, 158, 160, 160, 161, 161, 161, 161, 161,
1540  161, 162, 163, 163, 164, 164, 164, 166, 165, 167,
1541  167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
1542  168, 168, 169, 169, 170, 170, 170, 170, 170, 170,
1543  170, 170, 170, 170, 171, 171, 172, 172, 173, 173,
1544  174, 174, 174, 174, 174, 174, 174, 174, 174, 175,
1545  175, 175, 175, 175, 175, 175, 175, 175, 176, 176,
1546  177, 177, 177, 178, 178, 178, 178, 178, 179, 179,
1547  180, 180, 181, 182, 181, 183, 183, 183, 183, 183,
1548  183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
1549  183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
1550  183, 183, 183, 183, 184, 184, 184, 184, 184, 184,
1551  184, 184, 184, 184, 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, 185, 185, 185, 185, 185,
1555  185, 185, 185, 185, 185, 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, 186, 185, 185,
1559  185, 187, 188, 188, 188, 188, 189, 190, 190, 191,
1560  191, 191, 191, 191, 192, 192, 192, 192, 192, 194,
1561  193, 195, 196, 196, 197, 197, 197, 197, 198, 198,
1562  198, 199, 199, 199, 199, 199, 199, 199, 199, 199,
1563  200, 199, 201, 199, 199, 199, 199, 199, 199, 199,
1564  199, 199, 199, 202, 199, 199, 199, 199, 199, 199,
1565  199, 199, 199, 203, 204, 199, 205, 206, 199, 199,
1566  199, 207, 208, 199, 209, 199, 210, 211, 199, 212,
1567  199, 213, 199, 214, 215, 199, 199, 199, 199, 199,
1568  216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1569  226, 227, 228, 228, 228, 229, 229, 230, 230, 231,
1570  231, 232, 232, 233, 233, 234, 234, 235, 235, 235,
1571  235, 235, 235, 235, 235, 235, 236, 236, 236, 236,
1572  236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
1573  236, 237, 237, 238, 238, 238, 239, 239, 240, 240,
1574  241, 241, 243, 244, 242, 245, 245, 246, 246, 248,
1575  247, 249, 249, 249, 250, 250, 250, 250, 250, 250,
1576  250, 250, 250, 252, 251, 253, 251, 254, 255, 255,
1577  256, 256, 257, 257, 257, 258, 258, 259, 259, 260,
1578  260, 260, 261, 262, 262, 262, 263, 264, 265, 266,
1579  266, 267, 267, 268, 268, 269, 269, 270, 270, 271,
1580  271, 272, 272, 273, 273, 274, 275, 274, 276, 277,
1581  274, 278, 278, 278, 278, 279, 280, 280, 280, 280,
1582  281, 282, 282, 282, 282, 283, 283, 283, 283, 283,
1583  284, 284, 284, 284, 284, 284, 284, 285, 285, 286,
1584  286, 287, 287, 288, 289, 288, 288, 290, 290, 291,
1585  291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
1586  291, 291, 291, 291, 292, 292, 292, 292, 293, 293,
1587  294, 294, 295, 295, 296, 297, 298, 298, 299, 299,
1588  300, 300, 301, 301, 302, 302, 303, 304, 304, 305,
1589  306, 305, 307, 307, 308, 308, 309, 309, 310, 310,
1590  310, 311, 311, 311, 311, 312, 312, 312, 313, 313,
1591  314, 314, 315, 315, 316, 317, 318, 318, 318, 319,
1592  319, 320, 320, 321
1593 };
1594 
1595 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1596 static const yytype_uint8 yyr2[] =
1597 {
1598  0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
1599  0, 5, 4, 2, 1, 1, 3, 2, 0, 4,
1600  3, 3, 3, 2, 3, 3, 3, 3, 3, 4,
1601  1, 3, 3, 6, 5, 5, 5, 5, 3, 3,
1602  3, 3, 1, 3, 3, 1, 3, 3, 3, 2,
1603  1, 1, 1, 1, 1, 4, 4, 0, 5, 2,
1604  3, 4, 5, 4, 5, 2, 2, 2, 2, 2,
1605  1, 3, 1, 3, 1, 2, 3, 5, 2, 4,
1606  2, 4, 1, 3, 1, 3, 2, 3, 1, 3,
1607  1, 1, 4, 3, 3, 3, 3, 2, 1, 1,
1608  1, 4, 3, 3, 3, 3, 2, 1, 1, 1,
1609  2, 1, 3, 1, 1, 1, 1, 1, 1, 1,
1610  1, 1, 1, 0, 4, 1, 1, 1, 1, 1,
1611  1, 1, 1, 1, 1, 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, 3, 5, 3, 5, 6,
1618  5, 5, 5, 5, 4, 3, 3, 3, 3, 3,
1619  3, 3, 3, 3, 4, 4, 2, 2, 3, 3,
1620  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1621  3, 2, 2, 3, 3, 3, 3, 0, 4, 6,
1622  1, 1, 1, 2, 4, 2, 3, 1, 1, 1,
1623  1, 2, 4, 2, 1, 2, 2, 4, 1, 0,
1624  2, 2, 2, 1, 1, 2, 3, 4, 3, 4,
1625  2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1626  0, 4, 0, 4, 3, 3, 2, 3, 3, 1,
1627  4, 3, 1, 0, 6, 4, 3, 2, 1, 2,
1628  2, 6, 6, 0, 0, 7, 0, 0, 7, 5,
1629  4, 0, 0, 9, 0, 6, 0, 0, 8, 0,
1630  5, 0, 6, 0, 0, 9, 1, 1, 1, 1,
1631  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1632  1, 1, 1, 1, 2, 1, 1, 1, 5, 1,
1633  2, 1, 1, 1, 3, 1, 3, 1, 4, 6,
1634  3, 5, 2, 4, 1, 3, 6, 8, 4, 6,
1635  4, 2, 6, 2, 4, 6, 2, 4, 2, 4,
1636  1, 1, 1, 3, 1, 4, 1, 2, 1, 3,
1637  1, 1, 0, 0, 4, 4, 1, 3, 3, 0,
1638  5, 2, 4, 4, 2, 4, 4, 3, 3, 3,
1639  2, 1, 4, 0, 5, 0, 5, 5, 1, 1,
1640  6, 1, 1, 1, 1, 2, 1, 2, 1, 1,
1641  1, 1, 1, 1, 1, 2, 3, 3, 3, 3,
1642  3, 0, 3, 1, 2, 3, 3, 0, 3, 0,
1643  2, 0, 2, 0, 2, 1, 0, 3, 0, 0,
1644  5, 1, 1, 1, 1, 2, 1, 1, 1, 1,
1645  3, 1, 1, 2, 2, 1, 1, 1, 1, 1,
1646  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1647  1, 1, 1, 1, 0, 4, 2, 3, 2, 6,
1648  8, 4, 6, 4, 6, 2, 4, 6, 2, 4,
1649  2, 4, 1, 0, 1, 1, 1, 1, 1, 1,
1650  1, 3, 1, 3, 3, 3, 1, 3, 1, 3,
1651  1, 1, 2, 1, 1, 1, 2, 2, 1, 1,
1652  0, 4, 1, 2, 1, 3, 3, 2, 1, 1,
1653  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1654  0, 1, 0, 1, 2, 2, 0, 1, 1, 1,
1655  1, 1, 2, 0
1656 };
1657 
1658 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1659  Performed when YYTABLE doesn't specify something else to do. Zero
1660  means the default is an error. */
1661 static const yytype_uint16 yydefact[] =
1662 {
1663  2, 0, 0, 1, 0, 338, 339, 340, 0, 331,
1664  332, 333, 336, 334, 335, 337, 326, 327, 328, 329,
1665  289, 259, 259, 481, 480, 482, 483, 562, 0, 562,
1666  10, 0, 485, 484, 486, 475, 550, 477, 476, 478,
1667  479, 471, 472, 433, 491, 492, 0, 0, 0, 0,
1668  0, 573, 573, 82, 392, 451, 449, 451, 453, 441,
1669  447, 0, 0, 0, 3, 560, 6, 9, 30, 42,
1670  45, 53, 52, 0, 70, 0, 74, 84, 0, 50,
1671  240, 0, 280, 0, 0, 303, 306, 560, 0, 0,
1672  0, 0, 54, 298, 271, 272, 432, 434, 273, 274,
1673  275, 276, 430, 431, 429, 487, 488, 277, 0, 278,
1674  259, 5, 8, 164, 175, 165, 188, 161, 181, 171,
1675  170, 191, 192, 186, 169, 168, 163, 189, 193, 194,
1676  173, 162, 176, 180, 182, 174, 167, 183, 190, 185,
1677  184, 177, 187, 172, 160, 179, 178, 159, 166, 157,
1678  158, 154, 155, 156, 113, 115, 114, 149, 150, 146,
1679  128, 129, 130, 137, 134, 136, 131, 132, 151, 152,
1680  138, 139, 143, 133, 135, 125, 126, 127, 140, 141,
1681  142, 144, 145, 147, 148, 153, 118, 120, 122, 23,
1682  116, 117, 119, 121, 0, 0, 0, 0, 0, 0,
1683  0, 254, 0, 241, 264, 68, 258, 573, 0, 487,
1684  488, 0, 278, 573, 544, 69, 67, 562, 66, 0,
1685  573, 410, 65, 562, 563, 0, 0, 18, 237, 0,
1686  0, 326, 327, 289, 292, 411, 216, 0, 0, 217,
1687  286, 0, 0, 0, 560, 15, 562, 72, 14, 282,
1688  0, 566, 566, 242, 0, 0, 566, 542, 562, 0,
1689  0, 0, 80, 330, 0, 90, 91, 98, 300, 393,
1690  468, 467, 469, 466, 0, 465, 0, 0, 0, 0,
1691  0, 0, 0, 473, 474, 49, 231, 232, 569, 570,
1692  4, 571, 561, 0, 0, 0, 0, 0, 0, 0,
1693  399, 401, 0, 86, 0, 78, 75, 0, 0, 0,
1694  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1695  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1696  0, 0, 0, 0, 0, 573, 0, 0, 51, 0,
1697  0, 0, 0, 560, 0, 561, 0, 352, 351, 0,
1698  0, 487, 488, 278, 108, 109, 0, 0, 111, 0,
1699  0, 487, 488, 278, 319, 184, 177, 187, 172, 154,
1700  155, 156, 113, 114, 540, 321, 539, 0, 0, 0,
1701  415, 413, 299, 435, 0, 0, 404, 59, 297, 123,
1702  547, 286, 265, 261, 0, 0, 0, 255, 263, 0,
1703  573, 0, 0, 0, 0, 256, 562, 0, 291, 260,
1704  562, 250, 573, 573, 249, 562, 296, 48, 20, 22,
1705  21, 0, 293, 0, 0, 0, 0, 0, 0, 17,
1706  562, 284, 13, 561, 71, 562, 287, 568, 567, 243,
1707  568, 245, 288, 543, 0, 97, 473, 474, 88, 83,
1708  0, 0, 573, 0, 513, 455, 458, 456, 470, 452,
1709  436, 450, 437, 438, 454, 439, 440, 0, 443, 445,
1710  0, 446, 0, 0, 572, 7, 24, 25, 26, 27,
1711  28, 46, 47, 573, 0, 31, 40, 0, 41, 562,
1712  0, 76, 87, 44, 43, 0, 195, 264, 39, 213,
1713  221, 226, 227, 228, 223, 225, 235, 236, 229, 230,
1714  206, 207, 233, 234, 562, 222, 224, 218, 219, 220,
1715  208, 209, 210, 211, 212, 551, 556, 552, 557, 409,
1716  259, 407, 562, 551, 553, 552, 554, 408, 259, 0,
1717  573, 343, 0, 342, 0, 0, 0, 0, 0, 0,
1718  286, 0, 573, 0, 311, 316, 108, 109, 110, 0,
1719  494, 314, 493, 0, 573, 0, 0, 0, 513, 559,
1720  558, 323, 551, 552, 259, 259, 573, 573, 32, 197,
1721  38, 205, 57, 60, 0, 195, 546, 0, 266, 262,
1722  573, 555, 552, 562, 551, 552, 545, 290, 564, 246,
1723  251, 253, 295, 19, 0, 238, 0, 29, 0, 573,
1724  204, 73, 16, 283, 566, 0, 81, 94, 96, 562,
1725  551, 552, 519, 516, 515, 514, 517, 0, 531, 535,
1726  534, 530, 513, 0, 396, 518, 520, 522, 573, 528,
1727  573, 533, 573, 0, 512, 459, 0, 442, 444, 448,
1728  214, 215, 384, 573, 0, 382, 381, 270, 0, 85,
1729  79, 0, 0, 0, 0, 0, 0, 406, 63, 0,
1730  412, 0, 0, 248, 405, 61, 247, 341, 281, 573,
1731  573, 421, 573, 344, 573, 346, 304, 345, 307, 0,
1732  0, 310, 555, 285, 562, 551, 552, 0, 0, 496,
1733  0, 0, 108, 109, 112, 562, 0, 562, 513, 0,
1734  0, 0, 403, 56, 402, 55, 0, 0, 0, 573,
1735  124, 267, 257, 0, 0, 412, 0, 0, 573, 562,
1736  11, 244, 89, 92, 0, 519, 0, 364, 355, 357,
1737  562, 353, 573, 0, 0, 394, 0, 505, 538, 0,
1738  508, 532, 0, 510, 536, 0, 461, 462, 463, 457,
1739  464, 519, 0, 573, 0, 573, 526, 573, 573, 380,
1740  386, 0, 0, 268, 77, 196, 0, 37, 202, 36,
1741  203, 64, 565, 0, 34, 200, 35, 201, 62, 422,
1742  423, 573, 424, 0, 573, 349, 0, 0, 347, 0,
1743  0, 0, 309, 0, 0, 412, 0, 317, 0, 0,
1744  412, 320, 541, 562, 0, 498, 324, 0, 0, 198,
1745  0, 0, 252, 294, 524, 562, 0, 362, 0, 521,
1746  562, 0, 0, 523, 573, 573, 537, 573, 529, 573,
1747  573, 0, 0, 390, 387, 388, 391, 0, 383, 371,
1748  373, 0, 376, 0, 378, 400, 269, 239, 33, 199,
1749  0, 0, 426, 350, 0, 12, 428, 0, 301, 302,
1750  0, 0, 266, 573, 312, 0, 495, 315, 497, 322,
1751  513, 416, 414, 0, 354, 365, 0, 360, 356, 395,
1752  398, 397, 0, 501, 0, 503, 0, 509, 0, 506,
1753  511, 460, 0, 525, 0, 385, 573, 573, 573, 527,
1754  573, 573, 0, 425, 0, 99, 100, 107, 0, 427,
1755  0, 305, 308, 418, 419, 417, 0, 0, 0, 58,
1756  0, 363, 0, 358, 573, 573, 573, 573, 286, 0,
1757  389, 0, 368, 0, 370, 377, 0, 374, 379, 106,
1758  0, 573, 0, 573, 573, 0, 318, 0, 361, 0,
1759  502, 0, 499, 504, 507, 555, 285, 573, 573, 573,
1760  573, 555, 105, 562, 551, 552, 420, 348, 313, 325,
1761  359, 573, 369, 0, 366, 372, 375, 412, 500, 573,
1762  367
1763 };
1764 
1765 /* YYDEFGOTO[NTERM-NUM]. */
1766 static const yytype_int16 yydefgoto[] =
1767 {
1768  -1, 1, 2, 64, 65, 66, 229, 539, 540, 244,
1769  245, 421, 68, 69, 339, 70, 71, 583, 719, 72,
1770  73, 246, 74, 75, 76, 449, 77, 202, 358, 359,
1771  186, 187, 188, 189, 584, 536, 191, 79, 423, 204,
1772  250, 529, 674, 410, 411, 218, 219, 206, 397, 412,
1773  488, 80, 337, 435, 604, 341, 800, 342, 801, 697,
1774  926, 701, 698, 875, 566, 568, 711, 880, 237, 82,
1775  83, 84, 85, 86, 87, 88, 89, 90, 91, 678,
1776  542, 686, 797, 798, 350, 738, 739, 740, 763, 654,
1777  655, 764, 844, 845, 268, 269, 454, 633, 745, 301,
1778  483, 92, 93, 388, 577, 576, 549, 925, 680, 791,
1779  861, 865, 94, 95, 96, 97, 98, 99, 100, 280,
1780  467, 101, 282, 276, 274, 278, 459, 646, 645, 755,
1781  759, 102, 275, 103, 104, 209, 210, 107, 211, 212,
1782  561, 700, 709, 710, 635, 636, 637, 638, 639, 766,
1783  767, 640, 641, 642, 643, 836, 747, 377, 567, 255,
1784  413, 214, 238, 608, 531, 571, 290, 407, 408, 670,
1785  439, 543, 345, 248
1786 };
1787 
1788 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1789  STATE-NUM. */
1790 #define YYPACT_NINF -747
1791 static const yytype_int16 yypact[] =
1792 {
1793  -747, 81, 2552, -747, 7102, -747, -747, -747, 6615, -747,
1794  -747, -747, -747, -747, -747, -747, 7320, 7320, -747, -747,
1795  7320, 3237, 2814, -747, -747, -747, -747, 100, 6476, -31,
1796  -747, -26, -747, -747, -747, 5715, 2955, -747, -747, 5842,
1797  -747, -747, -747, -747, -747, -747, 8519, 8519, 83, 4434,
1798  8628, 7538, 7865, 6878, -747, 6337, -747, -747, -747, -24,
1799  29, 252, 8737, 8519, -747, 193, -747, 1104, -747, 458,
1800  -747, -747, 129, 77, -747, 69, 8846, -747, 139, 2797,
1801  22, 41, -747, 8628, 8628, -747, -747, 5078, 8951, 9056,
1802  9161, 5588, 33, 46, -747, -747, 157, -747, -747, -747,
1803  -747, -747, -747, -747, -747, 25, 58, -747, 179, 613,
1804  51, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1805  -747, -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, 134,
1812  -747, -747, -747, -747, 182, 8519, 279, 4564, 8519, 8519,
1813  8519, -747, 263, 2797, 260, -747, -747, 237, 207, 43,
1814  206, 298, 254, 265, -747, -747, -747, 4969, -747, 7320,
1815  7320, -747, -747, 5208, -747, 8628, 661, -747, 272, 287,
1816  4694, -747, -747, -747, 295, 307, -747, 304, 51, 416,
1817  619, 7211, 4434, 384, 193, 1104, -31, 399, -747, 458,
1818  419, 221, 300, -747, 260, 430, 300, -747, -31, 497,
1819  501, 9266, 442, -747, 351, 366, 383, 409, -747, -747,
1820  -747, -747, -747, -747, 644, -747, 754, 813, 605, 464,
1821  819, 478, 68, 530, 532, -747, -747, -747, -747, -747,
1822  -747, -747, 5317, 8628, 8628, 8628, 8628, 7211, 8628, 8628,
1823  -747, -747, 7974, -747, 4434, 6990, 470, 7974, 8519, 8519,
1824  8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519,
1825  8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519,
1826  8519, 8519, 8519, 8519, 9548, 7320, 9625, 3609, 458, 86,
1827  86, 8628, 8628, 193, 597, 480, 562, -747, -747, 454,
1828  601, 54, 76, 99, 331, 349, 8628, 481, -747, 45,
1829  473, -747, -747, -747, -747, 217, 286, 305, 318, 321,
1830  347, 363, 376, 381, -747, -747, -747, 391, 10549, 10549,
1831  -747, -747, -747, -747, 8737, 8737, -747, 535, -747, -747,
1832  -747, 388, -747, -747, 8519, 8519, 7429, -747, -747, 9702,
1833  7320, 9779, 8519, 8519, 7647, -747, -31, 492, -747, -747,
1834  -31, -747, 506, 539, -747, 106, -747, -747, -747, -747,
1835  -747, 6615, -747, 8519, 4029, 508, 9702, 9779, 8519, 1104,
1836  -31, -747, -747, 5445, 541, -31, -747, 7756, -747, -747,
1837  7865, -747, -747, -747, 272, 510, -747, -747, -747, 543,
1838  9266, 9856, 7320, 9933, 774, -747, -747, -747, -747, -747,
1839  -747, -747, -747, -747, -747, -747, -747, 313, -747, -747,
1840  491, -747, 8519, 8519, -747, -747, -747, -747, -747, -747,
1841  -747, -747, -747, 32, 8519, -747, 545, 546, -747, -31,
1842  9266, 551, -747, -747, -747, 566, 9473, -747, -747, 416,
1843  2184, 2184, 2184, 2184, 781, 781, 2273, 2938, 2184, 2184,
1844  1364, 1364, 662, 662, 2656, 781, 781, 927, 927, 768,
1845  397, 397, 416, 416, 416, 3378, 6083, 3464, 6197, -747,
1846  307, -747, -31, 647, -747, 660, -747, -747, 3096, 650,
1847  688, -747, 3754, 685, 4174, 56, 56, 597, 8083, 650,
1848  112, 10010, 7320, 10087, -747, 458, -747, 510, -747, 193,
1849  -747, -747, -747, 10164, 7320, 10241, 3609, 8628, 1131, -747,
1850  -747, -747, -747, -747, 1739, 1739, 32, 32, -747, 10608,
1851  -747, 2797, -747, -747, 6615, 10627, -747, 8519, 260, -747,
1852  265, 5969, 2673, -31, 490, 500, -747, -747, -747, -747,
1853  7429, 7647, -747, -747, 8628, 2797, 570, -747, 307, 307,
1854  2797, 213, 1104, -747, 300, 9266, 543, 505, 282, -31,
1855  38, 261, 603, -747, -747, -747, -747, 972, -747, -747,
1856  -747, -747, 1223, 66, -747, -747, -747, -747, 580, -747,
1857  583, 683, 589, 687, -747, -747, 893, -747, -747, -747,
1858  416, 416, -747, 576, 4839, -747, -747, 604, 8192, -747,
1859  543, 9266, 8737, 8519, 630, 8737, 8737, -747, 535, 608,
1860  677, 8737, 8737, -747, -747, 535, -747, -747, -747, 8301,
1861  740, -747, 588, -747, 740, -747, -747, -747, -747, 650,
1862  44, -747, 239, 257, -31, 141, 145, 8628, 193, -747,
1863  8628, 3609, 505, 282, -747, -31, 650, 106, 1223, 3609,
1864  193, 6754, -747, -747, -747, -747, 4839, 4694, 8519, 32,
1865  -747, -747, -747, 8519, 8519, 507, 8519, 8519, 636, 106,
1866  -747, -747, -747, 291, 8519, -747, 972, 457, -747, 651,
1867  -31, -747, 639, 4839, 4694, -747, 1223, -747, -747, 1223,
1868  -747, -747, 598, -747, -747, 4694, -747, -747, -747, -747,
1869  -747, 681, 1017, 639, 679, 654, -747, 656, 657, -747,
1870  -747, 789, 8519, 664, 543, 2797, 8519, -747, 2797, -747,
1871  2797, -747, -747, 8737, -747, 2797, -747, 2797, -747, 545,
1872  -747, 713, -747, 4304, 796, -747, 8628, 650, -747, 650,
1873  4839, 4839, -747, 8410, 3899, 189, 56, -747, 193, 650,
1874  -747, -747, -747, -31, 650, -747, -747, 799, 673, 2797,
1875  4694, 8519, 7647, -747, -747, -31, 884, 671, 1079, -747,
1876  -31, 803, 686, -747, 676, 678, -747, 684, -747, 694,
1877  684, 690, 9371, -747, 699, -747, -747, 711, -747, 1251,
1878  -747, 1251, -747, 598, -747, -747, 700, 2797, -747, 2797,
1879  9476, 86, -747, -747, 4839, -747, -747, 86, -747, -747,
1880  650, 650, -747, 365, -747, 3609, -747, -747, -747, -747,
1881  1131, -747, -747, 706, -747, 707, 884, 716, -747, -747,
1882  -747, -747, 1223, -747, 598, -747, 598, -747, 598, -747,
1883  -747, -747, 790, 520, 1017, -747, 708, 715, 684, -747,
1884  717, 684, 797, -747, 523, 366, 383, 409, 3609, -747,
1885  3754, -747, -747, -747, -747, -747, 4839, 650, 3609, -747,
1886  884, 707, 884, 721, 684, 727, 684, 684, -747, 10318,
1887  -747, 1251, -747, 598, -747, -747, 598, -747, -747, 510,
1888  10395, 7320, 10472, 688, 588, 650, -747, 650, 707, 884,
1889  -747, 598, -747, -747, -747, 730, 731, 684, 735, 684,
1890  684, 55, 282, -31, 128, 158, -747, -747, -747, -747,
1891  707, 684, -747, 598, -747, -747, -747, 163, -747, 684,
1892  -747
1893 };
1894 
1895 /* YYPGOTO[NTERM-NUM]. */
1896 static const yytype_int16 yypgoto[] =
1897 {
1898  -747, -747, -747, 452, -747, 28, -747, -545, 277, -747,
1899  39, -747, -293, 184, -58, 71, -747, -169, -747, -7,
1900  791, -142, -13, -37, -747, -396, -29, 1623, -312, 788,
1901  -54, -747, -25, -747, -747, 20, -747, 1066, -747, -45,
1902  -747, 11, 47, -324, 115, 5, -747, -322, -196, 53,
1903  -295, 8, -747, -747, -747, -747, -747, -747, -747, -747,
1904  -747, -747, -747, -747, -747, -747, -747, -747, 2, -747,
1905  -747, -747, -747, -747, -747, -747, -747, -747, -747, 205,
1906  -338, -516, -72, -618, -747, -722, -671, 147, -747, -489,
1907  -747, -600, -747, -12, -747, -747, -747, -747, -747, -747,
1908  -747, -747, -747, 798, -747, -747, -531, -747, -50, -747,
1909  -747, -747, -747, -747, -747, 811, -747, -747, -747, -747,
1910  -747, -747, -747, -747, 856, -747, -140, -747, -747, -747,
1911  -747, 7, -747, 12, -747, 1268, 1605, 823, 1289, 1575,
1912  -747, -747, 35, -387, -697, -568, -690, 273, -696, -746,
1913  72, 181, -747, -526, -747, -449, 270, -747, -747, -747,
1914  97, -360, 758, -276, -747, -747, -56, -4, 278, -585,
1915  -214, 6, -18, -2
1916 };
1917 
1918 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1919  positive, shift that token. If negative, reduce the rule which
1920  number is the opposite. If YYTABLE_NINF, syntax error. */
1921 #define YYTABLE_NINF -574
1922 static const yytype_int16 yytable[] =
1923 {
1924  111, 273, 544, 227, 81, 644, 81, 254, 725, 201,
1925  201, 532, 498, 201, 493, 192, 689, 405, 208, 208,
1926  193, 706, 208, 225, 262, 228, 340, 222, 190, 343,
1927  688, 344, 112, 221, 733, 192, 247, 375, 441, 306,
1928  193, 67, 443, 67, 596, 558, 559, 292, 190, 253,
1929  257, 81, 208, 838, 616, 264, 833, 541, 530, 741,
1930  538, 263, 794, -93, 208, 846, 799, 634, -103, 207,
1931  207, 291, 380, 207, 589, 190, 593, 380, 264, -99,
1932  596, 3, 589, 685, 263, 208, 208, 716, 717, 208,
1933  349, 360, 360, 291, 660, 743, 263, 263, 263, 541,
1934  430, -100, 574, 575, 251, 909, 888, -330, 652, 805,
1935  230, 190, -489, 213, 213, 387, 224, 213, 378, 644,
1936  810, 386, 279, 530, -107, 538, 334, 768, 619, 470,
1937  -489, 205, 215, 285, -99, 216, 461, -106, 464, 240,
1938  468, -102, 830, 298, 299, -490, 653, -93, 252, 256,
1939  390, 609, -99, 392, 393, 885, 809, 300, 560, 833,
1940  -330, -330, 489, 847, 814, -90, -102, -100, 741, 827,
1941  -104, -104, 379, 744, 471, 281, -101, 609, -93, 335,
1942  336, -93, 381, 644, 803, -93, 302, 381, 432, 288,
1943  288, 289, 289, 220, -90, 909, 838, -551, -91, 81,
1944  -103, 288, -103, 289, 769, 398, 833, 846, 888, 303,
1945  201, 398, 201, 201, -101, 931, -91, 405, 414, 208,
1946  835, 208, 208, 839, 448, 208, 433, 208, 694, 247,
1947  820, 288, 81, 289, 249, 476, 477, 478, 479, -98,
1948  705, 596, 223, 81, 81, 742, 221, 224, 307, 386,
1949  291, 704, -97, 224, 444, 923, 56, 486, 741, 644,
1950  741, 958, 497, 264, -103, 774, 384, 338, 338, 263,
1951  207, 338, 207, -102, 389, -102, 491, 609, 589, 589,
1952  429, -93, -105, 545, 546, -95, -95, 547, 980, 609,
1953  874, 247, 399, -490, 81, 208, 208, 208, 208, 81,
1954  208, 208, -481, -104, 208, -104, 81, 264, -101, 208,
1955  -101, 283, 284, 263, 213, -100, 213, -412, 741, 933,
1956  475, 813, -71, 907, 223, 910, 243, 648, 201, -92,
1957  927, 67, 406, 414, 409, 391, 480, 208, 288, 81,
1958  289, 403, 924, 208, 208, 400, 401, 537, 395, 291,
1959  586, 588, 804, -85, 528, 487, -481, -548, 208, 254,
1960  487, 437, 741, -107, 741, 562, 935, -285, 438, 493,
1961  -95, -480, 394, 485, 455, -549, -412, 396, 494, -94,
1962  793, -551, 548, 957, 790, 402, 208, 208, 987, 426,
1963  -482, 741, 588, 201, 722, 254, 603, -96, 414, -552,
1964  731, -95, 208, -483, -95, 404, -485, 415, -95, 417,
1965  398, 398, 537, 448, 422, 968, -475, 456, 457, 528,
1966  -285, -285, 111, 424, -552, -480, 81, -412, 192, -412,
1967  -412, 644, -484, 193, -478, 81, 451, 217, 537, 657,
1968  440, 190, 400, 427, -482, 201, 528, 438, -486, 220,
1969  414, -487, 264, 448, 208, 578, 580, -483, 263, 647,
1970  -485, -475, 596, 67, 537, 308, -478, -548, -488, -475,
1971  -475, 528, 612, -548, 243, 428, 569, 338, 338, 338,
1972  338, 656, 481, 482, 308, -549, -484, -478, -478, 452,
1973  453, -549, 264, 590, -278, 298, 299, -106, 263, 781,
1974  589, 416, -486, 497, -487, -487, 788, 425, -70, 735,
1975  664, 623, 624, 625, 626, -475, 331, 332, 333, 243,
1976  -478, -488, -488, 918, 434, 338, 338, 431, 669, 920,
1977  570, -555, 722, 556, 614, 668, 676, 557, 681, 551,
1978  555, 667, 721, 675, 81, 201, 81, -278, -278, 673,
1979  414, 687, 687, 445, 208, 588, 254, 201, 563, 720,
1980  446, 447, 414, 436, 537, 699, 208, 442, 81, 208,
1981  465, 528, 676, 676, 656, 656, 537, 726, 732, 713,
1982  715, 243, 450, 528, 469, 673, 673, 727, 398, 669,
1983  -555, 192, 552, 553, 821, -286, 193, 826, 472, -102,
1984  473, 690, 796, 793, 190, 939, 208, 676, 950, -104,
1985  492, 564, 565, 773, 548, 669, -101, 264, 550, 667,
1986  673, 712, 714, 263, 448, 474, 554, 973, 761, 582,
1987  623, 624, 625, 626, 789, 598, 748, 649, 748, 806,
1988  748, -555, 808, -555, -555, 607, 600, -551, -286, -286,
1989  735, 770, 623, 624, 625, 626, 81, 816, 564, 565,
1990  677, 951, 952, 264, 208, 627, 455, 208, 208, 263,
1991  463, 628, 629, 208, 208, 662, 609, 792, 795, 601,
1992  795, -85, 795, 615, 597, -264, 658, 627, 599, 824,
1993  669, 661, 630, 602, 629, 631, 679, 728, 683, 208,
1994  385, 669, 208, 81, 807, 455, 428, 730, 611, 456,
1995  457, 81, 734, 613, 630, 418, 815, 656, 81, 81,
1996  746, 762, -107, 749, 419, 420, 398, 856, -106, 752,
1997  308, 190, 487, 494, 671, 751, 777, 779, 867, 754,
1998  770, 776, 784, 786, -265, 81, 81, 672, 456, 457,
1999  458, 707, 782, -98, 691, 793, -102, 81, 872, -97,
2000  110, 770, 110, 748, 783, 748, 748, 659, 735, -104,
2001  623, 624, 625, 626, 110, 110, 822, 254, 110, 329,
2002  330, 331, 332, 333, 762, 208, -101, -93, 729, 862,
2003  842, 828, 866, 848, 849, 81, 851, 853, 208, 855,
2004  -95, 860, 81, 81, -266, 864, 81, 110, 110, 881,
2005  882, 886, 687, 890, 876, 455, 892, -92, 894, 682,
2006  110, 684, 81, 891, 896, 905, 622, 901, 623, 624,
2007  625, 626, 748, 748, 898, 748, 308, 748, 748, 904,
2008  -267, 110, 110, 929, 903, 110, 938, 930, 941, 308,
2009  263, 321, 322, 949, 858, 943, 932, 946, 456, 457,
2010  460, 959, 914, 627, 321, 322, 81, 961, 263, 628,
2011  629, 795, -551, -552, 455, 983, 606, 81, 364, 347,
2012  455, 338, 977, 825, 338, 329, 330, 331, 332, 333,
2013  630, 382, 940, 631, 802, 326, 327, 328, 329, 330,
2014  331, 332, 333, 976, 748, 748, 748, 383, 748, 748,
2015  750, 811, 753, 277, 376, 928, 632, 456, 457, 462,
2016  81, 906, 81, 456, 457, 466, 765, 834, 81, 0,
2017  81, 771, 748, 748, 748, 748, 735, 0, 623, 624,
2018  625, 626, 0, 0, 201, 0, 0, 756, 757, 414,
2019  758, 681, 795, 208, 0, 110, 44, 45, 0, 528,
2020  0, 0, 0, 537, 0, 748, 748, 748, 748, 669,
2021  528, 0, 0, 736, 0, 110, 0, 110, 110, 748,
2022  338, 110, 0, 110, 0, 812, 0, 748, 110, 0,
2023  0, 0, 0, 817, 818, 308, 0, 0, 0, 110,
2024  110, 0, 868, 0, 869, 0, 0, 823, 0, 0,
2025  321, 322, 0, 0, 877, 0, 0, 0, 829, 879,
2026  831, 832, 837, 0, 735, 840, 623, 624, 625, 626,
2027  0, 0, 841, 0, 0, 850, 0, 852, 854, 0,
2028  0, 0, 0, 328, 329, 330, 331, 332, 333, 0,
2029  110, 110, 110, 110, 110, 110, 110, 110, 0, 0,
2030  110, 736, 110, 0, 0, 110, 0, 737, 0, 843,
2031  863, 623, 624, 625, 626, 921, 922, 870, 871, 0,
2032  0, 873, 203, 203, 0, 0, 203, 0, 0, 0,
2033  0, 878, 0, 110, 0, 110, 0, 883, 0, 110,
2034  110, 0, 0, 884, 893, 895, 0, 897, 889, 899,
2035  900, 0, 236, 239, 110, 0, 0, 203, 203, 0,
2036  0, 0, 0, 0, 908, 0, 911, 0, 286, 287,
2037  0, 735, 956, 623, 624, 625, 626, 0, 0, 0,
2038  0, 919, 110, 110, 293, 294, 295, 296, 297, 0,
2039  0, 0, 0, 0, 0, 0, 0, 0, 110, 0,
2040  978, 0, 979, 0, 0, 934, 0, 936, 736, 0,
2041  0, 937, 0, 0, 887, 0, 942, 944, 945, 0,
2042  947, 948, 110, 622, 0, 623, 624, 625, 626, 0,
2043  0, 110, 0, 0, 0, 953, 0, 954, 0, 0,
2044  0, 0, 0, 955, 960, 962, 963, 964, 0, 0,
2045  110, 0, 0, 0, 967, 0, 969, 0, 0, 970,
2046  627, 0, 0, 0, 0, 0, 628, 629, 0, 0,
2047  0, 0, 0, 0, 981, 0, 0, 982, 984, 985,
2048  986, 0, 0, 0, 0, 0, 0, 630, 0, 0,
2049  631, 988, 0, 0, 0, 0, 989, 0, 0, 990,
2050  0, 203, 0, 0, 203, 203, 286, 0, 0, 0,
2051  105, 0, 105, 708, 0, 622, 0, 623, 624, 625,
2052  626, 0, 0, 203, 0, 203, 203, 0, 0, 0,
2053  0, 108, 0, 108, 0, 0, 0, 0, 0, 0,
2054  110, 0, 110, 761, 0, 623, 624, 625, 626, 0,
2055  110, 0, 627, 0, 0, 0, 0, 105, 628, 629,
2056  0, 265, 110, 0, 110, 110, 0, 0, 0, 0,
2057  0, 0, 0, 0, 0, 0, 0, 0, 108, 630,
2058  627, 0, 631, 0, 265, 0, 628, 629, 0, 0,
2059  0, 0, 0, 0, 0, 0, 351, 361, 361, 361,
2060  0, 0, 110, 0, 0, 0, 0, 630, 203, 0,
2061  631, 0, 0, 496, 499, 500, 501, 502, 503, 504,
2062  505, 506, 507, 508, 509, 510, 511, 512, 513, 514,
2063  515, 516, 517, 518, 519, 520, 521, 522, 523, 524,
2064  0, 203, 0, 0, 0, 0, 0, 0, 0, 0,
2065  0, 0, 110, 0, 0, 0, 0, 0, 0, 0,
2066  110, 0, 0, 110, 110, 0, 0, 0, 0, 110,
2067  110, 0, 308, 309, 310, 311, 312, 313, 314, 315,
2068  316, 317, 318, -574, -574, 0, 0, 321, 322, 0,
2069  579, 581, 0, 0, 0, 110, 0, 0, 110, 110,
2070  585, 203, 203, 0, 0, 105, 203, 110, 579, 581,
2071  203, 0, 0, 0, 110, 110, 324, 325, 326, 327,
2072  328, 329, 330, 331, 332, 333, 108, 0, 0, 605,
2073  0, 0, 0, 0, 610, 0, 0, 0, 105, 0,
2074  0, 110, 110, 203, 0, 0, 203, 0, 0, 105,
2075  105, 0, 0, 110, 0, 0, 0, 0, 203, 108,
2076  0, 0, 0, 0, 0, 0, 0, 0, 0, 265,
2077  108, 108, 0, 0, 0, 0, 0, 0, 650, 651,
2078  0, 110, 0, 0, 0, 0, 0, 0, 0, 0,
2079  203, 110, 0, 0, 110, 0, 0, 0, 110, 110,
2080  105, 0, 110, 0, 0, 105, 0, 0, 0, 0,
2081  0, 0, 105, 265, 0, 0, 0, 109, 110, 109,
2082  0, 108, 0, 0, 0, 0, 108, 0, 0, 0,
2083  0, 0, 0, 108, 0, 0, 0, 0, 0, 0,
2084  0, 0, 0, 0, 0, 105, 0, 106, 0, 106,
2085  0, 0, 0, 0, 203, 0, 0, 0, 203, 0,
2086  0, 0, 110, 0, 109, 78, 108, 78, 267, 0,
2087  203, 0, 0, 110, 0, 0, 0, 0, 0, 0,
2088  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2089  0, 267, 0, 203, 106, 0, 0, 0, 266, 0,
2090  0, 0, 0, 353, 363, 363, 203, 203, 0, 0,
2091  0, 0, 78, 0, 0, 0, 110, 0, 110, 0,
2092  0, 266, 0, 0, 110, 0, 110, 0, 0, 0,
2093  0, 0, 105, 352, 362, 362, 362, 0, 0, 0,
2094  0, 105, 0, 0, 0, 0, 0, 0, 0, 110,
2095  0, 348, 0, 108, 0, 0, 0, 0, 265, 0,
2096  0, 0, 108, 0, 203, 0, 0, 0, 585, 775,
2097  0, 778, 780, 0, 0, 0, 0, 785, 787, -573,
2098  0, 0, 0, 0, 0, 203, 0, -573, -573, -573,
2099  0, 0, -573, -573, -573, 0, -573, 0, 265, 0,
2100  0, 0, 0, 0, 0, 0, -573, 0, 0, 0,
2101  0, 0, 109, 0, 0, 0, -573, -573, 0, -573,
2102  -573, -573, -573, -573, 819, 0, 0, 0, 0, 778,
2103  780, 0, 785, 787, 0, 0, 0, 0, 0, 0,
2104  203, 0, 106, 0, 0, 109, 0, 0, 0, 0,
2105  105, 0, 105, 0, 0, 0, 109, 109, 0, 0,
2106  78, 0, 0, 0, -573, 0, 0, 0, 0, 0,
2107  0, 108, 0, 108, 105, 106, 267, 0, 203, 0,
2108  0, 0, 857, 0, 0, 0, 106, 106, 0, 859,
2109  0, 0, 0, 78, 0, 108, 0, 0, 0, 0,
2110  0, 0, 0, 0, 78, 78, 266, 109, 0, 203,
2111  0, 0, 109, 0, 0, 0, -573, 0, -573, 109,
2112  267, 220, -573, 265, -573, 0, -573, 859, 203, 0,
2113  0, 0, 0, 0, 0, 0, 0, 106, 0, 0,
2114  0, 0, 106, 0, 0, 0, 0, 0, 0, 106,
2115  266, 0, 109, 0, 0, 78, 0, 0, 0, 0,
2116  78, 0, 105, 0, 0, 0, 0, 78, 0, 265,
2117  495, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2118  0, 0, 106, 108, 0, 0, 0, 0, 0, 0,
2119  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2120  78, 0, 0, 0, 0, 0, 0, 0, 0, 105,
2121  0, 0, 0, 0, 0, 0, 0, 105, 0, 0,
2122  0, 0, 0, 0, 105, 105, 0, 0, 0, 0,
2123  108, 0, 0, 0, 0, 0, 0, 0, 108, 109,
2124  0, 0, 0, 0, 0, 108, 108, 0, 109, 0,
2125  0, 105, 105, 0, 0, 0, 0, 203, 0, 0,
2126  0, 0, 0, 105, 0, 267, 0, 0, 0, 106,
2127  0, 0, 108, 108, 0, 0, 0, 0, 106, 0,
2128  0, 0, 0, 0, 108, 0, 0, 78, 0, 0,
2129  0, 0, 0, 0, 0, 266, 78, 0, 0, 0,
2130  0, 105, 0, 0, 0, 267, 0, 0, 105, 105,
2131  0, 0, 105, 0, 0, 0, 0, 0, 0, 0,
2132  0, 0, 108, 0, 0, 0, 0, 0, 105, 108,
2133  108, 0, 0, 108, 0, 266, 0, 0, 0, 0,
2134  0, 0, 0, 0, 0, 0, 0, 0, 0, 108,
2135  361, 0, 0, 0, 0, 0, 0, 109, 0, 109,
2136  0, 0, 0, 0, 0, 0, 0, 0, 915, 0,
2137  0, 0, 105, 0, 0, 0, 0, 0, 0, 0,
2138  0, 109, 0, 105, 0, 0, 0, 106, 0, 106,
2139  0, 0, 0, 108, 0, 0, 0, 0, 0, 0,
2140  0, 0, 0, 0, 108, 78, 0, 78, 0, 0,
2141  0, 106, 0, 0, 0, 0, 0, 0, 0, 0,
2142  0, 0, 0, 0, 0, 0, 105, 0, 105, 78,
2143  267, 0, 0, 0, 105, 0, 105, 0, 0, 0,
2144  0, 0, 0, 0, 0, 0, 0, 108, 0, 108,
2145  0, 0, 0, 0, 0, 108, 0, 108, 0, 0,
2146  266, 760, 0, 0, 0, 0, 0, 0, 0, 109,
2147  0, 0, 0, 0, 0, 0, 267, 0, 0, 0,
2148  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2149  0, 0, 308, -574, -574, -574, -574, 313, 314, 106,
2150  0, -574, -574, 0, 0, 0, 266, 321, 322, 0,
2151  0, 0, 0, 0, 0, 0, 109, 78, 0, 0,
2152  0, 0, 0, 0, 109, 495, 0, 0, 0, 0,
2153  0, 109, 109, 0, 0, 0, 324, 325, 326, 327,
2154  328, 329, 330, 331, 332, 333, 106, 0, 0, 0,
2155  0, 0, 0, 0, 106, 0, 0, 0, 109, 109,
2156  0, 106, 106, 0, 78, 0, 0, 0, 0, 0,
2157  109, 0, 78, 0, 0, 0, 0, 0, 0, 78,
2158  78, 308, 309, 310, 311, 312, 313, 314, 106, 106,
2159  317, 318, 0, 0, 0, 0, 321, 322, 0, 0,
2160  106, 0, 0, 0, 0, 0, 78, 78, 109, 0,
2161  0, 0, 0, 0, 0, 109, 109, 0, 78, 109,
2162  0, 0, 0, 0, 0, 324, 325, 326, 327, 328,
2163  329, 330, 331, 332, 333, 109, 0, 0, 106, 0,
2164  0, 0, 0, 0, 0, 106, 106, 0, 0, 106,
2165  0, 0, 0, 0, 0, 0, 78, 363, 0, 0,
2166  0, 0, 0, 78, 78, 106, 0, 78, 0, 0,
2167  0, 0, 0, 0, 0, 917, 0, 0, 0, 109,
2168  0, 0, 0, 78, 0, 0, 0, 362, 0, 0,
2169  109, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2170  0, 0, 0, 0, 0, 916, 0, 0, 0, 106,
2171  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2172  106, 0, 0, 913, 0, 0, 0, 78, 0, 0,
2173  0, 0, 0, 109, 0, 109, 0, 0, 78, 0,
2174  0, 109, 0, 109, 0, 0, 0, 0, 0, 0,
2175  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2176  0, 0, 0, 106, 0, 106, 0, 0, 0, 0,
2177  0, 106, 0, 106, 0, 0, 0, 0, 0, 0,
2178  0, 78, 0, 78, 0, 0, 0, 0, 0, 78,
2179  0, 78, -573, 4, 0, 5, 6, 7, 8, 9,
2180  0, 0, 0, 10, 11, 0, 0, 0, 12, 0,
2181  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2182  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2183  0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
2184  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2185  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2186  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2187  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2188  0, 49, 50, 0, 51, 52, 0, 53, 0, 54,
2189  55, 56, 57, 58, 59, 60, 0, 0, 0, 0,
2190  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2191  0, 0, 0, -285, 61, 62, 63, 0, 0, 0,
2192  0, -285, -285, -285, 0, 0, -285, -285, -285, 0,
2193  -285, 0, 0, 0, 0, 0, 0, -573, 0, -573,
2194  -285, -285, -285, 0, 0, 0, 0, 0, 0, 0,
2195  -285, -285, 0, -285, -285, -285, -285, -285, 0, 0,
2196  0, 0, 0, 0, 308, 309, 310, 311, 312, 313,
2197  314, 315, 316, 317, 318, 319, 320, 0, 0, 321,
2198  322, -285, -285, -285, -285, -285, -285, -285, -285, -285,
2199  -285, -285, -285, -285, 0, 0, -285, -285, -285, 0,
2200  724, -285, 0, 0, 0, 0, 323, -285, 324, 325,
2201  326, 327, 328, 329, 330, 331, 332, 333, 0, 0,
2202  -285, 0, -105, -285, -285, -285, -285, -285, -285, -285,
2203  -285, -285, -285, -285, -285, 0, 0, 0, 0, 0,
2204  0, 0, 0, 224, 0, 0, 0, 0, 0, 0,
2205  -285, -285, -285, -285, -411, 0, -285, -285, -285, 0,
2206  -285, 0, -411, -411, -411, 0, 0, -411, -411, -411,
2207  0, -411, 0, 0, 0, 0, 0, 0, 0, 0,
2208  -411, -411, -411, 0, 0, 0, 0, 0, 0, 0,
2209  0, -411, -411, 0, -411, -411, -411, -411, -411, 0,
2210  0, 0, 0, 0, 0, 308, 309, 310, 311, 312,
2211  313, 314, 315, 316, 317, 318, 319, 320, 0, 0,
2212  321, 322, -411, -411, -411, -411, -411, -411, -411, -411,
2213  -411, -411, -411, -411, -411, 0, 0, -411, -411, -411,
2214  0, 0, -411, 0, 0, 0, 0, 323, -411, 324,
2215  325, 326, 327, 328, 329, 330, 331, 332, 333, 0,
2216  0, 0, 0, 0, -411, 0, -411, -411, -411, -411,
2217  -411, -411, -411, -411, -411, -411, 0, 0, 0, 0,
2218  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2219  -411, -411, -411, -411, -411, -279, 220, -411, -411, -411,
2220  0, -411, 0, -279, -279, -279, 0, 0, -279, -279,
2221  -279, 0, -279, 0, 0, 0, 0, 0, 0, 0,
2222  0, 0, -279, -279, -279, 0, 0, 0, 0, 0,
2223  0, 0, -279, -279, 0, -279, -279, -279, -279, -279,
2224  0, 0, 0, 0, 0, 0, 308, 309, 310, 311,
2225  312, 313, 314, 315, 0, 317, 318, 0, 0, 0,
2226  0, 321, 322, -279, -279, -279, -279, -279, -279, -279,
2227  -279, -279, -279, -279, -279, -279, 0, 0, -279, -279,
2228  -279, 0, 0, -279, 0, 0, 0, 0, 0, -279,
2229  324, 325, 326, 327, 328, 329, 330, 331, 332, 333,
2230  0, 0, -279, 0, 0, -279, -279, -279, -279, -279,
2231  -279, -279, -279, -279, -279, -279, -279, 0, 0, 0,
2232  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2233  0, 0, -279, -279, -279, -279, -573, 0, -279, -279,
2234  -279, 0, -279, 0, -573, -573, -573, 0, 0, -573,
2235  -573, -573, 0, -573, 0, 0, 0, 0, 0, 0,
2236  0, 0, -573, -573, -573, 0, 0, 0, 0, 0,
2237  0, 0, 0, -573, -573, 0, -573, -573, -573, -573,
2238  -573, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2239  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2240  0, 0, 0, 0, -573, -573, -573, -573, -573, -573,
2241  -573, -573, -573, -573, -573, -573, -573, 0, 0, -573,
2242  -573, -573, 0, 0, -573, 0, 0, 0, 0, 0,
2243  -573, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2244  0, 0, 0, 0, 0, 0, -573, 0, -573, -573,
2245  -573, -573, -573, -573, -573, -573, -573, -573, 0, 0,
2246  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2247  0, 0, -573, -573, -573, -573, -573, -292, 220, -573,
2248  -573, -573, 0, -573, 0, -292, -292, -292, 0, 0,
2249  -292, -292, -292, 0, -292, 0, 0, 0, 0, 0,
2250  0, 0, 0, 0, -292, -292, 0, 0, 0, 0,
2251  0, 0, 0, 0, -292, -292, 0, -292, -292, -292,
2252  -292, -292, 0, 0, 0, 0, 0, 0, 0, 0,
2253  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2254  0, 0, 0, 0, 0, -292, -292, -292, -292, -292,
2255  -292, -292, -292, -292, -292, -292, -292, -292, 0, 0,
2256  -292, -292, -292, 0, 0, -292, 0, 0, 0, 0,
2257  0, -292, 0, 0, 0, 0, 0, 0, 0, 0,
2258  0, 0, 0, 0, 0, 0, 0, -292, 0, -292,
2259  -292, -292, -292, -292, -292, -292, -292, -292, -292, 0,
2260  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2261  0, 0, 0, 0, -292, -292, -292, -292, -555, 217,
2262  -292, -292, -292, 0, -292, 0, -555, -555, -555, 0,
2263  0, 0, -555, -555, 0, -555, 0, 0, 0, 0,
2264  0, 0, 0, 0, -555, 0, 0, 0, 0, 0,
2265  0, 0, 0, 0, 0, -555, -555, 0, -555, -555,
2266  -555, -555, -555, 0, 0, 0, 0, 0, 0, 0,
2267  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2268  0, 0, 0, 0, 0, 0, -555, -555, -555, -555,
2269  -555, -555, -555, -555, -555, -555, -555, -555, -555, 0,
2270  0, -555, -555, -555, -285, 665, 0, 0, 0, 0,
2271  0, 0, -285, -285, -285, 0, 0, 0, -285, -285,
2272  0, -285, 0, 0, 0, 0, 0, -103, -555, 0,
2273  -555, -555, -555, -555, -555, -555, -555, -555, -555, -555,
2274  0, -285, -285, 0, -285, -285, -285, -285, -285, 0,
2275  0, 0, 0, 0, -555, -555, -555, -555, -94, 0,
2276  0, -555, 0, -555, 0, -555, 0, 0, 0, 0,
2277  0, 0, -285, -285, -285, -285, -285, -285, -285, -285,
2278  -285, -285, -285, -285, -285, 0, 0, -285, -285, -285,
2279  0, 666, 0, 0, 0, 0, 0, 0, 0, 0,
2280  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2281  0, 0, 0, -105, -285, 0, -285, -285, -285, -285,
2282  -285, -285, -285, -285, -285, -285, 0, 0, 0, 0,
2283  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2284  0, -285, -285, -285, -96, 0, 0, -285, 0, -285,
2285  241, -285, 5, 6, 7, 8, 9, -573, -573, -573,
2286  10, 11, 0, 0, -573, 12, 0, 13, 14, 15,
2287  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2288  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2289  0, 0, 0, 0, 28, 29, 0, 31, 32, 33,
2290  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2291  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2292  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2293  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2294  0, 51, 52, 0, 53, 0, 54, 55, 56, 57,
2295  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2296  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2297  0, 61, 62, 63, 0, 0, 0, 0, 0, 0,
2298  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2299  0, 0, 0, 0, -573, 241, -573, 5, 6, 7,
2300  8, 9, 0, 0, -573, 10, 11, 0, -573, -573,
2301  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2302  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2303  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2304  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2305  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2306  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2307  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2308  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2309  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2310  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2311  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2312  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2313  0, 0, 0, 0, 0, 0, 0, 0, 0, -573,
2314  241, -573, 5, 6, 7, 8, 9, 0, 0, -573,
2315  10, 11, 0, 0, -573, 12, -573, 13, 14, 15,
2316  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2317  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2318  0, 0, 0, 0, 28, 29, 0, 31, 32, 33,
2319  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2320  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2321  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2322  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2323  0, 51, 52, 0, 53, 0, 54, 55, 56, 57,
2324  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2325  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2326  0, 61, 62, 63, 0, 0, 0, 0, 0, 0,
2327  4, 0, 5, 6, 7, 8, 9, 0, 0, 0,
2328  10, 11, 0, 0, -573, 12, -573, 13, 14, 15,
2329  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2330  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2331  0, 0, 0, 0, 28, 29, 30, 31, 32, 33,
2332  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2333  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2334  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2335  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2336  0, 51, 52, 0, 53, 0, 54, 55, 56, 57,
2337  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2338  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2339  0, 61, 62, 63, 0, 0, 0, 0, 0, 0,
2340  0, 0, 0, 0, 0, 0, -573, 0, 0, 0,
2341  0, 0, 0, 0, -573, 241, -573, 5, 6, 7,
2342  8, 9, 0, 0, -573, 10, 11, 0, 0, -573,
2343  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2344  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2345  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2346  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2347  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2348  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2349  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2350  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2351  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2352  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2353  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2354  0, 0, 0, 0, 0, 241, 0, 5, 6, 7,
2355  8, 9, 0, -573, -573, 10, 11, 0, 0, -573,
2356  12, -573, 13, 14, 15, 16, 17, 18, 19, 0,
2357  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2358  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2359  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2360  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2361  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2362  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2363  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2364  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2365  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2366  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2367  0, 0, 0, 0, 0, 241, 0, 5, 6, 7,
2368  8, 9, 0, 0, 0, 10, 11, 0, 0, -573,
2369  12, -573, 13, 14, 15, 16, 17, 18, 19, 0,
2370  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2371  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2372  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2373  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2374  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2375  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2376  48, 0, 0, 242, 50, 0, 51, 52, 0, 53,
2377  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2378  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2379  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2380  0, 0, 0, 0, 0, 241, 0, 5, 6, 7,
2381  8, 9, 0, 0, 0, 10, 11, -573, 0, -573,
2382  12, -573, 13, 14, 15, 16, 17, 18, 19, 0,
2383  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2384  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2385  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2386  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2387  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2388  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2389  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2390  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2391  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2392  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2393  0, 0, 0, 0, 0, 241, 0, 5, 6, 7,
2394  8, 9, 0, 0, 0, 10, 11, -573, 0, -573,
2395  12, -573, 13, 14, 15, 16, 17, 18, 19, 0,
2396  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2397  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2398  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2399  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2400  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2401  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2402  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2403  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2404  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2405  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2406  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2407  0, -573, 0, 0, 0, 0, 0, 0, 0, -573,
2408  241, -573, 5, 6, 7, 8, 9, 0, 0, -573,
2409  10, 11, 0, 0, 0, 12, 0, 13, 14, 15,
2410  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2411  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2412  0, 0, 0, 0, 28, 29, 0, 31, 32, 33,
2413  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2414  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2415  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2416  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2417  0, 51, 52, 0, 53, 0, 54, 55, 56, 57,
2418  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2419  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2420  0, 61, 62, 63, 0, 0, 0, 0, 0, 0,
2421  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2422  10, 11, 0, 0, -573, 12, -573, 13, 14, 15,
2423  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2424  21, 22, 23, 24, 25, 26, 0, 0, 194, 0,
2425  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2426  34, 35, 36, 37, 38, 39, 40, 195, 41, 42,
2427  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2428  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2429  0, 0, 0, 0, 0, 196, 0, 0, 197, 50,
2430  0, 51, 52, 0, 198, 199, 54, 55, 56, 57,
2431  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2432  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2433  11, 61, 200, 63, 12, 0, 13, 14, 15, 16,
2434  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2435  22, 23, 24, 25, 26, 0, 224, 27, 0, 0,
2436  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2437  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2438  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2439  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2440  0, 0, 0, 0, 196, 0, 0, 197, 50, 0,
2441  51, 52, 0, 0, 0, 54, 55, 56, 57, 58,
2442  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2443  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2444  61, 62, 63, 0, 0, 0, 0, 0, 0, 0,
2445  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2446  11, 0, 0, 288, 12, 289, 13, 14, 15, 16,
2447  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2448  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2449  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2450  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2451  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2452  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2453  0, 0, 0, 0, 196, 0, 0, 197, 50, 0,
2454  51, 52, 0, 0, 0, 54, 55, 56, 57, 58,
2455  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2456  5, 6, 7, 8, 9, 0, 0, 0, 10, 11,
2457  61, 62, 63, 12, 0, 13, 14, 15, 16, 17,
2458  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2459  23, 24, 25, 26, 0, 224, 27, 0, 0, 0,
2460  0, 0, 28, 29, 30, 31, 32, 33, 34, 35,
2461  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2462  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2463  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2464  0, 0, 0, 48, 0, 0, 49, 50, 0, 51,
2465  52, 0, 53, 0, 54, 55, 56, 57, 58, 59,
2466  60, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2467  0, 0, 0, 0, 0, 0, 0, 0, 0, 61,
2468  62, 63, 0, 0, 0, 0, 0, 0, 5, 6,
2469  7, 8, 9, 0, 0, 0, 10, 11, 0, 0,
2470  0, 12, 474, 13, 14, 15, 16, 17, 18, 19,
2471  0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2472  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2473  28, 29, 0, 31, 32, 33, 34, 35, 36, 37,
2474  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2475  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2476  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2477  0, 48, 0, 0, 49, 50, 0, 51, 52, 0,
2478  53, 0, 54, 55, 56, 57, 58, 59, 60, 0,
2479  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2480  0, 0, 0, 0, 0, 0, 0, 61, 62, 63,
2481  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2482  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2483  474, 113, 114, 115, 116, 117, 118, 119, 120, 121,
2484  122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
2485  132, 133, 134, 135, 136, 0, 0, 0, 137, 138,
2486  139, 365, 366, 367, 368, 144, 145, 146, 0, 0,
2487  0, 0, 0, 147, 148, 149, 150, 369, 370, 371,
2488  372, 155, 37, 38, 373, 40, 0, 0, 0, 0,
2489  0, 0, 0, 0, 157, 158, 159, 160, 161, 162,
2490  163, 164, 165, 0, 0, 166, 167, 0, 0, 168,
2491  169, 170, 171, 0, 0, 0, 0, 0, 0, 0,
2492  0, 0, 0, 172, 0, 0, 0, 0, 0, 0,
2493  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2494  173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
2495  0, 183, 184, 0, 0, 0, 0, 0, -548, -548,
2496  -548, 0, -548, 0, 0, 0, -548, -548, 0, 185,
2497  374, -548, 0, -548, -548, -548, -548, -548, -548, -548,
2498  0, -548, 0, 0, 0, -548, -548, -548, -548, -548,
2499  -548, -548, 0, 0, -548, 0, 0, 0, 0, 0,
2500  0, -548, 0, 0, -548, -548, -548, -548, -548, -548,
2501  -548, -548, -548, -548, -548, -548, 0, -548, -548, -548,
2502  0, -548, -548, 0, 0, 0, 0, 0, 0, 0,
2503  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2504  0, -548, 0, 0, -548, -548, 0, -548, -548, 0,
2505  -548, -548, -548, -548, -548, -548, -548, -548, -548, 0,
2506  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2507  0, 0, 0, 0, 0, 0, 0, -548, -548, -548,
2508  0, 0, 0, 0, 0, -549, -549, -549, 0, -549,
2509  0, -548, 0, -549, -549, 0, 0, -548, -549, 0,
2510  -549, -549, -549, -549, -549, -549, -549, 0, -549, 0,
2511  0, 0, -549, -549, -549, -549, -549, -549, -549, 0,
2512  0, -549, 0, 0, 0, 0, 0, 0, -549, 0,
2513  0, -549, -549, -549, -549, -549, -549, -549, -549, -549,
2514  -549, -549, -549, 0, -549, -549, -549, 0, -549, -549,
2515  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2516  0, 0, 0, 0, 0, 0, 0, 0, -549, 0,
2517  0, -549, -549, 0, -549, -549, 0, -549, -549, -549,
2518  -549, -549, -549, -549, -549, -549, 0, 0, 0, 0,
2519  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2520  0, 0, 0, 0, -549, -549, -549, 0, 0, 0,
2521  0, 0, -551, -551, -551, 0, -551, 0, -549, 0,
2522  -551, -551, 0, 0, -549, -551, 0, -551, -551, -551,
2523  -551, -551, -551, -551, 0, 0, 0, 0, 0, -551,
2524  -551, -551, -551, -551, -551, -551, 0, 0, -551, 0,
2525  0, 0, 0, 0, 0, -551, 0, 0, -551, -551,
2526  -551, -551, -551, -551, -551, -551, -551, -551, -551, -551,
2527  0, -551, -551, -551, 0, -551, -551, 0, 0, 0,
2528  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2529  0, 0, 0, 0, 0, -551, 723, 0, -551, -551,
2530  0, -551, -551, 0, -551, -551, -551, -551, -551, -551,
2531  -551, -551, -551, 0, 0, 0, 0, 0, -103, 0,
2532  0, 0, 0, 0, 0, 0, -553, -553, -553, 0,
2533  -553, -551, -551, -551, -553, -553, 0, 0, 0, -553,
2534  0, -553, -553, -553, -553, -553, -553, -553, 0, 0,
2535  0, -551, 0, -553, -553, -553, -553, -553, -553, -553,
2536  0, 0, -553, 0, 0, 0, 0, 0, 0, -553,
2537  0, 0, -553, -553, -553, -553, -553, -553, -553, -553,
2538  -553, -553, -553, -553, 0, -553, -553, -553, 0, -553,
2539  -553, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2540  0, 0, 0, 0, 0, 0, 0, 0, 0, -553,
2541  0, 0, -553, -553, 0, -553, -553, 0, -553, -553,
2542  -553, -553, -553, -553, -553, -553, -553, 0, 0, 0,
2543  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2544  -554, -554, -554, 0, -554, -553, -553, -553, -554, -554,
2545  0, 0, 0, -554, 0, -554, -554, -554, -554, -554,
2546  -554, -554, 0, 0, 0, -553, 0, -554, -554, -554,
2547  -554, -554, -554, -554, 0, 0, -554, 0, 0, 0,
2548  0, 0, 0, -554, 0, 0, -554, -554, -554, -554,
2549  -554, -554, -554, -554, -554, -554, -554, -554, 0, -554,
2550  -554, -554, 0, -554, -554, 0, 0, 0, 0, 0,
2551  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2552  0, 0, 0, -554, 0, 0, -554, -554, 0, -554,
2553  -554, 0, -554, -554, -554, -554, -554, -554, -554, -554,
2554  -554, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2555  0, 0, 0, 0, 0, 0, 0, 0, 0, -554,
2556  -554, -554, 0, 0, 0, 0, 0, 0, 0, 0,
2557  0, 0, 0, 0, 0, 0, 0, 0, 0, -554,
2558  113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
2559  123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
2560  133, 134, 135, 136, 0, 0, 0, 137, 138, 139,
2561  140, 141, 142, 143, 144, 145, 146, 0, 0, 0,
2562  0, 0, 147, 148, 149, 150, 151, 152, 153, 154,
2563  155, 270, 271, 156, 272, 0, 0, 0, 0, 0,
2564  0, 0, 0, 157, 158, 159, 160, 161, 162, 163,
2565  164, 165, 0, 0, 166, 167, 0, 0, 168, 169,
2566  170, 171, 0, 0, 0, 0, 0, 0, 0, 0,
2567  0, 0, 172, 0, 0, 0, 0, 0, 0, 0,
2568  0, 0, 0, 0, 0, 0, 0, 0, 0, 173,
2569  174, 175, 176, 177, 178, 179, 180, 181, 182, 0,
2570  183, 184, 0, 0, 0, 0, 0, 0, 0, 0,
2571  0, 0, 0, 0, 0, 0, 0, 0, 185, 113,
2572  114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
2573  124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
2574  134, 135, 136, 0, 0, 0, 137, 138, 139, 140,
2575  141, 142, 143, 144, 145, 146, 0, 0, 0, 0,
2576  0, 147, 148, 149, 150, 151, 152, 153, 154, 155,
2577  226, 0, 156, 0, 0, 0, 0, 0, 0, 0,
2578  0, 0, 157, 158, 159, 160, 161, 162, 163, 164,
2579  165, 0, 0, 166, 167, 0, 0, 168, 169, 170,
2580  171, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2581  0, 172, 0, 0, 55, 0, 0, 0, 0, 0,
2582  0, 0, 0, 0, 0, 0, 0, 0, 173, 174,
2583  175, 176, 177, 178, 179, 180, 181, 182, 0, 183,
2584  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2585  0, 0, 0, 0, 0, 0, 0, 185, 113, 114,
2586  115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
2587  125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
2588  135, 136, 0, 0, 0, 137, 138, 139, 140, 141,
2589  142, 143, 144, 145, 146, 0, 0, 0, 0, 0,
2590  147, 148, 149, 150, 151, 152, 153, 154, 155, 0,
2591  0, 156, 0, 0, 0, 0, 0, 0, 0, 0,
2592  0, 157, 158, 159, 160, 161, 162, 163, 164, 165,
2593  0, 0, 166, 167, 0, 0, 168, 169, 170, 171,
2594  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2595  172, 0, 0, 55, 0, 0, 0, 0, 0, 0,
2596  0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
2597  176, 177, 178, 179, 180, 181, 182, 0, 183, 184,
2598  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2599  0, 0, 0, 0, 0, 0, 185, 113, 114, 115,
2600  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
2601  126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
2602  136, 0, 0, 0, 137, 138, 139, 140, 141, 142,
2603  143, 144, 145, 146, 0, 0, 0, 0, 0, 147,
2604  148, 149, 150, 151, 152, 153, 154, 155, 0, 0,
2605  156, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2606  157, 158, 159, 160, 161, 162, 163, 164, 165, 0,
2607  0, 166, 167, 0, 0, 168, 169, 170, 171, 0,
2608  0, 0, 0, 0, 0, 0, 0, 0, 0, 172,
2609  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2610  0, 0, 0, 0, 0, 0, 173, 174, 175, 176,
2611  177, 178, 179, 180, 181, 182, 0, 183, 184, 0,
2612  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2613  11, 0, 0, 0, 12, 185, 13, 14, 15, 231,
2614  232, 18, 19, 0, 0, 0, 0, 0, 233, 234,
2615  235, 23, 24, 25, 26, 0, 0, 194, 0, 0,
2616  0, 0, 0, 0, 258, 0, 0, 32, 33, 34,
2617  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2618  43, 44, 45, 0, 0, 0, 0, 0, 0, 0,
2619  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2620  0, 0, 0, 0, 259, 0, 0, 197, 50, 0,
2621  51, 52, 0, 0, 0, 54, 55, 56, 57, 58,
2622  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2623  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2624  260, 10, 11, 0, 0, 0, 12, 0, 13, 14,
2625  15, 231, 232, 18, 19, 0, 0, 0, 261, 0,
2626  233, 234, 235, 23, 24, 25, 26, 0, 0, 194,
2627  0, 0, 0, 0, 0, 0, 258, 0, 0, 32,
2628  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2629  42, 0, 43, 44, 45, 0, 0, 0, 0, 0,
2630  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2631  0, 0, 0, 0, 0, 0, 259, 0, 0, 197,
2632  50, 0, 51, 52, 0, 0, 0, 54, 55, 56,
2633  57, 58, 59, 60, 0, 0, 0, 0, 0, 0,
2634  0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
2635  0, 0, 260, 10, 11, 0, 0, 0, 12, 0,
2636  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2637  490, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2638  0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
2639  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2640  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2641  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2642  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2643  0, 49, 50, 0, 51, 52, 0, 53, 0, 54,
2644  55, 56, 57, 58, 59, 60, 0, 0, 0, 0,
2645  0, 0, 0, 0, 5, 6, 7, 8, 9, 0,
2646  0, 0, 10, 11, 61, 62, 63, 12, 0, 13,
2647  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2648  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2649  27, 0, 0, 0, 0, 0, 28, 29, 0, 31,
2650  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2651  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2652  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2653  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2654  49, 50, 0, 51, 52, 0, 53, 0, 54, 55,
2655  56, 57, 58, 59, 60, 0, 0, 0, 0, 0,
2656  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2657  0, 10, 11, 61, 62, 63, 12, 0, 13, 14,
2658  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2659  20, 21, 22, 23, 24, 25, 26, 0, 0, 194,
2660  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
2661  33, 34, 35, 36, 37, 38, 39, 40, 195, 41,
2662  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2663  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2664  0, 0, 0, 0, 0, 0, 196, 0, 0, 197,
2665  50, 0, 51, 52, 0, 198, 199, 54, 55, 56,
2666  57, 58, 59, 60, 0, 0, 0, 0, 0, 0,
2667  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2668  10, 11, 61, 200, 63, 12, 0, 13, 14, 15,
2669  231, 232, 18, 19, 0, 0, 0, 0, 0, 233,
2670  234, 235, 23, 24, 25, 26, 0, 0, 194, 0,
2671  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2672  34, 35, 36, 37, 38, 39, 40, 195, 41, 42,
2673  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2674  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2675  0, 0, 0, 0, 0, 196, 0, 0, 197, 50,
2676  0, 51, 52, 0, 587, 199, 54, 55, 56, 57,
2677  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2678  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2679  11, 61, 200, 63, 12, 0, 13, 14, 15, 231,
2680  232, 18, 19, 0, 0, 0, 0, 0, 233, 234,
2681  235, 23, 24, 25, 26, 0, 0, 194, 0, 0,
2682  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2683  35, 36, 37, 38, 39, 40, 195, 41, 42, 0,
2684  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2685  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2686  0, 0, 0, 0, 196, 0, 0, 197, 50, 0,
2687  51, 52, 0, 198, 0, 54, 55, 56, 57, 58,
2688  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2689  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2690  61, 200, 63, 12, 0, 13, 14, 15, 231, 232,
2691  18, 19, 0, 0, 0, 0, 0, 233, 234, 235,
2692  23, 24, 25, 26, 0, 0, 194, 0, 0, 0,
2693  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2694  36, 37, 38, 39, 40, 195, 41, 42, 0, 43,
2695  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2696  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2697  0, 0, 0, 196, 0, 0, 197, 50, 0, 51,
2698  52, 0, 0, 199, 54, 55, 56, 57, 58, 59,
2699  60, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2700  6, 7, 0, 9, 0, 0, 0, 10, 11, 61,
2701  200, 63, 12, 0, 13, 14, 15, 231, 232, 18,
2702  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2703  24, 25, 26, 0, 0, 194, 0, 0, 0, 0,
2704  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2705  37, 38, 39, 40, 195, 41, 42, 0, 43, 44,
2706  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2707  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2708  0, 0, 196, 0, 0, 197, 50, 0, 51, 52,
2709  0, 587, 0, 54, 55, 56, 57, 58, 59, 60,
2710  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2711  7, 0, 9, 0, 0, 0, 10, 11, 61, 200,
2712  63, 12, 0, 13, 14, 15, 231, 232, 18, 19,
2713  0, 0, 0, 0, 0, 233, 234, 235, 23, 24,
2714  25, 26, 0, 0, 194, 0, 0, 0, 0, 0,
2715  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2716  38, 39, 40, 195, 41, 42, 0, 43, 44, 45,
2717  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2718  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2719  0, 196, 0, 0, 197, 50, 0, 51, 52, 0,
2720  0, 0, 54, 55, 56, 57, 58, 59, 60, 0,
2721  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2722  0, 9, 0, 0, 0, 10, 11, 61, 200, 63,
2723  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2724  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2725  26, 0, 0, 194, 0, 0, 0, 0, 0, 0,
2726  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2727  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2728  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2729  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2730  196, 0, 0, 197, 50, 0, 51, 52, 0, 484,
2731  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2732  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2733  9, 0, 0, 0, 10, 11, 61, 200, 63, 12,
2734  0, 13, 14, 15, 231, 232, 18, 19, 0, 0,
2735  0, 0, 0, 233, 234, 235, 23, 24, 25, 26,
2736  0, 0, 194, 0, 0, 0, 0, 0, 0, 29,
2737  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2738  40, 0, 41, 42, 0, 43, 44, 45, 0, 46,
2739  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2740  0, 0, 0, 0, 0, 0, 0, 0, 0, 196,
2741  0, 0, 197, 50, 0, 51, 52, 0, 198, 0,
2742  54, 55, 56, 57, 58, 59, 60, 0, 0, 0,
2743  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2744  0, 0, 0, 10, 11, 61, 200, 63, 12, 0,
2745  13, 14, 15, 231, 232, 18, 19, 0, 0, 0,
2746  0, 0, 233, 234, 235, 23, 24, 25, 26, 0,
2747  0, 194, 0, 0, 0, 0, 0, 0, 29, 0,
2748  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2749  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2750  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2751  0, 0, 0, 0, 0, 0, 0, 0, 196, 0,
2752  0, 197, 50, 0, 51, 52, 0, 772, 0, 54,
2753  55, 56, 57, 58, 59, 60, 0, 0, 0, 0,
2754  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2755  0, 0, 10, 11, 61, 200, 63, 12, 0, 13,
2756  14, 15, 231, 232, 18, 19, 0, 0, 0, 0,
2757  0, 233, 234, 235, 23, 24, 25, 26, 0, 0,
2758  194, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2759  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2760  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2761  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2762  0, 0, 0, 0, 0, 0, 0, 196, 0, 0,
2763  197, 50, 0, 51, 52, 0, 484, 0, 54, 55,
2764  56, 57, 58, 59, 60, 0, 0, 0, 0, 0,
2765  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2766  0, 10, 11, 61, 200, 63, 12, 0, 13, 14,
2767  15, 231, 232, 18, 19, 0, 0, 0, 0, 0,
2768  233, 234, 235, 23, 24, 25, 26, 0, 0, 194,
2769  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
2770  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2771  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2772  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2773  0, 0, 0, 0, 0, 0, 196, 0, 0, 197,
2774  50, 0, 51, 52, 0, 587, 0, 54, 55, 56,
2775  57, 58, 59, 60, 0, 0, 0, 0, 0, 0,
2776  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2777  10, 11, 61, 200, 63, 12, 0, 13, 14, 15,
2778  231, 232, 18, 19, 0, 0, 0, 0, 0, 233,
2779  234, 235, 23, 24, 25, 26, 0, 0, 194, 0,
2780  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2781  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2782  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2783  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2784  0, 0, 0, 0, 0, 196, 0, 0, 197, 50,
2785  0, 51, 52, 0, 0, 0, 54, 55, 56, 57,
2786  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2787  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2788  11, 61, 200, 63, 12, 0, 13, 14, 15, 16,
2789  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2790  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2791  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2792  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2793  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2794  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2795  0, 0, 0, 0, 196, 0, 0, 197, 50, 0,
2796  51, 52, 0, 0, 0, 54, 55, 56, 57, 58,
2797  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2798  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2799  61, 62, 63, 12, 0, 13, 14, 15, 16, 17,
2800  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2801  23, 24, 25, 26, 0, 0, 194, 0, 0, 0,
2802  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2803  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2804  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2805  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2806  0, 0, 0, 196, 0, 0, 197, 50, 0, 51,
2807  52, 0, 0, 0, 54, 55, 56, 57, 58, 59,
2808  60, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2809  6, 7, 0, 9, 0, 0, 0, 10, 11, 61,
2810  200, 63, 12, 0, 13, 14, 15, 231, 232, 18,
2811  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2812  24, 25, 26, 0, 0, 194, 0, 0, 0, 0,
2813  0, 0, 258, 0, 0, 32, 33, 34, 35, 36,
2814  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2815  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2816  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2817  0, 0, 259, 0, 0, 304, 50, 0, 51, 52,
2818  0, 305, 0, 54, 55, 56, 57, 58, 59, 60,
2819  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2820  0, 0, 10, 11, 0, 0, 0, 12, 260, 13,
2821  14, 15, 231, 232, 18, 19, 0, 0, 0, 0,
2822  0, 233, 234, 235, 23, 24, 25, 26, 0, 0,
2823  194, 0, 0, 0, 0, 0, 0, 258, 0, 0,
2824  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2825  41, 42, 0, 43, 44, 45, 0, 0, 0, 0,
2826  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2827  0, 0, 0, 0, 0, 0, 0, 346, 0, 0,
2828  49, 50, 0, 51, 52, 0, 53, 0, 54, 55,
2829  56, 57, 58, 59, 60, 0, 0, 0, 0, 5,
2830  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
2831  0, 0, 12, 260, 13, 14, 15, 231, 232, 18,
2832  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2833  24, 25, 26, 0, 0, 194, 0, 0, 0, 0,
2834  0, 0, 258, 0, 0, 32, 33, 34, 354, 36,
2835  37, 38, 355, 40, 0, 41, 42, 0, 43, 44,
2836  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2837  0, 0, 0, 0, 0, 0, 0, 0, 0, 356,
2838  0, 0, 357, 0, 0, 197, 50, 0, 51, 52,
2839  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2840  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2841  0, 0, 10, 11, 0, 0, 0, 12, 260, 13,
2842  14, 15, 231, 232, 18, 19, 0, 0, 0, 0,
2843  0, 233, 234, 235, 23, 24, 25, 26, 0, 0,
2844  194, 0, 0, 0, 0, 0, 0, 258, 0, 0,
2845  32, 33, 34, 354, 36, 37, 38, 355, 40, 0,
2846  41, 42, 0, 43, 44, 45, 0, 0, 0, 0,
2847  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2848  0, 0, 0, 0, 0, 0, 0, 357, 0, 0,
2849  197, 50, 0, 51, 52, 0, 0, 0, 54, 55,
2850  56, 57, 58, 59, 60, 0, 0, 0, 0, 5,
2851  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
2852  0, 0, 12, 260, 13, 14, 15, 231, 232, 18,
2853  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2854  24, 25, 26, 0, 0, 194, 0, 0, 0, 0,
2855  0, 0, 258, 0, 0, 32, 33, 34, 35, 36,
2856  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2857  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2858  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2859  0, 0, 259, 0, 0, 304, 50, 0, 51, 52,
2860  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2861  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2862  0, 0, 10, 11, 0, 0, 0, 12, 260, 13,
2863  14, 15, 231, 232, 18, 19, 0, 0, 0, 0,
2864  0, 233, 234, 235, 23, 24, 25, 26, 0, 0,
2865  194, 0, 0, 0, 0, 0, 0, 258, 0, 0,
2866  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2867  41, 42, 0, 43, 44, 45, 0, 0, 0, 0,
2868  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2869  0, 0, 0, 0, 0, 0, 0, 902, 0, 0,
2870  197, 50, 0, 51, 52, 0, 0, 0, 54, 55,
2871  56, 57, 58, 59, 60, 0, 0, 0, 0, 5,
2872  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
2873  0, 0, 12, 260, 13, 14, 15, 231, 232, 18,
2874  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2875  24, 25, 26, 0, 0, 194, 0, 663, 0, 0,
2876  0, 0, 258, 0, 0, 32, 33, 34, 35, 36,
2877  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2878  45, 308, 309, 310, 311, 312, 313, 314, 315, 316,
2879  317, 318, 319, 320, 0, 0, 321, 322, 0, 0,
2880  0, 0, 912, 0, 0, 197, 50, 0, 51, 52,
2881  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2882  0, 0, 0, 323, 0, 324, 325, 326, 327, 328,
2883  329, 330, 331, 332, 333, 0, 0, 0, 260, 0,
2884  525, 526, 0, 0, 527, 0, 0, 0, 0, 0,
2885  0, 0, 0, -241, 157, 158, 159, 160, 161, 162,
2886  163, 164, 165, 0, 0, 166, 167, 0, 0, 168,
2887  169, 170, 171, 0, 0, 0, 0, 0, 0, 0,
2888  0, 0, 0, 172, 0, 0, 0, 0, 0, 0,
2889  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2890  173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
2891  0, 183, 184, 0, 0, 0, 0, 533, 534, 0,
2892  0, 535, 0, 0, 0, 0, 0, 0, 0, 185,
2893  220, 157, 158, 159, 160, 161, 162, 163, 164, 165,
2894  0, 0, 166, 167, 0, 0, 168, 169, 170, 171,
2895  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2896  172, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2897  0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
2898  176, 177, 178, 179, 180, 181, 182, 0, 183, 184,
2899  0, 0, 0, 0, 591, 526, 0, 0, 592, 0,
2900  0, 0, 0, 0, 0, 0, 185, 220, 157, 158,
2901  159, 160, 161, 162, 163, 164, 165, 0, 0, 166,
2902  167, 0, 0, 168, 169, 170, 171, 0, 0, 0,
2903  0, 0, 0, 0, 0, 0, 0, 172, 0, 0,
2904  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2905  0, 0, 0, 0, 173, 174, 175, 176, 177, 178,
2906  179, 180, 181, 182, 0, 183, 184, 0, 0, 0,
2907  0, 594, 534, 0, 0, 595, 0, 0, 0, 0,
2908  0, 0, 0, 185, 220, 157, 158, 159, 160, 161,
2909  162, 163, 164, 165, 0, 0, 166, 167, 0, 0,
2910  168, 169, 170, 171, 0, 0, 0, 0, 0, 0,
2911  0, 0, 0, 0, 172, 0, 0, 0, 0, 0,
2912  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2913  0, 173, 174, 175, 176, 177, 178, 179, 180, 181,
2914  182, 0, 183, 184, 0, 0, 0, 0, 617, 526,
2915  0, 0, 618, 0, 0, 0, 0, 0, 0, 0,
2916  185, 220, 157, 158, 159, 160, 161, 162, 163, 164,
2917  165, 0, 0, 166, 167, 0, 0, 168, 169, 170,
2918  171, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2919  0, 172, 0, 0, 0, 0, 0, 0, 0, 0,
2920  0, 0, 0, 0, 0, 0, 0, 0, 173, 174,
2921  175, 176, 177, 178, 179, 180, 181, 182, 0, 183,
2922  184, 0, 0, 0, 0, 620, 534, 0, 0, 621,
2923  0, 0, 0, 0, 0, 0, 0, 185, 220, 157,
2924  158, 159, 160, 161, 162, 163, 164, 165, 0, 0,
2925  166, 167, 0, 0, 168, 169, 170, 171, 0, 0,
2926  0, 0, 0, 0, 0, 0, 0, 0, 172, 0,
2927  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2928  0, 0, 0, 0, 0, 173, 174, 175, 176, 177,
2929  178, 179, 180, 181, 182, 0, 183, 184, 0, 0,
2930  0, 0, 692, 526, 0, 0, 693, 0, 0, 0,
2931  0, 0, 0, 0, 185, 220, 157, 158, 159, 160,
2932  161, 162, 163, 164, 165, 0, 0, 166, 167, 0,
2933  0, 168, 169, 170, 171, 0, 0, 0, 0, 0,
2934  0, 0, 0, 0, 0, 172, 0, 0, 0, 0,
2935  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2936  0, 0, 173, 174, 175, 176, 177, 178, 179, 180,
2937  181, 182, 0, 183, 184, 0, 0, 0, 0, 695,
2938  534, 0, 0, 696, 0, 0, 0, 0, 0, 0,
2939  0, 185, 220, 157, 158, 159, 160, 161, 162, 163,
2940  164, 165, 0, 0, 166, 167, 0, 0, 168, 169,
2941  170, 171, 0, 0, 0, 0, 0, 0, 0, 0,
2942  0, 0, 172, 0, 0, 0, 0, 0, 0, 0,
2943  0, 0, 0, 0, 0, 0, 0, 0, 0, 173,
2944  174, 175, 176, 177, 178, 179, 180, 181, 182, 0,
2945  183, 184, 0, 0, 0, 0, 702, 526, 0, 0,
2946  703, 0, 0, 0, 0, 0, 0, 0, 185, 220,
2947  157, 158, 159, 160, 161, 162, 163, 164, 165, 0,
2948  0, 166, 167, 0, 0, 168, 169, 170, 171, 0,
2949  0, 0, 0, 0, 0, 0, 0, 0, 0, 172,
2950  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2951  0, 0, 0, 0, 0, 0, 173, 174, 175, 176,
2952  177, 178, 179, 180, 181, 182, 0, 183, 184, 0,
2953  0, 0, 0, 572, 534, 0, 0, 573, 0, 0,
2954  0, 0, 0, 0, 0, 185, 220, 157, 158, 159,
2955  160, 161, 162, 163, 164, 165, 0, 0, 166, 167,
2956  0, 0, 168, 169, 170, 171, 0, 0, 0, 0,
2957  0, 0, 0, 0, 0, 0, 172, 0, 0, 0,
2958  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2959  0, 0, 0, 173, 174, 175, 176, 177, 178, 179,
2960  180, 181, 182, 0, 183, 184, 0, 0, 0, 0,
2961  965, 526, 0, 0, 966, 0, 0, 0, 0, 0,
2962  0, 0, 185, 220, 157, 158, 159, 160, 161, 162,
2963  163, 164, 165, 0, 0, 166, 167, 0, 0, 168,
2964  169, 170, 171, 0, 0, 0, 0, 0, 0, 0,
2965  0, 0, 0, 172, 0, 0, 0, 0, 0, 0,
2966  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2967  173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
2968  0, 183, 184, 0, 0, 0, 0, 971, 526, 0,
2969  0, 972, 0, 0, 0, 0, 0, 0, 0, 185,
2970  220, 157, 158, 159, 160, 161, 162, 163, 164, 165,
2971  0, 0, 166, 167, 0, 0, 168, 169, 170, 171,
2972  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2973  172, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2974  0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
2975  176, 177, 178, 179, 180, 181, 182, 0, 183, 184,
2976  0, 0, 0, 0, 974, 534, 0, 0, 975, 0,
2977  0, 0, 0, 0, 0, 0, 185, 220, 157, 158,
2978  159, 160, 161, 162, 163, 164, 165, 0, 0, 166,
2979  167, 0, 0, 168, 169, 170, 171, 0, 0, 0,
2980  0, 0, 0, 0, 0, 0, 0, 172, 0, 0,
2981  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2982  0, 0, 0, 0, 173, 174, 175, 176, 177, 178,
2983  179, 180, 181, 182, 0, 183, 184, 0, 0, 0,
2984  0, 572, 534, 0, 0, 573, 0, 0, 0, 0,
2985  0, 0, 0, 185, 220, 157, 158, 159, 160, 161,
2986  162, 163, 164, 165, 0, 0, 166, 167, 0, 0,
2987  168, 169, 170, 171, 0, 0, 0, 0, 0, 0,
2988  0, 0, 0, 0, 172, 0, 0, 0, 0, 0,
2989  0, 0, 718, 0, 0, 0, 0, 0, 0, 0,
2990  0, 173, 174, 175, 176, 177, 178, 179, 180, 181,
2991  182, 663, 183, 184, 0, 0, 308, 309, 310, 311,
2992  312, 313, 314, 315, 316, 317, 318, 319, 320, 0,
2993  185, 321, 322, 0, 0, 308, 309, 310, 311, 312,
2994  313, 314, 315, 316, 317, 318, 319, 320, 0, 0,
2995  321, 322, 0, 0, 0, 0, 0, 0, 323, 0,
2996  324, 325, 326, 327, 328, 329, 330, 331, 332, 333,
2997  0, 0, 0, 0, 0, 0, 0, 323, 0, 324,
2998  325, 326, 327, 328, 329, 330, 331, 332, 333
2999 };
3000 
3001 #define yypact_value_is_default(yystate) \
3002  ((yystate) == (-747))
3003 
3004 #define yytable_value_is_error(yytable_value) \
3005  ((yytable_value) == (-574))
3006 
3007 static const yytype_int16 yycheck[] =
3008 {
3009  2, 55, 340, 28, 2, 454, 4, 52, 593, 16,
3010  17, 335, 307, 20, 307, 8, 547, 213, 16, 17,
3011  8, 566, 20, 27, 53, 29, 84, 22, 8, 87,
3012  546, 87, 4, 22, 619, 28, 49, 91, 252, 76,
3013  28, 2, 256, 4, 404, 357, 1, 65, 28, 51,
3014  52, 49, 50, 749, 450, 53, 746, 13, 334, 627,
3015  336, 53, 680, 25, 62, 762, 684, 454, 13, 16,
3016  17, 65, 26, 20, 396, 55, 400, 26, 76, 25,
3017  440, 0, 404, 27, 76, 83, 84, 576, 577, 87,
3018  88, 89, 90, 87, 490, 29, 88, 89, 90, 13,
3019  242, 25, 378, 379, 51, 851, 828, 85, 76, 694,
3020  136, 91, 87, 16, 17, 110, 147, 20, 85, 568,
3021  705, 110, 146, 399, 25, 401, 85, 653, 452, 61,
3022  87, 16, 17, 62, 109, 20, 276, 25, 278, 56,
3023  280, 13, 742, 37, 38, 87, 114, 109, 51, 52,
3024  195, 427, 109, 198, 199, 826, 701, 28, 113, 849,
3025  138, 139, 304, 763, 709, 140, 25, 109, 736, 737,
3026  25, 13, 139, 107, 106, 146, 13, 453, 140, 138,
3027  139, 143, 136, 632, 140, 147, 109, 136, 244, 145,
3028  145, 147, 147, 142, 140, 941, 892, 142, 140, 197,
3029  145, 145, 147, 147, 653, 207, 896, 904, 930, 140,
3030  217, 213, 219, 220, 25, 886, 140, 413, 220, 217,
3031  746, 219, 220, 749, 261, 223, 244, 225, 552, 242,
3032  719, 145, 230, 147, 50, 293, 294, 295, 296, 140,
3033  564, 601, 142, 241, 242, 632, 235, 147, 109, 238,
3034  244, 563, 140, 147, 258, 873, 99, 302, 826, 708,
3035  828, 932, 307, 261, 25, 661, 87, 83, 84, 261,
3036  217, 87, 219, 145, 140, 147, 305, 553, 600, 601,
3037  241, 140, 25, 341, 342, 140, 25, 343, 959, 565,
3038  806, 304, 85, 87, 292, 293, 294, 295, 296, 297,
3039  298, 299, 85, 145, 302, 147, 304, 305, 145, 307,
3040  147, 59, 60, 305, 217, 109, 219, 26, 886, 887,
3041  292, 708, 109, 849, 142, 851, 49, 467, 335, 140,
3042  875, 292, 217, 335, 219, 56, 297, 335, 145, 337,
3043  147, 87, 873, 341, 342, 138, 139, 336, 88, 343,
3044  395, 396, 690, 140, 334, 302, 139, 26, 356, 404,
3045  307, 140, 930, 109, 932, 359, 892, 85, 147, 662,
3046  109, 85, 109, 302, 61, 26, 85, 140, 307, 140,
3047  15, 142, 17, 928, 679, 87, 384, 385, 973, 85,
3048  85, 959, 437, 400, 590, 440, 421, 140, 400, 142,
3049  614, 140, 400, 85, 143, 140, 85, 223, 147, 225,
3050  412, 413, 401, 450, 142, 941, 85, 104, 105, 399,
3051  138, 139, 424, 136, 142, 139, 424, 136, 421, 138,
3052  139, 880, 85, 421, 85, 433, 85, 142, 427, 484,
3053  140, 421, 138, 139, 139, 452, 426, 147, 85, 142,
3054  452, 85, 450, 490, 452, 384, 385, 139, 450, 146,
3055  139, 85, 822, 424, 453, 68, 85, 136, 85, 138,
3056  139, 451, 433, 142, 197, 87, 85, 293, 294, 295,
3057  296, 483, 298, 299, 68, 136, 139, 138, 139, 138,
3058  139, 142, 490, 396, 85, 37, 38, 109, 490, 668,
3059  822, 223, 139, 548, 138, 139, 675, 230, 109, 52,
3060  514, 54, 55, 56, 57, 139, 119, 120, 121, 242,
3061  139, 138, 139, 861, 246, 341, 342, 143, 532, 867,
3062  139, 26, 728, 52, 437, 530, 538, 56, 540, 85,
3063  356, 530, 587, 538, 542, 552, 544, 138, 139, 538,
3064  552, 545, 546, 56, 552, 600, 601, 564, 85, 584,
3065  59, 60, 564, 144, 553, 559, 564, 137, 566, 567,
3066  106, 551, 574, 575, 576, 577, 565, 87, 615, 574,
3067  575, 304, 140, 563, 106, 574, 575, 87, 590, 593,
3068  85, 584, 138, 139, 87, 85, 584, 140, 68, 109,
3069  68, 548, 14, 15, 584, 85, 604, 609, 85, 109,
3070  140, 138, 139, 658, 17, 619, 109, 615, 56, 608,
3071  609, 574, 575, 615, 661, 145, 25, 951, 52, 94,
3072  54, 55, 56, 57, 679, 143, 638, 146, 640, 697,
3073  642, 136, 700, 138, 139, 137, 140, 142, 138, 139,
3074  52, 653, 54, 55, 56, 57, 654, 711, 138, 139,
3075  10, 138, 139, 661, 662, 89, 61, 665, 666, 661,
3076  65, 95, 96, 671, 672, 109, 952, 679, 680, 140,
3077  682, 140, 684, 140, 406, 140, 140, 89, 410, 734,
3078  694, 140, 116, 415, 96, 119, 8, 600, 13, 697,
3079  87, 705, 700, 701, 698, 61, 87, 137, 430, 104,
3080  105, 709, 109, 435, 116, 54, 710, 719, 716, 717,
3081  140, 145, 109, 140, 63, 64, 728, 772, 109, 140,
3082  68, 711, 679, 662, 87, 52, 665, 666, 796, 52,
3083  742, 111, 671, 672, 140, 743, 744, 87, 104, 105,
3084  106, 567, 144, 140, 549, 15, 109, 755, 803, 140,
3085  2, 763, 4, 765, 87, 767, 768, 489, 52, 109,
3086  54, 55, 56, 57, 16, 17, 140, 822, 20, 117,
3087  118, 119, 120, 121, 145, 783, 109, 140, 604, 791,
3088  109, 140, 794, 114, 140, 793, 140, 140, 796, 10,
3089  140, 88, 800, 801, 140, 9, 804, 49, 50, 10,
3090  137, 140, 806, 10, 808, 61, 140, 140, 140, 542,
3091  62, 544, 820, 137, 140, 114, 52, 137, 54, 55,
3092  56, 57, 834, 835, 140, 837, 68, 839, 840, 140,
3093  140, 83, 84, 137, 842, 87, 56, 140, 140, 68,
3094  842, 83, 84, 56, 783, 140, 140, 140, 104, 105,
3095  106, 140, 860, 89, 83, 84, 864, 140, 860, 95,
3096  96, 873, 142, 142, 61, 140, 424, 875, 90, 88,
3097  61, 697, 954, 736, 700, 117, 118, 119, 120, 121,
3098  116, 93, 904, 119, 689, 114, 115, 116, 117, 118,
3099  119, 120, 121, 953, 906, 907, 908, 96, 910, 911,
3100  640, 706, 642, 57, 91, 880, 142, 104, 105, 106,
3101  918, 849, 920, 104, 105, 106, 653, 746, 926, -1,
3102  928, 654, 934, 935, 936, 937, 52, -1, 54, 55,
3103  56, 57, -1, -1, 951, -1, -1, 54, 55, 951,
3104  57, 953, 954, 951, -1, 197, 63, 64, -1, 939,
3105  -1, -1, -1, 952, -1, 967, 968, 969, 970, 973,
3106  950, -1, -1, 89, -1, 217, -1, 219, 220, 981,
3107  796, 223, -1, 225, -1, 707, -1, 989, 230, -1,
3108  -1, -1, -1, 716, 717, 68, -1, -1, -1, 241,
3109  242, -1, 797, -1, 799, -1, -1, 729, -1, -1,
3110  83, 84, -1, -1, 809, -1, -1, -1, 740, 814,
3111  743, 744, 749, -1, 52, 752, 54, 55, 56, 57,
3112  -1, -1, 755, -1, -1, 765, -1, 767, 768, -1,
3113  -1, -1, -1, 116, 117, 118, 119, 120, 121, -1,
3114  292, 293, 294, 295, 296, 297, 298, 299, -1, -1,
3115  302, 89, 304, -1, -1, 307, -1, 95, -1, 52,
3116  793, 54, 55, 56, 57, 870, 871, 800, 801, -1,
3117  -1, 804, 16, 17, -1, -1, 20, -1, -1, -1,
3118  -1, 813, -1, 335, -1, 337, -1, 820, -1, 341,
3119  342, -1, -1, 825, 834, 835, -1, 837, 830, 839,
3120  840, -1, 46, 47, 356, -1, -1, 51, 52, -1,
3121  -1, -1, -1, -1, 851, -1, 853, -1, 62, 63,
3122  -1, 52, 927, 54, 55, 56, 57, -1, -1, -1,
3123  -1, 864, 384, 385, 40, 41, 42, 43, 44, -1,
3124  -1, -1, -1, -1, -1, -1, -1, -1, 400, -1,
3125  955, -1, 957, -1, -1, 892, -1, 894, 89, -1,
3126  -1, 898, -1, -1, 95, -1, 906, 907, 908, -1,
3127  910, 911, 424, 52, -1, 54, 55, 56, 57, -1,
3128  -1, 433, -1, -1, -1, 918, -1, 920, -1, -1,
3129  -1, -1, -1, 926, 934, 935, 936, 937, -1, -1,
3130  452, -1, -1, -1, 941, -1, 943, -1, -1, 946,
3131  89, -1, -1, -1, -1, -1, 95, 96, -1, -1,
3132  -1, -1, -1, -1, 961, -1, -1, 967, 968, 969,
3133  970, -1, -1, -1, -1, -1, -1, 116, -1, -1,
3134  119, 981, -1, -1, -1, -1, 983, -1, -1, 989,
3135  -1, 195, -1, -1, 198, 199, 200, -1, -1, -1,
3136  2, -1, 4, 142, -1, 52, -1, 54, 55, 56,
3137  57, -1, -1, 217, -1, 219, 220, -1, -1, -1,
3138  -1, 2, -1, 4, -1, -1, -1, -1, -1, -1,
3139  542, -1, 544, 52, -1, 54, 55, 56, 57, -1,
3140  552, -1, 89, -1, -1, -1, -1, 49, 95, 96,
3141  -1, 53, 564, -1, 566, 567, -1, -1, -1, -1,
3142  -1, -1, -1, -1, -1, -1, -1, -1, 49, 116,
3143  89, -1, 119, -1, 76, -1, 95, 96, -1, -1,
3144  -1, -1, -1, -1, -1, -1, 88, 89, 90, 91,
3145  -1, -1, 604, -1, -1, -1, -1, 116, 302, -1,
3146  119, -1, -1, 307, 308, 309, 310, 311, 312, 313,
3147  314, 315, 316, 317, 318, 319, 320, 321, 322, 323,
3148  324, 325, 326, 327, 328, 329, 330, 331, 332, 333,
3149  -1, 335, -1, -1, -1, -1, -1, -1, -1, -1,
3150  -1, -1, 654, -1, -1, -1, -1, -1, -1, -1,
3151  662, -1, -1, 665, 666, -1, -1, -1, -1, 671,
3152  672, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3153  76, 77, 78, 79, 80, -1, -1, 83, 84, -1,
3154  384, 385, -1, -1, -1, 697, -1, -1, 700, 701,
3155  394, 395, 396, -1, -1, 197, 400, 709, 402, 403,
3156  404, -1, -1, -1, 716, 717, 112, 113, 114, 115,
3157  116, 117, 118, 119, 120, 121, 197, -1, -1, 423,
3158  -1, -1, -1, -1, 428, -1, -1, -1, 230, -1,
3159  -1, 743, 744, 437, -1, -1, 440, -1, -1, 241,
3160  242, -1, -1, 755, -1, -1, -1, -1, 452, 230,
3161  -1, -1, -1, -1, -1, -1, -1, -1, -1, 261,
3162  241, 242, -1, -1, -1, -1, -1, -1, 472, 473,
3163  -1, 783, -1, -1, -1, -1, -1, -1, -1, -1,
3164  484, 793, -1, -1, 796, -1, -1, -1, 800, 801,
3165  292, -1, 804, -1, -1, 297, -1, -1, -1, -1,
3166  -1, -1, 304, 305, -1, -1, -1, 2, 820, 4,
3167  -1, 292, -1, -1, -1, -1, 297, -1, -1, -1,
3168  -1, -1, -1, 304, -1, -1, -1, -1, -1, -1,
3169  -1, -1, -1, -1, -1, 337, -1, 2, -1, 4,
3170  -1, -1, -1, -1, 548, -1, -1, -1, 552, -1,
3171  -1, -1, 864, -1, 49, 2, 337, 4, 53, -1,
3172  564, -1, -1, 875, -1, -1, -1, -1, -1, -1,
3173  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3174  -1, 76, -1, 587, 49, -1, -1, -1, 53, -1,
3175  -1, -1, -1, 88, 89, 90, 600, 601, -1, -1,
3176  -1, -1, 49, -1, -1, -1, 918, -1, 920, -1,
3177  -1, 76, -1, -1, 926, -1, 928, -1, -1, -1,
3178  -1, -1, 424, 88, 89, 90, 91, -1, -1, -1,
3179  -1, 433, -1, -1, -1, -1, -1, -1, -1, 951,
3180  -1, 88, -1, 424, -1, -1, -1, -1, 450, -1,
3181  -1, -1, 433, -1, 658, -1, -1, -1, 662, 663,
3182  -1, 665, 666, -1, -1, -1, -1, 671, 672, 0,
3183  -1, -1, -1, -1, -1, 679, -1, 8, 9, 10,
3184  -1, -1, 13, 14, 15, -1, 17, -1, 490, -1,
3185  -1, -1, -1, -1, -1, -1, 27, -1, -1, -1,
3186  -1, -1, 197, -1, -1, -1, 37, 38, -1, 40,
3187  41, 42, 43, 44, 718, -1, -1, -1, -1, 723,
3188  724, -1, 726, 727, -1, -1, -1, -1, -1, -1,
3189  734, -1, 197, -1, -1, 230, -1, -1, -1, -1,
3190  542, -1, 544, -1, -1, -1, 241, 242, -1, -1,
3191  197, -1, -1, -1, 85, -1, -1, -1, -1, -1,
3192  -1, 542, -1, 544, 566, 230, 261, -1, 772, -1,
3193  -1, -1, 776, -1, -1, -1, 241, 242, -1, 783,
3194  -1, -1, -1, 230, -1, 566, -1, -1, -1, -1,
3195  -1, -1, -1, -1, 241, 242, 261, 292, -1, 803,
3196  -1, -1, 297, -1, -1, -1, 137, -1, 139, 304,
3197  305, 142, 143, 615, 145, -1, 147, 821, 822, -1,
3198  -1, -1, -1, -1, -1, -1, -1, 292, -1, -1,
3199  -1, -1, 297, -1, -1, -1, -1, -1, -1, 304,
3200  305, -1, 337, -1, -1, 292, -1, -1, -1, -1,
3201  297, -1, 654, -1, -1, -1, -1, 304, -1, 661,
3202  307, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3203  -1, -1, 337, 654, -1, -1, -1, -1, -1, -1,
3204  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3205  337, -1, -1, -1, -1, -1, -1, -1, -1, 701,
3206  -1, -1, -1, -1, -1, -1, -1, 709, -1, -1,
3207  -1, -1, -1, -1, 716, 717, -1, -1, -1, -1,
3208  701, -1, -1, -1, -1, -1, -1, -1, 709, 424,
3209  -1, -1, -1, -1, -1, 716, 717, -1, 433, -1,
3210  -1, 743, 744, -1, -1, -1, -1, 951, -1, -1,
3211  -1, -1, -1, 755, -1, 450, -1, -1, -1, 424,
3212  -1, -1, 743, 744, -1, -1, -1, -1, 433, -1,
3213  -1, -1, -1, -1, 755, -1, -1, 424, -1, -1,
3214  -1, -1, -1, -1, -1, 450, 433, -1, -1, -1,
3215  -1, 793, -1, -1, -1, 490, -1, -1, 800, 801,
3216  -1, -1, 804, -1, -1, -1, -1, -1, -1, -1,
3217  -1, -1, 793, -1, -1, -1, -1, -1, 820, 800,
3218  801, -1, -1, 804, -1, 490, -1, -1, -1, -1,
3219  -1, -1, -1, -1, -1, -1, -1, -1, -1, 820,
3220  842, -1, -1, -1, -1, -1, -1, 542, -1, 544,
3221  -1, -1, -1, -1, -1, -1, -1, -1, 860, -1,
3222  -1, -1, 864, -1, -1, -1, -1, -1, -1, -1,
3223  -1, 566, -1, 875, -1, -1, -1, 542, -1, 544,
3224  -1, -1, -1, 864, -1, -1, -1, -1, -1, -1,
3225  -1, -1, -1, -1, 875, 542, -1, 544, -1, -1,
3226  -1, 566, -1, -1, -1, -1, -1, -1, -1, -1,
3227  -1, -1, -1, -1, -1, -1, 918, -1, 920, 566,
3228  615, -1, -1, -1, 926, -1, 928, -1, -1, -1,
3229  -1, -1, -1, -1, -1, -1, -1, 918, -1, 920,
3230  -1, -1, -1, -1, -1, 926, -1, 928, -1, -1,
3231  615, 646, -1, -1, -1, -1, -1, -1, -1, 654,
3232  -1, -1, -1, -1, -1, -1, 661, -1, -1, -1,
3233  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3234  -1, -1, 68, 69, 70, 71, 72, 73, 74, 654,
3235  -1, 77, 78, -1, -1, -1, 661, 83, 84, -1,
3236  -1, -1, -1, -1, -1, -1, 701, 654, -1, -1,
3237  -1, -1, -1, -1, 709, 662, -1, -1, -1, -1,
3238  -1, 716, 717, -1, -1, -1, 112, 113, 114, 115,
3239  116, 117, 118, 119, 120, 121, 701, -1, -1, -1,
3240  -1, -1, -1, -1, 709, -1, -1, -1, 743, 744,
3241  -1, 716, 717, -1, 701, -1, -1, -1, -1, -1,
3242  755, -1, 709, -1, -1, -1, -1, -1, -1, 716,
3243  717, 68, 69, 70, 71, 72, 73, 74, 743, 744,
3244  77, 78, -1, -1, -1, -1, 83, 84, -1, -1,
3245  755, -1, -1, -1, -1, -1, 743, 744, 793, -1,
3246  -1, -1, -1, -1, -1, 800, 801, -1, 755, 804,
3247  -1, -1, -1, -1, -1, 112, 113, 114, 115, 116,
3248  117, 118, 119, 120, 121, 820, -1, -1, 793, -1,
3249  -1, -1, -1, -1, -1, 800, 801, -1, -1, 804,
3250  -1, -1, -1, -1, -1, -1, 793, 842, -1, -1,
3251  -1, -1, -1, 800, 801, 820, -1, 804, -1, -1,
3252  -1, -1, -1, -1, -1, 860, -1, -1, -1, 864,
3253  -1, -1, -1, 820, -1, -1, -1, 842, -1, -1,
3254  875, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3255  -1, -1, -1, -1, -1, 860, -1, -1, -1, 864,
3256  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3257  875, -1, -1, 860, -1, -1, -1, 864, -1, -1,
3258  -1, -1, -1, 918, -1, 920, -1, -1, 875, -1,
3259  -1, 926, -1, 928, -1, -1, -1, -1, -1, -1,
3260  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3261  -1, -1, -1, 918, -1, 920, -1, -1, -1, -1,
3262  -1, 926, -1, 928, -1, -1, -1, -1, -1, -1,
3263  -1, 918, -1, 920, -1, -1, -1, -1, -1, 926,
3264  -1, 928, 0, 1, -1, 3, 4, 5, 6, 7,
3265  -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
3266  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3267  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3268  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3269  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3270  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3271  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3272  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3273  -1, 89, 90, -1, 92, 93, -1, 95, -1, 97,
3274  98, 99, 100, 101, 102, 103, -1, -1, -1, -1,
3275  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3276  -1, -1, -1, 0, 122, 123, 124, -1, -1, -1,
3277  -1, 8, 9, 10, -1, -1, 13, 14, 15, -1,
3278  17, -1, -1, -1, -1, -1, -1, 145, -1, 147,
3279  27, 28, 29, -1, -1, -1, -1, -1, -1, -1,
3280  37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
3281  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
3282  74, 75, 76, 77, 78, 79, 80, -1, -1, 83,
3283  84, 68, 69, 70, 71, 72, 73, 74, 75, 76,
3284  77, 78, 79, 80, -1, -1, 83, 84, 85, -1,
3285  87, 88, -1, -1, -1, -1, 110, 94, 112, 113,
3286  114, 115, 116, 117, 118, 119, 120, 121, -1, -1,
3287  107, -1, 109, 110, 111, 112, 113, 114, 115, 116,
3288  117, 118, 119, 120, 121, -1, -1, -1, -1, -1,
3289  -1, -1, -1, 147, -1, -1, -1, -1, -1, -1,
3290  137, 138, 139, 140, 0, -1, 143, 144, 145, -1,
3291  147, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3292  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3293  26, 27, 28, -1, -1, -1, -1, -1, -1, -1,
3294  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3295  -1, -1, -1, -1, -1, 68, 69, 70, 71, 72,
3296  73, 74, 75, 76, 77, 78, 79, 80, -1, -1,
3297  83, 84, 68, 69, 70, 71, 72, 73, 74, 75,
3298  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3299  -1, -1, 88, -1, -1, -1, -1, 110, 94, 112,
3300  113, 114, 115, 116, 117, 118, 119, 120, 121, -1,
3301  -1, -1, -1, -1, 110, -1, 112, 113, 114, 115,
3302  116, 117, 118, 119, 120, 121, -1, -1, -1, -1,
3303  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3304  136, 137, 138, 139, 140, 0, 142, 143, 144, 145,
3305  -1, 147, -1, 8, 9, 10, -1, -1, 13, 14,
3306  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3307  -1, -1, 27, 28, 29, -1, -1, -1, -1, -1,
3308  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3309  -1, -1, -1, -1, -1, -1, 68, 69, 70, 71,
3310  72, 73, 74, 75, -1, 77, 78, -1, -1, -1,
3311  -1, 83, 84, 68, 69, 70, 71, 72, 73, 74,
3312  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3313  85, -1, -1, 88, -1, -1, -1, -1, -1, 94,
3314  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
3315  -1, -1, 107, -1, -1, 110, 111, 112, 113, 114,
3316  115, 116, 117, 118, 119, 120, 121, -1, -1, -1,
3317  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3318  -1, -1, 137, 138, 139, 140, 0, -1, 143, 144,
3319  145, -1, 147, -1, 8, 9, 10, -1, -1, 13,
3320  14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
3321  -1, -1, 26, 27, 28, -1, -1, -1, -1, -1,
3322  -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
3323  44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3324  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3325  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
3326  74, 75, 76, 77, 78, 79, 80, -1, -1, 83,
3327  84, 85, -1, -1, 88, -1, -1, -1, -1, -1,
3328  94, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3329  -1, -1, -1, -1, -1, -1, 110, -1, 112, 113,
3330  114, 115, 116, 117, 118, 119, 120, 121, -1, -1,
3331  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3332  -1, -1, 136, 137, 138, 139, 140, 0, 142, 143,
3333  144, 145, -1, 147, -1, 8, 9, 10, -1, -1,
3334  13, 14, 15, -1, 17, -1, -1, -1, -1, -1,
3335  -1, -1, -1, -1, 27, 28, -1, -1, -1, -1,
3336  -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
3337  43, 44, -1, -1, -1, -1, -1, -1, -1, -1,
3338  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3339  -1, -1, -1, -1, -1, 68, 69, 70, 71, 72,
3340  73, 74, 75, 76, 77, 78, 79, 80, -1, -1,
3341  83, 84, 85, -1, -1, 88, -1, -1, -1, -1,
3342  -1, 94, -1, -1, -1, -1, -1, -1, -1, -1,
3343  -1, -1, -1, -1, -1, -1, -1, 110, -1, 112,
3344  113, 114, 115, 116, 117, 118, 119, 120, 121, -1,
3345  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3346  -1, -1, -1, -1, 137, 138, 139, 140, 0, 142,
3347  143, 144, 145, -1, 147, -1, 8, 9, 10, -1,
3348  -1, -1, 14, 15, -1, 17, -1, -1, -1, -1,
3349  -1, -1, -1, -1, 26, -1, -1, -1, -1, -1,
3350  -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
3351  42, 43, 44, -1, -1, -1, -1, -1, -1, -1,
3352  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3353  -1, -1, -1, -1, -1, -1, 68, 69, 70, 71,
3354  72, 73, 74, 75, 76, 77, 78, 79, 80, -1,
3355  -1, 83, 84, 85, 0, 87, -1, -1, -1, -1,
3356  -1, -1, 8, 9, 10, -1, -1, -1, 14, 15,
3357  -1, 17, -1, -1, -1, -1, -1, 109, 110, -1,
3358  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
3359  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3360  -1, -1, -1, -1, 136, 137, 138, 139, 140, -1,
3361  -1, 143, -1, 145, -1, 147, -1, -1, -1, -1,
3362  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3363  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3364  -1, 87, -1, -1, -1, -1, -1, -1, -1, -1,
3365  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3366  -1, -1, -1, 109, 110, -1, 112, 113, 114, 115,
3367  116, 117, 118, 119, 120, 121, -1, -1, -1, -1,
3368  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3369  -1, 137, 138, 139, 140, -1, -1, 143, -1, 145,
3370  1, 147, 3, 4, 5, 6, 7, 8, 9, 10,
3371  11, 12, -1, -1, 15, 16, -1, 18, 19, 20,
3372  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3373  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3374  -1, -1, -1, -1, 45, 46, -1, 48, 49, 50,
3375  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3376  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3377  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3378  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3379  -1, 92, 93, -1, 95, -1, 97, 98, 99, 100,
3380  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3381  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3382  -1, 122, 123, 124, -1, -1, -1, -1, -1, -1,
3383  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3384  -1, -1, -1, -1, 145, 1, 147, 3, 4, 5,
3385  6, 7, -1, -1, 10, 11, 12, -1, 14, 15,
3386  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3387  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3388  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3389  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3390  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3391  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3392  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3393  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3394  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3395  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3396  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3397  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3398  -1, -1, -1, -1, -1, -1, -1, -1, -1, 145,
3399  1, 147, 3, 4, 5, 6, 7, -1, -1, 10,
3400  11, 12, -1, -1, 15, 16, 17, 18, 19, 20,
3401  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3402  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3403  -1, -1, -1, -1, 45, 46, -1, 48, 49, 50,
3404  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3405  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3406  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3407  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3408  -1, 92, 93, -1, 95, -1, 97, 98, 99, 100,
3409  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3410  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3411  -1, 122, 123, 124, -1, -1, -1, -1, -1, -1,
3412  1, -1, 3, 4, 5, 6, 7, -1, -1, -1,
3413  11, 12, -1, -1, 145, 16, 147, 18, 19, 20,
3414  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3415  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3416  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3417  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3418  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3419  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3420  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3421  -1, 92, 93, -1, 95, -1, 97, 98, 99, 100,
3422  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3423  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3424  -1, 122, 123, 124, -1, -1, -1, -1, -1, -1,
3425  -1, -1, -1, -1, -1, -1, 137, -1, -1, -1,
3426  -1, -1, -1, -1, 145, 1, 147, 3, 4, 5,
3427  6, 7, -1, -1, 10, 11, 12, -1, -1, 15,
3428  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3429  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3430  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3431  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3432  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3433  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3434  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3435  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3436  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3437  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3438  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3439  -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
3440  6, 7, -1, 9, 10, 11, 12, -1, -1, 145,
3441  16, 147, 18, 19, 20, 21, 22, 23, 24, -1,
3442  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3443  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3444  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3445  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3446  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3447  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3448  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3449  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3450  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3451  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3452  -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
3453  6, 7, -1, -1, -1, 11, 12, -1, -1, 145,
3454  16, 147, 18, 19, 20, 21, 22, 23, 24, -1,
3455  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3456  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3457  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3458  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3459  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3460  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3461  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3462  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3463  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3464  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3465  -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
3466  6, 7, -1, -1, -1, 11, 12, 143, -1, 145,
3467  16, 147, 18, 19, 20, 21, 22, 23, 24, -1,
3468  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3469  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3470  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3471  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3472  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3473  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3474  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3475  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3476  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3477  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3478  -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
3479  6, 7, -1, -1, -1, 11, 12, 143, -1, 145,
3480  16, 147, 18, 19, 20, 21, 22, 23, 24, -1,
3481  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3482  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3483  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3484  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3485  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3486  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3487  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3488  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3489  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3490  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3491  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3492  -1, 137, -1, -1, -1, -1, -1, -1, -1, 145,
3493  1, 147, 3, 4, 5, 6, 7, -1, -1, 10,
3494  11, 12, -1, -1, -1, 16, -1, 18, 19, 20,
3495  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3496  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3497  -1, -1, -1, -1, 45, 46, -1, 48, 49, 50,
3498  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3499  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3500  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3501  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3502  -1, 92, 93, -1, 95, -1, 97, 98, 99, 100,
3503  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3504  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3505  -1, 122, 123, 124, -1, -1, -1, -1, -1, -1,
3506  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3507  11, 12, -1, -1, 145, 16, 147, 18, 19, 20,
3508  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3509  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3510  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3511  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3512  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3513  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3514  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3515  -1, 92, 93, -1, 95, 96, 97, 98, 99, 100,
3516  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3517  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3518  12, 122, 123, 124, 16, -1, 18, 19, 20, 21,
3519  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3520  32, 33, 34, 35, 36, -1, 147, 39, -1, -1,
3521  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3522  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3523  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3524  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3525  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3526  92, 93, -1, -1, -1, 97, 98, 99, 100, 101,
3527  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3528  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3529  122, 123, 124, -1, -1, -1, -1, -1, -1, -1,
3530  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3531  12, -1, -1, 145, 16, 147, 18, 19, 20, 21,
3532  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3533  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3534  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3535  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3536  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3537  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3538  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3539  92, 93, -1, -1, -1, 97, 98, 99, 100, 101,
3540  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3541  3, 4, 5, 6, 7, -1, -1, -1, 11, 12,
3542  122, 123, 124, 16, -1, 18, 19, 20, 21, 22,
3543  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3544  33, 34, 35, 36, -1, 147, 39, -1, -1, -1,
3545  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3546  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
3547  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3548  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3549  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3550  93, -1, 95, -1, 97, 98, 99, 100, 101, 102,
3551  103, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3552  -1, -1, -1, -1, -1, -1, -1, -1, -1, 122,
3553  123, 124, -1, -1, -1, -1, -1, -1, 3, 4,
3554  5, 6, 7, -1, -1, -1, 11, 12, -1, -1,
3555  -1, 16, 145, 18, 19, 20, 21, 22, 23, 24,
3556  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3557  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3558  45, 46, -1, 48, 49, 50, 51, 52, 53, 54,
3559  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3560  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3561  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3562  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3563  95, -1, 97, 98, 99, 100, 101, 102, 103, -1,
3564  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3565  -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
3566  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3567  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3568  145, 3, 4, 5, 6, 7, 8, 9, 10, 11,
3569  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
3570  22, 23, 24, 25, 26, -1, -1, -1, 30, 31,
3571  32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
3572  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3573  52, 53, 54, 55, 56, 57, -1, -1, -1, -1,
3574  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
3575  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
3576  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
3577  -1, -1, -1, 95, -1, -1, -1, -1, -1, -1,
3578  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3579  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
3580  -1, 123, 124, -1, -1, -1, -1, -1, 3, 4,
3581  5, -1, 7, -1, -1, -1, 11, 12, -1, 141,
3582  142, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3583  -1, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3584  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3585  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3586  55, 56, 57, 58, 59, 60, -1, 62, 63, 64,
3587  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3588  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3589  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3590  95, 96, 97, 98, 99, 100, 101, 102, 103, -1,
3591  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3592  -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
3593  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
3594  -1, 136, -1, 11, 12, -1, -1, 142, 16, -1,
3595  18, 19, 20, 21, 22, 23, 24, -1, 26, -1,
3596  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3597  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3598  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3599  58, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3600  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3601  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3602  -1, 89, 90, -1, 92, 93, -1, 95, 96, 97,
3603  98, 99, 100, 101, 102, 103, -1, -1, -1, -1,
3604  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3605  -1, -1, -1, -1, 122, 123, 124, -1, -1, -1,
3606  -1, -1, 3, 4, 5, -1, 7, -1, 136, -1,
3607  11, 12, -1, -1, 142, 16, -1, 18, 19, 20,
3608  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3609  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3610  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3611  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3612  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3613  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3614  -1, -1, -1, -1, -1, 86, 87, -1, 89, 90,
3615  -1, 92, 93, -1, 95, 96, 97, 98, 99, 100,
3616  101, 102, 103, -1, -1, -1, -1, -1, 109, -1,
3617  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3618  7, 122, 123, 124, 11, 12, -1, -1, -1, 16,
3619  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3620  -1, 142, -1, 30, 31, 32, 33, 34, 35, 36,
3621  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3622  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3623  57, 58, 59, 60, -1, 62, 63, 64, -1, 66,
3624  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3625  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3626  -1, -1, 89, 90, -1, 92, 93, -1, 95, 96,
3627  97, 98, 99, 100, 101, 102, 103, -1, -1, -1,
3628  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3629  3, 4, 5, -1, 7, 122, 123, 124, 11, 12,
3630  -1, -1, -1, 16, -1, 18, 19, 20, 21, 22,
3631  23, 24, -1, -1, -1, 142, -1, 30, 31, 32,
3632  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3633  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3634  53, 54, 55, 56, 57, 58, 59, 60, -1, 62,
3635  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3636  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3637  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3638  93, -1, 95, 96, 97, 98, 99, 100, 101, 102,
3639  103, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3640  -1, -1, -1, -1, -1, -1, -1, -1, -1, 122,
3641  123, 124, -1, -1, -1, -1, -1, -1, -1, -1,
3642  -1, -1, -1, -1, -1, -1, -1, -1, -1, 142,
3643  3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
3644  13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
3645  23, 24, 25, 26, -1, -1, -1, 30, 31, 32,
3646  33, 34, 35, 36, 37, 38, 39, -1, -1, -1,
3647  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3648  53, 54, 55, 56, 57, -1, -1, -1, -1, -1,
3649  -1, -1, -1, 66, 67, 68, 69, 70, 71, 72,
3650  73, 74, -1, -1, 77, 78, -1, -1, 81, 82,
3651  83, 84, -1, -1, -1, -1, -1, -1, -1, -1,
3652  -1, -1, 95, -1, -1, -1, -1, -1, -1, -1,
3653  -1, -1, -1, -1, -1, -1, -1, -1, -1, 112,
3654  113, 114, 115, 116, 117, 118, 119, 120, 121, -1,
3655  123, 124, -1, -1, -1, -1, -1, -1, -1, -1,
3656  -1, -1, -1, -1, -1, -1, -1, -1, 141, 3,
3657  4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3658  14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
3659  24, 25, 26, -1, -1, -1, 30, 31, 32, 33,
3660  34, 35, 36, 37, 38, 39, -1, -1, -1, -1,
3661  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3662  54, -1, 56, -1, -1, -1, -1, -1, -1, -1,
3663  -1, -1, 66, 67, 68, 69, 70, 71, 72, 73,
3664  74, -1, -1, 77, 78, -1, -1, 81, 82, 83,
3665  84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3666  -1, 95, -1, -1, 98, -1, -1, -1, -1, -1,
3667  -1, -1, -1, -1, -1, -1, -1, -1, 112, 113,
3668  114, 115, 116, 117, 118, 119, 120, 121, -1, 123,
3669  124, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3670  -1, -1, -1, -1, -1, -1, -1, 141, 3, 4,
3671  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3672  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3673  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3674  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
3675  45, 46, 47, 48, 49, 50, 51, 52, 53, -1,
3676  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
3677  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3678  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3679  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3680  95, -1, -1, 98, -1, -1, -1, -1, -1, -1,
3681  -1, -1, -1, -1, -1, -1, -1, 112, 113, 114,
3682  115, 116, 117, 118, 119, 120, 121, -1, 123, 124,
3683  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3684  -1, -1, -1, -1, -1, -1, 141, 3, 4, 5,
3685  6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
3686  16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3687  26, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3688  36, 37, 38, 39, -1, -1, -1, -1, -1, 45,
3689  46, 47, 48, 49, 50, 51, 52, 53, -1, -1,
3690  56, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3691  66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
3692  -1, 77, 78, -1, -1, 81, 82, 83, 84, -1,
3693  -1, -1, -1, -1, -1, -1, -1, -1, -1, 95,
3694  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3695  -1, -1, -1, -1, -1, -1, 112, 113, 114, 115,
3696  116, 117, 118, 119, 120, 121, -1, 123, 124, -1,
3697  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3698  12, -1, -1, -1, 16, 141, 18, 19, 20, 21,
3699  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3700  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3701  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3702  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3703  62, 63, 64, -1, -1, -1, -1, -1, -1, -1,
3704  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3705  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3706  92, 93, -1, -1, -1, 97, 98, 99, 100, 101,
3707  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3708  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3709  122, 11, 12, -1, -1, -1, 16, -1, 18, 19,
3710  20, 21, 22, 23, 24, -1, -1, -1, 140, -1,
3711  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3712  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3713  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3714  60, -1, 62, 63, 64, -1, -1, -1, -1, -1,
3715  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3716  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3717  90, -1, 92, 93, -1, -1, -1, 97, 98, 99,
3718  100, 101, 102, 103, -1, -1, -1, -1, -1, -1,
3719  -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
3720  -1, -1, 122, 11, 12, -1, -1, -1, 16, -1,
3721  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3722  140, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3723  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3724  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3725  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3726  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3727  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3728  -1, 89, 90, -1, 92, 93, -1, 95, -1, 97,
3729  98, 99, 100, 101, 102, 103, -1, -1, -1, -1,
3730  -1, -1, -1, -1, 3, 4, 5, 6, 7, -1,
3731  -1, -1, 11, 12, 122, 123, 124, 16, -1, 18,
3732  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3733  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3734  39, -1, -1, -1, -1, -1, 45, 46, -1, 48,
3735  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3736  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3737  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3738  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3739  89, 90, -1, 92, 93, -1, 95, -1, 97, 98,
3740  99, 100, 101, 102, 103, -1, -1, -1, -1, -1,
3741  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3742  -1, 11, 12, 122, 123, 124, 16, -1, 18, 19,
3743  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3744  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3745  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3746  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
3747  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3748  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3749  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3750  90, -1, 92, 93, -1, 95, 96, 97, 98, 99,
3751  100, 101, 102, 103, -1, -1, -1, -1, -1, -1,
3752  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3753  11, 12, 122, 123, 124, 16, -1, 18, 19, 20,
3754  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3755  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3756  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3757  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3758  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3759  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3760  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3761  -1, 92, 93, -1, 95, 96, 97, 98, 99, 100,
3762  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3763  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3764  12, 122, 123, 124, 16, -1, 18, 19, 20, 21,
3765  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3766  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3767  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3768  52, 53, 54, 55, 56, 57, 58, 59, 60, -1,
3769  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3770  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3771  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3772  92, 93, -1, 95, -1, 97, 98, 99, 100, 101,
3773  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3774  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
3775  122, 123, 124, 16, -1, 18, 19, 20, 21, 22,
3776  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3777  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3778  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3779  53, 54, 55, 56, 57, 58, 59, 60, -1, 62,
3780  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3781  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3782  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3783  93, -1, -1, 96, 97, 98, 99, 100, 101, 102,
3784  103, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3785  4, 5, -1, 7, -1, -1, -1, 11, 12, 122,
3786  123, 124, 16, -1, 18, 19, 20, 21, 22, 23,
3787  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3788  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3789  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3790  54, 55, 56, 57, 58, 59, 60, -1, 62, 63,
3791  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
3792  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3793  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3794  -1, 95, -1, 97, 98, 99, 100, 101, 102, 103,
3795  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
3796  5, -1, 7, -1, -1, -1, 11, 12, 122, 123,
3797  124, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3798  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3799  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3800  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3801  55, 56, 57, 58, 59, 60, -1, 62, 63, 64,
3802  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3803  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3804  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3805  -1, -1, 97, 98, 99, 100, 101, 102, 103, -1,
3806  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3807  -1, 7, -1, -1, -1, 11, 12, 122, 123, 124,
3808  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3809  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3810  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3811  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3812  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3813  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3814  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3815  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3816  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3817  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3818  7, -1, -1, -1, 11, 12, 122, 123, 124, 16,
3819  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3820  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3821  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3822  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3823  57, -1, 59, 60, -1, 62, 63, 64, -1, 66,
3824  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3825  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3826  -1, -1, 89, 90, -1, 92, 93, -1, 95, -1,
3827  97, 98, 99, 100, 101, 102, 103, -1, -1, -1,
3828  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
3829  -1, -1, -1, 11, 12, 122, 123, 124, 16, -1,
3830  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3831  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3832  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3833  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3834  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3835  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3836  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3837  -1, 89, 90, -1, 92, 93, -1, 95, -1, 97,
3838  98, 99, 100, 101, 102, 103, -1, -1, -1, -1,
3839  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3840  -1, -1, 11, 12, 122, 123, 124, 16, -1, 18,
3841  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3842  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3843  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3844  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3845  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3846  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3847  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3848  89, 90, -1, 92, 93, -1, 95, -1, 97, 98,
3849  99, 100, 101, 102, 103, -1, -1, -1, -1, -1,
3850  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3851  -1, 11, 12, 122, 123, 124, 16, -1, 18, 19,
3852  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3853  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3854  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3855  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3856  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3857  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3858  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3859  90, -1, 92, 93, -1, 95, -1, 97, 98, 99,
3860  100, 101, 102, 103, -1, -1, -1, -1, -1, -1,
3861  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3862  11, 12, 122, 123, 124, 16, -1, 18, 19, 20,
3863  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3864  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3865  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3866  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3867  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3868  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3869  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3870  -1, 92, 93, -1, -1, -1, 97, 98, 99, 100,
3871  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3872  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3873  12, 122, 123, 124, 16, -1, 18, 19, 20, 21,
3874  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3875  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3876  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3877  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3878  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3879  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3880  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3881  92, 93, -1, -1, -1, 97, 98, 99, 100, 101,
3882  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3883  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
3884  122, 123, 124, 16, -1, 18, 19, 20, 21, 22,
3885  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3886  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3887  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3888  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
3889  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3890  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3891  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3892  93, -1, -1, -1, 97, 98, 99, 100, 101, 102,
3893  103, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3894  4, 5, -1, 7, -1, -1, -1, 11, 12, 122,
3895  123, 124, 16, -1, 18, 19, 20, 21, 22, 23,
3896  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3897  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3898  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3899  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3900  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3901  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3902  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3903  -1, 95, -1, 97, 98, 99, 100, 101, 102, 103,
3904  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3905  -1, -1, 11, 12, -1, -1, -1, 16, 122, 18,
3906  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3907  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3908  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3909  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3910  59, 60, -1, 62, 63, 64, -1, -1, -1, -1,
3911  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3912  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3913  89, 90, -1, 92, 93, -1, 95, -1, 97, 98,
3914  99, 100, 101, 102, 103, -1, -1, -1, -1, 3,
3915  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
3916  -1, -1, 16, 122, 18, 19, 20, 21, 22, 23,
3917  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3918  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3919  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3920  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3921  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3922  -1, -1, -1, -1, -1, -1, -1, -1, -1, 83,
3923  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3924  -1, -1, -1, 97, 98, 99, 100, 101, 102, 103,
3925  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3926  -1, -1, 11, 12, -1, -1, -1, 16, 122, 18,
3927  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3928  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3929  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3930  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3931  59, 60, -1, 62, 63, 64, -1, -1, -1, -1,
3932  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3933  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3934  89, 90, -1, 92, 93, -1, -1, -1, 97, 98,
3935  99, 100, 101, 102, 103, -1, -1, -1, -1, 3,
3936  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
3937  -1, -1, 16, 122, 18, 19, 20, 21, 22, 23,
3938  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3939  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3940  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3941  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3942  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3943  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3944  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3945  -1, -1, -1, 97, 98, 99, 100, 101, 102, 103,
3946  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3947  -1, -1, 11, 12, -1, -1, -1, 16, 122, 18,
3948  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3949  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3950  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3951  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3952  59, 60, -1, 62, 63, 64, -1, -1, -1, -1,
3953  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3954  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3955  89, 90, -1, 92, 93, -1, -1, -1, 97, 98,
3956  99, 100, 101, 102, 103, -1, -1, -1, -1, 3,
3957  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
3958  -1, -1, 16, 122, 18, 19, 20, 21, 22, 23,
3959  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3960  34, 35, 36, -1, -1, 39, -1, 44, -1, -1,
3961  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3962  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3963  64, 68, 69, 70, 71, 72, 73, 74, 75, 76,
3964  77, 78, 79, 80, -1, -1, 83, 84, -1, -1,
3965  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3966  -1, -1, -1, 97, 98, 99, 100, 101, 102, 103,
3967  -1, -1, -1, 110, -1, 112, 113, 114, 115, 116,
3968  117, 118, 119, 120, 121, -1, -1, -1, 122, -1,
3969  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
3970  -1, -1, -1, 140, 66, 67, 68, 69, 70, 71,
3971  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
3972  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
3973  -1, -1, -1, 95, -1, -1, -1, -1, -1, -1,
3974  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3975  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
3976  -1, 123, 124, -1, -1, -1, -1, 52, 53, -1,
3977  -1, 56, -1, -1, -1, -1, -1, -1, -1, 141,
3978  142, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3979  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3980  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3981  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3982  -1, -1, -1, -1, -1, -1, -1, 112, 113, 114,
3983  115, 116, 117, 118, 119, 120, 121, -1, 123, 124,
3984  -1, -1, -1, -1, 52, 53, -1, -1, 56, -1,
3985  -1, -1, -1, -1, -1, -1, 141, 142, 66, 67,
3986  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
3987  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
3988  -1, -1, -1, -1, -1, -1, -1, 95, -1, -1,
3989  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3990  -1, -1, -1, -1, 112, 113, 114, 115, 116, 117,
3991  118, 119, 120, 121, -1, 123, 124, -1, -1, -1,
3992  -1, 52, 53, -1, -1, 56, -1, -1, -1, -1,
3993  -1, -1, -1, 141, 142, 66, 67, 68, 69, 70,
3994  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
3995  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
3996  -1, -1, -1, -1, 95, -1, -1, -1, -1, -1,
3997  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3998  -1, 112, 113, 114, 115, 116, 117, 118, 119, 120,
3999  121, -1, 123, 124, -1, -1, -1, -1, 52, 53,
4000  -1, -1, 56, -1, -1, -1, -1, -1, -1, -1,
4001  141, 142, 66, 67, 68, 69, 70, 71, 72, 73,
4002  74, -1, -1, 77, 78, -1, -1, 81, 82, 83,
4003  84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4004  -1, 95, -1, -1, -1, -1, -1, -1, -1, -1,
4005  -1, -1, -1, -1, -1, -1, -1, -1, 112, 113,
4006  114, 115, 116, 117, 118, 119, 120, 121, -1, 123,
4007  124, -1, -1, -1, -1, 52, 53, -1, -1, 56,
4008  -1, -1, -1, -1, -1, -1, -1, 141, 142, 66,
4009  67, 68, 69, 70, 71, 72, 73, 74, -1, -1,
4010  77, 78, -1, -1, 81, 82, 83, 84, -1, -1,
4011  -1, -1, -1, -1, -1, -1, -1, -1, 95, -1,
4012  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4013  -1, -1, -1, -1, -1, 112, 113, 114, 115, 116,
4014  117, 118, 119, 120, 121, -1, 123, 124, -1, -1,
4015  -1, -1, 52, 53, -1, -1, 56, -1, -1, -1,
4016  -1, -1, -1, -1, 141, 142, 66, 67, 68, 69,
4017  70, 71, 72, 73, 74, -1, -1, 77, 78, -1,
4018  -1, 81, 82, 83, 84, -1, -1, -1, -1, -1,
4019  -1, -1, -1, -1, -1, 95, -1, -1, -1, -1,
4020  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4021  -1, -1, 112, 113, 114, 115, 116, 117, 118, 119,
4022  120, 121, -1, 123, 124, -1, -1, -1, -1, 52,
4023  53, -1, -1, 56, -1, -1, -1, -1, -1, -1,
4024  -1, 141, 142, 66, 67, 68, 69, 70, 71, 72,
4025  73, 74, -1, -1, 77, 78, -1, -1, 81, 82,
4026  83, 84, -1, -1, -1, -1, -1, -1, -1, -1,
4027  -1, -1, 95, -1, -1, -1, -1, -1, -1, -1,
4028  -1, -1, -1, -1, -1, -1, -1, -1, -1, 112,
4029  113, 114, 115, 116, 117, 118, 119, 120, 121, -1,
4030  123, 124, -1, -1, -1, -1, 52, 53, -1, -1,
4031  56, -1, -1, -1, -1, -1, -1, -1, 141, 142,
4032  66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
4033  -1, 77, 78, -1, -1, 81, 82, 83, 84, -1,
4034  -1, -1, -1, -1, -1, -1, -1, -1, -1, 95,
4035  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4036  -1, -1, -1, -1, -1, -1, 112, 113, 114, 115,
4037  116, 117, 118, 119, 120, 121, -1, 123, 124, -1,
4038  -1, -1, -1, 52, 53, -1, -1, 56, -1, -1,
4039  -1, -1, -1, -1, -1, 141, 142, 66, 67, 68,
4040  69, 70, 71, 72, 73, 74, -1, -1, 77, 78,
4041  -1, -1, 81, 82, 83, 84, -1, -1, -1, -1,
4042  -1, -1, -1, -1, -1, -1, 95, -1, -1, -1,
4043  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4044  -1, -1, -1, 112, 113, 114, 115, 116, 117, 118,
4045  119, 120, 121, -1, 123, 124, -1, -1, -1, -1,
4046  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
4047  -1, -1, 141, 142, 66, 67, 68, 69, 70, 71,
4048  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
4049  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
4050  -1, -1, -1, 95, -1, -1, -1, -1, -1, -1,
4051  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4052  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
4053  -1, 123, 124, -1, -1, -1, -1, 52, 53, -1,
4054  -1, 56, -1, -1, -1, -1, -1, -1, -1, 141,
4055  142, 66, 67, 68, 69, 70, 71, 72, 73, 74,
4056  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
4057  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4058  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4059  -1, -1, -1, -1, -1, -1, -1, 112, 113, 114,
4060  115, 116, 117, 118, 119, 120, 121, -1, 123, 124,
4061  -1, -1, -1, -1, 52, 53, -1, -1, 56, -1,
4062  -1, -1, -1, -1, -1, -1, 141, 142, 66, 67,
4063  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
4064  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
4065  -1, -1, -1, -1, -1, -1, -1, 95, -1, -1,
4066  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4067  -1, -1, -1, -1, 112, 113, 114, 115, 116, 117,
4068  118, 119, 120, 121, -1, 123, 124, -1, -1, -1,
4069  -1, 52, 53, -1, -1, 56, -1, -1, -1, -1,
4070  -1, -1, -1, 141, 142, 66, 67, 68, 69, 70,
4071  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
4072  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
4073  -1, -1, -1, -1, 95, -1, -1, -1, -1, -1,
4074  -1, -1, 44, -1, -1, -1, -1, -1, -1, -1,
4075  -1, 112, 113, 114, 115, 116, 117, 118, 119, 120,
4076  121, 44, 123, 124, -1, -1, 68, 69, 70, 71,
4077  72, 73, 74, 75, 76, 77, 78, 79, 80, -1,
4078  141, 83, 84, -1, -1, 68, 69, 70, 71, 72,
4079  73, 74, 75, 76, 77, 78, 79, 80, -1, -1,
4080  83, 84, -1, -1, -1, -1, -1, -1, 110, -1,
4081  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
4082  -1, -1, -1, -1, -1, -1, -1, 110, -1, 112,
4083  113, 114, 115, 116, 117, 118, 119, 120, 121
4084 };
4085 
4086 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4087  symbol of state STATE-NUM. */
4088 static const yytype_uint16 yystos[] =
4089 {
4090  0, 149, 150, 0, 1, 3, 4, 5, 6, 7,
4091  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4092  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4093  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4094  57, 59, 60, 62, 63, 64, 66, 67, 86, 89,
4095  90, 92, 93, 95, 97, 98, 99, 100, 101, 102,
4096  103, 122, 123, 124, 151, 152, 153, 158, 160, 161,
4097  163, 164, 167, 168, 170, 171, 172, 174, 175, 185,
4098  199, 216, 217, 218, 219, 220, 221, 222, 223, 224,
4099  225, 226, 249, 250, 260, 261, 262, 263, 264, 265,
4100  266, 269, 279, 281, 282, 283, 284, 285, 286, 287,
4101  310, 321, 153, 3, 4, 5, 6, 7, 8, 9,
4102  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
4103  20, 21, 22, 23, 24, 25, 26, 30, 31, 32,
4104  33, 34, 35, 36, 37, 38, 39, 45, 46, 47,
4105  48, 49, 50, 51, 52, 53, 56, 66, 67, 68,
4106  69, 70, 71, 72, 73, 74, 77, 78, 81, 82,
4107  83, 84, 95, 112, 113, 114, 115, 116, 117, 118,
4108  119, 120, 121, 123, 124, 141, 178, 179, 180, 181,
4109  183, 184, 279, 281, 39, 58, 86, 89, 95, 96,
4110  123, 167, 175, 185, 187, 192, 195, 197, 216, 283,
4111  284, 286, 287, 308, 309, 192, 192, 142, 193, 194,
4112  142, 189, 193, 142, 147, 315, 54, 180, 315, 154,
4113  136, 21, 22, 30, 31, 32, 185, 216, 310, 185,
4114  56, 1, 89, 156, 157, 158, 169, 170, 321, 161,
4115  188, 197, 308, 321, 187, 307, 308, 321, 46, 86,
4116  122, 140, 174, 199, 216, 283, 284, 287, 242, 243,
4117  54, 55, 57, 178, 272, 280, 271, 272, 273, 146,
4118  267, 146, 270, 59, 60, 163, 185, 185, 145, 147,
4119  314, 319, 320, 40, 41, 42, 43, 44, 37, 38,
4120  28, 247, 109, 140, 89, 95, 171, 109, 68, 69,
4121  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
4122  80, 83, 84, 110, 112, 113, 114, 115, 116, 117,
4123  118, 119, 120, 121, 85, 138, 139, 200, 161, 162,
4124  162, 203, 205, 162, 314, 320, 86, 168, 175, 216,
4125  232, 283, 284, 287, 52, 56, 83, 86, 176, 177,
4126  216, 283, 284, 287, 177, 33, 34, 35, 36, 49,
4127  50, 51, 52, 56, 142, 178, 285, 305, 85, 139,
4128  26, 136, 251, 263, 87, 87, 189, 193, 251, 140,
4129  187, 56, 187, 187, 109, 88, 140, 196, 321, 85,
4130  138, 139, 87, 87, 140, 196, 192, 315, 316, 192,
4131  191, 192, 197, 308, 321, 161, 316, 161, 54, 63,
4132  64, 159, 142, 186, 136, 156, 85, 139, 87, 158,
4133  169, 143, 314, 320, 316, 201, 144, 140, 147, 318,
4134  140, 318, 137, 318, 315, 56, 59, 60, 171, 173,
4135  140, 85, 138, 139, 244, 61, 104, 105, 106, 274,
4136  106, 274, 106, 65, 274, 106, 106, 268, 274, 106,
4137  61, 106, 68, 68, 145, 153, 162, 162, 162, 162,
4138  158, 161, 161, 248, 95, 163, 187, 197, 198, 169,
4139  140, 174, 140, 160, 163, 175, 185, 187, 198, 185,
4140  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
4141  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
4142  185, 185, 185, 185, 185, 52, 53, 56, 183, 189,
4143  311, 312, 191, 52, 53, 56, 183, 189, 311, 155,
4144  156, 13, 228, 319, 228, 162, 162, 314, 17, 254,
4145  56, 85, 138, 139, 25, 161, 52, 56, 176, 1,
4146  113, 288, 319, 85, 138, 139, 212, 306, 213, 85,
4147  139, 313, 52, 56, 311, 311, 253, 252, 163, 185,
4148  163, 185, 94, 165, 182, 185, 187, 95, 187, 195,
4149  308, 52, 56, 191, 52, 56, 309, 316, 143, 316,
4150  140, 140, 316, 180, 202, 185, 151, 137, 311, 311,
4151  185, 316, 158, 316, 308, 140, 173, 52, 56, 191,
4152  52, 56, 52, 54, 55, 56, 57, 89, 95, 96,
4153  116, 119, 142, 245, 291, 292, 293, 294, 295, 296,
4154  299, 300, 301, 302, 303, 276, 275, 146, 274, 146,
4155  185, 185, 76, 114, 237, 238, 321, 187, 140, 316,
4156  173, 140, 109, 44, 315, 87, 87, 189, 193, 315,
4157  317, 87, 87, 189, 190, 193, 321, 10, 227, 8,
4158  256, 321, 156, 13, 156, 27, 229, 319, 229, 254,
4159  197, 227, 52, 56, 191, 52, 56, 207, 210, 319,
4160  289, 209, 52, 56, 176, 191, 155, 161, 142, 290,
4161  291, 214, 190, 193, 190, 193, 237, 237, 44, 166,
4162  180, 187, 196, 87, 87, 317, 87, 87, 308, 161,
4163  137, 318, 171, 317, 109, 52, 89, 95, 233, 234,
4164  235, 293, 291, 29, 107, 246, 140, 304, 321, 140,
4165  304, 52, 140, 304, 52, 277, 54, 55, 57, 278,
4166  287, 52, 145, 236, 239, 295, 297, 298, 301, 303,
4167  321, 156, 95, 187, 173, 185, 111, 163, 185, 163,
4168  185, 165, 144, 87, 163, 185, 163, 185, 165, 187,
4169  198, 257, 321, 15, 231, 321, 14, 230, 231, 231,
4170  204, 206, 227, 140, 228, 317, 162, 319, 162, 155,
4171  317, 227, 316, 291, 155, 319, 178, 156, 156, 185,
4172  237, 87, 140, 316, 187, 235, 140, 293, 140, 316,
4173  239, 156, 156, 294, 299, 301, 303, 295, 296, 301,
4174  295, 156, 109, 52, 240, 241, 292, 239, 114, 140,
4175  304, 140, 304, 140, 304, 10, 187, 185, 163, 185,
4176  88, 258, 321, 156, 9, 259, 321, 162, 227, 227,
4177  156, 156, 187, 156, 229, 211, 319, 227, 316, 227,
4178  215, 10, 137, 156, 316, 234, 140, 95, 233, 316,
4179  10, 137, 140, 304, 140, 304, 140, 304, 140, 304,
4180  304, 137, 86, 216, 140, 114, 298, 301, 295, 297,
4181  301, 295, 86, 175, 216, 283, 284, 287, 228, 156,
4182  228, 227, 227, 231, 254, 255, 208, 155, 290, 137,
4183  140, 234, 140, 293, 295, 301, 295, 295, 56, 85,
4184  241, 140, 304, 140, 304, 304, 140, 304, 304, 56,
4185  85, 138, 139, 156, 156, 156, 227, 155, 234, 140,
4186  304, 140, 304, 304, 304, 52, 56, 295, 301, 295,
4187  295, 52, 56, 191, 52, 56, 256, 230, 227, 227,
4188  234, 295, 304, 140, 304, 304, 304, 317, 304, 295,
4189  304
4190 };
4191 
4192 #define yyerrok (yyerrstatus = 0)
4193 #define yyclearin (yychar = YYEMPTY)
4194 #define YYEMPTY (-2)
4195 #define YYEOF 0
4196 
4197 #define YYACCEPT goto yyacceptlab
4198 #define YYABORT goto yyabortlab
4199 #define YYERROR goto yyerrorlab
4200 
4201 
4202 /* Like YYERROR except do call yyerror. This remains here temporarily
4203  to ease the transition to the new meaning of YYERROR, for GCC.
4204  Once GCC version 2 has supplanted version 1, this can go. However,
4205  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
4206  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
4207  discussed. */
4208 
4209 #define YYFAIL goto yyerrlab
4210 #if defined YYFAIL
4211  /* This is here to suppress warnings from the GCC cpp's
4212  -Wunused-macros. Normally we don't worry about that warning, but
4213  some users do, and we want to make it easy for users to remove
4214  YYFAIL uses, which will produce warnings from Bison 2.5. */
4215 #endif
4216 
4217 #define YYRECOVERING() (!!yyerrstatus)
4218 
4219 #define YYBACKUP(Token, Value) \
4220 do \
4221  if (yychar == YYEMPTY && yylen == 1) \
4222  { \
4223  yychar = (Token); \
4224  yylval = (Value); \
4225  YYPOPSTACK (1); \
4226  goto yybackup; \
4227  } \
4228  else \
4229  { \
4230  parser_yyerror (parser, YY_("syntax error: cannot back up")); \
4231  YYERROR; \
4232  } \
4233 while (YYID (0))
4234 
4235 
4236 #define YYTERROR 1
4237 #define YYERRCODE 256
4238 
4239 
4240 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
4241  If N is 0, then set CURRENT to the empty location which ends
4242  the previous symbol: RHS[0] (always defined). */
4243 
4244 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
4245 #ifndef YYLLOC_DEFAULT
4246 # define YYLLOC_DEFAULT(Current, Rhs, N) \
4247  do \
4248  if (YYID (N)) \
4249  { \
4250  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
4251  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
4252  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
4253  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
4254  } \
4255  else \
4256  { \
4257  (Current).first_line = (Current).last_line = \
4258  YYRHSLOC (Rhs, 0).last_line; \
4259  (Current).first_column = (Current).last_column = \
4260  YYRHSLOC (Rhs, 0).last_column; \
4261  } \
4262  while (YYID (0))
4263 #endif
4264 
4265 
4266 /* This macro is provided for backward compatibility. */
4267 
4268 #ifndef YY_LOCATION_PRINT
4269 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
4270 #endif
4271 
4272 
4273 /* YYLEX -- calling `yylex' with the right arguments. */
4274 
4275 #ifdef YYLEX_PARAM
4276 # define YYLEX yylex (&yylval, YYLEX_PARAM)
4277 #else
4278 # define YYLEX yylex (&yylval, parser)
4279 #endif
4280 
4281 /* Enable debugging if requested. */
4282 #if YYDEBUG
4283 
4284 # ifndef YYFPRINTF
4285 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
4286 # define YYFPRINTF fprintf
4287 # endif
4288 
4289 # define YYDPRINTF(Args) \
4290 do { \
4291  if (yydebug) \
4292  YYFPRINTF Args; \
4293 } while (YYID (0))
4294 
4295 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
4296 do { \
4297  if (yydebug) \
4298  { \
4299  YYFPRINTF (stderr, "%s ", Title); \
4300  yy_symbol_print (stderr, \
4301  Type, Value, parser); \
4302  YYFPRINTF (stderr, "\n"); \
4303  } \
4304 } while (YYID (0))
4305 
4306 
4307 /*--------------------------------.
4308 | Print this symbol on YYOUTPUT. |
4309 `--------------------------------*/
4310 
4311 /*ARGSUSED*/
4312 #if (defined __STDC__ || defined __C99__FUNC__ \
4313  || defined __cplusplus || defined _MSC_VER)
4314 static void
4315 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4316 #else
4317 static void
4318 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
4319  FILE *yyoutput;
4320  int yytype;
4321  YYSTYPE const * const yyvaluep;
4322  struct parser_params *parser;
4323 #endif
4324 {
4325  if (!yyvaluep)
4326  return;
4327  YYUSE (parser);
4328 # ifdef YYPRINT
4329  if (yytype < YYNTOKENS)
4330  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4331 # else
4332  YYUSE (yyoutput);
4333 # endif
4334  switch (yytype)
4335  {
4336  default:
4337  break;
4338  }
4339 }
4340 
4341 
4342 /*--------------------------------.
4343 | Print this symbol on YYOUTPUT. |
4344 `--------------------------------*/
4345 
4346 #if (defined __STDC__ || defined __C99__FUNC__ \
4347  || defined __cplusplus || defined _MSC_VER)
4348 static void
4349 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4350 #else
4351 static void
4352 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
4353  FILE *yyoutput;
4354  int yytype;
4355  YYSTYPE const * const yyvaluep;
4356  struct parser_params *parser;
4357 #endif
4358 {
4359  if (yytype < YYNTOKENS)
4360  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4361  else
4362  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4363 
4364  yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
4365  YYFPRINTF (yyoutput, ")");
4366 }
4367 
4368 /*------------------------------------------------------------------.
4369 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4370 | TOP (included). |
4371 `------------------------------------------------------------------*/
4372 
4373 #if (defined __STDC__ || defined __C99__FUNC__ \
4374  || defined __cplusplus || defined _MSC_VER)
4375 static void
4376 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4377 #else
4378 static void
4379 yy_stack_print (yybottom, yytop)
4380  yytype_int16 *yybottom;
4381  yytype_int16 *yytop;
4382 #endif
4383 {
4384  YYFPRINTF (stderr, "Stack now");
4385  for (; yybottom <= yytop; yybottom++)
4386  {
4387  int yybot = *yybottom;
4388  YYFPRINTF (stderr, " %d", yybot);
4389  }
4390  YYFPRINTF (stderr, "\n");
4391 }
4392 
4393 # define YY_STACK_PRINT(Bottom, Top) \
4394 do { \
4395  if (yydebug) \
4396  yy_stack_print ((Bottom), (Top)); \
4397 } while (YYID (0))
4398 
4399 
4400 /*------------------------------------------------.
4401 | Report that the YYRULE is going to be reduced. |
4402 `------------------------------------------------*/
4403 
4404 #if (defined __STDC__ || defined __C99__FUNC__ \
4405  || defined __cplusplus || defined _MSC_VER)
4406 static void
4407 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
4408 #else
4409 static void
4410 yy_reduce_print (yyvsp, yyrule, parser)
4411  YYSTYPE *yyvsp;
4412  int yyrule;
4413  struct parser_params *parser;
4414 #endif
4415 {
4416  int yynrhs = yyr2[yyrule];
4417  int yyi;
4418  unsigned long int yylno = yyrline[yyrule];
4419  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4420  yyrule - 1, yylno);
4421  /* The symbols being reduced. */
4422  for (yyi = 0; yyi < yynrhs; yyi++)
4423  {
4424  YYFPRINTF (stderr, " $%d = ", yyi + 1);
4425  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4426  &(yyvsp[(yyi + 1) - (yynrhs)])
4427  , parser);
4428  YYFPRINTF (stderr, "\n");
4429  }
4430 }
4431 
4432 # define YY_REDUCE_PRINT(Rule) \
4433 do { \
4434  if (yydebug) \
4435  yy_reduce_print (yyvsp, Rule, parser); \
4436 } while (YYID (0))
4437 
4438 /* Nonzero means print parse trace. It is left uninitialized so that
4439  multiple parsers can coexist. */
4440 #ifndef yydebug
4441 int yydebug;
4442 #endif
4443 #else /* !YYDEBUG */
4444 # define YYDPRINTF(Args)
4445 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4446 # define YY_STACK_PRINT(Bottom, Top)
4447 # define YY_REDUCE_PRINT(Rule)
4448 #endif /* !YYDEBUG */
4449 
4450 
4451 /* YYINITDEPTH -- initial size of the parser's stacks. */
4452 #ifndef YYINITDEPTH
4453 # define YYINITDEPTH 200
4454 #endif
4455 
4456 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4457  if the built-in stack extension method is used).
4458 
4459  Do not make this value too large; the results are undefined if
4460  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4461  evaluated with infinite-precision integer arithmetic. */
4462 
4463 #ifndef YYMAXDEPTH
4464 # define YYMAXDEPTH 10000
4465 #endif
4466 
4467 
4468 #if YYERROR_VERBOSE
4469 
4470 # ifndef yystrlen
4471 # if defined __GLIBC__ && defined _STRING_H
4472 # define yystrlen strlen
4473 # else
4474 /* Return the length of YYSTR. */
4475 #if (defined __STDC__ || defined __C99__FUNC__ \
4476  || defined __cplusplus || defined _MSC_VER)
4477 static YYSIZE_T
4478 yystrlen (const char *yystr)
4479 #else
4480 static YYSIZE_T
4481 yystrlen (yystr)
4482  const char *yystr;
4483 #endif
4484 {
4485  YYSIZE_T yylen;
4486  for (yylen = 0; yystr[yylen]; yylen++)
4487  continue;
4488  return yylen;
4489 }
4490 # endif
4491 # endif
4492 
4493 # ifndef yystpcpy
4494 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4495 # define yystpcpy stpcpy
4496 # else
4497 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4498  YYDEST. */
4499 #if (defined __STDC__ || defined __C99__FUNC__ \
4500  || defined __cplusplus || defined _MSC_VER)
4501 static char *
4502 yystpcpy (char *yydest, const char *yysrc)
4503 #else
4504 static char *
4505 yystpcpy (yydest, yysrc)
4506  char *yydest;
4507  const char *yysrc;
4508 #endif
4509 {
4510  char *yyd = yydest;
4511  const char *yys = yysrc;
4512 
4513  while ((*yyd++ = *yys++) != '\0')
4514  continue;
4515 
4516  return yyd - 1;
4517 }
4518 # endif
4519 # endif
4520 
4521 # ifndef yytnamerr
4522 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4523  quotes and backslashes, so that it's suitable for yyerror. The
4524  heuristic is that double-quoting is unnecessary unless the string
4525  contains an apostrophe, a comma, or backslash (other than
4526  backslash-backslash). YYSTR is taken from yytname. If YYRES is
4527  null, do not copy; instead, return the length of what the result
4528  would have been. */
4529 static YYSIZE_T
4530 yytnamerr (char *yyres, const char *yystr)
4531 {
4532  if (*yystr == '"')
4533  {
4534  YYSIZE_T yyn = 0;
4535  char const *yyp = yystr;
4536 
4537  for (;;)
4538  switch (*++yyp)
4539  {
4540  case '\'':
4541  case ',':
4542  goto do_not_strip_quotes;
4543 
4544  case '\\':
4545  if (*++yyp != '\\')
4546  goto do_not_strip_quotes;
4547  /* Fall through. */
4548  default:
4549  if (yyres)
4550  yyres[yyn] = *yyp;
4551  yyn++;
4552  break;
4553 
4554  case '"':
4555  if (yyres)
4556  yyres[yyn] = '\0';
4557  return yyn;
4558  }
4559  do_not_strip_quotes: ;
4560  }
4561 
4562  if (! yyres)
4563  return yystrlen (yystr);
4564 
4565  return yystpcpy (yyres, yystr) - yyres;
4566 }
4567 # endif
4568 
4569 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
4570  about the unexpected token YYTOKEN for the state stack whose top is
4571  YYSSP.
4572 
4573  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
4574  not large enough to hold the message. In that case, also set
4575  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
4576  required number of bytes is too large to store. */
4577 static int
4578 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
4579  yytype_int16 *yyssp, int yytoken)
4580 {
4581  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
4582  YYSIZE_T yysize = yysize0;
4583  YYSIZE_T yysize1;
4584  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4585  /* Internationalized format string. */
4586  const char *yyformat = 0;
4587  /* Arguments of yyformat. */
4588  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4589  /* Number of reported tokens (one for the "unexpected", one per
4590  "expected"). */
4591  int yycount = 0;
4592 
4593  /* There are many possibilities here to consider:
4594  - Assume YYFAIL is not used. It's too flawed to consider. See
4595  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
4596  for details. YYERROR is fine as it does not invoke this
4597  function.
4598  - If this state is a consistent state with a default action, then
4599  the only way this function was invoked is if the default action
4600  is an error action. In that case, don't check for expected
4601  tokens because there are none.
4602  - The only way there can be no lookahead present (in yychar) is if
4603  this state is a consistent state with a default action. Thus,
4604  detecting the absence of a lookahead is sufficient to determine
4605  that there is no unexpected or expected token to report. In that
4606  case, just report a simple "syntax error".
4607  - Don't assume there isn't a lookahead just because this state is a
4608  consistent state with a default action. There might have been a
4609  previous inconsistent state, consistent state with a non-default
4610  action, or user semantic action that manipulated yychar.
4611  - Of course, the expected token list depends on states to have
4612  correct lookahead information, and it depends on the parser not
4613  to perform extra reductions after fetching a lookahead from the
4614  scanner and before detecting a syntax error. Thus, state merging
4615  (from LALR or IELR) and default reductions corrupt the expected
4616  token list. However, the list is correct for canonical LR with
4617  one exception: it will still contain any token that will not be
4618  accepted due to an error action in a later state.
4619  */
4620  if (yytoken != YYEMPTY)
4621  {
4622  int yyn = yypact[*yyssp];
4623  yyarg[yycount++] = yytname[yytoken];
4624  if (!yypact_value_is_default (yyn))
4625  {
4626  /* Start YYX at -YYN if negative to avoid negative indexes in
4627  YYCHECK. In other words, skip the first -YYN actions for
4628  this state because they are default actions. */
4629  int yyxbegin = yyn < 0 ? -yyn : 0;
4630  /* Stay within bounds of both yycheck and yytname. */
4631  int yychecklim = YYLAST - yyn + 1;
4632  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4633  int yyx;
4634 
4635  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4636  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
4637  && !yytable_value_is_error (yytable[yyx + yyn]))
4638  {
4639  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4640  {
4641  yycount = 1;
4642  yysize = yysize0;
4643  break;
4644  }
4645  yyarg[yycount++] = yytname[yyx];
4646  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4647  if (! (yysize <= yysize1
4648  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4649  return 2;
4650  yysize = yysize1;
4651  }
4652  }
4653  }
4654 
4655  switch (yycount)
4656  {
4657 # define YYCASE_(N, S) \
4658  case N: \
4659  yyformat = S; \
4660  break
4661  YYCASE_(0, YY_("syntax error"));
4662  YYCASE_(1, YY_("syntax error, unexpected %s"));
4663  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
4664  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
4665  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
4666  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
4667 # undef YYCASE_
4668  }
4669 
4670  yysize1 = yysize + yystrlen (yyformat);
4671  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4672  return 2;
4673  yysize = yysize1;
4674 
4675  if (*yymsg_alloc < yysize)
4676  {
4677  *yymsg_alloc = 2 * yysize;
4678  if (! (yysize <= *yymsg_alloc
4679  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
4680  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
4681  return 1;
4682  }
4683 
4684  /* Avoid sprintf, as that infringes on the user's name space.
4685  Don't have undefined behavior even if the translation
4686  produced a string with the wrong number of "%s"s. */
4687  {
4688  char *yyp = *yymsg;
4689  int yyi = 0;
4690  while ((*yyp = *yyformat) != '\0')
4691  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
4692  {
4693  yyp += yytnamerr (yyp, yyarg[yyi++]);
4694  yyformat += 2;
4695  }
4696  else
4697  {
4698  yyp++;
4699  yyformat++;
4700  }
4701  }
4702  return 0;
4703 }
4704 #endif /* YYERROR_VERBOSE */
4705 
4706 /*-----------------------------------------------.
4707 | Release the memory associated to this symbol. |
4708 `-----------------------------------------------*/
4709 
4710 /*ARGSUSED*/
4711 #if (defined __STDC__ || defined __C99__FUNC__ \
4712  || defined __cplusplus || defined _MSC_VER)
4713 static void
4714 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
4715 #else
4716 static void
4717 yydestruct (yymsg, yytype, yyvaluep, parser)
4718  const char *yymsg;
4719  int yytype;
4720  YYSTYPE *yyvaluep;
4721  struct parser_params *parser;
4722 #endif
4723 {
4724  YYUSE (yyvaluep);
4725  YYUSE (parser);
4726 
4727  if (!yymsg)
4728  yymsg = "Deleting";
4729  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4730 
4731  switch (yytype)
4732  {
4733 
4734  default:
4735  break;
4736  }
4737 }
4738 
4739 
4740 /* Prevent warnings from -Wmissing-prototypes. */
4741 #ifdef YYPARSE_PARAM
4742 #if defined __STDC__ || defined __cplusplus
4743 int yyparse (void *YYPARSE_PARAM);
4744 #else
4745 int yyparse ();
4746 #endif
4747 #else /* ! YYPARSE_PARAM */
4748 #if defined __STDC__ || defined __cplusplus
4749 int yyparse (struct parser_params *parser);
4750 #else
4751 int yyparse ();
4752 #endif
4753 #endif /* ! YYPARSE_PARAM */
4754 
4755 
4756 /*----------.
4757 | yyparse. |
4758 `----------*/
4759 
4760 #ifdef YYPARSE_PARAM
4761 #if (defined __STDC__ || defined __C99__FUNC__ \
4762  || defined __cplusplus || defined _MSC_VER)
4763 int
4764 yyparse (void *YYPARSE_PARAM)
4765 #else
4766 int
4767 yyparse (YYPARSE_PARAM)
4768  void *YYPARSE_PARAM;
4769 #endif
4770 #else /* ! YYPARSE_PARAM */
4771 #if (defined __STDC__ || defined __C99__FUNC__ \
4772  || defined __cplusplus || defined _MSC_VER)
4773 int
4774 yyparse (struct parser_params *parser)
4775 #else
4776 int
4777 yyparse (parser)
4778  struct parser_params *parser;
4779 #endif
4780 #endif
4781 {
4782 /* The lookahead symbol. */
4783 int yychar;
4784 
4785 /* The semantic value of the lookahead symbol. */
4786 YYSTYPE yylval;
4787 
4788  /* Number of syntax errors so far. */
4789  int yynerrs;
4790 
4791  int yystate;
4792  /* Number of tokens to shift before error messages enabled. */
4793  int yyerrstatus;
4794 
4795  /* The stacks and their tools:
4796  `yyss': related to states.
4797  `yyvs': related to semantic values.
4798 
4799  Refer to the stacks thru separate pointers, to allow yyoverflow
4800  to reallocate them elsewhere. */
4801 
4802  /* The state stack. */
4803  yytype_int16 yyssa[YYINITDEPTH];
4804  yytype_int16 *yyss;
4805  yytype_int16 *yyssp;
4806 
4807  /* The semantic value stack. */
4808  YYSTYPE yyvsa[YYINITDEPTH];
4809  YYSTYPE *yyvs;
4810  YYSTYPE *yyvsp;
4811 
4812  YYSIZE_T yystacksize;
4813 
4814  int yyn;
4815  int yyresult;
4816  /* Lookahead token as an internal (translated) token number. */
4817  int yytoken;
4818  /* The variables used to return semantic value and location from the
4819  action routines. */
4820  YYSTYPE yyval;
4821 
4822 #if YYERROR_VERBOSE
4823  /* Buffer for error messages, and its allocated size. */
4824  char yymsgbuf[128];
4825  char *yymsg = yymsgbuf;
4826  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
4827 #endif
4828 
4829 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
4830 
4831  /* The number of symbols on the RHS of the reduced rule.
4832  Keep to zero when no symbol should be popped. */
4833  int yylen = 0;
4834 
4835  yytoken = 0;
4836  yyss = yyssa;
4837  yyvs = yyvsa;
4838  yystacksize = YYINITDEPTH;
4839 
4840  YYDPRINTF ((stderr, "Starting parse\n"));
4841 
4842  yystate = 0;
4843  yyerrstatus = 0;
4844  yynerrs = 0;
4845  yychar = YYEMPTY; /* Cause a token to be read. */
4846 
4847  /* Initialize stack pointers.
4848  Waste one element of value and location stack
4849  so that they stay on the same level as the state stack.
4850  The wasted elements are never initialized. */
4851  yyssp = yyss;
4852  yyvsp = yyvs;
4853 
4854  goto yysetstate;
4855 
4856 /*------------------------------------------------------------.
4857 | yynewstate -- Push a new state, which is found in yystate. |
4858 `------------------------------------------------------------*/
4859  yynewstate:
4860  /* In all cases, when you get here, the value and location stacks
4861  have just been pushed. So pushing a state here evens the stacks. */
4862  yyssp++;
4863 
4864  yysetstate:
4865  *yyssp = yystate;
4866 
4867  if (yyss + yystacksize - 1 <= yyssp)
4868  {
4869  /* Get the current used size of the three stacks, in elements. */
4870  YYSIZE_T yysize = yyssp - yyss + 1;
4871 
4872 #ifdef yyoverflow
4873  {
4874  /* Give user a chance to reallocate the stack. Use copies of
4875  these so that the &'s don't force the real ones into
4876  memory. */
4877  YYSTYPE *yyvs1 = yyvs;
4878  yytype_int16 *yyss1 = yyss;
4879 
4880  /* Each stack pointer address is followed by the size of the
4881  data in use in that stack, in bytes. This used to be a
4882  conditional around just the two extra args, but that might
4883  be undefined if yyoverflow is a macro. */
4884  yyoverflow (YY_("memory exhausted"),
4885  &yyss1, yysize * sizeof (*yyssp),
4886  &yyvs1, yysize * sizeof (*yyvsp),
4887  &yystacksize);
4888 
4889  yyss = yyss1;
4890  yyvs = yyvs1;
4891  }
4892 #else /* no yyoverflow */
4893 # ifndef YYSTACK_RELOCATE
4894  goto yyexhaustedlab;
4895 # else
4896  /* Extend the stack our own way. */
4897  if (YYMAXDEPTH <= yystacksize)
4898  goto yyexhaustedlab;
4899  yystacksize *= 2;
4900  if (YYMAXDEPTH < yystacksize)
4901  yystacksize = YYMAXDEPTH;
4902 
4903  {
4904  yytype_int16 *yyss1 = yyss;
4905  union yyalloc *yyptr =
4906  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
4907  if (! yyptr)
4908  goto yyexhaustedlab;
4909  YYSTACK_RELOCATE (yyss_alloc, yyss);
4910  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
4911 # undef YYSTACK_RELOCATE
4912  if (yyss1 != yyssa)
4913  YYSTACK_FREE (yyss1);
4914  }
4915 # endif
4916 #endif /* no yyoverflow */
4917 
4918  yyssp = yyss + yysize - 1;
4919  yyvsp = yyvs + yysize - 1;
4920 
4921  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
4922  (unsigned long int) yystacksize));
4923 
4924  if (yyss + yystacksize - 1 <= yyssp)
4925  YYABORT;
4926  }
4927 
4928  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
4929 
4930  if (yystate == YYFINAL)
4931  YYACCEPT;
4932 
4933  goto yybackup;
4934 
4935 /*-----------.
4936 | yybackup. |
4937 `-----------*/
4938 yybackup:
4939 
4940  /* Do appropriate processing given the current state. Read a
4941  lookahead token if we need one and don't already have one. */
4942 
4943  /* First try to decide what to do without reference to lookahead token. */
4944  yyn = yypact[yystate];
4945  if (yypact_value_is_default (yyn))
4946  goto yydefault;
4947 
4948  /* Not known => get a lookahead token if don't already have one. */
4949 
4950  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
4951  if (yychar == YYEMPTY)
4952  {
4953  YYDPRINTF ((stderr, "Reading a token: "));
4954  yychar = YYLEX;
4955  }
4956 
4957  if (yychar <= YYEOF)
4958  {
4959  yychar = yytoken = YYEOF;
4960  YYDPRINTF ((stderr, "Now at end of input.\n"));
4961  }
4962  else
4963  {
4964  yytoken = YYTRANSLATE (yychar);
4965  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
4966  }
4967 
4968  /* If the proper action on seeing token YYTOKEN is to reduce or to
4969  detect an error, take that action. */
4970  yyn += yytoken;
4971  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
4972  goto yydefault;
4973  yyn = yytable[yyn];
4974  if (yyn <= 0)
4975  {
4976  if (yytable_value_is_error (yyn))
4977  goto yyerrlab;
4978  yyn = -yyn;
4979  goto yyreduce;
4980  }
4981 
4982  /* Count tokens shifted since error; after three, turn off error
4983  status. */
4984  if (yyerrstatus)
4985  yyerrstatus--;
4986 
4987  /* Shift the lookahead token. */
4988  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
4989 
4990  /* Discard the shifted token. */
4991  yychar = YYEMPTY;
4992 
4993  yystate = yyn;
4994  *++yyvsp = yylval;
4995 
4996  goto yynewstate;
4997 
4998 
4999 /*-----------------------------------------------------------.
5000 | yydefault -- do the default action for the current state. |
5001 `-----------------------------------------------------------*/
5002 yydefault:
5003  yyn = yydefact[yystate];
5004  if (yyn == 0)
5005  goto yyerrlab;
5006  goto yyreduce;
5007 
5008 
5009 /*-----------------------------.
5010 | yyreduce -- Do a reduction. |
5011 `-----------------------------*/
5012 yyreduce:
5013  /* yyn is the number of a rule to reduce with. */
5014  yylen = yyr2[yyn];
5015 
5016  /* If YYLEN is nonzero, implement the default value of the action:
5017  `$$ = $1'.
5018 
5019  Otherwise, the following line sets YYVAL to garbage.
5020  This behavior is undocumented and Bison
5021  users should not rely upon it. Assigning to YYVAL
5022  unconditionally makes the parser a bit smaller, and it avoids a
5023  GCC warning that YYVAL may be used uninitialized. */
5024  yyval = yyvsp[1-yylen];
5025 
5026 
5027  YY_REDUCE_PRINT (yyn);
5028  switch (yyn)
5029  {
5030  case 2:
5031 
5032 /* Line 1806 of yacc.c */
5033 #line 785 "ripper.y"
5034  {
5035  lex_state = EXPR_BEG;
5036 #if 0
5038 #endif
5039  local_push(0);
5040 
5041  }
5042  break;
5043 
5044  case 3:
5045 
5046 /* Line 1806 of yacc.c */
5047 #line 794 "ripper.y"
5048  {
5049 #if 0
5050  if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
5051  /* last expression should not be void */
5052  if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
5053  else {
5054  NODE *node = (yyvsp[(2) - (2)].val);
5055  while (node->nd_next) {
5056  node = node->nd_next;
5057  }
5058  void_expr(node->nd_head);
5059  }
5060  }
5061  ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val)));
5062 #endif
5063  (yyval.val) = (yyvsp[(2) - (2)].val);
5064  parser->result = dispatch1(program, (yyval.val));
5065 
5066  local_pop();
5067  }
5068  break;
5069 
5070  case 4:
5071 
5072 /* Line 1806 of yacc.c */
5073 #line 817 "ripper.y"
5074  {
5075 #if 0
5076  void_stmts((yyvsp[(1) - (2)].val));
5078 #endif
5079 
5080  (yyval.val) = (yyvsp[(1) - (2)].val);
5081  }
5082  break;
5083 
5084  case 5:
5085 
5086 /* Line 1806 of yacc.c */
5087 #line 828 "ripper.y"
5088  {
5089 #if 0
5090  (yyval.val) = NEW_BEGIN(0);
5091 #endif
5092  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5093  dispatch0(void_stmt));
5094 
5095  }
5096  break;
5097 
5098  case 6:
5099 
5100 /* Line 1806 of yacc.c */
5101 #line 837 "ripper.y"
5102  {
5103 #if 0
5104  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5105 #endif
5106  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5107 
5108  }
5109  break;
5110 
5111  case 7:
5112 
5113 /* Line 1806 of yacc.c */
5114 #line 845 "ripper.y"
5115  {
5116 #if 0
5117  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5118 #endif
5119  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5120 
5121  }
5122  break;
5123 
5124  case 8:
5125 
5126 /* Line 1806 of yacc.c */
5127 #line 853 "ripper.y"
5128  {
5129  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5130  }
5131  break;
5132 
5133  case 10:
5134 
5135 /* Line 1806 of yacc.c */
5136 #line 860 "ripper.y"
5137  {
5138  if (in_def || in_single) {
5139  yyerror("BEGIN in method");
5140  }
5141 #if 0
5142  /* local_push(0); */
5143 #endif
5144 
5145  }
5146  break;
5147 
5148  case 11:
5149 
5150 /* Line 1806 of yacc.c */
5151 #line 870 "ripper.y"
5152  {
5153 #if 0
5155  (yyvsp[(4) - (5)].val));
5156  /* NEW_PREEXE($4)); */
5157  /* local_pop(); */
5158  (yyval.val) = NEW_BEGIN(0);
5159 #endif
5160  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5161 
5162  }
5163  break;
5164 
5165  case 12:
5166 
5167 /* Line 1806 of yacc.c */
5168 #line 887 "ripper.y"
5169  {
5170 #if 0
5171  (yyval.val) = (yyvsp[(1) - (4)].val);
5172  if ((yyvsp[(2) - (4)].val)) {
5173  (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
5174  }
5175  else if ((yyvsp[(3) - (4)].val)) {
5176  rb_warn0("else without rescue is useless");
5177  (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val));
5178  }
5179  if ((yyvsp[(4) - (4)].val)) {
5180  if ((yyval.val)) {
5181  (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
5182  }
5183  else {
5184  (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL());
5185  }
5186  }
5187  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5188 #endif
5189  (yyval.val) = dispatch4(bodystmt,
5190  escape_Qundef((yyvsp[(1) - (4)].val)),
5191  escape_Qundef((yyvsp[(2) - (4)].val)),
5192  escape_Qundef((yyvsp[(3) - (4)].val)),
5193  escape_Qundef((yyvsp[(4) - (4)].val)));
5194 
5195  }
5196  break;
5197 
5198  case 13:
5199 
5200 /* Line 1806 of yacc.c */
5201 #line 917 "ripper.y"
5202  {
5203 #if 0
5204  void_stmts((yyvsp[(1) - (2)].val));
5206 #endif
5207 
5208  (yyval.val) = (yyvsp[(1) - (2)].val);
5209  }
5210  break;
5211 
5212  case 14:
5213 
5214 /* Line 1806 of yacc.c */
5215 #line 928 "ripper.y"
5216  {
5217 #if 0
5218  (yyval.val) = NEW_BEGIN(0);
5219 #endif
5220  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5221  dispatch0(void_stmt));
5222 
5223  }
5224  break;
5225 
5226  case 15:
5227 
5228 /* Line 1806 of yacc.c */
5229 #line 937 "ripper.y"
5230  {
5231 #if 0
5232  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5233 #endif
5234  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5235 
5236  }
5237  break;
5238 
5239  case 16:
5240 
5241 /* Line 1806 of yacc.c */
5242 #line 945 "ripper.y"
5243  {
5244 #if 0
5245  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5246 #endif
5247  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5248 
5249  }
5250  break;
5251 
5252  case 17:
5253 
5254 /* Line 1806 of yacc.c */
5255 #line 953 "ripper.y"
5256  {
5257  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5258  }
5259  break;
5260 
5261  case 18:
5262 
5263 /* Line 1806 of yacc.c */
5264 #line 958 "ripper.y"
5265  {lex_state = EXPR_FNAME;}
5266  break;
5267 
5268  case 19:
5269 
5270 /* Line 1806 of yacc.c */
5271 #line 959 "ripper.y"
5272  {
5273 #if 0
5274  (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5275 #endif
5276  (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5277 
5278  }
5279  break;
5280 
5281  case 20:
5282 
5283 /* Line 1806 of yacc.c */
5284 #line 967 "ripper.y"
5285  {
5286 #if 0
5287  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5288 #endif
5289  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5290 
5291  }
5292  break;
5293 
5294  case 21:
5295 
5296 /* Line 1806 of yacc.c */
5297 #line 975 "ripper.y"
5298  {
5299 #if 0
5300  char buf[2];
5301  buf[0] = '$';
5302  buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
5303  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
5304 #endif
5305  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5306 
5307  }
5308  break;
5309 
5310  case 22:
5311 
5312 /* Line 1806 of yacc.c */
5313 #line 986 "ripper.y"
5314  {
5315 #if 0
5316  yyerror("can't make alias for the number variables");
5317  (yyval.val) = NEW_BEGIN(0);
5318 #endif
5319  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5320  (yyval.val) = dispatch1(alias_error, (yyval.val));
5321 
5322  }
5323  break;
5324 
5325  case 23:
5326 
5327 /* Line 1806 of yacc.c */
5328 #line 996 "ripper.y"
5329  {
5330 #if 0
5331  (yyval.val) = (yyvsp[(2) - (2)].val);
5332 #endif
5333  (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
5334 
5335  }
5336  break;
5337 
5338  case 24:
5339 
5340 /* Line 1806 of yacc.c */
5341 #line 1004 "ripper.y"
5342  {
5343 #if 0
5344  (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5345  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5346 #endif
5347  (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5348 
5349  }
5350  break;
5351 
5352  case 25:
5353 
5354 /* Line 1806 of yacc.c */
5355 #line 1013 "ripper.y"
5356  {
5357 #if 0
5358  (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5359  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5360 #endif
5361  (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5362 
5363  }
5364  break;
5365 
5366  case 26:
5367 
5368 /* Line 1806 of yacc.c */
5369 #line 1022 "ripper.y"
5370  {
5371 #if 0
5372  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5373  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5374  }
5375  else {
5376  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5377  }
5378 #endif
5379  (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5380 
5381  }
5382  break;
5383 
5384  case 27:
5385 
5386 /* Line 1806 of yacc.c */
5387 #line 1035 "ripper.y"
5388  {
5389 #if 0
5390  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5391  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5392  }
5393  else {
5394  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5395  }
5396 #endif
5397  (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5398 
5399  }
5400  break;
5401 
5402  case 28:
5403 
5404 /* Line 1806 of yacc.c */
5405 #line 1048 "ripper.y"
5406  {
5407 #if 0
5408  NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0);
5409  (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0);
5410 #endif
5411  (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5412 
5413  }
5414  break;
5415 
5416  case 29:
5417 
5418 /* Line 1806 of yacc.c */
5419 #line 1057 "ripper.y"
5420  {
5421  if (in_def || in_single) {
5422  rb_warn0("END in method; use at_exit");
5423  }
5424 #if 0
5425  (yyval.val) = NEW_POSTEXE(NEW_NODE(
5426  NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */));
5427 #endif
5428  (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
5429 
5430  }
5431  break;
5432 
5433  case 31:
5434 
5435 /* Line 1806 of yacc.c */
5436 #line 1070 "ripper.y"
5437  {
5438 #if 0
5439  value_expr((yyvsp[(3) - (3)].val));
5440  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5441  (yyval.val) = (yyvsp[(1) - (3)].val);
5442 #endif
5443  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5444 
5445  }
5446  break;
5447 
5448  case 32:
5449 
5450 /* Line 1806 of yacc.c */
5451 #line 1080 "ripper.y"
5452  {
5453 #if 0
5454  value_expr((yyvsp[(3) - (3)].val));
5455  if ((yyvsp[(1) - (3)].val)) {
5456  ID vid = (yyvsp[(1) - (3)].val)->nd_vid;
5457  if ((yyvsp[(2) - (3)].val) == tOROP) {
5458  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5459  (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (3)].val));
5460  if (is_asgn_or_id(vid)) {
5461  (yyval.val)->nd_aid = vid;
5462  }
5463  }
5464  else if ((yyvsp[(2) - (3)].val) == tANDOP) {
5465  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5466  (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (3)].val));
5467  }
5468  else {
5469  (yyval.val) = (yyvsp[(1) - (3)].val);
5470  (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (3)].val), NEW_LIST((yyvsp[(3) - (3)].val)));
5471  }
5472  }
5473  else {
5474  (yyval.val) = NEW_BEGIN(0);
5475  }
5476 #endif
5477  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5478 
5479  }
5480  break;
5481 
5482  case 33:
5483 
5484 /* Line 1806 of yacc.c */
5485 #line 1109 "ripper.y"
5486  {
5487 #if 0
5488  NODE *args;
5489 
5490  value_expr((yyvsp[(6) - (6)].val));
5491  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
5492  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
5493  if ((yyvsp[(5) - (6)].val) == tOROP) {
5494  (yyvsp[(5) - (6)].val) = 0;
5495  }
5496  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
5497  (yyvsp[(5) - (6)].val) = 1;
5498  }
5499  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
5500  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
5501 #endif
5502  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
5503  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
5504 
5505  }
5506  break;
5507 
5508  case 34:
5509 
5510 /* Line 1806 of yacc.c */
5511 #line 1130 "ripper.y"
5512  {
5513 #if 0
5514  value_expr((yyvsp[(5) - (5)].val));
5515  if ((yyvsp[(4) - (5)].val) == tOROP) {
5516  (yyvsp[(4) - (5)].val) = 0;
5517  }
5518  else if ((yyvsp[(4) - (5)].val) == tANDOP) {
5519  (yyvsp[(4) - (5)].val) = 1;
5520  }
5521  (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5522  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
5523 #endif
5524  (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
5525  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5526 
5527  }
5528  break;
5529 
5530  case 35:
5531 
5532 /* Line 1806 of yacc.c */
5533 #line 1147 "ripper.y"
5534  {
5535 #if 0
5536  value_expr((yyvsp[(5) - (5)].val));
5537  if ((yyvsp[(4) - (5)].val) == tOROP) {
5538  (yyvsp[(4) - (5)].val) = 0;
5539  }
5540  else if ((yyvsp[(4) - (5)].val) == tANDOP) {
5541  (yyvsp[(4) - (5)].val) = 1;
5542  }
5543  (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5544  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
5545 #endif
5546  (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
5547  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5548 
5549  }
5550  break;
5551 
5552  case 36:
5553 
5554 /* Line 1806 of yacc.c */
5555 #line 1164 "ripper.y"
5556  {
5557 #if 0
5558  yyerror("constant re-assignment");
5559  (yyval.val) = 0;
5560 #endif
5561  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
5562  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5563  (yyval.val) = dispatch1(assign_error, (yyval.val));
5564 
5565  }
5566  break;
5567 
5568  case 37:
5569 
5570 /* Line 1806 of yacc.c */
5571 #line 1175 "ripper.y"
5572  {
5573 #if 0
5574  value_expr((yyvsp[(5) - (5)].val));
5575  if ((yyvsp[(4) - (5)].val) == tOROP) {
5576  (yyvsp[(4) - (5)].val) = 0;
5577  }
5578  else if ((yyvsp[(4) - (5)].val) == tANDOP) {
5579  (yyvsp[(4) - (5)].val) = 1;
5580  }
5581  (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5582  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
5583 #endif
5584  (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val));
5585  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5586 
5587  }
5588  break;
5589 
5590  case 38:
5591 
5592 /* Line 1806 of yacc.c */
5593 #line 1192 "ripper.y"
5594  {
5595 #if 0
5596  rb_backref_error((yyvsp[(1) - (3)].val));
5597  (yyval.val) = NEW_BEGIN(0);
5598 #endif
5599  (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
5600  (yyval.val) = dispatch1(assign_error, (yyval.val));
5601 
5602  }
5603  break;
5604 
5605  case 39:
5606 
5607 /* Line 1806 of yacc.c */
5608 #line 1202 "ripper.y"
5609  {
5610 #if 0
5611  value_expr((yyvsp[(3) - (3)].val));
5612  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5613 #endif
5614  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5615 
5616  }
5617  break;
5618 
5619  case 40:
5620 
5621 /* Line 1806 of yacc.c */
5622 #line 1211 "ripper.y"
5623  {
5624 #if 0
5625  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5626  (yyval.val) = (yyvsp[(1) - (3)].val);
5627 #endif
5628  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5629 
5630  }
5631  break;
5632 
5633  case 41:
5634 
5635 /* Line 1806 of yacc.c */
5636 #line 1220 "ripper.y"
5637  {
5638 #if 0
5639  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5640  (yyval.val) = (yyvsp[(1) - (3)].val);
5641 #endif
5642  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5643 
5644  }
5645  break;
5646 
5647  case 43:
5648 
5649 /* Line 1806 of yacc.c */
5650 #line 1232 "ripper.y"
5651  {
5652 #if 0
5653  value_expr((yyvsp[(3) - (3)].val));
5654  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5655 #endif
5656  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5657 
5658  }
5659  break;
5660 
5661  case 44:
5662 
5663 /* Line 1806 of yacc.c */
5664 #line 1241 "ripper.y"
5665  {
5666 #if 0
5667  value_expr((yyvsp[(3) - (3)].val));
5668  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5669 #endif
5670  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5671 
5672  }
5673  break;
5674 
5675  case 46:
5676 
5677 /* Line 1806 of yacc.c */
5678 #line 1254 "ripper.y"
5679  {
5680 #if 0
5681  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5682 #endif
5683  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val));
5684 
5685  }
5686  break;
5687 
5688  case 47:
5689 
5690 /* Line 1806 of yacc.c */
5691 #line 1262 "ripper.y"
5692  {
5693 #if 0
5694  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5695 #endif
5696  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val));
5697 
5698  }
5699  break;
5700 
5701  case 48:
5702 
5703 /* Line 1806 of yacc.c */
5704 #line 1270 "ripper.y"
5705  {
5706 #if 0
5707  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!');
5708 #endif
5709  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val));
5710 
5711  }
5712  break;
5713 
5714  case 49:
5715 
5716 /* Line 1806 of yacc.c */
5717 #line 1278 "ripper.y"
5718  {
5719 #if 0
5720  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
5721 #endif
5722  (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val));
5723 
5724  }
5725  break;
5726 
5727  case 51:
5728 
5729 /* Line 1806 of yacc.c */
5730 #line 1289 "ripper.y"
5731  {
5732 #if 0
5733  value_expr((yyvsp[(1) - (1)].val));
5734  (yyval.val) = (yyvsp[(1) - (1)].val);
5735  if (!(yyval.val)) (yyval.val) = NEW_NIL();
5736 #endif
5737  (yyval.val) = (yyvsp[(1) - (1)].val);
5738 
5739  }
5740  break;
5741 
5742  case 55:
5743 
5744 /* Line 1806 of yacc.c */
5745 #line 1306 "ripper.y"
5746  {
5747 #if 0
5748  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5749 #endif
5750  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
5751  (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
5752 
5753  }
5754  break;
5755 
5756  case 56:
5757 
5758 /* Line 1806 of yacc.c */
5759 #line 1315 "ripper.y"
5760  {
5761 #if 0
5762  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5763 #endif
5764  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val));
5765  (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
5766 
5767  }
5768  break;
5769 
5770  case 57:
5771 
5772 /* Line 1806 of yacc.c */
5773 #line 1326 "ripper.y"
5774  {
5775  (yyvsp[(1) - (1)].vars) = dyna_push();
5776 #if 0
5777  (yyval.num) = ruby_sourceline;
5778 #endif
5779 
5780  }
5781  break;
5782 
5783  case 58:
5784 
5785 /* Line 1806 of yacc.c */
5786 #line 1336 "ripper.y"
5787  {
5788 #if 0
5789  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
5790  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
5791 #endif
5792  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
5793 
5794  dyna_pop((yyvsp[(1) - (5)].vars));
5795  }
5796  break;
5797 
5798  case 59:
5799 
5800 /* Line 1806 of yacc.c */
5801 #line 1348 "ripper.y"
5802  {
5803 #if 0
5804  (yyval.val) = NEW_FCALL((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
5805  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
5806 #endif
5807  (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
5808 
5809  }
5810  break;
5811 
5812  case 60:
5813 
5814 /* Line 1806 of yacc.c */
5815 #line 1357 "ripper.y"
5816  {
5817 #if 0
5818  block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
5819  (yyvsp[(3) - (3)].val)->nd_iter = NEW_FCALL((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
5820  (yyval.val) = (yyvsp[(3) - (3)].val);
5821  fixpos((yyval.val), (yyvsp[(2) - (3)].val));
5822 #endif
5823  (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
5824  (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
5825 
5826  }
5827  break;
5828 
5829  case 61:
5830 
5831 /* Line 1806 of yacc.c */
5832 #line 1369 "ripper.y"
5833  {
5834 #if 0
5835  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5836  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5837 #endif
5838  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5839 
5840  }
5841  break;
5842 
5843  case 62:
5844 
5845 /* Line 1806 of yacc.c */
5846 #line 1378 "ripper.y"
5847  {
5848 #if 0
5849  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
5850  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
5851  (yyval.val) = (yyvsp[(5) - (5)].val);
5852  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
5853 #endif
5854  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
5855  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
5856 
5857  }
5858  break;
5859 
5860  case 63:
5861 
5862 /* Line 1806 of yacc.c */
5863 #line 1390 "ripper.y"
5864  {
5865 #if 0
5866  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5867  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5868 #endif
5869  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5870 
5871  }
5872  break;
5873 
5874  case 64:
5875 
5876 /* Line 1806 of yacc.c */
5877 #line 1399 "ripper.y"
5878  {
5879 #if 0
5880  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
5881  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
5882  (yyval.val) = (yyvsp[(5) - (5)].val);
5883  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
5884 #endif
5885  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
5886  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
5887 
5888  }
5889  break;
5890 
5891  case 65:
5892 
5893 /* Line 1806 of yacc.c */
5894 #line 1411 "ripper.y"
5895  {
5896 #if 0
5897  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
5898  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
5899 #endif
5900  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
5901 
5902  }
5903  break;
5904 
5905  case 66:
5906 
5907 /* Line 1806 of yacc.c */
5908 #line 1420 "ripper.y"
5909  {
5910 #if 0
5911  (yyval.val) = new_yield((yyvsp[(2) - (2)].val));
5912  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
5913 #endif
5914  (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
5915 
5916  }
5917  break;
5918 
5919  case 67:
5920 
5921 /* Line 1806 of yacc.c */
5922 #line 1429 "ripper.y"
5923  {
5924 #if 0
5925  (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
5926 #endif
5927  (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
5928 
5929  }
5930  break;
5931 
5932  case 68:
5933 
5934 /* Line 1806 of yacc.c */
5935 #line 1437 "ripper.y"
5936  {
5937 #if 0
5938  (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
5939 #endif
5940  (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
5941 
5942  }
5943  break;
5944 
5945  case 69:
5946 
5947 /* Line 1806 of yacc.c */
5948 #line 1445 "ripper.y"
5949  {
5950 #if 0
5951  (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
5952 #endif
5953  (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
5954 
5955  }
5956  break;
5957 
5958  case 71:
5959 
5960 /* Line 1806 of yacc.c */
5961 #line 1456 "ripper.y"
5962  {
5963 #if 0
5964  (yyval.val) = (yyvsp[(2) - (3)].val);
5965 #endif
5966  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
5967 
5968  }
5969  break;
5970 
5971  case 73:
5972 
5973 /* Line 1806 of yacc.c */
5974 #line 1467 "ripper.y"
5975  {
5976 #if 0
5977  (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0);
5978 #endif
5979  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
5980 
5981  }
5982  break;
5983 
5984  case 74:
5985 
5986 /* Line 1806 of yacc.c */
5987 #line 1477 "ripper.y"
5988  {
5989 #if 0
5990  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
5991 #endif
5992  (yyval.val) = (yyvsp[(1) - (1)].val);
5993 
5994  }
5995  break;
5996 
5997  case 75:
5998 
5999 /* Line 1806 of yacc.c */
6000 #line 1485 "ripper.y"
6001  {
6002 #if 0
6003  (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0);
6004 #endif
6005  (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
6006 
6007  }
6008  break;
6009 
6010  case 76:
6011 
6012 /* Line 1806 of yacc.c */
6013 #line 1493 "ripper.y"
6014  {
6015 #if 0
6016  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6017 #endif
6018  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6019 
6020  }
6021  break;
6022 
6023  case 77:
6024 
6025 /* Line 1806 of yacc.c */
6026 #line 1501 "ripper.y"
6027  {
6028 #if 0
6029  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val)));
6030 #endif
6031  (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6032  (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
6033 
6034  }
6035  break;
6036 
6037  case 78:
6038 
6039 /* Line 1806 of yacc.c */
6040 #line 1510 "ripper.y"
6041  {
6042 #if 0
6043  (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1);
6044 #endif
6045  (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
6046 
6047  }
6048  break;
6049 
6050  case 79:
6051 
6052 /* Line 1806 of yacc.c */
6053 #line 1518 "ripper.y"
6054  {
6055 #if 0
6056  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
6057 #endif
6058  (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
6059  (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6060 
6061  }
6062  break;
6063 
6064  case 80:
6065 
6066 /* Line 1806 of yacc.c */
6067 #line 1527 "ripper.y"
6068  {
6069 #if 0
6070  (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
6071 #endif
6072  (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
6073 
6074  }
6075  break;
6076 
6077  case 81:
6078 
6079 /* Line 1806 of yacc.c */
6080 #line 1535 "ripper.y"
6081  {
6082 #if 0
6083  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
6084 #endif
6085  (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
6086  (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
6087 
6088  }
6089  break;
6090 
6091  case 82:
6092 
6093 /* Line 1806 of yacc.c */
6094 #line 1544 "ripper.y"
6095  {
6096 #if 0
6097  (yyval.val) = NEW_MASGN(0, -1);
6098 #endif
6099  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6100 
6101  }
6102  break;
6103 
6104  case 83:
6105 
6106 /* Line 1806 of yacc.c */
6107 #line 1552 "ripper.y"
6108  {
6109 #if 0
6110  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
6111 #endif
6112  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6113  (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
6114 
6115  }
6116  break;
6117 
6118  case 85:
6119 
6120 /* Line 1806 of yacc.c */
6121 #line 1564 "ripper.y"
6122  {
6123 #if 0
6124  (yyval.val) = (yyvsp[(2) - (3)].val);
6125 #endif
6126  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6127 
6128  }
6129  break;
6130 
6131  case 86:
6132 
6133 /* Line 1806 of yacc.c */
6134 #line 1574 "ripper.y"
6135  {
6136 #if 0
6137  (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
6138 #endif
6139  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
6140 
6141  }
6142  break;
6143 
6144  case 87:
6145 
6146 /* Line 1806 of yacc.c */
6147 #line 1582 "ripper.y"
6148  {
6149 #if 0
6150  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6151 #endif
6152  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6153 
6154  }
6155  break;
6156 
6157  case 88:
6158 
6159 /* Line 1806 of yacc.c */
6160 #line 1592 "ripper.y"
6161  {
6162 #if 0
6163  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
6164 #endif
6165  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
6166 
6167  }
6168  break;
6169 
6170  case 89:
6171 
6172 /* Line 1806 of yacc.c */
6173 #line 1600 "ripper.y"
6174  {
6175 #if 0
6176  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6177 #endif
6178  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6179 
6180  }
6181  break;
6182 
6183  case 90:
6184 
6185 /* Line 1806 of yacc.c */
6186 #line 1610 "ripper.y"
6187  {
6188  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6189  }
6190  break;
6191 
6192  case 91:
6193 
6194 /* Line 1806 of yacc.c */
6195 #line 1614 "ripper.y"
6196  {
6197  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6198  }
6199  break;
6200 
6201  case 92:
6202 
6203 /* Line 1806 of yacc.c */
6204 #line 1618 "ripper.y"
6205  {
6206 #if 0
6207  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6208 #endif
6209  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6210 
6211  }
6212  break;
6213 
6214  case 93:
6215 
6216 /* Line 1806 of yacc.c */
6217 #line 1626 "ripper.y"
6218  {
6219 #if 0
6220  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6221 #endif
6222  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6223 
6224  }
6225  break;
6226 
6227  case 94:
6228 
6229 /* Line 1806 of yacc.c */
6230 #line 1634 "ripper.y"
6231  {
6232 #if 0
6233  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6234 #endif
6235  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6236 
6237  }
6238  break;
6239 
6240  case 95:
6241 
6242 /* Line 1806 of yacc.c */
6243 #line 1642 "ripper.y"
6244  {
6245 #if 0
6246  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6247 #endif
6248  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6249 
6250  }
6251  break;
6252 
6253  case 96:
6254 
6255 /* Line 1806 of yacc.c */
6256 #line 1650 "ripper.y"
6257  {
6258 #if 0
6259  if (in_def || in_single)
6260  yyerror("dynamic constant assignment");
6261  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6262 #endif
6263  if (in_def || in_single)
6264  yyerror("dynamic constant assignment");
6265  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6266 
6267  }
6268  break;
6269 
6270  case 97:
6271 
6272 /* Line 1806 of yacc.c */
6273 #line 1662 "ripper.y"
6274  {
6275 #if 0
6276  if (in_def || in_single)
6277  yyerror("dynamic constant assignment");
6278  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6279 #endif
6280  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6281 
6282  }
6283  break;
6284 
6285  case 98:
6286 
6287 /* Line 1806 of yacc.c */
6288 #line 1672 "ripper.y"
6289  {
6290 #if 0
6291  rb_backref_error((yyvsp[(1) - (1)].val));
6292  (yyval.val) = NEW_BEGIN(0);
6293 #endif
6294  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val));
6295  (yyval.val) = dispatch1(assign_error, (yyval.val));
6296 
6297  }
6298  break;
6299 
6300  case 99:
6301 
6302 /* Line 1806 of yacc.c */
6303 #line 1684 "ripper.y"
6304  {
6305  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6306 #if 0
6307  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6308 #endif
6309  (yyval.val) = dispatch1(var_field, (yyval.val));
6310 
6311  }
6312  break;
6313 
6314  case 100:
6315 
6316 /* Line 1806 of yacc.c */
6317 #line 1693 "ripper.y"
6318  {
6319  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6320 #if 0
6321  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6322 #endif
6323  (yyval.val) = dispatch1(var_field, (yyval.val));
6324 
6325  }
6326  break;
6327 
6328  case 101:
6329 
6330 /* Line 1806 of yacc.c */
6331 #line 1702 "ripper.y"
6332  {
6333 #if 0
6334  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6335 #endif
6336  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6337 
6338  }
6339  break;
6340 
6341  case 102:
6342 
6343 /* Line 1806 of yacc.c */
6344 #line 1710 "ripper.y"
6345  {
6346 #if 0
6347  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6348 #endif
6349  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6350 
6351  }
6352  break;
6353 
6354  case 103:
6355 
6356 /* Line 1806 of yacc.c */
6357 #line 1718 "ripper.y"
6358  {
6359 #if 0
6360  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6361 #endif
6362  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
6363 
6364  }
6365  break;
6366 
6367  case 104:
6368 
6369 /* Line 1806 of yacc.c */
6370 #line 1726 "ripper.y"
6371  {
6372 #if 0
6373  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6374 #endif
6375  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6376 
6377  }
6378  break;
6379 
6380  case 105:
6381 
6382 /* Line 1806 of yacc.c */
6383 #line 1734 "ripper.y"
6384  {
6385 #if 0
6386  if (in_def || in_single)
6387  yyerror("dynamic constant assignment");
6388  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6389 #endif
6390  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6391  if (in_def || in_single) {
6392  (yyval.val) = dispatch1(assign_error, (yyval.val));
6393  }
6394 
6395  }
6396  break;
6397 
6398  case 106:
6399 
6400 /* Line 1806 of yacc.c */
6401 #line 1747 "ripper.y"
6402  {
6403 #if 0
6404  if (in_def || in_single)
6405  yyerror("dynamic constant assignment");
6406  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6407 #endif
6408  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6409  if (in_def || in_single) {
6410  (yyval.val) = dispatch1(assign_error, (yyval.val));
6411  }
6412 
6413  }
6414  break;
6415 
6416  case 107:
6417 
6418 /* Line 1806 of yacc.c */
6419 #line 1760 "ripper.y"
6420  {
6421 #if 0
6422  rb_backref_error((yyvsp[(1) - (1)].val));
6423  (yyval.val) = NEW_BEGIN(0);
6424 #endif
6425  (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val));
6426 
6427  }
6428  break;
6429 
6430  case 108:
6431 
6432 /* Line 1806 of yacc.c */
6433 #line 1771 "ripper.y"
6434  {
6435 #if 0
6436  yyerror("class/module name must be CONSTANT");
6437 #endif
6438  (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
6439 
6440  }
6441  break;
6442 
6443  case 110:
6444 
6445 /* Line 1806 of yacc.c */
6446 #line 1782 "ripper.y"
6447  {
6448 #if 0
6449  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
6450 #endif
6451  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
6452 
6453  }
6454  break;
6455 
6456  case 111:
6457 
6458 /* Line 1806 of yacc.c */
6459 #line 1790 "ripper.y"
6460  {
6461 #if 0
6462  (yyval.val) = NEW_COLON2(0, (yyval.val));
6463 #endif
6464  (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
6465 
6466  }
6467  break;
6468 
6469  case 112:
6470 
6471 /* Line 1806 of yacc.c */
6472 #line 1798 "ripper.y"
6473  {
6474 #if 0
6475  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6476 #endif
6477  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6478 
6479  }
6480  break;
6481 
6482  case 116:
6483 
6484 /* Line 1806 of yacc.c */
6485 #line 1811 "ripper.y"
6486  {
6488  (yyval.val) = (yyvsp[(1) - (1)].val);
6489  }
6490  break;
6491 
6492  case 117:
6493 
6494 /* Line 1806 of yacc.c */
6495 #line 1816 "ripper.y"
6496  {
6498 #if 0
6499  (yyval.val) = (yyvsp[(1) - (1)].id);
6500 #endif
6501  (yyval.val) = (yyvsp[(1) - (1)].val);
6502 
6503  }
6504  break;
6505 
6506  case 120:
6507 
6508 /* Line 1806 of yacc.c */
6509 #line 1831 "ripper.y"
6510  {
6511 #if 0
6512  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
6513 #endif
6514  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
6515 
6516  }
6517  break;
6518 
6519  case 122:
6520 
6521 /* Line 1806 of yacc.c */
6522 #line 1842 "ripper.y"
6523  {
6524 #if 0
6525  (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
6526 #endif
6527  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
6528 
6529  }
6530  break;
6531 
6532  case 123:
6533 
6534 /* Line 1806 of yacc.c */
6535 #line 1849 "ripper.y"
6536  {lex_state = EXPR_FNAME;}
6537  break;
6538 
6539  case 124:
6540 
6541 /* Line 1806 of yacc.c */
6542 #line 1850 "ripper.y"
6543  {
6544 #if 0
6545  (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
6546 #endif
6547  rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6548 
6549  }
6550  break;
6551 
6552  case 125:
6553 
6554 /* Line 1806 of yacc.c */
6555 #line 1859 "ripper.y"
6556  { ifndef_ripper((yyval.val) = '|'); }
6557  break;
6558 
6559  case 126:
6560 
6561 /* Line 1806 of yacc.c */
6562 #line 1860 "ripper.y"
6563  { ifndef_ripper((yyval.val) = '^'); }
6564  break;
6565 
6566  case 127:
6567 
6568 /* Line 1806 of yacc.c */
6569 #line 1861 "ripper.y"
6570  { ifndef_ripper((yyval.val) = '&'); }
6571  break;
6572 
6573  case 128:
6574 
6575 /* Line 1806 of yacc.c */
6576 #line 1862 "ripper.y"
6577  { ifndef_ripper((yyval.val) = tCMP); }
6578  break;
6579 
6580  case 129:
6581 
6582 /* Line 1806 of yacc.c */
6583 #line 1863 "ripper.y"
6584  { ifndef_ripper((yyval.val) = tEQ); }
6585  break;
6586 
6587  case 130:
6588 
6589 /* Line 1806 of yacc.c */
6590 #line 1864 "ripper.y"
6591  { ifndef_ripper((yyval.val) = tEQQ); }
6592  break;
6593 
6594  case 131:
6595 
6596 /* Line 1806 of yacc.c */
6597 #line 1865 "ripper.y"
6598  { ifndef_ripper((yyval.val) = tMATCH); }
6599  break;
6600 
6601  case 132:
6602 
6603 /* Line 1806 of yacc.c */
6604 #line 1866 "ripper.y"
6605  { ifndef_ripper((yyval.val) = tNMATCH); }
6606  break;
6607 
6608  case 133:
6609 
6610 /* Line 1806 of yacc.c */
6611 #line 1867 "ripper.y"
6612  { ifndef_ripper((yyval.val) = '>'); }
6613  break;
6614 
6615  case 134:
6616 
6617 /* Line 1806 of yacc.c */
6618 #line 1868 "ripper.y"
6619  { ifndef_ripper((yyval.val) = tGEQ); }
6620  break;
6621 
6622  case 135:
6623 
6624 /* Line 1806 of yacc.c */
6625 #line 1869 "ripper.y"
6626  { ifndef_ripper((yyval.val) = '<'); }
6627  break;
6628 
6629  case 136:
6630 
6631 /* Line 1806 of yacc.c */
6632 #line 1870 "ripper.y"
6633  { ifndef_ripper((yyval.val) = tLEQ); }
6634  break;
6635 
6636  case 137:
6637 
6638 /* Line 1806 of yacc.c */
6639 #line 1871 "ripper.y"
6640  { ifndef_ripper((yyval.val) = tNEQ); }
6641  break;
6642 
6643  case 138:
6644 
6645 /* Line 1806 of yacc.c */
6646 #line 1872 "ripper.y"
6647  { ifndef_ripper((yyval.val) = tLSHFT); }
6648  break;
6649 
6650  case 139:
6651 
6652 /* Line 1806 of yacc.c */
6653 #line 1873 "ripper.y"
6654  { ifndef_ripper((yyval.val) = tRSHFT); }
6655  break;
6656 
6657  case 140:
6658 
6659 /* Line 1806 of yacc.c */
6660 #line 1874 "ripper.y"
6661  { ifndef_ripper((yyval.val) = '+'); }
6662  break;
6663 
6664  case 141:
6665 
6666 /* Line 1806 of yacc.c */
6667 #line 1875 "ripper.y"
6668  { ifndef_ripper((yyval.val) = '-'); }
6669  break;
6670 
6671  case 142:
6672 
6673 /* Line 1806 of yacc.c */
6674 #line 1876 "ripper.y"
6675  { ifndef_ripper((yyval.val) = '*'); }
6676  break;
6677 
6678  case 143:
6679 
6680 /* Line 1806 of yacc.c */
6681 #line 1877 "ripper.y"
6682  { ifndef_ripper((yyval.val) = '*'); }
6683  break;
6684 
6685  case 144:
6686 
6687 /* Line 1806 of yacc.c */
6688 #line 1878 "ripper.y"
6689  { ifndef_ripper((yyval.val) = '/'); }
6690  break;
6691 
6692  case 145:
6693 
6694 /* Line 1806 of yacc.c */
6695 #line 1879 "ripper.y"
6696  { ifndef_ripper((yyval.val) = '%'); }
6697  break;
6698 
6699  case 146:
6700 
6701 /* Line 1806 of yacc.c */
6702 #line 1880 "ripper.y"
6703  { ifndef_ripper((yyval.val) = tPOW); }
6704  break;
6705 
6706  case 147:
6707 
6708 /* Line 1806 of yacc.c */
6709 #line 1881 "ripper.y"
6710  { ifndef_ripper((yyval.val) = '!'); }
6711  break;
6712 
6713  case 148:
6714 
6715 /* Line 1806 of yacc.c */
6716 #line 1882 "ripper.y"
6717  { ifndef_ripper((yyval.val) = '~'); }
6718  break;
6719 
6720  case 149:
6721 
6722 /* Line 1806 of yacc.c */
6723 #line 1883 "ripper.y"
6724  { ifndef_ripper((yyval.val) = tUPLUS); }
6725  break;
6726 
6727  case 150:
6728 
6729 /* Line 1806 of yacc.c */
6730 #line 1884 "ripper.y"
6731  { ifndef_ripper((yyval.val) = tUMINUS); }
6732  break;
6733 
6734  case 151:
6735 
6736 /* Line 1806 of yacc.c */
6737 #line 1885 "ripper.y"
6738  { ifndef_ripper((yyval.val) = tAREF); }
6739  break;
6740 
6741  case 152:
6742 
6743 /* Line 1806 of yacc.c */
6744 #line 1886 "ripper.y"
6745  { ifndef_ripper((yyval.val) = tASET); }
6746  break;
6747 
6748  case 153:
6749 
6750 /* Line 1806 of yacc.c */
6751 #line 1887 "ripper.y"
6752  { ifndef_ripper((yyval.val) = '`'); }
6753  break;
6754 
6755  case 195:
6756 
6757 /* Line 1806 of yacc.c */
6758 #line 1905 "ripper.y"
6759  {
6760 #if 0
6761  value_expr((yyvsp[(3) - (3)].val));
6762  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6763 #endif
6764  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6765 
6766  }
6767  break;
6768 
6769  case 196:
6770 
6771 /* Line 1806 of yacc.c */
6772 #line 1914 "ripper.y"
6773  {
6774 #if 0
6775  value_expr((yyvsp[(3) - (5)].val));
6776  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6777  (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6778 #endif
6779  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)));
6780 
6781  }
6782  break;
6783 
6784  case 197:
6785 
6786 /* Line 1806 of yacc.c */
6787 #line 1924 "ripper.y"
6788  {
6789 #if 0
6790  value_expr((yyvsp[(3) - (3)].val));
6791  if ((yyvsp[(1) - (3)].val)) {
6792  ID vid = (yyvsp[(1) - (3)].val)->nd_vid;
6793  if ((yyvsp[(2) - (3)].val) == tOROP) {
6794  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
6795  (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (3)].val));
6796  if (is_asgn_or_id(vid)) {
6797  (yyval.val)->nd_aid = vid;
6798  }
6799  }
6800  else if ((yyvsp[(2) - (3)].val) == tANDOP) {
6801  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
6802  (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (3)].val));
6803  }
6804  else {
6805  (yyval.val) = (yyvsp[(1) - (3)].val);
6806  (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (3)].val), NEW_LIST((yyvsp[(3) - (3)].val)));
6807  }
6808  }
6809  else {
6810  (yyval.val) = NEW_BEGIN(0);
6811  }
6812 #endif
6813  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
6814 
6815  }
6816  break;
6817 
6818  case 198:
6819 
6820 /* Line 1806 of yacc.c */
6821 #line 1953 "ripper.y"
6822  {
6823 #if 0
6824  value_expr((yyvsp[(3) - (5)].val));
6825  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6826  if ((yyvsp[(1) - (5)].val)) {
6827  ID vid = (yyvsp[(1) - (5)].val)->nd_vid;
6828  if ((yyvsp[(2) - (5)].val) == tOROP) {
6829  (yyvsp[(1) - (5)].val)->nd_value = (yyvsp[(3) - (5)].val);
6830  (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (5)].val));
6831  if (is_asgn_or_id(vid)) {
6832  (yyval.val)->nd_aid = vid;
6833  }
6834  }
6835  else if ((yyvsp[(2) - (5)].val) == tANDOP) {
6836  (yyvsp[(1) - (5)].val)->nd_value = (yyvsp[(3) - (5)].val);
6837  (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (5)].val));
6838  }
6839  else {
6840  (yyval.val) = (yyvsp[(1) - (5)].val);
6841  (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (5)].val), NEW_LIST((yyvsp[(3) - (5)].val)));
6842  }
6843  }
6844  else {
6845  (yyval.val) = NEW_BEGIN(0);
6846  }
6847 #endif
6848  (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
6849  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val));
6850 
6851  }
6852  break;
6853 
6854  case 199:
6855 
6856 /* Line 1806 of yacc.c */
6857 #line 1984 "ripper.y"
6858  {
6859 #if 0
6860  NODE *args;
6861 
6862  value_expr((yyvsp[(6) - (6)].val));
6863  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
6864  if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
6865  args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6866  }
6867  else {
6868  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6869  }
6870  if ((yyvsp[(5) - (6)].val) == tOROP) {
6871  (yyvsp[(5) - (6)].val) = 0;
6872  }
6873  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
6874  (yyvsp[(5) - (6)].val) = 1;
6875  }
6876  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
6877  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
6878 #endif
6879  (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
6880  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
6881 
6882  }
6883  break;
6884 
6885  case 200:
6886 
6887 /* Line 1806 of yacc.c */
6888 #line 2010 "ripper.y"
6889  {
6890 #if 0
6891  value_expr((yyvsp[(5) - (5)].val));
6892  if ((yyvsp[(4) - (5)].val) == tOROP) {
6893  (yyvsp[(4) - (5)].val) = 0;
6894  }
6895  else if ((yyvsp[(4) - (5)].val) == tANDOP) {
6896  (yyvsp[(4) - (5)].val) = 1;
6897  }
6898  (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6899  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6900 #endif
6901  (yyvsp[(1) - (5)].val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
6902  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6903 
6904  }
6905  break;
6906 
6907  case 201:
6908 
6909 /* Line 1806 of yacc.c */
6910 #line 2027 "ripper.y"
6911  {
6912 #if 0
6913  value_expr((yyvsp[(5) - (5)].val));
6914  if ((yyvsp[(4) - (5)].val) == tOROP) {
6915  (yyvsp[(4) - (5)].val) = 0;
6916  }
6917  else if ((yyvsp[(4) - (5)].val) == tANDOP) {
6918  (yyvsp[(4) - (5)].val) = 1;
6919  }
6920  (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6921  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6922 #endif
6923  (yyvsp[(1) - (5)].val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
6924  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6925 
6926  }
6927  break;
6928 
6929  case 202:
6930 
6931 /* Line 1806 of yacc.c */
6932 #line 2044 "ripper.y"
6933  {
6934 #if 0
6935  value_expr((yyvsp[(5) - (5)].val));
6936  if ((yyvsp[(4) - (5)].val) == tOROP) {
6937  (yyvsp[(4) - (5)].val) = 0;
6938  }
6939  else if ((yyvsp[(4) - (5)].val) == tANDOP) {
6940  (yyvsp[(4) - (5)].val) = 1;
6941  }
6942  (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6943  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6944 #endif
6945  (yyvsp[(1) - (5)].val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val));
6946  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6947 
6948  }
6949  break;
6950 
6951  case 203:
6952 
6953 /* Line 1806 of yacc.c */
6954 #line 2061 "ripper.y"
6955  {
6956 #if 0
6957  yyerror("constant re-assignment");
6958  (yyval.val) = NEW_BEGIN(0);
6959 #endif
6960  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6961  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
6962  (yyval.val) = dispatch1(assign_error, (yyval.val));
6963 
6964  }
6965  break;
6966 
6967  case 204:
6968 
6969 /* Line 1806 of yacc.c */
6970 #line 2072 "ripper.y"
6971  {
6972 #if 0
6973  yyerror("constant re-assignment");
6974  (yyval.val) = NEW_BEGIN(0);
6975 #endif
6976  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val));
6977  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6978  (yyval.val) = dispatch1(assign_error, (yyval.val));
6979 
6980  }
6981  break;
6982 
6983  case 205:
6984 
6985 /* Line 1806 of yacc.c */
6986 #line 2083 "ripper.y"
6987  {
6988 #if 0
6989  rb_backref_error((yyvsp[(1) - (3)].val));
6990  (yyval.val) = NEW_BEGIN(0);
6991 #endif
6992  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val));
6993  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
6994  (yyval.val) = dispatch1(assign_error, (yyval.val));
6995 
6996  }
6997  break;
6998 
6999  case 206:
7000 
7001 /* Line 1806 of yacc.c */
7002 #line 2094 "ripper.y"
7003  {
7004 #if 0
7005  value_expr((yyvsp[(1) - (3)].val));
7006  value_expr((yyvsp[(3) - (3)].val));
7007  (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7008  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7009  nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7011  }
7012 #endif
7013  (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7014 
7015  }
7016  break;
7017 
7018  case 207:
7019 
7020 /* Line 1806 of yacc.c */
7021 #line 2108 "ripper.y"
7022  {
7023 #if 0
7024  value_expr((yyvsp[(1) - (3)].val));
7025  value_expr((yyvsp[(3) - (3)].val));
7026  (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7027  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7028  nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7030  }
7031 #endif
7032  (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7033 
7034  }
7035  break;
7036 
7037  case 208:
7038 
7039 /* Line 1806 of yacc.c */
7040 #line 2122 "ripper.y"
7041  {
7042 #if 0
7043  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
7044 #endif
7045  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val));
7046 
7047  }
7048  break;
7049 
7050  case 209:
7051 
7052 /* Line 1806 of yacc.c */
7053 #line 2130 "ripper.y"
7054  {
7055 #if 0
7056  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
7057 #endif
7058  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val));
7059 
7060  }
7061  break;
7062 
7063  case 210:
7064 
7065 /* Line 1806 of yacc.c */
7066 #line 2138 "ripper.y"
7067  {
7068 #if 0
7069  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
7070 #endif
7071  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val));
7072 
7073  }
7074  break;
7075 
7076  case 211:
7077 
7078 /* Line 1806 of yacc.c */
7079 #line 2146 "ripper.y"
7080  {
7081 #if 0
7082  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
7083 #endif
7084  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val));
7085 
7086  }
7087  break;
7088 
7089  case 212:
7090 
7091 /* Line 1806 of yacc.c */
7092 #line 2154 "ripper.y"
7093  {
7094 #if 0
7095  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
7096 #endif
7097  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val));
7098 
7099  }
7100  break;
7101 
7102  case 213:
7103 
7104 /* Line 1806 of yacc.c */
7105 #line 2162 "ripper.y"
7106  {
7107 #if 0
7108  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
7109 #endif
7110  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val));
7111 
7112  }
7113  break;
7114 
7115  case 214:
7116 
7117 /* Line 1806 of yacc.c */
7118 #line 2170 "ripper.y"
7119  {
7120 #if 0
7121  (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
7122 #endif
7123  (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
7124  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
7125 
7126  }
7127  break;
7128 
7129  case 215:
7130 
7131 /* Line 1806 of yacc.c */
7132 #line 2179 "ripper.y"
7133  {
7134 #if 0
7135  (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
7136 #endif
7137  (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
7138  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
7139 
7140  }
7141  break;
7142 
7143  case 216:
7144 
7145 /* Line 1806 of yacc.c */
7146 #line 2188 "ripper.y"
7147  {
7148 #if 0
7149  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
7150 #endif
7151  (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val));
7152 
7153  }
7154  break;
7155 
7156  case 217:
7157 
7158 /* Line 1806 of yacc.c */
7159 #line 2196 "ripper.y"
7160  {
7161 #if 0
7162  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
7163 #endif
7164  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
7165 
7166  }
7167  break;
7168 
7169  case 218:
7170 
7171 /* Line 1806 of yacc.c */
7172 #line 2204 "ripper.y"
7173  {
7174 #if 0
7175  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val));
7176 #endif
7177  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('|'), (yyvsp[(3) - (3)].val));
7178 
7179  }
7180  break;
7181 
7182  case 219:
7183 
7184 /* Line 1806 of yacc.c */
7185 #line 2212 "ripper.y"
7186  {
7187 #if 0
7188  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
7189 #endif
7190  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val));
7191 
7192  }
7193  break;
7194 
7195  case 220:
7196 
7197 /* Line 1806 of yacc.c */
7198 #line 2220 "ripper.y"
7199  {
7200 #if 0
7201  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
7202 #endif
7203  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val));
7204 
7205  }
7206  break;
7207 
7208  case 221:
7209 
7210 /* Line 1806 of yacc.c */
7211 #line 2228 "ripper.y"
7212  {
7213 #if 0
7214  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
7215 #endif
7216  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val));
7217 
7218  }
7219  break;
7220 
7221  case 222:
7222 
7223 /* Line 1806 of yacc.c */
7224 #line 2236 "ripper.y"
7225  {
7226 #if 0
7227  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
7228 #endif
7229  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val));
7230 
7231  }
7232  break;
7233 
7234  case 223:
7235 
7236 /* Line 1806 of yacc.c */
7237 #line 2244 "ripper.y"
7238  {
7239 #if 0
7240  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
7241 #endif
7242  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val));
7243 
7244  }
7245  break;
7246 
7247  case 224:
7248 
7249 /* Line 1806 of yacc.c */
7250 #line 2252 "ripper.y"
7251  {
7252 #if 0
7253  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
7254 #endif
7255  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val));
7256 
7257  }
7258  break;
7259 
7260  case 225:
7261 
7262 /* Line 1806 of yacc.c */
7263 #line 2260 "ripper.y"
7264  {
7265 #if 0
7266  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
7267 #endif
7268  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val));
7269 
7270  }
7271  break;
7272 
7273  case 226:
7274 
7275 /* Line 1806 of yacc.c */
7276 #line 2268 "ripper.y"
7277  {
7278 #if 0
7279  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
7280 #endif
7281  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val));
7282 
7283  }
7284  break;
7285 
7286  case 227:
7287 
7288 /* Line 1806 of yacc.c */
7289 #line 2276 "ripper.y"
7290  {
7291 #if 0
7292  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
7293 #endif
7294  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val));
7295 
7296  }
7297  break;
7298 
7299  case 228:
7300 
7301 /* Line 1806 of yacc.c */
7302 #line 2284 "ripper.y"
7303  {
7304 #if 0
7305  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
7306 #endif
7307  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val));
7308 
7309  }
7310  break;
7311 
7312  case 229:
7313 
7314 /* Line 1806 of yacc.c */
7315 #line 2292 "ripper.y"
7316  {
7317 #if 0
7318  (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7319  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && TYPE((yyvsp[(1) - (3)].val)->nd_lit) == T_REGEXP) {
7320  (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val));
7321  }
7322 #endif
7323  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val));
7324 
7325  }
7326  break;
7327 
7328  case 230:
7329 
7330 /* Line 1806 of yacc.c */
7331 #line 2303 "ripper.y"
7332  {
7333 #if 0
7334  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val));
7335 #endif
7336  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!~"), (yyvsp[(3) - (3)].val));
7337 
7338  }
7339  break;
7340 
7341  case 231:
7342 
7343 /* Line 1806 of yacc.c */
7344 #line 2311 "ripper.y"
7345  {
7346 #if 0
7347  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
7348 #endif
7349  (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val));
7350 
7351  }
7352  break;
7353 
7354  case 232:
7355 
7356 /* Line 1806 of yacc.c */
7357 #line 2319 "ripper.y"
7358  {
7359 #if 0
7360  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
7361 #endif
7362  (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val));
7363 
7364  }
7365  break;
7366 
7367  case 233:
7368 
7369 /* Line 1806 of yacc.c */
7370 #line 2327 "ripper.y"
7371  {
7372 #if 0
7373  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val));
7374 #endif
7375  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<<"), (yyvsp[(3) - (3)].val));
7376 
7377  }
7378  break;
7379 
7380  case 234:
7381 
7382 /* Line 1806 of yacc.c */
7383 #line 2335 "ripper.y"
7384  {
7385 #if 0
7386  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val));
7387 #endif
7388  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">>"), (yyvsp[(3) - (3)].val));
7389 
7390  }
7391  break;
7392 
7393  case 235:
7394 
7395 /* Line 1806 of yacc.c */
7396 #line 2343 "ripper.y"
7397  {
7398 #if 0
7399  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7400 #endif
7401  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val));
7402 
7403  }
7404  break;
7405 
7406  case 236:
7407 
7408 /* Line 1806 of yacc.c */
7409 #line 2351 "ripper.y"
7410  {
7411 #if 0
7412  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7413 #endif
7414  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val));
7415 
7416  }
7417  break;
7418 
7419  case 237:
7420 
7421 /* Line 1806 of yacc.c */
7422 #line 2358 "ripper.y"
7423  {in_defined = 1;}
7424  break;
7425 
7426  case 238:
7427 
7428 /* Line 1806 of yacc.c */
7429 #line 2359 "ripper.y"
7430  {
7431 #if 0
7432  in_defined = 0;
7433  (yyval.val) = NEW_DEFINED((yyvsp[(4) - (4)].val));
7434 #endif
7435  in_defined = 0;
7436  (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val));
7437 
7438  }
7439  break;
7440 
7441  case 239:
7442 
7443 /* Line 1806 of yacc.c */
7444 #line 2369 "ripper.y"
7445  {
7446 #if 0
7447  value_expr((yyvsp[(1) - (6)].val));
7448  (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7449  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
7450 #endif
7451  (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7452 
7453  }
7454  break;
7455 
7456  case 240:
7457 
7458 /* Line 1806 of yacc.c */
7459 #line 2379 "ripper.y"
7460  {
7461  (yyval.val) = (yyvsp[(1) - (1)].val);
7462  }
7463  break;
7464 
7465  case 241:
7466 
7467 /* Line 1806 of yacc.c */
7468 #line 2385 "ripper.y"
7469  {
7470 #if 0
7471  value_expr((yyvsp[(1) - (1)].val));
7472  (yyval.val) = (yyvsp[(1) - (1)].val);
7473  if (!(yyval.val)) (yyval.val) = NEW_NIL();
7474 #endif
7475  (yyval.val) = (yyvsp[(1) - (1)].val);
7476 
7477  }
7478  break;
7479 
7480  case 243:
7481 
7482 /* Line 1806 of yacc.c */
7483 #line 2398 "ripper.y"
7484  {
7485  (yyval.val) = (yyvsp[(1) - (2)].val);
7486  }
7487  break;
7488 
7489  case 244:
7490 
7491 /* Line 1806 of yacc.c */
7492 #line 2402 "ripper.y"
7493  {
7494 #if 0
7495  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7496 #endif
7497  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7498 
7499  }
7500  break;
7501 
7502  case 245:
7503 
7504 /* Line 1806 of yacc.c */
7505 #line 2410 "ripper.y"
7506  {
7507 #if 0
7508  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7509 #endif
7510  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7511 
7512  }
7513  break;
7514 
7515  case 246:
7516 
7517 /* Line 1806 of yacc.c */
7518 #line 2420 "ripper.y"
7519  {
7520 #if 0
7521  (yyval.val) = (yyvsp[(2) - (3)].val);
7522 #endif
7523  (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
7524 
7525  }
7526  break;
7527 
7528  case 251:
7529 
7530 /* Line 1806 of yacc.c */
7531 #line 2436 "ripper.y"
7532  {
7533  (yyval.val) = (yyvsp[(1) - (2)].val);
7534  }
7535  break;
7536 
7537  case 252:
7538 
7539 /* Line 1806 of yacc.c */
7540 #line 2440 "ripper.y"
7541  {
7542 #if 0
7543  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7544 #endif
7545  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7546 
7547  }
7548  break;
7549 
7550  case 253:
7551 
7552 /* Line 1806 of yacc.c */
7553 #line 2448 "ripper.y"
7554  {
7555 #if 0
7556  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7557 #endif
7558  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7559 
7560  }
7561  break;
7562 
7563  case 254:
7564 
7565 /* Line 1806 of yacc.c */
7566 #line 2458 "ripper.y"
7567  {
7568 #if 0
7569  value_expr((yyvsp[(1) - (1)].val));
7570  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7571 #endif
7572  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7573 
7574  }
7575  break;
7576 
7577  case 255:
7578 
7579 /* Line 1806 of yacc.c */
7580 #line 2467 "ripper.y"
7581  {
7582 #if 0
7583  (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7584 #endif
7585  (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7586 
7587  }
7588  break;
7589 
7590  case 256:
7591 
7592 /* Line 1806 of yacc.c */
7593 #line 2475 "ripper.y"
7594  {
7595 #if 0
7596  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7597  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
7598 #endif
7599  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7600  (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
7601 
7602  }
7603  break;
7604 
7605  case 257:
7606 
7607 /* Line 1806 of yacc.c */
7608 #line 2485 "ripper.y"
7609  {
7610 #if 0
7611  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7612  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
7613 #endif
7614  (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
7615 
7616  }
7617  break;
7618 
7619  case 258:
7620 
7621 /* Line 1806 of yacc.c */
7622 #line 2496 "ripper.y"
7623  {
7624  (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
7625  }
7626  break;
7627 
7628  case 259:
7629 
7630 /* Line 1806 of yacc.c */
7631 #line 2502 "ripper.y"
7632  {
7633  (yyval.val) = cmdarg_stack;
7634  CMDARG_PUSH(1);
7635  }
7636  break;
7637 
7638  case 260:
7639 
7640 /* Line 1806 of yacc.c */
7641 #line 2507 "ripper.y"
7642  {
7643  /* CMDARG_POP() */
7644  cmdarg_stack = (yyvsp[(1) - (2)].val);
7645  (yyval.val) = (yyvsp[(2) - (2)].val);
7646  }
7647  break;
7648 
7649  case 261:
7650 
7651 /* Line 1806 of yacc.c */
7652 #line 2515 "ripper.y"
7653  {
7654 #if 0
7655  (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
7656 #endif
7657  (yyval.val) = (yyvsp[(2) - (2)].val);
7658 
7659  }
7660  break;
7661 
7662  case 262:
7663 
7664 /* Line 1806 of yacc.c */
7665 #line 2525 "ripper.y"
7666  {
7667  (yyval.val) = (yyvsp[(2) - (2)].val);
7668  }
7669  break;
7670 
7671  case 263:
7672 
7673 /* Line 1806 of yacc.c */
7674 #line 2529 "ripper.y"
7675  {
7676  (yyval.val) = 0;
7677  }
7678  break;
7679 
7680  case 264:
7681 
7682 /* Line 1806 of yacc.c */
7683 #line 2535 "ripper.y"
7684  {
7685 #if 0
7686  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7687 #endif
7688  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7689 
7690  }
7691  break;
7692 
7693  case 265:
7694 
7695 /* Line 1806 of yacc.c */
7696 #line 2543 "ripper.y"
7697  {
7698 #if 0
7699  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7700 #endif
7701  (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
7702 
7703  }
7704  break;
7705 
7706  case 266:
7707 
7708 /* Line 1806 of yacc.c */
7709 #line 2551 "ripper.y"
7710  {
7711 #if 0
7712  NODE *n1;
7713  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7714  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7715  }
7716  else {
7717  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7718  }
7719 #endif
7720  (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7721 
7722  }
7723  break;
7724 
7725  case 267:
7726 
7727 /* Line 1806 of yacc.c */
7728 #line 2565 "ripper.y"
7729  {
7730 #if 0
7731  NODE *n1;
7732  if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7733  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7734  }
7735  else {
7736  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7737  }
7738 #endif
7739  (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7740 
7741  }
7742  break;
7743 
7744  case 268:
7745 
7746 /* Line 1806 of yacc.c */
7747 #line 2581 "ripper.y"
7748  {
7749 #if 0
7750  NODE *n1;
7751  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7752  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7753  }
7754  else {
7755  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7756  }
7757 #endif
7758  (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
7759 
7760  }
7761  break;
7762 
7763  case 269:
7764 
7765 /* Line 1806 of yacc.c */
7766 #line 2595 "ripper.y"
7767  {
7768 #if 0
7769  NODE *n1;
7770  if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
7771  (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7772  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7773  }
7774  else {
7775  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7776  }
7777 #endif
7778  (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
7779 
7780  }
7781  break;
7782 
7783  case 270:
7784 
7785 /* Line 1806 of yacc.c */
7786 #line 2610 "ripper.y"
7787  {
7788 #if 0
7789  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7790 #endif
7791  (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
7792 
7793  }
7794  break;
7795 
7796  case 279:
7797 
7798 /* Line 1806 of yacc.c */
7799 #line 2628 "ripper.y"
7800  {
7801 #if 0
7802  (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
7803 #endif
7804  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
7805 
7806  }
7807  break;
7808 
7809  case 280:
7810 
7811 /* Line 1806 of yacc.c */
7812 #line 2636 "ripper.y"
7813  {
7814 #if 0
7815  (yyval.num) = ruby_sourceline;
7816 #endif
7817 
7818  }
7819  break;
7820 
7821  case 281:
7822 
7823 /* Line 1806 of yacc.c */
7824 #line 2644 "ripper.y"
7825  {
7826 #if 0
7827  if ((yyvsp[(3) - (4)].val) == NULL) {
7828  (yyval.val) = NEW_NIL();
7829  }
7830  else {
7831  if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE ||
7832  nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE)
7833  nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
7834  (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val));
7835  }
7836  nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
7837 #endif
7838  (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
7839 
7840  }
7841  break;
7842 
7843  case 282:
7844 
7845 /* Line 1806 of yacc.c */
7846 #line 2660 "ripper.y"
7847  {lex_state = EXPR_ENDARG;}
7848  break;
7849 
7850  case 283:
7851 
7852 /* Line 1806 of yacc.c */
7853 #line 2661 "ripper.y"
7854  {
7855  rb_warning0("(...) interpreted as grouped expression");
7856 #if 0
7857  (yyval.val) = (yyvsp[(2) - (4)].val);
7858 #endif
7859  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
7860 
7861  }
7862  break;
7863 
7864  case 284:
7865 
7866 /* Line 1806 of yacc.c */
7867 #line 2670 "ripper.y"
7868  {
7869 #if 0
7870  (yyval.val) = (yyvsp[(2) - (3)].val);
7871 #endif
7872  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
7873 
7874  }
7875  break;
7876 
7877  case 285:
7878 
7879 /* Line 1806 of yacc.c */
7880 #line 2678 "ripper.y"
7881  {
7882 #if 0
7883  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7884 #endif
7885  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7886 
7887  }
7888  break;
7889 
7890  case 286:
7891 
7892 /* Line 1806 of yacc.c */
7893 #line 2686 "ripper.y"
7894  {
7895 #if 0
7896  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
7897 #endif
7898  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
7899 
7900  }
7901  break;
7902 
7903  case 287:
7904 
7905 /* Line 1806 of yacc.c */
7906 #line 2694 "ripper.y"
7907  {
7908 #if 0
7909  if ((yyvsp[(2) - (3)].val) == 0) {
7910  (yyval.val) = NEW_ZARRAY(); /* zero length array*/
7911  }
7912  else {
7913  (yyval.val) = (yyvsp[(2) - (3)].val);
7914  }
7915 #endif
7916  (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
7917 
7918  }
7919  break;
7920 
7921  case 288:
7922 
7923 /* Line 1806 of yacc.c */
7924 #line 2707 "ripper.y"
7925  {
7926 #if 0
7927  (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
7928 #endif
7929  (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
7930 
7931  }
7932  break;
7933 
7934  case 289:
7935 
7936 /* Line 1806 of yacc.c */
7937 #line 2715 "ripper.y"
7938  {
7939 #if 0
7940  (yyval.val) = NEW_RETURN(0);
7941 #endif
7942  (yyval.val) = dispatch0(return0);
7943 
7944  }
7945  break;
7946 
7947  case 290:
7948 
7949 /* Line 1806 of yacc.c */
7950 #line 2723 "ripper.y"
7951  {
7952 #if 0
7953  (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
7954 #endif
7955  (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
7956 
7957  }
7958  break;
7959 
7960  case 291:
7961 
7962 /* Line 1806 of yacc.c */
7963 #line 2731 "ripper.y"
7964  {
7965 #if 0
7966  (yyval.val) = NEW_YIELD(0, Qfalse);
7967 #endif
7968  (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
7969 
7970  }
7971  break;
7972 
7973  case 292:
7974 
7975 /* Line 1806 of yacc.c */
7976 #line 2739 "ripper.y"
7977  {
7978 #if 0
7979  (yyval.val) = NEW_YIELD(0, Qfalse);
7980 #endif
7981  (yyval.val) = dispatch0(yield0);
7982 
7983  }
7984  break;
7985 
7986  case 293:
7987 
7988 /* Line 1806 of yacc.c */
7989 #line 2746 "ripper.y"
7990  {in_defined = 1;}
7991  break;
7992 
7993  case 294:
7994 
7995 /* Line 1806 of yacc.c */
7996 #line 2747 "ripper.y"
7997  {
7998 #if 0
7999  in_defined = 0;
8000  (yyval.val) = NEW_DEFINED((yyvsp[(5) - (6)].val));
8001 #endif
8002  in_defined = 0;
8003  (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val));
8004 
8005  }
8006  break;
8007 
8008  case 295:
8009 
8010 /* Line 1806 of yacc.c */
8011 #line 2757 "ripper.y"
8012  {
8013 #if 0
8014  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
8015 #endif
8016  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val));
8017 
8018  }
8019  break;
8020 
8021  case 296:
8022 
8023 /* Line 1806 of yacc.c */
8024 #line 2765 "ripper.y"
8025  {
8026 #if 0
8027  (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
8028 #endif
8029  (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil);
8030 
8031  }
8032  break;
8033 
8034  case 297:
8035 
8036 /* Line 1806 of yacc.c */
8037 #line 2773 "ripper.y"
8038  {
8039 #if 0
8040  (yyvsp[(2) - (2)].val)->nd_iter = NEW_FCALL((yyvsp[(1) - (2)].val), 0);
8041  (yyval.val) = (yyvsp[(2) - (2)].val);
8042  fixpos((yyvsp[(2) - (2)].val)->nd_iter, (yyvsp[(2) - (2)].val));
8043 #endif
8044  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
8045  (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
8046 
8047  }
8048  break;
8049 
8050  case 299:
8051 
8052 /* Line 1806 of yacc.c */
8053 #line 2785 "ripper.y"
8054  {
8055 #if 0
8056  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
8057  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
8058  (yyval.val) = (yyvsp[(2) - (2)].val);
8059  fixpos((yyval.val), (yyvsp[(1) - (2)].val));
8060 #endif
8061  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
8062 
8063  }
8064  break;
8065 
8066  case 300:
8067 
8068 /* Line 1806 of yacc.c */
8069 #line 2796 "ripper.y"
8070  {
8071  (yyval.val) = (yyvsp[(2) - (2)].val);
8072  }
8073  break;
8074 
8075  case 301:
8076 
8077 /* Line 1806 of yacc.c */
8078 #line 2803 "ripper.y"
8079  {
8080 #if 0
8081  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8082  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8083 #endif
8084  (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8085 
8086  }
8087  break;
8088 
8089  case 302:
8090 
8091 /* Line 1806 of yacc.c */
8092 #line 2815 "ripper.y"
8093  {
8094 #if 0
8095  (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8096  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8097 #endif
8098  (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8099 
8100  }
8101  break;
8102 
8103  case 303:
8104 
8105 /* Line 1806 of yacc.c */
8106 #line 2823 "ripper.y"
8107  {COND_PUSH(1);}
8108  break;
8109 
8110  case 304:
8111 
8112 /* Line 1806 of yacc.c */
8113 #line 2823 "ripper.y"
8114  {COND_POP();}
8115  break;
8116 
8117  case 305:
8118 
8119 /* Line 1806 of yacc.c */
8120 #line 2826 "ripper.y"
8121  {
8122 #if 0
8123  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8124  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8125 #endif
8126  (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8127 
8128  }
8129  break;
8130 
8131  case 306:
8132 
8133 /* Line 1806 of yacc.c */
8134 #line 2834 "ripper.y"
8135  {COND_PUSH(1);}
8136  break;
8137 
8138  case 307:
8139 
8140 /* Line 1806 of yacc.c */
8141 #line 2834 "ripper.y"
8142  {COND_POP();}
8143  break;
8144 
8145  case 308:
8146 
8147 /* Line 1806 of yacc.c */
8148 #line 2837 "ripper.y"
8149  {
8150 #if 0
8151  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8152  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8153 #endif
8154  (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8155 
8156  }
8157  break;
8158 
8159  case 309:
8160 
8161 /* Line 1806 of yacc.c */
8162 #line 2848 "ripper.y"
8163  {
8164 #if 0
8165  (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8166  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8167 #endif
8168  (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8169 
8170  }
8171  break;
8172 
8173  case 310:
8174 
8175 /* Line 1806 of yacc.c */
8176 #line 2857 "ripper.y"
8177  {
8178 #if 0
8179  (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
8180 #endif
8181  (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
8182 
8183  }
8184  break;
8185 
8186  case 311:
8187 
8188 /* Line 1806 of yacc.c */
8189 #line 2865 "ripper.y"
8190  {COND_PUSH(1);}
8191  break;
8192 
8193  case 312:
8194 
8195 /* Line 1806 of yacc.c */
8196 #line 2867 "ripper.y"
8197  {COND_POP();}
8198  break;
8199 
8200  case 313:
8201 
8202 /* Line 1806 of yacc.c */
8203 #line 2870 "ripper.y"
8204  {
8205 #if 0
8206  /*
8207  * for a, b, c in e
8208  * #=>
8209  * e.each{|*x| a, b, c = x
8210  *
8211  * for a in e
8212  * #=>
8213  * e.each{|x| a, = x}
8214  */
8215  ID id = internal_id();
8216  ID *tbl = ALLOC_N(ID, 2);
8217  NODE *m = NEW_ARGS_AUX(0, 0);
8218  NODE *args, *scope;
8219 
8220  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) {
8221  /* if args.length == 1 && args[0].kind_of?(Array)
8222  * args = args[0]
8223  * end
8224  */
8225  NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
8226  NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
8227  m->nd_next = block_append(
8228  NEW_IF(
8230  NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("length"), 0),
8231  rb_intern("=="), one),
8232  NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero),
8233  rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
8234  0),
8235  NEW_DASGN_CURR(id,
8236  NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero)),
8237  0),
8238  node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id)));
8239 
8240  args = new_args(m, 0, id, 0, 0);
8241  }
8242  else {
8243  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN ||
8244  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN ||
8245  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) {
8246  (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id);
8247  m->nd_plen = 1;
8248  m->nd_next = (yyvsp[(2) - (9)].val);
8249  args = new_args(m, 0, 0, 0, 0);
8250  }
8251  else {
8252  m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id));
8253  args = new_args(m, 0, id, 0, 0);
8254  }
8255  }
8256  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
8257  tbl[0] = 1; tbl[1] = id;
8258  (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope);
8259  fixpos((yyval.val), (yyvsp[(2) - (9)].val));
8260 #endif
8261  (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
8262 
8263  }
8264  break;
8265 
8266  case 314:
8267 
8268 /* Line 1806 of yacc.c */
8269 #line 2931 "ripper.y"
8270  {
8271  if (in_def || in_single)
8272  yyerror("class definition in method body");
8273  local_push(0);
8274 #if 0
8275  (yyval.num) = ruby_sourceline;
8276 #endif
8277 
8278  }
8279  break;
8280 
8281  case 315:
8282 
8283 /* Line 1806 of yacc.c */
8284 #line 2942 "ripper.y"
8285  {
8286 #if 0
8287  (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
8288  nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
8289 #endif
8290  (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
8291 
8292  local_pop();
8293  }
8294  break;
8295 
8296  case 316:
8297 
8298 /* Line 1806 of yacc.c */
8299 #line 2952 "ripper.y"
8300  {
8301  (yyval.num) = in_def;
8302  in_def = 0;
8303  }
8304  break;
8305 
8306  case 317:
8307 
8308 /* Line 1806 of yacc.c */
8309 #line 2957 "ripper.y"
8310  {
8311  (yyval.num) = in_single;
8312  in_single = 0;
8313  local_push(0);
8314  }
8315  break;
8316 
8317  case 318:
8318 
8319 /* Line 1806 of yacc.c */
8320 #line 2964 "ripper.y"
8321  {
8322 #if 0
8323  (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8324  fixpos((yyval.val), (yyvsp[(3) - (8)].val));
8325 #endif
8326  (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8327 
8328  local_pop();
8329  in_def = (yyvsp[(4) - (8)].num);
8330  in_single = (yyvsp[(6) - (8)].num);
8331  }
8332  break;
8333 
8334  case 319:
8335 
8336 /* Line 1806 of yacc.c */
8337 #line 2976 "ripper.y"
8338  {
8339  if (in_def || in_single)
8340  yyerror("module definition in method body");
8341  local_push(0);
8342 #if 0
8343  (yyval.num) = ruby_sourceline;
8344 #endif
8345 
8346  }
8347  break;
8348 
8349  case 320:
8350 
8351 /* Line 1806 of yacc.c */
8352 #line 2987 "ripper.y"
8353  {
8354 #if 0
8355  (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8356  nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
8357 #endif
8358  (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8359 
8360  local_pop();
8361  }
8362  break;
8363 
8364  case 321:
8365 
8366 /* Line 1806 of yacc.c */
8367 #line 2997 "ripper.y"
8368  {
8369  (yyval.id) = cur_mid;
8370  cur_mid = (yyvsp[(2) - (2)].val);
8371  in_def++;
8372  local_push(0);
8373  }
8374  break;
8375 
8376  case 322:
8377 
8378 /* Line 1806 of yacc.c */
8379 #line 3006 "ripper.y"
8380  {
8381 #if 0
8382  NODE *body = remove_begin((yyvsp[(5) - (6)].val));
8383  reduce_nodes(&body);
8384  (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE);
8385  nd_set_line((yyval.val), (yyvsp[(1) - (6)].num));
8386 #endif
8387  (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8388 
8389  local_pop();
8390  in_def--;
8391  cur_mid = (yyvsp[(3) - (6)].id);
8392  }
8393  break;
8394 
8395  case 323:
8396 
8397 /* Line 1806 of yacc.c */
8398 #line 3019 "ripper.y"
8399  {lex_state = EXPR_FNAME;}
8400  break;
8401 
8402  case 324:
8403 
8404 /* Line 1806 of yacc.c */
8405 #line 3020 "ripper.y"
8406  {
8407  in_single++;
8408  lex_state = EXPR_ENDFN; /* force for args */
8409  local_push(0);
8410  }
8411  break;
8412 
8413  case 325:
8414 
8415 /* Line 1806 of yacc.c */
8416 #line 3028 "ripper.y"
8417  {
8418 #if 0
8419  NODE *body = remove_begin((yyvsp[(8) - (9)].val));
8420  reduce_nodes(&body);
8421  (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
8422  nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
8423 #endif
8424  (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
8425 
8426  local_pop();
8427  in_single--;
8428  }
8429  break;
8430 
8431  case 326:
8432 
8433 /* Line 1806 of yacc.c */
8434 #line 3041 "ripper.y"
8435  {
8436 #if 0
8437  (yyval.val) = NEW_BREAK(0);
8438 #endif
8439  (yyval.val) = dispatch1(break, arg_new());
8440 
8441  }
8442  break;
8443 
8444  case 327:
8445 
8446 /* Line 1806 of yacc.c */
8447 #line 3049 "ripper.y"
8448  {
8449 #if 0
8450  (yyval.val) = NEW_NEXT(0);
8451 #endif
8452  (yyval.val) = dispatch1(next, arg_new());
8453 
8454  }
8455  break;
8456 
8457  case 328:
8458 
8459 /* Line 1806 of yacc.c */
8460 #line 3057 "ripper.y"
8461  {
8462 #if 0
8463  (yyval.val) = NEW_REDO();
8464 #endif
8465  (yyval.val) = dispatch0(redo);
8466 
8467  }
8468  break;
8469 
8470  case 329:
8471 
8472 /* Line 1806 of yacc.c */
8473 #line 3065 "ripper.y"
8474  {
8475 #if 0
8476  (yyval.val) = NEW_RETRY();
8477 #endif
8478  (yyval.val) = dispatch0(retry);
8479 
8480  }
8481  break;
8482 
8483  case 330:
8484 
8485 /* Line 1806 of yacc.c */
8486 #line 3075 "ripper.y"
8487  {
8488 #if 0
8489  value_expr((yyvsp[(1) - (1)].val));
8490  (yyval.val) = (yyvsp[(1) - (1)].val);
8491  if (!(yyval.val)) (yyval.val) = NEW_NIL();
8492 #endif
8493  (yyval.val) = (yyvsp[(1) - (1)].val);
8494 
8495  }
8496  break;
8497 
8498  case 331:
8499 
8500 /* Line 1806 of yacc.c */
8501 #line 3087 "ripper.y"
8502  {
8503  token_info_push("begin");
8504  }
8505  break;
8506 
8507  case 332:
8508 
8509 /* Line 1806 of yacc.c */
8510 #line 3093 "ripper.y"
8511  {
8512  token_info_push("if");
8513  }
8514  break;
8515 
8516  case 333:
8517 
8518 /* Line 1806 of yacc.c */
8519 #line 3099 "ripper.y"
8520  {
8521  token_info_push("unless");
8522  }
8523  break;
8524 
8525  case 334:
8526 
8527 /* Line 1806 of yacc.c */
8528 #line 3105 "ripper.y"
8529  {
8530  token_info_push("while");
8531  }
8532  break;
8533 
8534  case 335:
8535 
8536 /* Line 1806 of yacc.c */
8537 #line 3111 "ripper.y"
8538  {
8539  token_info_push("until");
8540  }
8541  break;
8542 
8543  case 336:
8544 
8545 /* Line 1806 of yacc.c */
8546 #line 3117 "ripper.y"
8547  {
8548  token_info_push("case");
8549  }
8550  break;
8551 
8552  case 337:
8553 
8554 /* Line 1806 of yacc.c */
8555 #line 3123 "ripper.y"
8556  {
8557  token_info_push("for");
8558  }
8559  break;
8560 
8561  case 338:
8562 
8563 /* Line 1806 of yacc.c */
8564 #line 3129 "ripper.y"
8565  {
8566  token_info_push("class");
8567  }
8568  break;
8569 
8570  case 339:
8571 
8572 /* Line 1806 of yacc.c */
8573 #line 3135 "ripper.y"
8574  {
8575  token_info_push("module");
8576  }
8577  break;
8578 
8579  case 340:
8580 
8581 /* Line 1806 of yacc.c */
8582 #line 3141 "ripper.y"
8583  {
8584  token_info_push("def");
8585 #if 0
8586  (yyval.num) = ruby_sourceline;
8587 #endif
8588 
8589  }
8590  break;
8591 
8592  case 341:
8593 
8594 /* Line 1806 of yacc.c */
8595 #line 3151 "ripper.y"
8596  {
8597  token_info_pop("end");
8598  }
8599  break;
8600 
8601  case 342:
8602 
8603 /* Line 1806 of yacc.c */
8604 #line 3159 "ripper.y"
8605  { (yyval.val) = Qnil; }
8606  break;
8607 
8608  case 344:
8609 
8610 /* Line 1806 of yacc.c */
8611 #line 3165 "ripper.y"
8612  { (yyval.val) = (yyvsp[(2) - (2)].val); }
8613  break;
8614 
8615  case 345:
8616 
8617 /* Line 1806 of yacc.c */
8618 #line 3172 "ripper.y"
8619  { (yyval.val) = Qnil; }
8620  break;
8621 
8622  case 348:
8623 
8624 /* Line 1806 of yacc.c */
8625 #line 3181 "ripper.y"
8626  {
8627 #if 0
8628  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
8629  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8630 #endif
8631  (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
8632 
8633  }
8634  break;
8635 
8636  case 350:
8637 
8638 /* Line 1806 of yacc.c */
8639 #line 3193 "ripper.y"
8640  {
8641 #if 0
8642  (yyval.val) = (yyvsp[(2) - (2)].val);
8643 #endif
8644  (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
8645 
8646  }
8647  break;
8648 
8649  case 353:
8650 
8651 /* Line 1806 of yacc.c */
8652 #line 3207 "ripper.y"
8653  {
8654  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
8655 #if 0
8656 #endif
8657  (yyval.val) = dispatch1(mlhs_paren, (yyval.val));
8658 
8659  }
8660  break;
8661 
8662  case 354:
8663 
8664 /* Line 1806 of yacc.c */
8665 #line 3215 "ripper.y"
8666  {
8667 #if 0
8668  (yyval.val) = (yyvsp[(2) - (3)].val);
8669 #endif
8670  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
8671 
8672  }
8673  break;
8674 
8675  case 355:
8676 
8677 /* Line 1806 of yacc.c */
8678 #line 3225 "ripper.y"
8679  {
8680 #if 0
8681  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
8682 #endif
8683  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
8684 
8685  }
8686  break;
8687 
8688  case 356:
8689 
8690 /* Line 1806 of yacc.c */
8691 #line 3233 "ripper.y"
8692  {
8693 #if 0
8694  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8695 #endif
8696  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8697 
8698  }
8699  break;
8700 
8701  case 357:
8702 
8703 /* Line 1806 of yacc.c */
8704 #line 3243 "ripper.y"
8705  {
8706 #if 0
8707  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
8708 #endif
8709  (yyval.val) = (yyvsp[(1) - (1)].val);
8710 
8711  }
8712  break;
8713 
8714  case 358:
8715 
8716 /* Line 1806 of yacc.c */
8717 #line 3251 "ripper.y"
8718  {
8719  (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
8720 #if 0
8721  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val));
8722 #endif
8723  (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
8724 
8725  }
8726  break;
8727 
8728  case 359:
8729 
8730 /* Line 1806 of yacc.c */
8731 #line 3260 "ripper.y"
8732  {
8733  (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
8734 #if 0
8735  (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val)));
8736 #endif
8737  (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
8738 
8739  }
8740  break;
8741 
8742  case 360:
8743 
8744 /* Line 1806 of yacc.c */
8745 #line 3269 "ripper.y"
8746  {
8747 #if 0
8748  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
8749 #endif
8750  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
8751 
8752  }
8753  break;
8754 
8755  case 361:
8756 
8757 /* Line 1806 of yacc.c */
8758 #line 3277 "ripper.y"
8759  {
8760 #if 0
8761  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
8762 #endif
8763  (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
8764 
8765  }
8766  break;
8767 
8768  case 362:
8769 
8770 /* Line 1806 of yacc.c */
8771 #line 3285 "ripper.y"
8772  {
8773  (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
8774 #if 0
8775  (yyval.val) = NEW_MASGN(0, (yyval.val));
8776 #endif
8777  (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
8778 
8779  }
8780  break;
8781 
8782  case 363:
8783 
8784 /* Line 1806 of yacc.c */
8785 #line 3294 "ripper.y"
8786  {
8787  (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
8788 #if 0
8789  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val)));
8790 #endif
8791  #if 0
8792  TODO: Check me
8793  #endif
8794  (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val));
8795 
8796  }
8797  break;
8798 
8799  case 364:
8800 
8801 /* Line 1806 of yacc.c */
8802 #line 3306 "ripper.y"
8803  {
8804 #if 0
8805  (yyval.val) = NEW_MASGN(0, -1);
8806 #endif
8807  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8808 
8809  }
8810  break;
8811 
8812  case 365:
8813 
8814 /* Line 1806 of yacc.c */
8815 #line 3314 "ripper.y"
8816  {
8817 #if 0
8818  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
8819 #endif
8820  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8821 
8822  }
8823  break;
8824 
8825  case 366:
8826 
8827 /* Line 1806 of yacc.c */
8828 #line 3324 "ripper.y"
8829  {
8830 #if 0
8831  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), 0, (yyvsp[(6) - (6)].val));
8832 #endif
8833  (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnil, escape_Qundef((yyvsp[(6) - (6)].val)));
8834 
8835  }
8836  break;
8837 
8838  case 367:
8839 
8840 /* Line 1806 of yacc.c */
8841 #line 3332 "ripper.y"
8842  {
8843 #if 0
8844  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
8845 #endif
8846  (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)));
8847 
8848  }
8849  break;
8850 
8851  case 368:
8852 
8853 /* Line 1806 of yacc.c */
8854 #line 3340 "ripper.y"
8855  {
8856 #if 0
8857  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, 0, (yyvsp[(4) - (4)].val));
8858 #endif
8859  (yyval.val) = params_new((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
8860 
8861  }
8862  break;
8863 
8864  case 369:
8865 
8866 /* Line 1806 of yacc.c */
8867 #line 3348 "ripper.y"
8868  {
8869 #if 0
8870  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), 0, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8871 #endif
8872  (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnil, (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
8873 
8874  }
8875  break;
8876 
8877  case 370:
8878 
8879 /* Line 1806 of yacc.c */
8880 #line 3356 "ripper.y"
8881  {
8882 #if 0
8883  (yyval.val) = new_args((yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
8884 #endif
8885  (yyval.val) = params_new((yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
8886 
8887  }
8888  break;
8889 
8890  case 371:
8891 
8892 /* Line 1806 of yacc.c */
8893 #line 3364 "ripper.y"
8894  {
8895 #if 0
8896  (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 1, 0, 0);
8897 #endif
8898  (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil, Qnil, Qnil, Qnil);
8899  dispatch1(excessed_comma, (yyval.val));
8900 
8901  }
8902  break;
8903 
8904  case 372:
8905 
8906 /* Line 1806 of yacc.c */
8907 #line 3373 "ripper.y"
8908  {
8909 #if 0
8910  (yyval.val) = new_args((yyvsp[(1) - (6)].val), 0, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8911 #endif
8912  (yyval.val) = params_new((yyvsp[(1) - (6)].val), Qnil, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
8913 
8914  }
8915  break;
8916 
8917  case 373:
8918 
8919 /* Line 1806 of yacc.c */
8920 #line 3381 "ripper.y"
8921  {
8922 #if 0
8923  (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 0, 0, (yyvsp[(2) - (2)].val));
8924 #endif
8925  (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil,Qnil, Qnil, escape_Qundef((yyvsp[(2) - (2)].val)));
8926 
8927  }
8928  break;
8929 
8930  case 374:
8931 
8932 /* Line 1806 of yacc.c */
8933 #line 3389 "ripper.y"
8934  {
8935 #if 0
8936  (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
8937 #endif
8938  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
8939 
8940  }
8941  break;
8942 
8943  case 375:
8944 
8945 /* Line 1806 of yacc.c */
8946 #line 3397 "ripper.y"
8947  {
8948 #if 0
8949  (yyval.val) = new_args(0, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8950 #endif
8951  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
8952 
8953  }
8954  break;
8955 
8956  case 376:
8957 
8958 /* Line 1806 of yacc.c */
8959 #line 3405 "ripper.y"
8960  {
8961 #if 0
8962  (yyval.val) = new_args(0, (yyvsp[(1) - (2)].val), 0, 0, (yyvsp[(2) - (2)].val));
8963 #endif
8964  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (2)].val), Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
8965 
8966  }
8967  break;
8968 
8969  case 377:
8970 
8971 /* Line 1806 of yacc.c */
8972 #line 3413 "ripper.y"
8973  {
8974 #if 0
8975  (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
8976 #endif
8977  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
8978 
8979  }
8980  break;
8981 
8982  case 378:
8983 
8984 /* Line 1806 of yacc.c */
8985 #line 3421 "ripper.y"
8986  {
8987 #if 0
8988  (yyval.val) = new_args(0, 0, (yyvsp[(1) - (2)].val), 0, (yyvsp[(2) - (2)].val));
8989 #endif
8990  (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (2)].val), Qnil, escape_Qundef((yyvsp[(2) - (2)].val)));
8991 
8992  }
8993  break;
8994 
8995  case 379:
8996 
8997 /* Line 1806 of yacc.c */
8998 #line 3429 "ripper.y"
8999  {
9000 #if 0
9001  (yyval.val) = new_args(0, 0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9002 #endif
9003  (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
9004 
9005  }
9006  break;
9007 
9008  case 380:
9009 
9010 /* Line 1806 of yacc.c */
9011 #line 3437 "ripper.y"
9012  {
9013 #if 0
9014  (yyval.val) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].val));
9015 #endif
9016  (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, (yyvsp[(1) - (1)].val));
9017 
9018  }
9019  break;
9020 
9021  case 382:
9022 
9023 /* Line 1806 of yacc.c */
9024 #line 3448 "ripper.y"
9025  {
9026  command_start = TRUE;
9027  }
9028  break;
9029 
9030  case 383:
9031 
9032 /* Line 1806 of yacc.c */
9033 #line 3454 "ripper.y"
9034  {
9035 #if 0
9036  (yyval.val) = 0;
9037 #endif
9038  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
9039  escape_Qundef((yyvsp[(2) - (3)].val)));
9040 
9041  }
9042  break;
9043 
9044  case 384:
9045 
9046 /* Line 1806 of yacc.c */
9047 #line 3463 "ripper.y"
9048  {
9049 #if 0
9050  (yyval.val) = 0;
9051 #endif
9052  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
9053  Qnil);
9054 
9055  }
9056  break;
9057 
9058  case 385:
9059 
9060 /* Line 1806 of yacc.c */
9061 #line 3472 "ripper.y"
9062  {
9063 #if 0
9064  (yyval.val) = (yyvsp[(2) - (4)].val);
9065 #endif
9066  (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
9067 
9068  }
9069  break;
9070 
9071  case 387:
9072 
9073 /* Line 1806 of yacc.c */
9074 #line 3484 "ripper.y"
9075  {
9076 #if 0
9077  (yyval.val) = 0;
9078 #endif
9079  (yyval.val) = (yyvsp[(2) - (2)].val);
9080 
9081  }
9082  break;
9083 
9084  case 388:
9085 
9086 /* Line 1806 of yacc.c */
9087 #line 3496 "ripper.y"
9088  {
9089  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9090  }
9091  break;
9092 
9093  case 389:
9094 
9095 /* Line 1806 of yacc.c */
9096 #line 3503 "ripper.y"
9097  {
9098  rb_ary_push((yyval.val), (yyvsp[(3) - (3)].val));
9099  }
9100  break;
9101 
9102  case 390:
9103 
9104 /* Line 1806 of yacc.c */
9105 #line 3510 "ripper.y"
9106  {
9107  new_bv(get_id((yyvsp[(1) - (1)].val)));
9108 #if 0
9109 #endif
9110  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
9111 
9112  }
9113  break;
9114 
9115  case 391:
9116 
9117 /* Line 1806 of yacc.c */
9118 #line 3518 "ripper.y"
9119  {
9120  (yyval.val) = 0;
9121  }
9122  break;
9123 
9124  case 392:
9125 
9126 /* Line 1806 of yacc.c */
9127 #line 3523 "ripper.y"
9128  {
9129  (yyval.vars) = dyna_push();
9130  }
9131  break;
9132 
9133  case 393:
9134 
9135 /* Line 1806 of yacc.c */
9136 #line 3526 "ripper.y"
9137  {
9138  (yyval.num) = lpar_beg;
9139  lpar_beg = ++paren_nest;
9140  }
9141  break;
9142 
9143  case 394:
9144 
9145 /* Line 1806 of yacc.c */
9146 #line 3532 "ripper.y"
9147  {
9148  lpar_beg = (yyvsp[(2) - (4)].num);
9149 #if 0
9150  (yyval.val) = (yyvsp[(3) - (4)].val);
9151  (yyval.val)->nd_body = NEW_SCOPE((yyvsp[(3) - (4)].val)->nd_head, (yyvsp[(4) - (4)].val));
9152 #endif
9153  (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9154 
9155  dyna_pop((yyvsp[(1) - (4)].vars));
9156  }
9157  break;
9158 
9159  case 395:
9160 
9161 /* Line 1806 of yacc.c */
9162 #line 3545 "ripper.y"
9163  {
9164 #if 0
9165  (yyval.val) = NEW_LAMBDA((yyvsp[(2) - (4)].val));
9166 #endif
9167  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
9168 
9169  }
9170  break;
9171 
9172  case 396:
9173 
9174 /* Line 1806 of yacc.c */
9175 #line 3553 "ripper.y"
9176  {
9177 #if 0
9178  (yyval.val) = NEW_LAMBDA((yyvsp[(1) - (1)].val));
9179 #endif
9180  (yyval.val) = (yyvsp[(1) - (1)].val);
9181 
9182  }
9183  break;
9184 
9185  case 397:
9186 
9187 /* Line 1806 of yacc.c */
9188 #line 3563 "ripper.y"
9189  {
9190  (yyval.val) = (yyvsp[(2) - (3)].val);
9191  }
9192  break;
9193 
9194  case 398:
9195 
9196 /* Line 1806 of yacc.c */
9197 #line 3567 "ripper.y"
9198  {
9199  (yyval.val) = (yyvsp[(2) - (3)].val);
9200  }
9201  break;
9202 
9203  case 399:
9204 
9205 /* Line 1806 of yacc.c */
9206 #line 3573 "ripper.y"
9207  {
9208  (yyvsp[(1) - (1)].vars) = dyna_push();
9209 #if 0
9210  (yyval.num) = ruby_sourceline;
9211 #endif
9212  }
9213  break;
9214 
9215  case 400:
9216 
9217 /* Line 1806 of yacc.c */
9218 #line 3582 "ripper.y"
9219  {
9220 #if 0
9221  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9222  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9223 #endif
9224  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9225 
9226  dyna_pop((yyvsp[(1) - (5)].vars));
9227  }
9228  break;
9229 
9230  case 401:
9231 
9232 /* Line 1806 of yacc.c */
9233 #line 3594 "ripper.y"
9234  {
9235 #if 0
9236  if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
9237  compile_error(PARSER_ARG "block given to yield");
9238  }
9239  else {
9240  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
9241  }
9242  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
9243  (yyval.val) = (yyvsp[(2) - (2)].val);
9244  fixpos((yyval.val), (yyvsp[(1) - (2)].val));
9245 #endif
9246  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9247 
9248  }
9249  break;
9250 
9251  case 402:
9252 
9253 /* Line 1806 of yacc.c */
9254 #line 3610 "ripper.y"
9255  {
9256 #if 0
9257  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9258 #endif
9259  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
9260  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9261 
9262  }
9263  break;
9264 
9265  case 403:
9266 
9267 /* Line 1806 of yacc.c */
9268 #line 3619 "ripper.y"
9269  {
9270 #if 0
9271  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9272 #endif
9273  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val));
9274  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9275 
9276  }
9277  break;
9278 
9279  case 404:
9280 
9281 /* Line 1806 of yacc.c */
9282 #line 3630 "ripper.y"
9283  {
9284 #if 0
9285  (yyval.val) = NEW_FCALL((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9286  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
9287 #endif
9288  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
9289 
9290  }
9291  break;
9292 
9293  case 405:
9294 
9295 /* Line 1806 of yacc.c */
9296 #line 3639 "ripper.y"
9297  {
9298 #if 0
9299  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9300  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
9301 #endif
9302  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
9303  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9304 
9305  }
9306  break;
9307 
9308  case 406:
9309 
9310 /* Line 1806 of yacc.c */
9311 #line 3649 "ripper.y"
9312  {
9313 #if 0
9314  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9315  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
9316 #endif
9317  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
9318  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9319 
9320  }
9321  break;
9322 
9323  case 407:
9324 
9325 /* Line 1806 of yacc.c */
9326 #line 3659 "ripper.y"
9327  {
9328 #if 0
9329  (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
9330 #endif
9331  (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
9332 
9333  }
9334  break;
9335 
9336  case 408:
9337 
9338 /* Line 1806 of yacc.c */
9339 #line 3667 "ripper.y"
9340  {
9341 #if 0
9342  (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), rb_intern("call"), (yyvsp[(3) - (3)].val));
9343  fixpos((yyval.val), (yyvsp[(1) - (3)].val));
9344 #endif
9345  (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_id2sym('.'),
9346  ripper_intern("call"));
9347  (yyval.val) = method_optarg((yyval.val), (yyvsp[(3) - (3)].val));
9348 
9349  }
9350  break;
9351 
9352  case 409:
9353 
9354 /* Line 1806 of yacc.c */
9355 #line 3678 "ripper.y"
9356  {
9357 #if 0
9358  (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), rb_intern("call"), (yyvsp[(3) - (3)].val));
9359  fixpos((yyval.val), (yyvsp[(1) - (3)].val));
9360 #endif
9361  (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"),
9362  ripper_intern("call"));
9363  (yyval.val) = method_optarg((yyval.val), (yyvsp[(3) - (3)].val));
9364 
9365  }
9366  break;
9367 
9368  case 410:
9369 
9370 /* Line 1806 of yacc.c */
9371 #line 3689 "ripper.y"
9372  {
9373 #if 0
9374  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
9375 #endif
9376  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
9377 
9378  }
9379  break;
9380 
9381  case 411:
9382 
9383 /* Line 1806 of yacc.c */
9384 #line 3697 "ripper.y"
9385  {
9386 #if 0
9387  (yyval.val) = NEW_ZSUPER();
9388 #endif
9389  (yyval.val) = dispatch0(zsuper);
9390 
9391  }
9392  break;
9393 
9394  case 412:
9395 
9396 /* Line 1806 of yacc.c */
9397 #line 3705 "ripper.y"
9398  {
9399 #if 0
9400  if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
9401  (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val));
9402  else
9403  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val));
9404  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
9405 #endif
9406  (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
9407 
9408  }
9409  break;
9410 
9411  case 413:
9412 
9413 /* Line 1806 of yacc.c */
9414 #line 3719 "ripper.y"
9415  {
9416  (yyvsp[(1) - (1)].vars) = dyna_push();
9417 #if 0
9418  (yyval.num) = ruby_sourceline;
9419 #endif
9420 
9421  }
9422  break;
9423 
9424  case 414:
9425 
9426 /* Line 1806 of yacc.c */
9427 #line 3728 "ripper.y"
9428  {
9429 #if 0
9430  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9431  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9432 #endif
9433  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9434 
9435  dyna_pop((yyvsp[(1) - (5)].vars));
9436  }
9437  break;
9438 
9439  case 415:
9440 
9441 /* Line 1806 of yacc.c */
9442 #line 3738 "ripper.y"
9443  {
9444  (yyvsp[(1) - (1)].vars) = dyna_push();
9445 #if 0
9446  (yyval.num) = ruby_sourceline;
9447 #endif
9448 
9449  }
9450  break;
9451 
9452  case 416:
9453 
9454 /* Line 1806 of yacc.c */
9455 #line 3747 "ripper.y"
9456  {
9457 #if 0
9458  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9459  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9460 #endif
9461  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9462 
9463  dyna_pop((yyvsp[(1) - (5)].vars));
9464  }
9465  break;
9466 
9467  case 417:
9468 
9469 /* Line 1806 of yacc.c */
9470 #line 3761 "ripper.y"
9471  {
9472 #if 0
9473  (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9474 #endif
9475  (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
9476 
9477  }
9478  break;
9479 
9480  case 420:
9481 
9482 /* Line 1806 of yacc.c */
9483 #line 3777 "ripper.y"
9484  {
9485 #if 0
9486  if ((yyvsp[(3) - (6)].val)) {
9487  (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO());
9488  (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
9489  }
9490  (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9491  fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
9492 #endif
9493  (yyval.val) = dispatch4(rescue,
9494  escape_Qundef((yyvsp[(2) - (6)].val)),
9495  escape_Qundef((yyvsp[(3) - (6)].val)),
9496  escape_Qundef((yyvsp[(5) - (6)].val)),
9497  escape_Qundef((yyvsp[(6) - (6)].val)));
9498 
9499  }
9500  break;
9501 
9502  case 422:
9503 
9504 /* Line 1806 of yacc.c */
9505 #line 3797 "ripper.y"
9506  {
9507 #if 0
9508  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
9509 #endif
9510  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9511 
9512  }
9513  break;
9514 
9515  case 423:
9516 
9517 /* Line 1806 of yacc.c */
9518 #line 3805 "ripper.y"
9519  {
9520 #if 0
9521  if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
9522 #endif
9523  (yyval.val) = (yyvsp[(1) - (1)].val);
9524 
9525  }
9526  break;
9527 
9528  case 425:
9529 
9530 /* Line 1806 of yacc.c */
9531 #line 3816 "ripper.y"
9532  {
9533  (yyval.val) = (yyvsp[(2) - (2)].val);
9534  }
9535  break;
9536 
9537  case 427:
9538 
9539 /* Line 1806 of yacc.c */
9540 #line 3823 "ripper.y"
9541  {
9542 #if 0
9543  (yyval.val) = (yyvsp[(2) - (2)].val);
9544 #endif
9545  (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
9546 
9547  }
9548  break;
9549 
9550  case 430:
9551 
9552 /* Line 1806 of yacc.c */
9553 #line 3835 "ripper.y"
9554  {
9555 #if 0
9556  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
9557 #endif
9558  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
9559 
9560  }
9561  break;
9562 
9563  case 432:
9564 
9565 /* Line 1806 of yacc.c */
9566 #line 3846 "ripper.y"
9567  {
9568 #if 0
9569  NODE *node = (yyvsp[(1) - (1)].val);
9570  if (!node) {
9571  node = NEW_STR(STR_NEW0());
9572  }
9573  else {
9574  node = evstr2dstr(node);
9575  }
9576  (yyval.val) = node;
9577 #endif
9578  (yyval.val) = (yyvsp[(1) - (1)].val);
9579 
9580  }
9581  break;
9582 
9583  case 435:
9584 
9585 /* Line 1806 of yacc.c */
9586 #line 3865 "ripper.y"
9587  {
9588 #if 0
9589  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9590 #endif
9591  (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9592 
9593  }
9594  break;
9595 
9596  case 436:
9597 
9598 /* Line 1806 of yacc.c */
9599 #line 3875 "ripper.y"
9600  {
9601 #if 0
9602  (yyval.val) = (yyvsp[(2) - (3)].val);
9603 #endif
9604  (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val));
9605 
9606  }
9607  break;
9608 
9609  case 437:
9610 
9611 /* Line 1806 of yacc.c */
9612 #line 3885 "ripper.y"
9613  {
9614 #if 0
9615  NODE *node = (yyvsp[(2) - (3)].val);
9616  if (!node) {
9617  node = NEW_XSTR(STR_NEW0());
9618  }
9619  else {
9620  switch (nd_type(node)) {
9621  case NODE_STR:
9622  nd_set_type(node, NODE_XSTR);
9623  break;
9624  case NODE_DSTR:
9625  nd_set_type(node, NODE_DXSTR);
9626  break;
9627  default:
9628  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
9629  break;
9630  }
9631  }
9632  (yyval.val) = node;
9633 #endif
9634  (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val));
9635 
9636  }
9637  break;
9638 
9639  case 438:
9640 
9641 /* Line 1806 of yacc.c */
9642 #line 3912 "ripper.y"
9643  {
9644 #if 0
9645  int options = (yyvsp[(3) - (3)].val);
9646  NODE *node = (yyvsp[(2) - (3)].val);
9647  NODE *list, *prev;
9648  if (!node) {
9649  node = NEW_LIT(reg_compile(STR_NEW0(), options));
9650  }
9651  else switch (nd_type(node)) {
9652  case NODE_STR:
9653  {
9654  VALUE src = node->nd_lit;
9655  nd_set_type(node, NODE_LIT);
9656  node->nd_lit = reg_compile(src, options);
9657  }
9658  break;
9659  default:
9660  node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
9661  case NODE_DSTR:
9662  if (options & RE_OPTION_ONCE) {
9664  }
9665  else {
9666  nd_set_type(node, NODE_DREGX);
9667  }
9668  node->nd_cflag = options & RE_OPTION_MASK;
9669  if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
9670  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
9671  if (nd_type(list->nd_head) == NODE_STR) {
9672  VALUE tail = list->nd_head->nd_lit;
9673  if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
9674  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
9675  if (!literal_concat0(parser, lit, tail)) {
9676  node = 0;
9677  break;
9678  }
9679  rb_str_resize(tail, 0);
9680  prev->nd_next = list->nd_next;
9681  rb_gc_force_recycle((VALUE)list->nd_head);
9682  rb_gc_force_recycle((VALUE)list);
9683  list = prev;
9684  }
9685  else {
9686  prev = list;
9687  }
9688  }
9689  else {
9690  prev = 0;
9691  }
9692  }
9693  if (!node->nd_next) {
9694  VALUE src = node->nd_lit;
9695  nd_set_type(node, NODE_LIT);
9696  node->nd_lit = reg_compile(src, options);
9697  }
9698  break;
9699  }
9700  (yyval.val) = node;
9701 #endif
9702  (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
9703 
9704  }
9705  break;
9706 
9707  case 439:
9708 
9709 /* Line 1806 of yacc.c */
9710 #line 3977 "ripper.y"
9711  {
9712 #if 0
9713  (yyval.val) = NEW_ZARRAY();
9714 #endif
9715  (yyval.val) = dispatch0(words_new);
9716  (yyval.val) = dispatch1(array, (yyval.val));
9717 
9718  }
9719  break;
9720 
9721  case 440:
9722 
9723 /* Line 1806 of yacc.c */
9724 #line 3986 "ripper.y"
9725  {
9726 #if 0
9727  (yyval.val) = (yyvsp[(2) - (3)].val);
9728 #endif
9729  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9730 
9731  }
9732  break;
9733 
9734  case 441:
9735 
9736 /* Line 1806 of yacc.c */
9737 #line 3996 "ripper.y"
9738  {
9739 #if 0
9740  (yyval.val) = 0;
9741 #endif
9742  (yyval.val) = dispatch0(words_new);
9743 
9744  }
9745  break;
9746 
9747  case 442:
9748 
9749 /* Line 1806 of yacc.c */
9750 #line 4004 "ripper.y"
9751  {
9752 #if 0
9753  (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
9754 #endif
9755  (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9756 
9757  }
9758  break;
9759 
9760  case 443:
9761 
9762 /* Line 1806 of yacc.c */
9763 #line 4016 "ripper.y"
9764  {
9765  (yyval.val) = dispatch0(word_new);
9766  (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
9767  }
9768  break;
9769 
9770  case 444:
9771 
9772 /* Line 1806 of yacc.c */
9773 #line 4022 "ripper.y"
9774  {
9775 #if 0
9776  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9777 #endif
9778  (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9779 
9780  }
9781  break;
9782 
9783  case 445:
9784 
9785 /* Line 1806 of yacc.c */
9786 #line 4032 "ripper.y"
9787  {
9788 #if 0
9789  (yyval.val) = NEW_ZARRAY();
9790 #endif
9791  (yyval.val) = dispatch0(qwords_new);
9792  (yyval.val) = dispatch1(array, (yyval.val));
9793 
9794  }
9795  break;
9796 
9797  case 446:
9798 
9799 /* Line 1806 of yacc.c */
9800 #line 4041 "ripper.y"
9801  {
9802 #if 0
9803  (yyval.val) = (yyvsp[(2) - (3)].val);
9804 #endif
9805  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9806 
9807  }
9808  break;
9809 
9810  case 447:
9811 
9812 /* Line 1806 of yacc.c */
9813 #line 4051 "ripper.y"
9814  {
9815 #if 0
9816  (yyval.val) = 0;
9817 #endif
9818  (yyval.val) = dispatch0(qwords_new);
9819 
9820  }
9821  break;
9822 
9823  case 448:
9824 
9825 /* Line 1806 of yacc.c */
9826 #line 4059 "ripper.y"
9827  {
9828 #if 0
9829  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9830 #endif
9831  (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9832 
9833  }
9834  break;
9835 
9836  case 449:
9837 
9838 /* Line 1806 of yacc.c */
9839 #line 4069 "ripper.y"
9840  {
9841 #if 0
9842  (yyval.val) = 0;
9843 #endif
9844  (yyval.val) = dispatch0(string_content);
9845 
9846  }
9847  break;
9848 
9849  case 450:
9850 
9851 /* Line 1806 of yacc.c */
9852 #line 4077 "ripper.y"
9853  {
9854 #if 0
9855  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9856 #endif
9857  (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9858 
9859  }
9860  break;
9861 
9862  case 451:
9863 
9864 /* Line 1806 of yacc.c */
9865 #line 4087 "ripper.y"
9866  {
9867 #if 0
9868  (yyval.val) = 0;
9869 #endif
9870  (yyval.val) = dispatch0(xstring_new);
9871 
9872  }
9873  break;
9874 
9875  case 452:
9876 
9877 /* Line 1806 of yacc.c */
9878 #line 4095 "ripper.y"
9879  {
9880 #if 0
9881  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9882 #endif
9883  (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9884 
9885  }
9886  break;
9887 
9888  case 453:
9889 
9890 /* Line 1806 of yacc.c */
9891 #line 4105 "ripper.y"
9892  {
9893 #if 0
9894  (yyval.val) = 0;
9895 #endif
9896  (yyval.val) = dispatch0(regexp_new);
9897 
9898  }
9899  break;
9900 
9901  case 454:
9902 
9903 /* Line 1806 of yacc.c */
9904 #line 4113 "ripper.y"
9905  {
9906 #if 0
9907  NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
9908  if (!head) {
9909  (yyval.val) = tail;
9910  }
9911  else if (!tail) {
9912  (yyval.val) = head;
9913  }
9914  else {
9915  switch (nd_type(head)) {
9916  case NODE_STR:
9917  nd_set_type(head, NODE_DSTR);
9918  break;
9919  case NODE_DSTR:
9920  break;
9921  default:
9922  head = list_append(NEW_DSTR(Qnil), head);
9923  break;
9924  }
9925  (yyval.val) = list_append(head, tail);
9926  }
9927 #endif
9928  (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9929 
9930  }
9931  break;
9932 
9933  case 456:
9934 
9935 /* Line 1806 of yacc.c */
9936 #line 4143 "ripper.y"
9937  {
9938  (yyval.node) = lex_strterm;
9939  lex_strterm = 0;
9940  lex_state = EXPR_BEG;
9941  }
9942  break;
9943 
9944  case 457:
9945 
9946 /* Line 1806 of yacc.c */
9947 #line 4149 "ripper.y"
9948  {
9949 #if 0
9950  lex_strterm = (yyvsp[(2) - (3)].node);
9951  (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
9952 #endif
9953  lex_strterm = (yyvsp[(2) - (3)].node);
9954  (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
9955 
9956  }
9957  break;
9958 
9959  case 458:
9960 
9961 /* Line 1806 of yacc.c */
9962 #line 4159 "ripper.y"
9963  {
9964  (yyvsp[(1) - (1)].val) = cond_stack;
9965  (yyval.val) = cmdarg_stack;
9966  cond_stack = 0;
9967  cmdarg_stack = 0;
9968  }
9969  break;
9970 
9971  case 459:
9972 
9973 /* Line 1806 of yacc.c */
9974 #line 4165 "ripper.y"
9975  {
9976  (yyval.node) = lex_strterm;
9977  lex_strterm = 0;
9978  lex_state = EXPR_BEG;
9979  }
9980  break;
9981 
9982  case 460:
9983 
9984 /* Line 1806 of yacc.c */
9985 #line 4171 "ripper.y"
9986  {
9987  cond_stack = (yyvsp[(1) - (5)].val);
9988  cmdarg_stack = (yyvsp[(2) - (5)].val);
9989  lex_strterm = (yyvsp[(3) - (5)].node);
9990 #if 0
9991  if ((yyvsp[(4) - (5)].val)) (yyvsp[(4) - (5)].val)->flags &= ~NODE_FL_NEWLINE;
9992  (yyval.val) = new_evstr((yyvsp[(4) - (5)].val));
9993 #endif
9994  (yyval.val) = dispatch1(string_embexpr, (yyvsp[(4) - (5)].val));
9995 
9996  }
9997  break;
9998 
9999  case 461:
10000 
10001 /* Line 1806 of yacc.c */
10002 #line 4185 "ripper.y"
10003  {
10004 #if 0
10005  (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
10006 #endif
10007  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10008 
10009  }
10010  break;
10011 
10012  case 462:
10013 
10014 /* Line 1806 of yacc.c */
10015 #line 4193 "ripper.y"
10016  {
10017 #if 0
10018  (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
10019 #endif
10020  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10021 
10022  }
10023  break;
10024 
10025  case 463:
10026 
10027 /* Line 1806 of yacc.c */
10028 #line 4201 "ripper.y"
10029  {
10030 #if 0
10031  (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
10032 #endif
10033  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10034 
10035  }
10036  break;
10037 
10038  case 465:
10039 
10040 /* Line 1806 of yacc.c */
10041 #line 4212 "ripper.y"
10042  {
10043  lex_state = EXPR_END;
10044 #if 0
10045  (yyval.val) = (yyvsp[(2) - (2)].val);
10046 #endif
10047  (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
10048 
10049  }
10050  break;
10051 
10052  case 470:
10053 
10054 /* Line 1806 of yacc.c */
10055 #line 4229 "ripper.y"
10056  {
10057  lex_state = EXPR_END;
10058 #if 0
10059  if (!((yyval.val) = (yyvsp[(2) - (3)].val))) {
10060  (yyval.val) = NEW_LIT(ID2SYM(rb_intern("")));
10061  }
10062  else {
10063  VALUE lit;
10064 
10065  switch (nd_type((yyval.val))) {
10066  case NODE_DSTR:
10067  nd_set_type((yyval.val), NODE_DSYM);
10068  break;
10069  case NODE_STR:
10070  lit = (yyval.val)->nd_lit;
10071  (yyval.val)->nd_lit = ID2SYM(rb_intern_str(lit));
10072  nd_set_type((yyval.val), NODE_LIT);
10073  break;
10074  default:
10075  (yyval.val) = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST((yyval.val)));
10076  break;
10077  }
10078  }
10079 #endif
10080  (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
10081 
10082  }
10083  break;
10084 
10085  case 473:
10086 
10087 /* Line 1806 of yacc.c */
10088 #line 4261 "ripper.y"
10089  {
10090 #if 0
10091  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10092 #endif
10093  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10094 
10095  }
10096  break;
10097 
10098  case 474:
10099 
10100 /* Line 1806 of yacc.c */
10101 #line 4269 "ripper.y"
10102  {
10103 #if 0
10104  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10105 #endif
10106  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10107 
10108  }
10109  break;
10110 
10111  case 480:
10112 
10113 /* Line 1806 of yacc.c */
10114 #line 4285 "ripper.y"
10115  {ifndef_ripper((yyval.val) = keyword_nil);}
10116  break;
10117 
10118  case 481:
10119 
10120 /* Line 1806 of yacc.c */
10121 #line 4286 "ripper.y"
10122  {ifndef_ripper((yyval.val) = keyword_self);}
10123  break;
10124 
10125  case 482:
10126 
10127 /* Line 1806 of yacc.c */
10128 #line 4287 "ripper.y"
10129  {ifndef_ripper((yyval.val) = keyword_true);}
10130  break;
10131 
10132  case 483:
10133 
10134 /* Line 1806 of yacc.c */
10135 #line 4288 "ripper.y"
10136  {ifndef_ripper((yyval.val) = keyword_false);}
10137  break;
10138 
10139  case 484:
10140 
10141 /* Line 1806 of yacc.c */
10142 #line 4289 "ripper.y"
10143  {ifndef_ripper((yyval.val) = keyword__FILE__);}
10144  break;
10145 
10146  case 485:
10147 
10148 /* Line 1806 of yacc.c */
10149 #line 4290 "ripper.y"
10150  {ifndef_ripper((yyval.val) = keyword__LINE__);}
10151  break;
10152 
10153  case 486:
10154 
10155 /* Line 1806 of yacc.c */
10156 #line 4291 "ripper.y"
10157  {ifndef_ripper((yyval.val) = keyword__ENCODING__);}
10158  break;
10159 
10160  case 487:
10161 
10162 /* Line 1806 of yacc.c */
10163 #line 4295 "ripper.y"
10164  {
10165 #if 0
10166  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10167 #endif
10168  if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) {
10169  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10170  }
10171  else {
10172  (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val));
10173  }
10174 
10175  }
10176  break;
10177 
10178  case 488:
10179 
10180 /* Line 1806 of yacc.c */
10181 #line 4308 "ripper.y"
10182  {
10183 #if 0
10184  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10185 #endif
10186  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10187 
10188  }
10189  break;
10190 
10191  case 489:
10192 
10193 /* Line 1806 of yacc.c */
10194 #line 4318 "ripper.y"
10195  {
10196  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10197 #if 0
10198 #endif
10199  (yyval.val) = dispatch1(var_field, (yyval.val));
10200 
10201  }
10202  break;
10203 
10204  case 490:
10205 
10206 /* Line 1806 of yacc.c */
10207 #line 4326 "ripper.y"
10208  {
10209  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10210 #if 0
10211 #endif
10212  (yyval.val) = dispatch1(var_field, (yyval.val));
10213 
10214  }
10215  break;
10216 
10217  case 493:
10218 
10219 /* Line 1806 of yacc.c */
10220 #line 4340 "ripper.y"
10221  {
10222 #if 0
10223  (yyval.val) = 0;
10224 #endif
10225  (yyval.val) = Qnil;
10226 
10227  }
10228  break;
10229 
10230  case 494:
10231 
10232 /* Line 1806 of yacc.c */
10233 #line 4348 "ripper.y"
10234  {
10235  lex_state = EXPR_BEG;
10236  }
10237  break;
10238 
10239  case 495:
10240 
10241 /* Line 1806 of yacc.c */
10242 #line 4352 "ripper.y"
10243  {
10244  (yyval.val) = (yyvsp[(3) - (4)].val);
10245  }
10246  break;
10247 
10248  case 496:
10249 
10250 /* Line 1806 of yacc.c */
10251 #line 4356 "ripper.y"
10252  {
10253 #if 0
10254  yyerrok;
10255  (yyval.val) = 0;
10256 #endif
10257  yyerrok;
10258  (yyval.val) = Qnil;
10259 
10260  }
10261  break;
10262 
10263  case 497:
10264 
10265 /* Line 1806 of yacc.c */
10266 #line 4368 "ripper.y"
10267  {
10268 #if 0
10269  (yyval.val) = (yyvsp[(2) - (3)].val);
10270 #endif
10271  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
10272 
10273  lex_state = EXPR_BEG;
10274  command_start = TRUE;
10275  }
10276  break;
10277 
10278  case 498:
10279 
10280 /* Line 1806 of yacc.c */
10281 #line 4378 "ripper.y"
10282  {
10283  (yyval.val) = (yyvsp[(1) - (2)].val);
10284  lex_state = EXPR_BEG;
10285  command_start = TRUE;
10286  }
10287  break;
10288 
10289  case 499:
10290 
10291 /* Line 1806 of yacc.c */
10292 #line 4386 "ripper.y"
10293  {
10294 #if 0
10295  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), 0, (yyvsp[(6) - (6)].val));
10296 #endif
10297  (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnil, escape_Qundef((yyvsp[(6) - (6)].val)));
10298 
10299  }
10300  break;
10301 
10302  case 500:
10303 
10304 /* Line 1806 of yacc.c */
10305 #line 4394 "ripper.y"
10306  {
10307 #if 0
10308  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10309 #endif
10310  (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)));
10311 
10312  }
10313  break;
10314 
10315  case 501:
10316 
10317 /* Line 1806 of yacc.c */
10318 #line 4402 "ripper.y"
10319  {
10320 #if 0
10321  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, 0, (yyvsp[(4) - (4)].val));
10322 #endif
10323  (yyval.val) = params_new((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
10324 
10325  }
10326  break;
10327 
10328  case 502:
10329 
10330 /* Line 1806 of yacc.c */
10331 #line 4410 "ripper.y"
10332  {
10333 #if 0
10334  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), 0, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10335 #endif
10336  (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnil, (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
10337 
10338  }
10339  break;
10340 
10341  case 503:
10342 
10343 /* Line 1806 of yacc.c */
10344 #line 4418 "ripper.y"
10345  {
10346 #if 0
10347  (yyval.val) = new_args((yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
10348 #endif
10349  (yyval.val) = params_new((yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
10350 
10351  }
10352  break;
10353 
10354  case 504:
10355 
10356 /* Line 1806 of yacc.c */
10357 #line 4426 "ripper.y"
10358  {
10359 #if 0
10360  (yyval.val) = new_args((yyvsp[(1) - (6)].val), 0, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10361 #endif
10362  (yyval.val) = params_new((yyvsp[(1) - (6)].val), Qnil, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
10363 
10364  }
10365  break;
10366 
10367  case 505:
10368 
10369 /* Line 1806 of yacc.c */
10370 #line 4434 "ripper.y"
10371  {
10372 #if 0
10373  (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 0, 0, (yyvsp[(2) - (2)].val));
10374 #endif
10375  (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil, Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10376 
10377  }
10378  break;
10379 
10380  case 506:
10381 
10382 /* Line 1806 of yacc.c */
10383 #line 4442 "ripper.y"
10384  {
10385 #if 0
10386  (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
10387 #endif
10388  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
10389 
10390  }
10391  break;
10392 
10393  case 507:
10394 
10395 /* Line 1806 of yacc.c */
10396 #line 4450 "ripper.y"
10397  {
10398 #if 0
10399  (yyval.val) = new_args(0, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10400 #endif
10401  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
10402 
10403  }
10404  break;
10405 
10406  case 508:
10407 
10408 /* Line 1806 of yacc.c */
10409 #line 4458 "ripper.y"
10410  {
10411 #if 0
10412  (yyval.val) = new_args(0, (yyvsp[(1) - (2)].val), 0, 0, (yyvsp[(2) - (2)].val));
10413 #endif
10414  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (2)].val), Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10415 
10416  }
10417  break;
10418 
10419  case 509:
10420 
10421 /* Line 1806 of yacc.c */
10422 #line 4466 "ripper.y"
10423  {
10424 #if 0
10425  (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10426 #endif
10427  (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
10428 
10429  }
10430  break;
10431 
10432  case 510:
10433 
10434 /* Line 1806 of yacc.c */
10435 #line 4474 "ripper.y"
10436  {
10437 #if 0
10438  (yyval.val) = new_args(0, 0, (yyvsp[(1) - (2)].val), 0, (yyvsp[(2) - (2)].val));
10439 #endif
10440  (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (2)].val), Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10441 
10442  }
10443  break;
10444 
10445  case 511:
10446 
10447 /* Line 1806 of yacc.c */
10448 #line 4482 "ripper.y"
10449  {
10450 #if 0
10451  (yyval.val) = new_args(0, 0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10452 #endif
10453  (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
10454 
10455  }
10456  break;
10457 
10458  case 512:
10459 
10460 /* Line 1806 of yacc.c */
10461 #line 4490 "ripper.y"
10462  {
10463 #if 0
10464  (yyval.val) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].val));
10465 #endif
10466  (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, (yyvsp[(1) - (1)].val));
10467 
10468  }
10469  break;
10470 
10471  case 513:
10472 
10473 /* Line 1806 of yacc.c */
10474 #line 4498 "ripper.y"
10475  {
10476 #if 0
10477  (yyval.val) = new_args(0, 0, 0, 0, 0);
10478 #endif
10479  (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, Qnil);
10480 
10481  }
10482  break;
10483 
10484  case 514:
10485 
10486 /* Line 1806 of yacc.c */
10487 #line 4508 "ripper.y"
10488  {
10489 #if 0
10490  yyerror("formal argument cannot be a constant");
10491  (yyval.val) = 0;
10492 #endif
10493  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10494 
10495  }
10496  break;
10497 
10498  case 515:
10499 
10500 /* Line 1806 of yacc.c */
10501 #line 4517 "ripper.y"
10502  {
10503 #if 0
10504  yyerror("formal argument cannot be an instance variable");
10505  (yyval.val) = 0;
10506 #endif
10507  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10508 
10509  }
10510  break;
10511 
10512  case 516:
10513 
10514 /* Line 1806 of yacc.c */
10515 #line 4526 "ripper.y"
10516  {
10517 #if 0
10518  yyerror("formal argument cannot be a global variable");
10519  (yyval.val) = 0;
10520 #endif
10521  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10522 
10523  }
10524  break;
10525 
10526  case 517:
10527 
10528 /* Line 1806 of yacc.c */
10529 #line 4535 "ripper.y"
10530  {
10531 #if 0
10532  yyerror("formal argument cannot be a class variable");
10533  (yyval.val) = 0;
10534 #endif
10535  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10536 
10537  }
10538  break;
10539 
10540  case 519:
10541 
10542 /* Line 1806 of yacc.c */
10543 #line 4547 "ripper.y"
10544  {
10545  formal_argument(get_id((yyvsp[(1) - (1)].val)));
10546  (yyval.val) = (yyvsp[(1) - (1)].val);
10547  }
10548  break;
10549 
10550  case 520:
10551 
10552 /* Line 1806 of yacc.c */
10553 #line 4554 "ripper.y"
10554  {
10555  arg_var(get_id((yyvsp[(1) - (1)].val)));
10556 #if 0
10557  (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10558 #endif
10559  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10560 
10561  }
10562  break;
10563 
10564  case 521:
10565 
10566 /* Line 1806 of yacc.c */
10567 #line 4563 "ripper.y"
10568  {
10569  ID tid = internal_id();
10570  arg_var(tid);
10571 #if 0
10572  if (dyna_in_block()) {
10573  (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10574  }
10575  else {
10576  (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10577  }
10578  (yyval.val) = NEW_ARGS_AUX(tid, 1);
10579  (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10580 #endif
10581  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10582 
10583  }
10584  break;
10585 
10586  case 522:
10587 
10588 /* Line 1806 of yacc.c */
10589 #line 4584 "ripper.y"
10590  {
10591  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10592  }
10593  break;
10594 
10595  case 523:
10596 
10597 /* Line 1806 of yacc.c */
10598 #line 4589 "ripper.y"
10599  {
10600 #if 0
10601  (yyval.val) = (yyvsp[(1) - (3)].val);
10602  (yyval.val)->nd_plen++;
10603  (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10604  rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10605 #endif
10606  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10607 
10608  }
10609  break;
10610 
10611  case 524:
10612 
10613 /* Line 1806 of yacc.c */
10614 #line 4602 "ripper.y"
10615  {
10616  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10617  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10618 #if 0
10619  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10620 #endif
10621  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10622 
10623  }
10624  break;
10625 
10626  case 525:
10627 
10628 /* Line 1806 of yacc.c */
10629 #line 4614 "ripper.y"
10630  {
10631  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10632  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10633 #if 0
10634  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10635 #endif
10636  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10637 
10638  }
10639  break;
10640 
10641  case 526:
10642 
10643 /* Line 1806 of yacc.c */
10644 #line 4626 "ripper.y"
10645  {
10646 #if 0
10647  (yyval.val) = (yyvsp[(1) - (1)].val);
10648 #endif
10649  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10650 
10651  }
10652  break;
10653 
10654  case 527:
10655 
10656 /* Line 1806 of yacc.c */
10657 #line 4634 "ripper.y"
10658  {
10659 #if 0
10660  NODE *opts = (yyvsp[(1) - (3)].val);
10661 
10662  while (opts->nd_next) {
10663  opts = opts->nd_next;
10664  }
10665  opts->nd_next = (yyvsp[(3) - (3)].val);
10666  (yyval.val) = (yyvsp[(1) - (3)].val);
10667 #endif
10668  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10669 
10670  }
10671  break;
10672 
10673  case 528:
10674 
10675 /* Line 1806 of yacc.c */
10676 #line 4650 "ripper.y"
10677  {
10678 #if 0
10679  (yyval.val) = (yyvsp[(1) - (1)].val);
10680 #endif
10681  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10682 
10683  }
10684  break;
10685 
10686  case 529:
10687 
10688 /* Line 1806 of yacc.c */
10689 #line 4658 "ripper.y"
10690  {
10691 #if 0
10692  NODE *opts = (yyvsp[(1) - (3)].val);
10693 
10694  while (opts->nd_next) {
10695  opts = opts->nd_next;
10696  }
10697  opts->nd_next = (yyvsp[(3) - (3)].val);
10698  (yyval.val) = (yyvsp[(1) - (3)].val);
10699 #endif
10700  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10701 
10702  }
10703  break;
10704 
10705  case 532:
10706 
10707 /* Line 1806 of yacc.c */
10708 #line 4678 "ripper.y"
10709  {
10710 #if 0
10711  if (!is_local_id((yyvsp[(2) - (2)].val)))
10712  yyerror("rest argument must be local variable");
10713 #endif
10714  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10715 #if 0
10716  (yyval.val) = (yyvsp[(2) - (2)].val);
10717 #endif
10718  (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
10719 
10720  }
10721  break;
10722 
10723  case 533:
10724 
10725 /* Line 1806 of yacc.c */
10726 #line 4691 "ripper.y"
10727  {
10728 #if 0
10729  (yyval.val) = internal_id();
10730  arg_var((yyval.val));
10731 #endif
10732  (yyval.val) = dispatch1(rest_param, Qnil);
10733 
10734  }
10735  break;
10736 
10737  case 536:
10738 
10739 /* Line 1806 of yacc.c */
10740 #line 4706 "ripper.y"
10741  {
10742 #if 0
10743  if (!is_local_id((yyvsp[(2) - (2)].val)))
10744  yyerror("block argument must be local variable");
10745  else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
10746  yyerror("duplicated block argument name");
10747 #endif
10748  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10749 #if 0
10750  (yyval.val) = (yyvsp[(2) - (2)].val);
10751 #endif
10752  (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
10753 
10754  }
10755  break;
10756 
10757  case 537:
10758 
10759 /* Line 1806 of yacc.c */
10760 #line 4723 "ripper.y"
10761  {
10762  (yyval.val) = (yyvsp[(2) - (2)].val);
10763  }
10764  break;
10765 
10766  case 538:
10767 
10768 /* Line 1806 of yacc.c */
10769 #line 4727 "ripper.y"
10770  {
10771 #if 0
10772  (yyval.val) = 0;
10773 #endif
10774  (yyval.val) = Qundef;
10775 
10776  }
10777  break;
10778 
10779  case 539:
10780 
10781 /* Line 1806 of yacc.c */
10782 #line 4737 "ripper.y"
10783  {
10784 #if 0
10785  value_expr((yyvsp[(1) - (1)].val));
10786  (yyval.val) = (yyvsp[(1) - (1)].val);
10787  if (!(yyval.val)) (yyval.val) = NEW_NIL();
10788 #endif
10789  (yyval.val) = (yyvsp[(1) - (1)].val);
10790 
10791  }
10792  break;
10793 
10794  case 540:
10795 
10796 /* Line 1806 of yacc.c */
10797 #line 4746 "ripper.y"
10798  {lex_state = EXPR_BEG;}
10799  break;
10800 
10801  case 541:
10802 
10803 /* Line 1806 of yacc.c */
10804 #line 4747 "ripper.y"
10805  {
10806 #if 0
10807  if ((yyvsp[(3) - (4)].val) == 0) {
10808  yyerror("can't define singleton method for ().");
10809  }
10810  else {
10811  switch (nd_type((yyvsp[(3) - (4)].val))) {
10812  case NODE_STR:
10813  case NODE_DSTR:
10814  case NODE_XSTR:
10815  case NODE_DXSTR:
10816  case NODE_DREGX:
10817  case NODE_LIT:
10818  case NODE_ARRAY:
10819  case NODE_ZARRAY:
10820  yyerror("can't define singleton method for literals");
10821  default:
10822  value_expr((yyvsp[(3) - (4)].val));
10823  break;
10824  }
10825  }
10826  (yyval.val) = (yyvsp[(3) - (4)].val);
10827 #endif
10828  (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
10829 
10830  }
10831  break;
10832 
10833  case 543:
10834 
10835 /* Line 1806 of yacc.c */
10836 #line 4777 "ripper.y"
10837  {
10838 #if 0
10839  (yyval.val) = (yyvsp[(1) - (2)].val);
10840 #endif
10841  (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
10842 
10843  }
10844  break;
10845 
10846  case 544:
10847 
10848 /* Line 1806 of yacc.c */
10849 #line 4789 "ripper.y"
10850  {
10851  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10852  }
10853  break;
10854 
10855  case 545:
10856 
10857 /* Line 1806 of yacc.c */
10858 #line 4794 "ripper.y"
10859  {
10860 #if 0
10861  (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10862 #endif
10863  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10864 
10865  }
10866  break;
10867 
10868  case 546:
10869 
10870 /* Line 1806 of yacc.c */
10871 #line 4804 "ripper.y"
10872  {
10873 #if 0
10874  (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
10875 #endif
10876  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10877 
10878  }
10879  break;
10880 
10881  case 547:
10882 
10883 /* Line 1806 of yacc.c */
10884 #line 4812 "ripper.y"
10885  {
10886 #if 0
10887  (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
10888 #endif
10889  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10890 
10891  }
10892  break;
10893 
10894  case 558:
10895 
10896 /* Line 1806 of yacc.c */
10897 #line 4840 "ripper.y"
10898  { (yyval.val) = (yyvsp[(1) - (1)].val); }
10899  break;
10900 
10901  case 559:
10902 
10903 /* Line 1806 of yacc.c */
10904 #line 4845 "ripper.y"
10905  { (yyval.val) = (yyvsp[(1) - (1)].val); }
10906  break;
10907 
10908  case 569:
10909 
10910 /* Line 1806 of yacc.c */
10911 #line 4868 "ripper.y"
10912  {yyerrok;}
10913  break;
10914 
10915  case 572:
10916 
10917 /* Line 1806 of yacc.c */
10918 #line 4873 "ripper.y"
10919  {yyerrok;}
10920  break;
10921 
10922  case 573:
10923 
10924 /* Line 1806 of yacc.c */
10925 #line 4877 "ripper.y"
10926  {
10927 #if 0
10928  (yyval.val) = 0;
10929 #endif
10930  (yyval.val) = Qundef;
10931 
10932  }
10933  break;
10934 
10935 
10936 
10937 /* Line 1806 of yacc.c */
10938 #line 10937 "parse.c"
10939  default: break;
10940  }
10941  /* User semantic actions sometimes alter yychar, and that requires
10942  that yytoken be updated with the new translation. We take the
10943  approach of translating immediately before every use of yytoken.
10944  One alternative is translating here after every semantic action,
10945  but that translation would be missed if the semantic action invokes
10946  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
10947  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
10948  incorrect destructor might then be invoked immediately. In the
10949  case of YYERROR or YYBACKUP, subsequent parser actions might lead
10950  to an incorrect destructor call or verbose syntax error message
10951  before the lookahead is translated. */
10952  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
10953 
10954  YYPOPSTACK (yylen);
10955  yylen = 0;
10956  YY_STACK_PRINT (yyss, yyssp);
10957 
10958  *++yyvsp = yyval;
10959 
10960  /* Now `shift' the result of the reduction. Determine what state
10961  that goes to, based on the state we popped back to and the rule
10962  number reduced by. */
10963 
10964  yyn = yyr1[yyn];
10965 
10966  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
10967  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
10968  yystate = yytable[yystate];
10969  else
10970  yystate = yydefgoto[yyn - YYNTOKENS];
10971 
10972  goto yynewstate;
10973 
10974 
10975 /*------------------------------------.
10976 | yyerrlab -- here on detecting error |
10977 `------------------------------------*/
10978 yyerrlab:
10979  /* Make sure we have latest lookahead translation. See comments at
10980  user semantic actions for why this is necessary. */
10981  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
10982 
10983  /* If not already recovering from an error, report this error. */
10984  if (!yyerrstatus)
10985  {
10986  ++yynerrs;
10987 #if ! YYERROR_VERBOSE
10988  parser_yyerror (parser, YY_("syntax error"));
10989 #else
10990 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
10991  yyssp, yytoken)
10992  {
10993  char const *yymsgp = YY_("syntax error");
10994  int yysyntax_error_status;
10995  yysyntax_error_status = YYSYNTAX_ERROR;
10996  if (yysyntax_error_status == 0)
10997  yymsgp = yymsg;
10998  else if (yysyntax_error_status == 1)
10999  {
11000  if (yymsg != yymsgbuf)
11001  YYSTACK_FREE (yymsg);
11002  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11003  if (!yymsg)
11004  {
11005  yymsg = yymsgbuf;
11006  yymsg_alloc = sizeof yymsgbuf;
11007  yysyntax_error_status = 2;
11008  }
11009  else
11010  {
11011  yysyntax_error_status = YYSYNTAX_ERROR;
11012  yymsgp = yymsg;
11013  }
11014  }
11015  parser_yyerror (parser, yymsgp);
11016  if (yysyntax_error_status == 2)
11017  goto yyexhaustedlab;
11018  }
11019 # undef YYSYNTAX_ERROR
11020 #endif
11021  }
11022 
11023 
11024 
11025  if (yyerrstatus == 3)
11026  {
11027  /* If just tried and failed to reuse lookahead token after an
11028  error, discard it. */
11029 
11030  if (yychar <= YYEOF)
11031  {
11032  /* Return failure if at end of input. */
11033  if (yychar == YYEOF)
11034  YYABORT;
11035  }
11036  else
11037  {
11038  yydestruct ("Error: discarding",
11039  yytoken, &yylval, parser);
11040  yychar = YYEMPTY;
11041  }
11042  }
11043 
11044  /* Else will try to reuse lookahead token after shifting the error
11045  token. */
11046  goto yyerrlab1;
11047 
11048 
11049 /*---------------------------------------------------.
11050 | yyerrorlab -- error raised explicitly by YYERROR. |
11051 `---------------------------------------------------*/
11052 yyerrorlab:
11053 
11054  /* Pacify compilers like GCC when the user code never invokes
11055  YYERROR and the label yyerrorlab therefore never appears in user
11056  code. */
11057  if (/*CONSTCOND*/ 0)
11058  goto yyerrorlab;
11059 
11060  /* Do not reclaim the symbols of the rule which action triggered
11061  this YYERROR. */
11062  YYPOPSTACK (yylen);
11063  yylen = 0;
11064  YY_STACK_PRINT (yyss, yyssp);
11065  yystate = *yyssp;
11066  goto yyerrlab1;
11067 
11068 
11069 /*-------------------------------------------------------------.
11070 | yyerrlab1 -- common code for both syntax error and YYERROR. |
11071 `-------------------------------------------------------------*/
11072 yyerrlab1:
11073  yyerrstatus = 3; /* Each real token shifted decrements this. */
11074 
11075  for (;;)
11076  {
11077  yyn = yypact[yystate];
11078  if (!yypact_value_is_default (yyn))
11079  {
11080  yyn += YYTERROR;
11081  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11082  {
11083  yyn = yytable[yyn];
11084  if (0 < yyn)
11085  break;
11086  }
11087  }
11088 
11089  /* Pop the current state because it cannot handle the error token. */
11090  if (yyssp == yyss)
11091  YYABORT;
11092 
11093 
11094  yydestruct ("Error: popping",
11095  yystos[yystate], yyvsp, parser);
11096  YYPOPSTACK (1);
11097  yystate = *yyssp;
11098  YY_STACK_PRINT (yyss, yyssp);
11099  }
11100 
11101  *++yyvsp = yylval;
11102 
11103 
11104  /* Shift the error token. */
11105  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11106 
11107  yystate = yyn;
11108  goto yynewstate;
11109 
11110 
11111 /*-------------------------------------.
11112 | yyacceptlab -- YYACCEPT comes here. |
11113 `-------------------------------------*/
11114 yyacceptlab:
11115  yyresult = 0;
11116  goto yyreturn;
11117 
11118 /*-----------------------------------.
11119 | yyabortlab -- YYABORT comes here. |
11120 `-----------------------------------*/
11121 yyabortlab:
11122  yyresult = 1;
11123  goto yyreturn;
11124 
11125 #if !defined(yyoverflow) || YYERROR_VERBOSE
11126 /*-------------------------------------------------.
11127 | yyexhaustedlab -- memory exhaustion comes here. |
11128 `-------------------------------------------------*/
11129 yyexhaustedlab:
11130  parser_yyerror (parser, YY_("memory exhausted"));
11131  yyresult = 2;
11132  /* Fall through. */
11133 #endif
11134 
11135 yyreturn:
11136  if (yychar != YYEMPTY)
11137  {
11138  /* Make sure we have latest lookahead translation. See comments at
11139  user semantic actions for why this is necessary. */
11140  yytoken = YYTRANSLATE (yychar);
11141  yydestruct ("Cleanup: discarding lookahead",
11142  yytoken, &yylval, parser);
11143  }
11144  /* Do not reclaim the symbols of the rule which action triggered
11145  this YYABORT or YYACCEPT. */
11146  YYPOPSTACK (yylen);
11147  YY_STACK_PRINT (yyss, yyssp);
11148  while (yyssp != yyss)
11149  {
11150  yydestruct ("Cleanup: popping",
11151  yystos[*yyssp], yyvsp, parser);
11152  YYPOPSTACK (1);
11153  }
11154 #ifndef yyoverflow
11155  if (yyss != yyssa)
11156  YYSTACK_FREE (yyss);
11157 #endif
11158 #if YYERROR_VERBOSE
11159  if (yymsg != yymsgbuf)
11160  YYSTACK_FREE (yymsg);
11161 #endif
11162  /* Make sure YYID is used. */
11163  return YYID (yyresult);
11164 }
11165 
11166 
11167 
11168 /* Line 2067 of yacc.c */
11169 #line 4885 "ripper.y"
11170 
11171 # undef parser
11172 # undef yylex
11173 # undef yylval
11174 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
11175 
11176 static int parser_regx_options(struct parser_params*);
11177 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11178 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11179 static int parser_parse_string(struct parser_params*,NODE*);
11180 static int parser_here_document(struct parser_params*,NODE*);
11181 
11182 
11183 # define nextc() parser_nextc(parser)
11184 # define pushback(c) parser_pushback(parser, (c))
11185 # define newtok() parser_newtok(parser)
11186 # define tokspace(n) parser_tokspace(parser, (n))
11187 # define tokadd(c) parser_tokadd(parser, (c))
11188 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
11189 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
11190 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
11191 # define regx_options() parser_regx_options(parser)
11192 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11193 # define parse_string(n) parser_parse_string(parser,(n))
11194 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
11195 # define here_document(n) parser_here_document(parser,(n))
11196 # define heredoc_identifier() parser_heredoc_identifier(parser)
11197 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
11198 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
11199 
11200 #ifndef RIPPER
11201 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11202 # define set_yylval_num(x) (yylval.num = (x))
11203 # define set_yylval_id(x) (yylval.id = (x))
11204 # define set_yylval_name(x) (yylval.id = (x))
11205 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11206 # define set_yylval_node(x) (yylval.node = (x))
11207 # define yylval_id() (yylval.id)
11208 #else
11209 static inline VALUE
11210 ripper_yylval_id(ID x)
11211 {
11212  return (VALUE)NEW_LASGN(x, ID2SYM(x));
11213 }
11214 # define set_yylval_str(x) (void)(x)
11215 # define set_yylval_num(x) (void)(x)
11216 # define set_yylval_id(x) (void)(x)
11217 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11218 # define set_yylval_literal(x) (void)(x)
11219 # define set_yylval_node(x) (void)(x)
11220 # define yylval_id() yylval.id
11221 #endif
11222 
11223 #ifndef RIPPER
11224 #define ripper_flush(p) (void)(p)
11225 #else
11226 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11227 
11228 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11229 
11230 static int
11231 ripper_has_scan_event(struct parser_params *parser)
11232 {
11233 
11234  if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11235  return lex_p > parser->tokp;
11236 }
11237 
11238 static VALUE
11239 ripper_scan_event_val(struct parser_params *parser, int t)
11240 {
11241  VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11242  VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11243  ripper_flush(parser);
11244  return rval;
11245 }
11246 
11247 static void
11248 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11249 {
11250  if (!ripper_has_scan_event(parser)) return;
11251  yylval_rval = ripper_scan_event_val(parser, t);
11252 }
11253 
11254 static void
11255 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11256 {
11257  if (!ripper_has_scan_event(parser)) return;
11258  (void)ripper_scan_event_val(parser, t);
11259 }
11260 
11261 static void
11262 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11263 {
11264  int saved_line = ruby_sourceline;
11265  const char *saved_tokp = parser->tokp;
11266 
11267  ruby_sourceline = parser->delayed_line;
11268  parser->tokp = lex_pbeg + parser->delayed_col;
11269  yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11270  parser->delayed = Qnil;
11271  ruby_sourceline = saved_line;
11272  parser->tokp = saved_tokp;
11273 }
11274 #endif /* RIPPER */
11275 
11276 #include "ruby/regex.h"
11277 #include "ruby/util.h"
11278 
11279 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11280  since ours (we hope) works properly with all combinations of
11281  machines, compilers, `char' and `unsigned char' argument types.
11282  (Per Bothner suggested the basic approach.) */
11283 #undef SIGN_EXTEND_CHAR
11284 #if __STDC__
11285 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11286 #else /* not __STDC__ */
11287 /* As in Harbison and Steele. */
11288 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11289 #endif
11290 
11291 #define parser_encoding_name() (parser->enc->name)
11292 #define parser_mbclen() mbclen((lex_p-1),lex_pend,parser->enc)
11293 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,parser->enc)
11294 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11295 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,parser->enc))
11296 
11297 #define parser_isascii() ISASCII(*(lex_p-1))
11298 
11299 #ifndef RIPPER
11300 static int
11301 token_info_get_column(struct parser_params *parser, const char *token)
11302 {
11303  int column = 1;
11304  const char *p, *pend = lex_p - strlen(token);
11305  for (p = lex_pbeg; p < pend; p++) {
11306  if (*p == '\t') {
11307  column = (((column - 1) / 8) + 1) * 8;
11308  }
11309  column++;
11310  }
11311  return column;
11312 }
11313 
11314 static int
11315 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11316 {
11317  const char *p, *pend = lex_p - strlen(token);
11318  for (p = lex_pbeg; p < pend; p++) {
11319  if (*p != ' ' && *p != '\t') {
11320  return 1;
11321  }
11322  }
11323  return 0;
11324 }
11325 
11326 #undef token_info_push
11327 static void
11328 token_info_push(struct parser_params *parser, const char *token)
11329 {
11330  token_info *ptinfo;
11331 
11332  if (!parser->parser_token_info_enabled) return;
11333  ptinfo = ALLOC(token_info);
11334  ptinfo->token = token;
11335  ptinfo->linenum = ruby_sourceline;
11336  ptinfo->column = token_info_get_column(parser, token);
11337  ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11338  ptinfo->next = parser->parser_token_info;
11339 
11340  parser->parser_token_info = ptinfo;
11341 }
11342 
11343 #undef token_info_pop
11344 static void
11345 token_info_pop(struct parser_params *parser, const char *token)
11346 {
11347  int linenum;
11348  token_info *ptinfo = parser->parser_token_info;
11349 
11350  if (!ptinfo) return;
11351  parser->parser_token_info = ptinfo->next;
11352  if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11353  goto finish;
11354  }
11355  linenum = ruby_sourceline;
11356  if (linenum == ptinfo->linenum) { /* SKIP */
11357  goto finish;
11358  }
11359  if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11360  goto finish;
11361  }
11362  if (parser->parser_token_info_enabled) {
11364  "mismatched indentations at '%s' with '%s' at %d",
11365  token, ptinfo->token, ptinfo->linenum);
11366  }
11367 
11368  finish:
11369  xfree(ptinfo);
11370 }
11371 #endif /* RIPPER */
11372 
11373 static int
11374 parser_yyerror(struct parser_params *parser, const char *msg)
11375 {
11376 #ifndef RIPPER
11377  const int max_line_margin = 30;
11378  const char *p, *pe;
11379  char *buf;
11380  long len;
11381  int i;
11382 
11383  compile_error(PARSER_ARG "%s", msg);
11384  p = lex_p;
11385  while (lex_pbeg <= p) {
11386  if (*p == '\n') break;
11387  p--;
11388  }
11389  p++;
11390 
11391  pe = lex_p;
11392  while (pe < lex_pend) {
11393  if (*pe == '\n') break;
11394  pe++;
11395  }
11396 
11397  len = pe - p;
11398  if (len > 4) {
11399  char *p2;
11400  const char *pre = "", *post = "";
11401 
11402  if (len > max_line_margin * 2 + 10) {
11403  if (lex_p - p > max_line_margin) {
11404  p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11405  pre = "...";
11406  }
11407  if (pe - lex_p > max_line_margin) {
11408  pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11409  post = "...";
11410  }
11411  len = pe - p;
11412  }
11413  buf = ALLOCA_N(char, len+2);
11414  MEMCPY(buf, p, char, len);
11415  buf[len] = '\0';
11416  rb_compile_error_append("%s%s%s", pre, buf, post);
11417 
11418  i = (int)(lex_p - p);
11419  p2 = buf; pe = buf + len;
11420 
11421  while (p2 < pe) {
11422  if (*p2 != '\t') *p2 = ' ';
11423  p2++;
11424  }
11425  buf[i] = '^';
11426  buf[i+1] = '\0';
11427  rb_compile_error_append("%s%s", pre, buf);
11428  }
11429 #else
11430  dispatch1(parse_error, STR_NEW2(msg));
11431 #endif /* !RIPPER */
11432  return 0;
11433 }
11434 
11435 static void parser_prepare(struct parser_params *parser);
11436 
11437 #ifndef RIPPER
11438 static VALUE
11439 debug_lines(const char *f)
11440 {
11441  ID script_lines;
11442  CONST_ID(script_lines, "SCRIPT_LINES__");
11443  if (rb_const_defined_at(rb_cObject, script_lines)) {
11444  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11445  if (TYPE(hash) == T_HASH) {
11447  VALUE lines = rb_ary_new();
11448  rb_hash_aset(hash, fname, lines);
11449  return lines;
11450  }
11451  }
11452  return 0;
11453 }
11454 
11455 static VALUE
11456 coverage(const char *f, int n)
11457 {
11458  VALUE coverages = rb_get_coverages();
11459  if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11461  VALUE lines = rb_ary_new2(n);
11462  int i;
11463  RBASIC(lines)->klass = 0;
11464  for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11465  RARRAY(lines)->as.heap.len = n;
11466  rb_hash_aset(coverages, fname, lines);
11467  return lines;
11468  }
11469  return 0;
11470 }
11471 
11472 static int
11474 {
11475  return strcmp(ruby_sourcefile, "-e") == 0;
11476 }
11477 
11478 static VALUE
11479 yycompile0(VALUE arg, int tracing)
11480 {
11481  int n;
11482  NODE *tree;
11483  struct parser_params *parser = (struct parser_params *)arg;
11484 
11485  if (!compile_for_eval && rb_safe_level() == 0) {
11487  if (ruby_debug_lines && ruby_sourceline > 0) {
11488  VALUE str = STR_NEW0();
11489  n = ruby_sourceline;
11490  do {
11492  } while (--n);
11493  }
11494 
11495  if (!e_option_supplied(parser)) {
11497  }
11498  }
11499 
11500  parser_prepare(parser);
11501  deferred_nodes = 0;
11502 #ifndef RIPPER
11504 #endif
11505  n = yyparse((void*)parser);
11506  ruby_debug_lines = 0;
11507  ruby_coverage = 0;
11508  compile_for_eval = 0;
11509 
11510  lex_strterm = 0;
11511  lex_p = lex_pbeg = lex_pend = 0;
11512  lex_lastline = lex_nextline = 0;
11513  if (parser->nerr) {
11514  return 0;
11515  }
11516  tree = ruby_eval_tree;
11517  if (!tree) {
11518  tree = NEW_NIL();
11519  }
11520  else if (ruby_eval_tree_begin) {
11521  tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11522  }
11523  return (VALUE)tree;
11524 }
11525 
11526 static NODE*
11527 yycompile(struct parser_params *parser, const char *f, int line)
11528 {
11530  ruby_sourceline = line - 1;
11531  return (NODE *)ruby_suppress_tracing(yycompile0, (VALUE)parser, TRUE);
11532 }
11533 #endif /* !RIPPER */
11534 
11535 static rb_encoding *
11537 {
11538  rb_encoding *enc = rb_enc_get(s);
11539  if (!rb_enc_asciicompat(enc)) {
11540  rb_raise(rb_eArgError, "invalid source encoding");
11541  }
11542  return enc;
11543 }
11544 
11545 static VALUE
11546 lex_get_str(struct parser_params *parser, VALUE s)
11547 {
11548  char *beg, *end, *pend;
11550 
11551  beg = RSTRING_PTR(s);
11552  if (lex_gets_ptr) {
11553  if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11554  beg += lex_gets_ptr;
11555  }
11556  pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11557  end = beg;
11558  while (end < pend) {
11559  if (*end++ == '\n') break;
11560  }
11561  lex_gets_ptr = end - RSTRING_PTR(s);
11562  return rb_enc_str_new(beg, end - beg, enc);
11563 }
11564 
11565 static VALUE
11567 {
11568  VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11569  if (NIL_P(line)) return line;
11571 #ifndef RIPPER
11572  if (ruby_debug_lines) {
11573  rb_enc_associate(line, parser->enc);
11575  }
11576  if (ruby_coverage) {
11578  }
11579 #endif
11580  return line;
11581 }
11582 
11583 #ifdef RIPPER
11585 #else
11587 
11588 static NODE*
11589 parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11590 {
11591  struct parser_params *parser;
11592  NODE *node;
11593  volatile VALUE tmp;
11594 
11595  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11597  lex_gets_ptr = 0;
11598  lex_input = s;
11599  lex_pbeg = lex_p = lex_pend = 0;
11601 
11602  node = yycompile(parser, f, line);
11603  tmp = vparser; /* prohibit tail call optimization */
11604 
11605  return node;
11606 }
11607 
11608 NODE*
11609 rb_compile_string(const char *f, VALUE s, int line)
11610 {
11612  return parser_compile_string(rb_parser_new(), f, s, line);
11613 }
11614 
11615 NODE*
11616 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11617 {
11619  return parser_compile_string(vparser, f, s, line);
11620 }
11621 
11622 NODE*
11623 rb_compile_cstr(const char *f, const char *s, int len, int line)
11624 {
11625  VALUE str = rb_str_new(s, len);
11626  return parser_compile_string(rb_parser_new(), f, str, line);
11627 }
11628 
11629 NODE*
11630 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
11631 {
11632  VALUE str = rb_str_new(s, len);
11633  return parser_compile_string(vparser, f, str, line);
11634 }
11635 
11636 static VALUE
11637 lex_io_gets(struct parser_params *parser, VALUE io)
11638 {
11639  return rb_io_gets(io);
11640 }
11641 
11642 NODE*
11643 rb_compile_file(const char *f, VALUE file, int start)
11644 {
11645  VALUE volatile vparser = rb_parser_new();
11646 
11647  return rb_parser_compile_file(vparser, f, file, start);
11648 }
11649 
11650 NODE*
11651 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
11652 {
11653  struct parser_params *parser;
11654  volatile VALUE tmp;
11655  NODE *node;
11656 
11657  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11659  lex_input = file;
11660  lex_pbeg = lex_p = lex_pend = 0;
11662 
11663  node = yycompile(parser, f, start);
11664  tmp = vparser; /* prohibit tail call optimization */
11665 
11666  return node;
11667 }
11668 #endif /* !RIPPER */
11669 
11670 #define STR_FUNC_ESCAPE 0x01
11671 #define STR_FUNC_EXPAND 0x02
11672 #define STR_FUNC_REGEXP 0x04
11673 #define STR_FUNC_QWORDS 0x08
11674 #define STR_FUNC_SYMBOL 0x10
11675 #define STR_FUNC_INDENT 0x20
11676 
11678  str_squote = (0),
11686 };
11687 
11688 static VALUE
11689 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
11690 {
11691  VALUE str;
11692 
11693  str = rb_enc_str_new(p, n, enc);
11694  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
11696  }
11697  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
11699  }
11700  }
11701 
11702  return str;
11703 }
11704 
11705 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
11706 #define lex_eol_p() (lex_p >= lex_pend)
11707 #define peek(c) peek_n((c), 0)
11708 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
11709 
11710 static inline int
11712 {
11713  int c;
11714 
11715  if (lex_p == lex_pend) {
11716  VALUE v = lex_nextline;
11717  lex_nextline = 0;
11718  if (!v) {
11719  if (parser->eofp)
11720  return -1;
11721 
11722  if (!lex_input || NIL_P(v = lex_getline(parser))) {
11723  parser->eofp = Qtrue;
11724  lex_goto_eol(parser);
11725  return -1;
11726  }
11727  }
11728  {
11729 #ifdef RIPPER
11730  if (parser->tokp < lex_pend) {
11731  if (NIL_P(parser->delayed)) {
11732  parser->delayed = rb_str_buf_new(1024);
11733  rb_enc_associate(parser->delayed, parser->enc);
11734  rb_str_buf_cat(parser->delayed,
11735  parser->tokp, lex_pend - parser->tokp);
11736  parser->delayed_line = ruby_sourceline;
11737  parser->delayed_col = (int)(parser->tokp - lex_pbeg);
11738  }
11739  else {
11740  rb_str_buf_cat(parser->delayed,
11741  parser->tokp, lex_pend - parser->tokp);
11742  }
11743  }
11744 #endif
11745  if (heredoc_end > 0) {
11747  heredoc_end = 0;
11748  }
11749  ruby_sourceline++;
11750  parser->line_count++;
11751  lex_pbeg = lex_p = RSTRING_PTR(v);
11752  lex_pend = lex_p + RSTRING_LEN(v);
11753  ripper_flush(parser);
11754  lex_lastline = v;
11755  }
11756  }
11757  c = (unsigned char)*lex_p++;
11758  if (c == '\r' && peek('\n')) {
11759  lex_p++;
11760  c = '\n';
11761  }
11762 
11763  return c;
11764 }
11765 
11766 static void
11767 parser_pushback(struct parser_params *parser, int c)
11768 {
11769  if (c == -1) return;
11770  lex_p--;
11771  if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
11772  lex_p--;
11773  }
11774 }
11775 
11776 #define was_bol() (lex_p == lex_pbeg + 1)
11777 
11778 #define tokfix() (tokenbuf[tokidx]='\0')
11779 #define tok() tokenbuf
11780 #define toklen() tokidx
11781 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
11782 
11783 static char*
11785 {
11786  tokidx = 0;
11787  if (!tokenbuf) {
11788  toksiz = 60;
11789  tokenbuf = ALLOC_N(char, 60);
11790  }
11791  if (toksiz > 4096) {
11792  toksiz = 60;
11793  REALLOC_N(tokenbuf, char, 60);
11794  }
11795  return tokenbuf;
11796 }
11797 
11798 static char *
11799 parser_tokspace(struct parser_params *parser, int n)
11800 {
11801  tokidx += n;
11802 
11803  if (tokidx >= toksiz) {
11804  do {toksiz *= 2;} while (toksiz < tokidx);
11805  REALLOC_N(tokenbuf, char, toksiz);
11806  }
11807  return &tokenbuf[tokidx-n];
11808 }
11809 
11810 static void
11811 parser_tokadd(struct parser_params *parser, int c)
11812 {
11813  tokenbuf[tokidx++] = (char)c;
11814  if (tokidx >= toksiz) {
11815  toksiz *= 2;
11816  REALLOC_N(tokenbuf, char, toksiz);
11817  }
11818 }
11819 
11820 static int
11821 parser_tok_hex(struct parser_params *parser, size_t *numlen)
11822 {
11823  int c;
11824 
11825  c = scan_hex(lex_p, 2, numlen);
11826  if (!*numlen) {
11827  yyerror("invalid hex escape");
11828  return 0;
11829  }
11830  lex_p += *numlen;
11831  return c;
11832 }
11833 
11834 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
11835 
11836 static int
11838  int string_literal, int symbol_literal, int regexp_literal)
11839 {
11840  /*
11841  * If string_literal is true, then we allow multiple codepoints
11842  * in \u{}, and add the codepoints to the current token.
11843  * Otherwise we're parsing a character literal and return a single
11844  * codepoint without adding it
11845  */
11846 
11847  int codepoint;
11848  size_t numlen;
11849 
11850  if (regexp_literal) { tokadd('\\'); tokadd('u'); }
11851 
11852  if (peek('{')) { /* handle \u{...} form */
11853  do {
11854  if (regexp_literal) { tokadd(*lex_p); }
11855  nextc();
11856  codepoint = scan_hex(lex_p, 6, &numlen);
11857  if (numlen == 0) {
11858  yyerror("invalid Unicode escape");
11859  return 0;
11860  }
11861  if (codepoint > 0x10ffff) {
11862  yyerror("invalid Unicode codepoint (too large)");
11863  return 0;
11864  }
11865  lex_p += numlen;
11866  if (regexp_literal) {
11867  tokcopy((int)numlen);
11868  }
11869  else if (codepoint >= 0x80) {
11870  *encp = UTF8_ENC();
11871  if (string_literal) tokaddmbc(codepoint, *encp);
11872  }
11873  else if (string_literal) {
11874  tokadd(codepoint);
11875  }
11876  } while (string_literal && (peek(' ') || peek('\t')));
11877 
11878  if (!peek('}')) {
11879  yyerror("unterminated Unicode escape");
11880  return 0;
11881  }
11882 
11883  if (regexp_literal) { tokadd('}'); }
11884  nextc();
11885  }
11886  else { /* handle \uxxxx form */
11887  codepoint = scan_hex(lex_p, 4, &numlen);
11888  if (numlen < 4) {
11889  yyerror("invalid Unicode escape");
11890  return 0;
11891  }
11892  lex_p += 4;
11893  if (regexp_literal) {
11894  tokcopy(4);
11895  }
11896  else if (codepoint >= 0x80) {
11897  *encp = UTF8_ENC();
11898  if (string_literal) tokaddmbc(codepoint, *encp);
11899  }
11900  else if (string_literal) {
11901  tokadd(codepoint);
11902  }
11903  }
11904 
11905  return codepoint;
11906 }
11907 
11908 #define ESCAPE_CONTROL 1
11909 #define ESCAPE_META 2
11910 
11911 static int
11912 parser_read_escape(struct parser_params *parser, int flags,
11913  rb_encoding **encp)
11914 {
11915  int c;
11916  size_t numlen;
11917 
11918  switch (c = nextc()) {
11919  case '\\': /* Backslash */
11920  return c;
11921 
11922  case 'n': /* newline */
11923  return '\n';
11924 
11925  case 't': /* horizontal tab */
11926  return '\t';
11927 
11928  case 'r': /* carriage-return */
11929  return '\r';
11930 
11931  case 'f': /* form-feed */
11932  return '\f';
11933 
11934  case 'v': /* vertical tab */
11935  return '\13';
11936 
11937  case 'a': /* alarm(bell) */
11938  return '\007';
11939 
11940  case 'e': /* escape */
11941  return 033;
11942 
11943  case '0': case '1': case '2': case '3': /* octal constant */
11944  case '4': case '5': case '6': case '7':
11945  pushback(c);
11946  c = scan_oct(lex_p, 3, &numlen);
11947  lex_p += numlen;
11948  return c;
11949 
11950  case 'x': /* hex constant */
11951  c = tok_hex(&numlen);
11952  if (numlen == 0) return 0;
11953  return c;
11954 
11955  case 'b': /* backspace */
11956  return '\010';
11957 
11958  case 's': /* space */
11959  return ' ';
11960 
11961  case 'M':
11962  if (flags & ESCAPE_META) goto eof;
11963  if ((c = nextc()) != '-') {
11964  pushback(c);
11965  goto eof;
11966  }
11967  if ((c = nextc()) == '\\') {
11968  if (peek('u')) goto eof;
11969  return read_escape(flags|ESCAPE_META, encp) | 0x80;
11970  }
11971  else if (c == -1 || !ISASCII(c)) goto eof;
11972  else {
11973  return ((c & 0xff) | 0x80);
11974  }
11975 
11976  case 'C':
11977  if ((c = nextc()) != '-') {
11978  pushback(c);
11979  goto eof;
11980  }
11981  case 'c':
11982  if (flags & ESCAPE_CONTROL) goto eof;
11983  if ((c = nextc())== '\\') {
11984  if (peek('u')) goto eof;
11985  c = read_escape(flags|ESCAPE_CONTROL, encp);
11986  }
11987  else if (c == '?')
11988  return 0177;
11989  else if (c == -1 || !ISASCII(c)) goto eof;
11990  return c & 0x9f;
11991 
11992  eof:
11993  case -1:
11994  yyerror("Invalid escape character syntax");
11995  return '\0';
11996 
11997  default:
11998  return c;
11999  }
12000 }
12001 
12002 static void
12004 {
12005  int len = rb_enc_codelen(c, enc);
12006  rb_enc_mbcput(c, tokspace(len), enc);
12007 }
12008 
12009 static int
12011 {
12012  int c;
12013  int flags = 0;
12014  size_t numlen;
12015 
12016  first:
12017  switch (c = nextc()) {
12018  case '\n':
12019  return 0; /* just ignore */
12020 
12021  case '0': case '1': case '2': case '3': /* octal constant */
12022  case '4': case '5': case '6': case '7':
12023  {
12024  ruby_scan_oct(--lex_p, 3, &numlen);
12025  if (numlen == 0) goto eof;
12026  lex_p += numlen;
12027  tokcopy((int)numlen + 1);
12028  }
12029  return 0;
12030 
12031  case 'x': /* hex constant */
12032  {
12033  tok_hex(&numlen);
12034  if (numlen == 0) return -1;
12035  tokcopy((int)numlen + 2);
12036  }
12037  return 0;
12038 
12039  case 'M':
12040  if (flags & ESCAPE_META) goto eof;
12041  if ((c = nextc()) != '-') {
12042  pushback(c);
12043  goto eof;
12044  }
12045  tokcopy(3);
12046  flags |= ESCAPE_META;
12047  goto escaped;
12048 
12049  case 'C':
12050  if (flags & ESCAPE_CONTROL) goto eof;
12051  if ((c = nextc()) != '-') {
12052  pushback(c);
12053  goto eof;
12054  }
12055  tokcopy(3);
12056  goto escaped;
12057 
12058  case 'c':
12059  if (flags & ESCAPE_CONTROL) goto eof;
12060  tokcopy(2);
12061  flags |= ESCAPE_CONTROL;
12062  escaped:
12063  if ((c = nextc()) == '\\') {
12064  goto first;
12065  }
12066  else if (c == -1) goto eof;
12067  tokadd(c);
12068  return 0;
12069 
12070  eof:
12071  case -1:
12072  yyerror("Invalid escape character syntax");
12073  return -1;
12074 
12075  default:
12076  tokadd('\\');
12077  tokadd(c);
12078  }
12079  return 0;
12080 }
12081 
12082 static int
12084 {
12085  int kcode = 0;
12086  int kopt = 0;
12087  int options = 0;
12088  int c, opt, kc;
12089 
12090  newtok();
12091  while (c = nextc(), ISALPHA(c)) {
12092  if (c == 'o') {
12093  options |= RE_OPTION_ONCE;
12094  }
12095  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12096  if (kc >= 0) {
12097  if (kc != rb_ascii8bit_encindex()) kcode = c;
12098  kopt = opt;
12099  }
12100  else {
12101  options |= opt;
12102  }
12103  }
12104  else {
12105  tokadd(c);
12106  }
12107  }
12108  options |= kopt;
12109  pushback(c);
12110  if (toklen()) {
12111  tokfix();
12112  compile_error(PARSER_ARG "unknown regexp option%s - %s",
12113  toklen() > 1 ? "s" : "", tok());
12114  }
12115  return options | RE_OPTION_ENCODING(kcode);
12116 }
12117 
12118 static void
12120 {
12121  /* TODO: should use another API? */
12122  if (RBASIC(str)->flags & RSTRING_NOEMBED)
12123  xfree(RSTRING_PTR(str));
12124  rb_gc_force_recycle(str);
12125 }
12126 
12127 static int
12128 parser_tokadd_mbchar(struct parser_params *parser, int c)
12129 {
12130  int len = parser_precise_mbclen();
12131  if (!MBCLEN_CHARFOUND_P(len)) {
12132  compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12133  return -1;
12134  }
12135  tokadd(c);
12136  lex_p += --len;
12137  if (len > 0) tokcopy(len);
12138  return c;
12139 }
12140 
12141 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12142 
12143 static int
12145  int func, int term, int paren, long *nest,
12146  rb_encoding **encp)
12147 {
12148  int c;
12149  int has_nonascii = 0;
12150  rb_encoding *enc = *encp;
12151  char *errbuf = 0;
12152  static const char mixed_msg[] = "%s mixed within %s source";
12153 
12154 #define mixed_error(enc1, enc2) if (!errbuf) { \
12155  size_t len = sizeof(mixed_msg) - 4; \
12156  len += strlen(rb_enc_name(enc1)); \
12157  len += strlen(rb_enc_name(enc2)); \
12158  errbuf = ALLOCA_N(char, len); \
12159  snprintf(errbuf, len, mixed_msg, \
12160  rb_enc_name(enc1), \
12161  rb_enc_name(enc2)); \
12162  yyerror(errbuf); \
12163  }
12164 #define mixed_escape(beg, enc1, enc2) do { \
12165  const char *pos = lex_p; \
12166  lex_p = (beg); \
12167  mixed_error((enc1), (enc2)); \
12168  lex_p = pos; \
12169  } while (0)
12170 
12171  while ((c = nextc()) != -1) {
12172  if (paren && c == paren) {
12173  ++*nest;
12174  }
12175  else if (c == term) {
12176  if (!nest || !*nest) {
12177  pushback(c);
12178  break;
12179  }
12180  --*nest;
12181  }
12182  else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12183  int c2 = *lex_p;
12184  if (c2 == '$' || c2 == '@' || c2 == '{') {
12185  pushback(c);
12186  break;
12187  }
12188  }
12189  else if (c == '\\') {
12190  const char *beg = lex_p - 1;
12191  c = nextc();
12192  switch (c) {
12193  case '\n':
12194  if (func & STR_FUNC_QWORDS) break;
12195  if (func & STR_FUNC_EXPAND) continue;
12196  tokadd('\\');
12197  break;
12198 
12199  case '\\':
12200  if (func & STR_FUNC_ESCAPE) tokadd(c);
12201  break;
12202 
12203  case 'u':
12204  if ((func & STR_FUNC_EXPAND) == 0) {
12205  tokadd('\\');
12206  break;
12207  }
12208  parser_tokadd_utf8(parser, &enc, 1,
12209  func & STR_FUNC_SYMBOL,
12210  func & STR_FUNC_REGEXP);
12211  if (has_nonascii && enc != *encp) {
12212  mixed_escape(beg, enc, *encp);
12213  }
12214  continue;
12215 
12216  default:
12217  if (c == -1) return -1;
12218  if (!ISASCII(c)) {
12219  if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12220  goto non_ascii;
12221  }
12222  if (func & STR_FUNC_REGEXP) {
12223  pushback(c);
12224  if ((c = tokadd_escape(&enc)) < 0)
12225  return -1;
12226  if (has_nonascii && enc != *encp) {
12227  mixed_escape(beg, enc, *encp);
12228  }
12229  continue;
12230  }
12231  else if (func & STR_FUNC_EXPAND) {
12232  pushback(c);
12233  if (func & STR_FUNC_ESCAPE) tokadd('\\');
12234  c = read_escape(0, &enc);
12235  }
12236  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12237  /* ignore backslashed spaces in %w */
12238  }
12239  else if (c != term && !(paren && c == paren)) {
12240  tokadd('\\');
12241  pushback(c);
12242  continue;
12243  }
12244  }
12245  }
12246  else if (!parser_isascii()) {
12247  non_ascii:
12248  has_nonascii = 1;
12249  if (enc != *encp) {
12250  mixed_error(enc, *encp);
12251  continue;
12252  }
12253  if (tokadd_mbchar(c) == -1) return -1;
12254  continue;
12255  }
12256  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12257  pushback(c);
12258  break;
12259  }
12260  if (c & 0x80) {
12261  has_nonascii = 1;
12262  if (enc != *encp) {
12263  mixed_error(enc, *encp);
12264  continue;
12265  }
12266  }
12267  tokadd(c);
12268  }
12269  *encp = enc;
12270  return c;
12271 }
12272 
12273 #define NEW_STRTERM(func, term, paren) \
12274  rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12275 
12276 #ifdef RIPPER
12277 static void
12278 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12279 {
12280  if (!NIL_P(parser->delayed)) {
12281  ptrdiff_t len = lex_p - parser->tokp;
12282  if (len > 0) {
12283  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12284  }
12285  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12286  parser->tokp = lex_p;
12287  }
12288 }
12289 
12290 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12291 #else
12292 #define flush_string_content(enc) ((void)(enc))
12293 #endif
12294 
12295 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12296 /* this can be shared with ripper, since it's independent from struct
12297  * parser_params. */
12298 #ifndef RIPPER
12299 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12300 #define SPECIAL_PUNCT(idx) ( \
12301  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', 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('0', idx))
12307 const unsigned int ruby_global_name_punct_bits[] = {
12308  SPECIAL_PUNCT(0),
12309  SPECIAL_PUNCT(1),
12310  SPECIAL_PUNCT(2),
12311 };
12312 #undef BIT
12313 #undef SPECIAL_PUNCT
12314 #endif
12315 
12316 static inline int
12318 {
12319  if (c <= 0x20 || 0x7e < c) return 0;
12320  return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12321 }
12322 
12323 static int
12325 {
12326  int c;
12327  const char *p = lex_p;
12328 
12329  if (p + 1 >= lex_pend) return 0;
12330  c = *p++;
12331  switch (c) {
12332  case '$':
12333  if ((c = *p) == '-') {
12334  if (++p >= lex_pend) return 0;
12335  c = *p;
12336  }
12337  else if (is_global_name_punct(c) || ISDIGIT(c)) {
12338  return tSTRING_DVAR;
12339  }
12340  break;
12341  case '@':
12342  if ((c = *p) == '@') {
12343  if (++p >= lex_pend) return 0;
12344  c = *p;
12345  }
12346  break;
12347  case '{':
12348  lex_p = p;
12349  command_start = TRUE;
12350  return tSTRING_DBEG;
12351  default:
12352  return 0;
12353  }
12354  if (!ISASCII(c) || c == '_' || ISALPHA(c))
12355  return tSTRING_DVAR;
12356  return 0;
12357 }
12358 
12359 static int
12360 parser_parse_string(struct parser_params *parser, NODE *quote)
12361 {
12362  int func = (int)quote->nd_func;
12363  int term = nd_term(quote);
12364  int paren = nd_paren(quote);
12365  int c, space = 0;
12366  rb_encoding *enc = parser->enc;
12367 
12368  if (func == -1) return tSTRING_END;
12369  c = nextc();
12370  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12371  do {c = nextc();} while (ISSPACE(c));
12372  space = 1;
12373  }
12374  if (c == term && !quote->nd_nest) {
12375  if (func & STR_FUNC_QWORDS) {
12376  quote->nd_func = -1;
12377  return ' ';
12378  }
12379  if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12381  return tREGEXP_END;
12382  }
12383  if (space) {
12384  pushback(c);
12385  return ' ';
12386  }
12387  newtok();
12388  if ((func & STR_FUNC_EXPAND) && c == '#') {
12389  int t = parser_peek_variable_name(parser);
12390  if (t) return t;
12391  tokadd('#');
12392  c = nextc();
12393  }
12394  pushback(c);
12395  if (tokadd_string(func, term, paren, &quote->nd_nest,
12396  &enc) == -1) {
12397  ruby_sourceline = nd_line(quote);
12398  if (func & STR_FUNC_REGEXP) {
12399  if (parser->eofp)
12400  compile_error(PARSER_ARG "unterminated regexp meets end of file");
12401  return tREGEXP_END;
12402  }
12403  else {
12404  if (parser->eofp)
12405  compile_error(PARSER_ARG "unterminated string meets end of file");
12406  return tSTRING_END;
12407  }
12408  }
12409 
12410  tokfix();
12411  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12412  flush_string_content(enc);
12413 
12414  return tSTRING_CONTENT;
12415 }
12416 
12417 static int
12419 {
12420  int c = nextc(), term, func = 0;
12421  long len;
12422 
12423  if (c == '-') {
12424  c = nextc();
12425  func = STR_FUNC_INDENT;
12426  }
12427  switch (c) {
12428  case '\'':
12429  func |= str_squote; goto quoted;
12430  case '"':
12431  func |= str_dquote; goto quoted;
12432  case '`':
12433  func |= str_xquote;
12434  quoted:
12435  newtok();
12436  tokadd(func);
12437  term = c;
12438  while ((c = nextc()) != -1 && c != term) {
12439  if (tokadd_mbchar(c) == -1) return 0;
12440  }
12441  if (c == -1) {
12442  compile_error(PARSER_ARG "unterminated here document identifier");
12443  return 0;
12444  }
12445  break;
12446 
12447  default:
12448  if (!parser_is_identchar()) {
12449  pushback(c);
12450  if (func & STR_FUNC_INDENT) {
12451  pushback('-');
12452  }
12453  return 0;
12454  }
12455  newtok();
12456  term = '"';
12457  tokadd(func |= str_dquote);
12458  do {
12459  if (tokadd_mbchar(c) == -1) return 0;
12460  } while ((c = nextc()) != -1 && parser_is_identchar());
12461  pushback(c);
12462  break;
12463  }
12464 
12465  tokfix();
12466 #ifdef RIPPER
12467  ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12468 #endif
12469  len = lex_p - lex_pbeg;
12470  lex_goto_eol(parser);
12472  STR_NEW(tok(), toklen()), /* nd_lit */
12473  len, /* nd_nth */
12474  lex_lastline); /* nd_orig */
12476  ripper_flush(parser);
12477  return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12478 }
12479 
12480 static void
12482 {
12483  VALUE line;
12484 
12485  line = here->nd_orig;
12486  lex_lastline = line;
12487  lex_pbeg = RSTRING_PTR(line);
12488  lex_pend = lex_pbeg + RSTRING_LEN(line);
12489  lex_p = lex_pbeg + here->nd_nth;
12491  ruby_sourceline = nd_line(here);
12492  dispose_string(here->nd_lit);
12493  rb_gc_force_recycle((VALUE)here);
12494  ripper_flush(parser);
12495 }
12496 
12497 static int
12499  const char *eos, long len, int indent)
12500 {
12501  const char *p = lex_pbeg;
12502  long n;
12503 
12504  if (indent) {
12505  while (*p && ISSPACE(*p)) p++;
12506  }
12507  n = lex_pend - (p + len);
12508  if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12509  return strncmp(eos, p, len) == 0;
12510 }
12511 
12512 #ifdef RIPPER
12513 static void
12514 ripper_dispatch_heredoc_end(struct parser_params *parser)
12515 {
12516  if (!NIL_P(parser->delayed))
12517  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12518  lex_goto_eol(parser);
12519  ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12520 }
12521 
12522 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12523 #else
12524 #define dispatch_heredoc_end() ((void)0)
12525 #endif
12526 
12527 static int
12529 {
12530  int c, func, indent = 0;
12531  const char *eos, *p, *pend;
12532  long len;
12533  VALUE str = 0;
12534  rb_encoding *enc = parser->enc;
12535 
12536  eos = RSTRING_PTR(here->nd_lit);
12537  len = RSTRING_LEN(here->nd_lit) - 1;
12538  indent = (func = *eos++) & STR_FUNC_INDENT;
12539 
12540  if ((c = nextc()) == -1) {
12541  error:
12542  compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12543 #ifdef RIPPER
12544  if (NIL_P(parser->delayed)) {
12545  ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12546  }
12547  else {
12548  if (str ||
12549  ((len = lex_p - parser->tokp) > 0 &&
12550  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12551  rb_str_append(parser->delayed, str);
12552  }
12553  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12554  }
12555  lex_goto_eol(parser);
12556 #endif
12557  restore:
12559  lex_strterm = 0;
12560  return 0;
12561  }
12562  if (was_bol() && whole_match_p(eos, len, indent)) {
12565  return tSTRING_END;
12566  }
12567 
12568  if (!(func & STR_FUNC_EXPAND)) {
12569  do {
12571  pend = lex_pend;
12572  if (pend > p) {
12573  switch (pend[-1]) {
12574  case '\n':
12575  if (--pend == p || pend[-1] != '\r') {
12576  pend++;
12577  break;
12578  }
12579  case '\r':
12580  --pend;
12581  }
12582  }
12583  if (str)
12584  rb_str_cat(str, p, pend - p);
12585  else
12586  str = STR_NEW(p, pend - p);
12587  if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12588  lex_goto_eol(parser);
12589  if (nextc() == -1) {
12590  if (str) dispose_string(str);
12591  goto error;
12592  }
12593  } while (!whole_match_p(eos, len, indent));
12594  }
12595  else {
12596  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12597  newtok();
12598  if (c == '#') {
12599  int t = parser_peek_variable_name(parser);
12600  if (t) return t;
12601  tokadd('#');
12602  c = nextc();
12603  }
12604  do {
12605  pushback(c);
12606  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
12607  if (parser->eofp) goto error;
12608  goto restore;
12609  }
12610  if (c != '\n') {
12611  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12612  flush_string_content(enc);
12613  return tSTRING_CONTENT;
12614  }
12615  tokadd(nextc());
12616  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
12617  if ((c = nextc()) == -1) goto error;
12618  } while (!whole_match_p(eos, len, indent));
12619  str = STR_NEW3(tok(), toklen(), enc, func);
12620  }
12623  lex_strterm = NEW_STRTERM(-1, 0, 0);
12624  set_yylval_str(str);
12625  return tSTRING_CONTENT;
12626 }
12627 
12628 #include "lex.c"
12629 
12630 static void
12632 {
12633 #ifndef RIPPER
12634  rb_warning0("ambiguous first argument; put parentheses or even spaces");
12635 #else
12637 #endif
12638 }
12639 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
12640 
12641 static ID
12643 {
12644 #ifndef RIPPER
12645  if (!is_local_id(lhs))
12646  yyerror("formal argument must be local variable");
12647 #endif
12648  shadowing_lvar(lhs);
12649  return lhs;
12650 }
12651 
12652 static int
12653 lvar_defined_gen(struct parser_params *parser, ID id)
12654 {
12655  return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
12656 }
12657 
12658 /* emacsen -*- hack */
12659 static long
12660 parser_encode_length(struct parser_params *parser, const char *name, long len)
12661 {
12662  long nlen;
12663 
12664  if (len > 5 && name[nlen = len - 5] == '-') {
12665  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
12666  return nlen;
12667  }
12668  if (len > 4 && name[nlen = len - 4] == '-') {
12669  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
12670  return nlen;
12671  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
12672  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
12673  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
12674  return nlen;
12675  }
12676  return len;
12677 }
12678 
12679 static void
12680 parser_set_encode(struct parser_params *parser, const char *name)
12681 {
12682  int idx = rb_enc_find_index(name);
12683  rb_encoding *enc;
12684  VALUE excargs[3];
12685 
12686  if (idx < 0) {
12687  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
12688  error:
12689  excargs[0] = rb_eArgError;
12690  excargs[2] = rb_make_backtrace();
12691  rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
12692  rb_exc_raise(rb_make_exception(3, excargs));
12693  }
12694  enc = rb_enc_from_index(idx);
12695  if (!rb_enc_asciicompat(enc)) {
12696  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
12697  goto error;
12698  }
12699  parser->enc = enc;
12700 #ifndef RIPPER
12701  if (ruby_debug_lines) {
12702  long i, n = RARRAY_LEN(ruby_debug_lines);
12703  const VALUE *p = RARRAY_PTR(ruby_debug_lines);
12704  for (i = 0; i < n; ++i) {
12705  rb_enc_associate_index(*p, idx);
12706  }
12707  }
12708 #endif
12709 }
12710 
12711 static int
12713 {
12714  const char *p = lex_pbeg, *pend = lex_p - 1;
12715  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
12716  while (p < pend) {
12717  if (!ISSPACE(*p)) return 0;
12718  p++;
12719  }
12720  return 1;
12721 }
12722 
12723 #ifndef RIPPER
12724 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
12725 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
12726 
12727 static void
12728 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
12729 {
12730  if (!comment_at_top(parser)) {
12731  return;
12732  }
12733  parser_set_encode(parser, val);
12734 }
12735 
12736 static void
12737 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
12738 {
12739  int *p = &parser->parser_token_info_enabled;
12740 
12741  switch (*val) {
12742  case 't': case 'T':
12743  if (strcasecmp(val, "true") == 0) {
12744  *p = TRUE;
12745  return;
12746  }
12747  break;
12748  case 'f': case 'F':
12749  if (strcasecmp(val, "false") == 0) {
12750  *p = FALSE;
12751  return;
12752  }
12753  break;
12754  }
12755  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
12756 }
12757 
12759  const char *name;
12762 };
12763 
12764 static const struct magic_comment magic_comments[] = {
12767  {"warn_indent", parser_set_token_info},
12768 };
12769 #endif
12770 
12771 static const char *
12772 magic_comment_marker(const char *str, long len)
12773 {
12774  long i = 2;
12775 
12776  while (i < len) {
12777  switch (str[i]) {
12778  case '-':
12779  if (str[i-1] == '*' && str[i-2] == '-') {
12780  return str + i + 1;
12781  }
12782  i += 2;
12783  break;
12784  case '*':
12785  if (i + 1 >= len) return 0;
12786  if (str[i+1] != '-') {
12787  i += 4;
12788  }
12789  else if (str[i-1] != '-') {
12790  i += 2;
12791  }
12792  else {
12793  return str + i + 2;
12794  }
12795  break;
12796  default:
12797  i += 3;
12798  break;
12799  }
12800  }
12801  return 0;
12802 }
12803 
12804 static int
12805 parser_magic_comment(struct parser_params *parser, const char *str, long len)
12806 {
12807  VALUE name = 0, val = 0;
12808  const char *beg, *end, *vbeg, *vend;
12809 #define str_copy(_s, _p, _n) ((_s) \
12810  ? (void)(rb_str_resize((_s), (_n)), \
12811  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
12812  : (void)((_s) = STR_NEW((_p), (_n))))
12813 
12814  if (len <= 7) return FALSE;
12815  if (!(beg = magic_comment_marker(str, len))) return FALSE;
12816  if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
12817  str = beg;
12818  len = end - beg - 3;
12819 
12820  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
12821  while (len > 0) {
12822 #ifndef RIPPER
12823  const struct magic_comment *p = magic_comments;
12824 #endif
12825  char *s;
12826  int i;
12827  long n = 0;
12828 
12829  for (; len > 0 && *str; str++, --len) {
12830  switch (*str) {
12831  case '\'': case '"': case ':': case ';':
12832  continue;
12833  }
12834  if (!ISSPACE(*str)) break;
12835  }
12836  for (beg = str; len > 0; str++, --len) {
12837  switch (*str) {
12838  case '\'': case '"': case ':': case ';':
12839  break;
12840  default:
12841  if (ISSPACE(*str)) break;
12842  continue;
12843  }
12844  break;
12845  }
12846  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
12847  if (!len) break;
12848  if (*str != ':') continue;
12849 
12850  do str++; while (--len > 0 && ISSPACE(*str));
12851  if (!len) break;
12852  if (*str == '"') {
12853  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
12854  if (*str == '\\') {
12855  --len;
12856  ++str;
12857  }
12858  }
12859  vend = str;
12860  if (len) {
12861  --len;
12862  ++str;
12863  }
12864  }
12865  else {
12866  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
12867  vend = str;
12868  }
12869  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
12870 
12871  n = end - beg;
12872  str_copy(name, beg, n);
12873  s = RSTRING_PTR(name);
12874  for (i = 0; i < n; ++i) {
12875  if (s[i] == '-') s[i] = '_';
12876  }
12877 #ifndef RIPPER
12878  do {
12879  if (STRNCASECMP(p->name, s, n) == 0) {
12880  n = vend - vbeg;
12881  if (p->length) {
12882  n = (*p->length)(parser, vbeg, n);
12883  }
12884  str_copy(val, vbeg, n);
12885  (*p->func)(parser, s, RSTRING_PTR(val));
12886  break;
12887  }
12888  } while (++p < magic_comments + numberof(magic_comments));
12889 #else
12890  str_copy(val, vbeg, vend - vbeg);
12891  dispatch2(magic_comment, name, val);
12892 #endif
12893  }
12894 
12895  return TRUE;
12896 }
12897 
12898 static void
12899 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
12900 {
12901  int sep = 0;
12902  const char *beg = str;
12903  VALUE s;
12904 
12905  for (;;) {
12906  if (send - str <= 6) return;
12907  switch (str[6]) {
12908  case 'C': case 'c': str += 6; continue;
12909  case 'O': case 'o': str += 5; continue;
12910  case 'D': case 'd': str += 4; continue;
12911  case 'I': case 'i': str += 3; continue;
12912  case 'N': case 'n': str += 2; continue;
12913  case 'G': case 'g': str += 1; continue;
12914  case '=': case ':':
12915  sep = 1;
12916  str += 6;
12917  break;
12918  default:
12919  str += 6;
12920  if (ISSPACE(*str)) break;
12921  continue;
12922  }
12923  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
12924  }
12925  for (;;) {
12926  do {
12927  if (++str >= send) return;
12928  } while (ISSPACE(*str));
12929  if (sep) break;
12930  if (*str != '=' && *str != ':') return;
12931  sep = 1;
12932  str++;
12933  }
12934  beg = str;
12935  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
12936  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
12937  parser_set_encode(parser, RSTRING_PTR(s));
12938  rb_str_resize(s, 0);
12939 }
12940 
12941 static void
12943 {
12944  int c = nextc();
12945  switch (c) {
12946  case '#':
12947  if (peek('!')) parser->has_shebang = 1;
12948  break;
12949  case 0xef: /* UTF-8 BOM marker */
12950  if (lex_pend - lex_p >= 2 &&
12951  (unsigned char)lex_p[0] == 0xbb &&
12952  (unsigned char)lex_p[1] == 0xbf) {
12953  parser->enc = rb_utf8_encoding();
12954  lex_p += 2;
12955  lex_pbeg = lex_p;
12956  return;
12957  }
12958  break;
12959  case EOF:
12960  return;
12961  }
12962  pushback(c);
12963  parser->enc = rb_enc_get(lex_lastline);
12964 }
12965 
12966 #define IS_ARG() (lex_state == EXPR_ARG || lex_state == EXPR_CMDARG)
12967 #define IS_END() (lex_state == EXPR_END || lex_state == EXPR_ENDARG || lex_state == EXPR_ENDFN)
12968 #define IS_BEG() (lex_state == EXPR_BEG || lex_state == EXPR_MID || lex_state == EXPR_VALUE || lex_state == EXPR_CLASS)
12969 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
12970 #define IS_LABEL_POSSIBLE() ((lex_state == EXPR_BEG && !cmd_state) || IS_ARG())
12971 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
12972 
12973 #ifndef RIPPER
12974 #define ambiguous_operator(op, syn) ( \
12975  rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
12976  rb_warning0("even though it seems like "syn""))
12977 #else
12978 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
12979 #endif
12980 #define warn_balanced(op, syn) ((void) \
12981  (last_state != EXPR_CLASS && last_state != EXPR_DOT && \
12982  last_state != EXPR_FNAME && last_state != EXPR_ENDFN && \
12983  last_state != EXPR_ENDARG && \
12984  space_seen && !ISSPACE(c) && \
12985  (ambiguous_operator(op, syn), 0)))
12986 
12987 static int
12989 {
12990  register int c;
12991  int space_seen = 0;
12992  int cmd_state;
12993  enum lex_state_e last_state;
12994  rb_encoding *enc;
12995  int mb;
12996 #ifdef RIPPER
12997  int fallthru = FALSE;
12998 #endif
12999 
13000  if (lex_strterm) {
13001  int token;
13002  if (nd_type(lex_strterm) == NODE_HEREDOC) {
13003  token = here_document(lex_strterm);
13004  if (token == tSTRING_END) {
13005  lex_strterm = 0;
13006  lex_state = EXPR_END;
13007  }
13008  }
13009  else {
13010  token = parse_string(lex_strterm);
13011  if (token == tSTRING_END || token == tREGEXP_END) {
13013  lex_strterm = 0;
13014  lex_state = EXPR_END;
13015  }
13016  }
13017  return token;
13018  }
13019  cmd_state = command_start;
13020  command_start = FALSE;
13021  retry:
13022  last_state = lex_state;
13023  switch (c = nextc()) {
13024  case '\0': /* NUL */
13025  case '\004': /* ^D */
13026  case '\032': /* ^Z */
13027  case -1: /* end of script. */
13028  return 0;
13029 
13030  /* white spaces */
13031  case ' ': case '\t': case '\f': case '\r':
13032  case '\13': /* '\v' */
13033  space_seen = 1;
13034 #ifdef RIPPER
13035  while ((c = nextc())) {
13036  switch (c) {
13037  case ' ': case '\t': case '\f': case '\r':
13038  case '\13': /* '\v' */
13039  break;
13040  default:
13041  goto outofloop;
13042  }
13043  }
13044  outofloop:
13045  pushback(c);
13046  ripper_dispatch_scan_event(parser, tSP);
13047 #endif
13048  goto retry;
13049 
13050  case '#': /* it's a comment */
13051  /* no magic_comment in shebang line */
13052  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13053  if (comment_at_top(parser)) {
13054  set_file_encoding(parser, lex_p, lex_pend);
13055  }
13056  }
13057  lex_p = lex_pend;
13058 #ifdef RIPPER
13059  ripper_dispatch_scan_event(parser, tCOMMENT);
13060  fallthru = TRUE;
13061 #endif
13062  /* fall through */
13063  case '\n':
13064  switch (lex_state) {
13065  case EXPR_BEG:
13066  case EXPR_FNAME:
13067  case EXPR_DOT:
13068  case EXPR_CLASS:
13069  case EXPR_VALUE:
13070 #ifdef RIPPER
13071  if (!fallthru) {
13072  ripper_dispatch_scan_event(parser, tIGNORED_NL);
13073  }
13074  fallthru = FALSE;
13075 #endif
13076  goto retry;
13077  default:
13078  break;
13079  }
13080  while ((c = nextc())) {
13081  switch (c) {
13082  case ' ': case '\t': case '\f': case '\r':
13083  case '\13': /* '\v' */
13084  space_seen = 1;
13085  break;
13086  case '.': {
13087  if ((c = nextc()) != '.') {
13088  pushback(c);
13089  pushback('.');
13090  goto retry;
13091  }
13092  }
13093  default:
13094  --ruby_sourceline;
13096  case -1: /* EOF no decrement*/
13097  lex_goto_eol(parser);
13098 #ifdef RIPPER
13099  if (c != -1) {
13100  parser->tokp = lex_p;
13101  }
13102 #endif
13103  goto normal_newline;
13104  }
13105  }
13106  normal_newline:
13107  command_start = TRUE;
13108  lex_state = EXPR_BEG;
13109  return '\n';
13110 
13111  case '*':
13112  if ((c = nextc()) == '*') {
13113  if ((c = nextc()) == '=') {
13115  lex_state = EXPR_BEG;
13116  return tOP_ASGN;
13117  }
13118  pushback(c);
13119  c = tPOW;
13120  }
13121  else {
13122  if (c == '=') {
13123  set_yylval_id('*');
13124  lex_state = EXPR_BEG;
13125  return tOP_ASGN;
13126  }
13127  pushback(c);
13128  if (IS_SPCARG(c)) {
13129  rb_warning0("`*' interpreted as argument prefix");
13130  c = tSTAR;
13131  }
13132  else if (IS_BEG()) {
13133  c = tSTAR;
13134  }
13135  else {
13136  warn_balanced("*", "argument prefix");
13137  c = '*';
13138  }
13139  }
13140  switch (lex_state) {
13141  case EXPR_FNAME: case EXPR_DOT:
13142  lex_state = EXPR_ARG; break;
13143  default:
13144  lex_state = EXPR_BEG; break;
13145  }
13146  return c;
13147 
13148  case '!':
13149  c = nextc();
13150  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13151  lex_state = EXPR_ARG;
13152  if (c == '@') {
13153  return '!';
13154  }
13155  }
13156  else {
13157  lex_state = EXPR_BEG;
13158  }
13159  if (c == '=') {
13160  return tNEQ;
13161  }
13162  if (c == '~') {
13163  return tNMATCH;
13164  }
13165  pushback(c);
13166  return '!';
13167 
13168  case '=':
13169  if (was_bol()) {
13170  /* skip embedded rd document */
13171  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13172 #ifdef RIPPER
13173  int first_p = TRUE;
13174 
13175  lex_goto_eol(parser);
13176  ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13177 #endif
13178  for (;;) {
13179  lex_goto_eol(parser);
13180 #ifdef RIPPER
13181  if (!first_p) {
13182  ripper_dispatch_scan_event(parser, tEMBDOC);
13183  }
13184  first_p = FALSE;
13185 #endif
13186  c = nextc();
13187  if (c == -1) {
13188  compile_error(PARSER_ARG "embedded document meets end of file");
13189  return 0;
13190  }
13191  if (c != '=') continue;
13192  if (strncmp(lex_p, "end", 3) == 0 &&
13193  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13194  break;
13195  }
13196  }
13197  lex_goto_eol(parser);
13198 #ifdef RIPPER
13199  ripper_dispatch_scan_event(parser, tEMBDOC_END);
13200 #endif
13201  goto retry;
13202  }
13203  }
13204 
13205  switch (lex_state) {
13206  case EXPR_FNAME: case EXPR_DOT:
13207  lex_state = EXPR_ARG; break;
13208  default:
13209  lex_state = EXPR_BEG; break;
13210  }
13211  if ((c = nextc()) == '=') {
13212  if ((c = nextc()) == '=') {
13213  return tEQQ;
13214  }
13215  pushback(c);
13216  return tEQ;
13217  }
13218  if (c == '~') {
13219  return tMATCH;
13220  }
13221  else if (c == '>') {
13222  return tASSOC;
13223  }
13224  pushback(c);
13225  return '=';
13226 
13227  case '<':
13228  last_state = lex_state;
13229  c = nextc();
13230  if (c == '<' &&
13231  lex_state != EXPR_DOT &&
13232  lex_state != EXPR_CLASS &&
13233  !IS_END() &&
13234  (!IS_ARG() || space_seen)) {
13235  int token = heredoc_identifier();
13236  if (token) return token;
13237  }
13238  switch (lex_state) {
13239  case EXPR_FNAME: case EXPR_DOT:
13240  lex_state = EXPR_ARG; break;
13241  default:
13242  lex_state = EXPR_BEG; break;
13243  }
13244  if (c == '=') {
13245  if ((c = nextc()) == '>') {
13246  return tCMP;
13247  }
13248  pushback(c);
13249  return tLEQ;
13250  }
13251  if (c == '<') {
13252  if ((c = nextc()) == '=') {
13254  lex_state = EXPR_BEG;
13255  return tOP_ASGN;
13256  }
13257  pushback(c);
13258  warn_balanced("<<", "here document");
13259  return tLSHFT;
13260  }
13261  pushback(c);
13262  return '<';
13263 
13264  case '>':
13265  switch (lex_state) {
13266  case EXPR_FNAME: case EXPR_DOT:
13267  lex_state = EXPR_ARG; break;
13268  default:
13269  lex_state = EXPR_BEG; break;
13270  }
13271  if ((c = nextc()) == '=') {
13272  return tGEQ;
13273  }
13274  if (c == '>') {
13275  if ((c = nextc()) == '=') {
13277  lex_state = EXPR_BEG;
13278  return tOP_ASGN;
13279  }
13280  pushback(c);
13281  return tRSHFT;
13282  }
13283  pushback(c);
13284  return '>';
13285 
13286  case '"':
13287  lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13288  return tSTRING_BEG;
13289 
13290  case '`':
13291  if (lex_state == EXPR_FNAME) {
13293  return c;
13294  }
13295  if (lex_state == EXPR_DOT) {
13296  if (cmd_state)
13298  else
13299  lex_state = EXPR_ARG;
13300  return c;
13301  }
13302  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13303  return tXSTRING_BEG;
13304 
13305  case '\'':
13306  lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13307  return tSTRING_BEG;
13308 
13309  case '?':
13310  if (IS_END()) {
13312  return '?';
13313  }
13314  c = nextc();
13315  if (c == -1) {
13316  compile_error(PARSER_ARG "incomplete character syntax");
13317  return 0;
13318  }
13319  if (rb_enc_isspace(c, parser->enc)) {
13320  if (!IS_ARG()) {
13321  int c2 = 0;
13322  switch (c) {
13323  case ' ':
13324  c2 = 's';
13325  break;
13326  case '\n':
13327  c2 = 'n';
13328  break;
13329  case '\t':
13330  c2 = 't';
13331  break;
13332  case '\v':
13333  c2 = 'v';
13334  break;
13335  case '\r':
13336  c2 = 'r';
13337  break;
13338  case '\f':
13339  c2 = 'f';
13340  break;
13341  }
13342  if (c2) {
13343  rb_warnI("invalid character syntax; use ?\\%c", c2);
13344  }
13345  }
13346  ternary:
13347  pushback(c);
13349  return '?';
13350  }
13351  newtok();
13352  enc = parser->enc;
13353  if (!parser_isascii()) {
13354  if (tokadd_mbchar(c) == -1) return 0;
13355  }
13356  else if ((rb_enc_isalnum(c, parser->enc) || c == '_') &&
13357  lex_p < lex_pend && is_identchar(lex_p, lex_pend, parser->enc)) {
13358  goto ternary;
13359  }
13360  else if (c == '\\') {
13361  if (peek('u')) {
13362  nextc();
13363  c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13364  if (0x80 <= c) {
13365  tokaddmbc(c, enc);
13366  }
13367  else {
13368  tokadd(c);
13369  }
13370  }
13371  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13372  nextc();
13373  if (tokadd_mbchar(c) == -1) return 0;
13374  }
13375  else {
13376  c = read_escape(0, &enc);
13377  tokadd(c);
13378  }
13379  }
13380  else {
13381  tokadd(c);
13382  }
13383  tokfix();
13384  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13385  lex_state = EXPR_END;
13386  return tCHAR;
13387 
13388  case '&':
13389  if ((c = nextc()) == '&') {
13390  lex_state = EXPR_BEG;
13391  if ((c = nextc()) == '=') {
13393  lex_state = EXPR_BEG;
13394  return tOP_ASGN;
13395  }
13396  pushback(c);
13397  return tANDOP;
13398  }
13399  else if (c == '=') {
13400  set_yylval_id('&');
13401  lex_state = EXPR_BEG;
13402  return tOP_ASGN;
13403  }
13404  pushback(c);
13405  if (IS_SPCARG(c)) {
13406  rb_warning0("`&' interpreted as argument prefix");
13407  c = tAMPER;
13408  }
13409  else if (IS_BEG()) {
13410  c = tAMPER;
13411  }
13412  else {
13413  warn_balanced("&", "argument prefix");
13414  c = '&';
13415  }
13416  switch (lex_state) {
13417  case EXPR_FNAME: case EXPR_DOT:
13418  lex_state = EXPR_ARG; break;
13419  default:
13420  lex_state = EXPR_BEG;
13421  }
13422  return c;
13423 
13424  case '|':
13425  if ((c = nextc()) == '|') {
13426  lex_state = EXPR_BEG;
13427  if ((c = nextc()) == '=') {
13429  lex_state = EXPR_BEG;
13430  return tOP_ASGN;
13431  }
13432  pushback(c);
13433  return tOROP;
13434  }
13435  if (c == '=') {
13436  set_yylval_id('|');
13437  lex_state = EXPR_BEG;
13438  return tOP_ASGN;
13439  }
13440  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13441  lex_state = EXPR_ARG;
13442  }
13443  else {
13444  lex_state = EXPR_BEG;
13445  }
13446  pushback(c);
13447  return '|';
13448 
13449  case '+':
13450  c = nextc();
13451  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13452  lex_state = EXPR_ARG;
13453  if (c == '@') {
13454  return tUPLUS;
13455  }
13456  pushback(c);
13457  return '+';
13458  }
13459  if (c == '=') {
13460  set_yylval_id('+');
13461  lex_state = EXPR_BEG;
13462  return tOP_ASGN;
13463  }
13464  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13465  lex_state = EXPR_BEG;
13466  pushback(c);
13467  if (c != -1 && ISDIGIT(c)) {
13468  c = '+';
13469  goto start_num;
13470  }
13471  return tUPLUS;
13472  }
13473  lex_state = EXPR_BEG;
13474  pushback(c);
13475  warn_balanced("+", "unary operator");
13476  return '+';
13477 
13478  case '-':
13479  c = nextc();
13480  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13481  lex_state = EXPR_ARG;
13482  if (c == '@') {
13483  return tUMINUS;
13484  }
13485  pushback(c);
13486  return '-';
13487  }
13488  if (c == '=') {
13489  set_yylval_id('-');
13490  lex_state = EXPR_BEG;
13491  return tOP_ASGN;
13492  }
13493  if (c == '>') {
13494  lex_state = EXPR_ARG;
13495  return tLAMBDA;
13496  }
13497  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13498  lex_state = EXPR_BEG;
13499  pushback(c);
13500  if (c != -1 && ISDIGIT(c)) {
13501  return tUMINUS_NUM;
13502  }
13503  return tUMINUS;
13504  }
13505  lex_state = EXPR_BEG;
13506  pushback(c);
13507  warn_balanced("-", "unary operator");
13508  return '-';
13509 
13510  case '.':
13511  lex_state = EXPR_BEG;
13512  if ((c = nextc()) == '.') {
13513  if ((c = nextc()) == '.') {
13514  return tDOT3;
13515  }
13516  pushback(c);
13517  return tDOT2;
13518  }
13519  pushback(c);
13520  if (c != -1 && ISDIGIT(c)) {
13521  yyerror("no .<digit> floating literal anymore; put 0 before dot");
13522  }
13523  lex_state = EXPR_DOT;
13524  return '.';
13525 
13526  start_num:
13527  case '0': case '1': case '2': case '3': case '4':
13528  case '5': case '6': case '7': case '8': case '9':
13529  {
13530  int is_float, seen_point, seen_e, nondigit;
13531 
13532  is_float = seen_point = seen_e = nondigit = 0;
13533  lex_state = EXPR_END;
13534  newtok();
13535  if (c == '-' || c == '+') {
13536  tokadd(c);
13537  c = nextc();
13538  }
13539  if (c == '0') {
13540 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13541  int start = toklen();
13542  c = nextc();
13543  if (c == 'x' || c == 'X') {
13544  /* hexadecimal */
13545  c = nextc();
13546  if (c != -1 && ISXDIGIT(c)) {
13547  do {
13548  if (c == '_') {
13549  if (nondigit) break;
13550  nondigit = c;
13551  continue;
13552  }
13553  if (!ISXDIGIT(c)) break;
13554  nondigit = 0;
13555  tokadd(c);
13556  } while ((c = nextc()) != -1);
13557  }
13558  pushback(c);
13559  tokfix();
13560  if (toklen() == start) {
13561  no_digits();
13562  }
13563  else if (nondigit) goto trailing_uc;
13565  return tINTEGER;
13566  }
13567  if (c == 'b' || c == 'B') {
13568  /* binary */
13569  c = nextc();
13570  if (c == '0' || c == '1') {
13571  do {
13572  if (c == '_') {
13573  if (nondigit) break;
13574  nondigit = c;
13575  continue;
13576  }
13577  if (c != '0' && c != '1') break;
13578  nondigit = 0;
13579  tokadd(c);
13580  } while ((c = nextc()) != -1);
13581  }
13582  pushback(c);
13583  tokfix();
13584  if (toklen() == start) {
13585  no_digits();
13586  }
13587  else if (nondigit) goto trailing_uc;
13589  return tINTEGER;
13590  }
13591  if (c == 'd' || c == 'D') {
13592  /* decimal */
13593  c = nextc();
13594  if (c != -1 && ISDIGIT(c)) {
13595  do {
13596  if (c == '_') {
13597  if (nondigit) break;
13598  nondigit = c;
13599  continue;
13600  }
13601  if (!ISDIGIT(c)) break;
13602  nondigit = 0;
13603  tokadd(c);
13604  } while ((c = nextc()) != -1);
13605  }
13606  pushback(c);
13607  tokfix();
13608  if (toklen() == start) {
13609  no_digits();
13610  }
13611  else if (nondigit) goto trailing_uc;
13613  return tINTEGER;
13614  }
13615  if (c == '_') {
13616  /* 0_0 */
13617  goto octal_number;
13618  }
13619  if (c == 'o' || c == 'O') {
13620  /* prefixed octal */
13621  c = nextc();
13622  if (c == -1 || c == '_' || !ISDIGIT(c)) {
13623  no_digits();
13624  }
13625  }
13626  if (c >= '0' && c <= '7') {
13627  /* octal */
13628  octal_number:
13629  do {
13630  if (c == '_') {
13631  if (nondigit) break;
13632  nondigit = c;
13633  continue;
13634  }
13635  if (c < '0' || c > '9') break;
13636  if (c > '7') goto invalid_octal;
13637  nondigit = 0;
13638  tokadd(c);
13639  } while ((c = nextc()) != -1);
13640  if (toklen() > start) {
13641  pushback(c);
13642  tokfix();
13643  if (nondigit) goto trailing_uc;
13645  return tINTEGER;
13646  }
13647  if (nondigit) {
13648  pushback(c);
13649  goto trailing_uc;
13650  }
13651  }
13652  if (c > '7' && c <= '9') {
13653  invalid_octal:
13654  yyerror("Invalid octal digit");
13655  }
13656  else if (c == '.' || c == 'e' || c == 'E') {
13657  tokadd('0');
13658  }
13659  else {
13660  pushback(c);
13662  return tINTEGER;
13663  }
13664  }
13665 
13666  for (;;) {
13667  switch (c) {
13668  case '0': case '1': case '2': case '3': case '4':
13669  case '5': case '6': case '7': case '8': case '9':
13670  nondigit = 0;
13671  tokadd(c);
13672  break;
13673 
13674  case '.':
13675  if (nondigit) goto trailing_uc;
13676  if (seen_point || seen_e) {
13677  goto decode_num;
13678  }
13679  else {
13680  int c0 = nextc();
13681  if (c0 == -1 || !ISDIGIT(c0)) {
13682  pushback(c0);
13683  goto decode_num;
13684  }
13685  c = c0;
13686  }
13687  tokadd('.');
13688  tokadd(c);
13689  is_float++;
13690  seen_point++;
13691  nondigit = 0;
13692  break;
13693 
13694  case 'e':
13695  case 'E':
13696  if (nondigit) {
13697  pushback(c);
13698  c = nondigit;
13699  goto decode_num;
13700  }
13701  if (seen_e) {
13702  goto decode_num;
13703  }
13704  tokadd(c);
13705  seen_e++;
13706  is_float++;
13707  nondigit = c;
13708  c = nextc();
13709  if (c != '-' && c != '+') continue;
13710  tokadd(c);
13711  nondigit = c;
13712  break;
13713 
13714  case '_': /* `_' in number just ignored */
13715  if (nondigit) goto decode_num;
13716  nondigit = c;
13717  break;
13718 
13719  default:
13720  goto decode_num;
13721  }
13722  c = nextc();
13723  }
13724 
13725  decode_num:
13726  pushback(c);
13727  if (nondigit) {
13728  char tmp[30];
13729  trailing_uc:
13730  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
13731  yyerror(tmp);
13732  }
13733  tokfix();
13734  if (is_float) {
13735  double d = strtod(tok(), 0);
13736  if (errno == ERANGE) {
13737  rb_warningS("Float %s out of range", tok());
13738  errno = 0;
13739  }
13741  return tFLOAT;
13742  }
13744  return tINTEGER;
13745  }
13746 
13747  case ')':
13748  case ']':
13749  paren_nest--;
13750  case '}':
13751  COND_LEXPOP();
13752  CMDARG_LEXPOP();
13753  if (c == ')')
13755  else
13757  return c;
13758 
13759  case ':':
13760  c = nextc();
13761  if (c == ':') {
13762  if (IS_BEG() || lex_state == EXPR_CLASS || IS_SPCARG(-1)) {
13763  lex_state = EXPR_BEG;
13764  return tCOLON3;
13765  }
13766  lex_state = EXPR_DOT;
13767  return tCOLON2;
13768  }
13769  if (IS_END() || ISSPACE(c)) {
13770  pushback(c);
13771  warn_balanced(":", "symbol literal");
13772  lex_state = EXPR_BEG;
13773  return ':';
13774  }
13775  switch (c) {
13776  case '\'':
13777  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
13778  break;
13779  case '"':
13780  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
13781  break;
13782  default:
13783  pushback(c);
13784  break;
13785  }
13787  return tSYMBEG;
13788 
13789  case '/':
13790  if (IS_BEG()) {
13791  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13792  return tREGEXP_BEG;
13793  }
13794  if ((c = nextc()) == '=') {
13795  set_yylval_id('/');
13796  lex_state = EXPR_BEG;
13797  return tOP_ASGN;
13798  }
13799  pushback(c);
13800  if (IS_SPCARG(c)) {
13801  (void)arg_ambiguous();
13802  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13803  return tREGEXP_BEG;
13804  }
13805  switch (lex_state) {
13806  case EXPR_FNAME: case EXPR_DOT:
13807  lex_state = EXPR_ARG; break;
13808  default:
13809  lex_state = EXPR_BEG; break;
13810  }
13811  warn_balanced("/", "regexp literal");
13812  return '/';
13813 
13814  case '^':
13815  if ((c = nextc()) == '=') {
13816  set_yylval_id('^');
13817  lex_state = EXPR_BEG;
13818  return tOP_ASGN;
13819  }
13820  switch (lex_state) {
13821  case EXPR_FNAME: case EXPR_DOT:
13822  lex_state = EXPR_ARG; break;
13823  default:
13824  lex_state = EXPR_BEG; break;
13825  }
13826  pushback(c);
13827  return '^';
13828 
13829  case ';':
13830  lex_state = EXPR_BEG;
13831  command_start = TRUE;
13832  return ';';
13833 
13834  case ',':
13835  lex_state = EXPR_BEG;
13836  return ',';
13837 
13838  case '~':
13839  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13840  if ((c = nextc()) != '@') {
13841  pushback(c);
13842  }
13843  lex_state = EXPR_ARG;
13844  }
13845  else {
13846  lex_state = EXPR_BEG;
13847  }
13848  return '~';
13849 
13850  case '(':
13851  if (IS_BEG()) {
13852  c = tLPAREN;
13853  }
13854  else if (IS_SPCARG(-1)) {
13855  c = tLPAREN_ARG;
13856  }
13857  paren_nest++;
13858  COND_PUSH(0);
13859  CMDARG_PUSH(0);
13860  lex_state = EXPR_BEG;
13861  return c;
13862 
13863  case '[':
13864  paren_nest++;
13865  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13866  lex_state = EXPR_ARG;
13867  if ((c = nextc()) == ']') {
13868  if ((c = nextc()) == '=') {
13869  return tASET;
13870  }
13871  pushback(c);
13872  return tAREF;
13873  }
13874  pushback(c);
13875  return '[';
13876  }
13877  else if (IS_BEG()) {
13878  c = tLBRACK;
13879  }
13880  else if (IS_ARG() && space_seen) {
13881  c = tLBRACK;
13882  }
13883  lex_state = EXPR_BEG;
13884  COND_PUSH(0);
13885  CMDARG_PUSH(0);
13886  return c;
13887 
13888  case '{':
13889  if (lpar_beg && lpar_beg == paren_nest) {
13890  lex_state = EXPR_BEG;
13891  lpar_beg = 0;
13892  --paren_nest;
13893  COND_PUSH(0);
13894  CMDARG_PUSH(0);
13895  return tLAMBEG;
13896  }
13897  if (IS_ARG() || lex_state == EXPR_END || lex_state == EXPR_ENDFN)
13898  c = '{'; /* block (primary) */
13899  else if (lex_state == EXPR_ENDARG)
13900  c = tLBRACE_ARG; /* block (expr) */
13901  else
13902  c = tLBRACE; /* hash */
13903  COND_PUSH(0);
13904  CMDARG_PUSH(0);
13905  lex_state = EXPR_BEG;
13906  if (c != tLBRACE) command_start = TRUE;
13907  return c;
13908 
13909  case '\\':
13910  c = nextc();
13911  if (c == '\n') {
13912  space_seen = 1;
13913 #ifdef RIPPER
13914  ripper_dispatch_scan_event(parser, tSP);
13915 #endif
13916  goto retry; /* skip \\n */
13917  }
13918  pushback(c);
13919  return '\\';
13920 
13921  case '%':
13922  if (IS_BEG()) {
13923  int term;
13924  int paren;
13925 
13926  c = nextc();
13927  quotation:
13928  if (c == -1 || !ISALNUM(c)) {
13929  term = c;
13930  c = 'Q';
13931  }
13932  else {
13933  term = nextc();
13934  if (rb_enc_isalnum(term, parser->enc) || !parser_isascii()) {
13935  yyerror("unknown type of %string");
13936  return 0;
13937  }
13938  }
13939  if (c == -1 || term == -1) {
13940  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
13941  return 0;
13942  }
13943  paren = term;
13944  if (term == '(') term = ')';
13945  else if (term == '[') term = ']';
13946  else if (term == '{') term = '}';
13947  else if (term == '<') term = '>';
13948  else paren = 0;
13949 
13950  switch (c) {
13951  case 'Q':
13952  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
13953  return tSTRING_BEG;
13954 
13955  case 'q':
13956  lex_strterm = NEW_STRTERM(str_squote, term, paren);
13957  return tSTRING_BEG;
13958 
13959  case 'W':
13960  lex_strterm = NEW_STRTERM(str_dword, term, paren);
13961  do {c = nextc();} while (ISSPACE(c));
13962  pushback(c);
13963  return tWORDS_BEG;
13964 
13965  case 'w':
13966  lex_strterm = NEW_STRTERM(str_sword, term, paren);
13967  do {c = nextc();} while (ISSPACE(c));
13968  pushback(c);
13969  return tQWORDS_BEG;
13970 
13971  case 'x':
13972  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
13973  return tXSTRING_BEG;
13974 
13975  case 'r':
13976  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
13977  return tREGEXP_BEG;
13978 
13979  case 's':
13980  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
13982  return tSYMBEG;
13983 
13984  default:
13985  yyerror("unknown type of %string");
13986  return 0;
13987  }
13988  }
13989  if ((c = nextc()) == '=') {
13990  set_yylval_id('%');
13991  lex_state = EXPR_BEG;
13992  return tOP_ASGN;
13993  }
13994  if (IS_SPCARG(c)) {
13995  goto quotation;
13996  }
13997  switch (lex_state) {
13998  case EXPR_FNAME: case EXPR_DOT:
13999  lex_state = EXPR_ARG; break;
14000  default:
14001  lex_state = EXPR_BEG; break;
14002  }
14003  pushback(c);
14004  warn_balanced("%%", "string literal");
14005  return '%';
14006 
14007  case '$':
14008  lex_state = EXPR_END;
14009  newtok();
14010  c = nextc();
14011  switch (c) {
14012  case '_': /* $_: last read line string */
14013  c = nextc();
14014  if (parser_is_identchar()) {
14015  tokadd('$');
14016  tokadd('_');
14017  break;
14018  }
14019  pushback(c);
14020  c = '_';
14021  /* fall through */
14022  case '~': /* $~: match-data */
14023  case '*': /* $*: argv */
14024  case '$': /* $$: pid */
14025  case '?': /* $?: last status */
14026  case '!': /* $!: error string */
14027  case '@': /* $@: error position */
14028  case '/': /* $/: input record separator */
14029  case '\\': /* $\: output record separator */
14030  case ';': /* $;: field separator */
14031  case ',': /* $,: output field separator */
14032  case '.': /* $.: last read line number */
14033  case '=': /* $=: ignorecase */
14034  case ':': /* $:: load path */
14035  case '<': /* $<: reading filename */
14036  case '>': /* $>: default output handle */
14037  case '\"': /* $": already loaded files */
14038  tokadd('$');
14039  tokadd(c);
14040  tokfix();
14042  return tGVAR;
14043 
14044  case '-':
14045  tokadd('$');
14046  tokadd(c);
14047  c = nextc();
14048  if (parser_is_identchar()) {
14049  if (tokadd_mbchar(c) == -1) return 0;
14050  }
14051  else {
14052  pushback(c);
14053  }
14054  gvar:
14055  tokfix();
14057  return tGVAR;
14058 
14059  case '&': /* $&: last match */
14060  case '`': /* $`: string before last match */
14061  case '\'': /* $': string after last match */
14062  case '+': /* $+: string matches last paren. */
14063  if (last_state == EXPR_FNAME) {
14064  tokadd('$');
14065  tokadd(c);
14066  goto gvar;
14067  }
14069  return tBACK_REF;
14070 
14071  case '1': case '2': case '3':
14072  case '4': case '5': case '6':
14073  case '7': case '8': case '9':
14074  tokadd('$');
14075  do {
14076  tokadd(c);
14077  c = nextc();
14078  } while (c != -1 && ISDIGIT(c));
14079  pushback(c);
14080  if (last_state == EXPR_FNAME) goto gvar;
14081  tokfix();
14082  set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
14083  return tNTH_REF;
14084 
14085  default:
14086  if (!parser_is_identchar()) {
14087  pushback(c);
14088  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14089  return 0;
14090  }
14091  case '0':
14092  tokadd('$');
14093  }
14094  break;
14095 
14096  case '@':
14097  c = nextc();
14098  newtok();
14099  tokadd('@');
14100  if (c == '@') {
14101  tokadd('@');
14102  c = nextc();
14103  }
14104  if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14105  pushback(c);
14106  if (tokidx == 1) {
14107  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14108  }
14109  else {
14110  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14111  }
14112  return 0;
14113  }
14114  break;
14115 
14116  case '_':
14117  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14118  ruby__end__seen = 1;
14119  parser->eofp = Qtrue;
14120 #ifndef RIPPER
14121  return -1;
14122 #else
14123  lex_goto_eol(parser);
14124  ripper_dispatch_scan_event(parser, k__END__);
14125  return 0;
14126 #endif
14127  }
14128  newtok();
14129  break;
14130 
14131  default:
14132  if (!parser_is_identchar()) {
14133  rb_compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14134  goto retry;
14135  }
14136 
14137  newtok();
14138  break;
14139  }
14140 
14141  mb = ENC_CODERANGE_7BIT;
14142  do {
14143  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14144  if (tokadd_mbchar(c) == -1) return 0;
14145  c = nextc();
14146  } while (parser_is_identchar());
14147  switch (tok()[0]) {
14148  case '@': case '$':
14149  pushback(c);
14150  break;
14151  default:
14152  if ((c == '!' || c == '?') && !peek('=')) {
14153  tokadd(c);
14154  }
14155  else {
14156  pushback(c);
14157  }
14158  }
14159  tokfix();
14160 
14161  {
14162  int result = 0;
14163 
14164  last_state = lex_state;
14165  switch (tok()[0]) {
14166  case '$':
14167  lex_state = EXPR_END;
14168  result = tGVAR;
14169  break;
14170  case '@':
14171  lex_state = EXPR_END;
14172  if (tok()[1] == '@')
14173  result = tCVAR;
14174  else
14175  result = tIVAR;
14176  break;
14177 
14178  default:
14179  if (toklast() == '!' || toklast() == '?') {
14180  result = tFID;
14181  }
14182  else {
14183  if (lex_state == EXPR_FNAME) {
14184  if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14185  (!peek('=') || (peek_n('>', 1)))) {
14186  result = tIDENTIFIER;
14187  tokadd(c);
14188  tokfix();
14189  }
14190  else {
14191  pushback(c);
14192  }
14193  }
14194  if (result == 0 && ISUPPER(tok()[0])) {
14195  result = tCONSTANT;
14196  }
14197  else {
14198  result = tIDENTIFIER;
14199  }
14200  }
14201 
14202  if (IS_LABEL_POSSIBLE()) {
14203  if (IS_LABEL_SUFFIX(0)) {
14204  lex_state = EXPR_BEG;
14205  nextc();
14207  return tLABEL;
14208  }
14209  }
14210  if (mb == ENC_CODERANGE_7BIT && lex_state != EXPR_DOT) {
14211  const struct kwtable *kw;
14212 
14213  /* See if it is a reserved word. */
14214  kw = rb_reserved_word(tok(), toklen());
14215  if (kw) {
14216  enum lex_state_e state = lex_state;
14217  lex_state = kw->state;
14218  if (state == EXPR_FNAME) {
14220  return kw->id[0];
14221  }
14222  if (kw->id[0] == keyword_do) {
14223  command_start = TRUE;
14224  if (lpar_beg && lpar_beg == paren_nest) {
14225  lpar_beg = 0;
14226  --paren_nest;
14227  return keyword_do_LAMBDA;
14228  }
14229  if (COND_P()) return keyword_do_cond;
14230  if (CMDARG_P() && state != EXPR_CMDARG)
14231  return keyword_do_block;
14232  if (state == EXPR_ENDARG || state == EXPR_BEG)
14233  return keyword_do_block;
14234  return keyword_do;
14235  }
14236  if (state == EXPR_BEG || state == EXPR_VALUE)
14237  return kw->id[0];
14238  else {
14239  if (kw->id[0] != kw->id[1])
14240  lex_state = EXPR_BEG;
14241  return kw->id[1];
14242  }
14243  }
14244  }
14245 
14246  if (IS_BEG() ||
14247  lex_state == EXPR_DOT ||
14248  IS_ARG()) {
14249  if (cmd_state) {
14251  }
14252  else {
14253  lex_state = EXPR_ARG;
14254  }
14255  }
14256  else if (lex_state == EXPR_FNAME) {
14258  }
14259  else {
14260  lex_state = EXPR_END;
14261  }
14262  }
14263  {
14264  ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14265 
14266  set_yylval_name(ident);
14267  if (last_state != EXPR_DOT && last_state != EXPR_FNAME &&
14268  is_local_id(ident) && lvar_defined(ident)) {
14269  lex_state = EXPR_END;
14270  }
14271  }
14272  return result;
14273  }
14274 }
14275 
14276 #if YYPURE
14277 static int
14278 yylex(void *lval, void *p)
14279 #else
14280 yylex(void *p)
14281 #endif
14282 {
14283  struct parser_params *parser = (struct parser_params*)p;
14284  int t;
14285 
14286 #if YYPURE
14287  parser->parser_yylval = lval;
14288  parser->parser_yylval->val = Qundef;
14289 #endif
14290  t = parser_yylex(parser);
14291 #ifdef RIPPER
14292  if (!NIL_P(parser->delayed)) {
14293  ripper_dispatch_delayed_token(parser, t);
14294  return t;
14295  }
14296  if (t != 0)
14297  ripper_dispatch_scan_event(parser, t);
14298 #endif
14299 
14300  return t;
14301 }
14302 
14303 #ifndef RIPPER
14304 static NODE*
14305 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14306 {
14307  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14309  return n;
14310 }
14311 
14312 enum node_type
14313 nodetype(NODE *node) /* for debug */
14314 {
14315  return (enum node_type)nd_type(node);
14316 }
14317 
14318 int
14320 {
14321  return nd_line(node);
14322 }
14323 
14324 static NODE*
14326 {
14327  if (node) {
14328  node = remove_begin(node);
14329  node->flags |= NODE_FL_NEWLINE;
14330  }
14331  return node;
14332 }
14333 
14334 static void
14335 fixpos(NODE *node, NODE *orig)
14336 {
14337  if (!node) return;
14338  if (!orig) return;
14339  if (orig == (NODE*)1) return;
14340  nd_set_line(node, nd_line(orig));
14341 }
14342 
14343 static void
14344 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14345 {
14346  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14347 }
14348 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14349 
14350 static void
14351 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14352 {
14353  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14354 }
14355 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14356 
14357 static NODE*
14358 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14359 {
14360  NODE *end, *h = head, *nd;
14361 
14362  if (tail == 0) return head;
14363 
14364  if (h == 0) return tail;
14365  switch (nd_type(h)) {
14366  case NODE_LIT:
14367  case NODE_STR:
14368  case NODE_SELF:
14369  case NODE_TRUE:
14370  case NODE_FALSE:
14371  case NODE_NIL:
14372  parser_warning(h, "unused literal ignored");
14373  return tail;
14374  default:
14375  h = end = NEW_BLOCK(head);
14376  end->nd_end = end;
14377  fixpos(end, head);
14378  head = end;
14379  break;
14380  case NODE_BLOCK:
14381  end = h->nd_end;
14382  break;
14383  }
14384 
14385  nd = end->nd_head;
14386  switch (nd_type(nd)) {
14387  case NODE_RETURN:
14388  case NODE_BREAK:
14389  case NODE_NEXT:
14390  case NODE_REDO:
14391  case NODE_RETRY:
14392  if (RTEST(ruby_verbose)) {
14393  parser_warning(nd, "statement not reached");
14394  }
14395  break;
14396 
14397  default:
14398  break;
14399  }
14400 
14401  if (nd_type(tail) != NODE_BLOCK) {
14402  tail = NEW_BLOCK(tail);
14403  tail->nd_end = tail;
14404  }
14405  end->nd_next = tail;
14406  h->nd_end = tail->nd_end;
14407  return head;
14408 }
14409 
14410 /* append item to the list */
14411 static NODE*
14412 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14413 {
14414  NODE *last;
14415 
14416  if (list == 0) return NEW_LIST(item);
14417  if (list->nd_next) {
14418  last = list->nd_next->nd_end;
14419  }
14420  else {
14421  last = list;
14422  }
14423 
14424  list->nd_alen += 1;
14425  last->nd_next = NEW_LIST(item);
14426  list->nd_next->nd_end = last->nd_next;
14427  return list;
14428 }
14429 
14430 /* concat two lists */
14431 static NODE*
14432 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14433 {
14434  NODE *last;
14435 
14436  if (head->nd_next) {
14437  last = head->nd_next->nd_end;
14438  }
14439  else {
14440  last = head;
14441  }
14442 
14443  head->nd_alen += tail->nd_alen;
14444  last->nd_next = tail;
14445  if (tail->nd_next) {
14446  head->nd_next->nd_end = tail->nd_next->nd_end;
14447  }
14448  else {
14449  head->nd_next->nd_end = tail;
14450  }
14451 
14452  return head;
14453 }
14454 
14455 static int
14456 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
14457 {
14458  if (NIL_P(tail)) return 1;
14459  if (!rb_enc_compatible(head, tail)) {
14460  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14461  rb_enc_name(rb_enc_get(head)),
14462  rb_enc_name(rb_enc_get(tail)));
14463  rb_str_resize(head, 0);
14464  rb_str_resize(tail, 0);
14465  return 0;
14466  }
14467  rb_str_buf_append(head, tail);
14468  return 1;
14469 }
14470 
14471 /* concat two string literals */
14472 static NODE *
14473 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14474 {
14475  enum node_type htype;
14476 
14477  if (!head) return tail;
14478  if (!tail) return head;
14479 
14480  htype = nd_type(head);
14481  if (htype == NODE_EVSTR) {
14482  NODE *node = NEW_DSTR(Qnil);
14483  head = list_append(node, head);
14484  }
14485  switch (nd_type(tail)) {
14486  case NODE_STR:
14487  if (htype == NODE_STR) {
14488  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit)) {
14489  error:
14490  rb_gc_force_recycle((VALUE)head);
14491  rb_gc_force_recycle((VALUE)tail);
14492  return 0;
14493  }
14494  rb_gc_force_recycle((VALUE)tail);
14495  }
14496  else {
14497  list_append(head, tail);
14498  }
14499  break;
14500 
14501  case NODE_DSTR:
14502  if (htype == NODE_STR) {
14503  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14504  goto error;
14505  tail->nd_lit = head->nd_lit;
14506  rb_gc_force_recycle((VALUE)head);
14507  head = tail;
14508  }
14509  else if (NIL_P(tail->nd_lit)) {
14510  head->nd_alen += tail->nd_alen - 1;
14511  head->nd_next->nd_end->nd_next = tail->nd_next;
14512  head->nd_next->nd_end = tail->nd_next->nd_end;
14513  rb_gc_force_recycle((VALUE)tail);
14514  }
14515  else {
14516  nd_set_type(tail, NODE_ARRAY);
14517  tail->nd_head = NEW_STR(tail->nd_lit);
14518  list_concat(head, tail);
14519  }
14520  break;
14521 
14522  case NODE_EVSTR:
14523  if (htype == NODE_STR) {
14524  nd_set_type(head, NODE_DSTR);
14525  head->nd_alen = 1;
14526  }
14527  list_append(head, tail);
14528  break;
14529  }
14530  return head;
14531 }
14532 
14533 static NODE *
14534 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14535 {
14536  if (nd_type(node) == NODE_EVSTR) {
14537  node = list_append(NEW_DSTR(Qnil), node);
14538  }
14539  return node;
14540 }
14541 
14542 static NODE *
14543 new_evstr_gen(struct parser_params *parser, NODE *node)
14544 {
14545  NODE *head = node;
14546 
14547  if (node) {
14548  switch (nd_type(node)) {
14549  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14550  return node;
14551  }
14552  }
14553  return NEW_EVSTR(head);
14554 }
14555 
14556 static NODE *
14557 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14558 {
14559  value_expr(recv);
14560  value_expr(arg1);
14561  return NEW_CALL(recv, id, NEW_LIST(arg1));
14562 }
14563 
14564 static NODE *
14565 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
14566 {
14567  value_expr(recv);
14568  return NEW_CALL(recv, id, 0);
14569 }
14570 
14571 static NODE*
14572 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14573 {
14574  value_expr(node1);
14575  value_expr(node2);
14576  if (node1) {
14577  switch (nd_type(node1)) {
14578  case NODE_DREGX:
14579  case NODE_DREGX_ONCE:
14580  return NEW_MATCH2(node1, node2);
14581 
14582  case NODE_LIT:
14583  if (TYPE(node1->nd_lit) == T_REGEXP) {
14584  return NEW_MATCH2(node1, node2);
14585  }
14586  }
14587  }
14588 
14589  if (node2) {
14590  switch (nd_type(node2)) {
14591  case NODE_DREGX:
14592  case NODE_DREGX_ONCE:
14593  return NEW_MATCH3(node2, node1);
14594 
14595  case NODE_LIT:
14596  if (TYPE(node2->nd_lit) == T_REGEXP) {
14597  return NEW_MATCH3(node2, node1);
14598  }
14599  }
14600  }
14601 
14602  return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
14603 }
14604 
14605 static NODE*
14606 gettable_gen(struct parser_params *parser, ID id)
14607 {
14608  if (id == keyword_self) {
14609  return NEW_SELF();
14610  }
14611  else if (id == keyword_nil) {
14612  return NEW_NIL();
14613  }
14614  else if (id == keyword_true) {
14615  return NEW_TRUE();
14616  }
14617  else if (id == keyword_false) {
14618  return NEW_FALSE();
14619  }
14620  else if (id == keyword__FILE__) {
14623  }
14624  else if (id == keyword__LINE__) {
14625  return NEW_LIT(INT2FIX(ruby_sourceline));
14626  }
14627  else if (id == keyword__ENCODING__) {
14628  return NEW_LIT(rb_enc_from_encoding(parser->enc));
14629  }
14630  else if (is_local_id(id)) {
14631  if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
14632  if (local_id(id)) return NEW_LVAR(id);
14633  /* method call without arguments */
14634  return NEW_VCALL(id);
14635  }
14636  else if (is_global_id(id)) {
14637  return NEW_GVAR(id);
14638  }
14639  else if (is_instance_id(id)) {
14640  return NEW_IVAR(id);
14641  }
14642  else if (is_const_id(id)) {
14643  return NEW_CONST(id);
14644  }
14645  else if (is_class_id(id)) {
14646  return NEW_CVAR(id);
14647  }
14648  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14649  return 0;
14650 }
14651 #else /* !RIPPER */
14652 static int
14653 id_is_var_gen(struct parser_params *parser, ID id)
14654 {
14655  if (is_notop_id(id)) {
14656  switch (id & ID_SCOPE_MASK) {
14657  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
14658  return 1;
14659  case ID_LOCAL:
14660  if (dyna_in_block() && dvar_defined(id)) return 1;
14661  if (local_id(id)) return 1;
14662  /* method call without arguments */
14663  return 0;
14664  }
14665  }
14666  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14667  return 0;
14668 }
14669 #endif /* !RIPPER */
14670 
14671 #ifdef RIPPER
14672 static VALUE
14673 assignable_gen(struct parser_params *parser, VALUE lhs)
14674 #else
14675 static NODE*
14676 assignable_gen(struct parser_params *parser, ID id, NODE *val)
14677 #endif
14678 {
14679 #ifdef RIPPER
14680  ID id = get_id(lhs);
14681 # define assignable_result(x) get_value(lhs)
14682 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
14683 #else
14684 # define assignable_result(x) (x)
14685 #endif
14686  if (!id) return assignable_result(0);
14687  if (id == keyword_self) {
14688  yyerror("Can't change the value of self");
14689  }
14690  else if (id == keyword_nil) {
14691  yyerror("Can't assign to nil");
14692  }
14693  else if (id == keyword_true) {
14694  yyerror("Can't assign to true");
14695  }
14696  else if (id == keyword_false) {
14697  yyerror("Can't assign to false");
14698  }
14699  else if (id == keyword__FILE__) {
14700  yyerror("Can't assign to __FILE__");
14701  }
14702  else if (id == keyword__LINE__) {
14703  yyerror("Can't assign to __LINE__");
14704  }
14705  else if (id == keyword__ENCODING__) {
14706  yyerror("Can't assign to __ENCODING__");
14707  }
14708  else if (is_local_id(id)) {
14709  if (dyna_in_block()) {
14710  if (dvar_curr(id)) {
14711  return assignable_result(NEW_DASGN_CURR(id, val));
14712  }
14713  else if (dvar_defined(id)) {
14714  return assignable_result(NEW_DASGN(id, val));
14715  }
14716  else if (local_id(id)) {
14717  return assignable_result(NEW_LASGN(id, val));
14718  }
14719  else {
14720  dyna_var(id);
14721  return assignable_result(NEW_DASGN_CURR(id, val));
14722  }
14723  }
14724  else {
14725  if (!local_id(id)) {
14726  local_var(id);
14727  }
14728  return assignable_result(NEW_LASGN(id, val));
14729  }
14730  }
14731  else if (is_global_id(id)) {
14732  return assignable_result(NEW_GASGN(id, val));
14733  }
14734  else if (is_instance_id(id)) {
14735  return assignable_result(NEW_IASGN(id, val));
14736  }
14737  else if (is_const_id(id)) {
14738  if (!in_def && !in_single)
14739  return assignable_result(NEW_CDECL(id, val, 0));
14740  yyerror("dynamic constant assignment");
14741  }
14742  else if (is_class_id(id)) {
14743  return assignable_result(NEW_CVASGN(id, val));
14744  }
14745  else {
14746  compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
14747  }
14748  return assignable_result(0);
14749 #undef assignable_result
14750 #undef parser_yyerror
14751 }
14752 
14753 #define LVAR_USED ((int)1 << (sizeof(int) * CHAR_BIT - 1))
14754 
14755 static ID
14756 shadowing_lvar_gen(struct parser_params *parser, ID name)
14757 {
14758  if (idUScore == name) return name;
14759  if (dyna_in_block()) {
14760  if (dvar_curr(name)) {
14761  yyerror("duplicated argument name");
14762  }
14763  else if (dvar_defined_get(name) || local_id(name)) {
14764  rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
14765  vtable_add(lvtbl->vars, name);
14766  if (lvtbl->used) {
14768  }
14769  }
14770  }
14771  else {
14772  if (local_id(name)) {
14773  yyerror("duplicated argument name");
14774  }
14775  }
14776  return name;
14777 }
14778 
14779 static void
14780 new_bv_gen(struct parser_params *parser, ID name)
14781 {
14782  if (!name) return;
14783  if (!is_local_id(name)) {
14784  compile_error(PARSER_ARG "invalid local variable - %s",
14785  rb_id2name(name));
14786  return;
14787  }
14788  shadowing_lvar(name);
14789  dyna_var(name);
14790 }
14791 
14792 #ifndef RIPPER
14793 static NODE *
14794 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
14795 {
14796  if (recv && nd_type(recv) == NODE_SELF)
14797  recv = (NODE *)1;
14798  return NEW_ATTRASGN(recv, tASET, idx);
14799 }
14800 
14801 static void
14802 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14803 {
14804  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
14805  compile_error(PARSER_ARG "both block arg and actual block given");
14806  }
14807 }
14808 
14809 ID
14811 {
14812  id &= ~ID_SCOPE_MASK;
14813  id |= ID_ATTRSET;
14814  return id;
14815 }
14816 
14817 static NODE *
14818 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
14819 {
14820  if (recv && nd_type(recv) == NODE_SELF)
14821  recv = (NODE *)1;
14822  return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
14823 }
14824 
14825 static void
14827 {
14828  switch (nd_type(node)) {
14829  case NODE_NTH_REF:
14830  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
14831  break;
14832  case NODE_BACK_REF:
14833  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
14834  break;
14835  }
14836 }
14837 
14838 static NODE *
14839 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14840 {
14841  if (!node2) return node1;
14842  switch (nd_type(node1)) {
14843  case NODE_BLOCK_PASS:
14844  if (node1->nd_head)
14845  node1->nd_head = arg_concat(node1->nd_head, node2);
14846  else
14847  node1->nd_head = NEW_LIST(node2);
14848  return node1;
14849  case NODE_ARGSPUSH:
14850  if (nd_type(node2) != NODE_ARRAY) break;
14851  node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
14852  nd_set_type(node1, NODE_ARGSCAT);
14853  return node1;
14854  case NODE_ARGSCAT:
14855  if (nd_type(node2) != NODE_ARRAY ||
14856  nd_type(node1->nd_body) != NODE_ARRAY) break;
14857  node1->nd_body = list_concat(node1->nd_body, node2);
14858  return node1;
14859  }
14860  return NEW_ARGSCAT(node1, node2);
14861 }
14862 
14863 static NODE *
14864 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14865 {
14866  if (!node1) return NEW_LIST(node2);
14867  switch (nd_type(node1)) {
14868  case NODE_ARRAY:
14869  return list_append(node1, node2);
14870  case NODE_BLOCK_PASS:
14871  node1->nd_head = arg_append(node1->nd_head, node2);
14872  return node1;
14873  case NODE_ARGSPUSH:
14874  node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
14875  nd_set_type(node1, NODE_ARGSCAT);
14876  return node1;
14877  }
14878  return NEW_ARGSPUSH(node1, node2);
14879 }
14880 
14881 static NODE *
14883 {
14884  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
14885  if (nd_type(node) == NODE_ARRAY) return node;
14886  return 0;
14887 }
14888 
14889 static NODE *
14890 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
14891 {
14892  if (!lhs) return 0;
14893 
14894  switch (nd_type(lhs)) {
14895  case NODE_GASGN:
14896  case NODE_IASGN:
14897  case NODE_IASGN2:
14898  case NODE_LASGN:
14899  case NODE_DASGN:
14900  case NODE_DASGN_CURR:
14901  case NODE_MASGN:
14902  case NODE_CDECL:
14903  case NODE_CVASGN:
14904  lhs->nd_value = rhs;
14905  break;
14906 
14907  case NODE_ATTRASGN:
14908  case NODE_CALL:
14909  lhs->nd_args = arg_append(lhs->nd_args, rhs);
14910  break;
14911 
14912  default:
14913  /* should not happen */
14914  break;
14915  }
14916 
14917  return lhs;
14918 }
14919 
14920 static int
14921 value_expr_gen(struct parser_params *parser, NODE *node)
14922 {
14923  int cond = 0;
14924 
14925  if (!node) {
14926  rb_warning0("empty expression");
14927  }
14928  while (node) {
14929  switch (nd_type(node)) {
14930  case NODE_DEFN:
14931  case NODE_DEFS:
14932  parser_warning(node, "void value expression");
14933  return FALSE;
14934 
14935  case NODE_RETURN:
14936  case NODE_BREAK:
14937  case NODE_NEXT:
14938  case NODE_REDO:
14939  case NODE_RETRY:
14940  if (!cond) yyerror("void value expression");
14941  /* or "control never reach"? */
14942  return FALSE;
14943 
14944  case NODE_BLOCK:
14945  while (node->nd_next) {
14946  node = node->nd_next;
14947  }
14948  node = node->nd_head;
14949  break;
14950 
14951  case NODE_BEGIN:
14952  node = node->nd_body;
14953  break;
14954 
14955  case NODE_IF:
14956  if (!node->nd_body) {
14957  node = node->nd_else;
14958  break;
14959  }
14960  else if (!node->nd_else) {
14961  node = node->nd_body;
14962  break;
14963  }
14964  if (!value_expr(node->nd_body)) return FALSE;
14965  node = node->nd_else;
14966  break;
14967 
14968  case NODE_AND:
14969  case NODE_OR:
14970  cond = 1;
14971  node = node->nd_2nd;
14972  break;
14973 
14974  default:
14975  return TRUE;
14976  }
14977  }
14978 
14979  return TRUE;
14980 }
14981 
14982 static void
14983 void_expr_gen(struct parser_params *parser, NODE *node)
14984 {
14985  const char *useless = 0;
14986 
14987  if (!RTEST(ruby_verbose)) return;
14988 
14989  if (!node) return;
14990  switch (nd_type(node)) {
14991  case NODE_CALL:
14992  switch (node->nd_mid) {
14993  case '+':
14994  case '-':
14995  case '*':
14996  case '/':
14997  case '%':
14998  case tPOW:
14999  case tUPLUS:
15000  case tUMINUS:
15001  case '|':
15002  case '^':
15003  case '&':
15004  case tCMP:
15005  case '>':
15006  case tGEQ:
15007  case '<':
15008  case tLEQ:
15009  case tEQ:
15010  case tNEQ:
15011  useless = rb_id2name(node->nd_mid);
15012  break;
15013  }
15014  break;
15015 
15016  case NODE_LVAR:
15017  case NODE_DVAR:
15018  case NODE_GVAR:
15019  case NODE_IVAR:
15020  case NODE_CVAR:
15021  case NODE_NTH_REF:
15022  case NODE_BACK_REF:
15023  useless = "a variable";
15024  break;
15025  case NODE_CONST:
15026  useless = "a constant";
15027  break;
15028  case NODE_LIT:
15029  case NODE_STR:
15030  case NODE_DSTR:
15031  case NODE_DREGX:
15032  case NODE_DREGX_ONCE:
15033  useless = "a literal";
15034  break;
15035  case NODE_COLON2:
15036  case NODE_COLON3:
15037  useless = "::";
15038  break;
15039  case NODE_DOT2:
15040  useless = "..";
15041  break;
15042  case NODE_DOT3:
15043  useless = "...";
15044  break;
15045  case NODE_SELF:
15046  useless = "self";
15047  break;
15048  case NODE_NIL:
15049  useless = "nil";
15050  break;
15051  case NODE_TRUE:
15052  useless = "true";
15053  break;
15054  case NODE_FALSE:
15055  useless = "false";
15056  break;
15057  case NODE_DEFINED:
15058  useless = "defined?";
15059  break;
15060  }
15061 
15062  if (useless) {
15063  int line = ruby_sourceline;
15064 
15065  ruby_sourceline = nd_line(node);
15066  rb_warnS("possibly useless use of %s in void context", useless);
15067  ruby_sourceline = line;
15068  }
15069 }
15070 
15071 static void
15072 void_stmts_gen(struct parser_params *parser, NODE *node)
15073 {
15074  if (!RTEST(ruby_verbose)) return;
15075  if (!node) return;
15076  if (nd_type(node) != NODE_BLOCK) return;
15077 
15078  for (;;) {
15079  if (!node->nd_next) return;
15080  void_expr0(node->nd_head);
15081  node = node->nd_next;
15082  }
15083 }
15084 
15085 static NODE *
15087 {
15088  NODE **n = &node, *n1 = node;
15089  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15090  *n = n1 = n1->nd_body;
15091  }
15092  return node;
15093 }
15094 
15095 static void
15096 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15097 {
15098  NODE *node = *body;
15099 
15100  if (!node) {
15101  *body = NEW_NIL();
15102  return;
15103  }
15104 #define subnodes(n1, n2) \
15105  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15106  (!node->n2) ? (body = &node->n1, 1) : \
15107  (reduce_nodes(&node->n1), body = &node->n2, 1))
15108 
15109  while (node) {
15110  int newline = (int)(node->flags & NODE_FL_NEWLINE);
15111  switch (nd_type(node)) {
15112  end:
15113  case NODE_NIL:
15114  *body = 0;
15115  return;
15116  case NODE_RETURN:
15117  *body = node = node->nd_stts;
15118  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15119  continue;
15120  case NODE_BEGIN:
15121  *body = node = node->nd_body;
15122  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15123  continue;
15124  case NODE_BLOCK:
15125  body = &node->nd_end->nd_head;
15126  break;
15127  case NODE_IF:
15128  if (subnodes(nd_body, nd_else)) break;
15129  return;
15130  case NODE_CASE:
15131  body = &node->nd_body;
15132  break;
15133  case NODE_WHEN:
15134  if (!subnodes(nd_body, nd_next)) goto end;
15135  break;
15136  case NODE_ENSURE:
15137  if (!subnodes(nd_head, nd_resq)) goto end;
15138  break;
15139  case NODE_RESCUE:
15140  if (node->nd_else) {
15141  body = &node->nd_resq;
15142  break;
15143  }
15144  if (!subnodes(nd_head, nd_resq)) goto end;
15145  break;
15146  default:
15147  return;
15148  }
15149  node = *body;
15150  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15151  }
15152 
15153 #undef subnodes
15154 }
15155 
15156 static int
15157 assign_in_cond(struct parser_params *parser, NODE *node)
15158 {
15159  switch (nd_type(node)) {
15160  case NODE_MASGN:
15161  yyerror("multiple assignment in conditional");
15162  return 1;
15163 
15164  case NODE_LASGN:
15165  case NODE_DASGN:
15166  case NODE_DASGN_CURR:
15167  case NODE_GASGN:
15168  case NODE_IASGN:
15169  break;
15170 
15171  default:
15172  return 0;
15173  }
15174 
15175  if (!node->nd_value) return 1;
15176  switch (nd_type(node->nd_value)) {
15177  case NODE_LIT:
15178  case NODE_STR:
15179  case NODE_NIL:
15180  case NODE_TRUE:
15181  case NODE_FALSE:
15182  /* reports always */
15183  parser_warn(node->nd_value, "found = in conditional, should be ==");
15184  return 1;
15185 
15186  case NODE_DSTR:
15187  case NODE_XSTR:
15188  case NODE_DXSTR:
15189  case NODE_EVSTR:
15190  case NODE_DREGX:
15191  default:
15192  break;
15193  }
15194  return 1;
15195 }
15196 
15197 static void
15198 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15199 {
15200  if (!e_option_supplied(parser)) parser_warn(node, str);
15201 }
15202 
15203 static void
15204 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15205 {
15206  if (!e_option_supplied(parser)) parser_warning(node, str);
15207 }
15208 
15209 static void
15210 fixup_nodes(NODE **rootnode)
15211 {
15212  NODE *node, *next, *head;
15213 
15214  for (node = *rootnode; node; node = next) {
15215  enum node_type type;
15216  VALUE val;
15217 
15218  next = node->nd_next;
15219  head = node->nd_head;
15220  rb_gc_force_recycle((VALUE)node);
15221  *rootnode = next;
15222  switch (type = nd_type(head)) {
15223  case NODE_DOT2:
15224  case NODE_DOT3:
15225  val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15226  type == NODE_DOT3);
15227  rb_gc_force_recycle((VALUE)head->nd_beg);
15228  rb_gc_force_recycle((VALUE)head->nd_end);
15229  nd_set_type(head, NODE_LIT);
15230  head->nd_lit = val;
15231  break;
15232  default:
15233  break;
15234  }
15235  }
15236 }
15237 
15238 static NODE *cond0(struct parser_params*,NODE*);
15239 
15240 static NODE*
15241 range_op(struct parser_params *parser, NODE *node)
15242 {
15243  enum node_type type;
15244 
15245  if (node == 0) return 0;
15246 
15247  type = nd_type(node);
15248  value_expr(node);
15249  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15250  warn_unless_e_option(parser, node, "integer literal in conditional range");
15251  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15252  }
15253  return cond0(parser, node);
15254 }
15255 
15256 static int
15258 {
15259  if (!node) return 1; /* same as NODE_NIL */
15260  switch (nd_type(node)) {
15261  case NODE_LIT:
15262  case NODE_STR:
15263  case NODE_DSTR:
15264  case NODE_EVSTR:
15265  case NODE_DREGX:
15266  case NODE_DREGX_ONCE:
15267  case NODE_DSYM:
15268  return 2;
15269  case NODE_TRUE:
15270  case NODE_FALSE:
15271  case NODE_NIL:
15272  return 1;
15273  }
15274  return 0;
15275 }
15276 
15277 static NODE*
15278 cond0(struct parser_params *parser, NODE *node)
15279 {
15280  if (node == 0) return 0;
15281  assign_in_cond(parser, node);
15282 
15283  switch (nd_type(node)) {
15284  case NODE_DSTR:
15285  case NODE_EVSTR:
15286  case NODE_STR:
15287  rb_warn0("string literal in condition");
15288  break;
15289 
15290  case NODE_DREGX:
15291  case NODE_DREGX_ONCE:
15292  warning_unless_e_option(parser, node, "regex literal in condition");
15293  return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15294 
15295  case NODE_AND:
15296  case NODE_OR:
15297  node->nd_1st = cond0(parser, node->nd_1st);
15298  node->nd_2nd = cond0(parser, node->nd_2nd);
15299  break;
15300 
15301  case NODE_DOT2:
15302  case NODE_DOT3:
15303  node->nd_beg = range_op(parser, node->nd_beg);
15304  node->nd_end = range_op(parser, node->nd_end);
15305  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15306  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15307  if (!e_option_supplied(parser)) {
15308  int b = literal_node(node->nd_beg);
15309  int e = literal_node(node->nd_end);
15310  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15311  parser_warn(node, "range literal in condition");
15312  }
15313  }
15314  break;
15315 
15316  case NODE_DSYM:
15317  parser_warning(node, "literal in condition");
15318  break;
15319 
15320  case NODE_LIT:
15321  if (TYPE(node->nd_lit) == T_REGEXP) {
15322  warn_unless_e_option(parser, node, "regex literal in condition");
15323  nd_set_type(node, NODE_MATCH);
15324  }
15325  else {
15326  parser_warning(node, "literal in condition");
15327  }
15328  default:
15329  break;
15330  }
15331  return node;
15332 }
15333 
15334 static NODE*
15335 cond_gen(struct parser_params *parser, NODE *node)
15336 {
15337  if (node == 0) return 0;
15338  return cond0(parser, node);
15339 }
15340 
15341 static NODE*
15342 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15343 {
15344  value_expr(left);
15345  if (left && (enum node_type)nd_type(left) == type) {
15346  NODE *node = left, *second;
15347  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15348  node = second;
15349  }
15350  node->nd_2nd = NEW_NODE(type, second, right, 0);
15351  return left;
15352  }
15353  return NEW_NODE(type, left, right, 0);
15354 }
15355 
15356 static void
15357 no_blockarg(struct parser_params *parser, NODE *node)
15358 {
15359  if (node && nd_type(node) == NODE_BLOCK_PASS) {
15360  compile_error(PARSER_ARG "block argument should not be given");
15361  }
15362 }
15363 
15364 static NODE *
15365 ret_args_gen(struct parser_params *parser, NODE *node)
15366 {
15367  if (node) {
15368  no_blockarg(parser, node);
15369  if (nd_type(node) == NODE_ARRAY) {
15370  if (node->nd_next == 0) {
15371  node = node->nd_head;
15372  }
15373  else {
15374  nd_set_type(node, NODE_VALUES);
15375  }
15376  }
15377  }
15378  return node;
15379 }
15380 
15381 static NODE *
15382 new_yield_gen(struct parser_params *parser, NODE *node)
15383 {
15384  long state = Qtrue;
15385 
15386  if (node) {
15387  no_blockarg(parser, node);
15388  if (node && nd_type(node) == NODE_SPLAT) {
15389  state = Qtrue;
15390  }
15391  }
15392  else {
15393  state = Qfalse;
15394  }
15395  return NEW_YIELD(node, state);
15396 }
15397 
15398 static NODE*
15400 {
15401  switch (TYPE(node->nd_lit)) {
15402  case T_FIXNUM:
15403  node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15404  break;
15405  case T_BIGNUM:
15406  node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15407  break;
15408  case T_FLOAT:
15409  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15410  break;
15411  default:
15412  break;
15413  }
15414  return node;
15415 }
15416 
15417 static NODE *
15418 arg_blk_pass(NODE *node1, NODE *node2)
15419 {
15420  if (node2) {
15421  node2->nd_head = node1;
15422  return node2;
15423  }
15424  return node1;
15425 }
15426 
15427 static NODE*
15428 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, ID b)
15429 {
15430  int saved_line = ruby_sourceline;
15431  NODE *node;
15432  NODE *i1, *i2 = 0;
15433 
15434  node = NEW_ARGS(m ? m->nd_plen : 0, o);
15435  i1 = m ? m->nd_next : 0;
15436  node->nd_next = NEW_ARGS_AUX(r, b);
15437 
15438  if (p) {
15439  i2 = p->nd_next;
15440  node->nd_next->nd_next = NEW_ARGS_AUX(p->nd_pid, p->nd_plen);
15441  }
15442  else if (i1) {
15443  node->nd_next->nd_next = NEW_ARGS_AUX(0, 0);
15444  }
15445  if (i1 || i2) {
15446  node->nd_next->nd_next->nd_next = NEW_NODE(NODE_AND, i1, i2, 0);
15447  }
15448  ruby_sourceline = saved_line;
15449  return node;
15450 }
15451 #endif /* !RIPPER */
15452 
15453 static void
15454 warn_unused_var(struct parser_params *parser, struct local_vars *local)
15455 {
15456  int i, cnt;
15457  ID *v, *u;
15458 
15459  if (!local->used) return;
15460  v = local->vars->tbl;
15461  u = local->used->tbl;
15462  cnt = local->used->pos;
15463  if (cnt != local->vars->pos) {
15464  rb_bug("local->used->pos != local->vars->pos");
15465  }
15466  for (i = 0; i < cnt; ++i) {
15467  if (!v[i] || (u[i] & LVAR_USED)) continue;
15468  if (idUScore == v[i]) continue;
15469  rb_compile_warn(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
15470  }
15471 }
15472 
15473 static void
15474 local_push_gen(struct parser_params *parser, int inherit_dvars)
15475 {
15476  struct local_vars *local;
15477 
15478  local = ALLOC(struct local_vars);
15479  local->prev = lvtbl;
15480  local->args = vtable_alloc(0);
15481  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
15482  local->used = !inherit_dvars && RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
15483  lvtbl = local;
15484 }
15485 
15486 static void
15488 {
15489  struct local_vars *local = lvtbl->prev;
15490  if (lvtbl->used) {
15491  warn_unused_var(parser, lvtbl);
15492  vtable_free(lvtbl->used);
15493  }
15494  vtable_free(lvtbl->args);
15495  vtable_free(lvtbl->vars);
15496  xfree(lvtbl);
15497  lvtbl = local;
15498 }
15499 
15500 #ifndef RIPPER
15501 static ID*
15502 vtable_tblcpy(ID *buf, const struct vtable *src)
15503 {
15504  int i, cnt = vtable_size(src);
15505 
15506  if (cnt > 0) {
15507  buf[0] = cnt;
15508  for (i = 0; i < cnt; i++) {
15509  buf[i] = src->tbl[i];
15510  }
15511  return buf;
15512  }
15513  return 0;
15514 }
15515 
15516 static ID*
15518 {
15519  int cnt = vtable_size(lvtbl->args) + vtable_size(lvtbl->vars);
15520  ID *buf;
15521 
15522  if (cnt <= 0) return 0;
15523  buf = ALLOC_N(ID, cnt + 1);
15524  vtable_tblcpy(buf+1, lvtbl->args);
15525  vtable_tblcpy(buf+vtable_size(lvtbl->args)+1, lvtbl->vars);
15526  buf[0] = cnt;
15527  return buf;
15528 }
15529 #endif
15530 
15531 static int
15532 arg_var_gen(struct parser_params *parser, ID id)
15533 {
15534  vtable_add(lvtbl->args, id);
15535  return vtable_size(lvtbl->args) - 1;
15536 }
15537 
15538 static int
15539 local_var_gen(struct parser_params *parser, ID id)
15540 {
15541  vtable_add(lvtbl->vars, id);
15542  if (lvtbl->used) {
15544  }
15545  return vtable_size(lvtbl->vars) - 1;
15546 }
15547 
15548 static int
15549 local_id_gen(struct parser_params *parser, ID id)
15550 {
15551  struct vtable *vars, *args, *used;
15552 
15553  vars = lvtbl->vars;
15554  args = lvtbl->args;
15555  used = lvtbl->used;
15556 
15557  while (vars && POINTER_P(vars->prev)) {
15558  vars = vars->prev;
15559  args = args->prev;
15560  if (used) used = used->prev;
15561  }
15562 
15563  if (vars && vars->prev == DVARS_INHERIT) {
15564  return rb_local_defined(id);
15565  }
15566  else if (vtable_included(args, id)) {
15567  return 1;
15568  }
15569  else {
15570  int i = vtable_included(vars, id);
15571  if (i && used) used->tbl[i-1] |= LVAR_USED;
15572  return i != 0;
15573  }
15574 }
15575 
15576 static const struct vtable *
15578 {
15579  lvtbl->args = vtable_alloc(lvtbl->args);
15580  lvtbl->vars = vtable_alloc(lvtbl->vars);
15581  if (lvtbl->used) {
15582  lvtbl->used = vtable_alloc(lvtbl->used);
15583  }
15584  return lvtbl->args;
15585 }
15586 
15587 static void
15588 dyna_pop_1(struct parser_params *parser)
15589 {
15590  struct vtable *tmp;
15591 
15592  if ((tmp = lvtbl->used) != 0) {
15593  warn_unused_var(parser, lvtbl);
15594  lvtbl->used = lvtbl->used->prev;
15595  vtable_free(tmp);
15596  }
15597  tmp = lvtbl->args;
15598  lvtbl->args = lvtbl->args->prev;
15599  vtable_free(tmp);
15600  tmp = lvtbl->vars;
15601  lvtbl->vars = lvtbl->vars->prev;
15602  vtable_free(tmp);
15603 }
15604 
15605 static void
15606 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
15607 {
15608  while (lvtbl->args != lvargs) {
15609  dyna_pop_1(parser);
15610  if (!lvtbl->args) {
15611  struct local_vars *local = lvtbl->prev;
15612  xfree(lvtbl);
15613  lvtbl = local;
15614  }
15615  }
15616  dyna_pop_1(parser);
15617 }
15618 
15619 static int
15621 {
15622  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
15623 }
15624 
15625 static int
15626 dvar_defined_gen(struct parser_params *parser, ID id, int get)
15627 {
15628  struct vtable *vars, *args, *used;
15629  int i;
15630 
15631  args = lvtbl->args;
15632  vars = lvtbl->vars;
15633  used = lvtbl->used;
15634 
15635  while (POINTER_P(vars)) {
15636  if (vtable_included(args, id)) {
15637  return 1;
15638  }
15639  if ((i = vtable_included(vars, id)) != 0) {
15640  if (used) used->tbl[i-1] |= LVAR_USED;
15641  return 1;
15642  }
15643  args = args->prev;
15644  vars = vars->prev;
15645  if (get) used = 0;
15646  if (used) used = used->prev;
15647  }
15648 
15649  if (vars == DVARS_INHERIT) {
15650  return rb_dvar_defined(id);
15651  }
15652 
15653  return 0;
15654 }
15655 
15656 static int
15657 dvar_curr_gen(struct parser_params *parser, ID id)
15658 {
15659  return (vtable_included(lvtbl->args, id) ||
15660  vtable_included(lvtbl->vars, id));
15661 }
15662 
15663 #ifndef RIPPER
15664 static void
15666 {
15667  int c = RE_OPTION_ENCODING_IDX(options);
15668 
15669  if (c) {
15670  int opt, idx;
15671  rb_char_to_option_kcode(c, &opt, &idx);
15672  if (idx != ENCODING_GET(str) &&
15674  goto error;
15675  }
15676  ENCODING_SET(str, idx);
15677  }
15678  else if (RE_OPTION_ENCODING_NONE(options)) {
15679  if (!ENCODING_IS_ASCII8BIT(str) &&
15681  c = 'n';
15682  goto error;
15683  }
15685  }
15686  else if (parser->enc == rb_usascii_encoding()) {
15688  /* raise in re.c */
15690  }
15691  else {
15693  }
15694  }
15695  return;
15696 
15697  error:
15699  "regexp encoding option '%c' differs from source encoding '%s'",
15700  c, rb_enc_name(rb_enc_get(str)));
15701 }
15702 
15703 static int
15705 {
15706  VALUE err;
15707  reg_fragment_setenc(str, options);
15708  err = rb_reg_check_preprocess(str);
15709  if (err != Qnil) {
15710  err = rb_obj_as_string(err);
15711  compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
15712  RB_GC_GUARD(err);
15713  return 0;
15714  }
15715  return 1;
15716 }
15717 
15718 typedef struct {
15723  int num;
15725 
15726 static int
15728  int back_num, int *back_refs, OnigRegex regex, void *arg0)
15729 {
15731  struct parser_params* parser = arg->parser;
15732  rb_encoding *enc = arg->enc;
15733  long len = name_end - name;
15734  const char *s = (const char *)name;
15735  ID var;
15736 
15737  arg->num++;
15738 
15739  if (arg->succ_block == 0) {
15740  arg->succ_block = NEW_BEGIN(0);
15741  arg->fail_block = NEW_BEGIN(0);
15742  }
15743 
15744  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
15745  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
15746  !rb_enc_symname2_p(s, len, enc)) {
15747  return ST_CONTINUE;
15748  }
15749  var = rb_intern3(s, len, enc);
15750  if (dvar_defined(var) || local_id(var)) {
15751  rb_warningS("named capture conflicts a local variable - %s",
15752  rb_id2name(var));
15753  }
15754  arg->succ_block = block_append(arg->succ_block,
15756  NEW_CALL(
15757  gettable(rb_intern("$~")),
15758  idAREF,
15759  NEW_LIST(NEW_LIT(ID2SYM(var))))
15760  )));
15761  arg->fail_block = block_append(arg->fail_block,
15763  return ST_CONTINUE;
15764 }
15765 
15766 static NODE *
15768 {
15770 
15771  arg.parser = parser;
15772  arg.enc = rb_enc_get(regexp);
15773  arg.succ_block = 0;
15774  arg.fail_block = 0;
15775  arg.num = 0;
15776  onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
15777 
15778  if (arg.num == 0)
15779  return match;
15780 
15781  return
15782  block_append(
15783  newline_node(match),
15784  NEW_IF(gettable(rb_intern("$~")),
15785  block_append(
15786  newline_node(arg.succ_block),
15787  newline_node(
15788  NEW_CALL(
15789  gettable(rb_intern("$~")),
15790  rb_intern("begin"),
15791  NEW_LIST(NEW_LIT(INT2FIX(0)))))),
15792  block_append(
15793  newline_node(arg.fail_block),
15794  newline_node(
15795  NEW_LIT(Qnil)))));
15796 }
15797 
15798 static VALUE
15799 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
15800 {
15801  VALUE re;
15802  VALUE err;
15803 
15804  reg_fragment_setenc(str, options);
15805  err = rb_errinfo();
15807  if (NIL_P(re)) {
15808  ID mesg = rb_intern("mesg");
15809  VALUE m = rb_attr_get(rb_errinfo(), mesg);
15810  rb_set_errinfo(err);
15811  if (!NIL_P(err)) {
15812  rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
15813  }
15814  else {
15816  }
15817  return Qnil;
15818  }
15819  return re;
15820 }
15821 
15822 void
15824 {
15825 }
15826 
15827 NODE*
15829 {
15830  NODE *prelude = 0;
15831  NODE *scope = node;
15832  struct parser_params *parser;
15833 
15834  if (!node) return node;
15835 
15836  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15837 
15838  node = node->nd_body;
15839 
15840  if (nd_type(node) == NODE_PRELUDE) {
15841  prelude = node;
15842  node = node->nd_body;
15843  }
15844 
15845  node = block_append(node,
15846  NEW_FCALL(rb_intern("print"),
15847  NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
15848  if (prelude) {
15849  prelude->nd_body = node;
15850  scope->nd_body = prelude;
15851  }
15852  else {
15853  scope->nd_body = node;
15854  }
15855 
15856  return scope;
15857 }
15858 
15859 NODE *
15860 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
15861 {
15862  NODE *prelude = 0;
15863  NODE *scope = node;
15864  struct parser_params *parser;
15865 
15866  if (!node) return node;
15867 
15868  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15869 
15870  node = node->nd_body;
15871 
15872  if (nd_type(node) == NODE_PRELUDE) {
15873  prelude = node;
15874  node = node->nd_body;
15875  }
15876  if (split) {
15877  node = block_append(NEW_GASGN(rb_intern("$F"),
15878  NEW_CALL(NEW_GVAR(rb_intern("$_")),
15879  rb_intern("split"), 0)),
15880  node);
15881  }
15882  if (chop) {
15883  node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
15884  rb_intern("chop!"), 0), node);
15885  }
15886 
15887  node = NEW_OPT_N(node);
15888 
15889  if (prelude) {
15890  prelude->nd_body = node;
15891  scope->nd_body = prelude;
15892  }
15893  else {
15894  scope->nd_body = node;
15895  }
15896 
15897  return scope;
15898 }
15899 
15900 static const struct {
15902  const char *name;
15903 } op_tbl[] = {
15904  {tDOT2, ".."},
15905  {tDOT3, "..."},
15906  {tPOW, "**"},
15907  {tUPLUS, "+@"},
15908  {tUMINUS, "-@"},
15909  {tCMP, "<=>"},
15910  {tGEQ, ">="},
15911  {tLEQ, "<="},
15912  {tEQ, "=="},
15913  {tEQQ, "==="},
15914  {tNEQ, "!="},
15915  {tMATCH, "=~"},
15916  {tNMATCH, "!~"},
15917  {tAREF, "[]"},
15918  {tASET, "[]="},
15919  {tLSHFT, "<<"},
15920  {tRSHFT, ">>"},
15921  {tCOLON2, "::"},
15922 };
15923 
15924 #define op_tbl_count numberof(op_tbl)
15925 
15926 #ifndef ENABLE_SELECTOR_NAMESPACE
15927 #define ENABLE_SELECTOR_NAMESPACE 0
15928 #endif
15929 
15930 static struct symbols {
15934 #if ENABLE_SELECTOR_NAMESPACE
15935  st_table *ivar2_id;
15936  st_table *id_ivar2;
15937 #endif
15939 } global_symbols = {tLAST_ID};
15940 
15941 static const struct st_hash_type symhash = {
15943  rb_str_hash,
15944 };
15945 
15946 #if ENABLE_SELECTOR_NAMESPACE
15947 struct ivar2_key {
15948  ID id;
15949  VALUE klass;
15950 };
15951 
15952 static int
15953 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
15954 {
15955  if (key1->id == key2->id && key1->klass == key2->klass) {
15956  return 0;
15957  }
15958  return 1;
15959 }
15960 
15961 static int
15962 ivar2_hash(struct ivar2_key *key)
15963 {
15964  return (key->id << 8) ^ (key->klass >> 2);
15965 }
15966 
15967 static const struct st_hash_type ivar2_hash_type = {
15968  ivar2_cmp,
15969  ivar2_hash,
15970 };
15971 #endif
15972 
15973 void
15975 {
15976  global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
15978 #if ENABLE_SELECTOR_NAMESPACE
15979  global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
15980  global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
15981 #endif
15982 
15983  Init_id();
15984 }
15985 
15986 void
15988 {
15992 }
15993 #endif /* !RIPPER */
15994 
15995 static ID
15997 {
15998  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
15999  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16000  return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16001 }
16002 
16003 #ifndef RIPPER
16004 static int
16005 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16006 {
16007  int mb = 0;
16008 
16009  if (m >= e) return 0;
16010  if (is_global_name_punct(*m)) {
16011  ++m;
16012  }
16013  else if (*m == '-') {
16014  ++m;
16015  if (m < e && is_identchar(m, e, enc)) {
16016  if (!ISASCII(*m)) mb = 1;
16017  m += rb_enc_mbclen(m, e, enc);
16018  }
16019  }
16020  else {
16021  if (!rb_enc_isdigit(*m, enc)) return 0;
16022  do {
16023  if (!ISASCII(*m)) mb = 1;
16024  ++m;
16025  } while (m < e && rb_enc_isdigit(*m, enc));
16026  }
16027  return m == e ? mb + 1 : 0;
16028 }
16029 
16030 int
16031 rb_symname_p(const char *name)
16032 {
16033  return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16034 }
16035 
16036 int
16037 rb_enc_symname_p(const char *name, rb_encoding *enc)
16038 {
16039  return rb_enc_symname2_p(name, strlen(name), enc);
16040 }
16041 
16042 int
16043 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16044 {
16045  const char *m = name;
16046  const char *e = m + len;
16047  int localid = FALSE;
16048 
16049  if (!m || len <= 0) return FALSE;
16050  switch (*m) {
16051  case '\0':
16052  return FALSE;
16053 
16054  case '$':
16055  if (is_special_global_name(++m, e, enc)) return TRUE;
16056  goto id;
16057 
16058  case '@':
16059  if (*++m == '@') ++m;
16060  goto id;
16061 
16062  case '<':
16063  switch (*++m) {
16064  case '<': ++m; break;
16065  case '=': if (*++m == '>') ++m; break;
16066  default: break;
16067  }
16068  break;
16069 
16070  case '>':
16071  switch (*++m) {
16072  case '>': case '=': ++m; break;
16073  }
16074  break;
16075 
16076  case '=':
16077  switch (*++m) {
16078  case '~': ++m; break;
16079  case '=': if (*++m == '=') ++m; break;
16080  default: return FALSE;
16081  }
16082  break;
16083 
16084  case '*':
16085  if (*++m == '*') ++m;
16086  break;
16087 
16088  case '+': case '-':
16089  if (*++m == '@') ++m;
16090  break;
16091 
16092  case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16093  ++m;
16094  break;
16095 
16096  case '[':
16097  if (*++m != ']') return FALSE;
16098  if (*++m == '=') ++m;
16099  break;
16100 
16101  case '!':
16102  if (len == 1) return TRUE;
16103  switch (*++m) {
16104  case '=': case '~': ++m; break;
16105  default: return FALSE;
16106  }
16107  break;
16108 
16109  default:
16110  localid = !rb_enc_isupper(*m, enc);
16111  id:
16112  if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16113  return FALSE;
16114  while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16115  if (localid) {
16116  switch (*m) {
16117  case '!': case '?': case '=': ++m;
16118  }
16119  }
16120  break;
16121  }
16122  return m == e;
16123 }
16124 
16125 static ID
16126 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16127 {
16128  VALUE str = rb_enc_str_new(name, len, enc);
16129  OBJ_FREEZE(str);
16132  return id;
16133 }
16134 
16135 ID
16136 rb_intern3(const char *name, long len, rb_encoding *enc)
16137 {
16138  const char *m = name;
16139  const char *e = m + len;
16140  unsigned char c;
16141  VALUE str;
16142  ID id;
16143  long last;
16144  int mb;
16145  st_data_t data;
16146  struct RString fake_str;
16147  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
16148  fake_str.basic.klass = rb_cString;
16149  fake_str.as.heap.len = len;
16150  fake_str.as.heap.ptr = (char *)name;
16151  fake_str.as.heap.aux.capa = len;
16152  str = (VALUE)&fake_str;
16153  rb_enc_associate(str, enc);
16154  OBJ_FREEZE(str);
16155 
16157  rb_raise(rb_eEncodingError, "invalid encoding symbol");
16158  }
16159 
16160  if (st_lookup(global_symbols.sym_id, str, &data))
16161  return (ID)data;
16162 
16163  if (rb_cString && !rb_enc_asciicompat(enc)) {
16164  id = ID_JUNK;
16165  goto new_id;
16166  }
16167  last = len-1;
16168  id = 0;
16169  switch (*m) {
16170  case '$':
16171  id |= ID_GLOBAL;
16172  if ((mb = is_special_global_name(++m, e, enc)) != 0) {
16173  if (!--mb) enc = rb_ascii8bit_encoding();
16174  goto new_id;
16175  }
16176  break;
16177  case '@':
16178  if (m[1] == '@') {
16179  m++;
16180  id |= ID_CLASS;
16181  }
16182  else {
16183  id |= ID_INSTANCE;
16184  }
16185  m++;
16186  break;
16187  default:
16188  c = m[0];
16189  if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
16190  /* operators */
16191  int i;
16192 
16193  if (len == 1) {
16194  id = c;
16195  goto id_register;
16196  }
16197  for (i = 0; i < op_tbl_count; i++) {
16198  if (*op_tbl[i].name == *m &&
16199  strcmp(op_tbl[i].name, m) == 0) {
16200  id = op_tbl[i].token;
16201  goto id_register;
16202  }
16203  }
16204  }
16205 
16206  if (m[last] == '=') {
16207  /* attribute assignment */
16208  id = rb_intern3(name, last, enc);
16209  if (id > tLAST_TOKEN && !is_attrset_id(id)) {
16210  enc = rb_enc_get(rb_id2str(id));
16211  id = rb_id_attrset(id);
16212  goto id_register;
16213  }
16214  id = ID_ATTRSET;
16215  }
16216  else if (rb_enc_isupper(m[0], enc)) {
16217  id = ID_CONST;
16218  }
16219  else {
16220  id = ID_LOCAL;
16221  }
16222  break;
16223  }
16224  mb = 0;
16225  if (!rb_enc_isdigit(*m, enc)) {
16226  while (m <= name + last && is_identchar(m, e, enc)) {
16227  if (ISASCII(*m)) {
16228  m++;
16229  }
16230  else {
16231  mb = 1;
16232  m += rb_enc_mbclen(m, e, enc);
16233  }
16234  }
16235  }
16236  if (m - name < len) id = ID_JUNK;
16237  if (enc != rb_usascii_encoding()) {
16238  /*
16239  * this clause makes sense only when called from other than
16240  * rb_intern_str() taking care of code-range.
16241  */
16242  if (!mb) {
16243  for (; m <= name + len; ++m) {
16244  if (!ISASCII(*m)) goto mbstr;
16245  }
16246  enc = rb_usascii_encoding();
16247  }
16248  mbstr:;
16249  }
16250  new_id:
16252  if (len > 20) {
16253  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
16254  name);
16255  }
16256  else {
16257  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
16258  (int)len, name);
16259  }
16260  }
16262  id_register:
16263  return register_symid(id, name, len, enc);
16264 }
16265 
16266 ID
16267 rb_intern2(const char *name, long len)
16268 {
16269  return rb_intern3(name, len, rb_usascii_encoding());
16270 }
16271 
16272 #undef rb_intern
16273 ID
16274 rb_intern(const char *name)
16275 {
16276  return rb_intern2(name, strlen(name));
16277 }
16278 
16279 ID
16281 {
16282  rb_encoding *enc;
16283  ID id;
16284 
16286  enc = rb_usascii_encoding();
16287  }
16288  else {
16289  enc = rb_enc_get(str);
16290  }
16291  id = rb_intern3(RSTRING_PTR(str), RSTRING_LEN(str), enc);
16292  RB_GC_GUARD(str);
16293  return id;
16294 }
16295 
16296 VALUE
16298 {
16299  st_data_t data;
16300 
16301  if (id < tLAST_TOKEN) {
16302  int i = 0;
16303 
16304  if (id < INT_MAX && rb_ispunct((int)id)) {
16305  VALUE str = global_symbols.op_sym[i = (int)id];
16306  if (!str) {
16307  char name[2];
16308  name[0] = (char)id;
16309  name[1] = 0;
16310  str = rb_usascii_str_new(name, 1);
16311  OBJ_FREEZE(str);
16312  global_symbols.op_sym[i] = str;
16313  }
16314  return str;
16315  }
16316  for (i = 0; i < op_tbl_count; i++) {
16317  if (op_tbl[i].token == id) {
16318  VALUE str = global_symbols.op_sym[i];
16319  if (!str) {
16320  str = rb_usascii_str_new2(op_tbl[i].name);
16321  OBJ_FREEZE(str);
16322  global_symbols.op_sym[i] = str;
16323  }
16324  return str;
16325  }
16326  }
16327  }
16328 
16329  if (st_lookup(global_symbols.id_str, id, &data)) {
16330  VALUE str = (VALUE)data;
16331  if (RBASIC(str)->klass == 0)
16332  RBASIC(str)->klass = rb_cString;
16333  return str;
16334  }
16335 
16336  if (is_attrset_id(id)) {
16337  ID id2 = (id & ~ID_SCOPE_MASK) | ID_LOCAL;
16338  VALUE str;
16339 
16340  while (!(str = rb_id2str(id2))) {
16341  if (!is_local_id(id2)) return 0;
16342  id2 = (id & ~ID_SCOPE_MASK) | ID_CONST;
16343  }
16344  str = rb_str_dup(str);
16345  rb_str_cat(str, "=", 1);
16346  rb_intern_str(str);
16347  if (st_lookup(global_symbols.id_str, id, &data)) {
16348  VALUE str = (VALUE)data;
16349  if (RBASIC(str)->klass == 0)
16350  RBASIC(str)->klass = rb_cString;
16351  return str;
16352  }
16353  }
16354  return 0;
16355 }
16356 
16357 const char *
16359 {
16360  VALUE str = rb_id2str(id);
16361 
16362  if (!str) return 0;
16363  return RSTRING_PTR(str);
16364 }
16365 
16366 static int
16368 {
16369  rb_ary_push(ary, ID2SYM(value));
16370  return ST_CONTINUE;
16371 }
16372 
16373 /*
16374  * call-seq:
16375  * Symbol.all_symbols => array
16376  *
16377  * Returns an array of all the symbols currently in Ruby's symbol
16378  * table.
16379  *
16380  * Symbol.all_symbols.size #=> 903
16381  * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
16382  * :chown, :EOFError, :$;, :String,
16383  * :LOCK_SH, :"setuid?", :$<,
16384  * :default_proc, :compact, :extend,
16385  * :Tms, :getwd, :$=, :ThreadGroup,
16386  * :wait2, :$>]
16387  */
16388 
16389 VALUE
16391 {
16393 
16395  return ary;
16396 }
16397 
16398 int
16400 {
16401  return is_const_id(id);
16402 }
16403 
16404 int
16406 {
16407  return is_class_id(id);
16408 }
16409 
16410 int
16412 {
16413  return is_instance_id(id);
16414 }
16415 
16416 int
16418 {
16419  return is_local_id(id);
16420 }
16421 
16422 int
16424 {
16425  return is_junk_id(id);
16426 }
16427 
16428 #endif /* !RIPPER */
16429 
16430 static void
16432 {
16433  parser->eofp = Qfalse;
16434 
16435  parser->parser_lex_strterm = 0;
16436  parser->parser_cond_stack = 0;
16437  parser->parser_cmdarg_stack = 0;
16438  parser->parser_class_nest = 0;
16439  parser->parser_paren_nest = 0;
16440  parser->parser_lpar_beg = 0;
16441  parser->parser_in_single = 0;
16442  parser->parser_in_def = 0;
16443  parser->parser_in_defined = 0;
16444  parser->parser_compile_for_eval = 0;
16445  parser->parser_cur_mid = 0;
16446  parser->parser_tokenbuf = NULL;
16447  parser->parser_tokidx = 0;
16448  parser->parser_toksiz = 0;
16449  parser->parser_heredoc_end = 0;
16450  parser->parser_command_start = TRUE;
16451  parser->parser_deferred_nodes = 0;
16452  parser->parser_lex_pbeg = 0;
16453  parser->parser_lex_p = 0;
16454  parser->parser_lex_pend = 0;
16455  parser->parser_lvtbl = 0;
16456  parser->parser_ruby__end__seen = 0;
16457  parser->parser_ruby_sourcefile = 0;
16458 #ifndef RIPPER
16459  parser->is_ripper = 0;
16460  parser->parser_eval_tree_begin = 0;
16461  parser->parser_eval_tree = 0;
16462 #else
16463  parser->is_ripper = 1;
16464  parser->parser_ruby_sourcefile_string = Qnil;
16465  parser->delayed = Qnil;
16466 
16467  parser->result = Qnil;
16468  parser->parsing_thread = Qnil;
16469  parser->toplevel_p = TRUE;
16470 #endif
16471 #ifdef YYMALLOC
16472  parser->heap = NULL;
16473 #endif
16474  parser->enc = rb_usascii_encoding();
16475 }
16476 
16477 #ifdef RIPPER
16478 #define parser_mark ripper_parser_mark
16479 #define parser_free ripper_parser_free
16480 #endif
16481 
16482 static void
16484 {
16485  struct parser_params *p = (struct parser_params*)ptr;
16486 
16492 #ifndef RIPPER
16495  rb_gc_mark(p->debug_lines);
16496 #else
16497  rb_gc_mark(p->parser_ruby_sourcefile_string);
16498  rb_gc_mark(p->delayed);
16499  rb_gc_mark(p->value);
16500  rb_gc_mark(p->result);
16501  rb_gc_mark(p->parsing_thread);
16502 #endif
16503 #ifdef YYMALLOC
16504  rb_gc_mark((VALUE)p->heap);
16505 #endif
16506 }
16507 
16508 static void
16509 parser_free(void *ptr)
16510 {
16511  struct parser_params *p = (struct parser_params*)ptr;
16512  struct local_vars *local, *prev;
16513 
16514  if (p->parser_tokenbuf) {
16515  xfree(p->parser_tokenbuf);
16516  }
16517  for (local = p->parser_lvtbl; local; local = prev) {
16518  if (local->vars) xfree(local->vars);
16519  prev = local->prev;
16520  xfree(local);
16521  }
16522 #ifndef RIPPER
16524 #endif
16525  xfree(p);
16526 }
16527 
16528 static size_t
16529 parser_memsize(const void *ptr)
16530 {
16531  struct parser_params *p = (struct parser_params*)ptr;
16532  struct local_vars *local;
16533  size_t size = sizeof(*p);
16534 
16535  if (!ptr) return 0;
16536  size += p->parser_toksiz;
16537  for (local = p->parser_lvtbl; local; local = local->prev) {
16538  size += sizeof(*local);
16539  if (local->vars) size += local->vars->capa * sizeof(ID);
16540  }
16541 #ifndef RIPPER
16542  if (p->parser_ruby_sourcefile) {
16543  size += strlen(p->parser_ruby_sourcefile) + 1;
16544  }
16545 #endif
16546  return size;
16547 }
16548 
16549 static
16550 #ifndef RIPPER
16551 const
16552 #endif
16553 rb_data_type_t parser_data_type = {
16554  "parser",
16555  {
16556  parser_mark,
16557  parser_free,
16559  },
16560 };
16561 
16562 #ifndef RIPPER
16563 #undef rb_reserved_word
16564 
16565 const struct kwtable *
16566 rb_reserved_word(const char *str, unsigned int len)
16567 {
16568  return reserved_word(str, len);
16569 }
16570 
16571 static struct parser_params *
16573 {
16574  struct parser_params *p;
16575 
16576  p = ALLOC_N(struct parser_params, 1);
16577  MEMZERO(p, struct parser_params, 1);
16578  parser_initialize(p);
16579  return p;
16580 }
16581 
16582 VALUE
16584 {
16585  struct parser_params *p = parser_new();
16586 
16587  return TypedData_Wrap_Struct(0, &parser_data_type, p);
16588 }
16589 
16590 /*
16591  * call-seq:
16592  * ripper#end_seen? -> Boolean
16593  *
16594  * Return true if parsed source ended by +\_\_END\_\_+.
16595  */
16596 VALUE
16598 {
16599  struct parser_params *parser;
16600 
16601  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16602  return ruby__end__seen ? Qtrue : Qfalse;
16603 }
16604 
16605 /*
16606  * call-seq:
16607  * ripper#encoding -> encoding
16608  *
16609  * Return encoding of the source.
16610  */
16611 VALUE
16613 {
16614  struct parser_params *parser;
16615 
16616  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16617  return rb_enc_from_encoding(parser->enc);
16618 }
16619 
16620 /*
16621  * call-seq:
16622  * ripper.yydebug -> true or false
16623  *
16624  * Get yydebug.
16625  */
16626 VALUE
16628 {
16629  struct parser_params *parser;
16630 
16631  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16632  return yydebug ? Qtrue : Qfalse;
16633 }
16634 
16635 /*
16636  * call-seq:
16637  * ripper.yydebug = flag
16638  *
16639  * Set yydebug.
16640  */
16641 VALUE
16643 {
16644  struct parser_params *parser;
16645 
16646  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16647  yydebug = RTEST(flag);
16648  return flag;
16649 }
16650 
16651 #ifdef YYMALLOC
16652 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
16653 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
16654 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
16655  (n)->u3.cnt = (c), (p))
16656 
16657 void *
16658 rb_parser_malloc(struct parser_params *parser, size_t size)
16659 {
16660  size_t cnt = HEAPCNT(1, size);
16661  NODE *n = NEWHEAP();
16662  void *ptr = xmalloc(size);
16663 
16664  return ADD2HEAP(n, cnt, ptr);
16665 }
16666 
16667 void *
16668 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
16669 {
16670  size_t cnt = HEAPCNT(nelem, size);
16671  NODE *n = NEWHEAP();
16672  void *ptr = xcalloc(nelem, size);
16673 
16674  return ADD2HEAP(n, cnt, ptr);
16675 }
16676 
16677 void *
16678 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
16679 {
16680  NODE *n;
16681  size_t cnt = HEAPCNT(1, size);
16682 
16683  if (ptr && (n = parser->heap) != NULL) {
16684  do {
16685  if (n->u1.node == ptr) {
16686  n->u1.node = ptr = xrealloc(ptr, size);
16687  if (n->u3.cnt) n->u3.cnt = cnt;
16688  return ptr;
16689  }
16690  } while ((n = n->u2.node) != NULL);
16691  }
16692  n = NEWHEAP();
16693  ptr = xrealloc(ptr, size);
16694  return ADD2HEAP(n, cnt, ptr);
16695 }
16696 
16697 void
16698 rb_parser_free(struct parser_params *parser, void *ptr)
16699 {
16700  NODE **prev = &parser->heap, *n;
16701 
16702  while ((n = *prev) != NULL) {
16703  if (n->u1.node == ptr) {
16704  *prev = n->u2.node;
16706  break;
16707  }
16708  prev = &n->u2.node;
16709  }
16710  xfree(ptr);
16711 }
16712 #endif
16713 #endif
16714 
16715 #ifdef RIPPER
16716 #ifdef RIPPER_DEBUG
16717 extern int rb_is_pointer_to_heap(VALUE);
16718 
16719 /* :nodoc: */
16720 static VALUE
16721 ripper_validate_object(VALUE self, VALUE x)
16722 {
16723  if (x == Qfalse) return x;
16724  if (x == Qtrue) return x;
16725  if (x == Qnil) return x;
16726  if (x == Qundef)
16727  rb_raise(rb_eArgError, "Qundef given");
16728  if (FIXNUM_P(x)) return x;
16729  if (SYMBOL_P(x)) return x;
16730  if (!rb_is_pointer_to_heap(x))
16731  rb_raise(rb_eArgError, "invalid pointer: %p", x);
16732  switch (TYPE(x)) {
16733  case T_STRING:
16734  case T_OBJECT:
16735  case T_ARRAY:
16736  case T_BIGNUM:
16737  case T_FLOAT:
16738  return x;
16739  case T_NODE:
16740  if (nd_type(x) != NODE_LASGN) {
16741  rb_raise(rb_eArgError, "NODE given: %p", x);
16742  }
16743  return ((NODE *)x)->nd_rval;
16744  default:
16745  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
16746  x, rb_obj_classname(x));
16747  }
16748  return x;
16749 }
16750 #endif
16751 
16752 #define validate(x) ((x) = get_value(x))
16753 
16754 static VALUE
16755 ripper_dispatch0(struct parser_params *parser, ID mid)
16756 {
16757  return rb_funcall(parser->value, mid, 0);
16758 }
16759 
16760 static VALUE
16761 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
16762 {
16763  validate(a);
16764  return rb_funcall(parser->value, mid, 1, a);
16765 }
16766 
16767 static VALUE
16768 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
16769 {
16770  validate(a);
16771  validate(b);
16772  return rb_funcall(parser->value, mid, 2, a, b);
16773 }
16774 
16775 static VALUE
16776 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
16777 {
16778  validate(a);
16779  validate(b);
16780  validate(c);
16781  return rb_funcall(parser->value, mid, 3, a, b, c);
16782 }
16783 
16784 static VALUE
16785 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
16786 {
16787  validate(a);
16788  validate(b);
16789  validate(c);
16790  validate(d);
16791  return rb_funcall(parser->value, mid, 4, a, b, c, d);
16792 }
16793 
16794 static VALUE
16795 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
16796 {
16797  validate(a);
16798  validate(b);
16799  validate(c);
16800  validate(d);
16801  validate(e);
16802  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
16803 }
16804 
16805 static const struct kw_assoc {
16806  ID id;
16807  const char *name;
16808 } keyword_to_name[] = {
16809  {keyword_class, "class"},
16810  {keyword_module, "module"},
16811  {keyword_def, "def"},
16812  {keyword_undef, "undef"},
16813  {keyword_begin, "begin"},
16814  {keyword_rescue, "rescue"},
16815  {keyword_ensure, "ensure"},
16816  {keyword_end, "end"},
16817  {keyword_if, "if"},
16818  {keyword_unless, "unless"},
16819  {keyword_then, "then"},
16820  {keyword_elsif, "elsif"},
16821  {keyword_else, "else"},
16822  {keyword_case, "case"},
16823  {keyword_when, "when"},
16824  {keyword_while, "while"},
16825  {keyword_until, "until"},
16826  {keyword_for, "for"},
16827  {keyword_break, "break"},
16828  {keyword_next, "next"},
16829  {keyword_redo, "redo"},
16830  {keyword_retry, "retry"},
16831  {keyword_in, "in"},
16832  {keyword_do, "do"},
16833  {keyword_do_cond, "do"},
16834  {keyword_do_block, "do"},
16835  {keyword_return, "return"},
16836  {keyword_yield, "yield"},
16837  {keyword_super, "super"},
16838  {keyword_self, "self"},
16839  {keyword_nil, "nil"},
16840  {keyword_true, "true"},
16841  {keyword_false, "false"},
16842  {keyword_and, "and"},
16843  {keyword_or, "or"},
16844  {keyword_not, "not"},
16845  {modifier_if, "if"},
16846  {modifier_unless, "unless"},
16847  {modifier_while, "while"},
16848  {modifier_until, "until"},
16849  {modifier_rescue, "rescue"},
16850  {keyword_alias, "alias"},
16851  {keyword_defined, "defined?"},
16852  {keyword_BEGIN, "BEGIN"},
16853  {keyword_END, "END"},
16854  {keyword__LINE__, "__LINE__"},
16855  {keyword__FILE__, "__FILE__"},
16856  {keyword__ENCODING__, "__ENCODING__"},
16857  {0, NULL}
16858 };
16859 
16860 static const char*
16861 keyword_id_to_str(ID id)
16862 {
16863  const struct kw_assoc *a;
16864 
16865  for (a = keyword_to_name; a->id; a++) {
16866  if (a->id == id)
16867  return a->name;
16868  }
16869  return NULL;
16870 }
16871 
16872 #undef ripper_id2sym
16873 static VALUE
16874 ripper_id2sym(ID id)
16875 {
16876  const char *name;
16877  char buf[8];
16878 
16879  if (id <= 256) {
16880  buf[0] = (char)id;
16881  buf[1] = '\0';
16882  return ID2SYM(rb_intern2(buf, 1));
16883  }
16884  if ((name = keyword_id_to_str(id))) {
16885  return ID2SYM(rb_intern(name));
16886  }
16887  switch (id) {
16888  case tOROP:
16889  name = "||";
16890  break;
16891  case tANDOP:
16892  name = "&&";
16893  break;
16894  default:
16895  name = rb_id2name(id);
16896  if (!name) {
16897  rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
16898  }
16899  return ID2SYM(id);
16900  }
16901  return ID2SYM(rb_intern(name));
16902 }
16903 
16904 static ID
16905 ripper_get_id(VALUE v)
16906 {
16907  NODE *nd;
16908  if (!RB_TYPE_P(v, T_NODE)) return 0;
16909  nd = (NODE *)v;
16910  if (nd_type(nd) != NODE_LASGN) return 0;
16911  return nd->nd_vid;
16912 }
16913 
16914 static VALUE
16915 ripper_get_value(VALUE v)
16916 {
16917  NODE *nd;
16918  if (v == Qundef) return Qnil;
16919  if (!RB_TYPE_P(v, T_NODE)) return v;
16920  nd = (NODE *)v;
16921  if (nd_type(nd) != NODE_LASGN) return Qnil;
16922  return nd->nd_rval;
16923 }
16924 
16925 static void
16926 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
16927 {
16928  VALUE str;
16929  va_list args;
16930 
16931  va_start(args, fmt);
16932  str = rb_vsprintf(fmt, args);
16933  va_end(args);
16934  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
16935 }
16936 
16937 static void
16938 ripper_warn0(struct parser_params *parser, const char *fmt)
16939 {
16940  rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
16941 }
16942 
16943 static void
16944 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
16945 {
16946  rb_funcall(parser->value, rb_intern("warn"), 2,
16947  STR_NEW2(fmt), INT2NUM(a));
16948 }
16949 
16950 #if 0
16951 static void
16952 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
16953 {
16954  rb_funcall(parser->value, rb_intern("warn"), 2,
16955  STR_NEW2(fmt), STR_NEW2(str));
16956 }
16957 #endif
16958 
16959 static void
16960 ripper_warning0(struct parser_params *parser, const char *fmt)
16961 {
16962  rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
16963 }
16964 
16965 static void
16966 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
16967 {
16968  rb_funcall(parser->value, rb_intern("warning"), 2,
16969  STR_NEW2(fmt), STR_NEW2(str));
16970 }
16971 
16972 static VALUE
16973 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
16974 {
16975  return rb_funcall(src, ripper_id_gets, 0);
16976 }
16977 
16978 static VALUE
16979 ripper_s_allocate(VALUE klass)
16980 {
16981  struct parser_params *p;
16982  VALUE self;
16983 
16984  p = ALLOC_N(struct parser_params, 1);
16985  MEMZERO(p, struct parser_params, 1);
16986  self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
16987  p->value = self;
16988  return self;
16989 }
16990 
16991 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
16992 
16993 /*
16994  * call-seq:
16995  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
16996  *
16997  * Create a new Ripper object.
16998  * _src_ must be a String, an IO, or an Object which has #gets method.
16999  *
17000  * This method does not starts parsing.
17001  * See also Ripper#parse and Ripper.parse.
17002  */
17003 static VALUE
17004 ripper_initialize(int argc, VALUE *argv, VALUE self)
17005 {
17006  struct parser_params *parser;
17007  VALUE src, fname, lineno;
17008 
17009  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17010  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
17011  if (rb_obj_respond_to(src, ripper_id_gets, 0)) {
17012  parser->parser_lex_gets = ripper_lex_get_generic;
17013  }
17014  else {
17015  StringValue(src);
17016  parser->parser_lex_gets = lex_get_str;
17017  }
17018  parser->parser_lex_input = src;
17019  parser->eofp = Qfalse;
17020  if (NIL_P(fname)) {
17021  fname = STR_NEW2("(ripper)");
17022  }
17023  else {
17024  StringValue(fname);
17025  }
17026  parser_initialize(parser);
17027 
17028  parser->parser_ruby_sourcefile_string = fname;
17029  parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
17030  parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
17031 
17032  return Qnil;
17033 }
17034 
17035 struct ripper_args {
17036  struct parser_params *parser;
17037  int argc;
17038  VALUE *argv;
17039 };
17040 
17041 static VALUE
17042 ripper_parse0(VALUE parser_v)
17043 {
17044  struct parser_params *parser;
17045 
17046  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17047  parser_prepare(parser);
17048  ripper_yyparse((void*)parser);
17049  return parser->result;
17050 }
17051 
17052 static VALUE
17053 ripper_ensure(VALUE parser_v)
17054 {
17055  struct parser_params *parser;
17056 
17057  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17058  parser->parsing_thread = Qnil;
17059  return Qnil;
17060 }
17061 
17062 /*
17063  * call-seq:
17064  * ripper#parse
17065  *
17066  * Start parsing and returns the value of the root action.
17067  */
17068 static VALUE
17069 ripper_parse(VALUE self)
17070 {
17071  struct parser_params *parser;
17072 
17073  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17074  if (!ripper_initialized_p(parser)) {
17075  rb_raise(rb_eArgError, "method called for uninitialized object");
17076  }
17077  if (!NIL_P(parser->parsing_thread)) {
17078  if (parser->parsing_thread == rb_thread_current())
17079  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
17080  else
17081  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
17082  }
17083  parser->parsing_thread = rb_thread_current();
17084  rb_ensure(ripper_parse0, self, ripper_ensure, self);
17085 
17086  return parser->result;
17087 }
17088 
17089 /*
17090  * call-seq:
17091  * ripper#column -> Integer
17092  *
17093  * Return column number of current parsing line.
17094  * This number starts from 0.
17095  */
17096 static VALUE
17097 ripper_column(VALUE self)
17098 {
17099  struct parser_params *parser;
17100  long col;
17101 
17102  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17103  if (!ripper_initialized_p(parser)) {
17104  rb_raise(rb_eArgError, "method called for uninitialized object");
17105  }
17106  if (NIL_P(parser->parsing_thread)) return Qnil;
17107  col = parser->tokp - parser->parser_lex_pbeg;
17108  return LONG2NUM(col);
17109 }
17110 
17111 /*
17112  * call-seq:
17113  * ripper#filename -> String
17114  *
17115  * Return current parsing filename.
17116  */
17117 static VALUE
17118 ripper_filename(VALUE self)
17119 {
17120  struct parser_params *parser;
17121 
17122  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17123  if (!ripper_initialized_p(parser)) {
17124  rb_raise(rb_eArgError, "method called for uninitialized object");
17125  }
17126  return parser->parser_ruby_sourcefile_string;
17127 }
17128 
17129 /*
17130  * call-seq:
17131  * ripper#lineno -> Integer
17132  *
17133  * Return line number of current parsing line.
17134  * This number starts from 1.
17135  */
17136 static VALUE
17137 ripper_lineno(VALUE self)
17138 {
17139  struct parser_params *parser;
17140 
17141  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17142  if (!ripper_initialized_p(parser)) {
17143  rb_raise(rb_eArgError, "method called for uninitialized object");
17144  }
17145  if (NIL_P(parser->parsing_thread)) return Qnil;
17146  return INT2NUM(parser->parser_ruby_sourceline);
17147 }
17148 
17149 #ifdef RIPPER_DEBUG
17150 /* :nodoc: */
17151 static VALUE
17152 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
17153 {
17154  StringValue(msg);
17155  if (obj == Qundef) {
17156  rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
17157  }
17158  return Qnil;
17159 }
17160 
17161 /* :nodoc: */
17162 static VALUE
17163 ripper_value(VALUE self, VALUE obj)
17164 {
17165  return ULONG2NUM(obj);
17166 }
17167 #endif
17168 
17169 
17170 void
17171 InitVM_ripper(void)
17172 {
17173  parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
17174 }
17175 
17176 void
17177 Init_ripper(void)
17178 {
17179  VALUE Ripper;
17180 
17181  InitVM(ripper);
17182  Ripper = rb_define_class("Ripper", rb_cObject);
17183  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
17184  rb_define_alloc_func(Ripper, ripper_s_allocate);
17185  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
17186  rb_define_method(Ripper, "parse", ripper_parse, 0);
17187  rb_define_method(Ripper, "column", ripper_column, 0);
17188  rb_define_method(Ripper, "filename", ripper_filename, 0);
17189  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
17190  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
17191  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
17192  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
17193  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
17194 #ifdef RIPPER_DEBUG
17195  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
17196  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
17197  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
17198 #endif
17199 
17200  ripper_id_gets = rb_intern("gets");
17201  ripper_init_eventids1(Ripper);
17202  ripper_init_eventids2(Ripper);
17203  /* ensure existing in symbol table */
17204  (void)rb_intern("||");
17205  (void)rb_intern("&&");
17206 
17207 # if 0
17208  /* Hack to let RDoc document SCRIPT_LINES__ */
17209 
17210  /*
17211  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
17212  * after the assignment will be added as an Array of lines with the file
17213  * name as the key.
17214  */
17215  rb_define_global_const("SCRIPT_LINES__", Qnil);
17216 #endif
17217 
17218 }
17219 #endif /* RIPPER */
17220 
17221